Website Summary Files Commits Branches @commit @diff @stats
path: root / gctest / minitrace / minitrace.c
diff options
context:
space:
mode:
Commitfefc19f44df05b8dce8eff0fcff50ad3761bb78e (patch)
Author
 Dimitar Trendafilov <trendafilov.dn@gmail.com>
2020-12-23 14:55:13 +0200
Committer
 Dimitar Trendafilov <trendafilov.dn@gmail.com>
2020-12-23 14:55:13 +0200
Filesa67c5916f28efc4267fb22ae141a23e2bbeb66dd /gctest/minitrace/minitrace.c
IPL-fefc19f44df05b8dce8eff0fcff50ad3761bb78e.tar
IPL-fefc19f44df05b8dce8eff0fcff50ad3761bb78e.tar.gz
IPL-fefc19f44df05b8dce8eff0fcff50ad3761bb78e.zip
Parent32f732d5e91da6c911e2f983e317dc4da8b1c1e3 (diff)
Parentdbe9285608507c592fede216f2c147c5a3d40cea (diff)
Merge commit 'dbe9285608507c592fede216f2c147c5a3d40cea' as 'gctest/minitrace'
1 files changed, 481 insertions, 0 deletions
-rw-r--r--gctest/minitrace/minitrace.c481
diff --git a/gctest/minitrace/minitrace.c b/gctest/minitrace/minitrace.c
new file mode 100644
index 0000000..42c2634
--- /dev/null
+++ b/gctest/minitrace/minitrace.c
@@ -0,0 +1,481 @@
+// minitrace
+// Copyright 2014 by Henrik RydgÄrd
+// http://www.github.com/hrydgard/minitrace
+// Released under the MIT license.
+
+// See minitrace.h for basic documentation.
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef _WIN32
+#pragma warning (disable:4996)
+#define WIN32_LEAN_AND_MEAN
+#include <windows.h>
+#define __thread __declspec(thread)
+#define pthread_mutex_t CRITICAL_SECTION
+#define pthread_mutex_init(a, b) InitializeCriticalSection(a)
+#define pthread_mutex_lock(a) EnterCriticalSection(a)
+#define pthread_mutex_unlock(a) LeaveCriticalSection(a)
+#define pthread_mutex_destroy(a) DeleteCriticalSection(a)
+#else
+#include <signal.h>
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+#include "minitrace.h"
+
+#ifdef __GNUC__
+#define ATTR_NORETURN __attribute__((noreturn))
+#else
+#define ATTR_NORETURN
+#endif
+
+#define ARRAY_SIZE(x) sizeof(x)/sizeof(x[0])
+#define TRUE 1
+#define FALSE 0
+
+// Ugh, this struct is already pretty heavy.
+// Will probably need to move arguments to a second buffer to support more than one.
+typedef struct raw_event {
+ const char *name;
+ const char *cat;
+ void *id;
+ int64_t ts;
+ uint32_t pid;
+ uint32_t tid;
+ char ph;
+ mtr_arg_type arg_type;
+ const char *arg_name;
+ union {
+ const char *a_str;
+ int a_int;
+ double a_double;
+ };
+} raw_event_t;
+
+static raw_event_t *event_buffer;
+static raw_event_t *flush_buffer;
+static volatile int event_count;
+static int is_tracing = FALSE;
+static int is_flushing = FALSE;
+static int events_in_progress = 0;
+static int64_t time_offset;
+static int first_line = 1;
+static FILE *f;
+static __thread int cur_thread_id; // Thread local storage
+static int cur_process_id;
+static pthread_mutex_t mutex;
+static pthread_mutex_t event_mutex;
+
+#define STRING_POOL_SIZE 100
+static char *str_pool[100];
+
+// forward declaration
+void mtr_flush_with_state(int);
+
+// Tiny portability layer.
+// Exposes:
+// get_cur_thread_id()
+// get_cur_process_id()
+// mtr_time_s()
+// pthread basics
+#ifdef _WIN32
+static int get_cur_thread_id() {
+ return (int)GetCurrentThreadId();
+}
+static int get_cur_process_id() {
+ return (int)GetCurrentProcessId();
+}
+
+static uint64_t _frequency = 0;
+static uint64_t _starttime = 0;
+double mtr_time_s() {
+ if (_frequency == 0) {
+ QueryPerformanceFrequency((LARGE_INTEGER*)&_frequency);
+ QueryPerformanceCounter((LARGE_INTEGER*)&_starttime);
+ }
+ __int64 time;
+ QueryPerformanceCounter((LARGE_INTEGER*)&time);
+ return ((double) (time - _starttime) / (double) _frequency);
+}
+
+// Ctrl+C handling for Windows console apps
+static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType) {
+ if (is_tracing && fdwCtrlType == CTRL_C_EVENT) {
+ printf("Ctrl-C detected! Flushing trace and shutting down.\n\n");
+ mtr_flush();
+ mtr_shutdown();
+ }
+ ExitProcess(1);
+}
+
+void mtr_register_sigint_handler() {
+ // For console apps:
+ SetConsoleCtrlHandler(&CtrlHandler, TRUE);
+}
+
+#else
+
+static inline int get_cur_thread_id() {
+ return (int)(intptr_t)pthread_self();
+}
+static inline int get_cur_process_id() {
+ return (int)getpid();
+}
+
+#if defined(BLACKBERRY)
+double mtr_time_s() {
+ struct timespec time;
+ clock_gettime(CLOCK_MONOTONIC, &time); // Linux must use CLOCK_MONOTONIC_RAW due to time warps
+ return time.tv_sec + time.tv_nsec / 1.0e9;
+}
+#else
+double mtr_time_s() {
+ static time_t start;
+ struct timeval tv;
+ gettimeofday(&tv, NULL);
+ if (start == 0) {
+ start = tv.tv_sec;
+ }
+ tv.tv_sec -= start;
+ return (double)tv.tv_sec + (double)tv.tv_usec / 1000000.0;
+}
+#endif // !BLACKBERRY
+
+static void termination_handler(int signum) ATTR_NORETURN;
+static void termination_handler(int signum) {
+ (void) signum;
+ if (is_tracing) {
+ printf("Ctrl-C detected! Flushing trace and shutting down.\n\n");
+ mtr_flush();
+ fwrite("\n]}\n", 1, 4, f);
+ fclose(f);
+ }
+ exit(1);
+}
+
+void mtr_register_sigint_handler() {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ // Avoid altering set-to-be-ignored handlers while registering.
+ if (signal(SIGINT, &termination_handler) == SIG_IGN)
+ signal(SIGINT, SIG_IGN);
+}
+
+#endif
+
+void mtr_init_from_stream(void *stream) {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ event_buffer = (raw_event_t *)malloc(INTERNAL_MINITRACE_BUFFER_SIZE * sizeof(raw_event_t));
+ flush_buffer = (raw_event_t *)malloc(INTERNAL_MINITRACE_BUFFER_SIZE * sizeof(raw_event_t));
+ is_tracing = 1;
+ event_count = 0;
+ f = (FILE *)stream;
+ const char *header = "{\"traceEvents\":[\n";
+ fwrite(header, 1, strlen(header), f);
+ time_offset = (uint64_t)(mtr_time_s() * 1000000);
+ first_line = 1;
+ pthread_mutex_init(&mutex, 0);
+ pthread_mutex_init(&event_mutex, 0);
+}
+
+void mtr_init(const char *json_file) {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ mtr_init_from_stream(fopen(json_file, "wb"));
+}
+
+void mtr_shutdown() {
+ int i;
+#ifndef MTR_ENABLED
+ return;
+#endif
+ pthread_mutex_lock(&mutex);
+ is_tracing = FALSE;
+ pthread_mutex_unlock(&mutex);
+ mtr_flush_with_state(TRUE);
+
+ fwrite("\n]}\n", 1, 4, f);
+ fclose(f);
+ pthread_mutex_destroy(&mutex);
+ pthread_mutex_destroy(&event_mutex);
+ f = 0;
+ free(event_buffer);
+ event_buffer = 0;
+ for (i = 0; i < STRING_POOL_SIZE; i++) {
+ if (str_pool[i]) {
+ free(str_pool[i]);
+ str_pool[i] = 0;
+ }
+ }
+}
+
+const char *mtr_pool_string(const char *str) {
+ int i;
+ for (i = 0; i < STRING_POOL_SIZE; i++) {
+ if (!str_pool[i]) {
+ str_pool[i] = (char*)malloc(strlen(str) + 1);
+ strcpy(str_pool[i], str);
+ return str_pool[i];
+ } else {
+ if (!strcmp(str, str_pool[i]))
+ return str_pool[i];
+ }
+ }
+ return "string pool full";
+}
+
+void mtr_start() {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ pthread_mutex_lock(&mutex);
+ is_tracing = TRUE;
+ pthread_mutex_unlock(&mutex);
+}
+
+void mtr_stop() {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ pthread_mutex_lock(&mutex);
+ is_tracing = FALSE;
+ pthread_mutex_unlock(&mutex);
+}
+
+// TODO: fwrite more than one line at a time.
+// Flushing is thread safe and process async
+// using double-buffering mechanism.
+// Aware: only one flushing process may be
+// running at any point of time
+void mtr_flush_with_state(int is_last) {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ int i = 0;
+ char linebuf[1024];
+ char arg_buf[1024];
+ char id_buf[256];
+ int event_count_copy = 0;
+ int events_in_progress_copy = 1;
+ raw_event_t *event_buffer_tmp = NULL;
+
+ // small critical section to swap buffers
+ // - no any new events can be spawn while
+ // swapping since they tied to the same mutex
+ // - checks for any flushing in process
+ pthread_mutex_lock(&mutex);
+ // if not flushing already
+ if (is_flushing) {
+ pthread_mutex_unlock(&mutex);
+ return;
+ }
+ is_flushing = TRUE;
+ event_count_copy = event_count;
+ event_buffer_tmp = flush_buffer;
+ flush_buffer = event_buffer;
+ event_buffer = event_buffer_tmp;
+ event_count = 0;
+ // waiting for any unfinished events before swap
+ while (events_in_progress_copy != 0) {
+ pthread_mutex_lock(&event_mutex);
+ events_in_progress_copy = events_in_progress;
+ pthread_mutex_unlock(&event_mutex);
+ }
+ pthread_mutex_unlock(&mutex);
+
+ for (i = 0; i < event_count_copy; i++) {
+ raw_event_t *raw = &flush_buffer[i];
+ int len;
+ switch (raw->arg_type) {
+ case MTR_ARG_TYPE_INT:
+ snprintf(arg_buf, ARRAY_SIZE(arg_buf), "\"%s\":%i", raw->arg_name, raw->a_int);
+ break;
+ case MTR_ARG_TYPE_STRING_CONST:
+ snprintf(arg_buf, ARRAY_SIZE(arg_buf), "\"%s\":\"%s\"", raw->arg_name, raw->a_str);
+ break;
+ case MTR_ARG_TYPE_STRING_COPY:
+ if (strlen(raw->a_str) > 700) {
+ snprintf(arg_buf, ARRAY_SIZE(arg_buf), "\"%s\":\"%.*s\"", raw->arg_name, 700, raw->a_str);
+ } else {
+ snprintf(arg_buf, ARRAY_SIZE(arg_buf), "\"%s\":\"%s\"", raw->arg_name, raw->a_str);
+ }
+ break;
+ case MTR_ARG_TYPE_NONE:
+ arg_buf[0] = '\0';
+ break;
+ }
+ if (raw->id) {
+ switch (raw->ph) {
+ case 'S':
+ case 'T':
+ case 'F':
+ // TODO: Support full 64-bit pointers
+ snprintf(id_buf, ARRAY_SIZE(id_buf), ",\"id\":\"0x%08x\"", (uint32_t)(uintptr_t)raw->id);
+ break;
+ case 'X':
+ snprintf(id_buf, ARRAY_SIZE(id_buf), ",\"dur\":%i", (int)raw->a_double);
+ break;
+ }
+ } else {
+ id_buf[0] = 0;
+ }
+ const char *cat = raw->cat;
+#ifdef _WIN32
+ // On Windows, we often end up with backslashes in category.
+ char temp[256];
+ {
+ int len = (int)strlen(cat);
+ int i;
+ if (len > 255) len = 255;
+ for (i = 0; i < len; i++) {
+ temp[i] = cat[i] == '\\' ? '/' : cat[i];
+ }
+ temp[len] = 0;
+ cat = temp;
+ }
+#endif
+
+ len = snprintf(linebuf, ARRAY_SIZE(linebuf), "%s{\"cat\":\"%s\",\"pid\":%i,\"tid\":%i,\"ts\":%" PRId64 ",\"ph\":\"%c\",\"name\":\"%s\",\"args\":{%s}%s}",
+ first_line ? "" : ",\n",
+ cat, raw->pid, raw->tid, raw->ts - time_offset, raw->ph, raw->name, arg_buf, id_buf);
+ fwrite(linebuf, 1, len, f);
+ first_line = 0;
+
+ #ifdef MTR_COPY_EVENT_CATEGORY_AND_NAME
+ free(raw->name);
+ free(raw->cat);
+ #endif
+ }
+
+ pthread_mutex_lock(&mutex);
+ is_flushing = is_last;
+ pthread_mutex_unlock(&mutex);
+}
+
+void mtr_flush() {
+ mtr_flush_with_state(FALSE);
+}
+
+void internal_mtr_raw_event(const char *category, const char *name, char ph, void *id) {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ pthread_mutex_lock(&mutex);
+ if (!is_tracing || event_count >= INTERNAL_MINITRACE_BUFFER_SIZE) {
+ pthread_mutex_unlock(&mutex);
+ return;
+ }
+ raw_event_t *ev = &event_buffer[event_count];
+ ++event_count;
+ pthread_mutex_lock(&event_mutex);
+ ++events_in_progress;
+ pthread_mutex_unlock(&event_mutex);
+ pthread_mutex_unlock(&mutex);
+
+ double ts = mtr_time_s();
+ if (!cur_thread_id) {
+ cur_thread_id = get_cur_thread_id();
+ }
+ if (!cur_process_id) {
+ cur_process_id = get_cur_process_id();
+ }
+
+#ifdef MTR_COPY_EVENT_CATEGORY_AND_NAME
+ const size_t category_len = strlen(category);
+ ev->cat = malloc(category_len + 1);
+ strcpy(ev->cat, category);
+
+ const size_t name_len = strlen(name);
+ ev->name = malloc(name_len + 1);
+ strcpy(ev->name, name);
+
+#else
+ ev->cat = category;
+ ev->name = name;
+#endif
+
+ ev->id = id;
+ ev->ph = ph;
+ if (ev->ph == 'X') {
+ double x;
+ memcpy(&x, id, sizeof(double));
+ ev->ts = (int64_t)(x * 1000000);
+ ev->a_double = (ts - x) * 1000000;
+ } else {
+ ev->ts = (int64_t)(ts * 1000000);
+ }
+ ev->tid = cur_thread_id;
+ ev->pid = cur_process_id;
+ ev->arg_type = MTR_ARG_TYPE_NONE;
+
+ pthread_mutex_lock(&event_mutex);
+ --events_in_progress;
+ pthread_mutex_unlock(&event_mutex);
+}
+
+void internal_mtr_raw_event_arg(const char *category, const char *name, char ph, void *id, mtr_arg_type arg_type, const char *arg_name, void *arg_value) {
+#ifndef MTR_ENABLED
+ return;
+#endif
+ pthread_mutex_lock(&mutex);
+ if (!is_tracing || event_count >= INTERNAL_MINITRACE_BUFFER_SIZE) {
+ pthread_mutex_unlock(&mutex);
+ return;
+ }
+ raw_event_t *ev = &event_buffer[event_count];
+ ++event_count;
+ pthread_mutex_lock(&event_mutex);
+ ++events_in_progress;
+ pthread_mutex_unlock(&event_mutex);
+ pthread_mutex_unlock(&mutex);
+
+ if (!cur_thread_id) {
+ cur_thread_id = get_cur_thread_id();
+ }
+ if (!cur_process_id) {
+ cur_process_id = get_cur_process_id();
+ }
+ double ts = mtr_time_s();
+
+#ifdef MTR_COPY_EVENT_CATEGORY_AND_NAME
+ const size_t category_len = strlen(category);
+ ev->cat = malloc(category_len + 1);
+ strcpy(ev->cat, category);
+
+ const size_t name_len = strlen(name);
+ ev->name = malloc(name_len + 1);
+ strcpy(ev->name, name);
+
+#else
+ ev->cat = category;
+ ev->name = name;
+#endif
+
+ ev->id = id;
+ ev->ts = (int64_t)(ts * 1000000);
+ ev->ph = ph;
+ ev->tid = cur_thread_id;
+ ev->pid = cur_process_id;
+ ev->arg_type = arg_type;
+ ev->arg_name = arg_name;
+ switch (arg_type) {
+ case MTR_ARG_TYPE_INT: ev->a_int = (int)(uintptr_t)arg_value; break;
+ case MTR_ARG_TYPE_STRING_CONST: ev->a_str = (const char*)arg_value; break;
+ case MTR_ARG_TYPE_STRING_COPY: ev->a_str = strdup((const char*)arg_value); break;
+ case MTR_ARG_TYPE_NONE: break;
+ }
+
+ pthread_mutex_lock(&event_mutex);
+ --events_in_progress;
+ pthread_mutex_unlock(&event_mutex);
+}
+