Andrew's git - gitweb.git/blob

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