Changeset 15280


Ignore:
Timestamp:
04/08/13 14:26:32 (12 years ago)
Author:
tbretz
Message:
Added a new, faster, scheme to allocate and free memory. Memeory new is never really free'd anymore. Note that decreasing memory usage during operation at the moment is not possible at the moment. For the moment switched off some log output to improve performance. The sleeping was a bit odd on a slow machine. Instead, sleep once after each try of all 40 boards for 1us. Restructured the reading loop (continue instead of many if's and goto's) for better readability and maintainability.
File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/FACT++/src/EventBuilder.c

    r15127 r15280  
    4646
    4747extern void factOut (int severity, int err, char *message);
     48extern void factReportIncomplete (uint64_t rep);
    4849
    4950extern void gotNewRun (int runnr, PEVNT_HEADER * headers);
     
    9899int gw_runStat;
    99100
    100 int gi_memStat = +1;
     101//int gi_memStat = +1;
    101102
    102103uint32_t gi_myRun = 0;
     
    128129char str[MXSTR];
    129130
     131#define THOMAS_MALLOC
     132
     133#ifdef THOMAS_MALLOC
     134#define MAX_HEAD_MEM (NBOARDS * sizeof(PEVNT_HEADER))
     135#define MAX_TOT_MEM (sizeof(EVENT) + (NPIX+NTMARK)*1024*2 + MAX_HEAD_MEM)
     136typedef struct TGB_struct
     137{
     138    struct TGB_struct *prev;
     139    void *mem;
     140} TGB_entry;
     141
     142TGB_entry  *tgb_last = NULL;
     143uint64_t    tgb_memory = 0;
     144uint64_t    tgb_inuse  = 0;
     145
     146void *TGB_Malloc()
     147{
     148    // No free slot available, next alloc would exceed max memory
     149    if (!tgb_last && tgb_memory+MAX_TOT_MEM>g_maxMem)
     150        return NULL;
     151
     152    // We will return this amount of memory
     153    tgb_inuse += MAX_TOT_MEM;
     154
     155    // No free slot available, allocate a new one
     156    if (!tgb_last)
     157    {
     158        tgb_memory += MAX_TOT_MEM;
     159        return malloc(MAX_TOT_MEM);
     160    }
     161
     162    // Get the next free slot from the stack and return it
     163    TGB_entry *last = tgb_last;
     164
     165    TGB_entry *mem = last->mem;
     166    tgb_last       = last->prev;
     167
     168    free(last);
     169
     170    return mem;
     171};
     172
     173void TGB_free(void *mem)
     174{
     175    // Add the last free slot to the stack
     176    TGB_entry *entry = malloc(sizeof(TGB_entry));
     177
     178    entry->prev = tgb_last;
     179    entry->mem  = mem;
     180
     181    tgb_last = entry;
     182
     183    // Decrease the amont of memory in use accordingly
     184    tgb_inuse -= MAX_TOT_MEM;
     185}
     186#endif
     187
     188#ifdef ETIENNE_MALLOC
    130189//ETIENNE
    131190#define MAX_SLOTS_PER_CHUNK 100
     
    207266    for (int i=1;i<numNewSlots;i++)
    208267    {
    209         EtiMemoryChunks[numAllocatedChunks].pointers[i] = EtiMemoryChunks[numAllocatedChunks].pointers[0] + i*MAX_SLOT_SIZE;// &(((char*)(EtiMemoryChunks[numAllocatedChunks].pointers[i-1]))[MAX_SLOT_SIZE]);
     268        EtiMemoryChunks[numAllocatedChunks].pointers[i] = (char*)EtiMemoryChunks[numAllocatedChunks].pointers[0] + i*MAX_SLOT_SIZE;// &(((char*)(EtiMemoryChunks[numAllocatedChunks].pointers[i-1]))[MAX_SLOT_SIZE]);
    210269        EtiMemoryChunks[numAllocatedChunks].events[i] = -1;
    211270    }
     
    226285    currentChunk->events[mBufferMapping[evtIndex].slot] = -1;
    227286    currentChunk->nFreeSlots++;
    228        
     287
     288    return; /* TEST */
     289
    229290    int chunkIndex = mBufferMapping[evtIndex].chunk;
    230291    if (chunkIndex != numAllocatedChunks-1)
     
    249310}
    250311//END ETIENNE
    251 
     312#endif
    252313
    253314
     
    465526      evtCtrl.pcTime[i] = actime;       //initiate to far future
    466527
     528#ifdef ETIENNE_MALLOC
    467529      //ETIENNE
    468530      mBufferMapping[i].chunk = -1;
     
    470532      mBufferMapping[i].slot = -1;
    471533      //END ETIENNE
    472    }
     534#endif
     535   }
     536#ifdef ETIENNE_MALLOC
    473537   for (int j=0;j<MAX_CHUNKS;j++)
    474538       EtiMemoryChunks[j].pointers[0] = NULL;
     539#endif
    475540
    476541   actRun.FADhead = malloc (NBOARDS * sizeof (PEVNT_HEADER));
     
    498563//        < 0    if no space left
    499564
    500    struct timeval *tv, atv;
    501    tv = &atv;
     565   struct timeval tv;
    502566   uint32_t tsec, tusec;
    503567   uint oldest;
     
    506570   int i, b, evFree;
    507571//   int headmem = 0;
    508    size_t needmem = 0;
     572//   size_t needmem = 0;
    509573
    510574
     
    578642   i = evFree;                  //found free entry; use it ...
    579643
    580    gettimeofday (tv, NULL);
    581    tsec = atv.tv_sec;
    582    tusec = atv.tv_usec;
     644   gettimeofday (&tv, NULL);
     645   tsec = tv.tv_sec;
     646   tusec = tv.tv_usec;
    583647
    584648   //check if runId already registered in runCtrl
     
    665729      return -11;
    666730   }
    667 */
     731   */
     732
     733#ifdef THOMAS_MALLOC
     734   mBuffer[i].FADhead = TGB_Malloc();
     735   mBuffer[i].fEvent  = NULL;
     736   mBuffer[i].buffer  = NULL;
     737   if (mBuffer[i].FADhead == NULL) {
     738      snprintf (str, MXSTR, "malloc header failed for event %d", evID);
     739      factOut (kError, 882, str);
     740      return -12;
     741   }
     742   mBuffer[i].fEvent = (void*)((char*)mBuffer[i].FADhead+MAX_HEAD_MEM);
     743#endif
     744
     745#ifdef ETIENNE_MALLOC
    668746   mBuffer[i].FADhead = ETI_Malloc(evID, i);
    669747   mBuffer[i].buffer = NULL;
     
    678756       if (gj.usdMem > gj.maxMem)
    679757          gj.maxMem = gj.usdMem;
    680        if (gi_memStat > 0) {
     758       /*if (gi_memStat > 0) {
    681759           gi_memStat = -99;
    682760           snprintf (str, MXSTR, "No memory left to keep event %6d sock %3d",
    683761                     evID, sk);
    684762           factOut (kError, 882, str);
    685         }
     763        }*/
    686764#ifdef EVTDEBUG
    687765       else
     
    694772       return -11;
    695773   }
     774#endif
     775
     776#ifdef STANDARD_MALLOC
     777
     778   mBuffer[i].FADhead = malloc (MAX_HEAD_MEM+MAX_EVT_MEM);
     779   mBuffer[i].fEvent  = NULL;
     780   mBuffer[i].buffer  = NULL;
     781   if (mBuffer[i].FADhead == NULL) {
     782      snprintf (str, MXSTR, "malloc header failed for event %d", evID);
     783      factOut (kError, 882, str);
     784      return -12;
     785   }
     786   mBuffer[i].fEvent = (void*)((char*)mBuffer[i].FADhead+MAX_HEAD_MEM);
     787#endif
     788
    696789   /*
    697790   mBuffer[i].FADhead = malloc (headmem);
     
    746839   mBuffer[i].trgNum = trgNum;
    747840   mBuffer[i].trgTyp = trgTyp;
    748    mBuffer[i].evtLen = needmem;
     841//   mBuffer[i].evtLen = needmem;
    749842   mBuffer[i].Errors[0] =
    750       mBuffer[i].Errors[1] = mBuffer[i].Errors[2] = mBuffer[i].Errors[3] = 0;
     843       mBuffer[i].Errors[1] = mBuffer[i].Errors[2] = mBuffer[i].Errors[3] = 0;
     844
     845#ifdef ETIENNE_MALLOC
    751846//ETIENNE
    752847   //gj.usdMem += needmem + headmem + gi_maxSize;
     
    757852   }
    758853//END ETIENNE
     854#endif
     855
     856#ifdef THOMAS_MALLOC
     857   gj.usdMem = tgb_inuse;
     858#endif
     859
    759860   if (gj.usdMem > gj.maxMem)
    760861      gj.maxMem = gj.usdMem;
     
    800901
    801902//   int headmem = 0;
     903//   size_t freemem = 0;
     904
     905#ifdef ETIENNE_MALLOC
    802906   int evid;
    803 //   size_t freemem = 0;
    804 
    805907   evid = mBuffer[i].evNum;
     908   ETI_Free(evid, i);
     909#endif
     910
    806911//   freemem = mBuffer[i].evtLen;
    807912   //ETIENNE
    808    ETI_Free(evid, i);
     913#ifdef THOMAS_MALLOC
     914   TGB_free(mBuffer[i].FADhead);
     915#endif
     916
     917#ifdef STANDARD_MALLOC
     918   free (mBuffer[i].FADhead);
     919#endif
     920
    809921//   free (mBuffer[i].fEvent);
    810922   mBuffer[i].fEvent = NULL;
     
    819931   mBuffer[i].evNum = mBuffer[i].nRoi = -1;
    820932   mBuffer[i].runNum = 0;
     933
     934#ifdef ETIENNE_MALLOC
    821935//ETIENNE
    822936//   gj.usdMem = gj.usdMem - freemem - headmem - gi_maxSize;
     
    827941   }
    828942//END ETIENNE
     943#endif
     944
     945#ifdef THOMAS_MALLOC
     946   gj.usdMem = tgb_inuse;
     947#endif
     948
    829949   gj.bufTot--;
    830950
    831    if (gi_memStat < 0) {
     951   /*if (gi_memStat < 0) {
    832952      if (gj.usdMem <= 0.75 * gj.maxMem)
    833953         gi_memStat = +1;
    834    }
    835 
     954   }*/
    836955
    837956   return 0;
     
    8831002} /*-----------------------------------------------------------------*/
    8841003
     1004//struct rnd
     1005//{
     1006//    int val;
     1007//    int idx;
     1008//};
     1009//
     1010//struct rnd random_arr[MAX_SOCK];
     1011//
     1012//int compare(const void *f1, const void *f2)
     1013//{
     1014//    struct rnd *r1 = (struct rnd*)f1;
     1015//    struct rnd *r2 = (struct rnd*)f2;
     1016//    return r1->val - r2->val;
     1017//}
    8851018
    8861019
     
    9041037
    9051038
    906    struct timeval *tv, atv;
    907    tv = &atv;
     1039   struct timeval tv;
    9081040   uint32_t tsec, tusec;
    9091041
     
    9461078
    9471079 START:
    948    gettimeofday (tv, NULL);
    949    g_actTime = tsec = atv.tv_sec;
    950    g_actUsec = tusec = atv.tv_usec;
     1080   gettimeofday (&tv, NULL);
     1081   g_actTime = tsec = tv.tv_sec;
     1082   g_actUsec = tusec = tv.tv_usec;
    9511083   gi_myRun = g_actTime;
    9521084   evtCtrl.frstPtr = 0;
     
    9831115      gj.bufTot = gj.maxEvt = gj.xxxEvt = 0;
    9841116      gj.usdMem = gj.maxMem = gj.xxxMem = 0;
     1117#ifdef THOMAS_MALLOC
     1118      gj.totMem = tgb_memory;
     1119#else
    9851120      gj.totMem = g_maxMem;
     1121#endif
    9861122      gj.bufNew = gj.bufEvt = 0;
    9871123      gj.badRoiE = gj.badRoiR = gj.badRoiB =
     
    10051141      gi_runStat = g_runStat;
    10061142      gj.readStat = g_runStat;
    1007       gettimeofday (tv, NULL);
    1008       g_actTime = tsec = atv.tv_sec;
    1009       g_actUsec = tusec = atv.tv_usec;
     1143      gettimeofday (&tv, NULL);
     1144      g_actTime = tsec = tv.tv_sec;
     1145      g_actUsec = tusec = tv.tv_usec;
    10101146
    10111147
     
    10521188      numok = 0;                //count number of succesfull actions
    10531189
    1054       for (i = 0; i < MAX_SOCK; i++) {  //check all sockets if something to read
     1190/*
     1191      for (i=0; i<MAX_SOCK/7; i++)
     1192      {
     1193          random_arr[i].val = rand();
     1194          random_arr[i].idx = i;
     1195      }
     1196
     1197      qsort(random_arr, MAX_SOCK/7, sizeof(struct rnd), compare);
     1198
     1199      for (int iii = 0; iii < MAX_SOCK/7; iii++) {  //check all sockets if something to read
     1200
     1201      b = random_arr[iii].idx;
     1202      i = b*7;
     1203      p = 0;
     1204      */
     1205
     1206      for (i = 0; i < MAX_SOCK; i+=7) {  //check all sockets if something to read
     1207
    10551208         b = i / 7 ;
    10561209         p = i % 7 ;
    10571210
    1058 if ( p >= NUMSOCK) { ; }
    1059 else {
     1211/*if ( p >= NUMSOCK) { ; }
     1212else*/ {
    10601213         if (sockDef[b] > 0)
    10611214            s0 = +1;
     
    10701223               if (rd[i].sockStat == -1) {
    10711224                  rd[i].errCnt++ ;
     1225                   usleep(25000);
    10721226//                if (rd[i].errCnt < 100) rd[i].sockStat = rd[i].errCnt ;
    10731227//                else if (rd[i].errCnt < 1000) rd[i].sockStat = 1000 ;
     
    11011255
    11021256         if (rd[i].sockStat == 0) {     //we have a connection ==> try to read
    1103             if (rd[i].bufLen > 0) {     //might be nothing to read [buffer full]
     1257
     1258             if (rd[i].bufLen<=0)
     1259             {
     1260#ifdef EVTDEBUG
     1261               snprintf (str, MXSTR, "do not read from socket %d  %d", i,
     1262                         rd[i].bufLen);
     1263               factOut (kDebug, 301, str);
     1264#endif
     1265                 continue;
     1266             }
     1267
     1268//            if (rd[i].bufLen > 0) {     //might be nothing to read [buffer full]
    11041269               numok++;
    1105                size_t maxread = rd[i].bufLen ;
    1106                if (maxread > MAXREAD ) maxread=MAXREAD ;
    11071270
    11081271               jrd =
    11091272                  recv (rd[i].socket, &rd[i].rBuf->B[rd[i].bufPos],
    1110                         maxread, MSG_DONTWAIT);
    1111 //                      rd[i].bufLen, MSG_DONTWAIT);
     1273                        rd[i].bufLen, MSG_DONTWAIT);
     1274
     1275#ifdef EVTDEBUG
    11121276               if (jrd > 0) {
    11131277                  debugStream (i, &rd[i].rBuf->B[rd[i].bufPos], jrd);
    1114 #ifdef EVTDEBUG
    11151278                  memcpy (&rd[i].xBuf->B[rd[i].bufPos],
    11161279                          &rd[i].rBuf->B[rd[i].bufPos], jrd);
     
    11201283                            rd[i].rBuf->B[rd[i].bufPos + 1]);
    11211284                  factOut (kDebug, 301, str);
    1122 #endif
    11231285               }
     1286#endif
    11241287
    11251288               if (jrd == 0) {  //connection has closed ...
     
    11401303                  } else
    11411304                     numok--;   //else nothing waiting to be read
    1142                   jrd = 0;
     1305                  //jrd = 0;
    11431306               }
    1144             } else {
    1145                jrd = 0;         //did read nothing as requested
     1307/*            } else {
     1308             //  jrd = 0;         //did read nothing as requested
    11461309#ifdef EVTDEBUG
    11471310               snprintf (str, MXSTR, "do not read from socket %d  %d", i,
     
    11501313#endif
    11511314               }
     1315*/
     1316            if (jrd<=0)
     1317                continue;
    11521318
    11531319            gi.gotByte[b] += jrd;
    11541320            gj.rateBytes[b] += jrd;
    11551321
    1156             if (jrd > 0) {
     1322            //if (jrd > 0) {
    11571323               numokx++;
    11581324               jrdx += jrd;
    1159             }
     1325            //}
    11601326
    11611327
     
    11671333               factOut (kInfo, 301, str);
    11681334#endif
    1169 
    1170             } else if (rd[i].bufTyp > 0) {      // we are reading data ...
    1171                if (jrd < rd[i].bufLen) {        //not yet all read
    1172                   rd[i].bufPos += jrd;  //==> prepare for continuation
    1173                   rd[i].bufLen -= jrd;
     1335               continue;
     1336            }
     1337
     1338            rd[i].bufPos += jrd;  //==> prepare for continuation
     1339            rd[i].bufLen -= jrd;
     1340
     1341            if (rd[i].bufTyp > 0) {      // we are reading data ...
     1342
     1343               if (rd[i].bufLen>0/*jrd < rd[i].bufLen*/) {        //not yet all read
     1344#ifdef EVTDEBUG
    11741345                  debugRead (i, jrd, rd[i].evtID, rd[i].ftmID, rd[i].runID, 0, tsec, tusec);    // i=socket; jrd=#bytes; ievt=eventid; 0=reading data
    1175                } else {         //full dataset read
    1176                   rd[i].bufLen = 0;
    1177                   rd[i].bufPos = rd[i].fadLen;
    1178                   if (rd[i].rBuf->B[rd[i].bufPos - 1] != stop.B[0]
    1179                       || rd[i].rBuf->B[rd[i].bufPos - 2] != stop.B[1]) {
     1346#endif
     1347                  continue;
     1348               }
     1349
     1350               //int pos = rdi_bufPos = rd[i].bufPos;
     1351               //int pos = rdi_bufLen = rd[i].bufLen;
     1352               //int pos = rdi_bufTyp = rd[i].bufTyp;
     1353
     1354               rd[i].bufTyp = 0;     //ready to read next header
     1355               rd[i].bufLen = frst_len;
     1356               rd[i].bufPos = 0;
     1357
     1358               //{
     1359               //full dataset read
     1360                  //rd[i].bufLen = 0;
     1361                  //rd[i].bufPos = rd[i].fadLen;
     1362                  if (rd[i].rBuf->B[rd[i].fadLen - 1] != stop.B[0] ||
     1363                      rd[i].rBuf->B[rd[i].fadLen - 2] != stop.B[1]) {
    11801364                     gi.evtErr++;
    11811365                     snprintf (str, MXSTR,
    11821366                               "End-of-event flag wrong on socket %3d for event %4d (len=%5d), expected %3d %3d, got %3d %3d",
    11831367                               i, rd[i].evtID, rd[i].fadLen, stop.B[0], stop.B[1],
    1184                                rd[i].rBuf->B[rd[i].bufPos - 1], rd[i].rBuf->B[rd[i].bufPos - 2]);
     1368                               rd[i].rBuf->B[rd[i].fadLen - 1], rd[i].rBuf->B[rd[i].fadLen - 2]);
    11851369                     factOut (kError, 301, str);
    1186                      goto EndBuf;
     1370                     //goto EndBuf;
     1371                     continue;
    11871372
    11881373#ifdef EVTDEBUG
     
    11921377                               i, rd[i].fadLen, rd[i].rBuf->B[0],
    11931378                               rd[i].rBuf->B[1], start.B[1], start.B[0],
    1194                                rd[i].rBuf->B[rd[i].bufPos - 2],
    1195                                rd[i].rBuf->B[rd[i].bufPos - 1], stop.B[1],
     1379                               rd[i].rBuf->B[rd[i].fadLen - 2],
     1380                               rd[i].rBuf->B[rd[i].fadLen - 1], stop.B[1],
    11961381                               stop.B[0]);
    11971382                     factOut (kDebug, 301, str);
     
    11991384                  }
    12001385
    1201                   if (jrd > 0)
     1386#ifdef EVTDEBUG
     1387                  //if (jrd > 0)
    12021388                     debugRead (i, jrd, rd[i].evtID, rd[i].ftmID, rd[i].runID, 1, tsec, tusec); // i=socket; jrd=#bytes; ievt=eventid; 1=finished event
     1389#endif
    12031390
    12041391/*                  //we have a complete buffer, copy to WORK area
     
    12611448                          snprintf (str, MXSTR, "Inconsistent Roi accross boards B=%d, expected %d, got %d", kr, checkRoi, roi[0]);
    12621449                          factOut (kError, 1, str);
    1263                           goto EndBuf;
     1450//                          goto EndBuf;
     1451                          continue;
    12641452                      }
    12651453                      roiHopper += checkRoi+4;
     
    12771465                             snprintf (str, MXSTR, "Inconsistent Roi accross patches B=%d P=%d, expected %d, got %d", kr, jr, roi[jr], checkRoi);
    12781466                             factOut (kFatal, 1, str);
    1279                              goto EndBuf;
     1467//                             goto EndBuf;
     1468                             continue;
    12801469                         }
    12811470                     }
     
    12941483
    12951484                  if (evID < -1000) {
    1296                      goto EndBuf;       //not usable board/event/run --> skip it
     1485//                     goto EndBuf;       //not usable board/event/run --> skip it
     1486                  //rd[i].bufTyp = 0;     //ready to read next header
     1487                  //rd[i].bufLen = frst_len;
     1488                  //rd[i].bufPos = 0;
     1489                  continue;
    12971490                  }
    12981491                  if (evID < 0) {       //no space left, retry later
     
    13031496                     }
    13041497#endif
    1305                      xwait.tv_sec = 0;
    1306                      xwait.tv_nsec = 10000000;  // sleep for ~10 msec
    1307                      nanosleep (&xwait, NULL);
    1308                      goto EndBuf1;      //hope there is free space next round
     1498                     rd[i].bufTyp = -1;
     1499                     rd[i].bufLen = 0;
     1500                     rd[i].bufPos = rd[i].fadLen;
     1501
     1502                     //xwait.tv_sec = 0;
     1503                     //xwait.tv_nsec = 10000000;  // sleep for ~10 msec
     1504                     //nanosleep (&xwait, NULL);
     1505                     continue;
     1506                     //goto EndBuf1;      //hope there is free space next round
    13091507                  }
    13101508                  //we have a valid entry in mBuffer[]; fill it
     
    13421540                               evID, boardId, i, rd[i].fadLen,
    13431541                               rd[i].rBuf->B[0], rd[i].rBuf->B[1],
    1344                                rd[i].rBuf->B[rd[i].bufPos - 2],
    1345                                rd[i].rBuf->B[rd[i].bufPos - 1]);
     1542                               rd[i].rBuf->B[rd[i].fadLen - 2],
     1543                               rd[i].rBuf->B[rd[i].fadLen - 1]);
    13461544                     factOut (kWarn, 501, str);
    1347                      goto EndBuf;       //--> skip Board
     1545//                     goto EndBuf;       //--> skip Board
     1546                     //rd[i].bufTyp = 0;     //ready to read next header
     1547                     //rd[i].bufLen = frst_len;
     1548                     //rd[i].bufPos = 0;
     1549                  continue;
    13481550                  }
    13491551
     
    14331635                  }
    14341636
    1435                 EndBuf:
    1436                   rd[i].bufTyp = 0;     //ready to read next header
    1437                   rd[i].bufLen = frst_len;
    1438                   rd[i].bufPos = 0;
    1439                 EndBuf1:
     1637//                EndBuf:
     1638                  //rd[i].bufTyp = 0;     //ready to read next header
     1639                  //rd[i].bufLen = frst_len;
     1640                  //rd[i].bufPos = 0;
     1641                //EndBuf1:
    14401642                  ;
    1441                }
     1643               //}
    14421644
    14431645            } else {            //we are reading event header
    1444                rd[i].bufPos += jrd;
    1445                rd[i].bufLen -= jrd;
    1446                if (rd[i].bufPos >= minLen) {    //sufficient data to take action
     1646                //rd[i].bufPos += jrd;
     1647                //rd[i].bufLen -= jrd;
     1648                if (rd[i].bufPos < minLen) //{    //sufficient data to take action
     1649                {
     1650#ifdef EVTDEBUG
     1651                    debugRead (i, jrd, 0, 0, 0, -2, tsec, tusec);      // i=socket; jrd=#bytes; ievt=eventid; -2=start event, unknown id yet
     1652#endif
     1653                    continue;
     1654                }
     1655
    14471656                  //check if startflag correct; else shift block ....
    14481657                  for (k = 0; k < rd[i].bufPos - 1; k++) {
     
    14561665                     rd[i].bufPos = 0;
    14571666                     rd[i].bufLen = head_len;
    1458                   } else if (k > 0) {
     1667                     continue;
     1668                  }
     1669
     1670                  if (k > 0) {
    14591671                     rd[i].bufPos -= k;
    14601672                     rd[i].bufLen += k;
    1461                      memcpy (&rd[i].rBuf->B[0], &rd[i].rBuf->B[k],
    1462                              rd[i].bufPos);
     1673                     memmove (&rd[i].rBuf->B[0], &rd[i].rBuf->B[k],
     1674                              rd[i].bufPos);
    14631675#ifdef EVTDEBUG
    14641676                     memcpy (&rd[i].xBuf->B[0], &rd[i].xBuf->B[k],
     
    14661678#endif
    14671679                  }
    1468                   if (rd[i].bufPos >= minLen) {
     1680
     1681                  if (rd[i].bufPos < minLen)
     1682                  {
     1683#ifdef EVTDEBUG
     1684                      debugRead (i, jrd, 0, 0, 0, -2, tsec, tusec);      // i=socket; jrd=#bytes; ievt=eventid; -2=start event, unknown id yet
     1685#endif
     1686                      continue;
     1687                  }
     1688
     1689                  //{
    14691690                     if (rd[i].skip > 0) {
    14701691                        snprintf (str, MXSTR, "Skipped %d bytes on port %d",
     
    14731694                        rd[i].skip = 0;
    14741695                     }
     1696
     1697                     // TGB: This needs much more checks than just the first two bytes!
    14751698                     goodhed++;
    14761699
     
    15231746                        rd[i].runID = gi_myRun;
    15241747
    1525                      if (rd[i].bufLen <= head_len || rd[i].bufLen > MAX_LEN) {
     1748                     /*if (rd[i].bufLen <= head_len || rd[i].bufLen > MAX_LEN) {
    15261749                        snprintf (str, MXSTR,
    15271750                                  "Illegal event-length %d on port %d, %d expected.", rd[i].bufLen, i, head_len);
    15281751                        factOut (kFatal, 881, str);
    15291752                        rd[i].bufLen = 100000;  //?
    1530                      }
     1753                     }*/
    15311754
    15321755                     int fadBoard = rd[i].rBuf->S[12];
    15331756                     debugHead (i, fadBoard, rd[i].rBuf);
    15341757                     debugRead (i, jrd, rd[i].evtID, rd[i].ftmID, rd[i].runID, -1, tsec, tusec);        // i=socket; jrd=#bytes; ievt=eventid;-1=start event
    1535                   } else {
    1536                      debugRead (i, jrd, 0, 0, 0, -2, tsec, tusec);      // i=socket; jrd=#bytes; ievt=eventid; -2=start event, unknown id yet
    1537                   }
    1538                } else {
    1539                   debugRead (i, jrd, 0, 0, 0, -2, tsec, tusec); // i=socket; jrd=#bytes; ievt=eventid; -2=start event, unknown id yet
    1540                }
    1541 
    15421758            }                   //end interpreting last read
    15431759}
     
    15531769
    15541770      g_actTime = time (NULL);
    1555       if (g_actTime > gi_SecTime) {
     1771      if (g_actTime <= gi_SecTime) {
     1772          usleep(1);
     1773          continue;
     1774      }
     1775
    15561776         gi_SecTime = g_actTime;
    15571777
     
    15791799                  factOut (kWarn, 601, str);
    15801800
     1801                  uint64_t report = 0;
     1802
    15811803                  int ik,ib,jb;
    15821804                  ik=0;
    15831805                  for (ib=0; ib<NBOARDS; ib++) {
    1584                      if (ib%10==0) {
    1585                         snprintf (&str[ik], MXSTR, "|");
    1586                         ik++;
     1806                      if (ib%10==0) {
     1807                          str[ik++] = '|';
    15871808                     }
    15881809                     jb = mBuffer[id].board[ib];
    15891810                     if ( jb<0 ) {
    1590                         if (gi_NumConnect[b] >0 ) {
    1591                            snprintf (&str[ik], MXSTR, ".");
    1592                         } else {
    1593                            snprintf (&str[ik], MXSTR, "x");
     1811                         if (gi_NumConnect[b] >0 ) {
     1812                             str[ik++] = '.';
     1813                            report |= 1<<ib;
     1814                         } else {
     1815                             str[ik++] = 'x';
    15941816                        }
    15951817                     } else {
    1596                         snprintf (&str[ik], MXSTR, "%d",jb%10);
     1818                         str[ik++] = '0'+(jb%10);
    15971819                     }
    1598                      ik++;
    15991820                  }
    1600                   snprintf (&str[ik], MXSTR, "|");
     1821                  str[ik] = '|';
    16011822                  factOut (kWarn, 601, str);
     1823
     1824                  factReportIncomplete(report);
    16021825
    16031826                  evtCtrl.evtStat[k0] = 91;     //timeout for incomplete events
     
    16311854         gj.deltaT = 1000;      //temporary, must be improved
    16321855
    1633          int b;
    1634          for (b = 0; b < NBOARDS; b++)
    1635             gj.totBytes[b] += gj.rateBytes[b];
    1636          gj.totMem = g_maxMem;
     1856         for (int ib = 0; ib < NBOARDS; ib++)
     1857            gj.totBytes[ib] += gj.rateBytes[ib];
     1858#ifdef THOMAS_MALLOC
     1859      gj.totMem = tgb_memory;
     1860#else
     1861      gj.totMem = g_maxMem;
     1862#endif
    16371863         if (gj.maxMem > gj.xxxMem)
    16381864            gj.xxxMem = gj.maxMem;
     
    16471873         for (b = 0; b < NBOARDS; b++)
    16481874            gj.rateBytes[b] = 0;
    1649       }
    1650 
     1875/*
     1876      }
    16511877      if (numok > 0)
    16521878         numok2 = 0;
     
    16611887         nanosleep (&xwait, NULL);
    16621888      }
    1663 
     1889      */
    16641890   }                            //and do next loop over all sockets ...
    1665 
    16661891
    16671892   snprintf (str, MXSTR, "Stop reading ... RESET=%d", g_reset);
     
    17531978            if (evtCtrl.evtStat[k0] > minclear) {
    17541979               int id = evtCtrl.evtBuf[k0];
     1980#ifdef EVTDEBUG
    17551981               snprintf (str, MXSTR, "ev %5d free event buffer, nb=%3d",
    17561982                         mBuffer[id].evNum, mBuffer[id].nBoard);
    17571983               factOut (kDebug, -1, str);
     1984#endif
    17581985               mBufFree (id);   //event written--> free memory
    17591986               evtCtrl.evtStat[k0] = -1;
     
    17892016
    17902017
    1791    snprintf (str, MXSTR, "Exit read Process ...");
     2018   snprintf (str, MXSTR, "Exit read Process...");
    17922019   factOut (kInfo, -1, str);
     2020
     2021#ifdef THOMAS_MALLOC
     2022   snprintf (str, MXSTR, "%ld Bytes flaged as in-use.", tgb_inuse);
     2023   factOut (kInfo, -1, str);
     2024#endif
     2025
    17932026   gi_runStat = -99;
    17942027   gj.readStat = -99;
     
    20222255               }
    20232256               if (runCtrl[j].procId != 0) {
     2257#ifdef EVTDEBUG
    20242258                  snprintf (str, MXSTR,
    20252259                            "procEvt: Skip event %d because no active run %d", ievt,
    20262260                            irun);
    20272261                  factOut (kDebug, 502, str);
     2262#endif
    20282263                  evtCtrl.evtStat[k0] = 9091;
    20292264               } else {
     
    22952530                     runCtrl[j].fileId += 100;
    22962531                  } else {
     2532#ifdef EVTDEBUG
    22972533                      snprintf (str, MXSTR, "writeEvt: File for run %d is closed",
    22982534                               irun);
    22992535                     factOut (kDebug, 123, str);
     2536#endif
    23002537                  }
    23012538                  evtCtrl.evtStat[k0] = 9903;
     
    23102547                     runCtrl[j].actEvt++;
    23112548                     evtCtrl.evtStat[k0] = 9901;
     2549#ifdef EVTDEBUG
    23122550                     snprintf (str, MXSTR,
    23132551                               "%5d successfully wrote for run %d id %5d",
    23142552                               ievt, irun, k0);
    23152553                     factOut (kDebug, 504, str);
     2554#endif
    23162555//               gj.writEvt++ ;
    23172556                  } else {
Note: See TracChangeset for help on using the changeset viewer.