mirror of
https://github.com/git/git
synced 2024-08-27 19:49:21 +00:00
![Elijah Newren](/assets/img/avatar_default.png)
This allows us to replace includes of cache.h with includes of the much smaller alloc.h in many places. It does mean that we also need to add includes of alloc.h in a number of C files. Signed-off-by: Elijah Newren <newren@gmail.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
196 lines
4.2 KiB
C
196 lines
4.2 KiB
C
#include "git-compat-util.h"
|
|
#include "alloc.h"
|
|
#include "thread-utils.h"
|
|
#include "trace.h"
|
|
#include "trace2/tr2_tls.h"
|
|
|
|
/*
|
|
* Initialize size of the thread stack for nested regions.
|
|
* This is used to store nested region start times. Note that
|
|
* this stack is per-thread and not per-trace-key.
|
|
*/
|
|
#define TR2_REGION_NESTING_INITIAL_SIZE (100)
|
|
|
|
static struct tr2tls_thread_ctx *tr2tls_thread_main;
|
|
static uint64_t tr2tls_us_start_process;
|
|
|
|
static pthread_mutex_t tr2tls_mutex;
|
|
static pthread_key_t tr2tls_key;
|
|
|
|
static int tr2_next_thread_id; /* modify under lock */
|
|
|
|
void tr2tls_start_process_clock(void)
|
|
{
|
|
if (tr2tls_us_start_process)
|
|
return;
|
|
|
|
/*
|
|
* Keep the absolute start time of the process (i.e. the main
|
|
* process) in a fixed variable since other threads need to
|
|
* access it. This allows them to do that without a lock on
|
|
* main thread's array data (because of reallocs).
|
|
*/
|
|
tr2tls_us_start_process = getnanotime() / 1000;
|
|
}
|
|
|
|
struct tr2tls_thread_ctx *tr2tls_create_self(const char *thread_base_name,
|
|
uint64_t us_thread_start)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx = xcalloc(1, sizeof(*ctx));
|
|
struct strbuf buf = STRBUF_INIT;
|
|
|
|
/*
|
|
* Implicitly "tr2tls_push_self()" to capture the thread's start
|
|
* time in array_us_start[0]. For the main thread this gives us the
|
|
* application run time.
|
|
*/
|
|
ctx->alloc = TR2_REGION_NESTING_INITIAL_SIZE;
|
|
ctx->array_us_start = (uint64_t *)xcalloc(ctx->alloc, sizeof(uint64_t));
|
|
ctx->array_us_start[ctx->nr_open_regions++] = us_thread_start;
|
|
|
|
ctx->thread_id = tr2tls_locked_increment(&tr2_next_thread_id);
|
|
|
|
strbuf_init(&buf, 0);
|
|
if (ctx->thread_id)
|
|
strbuf_addf(&buf, "th%02d:", ctx->thread_id);
|
|
strbuf_addstr(&buf, thread_base_name);
|
|
if (buf.len > TR2_MAX_THREAD_NAME)
|
|
strbuf_setlen(&buf, TR2_MAX_THREAD_NAME);
|
|
ctx->thread_name = strbuf_detach(&buf, NULL);
|
|
|
|
pthread_setspecific(tr2tls_key, ctx);
|
|
|
|
return ctx;
|
|
}
|
|
|
|
struct tr2tls_thread_ctx *tr2tls_get_self(void)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx;
|
|
|
|
if (!HAVE_THREADS)
|
|
return tr2tls_thread_main;
|
|
|
|
ctx = pthread_getspecific(tr2tls_key);
|
|
|
|
/*
|
|
* If the current thread's thread-proc did not call
|
|
* trace2_thread_start(), then the thread will not have any
|
|
* thread-local storage. Create it now and silently continue.
|
|
*/
|
|
if (!ctx)
|
|
ctx = tr2tls_create_self("unknown", getnanotime() / 1000);
|
|
|
|
return ctx;
|
|
}
|
|
|
|
int tr2tls_is_main_thread(void)
|
|
{
|
|
if (!HAVE_THREADS)
|
|
return 1;
|
|
|
|
return pthread_getspecific(tr2tls_key) == tr2tls_thread_main;
|
|
}
|
|
|
|
void tr2tls_unset_self(void)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx;
|
|
|
|
ctx = tr2tls_get_self();
|
|
|
|
pthread_setspecific(tr2tls_key, NULL);
|
|
|
|
free((char *)ctx->thread_name);
|
|
free(ctx->array_us_start);
|
|
free(ctx);
|
|
}
|
|
|
|
void tr2tls_push_self(uint64_t us_now)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
|
|
|
|
ALLOC_GROW(ctx->array_us_start, ctx->nr_open_regions + 1, ctx->alloc);
|
|
ctx->array_us_start[ctx->nr_open_regions++] = us_now;
|
|
}
|
|
|
|
void tr2tls_pop_self(void)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
|
|
|
|
if (!ctx->nr_open_regions)
|
|
BUG("no open regions in thread '%s'", ctx->thread_name);
|
|
|
|
ctx->nr_open_regions--;
|
|
}
|
|
|
|
void tr2tls_pop_unwind_self(void)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx = tr2tls_get_self();
|
|
|
|
while (ctx->nr_open_regions > 1)
|
|
tr2tls_pop_self();
|
|
}
|
|
|
|
uint64_t tr2tls_region_elasped_self(uint64_t us)
|
|
{
|
|
struct tr2tls_thread_ctx *ctx;
|
|
uint64_t us_start;
|
|
|
|
ctx = tr2tls_get_self();
|
|
if (!ctx->nr_open_regions)
|
|
return 0;
|
|
|
|
us_start = ctx->array_us_start[ctx->nr_open_regions - 1];
|
|
|
|
return us - us_start;
|
|
}
|
|
|
|
uint64_t tr2tls_absolute_elapsed(uint64_t us)
|
|
{
|
|
if (!tr2tls_thread_main)
|
|
return 0;
|
|
|
|
return us - tr2tls_us_start_process;
|
|
}
|
|
|
|
void tr2tls_init(void)
|
|
{
|
|
tr2tls_start_process_clock();
|
|
|
|
pthread_key_create(&tr2tls_key, NULL);
|
|
init_recursive_mutex(&tr2tls_mutex);
|
|
|
|
tr2tls_thread_main =
|
|
tr2tls_create_self("main", tr2tls_us_start_process);
|
|
}
|
|
|
|
void tr2tls_release(void)
|
|
{
|
|
tr2tls_unset_self();
|
|
tr2tls_thread_main = NULL;
|
|
|
|
pthread_mutex_destroy(&tr2tls_mutex);
|
|
pthread_key_delete(tr2tls_key);
|
|
}
|
|
|
|
int tr2tls_locked_increment(int *p)
|
|
{
|
|
int current_value;
|
|
|
|
pthread_mutex_lock(&tr2tls_mutex);
|
|
current_value = *p;
|
|
*p = current_value + 1;
|
|
pthread_mutex_unlock(&tr2tls_mutex);
|
|
|
|
return current_value;
|
|
}
|
|
|
|
void tr2tls_lock(void)
|
|
{
|
|
pthread_mutex_lock(&tr2tls_mutex);
|
|
}
|
|
|
|
void tr2tls_unlock(void)
|
|
{
|
|
pthread_mutex_unlock(&tr2tls_mutex);
|
|
}
|