Salome HOME
8fd4c5bf2d3bfea754094b37bdf59eddc5e72352
[modules/kernel.git] / 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org 
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 #endif
35
36 //#define _DEVDEBUG_
37 #include "LocalTraceBufferPool.hxx"
38 #include "BaseTraceCollector.hxx"
39 #include "LocalTraceCollector.hxx"
40 #include "FileTraceCollector.hxx"
41 #include "BasicsGenericDestructor.hxx"
42 #include "utilities.h"
43
44 using namespace std;
45
46 // In case of truncated message, end of trace contains "...\n\0"
47
48 #define TRUNCATED_MESSAGE "...\n"
49 #define MAXMESS_LENGTH MAX_TRACE_LENGTH-5
50
51 // Class static attributes initialisation
52
53 LocalTraceBufferPool* LocalTraceBufferPool::_singleton = 0;
54 #ifndef WNT
55 pthread_mutex_t LocalTraceBufferPool::_singletonMutex;
56 #else
57 pthread_mutex_t LocalTraceBufferPool::_singletonMutex =
58   PTHREAD_MUTEX_INITIALIZER;
59 #endif
60 BaseTraceCollector *LocalTraceBufferPool::_myThreadTrace = 0;
61
62 // ============================================================================
63 /*!
64  *  Guarantees a unique object instance of the class (singleton thread safe).
65  *  When the LocalTraceBufferPool instance is created, the trace collector is
66  *  also created (singleton). Type of trace collector to create depends on 
67  *  environment variable "SALOME_trace":
68  *  - "local" implies standard err trace, LocalTraceCollector is launched.
69  *  - "file" implies trace in /tmp/tracetest.log
70  *  - "file:pathname" implies trace in file pathname
71  *  - anything else like "other" : try to load dynamically a library named
72  *    otherTraceCollector, and invoque C method instance() to start a singleton
73  *    instance of the trace collector. Example: with_loggerTraceCollector, for
74  *    CORBA Log.
75  */
76 // ============================================================================
77
78 LocalTraceBufferPool* LocalTraceBufferPool::instance()
79 {
80   if (_singleton == 0) // no need of lock when singleton already exists
81     {
82       int ret;
83       ret = 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           DESTRUCTOR_OF<LocalTraceBufferPool> *ptrDestroy =
90             new DESTRUCTOR_OF<LocalTraceBufferPool> (*myInstance);
91           _singleton = myInstance;
92
93           // --- start a trace Collector
94
95           char* traceKind = getenv("SALOME_trace");
96           assert(traceKind);
97           //cerr<<"SALOME_trace="<<traceKind<<endl;
98
99           if (strcmp(traceKind,"local")==0)
100             {
101               _myThreadTrace = LocalTraceCollector::instance();
102             }
103           else if (strncmp(traceKind,"file",strlen("file"))==0)
104             {
105               char *fileName;
106               if (strlen(traceKind) > strlen("file"))
107                 fileName = &traceKind[strlen("file")+1];
108               else
109                 fileName = "/tmp/tracetest.log";
110               
111               _myThreadTrace = FileTraceCollector::instance(fileName);
112             }
113           else // --- try a dynamic library
114             {
115               void* handle;
116 #ifndef WNT
117               string impl_name = string ("lib") + traceKind 
118                 + string("TraceCollector.so");
119               handle = dlopen( impl_name.c_str() , RTLD_LAZY ) ;
120 #else
121               string impl_name = string ("lib") + traceKind + string(".dll");
122               handle = dlopen( impl_name.c_str() , 0 ) ;
123 #endif
124               if ( handle )
125                 {
126                   typedef BaseTraceCollector * (*FACTORY_FUNCTION) (void);
127                   FACTORY_FUNCTION TraceCollectorFactory =
128                     (FACTORY_FUNCTION) dlsym(handle, "SingletonInstance");
129                   char *error ;
130                   if ( (error = dlerror() ) != NULL)
131                     {
132                       cerr << "Can't resolve symbol: SingletonInstance" <<endl;
133                       cerr << "dlerror: " << error << endl;
134                       assert(error == NULL); // to give file and line
135                       exit(1);               // in case assert is deactivated
136                     }
137                   _myThreadTrace = (TraceCollectorFactory) ();
138                 }
139               else
140                 {
141                   cerr << "library: " << impl_name << " not found !" << endl;
142                   assert(handle); // to give file and line
143                   exit(1);        // in case assert is deactivated
144                 }             
145             }
146           DEVTRACE("New buffer pool: end");
147         }
148       ret = pthread_mutex_unlock(&_singletonMutex); // release lock
149     }
150   return _singleton;
151 }
152
153 // ============================================================================
154 /*!
155  *  Called by trace producers within their threads. The trace message is copied
156  *  in specific buffer from a circular pool of buffers.
157  *  Waits until there is a free buffer in the pool, gets the first available
158  *  buffer, fills it with the message.
159  *  Messages are printed in a separate thread (see retrieve method)
160  */
161 // ============================================================================
162
163 int LocalTraceBufferPool::insert(int traceType, const char* msg)
164 {
165
166   // get immediately a message number to control sequence (mutex protected)
167
168   unsigned long myMessageNumber = lockedIncrement(_position);
169
170   // wait until there is a free buffer in the pool
171
172   int ret = sem_wait(&_freeBufferSemaphore);
173
174   // get the next free buffer available (mutex protected) 
175
176   unsigned long myInsertPos = lockedIncrement(_insertPos);
177
178   // fill the buffer with message, thread id and type (normal or abort)
179
180   strncpy(_myBuffer[myInsertPos%TRACE_BUFFER_SIZE].trace,
181           msg,
182           MAXMESS_LENGTH); // last chars always "...\n\0" if msg too long
183   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].threadId =pthread_self();//thread id
184   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].traceType = traceType;
185   _myBuffer[myInsertPos%TRACE_BUFFER_SIZE].position = myMessageNumber;
186
187
188   // increment the full buffer semaphore
189   // (if previously 0, awake thread in charge of trace)
190
191   ret = sem_post(&_fullBufferSemaphore);
192
193   // returns the number of free buffers
194
195   sem_getvalue(&_freeBufferSemaphore, &ret);
196   return ret;  
197 }
198
199 // ============================================================================
200 /*!
201  *  Called by the thread in charge of printing trace messages.
202  *  Waits until there is a buffer with a message to print.
203  *  Gets the first buffer to print, copies it int the provided buffer
204  */
205 // ============================================================================
206
207 int LocalTraceBufferPool::retrieve(LocalTrace_TraceInfo& aTrace)
208 {
209
210   // wait until there is a buffer in the pool, with a message to print
211
212   int ret = sem_wait(&_fullBufferSemaphore);
213
214   // get the next buffer to print
215
216   unsigned long myRetrievePos = lockedIncrement(_retrievePos);
217
218   // copy the buffer from the pool to the provided buffer
219
220   memcpy((void*)&aTrace,
221          (void*)&_myBuffer[myRetrievePos%TRACE_BUFFER_SIZE],
222          sizeof(aTrace));
223
224   // increment the free buffer semaphore
225   // (if previously 0, awake one of the threads waiting to put a trace, if any)
226   // there is no way to preserve the order of waiting threads if several
227   // threads are waiting to put a trace: the waken up thread is not
228   // necessarily the first thread to wait.
229
230   ret = sem_post(&_freeBufferSemaphore);
231
232   // returns the number of full buffers
233
234   sem_getvalue(&_fullBufferSemaphore, &ret);
235   return ret;
236 }
237
238 // ============================================================================
239 /*!
240  *  Gives the number of buffers to print.
241  *  Usage : when the thread in charge of messages print id to be stopped,
242  *  check if there is still something to print, before stop.
243  *  There is no need of mutex here, provided there is only one thread to
244  *  retrieve and print the buffers.
245  */
246 // ============================================================================
247
248 unsigned long LocalTraceBufferPool::toCollect()
249 {
250   return _insertPos - _retrievePos;
251 }
252
253 // ============================================================================
254 /*!
255  * Constructor : initialize pool of buffers, semaphores and mutex.
256  */
257 // ============================================================================
258
259 LocalTraceBufferPool::LocalTraceBufferPool()
260 {
261   //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()" << endl;
262
263   _insertPos   = ULONG_MAX;  // first increment will give 0
264   _retrievePos = ULONG_MAX;
265   _position=0;               // first message will have number = 1
266
267   memset(_myBuffer, 0, sizeof(_myBuffer)); // to guarantee end of strings = 0
268   for (int i=0; i<TRACE_BUFFER_SIZE; i++)
269     strcpy(&(_myBuffer[i].trace[MAXMESS_LENGTH]),TRUNCATED_MESSAGE);
270   int ret;
271   ret=sem_init(&_freeBufferSemaphore, 0, TRACE_BUFFER_SIZE); // all buffer free
272   if (ret!=0) IMMEDIATE_ABORT(ret);
273   ret=sem_init(&_fullBufferSemaphore, 0, 0);                 // 0 buffer full
274   if (ret!=0) IMMEDIATE_ABORT(ret);
275   ret=pthread_mutex_init(&_incrementMutex,NULL); // default = fast mutex
276   if (ret!=0) IMMEDIATE_ABORT(ret);
277
278   //cerr << "LocalTraceBufferPool::LocalTraceBufferPool()-end" << endl;
279 }
280
281 // ============================================================================
282 /*!
283  * Destructor : release memory associated with semaphores and mutex
284  */
285 // ============================================================================
286
287 LocalTraceBufferPool::~LocalTraceBufferPool()
288 {
289   int ret = pthread_mutex_lock(&_singletonMutex); // acquire lock to be alone
290   if (_singleton)
291     {
292       DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()");
293       delete (_myThreadTrace);
294       _myThreadTrace = 0;
295       int ret;
296       ret=sem_destroy(&_freeBufferSemaphore);
297       ret=sem_destroy(&_fullBufferSemaphore);
298       ret=pthread_mutex_destroy(&_incrementMutex);
299       DEVTRACE("LocalTraceBufferPool::~LocalTraceBufferPool()-end");
300       _singleton = 0;
301     }
302   ret = pthread_mutex_unlock(&_singletonMutex); // release lock
303 }
304
305 // ============================================================================
306 /*!
307  * pool counters are incremented under a mutex protection
308  */
309 // ============================================================================
310
311 unsigned long LocalTraceBufferPool::lockedIncrement(unsigned long& pos)
312 {
313   int ret;
314   ret = pthread_mutex_lock(&_incrementMutex);   // lock access to counters
315   pos++;
316   ret = pthread_mutex_unlock(&_incrementMutex); // release lock
317   return pos;
318 }
319