1 // Copyright (C) 2007-2023 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // Author : Paul RASCLE (EDF)
26 // Cf. C++ Users Journal, June 2004, Tracing Application Execution, Tomer Abramson
41 #include "LocalTraceBufferPool.hxx"
42 #include "BaseTraceCollector.hxx"
43 #include "LocalTraceCollector.hxx"
44 #include "FileTraceCollector.hxx"
45 #include "utilities.h"
47 // In case of truncated message, end of trace contains "...\n\0"
49 #define TRUNCATED_MESSAGE "...\n"
50 #define MAXMESS_LENGTH MAX_TRACE_LENGTH-5
52 // Class static attributes initialisation
54 LocalTraceBufferPool* LocalTraceBufferPool::_singleton = 0;
56 //pthread_mutex_t LocalTraceBufferPool::_singletonMutex;
58 pthread_mutex_t LocalTraceBufferPool::_singletonMutex =
59 PTHREAD_MUTEX_INITIALIZER;
61 BaseTraceCollector *LocalTraceBufferPool::_myThreadTrace = 0;
63 // ============================================================================
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
77 // ============================================================================
79 LocalTraceBufferPool* LocalTraceBufferPool::instance()
81 if (_singleton == 0) // no need of lock when singleton already exists
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();
89 new DESTRUCTOR_OF<LocalTraceBufferPool> (*myInstance);
90 _singleton = myInstance;
92 // --- start a trace Collector
94 char* traceKind = getenv("SALOME_trace");
96 if ( !traceKind || strcmp(traceKind,"local")==0 ) // mkr : 27.11.2006 : PAL13967 - Distributed supervision graphs - Problem with "SALOME_trace"
98 _myThreadTrace = LocalTraceCollector::instance();
100 else if (strncmp(traceKind,"file",strlen("file"))==0)
102 const char *fileName;
103 if (strlen(traceKind) > strlen("file"))
104 fileName = &traceKind[strlen("file")+1];
106 fileName = "/tmp/tracetest.log";
108 _myThreadTrace = FileTraceCollector::instance(fileName);
110 else // --- try a dynamic library
114 std::string impl_name = std::string ("lib") + traceKind
116 + std::string("TraceCollector.dylib");
118 + std::string("TraceCollector.so");
120 handle = dlopen( impl_name.c_str() , RTLD_LAZY | RTLD_GLOBAL ) ;
123 std::string impl_name = std::string ("lib") + traceKind + std::string(".dll");
124 handle = LoadLibraryA( impl_name.c_str() );
128 typedef BaseTraceCollector * (*FACTORY_FUNCTION) (void);
130 FACTORY_FUNCTION TraceCollectorFactory =
131 (FACTORY_FUNCTION) dlsym(handle, "SingletonInstance");
133 FACTORY_FUNCTION TraceCollectorFactory =
134 (FACTORY_FUNCTION)GetProcAddress(handle, "SingletonInstance");
136 if ( !TraceCollectorFactory )
138 std::cerr << "Can't resolve symbol: SingletonInstance" <<std::endl;
140 std::cerr << "dlerror: " << dlerror() << std::endl;
144 _myThreadTrace = (TraceCollectorFactory) ();
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
153 DEVTRACE("New buffer pool: end");
155 pthread_mutex_unlock(&_singletonMutex); // release lock
160 // ============================================================================
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)
168 // ============================================================================
170 int LocalTraceBufferPool::insert(int traceType, const char* msg)
173 // get immediately a message number to control sequence (mutex protected)
175 unsigned long myMessageNumber = lockedIncrement(_position);
177 // wait until there is a free buffer in the pool
180 dispatch_semaphore_wait(_freeBufferSemaphore, DISPATCH_TIME_FOREVER);
185 ret = sem_wait(&_freeBufferSemaphore);
186 if (ret) perror(" LocalTraceBufferPool::insert, sem_wait");
189 // get the next free buffer available (mutex protected)
191 unsigned long myInsertPos = lockedIncrement(_insertPos);
193 // fill the buffer with message, thread id and type (normal or abort)
195 strncpy(_myBuffer[myInsertPos%TRACE_BUFFER_SIZE].trace,
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;
203 // increment the full buffer semaphore
204 // (if previously 0, awake thread in charge of trace)
207 dispatch_semaphore_signal(_fullBufferSemaphore);
209 ret = sem_post(&_fullBufferSemaphore);
213 // returns the number of free buffers
217 sem_getvalue(&_freeBufferSemaphore, &ret);
222 // ============================================================================
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
228 // ============================================================================
230 int LocalTraceBufferPool::retrieve(LocalTrace_TraceInfo& aTrace)
233 // wait until there is a buffer in the pool, with a message to print
236 dispatch_semaphore_wait(_fullBufferSemaphore, DISPATCH_TIME_FOREVER);
241 ret = sem_wait(&_fullBufferSemaphore);
242 if (ret) MESSAGE (" LocalTraceBufferPool::retrieve, sem_wait");
245 // get the next buffer to print
247 unsigned long myRetrievePos = lockedIncrement(_retrievePos);
249 // copy the buffer from the pool to the provided buffer
251 memcpy((void*)&aTrace,
252 (void*)&_myBuffer[myRetrievePos%TRACE_BUFFER_SIZE],
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.
262 dispatch_semaphore_signal(_freeBufferSemaphore);
264 ret = sem_post(&_freeBufferSemaphore);
267 // returns the number of full buffers
272 sem_getvalue(&_fullBufferSemaphore, &ret);
277 // ============================================================================
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.
285 // ============================================================================
287 unsigned long LocalTraceBufferPool::toCollect()
289 return _insertPos - _retrievePos;
292 // ============================================================================
294 * Constructor : initialize pool of buffers, semaphores and mutex.
296 // ============================================================================
298 LocalTraceBufferPool::LocalTraceBufferPool()
300 //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()" << endl;
302 _insertPos = ULONG_MAX; // first increment will give 0
303 _retrievePos = ULONG_MAX;
304 _position=0; // first message will have number = 1
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);
311 dispatch_semaphore_t* sem1 = &_freeBufferSemaphore, *sem2 = &_fullBufferSemaphore;
312 *sem1 = dispatch_semaphore_create(TRACE_BUFFER_SIZE);
313 *sem2 = dispatch_semaphore_create(0);
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);
320 ret=pthread_mutex_init(&_incrementMutex,NULL); // default = fast mutex
321 if (ret!=0) IMMEDIATE_ABORT(ret);
323 //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()-end" << endl;
326 // ============================================================================
328 * Destructor : release memory associated with semaphores and mutex
330 // ============================================================================
332 LocalTraceBufferPool::~LocalTraceBufferPool()
334 pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
337 DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()");
338 delete (_myThreadTrace);
341 dispatch_release(_freeBufferSemaphore);
342 dispatch_release(_fullBufferSemaphore);
344 sem_destroy(&_freeBufferSemaphore);
345 sem_destroy(&_fullBufferSemaphore);
347 pthread_mutex_destroy(&_incrementMutex);
348 DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()-end");
351 pthread_mutex_unlock(&_singletonMutex); // release lock
354 // ============================================================================
356 * pool counters are incremented under a mutex protection
358 // ============================================================================
360 unsigned long LocalTraceBufferPool::lockedIncrement(unsigned long& pos)
362 pthread_mutex_lock(&_incrementMutex); // lock access to counters
363 unsigned long mypos = ++pos;
364 pthread_mutex_unlock(&_incrementMutex); // release lock