mirror of
https://github.com/git/git
synced 2024-08-28 20:20:07 +00:00
![Jeff Hostetler](/assets/img/avatar_default.png)
Add stopwatch timer mechanism to Trace2. Timers are an alternative to Trace2 Regions. Regions are useful for measuring the time spent in various computation phases, such as the time to read the index, time to scan for unstaged files, time to scan for untracked files, and etc. However, regions are not appropriate in all places. For example, during a checkout, it would be very inefficient to use regions to measure the total time spent inflating objects from the ODB from across the entire lifetime of the process; a per-unzip() region would flood the output and significantly slow the command; and some form of post-processing would be requried to compute the time spent in unzip(). Timers can be used to measure a series of timer intervals and emit a single summary event (at thread and/or process exit). Signed-off-by: Jeff Hostetler <jeffhost@microsoft.com> Signed-off-by: Junio C Hamano <gitster@pobox.com>
194 lines
4.2 KiB
C
194 lines
4.2 KiB
C
#include "cache.h"
|
|
#include "thread-utils.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);
|
|
}
|