wow. that was easy: git mv core nucleus
[feisty_meow.git] / nucleus / library / structures / static_memory_gremlin.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : static_memory_gremlin                                             *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 2004-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "static_memory_gremlin.h"
16
17 #include <basis/functions.h>
18
19 #include <basis/array.h>
20 //temp!  needed for fake continuable error etc
21
22 #include <stdio.h>
23 #include <string.h>
24
25 using namespace basis;
26
27 namespace structures {
28
29 //#define DEBUG_STATIC_MEMORY_GREMLIN
30   // comment this out to eliminate debugging print-outs.  otherwise they
31   // are controlled by the class interface.
32
33 //#define SKIP_STATIC_CLEANUP
34   // don't uncomment this unless you want all static objects to be left
35   // allocated on shutdown of the program.  that's very sloppy but may
36   // sometimes be needed for testing.
37
38 //////////////
39
40 const int SMG_CHUNKING_FACTOR = 32;
41   // we'll allocate this many indices at a time.
42
43 //////////////
44
45 static bool __global_program_is_dying = false;
46   // this is set to true when no more logging or access to static objects
47   // should be allowed.
48
49 //////////////
50
51 class gremlin_object_record
52 {
53 public:
54   root_object *c_object;
55   const char *c_name;
56 };
57
58 //////////////
59
60 static_memory_gremlin::static_memory_gremlin()
61 : c_lock(),
62   c_top_index(0),
63   c_actual_size(0),
64   c_pointers(NIL),
65   c_show_debugging(false)
66 {
67   ensure_space_exists();
68 }
69
70 static_memory_gremlin::~static_memory_gremlin()
71 {
72   __global_program_is_dying = true;
73     // now the rest of the program is on notice; we're practically gone.
74
75 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
76   if (c_show_debugging)
77     printf("SMG: beginning static object shutdown...\n");
78 #endif
79
80 #ifndef SKIP_STATIC_CLEANUP
81   // clean up any allocated pointers in reverse order of addition.
82   while (c_top_index > 0) {
83     // make sure we fixate on which guy is shutting down.  some new ones
84     // could be added on the end of the list as a result of this destruction.
85     int zapped_index = c_top_index - 1;
86     gremlin_object_record *ptr = c_pointers[zapped_index];
87     c_pointers[zapped_index] = NIL;
88       // since we know the one we're zapping, we no longer need that index.
89     c_top_index--;
90       // this should allow us to keep chewing on items that are newly being
91       // added during static shutdown, since we have taken the current object
92       // entirely out of the picture.
93     if (ptr) {
94 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
95       if (c_show_debugging)
96         printf((astring("SMG: deleting ") + ptr->c_object->instance_name()
97             + " called " + ptr->c_name
98             + a_sprintf(" at index %d.\n", zapped_index) ).s());
99 #endif
100       WHACK(ptr->c_object);
101       WHACK(ptr);
102     }
103   }
104 #endif
105   delete [] c_pointers;
106   c_pointers = NIL;
107 }
108
109 bool static_memory_gremlin::__program_is_dying() { return __global_program_is_dying; }
110
111 mutex &static_memory_gremlin::__memory_gremlin_synchronizer()
112 {
113   static mutex __globabl_synch_mem;
114   return __globabl_synch_mem;
115 }
116
117 int static_memory_gremlin::locate(const char *unique_name)
118 {
119   auto_synchronizer l(c_lock);
120   for (int i = 0; i < c_top_index; i++) {
121     if (!strcmp(c_pointers[i]->c_name, unique_name)) return i;
122   }
123   return common::NOT_FOUND;
124 }
125
126 root_object *static_memory_gremlin::get(const char *unique_name)
127 {
128   auto_synchronizer l(c_lock);
129   int indy = locate(unique_name);
130   if (negative(indy)) return NIL;
131   return c_pointers[indy]->c_object;
132 }
133
134 const char *static_memory_gremlin::find(const root_object *ptr)
135 {
136   auto_synchronizer l(c_lock);
137   for (int i = 0; i < c_top_index; i++) {
138     if (ptr == c_pointers[i]->c_object)
139       return c_pointers[i]->c_name;
140   }
141   return NIL;
142 }
143
144 bool static_memory_gremlin::put(const char *unique_name, root_object *to_put)
145 {
146   auto_synchronizer l(c_lock);
147   int indy = locate(unique_name);
148   // see if that name already exists.
149   if (non_negative(indy)) {
150 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
151     if (c_show_debugging)
152       printf((astring("SMG: cleaning out old object ")
153           + c_pointers[indy]->c_object->instance_name()
154           + " called " + c_pointers[indy]->c_name 
155           + " in favor of object " + to_put->instance_name()
156           + " called " + unique_name
157           + a_sprintf(" at index %d.\n", indy)).s());
158 #endif
159     WHACK(c_pointers[indy]->c_object);
160     c_pointers[indy]->c_object = to_put;
161     return true;
162   }
163 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
164   if (c_show_debugging)
165     printf((astring("SMG: storing ") + to_put->instance_name()
166         + " called " + unique_name
167         + a_sprintf(" at index %d.\n", c_top_index)).s());
168 #endif
169   ensure_space_exists();
170   c_pointers[c_top_index] = new gremlin_object_record;
171   c_pointers[c_top_index]->c_object = to_put;
172   c_pointers[c_top_index]->c_name = unique_name;
173   c_top_index++;
174   return true;
175 }
176
177 void static_memory_gremlin::ensure_space_exists()
178 {
179   auto_synchronizer l(c_lock);
180   if (!c_pointers || (c_top_index + 1 >= c_actual_size) ) {
181     // never had any contents yet or not enough space exists.
182 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
183     if (c_show_debugging)
184       printf(a_sprintf("SMG: adding space for top at %d.\n", c_top_index).s());
185 #endif
186     c_actual_size += SMG_CHUNKING_FACTOR;
187     typedef gremlin_object_record *base_ptr;
188     gremlin_object_record **new_ptr = new base_ptr[c_actual_size];
189     if (!new_ptr) {
190       throw "error: static_memory_gremlin::ensure_space_exists: failed to allocate memory for pointer list";
191     }
192     for (int i = 0; i < c_actual_size; i++) new_ptr[i] = NIL;
193     for (int j = 0; j < c_actual_size - SMG_CHUNKING_FACTOR; j++) 
194       new_ptr[j] = c_pointers[j];
195     if (c_pointers) delete [] c_pointers;
196     c_pointers = new_ptr;
197   }
198 }
199
200 // this function ensures that the space for the global objects is kept until
201 // the program goes away.  if it's the first time through, then the gremlin
202 // gets created; otherwise the existing one is used.  this function should
203 // always be called by the main program before any attempts to use global
204 // features like SAFE_STATIC or the program wide logger.  it is crucial that no
205 // user-level threads have been created in the program before this is called.
206 static_memory_gremlin &static_memory_gremlin::__hoople_globals()
207 {
208   static bool _initted = false;  // tells whether we've gone through yet.
209   static static_memory_gremlin *_internal_gremlin = NIL;
210     // holds our list of shared pieces...
211
212   if (!_initted) {
213 #ifdef DEBUG_STATIC_MEMORY_GREMLIN
214     printf("%s: initializing HOOPLE_GLOBALS now.\n", _global_argv[0]); 
215 #endif
216
217 #ifdef ENABLE_MEMORY_HOOK
218     void *temp = program_wide_memories().provide_memory(1, __FILE__, __LINE__);
219       // invoke now to get memory engine instantiated.
220     program_wide_memories().release_memory(temp);  // clean up junk.
221 #endif
222
223 #ifdef ENABLE_CALLSTACK_TRACKING
224     program_wide_stack_trace().full_trace_size();
225       // invoke now to get callback tracking instantiated.
226 #endif
227     FUNCDEF("HOOPLE_GLOBALS remainder");
228       // this definition must be postponed until after the objects that would
229       // track it actually exist.
230     if (func) {}  // shut up the compiler about using it.
231
232     // this simple approach is not going to succeed if the SAFE_STATIC macros
233     // are used in a static library which is then used in more than one dynamic
234     // library on win32.  this is because each dll in win32 will have a
235     // different version of certain static objects that should only occur once
236     // per program.  this problem is due to the win32 memory model, but in
237     // hoople at least this has been prevented; our only static library that
238     // appears in a bunch of dlls is basis and it is not allowed to use the
239     // SAFE_STATIC macro.
240     _internal_gremlin = new static_memory_gremlin;
241     _initted = true;
242   }
243
244   return *_internal_gremlin;
245 }
246
247 //////////////
248
249 } // namespace.
250