PR: debug delete trace classes

diff --git a/src/SALOMELocalTrace/BaseTraceCollector.cxx b/src/SALOMELocalTrace/BaseTraceCollector.cxx
index 8c385bff82371c1451b6d1fa15edbf2c58160709..942f07307088dae61766d5319199721fc5f57606 100644 (file)
--- a/src/SALOMELocalTrace/BaseTraceCollector.cxx
+++ b/src/SALOMELocalTrace/BaseTraceCollector.cxx
@@ -43,35 +43,25 @@ pthread_t* BaseTraceCollector::_threadId = 0; // used to control single run
 
 // ============================================================================
 /*!
- *  Destructor: wait until printing thread ends (BaseTraceCollector::run)
+ *  Destructor: virtual, implemented in derived classes.
+ *  Wait until printing thread ends (BaseTraceCollector::run)
  */
 // ============================================================================
 
 BaseTraceCollector:: ~BaseTraceCollector()
 {
-  LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
-  _threadToClose = 1;
-  cerr << "BaseTraceCollector:: ~BaseTraceCollector()" << endl << flush;
-  myTraceBuffer->insert(NORMAL_MESS,"end of trace"); //needed to wake up thread
-  if (_threadId)
-    {
-      int ret = pthread_join(*_threadId, NULL);
-      if (ret) cerr << "error close BaseTraceCollector : "<< ret << endl;
-      else cerr << "BaseTraceCollector destruction OK" << endl;
-      _threadId = 0;
-    }
 }
 
 // ============================================================================
 /*!
  * Constructor: no need of LocalTraceBufferPool object initialization here,
  * thread safe singleton used in LocalTraceBufferPool::instance()
+ * See derived classes.
  */
 // ============================================================================
 
 BaseTraceCollector::BaseTraceCollector()
 {
-  _threadId=0;
 }
 
 

diff --git a/src/SALOMELocalTrace/BaseTraceCollector.hxx b/src/SALOMELocalTrace/BaseTraceCollector.hxx
index 8f97e28c3d840b158f073aa06717816452dbc82b..c05b2fe2b611e296e100c2ae2169b5d8b0c880d0 100644 (file)
--- a/src/SALOMELocalTrace/BaseTraceCollector.hxx
+++ b/src/SALOMELocalTrace/BaseTraceCollector.hxx
@@ -50,7 +50,7 @@
 class SALOMELOCALTRACE_EXPORT BaseTraceCollector
 {
  public:
-  ~BaseTraceCollector();
+  virtual ~BaseTraceCollector();
 
  protected:
   BaseTraceCollector();

diff --git a/src/SALOMELocalTrace/FileTraceCollector.cxx b/src/SALOMELocalTrace/FileTraceCollector.cxx
index 8eb28861b20548b5715c8a73f4e348a9183edd46..12697b53236138178de9a1a1900bff2cb4da3326 100644 (file)
--- a/src/SALOMELocalTrace/FileTraceCollector.cxx
+++ b/src/SALOMELocalTrace/FileTraceCollector.cxx
@@ -39,16 +39,12 @@ std::string FileTraceCollector::_fileName = "";
 
 // ============================================================================
 /*!
- *  This class is for use without CORBA, outside SALOME.
+ *  This class is for use without CORBA, inside or outside SALOME.
  *  SALOME uses SALOMETraceCollector, to allow trace collection via CORBA.
+ *  Type of trace (and corresponding class) is choosen in LocalTraceBufferPool.
  *
- *  guarantees a unique object instance of the class (singleton thread safe)
+ *  Guarantees a unique object instance of the class (singleton thread safe)
  *  a separate thread for loop to print traces is launched.
- *  \param typeTrace 0=standard out, 1=file(/tmp/tracetest.log)
- *  If typeTrace=0, checks environment for "SALOME_trace". Test values in
- *  the following order:
- *  - "local"  standard out
- *  - anything else is kept as a file name
  */
 // ============================================================================
 
@@ -60,15 +56,17 @@ BaseTraceCollector* FileTraceCollector::instance(const char *fileName)
       ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
       if (_singleton == 0)                     // another thread may have got
        {                                      // the lock after the first test
+         //cerr << "FileTraceCollector:: instance()" << endl << flush;
          _singleton = new FileTraceCollector();
 
          _fileName = fileName;
-         cout << " _fileName: " << _fileName << endl;
+         //cerr << " _fileName: " << _fileName << endl;
 
          pthread_t traceThread;
          int bid;
          int re2 = pthread_create(&traceThread, NULL,
                                   FileTraceCollector::run, (void *)bid);
+         //cerr << "FileTraceCollector:: instance()-end" << endl << flush;
        }
       ret = pthread_mutex_unlock(&_singletonMutex); // release lock
     }
@@ -100,23 +98,18 @@ void* FileTraceCollector::run(void *bid)
        }
       *_threadId = pthread_self();
     }
-  else cout << "----- Comment est-ce possible de passer la ? -------" <<endl;
+  else cerr << "--- FileTraceCollector::run-serious design problem..." <<endl;
 
   ret = pthread_mutex_unlock(&_singletonMutex); // release lock
 
   if (isOKtoRun)
     { 
-//       if (_threadId == 0)
-//     {
-//       _threadId = new pthread_t;
-//     }
       if (_threadId == 0)
        {
          cerr << "FileTraceCollector::run error!" << endl << flush;
          exit(1);
        }
 
-//       *_threadId = pthread_self();
       LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
       LocalTrace_TraceInfo myTrace;
 
@@ -137,6 +130,9 @@ void* FileTraceCollector::run(void *bid)
 
       while ((!_threadToClose) || myTraceBuffer->toCollect() )
        {
+         //if (_threadToClose)
+         //  cerr << "FileTraceCollector _threadToClose" << endl << flush;
+
          int fullBuf = myTraceBuffer->retrieve(myTrace);
          if (myTrace.traceType == ABORT_MESS)
            {
@@ -185,7 +181,25 @@ void* FileTraceCollector::run(void *bid)
 
 FileTraceCollector:: ~FileTraceCollector()
 {
-  cerr << "FileTraceCollector:: ~FileTraceCollector()" << endl << flush;
+  int ret;
+  ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
+  if (_singleton)
+    {
+      //cerr << "FileTraceCollector:: ~FileTraceCollector()" << endl << flush;
+      LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
+      _threadToClose = 1;
+      myTraceBuffer->insert(NORMAL_MESS,"end of trace\n"); // to wake up thread
+      if (_threadId)
+       {
+         int ret = pthread_join(*_threadId, NULL);
+         if (ret) cerr << "error close FileTraceCollector : "<< ret << endl;
+         //else cerr << "FileTraceCollector destruction OK" << endl;
+         _threadId = 0;
+         _threadToClose = 0;
+       }
+      _singleton = 0;
+      ret = pthread_mutex_unlock(&_singletonMutex); // release lock
+    }
 }
 
 // ============================================================================
@@ -198,6 +212,7 @@ FileTraceCollector:: ~FileTraceCollector()
 FileTraceCollector::FileTraceCollector()
 {
   _threadId=0;
+  _threadToClose = 0;
 }
 
 

diff --git a/src/SALOMELocalTrace/LocalTraceBufferPool.cxx b/src/SALOMELocalTrace/LocalTraceBufferPool.cxx
index 8a136ceef1812d22a8bc73b352f5dc56cbb3f96c..b690bb5acee25d6be57d66cfbd6d733cc686d45c 100644 (file)
--- a/src/SALOMELocalTrace/LocalTraceBufferPool.cxx
+++ b/src/SALOMELocalTrace/LocalTraceBufferPool.cxx
@@ -105,7 +105,7 @@ LocalTraceBufferPool* LocalTraceBufferPool::instance()
 
          char* traceKind = getenv("SALOME_trace");
          assert(traceKind);
-         cout<<"SALOME_trace="<<traceKind<<endl;
+         //cerr<<"SALOME_trace="<<traceKind<<endl;
 
          if (strcmp(traceKind,"local")==0)
            {
@@ -268,7 +268,7 @@ unsigned long LocalTraceBufferPool::toCollect()
 
 LocalTraceBufferPool::LocalTraceBufferPool()
 {
-  //cout << "LocalTraceBufferPool::LocalTraceBufferPool()" << endl;
+  //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()" << endl;
 
   _insertPos   = ULONG_MAX;  // first increment will give 0
   _retrievePos = ULONG_MAX;
@@ -284,6 +284,8 @@ LocalTraceBufferPool::LocalTraceBufferPool()
   if (ret!=0) IMMEDIATE_ABORT(ret);
   ret=pthread_mutex_init(&_incrementMutex,NULL); // default = fast mutex
   if (ret!=0) IMMEDIATE_ABORT(ret);
+
+  //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()-end" << endl;
 }
 
 // ============================================================================
@@ -294,13 +296,20 @@ LocalTraceBufferPool::LocalTraceBufferPool()
 
 LocalTraceBufferPool::~LocalTraceBufferPool()
 {
-  cerr << "LocalTraceBufferPool::~LocalTraceBufferPool()" << endl << flush;
-  delete (_myThreadTrace);
-  int ret;
-  ret=sem_destroy(&_freeBufferSemaphore);
-  ret=sem_destroy(&_fullBufferSemaphore);
-  ret=pthread_mutex_destroy(&_incrementMutex);
-  cerr << "LocalTraceBufferPool::~LocalTraceBufferPool()" << endl << flush;
+  int ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
+  if (_singleton)
+    {
+      //cerr << "LocalTraceBufferPool::~LocalTraceBufferPool()" << endl<<flush;
+      delete (_myThreadTrace);
+      _myThreadTrace = 0;
+      int ret;
+      ret=sem_destroy(&_freeBufferSemaphore);
+      ret=sem_destroy(&_fullBufferSemaphore);
+      ret=pthread_mutex_destroy(&_incrementMutex);
+      //cerr<<"LocalTraceBufferPool::~LocalTraceBufferPool()-end"<<endl<<flush;
+      _singleton = 0;
+      ret = pthread_mutex_unlock(&_singletonMutex); // release lock
+    }
 }
 
 // ============================================================================

diff --git a/src/SALOMELocalTrace/LocalTraceBufferPool.hxx b/src/SALOMELocalTrace/LocalTraceBufferPool.hxx
index 2bedd3a962161082ce8f59eb4d830380fda804de..6d64ace3e5ce04b0c113e284e3834185bbd46c19 100644 (file)
--- a/src/SALOMELocalTrace/LocalTraceBufferPool.hxx
+++ b/src/SALOMELocalTrace/LocalTraceBufferPool.hxx
@@ -59,6 +59,8 @@ class SALOMELOCALTRACE_EXPORT LocalTraceBufferPool
  private:
   static LocalTraceBufferPool* _singleton;
   static pthread_mutex_t _singletonMutex;
+  static BaseTraceCollector *_myThreadTrace;
+
   LocalTrace_TraceInfo _myBuffer[TRACE_BUFFER_SIZE];
   sem_t _freeBufferSemaphore;       // to wait until there is a free buffer
   sem_t _fullBufferSemaphore;       // to wait until there is a buffer to print
@@ -66,8 +68,6 @@ class SALOMELOCALTRACE_EXPORT LocalTraceBufferPool
   unsigned long _position;
   unsigned long _insertPos;
   unsigned long _retrievePos;
-  pthread_t _threadId;
-  static BaseTraceCollector *_myThreadTrace;
 };
 
 #endif

diff --git a/src/SALOMELocalTrace/LocalTraceCollector.cxx b/src/SALOMELocalTrace/LocalTraceCollector.cxx
index f415e4924d2145431129fd1c1b228f4ee6da4184..e19e2252afb0615eea1bb76b933b03512c36aad4 100644 (file)
--- a/src/SALOMELocalTrace/LocalTraceCollector.cxx
+++ b/src/SALOMELocalTrace/LocalTraceCollector.cxx
@@ -35,16 +35,12 @@ using namespace std;
 
 // ============================================================================
 /*!
- *  This class is for use without CORBA, outside SALOME.
+ *  This class is for use without CORBA, inside or outside SALOME.
  *  SALOME uses SALOMETraceCollector, to allow trace collection via CORBA.
+ *  Type of trace (and corresponding class) is choosen in LocalTraceBufferPool.
  *
- *  guarantees a unique object instance of the class (singleton thread safe)
+ *  Guarantees a unique object instance of the class (singleton thread safe)
  *  a separate thread for loop to print traces is launched.
- *  \param typeTrace 0=standard out, 1=file(/tmp/tracetest.log)
- *  If typeTrace=0, checks environment for "SALOME_trace". Test values in
- *  the following order:
- *  - "local"  standard out
- *  - anything else is kept as a file name
  */
 // ============================================================================
 
@@ -87,12 +83,13 @@ void* LocalTraceCollector::run(void *bid)
   if (! _threadId)  // only one run
     {
       isOKtoRun = 1;
-      if(_threadId == 0) {
-       _threadId = new pthread_t;
-      }
+      if(_threadId == 0)
+       {
+         _threadId = new pthread_t;
+       }
       *_threadId = pthread_self();
     }
-  else cout << "----- Comment est-ce possible de passer la ? -------" <<endl;
+  else cerr << "--- LocalTraceCollector::run-serious design problem..." <<endl;
 
   ret = pthread_mutex_unlock(&_singletonMutex); // release lock
 
@@ -100,10 +97,10 @@ void* LocalTraceCollector::run(void *bid)
     { 
       if(_threadId == 0) 
        {
-         _threadId = new pthread_t;
+         cerr << "LocalTraceCollector::run error!" << endl << flush;
+         exit(1);
        }
 
-      *_threadId = pthread_self();
       LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
       LocalTrace_TraceInfo myTrace;
 
@@ -112,6 +109,9 @@ void* LocalTraceCollector::run(void *bid)
 
       while ((!_threadToClose) || myTraceBuffer->toCollect() )
        {
+         //if (_threadToClose)
+         //  cerr << "FileTraceCollector _threadToClose" << endl << flush;
+
          int fullBuf = myTraceBuffer->retrieve(myTrace);
          if (myTrace.traceType == ABORT_MESS)
            {
@@ -151,7 +151,25 @@ void* LocalTraceCollector::run(void *bid)
 
 LocalTraceCollector:: ~LocalTraceCollector()
 {
-  cerr << "LocalTraceCollector:: ~LocalTraceCollector()" << endl << flush;
+  int ret;
+  ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
+  if (_singleton)
+    {
+      //cerr << "LocalTraceCollector:: ~LocalTraceCollector()" << endl <<flush;
+      LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
+      _threadToClose = 1;
+      myTraceBuffer->insert(NORMAL_MESS,"end of trace\n"); // to wake up thread
+      if (_threadId)
+       {
+         int ret = pthread_join(*_threadId, NULL);
+         if (ret) cerr << "error close LocalTraceCollector : "<< ret << endl;
+         //else cerr << "LocalTraceCollector destruction OK" << endl;
+         _threadId = 0;
+         _threadToClose = 0;
+       }
+      _singleton = 0;
+      ret = pthread_mutex_unlock(&_singletonMutex); // release lock
+    }
 }
 
 // ============================================================================
@@ -164,6 +182,7 @@ LocalTraceCollector:: ~LocalTraceCollector()
 LocalTraceCollector::LocalTraceCollector()
 {
   _threadId=0;
+  _threadToClose = 0;
 }
 
 

diff --git a/src/SALOMETraceCollector/SALOMETraceCollector.cxx b/src/SALOMETraceCollector/SALOMETraceCollector.cxx
index 6c96bfd7e81a1da9b2d41e281474cd04c7894d44..93dd0ebc4e0a21c87125119ed58b6ee6bf42cd24 100644 (file)
--- a/src/SALOMETraceCollector/SALOMETraceCollector.cxx
+++ b/src/SALOMETraceCollector/SALOMETraceCollector.cxx
@@ -34,7 +34,6 @@ using namespace std;
 
 #include "SALOMETraceCollector.hxx"
 #include "TraceCollector_WaitForServerReadiness.hxx"
-//#include "SALOME_Log.hxx"
 #include <SALOMEconfig.h>
 #include CORBA_CLIENT_HEADER(Logger)
 
@@ -44,17 +43,11 @@ CORBA::ORB_ptr SALOMETraceCollector::_orb = 0;
 
 // ============================================================================
 /*!
- *  This class replaces LocalTraceCollector, which is to use outside SALOME,
- *  without CORBA.
+ *  This class is for use with CORBA, inside SALOME.
+ *  Type of trace (and corresponding class) is choosen in LocalTraceBufferPool.
  *
- *  guarantees a unique object instance of the class (singleton thread safe)
+ *  Guarantees a unique object instance of the class (singleton thread safe)
  *  a separate thread for loop to print traces is launched.
- *  \param typeTrace 0=standard out, 1=file(/tmp/tracetest.log), 2=CORBA log
- *  If typeTrace=0, checks environment for "SALOME_trace". Test values in
- *  the following order:
- *  - "local"  standard out
- *  - "with_logger" CORBA log
- *  - anything else is kept as a file name
  */
 // ============================================================================
 
@@ -107,17 +100,18 @@ void* SALOMETraceCollector::run(void *bid)
 
       *_threadId = pthread_self();
     }
-  else cout << "----- Comment est-ce possible de passer la ? -------" <<endl;
+  else cerr << "-- SALOMETraceCollector::run-serious design problem..." <<endl;
+
   ret = pthread_mutex_unlock(&_singletonMutex); // release lock
 
   if (isOKtoRun)
     { 
       if(_threadId == 0)
        {
-         _threadId = new pthread_t;
+         cerr << "SALOMETraceCollector::run error!" << endl << flush;
+         exit(1);
        }
 
-      *_threadId = pthread_self();
       LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
       LocalTrace_TraceInfo myTrace;
 
@@ -138,7 +132,7 @@ void* SALOMETraceCollector::run(void *bid)
          CORBA::String_var LogMsg =
            CORBA::string_dup("\n---Init logger trace---\n");
          m_pInterfaceLogger->putMessage(LogMsg);
-         cout << " Logger server found" << endl;
+         //cerr << " Logger server found" << endl;
        }
 
       // --- Loop until there is no more buffer to print,
@@ -190,6 +184,25 @@ void* SALOMETraceCollector::run(void *bid)
 
 SALOMETraceCollector:: ~SALOMETraceCollector()
 {
+  int ret;
+  ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
+  if (_singleton)
+    {
+      //cerr << "SALOMETraceCollector:: ~SALOMETraceCollector()" <<endl<<flush;
+      LocalTraceBufferPool* myTraceBuffer = LocalTraceBufferPool::instance();
+      _threadToClose = 1;
+      myTraceBuffer->insert(NORMAL_MESS,"end of trace\n"); // to wake up thread
+      if (_threadId)
+       {
+         int ret = pthread_join(*_threadId, NULL);
+         if (ret) cerr << "error close SALOMETraceCollector : "<< ret << endl;
+         //else cerr << "SALOMETraceCollector destruction OK" << endl;
+         _threadId = 0;
+         _threadToClose = 0;
+       }
+      _singleton = 0;
+      ret = pthread_mutex_unlock(&_singletonMutex); // release lock
+    }
 }
 
 // ============================================================================
@@ -202,6 +215,7 @@ SALOMETraceCollector:: ~SALOMETraceCollector()
 SALOMETraceCollector::SALOMETraceCollector()
 {
   _threadId=0;
+  _threadToClose = 0;
 }
 
 // ============================================================================

diff --git a/src/SALOMETraceCollector/TraceCollector_WaitForServerReadiness.cxx b/src/SALOMETraceCollector/TraceCollector_WaitForServerReadiness.cxx
index 2545cbce53919a6a7798fbcae71c9bd3b968e5ee..56321a0478f1d5f3012996ff9901fd16019b3c30 100644 (file)
--- a/src/SALOMETraceCollector/TraceCollector_WaitForServerReadiness.cxx
+++ b/src/SALOMETraceCollector/TraceCollector_WaitForServerReadiness.cxx
@@ -103,8 +103,8 @@ CORBA::Object_ptr TraceCollector_WaitForServerReadiness(CORBA::ORB_ptr orb,
                  obj = inc->resolve(name);
                  if (!CORBA::is_nil(obj))
                    {
-                     cout << "TraceCollector_WaitForServerReadiness: "
-                          << serverName << " found in CORBA Name Service" << endl;
+                     //cout << "TraceCollector_WaitForServerReadiness: "
+                     //           << serverName << " found in CORBA Name Service" << endl;
                      break;
                    }
                }