| /* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 4 -*- */ |
| /* This Source Code Form is subject to the terms of the Mozilla Public |
| * License, v. 2.0. If a copy of the MPL was not distributed with this |
| * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ |
| |
| #include "VMPI.h" |
| |
| // Note, this is not supported in configurations with more than one AvmCore running |
| // in the same process. |
| |
| #ifdef WIN32 |
| #include "windows.h" |
| #else |
| #define __cdecl |
| #include <stdarg.h> |
| #include <string.h> |
| #endif |
| |
| #include "vprof.h" |
| |
| #ifndef MIN |
| #define MIN(x,y) ((x) <= (y) ? x : y) |
| #endif |
| #ifndef MAX |
| #define MAX(x,y) ((x) >= (y) ? x : y) |
| #endif |
| |
| #ifndef MAXINT |
| #define MAXINT int(unsigned(-1)>>1) |
| #endif |
| |
| #ifndef MAXINT64 |
| #define MAXINT64 int64_t(uint64_t(-1)>>1) |
| #endif |
| |
| #ifndef __STDC_WANT_SECURE_LIB__ |
| #define sprintf_s(b,size,fmt,...) sprintf((b),(fmt),__VA_ARGS__) |
| #endif |
| |
| #if THREADED |
| #define DO_LOCK(lock) Lock(lock); { |
| #define DO_UNLOCK(lock) }; Unlock(lock) |
| #else |
| #define DO_LOCK(lock) { (void)(lock); |
| #define DO_UNLOCK(lock) } |
| #endif |
| |
| #if THREAD_SAFE |
| #define LOCK(lock) DO_LOCK(lock) |
| #define UNLOCK(lock) DO_UNLOCK(lock) |
| #else |
| #define LOCK(lock) { (void)(lock); |
| #define UNLOCK(lock) } |
| #endif |
| |
| static entry* entries = NULL; |
| static bool notInitialized = true; |
| static long glock = LOCK_IS_FREE; |
| |
| #define Lock(lock) while (_InterlockedCompareExchange(lock, LOCK_IS_TAKEN, LOCK_IS_FREE) == LOCK_IS_TAKEN){}; |
| #define Unlock(lock) _InterlockedCompareExchange(lock, LOCK_IS_FREE, LOCK_IS_TAKEN); |
| |
| #if defined(WIN32) |
| static void vprof_printf(const char* format, ...) |
| { |
| va_list args; |
| va_start(args, format); |
| |
| char buf[1024]; |
| vsnprintf(buf, sizeof(buf), format, args); |
| |
| va_end(args); |
| |
| printf(buf); |
| ::OutputDebugStringA(buf); |
| } |
| #else |
| #define vprof_printf printf |
| #endif |
| |
| inline static entry* reverse (entry* s) |
| { |
| entry_t e, n, p; |
| |
| p = NULL; |
| for (e = s; e; e = n) { |
| n = e->next; |
| e->next = p; |
| p = e; |
| } |
| |
| return p; |
| } |
| |
| static char* f (double d) |
| { |
| static char s[80]; |
| char* p; |
| sprintf_s (s, sizeof(s), "%lf", d); |
| p = s+VMPI_strlen(s)-1; |
| while (*p == '0') { |
| *p = '\0'; |
| p--; |
| if (p == s) break; |
| } |
| if (*p == '.') *p = '\0'; |
| return s; |
| } |
| |
| static void dumpProfile (void) |
| { |
| entry_t e; |
| |
| entries = reverse(entries); |
| vprof_printf ("event avg [min : max] total count\n"); |
| for (e = entries; e; e = e->next) { |
| if (e->count == 0) continue; // ignore entries with zero count. |
| vprof_printf ("%s", e->file); |
| if (e->line >= 0) { |
| vprof_printf (":%d", e->line); |
| } |
| vprof_printf (" %s [%lld : %lld] %lld %lld ", |
| f(((double)e->sum)/((double)e->count)), (long long int)e->min, (long long int)e->max, (long long int)e->sum, (long long int)e->count); |
| if (e->h) { |
| int j = MAXINT; |
| for (j = 0; j < e->h->nbins; j ++) { |
| vprof_printf ("(%lld < %lld) ", (long long int)e->h->count[j], (long long int)e->h->lb[j]); |
| } |
| vprof_printf ("(%lld >= %lld) ", (long long int)e->h->count[e->h->nbins], (long long int)e->h->lb[e->h->nbins-1]); |
| } |
| if (e->func) { |
| int j; |
| for (j = 0; j < NUM_EVARS; j++) { |
| if (e->ivar[j] != 0) { |
| vprof_printf ("IVAR%d %d ", j, e->ivar[j]); |
| } |
| } |
| for (j = 0; j < NUM_EVARS; j++) { |
| if (e->i64var[j] != 0) { |
| vprof_printf ("I64VAR%d %lld ", j, (long long int)e->i64var[j]); |
| } |
| } |
| for (j = 0; j < NUM_EVARS; j++) { |
| if (e->dvar[j] != 0) { |
| vprof_printf ("DVAR%d %lf ", j, e->dvar[j]); |
| } |
| } |
| } |
| vprof_printf ("\n"); |
| } |
| entries = reverse(entries); |
| } |
| |
| inline static entry_t findEntry (char* file, int line) |
| { |
| for (entry_t e = entries; e; e = e->next) { |
| if ((e->line == line) && (VMPI_strcmp (e->file, file) == 0)) { |
| return e; |
| } |
| } |
| return NULL; |
| } |
| |
| // Initialize the location pointed to by 'id' to a new value profile entry |
| // associated with 'file' and 'line', or do nothing if already initialized. |
| // An optional final argument provides a user-defined probe function. |
| |
| int initValueProfile(void** id, char* file, int line, ...) |
| { |
| DO_LOCK (&glock); |
| entry_t e = (entry_t) *id; |
| if (notInitialized) { |
| atexit (dumpProfile); |
| notInitialized = false; |
| } |
| |
| if (e == NULL) { |
| e = findEntry (file, line); |
| if (e) { |
| *id = e; |
| } |
| } |
| |
| if (e == NULL) { |
| va_list va; |
| e = (entry_t) malloc (sizeof(entry)); |
| e->lock = LOCK_IS_FREE; |
| e->file = file; |
| e->line = line; |
| e->value = 0; |
| e->sum = 0; |
| e->count = 0; |
| e->min = 0; |
| e->max = 0; |
| // optional probe function argument |
| va_start (va, line); |
| e->func = (void (__cdecl*)(void*)) va_arg (va, void*); |
| va_end (va); |
| e->h = NULL; |
| e->genptr = NULL; |
| VMPI_memset (&e->ivar, 0, sizeof(e->ivar)); |
| VMPI_memset (&e->i64var, 0, sizeof(e->i64var)); |
| VMPI_memset (&e->dvar, 0, sizeof(e->dvar)); |
| e->next = entries; |
| entries = e; |
| *id = e; |
| } |
| DO_UNLOCK (&glock); |
| |
| return 0; |
| } |
| |
| // Record a value profile event. |
| |
| int profileValue(void* id, int64_t value) |
| { |
| entry_t e = (entry_t) id; |
| long* lock = &(e->lock); |
| LOCK (lock); |
| e->value = value; |
| if (e->count == 0) { |
| e->sum = value; |
| e->count = 1; |
| e->min = value; |
| e->max = value; |
| } else { |
| e->sum += value; |
| e->count ++; |
| e->min = MIN (e->min, value); |
| e->max = MAX (e->max, value); |
| } |
| if (e->func) e->func (e); |
| UNLOCK (lock); |
| |
| return 0; |
| } |
| |
| // Initialize the location pointed to by 'id' to a new histogram profile entry |
| // associated with 'file' and 'line', or do nothing if already initialized. |
| |
| int initHistProfile(void** id, char* file, int line, int nbins, ...) |
| { |
| DO_LOCK (&glock); |
| entry_t e = (entry_t) *id; |
| if (notInitialized) { |
| atexit (dumpProfile); |
| notInitialized = false; |
| } |
| |
| if (e == NULL) { |
| e = findEntry (file, line); |
| if (e) { |
| *id = e; |
| } |
| } |
| |
| if (e == NULL) { |
| va_list va; |
| hist_t h; |
| int b, n, s; |
| int64_t* lb; |
| |
| e = (entry_t) malloc (sizeof(entry)); |
| e->lock = LOCK_IS_FREE; |
| e->file = file; |
| e->line = line; |
| e->value = 0; |
| e->sum = 0; |
| e->count = 0; |
| e->min = 0; |
| e->max = 0; |
| e->func = NULL; |
| e->h = h = (hist_t) malloc (sizeof(hist)); |
| n = 1+MAX(nbins,0); |
| h->nbins = n-1; |
| s = n*sizeof(int64_t); |
| lb = (int64_t*) malloc (s); |
| h->lb = lb; |
| VMPI_memset (h->lb, 0, s); |
| h->count = (int64_t*) malloc (s); |
| VMPI_memset (h->count, 0, s); |
| |
| va_start (va, nbins); |
| for (b = 0; b < nbins; b++) { |
| //lb[b] = va_arg (va, int64_t); |
| lb[b] = va_arg (va, int); |
| } |
| lb[b] = MAXINT64; |
| va_end (va); |
| |
| e->genptr = NULL; |
| VMPI_memset (&e->ivar, 0, sizeof(e->ivar)); |
| VMPI_memset (&e->i64var, 0, sizeof(e->i64var)); |
| VMPI_memset (&e->dvar, 0, sizeof(e->dvar)); |
| e->next = entries; |
| entries = e; |
| *id = e; |
| } |
| DO_UNLOCK (&glock); |
| |
| return 0; |
| } |
| |
| // Record a histogram profile event. |
| |
| int histValue(void* id, int64_t value) |
| { |
| entry_t e = (entry_t) id; |
| long* lock = &(e->lock); |
| hist_t h = e->h; |
| int nbins = h->nbins; |
| int64_t* lb = h->lb; |
| int b; |
| |
| LOCK (lock); |
| e->value = value; |
| if (e->count == 0) { |
| e->sum = value; |
| e->count = 1; |
| e->min = value; |
| e->max = value; |
| } else { |
| e->sum += value; |
| e->count ++; |
| e->min = MIN (e->min, value); |
| e->max = MAX (e->max, value); |
| } |
| for (b = 0; b < nbins; b ++) { |
| if (value < lb[b]) break; |
| } |
| h->count[b] ++; |
| UNLOCK (lock); |
| |
| return 0; |
| } |
| |
| #if defined(_MSC_VER) && defined(_M_IX86) |
| uint64_t readTimestampCounter() |
| { |
| // read the cpu cycle counter. 1 tick = 1 cycle on IA32 |
| _asm rdtsc; |
| } |
| #elif defined(__GNUC__) && (__i386__ || __x86_64__) |
| uint64_t readTimestampCounter() |
| { |
| uint32_t lo, hi; |
| __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi)); |
| return (uint64_t(hi) << 32) | lo; |
| } |
| #else |
| // add stub for platforms without it, so fat builds don't fail |
| uint64_t readTimestampCounter() { return 0; } |
| #endif |
| |
