Changeset 3177 in Sophya for trunk/SophyaProg/Tests/zthr.cc

Timestamp:

Feb 6, 2007, 9:19:44 AM (19 years ago)

Author:

ansari

Message:

Ajout de test avec synchronisation entre threads dans zthr.cc , Reza 06/02/2007

File:

• trunk/SophyaProg/Tests/zthr.cc (modified) (10 diffs)

trunk/SophyaProg/Tests/zthr.cc

@@ -7 +7 @@
 
 #include "tmatrix.h"
+#include "tvector.h"
 #include "tarrinit.h"
 
@@ -18 +19 @@
   csh> time zthr mtx 2 500
   csh> time zthr arr 2 500
+  csh> time zthr sync 4 1000
 */
  
@@ -24 +26 @@
 
 #include "timing.h"
+#include "ctimer.h"
 
 
 // --- Structure d'argument pour fonction d'execution dans les threads de test
 typedef struct  {
-  int thid;
-  int M;
+  int_4 thid;
+  int_4 M;
 } ztarg;
 
@@ -91 +94 @@
 
 
+// Structure de gestion utilisee par la classe MTVecPool
+typedef struct {
+  bool busy;
+  int stat;
+} St_VecPool;
+
+// -------------------------------------------------------------------
+// Structure de gestion de zones memoire partagee (des vecteurs) entre
+// threads - qui doivent operer successivement sur les vecteurs
+// -------------------------------------------------------------------
+class MTVecPool {
+public:
+  MTVecPool(uint_4 nth, uint_4 vsz, uint_4 nvec)
+  {
+    if (nth > 60) throw ParmError("MTVecPool::MTVecPool() nth > 60");
+    if ((nth < 1) || (vsz < 2))
+        throw ParmError("MTVecPool::MTVecPool() nth<1 OR vsz<2 ");
+    _vmx.SetSize(vsz, nvec);
+    _nth = nth;
+    _vsz = vsz; 
+    cout << "-- MTVecPool(nth=" << nth << ")" << endl;
+    _vmx.Show();
+  }
+  ~MTVecPool()   { }
+  // Renvoie un pointeur de vecteur pour thread tid
+  TVector<int_8>  GetVec(uint_4 tid, uint_4& idx)
+  {
+    if (tid >= _nth) ParmError("MTVecPool::getvec() tid > _nth");
+    //DBG  cout << "DBG-GetVec(tid= " << tid << ")" << endl;
+    if (tid == 0) {
+      mex.lock();
+      St_VecPool stv;
+      idx = _vecs.size();
+      stv.busy = true;
+      stv.stat = 0;
+      _vecs.push_back(stv);
+      mex.unlock();
+      //DBG cout << "DBG-GetVec(tid= " << tid << ") -> Idx=" << idx << " VecSz=" << _vmx.Column(idx).Size() << endl;
+      return (_vmx.Column(idx));
+    }
+    else {
+      mex.lock();
+      bool found = false;
+      while (!found) {
+        for(uint_4 k=0; k<_vecs.size(); k++) {
+          if ( (_vecs[k].stat == tid) && (! _vecs[k].busy) ) {
+            found = true;  idx = k;
+            _vecs[k].stat = tid; _vecs[k].busy = true; 
+            break;
+          }
+        }
+        if (found) {
+          mex.unlock();
+          //DBG  cout << "DBG-GetVec(tid= " << tid << ") -> nv=" << hex << rv << dec << endl;
+          return (_vmx.Column(idx));
+        }
+        else { 
+          mex.broadcast();
+          mex.wait();
+        }
+      }
+    }
+  }
+
+  // Retourne le pointeur de vecteur au gestionnaire, qui le marque comme disponible
+  void RetVec(uint_4 idx)
+  {
+    //DBG cout << "DBG-RetVec(idx= " << idx << ")" << endl;
+    ZSync zs(mex, 2);
+    _vecs[idx].busy = false; _vecs[idx].stat++; 
+    zs.NOp();
+  }
+
+  // Verifie l'etat memoire de tous les vecteurs et fait des print
+  int Check()
+  {
+    cout << "MTVecPool::Check() NVec=" << _vecs.size() << " VSz=" 
+         << _vsz << " NThreads=" << _nth << endl;
+    int nerr = 0;
+    int_8 sum = 0;
+    int_8 p2 = 1;
+    int_8 min,max;
+    for(int i=0; i<_nth; i++) { sum += p2; p2 *= 2; }
+    for(uint_4 k=0; k<_vecs.size(); k++) {
+      if ( (_vecs[k].busy) || (_vecs[k].stat != _nth) ) {
+        cout << " Check()/Pb Busy Or Stat  for k=" << k << endl;
+        nerr++;
+      }
+      _vmx.Column(k) -= sum;
+      _vmx.Column(k).MinMax(min, max);
+      if ((min!=0) || (max!=0)) {
+        cout << " Check()/Pb vec[k=" << k << "] != (sum=" << sum << ")" << endl;
+        nerr++;
+      }
+    }
+    if (nerr == 0) cout << "MTVecPool::Check()  - OK (NErr=0)" << endl;
+    else cout << "MTVecPool::Check() PB NErr=" << nerr << endl;
+    return nerr;
+  }
+
+  // ... variables membres
+  ZMutex mex;
+  uint_4 _vsz;
+  uint_4 _nth;
+  TMatrix<int_8> _vmx;
+  vector< St_VecPool> _vecs;
+};
+
+
+static MTVecPool* mtvp = NULL;
+
+// --- fonction de test avec synchronisation entre threads
+void sync_funzt(void *arg)
+{
+  ztarg * za = (ztarg *)arg;
+  cout << ">>>> sync_funzt(ThId=" << za->thid << ") - NVec/NLoop= " << za->M << endl;
+  
+  if (mtvp == NULL) 
+    throw NullPtrError("sync_funzt: MTVecPool* mtvp = NULL");
+
+  int_4 L = za->M;
+  int_8 p2 = 1;
+  uint_4 k, tid;
+  tid = za->thid;
+  for(k=0; k<tid; k++) p2 *= 2;
+
+  char buff[128];
+  sprintf(buff, "sync_funzt(ThId=%d) StarOfLoop", za->thid); 
+  PrtTim(buff);
+  uint_4 idx;
+  for(k=0; k<L; k++) {
+    mtvp->GetVec(tid, idx) += p2;
+    //DBG cout << "DBG-sync_funzt(tid=" << tid << ", idx=" << idx << endl;
+    mtvp->RetVec(idx);
+  }
+  sprintf(buff, "sync_funzt(ThId=%d) EndOfLoop", za->thid); 
+  PrtTim(buff);
+  return;
+}
 
 class CountLock : public ZMutex {
@@ -103 +245 @@
 static int N = 1;
 static int M = 5;
+static int VSZ = 128;
 
 int main(int narg, char *arg[])
@@ -109 +252 @@
 
   if (narg < 4) {
-    cout << " Usage: zthr select N LM" << endl;
+    cout << " Usage: zthr select N LM [Sz] " << endl;
     cout << "  select= sl -> simple loop with sleep " << endl;
     cout << "  select= mtx -> matrix init and multiply mx1*mx2" << endl;
     cout << "  select= arr -> array/matrix init and operation c1*a1+c2*a2 " << endl;
     cout << "  select= clk -> Mutex lock count  " << endl;
+    cout << "  select= sync -> Thread synchronisation using ZMutex" << endl;
     cout << "  N= Number of threads (sl/mtx) or CountLock " << endl;
-    cout << "  LM = Loop limit (sl) or Matrix size (mtx) " << endl;
+    cout << "  LM = Loop limit (sl/sync) or Matrix size (mtx) " << endl;
+    cout << "  Sz = Vector size for select=sync (default=256) " << endl;
     return(1);
   }
 
   string sel = arg[1];
-  if ((sel != "sl") && (sel != "mtx") && (sel != "arr") && (sel != "clk")) {
+  if ((sel != "sl") && (sel != "mtx") && (sel != "arr") && 
+      (sel != "sync") && (sel != "clk")) {
     cout << "zthr/erreur argument sel (!= sl / mtx / arr / clk) " << endl;
     return 2;
@@ -128 +274 @@
   N = atoi(arg[2]);
   M = atoi(arg[3]);
-  cout << "zthr/Info: select=" << sel << " N=" << N << " M= " << M << endl;
+  if (narg > 4) VSZ = atoi(arg[4]);
+  cout << "zthr/Info: select=" << sel << " N=" << N << " M= " << M 
+       << " VSz=" << VSZ << endl;
  
   
@@ -136 +284 @@
   int rc = 0;
   try {
-    ResourceUsage res;
-    if ((sel == "mtx") || (sel == "arr") || (sel == "sl")) {
+    ResourceUsage res(ResourceUsage::RU_All);
+    if ((sel == "mtx") || (sel == "arr") || (sel == "sl") || (sel == "sync") ) {
+      if (sel == "sync") mtvp = new MTVecPool(N,VSZ,M);
       vector<ztarg *> vza;
       vector<ZThread *> vzth;
@@ -145 +294 @@
         ztarg* zap = new ztarg;
         vzth.push_back(pzt);
-        zap->thid = i+1;  zap->M = M;
+        // ATTENTION : il faut que le thid = 0 ... N-1 (et pas 1)
+        zap->thid = i;  zap->M = M;
         vza.push_back(zap);
         if (sel == "mtx")  pzt->setAction(mtx_funzt, vza[i]);
         else if (sel == "arr")  pzt->setAction(arr_funzt, vza[i]);
+        else if (sel == "sync")  pzt->setAction(sync_funzt, vza[i]);
         else pzt->setAction(funzt, vza[i]);
       }
@@ -161 +312 @@
       cout << "***zthr Threads Z1 ... Z" << N << " Finished OK" << endl;
       cout << res;
+      cout << " Resu: getDataSize() = " << res.getDataSize() << "  getStackSize()=" 
+           << res.getStackSize() << endl;
       for(int i=0; i<N; i++) {
         delete vzth[i];
         delete vza[i];
+      }
+      if (mtvp) {
+        Timer tm("MTVecPool::Check()");
+        mtvp->Check();
+        tm.Nop();
+        delete mtvp;
       }
     }