Grand finalle to this long patch series. Move remembered set implementation to use...

	* sgen-gc.c: Kill use_cardtable and replace it with indirect calls thru a pointer table.
	This might be a bit slower on some configurations but it make the whole thing a hell lot neater.

diff --git a/mono/metadata/sgen-cardtable.c b/mono/metadata/sgen-cardtable.c
index fa0fe6537b271a4275b826a24aa30816fecf8f51..9b762bf0bb4cf02f057add8d680983733ee6aa54 100644 (file)
--- a/mono/metadata/sgen-cardtable.c
+++ b/mono/metadata/sgen-cardtable.c
@@ -71,6 +71,9 @@ static long long los_card_scan_time;
 static long long last_major_scan_time;
 static long long last_los_scan_time;
 
+static void sgen_card_tables_collect_stats (gboolean begin);
+
+
 /*WARNING: This function returns the number of cards regardless of overflow in case of overlapping cards.*/
 static mword
 cards_in_range (mword address, mword size)
@@ -79,7 +82,7 @@ cards_in_range (mword address, mword size)
        return (end >> CARD_BITS) - (address >> CARD_BITS) + 1;
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 {
        *(void**)field_ptr = value;
@@ -88,7 +91,7 @@ mono_sgen_card_table_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, Mo
        mono_sgen_dummy_use (value);
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 {
        *(void**)slot_ptr = value;
@@ -97,7 +100,7 @@ mono_sgen_card_table_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, M
        mono_sgen_dummy_use (value);    
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 {
        gpointer *dest = dest_ptr;
@@ -128,7 +131,7 @@ mono_sgen_card_table_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr
        }       
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 {
        size_t element_size = mono_class_value_size (klass, NULL);
@@ -149,7 +152,7 @@ mono_sgen_card_table_wbarrier_value_copy (gpointer dest, gpointer src, int count
 #endif
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 {
        int size;
@@ -172,7 +175,7 @@ mono_sgen_card_table_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 #endif 
 }
 
-void
+static void
 mono_sgen_card_table_wbarrier_generic_nostore (gpointer ptr)
 {
        sgen_card_table_mark_address ((mword)ptr);      
@@ -269,29 +272,16 @@ sgen_card_table_is_range_marked (guint8 *cards, mword address, mword size)
 
 }
 
-void
-sgen_card_table_init (void)
+static void
+mono_sgen_card_table_record_pointer (gpointer address)
 {
-       sgen_cardtable = mono_sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE);
-
-#ifdef SGEN_HAVE_OVERLAPPING_CARDS
-       sgen_shadow_cardtable = mono_sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE);
-#endif
-
-#ifdef HEAVY_STATISTICS
-       mono_counters_register ("marked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &marked_cards);
-       mono_counters_register ("scanned cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &scanned_cards);
-       mono_counters_register ("remarked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &remarked_cards);
+       *sgen_card_table_get_card_address ((mword)address) = 1;
+}
 
-       mono_counters_register ("los marked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_marked_cards);
-       mono_counters_register ("los array cards scanned ", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_array_cards);
-       mono_counters_register ("los array remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_array_remsets);
-       mono_counters_register ("cardtable scanned objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &scanned_objects);
-       mono_counters_register ("cardtable large objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &large_objects);
-       mono_counters_register ("cardtable bloby objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &bloby_objects);
-#endif
-       mono_counters_register ("cardtable major scan time", MONO_COUNTER_GC | MONO_COUNTER_LONG, &major_card_scan_time);
-       mono_counters_register ("cardtable los scan time", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_card_scan_time);
+static gboolean
+mono_sgen_card_table_find_address (char *addr)
+{
+       return sgen_card_table_address_is_marked ((mword)addr);
 }
 
 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
@@ -342,7 +332,7 @@ clear_cards (mword start, mword size)
 
 #endif
 
-void
+static void
 mono_sgen_card_table_prepare_for_major_collection (void)
 {
        /*XXX we could do this in 2 ways. using mincore or iterating over all sections/los objects */
@@ -350,13 +340,13 @@ mono_sgen_card_table_prepare_for_major_collection (void)
        mono_sgen_los_iterate_live_block_ranges (clear_cards);
 }
 
-void
+static void
 mono_sgen_card_table_finish_minor_collection (void)
 {
        sgen_card_tables_collect_stats (FALSE);
 }
 
-void
+static void
 mono_sgen_card_table_finish_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue)
 {
        SGEN_TV_DECLARE (atv);
@@ -638,7 +628,7 @@ count_remarked_cards (mword start, mword size)
 
 #endif
 
-void
+static void
 sgen_card_tables_collect_stats (gboolean begin)
 {
 #ifdef CARDTABLE_STATS
@@ -662,6 +652,47 @@ sgen_card_tables_collect_stats (gboolean begin)
 #endif
 }
 
+void
+sgen_card_table_init (SgenRemeberedSet *remset)
+{
+       sgen_cardtable = mono_sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE);
+
+#ifdef SGEN_HAVE_OVERLAPPING_CARDS
+       sgen_shadow_cardtable = mono_sgen_alloc_os_memory (CARD_COUNT_IN_BYTES, TRUE);
+#endif
+
+#ifdef HEAVY_STATISTICS
+       mono_counters_register ("marked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &marked_cards);
+       mono_counters_register ("scanned cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &scanned_cards);
+       mono_counters_register ("remarked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &remarked_cards);
+
+       mono_counters_register ("los marked cards", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_marked_cards);
+       mono_counters_register ("los array cards scanned ", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_array_cards);
+       mono_counters_register ("los array remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_array_remsets);
+       mono_counters_register ("cardtable scanned objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &scanned_objects);
+       mono_counters_register ("cardtable large objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &large_objects);
+       mono_counters_register ("cardtable bloby objects", MONO_COUNTER_GC | MONO_COUNTER_LONG, &bloby_objects);
+#endif
+       mono_counters_register ("cardtable major scan time", MONO_COUNTER_GC | MONO_COUNTER_LONG, &major_card_scan_time);
+       mono_counters_register ("cardtable los scan time", MONO_COUNTER_GC | MONO_COUNTER_LONG, &los_card_scan_time);
+
+
+       remset->wbarrier_set_field = mono_sgen_card_table_wbarrier_set_field;
+       remset->wbarrier_set_arrayref = mono_sgen_card_table_wbarrier_set_arrayref;
+       remset->wbarrier_arrayref_copy = mono_sgen_card_table_wbarrier_arrayref_copy;
+       remset->wbarrier_value_copy = mono_sgen_card_table_wbarrier_value_copy;
+       remset->wbarrier_object_copy = mono_sgen_card_table_wbarrier_object_copy;
+       remset->wbarrier_generic_nostore = mono_sgen_card_table_wbarrier_generic_nostore;
+       remset->record_pointer = mono_sgen_card_table_record_pointer;
+
+       remset->finish_scan_remsets = mono_sgen_card_table_finish_scan_remsets;
+
+       remset->finish_minor_collection = mono_sgen_card_table_finish_minor_collection;
+       remset->prepare_for_major_collection = mono_sgen_card_table_prepare_for_major_collection;
+
+       remset->find_address = mono_sgen_card_table_find_address;
+}
+
 #else
 
 void

diff --git a/mono/metadata/sgen-cardtable.h b/mono/metadata/sgen-cardtable.h
index ca7ad10fd57aabc67135483c1dff88f73969b21c..b5d0c01b8696c2cd9f9cf706a580a9055fc164a6 100644 (file)
--- a/mono/metadata/sgen-cardtable.h
+++ b/mono/metadata/sgen-cardtable.h
@@ -34,17 +34,8 @@ void sgen_card_table_mark_range (mword address, mword size) MONO_INTERNAL;
 void sgen_cardtable_scan_object (char *obj, mword obj_size, guint8 *cards, SgenGrayQueue *queue) MONO_INTERNAL;
 
 gboolean sgen_card_table_get_card_data (guint8 *dest, mword address, mword cards) MONO_INTERNAL;
-void mono_sgen_card_table_finish_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue) MONO_INTERNAL;
-void mono_sgen_card_table_prepare_for_major_collection (void) MONO_INTERNAL;
-void mono_sgen_card_table_finish_minor_collection (void) MONO_INTERNAL;
-void sgen_card_table_init (void) MONO_INTERNAL;
-
-void mono_sgen_card_table_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value) MONO_INTERNAL;
-void mono_sgen_card_table_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value) MONO_INTERNAL;
-void mono_sgen_card_table_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count) MONO_INTERNAL;
-void mono_sgen_card_table_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass) MONO_INTERNAL;
-void mono_sgen_card_table_wbarrier_object_copy (MonoObject* obj, MonoObject *src) MONO_INTERNAL;
-void mono_sgen_card_table_wbarrier_generic_nostore (gpointer ptr) MONO_INTERNAL;
+
+void sgen_card_table_init (SgenRemeberedSet *remset) MONO_INTERNAL;
 
 /*How many bytes a single card covers*/
 #define CARD_BITS 9
@@ -134,12 +125,6 @@ sgen_card_table_mark_address (mword address)
        *sgen_card_table_get_card_address (address) = 1;
 }
 
-static inline void
-mono_sgen_card_table_record_pointer (gpointer address)
-{
-       *sgen_card_table_get_card_address ((mword)address) = 1;
-}
-
 #else /*if SGEN_HAVE_CARDTABLE */
 
 static inline void
@@ -155,9 +140,7 @@ sgen_card_table_mark_range (mword address, mword size)
 }
 
 #define sgen_card_table_address_is_marked(p)   FALSE
-#define mono_sgen_card_table_scan_from_remsets(start,end,queue)
-#define mono_sgen_card_table_prepare_for_major_collection()
-#define sgen_card_table_init()
+#define sgen_card_table_init(p)
 
 guint8*
 mono_gc_get_card_table (int *shift_bits, gpointer *mask)
@@ -165,14 +148,6 @@ mono_gc_get_card_table (int *shift_bits, gpointer *mask)
        return NULL;
 }
 
-static void
-mono_sgen_card_table_record_pointer (gpointer address)
-{
-       g_assert_not_reached ();
-}
-
 #endif
 
-
-
 #endif

diff --git a/mono/metadata/sgen-debug.c b/mono/metadata/sgen-debug.c
index 659ef9248626a3bfa05e4edc569fadb8420edbf4..63e2db0a77706c8d95ce7f4ccb572e6edb7cd68a 100644 (file)
--- a/mono/metadata/sgen-debug.c
+++ b/mono/metadata/sgen-debug.c
@@ -128,7 +128,7 @@ static gboolean missing_remsets;
 #undef HANDLE_PTR
 #define HANDLE_PTR(ptr,obj)    do {    \
        if (*(ptr) && mono_sgen_ptr_in_nursery ((char*)*(ptr))) { \
-               if (!mono_sgen_ssb_find_address ((char*)(ptr)) && (!use_cardtable || !sgen_card_table_address_is_marked ((mword)ptr))) { \
+               if (!mono_sgen_get_remset ()->find_address ((char*)(ptr))) { \
                        fprintf (gc_debug_file, "Oldspace->newspace reference %p at offset %td in object %p (%s.%s) not found in remsets.\n", *(ptr), (char*)(ptr) - (char*)(obj), (obj), ((MonoObject*)(obj))->vtable->klass->name_space, ((MonoObject*)(obj))->vtable->klass->name); \
                        binary_protocol_missing_remset ((obj), (gpointer)LOAD_VTABLE ((obj)), (char*)(ptr) - (char*)(obj), *(ptr), (gpointer)LOAD_VTABLE(*(ptr)), object_is_pinned (*(ptr))); \
                        if (!object_is_pinned (*(ptr)))                                                         \

diff --git a/mono/metadata/sgen-gc.c b/mono/metadata/sgen-gc.c
index 4a70fab7431007362be343b3020a2bf5ced35fce..68c04e06a56dccc7e16c8fc19864de905607321d 100644 (file)
--- a/mono/metadata/sgen-gc.c
+++ b/mono/metadata/sgen-gc.c
@@ -407,7 +407,7 @@ mono_sgen_safe_name (void* obj)
 LOCK_DECLARE (gc_mutex);
 static int gc_disabled = 0;
 
-gboolean use_cardtable;
+static gboolean use_cardtable;
 
 #ifdef USER_CONFIG
 
@@ -712,6 +712,7 @@ static void null_ephemerons_for_domain (MonoDomain *domain);
 SgenMajorCollector major_collector;
 static GrayQueue gray_queue;
 
+static SgenRemeberedSet remset;
 
 
 #define WORKERS_DISTRIBUTE_GRAY_QUEUE (mono_sgen_collection_is_parallel () ? mono_sgen_workers_get_distribute_gray_queue () : &gray_queue)
@@ -1230,10 +1231,7 @@ mono_gc_clear_domain (MonoDomain * domain)
 void
 mono_sgen_add_to_global_remset (gpointer ptr)
 {
-       if (use_cardtable)
-               mono_sgen_card_table_record_pointer (ptr);
-       else
-               mono_sgen_ssb_record_pointer (ptr);
+       remset.record_pointer (ptr);
 }
 
 /*
@@ -2487,10 +2485,7 @@ job_finish_remembered_set_scan (WorkerData *worker_data, void *job_data_untyped)
 {
        FinishRememberedSetScanJobData *job_data = job_data_untyped;
 
-       if (use_cardtable)
-               mono_sgen_card_table_finish_scan_remsets (job_data->heap_start, job_data->heap_end, mono_sgen_workers_get_job_gray_queue (worker_data));
-       else
-               mono_sgen_ssb_finish_scan_remsets (job_data->heap_start, job_data->heap_end, mono_sgen_workers_get_job_gray_queue (worker_data));
+       remset.finish_scan_remsets (job_data->heap_start, job_data->heap_end, mono_sgen_workers_get_job_gray_queue (worker_data));
 }
 
 typedef struct
@@ -2650,8 +2645,8 @@ collect_nursery (size_t requested_size)
        stat_minor_gcs++;
        mono_stats.minor_gc_count ++;
 
-       if (!use_cardtable)
-               mono_sgen_ssb_prepare_for_minor_collection ();
+       if (remset.prepare_for_minor_collection)
+               remset.prepare_for_minor_collection ();
 
        process_fin_stage_entries ();
        process_dislink_stage_entries ();
@@ -2679,8 +2674,8 @@ collect_nursery (size_t requested_size)
         * Perform the sequential part of remembered set scanning.
         * This usually involves scanning global information that might later be produced by evacuation.
         */
-       if (!use_cardtable)
-               mono_sgen_ssb_begin_scan_remsets (nursery_start, nursery_next, WORKERS_DISTRIBUTE_GRAY_QUEUE);
+       if (remset.begin_scan_remsets)
+               remset.begin_scan_remsets (nursery_start, nursery_next, WORKERS_DISTRIBUTE_GRAY_QUEUE);
 
        mono_sgen_workers_start_marking ();
 
@@ -2795,8 +2790,8 @@ collect_nursery (size_t requested_size)
 
        g_assert (mono_sgen_gray_object_queue_is_empty (&gray_queue));
 
-       if (use_cardtable)
-               mono_sgen_card_table_finish_minor_collection ();
+       if (remset.finish_minor_collection)
+               remset.finish_minor_collection ();
 
        check_scan_starts ();
 
@@ -2911,10 +2906,7 @@ major_do_collection (const char *reason)
                check_for_xdomain_refs ();
 
        /* Remsets are not useful for a major collection */
-       if (use_cardtable)
-               mono_sgen_card_table_prepare_for_major_collection ();
-       else
-               mono_sgen_ssb_prepare_for_major_collection ();
+       remset.prepare_for_major_collection ();
 
        process_fin_stage_entries ();
        process_dislink_stage_entries ();
@@ -4104,8 +4096,8 @@ sgen_thread_register (SgenThreadInfo* info, void *addr)
        stack_end = info->stack_end;
 #endif
 
-       if (!use_cardtable)
-               mono_sgen_ssb_register_thread (info);
+       if (remset.register_thread)
+               remset.register_thread (info);
 
        DEBUG (3, fprintf (gc_debug_file, "registered thread %p (%p) stack end %p\n", info, (gpointer)mono_thread_info_get_tid (info), info->stack_end));
 
@@ -4119,8 +4111,8 @@ sgen_thread_register (SgenThreadInfo* info, void *addr)
 static void
 mono_sgen_wbarrier_cleanup_thread (SgenThreadInfo *p)
 {
-       if (!use_cardtable)
-               mono_sgen_ssb_cleanup_thread (p);
+       if (remset.cleanup_thread)
+               remset.cleanup_thread (p);
 }
 
 static void
@@ -4274,10 +4266,7 @@ mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* val
        if (value)
                binary_protocol_wbarrier (field_ptr, value, value->vtable);
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_set_field (obj, field_ptr, value);
-       else
-               mono_sgen_ssb_wbarrier_set_field (obj, field_ptr, value);
+       remset.wbarrier_set_field (obj, field_ptr, value);
 }
 
 void
@@ -4292,10 +4281,7 @@ mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* va
        if (value)
                binary_protocol_wbarrier (slot_ptr, value, value->vtable);
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_set_arrayref (arr, slot_ptr, value);
-       else
-               mono_sgen_ssb_wbarrier_set_arrayref (arr, slot_ptr, value);
+       remset.wbarrier_set_arrayref (arr, slot_ptr, value);
 }
 
 void
@@ -4320,10 +4306,7 @@ mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
        }
 #endif
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_arrayref_copy (dest_ptr, src_ptr, count);
-       else
-               mono_sgen_ssb_wbarrier_arrayref_copy (dest_ptr, src_ptr, count);
+       remset.wbarrier_arrayref_copy (dest_ptr, src_ptr, count);
 }
 
 static char *found_obj;
@@ -4397,10 +4380,7 @@ mono_gc_wbarrier_generic_nostore (gpointer ptr)
 
        DEBUG (8, fprintf (gc_debug_file, "Adding remset at %p\n", ptr));
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_generic_nostore (ptr);
-       else
-               mono_sgen_ssb_wbarrier_generic_nostore (ptr);
+       remset.wbarrier_generic_nostore (ptr);
 }
 
 void
@@ -4474,10 +4454,7 @@ mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *
        }
 #endif
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_value_copy (dest, src, count, klass);
-       else
-               mono_sgen_ssb_wbarrier_value_copy (dest, src, count, klass);
+       remset.wbarrier_value_copy (dest, src, count, klass);
 }
 
 /**
@@ -4503,10 +4480,7 @@ mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
        scan_object_for_binary_protocol_copy_wbarrier (obj, (char*)src, (mword) src->vtable->gc_descr);
 #endif
 
-       if (use_cardtable)
-               mono_sgen_card_table_wbarrier_object_copy (obj, src);
-       else
-               mono_sgen_ssb_wbarrier_object_copy (obj, src);
+       remset.wbarrier_object_copy (obj, src);
 }
 
 /*
@@ -4752,7 +4726,7 @@ is_critical_method (MonoMethod *method)
 {
        return mono_runtime_is_critical_method (method) || mono_gc_is_critical_method (method);
 }
-
+       
 void
 mono_gc_base_init (void)
 {
@@ -5100,10 +5074,17 @@ mono_gc_base_init (void)
        if (major_collector.post_param_init)
                major_collector.post_param_init ();
 
+       memset (&remset, 0, sizeof (remset));
+
+#ifdef SGEN_HAVE_CARDTABLE
        if (use_cardtable)
-               sgen_card_table_init ();
+               sgen_card_table_init (&remset);
        else
-               mono_sgen_ssb_init ();
+#endif
+               mono_sgen_ssb_init (&remset);
+
+       if (remset.register_thread)
+               remset.register_thread (mono_thread_info_current ());
 
        gc_initialized = 1;
 }
@@ -5511,4 +5492,10 @@ void mono_gc_set_skip_thread (gboolean skip)
        UNLOCK_GC;
 }
 
+SgenRemeberedSet*
+mono_sgen_get_remset (void)
+{
+       return &remset;
+}
+
 #endif /* HAVE_SGEN_GC */

diff --git a/mono/metadata/sgen-gc.h b/mono/metadata/sgen-gc.h
index a28dadf064d1bae3ff88db6bf870fe23e3d692d7..33034541bd9d04f3af63bbcbca670dc16f87b890 100644 (file)
--- a/mono/metadata/sgen-gc.h
+++ b/mono/metadata/sgen-gc.h
@@ -510,6 +510,30 @@ void mono_sgen_marksweep_fixed_par_init (SgenMajorCollector *collector) MONO_INT
 void mono_sgen_copying_init (SgenMajorCollector *collector) MONO_INTERNAL;
 SgenMajorCollector* mono_sgen_get_major_collector (void) MONO_INTERNAL;
 
+
+typedef struct {
+       void (*wbarrier_set_field) (MonoObject *obj, gpointer field_ptr, MonoObject* value);
+       void (*wbarrier_set_arrayref) (MonoArray *arr, gpointer slot_ptr, MonoObject* value);
+       void (*wbarrier_arrayref_copy) (gpointer dest_ptr, gpointer src_ptr, int count);
+       void (*wbarrier_value_copy) (gpointer dest, gpointer src, int count, MonoClass *klass);
+       void (*wbarrier_object_copy) (MonoObject* obj, MonoObject *src);
+       void (*wbarrier_generic_nostore) (gpointer ptr);
+       void (*record_pointer) (gpointer ptr);
+
+       void (*begin_scan_remsets) (void *start_nursery, void *end_nursery, SgenGrayQueue *queue); /* OPTIONAL */
+       void (*finish_scan_remsets) (void *start_nursery, void *end_nursery, SgenGrayQueue *queue);
+
+       void (*register_thread) (SgenThreadInfo *p); /* OPTIONAL */
+       void (*cleanup_thread) (SgenThreadInfo *p); /* OPTIONAL */
+       void (*prepare_for_minor_collection) (void); /* OPTIONAL */
+       void (*prepare_for_major_collection) (void);
+
+       void (*finish_minor_collection) (void); /* OPTIONAL */
+       gboolean (*find_address) (char *addr);
+} SgenRemeberedSet;
+
+SgenRemeberedSet *mono_sgen_get_remset (void) MONO_INTERNAL;
+
 static guint /*__attribute__((noinline)) not sure if this hint is a good idea*/
 slow_object_get_size (MonoVTable *vtable, MonoObject* o)
 {
@@ -804,7 +828,6 @@ extern NurseryClearPolicy nursery_clear_policy;
 extern LOCK_DECLARE (gc_mutex);
 
 extern int do_pin_stats;
-extern gboolean use_cardtable;
 
 /* Object Allocation */
 

diff --git a/mono/metadata/sgen-ssb.c b/mono/metadata/sgen-ssb.c
index ddf71f808d6ad9ab1065ba3ad2e9127f44daddee..1d39da51e3055d4e7ab2e17b9291a4069e0b5c22 100644 (file)
--- a/mono/metadata/sgen-ssb.c
+++ b/mono/metadata/sgen-ssb.c
@@ -126,7 +126,7 @@ mono_sgen_alloc_remset (int size, gpointer id, gboolean global)
 
 
 
-void
+static void
 mono_sgen_ssb_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
 {
        RememberedSet *rs;
@@ -151,7 +151,7 @@ mono_sgen_ssb_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObjec
        UNLOCK_GC;
 }
 
-void
+static void
 mono_sgen_ssb_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
 {
        RememberedSet *rs;
@@ -176,7 +176,7 @@ mono_sgen_ssb_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObje
        UNLOCK_GC;
 }
 
-void
+static void
 mono_sgen_ssb_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
 {
        RememberedSet *rs;
@@ -204,7 +204,7 @@ mono_sgen_ssb_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int c
        UNLOCK_GC;
 }
 
-void
+static void
 mono_sgen_ssb_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
 {
        RememberedSet *rs;
@@ -239,7 +239,7 @@ mono_sgen_ssb_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoC
        UNLOCK_GC;
 }      
 
-void
+static void
 mono_sgen_ssb_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
 {
        int size;
@@ -272,7 +272,7 @@ mono_sgen_ssb_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
        UNLOCK_GC;
 }
 
-void
+static void
 mono_sgen_ssb_wbarrier_generic_nostore (gpointer ptr)
 {
        gpointer *buffer;
@@ -472,7 +472,7 @@ handle_remset (mword *p, void *start_nursery, void *end_nursery, gboolean global
        return NULL;
 }
 
-void
+static void
 mono_sgen_ssb_begin_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue)
 {
        RememberedSet *remset;
@@ -511,7 +511,7 @@ mono_sgen_ssb_begin_scan_remsets (void *start_nursery, void *end_nursery, SgenGr
        }
 }
 
-void
+static void
 mono_sgen_ssb_finish_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue)
 {
        int i;
@@ -577,7 +577,7 @@ mono_sgen_ssb_finish_scan_remsets (void *start_nursery, void *end_nursery, SgenG
 }
 
 
-void
+static void
 mono_sgen_ssb_cleanup_thread (SgenThreadInfo *p)
 {
        RememberedSet *rset;
@@ -609,7 +609,7 @@ mono_sgen_ssb_cleanup_thread (SgenThreadInfo *p)
        *p->store_remset_buffer_addr = NULL;
 }
 
-void
+static void
 mono_sgen_ssb_register_thread (SgenThreadInfo *info)
 {
 #ifndef HAVE_KW_THREAD
@@ -626,7 +626,7 @@ mono_sgen_ssb_register_thread (SgenThreadInfo *info)
        STORE_REMSET_BUFFER_INDEX = 0;
 }
 
-void
+static void
 mono_sgen_ssb_prepare_for_minor_collection (void)
 {
        memset (global_remset_cache, 0, sizeof (global_remset_cache));
@@ -637,7 +637,7 @@ mono_sgen_ssb_prepare_for_minor_collection (void)
  * the per-thread ones are not needed and the global ones will be reconstructed
  * during the copy.
  */
-void
+static void
 mono_sgen_ssb_prepare_for_major_collection (void)
 {
        SgenThreadInfo *info;
@@ -721,7 +721,7 @@ global_remset_location_was_not_added (gpointer ptr)
        return TRUE;
 }
 
-void
+static void
 mono_sgen_ssb_record_pointer (gpointer ptr)
 {
        RememberedSet *rs;
@@ -771,31 +771,6 @@ mono_sgen_ssb_record_pointer (gpointer ptr)
                UNLOCK_GLOBAL_REMSET;
 }
 
-void
-mono_sgen_ssb_init (void)
-{
-       LOCK_INIT (global_remset_mutex);
-
-       global_remset = mono_sgen_alloc_remset (1024, NULL, FALSE);
-       global_remset->next = NULL;
-
-       mono_native_tls_alloc (&remembered_set_key, NULL);
-
-#ifdef HEAVY_STATISTICS
-       mono_counters_register ("WBarrier generic store stored", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_generic_store_remset);
-
-       mono_counters_register ("Store remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_store_remsets);
-       mono_counters_register ("Unique store remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_store_remsets_unique);
-       mono_counters_register ("Saved remsets 1", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_saved_remsets_1);
-       mono_counters_register ("Saved remsets 2", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_saved_remsets_2);
-       mono_counters_register ("Non-global remsets processed", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_local_remsets_processed);
-       mono_counters_register ("Global remsets added", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_added);
-       mono_counters_register ("Global remsets re-added", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_readded);
-       mono_counters_register ("Global remsets processed", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_processed);
-       mono_counters_register ("Global remsets discarded", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_discarded);
-#endif
-}
-
 /*
  * ######################################################################
  * ########  Debug support
@@ -849,7 +824,7 @@ find_in_remset_loc (mword *p, char *addr, gboolean *found)
 /*
  * Return whenever ADDR occurs in the remembered sets
  */
-gboolean
+static gboolean
 mono_sgen_ssb_find_address (char *addr)
 {
        int i;
@@ -907,4 +882,47 @@ mono_sgen_ssb_find_address (char *addr)
        return FALSE;
 }
 
+
+void
+mono_sgen_ssb_init (SgenRemeberedSet *remset)
+{
+       LOCK_INIT (global_remset_mutex);
+
+       global_remset = mono_sgen_alloc_remset (1024, NULL, FALSE);
+       global_remset->next = NULL;
+
+       mono_native_tls_alloc (&remembered_set_key, NULL);
+
+#ifdef HEAVY_STATISTICS
+       mono_counters_register ("WBarrier generic store stored", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_generic_store_remset);
+
+       mono_counters_register ("Store remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_store_remsets);
+       mono_counters_register ("Unique store remsets", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_store_remsets_unique);
+       mono_counters_register ("Saved remsets 1", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_saved_remsets_1);
+       mono_counters_register ("Saved remsets 2", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_saved_remsets_2);
+       mono_counters_register ("Non-global remsets processed", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_local_remsets_processed);
+       mono_counters_register ("Global remsets added", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_added);
+       mono_counters_register ("Global remsets re-added", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_readded);
+       mono_counters_register ("Global remsets processed", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_processed);
+       mono_counters_register ("Global remsets discarded", MONO_COUNTER_GC | MONO_COUNTER_LONG, &stat_global_remsets_discarded);
+#endif
+
+       remset->wbarrier_set_field = mono_sgen_ssb_wbarrier_set_field;
+       remset->wbarrier_set_arrayref = mono_sgen_ssb_wbarrier_set_arrayref;
+       remset->wbarrier_arrayref_copy = mono_sgen_ssb_wbarrier_arrayref_copy;
+       remset->wbarrier_value_copy = mono_sgen_ssb_wbarrier_value_copy;
+       remset->wbarrier_object_copy = mono_sgen_ssb_wbarrier_object_copy;
+       remset->wbarrier_generic_nostore = mono_sgen_ssb_wbarrier_generic_nostore;
+       remset->record_pointer = mono_sgen_ssb_record_pointer;
+
+       remset->begin_scan_remsets = mono_sgen_ssb_begin_scan_remsets;
+       remset->finish_scan_remsets = mono_sgen_ssb_finish_scan_remsets;
+
+       remset->register_thread = mono_sgen_ssb_register_thread;
+       remset->cleanup_thread = mono_sgen_ssb_cleanup_thread;
+       remset->prepare_for_minor_collection = mono_sgen_ssb_prepare_for_minor_collection;
+       remset->prepare_for_major_collection = mono_sgen_ssb_prepare_for_major_collection;
+
+       remset->find_address = mono_sgen_ssb_find_address;
+}
 #endif

diff --git a/mono/metadata/sgen-ssb.h b/mono/metadata/sgen-ssb.h
index 5dfdd876ffacdb1e8c18164e06ef0edc949dfdcd..7187a3514276d78a285471c5580941f2aac9f795 100644 (file)
--- a/mono/metadata/sgen-ssb.h
+++ b/mono/metadata/sgen-ssb.h
@@ -24,26 +24,7 @@
 #ifndef __MONO_SGEN_SSB_H__
 #define __MONO_SGEN_SSB_H__
 
-
-void mono_sgen_ssb_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value) MONO_INTERNAL;
-void mono_sgen_ssb_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value) MONO_INTERNAL;
-void mono_sgen_ssb_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count) MONO_INTERNAL;
-void mono_sgen_ssb_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass) MONO_INTERNAL;
-void mono_sgen_ssb_wbarrier_object_copy (MonoObject* obj, MonoObject *src) MONO_INTERNAL;
-void mono_sgen_ssb_wbarrier_generic_nostore (gpointer ptr) MONO_INTERNAL;
-
-void mono_sgen_ssb_finish_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue) MONO_INTERNAL;
-void mono_sgen_ssb_begin_scan_remsets (void *start_nursery, void *end_nursery, SgenGrayQueue *queue) MONO_INTERNAL;
-
-void mono_sgen_ssb_cleanup_thread (SgenThreadInfo *p) MONO_INTERNAL;
-void mono_sgen_ssb_register_thread (SgenThreadInfo *p) MONO_INTERNAL;
-void mono_sgen_ssb_prepare_for_minor_collection (void) MONO_INTERNAL;
-void mono_sgen_ssb_prepare_for_major_collection (void) MONO_INTERNAL;
-void mono_sgen_ssb_init (void) MONO_INTERNAL;
-
-void mono_sgen_ssb_record_pointer (gpointer ptr) MONO_INTERNAL;
-
-gboolean mono_sgen_ssb_find_address (char *addr) MONO_INTERNAL;
+void mono_sgen_ssb_init (SgenRemeberedSet *remset) MONO_INTERNAL;
 
 #endif