Changeset 3626 in Sophya for trunk

Timestamp:

May 22, 2009, 6:18:06 PM (16 years ago)

Author:

ansari

Message:

Introduction numero d'ordre de remplissage, mask de recyclage,
et sequence de traitement procA/B/C dans le gestionnaire de
memoire - Reza 22/05/2009

Location:

trunk/AddOn/TAcq

Files:

• brpaqu.cc (modified) (1 diff)
• pciewrap.cc (modified) (1 diff)
• racqumem.cc (modified) (9 diffs)
• racqumem.h (modified) (4 diffs)

trunk/AddOn/TAcq/brpaqu.cc

@@ -483 +483 @@
     lostframes += (unsigned long long)delfc - 1;
     if (delfc != 1) { 
-    cnt_pb++; 
-    if (cnt_pb < 5) paq.Print();
+      cnt_pb++; 
+      if (cnt_pb < 5) { 
+        cout << "BRPaqChecker::Check([NumFrameOK=" << nframeok 
+             << ")/Debug  FrameCounter Cur=" << curfc 
+             << " Last=" << frclst << " -> delta=" << delfc << endl;  
+        paq.Print();
+      }
     }
   }

trunk/AddOn/TAcq/pciewrap.cc

@@ -48 +48 @@
     bp[kk] = (Byte)(sin(0.0345*kk)*78.+127.5);
 */
-  for(UInt32 kk=0; kk<paq.DataSize(); kk++)
+  UInt32 kkmax = paq.DataSize();
+  for(UInt32 kk=0; kk<kkmax; kk++)
     bp[kk] = (Byte)(kk%200+20);
   tottransfer_ += size_;

trunk/AddOn/TAcq/racqumem.cc

@@ -6 +6 @@
 //----------------------------------------------------------------
 
-
+/* --Methode-- */
 RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nz, uint_4 np, uint_4 psz)
   : mex(true), nzones(nz), npaq(np), paqsz(psz), stop_(false)
@@ -12 +12 @@
   St_MemZ st;
 
+  st.serial = 0;
   st.act = (uint_4)MemZA_None;
-  st.stat = (uint_8)MemZS_Free;
-  for(int k=0; k<3; k++) st.nbact[k] = 0;
+  st.stat = (uint_4)MemZS_Free;
+  for(int k=0; k<6; k++) st.nbact[k] = 0;
   uint_8 mzsz = npaq*paqsz;
 
@@ -21 +22 @@
      states.push_back(st);
    }
-  
+  serial_ = 0;
+  SetFinalizedMask();
 }
 
+/* --Methode-- */
 RAcqMemZoneMgr::~RAcqMemZoneMgr()
 {
@@ -29 +32 @@
 }
 
+/* --Methode-- */
 int RAcqMemZoneMgr::FindMemZoneId(MemZaction act)
+// Recherche et renvoie une zone memoire compatible pour effectuer l'operation act
+// Pour act = MemZA_Fill : Zone vide ou satisfaisant la condition mask_finalized_
+// On recherche a chaque fois la zone ayant le plus petit numero de serie 
+// cad le numero d'ordre de remplissage
+// Pour ProcA/B/C on attend que la zone avec le plus petit numero soit disponible
+
 {
   int rid = -1;
@@ -35 +45 @@
   if ((act != MemZA_Fill) && (act != MemZA_Save) && (act != MemZA_Proc)) return rid;
   mex.lock();
+  uint_8 bestserial = serial_ + 5;
   while ((rid < 0)&&(!stop_)) {
-    switch (act)
-      {
+    switch (act)  {
       case MemZA_Fill:
         if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
           if ((states[k].act == MemZA_None) && 
-              ((states[k].stat == MemZS_Free)||(states[k].stat & MemZS_Saved)) ) 
-            { rid = k; break; } 
+              ((states[k].stat == MemZS_Free)||(states[k].stat & mask_finalized_)) ) {
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
         }
         if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
@@ -48 +59 @@
       case MemZA_Save:
         for(uint_4 k=0; k<NbZones(); k++) {
-          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
-              !(states[k].stat & MemZS_Saved) ) { rid = k; break; } 
+          if ((states[k].act == MemZA_None) && 
+              (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Saved) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          } 
         }
         if (rid >= 0) states[rid].act = MemZA_Save; 
@@ -55 +68 @@
       case MemZA_Proc:
         for(uint_4 k=0; k<NbZones(); k++) {
+          if ((states[k].act == MemZA_None) && 
+              (states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Proc) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+        }
+        if (rid >= 0) states[rid].act = MemZA_Proc;  
+        break;            
+      case MemZA_ProcA:
+        for(uint_4 k=0; k<NbZones(); k++) {
           if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
-              !(states[k].stat & MemZS_Proc) ) { rid = k; break; } 
+              !(states[k].stat & MemZS_ProcA) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
         }
-        if (rid >= 0) states[rid].act = MemZA_Proc;               
+        if (rid >= 0) states[rid].act = MemZA_ProcA;              
+        break;
+      case MemZA_ProcB:
+        for(uint_4 k=0; k<NbZones(); k++) {
+          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
+              (states[k].stat & MemZS_ProcA) && !(states[k].stat & MemZS_ProcB) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+        }
+        if (rid >= 0) states[rid].act = MemZA_ProcB;              
+        break;
+      case MemZA_ProcC:
+        for(uint_4 k=0; k<NbZones(); k++) {
+          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
+              (states[k].stat & MemZS_ProcB) && !(states[k].stat & MemZS_ProcC) ) { 
+            if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; } 
+          }
+        }
+        if (rid >= 0) states[rid].act = MemZA_ProcC;              
         break;
       case MemZA_None:   // MTQ pour supprimer un warning
         break;
-      }
+      }  // Fin de switch 
     if (rid < 0)  mex.wait();
-  }
+  }  // Fin de while 
   mex.unlock();
   return rid;
 }
 
+/* --Methode-- */
 int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
 {
@@ -75 +118 @@
   mex.lock();
   switch (st) {
-        case MemZS_Free :
-          states[id].stat = MemZS_Free; 
-          states[id].act = MemZA_None;
-        break;
-        case MemZS_Filled :
-          if (states[id].act != MemZA_Fill)  rc = 2;
-          else states[id].nbact[0]++;
-          states[id].stat |= MemZS_Filled; 
-          states[id].act = MemZA_None;
-        break;
-        case MemZS_Saved :
-          if (states[id].act != MemZA_Save)  rc = 4;
-          else states[id].nbact[1]++;     
-          states[id].stat |= MemZS_Saved; 
-          states[id].act = MemZA_None;
-        break;
-        case MemZS_Proc :
-          if (states[id].act != MemZA_Proc)  rc = 8;
-          else states[id].nbact[2]++;     
-          states[id].stat |= MemZS_Proc; 
-          states[id].act = MemZA_None;
-        break;
-        default :
-          rc = 16;
-          states[id].stat = MemZS_Free; 
-          states[id].act = MemZA_None;
-        break;
-  }
+    case MemZS_Free :
+      states[id].serial = 0;
+      states[id].stat = MemZS_Free; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Filled :
+      if (states[id].act != MemZA_Fill)  rc = 2;
+      else states[id].nbact[0]++;
+      serial_ ++;
+      states[id].serial = serial_;
+      states[id].stat |= MemZS_Filled; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Saved :
+      if (states[id].act != MemZA_Save)  rc = 4;
+      else states[id].nbact[1]++;         
+      states[id].stat |= MemZS_Saved; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_Proc :
+      if (states[id].act != MemZA_Proc)  rc = 8;
+      else states[id].nbact[2]++;         
+      states[id].stat |= MemZS_Proc; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcA :
+      if (states[id].act != MemZA_ProcA)  rc = 16;
+      else states[id].nbact[3]++;         
+      states[id].stat |= MemZS_ProcA; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcB :
+      if (states[id].act != MemZA_ProcB)  rc = 32;
+      else states[id].nbact[4]++;         
+      states[id].stat |= MemZS_ProcB; 
+      states[id].act = MemZA_None;
+      break;
+    case MemZS_ProcC :
+      if (states[id].act != MemZA_ProcC)  rc = 64;
+      else states[id].nbact[4]++;         
+      states[id].stat |= MemZS_ProcC; 
+      states[id].act = MemZA_None;
+      break;
+    default :
+      rc = 128;
+      states[id].serial = 0;
+      states[id].stat = MemZS_Free; 
+      states[id].act = MemZA_None;
+      break;
+  }  // Fin de switch 
   mex.unlock();
   mex.broadcast();
@@ -121 +186 @@
   for(uint_4 k=0; k<states.size(); k++) 
     os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat 
-       << " NbAct[0..2]=" << states[k].nbact[0] << "," << states[k].nbact[1]
-       << "," << states[k].nbact[2] << endl;    
+       << " NbAct[0..5]=" << states[k].nbact[0] << "," << states[k].nbact[1]
+       << "," << states[k].nbact[2] << "," << states[k].nbact[3] 
+       << "," << states[k].nbact[4] << "," << states[k].nbact[5] << endl;       
   return os;   
 }

trunk/AddOn/TAcq/racqumem.h

@@ -5 +5 @@
 // ---- classes de gestion memoire pour acquisition BAORadio -----
 // LAL -      R. Ansari - Juin/Juillet 2008 
+//       Modifs Mai 2009 
+//       - Introduction du numero d'ordre de remplissage 
+//       - Introduction de mask de recyclage et sequence de traitement procA/B/C
 //----------------------------------------------------------------
 
@@ -21 +24 @@
 // Structure de gestion utilisee par la classe RAcqMemMgr
 typedef struct {
-  uint_4 act;
-  uint_4 stat;
-  uint_4 nbact[3]; 
-//  int tid;
+  uint_8 serial;    // Numero de serie permettant d'ordonner en temps les zones memoire rempli
+  uint_4 act;       // Indique l'action en cours sur une zone Fill,Save ...
+  uint_4 stat;      // Champ de flag (bits) indiquant les operations effectuees sur la zone
+  uint_4 nbact[6];  // compteurs nb de fois ou (fill,save,proc,procA/B/C) a ete effectuee sur la zone 
+//  int tid;        Pas utilise pour le moment, permet l'identification du thread operant sur la zone
 } St_MemZ;
 
-enum MemZStatus { MemZS_Free=0, MemZS_Filled=1, MemZS_Saved=2, MemZS_Proc=4 };
-enum MemZaction { MemZA_None=0, MemZA_Fill=1, MemZA_Save=2, MemZA_Proc=4};
+// Les flags (bits) correspondant aux operations effectuees sur une zone
+// Free->libre, Filled->rempli(par DMA), Saved(ecrit sur disque), Proc(Traitement)
+// ProcA/B/C : Trois traitement qui doivent s'enchainer 
+enum MemZStatus { MemZS_Free=0, MemZS_Filled=1, MemZS_Saved=2, MemZS_Proc=4, 
+                  MemZS_ProcA=8, MemZS_ProcB=16, MemZS_ProcC=32 };
+// L'action en cours sur une zone 
+enum MemZaction { MemZA_None=0, MemZA_Fill=1, MemZA_Save=2, MemZA_Proc=4, 
+                  MemZA_ProcA=8, MemZA_ProcB=16, MemZA_ProcC=32 };
 
 // -------------------------------------------------------------------
-// Structure de gestion de zones memoire partagee (des vecteurs) entre
+// Classe de gestion de zones memoire partagee (des buffers) entre
 // threads - qui doivent operer successivement sur les vecteurs
 // -------------------------------------------------------------------
 class RAcqMemZoneMgr {
 public:
-// Constructeur, classe dma, nz=Nb de zones, np=Nb de paquets/zone , psz=taille de paquet
-  RAcqMemZoneMgr(uint_4 nz, uint_4 np=1000, uint_4 psz=4096);
+// Constructeur, nz=Nb de zones, np=Nb de paquets/zone , psz=taille de paquet
+  RAcqMemZoneMgr(uint_4 nz, uint_4 np=256, uint_4 psz=4096);
   ~RAcqMemZoneMgr();
   
@@ -49 +59 @@
   inline uint_4 ZoneSize() { return npaq*paqsz; }
   
+  // Definit l'etat des operations obligatoires avant qu'une zone 
+  // remplie ne puisse etre recyclee (re-remplie)
+  inline uint_4 SetFinalizedMask(uint_4 mask=((uint_4)MemZS_Saved))
+    { mask_finalized_ = mask; }
+  inline uint_4 GetFinalizedMask() { return mask_finalized_; }
 
   // Retourne un MemZone disponible pour une action specifique
@@ -71 +86 @@
   vector< St_MemZ > states; 
   bool stop_;
+  uint_4 mask_finalized_;
+  uint_8 serial_;  
 };