Ignore:
Timestamp:
07/07/11 19:52:05 (13 years ago)
Author:
tbretz
Message:
Mainly new statistics.
File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/FACT++/src/EventBuilder.c

    r11191 r11282  
    3535
    3636#define MIN_LEN  32        // min #bytes needed to interpret FADheader
    37 #define MAX_LEN  64*1024   // size of read-buffer per socket
     37#define MAX_LEN 256*1024   // size of read-buffer per socket
    3838   
    3939extern FileHandle_t  runOpen(uint32_t irun, RUN_HEAD *runhd, size_t len ) ;
    … …  
    4141extern int  runClose(FileHandle_t fileHd ,  RUN_TAIL *runth, size_t len ) ;
    4242extern void factOut(int severity, int err, char* message ) ;
    43 extern void factStat(int64_t *array , int len ) ;
     43
     44extern void factStat(GUI_STAT gj) ;
     45
     46extern void factStatNew(EVT_STAT gi) ;
    4447
    4548extern int  eventCheck( PEVNT_HEADER *fadhd, EVENT *event) ;
    4649
    47 
    48 extern void debugHead(int i, void *buf);
    49 
    50 extern void debugRead(int isock, int ibyte, int32_t event,int32_t ftmevt, int32_t runnr, int state,
    51                       uint32_t tsec, uint32_t tusec ) ;
     50extern void debugHead(int i, int j, void *buf);
     51
     52extern void debugRead(int isock, int ibyte, int32_t event,int32_t ftmevt,
     53                      int32_t runnr, int state, uint32_t tsec, uint32_t tusec ) ;
    5254extern void debugStream(int isock, void *buf, int len) ;
    5355
    5456
    5557
    56 int g_actTime   =  0 ;
    57 int g_runStat   = 40 ;
     58int g_actTime   ;
     59int g_runStat   ;
    5860size_t g_maxMem  ;  //maximum memory allowed for buffer
    5961
    … …  
    6668
    6769
    68 int gi_runStat ;
    69 int gp_runStat ;
    70 int gw_runStat ;
    71 
    72 
    73 uint gi_SecRate[MAX_SOCK] ;
    74 uint gi_S10Rate[MAX_SOCK] ;
    75 uint gi_MinRate[MAX_SOCK] ;
    76 uint gi_ErrCnt[MAX_SOCK] ;
     70 int gi_runStat ;
     71 int gp_runStat ;
     72 int gw_runStat ;
     73 int32_t gi_myRun ;
     74
     75
    7776
    7877uint gi_NumConnect[NBOARDS];   //4 crates * 10 boards
    7978
    80 uint gi_SecTime, gi_S10Time, gi_MinTime ;
    81 uint gi_EvtStart= 0 ;
    82 uint gi_EvtRead = 0 ;
    83 uint gi_EvtBad  = 0 ;
    84 uint gi_EvtTot  = 0 ;
    85 size_t gi_usedMem = 0 ;
    86 
    87 uint gw_EvtTot  = 0 ;
    88 uint gp_EvtTot  = 0 ;
     79//uint gi_EvtStart= 0 ;
     80//uint gi_EvtRead = 0 ;
     81//uint gi_EvtBad  = 0 ;
     82//uint gi_EvtTot  = 0 ;
     83//size_t gi_usedMem = 0 ;
     84
     85//uint gw_EvtTot  = 0 ;
     86//uint gp_EvtTot  = 0 ;
    8987
    9088PIX_MAP g_pixMap[NPIX] ;
     89
     90EVT_STAT    gi ;
     91GUI_STAT    gj ;
    9192
    9293EVT_CTRL    evtCtrl ;       //control of events during processing
    … …  
    305306   headmem = NBOARDS* sizeof(PEVNT_HEADER) ;
    306307
    307    if ( gi_usedMem + needmem + headmem > g_maxMem) {
     308   if ( gj.usdMem + needmem + headmem > g_maxMem) {
    308309        snprintf(str,MXSTR,"no memory left to keep event %d",evID) ;
    309310        factOut(kError,882, str ) ;
    … …  
    349350   mBuffer[i].evtLen  = needmem ;
    350351
    351    gi_usedMem += needmem + headmem;
     352   gj.usdMem += needmem + headmem;
     353   if (gj.usdMem > gj.maxMem ) gj.maxMem = gj.usdMem ;
    352354
    353355   //register event in 'active list (reading)'
    … …  
    357359   evtCtrl.pcTime[  evtCtrl.lastPtr] = g_actTime ;
    358360   evtIdx[i] = evtCtrl.lastPtr ;
     361
     362   gj.readEvt++ ;           //#events read
     363   gj.evtBuf++ ;
     364
     365
    359366snprintf(str,MXSTR,"%5d start new evt  %8d %8d %2d",evID,i,evtCtrl.lastPtr,0);
    360367factOut(kDebug,-11, str ) ;
    … …  
    363370
    364371
    365 
    366 
    367    gi_EvtStart++ ;
     372   gi.evtGet++ ;
    368373
    369374   //check if runId already registered in runCtrl
    … …  
    379384   } else {
    380385      runCtrl[evFree].runId = runID ;
     386      runCtrl[evFree].fileId = -2 ;
     387      runCtrl[evFree].nextEvt= 0;
     388      runCtrl[evFree].actEvt = 0;
     389      runCtrl[evFree].maxEvt = 999999999 ; //max number events allowed
     390      runCtrl[evFree].lastTime=g_actTime ;
     391      runCtrl[evFree].closeTime=g_actTime + 3600*24 ; //max time allowed
     392      runCtrl[evFree].lastTime = 0 ;
     393
     394      runTail[evFree].nEventsOk =
     395      runTail[evFree].nEventsRej =
     396      runTail[evFree].nEventsBad =
     397      runTail[evFree].PCtime0 =
     398      runTail[evFree].PCtimeX = 0 ;
    381399   }
    382400
    … …  
    384402 
    385403} /*-----------------------------------------------------------------*/
     404
     405
    386406
    387407
    … …  
    405425   mBuffer[i].evNum   = mBuffer[i].runNum = mBuffer[i].nRoi= -1;
    406426
    407    gi_usedMem = gi_usedMem - freemem - headmem;
    408 
     427   gj.usdMem = gj.usdMem - freemem - headmem;
     428   gj.evtBuf-- ;
    409429
    410430   return 0 ;
    … …  
    413433
    414434
    415   /*-----------------------------------------------------------------*/
     435void resetEvtStat() {
     436  int i ;
     437
     438  for (i=0; i<MAX_SOCK; i++) gi.numRead[i] = 0 ;
     439
     440  for (i=0; i<NBOARDS; i++ ) {
     441     gi.gotByte[i] = 0 ;
     442     gi.gotErr[i]  = 0 ;
     443  }
     444
     445  gi.evtGet  = 0 ;             //#new Start of Events read
     446  gi.evtTot  = 0 ;             //#complete Events read
     447  gi.evtErr  = 0 ;             //#Events with Errors
     448  gi.evtSkp  = 0 ;             //#Events incomplete (timeout)
     449
     450  gi.procTot = 0 ;             //#Events processed
     451  gi.procErr = 0 ;             //#Events showed problem in processing
     452  gi.procTrg = 0 ;             //#Events accepted by SW trigger
     453  gi.procSkp = 0 ;             //#Events rejected by SW trigger
     454
     455  gi.feedTot = 0 ;             //#Events used for feedBack system
     456  gi.feedErr = 0 ;             //#Events rejected by feedBack
     457
     458  gi.wrtTot  = 0 ;             //#Events written to disk
     459  gi.wrtErr  = 0 ;             //#Events with write-error
     460
     461  gi.runOpen = 0 ;             //#Runs opened
     462  gi.runClose= 0 ;             //#Runs closed
     463  gi.runErr  = 0 ;             //#Runs with open/close errors
     464
     465return ;
     466} /*-----------------------------------------------------------------*/
    416467
    417468
    … …  
    428479  int actBoards = 0, minLen ;
    429480  int32_t jrd ;
    430   int32_t myRun ;
     481  int64_t stat[9] ;
    431482  int boardId, roi,drs,px,src,pixS,pixH,pixC,pixR,tmS ;
    432483  uint qtot = 0, qread = 0, qconn = 0 ;
     484
     485  int goodhed = 0 ;
    433486  int errcnt0 = 0 ;
    434487
    435   int goodhed=0;
    436 
    437488  struct timespec xwait ;
    438489
    439   int nokCnt[MAX_SOCK],loopCnt=0;
    440   int sokCnt[MAX_SOCK];
    441   int sockDef[NBOARDS];
    442490
    443491  struct timeval  *tv, atv;
    … …  
    470518     rd[i].sockStat = 99 ;
    471519  }
     520
     521  int sockDef[NBOARDS];    //internal state of sockets
    472522  for (i=0; i<NBOARDS; i++) sockDef[i]= 0 ;
    473523
    474524
    475   g_actTime = time(NULL) ;
    476   for (k=0; k<MAX_SOCK; k++)
    477      gi_SecRate[k]=gi_S10Rate[k]=gi_MinRate[k]=gi_ErrCnt[k] = 0 ;
    478 
    479   for (k=0; k<NBOARDS; k++)
     525  resetEvtStat();
     526  gj.usdMem = gj.maxMem = 0 ;
     527  gj.evtBuf = 0 ;
     528
     529  for (k=0; k<NBOARDS; k++) {
    480530     gi_NumConnect[k]=0;
    481 
    482 
    483   gi_SecTime= gi_S10Time= gi_MinTime= g_actTime ;
     531     gi.numConn[k]   =0;
     532  }
     533
     534
     535  uint gi_SecTime ;        //time in seconds
     536  gi_SecTime= g_actTime ;
    484537
    485538  mBufInit() ;    //initialize buffers
    … …  
    489542
    490543
    491   for (k=0; k<MAX_SOCK; k++) sokCnt[k]=nokCnt[k]=0 ;
    492544
    493545  head_len = sizeof(PEVNT_HEADER) ;
    … …  
    503555  stop.S= 0x04FE;
    504556
    505   myRun = g_actTime ;
    506 
     557  gi_myRun = g_actTime ;
    507558  gi_runStat = g_runStat ;
     559  gj.readStat= g_runStat ;
    508560
    509561
    510562  while (g_runStat >=0) {           //loop until global variable g_runStat claims stop
    511563
    512     gi_runStat = g_runStat ;
     564    gi_runStat = g_runStat;
     565    gj.readStat= g_runStat;
     566    gj.totMem  = g_maxMem ;
     567//  if (gi.totMem < 50000000 ) gi.totMem = 500000000 ;
    513568
    514569    int b,p,p0,s0,nch;
    … …  
    519574          nch++ ;
    520575          gi_NumConnect[ b ] = 0 ;                  //must close all connections
     576          gi.numConn[ b ] = 0;
    521577          if (            sockDef[b] == 0) s0= 0 ;  //sockets to be defined and opened   
    522578          else if (g_port[b].sockDef == 0) s0=-1 ;  //sockets to be destroyed
    … …  
    542598
    543599
    544     g_actTime = time(NULL) ;
    545     nokCnt[numok]++;
    546 
    547     loopCnt++ ;
     600
    548601
    549602    numok = 0 ;                       //count number of succesfull actions
    … …  
    555608
    556609      gettimeofday( tv, NULL);
    557       tsec = atv.tv_sec ;
     610      g_actTime = tsec = atv.tv_sec ;
    558611      tusec= atv.tv_usec ;
    559612
    … …  
    572625          rd[i].skip   = 0 ;            //  start empty
    573626          gi_NumConnect[ b ]++ ;
    574           numok++ ;                     //make sure next round will execute
    575           snprintf(str,MXSTR,"+++connect %d %d",b,gi_NumConnect[ b ]);
     627          gi.numConn[ b ]++ ;
     628          snprintf(str,MXSTR,"+++connect %d %d",b,gi.numConn[ b ]);
    576629          factOut(kInfo,-1, str ) ;
    577630        }
    … …  
    581634        if (rd[i].bufLen > 0) {      //might be nothing to read [buffer full]
    582635          numok++ ;
    583           sokCnt[i]++;
    584636          jrd=recv(rd[i].socket,&rd[i].rBuf->B[ rd[i].bufPos], rd[i].bufLen, MSG_DONTWAIT);
    585637
    … …  
    593645             factOut(kInfo,441, str ) ;
    594646             GenSock(s0, i, 0,NULL, &rd[i]) ;
    595              gi_ErrCnt[i]++ ;
     647             gi.gotErr[ b ]++ ;
    596648             gi_NumConnect[ b ]-- ;
     649             gi.numConn[ b ]-- ;
    597650
    598651          } else if ( jrd<0 ) {           //did not read anything
    … …  
    600653                snprintf(str,MXSTR,"Error Reading from %d | %m",i);
    601654                factOut(kError,442, str ) ;
    602                 gi_ErrCnt[i]++ ;
     655                gi.gotErr[ b ]++ ;
    603656             } else  numok-- ;            //else nothing waiting to be read
    604657             jrd = 0 ;
    605658          }
    606659        } else jrd = 0 ;                //did read nothing as requested
     660
     661        gi.gotByte[ b ] += jrd ;
    607662
    608663        if ( rd[i].bufTyp <0 ) { // we are skipping this board ...
    … …  
    619674             if ( rd[i].rBuf->B[ rd[i].bufPos-1] != stop.B[0]
    620675               && rd[i].rBuf->B[ rd[i].bufPos  ] != stop.B[1]) {
    621                 gi_ErrCnt[i]++ ;
     676                gi.evtErr++ ;
    622677                snprintf(str,MXSTR,"wrong end of buffer found %d",rd[i].bufPos);
    623678                factOut(kError,301, str ) ;
    … …  
    628683
    629684             //we have a complete buffer, copy to WORK area
    630              gi_SecRate[i]++ ;
    631 
    632685             roi = ntohs(rd[i].rBuf->S[ head_len/2 + 2 ]) ;
    633686             //get index into mBuffer for this event (create if needed)
    … …  
    651704                snprintf(str,MXSTR,"wrong Board ID %d %d %d",fadCrate,fadBoard%256,boardId) ;
    652705                if (errcnt0++ < 99 ) factOut(kWarn,301, str ) ;  //print only few times
    653 //           } else {
    654 //              snprintf(str,MXSTR,"correct Board ID %d %d %d",fadCrate,fadBoard%256,boardId) ;
    655 //              if (errcnt0++ < 99 ) factOut(kWarn,301, str ) ;  //print only few times
    656706             }
    657707             if ( mBuffer[evID].board[ boardId ] != -1) {   
    … …  
    703753                   } else {
    704754                      snprintf(str,MXSTR,"wrong roi %d %d %d %d",px,pixR,roi,src-2);
     755                      gi.evtErr++ ;
    705756                      factOut(kError,202, str ) ;
    706757                      goto EndBuf ;
    … …  
    708759                }
    709760             }// now we have stored a new board contents into Event structure
     761
    710762             mBuffer[evID].board[ boardId ] = boardId ;
    711763             evtCtrl.evtStat[ iDx ]++ ;
    … …  
    717769                //complete event read ---> flag for next processing
    718770                evtCtrl.evtStat[ iDx ] = 99;
    719                 gi_EvtRead++ ;
    720                 gi_EvtTot++ ;   
     771                gi.evtTot++ ;
    721772             }
    722773
    … …  
    763814                 rd[i].ftmID  = ntohl(rd[i].rBuf->I[5]) ; //(FTMevt)
    764815                 rd[i].runID  = ntohl(rd[i].rBuf->I[11]) ;
    765                  if (rd[i].runID ==0 ) rd[i].runID = myRun ;
     816                 if (rd[i].runID ==0 ) rd[i].runID = gi_myRun ;
    766817                 rd[i].bufTyp = 1 ;       //ready to read full record
    767818                 rd[i].bufLen = rd[i].fadLen - rd[i].bufPos ;
    768819                 if (rd[i].bufLen <=0 ) rd[i].bufLen = 100000 ;    //?
    769                  debugHead(i,rd[i].rBuf);
     820                 int fadBoard = ntohs(rd[i].rBuf->S[12] ) ;
     821                 debugHead(i,fadBoard,rd[i].rBuf);
    770822                 debugRead(i,jrd,rd[i].evtID,rd[i].ftmID,rd[i].runID,-1,tsec,tusec) ; // i=socket; jrd=#bytes; ievt=eventid;-1=start event
    771823              } else {
    … …  
    780832    } //finished trying to read all sockets
    781833
     834    gi.numRead[ numok ] ++ ;
     835
    782836    int qwait=0, qdel=0, qskip=0 ;
    783837    g_actTime = time(NULL) ;
    … …  
    806860             factOut(kWarn,601, str ) ;
    807861             evtCtrl.evtStat[k0] = 91 ;      //timeout for incomplete events
    808              gi_EvtBad++ ;
    809              gi_EvtTot++ ;   
     862             gi.evtSkp++ ;
     863             gi.evtTot++ ;   
     864             gj.skipEvt++;
    810865             qskip++;
    811866           }
    … …  
    831886int ib ;
    832887for (ib=0; ib<NBOARDS; ib++) qconn+=gi_NumConnect[ib] ;
    833 int64_t stat[9] ;
    834888        stat[0]= qwait;
    835889        stat[1]= qskip;
    836890        stat[2]= qdel ;
    837891        stat[3]= qtot ;
    838         stat[4]= gi_usedMem ;
     892        stat[4]= gj.usdMem ;
    839893        stat[5]= qread;
    840894        stat[6]= qconn;
    841895
    842 factStat(stat,7);
    843896qread=0 ;
     897       gj.deltaT = 1000 ;   //temporary, must be improved
     898
     899       factStat(gj);
     900       factStatNew(gi) ;
     901
     902       gj.readEvt = gj.procEvt = gj.writEvt = gj.skipEvt = 0 ;
    844903    }
    845904
    … …  
    876935     && evtCtrl.evtStat[k0] < 90 ) {
    877936       evtCtrl.evtStat[k0] = 91 ;   
    878        gi_EvtBad++ ;
    879        gi_EvtTot++ ;   
     937       gi.evtSkp++ ;
     938       gi.evtTot++ ;   
    880939    }
    881940 }
    … …  
    885944 factOut(kInfo,-1, str ) ;
    886945 for (i=0; i<MAX_SOCK; i++) { 
    887      GenSock(-1, i, 0, NULL, &rd[i]) ; //close and destroy socket
    888      if (gi_NumConnect[ i/7 ]>0)
    889          gi_NumConnect[ i/7 ]-- ;
     946    if (rd[i].sockStat ==0 ) {
     947       GenSock(-1, i, 0, NULL, &rd[i]) ; //close and destroy socket   
     948       gi_NumConnect[ i/7 ]-- ;
     949       gi.numConn[ i/7 ]-- ;
     950    }
    890951 }
    891952
    … …  
    894955 nanosleep( &xwait , NULL ) ;
    895956 gi_runStat = -11 ;  //inform all that no update to happen any more
     957 gj.readStat= -11 ;  //inform all that no update to happen any more
    896958
    897959
    … …  
    930992 factOut(kInfo,-1, str ) ;
    931993 gi_runStat = -99 ;
     994 gj.readStat= -99 ;
     995 factStat(gj);
     996 factStatNew(gi) ;
    932997 return 0;
    933998
    … …  
    10091074
    10101075           int i=eventCheck(mBuffer[id].FADhead,mBuffer[id].fEvent) ;
    1011            
    1012            if (i<0) evtCtrl.evtStat[k0] = 999 ; //flag event to be skipped
    1013 
     1076           gj.procEvt++ ;
     1077           gi.procTot++ ;
    10141078           numProc++ ;
    10151079           evtCtrl.evtStat[k0] = 520 ;
    1016            gp_EvtTot++ ;
     1080           
     1081           if (i<0) {
     1082              evtCtrl.evtStat[k0] = 999 ; //flag event to be skipped
     1083              gi.procErr++ ;
     1084           }
    10171085        } else if ( evtCtrl.evtStat[k0] >=0 && evtCtrl.evtStat[k0] < 90 ) {
    10181086           numWait++ ;
    … …  
    10201088     }
    10211089
    1022      if ( gi_runStat < -10 && numWait == 0) {  //nothing left to do
     1090     if ( gj.readStat < -10 && numWait == 0) {  //nothing left to do
    10231091        snprintf(str,MXSTR,"Exit Processing Process ...");
    10241092        factOut(kInfo,-1, str ) ;
    10251093        gp_runStat = -22 ;                     //==> we should exit
     1094        gj.procStat= -22 ;                     //==> we should exit
    10261095        return 0 ;
    10271096     }
    … …  
    10341103     }
    10351104     gp_runStat = gi_runStat ;
     1105     gj.procStat= gj.readStat ;
    10361106
    10371107  }
    … …  
    10541124
    10551125  gp_runStat = -99 ;
     1126  gj.procStat= -99 ;
    10561127
    10571128  return 0;
    … …  
    10591130} /*-----------------------------------------------------------------*/
    10601131
    1061 int CloseRunFile(uint32_t runId, uint32_t closeTime) {
     1132int CloseRunFile(uint32_t runId, uint32_t closeTime, uint32_t maxEvt) {
    10621133/* close run runId (all all runs if runId=0) */
    10631134/* return: 0=close scheduled / >0 already closed / <0 does not exist */
    1064   int i, j ;
    1065 
    1066   if (runId == 0 ) {
     1135  int j ;
     1136
     1137
     1138  if ( runId == 0 ) {
    10671139     for ( j=0; j<MAX_RUN; j++) {
    10681140        if ( runCtrl[j].fileId == 0 ) {  //run is open
    1069            i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
    1070            if (i<0) {
    1071               snprintf(str,MXSTR,"error closing run %d %d",runCtrl[j].runId,i) ;
    1072               factOut(kError,506, str ) ;
    1073               runCtrl[j].fileId = 888 ;
    1074            } else {
    1075               snprintf(str,MXSTR,"closing run %d ok  AAA",runCtrl[j].runId);
    1076               factOut(kInfo,507, str ) ;
    1077               runCtrl[j].fileId = 7777 ;
    1078            }
    10791141           runCtrl[j].closeTime = closeTime ;
     1142           runCtrl[j].maxEvt = maxEvt ;
    10801143        }
    10811144     }
    1082      return 0 ;
    1083   }
    1084 
     1145     return 0;
     1146  }
    10851147
    10861148  for ( j=0; j<MAX_RUN; j++) {
    10871149     if ( runCtrl[j].runId == runId ) {
    10881150        if ( runCtrl[j].fileId == 0 ) {  //run is open
    1089            i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
    1090            if (i<0) {
    1091               snprintf(str,MXSTR,"error closing run %d %d",runCtrl[j].runId,i) ;
    1092               factOut(kError,506, str ) ;
    1093               runCtrl[j].fileId = 888 ;
    1094            } else {
    1095               snprintf(str,MXSTR,"closing run %d ok  AAA",runCtrl[j].runId);
    1096               factOut(kInfo,507, str ) ;
    1097               runCtrl[j].fileId = 7777 ;
    1098            }
    10991151           runCtrl[j].closeTime = closeTime ;
     1152           runCtrl[j].maxEvt = maxEvt ;
    11001153           return 0;
    11011154        } else if ( runCtrl[j].fileId <0 ) { //run not yet opened
    11021155           runCtrl[j].closeTime = closeTime ;
     1156           runCtrl[j].maxEvt = maxEvt ;
    11031157           return +1;
    11041158        } else {     // run already closed
    … …  
    11161170
    11171171  int  numWrite, numWait ;
    1118   int k,j ;
     1172  int k,j,i ;
    11191173  struct timespec xwait ;
    11201174  char str[MXSTR] ;
    … …  
    11521206           int      ievt = mBuffer[id].evNum ;
    11531207
     1208           gi.wrtTot++ ;
    11541209           if (runCtrl[lastRun].runId == irun ) {
    11551210              j = lastRun ;
    … …  
    11621217                 snprintf(str,MXSTR,"W error: can not find run %d for event %d in %d", irun,ievt,id);
    11631218                 factOut(kFatal,901, str ) ;
     1219                 gi.wrtErr++ ;
    11641220for ( j=0; j<MAX_RUN; j++) printf("j %d   run.j %d   run %d\n",j,runCtrl[j].runId,irun );
    11651221exit(111);
    … …  
    11761232              actRun.Nroi    = mBuffer[id].nRoi ;
    11771233//            actRun.FADhead = mBuffer[id].FADhead ;  //to be corrected
    1178               runCtrl[j].nextEvt= 0;
    1179               runCtrl[j].lastTime=g_actTime ;
     1234
    11801235              runCtrl[j].fileHd = runOpen(irun,  &actRun, sizeof(actRun) ) ;
    11811236              if (runCtrl[j].fileHd == NULL ) {
    … …  
    11911246           }
    11921247
    1193            if (runCtrl[j].fileId > 0 ) {
     1248           if (runCtrl[j].fileId != 0 ) {
    11941249              snprintf(str,MXSTR,"W no open file for this run %d",irun) ;
    1195               factOut(kDebug,123,str) ;
     1250              factOut(kWarn,123,str) ;
    11961251              evtCtrl.evtStat[k0] = 902 ;
     1252              gi.wrtErr++ ;
    11971253           } else {
    1198               int i=runWrite(runCtrl[j].fileHd, mBuffer[id].fEvent, sizeof(mBuffer[id]) );
    1199               if (i<0) {
     1254              i=runWrite(runCtrl[j].fileHd, mBuffer[id].fEvent, sizeof(mBuffer[id]) );
     1255              if ( i>=0 ) {
     1256                 runCtrl[j].lastTime = g_actTime;
     1257                 runCtrl[j].actEvt++ ;
     1258                 evtCtrl.evtStat[k0] = 901 ;
     1259                 snprintf(str,MXSTR,"%5d successfully wrote for run %d id %5d",ievt,irun,k0);
     1260                 factOut(kDebug,504, str ) ;
     1261                 gj.writEvt++ ;
     1262              } else {
    12001263                 snprintf(str,MXSTR,"W error writing event for run %d",irun) ;
    12011264                 factOut(kError,503, str ) ;
    12021265                 evtCtrl.evtStat[k0] = 901 ;
    1203                  //close run
     1266                 gi.wrtErr++ ;
     1267              }
     1268
     1269              if ( i < 0
     1270                || runCtrl[j].closeTime < g_actTime
     1271                || runCtrl[j].lastTime  < g_actTime-300
     1272                || runCtrl[j].maxEvt    < runCtrl[j].actEvt )  {
     1273int ii =0 ;
     1274if ( i < 0 ) ii=1 ;
     1275else if (runCtrl[j].closeTime < g_actTime ) ii=2 ;
     1276else if (runCtrl[j].lastTime  < g_actTime-300 ) ii=3 ;
     1277else if (runCtrl[j].maxEvt    < runCtrl[j].actEvt ) ii=4 ;
     1278
     1279
     1280
     1281                 //close run for whatever reason
     1282                 if (runCtrl[j].runId == gi_myRun) gi_myRun = g_actTime ;
    12041283                 i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
    12051284                 if (i<0) {
    1206                     snprintf(str,MXSTR,"W error closing run %d",irun) ;
     1285                    snprintf(str,MXSTR,"error closing run %d %d AAA",runCtrl[j].runId,i) ;
    12071286                    factOut(kError,503, str ) ;
     1287                    runCtrl[j].fileId = 9001 ;
    12081288                 } else {
    1209                     snprintf(str,MXSTR,"W closed run %d because of write error",irun) ;
     1289                    snprintf(str,MXSTR,"W closed run %d AAA %d",irun,ii) ;
    12101290                    factOut(kInfo,503, str ) ;
     1291                    runCtrl[j].fileId = 901 ;
    12111292                 }
    1212                  runCtrl[j].fileId = 9999 ;
    1213               } else {
    1214                  runCtrl[j].lastTime = g_actTime;
    1215                  evtCtrl.evtStat[k0] = 901 ;
    1216                  snprintf(str,MXSTR,"%5d successfully wrote for run %d id %5d",ievt,irun,k0);
    1217                  factOut(kDebug,504, str ) ;
    12181293              }
    12191294           }
    … …  
    12211296     }
    12221297
    1223      //check if we should close a run ...
     1298     //check if we should close a run (mainly when no event pending)
    12241299     for ( j=0; j<MAX_RUN; j++) {
    12251300        if ( runCtrl[j].fileId==0   
    12261301          && (  runCtrl[j].closeTime < g_actTime 
    1227               ||runCtrl[j].lastTime  < g_actTime-120) ) {
    1228            int i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
     1302              ||runCtrl[j].lastTime  < g_actTime-300
     1303              ||runCtrl[j].maxEvt    < runCtrl[j].actEvt ) ) {
     1304           if (runCtrl[j].runId == gi_myRun) gi_myRun = g_actTime ;
     1305int ii =0 ;
     1306if ( i < 0 ) ii=1 ;
     1307else if (runCtrl[j].closeTime < g_actTime ) ii=2 ;
     1308else if (runCtrl[j].lastTime  < g_actTime-300 ) ii=3 ;
     1309else if (runCtrl[j].maxEvt    < runCtrl[j].actEvt ) ii=4 ;
     1310
     1311
     1312           i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
    12291313           if (i<0) {
    1230               snprintf(str,MXSTR,"error closing run %d %d",runCtrl[j].runId,i) ;
     1314              snprintf(str,MXSTR,"error closing run %d %d BBB",runCtrl[j].runId,i) ;
    12311315              factOut(kError,506, str ) ;
    1232               runCtrl[j].fileId = 888 ;
     1316              runCtrl[j].fileId = 9011 ;
    12331317           } else {
    1234               snprintf(str,MXSTR,"closing run %d ok  BBB",runCtrl[j].runId);
     1318              snprintf(str,MXSTR,"W closed run %d BBB %d",runCtrl[j].runId,ii) ;
    12351319              factOut(kInfo,507, str ) ;
    1236               runCtrl[j].fileId = 7777 ;
     1320              runCtrl[j].fileId = 911 ;
    12371321           }
    12381322        }
    … …  
    12461330     }
    12471331
    1248      if ( gi_runStat < -10 && numWait == 0) {  //nothing left to do
     1332     if ( gj.readStat < -10 && numWait == 0) {  //nothing left to do
    12491333        snprintf(str,MXSTR,"Finish Write Process ...");
    12501334        factOut(kInfo,-1, str ) ;
    12511335        gw_runStat = -22 ;                     //==> we should exit
     1336        gj.writStat= -22 ;                     //==> we should exit
    12521337        goto closerun ;
    12531338     }
    12541339     gw_runStat = gi_runStat ;
     1340     gj.writStat= gj.readStat ;
    12551341
    12561342  }
    … …  
    12641350  for ( j=0; j<MAX_RUN; j++)
    12651351     if ( runCtrl[j].fileId ==0 ) {
    1266         int i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
     1352        if (runCtrl[j].runId == gi_myRun) gi_myRun = g_actTime ;
     1353        i=runClose(runCtrl[j].fileHd, &runTail[j], sizeof(runTail[j]) );
     1354int ii =0 ;
     1355if ( i < 0 ) ii=1 ;
     1356else if (runCtrl[j].closeTime < g_actTime ) ii=2 ;
     1357else if (runCtrl[j].lastTime  < g_actTime-300 ) ii=3 ;
     1358else if (runCtrl[j].maxEvt    < runCtrl[j].actEvt ) ii=4 ;
    12671359        if (i<0) {
    1268            snprintf(str,MXSTR,"error closing run %d %d",runCtrl[j].runId,i) ;
     1360           snprintf(str,MXSTR,"error closing run %d %d CCC",runCtrl[j].runId,i) ;
    12691361           factOut(kError,506, str ) ;
    1270            runCtrl[j].fileId = 888 ;
     1362           runCtrl[j].fileId = 9021 ;
    12711363        } else {
    1272            snprintf(str,MXSTR,"closing run %d ok  AAA",runCtrl[j].runId);
     1364           snprintf(str,MXSTR,"W closed run %d CCC %d",runCtrl[j].runId,ii) ;
    12731365           factOut(kInfo,507, str ) ;
    1274            runCtrl[j].fileId = 7777 ;
     1366           runCtrl[j].fileId = 921 ;
    12751367        }
    12761368     }
    12771369
    12781370  gw_runStat = -99;
     1371  gj.writStat= -99;
    12791372  snprintf(str,MXSTR,"Exit Writing Process ...");
    12801373  factOut(kInfo,-1, str ) ;
    … …  
    12971390
    12981391  gi_runStat = gp_runStat = gw_runStat = 0 ;
     1392  gj.readStat= gj.procStat= gj.writStat= 0 ;
     1393
    12991394
    13001395  snprintf(str,MXSTR,"Starting EventBuilder");
    … …  
    13091404   for (i=0; i<MAX_RUN; i++) {
    13101405      runCtrl[i].runId = 0 ;
    1311       runCtrl[i].lastTime = 0 ;
    1312       runCtrl[i].closeTime = time(NULL) + 3600*24*7;
    1313 
    1314       runCtrl[i].nextEvt = 0 ;
    13151406      runCtrl[i].fileId = -2 ;
    1316 
    1317       runTail[i].nEventsOk =
    1318       runTail[i].nEventsRej =
    1319       runTail[i].nEventsBad =
    1320       runTail[i].PCtime0 =
    1321       runTail[i].PCtimeX = 0 ;
    1322    }
     1407   }
     1408
     1409   gj.evtBuf =
     1410   gj.readEvt =
     1411   gj.procEvt =
     1412   gj.writEvt =
     1413   gj.skipEvt = 0 ;
    13231414
    13241415//start all threads (more to come) when we are allowed to ....
    … …  
    13381429  imax=i ;
    13391430
    1340 
    1341 
    1342 
    1343 
    1344 /*
     1431#ifdef BILAND
    13451432     xwait.tv_sec = 20;;
    13461433     xwait.tv_nsec= 0 ;  // sleep for ~20sec
    13471434     nanosleep( &xwait , NULL ) ;
    13481435
    1349 
    13501436     printf("close all runs in 2 seconds\n");
    13511437
    1352 
    1353      CloseRunFile( 0, time(NULL)+2) ;
     1438     CloseRunFile( 0, time(NULL)+2, 0) ;
    13541439
    13551440     xwait.tv_sec = 5;;
    … …  
    13601445
    13611446     g_runStat = -1 ;
    1362 */
    1363 
    1364 
    1365 
    1366 
    1367 
    1368 
    1369 
    1370 
    1371 
     1447#endif
    13721448
    13731449
    … …  
    13781454
    13791455} /*-----------------------------------------------------------------*/
     1456
     1457
     1458
     1459
     1460
     1461
     1462
     1463
     1464
     1465
    13801466
    13811467
    … …  
    13881474  /*-----------------------------------------------------------------*/
    13891475  /*-----------------------------------------------------------------*/
     1476
     1477
     1478#ifdef BILAND
     1479
     1480
    13901481  /*-----------------------------------------------------------------*/
    13911482  /*-----------------------------------------------------------------*/
    … …  
    13951486
    13961487 
    1397 /*
     1488
    13981489
    13991490FileHandle_t  runOpen(uint32_t irun, RUN_HEAD *runhd, size_t len )
    … …  
    14201511
    14211512
    1422 void factStat(int64_t *array, int len ) {
    1423   printf("stat: bfr%5lu skp%4lu free%4lu (tot%7lu) mem%12lu rd%12lu %3lu\n",
    1424     array[0],array[1],array[2],array[3],array[4],array[5],array[6]);
     1513void factStatNew(EVT_STAT gi) {
     1514  int i ;
     1515
     1516  for (i=0;i<MAX_SOCK;i++) {
     1517     printf("%4d",gi.numRead[i]);
     1518     if (i%20 == 0 ) printf("\n");
     1519  }
     1520}
     1521
     1522
     1523void factStat(GUI_STAT gj) {
     1524//  printf("stat: bfr%5lu skp%4lu free%4lu (tot%7lu) mem%12lu rd%12lu %3lu\n",
     1525//    array[0],array[1],array[2],array[3],array[4],array[5],array[6]);
    14251526}
    14261527
    … …  
    14351536}
    14361537
    1437 void debugHead(int i, void *buf) {
     1538void debugHead(int i, int j, void *buf) {
    14381539}
    14391540
    … …  
    14851586//}
    14861587//
    1487 //version for PC-test
     1588//version for PC-test *
    14881589  for (c=0; c<4; c++) {
    14891590     for (b=0; b<10; b++) {
    … …  
    15131614
    15141615}
    1515 */
     1616#endif
Note: See TracChangeset for help on using the changeset viewer.