Merge branch 'jk/delta-islands-progress-fix' into maint
[git] / trace2 / tr2_tls.c
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
12 static struct tr2tls_thread_ctx *tr2tls_thread_main;
13 static uint64_t tr2tls_us_start_process;
14
15 static pthread_mutex_t tr2tls_mutex;
16 static pthread_key_t tr2tls_key;
17
18 static int tr2_next_thread_id; /* modify under lock */
19
20 void 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
34 struct 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
62 struct 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
82 int 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
90 void 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
102 void 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
110 void 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
120 void 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
128 uint64_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
142 uint64_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
150 void 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
161 void 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
170 int 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 }