mono/metadata/sgen-toggleref.c

   1 /**
   2  * \file
   3  * toggleref support for sgen
   4  *
   5  * Author:
   6  *  Rodrigo Kumpera (kumpera@gmail.com)
   7  *
   8  * Copyright 2011 Xamarin, Inc.
   9  * Copyright (C) 2012 Xamarin Inc
  10  *
  11  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  12  */
  13
  14 #include "config.h"
  15
  16 #ifdef HAVE_SGEN_GC
  17
  18 #include "sgen/sgen-gc.h"
  19 #include "sgen-toggleref.h"
  20 #include "sgen/sgen-client.h"
  21
  22
  23 /*only one of the two can be non null at a given time*/
  24 typedef struct {
  25         GCObject *strong_ref;
  26         GCObject *weak_ref;
  27 } MonoGCToggleRef;
  28
  29 static MonoToggleRefStatus (*toggleref_callback) (MonoObject *obj);
  30 static MonoGCToggleRef *toggleref_array;
  31 static int toggleref_array_size;
  32 static int toggleref_array_capacity;
  33
  34 void
  35 sgen_process_togglerefs (void)
  36 {
  37         int i, w;
  38         int toggle_ref_counts [3] = { 0, 0, 0 };
  39
  40         SGEN_LOG (4, "Proccessing ToggleRefs %d", toggleref_array_size);
  41
  42         for (i = w = 0; i < toggleref_array_size; ++i) {
  43                 int res;
  44                 MonoGCToggleRef r = toggleref_array [i];
  45
  46                 MonoObject *obj;
  47
  48                 if (r.strong_ref)
  49                         obj = r.strong_ref;
  50                 else if (r.weak_ref)
  51                         obj = r.weak_ref;
  52                 else
  53                         continue;
  54
  55                 res = toggleref_callback (obj);
  56                 ++toggle_ref_counts [res];
  57                 switch (res) {
  58                 case MONO_TOGGLE_REF_DROP:
  59                         break;
  60                 case MONO_TOGGLE_REF_STRONG:
  61                         toggleref_array [w].strong_ref = obj;
  62                         toggleref_array [w].weak_ref = NULL;
  63                         ++w;
  64                         break;
  65                 case MONO_TOGGLE_REF_WEAK:
  66                         toggleref_array [w].strong_ref = NULL;
  67                         toggleref_array [w].weak_ref = obj;
  68                         ++w;
  69                         break;
  70                 default:
  71                         g_assert_not_reached ();
  72                 }
  73         }
  74
  75         toggleref_array_size = w;
  76
  77         SGEN_LOG (4, "Done Proccessing ToggleRefs dropped %d strong %d weak %d final size %d",
  78                 toggle_ref_counts [MONO_TOGGLE_REF_DROP],
  79                 toggle_ref_counts [MONO_TOGGLE_REF_STRONG],
  80                 toggle_ref_counts [MONO_TOGGLE_REF_WEAK],
  81                 w);
  82 }
  83
  84 void sgen_client_mark_togglerefs (char *start, char *end, ScanCopyContext ctx)
  85 {
  86         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
  87         SgenGrayQueue *queue = ctx.queue;
  88         int i;
  89
  90         SGEN_LOG (4, "Marking ToggleRefs %d", toggleref_array_size);
  91
  92         for (i = 0; i < toggleref_array_size; ++i) {
  93                 if (toggleref_array [i].strong_ref) {
  94                         GCObject *object = toggleref_array [i].strong_ref;
  95                         if ((char*)object >= start && (char*)object < end) {
  96                                 SGEN_LOG (6, "\tcopying strong slot %d", i);
  97                                 copy_func (&toggleref_array [i].strong_ref, queue);
  98                         }
  99                 }
 100         }
 101         sgen_drain_gray_stack (ctx);
 102 }
 103
 104 void
 105 sgen_foreach_toggleref_root (void (*callback)(MonoObject*, gpointer), gpointer data)
 106 {
 107         int i;
 108         for (i = 0; i < toggleref_array_size; ++i) {
 109                 if (toggleref_array [i].strong_ref)
 110                         callback (toggleref_array [i].strong_ref, data);
 111         }
 112 }
 113
 114 void sgen_client_clear_togglerefs (char *start, char *end, ScanCopyContext ctx)
 115 {
 116         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
 117         SgenGrayQueue *queue = ctx.queue;
 118         int i;
 119
 120         SGEN_LOG (4, "Clearing ToggleRefs %d", toggleref_array_size);
 121
 122         for (i = 0; i < toggleref_array_size; ++i) {
 123                 if (toggleref_array [i].weak_ref) {
 124                         GCObject *object = toggleref_array [i].weak_ref;
 125
 126                         if ((char*)object >= start && (char*)object < end) {
 127                                 if (sgen_gc_is_object_ready_for_finalization (object)) {
 128                                         SGEN_LOG (6, "\tcleaning weak slot %d", i);
 129                                         toggleref_array [i].weak_ref = NULL; /* We defer compaction to only happen on the callback step. */
 130                                 } else {
 131                                         SGEN_LOG (6, "\tkeeping weak slot %d", i);
 132                                         copy_func (&toggleref_array [i].weak_ref, queue);
 133                                 }
 134                         }
 135                 }
 136         }
 137         sgen_drain_gray_stack (ctx);
 138 }
 139
 140 static void
 141 ensure_toggleref_capacity (int capacity)
 142 {
 143         if (!toggleref_array) {
 144                 toggleref_array_capacity = 32;
 145                 toggleref_array = (MonoGCToggleRef *)sgen_alloc_internal_dynamic (
 146                         toggleref_array_capacity * sizeof (MonoGCToggleRef),
 147                         INTERNAL_MEM_TOGGLEREF_DATA,
 148                         TRUE);
 149         }
 150         if (toggleref_array_size + capacity >= toggleref_array_capacity) {
 151                 MonoGCToggleRef *tmp;
 152                 int old_capacity = toggleref_array_capacity;
 153                 while (toggleref_array_capacity < toggleref_array_size + capacity)
 154                         toggleref_array_capacity *= 2;
 155
 156                 tmp = (MonoGCToggleRef *)sgen_alloc_internal_dynamic (
 157                         toggleref_array_capacity * sizeof (MonoGCToggleRef),
 158                         INTERNAL_MEM_TOGGLEREF_DATA,
 159                         TRUE);
 160
 161                 memcpy (tmp, toggleref_array, toggleref_array_size * sizeof (MonoGCToggleRef));
 162
 163                 sgen_free_internal_dynamic (toggleref_array, old_capacity * sizeof (MonoGCToggleRef), INTERNAL_MEM_TOGGLEREF_DATA);
 164                 toggleref_array = tmp;
 165         }
 166 }
 167
 168 /**
 169  * mono_gc_toggleref_add:
 170  * @object object to register for toggleref processing
 171  * @strong_ref if true the object is registered with a strong ref, a weak one otherwise
 172  *
 173  * Register a given object for toggleref processing. It will be stored internally and the toggleref callback will be called
 174  * on it until it returns MONO_TOGGLE_REF_DROP or is collected.
 175 */
 176 void
 177 mono_gc_toggleref_add (MonoObject *object, mono_bool strong_ref)
 178 {
 179         if (!toggleref_callback)
 180                 return;
 181
 182         MONO_ENTER_GC_UNSAFE;
 183
 184         SGEN_LOG (4, "Adding toggleref %p %d", object, strong_ref);
 185
 186         sgen_gc_lock ();
 187
 188         ensure_toggleref_capacity (1);
 189         toggleref_array [toggleref_array_size].strong_ref = strong_ref ? object : NULL;
 190         toggleref_array [toggleref_array_size].weak_ref = strong_ref ? NULL : object;
 191         ++toggleref_array_size;
 192
 193         sgen_gc_unlock ();
 194
 195         MONO_EXIT_GC_UNSAFE;
 196 }
 197
 198 /**
 199  * mono_gc_toggleref_register_callback:
 200  * \param callback callback used to determine the new state of the given object.
 201  *
 202  * The callback must decide the status of a given object. It must return one of the values in the \c MONO_TOGGLE_REF_ enum.
 203  * This function is called with the world running but with the GC locked. This means that you can do everything that doesn't
 204  * require GC interaction. This includes, but not limited to, allocating objects, (de)registering for finalization, manipulating
 205  * gchandles, storing to reference fields or interacting with other threads that might perform such operations.
 206  */
 207 void
 208 mono_gc_toggleref_register_callback (MonoToggleRefStatus (*proccess_toggleref) (MonoObject *obj))
 209 {
 210         toggleref_callback = proccess_toggleref;
 211 }
 212
 213 static MonoToggleRefStatus
 214 test_toggleref_callback (MonoObject *obj)
 215 {
 216         MonoToggleRefStatus status = MONO_TOGGLE_REF_DROP;
 217
 218         MONO_STATIC_POINTER_INIT (MonoClassField, mono_toggleref_test_field)
 219
 220                 mono_toggleref_test_field = mono_class_get_field_from_name_full (mono_object_class (obj), "__test", NULL);
 221                 g_assert (mono_toggleref_test_field);
 222
 223         MONO_STATIC_POINTER_INIT_END (MonoClassField, mono_toggleref_test_field)
 224
 225         /* In coop mode, important to not call a helper that will pin obj! */
 226         mono_field_get_value_internal (obj, mono_toggleref_test_field, &status);
 227         printf ("toggleref-cb obj %d\n", status);
 228         return status;
 229 }
 230
 231 void
 232 sgen_register_test_toggleref_callback (void)
 233 {
 234         toggleref_callback = test_toggleref_callback;
 235 }
 236
 237 #endif