mono/metadata/sgen-minor-copy-object.h

   1 /*
   2  * sgen-minor-copy-object.h: Copy functions for nursery collections.
   3  *
   4  * Copyright 2001-2003 Ximian, Inc
   5  * Copyright 2003-2010 Novell, Inc.
   6  * Copyright (C) 2012 Xamarin Inc
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License 2.0 as published by the Free Software Foundation;
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License 2.0 along with this library; if not, write to the Free
  19  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  */
  21
  22 #define collector_pin_object(obj, queue) sgen_pin_object (obj, queue);
  23 #define COLLECTOR_SERIAL_ALLOC_FOR_PROMOTION alloc_for_promotion
  24 #define COLLECTOR_PARALLEL_ALLOC_FOR_PROMOTION par_alloc_for_promotion
  25
  26 extern long long stat_nursery_copy_object_failed_to_space; /* from sgen-gc.c */
  27
  28 #include "sgen-copy-object.h"
  29
  30 /*
  31  * This is how the copying happens from the nursery to the old generation.
  32  * We assume that at this time all the pinned objects have been identified and
  33  * marked as such.
  34  * We run scan_object() for each pinned object so that each referenced
  35  * objects if possible are copied. The new gray objects created can have
  36  * scan_object() run on them right away, too.
  37  * Then we run copy_object() for the precisely tracked roots. At this point
  38  * all the roots are either gray or black. We run scan_object() on the gray
  39  * objects until no more gray objects are created.
  40  * At the end of the process we walk again the pinned list and we unmark
  41  * the pinned flag. As we go we also create the list of free space for use
  42  * in the next allocation runs.
  43  *
  44  * We need to remember objects from the old generation that point to the new one
  45  * (or just addresses?).
  46  *
  47  * copy_object could be made into a macro once debugged (use inline for now).
  48  */
  49
  50 #ifdef _MSC_VER
  51 static __forceinline void
  52 #else
  53 static inline void __attribute__((always_inline))
  54 #endif
  55 SERIAL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue)
  56 {
  57         char *forwarded;
  58         char *obj = *obj_slot;
  59
  60         SGEN_ASSERT (9, current_collection_generation == GENERATION_NURSERY, "calling minor-serial-copy from a %d generation collection", current_collection_generation);
  61
  62         HEAVY_STAT (++stat_copy_object_called_nursery);
  63
  64         if (!sgen_ptr_in_nursery (obj)) {
  65                 HEAVY_STAT (++stat_nursery_copy_object_failed_from_space);
  66                 return;
  67         }
  68
  69         SGEN_LOG (9, "Precise copy of %p from %p", obj, obj_slot);
  70
  71         /*
  72          * Before we can copy the object we must make sure that we are
  73          * allowed to, i.e. that the object not pinned, not already
  74          * forwarded or belongs to the nursery To Space.
  75          */
  76
  77         if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) {
  78                 SGEN_ASSERT (9, (*(MonoVTable**)SGEN_LOAD_VTABLE (obj))->gc_descr,  "forwarded object %p has no gc descriptor", forwarded);
  79                 SGEN_LOG (9, " (already forwarded to %p)", forwarded);
  80                 HEAVY_STAT (++stat_nursery_copy_object_failed_forwarded);
  81                 *obj_slot = forwarded;
  82                 return;
  83         }
  84         if (G_UNLIKELY (SGEN_OBJECT_IS_PINNED (obj))) {
  85                 SGEN_ASSERT (9, ((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr, "pinned object %p has no gc descriptor", obj);
  86                 SGEN_LOG (9, " (pinned, no change)");
  87                 HEAVY_STAT (++stat_nursery_copy_object_failed_pinned);
  88                 return;
  89         }
  90
  91 #ifndef SGEN_SIMPLE_NURSERY
  92         if (sgen_nursery_is_to_space (obj)) {
  93                 SGEN_ASSERT (9, ((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr, "to space object %p has no gc descriptor", obj);
  94                 SGEN_LOG (9, " (tospace, no change)");
  95                 HEAVY_STAT (++stat_nursery_copy_object_failed_to_space);
  96                 return;
  97         }
  98 #endif
  99
 100         HEAVY_STAT (++stat_objects_copied_nursery);
 101
 102         *obj_slot = copy_object_no_checks (obj, queue);
 103 }
 104
 105 /*
 106  * SERIAL_COPY_OBJECT_FROM_OBJ:
 107  *
 108  *   Similar to SERIAL_COPY_OBJECT, but assumes that OBJ_SLOT is part of an object, so it handles global remsets as well.
 109  */
 110 #ifdef _MSC_VER
 111 static __forceinline void
 112 #else
 113 static inline void __attribute__((always_inline))
 114 #endif
 115 SERIAL_COPY_OBJECT_FROM_OBJ (void **obj_slot, SgenGrayQueue *queue)
 116 {
 117         char *forwarded;
 118         char *obj = *obj_slot;
 119         void *copy;
 120
 121         SGEN_ASSERT (9, current_collection_generation == GENERATION_NURSERY, "calling minor-serial-copy-from-obj from a %d generation collection", current_collection_generation);
 122
 123         HEAVY_STAT (++stat_copy_object_called_nursery);
 124
 125         if (!sgen_ptr_in_nursery (obj)) {
 126                 HEAVY_STAT (++stat_nursery_copy_object_failed_from_space);
 127                 return;
 128         }
 129
 130         SGEN_LOG (9, "Precise copy of %p from %p", obj, obj_slot);
 131
 132         /*
 133          * Before we can copy the object we must make sure that we are
 134          * allowed to, i.e. that the object not pinned, not already
 135          * forwarded or belongs to the nursery To Space.
 136          */
 137
 138         if ((forwarded = SGEN_OBJECT_IS_FORWARDED (obj))) {
 139                 SGEN_ASSERT (9, (*(MonoVTable**)SGEN_LOAD_VTABLE (obj))->gc_descr,  "forwarded object %p has no gc descriptor", forwarded);
 140                 SGEN_LOG (9, " (already forwarded to %p)", forwarded);
 141                 HEAVY_STAT (++stat_nursery_copy_object_failed_forwarded);
 142                 *obj_slot = forwarded;
 143 #ifndef SGEN_SIMPLE_NURSERY
 144                 if (G_UNLIKELY (sgen_ptr_in_nursery (forwarded) && !sgen_ptr_in_nursery (obj_slot)))
 145                         sgen_add_to_global_remset (obj_slot);
 146 #endif
 147                 return;
 148         }
 149         if (G_UNLIKELY (SGEN_OBJECT_IS_PINNED (obj))) {
 150                 SGEN_ASSERT (9, ((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr, "pinned object %p has no gc descriptor", obj);
 151                 SGEN_LOG (9, " (pinned, no change)");
 152                 HEAVY_STAT (++stat_nursery_copy_object_failed_pinned);
 153                 if (!sgen_ptr_in_nursery (obj_slot))
 154                         sgen_add_to_global_remset (obj_slot);
 155                 return;
 156         }
 157
 158 #ifndef SGEN_SIMPLE_NURSERY
 159         if (sgen_nursery_is_to_space (obj)) {
 160                 SGEN_ASSERT (9, ((MonoVTable*)SGEN_LOAD_VTABLE(obj))->gc_descr, "to space object %p has no gc descriptor", obj);
 161                 SGEN_LOG (9, " (tospace, no change)");
 162                 HEAVY_STAT (++stat_nursery_copy_object_failed_to_space);
 163                 return;
 164         }
 165 #endif
 166
 167         HEAVY_STAT (++stat_objects_copied_nursery);
 168
 169         copy = copy_object_no_checks (obj, queue);
 170         *obj_slot = copy;
 171 #ifndef SGEN_SIMPLE_NURSERY
 172         if (G_UNLIKELY (sgen_ptr_in_nursery (copy) && !sgen_ptr_in_nursery (obj_slot)))
 173                 sgen_add_to_global_remset (obj_slot);
 174 #else
 175         /* copy_object_no_checks () can return obj on OOM */
 176         if (G_UNLIKELY (obj == copy)) {
 177                 if (G_UNLIKELY (sgen_ptr_in_nursery (copy) && !sgen_ptr_in_nursery (obj_slot)))
 178                         sgen_add_to_global_remset (obj_slot);
 179         }
 180 #endif
 181 }
 182
 183 static void
 184 PARALLEL_COPY_OBJECT (void **obj_slot, SgenGrayQueue *queue)
 185 {
 186         char *obj = *obj_slot;
 187         mword vtable_word, objsize;
 188         MonoVTable *vt;
 189         void *destination;
 190         gboolean has_references;
 191
 192         SGEN_ASSERT (9, current_collection_generation == GENERATION_NURSERY, "calling minor-par-copy from a %d generation collection", current_collection_generation);
 193
 194         HEAVY_STAT (++stat_copy_object_called_nursery);
 195
 196         if (!sgen_ptr_in_nursery (obj)) {
 197                 HEAVY_STAT (++stat_nursery_copy_object_failed_from_space);
 198                 return;
 199         }
 200
 201         vtable_word = *(mword*)obj;
 202         vt = (MonoVTable*)(vtable_word & ~SGEN_VTABLE_BITS_MASK);
 203
 204         /*
 205          * Before we can copy the object we must make sure that we are
 206          * allowed to, i.e. that the object not pinned, not already
 207          * forwarded and not in the nursery To Space.
 208          */
 209
 210         if (vtable_word & SGEN_FORWARDED_BIT) {
 211                 HEAVY_STAT (++stat_nursery_copy_object_failed_forwarded);
 212                 *obj_slot = vt;
 213                 return;
 214         }
 215         if (vtable_word & SGEN_PINNED_BIT) {
 216                 HEAVY_STAT (++stat_nursery_copy_object_failed_pinned);
 217                 return;
 218         }
 219
 220         if (sgen_nursery_is_to_space (obj)) {
 221                 HEAVY_STAT (++stat_nursery_copy_object_failed_to_space);
 222                 return;
 223         }
 224
 225         HEAVY_STAT (++stat_objects_copied_nursery);
 226
 227         objsize = SGEN_ALIGN_UP (sgen_par_object_get_size (vt, (MonoObject*)obj));
 228         has_references = SGEN_VTABLE_HAS_REFERENCES (vt);
 229
 230         destination = COLLECTOR_PARALLEL_ALLOC_FOR_PROMOTION (obj, objsize, has_references);
 231
 232         if (G_UNLIKELY (!destination)) {
 233                 sgen_parallel_pin_or_update (obj_slot, obj, vt, queue);
 234                 return;
 235         }
 236
 237         *(MonoVTable**)destination = vt;
 238
 239         if (SGEN_CAS_PTR ((void*)obj, (void*)((mword)destination | SGEN_FORWARDED_BIT), vt) == vt) {
 240                 par_copy_object_no_checks (destination, vt, obj, objsize, has_references ? queue : NULL);
 241                 obj = destination;
 242                 *obj_slot = obj;
 243         } else {
 244                 /* FIXME: unify with code in major_copy_or_mark_object() */
 245
 246                 /* FIXME: Give destination back to the allocator. */
 247                 /*The major collector only needs the first word zeroed and nursery requires all bits to be. */
 248                 if (!sgen_ptr_in_nursery (destination))
 249                         *(void**)destination = NULL;
 250                 else
 251                         memset (destination, 0, objsize);
 252
 253                 vtable_word = *(mword*)obj;
 254                 g_assert (vtable_word & SGEN_FORWARDED_BIT);
 255
 256                 obj = (void*)(vtable_word & ~SGEN_VTABLE_BITS_MASK);
 257
 258                 *obj_slot = obj;
 259
 260                 HEAVY_STAT (++stat_slots_allocated_in_vain);
 261         }
 262 }
 263
 264 #define FILL_MINOR_COLLECTOR_COPY_OBJECT(collector)     do {                    \
 265                 (collector)->serial_ops.copy_or_mark_object = SERIAL_COPY_OBJECT;                       \
 266                 (collector)->parallel_ops.copy_or_mark_object = PARALLEL_COPY_OBJECT;   \
 267         } while (0)