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 /**
  30  * If the GALLIUM_REFCNT_LOG env var is defined as a filename, gallium
  31  * reference counting will be logged to the file.
  32  *
  33  * See http://www-archive.mozilla.org/performance/refcnt-balancer.html
  34  * for what to do with the output on Linux, use tools/addr2line.sh to
  35  * postprocess it before anything else.
  36  */
  37
  38 #include <stdio.h>
  39
  40 #include "util/u_debug.h"
  41 #include "util/u_debug_refcnt.h"
  42 #include "util/u_debug_stack.h"
  43 #include "util/u_debug_symbol.h"
  44 #include "util/u_string.h"
  45 #include "util/u_hash_table.h"
  46 #include "os/os_thread.h"
  47
  48 int debug_refcnt_state;
  49
  50 static FILE *stream;
  51
  52 /* TODO: maybe move this serial machinery to a stand-alone module and
  53  * expose it?
  54  */
  55 static mtx_t serials_mutex = _MTX_INITIALIZER_NP;
  56
  57 static struct hash_table *serials_hash;
  58 static unsigned serials_last;
  59
  60
  61 /**
  62  * Return a small integer serial number for the given pointer.
  63  */
  64 static boolean
  65 debug_serial(void *p, unsigned *pserial)
  66 {
  67    unsigned serial;
  68    boolean found = TRUE;
  69 #ifdef PIPE_OS_WINDOWS
  70    static boolean first = TRUE;
  71
  72    if (first) {
  73       (void) mtx_init(&serials_mutex, mtx_plain);
  74       first = FALSE;
  75    }
  76 #endif
  77
  78    mtx_lock(&serials_mutex);
  79    if (!serials_hash)
  80       serials_hash = util_hash_table_create_ptr_keys();
  81
  82    serial = (unsigned) (uintptr_t) util_hash_table_get(serials_hash, p);
  83    if (!serial) {
  84       /* time to stop logging... (you'll have a 100 GB logfile at least at
  85        * this point)  TODO: avoid this
  86        */
  87       serial = ++serials_last;
  88       if (!serial) {
  89          debug_error("More than 2^32 objects detected, aborting.\n");
  90          os_abort();
  91       }
  92
  93       _mesa_hash_table_insert(serials_hash, p, (void *) (uintptr_t) serial);
  94       found = FALSE;
  95    }
  96    mtx_unlock(&serials_mutex);
  97
  98    *pserial = serial;
  99
 100    return found;
 101 }
 102
 103
 104 /**
 105  * Free the serial number for the given pointer.
 106  */
 107 static void
 108 debug_serial_delete(void *p)
 109 {
 110    mtx_lock(&serials_mutex);
 111    _mesa_hash_table_remove_key(serials_hash, p);
 112    mtx_unlock(&serials_mutex);
 113 }
 114
 115
 116 #define STACK_LEN 64
 117
 118 /**
 119  * Log a reference count change to the log file (if enabled).
 120  * This is called via the pipe_reference() and debug_reference() functions,
 121  * basically whenever a reference count is initialized or changed.
 122  *
 123  * \param p  the refcount being changed (the value is not changed here)
 124  * \param get_desc  a function which will be called to print an object's
 125  *                  name/pointer into a string buffer during logging
 126  * \param change  the reference count change which must be +/-1 or 0 when
 127  *                creating the object and initializing the refcount.
 128  */
 129 void
 130 debug_reference_slowpath(const struct pipe_reference *p,
 131                          debug_reference_descriptor get_desc, int change)
 132 {
 133    assert(change >= -1);
 134    assert(change <= 1);
 135
 136    if (debug_refcnt_state < 0)
 137       return;
 138
 139    if (!debug_refcnt_state) {
 140       const char *filename = debug_get_option("GALLIUM_REFCNT_LOG", NULL);
 141       if (filename && filename[0])
 142          stream = fopen(filename, "wt");
 143
 144       if (stream)
 145          debug_refcnt_state = 1;
 146       else
 147          debug_refcnt_state = -1;
 148    }
 149
 150    if (debug_refcnt_state > 0) {
 151       struct debug_stack_frame frames[STACK_LEN];
 152       char buf[1024];
 153       unsigned i;
 154       unsigned refcnt = p->count;
 155       unsigned serial;
 156       boolean existing = debug_serial((void *) p, &serial);
 157
 158       debug_backtrace_capture(frames, 1, STACK_LEN);
 159
 160       get_desc(buf, p);
 161
 162       if (!existing) {
 163          fprintf(stream, "<%s> %p %u Create\n", buf, (void *) p, serial);
 164          debug_backtrace_print(stream, frames, STACK_LEN);
 165
 166          /* this is here to provide a gradual change even if we don't see
 167           * the initialization
 168           */
 169          for (i = 1; i <= refcnt - change; ++i) {
 170             fprintf(stream, "<%s> %p %u AddRef %u\n", buf, (void *) p,
 171                     serial, i);
 172             debug_backtrace_print(stream, frames, STACK_LEN);
 173          }
 174       }
 175
 176       if (change) {
 177          fprintf(stream, "<%s> %p %u %s %u\n", buf, (void *) p, serial,
 178                  change > 0 ? "AddRef" : "Release", refcnt);
 179          debug_backtrace_print(stream, frames, STACK_LEN);
 180       }
 181
 182       if (!refcnt) {
 183          debug_serial_delete((void *) p);
 184          fprintf(stream, "<%s> %p %u Destroy\n", buf, (void *) p, serial);
 185          debug_backtrace_print(stream, frames, STACK_LEN);
 186       }
 187
 188       fflush(stream);
 189    }
 190 }
 191
 192 #endif /* DEBUG */