mono/metadata/sgen-marksweep-drain-gray-stack.h

   1 /*
   2  * sgen-marksweep-drain-gray-stack.h: The copy/mark and gray stack
   3  *     draining functions of the M&S major collector.
   4  *
   5  * Copyright (C) 2014 Xamarin Inc
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License 2.0 as published by the Free Software Foundation;
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Library General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Library General Public
  17  * License 2.0 along with this library; if not, write to the Free
  18  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 /*
  22  * COPY_OR_MARK_FUNCTION_NAME must be defined to be the function name of the copy/mark
  23  * function.
  24  *
  25  * SCAN_OBJECT_FUNCTION_NAME must be defined to be the function name of the object scanning
  26  * function.
  27  *
  28  * DRAIN_GRAY_STACK_FUNCTION_NAME must be defined to be the function name of the gray stack
  29  * draining function.
  30  *
  31  * Define COPY_OR_MARK_WITH_EVACUATION to support evacuation.
  32  */
  33
  34 /* Returns whether the object is still in the nursery. */
  35 static inline MONO_ALWAYS_INLINE gboolean
  36 COPY_OR_MARK_FUNCTION_NAME (void **ptr, void *obj, SgenGrayQueue *queue)
  37 {
  38         MSBlockInfo *block;
  39
  40 #ifdef HEAVY_STATISTICS
  41         ++stat_optimized_copy;
  42         {
  43                 char *forwarded;
  44                 mword desc;
  45                 if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj)))
  46                         desc = sgen_obj_get_descriptor_safe (forwarded);
  47                 else
  48                         desc = sgen_obj_get_descriptor_safe (obj);
  49
  50                 sgen_descriptor_count_copied_object (desc);
  51         }
  52 #endif
  53
  54         SGEN_ASSERT (9, obj, "null object from pointer %p", ptr);
  55         SGEN_ASSERT (9, current_collection_generation == GENERATION_OLD, "old gen parallel allocator called from a %d collection", current_collection_generation);
  56
  57         if (sgen_ptr_in_nursery (obj)) {
  58                 int word, bit;
  59                 char *forwarded, *old_obj;
  60                 mword vtable_word = *(mword*)obj;
  61
  62                 HEAVY_STAT (++stat_optimized_copy_nursery);
  63
  64 #if SGEN_MAX_DEBUG_LEVEL >= 9
  65                 if (sgen_nursery_is_to_space (obj))
  66                         SGEN_ASSERT (9, !SGEN_VTABLE_IS_PINNED (vtable_word) && !SGEN_VTABLE_IS_FORWARDED (vtable_word), "To-space object can't be pinned or forwarded.");
  67 #endif
  68
  69                 if (SGEN_VTABLE_IS_PINNED (vtable_word)) {
  70                         SGEN_ASSERT (9, !SGEN_VTABLE_IS_FORWARDED (vtable_word), "Cannot be both pinned and forwarded.");
  71                         HEAVY_STAT (++stat_optimized_copy_nursery_pinned);
  72                         return TRUE;
  73                 }
  74                 if ((forwarded = SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
  75                         HEAVY_STAT (++stat_optimized_copy_nursery_forwarded);
  76                         *ptr = forwarded;
  77                         return sgen_ptr_in_nursery (forwarded);
  78                 }
  79
  80                 /* An object in the nursery To Space has already been copied and grayed. Nothing to do. */
  81                 if (sgen_nursery_is_to_space (obj))
  82                         return TRUE;
  83
  84 #ifdef COPY_OR_MARK_WITH_EVACUATION
  85         do_copy_object:
  86 #endif
  87                 old_obj = obj;
  88                 obj = copy_object_no_checks (obj, queue);
  89                 if (G_UNLIKELY (old_obj == obj)) {
  90                         /*
  91                          * If we fail to evacuate an object we just stop doing it for a
  92                          * given block size as all other will surely fail too.
  93                          */
  94                         /* FIXME: test this case somehow. */
  95                         if (!sgen_ptr_in_nursery (obj)) {
  96                                 int size_index;
  97                                 block = MS_BLOCK_FOR_OBJ (obj);
  98                                 size_index = block->obj_size_index;
  99                                 evacuate_block_obj_sizes [size_index] = FALSE;
 100                                 MS_MARK_OBJECT_AND_ENQUEUE (obj, sgen_obj_get_descriptor (obj), block, queue);
 101                                 return FALSE;
 102                         }
 103                         return TRUE;
 104                 }
 105                 HEAVY_STAT (++stat_objects_copied_major);
 106                 *ptr = obj;
 107
 108                 if (sgen_ptr_in_nursery (obj))
 109                         return TRUE;
 110
 111                 /*
 112                  * FIXME: See comment for copy_object_no_checks().  If
 113                  * we have that, we can let the allocation function
 114                  * give us the block info, too, and we won't have to
 115                  * re-fetch it.
 116                  *
 117                  * FIXME (2): We should rework this to avoid all those nursery checks.
 118                  */
 119                 /*
 120                  * For the split nursery allocator the object might
 121                  * still be in the nursery despite having being
 122                  * promoted, in which case we can't mark it.
 123                  */
 124                 block = MS_BLOCK_FOR_OBJ (obj);
 125                 MS_CALC_MARK_BIT (word, bit, obj);
 126                 SGEN_ASSERT (9, !MS_MARK_BIT (block, word, bit), "object %p already marked", obj);
 127                 MS_SET_MARK_BIT (block, word, bit);
 128                 binary_protocol_mark (obj, (gpointer)LOAD_VTABLE (obj), sgen_safe_object_get_size ((MonoObject*)obj));
 129
 130                 return FALSE;
 131         } else {
 132                 mword vtable_word = *(mword*)obj;
 133                 mword desc = sgen_vtable_get_descriptor ((MonoVTable*)vtable_word);
 134                 int type = desc & DESC_TYPE_MASK;
 135
 136                 HEAVY_STAT (++stat_optimized_copy_major);
 137
 138 #ifdef COPY_OR_MARK_WITH_EVACUATION
 139                 {
 140                         char *forwarded;
 141                         if ((forwarded = SGEN_VTABLE_IS_FORWARDED (vtable_word))) {
 142                                 HEAVY_STAT (++stat_optimized_copy_major_forwarded);
 143                                 *ptr = forwarded;
 144                                 SGEN_ASSERT (9, !sgen_ptr_in_nursery (forwarded), "Cannot be forwarded to nursery.");
 145                                 return FALSE;
 146                         }
 147                 }
 148 #endif
 149
 150                 if (type <= DESC_TYPE_MAX_SMALL_OBJ || SGEN_ALIGN_UP (sgen_safe_object_get_size ((MonoObject*)obj)) <= SGEN_MAX_SMALL_OBJ_SIZE) {
 151 #ifdef HEAVY_STATISTICS
 152                         if (type <= DESC_TYPE_MAX_SMALL_OBJ)
 153                                 ++stat_optimized_copy_major_small_fast;
 154                         else
 155                                 ++stat_optimized_copy_major_small_slow;
 156 #endif
 157
 158                         block = MS_BLOCK_FOR_OBJ (obj);
 159
 160 #ifdef COPY_OR_MARK_WITH_EVACUATION
 161                         {
 162                                 int size_index = block->obj_size_index;
 163
 164                                 if (evacuate_block_obj_sizes [size_index] && !block->has_pinned) {
 165                                         HEAVY_STAT (++stat_optimized_copy_major_small_evacuate);
 166                                         if (block->is_to_space)
 167                                                 return FALSE;
 168                                         goto do_copy_object;
 169                                 }
 170                         }
 171 #endif
 172
 173                         MS_MARK_OBJECT_AND_ENQUEUE (obj, desc, block, queue);
 174                 } else {
 175                         HEAVY_STAT (++stat_optimized_copy_major_large);
 176
 177                         if (sgen_los_object_is_pinned (obj))
 178                                 return FALSE;
 179                         binary_protocol_pin (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size ((MonoObject*)obj));
 180
 181                         sgen_los_pin_object (obj);
 182                         if (SGEN_OBJECT_HAS_REFERENCES (obj))
 183                                 GRAY_OBJECT_ENQUEUE (queue, obj, sgen_obj_get_descriptor (obj));
 184                 }
 185                 return FALSE;
 186         }
 187         return FALSE;
 188 }
 189
 190 static void
 191 SCAN_OBJECT_FUNCTION_NAME (char *obj, mword desc, SgenGrayQueue *queue)
 192 {
 193         char *start = obj;
 194
 195 #ifdef HEAVY_STATISTICS
 196         ++stat_optimized_major_scan;
 197         if (!sgen_gc_descr_has_references (desc))
 198                 ++stat_optimized_major_scan_no_refs;
 199         sgen_descriptor_count_scanned_object (desc);
 200 #endif
 201 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
 202         add_scanned_object (start);
 203 #endif
 204
 205         /* Now scan the object. */
 206
 207 #undef HANDLE_PTR
 208 #define HANDLE_PTR(ptr,obj)     do {                                    \
 209                 void *__old = *(ptr);                                   \
 210                 binary_protocol_scan_process_reference ((obj), (ptr), __old); \
 211                 if (__old) {                                            \
 212                         gboolean __still_in_nursery = COPY_OR_MARK_FUNCTION_NAME ((ptr), __old, queue); \
 213                         if (G_UNLIKELY (__still_in_nursery && !sgen_ptr_in_nursery ((ptr)) && !SGEN_OBJECT_IS_CEMENTED (*(ptr)))) { \
 214                                 void *__copy = *(ptr);                  \
 215                                 sgen_add_to_global_remset ((ptr), __copy); \
 216                         }                                               \
 217                 }                                                       \
 218         } while (0)
 219
 220 #define SCAN_OBJECT_PROTOCOL
 221 #include "sgen-scan-object.h"
 222 }
 223
 224 static gboolean
 225 DRAIN_GRAY_STACK_FUNCTION_NAME (ScanCopyContext ctx)
 226 {
 227         SgenGrayQueue *queue = ctx.queue;
 228
 229         SGEN_ASSERT (0, ctx.scan_func == major_scan_object_with_evacuation, "Wrong scan function");
 230
 231         for (;;) {
 232                 char *obj;
 233                 mword desc;
 234
 235                 HEAVY_STAT (++stat_drain_loops);
 236
 237                 GRAY_OBJECT_DEQUEUE (queue, &obj, &desc);
 238                 if (!obj)
 239                         return TRUE;
 240
 241                 SCAN_OBJECT_FUNCTION_NAME (obj, desc, ctx.queue);
 242         }
 243 }
 244
 245 #undef COPY_OR_MARK_FUNCTION_NAME
 246 #undef COPY_OR_MARK_WITH_EVACUATION
 247 #undef SCAN_OBJECT_FUNCTION_NAME
 248 #undef DRAIN_GRAY_STACK_FUNCTION_NAME