AC_ARG_WITH(xammac, [ --with-xammac=yes,no If you want to build the Xamarin.Mac assemblies (defaults to no)], [], [with_xammac=no])
AC_ARG_WITH(mobile_static, [ --with-mobile_static=yes,no If you want to build the mobile_static assemblies (defaults to no)], [], [with_mobile_static=no])
-OPROFILE=no
-AC_ARG_WITH(oprofile,[ --with-oprofile=no,<oprofile install dir> Enable oprofile support (defaults to no)],[
- if test x$with_oprofile != xno; then
- oprofile_include=$with_oprofile/include
- if test ! -f $oprofile_include/opagent.h; then
- AC_MSG_ERROR([oprofile include file not found at $oprofile_include/opagent.h])
- fi
- OPROFILE=yes
- OPROFILE_CFLAGS="-I$oprofile_include"
- OPROFILE_LIBS="-L$with_oprofile/lib/oprofile -lopagent"
- AC_DEFINE(HAVE_OPROFILE,1,[Have oprofile support])
- fi
-])
-
MALLOC_MEMPOOLS=no
AC_ARG_WITH(malloc_mempools,[ --with-malloc-mempools=yes,no Use malloc for each single mempool allocation (only for runtime debugging, defaults to no)],[
if test x$with_malloc_mempools = xyes; then
## Maybe should also disable if mcsdir is invalid. Let's punt the issue for now.
AM_CONDITIONAL(BUILD_MCS, [test x$cross_compiling = xno && test x$enable_mcs_build != xno])
-AM_CONDITIONAL(HAVE_OPROFILE, test x$OPROFILE = xyes)
-AC_SUBST(OPROFILE_CFLAGS)
-AC_SUBST(OPROFILE_LIBS)
-
libmono_ldflags="$libmono_ldflags $LIBS"
AM_CONDITIONAL(INSTALL_4_x, [test "x$with_profile4_x" = xyes])
TLS: $with_tls
SIGALTSTACK: $with_sigaltstack
Engine: $jit_status
- oprofile: $OPROFILE
BigArrays: $enable_big_arrays
DTrace: $enable_dtrace
LLVM Back End: $enable_llvm (dynamically loaded: $enable_loadedllvm)
}
}
+ static byte[] PEM (string type, byte[] data)
+ {
+ string pem = Encoding.ASCII.GetString (data);
+ string header = String.Format ("-----BEGIN {0}-----", type);
+ string footer = String.Format ("-----END {0}-----", type);
+ int start = pem.IndexOf (header) + header.Length;
+ int end = pem.IndexOf (footer, start);
+ string base64 = pem.Substring (start, (end - start));
+ return Convert.FromBase64String (base64);
+ }
+
+ static byte[] ConvertData (byte[] data)
+ {
+ if (data == null || data.Length == 0)
+ return data;
+
+ // does it looks like PEM ?
+ if (data [0] != 0x30) {
+ try {
+ return PEM ("CERTIFICATE", data);
+ } catch {
+ // let the implementation take care of it.
+ }
+ }
+ return data;
+ }
+
#if !MONOTOUCH && !XAMMAC
public static X509CertificateImpl Import (byte[] rawData, string password, X509KeyStorageFlags keyStorageFlags)
{
+ rawData = ConvertData (rawData);
if (nativeHelper != null)
return nativeHelper.Import (rawData, password, keyStorageFlags);
WapiHandle_process *process_handle;
pid_t pid G_GNUC_UNUSED, ret;
int status;
- guint32 start;
- guint32 now;
+ gint64 start, now;
struct MonoProcess *mp;
/* FIXME: We can now easily wait on processes that aren't our own children,
finished = TRUE;
if (mono_thread_internal_current () != gc_thread) {
gboolean timed_out = FALSE;
- guint32 start_ticks = mono_msec_ticks ();
- guint32 end_ticks = start_ticks + 2000;
+ gint64 start_ticks = mono_msec_ticks ();
+ gint64 end_ticks = start_ticks + 2000;
mono_gc_finalize_notify ();
/* Finishing the finalizer thread, so wait a little bit... */
/* MS seems to wait for about 2 seconds */
while (!finalizer_thread_exited) {
- guint32 current_ticks = mono_msec_ticks ();
+ gint64 current_ticks = mono_msec_ticks ();
guint32 timeout;
if (current_ticks >= end_ticks)
ICALL(ENV_11, "get_MachineName", ves_icall_System_Environment_get_MachineName)
ICALL(ENV_13, "get_Platform", ves_icall_System_Environment_get_Platform)
ICALL(ENV_14, "get_ProcessorCount", mono_cpu_count)
-ICALL(ENV_15, "get_TickCount", mono_msec_ticks)
+ICALL(ENV_15, "get_TickCount", ves_icall_System_Environment_get_TickCount)
ICALL(ENV_16, "get_UserName", ves_icall_System_Environment_get_UserName)
ICALL(ENV_16m, "internalBroadcastSettingChange", ves_icall_System_Environment_BroadcastSettingChange)
ICALL(ENV_17, "internalGetEnvironmentVariable", ves_icall_System_Environment_GetEnvironmentVariable)
#endif
}
+ICALL_EXPORT
+gint32
+ves_icall_System_Environment_get_TickCount (void)
+{
+ /* this will overflow after ~24 days */
+ return (gint32) (mono_msec_boottime () & 0xffffffff);
+}
+
ICALL_EXPORT gint32
ves_icall_System_Runtime_Versioning_VersioningHelper_GetRuntimeId (void)
{
LockWord lw;
MonoThreadsSync *mon;
HANDLE sem;
- guint32 then = 0, now, delta;
+ gint64 then = 0, now, delta;
guint32 waitms;
guint32 ret;
guint32 new_status, old_status, tmp_status;
if (!mono_thread_test_state (mono_thread_internal_current (), (MonoThreadState)(ThreadState_StopRequested | ThreadState_SuspendRequested | ThreadState_AbortRequested))) {
if (ms != INFINITE) {
now = mono_msec_ticks ();
- if (now < then) {
- LOCK_DEBUG (g_message ("%s: wrapped around! now=0x%x then=0x%x", __func__, now, then));
- now += (0xffffffff - then);
- then = 0;
-
- LOCK_DEBUG (g_message ("%s: wrap rejig: now=0x%x then=0x%x delta=0x%x", __func__, now, then, now-then));
- }
+ /* it should not overflow before ~30k years */
+ g_assert (now >= then);
delta = now - then;
if (delta >= ms) {
MonoCoopMutex worker_creation_lock;
gint32 heuristic_completions;
- guint32 heuristic_sample_start;
- guint32 heuristic_last_dequeue; // ms
- guint32 heuristic_last_adjustment; // ms
- guint32 heuristic_adjustment_interval; // ms
+ gint64 heuristic_sample_start;
+ gint64 heuristic_last_dequeue; // ms
+ gint64 heuristic_last_adjustment; // ms
+ gint64 heuristic_adjustment_interval; // ms
ThreadPoolHillClimbing heuristic_hill_climbing;
MonoCoopMutex heuristic_lock;
static gboolean
monitor_sufficient_delay_since_last_dequeue (void)
{
- guint32 threshold;
+ gint64 threshold;
g_assert (threadpool);
mono_gc_set_skip_thread (TRUE);
do {
- guint32 ts;
+ gint64 ts;
gboolean alerted = FALSE;
if (mono_runtime_is_shutting_down ())
}
static gint16
-hill_climbing_update (gint16 current_thread_count, guint32 sample_duration, gint32 completions, guint32 *adjustment_interval)
+hill_climbing_update (gint16 current_thread_count, guint32 sample_duration, gint32 completions, gint64 *adjustment_interval)
{
ThreadPoolHillClimbing *hc;
ThreadPoolHeuristicStateTransition transition;
if (mono_coop_mutex_trylock (&threadpool->heuristic_lock) == 0) {
gint32 completions = InterlockedExchange (&threadpool->heuristic_completions, 0);
- guint32 sample_end = mono_msec_ticks ();
- guint32 sample_duration = sample_end - threadpool->heuristic_sample_start;
+ gint64 sample_end = mono_msec_ticks ();
+ gint64 sample_duration = sample_end - threadpool->heuristic_sample_start;
if (sample_duration >= threadpool->heuristic_adjustment_interval / 2) {
ThreadPoolCounter counter;
mono_threadpool_ms_remove_domain_jobs (MonoDomain *domain, int timeout)
{
gboolean res = TRUE;
- guint32 start;
+ gint64 end;
gpointer sem;
g_assert (domain);
g_assert (mono_domain_is_unloading (domain));
if (timeout != -1)
- start = mono_msec_ticks ();
+ end = mono_msec_ticks () + timeout;
#ifndef DISABLE_SOCKETS
mono_threadpool_ms_io_remove_domain_jobs (domain);
if (timeout != -1) {
- timeout -= mono_msec_ticks () - start;
- if (timeout < 0)
+ if (mono_msec_ticks () > end)
return FALSE;
}
#endif
mono_memory_write_barrier ();
while (domain->threadpool_jobs) {
- MONO_PREPARE_BLOCKING;
- WaitForSingleObject (sem, timeout);
- MONO_FINISH_BLOCKING;
+ gint64 now;
+
if (timeout != -1) {
- timeout -= mono_msec_ticks () - start;
- if (timeout <= 0) {
+ now = mono_msec_ticks ();
+ if (now > end) {
res = FALSE;
break;
}
}
+
+ MONO_PREPARE_BLOCKING;
+ WaitForSingleObject (sem, timeout != -1 ? end - now : timeout);
+ MONO_FINISH_BLOCKING;
}
domain->cleanup_semaphore = NULL;
#endif
abort_appdomain_data user_data;
- guint32 start_time;
+ gint64 start_time;
int orig_timeout = timeout;
int i;
int total = 0;
int fd = conn_fd;
int flags = 0;
- static gint32 last_keepalive;
- gint32 msecs;
+ static gint64 last_keepalive;
+ gint64 msecs;
MONO_PREPARE_BLOCKING;
endif
AM_CPPFLAGS = \
- -fexceptions -DMONO_USE_EXC_TABLES \
-DSUPPRESSION_DIR=\""$(datadir)/mono-$(API_VER)/mono/profiler"\" \
-I$(top_srcdir) \
$(GLIB_CFLAGS)
if !DISABLE_PROFILER
bin_PROGRAMS = mprof-report
+if !BITCODE
+prof_shlibs = \
+ libmono-profiler-aot.la \
+ libmono-profiler-iomap.la \
+ libmono-profiler-log.la
+endif
+
if HAVE_VTUNE
-vtune_lib = libmono-profiler-vtune.la
+vtune_stlibs = libmono-profiler-vtune-static.la
+if !BITCODE
+vtune_shlibs = libmono-profiler-vtune.la
+endif
endif
-lib_LTLIBRARIES = libmono-profiler-aot.la libmono-profiler-iomap.la libmono-profiler-log.la libmono-profiler-log-static.la $(vtune_lib)
+lib_LTLIBRARIES = \
+ $(prof_shlibs) \
+ libmono-profiler-aot-static.la \
+ libmono-profiler-iomap-static.la \
+ libmono-profiler-log-static.la \
+ $(vtune_shlibs) \
+ $(vtune_stlibs)
if PLATFORM_DARWIN
-if BITCODE
-libmono_profiler_log_la_LDFLAGS = -no-undefined
-else
-libmono_profiler_log_la_LDFLAGS = -Wl,-undefined -Wl,suppress -Wl,-flat_namespace
-endif
-endif
-if PLATFORM_ANDROID
-libmono_profiler_log_la_LDFLAGS = -avoid-version
-endif
-endif
-endif
+prof_ldflags = -Wl,-undefined -Wl,suppress -Wl,-flat_namespace
endif
-if HAVE_OPROFILE
-# Do something that uses OPROFILE_CFLAGS and OPROFILE_LIBS
+if PLATFORM_ANDROID
+prof_ldflags = -avoid-version
endif
-if SUPPORT_BOEHM
-if DISABLE_EXECUTABLES
-LIBMONO=$(top_builddir)/mono/mini/$(LIBMONO_LA)
-else
-if !SHARED_MONO
-static_libs= \
- $(top_builddir)/mono/metadata/libmonoruntime-static.la \
- $(top_builddir)/mono/io-layer/libwapi.la \
- $(top_builddir)/mono/utils/libmonoutils.la \
- $(GLIB_LIBS) $(LIBICONV) \
- $(LIBGC_STATIC_LIBS)
-
-LIBMONO=$(top_builddir)/mono/mini/$(LIBMONO_LA) $(static_libs)
-else
-LIBMONO=$(top_builddir)/mono/mini/$(LIBMONO_LA)
endif
endif
-else
-LIBMONO=$(top_builddir)/mono/mini/libmonosgen-$(API_VER).la
endif
+# The log profiler uses eglib functions, so it needs to be linked against
+# libeglib in shared mode, but not in static mode, since that would
+# leads to duplicate symbols when it is linked into an app which
+# also uses eglib (e.g. the runtime). Automake doesn't support this
+# functionality, so create a separate static version of the library.
+
libmono_profiler_aot_la_SOURCES = mono-profiler-aot.c
libmono_profiler_aot_la_LIBADD = $(GLIB_LIBS) $(LIBICONV)
-if BITCODE
-libmono_profiler_aot_la_LDFLAGS = -no-undefined
-endif
+libmono_profiler_aot_la_LDFLAGS = $(prof_ldflags)
+libmono_profiler_aot_static_la_SOURCES = mono-profiler-aot.c
+libmono_profiler_aot_static_la_LDFLAGS = -static
+
libmono_profiler_iomap_la_SOURCES = mono-profiler-iomap.c
libmono_profiler_iomap_la_LIBADD = $(GLIB_LIBS) $(LIBICONV)
-if BITCODE
-libmono_profiler_iomap_la_LDFLAGS = -no-undefined
-endif
+libmono_profiler_iomap_la_LDFLAGS = $(prof_ldflags)
+libmono_profiler_iomap_static_la_SOURCES = mono-profiler-iomap.c
+libmono_profiler_iomap_static_la_LDFLAGS = -static
+
libmono_profiler_log_la_SOURCES = proflog.c
libmono_profiler_log_la_LIBADD = $(GLIB_LIBS) $(Z_LIBS)
+libmono_profiler_log_la_LDFLAGS = $(prof_ldflags)
+libmono_profiler_log_static_la_SOURCES = proflog.c
+libmono_profiler_log_static_la_LDFLAGS = -static
+
if HAVE_VTUNE
libmono_profiler_vtune_la_SOURCES = mono-profiler-vtune.c
libmono_profiler_vtune_la_CFLAGS = $(VTUNE_CFLAGS)
libmono_profiler_vtune_la_LIBADD = $(VTUNE_LIBS) $(GLIB_LIBS) $(LIBICONV)
+libmono_profiler_vtune_la_LDFLAGS = $(prof_ldflags)
+libmono_profiler_vtune_static_la_SOURCES = mono-profiler-vtune.c
+libmono_profiler_vtune_static_la_LDFLAGS = -static
endif
-# The log profile uses eglib functions, so it needs to be linked against
-# libeglib in shared mode, but not in static mode, since that would
-# leads to duplicate symbols when it is linked into an app which
-# also uses eglib (e.g. the runtime). Automake doesn't support this
-# functionality, so create a separate static version of the library.
-libmono_profiler_log_static_la_SOURCES = proflog.c
-libmono_profiler_log_static_la_LDFLAGS = -static
-
mprof_report_SOURCES = decode.c
mprof_report_LDADD = $(Z_LIBS) $(GLIB_LIBS) $(LIBICONV)
if (*start_time == 0) {
static guint64 boot_time = 0;
if (!boot_time)
- boot_time = mono_100ns_datetime () - ((guint64)mono_msec_ticks ()) * 10000;
+ boot_time = mono_100ns_datetime () - mono_msec_boottime () * 10000;
*start_time = boot_time + mono_process_get_data (pid, MONO_PROCESS_ELAPSED);
}
#include <utils/mono-time.h>
-#define MTICKS_PER_SEC 10000000
+#define MTICKS_PER_SEC (10 * 1000 * 1000)
+
+gint64
+mono_msec_ticks (void)
+{
+ return mono_100ns_ticks () / 10 / 1000;
+}
#ifdef HOST_WIN32
#include <windows.h>
-guint32
-mono_msec_ticks (void)
+#ifndef _MSC_VER
+/* we get "error: implicit declaration of function 'GetTickCount64'" */
+WINBASEAPI ULONGLONG WINAPI GetTickCount64(void);
+#endif
+
+gint64
+mono_msec_boottime (void)
{
/* GetTickCount () is reportedly monotonic */
- return GetTickCount ();
+ return GetTickCount64 ();
}
/* Returns the number of 100ns ticks from unspecified time: this should be monotonic */
if (uptime) {
double upt;
if (fscanf (uptime, "%lf", &upt) == 1) {
- gint64 now = mono_100ns_ticks ();
+ gint64 now = mono_100ns_datetime ();
fclose (uptime);
return now - (gint64)(upt * MTICKS_PER_SEC);
}
}
/* Returns the number of milliseconds from boot time: this should be monotonic */
-guint32
-mono_msec_ticks (void)
+gint64
+mono_msec_boottime (void)
{
static gint64 boot_time = 0;
gint64 now;
if (!boot_time)
boot_time = get_boot_time ();
- now = mono_100ns_ticks ();
+ now = mono_100ns_datetime ();
/*printf ("now: %llu (boot: %llu) ticks: %llu\n", (gint64)now, (gint64)boot_time, (gint64)(now - boot_time));*/
return (now - boot_time)/10000;
}
#include <sys/time.h>
#endif
-/* Returns the number of milliseconds from boot time: this should be monotonic */
-guint32 mono_msec_ticks (void);
+/* Returns the number of milliseconds from boot time: this should be monotonic
+ *
+ * Prefer to use mono_msec_ticks for elapsed time calculation. */
+gint64 mono_msec_boottime (void);
+
+/* Returns the number of milliseconds ticks from unspecified time: this should be monotonic */
+gint64 mono_msec_ticks (void);
/* Returns the number of 100ns ticks from unspecified time: this should be monotonic */
-gint64 mono_100ns_ticks (void);
+gint64 mono_100ns_ticks (void);
/* Returns the number of 100ns ticks since 1/1/1601, UTC timezone */
-gint64 mono_100ns_datetime (void);
+gint64 mono_100ns_datetime (void);
#ifndef HOST_WIN32
gint64 mono_100ns_datetime_from_timeval (struct timeval tv);
/* No GC support. */
/* #undef HAVE_NULL_GC */
-/* Have oprofile support */
-/* #undef HAVE_OPROFILE */
-
/* Define to 1 if you have the `poll' function. */
/* #undef HAVE_POLL */
projects / mono.git / commitdiff