X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=mono%2Fmetadata%2Fsgen-protocol.c;h=c41df40339f927a4f140231ec7317e9f020a468c;hb=01bc03ffde6db4fd421f455dd37a083679ccbaa8;hp=270d86842c5f661e5a982f5704e511f0b3da2033;hpb=0aedc3f6fb2194817c766659c50a7e7f4786672e;p=mono.git diff --git a/mono/metadata/sgen-protocol.c b/mono/metadata/sgen-protocol.c index 270d86842c5..c41df40339f 100644 --- a/mono/metadata/sgen-protocol.c +++ b/mono/metadata/sgen-protocol.c @@ -1,47 +1,52 @@ /* + * sgen-protocol.c: Binary protocol of internal activity, to aid + * debugging. + * * Copyright 2001-2003 Ximian, Inc * Copyright 2003-2010 Novell, Inc. - * - * Permission is hereby granted, free of charge, to any person obtaining - * a copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sublicense, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * Copyright (C) 2012 Xamarin Inc + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License 2.0 as published by the Free Software Foundation; + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License 2.0 along with this library; if not, write to the Free + * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +#ifdef HAVE_SGEN_GC + #include "config.h" +#include "sgen-gc.h" #include "sgen-protocol.h" +#include "sgen-memory-governor.h" +#include "utils/mono-mmap.h" +#include "utils/mono-threads.h" #ifdef SGEN_BINARY_PROTOCOL /* If not null, dump binary protocol to this file */ static FILE *binary_protocol_file = NULL; -static int binary_protocol_use_count = 0; +/* We set this to -1 to indicate an exclusive lock */ +static volatile int binary_protocol_use_count = 0; #define BINARY_PROTOCOL_BUFFER_SIZE (65536 - 2 * 8) typedef struct _BinaryProtocolBuffer BinaryProtocolBuffer; struct _BinaryProtocolBuffer { - BinaryProtocolBuffer *next; - int index; + BinaryProtocolBuffer * volatile next; + volatile int index; unsigned char buffer [BINARY_PROTOCOL_BUFFER_SIZE]; }; -static BinaryProtocolBuffer *binary_protocol_buffers = NULL; +static BinaryProtocolBuffer * volatile binary_protocol_buffers = NULL; void binary_protocol_init (const char *filename) @@ -55,32 +60,92 @@ binary_protocol_is_enabled (void) return binary_protocol_file != NULL; } +static gboolean +try_lock_exclusive (void) +{ + do { + if (binary_protocol_use_count) + return FALSE; + } while (InterlockedCompareExchange (&binary_protocol_use_count, -1, 0) != 0); + mono_memory_barrier (); + return TRUE; +} + static void -binary_protocol_flush_buffers_rec (BinaryProtocolBuffer *buffer) +unlock_exclusive (void) { - if (!buffer) - return; + mono_memory_barrier (); + SGEN_ASSERT (0, binary_protocol_use_count == -1, "Exclusively locked count must be -1"); + if (InterlockedCompareExchange (&binary_protocol_use_count, 0, -1) != -1) + SGEN_ASSERT (0, FALSE, "Somebody messed with the exclusive lock"); +} + +static void +lock_recursive (void) +{ + int old_count; + do { + retry: + old_count = binary_protocol_use_count; + if (old_count < 0) { + /* Exclusively locked - retry */ + /* FIXME: short back-off */ + goto retry; + } + } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count + 1, old_count) != old_count); + mono_memory_barrier (); +} - binary_protocol_flush_buffers_rec (buffer->next); +static void +unlock_recursive (void) +{ + int old_count; + mono_memory_barrier (); + do { + old_count = binary_protocol_use_count; + SGEN_ASSERT (0, old_count > 0, "Locked use count must be at least 1"); + } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count - 1, old_count) != old_count); +} +static void +binary_protocol_flush_buffer (BinaryProtocolBuffer *buffer) +{ g_assert (buffer->index > 0); fwrite (buffer->buffer, 1, buffer->index, binary_protocol_file); - mono_sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer)); + sgen_free_os_memory (buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL); } void binary_protocol_flush_buffers (gboolean force) { + int num_buffers = 0, i; + BinaryProtocolBuffer *buf; + BinaryProtocolBuffer **bufs; + if (!binary_protocol_file) return; - if (!force && binary_protocol_use_count != 0) + if (!force && !try_lock_exclusive ()) return; - binary_protocol_flush_buffers_rec (binary_protocol_buffers); + for (buf = binary_protocol_buffers; buf != NULL; buf = buf->next) + ++num_buffers; + bufs = sgen_alloc_internal_dynamic (num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL, TRUE); + for (buf = binary_protocol_buffers, i = 0; buf != NULL; buf = buf->next, i++) + bufs [i] = buf; + SGEN_ASSERT (0, i == num_buffers, "Binary protocol buffer count error"); + binary_protocol_buffers = NULL; + for (i = num_buffers - 1; i >= 0; --i) + binary_protocol_flush_buffer (bufs [i]); + + sgen_free_internal_dynamic (buf, num_buffers * sizeof (BinaryProtocolBuffer*), INTERNAL_MEM_BINARY_PROTOCOL); + + if (!force) + unlock_exclusive (); + fflush (binary_protocol_file); } @@ -94,12 +159,12 @@ binary_protocol_get_buffer (int length) if (buffer && buffer->index + length <= BINARY_PROTOCOL_BUFFER_SIZE) return buffer; - new_buffer = mono_sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), TRUE); + new_buffer = sgen_alloc_os_memory (sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL | SGEN_ALLOC_ACTIVATE, "debugging memory"); new_buffer->next = buffer; new_buffer->index = 0; if (InterlockedCompareExchangePointer ((void**)&binary_protocol_buffers, new_buffer, buffer) != buffer) { - mono_sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer)); + sgen_free_os_memory (new_buffer, sizeof (BinaryProtocolBuffer), SGEN_ALLOC_INTERNAL); goto retry; } @@ -112,15 +177,14 @@ protocol_entry (unsigned char type, gpointer data, int size) { int index; BinaryProtocolBuffer *buffer; - int old_count; if (!binary_protocol_file) return; - do { - old_count = binary_protocol_use_count; - g_assert (old_count >= 0); - } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count + 1, old_count) != old_count); + if (sgen_is_worker_thread (mono_native_thread_id_get ())) + type |= 0x80; + + lock_recursive (); retry: buffer = binary_protocol_get_buffer (size + 1); @@ -141,18 +205,31 @@ protocol_entry (unsigned char type, gpointer data, int size) g_assert (index <= BINARY_PROTOCOL_BUFFER_SIZE); - do { - old_count = binary_protocol_use_count; - g_assert (old_count > 0); - } while (InterlockedCompareExchange (&binary_protocol_use_count, old_count - 1, old_count) != old_count); + unlock_recursive (); +} + +void +binary_protocol_collection_force (int generation) +{ + SGenProtocolCollectionForce entry = { generation }; + binary_protocol_flush_buffers (FALSE); + protocol_entry (SGEN_PROTOCOL_COLLECTION_FORCE, &entry, sizeof (SGenProtocolCollectionForce)); +} + +void +binary_protocol_collection_begin (int index, int generation) +{ + SGenProtocolCollection entry = { index, generation }; + binary_protocol_flush_buffers (FALSE); + protocol_entry (SGEN_PROTOCOL_COLLECTION_BEGIN, &entry, sizeof (SGenProtocolCollection)); } void -binary_protocol_collection (int generation) +binary_protocol_collection_end (int index, int generation) { - SGenProtocolCollection entry = { generation }; + SGenProtocolCollection entry = { index, generation }; binary_protocol_flush_buffers (FALSE); - protocol_entry (SGEN_PROTOCOL_COLLECTION, &entry, sizeof (SGenProtocolCollection)); + protocol_entry (SGEN_PROTOCOL_COLLECTION_END, &entry, sizeof (SGenProtocolCollection)); } void @@ -197,6 +274,20 @@ binary_protocol_mark (gpointer obj, gpointer vtable, int size) protocol_entry (SGEN_PROTOCOL_MARK, &entry, sizeof (SGenProtocolMark)); } +void +binary_protocol_scan_begin (gpointer obj, gpointer vtable, int size) +{ + SGenProtocolScanBegin entry = { obj, vtable, size }; + protocol_entry (SGEN_PROTOCOL_SCAN_BEGIN, &entry, sizeof (SGenProtocolScanBegin)); +} + +void +binary_protocol_scan_vtype_begin (gpointer obj, int size) +{ + SGenProtocolScanVTypeBegin entry = { obj, size }; + protocol_entry (SGEN_PROTOCOL_SCAN_VTYPE_BEGIN, &entry, sizeof (SGenProtocolScanVTypeBegin)); +} + void binary_protocol_wbarrier (gpointer ptr, gpointer value, gpointer value_vtable) { @@ -232,12 +323,18 @@ binary_protocol_empty (gpointer start, int size) protocol_entry (SGEN_PROTOCOL_EMPTY, &entry, sizeof (SGenProtocolEmpty)); } +void +binary_protocol_thread_suspend (gpointer thread, gpointer stopped_ip) +{ + SGenProtocolThreadSuspend entry = { thread, stopped_ip }; + protocol_entry (SGEN_PROTOCOL_THREAD_SUSPEND, &entry, sizeof (SGenProtocolThreadSuspend)); +} + void binary_protocol_thread_restart (gpointer thread) { SGenProtocolThreadRestart entry = { thread }; protocol_entry (SGEN_PROTOCOL_THREAD_RESTART, &entry, sizeof (SGenProtocolThreadRestart)); - } void @@ -264,4 +361,61 @@ binary_protocol_missing_remset (gpointer obj, gpointer obj_vtable, int offset, g } +void +binary_protocol_card_scan (gpointer start, int size) +{ + SGenProtocolCardScan entry = { start, size }; + protocol_entry (SGEN_PROTOCOL_CARD_SCAN, &entry, sizeof (SGenProtocolCardScan)); +} + +void +binary_protocol_cement (gpointer obj, gpointer vtable, int size) +{ + SGenProtocolCement entry = { obj, vtable, size }; + protocol_entry (SGEN_PROTOCOL_CEMENT, &entry, sizeof (SGenProtocolCement)); +} + +void +binary_protocol_cement_reset (void) +{ + protocol_entry (SGEN_PROTOCOL_CEMENT_RESET, NULL, 0); +} + +void +binary_protocol_dislink_update (gpointer link, gpointer obj, int track, int staged) +{ + SGenProtocolDislinkUpdate entry = { link, obj, track, staged }; + protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE, &entry, sizeof (SGenProtocolDislinkUpdate)); +} + +void +binary_protocol_dislink_update_staged (gpointer link, gpointer obj, int track, int index) +{ + SGenProtocolDislinkUpdateStaged entry = { link, obj, track, index }; + protocol_entry (SGEN_PROTOCOL_DISLINK_UPDATE_STAGED, &entry, sizeof (SGenProtocolDislinkUpdateStaged)); +} + +void +binary_protocol_dislink_process_staged (gpointer link, gpointer obj, int index) +{ + SGenProtocolDislinkProcessStaged entry = { link, obj, index }; + protocol_entry (SGEN_PROTOCOL_DISLINK_PROCESS_STAGED, &entry, sizeof (SGenProtocolDislinkProcessStaged)); +} + +void +binary_protocol_domain_unload_begin (gpointer domain) +{ + SGenProtocolDomainUnload entry = { domain }; + protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_BEGIN, &entry, sizeof (SGenProtocolDomainUnload)); +} + +void +binary_protocol_domain_unload_end (gpointer domain) +{ + SGenProtocolDomainUnload entry = { domain }; + protocol_entry (SGEN_PROTOCOL_DOMAIN_UNLOAD_END, &entry, sizeof (SGenProtocolDomainUnload)); +} + #endif + +#endif /* HAVE_SGEN_GC */