trace2/tr2_tls.c

   1 #include "git-compat-util.h"
   2 #include "thread-utils.h"
   3 #include "trace.h"
   4 #include "trace2/tr2_tls.h"
   5
   6 /*
   7  * Initialize size of the thread stack for nested regions.
   8  * This is used to store nested region start times.  Note that
   9  * this stack is per-thread and not per-trace-key.
  10  */
  11 #define TR2_REGION_NESTING_INITIAL_SIZE (100)
  12
  13 static struct tr2tls_thread_ctx *tr2tls_thread_main;
  14 static uint64_t tr2tls_us_start_process;
  15
  16 static pthread_mutex_t tr2tls_mutex;
  17 static pthread_key_t tr2tls_key;
  18
  19 static int tr2_next_thread_id; /* modify under lock */
  20
  21 void tr2tls_start_process_clock(void)
  22 {
  23         if (tr2tls_us_start_process)
  24                 return;
  25
  26         /*
  27          * Keep the absolute start time of the process (i.e. the main
  28          * process) in a fixed variable since other threads need to
  29          * access it.  This allows them to do that without a lock on
  30          * main thread's array data (because of reallocs).
  31          */
  32         tr2tls_us_start_process = getnanotime() / 1000;
  33 }
  34
  35 struct tr2tls_thread_ctx *tr2tls_create_self(const char *thread_base_name,
  36                                              uint64_t us_thread_start)
  37 {
  38         struct tr2tls_thread_ctx *ctx = xcalloc(1, sizeof(*ctx));
  39         struct strbuf buf = STRBUF_INIT;
  40
  41         /*
  42          * Implicitly "tr2tls_push_self()" to capture the thread's start
  43          * time in array_us_start[0].  For the main thread this gives us the
  44          * application run time.
  45          */
  46         ctx->alloc = TR2_REGION_NESTING_INITIAL_SIZE;
  47         ctx->array_us_start = (uint64_t *)xcalloc(ctx->alloc, sizeof(uint64_t));
  48         ctx->array_us_start[ctx->nr_open_regions++] = us_thread_start;
  49
  50         ctx->thread_id = tr2tls_locked_increment(&tr2_next_thread_id);
  51
  52         strbuf_init(&buf, 0);
  53         if (ctx->thread_id)
  54                 strbuf_addf(&buf, "th%02d:", ctx->thread_id);
  55         strbuf_addstr(&buf, thread_base_name);
  56         if (buf.len > TR2_MAX_THREAD_NAME)
  57                 strbuf_setlen(&buf, TR2_MAX_THREAD_NAME);
  58         ctx->thread_name = strbuf_detach(&buf, NULL);
  59
  60         pthread_setspecific(tr2tls_key, ctx);
  61
  62         return ctx;
  63 }
  64
  65 struct tr2tls_thread_ctx *tr2tls_get_self(void)
  66 {
  67         struct tr2tls_thread_ctx *ctx;
  68
  69         if (!HAVE_THREADS)
  70                 return tr2tls_thread_main;
  71
  72         ctx = pthread_getspecific(tr2tls_key);
  73
  74         /*
  75          * If the current thread's thread-proc did not call
  76          * trace2_thread_start(), then the thread will not have any
  77          * thread-local storage.  Create it now and silently continue.
  78          */
  79         if (!ctx)
  80                 ctx = tr2tls_create_self("unknown", getnanotime() / 1000);
  81
  82         return ctx;
  83 }
  84
  85 int tr2tls_is_main_thread(void)
  86 {
  87         if (!HAVE_THREADS)
  88                 return 1;
  89
  90         return pthread_getspecific(tr2tls_key) == tr2tls_thread_main;
  91 }
  92
  93 void tr2tls_unset_self(void)
  94 {
  95         struct tr2tls_thread_ctx *ctx;
  96
  97         ctx = tr2tls_get_self();
  98
  99         pthread_setspecific(tr2tls_key, NULL);
 100
 101         free((char *)ctx->thread_name);
 102         free(ctx->array_us_start);
 103         free(ctx);
 104 }
 105
 106 void tr2tls_push_self(uint64_t us_now)
 107 {
 108         struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
 109
 110         ALLOC_GROW(ctx->array_us_start, ctx->nr_open_regions + 1, ctx->alloc);
 111         ctx->array_us_start[ctx->nr_open_regions++] = us_now;
 112 }
 113
 114 void tr2tls_pop_self(void)
 115 {
 116         struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
 117
 118         if (!ctx->nr_open_regions)
 119                 BUG("no open regions in thread '%s'", ctx->thread_name);
 120
 121         ctx->nr_open_regions--;
 122 }
 123
 124 void tr2tls_pop_unwind_self(void)
 125 {
 126         struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
 127
 128         while (ctx->nr_open_regions > 1)
 129                 tr2tls_pop_self();
 130 }
 131
 132 uint64_t tr2tls_region_elasped_self(uint64_t us)
 133 {
 134         struct tr2tls_thread_ctx *ctx;
 135         uint64_t us_start;
 136
 137         ctx = tr2tls_get_self();
 138         if (!ctx->nr_open_regions)
 139                 return 0;
 140
 141         us_start = ctx->array_us_start[ctx->nr_open_regions - 1];
 142
 143         return us - us_start;
 144 }
 145
 146 uint64_t tr2tls_absolute_elapsed(uint64_t us)
 147 {
 148         if (!tr2tls_thread_main)
 149                 return 0;
 150
 151         return us - tr2tls_us_start_process;
 152 }
 153
 154 void tr2tls_init(void)
 155 {
 156         tr2tls_start_process_clock();
 157
 158         pthread_key_create(&tr2tls_key, NULL);
 159         init_recursive_mutex(&tr2tls_mutex);
 160
 161         tr2tls_thread_main =
 162                 tr2tls_create_self("main", tr2tls_us_start_process);
 163 }
 164
 165 void tr2tls_release(void)
 166 {
 167         tr2tls_unset_self();
 168         tr2tls_thread_main = NULL;
 169
 170         pthread_mutex_destroy(&tr2tls_mutex);
 171         pthread_key_delete(tr2tls_key);
 172 }
 173
 174 int tr2tls_locked_increment(int *p)
 175 {
 176         int current_value;
 177
 178         pthread_mutex_lock(&tr2tls_mutex);
 179         current_value = *p;
 180         *p = current_value + 1;
 181         pthread_mutex_unlock(&tr2tls_mutex);
 182
 183         return current_value;
 184 }
 185
 186 void tr2tls_lock(void)
 187 {
 188         pthread_mutex_lock(&tr2tls_mutex);
 189 }
 190
 191 void tr2tls_unlock(void)
 192 {
 193         pthread_mutex_unlock(&tr2tls_mutex);
 194 }