int main(int argc,char **argv)
{
int i, j, c, i_tmp, status, swappedData, numRead;
int startingVal=0, errflg=0, group=1, chunk=1, size=32, verbose=0;
int sendBufSize=0, recvBufSize=0, noDelay=0;
unsigned short serverPort = ET_SERVER_PORT;
char et_name[ET_FILENAME_LENGTH], host[256], mcastAddr[16], interface[16];
void *fakeData;
et_att_id attach1;
et_sys_id id;
et_openconfig openconfig;
et_event **pe;
struct timespec timeout;
#if defined __APPLE__
struct timeval t1, t2;
#else
struct timespec t1, t2;
#endif
pthread_t tid;
/* statistics variables */
double eventRate=0.0, avgEventRate=0.0;
int64_t eventCount=0, totalEventCount=0;
double byteRate=0.0, avgByteRate=0.0;
int64_t byteCount=0, totalByteCount=0;
int64_t totalT=0, time, time1, time2;
/* multiple character command-line options */
static struct option long_options[] = {
{"host", 1, NULL, 0},
{"rb", 1, NULL, 1},
{"sb", 1, NULL, 2},
{"nd", 0, NULL, 3},
{0, 0, 0, 0}
};
memset(host, 0, 16);
memset(mcastAddr, 0, 16);
memset(et_name, 0, ET_FILENAME_LENGTH);
while ((c = getopt_long_only(argc, argv, "vn:s:p:d:f:c:g:i:", long_options, 0)) != EOF) {
if (c == -1)
break;
switch (c) {
case 'c':
i_tmp = atoi(optarg);
if (i_tmp > 0 && i_tmp < 1001) {
chunk = i_tmp;
printf("Setting chunk to %d\n", chunk);
} else {
printf("Invalid argument to -c. Must < 1001 & > 0.\n");
exit(-1);
}
break;
case 's':
i_tmp = atoi(optarg);
if (i_tmp > 0) {
size = i_tmp;
} else {
printf("Invalid argument to -s. Must be a positive integer.\n");
exit(-1);
}
break;
case 'p':
i_tmp = atoi(optarg);
if (i_tmp > 1023 && i_tmp < 65535) {
serverPort = i_tmp;
} else {
printf("Invalid argument to -p. Must be < 65535 & > 1023.\n");
exit(-1);
}
break;
case 'g':
i_tmp = atoi(optarg);
if (i_tmp > 0 && i_tmp < 501) {
group = i_tmp;
} else {
printf("Invalid argument to -g. Must be 501 > g > 0.\n");
exit(-1);
}
break;
case 'f':
if (strlen(optarg) >= ET_FILENAME_LENGTH) {
fprintf(stderr, "ET file name is too long\n");
exit(-1);
}
strcpy(et_name, optarg);
break;
case 'i':
if (strlen(optarg) > 15 || strlen(optarg) < 7) {
fprintf(stderr, "interface address is bad\n");
exit(-1);
}
strcpy(interface, optarg);
break;
case 0:
if (strlen(optarg) >= 255) {
fprintf(stderr, "host name is too long\n");
exit(-1);
}
strcpy(host, optarg);
break;
case 1:
i_tmp = atoi(optarg);
if (i_tmp < 1) {
printf("Invalid argument to -rb. Recv buffer size must be > 0.\n");
exit(-1);
}
recvBufSize = i_tmp;
break;
case 2:
i_tmp = atoi(optarg);
if (i_tmp < 1) {
printf("Invalid argument to -rb. Send buffer size must be > 0.\n");
exit(-1);
}
sendBufSize = i_tmp;
break;
case 3:
noDelay = 1;
break;
case 'v':
verbose = ET_DEBUG_INFO;
break;
case ':':
case 'h':
case '?':
default:
errflg++;
}
}
if (optind < argc || errflg || strlen(host) < 1 || strlen(et_name) < 1) {
fprintf(stderr,
"usage: %s %s\n%s\n%s\n\n",
argv[0],
"-f <ET name> -host <ET host> [-h] [-v] [-c <chunk size>] [-s <event size>]",
" [-g <group>] [-p <ET server port>] [-i <interface address>]",
" [-rb <buf size>] [-sb <buf size>] [-nd]");
fprintf(stderr, " -host ET system's host\n");
fprintf(stderr, " -f ET system's (memory-mapped file) name\n");
fprintf(stderr, " -h help\n");
fprintf(stderr, " -v verbose output\n");
fprintf(stderr, " -c number of events in one get/put array\n");
fprintf(stderr, " -s event size in bytes\n");
fprintf(stderr, " -g group from which to get new events (1,2,...)\n");
fprintf(stderr, " -p ET server port\n");
fprintf(stderr, " -i outgoing network interface IP address (dot-decimal)\n");
fprintf(stderr, " -rb TCP receive buffer size (bytes)\n");
fprintf(stderr, " -sb TCP send buffer size (bytes)\n");
fprintf(stderr, " -nd use TCP_NODELAY option\n\n");
fprintf(stderr, " This blaster works by making a direct connection to the\n");
fprintf(stderr, " ET system's server port and blasting as much data as possible\n");
fprintf(stderr, " over the connecting TCP socket.\n\n");
exit(2);
}
/* allocate some memory */
pe = (et_event **) calloc(chunk, sizeof(et_event *));
if (pe == NULL) {
printf("%s: out of memory\n", argv[0]);
exit(1);
}
fakeData = (void *) malloc(size);
if (fakeData == NULL) {
printf("%s: out of memory\n", argv[0]);
exit(1);
}
/******************/
/* open ET system */
/******************/
et_open_config_init(&openconfig);
et_open_config_setcast(openconfig, ET_DIRECT);
et_open_config_sethost(openconfig, host);
et_open_config_setserverport(openconfig, serverPort);
et_open_config_setmode(openconfig, ET_HOST_AS_REMOTE);
/* Defaults are to use operating system default buffer sizes and turn off TCP_NODELAY */
et_open_config_settcp(openconfig, recvBufSize, sendBufSize, noDelay);
if (strlen(interface) > 6) {
et_open_config_setinterface(openconfig, interface);
}
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
if (et_open(&id, et_name, openconfig) != ET_OK) {
printf("%s: et_open problems\n", argv[0]);
exit(1);
}
et_open_config_destroy(openconfig);
/* set level of debug output (everything) */
if (verbose) {
et_system_setdebug(id, ET_DEBUG_INFO);
}
/* attach to grandcentral station */
if (et_station_attach(id, ET_GRANDCENTRAL, &attach1) < 0) {
printf("%s: error in et_station_attach\n", argv[0]);
exit(1);
}
/* create thread to deal with client */
// pthread_create(&tid, NULL, newEventsThread, (void *) pinfo);
/* read time for future statistics calculations */
#if defined __APPLE__
gettimeofday(&t1, NULL);
time1 = 1000L*t1.tv_sec + t1.tv_usec/1000L; /* milliseconds */
#else
clock_gettime(CLOCK_REALTIME, &t1);
time1 = 1000L*t1.tv_sec + t1.tv_nsec/1000000L; /* milliseconds */
#endif
while (1) {
status = et_events_new_group(id, attach1, pe, ET_SLEEP | ET_NOALLOC,
NULL, size, chunk, group, &numRead);
if (status != ET_OK) {
printf("%s: et_events_new_group error, status = %d\n", argv[0], status);
goto error;
}
/* set data to existing buffer (with ET_NOALLOC), and set data length */
if (1) {
for (i=0; i < numRead; i++) {
et_event_setlength(pe[i], size);
et_event_setdatabuffer(id, pe[i], fakeData);
}
}
/* put events back into the ET system */
status = et_events_put(id, attach1, pe, numRead);
if (status != ET_OK) {
printf("%s: et_events_put error, status = %d\n", argv[0], status);
goto error;
}
eventCount += numRead;
byteCount += numRead*(size + 52) + 20; /* 52 is event overhead, 20 is ET call overhead */
/* statistics */
#if defined __APPLE__
gettimeofday(&t2, NULL);
time2 = 1000L*t2.tv_sec + t2.tv_usec/1000L; /* milliseconds */
#else
clock_gettime(CLOCK_REALTIME, &t2);
time2 = 1000L*t2.tv_sec + t2.tv_nsec/1000000L; /* milliseconds */
#endif
time = time2 - time1;
if (time > 5000) {
eventRate = 1000.0 * ((double) eventCount) / time;
byteRate = 1000.0 * ((double) byteCount) / time;
totalEventCount += eventCount;
totalByteCount += byteCount;
totalT += time;
avgEventRate = 1000.0 * ((double) totalEventCount) / totalT;
avgByteRate = 1000.0 * ((double) totalByteCount) / totalT;
printf("evRate: %3.4g Hz, %3.4g avg; byteRate: %3.4g bytes/sec, %3.4g avg\n",
argv[0], eventRate, avgEventRate, byteRate, avgByteRate);
eventCount = 0;
byteCount = 0;
#if defined __APPLE__
gettimeofday(&t1, NULL);
time1 = 1000L*t1.tv_sec + t1.tv_usec/1000L;
#else
clock_gettime(CLOCK_REALTIME, &t1);
time1 = 1000L*t1.tv_sec + t1.tv_nsec/1000000L;
#endif
}
} /* while(1) */
error:
printf("%s: DONE\n", argv[0]);
exit(0);
}
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);
}
/* ET Initialization */
int
mon_et_initialize(void)
{
et_statconfig sconfig;
et_openconfig openconfig;
int status;
struct timespec timeout;
timeout.tv_sec = 2;
timeout.tv_nsec = 0;
/* Normally, initialization is done only once. However, if the ET
* system dies and is restarted, and we're running on a Linux or
* Linux-like operating system, then we need to re-initalize in
* order to reestablish the tcp connection for communication etc.
* Thus, we must undo some of the previous initialization before
* we do it again.
*/
if(et_init > 0)
{
/* unmap shared mem, detach attachment, close socket, free et_sys */
et_forcedclose(et_sys);
}
printf("mon_et_initialize: start ET stuff\n");
if(et_open_config_init(&openconfig) != ET_OK)
{
printf("ERROR: mon ET init: cannot allocate mem to open ET system\n");
return MON_ERROR;
}
et_open_config_setwait(openconfig, ET_OPEN_WAIT);
et_open_config_settimeout(openconfig, timeout);
if(et_open(&et_sys, et_name, openconfig) != ET_OK)
{
printf("ERROR: mon ET init: cannot open ET system\n");
return MON_ERROR;
}
et_open_config_destroy(openconfig);
/* set level of debug output */
et_system_setdebug(et_sys, ET_DEBUG_ERROR);
/* where am I relative to the ET system? */
et_system_getlocality(et_sys, &et_locality);
et_station_config_init(&sconfig);
et_station_config_setselect(sconfig, ET_STATION_SELECT_ALL);
et_station_config_setblock(sconfig, ET_STATION_BLOCKING);
et_station_config_setuser(sconfig, ET_STATION_USER_MULTI);
et_station_config_setrestore(sconfig, ET_STATION_RESTORE_OUT);
et_station_config_setprescale(sconfig,1);
if((status = et_station_create(et_sys, &et_statid, "TAPE", sconfig)) < 0)
{
if (status == ET_ERROR_EXISTS) {
printf("mon ET init: station exists, will attach\n");
}
else
{
et_close(et_sys);
et_station_config_destroy(sconfig);
printf("ERROR: mon ET init: cannot create ET station (status = %d)\n",
status);
return(MON_ERROR);
}
}
et_station_config_destroy(sconfig);
if (et_station_attach(et_sys, et_statid, &et_attach) != ET_OK) {
et_close(et_sys);
printf("ERROR: mon ET init: cannot attach to ET station\n");
return MON_ERROR;
}
et_init++;
et_reinit = 0;
printf("mon ET init: ET fully initialized\n");
return MON_OK;
}
