src/SALOMELocalTrace/LocalTraceBufferPool.cxx

   1 //  Copyright (C) 2004  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 //
  20 //  Author : Paul RASCLE (EDF)
  21 //  Module : KERNEL
  22 //  $Header$
  23 //
  24 // Cf. C++ Users Journal, June 2004, Tracing Application Execution, Tomer Abramson
  25 //
  26
  27 #include <iostream>
  28 #include <limits.h>
  29 #include <cassert>
  30
  31 #ifndef WNT
  32 #include <dlfcn.h>
  33 #else
  34 #include <windows.h>
  35 #endif
  36
  37 //#define _DEVDEBUG_
  38 #include "LocalTraceBufferPool.hxx"
  39 #include "BaseTraceCollector.hxx"
  40 #include "LocalTraceCollector.hxx"
  41 #include "FileTraceCollector.hxx"
  42 #include "BasicsGenericDestructor.hxx"
  43 #include "utilities.h"
  44
  45 using namespace std;
  46
  47 // In case of truncated message, end of trace contains "...\n\0"
  48
  49 #define TRUNCATED_MESSAGE "...\n"
  50 #define MAXMESS_LENGTH MAX_TRACE_LENGTH-5
  51
  52 // Class static attributes initialisation
  53
  54 LocalTraceBufferPool* LocalTraceBufferPool::_singleton = 0;
  55 //#ifndef WNT
  56 //pthread_mutex_t LocalTraceBufferPool::_singletonMutex;
  57 //#else
  58 pthread_mutex_t LocalTraceBufferPool::_singletonMutex =
  59   PTHREAD_MUTEX_INITIALIZER;
  60 //#endif
  61 BaseTraceCollector *LocalTraceBufferPool::_myThreadTrace = 0;
  62
  63 // ============================================================================
  64 /*!
  65  *  Guarantees a unique object instance of the class (singleton thread safe).
  66  *  When the LocalTraceBufferPool instance is created, the trace collector is
  67  *  also created (singleton). Type of trace collector to create depends on
  68  *  environment variable "SALOME_trace":
  69  *  - "local" implies standard err trace, LocalTraceCollector is launched.
  70  *  - "file" implies trace in /tmp/tracetest.log
  71  *  - "file:pathname" implies trace in file pathname
  72  *  - anything else like "other" : try to load dynamically a library named
  73  *    otherTraceCollector, and invoque C method instance() to start a singleton
  74  *    instance of the trace collector. Example: with_loggerTraceCollector, for
  75  *    CORBA Log.
  76  */
  77 // ============================================================================
  78
  79 LocalTraceBufferPool* LocalTraceBufferPool::instance()
  80 {
  81   if (_singleton == 0) // no need of lock when singleton already exists
  82     {
  83       int ret;
  84       ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
  85       if (_singleton == 0)                     // another thread may have got
  86         {                                      // the lock after the first test
  87           DEVTRACE("New buffer pool");
  88           LocalTraceBufferPool* myInstance = new LocalTraceBufferPool();
  89
  90           DESTRUCTOR_OF<LocalTraceBufferPool> *ptrDestroy =
  91             new DESTRUCTOR_OF<LocalTraceBufferPool> (*myInstance);
  92           _singleton = myInstance;
  93
  94           // --- start a trace Collector
  95
  96           char* traceKind;
  97           bool isNotDefined = false;
  98           if ( getenv("SALOME_trace") )
  99             traceKind = getenv("SALOME_trace");
 100           else
 101             isNotDefined = true; // mkr : 27.11.2006 : PAL13967 - Distributed supervision graphs - Problem with "SALOME_trace"
 102
 103           assert(traceKind);
 104           //cerr<<"SALOME_trace="<<traceKind<<endl;
 105
 106           if ( isNotDefined || strcmp(traceKind,"local")==0 )
 107             {
 108               _myThreadTrace = LocalTraceCollector::instance();
 109             }
 110           else if (strncmp(traceKind,"file",strlen("file"))==0)
 111             {
 112               char *fileName;
 113               if (strlen(traceKind) > strlen("file"))
 114                 fileName = &traceKind[strlen("file")+1];
 115               else
 116                 fileName = "/tmp/tracetest.log";
 117
 118               _myThreadTrace = FileTraceCollector::instance(fileName);
 119             }
 120           else // --- try a dynamic library
 121             {
 122 #ifndef WNT
 123               void* handle;
 124               string impl_name = string ("lib") + traceKind
 125                 + string("TraceCollector.so");
 126               handle = dlopen( impl_name.c_str() , RTLD_LAZY ) ;
 127 #else
 128               HINSTANCE handle;
 129               string impl_name = string ("lib") + traceKind + string(".dll");
 130               handle = LoadLibrary( impl_name.c_str() );
 131 #endif
 132               if ( handle )
 133                 {
 134                   typedef BaseTraceCollector * (*FACTORY_FUNCTION) (void);
 135 #ifndef WNT
 136                   FACTORY_FUNCTION TraceCollectorFactory =
 137                     (FACTORY_FUNCTION) dlsym(handle, "SingletonInstance");
 138 #else
 139                   FACTORY_FUNCTION TraceCollectorFactory =
 140                     (FACTORY_FUNCTION)GetProcAddress(handle, "SingletonInstance");
 141 #endif
 142                   if ( !TraceCollectorFactory )
 143                   {
 144                       cerr << "Can't resolve symbol: SingletonInstance" <<endl;
 145 #ifndef WNT
 146                       cerr << "dlerror: " << dlerror() << endl;
 147 #endif
 148                       exit( 1 );
 149                     }
 150                   _myThreadTrace = (TraceCollectorFactory) ();
 151                 }
 152               else
 153                 {
 154                   cerr << "library: " << impl_name << " not found !" << endl;
 155                   assert(handle); // to give file and line
 156                   exit(1);        // in case assert is deactivated
 157                 }
 158             }
 159           DEVTRACE("New buffer pool: end");
 160         }
 161       ret = pthread_mutex_unlock(&_singletonMutex); // release lock
 162     }
 163   return _singleton;
 164 }
 165
 166 // ============================================================================
 167 /*!
 168  *  Called by trace producers within their threads. The trace message is copied
 169  *  in specific buffer from a circular pool of buffers.
 170  *  Waits until there is a free buffer in the pool, gets the first available
 171  *  buffer, fills it with the message.
 172  *  Messages are printed in a separate thread (see retrieve method)
 173  */
 174 // ============================================================================
 175
 176 int LocalTraceBufferPool::insert(int traceType, const char* msg)
 177 {
 178
 179   // get immediately a message number to control sequence (mutex protected)
 180
 181   unsigned long myMessageNumber = lockedIncrement(_position);
 182
 183   // wait until there is a free buffer in the pool
 184
 185   int ret = -1;
 186   while (ret)
 187     {
 188       ret = sem_wait(&_freeBufferSemaphore);
 189       if (ret) perror(" LocalTraceBufferPool::insert, sem_wait");
 190     }
 191
 192   // get the next free buffer available (mutex protected)
 193
 194   unsigned long myInsertPos = lockedIncrement(_insertPos);
 195
 196   // fill the buffer with message, thread id and type (normal or abort)
 197
 198   strncpy(_myBuffer[myInsertPos%TRACE_BUFFER_SIZE].trace,
 199           msg,
 200           MAXMESS_LENGTH); // last chars always "...\n\0" if msg too long
 201   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].threadId =pthread_self();//thread id
 202   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].traceType = traceType;
 203   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].position = myMessageNumber;
 204
 205
 206   // increment the full buffer semaphore
 207   // (if previously 0, awake thread in charge of trace)
 208
 209   ret = sem_post(&_fullBufferSemaphore);
 210
 211   // returns the number of free buffers
 212
 213   sem_getvalue(&_freeBufferSemaphore, &ret);
 214   return ret;
 215 }
 216
 217 // ============================================================================
 218 /*!
 219  *  Called by the thread in charge of printing trace messages.
 220  *  Waits until there is a buffer with a message to print.
 221  *  Gets the first buffer to print, copies it int the provided buffer
 222  */
 223 // ============================================================================
 224
 225 int LocalTraceBufferPool::retrieve(LocalTrace_TraceInfo& aTrace)
 226 {
 227
 228   // wait until there is a buffer in the pool, with a message to print
 229
 230   int ret = -1;
 231   while (ret)
 232     {
 233       ret = sem_wait(&_fullBufferSemaphore);
 234       if (ret) perror(" LocalTraceBufferPool::retrieve, sem_wait");
 235     }
 236
 237   // get the next buffer to print
 238
 239   unsigned long myRetrievePos = lockedIncrement(_retrievePos);
 240
 241   // copy the buffer from the pool to the provided buffer
 242
 243   memcpy((void*)&aTrace,
 244          (void*)&_myBuffer[myRetrievePos%TRACE_BUFFER_SIZE],
 245          sizeof(aTrace));
 246
 247   // increment the free buffer semaphore
 248   // (if previously 0, awake one of the threads waiting to put a trace, if any)
 249   // there is no way to preserve the order of waiting threads if several
 250   // threads are waiting to put a trace: the waken up thread is not
 251   // necessarily the first thread to wait.
 252
 253   ret = sem_post(&_freeBufferSemaphore);
 254
 255   // returns the number of full buffers
 256
 257   sem_getvalue(&_fullBufferSemaphore, &ret);
 258   return ret;
 259 }
 260
 261 // ============================================================================
 262 /*!
 263  *  Gives the number of buffers to print.
 264  *  Usage : when the thread in charge of messages print id to be stopped,
 265  *  check if there is still something to print, before stop.
 266  *  There is no need of mutex here, provided there is only one thread to
 267  *  retrieve and print the buffers.
 268  */
 269 // ============================================================================
 270
 271 unsigned long LocalTraceBufferPool::toCollect()
 272 {
 273   return _insertPos - _retrievePos;
 274 }
 275
 276 // ============================================================================
 277 /*!
 278  * Constructor : initialize pool of buffers, semaphores and mutex.
 279  */
 280 // ============================================================================
 281
 282 LocalTraceBufferPool::LocalTraceBufferPool()
 283 {
 284   //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()" << endl;
 285
 286   _insertPos   = ULONG_MAX;  // first increment will give 0
 287   _retrievePos = ULONG_MAX;
 288   _position=0;               // first message will have number = 1
 289
 290   memset(_myBuffer, 0, sizeof(_myBuffer)); // to guarantee end of strings = 0
 291   for (int i=0; i<TRACE_BUFFER_SIZE; i++)
 292     strcpy(&(_myBuffer[i].trace[MAXMESS_LENGTH]),TRUNCATED_MESSAGE);
 293   int ret;
 294   ret=sem_init(&_freeBufferSemaphore, 0, TRACE_BUFFER_SIZE); // all buffer free
 295   if (ret!=0) IMMEDIATE_ABORT(ret);
 296   ret=sem_init(&_fullBufferSemaphore, 0, 0);                 // 0 buffer full
 297   if (ret!=0) IMMEDIATE_ABORT(ret);
 298   ret=pthread_mutex_init(&_incrementMutex,NULL); // default = fast mutex
 299   if (ret!=0) IMMEDIATE_ABORT(ret);
 300
 301   //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()-end" << endl;
 302 }
 303
 304 // ============================================================================
 305 /*!
 306  * Destructor : release memory associated with semaphores and mutex
 307  */
 308 // ============================================================================
 309
 310 LocalTraceBufferPool::~LocalTraceBufferPool()
 311 {
 312   int ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
 313   if (_singleton)
 314     {
 315       DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()");
 316       delete (_myThreadTrace);
 317       _myThreadTrace = 0;
 318       int ret;
 319       ret=sem_destroy(&_freeBufferSemaphore);
 320       ret=sem_destroy(&_fullBufferSemaphore);
 321       ret=pthread_mutex_destroy(&_incrementMutex);
 322       DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()-end");
 323       _singleton = 0;
 324     }
 325   ret = pthread_mutex_unlock(&_singletonMutex); // release lock
 326 }
 327
 328 // ============================================================================
 329 /*!
 330  * pool counters are incremented under a mutex protection
 331  */
 332 // ============================================================================
 333
 334 unsigned long LocalTraceBufferPool::lockedIncrement(unsigned long& pos)
 335 {
 336   int ret;
 337   ret = pthread_mutex_lock(&_incrementMutex);   // lock access to counters
 338   unsigned long mypos = ++pos;
 339   ret = pthread_mutex_unlock(&_incrementMutex); // release lock
 340   return mypos;
 341 }
 342