+/*
+ * utils.c: log profiler and reporter utils
+ *
+ * We have here the minimal needed portability functions: we can't depend
+ * on the ones provided by the runtime, since they are internal and,
+ * especially mprof-report is an external program.
+ * Note also that we don't take a glib/eglib dependency here for mostly
+ * the same reason (but also because we need tight control in the profiler
+ * over memory allocation, which needs to work with the world stopped).
+ *
+ * Author:
+ * Paolo Molaro (lupus@ximian.com)
+ *
+ * Copyright 2010 Novell, Inc (http://www.novell.com)
+ * Licensed under the MIT license. See LICENSE file in the project root for full license information.
+ */
+#include "utils.h"
#include <stdlib.h>
-#include <inttypes.h>
#include <time.h>
-#include <pthread.h>
#include <stdio.h>
#include <string.h>
+#include <unistd.h>
+#ifdef HOST_WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
#include <sched.h>
+#endif
-#include "utils.h"
-//#ifdef HAVE_SYS_TIME_H
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
-//#endif
-//#if HAVE_SYS_MMAN_H
+#endif
+#if HAVE_SYS_MMAN_H
#include <sys/mman.h>
-//#endif
+#endif
#if defined(__APPLE__)
#include <mach/mach_time.h>
static mach_timebase_info_data_t timebase_info;
#endif
-#ifndef MAP_ANON
+#ifndef MAP_ANONYMOUS
#define MAP_ANONYMOUS MAP_ANON
#endif
#define TICKS_PER_SEC 1000000000LL
+#if (defined(TARGET_X86) || defined(TARGET_AMD64)) && defined(__linux__) && defined(HAVE_SCHED_GETCPU)
+#define HAVE_RDTSC 1
+#endif
+
typedef struct {
unsigned int timer_count;
int last_cpu;
uint64_t last_time;
} TlsData;
-#if HAVE_KW_THREAD
+#ifdef HOST_WIN32
+static int tls_data;
+#define DECL_TLS_DATA TlsData *tls; tls = (TlsData *) TlsGetValue (tls_data); if (tls == NULL) { tls = (TlsData *) calloc (sizeof (TlsData), 1); TlsSetValue (tls_data, tls); }
+#define TLS_INIT(x) x = TlsAlloc()
+#elif HAVE_KW_THREAD
static __thread TlsData tls_data;
#define DECL_TLS_DATA TlsData *tls = &tls_data
#define TLS_INIT(x)
#else
static pthread_key_t tls_data;
-#define DECL_TLS_DATA TlsData *tls; tls = (TlsData *) pthread_getspecific (tls_data); if (tls == NULL) { tls = (TlsData *) malloc (sizeof (TlsData)); pthread_setspecific (tls_data, tls); }
+#define DECL_TLS_DATA TlsData *tls; tls = (TlsData *) pthread_getspecific (tls_data); if (tls == NULL) { tls = (TlsData *) calloc (sizeof (TlsData), 1); pthread_setspecific (tls_data, tls); }
#define TLS_INIT(x) pthread_key_create(&x, NULL)
#endif
+#ifdef HOST_WIN32
+static CRITICAL_SECTION log_lock;
+static LARGE_INTEGER pcounter_freq;
+#else
static pthread_mutex_t log_lock = PTHREAD_MUTEX_INITIALIZER;
+#endif
+static int timer_overhead = 0;
static uint64_t time_inc = 0;
typedef uint64_t (*TimeFunc)(void);
#if defined(__APPLE__)
uint64_t time = mach_absolute_time ();
- time *= info.numer;
- time /= info.denom;
+ time *= timebase_info.numer;
+ time /= timebase_info.denom;
return time;
-#else
+#elif defined(HOST_WIN32)
+ LARGE_INTEGER value;
+ QueryPerformanceCounter (&value);
+ return value.QuadPart * TICKS_PER_SEC / pcounter_freq.QuadPart;
+#elif defined(CLOCK_MONOTONIC)
struct timespec tspec;
clock_gettime (CLOCK_MONOTONIC, &tspec);
return ((uint64_t)tspec.tv_sec * TICKS_PER_SEC + tspec.tv_nsec);
+#else
+ struct timeval tv;
+ gettimeofday (&tv, NULL);
+ return ((uint64_t)tv.tv_sec * TICKS_PER_SEC + tv.tv_usec * 1000);
#endif
}
return tls->last_time;
}
+#if HAVE_RDTSC
+
#define rdtsc(low,high) \
__asm__ __volatile__("rdtsc" : "=a" (low), "=d" (high))
-#if !defined(__APPLE__)
static uint64_t
safe_rdtsc (int *cpu)
{
int have_flag = 0;
float val;
FILE *cpuinfo;
+ int cpu = sched_getcpu ();
+
+ if (cpu < 0)
+ return 0;
if (!(cpuinfo = fopen ("/proc/cpuinfo", "r")))
return 0;
tls->last_rdtsc = safe_rdtsc (&tls->last_cpu);
return tls->last_time;
}
+#else
+#define have_rdtsc() 0
+#define rdtsc_current_time fast_current_time
#endif
static uint64_t
void
utils_init (int fast_time)
{
+ int i;
+ uint64_t time_start, time_end;
TLS_INIT (tls_data);
+#ifdef HOST_WIN32
+ InitializeCriticalSection (&log_lock);
+ QueryPerformanceFrequency (&pcounter_freq);
+#endif
+#if defined (__APPLE__)
+ mach_timebase_info (&timebase_info);
+#endif
if (fast_time > 1) {
time_func = null_time;
} else if (fast_time) {
-#if defined (__APPLE__)
- mach_timebase_info (&timebase_info);
- time_func = fast_current_time;
-#else
uint64_t timea;
uint64_t timeb;
- int cpu = sched_getcpu ();
clock_time ();
timea = clock_time ();
timeb = clock_time ();
time_inc = (timeb - timea) / TIME_ADJ;
/*printf ("time inc: %llu, timea: %llu, timeb: %llu, diff: %llu\n", time_inc, timea, timeb, timec-timeb);*/
- if (cpu != -1 && have_rdtsc ())
+ if (have_rdtsc ())
time_func = rdtsc_current_time;
else
time_func = fast_current_time;
-#endif
} else {
time_func = clock_time;
}
+ time_start = time_func ();
+ for (i = 0; i < 256; ++i)
+ time_func ();
+ time_end = time_func ();
+ timer_overhead = (time_end - time_start) / 256;
+}
+
+int
+get_timer_overhead (void)
+{
+ return timer_overhead;
}
uint64_t
alloc_buffer (int size)
{
void *ptr;
+#ifdef HOST_WIN32
+ ptr = VirtualAlloc (NULL, size, MEM_COMMIT, PAGE_READWRITE);
+ return ptr;
+#else
ptr = mmap (NULL, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
- if (ptr == (void*)-1)
+ if (ptr == MAP_FAILED)
return NULL;
return ptr;
+#endif
}
void
free_buffer (void *buf, int size)
{
+#ifdef HOST_WIN32
+ VirtualFree (buf, 0, MEM_RELEASE);
+#else
munmap (buf, size);
+#endif
}
void
take_lock (void)
{
+#ifdef HOST_WIN32
+ EnterCriticalSection (&log_lock);
+#else
pthread_mutex_lock (&log_lock);
+#endif
}
void
release_lock (void)
{
+#ifdef HOST_WIN32
+ LeaveCriticalSection (&log_lock);
+#else
pthread_mutex_unlock (&log_lock);
+#endif
}
void
uintptr_t
thread_id (void)
{
+#ifdef HOST_WIN32
+ return (uintptr_t)GetCurrentThreadId ();
+#else
return (uintptr_t)pthread_self ();
+#endif
+}
+
+uintptr_t
+process_id (void)
+{
+#ifdef HOST_WIN32
+ return 0; /* FIXME */
+#else
+ return (uintptr_t)getpid ();
+#endif
}
projects / mono.git / blobdiff