main(int argc,char **argv)
{
int *ev, len, i, j, status, numread, totalread=0, nevents_max, event_size, chunk;
int con[ET_STATION_SELECT_INTS];
et_event **pe;
et_openconfig openconfig;
et_statconfig sconfig;
et_att_id attach;
et_stat_id my_stat;
et_sys_id id;
sigset_t sigblock;
struct timespec timeout;
pthread_t tid;
BOSIOptr BIOstream;
char *ch;
char *str1 =
"OPEN UNIT=11 FILE='/scratch/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";
/*"OPEN UNIT=11 FILE='/work/clas/disk1/boiarino/test.A00' WRITE RECL=32768 SPLITMB=2047 RAW SEQ NEW BINARY";*/
if(argc != 3) {
printf("Usage: et2bos_test <et_filename> <station_name>\n");
exit(1);
}
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
/* setup signal handling */
sigfillset(&sigblock);
/* block all signals */
status = pthread_sigmask(SIG_BLOCK, &sigblock, NULL);
if (status != 0) {
printf("et2bos: pthread_sigmask failure\n");
exit(1);
}
#ifdef sun
thr_setconcurrency(thr_getconcurrency() + 1);
#endif
/* spawn signal handling thread */
pthread_create(&tid, NULL, signal_thread, (void *)NULL);
restartLinux:
/* open ET system */
et_open_config_init(&openconfig);
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
if (et_open(&id, argv[1], openconfig) != ET_OK) {
printf("et2bos: et_open problems\n");
exit(1);
}
et_open_config_destroy(openconfig);
/*
* Now that we have access to an ET system, find out how many
* events it has and what size they are. Then allocate an array
* of pointers to use for reading, writing, and modifying these events.
*/
if (et_system_getnumevents(id, &nevents_max) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if (et_system_geteventsize(id, &event_size) != ET_OK)
{
printf("et2bos: ET has died\n");
exit(1);
}
if ( (pe = (et_event **) calloc(nevents_max, sizeof(et_event *))) == NULL)
{
printf("et2bos: cannot allocate memory\n");
exit(1);
}
et_station_config_init(&sconfig);
et_station_config_setuser(sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(sconfig, 1);
/* old "all" mode */
et_station_config_setselect(sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(sconfig, ET_STATION_BLOCKING);
et_station_config_setcue(sconfig, 150); /* if ET_STATION_NONBLOCKING */
/* set debug level */
et_system_setdebug(id, ET_DEBUG_INFO);
/* create station */
if ((status = et_station_create(id, &my_stat, argv[2], sconfig)) < 0)
{
if (status == ET_ERROR_EXISTS)
{
/* my_stat contains pointer to existing station */;
printf("et2bos: set ptr to the existing station\n");
}
else if (status == ET_ERROR_TOOMANY)
{
printf("et2bos: too many stations created\n");
goto error;
}
else
{
printf("et2bos: error in station creation\n");
goto error;
}
}
printf("et2bos: station ready\n");
if (et_station_attach(id, my_stat, &attach) < 0)
{
printf("et2bos: error in station attach\n");
goto error;
}
/* open FPACK file for writing */
/*if( (status = FParm(str1,&fd)) !=0)
{
printf("FParm status %d \n",status);
printf("command was >%s<\n",str1);
exit(1);
}*/
/* set file descriptor pointer */
BIOstream = (BOSIOptr)fd;
/* initialize BOS array */
bosInit(jw,NBCS);
while (et_alive(id))
{
/**************/
/* read data */
/**************/
/* example of single, timeout read */
/* status = et_event_get(&id, attach, &pe[0], ET_TIMED, &timeout); */
/* example of single, asynchronous read */
/* status = et_event_get(&id, attach, &pe[0], ET_ASYNC, NULL);*/
/* example of reading array of up to "chunk" events */
/* chunk = 500; */
/* numread = status = et_events_get(&id, attach, pe, ET_SLEEP, NULL, chunk, &numread);*/
chunk = 500;
status = et_events_get(id, attach, pe, ET_SLEEP, NULL, chunk, &numread);
if (status == ET_OK) {
;
}
else if (status == ET_ERROR_DEAD) {
printf("et2bos: ET system is dead\n");
goto end;
}
else if (status == ET_ERROR_TIMEOUT) {
printf("et2bos: got timeout\n");
goto end;
}
else if (status == ET_ERROR_EMPTY) {
printf("et2bos: no events\n");
goto end;
}
else if (status == ET_ERROR_BUSY) {
printf("et2bos: station is busy\n");
goto end;
}
else if (status == ET_ERROR_WAKEUP) {
printf("et2bos: someone told me to wake up\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: get error\n");
goto error;
}
/****************************************/
/* print data, write data to FPACK file */
/****************************************/
for (j=0; j<numread; j++)
{
et_event_getdata(pe[j], (void **) &ev);
/*
et_event_getlength(pe[j], &len);
printf("et2bos: recname=>%4.4s%4.4s<, run#=%d, event#=%d, reclen=%d\n",
(char *)&ev[3],(char *)&ev[4],ev[5],ev[6],ev[10]);
printf(" temp = %d, pri = %d, len = %d\n",
pe[j]->temp,et_event_getpriority(pe[j]),len);
et_event_getcontrol(pe[j], con);
for (i=0; i < ET_STATION_SELECT_INTS; i++)
{
printf("control[%d] = %d\n",i,con[i]);
}
*/
/* drop banks from previous event */
bosLdrop(jw, "E");
bosNgarbage(jw);
bosWgarbage(jw);
/* create banks in BOS array */
status = et2bos(ev, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in et2bos()\n",status);
exit(1);
}
/* call next if want to use ET record header; otherwise
record name will be "RUNEVENT" and other info from HEAD bank */
/*bosWriteRecord(fd,&ev[3],ev[5],ev[6],ev[8]);*/
/* write down BOS banks to file */
/*
status = bosWrite(fd, jw, "E");
if (status != 0)
{
printf ("et2bos_test: error %d in bosWrite()\n",status);
exit(1);
}
*/
}
/*********************/
/* return data to ET */
/*********************/
/* example of writing single event */
/* status = et_event_put(id, attach, pe[0]);*/
/* example of writing array of events */
status = et_events_put(id, attach, pe, numread);
if (status == ET_ERROR_DEAD) {
printf("et2bos: ET is dead\n");
goto end;
}
else if ((status == ET_ERROR_WRITE) || (status == ET_ERROR_READ)) {
printf("et2bos: socket communication error\n");
goto end;
}
else if (status != ET_OK) {
printf("et2bos: put error\n");
goto error;
}
totalread += numread;
end:
/* print something out after having read NUMEVENTS events */
if (totalread >= NUMEVENTS)
{
totalread = 0;
printf(" et2bos: %d events\n", NUMEVENTS);
}
/* if ET system is dead, wait here until it comes back */
while (!et_alive(id)) {
status = et_wait_for_alive(id);
if (status == ET_OK) {
int locality;
et_system_getlocality(id, &locality);
/* if Linux, re-establish connection to ET system since socket broken */
if (locality == ET_LOCAL_NOSHARE) {
printf("et2bos: try to reconnect Linux client\n");
et_forcedclose(id);
goto restartLinux;
}
}
}
} /* while(alive) */
error:
free(pe);
printf("et2bos: ERROR\n");
exit(0);
}
/*
* Class: org_jlab_coda_et_EtJniAccess
* Method: getEvents
* Signature: (JIIIIII)[Lorg/jlab/coda/et/EtEvent;
*/
JNIEXPORT jobjectArray JNICALL Java_org_jlab_coda_et_EtJniAccess_getEvents
(JNIEnv *env , jobject thisObj, jlong etId, jint attId,
jint mode, jint sec, jint nsec, jint count)
{
int i, j, numread, status, biteOrder;
void *data;
et_event *pe[count];
jclass clazz;
jboolean isCopy;
jint* intArrayElems;
jintArray controlInts;
jobjectArray eventArray;
jobject event, byteBuf;
/* translate timeout */
struct timespec deltaTime;
deltaTime.tv_sec = sec;
deltaTime.tv_nsec = nsec;
if (debug) printf("getEvents (native) : will attempt to get events\n");
/* reading array of up to "count" events */
status = et_events_get((et_sys_id)etId, (et_att_id)attId, pe, mode, &deltaTime, count, &numread);
if (status != ET_OK) {
if (status == ET_ERROR_DEAD) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtDeadException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_DEAD");
}
else if (status == ET_ERROR_WAKEUP) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtWakeUpException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_WAKEUP");
}
else if (status == ET_ERROR_TIMEOUT) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtTimeoutException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_TIMEOUT");
}
else if (status == ET_ERROR_CLOSED) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtClosedException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_CLOSED");
}
else if (status == ET_ERROR_BUSY) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtBusyException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_BUSY");
}
else if (status == ET_ERROR_EMPTY) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtEmptyException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_EMPTY");
}
else if (status == ET_ERROR_READ) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtReadException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_READ");
}
else if (status == ET_ERROR_WRITE) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtWriteException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_WRITE");
}
else {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtException");
(*env)->ThrowNew(env, clazz, "getEvents (native): ET_ERROR_REMOTE");
}
return NULL;
}
/* create array of EventImpl objects */
eventArray = (*env)->NewObjectArray(env, numread, eventImplClass, NULL);
/* fill array */
for (i=0; i < numread; i++) {
/*printf("getEvents (native) : data for event %d = %d\n", i, *((int *)pe[i]->pdata));*/
/* create control int array */
controlInts = (*env)->NewIntArray(env, ET_STATION_SELECT_INTS);
intArrayElems = (*env)->GetIntArrayElements(env, controlInts, &isCopy);
for (j=0; j < ET_STATION_SELECT_INTS; j++) {
intArrayElems[j] = pe[i]->control[j];
}
if (isCopy == JNI_TRUE) {
(*env)->ReleaseIntArrayElements(env, controlInts, intArrayElems, 0);
}
/* If we're on a little endian machine, int args will be swapped as
they go through the jni interface. We don't want this for the int
designating the byte order, so swap it here to compensate. */
biteOrder = pe[i]->byteorder;
if (localByteOrder == ET_ENDIAN_LITTLE) {
biteOrder = ET_SWAP32(biteOrder);
}
/* wrap data pointer in ByteBuffer object */
et_event_getdata(pe[i], &data);
byteBuf = (*env)->NewDirectByteBuffer(env, data, (jlong) pe[i]->memsize);
/* create event object */
event = (*env)->NewObject(env, eventImplClass, constrMethodId3, /* constructor args ... */
(jint)pe[i]->memsize, (jint)pe[i]->memsize, (jint)pe[i]->datastatus,
(jint)pe[i]->place, (jint)pe[i]->age, (jint)pe[i]->owner,
(jint)pe[i]->modify, (jint)pe[i]->length, (jint)pe[i]->priority,
(jint)biteOrder, controlInts, (jboolean)pe[i]->temp, byteBuf);
/* put event in array */
(*env)->SetObjectArrayElement(env, eventArray, i, event);
/* get rid of uneeded references - good if numread is big */
(*env)->DeleteLocalRef(env, event);
(*env)->DeleteLocalRef(env, controlInts);
(*env)->DeleteLocalRef(env, byteBuf);
}
if (debug) printf("getEvents (native) : filled array!\n");
/* return the array */
return eventArray;
}
/*
* Class: org_jlab_coda_et_EtJniAccess
* Method: newEvents
* Signature: (JIIIIIII)[Lorg/jlab/coda/et/EtEventImpl;
*/
JNIEXPORT jobjectArray JNICALL Java_org_jlab_coda_et_EtJniAccess_newEvents
(JNIEnv *env, jobject thisObj, jlong etId, jint attId, jint mode,
jint sec, jint nsec, jint count, jint size, jint group)
{
int i, numread, status, biteOrder;
void *data;
et_event *pe[count];
jclass clazz;
jobjectArray eventArray;
jobject event, byteBuf;
/* translate timeout */
struct timespec deltaTime;
deltaTime.tv_sec = sec;
deltaTime.tv_nsec = nsec;
if (debug) printf("newEvents (native) : will attempt to get new events\n");
/* reading array of up to "count" events */
status = et_events_new_group((et_sys_id)etId, (et_att_id)attId, pe, mode,
&deltaTime, (size_t)size, count, group, &numread);
if (status != ET_OK) {
if (status == ET_ERROR_DEAD) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtDeadException");
}
else if (status == ET_ERROR_WAKEUP) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtWakeUpException");
}
else if (status == ET_ERROR_TIMEOUT) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtTimeoutException");
}
else if (status == ET_ERROR_CLOSED) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtClosedException");
}
else if (status == ET_ERROR_BUSY) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtBusyException");
}
else if (status == ET_ERROR_EMPTY) {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtEmptyException");
}
else {
clazz = (*env)->FindClass(env, "org/jlab/coda/et/exception/EtException");
}
(*env)->ThrowNew(env, clazz, "newEvents (native): cannot get new events");
return NULL;
}
/* create array of EventImpl objects */
eventArray = (*env)->NewObjectArray(env, numread, eventImplClass, NULL);
/* fill array */
for (i=0; i < numread; i++) {
/* If we're on a little endian machine, int args will be swapped as
they go through the jni interface. We don't want this for the int
designating the byte order, so swap it here to compensate. */
biteOrder = pe[i]->byteorder;
if (localByteOrder == ET_ENDIAN_LITTLE) {
biteOrder = ET_SWAP32(biteOrder);
}
/* wrap data pointer in ByteBuffer object */
et_event_getdata(pe[i], &data);
byteBuf = (*env)->NewDirectByteBuffer(env, data, (jlong) pe[i]->memsize);
/* create event object */
event = (*env)->NewObject(env, eventImplClass, constrMethodId2, /* constructor args ... */
(jint)pe[i]->memsize, (jint)pe[i]->memsize,
(jint)pe[i]->place, (jint)pe[i]->owner,
(jint)pe[i]->modify, (jint)pe[i]->length, (jint)pe[i]->priority,
(jint)biteOrder, (jboolean)pe[i]->temp, byteBuf);
/* put event in array */
(*env)->SetObjectArrayElement(env, eventArray, i, event);
/* get rid of uneeded references - good if numread is big */
(*env)->DeleteLocalRef(env, event);
(*env)->DeleteLocalRef(env, byteBuf);
}
if (debug) printf("newEvents (native) : filled array!\n");
/* return the array */
return eventArray;
}
main(int argc,char **argv)
{
int *jw;
BOSIO *fd;
int status, i, j, size, nevents_max, event_size,
freq, freq_tot=0, freq_avg, iterations=1, count;
int con[ET_STATION_SELECT_INTS];
et_statconfig sconfig;
et_openconfig openconfig;
et_event **pe;
et_att_id attach;
et_sys_id id;
struct timespec timeout, t1, t2;
double time, avgsize, totsize;
sigset_t sigblock;
pthread_t tid;
if (argc != 2) {
printf("Usage: fpack2et <et_filename>\n");
exit(1);
}
timeout.tv_sec = 0;
timeout.tv_nsec = 1;
printf("fpack2et: will try to attach\n");
et_open_config_init(&openconfig);
if (et_open(&id, argv[1], openconfig) != ET_OK) {
printf("fpack2et: et_attach problems\n");
exit(1);
}
et_open_config_destroy(openconfig);
et_system_setdebug(id, ET_DEBUG_INFO);
/*
* Now that we have access to an ET system, find out have many
* events it has and what size they are. Then allocate an array
* of pointers to use for reading, writing, and modifying these events.
*/
if (et_system_getnumevents(id, &nevents_max) != ET_OK) {
printf("et_client: ET has died");
exit(1);
}
if (et_system_geteventsize(id, &event_size) != ET_OK) {
printf("et_client: ET has died");
exit(1);
}
printf("event_size=%d\n",event_size);
if ( (pe = (et_event **) calloc(nevents_max, sizeof(et_event *))) == NULL) {
printf("et_client: cannot allocate memory");
exit(1);
}
if (et_station_attach(id, ET_GRANDCENTRAL, &attach) < 0) {
printf("et_client: error in station attach\n");
exit(1);
}
printf("fpack2et: attached to gc, att = %d, pid = %d\n", attach, getpid());
/* open FPACK file */
if ( (status = bosOpen("./bigfile","r",&fd)) !=0)
{
printf("bosOpen status %d \n",status);
fflush(stdout);
goto error;
}
while (et_alive(id))
{
#if defined(linux) || defined(Darwin)
gettimeofday(&t1, NULL);
#else
clock_gettime(CLOCK_REALTIME, &t1);
#endif
avgsize = 0.;
totsize = 0.;
for (j=0; j < NUMLOOPS ; j++)
{
count = 0;
for (i=0; i < CHUNK ; i++)
{
/*status = et_event_new(id, attach, &pe[i], ET_SLEEP, NULL, size);*/
status = et_event_new(id, attach, &pe[i], ET_SLEEP, NULL, (event_size-100));
if (status == ET_OK)
{
count++;
}
else if (status == ET_ERROR)
{
printf("fpack2et: et_event_new() returns ET_ERROR\n");
break;
}
else if (status == ET_ERROR_TIMEOUT)
{
printf("fpack2et: got timeout\n");
break;
}
else if (status == ET_ERROR_EMPTY)
{
printf("fpack2et: no events\n");
break;
}
else if (status == ET_ERROR_BUSY)
{
printf("fpack2et: grandcentral is busy\n");
break;
}
else if (status != ET_OK)
{
printf("fpack2et: request error\n");
goto error;
}
/************************************************/
/* write data, set priority, set control values */
/************************************************/
/* read one event from FPACK file */
et_event_getdata(pe[i], (void **)&jw);
if((status = etRead(fd,jw,event_size,&size,control) ) == EBIO_EOF)
{
/*goto endoffile;*/
bosRewind(fd);
status = etRead(fd,jw,event_size,&size,control);
}
avgsize += (double)size;
totsize += (double)size;
if ( status != 0)
{
printf("etRead error = %d\n",status); fflush(stdout);
goto error;
}
control[0] = 1; /* to make MON happy */
et_event_setcontrol(pe[i], control, 4);
et_event_setlength(pe[i], size);
/*if(i==5) et_event_setpriority(pe[i], ET_HIGH);*/
/*
status = et_event_put(id, attach, pe[i]);
*/
} /* for CHUNK */
/* write data */
/*
goto a456;
*/
status = et_events_put(id, attach, pe, count);
/*exit(0);*/
if (status == ET_OK)
{
;
}
else if (status == ET_ERROR_DEAD)
{
printf("fpack2et: et_events_put() returns ET_ERROR_DEAD\n");
break;
}
else if (status != ET_OK)
{
printf("fpack2et: put error\n");
goto error;
}
a456:
;
} /* for NUMLOOPS */
/* statistics */
avgsize = avgsize / ((double)(CHUNK*NUMLOOPS));
#if defined(linux) || defined(Darwin)
gettimeofday(&t2, NULL);
#else
clock_gettime(CLOCK_REALTIME, &t2);
#endif
time = (double)(t2.tv_sec - t1.tv_sec) + 1.e-9*(t2.tv_nsec - t1.tv_nsec);
freq = (CHUNK*NUMLOOPS)/time;
if ((INT_MAX - freq_tot) < freq)
{
freq_tot = 0;
iterations = 1;
}
freq_tot += freq;
freq_avg = freq_tot/iterations;
totsize = totsize/time/1024./1024.;
iterations++;
printf("%4d fpack2et: %7d Hz, %7d Hz Avg; %7.1f bytes size, %6.1f MBytes/sec\n",
(int)totsize,freq,freq_avg,avgsize,totsize);
if (!et_alive(id))
{
et_wait_for_alive(id);
}
} /* while(alive) */
error:
printf("fpack2et: ERROR\n");
exit(0);
endoffile:
/* close FPACK file */
bosClose(fd);
exit(0);
}
