src/SALOMELocalTrace/LocalTraceBufferPool.cxx

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