cinelerra-5.1/guicast/bctrace.h

   1 #ifndef __BC_TRACE_H__
   2 #define __BC_TRACE_H__
   3
   4 #include "arraylist.h"
   5 #include "linklist.h"
   6 #include "bctrace.inc"
   7 #include "bcwindowbase.inc"
   8 #include "cstrdup.h"
   9 #include <pthread.h>
  10
  11
  12 class BC_Trace
  13 {
  14 public:
  15         BC_Trace();
  16         ~BC_Trace();
  17
  18         static BC_Trace *global_trace;
  19         static void reset_locks();
  20
  21         static void delete_temps();
  22         static void set_temp(char *string);
  23         static void unset_temp(char *string);
  24
  25         static void enable_locks();
  26         static void disable_locks();
  27         static int set_lock(const char *title, const char *location, trace_info *info);
  28         static void set_lock2(int table_id, trace_info *info);
  29         static void unset_lock2(int table_id, trace_info *info);
  30         static void unset_lock(trace_info *info);
  31 // Used in lock destructors so takes away all references
  32         static void unset_all_locks(trace_info *info);
  33         static void clear_locks_tid(pthread_t tid);
  34
  35         static void new_trace(const char *text);
  36         static void new_trace(const char *file, const char *function, int line);
  37         static void delete_traces();
  38
  39         static void enable_memory();
  40         static void disable_memory();
  41         static void set_buffer(int size, void *ptr, const char* location);
  42 // This one returns 1 if the buffer wasn't found.
  43         static int unset_buffer(void *ptr);
  44         static void lock_locks(const char *s);
  45         static void unlock_locks();
  46
  47         static void dump_traces(FILE *fp=stdout);
  48         static void dump_locks(FILE *fp=stdout);
  49         static void dump_buffers(FILE *fp=stdout);
  50         static void dump_threads(FILE *fp=stdout);
  51
  52         static void dump_shm_stat(const char *fn, FILE *fp=stdout);
  53         static void dump_shm_stats(FILE *fp=stdout);
  54 };
  55
  56 class bc_trace_list : public List<trace_item> {
  57 public:
  58         void clear() { while( last ) remove(last); }
  59         bc_trace_list() {}
  60         ~bc_trace_list() { clear(); }
  61 };
  62
  63 class bc_trace_t : public bc_trace_list {
  64 public:
  65         int size;
  66         bc_trace_t() : size(0) {}
  67         ~bc_trace_t() {}
  68 };
  69
  70 class bc_trace_spin : public bc_trace_t {
  71         pthread_spinlock_t spin;
  72 public:
  73         void *operator new(size_t n) { return (void*) malloc(n); }
  74         void operator delete(void *t, size_t n) { free(t); }
  75
  76         void lock() { pthread_spin_lock(&spin); }
  77         void unlock() { pthread_spin_unlock(&spin); }
  78         bc_trace_spin() { pthread_spin_init(&spin, PTHREAD_PROCESS_PRIVATE); }
  79         ~bc_trace_spin() { pthread_spin_destroy(&spin); }
  80 };
  81
  82 class bc_trace_mutex : public bc_trace_t {
  83         pthread_mutex_t mutex;
  84 public:
  85         void *operator new(size_t n) { return (void*) malloc(n); }
  86         void operator delete(void *t, size_t n) { free(t); }
  87
  88         void lock() { pthread_mutex_lock(&mutex); }
  89         void unlock() { pthread_mutex_unlock(&mutex); }
  90         bc_trace_mutex() { pthread_mutex_init(&mutex, 0); }
  91         ~bc_trace_mutex() { pthread_mutex_destroy(&mutex); }
  92 };
  93
  94 extern bc_trace_mutex execution_table;
  95 extern bc_trace_mutex memory_table;
  96 extern bc_trace_mutex lock_table;
  97 extern bc_trace_mutex file_table;
  98 extern "C" void dump();
  99
 100 class trace_item : public ListItem<trace_item> {
 101 public:
 102         bc_trace_t &table;
 103         trace_item(bc_trace_t &t);
 104         ~trace_item();
 105 };
 106
 107 class execution_item : public trace_item {
 108 public:
 109         void *operator new(size_t n) { return (void*) malloc(n); }
 110         void operator delete(void *t, size_t n) { free(t); }
 111
 112         const char *value;
 113         void clear() { delete [] value;  value = 0; }
 114         void set(const char *v) { delete [] value;  value = cstrdup(v); }
 115
 116         execution_item() : trace_item(execution_table) { value = 0; }
 117         ~execution_item() { clear(); }
 118 };
 119
 120 class lock_item : public trace_item {
 121         static int table_id;
 122 public:
 123         void *operator new(size_t n) { return (void*) malloc(n); }
 124         void operator delete(void *t, size_t n) { free(t); }
 125
 126         trace_info *info;
 127         const char *title;
 128         const char *loc;
 129         int is_owner;
 130         int id;
 131         pthread_t tid;
 132         void set(trace_info *info, const char *title, const char *loc) {
 133                 this->info = info;  this->title = title;
 134                 this->loc = loc;  this->is_owner = 0;
 135                 this->id = table_id++;  this->tid = pthread_self();
 136         }
 137         void clear() {
 138                 this->info = 0;  this->title = 0; this->loc = 0;
 139                 this->is_owner = 0;  this->id = -1;  this->tid = 0;
 140         }
 141
 142         lock_item() : trace_item(lock_table) { clear(); }
 143         ~lock_item() {}
 144 };
 145
 146 class memory_item : public trace_item {
 147 public:
 148         void *operator new(size_t n) { return (void*) malloc(n); }
 149         void operator delete(void *t, size_t n) { free(t); }
 150
 151         int size;
 152         void *ptr;
 153         const char *loc;
 154
 155         memory_item(int size, void *ptr, const char *loc)
 156          : trace_item(memory_table) {
 157                 this->size = size; this->ptr = ptr; this->loc = loc;
 158         }
 159         ~memory_item() {}
 160 };
 161
 162 class file_item : public trace_item {
 163 public:
 164         void *operator new(size_t n) { return (void*) malloc(n); }
 165         void operator delete(void *t, size_t n) { free(t); }
 166
 167         const char *value;
 168         void clear() { delete [] value;  value = 0; }
 169         void set(const char *v) { delete [] value;  value = cstrdup(v); }
 170
 171         file_item() : trace_item(file_table) { value = 0; }
 172         ~file_item() { clear(); }
 173 };
 174
 175 // track unjoined threads at termination
 176 #ifdef TRACE_THREADS
 177
 178 class TheLock {
 179 public:
 180         pthread_mutex_t the_lock;
 181
 182         void lock() { pthread_mutex_lock(&the_lock); }
 183         void unlock() { pthread_mutex_unlock(&the_lock); }
 184
 185         void init() {
 186                 pthread_mutexattr_t attr;
 187                 pthread_mutexattr_init(&attr);
 188                 pthread_mutex_init(&the_lock, &attr);
 189         }
 190         void finit() {
 191                 pthread_mutex_destroy(&the_lock);
 192         }
 193         void reset() { finit();  init(); }
 194
 195         TheLock()  { init();  }
 196         ~TheLock() { finit(); }
 197 };
 198
 199 class TheLocker {
 200 public:
 201         static TheLock the_lock;
 202         static void reset() { the_lock.reset(); }
 203
 204         TheLocker() { the_lock.lock(); }
 205         ~TheLocker() { the_lock.unlock(); }
 206 };
 207
 208 class TheDbg {
 209 public:
 210         pthread_t tid, owner;  const char *name;
 211         TheDbg(pthread_t t, pthread_t o, const char *nm) { tid = t; owner = o; name = nm; }
 212         ~TheDbg() {}
 213 };
 214
 215
 216 class TheList : public ArrayList<TheDbg *> {
 217 public:
 218         static TheList the_list;
 219         static void dump_threads(FILE *fp);
 220         static void dbg_add(pthread_t tid, pthread_t owner, const char *nm);
 221         static void dbg_del(pthread_t tid);
 222         static void reset() { the_list.remove_all_objects(); TheLocker::reset(); }
 223          TheList() {}
 224         ~TheList() { reset(); }
 225 };
 226
 227 class TheChk {
 228 public:
 229         static TheChk the_chk;
 230
 231         TheChk() {}
 232         ~TheChk() {
 233                 int i = TheList::the_list.size();
 234                 if( !i ) return;
 235                 printf("unjoined tids / owner %d\n", i);
 236                 while( --i >= 0 ) printf("  %016lx / %016lx %s\n",
 237                         (unsigned long)TheList::the_list[i]->tid,
 238                         (unsigned long)TheList::the_list[i]->owner,
 239                         TheList::the_list[i]->name);
 240         }
 241 };
 242
 243 #endif
 244
 245 #endif