#include "git-compat-util.h"

#include "strbuf.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);

}