ul in parallel monolithic case, ul in parallel memory leak fix

common/utils/threadPool/thread-pool.c

@@ -84,7 +84,7 @@ void *one_thread(void *arg) {
         delNotifiedFIFO_elt(elt);
       else
         pushNotifiedFIFO(elt->reponseFifo, elt);
-
+      myThread->runningOnKey=-1;
       mutexunlock(tp->incomingFifo.lockF);
     }
   } while (true);
@@ -116,7 +116,7 @@ void initTpool(char *params,tpool_t *pool, bool performanceMeas) {
   pool->nbThreads=0;
   pool->restrictRNTI=false;
   curptr=strtok_r(params,",",&saveptr);
-
+  struct one_thread * ptr;
   while ( curptr!=NULL ) {
     int c=toupper(curptr[0]);
 
@@ -130,8 +130,9 @@ void initTpool(char *params,tpool_t *pool, bool performanceMeas) {
         break;
 
       default:
+	ptr=pool->allthreads;
         pool->allthreads=(struct one_thread *)malloc(sizeof(struct one_thread));
-        pool->allthreads->next=pool->allthreads;
+        pool->allthreads->next=ptr;
         printf("create a thread for core %d\n", atoi(curptr));
         pool->allthreads->coreID=atoi(curptr);
         pool->allthreads->id=pool->nbThreads;

common/utils/threadPool/thread-pool.h

@@ -137,8 +137,9 @@ static inline  notifiedFIFO_elt_t *pollNotifiedFIFO(notifiedFIFO_t *nf) {
 // This function aborts all messages matching the key
 // If the queue is used in thread pools, it doesn't cancels already running processing
 // because the message has already been picked
-static inline void abortNotifiedFIFO(notifiedFIFO_t *nf, uint64_t key) {
+static inline int abortNotifiedFIFO(notifiedFIFO_t *nf, uint64_t key) {
   mutexlock(nf->lockF);
+  int nbDeleted=0;
   notifiedFIFO_elt_t **start=&nf->outF;
 
   while(*start!=NULL) {
@@ -146,13 +147,15 @@ static inline void abortNotifiedFIFO(notifiedFIFO_t *nf, uint64_t key) {
       notifiedFIFO_elt_t *request=*start;
       *start=(*start)->next;
       delNotifiedFIFO_elt(request);
-    }
-
-    if (*start != NULL)
+      nbDeleted++;
+    } else
       start=&(*start)->next;
   }
+  if (nf->outF == NULL)
+    nf->inF=NULL;
 
   mutexunlock(nf->lockF);
+  return nbDeleted;
 }
 
 struct one_thread {
@@ -181,8 +184,17 @@ typedef struct thread_pool {
 
 static inline void pushTpool(tpool_t *t, notifiedFIFO_elt_t *msg) {
   if (t->measurePerf) msg->creationTime=rdtsc();
-
-  pushNotifiedFIFO(&t->incomingFifo, msg);
+  if ( t->activated)
+    pushNotifiedFIFO(&t->incomingFifo, msg);
+  else {
+        if (t->measurePerf)
+	  msg->startProcessingTime=rdtsc();
+	msg->processingFunc(NotifiedFifoData(msg));
+	if (t->measurePerf)
+	  msg->endProcessingTime=rdtsc();
+	if (msg->reponseFifo) 
+	  pushNotifiedFIFO(msg->reponseFifo, msg);
+  }
 }
 
 static inline notifiedFIFO_elt_t *pullTpool(notifiedFIFO_t *responseFifo, tpool_t *t) {
@@ -212,7 +224,8 @@ static inline notifiedFIFO_elt_t *tryPullTpool(notifiedFIFO_t *responseFifo, tpo
   return msg;
 }
 
-static inline void abortTpool(tpool_t *t, uint64_t key) {
+static inline int abortTpool(tpool_t *t, uint64_t key) {
+  int nbRemoved=0;
   notifiedFIFO_t *nf=&t->incomingFifo;
   mutexlock(nf->lockF);
   notifiedFIFO_elt_t **start=&nf->outF;
@@ -222,22 +235,26 @@ static inline void abortTpool(tpool_t *t, uint64_t key) {
       notifiedFIFO_elt_t *request=*start;
       *start=(*start)->next;
       delNotifiedFIFO_elt(request);
-    }
-
-    if (*start != NULL)
+      nbRemoved++;
+    } else
       start=&(*start)->next;
   }
+  if (t->incomingFifo.outF==NULL)
+    t->incomingFifo.inF=NULL;
 
   struct one_thread *ptr=t->allthreads;
 
   while(ptr!=NULL) {
-    if (ptr->runningOnKey==key)
+    if (ptr->runningOnKey==key) {
       ptr->abortFlag=true;
+      nbRemoved++;
+    }
 
     ptr=ptr->next;
   }
 
   mutexunlock(nf->lockF);
+  return nbRemoved;
 }
 void initTpool(char *params,tpool_t *pool, bool performanceMeas);
 

executables/main-fs6.c

@@ -615,7 +615,7 @@ void pusch_procedures_fromsplit(uint8_t *bufferZone, int bufSize, PHY_VARS_eNB *
                        &ulsch_harq->Kplus,
                        &ulsch_harq->Kminus,
                        &ulsch_harq->F);
-      int ret = ulsch_decoding_data(eNB, i, harq_pid,
+      int ret = ulsch_decoding_data(eNB, proc, i, harq_pid,
                                     ulsch_harq->nb_rb>20 ? 1 : 0);
       stop_meas(&eNB->ulsch_decoding_stats);
       LOG_D(PHY,

executables/main-ocp.c

@@ -692,13 +692,14 @@ static void *ru_thread( void *param ) {
   L1_rxtx_proc_t L1proc;
   L1_rxtx_proc_t *proc=&L1proc;
 
-  if ( strlen(get_softmodem_params()->threadPoolConfig) > 0 ) {
+  if ( strlen(get_softmodem_params()->threadPoolConfig) > 0 )
     initTpool(get_softmodem_params()->threadPoolConfig, &L1proc.threadPool, true);
-    initNotifiedFIFO(&L1proc.respEncode);
-    initNotifiedFIFO(&L1proc.respDecode);
-  }  else
+  else
     initTpool("n", &L1proc.threadPool, true);
 
+  initNotifiedFIFO(&L1proc.respEncode);
+  initNotifiedFIFO(&L1proc.respDecode);
+
   if (ru->if_south == LOCAL_RF) { // configure RF parameters only
     fill_rf_config(ru,ru->rf_config_file);
     init_frame_parms(&ru->frame_parms,1);

openair1/PHY/LTE_TRANSPORT/dlsch_coding.c

@@ -398,6 +398,7 @@ int dlsch_encoding(PHY_VARS_eNB *eNB,
       proc->nbEncode++;
     } else {
       TPencode(rdata);
+      delNotifiedFIFO_elt(req);
     }
     
     int Qm=hadlsch->Qm;

openair1/PHY/LTE_TRANSPORT/transport_eNB.h

@@ -288,6 +288,7 @@ typedef struct {
   uint8_t rvidx;
   /// soft bits for each received segment ("w"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
   int16_t w[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
+  int16_t pusch_rep_buffer[MAX_NUM_ULSCH_SEGMENTS][3*(6144+64)];
   /// soft bits for each received segment ("d"-sequence)(for definition see 36-212 V8.6 2009-03, p.15)
   //TBD
   int16_t *d[MAX_NUM_ULSCH_SEGMENTS];

openair1/PHY/LTE_TRANSPORT/transport_proto.h

@@ -469,6 +469,7 @@ void rx_ulsch(PHY_VARS_eNB *eNB,
 
 
 int ulsch_decoding_data_all(PHY_VARS_eNB *eNB,
+                        L1_rxtx_proc_t *proc,
                         int UE_id,
                         int harq_pid,
                         int llr8_flag);
@@ -513,6 +514,7 @@ int ulsch_decoding_data_2thread(PHY_VARS_eNB *eNB,
   @returns 0 on success
 */
 int ulsch_decoding_data(PHY_VARS_eNB *eNB,
+                        L1_rxtx_proc_t *proc,
                         int UE_id,
                         int harq_pid,
                         int llr8_flag);

openair1/PHY/defs_eNB.h

@@ -871,20 +871,19 @@ union turboReqUnion {
 };
 
 typedef struct TurboDecode_s {
-     decoder_if_t *function;
-    int16_t soft_bits[3*8*6144+12+96] __attribute__((aligned(32)));
-    uint8_t decoded_bytes[3+768] __attribute__((aligned(32)));
+    PHY_VARS_eNB *eNB;
+    decoder_if_t *function;
+    uint8_t decoded_bytes[3+1768] __attribute__((aligned(32)));
     int UEid;
     int harq_pid;
     int frame;
     int subframe;
-    int iind;
     int Fbits;
     int Kr;
     LTE_UL_eNB_HARQ_t *ulsch_harq;
-    PHY_VARS_eNB *eNB;
     int nbSegments;
     int segment_r;
+    int r_offset;
     int offset;
     int maxIterations;
     int decodeIterations;