Changeset 6654

Timestamp:

13/05/10 17:30:03 (21 months ago)

Author:

westram

Message:

• This patch stuffs all memory leaks in ARBDB (as far as covered by unit-tests) for DEBUG and NDEBUG version!
• ARBDB global data (aka 'gb_local')
  • track number of opened/closed DBs
  • GBK_install_SIGSEGV_handler only once in GB_init_gb()
  • when closing last DB -> call GB_exit_gb() freeing more memory (also called atexit, including assertion failing if a DB is still open)
  • added class ARBDB_memory_manager (just calls gbm_init_mem + gbm_flush_mem)
  • GB_exit_gb flushes ARBDB_memory_manager (if all blocks were freed by gbm_free_mem, everything will be flushed)
• fixed a few more static buffer leaks
• gb_make_entry - alloc correct blocksizes for GB_STRING and GB_LINK
• fixed a hack in gb_read_bin_rek_V2
  • was increasing size of memory block to avoid illegal memory access in decompress (introduced in [1003]; may occur again)
  • due to mismatch in size between gbm_get_mem and gbm_free_mem memory was never flushed even if all blocks have been freed
• fixed memleak in gb_read_bin_rek_V2
  • when loading mapfile, previously created 'gb_main' was not freed
• added allocation logger to admalloc.cxx (inactive - use TRACE_ALLOCS to activate it)
  • traces all allocs/frees of ARBDB managed memory
  • detects wrong usage (double free, size and index mismatch) and shows were the block was allocated
  • added new backtrace functions helpful for debugging (store stack-backtraces and print them later)

Location:

trunk/ARBDB

Files:

• Makefile (modified) (1 diff)
• adTest.cxx (modified) (1 diff)
• ad_core.cxx (modified) (8 diffs)
• ad_k_prot.h (modified) (1 diff)
• ad_load.cxx (modified) (5 diffs)
• ad_prot.h (modified) (1 diff)
• adcompr.cxx (modified) (1 diff)
• admalloc.cxx (modified) (8 diffs)
• adstring.cxx (modified) (2 diffs)
• arbdb.cxx (modified) (6 diffs)
• gb_local.h (modified) (1 diff)
• gb_localdata.h (modified) (1 diff)
• gb_prot.h (modified) (2 diffs)

trunk/ARBDB/Makefile

@@ -145 +145 @@
 ad_core.o: gb_key.h
 ad_core.o: gb_local.h
+ad_core.o: gb_localdata.h
 ad_core.o: gb_main.h
 ad_core.o: gb_memory.h

trunk/ARBDB/adTest.cxx

@@ -172 +172 @@
 
     if (gb_father) {
-        char *father_path = strdup(GB_get_db_path(gb_father));
-
-        static char *result; // careful! used recursively
-        freeset(result, GBS_global_string_copy("%s/%s", father_path, GB_KEY(gbd)));
-        free(father_path);
-
-        return result;
+        const char *father_path = GB_get_db_path(gb_father);
+
+        static SmartMallocPtr(char) result;         // careful! used recursively
+        char *key = GB_KEY(gbd);
+        result    = GBS_global_string_copy("%s/%s", father_path, key ? key : "<gbmain>");
+
+        return &*result;
     }
     return "";

trunk/ARBDB/ad_core.cxx

@@ -12 +12 @@
 #include "gb_storage.h"
 #include "gb_index.h"
+#include "gb_localdata.h"
 
 // Copy all info + external data mem to an one step undo buffer
@@ -73 +74 @@
 }
 
-void gb_touch_header(GBCONTAINER *gbc)
-{
+void gb_touch_header(GBCONTAINER *gbc) {
     gbc->flags2.header_changed = 1;
     gb_touch_entry((GBDATA*)gbc, GB_NORMAL_CHANGE);
@@ -80 +80 @@
 
 
-void
-gb_untouch_children(GBCONTAINER * gbc)
-{
+void gb_untouch_children(GBCONTAINER * gbc) {
     GBDATA    *gbd;
     int        index, start, end;
@@ -120 +118 @@
 }
 
-void gb_untouch_me(GBDATA * gbc)
-{
+void gb_untouch_me(GBDATA * gbc) {
     GB_DATA_LIST_HEADER(GB_FATHER(gbc)->d)[gbc->index].flags.changed = GB_UNCHANGED;
     if (GB_TYPE(gbc) == GB_DB) {
@@ -129 +126 @@
 }
 
-void gb_set_update_in_server_flags(GBCONTAINER * gbc)
-{
+void gb_set_update_in_server_flags(GBCONTAINER * gbc) {
     int             index;
     GBDATA         *gbd;
@@ -258 +254 @@
 
     Main = (GB_MAIN_TYPE *)gbm_get_mem(sizeof(*Main), 0);
-    if (path) Main->path = strdup((char*)path);
+    if (path) Main->path   = strdup((char*)path);
     Main->key_2_index_hash = GBS_create_hash(ALLOWED_KEYS, GB_MIND_CASE);
-    Main->compression_mask = -1;        // allow all compressions
+    Main->compression_mask = -1;                    // allow all compressions
     gb_init_cache(Main);
     gb_init_undo_stack(Main);
     gb_init_ctype_table();
+    gb_local->openedDBs++;
     return Main;
 }
@@ -287 +284 @@
     free(Main->path);
     free(Main->qs.quick_save_disabled);
-    
+
     gbm_free_mem((char *)Main, sizeof(*Main), 0);
+
+    gb_local->closedDBs++;
+    if (gb_local->closedDBs == gb_local->openedDBs) {
+        GB_exit_gb(); // free most memory allocated by ARBDB library
+    }
 
     return 0;
@@ -331 +333 @@
 GBDATA *gb_make_entry(GBCONTAINER * father, const char *key, long index_pos, GBQUARK keyq, GB_TYPES type) {
     // creates a terminal database object
-    GBDATA       *gbd;
-    long          gbm_index;
-    static char  *buffer = 0;
-    char         *p;
-    GB_MAIN_TYPE *Main   = GBCONTAINER_MAIN(father);
+    GB_MAIN_TYPE *Main = GBCONTAINER_MAIN(father);
 
     if (!keyq) keyq = gb_key_2_quark(Main, key);
-    gbm_index = GB_QUARK_2_GBMINDEX(Main, keyq);
-    gbd = (GBDATA *) gbm_get_mem(sizeof(GBDATA), gbm_index);
+
+    long    gbm_index = GB_QUARK_2_GBMINDEX(Main, keyq);
+    GBDATA *gbd       = (GBDATA *) gbm_get_mem(sizeof(GBDATA), gbm_index);
+
     GB_GBM_INDEX(gbd) = gbm_index;
     SET_GB_FATHER(gbd, father);
 
-    switch (type)
-    {
-        case GB_STRING_SHRT:    type = GB_STRING;
+    switch (type) {
+        case GB_STRING_SHRT:
+            type = GB_STRING;
+            // fall-through
         case GB_STRING:
-            if (!buffer) buffer = strdup("1234");
-            p = buffer;
-            while (!(++(*p))) { (*p)++; p++; if (!(*p)) break; }
-            GB_SETSMDMALLOC(gbd, 5, 5, buffer);
+            GB_SETSMDMALLOC(gbd, 6, 7, "<NONE>");
             break;
         case GB_LINK:
-            buffer[0] = ':';
-            buffer[1] = 0;
-            GB_SETSMDMALLOC(gbd, 0, 0, buffer);
+            GB_SETSMDMALLOC(gbd, 1, 2, ":");
             break;
-        default:        break;
+        default:
+            break;
     }
     gbd->flags.type = type;

trunk/ARBDB/ad_k_prot.h

@@ -15 +15 @@
 
 /* adstring.cxx */
-void GBK_dump_backtrace(FILE *out, GB_ERROR error);
+class BackTraceInfo *GBK_get_backtrace(size_t skipFramesAtBottom);
+void GBK_dump_former_backtrace(class BackTraceInfo *trace, FILE *out, GB_CSTR message);
+void GBK_free_backtrace(class BackTraceInfo *trace);
+void GBK_dump_backtrace(FILE *out, GB_CSTR message);
 void GBK_install_SIGSEGV_handler(bool dump_backtrace);
 bool GBK_raises_SIGSEGV(void (*cb)(void));

trunk/ARBDB/ad_load.cxx

@@ -945 +945 @@
             case GB_INTS:
             case GB_FLOATS:
-                size = gb_read_number(in);
-                memsize =  gb_read_number(in);
+                size    = gb_read_number(in);
+                memsize = gb_read_number(in);
+
                 DEBUG_DUMP_INDENTED(deep, GBS_global_string("size=%li memsize=%li", size, memsize));
                 if (GB_CHECKINTERN(size, memsize)) {
@@ -954 +955 @@
                 else {
                     GB_SETEXTERN(gb2);
-                    p = gbm_get_mem((size_t)memsize+1, GB_GBM_INDEX(gb2)); // ralf: added +1 because decompress ran out of this block
+                    // memsize++; // ralf: added +1 because decompress ran out of this block (cant solve like this - breaks memory management!)
+                    p = gbm_get_mem((size_t)memsize, GB_GBM_INDEX(gb2)); 
                 }
                 i = fread(p, 1, (size_t)memsize, in);
@@ -1200 +1202 @@
 
                         gb_main_array[new_idx] = Main;
+
+                        gbm_free_mem((char*)Main->data, sizeof(GBCONTAINER), GB_QUARK_2_GBMINDEX(Main, 0));
+
                         Main->data = newGbd;
                         father->main_idx = new_idx;
@@ -1378 +1383 @@
     bool           dbCreated           = false;
 
-    GBK_install_SIGSEGV_handler(true);
-
     if (!opent) opentype = gb_open_all;
     else if (strchr(opent, 'w')) opentype = gb_open_all;
@@ -1451 +1454 @@
     }
 
-    gbm_init_mem();
+    if (GB_install_pid(1)) return 0;
+    
     GB_init_gb();
-
-    if (GB_install_pid(1)) return 0;
 
     Main = gb_make_gb_main_type(path);

trunk/ARBDB/ad_prot.h

@@ -237 +237 @@
 char *GB_check_out_buffer(GB_CBUFFER buffer);
 GB_BUFFER GB_give_other_buffer(GB_CBUFFER buffer, long size);
+void GB_exit_gb(void);
 void GB_init_gb(void);
 void GB_atclose(GBDATA *gbd, void (*fun)(GBDATA *gb_main, void *client_data), void *client_data);

trunk/ARBDB/adcompr.cxx

@@ -191 +191 @@
 }
 
-struct gb_compress_list *gb_build_compress_list(const unsigned char *data, long short_flag, long *size)
+gb_compress_list *gb_build_compress_list(const unsigned char *data, long short_flag, long *size)
 {
     struct gb_compress_list *list;

trunk/ARBDB/admalloc.cxx

@@ -15 +15 @@
 #include <unistd.h>
 #include <climits>
+#include <set>
 
 #include "gb_storage.h"
 
-
 // #define DUMP_MEMBLKS
+// #define DUMP_MEMBLKS_AT_EXIT
+
 #ifndef NDEBUG
-//  #define TEST_MEMBLKS
+// #define TEST_MEMBLKS
+// #define TRACE_ALLOCS
 #endif
 
@@ -185 +188 @@
 }
 
-
-void gbm_init_mem()
-{
-    int i;
-    static int flag = 0;
-
-    if (flag) return;
-
-    flag = 1;
-    for (i=0; i<GBM_MAX_INDEX; i++)
-    {
-        memset((char *)&gbm_global[i], 0, sizeof(struct gbm_struct));
-        gbm_global[i].tables[0] = 0;        // CORE zero get mem
-    }
-    gbm_global2.old_sbrk = (char *)sbrk(0);
-
-    /* init GBB:
-     * --------- */
-
-    gbb_cluster[0].size  = GBB_MINSIZE;
-    gbb_cluster[0].first = NULL;
-
-    for (i=1; i<GBB_CLUSTERS; i++)
-    {
-        long nextSize = gbb_cluster[i-1].size * (100+GBB_INCR);
-
-        nextSize /= 100;
-        nextSize >>= GBB_ALIGN;
-        nextSize ++;
-        nextSize <<= GBB_ALIGN;
-
-        gbb_cluster[i].size  = nextSize;
-        gbb_cluster[i].first = NULL;
-    }
-
-    // last cluster contains ALL bigger blocks
-
-    gbb_cluster[GBB_CLUSTERS].size  = INT_MAX;
-    gbb_cluster[GBB_CLUSTERS].first = NULL;
-}
+#ifdef TRACE_ALLOCS
+
+class AllocLogEntry {
+    char   *block;
+    size_t  size;
+    long    index;
+
+    mutable BackTraceInfo *trace;
+
+public:
+    AllocLogEntry(char *block_, size_t size_, long index_, bool do_trace)
+        : block(block_)
+        , size(size_)
+        , index(index_)
+        , trace(do_trace ? GBK_get_backtrace(5) : NULL)
+    { }
+    AllocLogEntry(const AllocLogEntry& other)
+        : block(other.block)
+        , size(other.size)
+        , index(other.index)
+        , trace(other.trace)
+    {
+        other.trace = NULL;
+    }
+    ~AllocLogEntry() { if (trace) GBK_free_backtrace(trace); }
+
+    size_t get_size() const { return size; }
+    long get_index() const { return index; }
+    
+    bool operator<(const AllocLogEntry& other) const { return block < other.block; }
+    void dump(FILE *out, GB_CSTR message) const { GBK_dump_former_backtrace(trace, out, message); }
+};
+
+typedef std::set<AllocLogEntry> AllocLogEntries;
+
+class AllocLogger {
+    AllocLogEntries entries;
+
+    const AllocLogEntry *existingEntry(char *block) {
+        AllocLogEntries::const_iterator found = entries.find(AllocLogEntry(block, 0, 0, false));
+        
+        return found == entries.end() ? NULL : &*found;
+    }
+
+public:
+    AllocLogger() {
+    }
+    ~AllocLogger() {
+        size_t count = entries.size();
+        if (count) {
+            fprintf(stderr, "%zu non-freed blocks:\n", count);
+            AllocLogEntries::const_iterator end = entries.end();
+            for (AllocLogEntries::const_iterator entry = entries.begin(); entry != end; ++entry) {
+                entry->dump(stderr, "block was allocated from here");
+            }
+        }
+    }
+
+    void allocated(char *block, size_t size, long index) {
+        const AllocLogEntry *exists = existingEntry(block);
+        if (exists) {
+            GBK_dump_backtrace(stderr, "Block allocated again");
+            exists->dump(stderr, "Already allocated from here");
+        }
+        else {
+            entries.insert(AllocLogEntry(block, size, index, true));
+        }
+    }
+    void freed(char *block, size_t size, long index) {
+        const AllocLogEntry *exists = existingEntry(block);
+        if (!exists) {
+            if (!gb_isMappedMemory(block)) {
+                gb_assert(0);
+                // GBK_dump_backtrace(stderr, "Tried to free unallocated block");
+            }
+        }
+        else {
+            gb_assert(exists->get_size() == size);
+            gb_assert(exists->get_index() == index);
+            entries.erase(*exists);
+        }
+    }
+};
+
+static AllocLogger allocLogger;
+
+#endif
+
+inline void free_gbm_table(gbm_table_struct *table) {
+    while (table) {
+        gbm_table_struct *next = table->next;
+        
+        free(table);
+        table = next;
+    }
+}
+
+static bool gbm_mem_initialized = false;
+
+void gbm_flush_mem() {
+    gb_assert(gbm_mem_initialized);
+
+    for (int i = 0; i<GBM_MAX_INDEX; ++i) {
+        gbm_struct& gbm             = gbm_global[i];
+        bool        have_used_items = false;
+
+        for (int t = 0; t < GBM_MAX_TABLES; t++) {
+            if (gbm.useditems[t]) {
+                have_used_items = true;
+                break;
+            }
+        }
+
+        if (!have_used_items) {
+            free_gbm_table(gbm.first);
+            memset((char*)&gbm, 0, sizeof(gbm));
+        }
+    }
+}
+
+void gbm_init_mem() {
+    if (!gbm_mem_initialized) {
+        for (int i = 0; i<GBM_MAX_INDEX; ++i) {
+            memset((char *)&gbm_global[i], 0, sizeof(struct gbm_struct));
+            gbm_global[i].tables[0] = 0;        // CORE zero get mem
+        }
+        gbm_global2.old_sbrk = (char *)sbrk(0);
+
+        /* init GBB:
+         * --------- */
+
+        gbb_cluster[0].size  = GBB_MINSIZE;
+        gbb_cluster[0].first = NULL;
+
+        for (int i = 1; i<GBB_CLUSTERS; ++i) {
+            long nextSize = gbb_cluster[i-1].size * (100+GBB_INCR);
+
+            nextSize /= 100;
+            nextSize >>= GBB_ALIGN;
+            nextSize ++;
+            nextSize <<= GBB_ALIGN;
+
+            gbb_cluster[i].size  = nextSize;
+            gbb_cluster[i].first = NULL;
+        }
+
+        // last cluster contains ALL bigger blocks
+
+        gbb_cluster[GBB_CLUSTERS].size  = INT_MAX;
+        gbb_cluster[GBB_CLUSTERS].first = NULL;
+
+        gbm_mem_initialized = true;
+    }
+}
+
+struct ARBDB_memory_manager {
+    ARBDB_memory_manager() {
+        gb_assert(!gbm_mem_initialized); // there may be only one instance!
+        gbm_init_mem();
+    }
+    ~ARBDB_memory_manager() {
+#if defined(DUMP_MEMBLKS_AT_EXIT)
+        printf("memory at exit:\n");
+        gbm_debug_mem();
+#endif // DUMP_MEMBLKS_AT_EXIT
+        gbm_flush_mem();
+#if defined(DUMP_MEMBLKS_AT_EXIT)
+        printf("memory at exit (after flush):\n");
+        gbm_debug_mem();
+#endif // DUMP_MEMBLKS_AT_EXIT
+    }
+};
+static ARBDB_memory_manager memman;
 
 void GB_memerr()
@@ -424 +560 @@
 
         erg = gbm_get_memblk((size_t)nsize);
-        return erg;
-    }
-
-    pos = nsize >> GBM_LD_ALIGNED;
-    if ((gds = ggi->tables[pos]))
-    {
-        ggi->tablecnt[pos]--;
-        erg = (char *)gds;
-        if (gds->magic != GBM_MAGIC)
+    }
+    else {
+        pos = nsize >> GBM_LD_ALIGNED;
+        if ((gds = ggi->tables[pos]))
         {
-            printf("%lX!= %lX\n", gds->magic, (long)GBM_MAGIC);
-            GB_internal_error("Dangerous internal error: Inconsistent database: "
-                              "Do not overwrite old files with this database");
-        }
-        ggi->tables[pos] = ggi->tables[pos]->next;
-    }
-    else
-    {
-        if (ggi->size < nsize)
+            ggi->tablecnt[pos]--;
+            erg = (char *)gds;
+            if (gds->magic != GBM_MAGIC)
+            {
+                printf("%lX!= %lX\n", gds->magic, (long)GBM_MAGIC);
+                GB_internal_error("Dangerous internal error: Inconsistent database: "
+                                  "Do not overwrite old files with this database");
+            }
+            ggi->tables[pos] = ggi->tables[pos]->next;
+        }
+        else
         {
-            struct gbm_table_struct *gts = (struct gbm_table_struct *)GB_MEMALIGN(GBM_SYSTEM_PAGE_SIZE, GBM_TABLE_SIZE);
-
-            if (!gts) { GB_memerr(); return NULL; }
-
-            memset((char *)gts, 0, GBM_TABLE_SIZE);
-            ggi->gds = &gts->data[0];
-            gts->next = ggi->first; // link tables
-            ggi->first = gts;
-            ggi->size = GBM_TABLE_SIZE - sizeof(void *);
-            ggi->allsize += GBM_TABLE_SIZE;
-        }
-        erg = (char *)ggi->gds;
-        ggi->gds = (struct gbm_data_struct *)(((char *)ggi->gds) + nsize);
-        ggi->size -= (size_t)nsize;
-    }
-
-    ggi->useditems[pos]++;
-    memset(erg, 0, nsize);
-
+            if (ggi->size < nsize)
+            {
+                struct gbm_table_struct *gts = (struct gbm_table_struct *)GB_MEMALIGN(GBM_SYSTEM_PAGE_SIZE, GBM_TABLE_SIZE);
+
+                if (!gts) { GB_memerr(); return NULL; }
+
+                memset((char *)gts, 0, GBM_TABLE_SIZE);
+                ggi->gds = &gts->data[0];
+                gts->next = ggi->first; // link tables
+                ggi->first = gts;
+                ggi->size = GBM_TABLE_SIZE - sizeof(void *);
+                ggi->allsize += GBM_TABLE_SIZE;
+            }
+            erg = (char *)ggi->gds;
+            ggi->gds = (struct gbm_data_struct *)(((char *)ggi->gds) + nsize);
+            ggi->size -= (size_t)nsize;
+        }
+
+        ggi->useditems[pos]++;
+        memset(erg, 0, nsize); // act like calloc()
+    }
+
+#ifdef TRACE_ALLOCS
+    allocLogger.allocated(erg, size, index);
+#endif
     return erg;
 }
@@ -475 +614 @@
     ggi = & gbm_global[index];
     nsize = (size + (GBM_ALIGNED - 1)) & (-GBM_ALIGNED);
+
+#ifdef TRACE_ALLOCS
+    allocLogger.freed(data, size, index);
+#endif
 
     if (nsize > GBM_MAX_SIZE)
@@ -533 +676 @@
 #endif // MEMORY_TEST==0
 
-void gbm_debug_mem(GB_MAIN_TYPE *Main)
-{
+void gbm_debug_mem() {
     int i;
     int index;
@@ -551 +693 @@
             total += i * GBM_ALIGNED * (int) ggi->useditems[i];
 
-            if (ggi->useditems[i] || ggi->tablecnt[i])
-            {
-                {
-                    int j;
-                    for (j = index; j < Main->keycnt; j+=GBM_MAX_INDEX) {
-                        if (Main->keys[j].key) {
-                            printf("%15s", Main->keys[j].key);
-                        }
-                        else {
-                            printf("%15s", "*** unused ****");
-                        }
-                    }
-                }
+            if (ggi->useditems[i] || ggi->tablecnt[i]) {
                 printf("\t'I=%3i' 'Size=%3i' * 'Items %4i' = 'size %7i'    'sum=%7li'   'totalsum=%7li' :   Free %3i\n",
                        index,
@@ -574 +704 @@
             }
         }
-        if (ggi->extern_data_size)
-        {
+        if (ggi->extern_data_size) {
             index_total += ggi->extern_data_size;
             total += ggi->extern_data_size;
-            printf("\t\t'I=%3i' External Data Items=%3li = Sum=%3li  'sum=%7li'  'total=%7li\n",
+            printf("\t'I=%3i' External Data Items=%3li = Sum=%3li  'sum=%7li'  'total=%7li\n",
                    index,
                    ggi->extern_data_items,
@@ -595 +724 @@
     }
 }
+
+// --------------------------------------------------------------------------------
+
+#if (UNIT_TESTS == 1) && 0
+
+#include <test_unit.h>
+
+void TEST_ARBDB_memory() { // not a real unit test - just was used for debugging
+#define ALLOCS 69
+    long *blocks[ALLOCS];
+
+#if (MEMORY_TEST == 0)
+    printf("Before allocations:\n");
+    gbm_debug_mem();
+
+#if 1    
+    static int16_t non_alloc[75];                   // 150 byte
+    gbm_put_memblk((char*)non_alloc, sizeof(non_alloc));
+
+    printf("Added one non-allocated block:\n");
+    gbm_debug_mem();
+#endif
+#endif
+
+    for (int pass = 1; pass <= 2; ++pass) {
+        long allocs = 0;
+
+        for (size_t size = 10; size<5000; size += size/3) {
+            for (long index = 0; index<3; ++index) {
+                if (pass == 1) {
+                    long *block = (long*)gbm_get_mem(size, index);
+
+                    block[0] = size;
+                    block[1] = index;
+
+                    blocks[allocs++] = block;
+                }
+                else {
+                    long *block = blocks[allocs++];
+                    gbm_free_mem((char*)block, (size_t)block[0], block[1]);
+                }
+            }
+        }
+
+#if (MEMORY_TEST == 0)
+        if (pass == 1) {
+            printf("%li memory blocks allocated:\n", allocs);
+            gbm_debug_mem();
+        }
+        else {
+            printf("Memory freed:\n");
+            gbm_debug_mem();
+        }
+        printf("Memory flushed:\n");
+        gbm_flush_mem();
+        gbm_debug_mem();
+#endif
+
+        gb_assert(allocs == ALLOCS);
+    }
+
+    GBK_dump_backtrace(stderr, "test");
+}
+
+
+#endif

trunk/ARBDB/adstring.cxx

@@ -167 +167 @@
 GB_ERROR GB_await_error() {
     if (GB_error_buffer) {
-        static char *err = 0;
-        reassign(err, GB_error_buffer);
-        return err;
+        static SmartMallocPtr(char) err;
+        err             = GB_error_buffer;
+        GB_error_buffer = NULL;
+        return &*err;
     }
     gb_assert(0);               // please correct error handling
@@ -1113 +1114 @@
 #define MAX_BACKTRACE 66
 
-void GBK_dump_backtrace(FILE *out, GB_ERROR error) {
-    void   *array[MAX_BACKTRACE];
-    size_t  size = backtrace(array, MAX_BACKTRACE); // get void*'s for all entries on the stack
-
-    if (!out) out = stderr;
-
-    // print out all the frames to out
-    fprintf(out, "\n-------------------- ARB-backtrace for '%s':\n", error);
-    backtrace_symbols_fd(array, size, fileno(out));
-    if (size == MAX_BACKTRACE) fputs("[stack truncated to avoid deadlock]\n", out);
-    fputs("-------------------- End of backtrace\n", out);
-    fflush(out);
+class BackTraceInfo {
+    void   **array;
+    size_t  size;
+public:
+    BackTraceInfo(size_t skipFramesAtBottom) {
+        void *tmp[MAX_BACKTRACE];
+        size = backtrace(tmp, MAX_BACKTRACE);
+
+        size_t ssize = skipFramesAtBottom*sizeof(*array);
+        size_t msize = size*sizeof(*array) - ssize;
+
+        gb_assert(msize>0);
+        
+        array = (void**)malloc(msize);
+        memcpy(array, tmp+skipFramesAtBottom, msize);
+    }
+    ~BackTraceInfo() { free(array); }
+
+    void dump(FILE *out, GB_CSTR message) {
+        // print out all the frames to out
+        fprintf(out, "\n-------------------- ARB-backtrace '%s':\n", message);
+        backtrace_symbols_fd(array, size, fileno(out));
+        if (size == MAX_BACKTRACE) fputs("[stack truncated to avoid deadlock]\n", out);
+        fputs("-------------------- End of backtrace\n", out);
+        fflush(out);
+    }
+};
+
+class BackTraceInfo *GBK_get_backtrace(size_t skipFramesAtBottom) {
+    return new BackTraceInfo(skipFramesAtBottom);
+}
+void GBK_dump_former_backtrace(class BackTraceInfo *trace, FILE *out, GB_CSTR message) {
+    trace->dump(out, message);
+}
+void GBK_free_backtrace(class BackTraceInfo *trace) {
+    delete trace;
+}
+
+void GBK_dump_backtrace(FILE *out, GB_CSTR message) {
+    BackTraceInfo trace(0);
+    trace.dump(out ? out : stderr, message);
 }
 

trunk/ARBDB/arbdb.cxx

@@ -285 +285 @@
 };
 
+void GB_exit_gb() {
+    if (gb_local) {
+        gb_assert(gb_local->openedDBs == gb_local->closedDBs);
+
+        free(gb_local->bitcompress);
+        gb_free_compress_tree(gb_local->bituncompress);
+        free(gb_local->write_buffer);
+
+        free(check_out_buffer(&gb_local->buf2));
+        free(check_out_buffer(&gb_local->buf1));
+
+        gbm_free_mem((char*)gb_local, sizeof(*gb_local), 0);
+        gb_local = NULL;
+
+        gbm_flush_mem();
+    }
+}
+
 void GB_init_gb() {
     if (!gb_local) {
-        gb_local = (struct gb_local_data *)gbm_get_mem(sizeof(struct gb_local_data), 0);
+        GBK_install_SIGSEGV_handler(true);          // never uninstalled
+
+        gbm_init_mem();
+
+        gb_local = (gb_local_data *)gbm_get_mem(sizeof(gb_local_data), 0);
 
         init_buffer(&gb_local->buf1, 4000);
@@ -300 +322 @@
         gb_local->bitcompress   = gb_build_compress_list(GB_BIT_compress_data, 1, &(gb_local->bc_size));
 
+        gb_local->openedDBs = 0;
+        gb_local->closedDBs = 0;
+
 #ifdef ARBDB_SIZEDEBUG
         arbdb_stat = (long *)GB_calloc(sizeof(long), 1000);
 #endif
+
+        atexit(GB_exit_gb);
     }
 }
@@ -969 +996 @@
 {
     char *d;
-    long memsize[2];
+    long memsize;
 
     GB_TEST_WRITE(gbd, GB_BITS, "GB_write_bits");
@@ -975 +1002 @@
     gb_save_extern_data_in_ts(gbd);
 
-    d = gb_compress_bits(bits, size, (const unsigned char *)c_0, memsize);
+    d = gb_compress_bits(bits, size, (const unsigned char *)c_0, &memsize);
     gbd->flags.compressed_data = 1;
-    GB_SETSMDMALLOC(gbd, size, memsize[0], d);
+    GB_SETSMDMALLOC(gbd, size, memsize, d);
     gb_touch_entry(gbd, GB_NORMAL_CHANGE);
     GB_DO_CALLBACKS(gbd);
@@ -2599 +2626 @@
 
 GB_ERROR GB_print_debug_information(void */*dummy_AW_root*/, GBDATA *gb_main) {
-    int i;
     GB_MAIN_TYPE *Main = GB_MAIN(gb_main);
     GB_push_transaction(gb_main);
-    for (i=0; i<Main->keycnt; i++) {
+    for (int i=0; i<Main->keycnt; i++) {
         if (Main->keys[i].key) {
             printf("%3i %20s    nref %i\n", i, Main->keys[i].key, (int)Main->keys[i].nref);
@@ -2610 +2636 @@
         }
     }
-    gbm_debug_mem(Main);
+    gbm_debug_mem();
     GB_pop_transaction(gb_main);
     return 0;

trunk/ARBDB/gb_local.h

@@ -42 +42 @@
 struct gb_scandir;
 struct gb_transaction_save;
+struct gb_compress_list;
 
 // -------------------

trunk/ARBDB/gb_localdata.h

@@ -55 +55 @@
         GBDATA *gb_main;
     } gbl;
+
+    int openedDBs; 
+    int closedDBs;
 };
 

trunk/ARBDB/gb_prot.h

@@ -88 +88 @@
 
 /* admalloc.cxx */
+void gbm_flush_mem(void);
 void gbm_init_mem(void);
-void gbm_debug_mem(GB_MAIN_TYPE *Main);
+void gbm_debug_mem(void);
 
 /* adoptimize.cxx */
@@ -176 +177 @@
 struct gb_compress_tree *gb_build_uncompress_tree(const unsigned char *data, long short_flag, char **end);
 void gb_free_compress_tree(struct gb_compress_tree *tree);
-struct gb_compress_list *gb_build_compress_list(const unsigned char *data, long short_flag, long *size);
+gb_compress_list *gb_build_compress_list(const unsigned char *data, long short_flag, long *size);
 char *gb_compress_bits(const char *source, long size, const unsigned char *c_0, long *msize);
 GB_BUFFER gb_uncompress_bits(const char *source, long size, char c_0, char c_1);