Index: trunk/SophyaProg/Tests/pizthr.cc
===================================================================
--- trunk/SophyaProg/Tests/pizthr.cc	(revision 1611)
+++ trunk/SophyaProg/Tests/pizthr.cc	(revision 1611)
@@ -0,0 +1,409 @@
+#include "machdefs.h"
+#include "zthread.h"
+
+#include <math.h>
+#include <unistd.h>
+#include <iostream.h>
+#include <stdexcept>
+
+//  Include file pour PI 
+#include "pisysdep.h"
+
+#include PIAPP_H
+#include PIMENU_H 
+#include PISTDWDG_H 
+#include PIWIN_H
+#include PIPERIODIC_H
+#include "picons.h"
+
+//  Include file Sophya (TArray) 
+#include "tarrinit.h"
+#include "array.h"
+#include "timing.h"
+
+using namespace std;
+
+// ..........................................................
+// Programme interactive de test des threads ZThread
+// avec les arrays de Sophya et PI 
+//     R. Ansari  LAL-IN2P3/CNRS   02/2001
+// ..........................................................
+
+// ................... MtxComputer ...................
+// A thread class for doing matrix computation 
+class PIZTApp;
+class MtxComputer : public ZThread   // <JThreadC++> 
+{
+public:
+  MtxComputer(PIZTApp * app, PIScale * sc, int id, int sz, int nloop);
+  virtual ~MtxComputer();
+  virtual void run();
+protected:
+  int id_;
+  int sz_;
+  int nloop_;
+  PIZTApp * zapp_;
+  PIScale * sc_;
+};
+
+// ................... CPUTimer ...................
+// Periodic class for CPU and elapsed time counting 
+class CPUTimer : public PIPeriodic {
+public:
+  CPUTimer(PIZTApp * app);
+  virtual void DoPeriodic();
+protected:
+  PIZTApp * zapp; 
+  int dt;
+};
+
+// ................... PIZTApp ...................
+// La classe application   <JThreadC++> 
+// class PIZTApp : public PIApplication , public ZThread {
+class PIZTApp : public PIApplication  {   // Pas oblige d'en faire un Thread
+public:
+  PIZTApp(int narg, char* arg[]);
+  ~PIZTApp();
+  virtual void   Process(PIMessage msg, PIMsgHandler* sender, void* data=NULL);
+  virtual void   UpdateCPUTime();
+  virtual void   run();    //  <ZTread> 
+  // virtual void Run();    Si pas thread
+  ZMutex &   getMutex();  // <ZThread>  for synchronization 
+protected:
+  PIMenu * m[3];
+  PIScale *sc[2];
+  PILabel *tlab[2];
+  PILabel *cputlab;
+  PIConsole* cons;
+  // CPU and elapsed time
+  CPUTimer tm;
+  clock_t cput0;
+  time_t t0;
+  // The computing threads 
+  ZThread * thr[2];    //  <JThreadC++> 
+  // for synchronization with other threads
+  ZMutex amon;   //  <JThreadC++> 
+  int syn_cntrl;
+};
+
+
+// .........................................................
+// .............   PIZTApp  implementation .................
+// .........................................................
+
+PIZTApp::PIZTApp(int narg, char* arg[])
+  : PIApplication(600, 400, narg, arg) , tm(this)  // 200 ms timer
+{
+if (narg < 3) throw ParmError("PIZTApp::PIZTApp() narg<3 !");
+
+m[0] = new PIMenu(Menubar(),"Fichier");
+m[0]->AppendItem("Start", 10101);
+m[0]->AppendItem("Exit", 10110);
+AppendMenu(m[0]);
+m[1] = new PIMenu(Menubar(),"Thread-1");
+m[1]->AppendItem("Stop", 10203);
+AppendMenu(m[1]);
+m[2] = new PIMenu(Menubar(),"Thread-2");
+m[2]->AppendItem("Stop", 10303);
+AppendMenu(m[2]);
+
+cputlab = new PILabel(MainWin(), "CPUTime", 590, 30, 5, 5);
+cputlab->SetBorderWidth(1);
+
+tlab[0] = new PILabel(MainWin(), "Thr-1", 50, 30, 10, 40);
+sc[0] = new PIScale(MainWin(), "Sc-Thr-1", 510, kSDirLtoR, 220, 40, 70, 40);
+sc[0]->SetValue(0);
+tlab[1] = new PILabel(MainWin(), "Thr-2", 50, 30, 300, 40);
+sc[1] = new PIScale(MainWin(), "Sc-Thr-2", 520, kSDirLtoR, 220, 40, 360, 40);
+sc[1]->SetValue(0);
+
+// Creating the console and redirecting output
+cons = new PIConsole(MainWin(), "PIConsole", 700, 500, 80, 600, 315, 0, 85, true );
+cons->SetBinding(PIBK_fixed, PIBK_fixed, PIBK_fixed, PIBK_fixed);
+RedirectOutStream(cons);
+//RedirectErrStream(cons);
+
+// Creating matrix Computing thread 
+int nloop = atoi(arg[1]);
+int size = atoi(arg[2]);
+thr[0] = new MtxComputer(this, sc[0], 0, size, nloop);
+thr[1] = new MtxComputer(this, sc[1], 1, size, nloop);
+
+cput0 = clock();  t0 = time(NULL);
+tm.Start();  // We start our cpu timer
+syn_cntrl = 0;  // Normal event loop 
+}
+
+PIZTApp::~PIZTApp()
+{
+cout << " Getting in PIZTApp::~PIZTApp() - " << endl;
+int k;
+ cout << " PIZTApp::~PIZTApp() - deleting m[0..2] ... " << endl;
+for(k=0; k<3; k++) delete m;
+ cout << " PIZTApp::~PIZTApp() - deleting tlab/sc[0..1] ... " << endl;
+for(k=0; k<2; k++) { delete tlab[k];  delete sc[k]; }
+ cout << " PIZTApp::~PIZTApp() - deleting cputlab ... " << endl;
+delete cputlab;
+ cout << " PIZTApp::~PIZTApp() - deleting thr[0..1] ... " << endl;
+delete thr[0];
+delete thr[1];
+ cout << " PIZTApp::~PIZTApp() - deleting cons ... " << endl;
+delete cons;
+}
+
+void PIZTApp::UpdateCPUTime()
+{
+clock_t cput;
+time_t elt;
+time_t tm;  struct tm * stm;
+elt = time(&tm);  stm = localtime(&tm);
+cput = clock();
+float tcal = ( (float)(cput) - (float)(cput0) ) / (float)(CLOCKS_PER_SEC);
+float  etm = elt - t0;
+float percen = (elt > t0) ?  (tcal*100.)/etm : 0.;
+char buff[192];
+sprintf(buff, "%02d:%02d:%02d CPUTime= %g sec Elapsed= %g sec (%g %%)", 
+	stm->tm_hour, stm->tm_min, stm->tm_sec,
+	tcal, etm, percen);
+
+string s = buff;
+cputlab->SetLabel(s);
+}
+
+ZMutex &  PIZTApp::getMutex()
+{
+syn_cntrl++;
+return amon;
+}
+
+void PIZTApp::run()
+  // void PIZTApp::Run()  Si pas thread
+{
+
+XEvent evt;
+int szx, szy, szf;
+XtAppContext * appctx = PIXtAppCtx(szx, szy, szf);
+// Pour appeler FinishCreate() des objets dans la fenetre principale 
+if (mStop) { // C'est la premiere fois
+  topcont->SetSize(topcont->XSize(), topcont->YSize());
+  MBCont()->FinishCreate();   
+  }
+else mStop = true;   // On rerentre apres un stop 
+
+cout << "DBG-PIZTApp::run/Run Starting event loop " << endl;
+try {
+
+  while (mStop) {
+    //    while (syn_cntrl > 0) {
+    //      amon.wait();  //  <JThreadC++>  
+    //      syn_cntrl = 0;
+    //    }
+    amon.lock(); //  <ZThread> 
+    while (XtAppPending(*appctx) != 0) {
+      XtAppNextEvent(*appctx, &evt);
+      XtDispatchEvent(&evt);
+    }
+    amon.unlock(); // <ZThread>
+    usleep(1000);
+  }
+}
+catch (PThrowable  & e) {  
+  cerr << "PIZTApp::Run() Catched Exception  Msg= " << e.Msg() << endl;
+}
+catch (...) {
+  cerr << "PIZTApp::run() Catched ... exception " << endl;
+}
+
+
+}
+
+void PIZTApp::Process(PIMessage msg, PIMsgHandler* sender, void* data)
+{
+  int num;
+try {
+  switch(UserMsg(msg)) {
+  case 10101 : // starting computing threads 
+    thr[0]->start();  //  <ZThread> 
+    thr[1]->start();  //  <ZThread> 
+    break;
+  case 10110 : // stoping computing threads 
+    RedirectOutStream(NULL);
+    RedirectErrStream(NULL);
+    cout << " PIZTApp::Process() Waiting for threads to terminate ... " << endl;
+    thr[0]->join();  //  <ZThread> 
+    thr[1]->join();  //  <ZThread> 
+    Stop();
+    break;
+  case 10203 :
+  case 10303 :
+    num = (UserMsg(msg)-10203)/100;
+    thr[num]->stop();  //  <ZThread> 
+    break;
+  }
+}
+catch (ZThreadExc  & e) {  // <ZThread>
+  cerr << "PIZTApp::Process() Catched ZThreadExc  Msg= " << e.Msg() << endl;
+}
+catch (...) {
+  cerr << "PIZTApp::Process() Catched ... exception " << endl;
+}
+
+}
+
+// .........................................................
+// .............   CPUTimer implementation .................
+// .........................................................
+
+CPUTimer::CPUTimer(PIZTApp * app)
+: PIPeriodic(1)
+{
+zapp = app;
+dt = -1;
+SetIntervalms(200);  // 200 ms interval timer
+}
+
+void
+CPUTimer::DoPeriodic()
+{
+dt++;
+if ((dt == 0) || (dt >= 5)) { zapp->UpdateCPUTime();  dt = 0; }
+}
+
+
+// .........................................................
+// .............  MtxComputer implementation ...............
+// .........................................................
+
+// A global monitor for print synchronisation 
+ZMutex prtmon;  // <ZThread> 
+
+MtxComputer::MtxComputer(PIZTApp * app, PIScale * sc, int id, int sz, int nloop)
+{
+  id_ = id;  sz_ = sz;  nloop_ = nloop;  zapp_ = app;  sc_ = sc; 
+}
+
+MtxComputer::~MtxComputer()
+{
+}
+
+void MtxComputer::run()
+{
+  int n = sz_;
+  double seuil = 1.e-6;
+  Matrix id;
+  id = IdentityMatrix(1.,n);
+  double gmax = -1.e99;
+  double gmin = 1.e99;
+  int npb = 0;
+  // Loop creating a random matrix, inverting it
+  // and checking the result 
+  for(int k=0; k<nloop_; k++) {
+    try {
+      Matrix a(n,n);
+      a = RandomSequence(RandomSequence::Gaussian, 0., 2.5);
+      Matrix inva = Inverse(a);
+      Matrix diff = id-a*inva;
+      double max = -1.e99;
+      double min = 1.e99;
+      double x;
+      int nerr = 0;
+      for(int i=0; i<n; i++) 
+	for(int j=0; j<n; j++) {
+	  x = diff(i,j);
+	  if (x < min)  min = diff(i,j); 
+	  if (x > max)  max = diff(i,j); 
+	  if (fabs(x) > seuil)  nerr++;
+	}
+      if (min < gmin) gmin = min;
+      if (max > gmax) gmax = max;
+      if (nerr > 0) npb++;
+      {  // Synchronized writing to cout stream  
+	ZSync sync(prtmon);  // <ZThread> 
+	cout << " ------- Thread[" << id_ << "] K= " 
+	     << k << "  NErr = " << nerr << endl;
+	cout << "  Min(Diff) = " << min << " Max(Diff) = " << max << endl;
+	if (k == nloop_-1) {
+	  double frac = (double)npb*100./(double)nloop_;
+	  cout << " ...... Thread[" << id_ << "] End NPb= " << npb 
+	       << " / NTot= " << nloop_ << " ( = " << frac << " %) " << endl;
+	  cout << "  GMin(Diff) = " << gmin << " GMax(Diff) = " << gmax << endl;
+	  cout << " ..................................................... " << endl;
+	}
+      }
+      {  // Synchronized updating of Scale Widget 
+	ZSync sync(zapp_->getMutex());  // <ZThread> 
+	// The event loop should be stopped until the end of the block
+	int percentage = 100*(k+1)/nloop_;
+	sc_->SetValue(percentage);
+      }
+ 
+    }
+    catch (ZThreadExc const & e) {  // <ZThread>
+      cerr << "MtxComputer Catched ZThreadExc in  Thread(" // << (string)getName() 
+	     << ") Msg= " << e.Msg() << endl;
+    }
+    catch (PException const & e) {
+      cerr << "MtxComputer Catched PException in  Thread(" // << (string)getName() 
+	     << ") Msg= " << e.Msg() << endl;
+    }
+  }
+}
+
+
+static void run_piapp(void * x)
+{
+    PIZTApp * t = (PIZTApp *)x;
+    t->run();
+    return;
+}
+
+// .........................................................
+// ................... The main program ....................
+// .........................................................
+
+int main(int narg, char* arg[])
+{
+
+  if (narg < 3) {
+    cout << " pizthr - ZThread/PI/Sophya::TArray<T> Test \n " 
+	 << " ... Usage pizthr NLoop MtxSize [-JTCss ... \n" 
+	 << "     NLoop=10...10^4  MtxSize=10...10^3 \n"
+	 << endl;
+    exit(0);
+  }
+
+  InitTim();   // Initializing the CPU timer
+
+  int nloop = atoi(arg[1]);
+  int size = atoi(arg[2]);
+  cout << " ::::: pizthr - ZThread/PI/Sophya::TArray<T> Test ::::: \n"
+       << " NLoop= " << nloop << " MtxSize= " << size << endl;   
+
+  try {
+    SophyaInit();  // Sophya Initialization
+    PIZTApp * t = new PIZTApp(narg, arg);  // <ZThread>  
+    //    t->Run();
+    ZThread * zt = new ZThread(50000);
+    zt->setAction(run_piapp, t);
+    zt->start();   // <ZThread>  -   starting event loop 
+    cout << " Waiting for PIZTApp thread to end ... " << endl;
+    zt->join();    // <ZThread>  Waiting for thread to end
+    //  PIZTApp * t = new  PIZTApp(narg, arg); Si pas thread
+    //  t->Run();      Si pas thread
+    cout << " PIZTApp thread ended - deleting PIZTApplication ... " << endl;
+    delete zt;
+    delete t;
+  }
+  catch (PThrowable const & e) {
+    cerr << " Catched PThrowable in main Msg= " << e.Msg() << endl;
+  }
+  catch(...) {
+    cerr << " Catched ... exception in main " << endl;
+  }
+
+  PrtTim("End of pizthr");
+}
+
+
+
+
Index: trunk/SophyaProg/Tests/zthr.cc
===================================================================
--- trunk/SophyaProg/Tests/zthr.cc	(revision 1611)
+++ trunk/SophyaProg/Tests/zthr.cc	(revision 1611)
@@ -0,0 +1,108 @@
+#include "zthread.h"
+
+#include <iostream.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+
+#include <time.h>
+#include <unistd.h>
+
+#include "timing.h"
+
+
+void fun2(void * arg)
+{
+time_t t0, t1;
+int i;
+char *strg;
+strg = (char *)arg;
+
+t0 = time(NULL);
+printf("**** Entry to fun2 (arg= %s) ***** \n", strg);
+int imax = atoi(strg);
+for(i=0; i<imax; i++)
+  {
+  sleep(4);
+  t1 = time(NULL)-t0;
+  printf("######## Fun2 [%d]  Dt= %d \n", i, (int)t1);
+  }
+
+return;
+}
+
+void fun1(void *arg)
+{
+time_t t0, t1;
+int i;
+
+char * strg = (char *)arg;
+
+t0 = time(NULL);
+printf("++++ Entry to fun1 (arg= %s) +++++ \n", strg);
+int imax = atoi(strg);
+for(i=0; i<imax; i++)
+  {
+  sleep(3);
+  t1 = time(NULL)-t0;
+  printf("%%%% Fun1 [%d]  Dt= %d \n", i, (int)t1);
+  }
+
+return;
+}
+
+class CountLock : public ZMutex {
+  int count;
+public:
+  CountLock() { count = 0; }
+  inline int Count() { lock(); int rc = ++count; unlock(); return(rc); 
+  }
+};
+
+
+int main(int narg, char *arg[])
+
+{
+
+  if (narg < 4) {
+    cout << " Usage: zthr N1 N2 NLock" << endl;
+    exit(1);
+  }
+
+  cout << " zthr-main() arg[1] = " << arg[1] << " arg[2]= " << arg[2] << endl;
+  InitTim();
+
+  CountLock clk;
+  for(int kk=0; kk<atoi(arg[3]); kk++) {
+    clk.Count();
+  }
+  cout << " End Count= " << clk.Count() << endl;
+  PrtTim("EndOfCount1 ");
+
+  cout << ">>> Creating Thread Z1 and Z2 " << endl;
+  ZThread zt1;
+  zt1.setAction(fun1, arg[1]);
+  ZThread zt2;
+  zt2.setAction(fun2, arg[2]);
+  cout << ">>> Starting Thread Z1 and Z2 " << endl;
+  zt1.start();
+  zt2.start();
+
+  PrtTim("BeginOfCount2 ");
+  for(int kk=0; kk<atoi(arg[3]); kk++) {
+    clk.Count();
+  }
+  cout << " End Count= " << clk.Count() << endl;
+  PrtTim("EndOfCount2 ");
+
+  //  sleep(5);
+  cout << ">>> Joining Thread Z1 and Z2 " << endl;
+
+  zt1.join();
+  zt2.join();
+  cout << ">>> Thread Z1 and Z2 Finished " << endl;
+ 
+  return(0);
+  
+}
