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; }