src/gallium/auxiliary/util/u_debug_refcnt.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2010 Luca Barbieri
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining
   6  * a copy of this software and associated documentation files (the
   7  * "Software"), to deal in the Software without restriction, including
   8  * without limitation the rights to use, copy, modify, merge, publish,
   9  * distribute, sublicense, and/or sell copies of the Software, and to
  10  * permit persons to whom the Software is furnished to do so, subject to
  11  * the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the
  14  * next paragraph) shall be included in all copies or substantial
  15  * portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  19  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  20  * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
  21  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  22  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  23  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  24  *
  25  **************************************************************************/
  26
  27 #if defined(DEBUG)
  28
  29 /* see http://www.mozilla.org/performance/refcnt-balancer.html for what do with the output
  30  * on Linux, use tools/addr2line.sh to postprocess it before anything else
  31  **/
  32
  33 #include <stdio.h>
  34
  35 #include "util/u_debug.h"
  36 #include "util/u_debug_refcnt.h"
  37 #include "util/u_debug_stack.h"
  38 #include "util/u_debug_symbol.h"
  39 #include "util/u_string.h"
  40 #include "util/u_hash_table.h"
  41 #include "os/os_thread.h"
  42
  43 int debug_refcnt_state;
  44
  45 FILE* stream;
  46
  47 /* TODO: maybe move this serial machinery to a stand-alone module and expose it? */
  48 pipe_static_mutex(serials_mutex);
  49
  50 static struct util_hash_table* serials_hash;
  51 static unsigned serials_last;
  52
  53 static unsigned hash_ptr(void* p)
  54 {
  55    return (unsigned)(uintptr_t)p;
  56 }
  57
  58 static int compare_ptr(void* a, void* b)
  59 {
  60    if(a == b)
  61       return 0;
  62    else if(a < b)
  63       return -1;
  64    else
  65       return 1;
  66 }
  67
  68 static boolean debug_serial(void* p, unsigned* pserial)
  69 {
  70    unsigned serial;
  71    boolean found = TRUE;
  72 #ifdef PIPE_SUBSYSTEM_WINDOWS_USER
  73    static boolean first = TRUE;
  74
  75    if (first) {
  76       pipe_mutex_init(serials_mutex);
  77       first = FALSE;
  78    }
  79 #endif
  80
  81    pipe_mutex_lock(serials_mutex);
  82    if(!serials_hash)
  83       serials_hash = util_hash_table_create(hash_ptr, compare_ptr);
  84    serial = (unsigned)(uintptr_t)util_hash_table_get(serials_hash, p);
  85    if(!serial)
  86    {
  87       /* time to stop logging... (you'll have a 100 GB logfile at least at this point)
  88        * TODO: avoid this
  89        */
  90       serial = ++serials_last;
  91       if(!serial)
  92       {
  93          debug_error("More than 2^32 objects detected, aborting.\n");
  94          os_abort();
  95       }
  96
  97       util_hash_table_set(serials_hash, p, (void*)(uintptr_t)serial);
  98       found = FALSE;
  99    }
 100    pipe_mutex_unlock(serials_mutex);
 101    *pserial = serial;
 102    return found;
 103 }
 104
 105 static void debug_serial_delete(void* p)
 106 {
 107    pipe_mutex_lock(serials_mutex);
 108    util_hash_table_remove(serials_hash, p);
 109    pipe_mutex_unlock(serials_mutex);
 110 }
 111
 112 #define STACK_LEN 64
 113
 114 static void dump_stack(const char* symbols[STACK_LEN])
 115 {
 116    unsigned i;
 117    for(i = 0; i < STACK_LEN; ++i)
 118    {
 119       if(symbols[i])
 120          fprintf(stream, "%s\n", symbols[i]);
 121    }
 122    fprintf(stream, "\n");
 123 }
 124
 125 void debug_reference_slowpath(const struct pipe_reference* p, debug_reference_descriptor get_desc, int change)
 126 {
 127    if(debug_refcnt_state < 0)
 128       return;
 129
 130    if(!debug_refcnt_state)
 131    {
 132       const char* filename = debug_get_option("GALLIUM_REFCNT_LOG", NULL);
 133       if(filename && filename[0])
 134          stream = fopen(filename, "wt");
 135
 136       if(stream)
 137          debug_refcnt_state = 1;
 138       else
 139          debug_refcnt_state = -1;
 140    }
 141
 142    if(debug_refcnt_state > 0)
 143    {
 144       struct debug_stack_frame frames[STACK_LEN];
 145       const char* symbols[STACK_LEN];
 146       char buf[1024];
 147
 148       unsigned i;
 149       unsigned refcnt = p->count;
 150       unsigned serial;
 151       boolean existing = debug_serial((void*)p, &serial);
 152
 153       debug_backtrace_capture(frames, 1, STACK_LEN);
 154       for(i = 0; i < STACK_LEN; ++i)
 155       {
 156          if(frames[i].function)
 157             symbols[i] = debug_symbol_name_cached(frames[i].function);
 158          else
 159             symbols[i] = 0;
 160       }
 161
 162       get_desc(buf, p);
 163
 164       if(!existing)
 165       {
 166          fprintf(stream, "<%s> %p %u Create\n", buf, (void *) p, serial);
 167          dump_stack(symbols);
 168
 169          /* this is there to provide a gradual change even if we don't see the initialization */
 170          for(i = 1; i <= refcnt - change; ++i)
 171          {
 172             fprintf(stream, "<%s> %p %u AddRef %u\n", buf, (void *) p,
 173                     serial, i);
 174             dump_stack(symbols);
 175          }
 176       }
 177
 178       if(change)
 179       {
 180          fprintf(stream, "<%s> %p %u %s %u\n", buf, (void *) p, serial,
 181                  change > 0 ? "AddRef" : "Release", refcnt);
 182          dump_stack(symbols);
 183       }
 184
 185       if(!refcnt)
 186       {
 187          debug_serial_delete((void*)p);
 188          fprintf(stream, "<%s> %p %u Destroy\n", buf, (void *) p, serial);
 189          dump_stack(symbols);
 190       }
 191
 192       fflush(stream);
 193    }
 194 }
 195 #endif