mono/metadata/sgen-old-bridge.c

   1 /*
   2  * sgen-bridge.c: Simple generational GC.
   3  *
   4  * Copyright 2011 Novell, Inc (http://www.novell.com)
   5  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
   6  * Copyright 2001-2003 Ximian, Inc
   7  * Copyright 2003-2010 Novell, Inc.
   8  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
   9  */
  10
  11 #include "config.h"
  12
  13 #ifdef HAVE_SGEN_GC
  14
  15 #include <stdlib.h>
  16
  17 #include "sgen/sgen-gc.h"
  18 #include "sgen-bridge-internals.h"
  19 #include "sgen/sgen-hash-table.h"
  20 #include "sgen/sgen-qsort.h"
  21 #include "sgen/sgen-client.h"
  22 #include "utils/mono-logger-internals.h"
  23
  24 typedef struct {
  25         int size;
  26         int capacity;
  27         char *data;
  28 } DynArray;
  29
  30 /*Specializations*/
  31
  32 typedef struct {
  33         DynArray array;
  34 } DynIntArray;
  35
  36 typedef struct {
  37         DynArray array;
  38 } DynPtrArray;
  39
  40 typedef struct {
  41         DynArray array;
  42 } DynSCCArray;
  43
  44 /*
  45  * Bridge data for a single managed object
  46  *
  47  * FIXME: Optimizations:
  48  *
  49  * Don't allocate a srcs array for just one source.  Most objects have
  50  * just one source, so use the srcs pointer itself.
  51  */
  52 typedef struct _HashEntry {
  53         GCObject *obj;  /* This is a duplicate - it's already stored in the hash table */
  54
  55         gboolean is_bridge;
  56         gboolean is_visited;
  57
  58         int finishing_time;
  59
  60         // "Source" managed objects pointing at this destination
  61         DynPtrArray srcs;
  62
  63         // Index in sccs array of SCC this object was folded into
  64         int scc_index;
  65 } HashEntry;
  66
  67 typedef struct {
  68         HashEntry entry;
  69         double weight;
  70 } HashEntryWithAccounting;
  71
  72 // The graph of managed objects/HashEntries is reduced to a graph of strongly connected components
  73 typedef struct _SCC {
  74         int index;
  75         int api_index;
  76
  77         // How many bridged objects does this SCC hold references to?
  78         int num_bridge_entries;
  79
  80         // Index in global sccs array of SCCs holding pointers to this SCC
  81         DynIntArray xrefs;              /* these are incoming, not outgoing */
  82 } SCC;
  83
  84 // Maps managed objects to corresponding HashEntry stricts
  85 static SgenHashTable hash_table = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_OLD_BRIDGE_HASH_TABLE, INTERNAL_MEM_OLD_BRIDGE_HASH_TABLE_ENTRY, sizeof (HashEntry), mono_aligned_addr_hash, NULL);
  86
  87 static int current_time;
  88
  89 static gboolean bridge_accounting_enabled = FALSE;
  90
  91 static SgenBridgeProcessor *bridge_processor;
  92
  93 /* Core functions */
  94 /* public */
  95
  96 /* private */
  97
  98 static void
  99 dyn_array_init (DynArray *da)
 100 {
 101         da->size = 0;
 102         da->capacity = 0;
 103         da->data = NULL;
 104 }
 105
 106 static void
 107 dyn_array_uninit (DynArray *da, int elem_size)
 108 {
 109         if (da->capacity <= 0)
 110                 return;
 111
 112         sgen_free_internal_dynamic (da->data, elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA);
 113         da->data = NULL;
 114 }
 115
 116 static void
 117 dyn_array_ensure_capacity (DynArray *da, int capacity, int elem_size)
 118 {
 119         int old_capacity = da->capacity;
 120         char *new_data;
 121
 122         if (capacity <= old_capacity)
 123                 return;
 124
 125         if (da->capacity == 0)
 126                 da->capacity = 2;
 127         while (capacity > da->capacity)
 128                 da->capacity *= 2;
 129
 130         new_data = (char *)sgen_alloc_internal_dynamic (elem_size * da->capacity, INTERNAL_MEM_BRIDGE_DATA, TRUE);
 131         memcpy (new_data, da->data, elem_size * da->size);
 132         sgen_free_internal_dynamic (da->data, elem_size * old_capacity, INTERNAL_MEM_BRIDGE_DATA);
 133         da->data = new_data;
 134 }
 135
 136 static void*
 137 dyn_array_add (DynArray *da, int elem_size)
 138 {
 139         void *p;
 140
 141         dyn_array_ensure_capacity (da, da->size + 1, elem_size);
 142
 143         p = da->data + da->size * elem_size;
 144         ++da->size;
 145         return p;
 146 }
 147
 148 /* int */
 149 static void
 150 dyn_array_int_init (DynIntArray *da)
 151 {
 152         dyn_array_init (&da->array);
 153 }
 154
 155 static void
 156 dyn_array_int_uninit (DynIntArray *da)
 157 {
 158         dyn_array_uninit (&da->array, sizeof (int));
 159 }
 160
 161 static int
 162 dyn_array_int_size (DynIntArray *da)
 163 {
 164         return da->array.size;
 165 }
 166
 167 static void
 168 dyn_array_int_set_size (DynIntArray *da, int size)
 169 {
 170         da->array.size = size;
 171 }
 172
 173 static void
 174 dyn_array_int_add (DynIntArray *da, int x)
 175 {
 176         int *p = (int *)dyn_array_add (&da->array, sizeof (int));
 177         *p = x;
 178 }
 179
 180 static int
 181 dyn_array_int_get (DynIntArray *da, int x)
 182 {
 183         return ((int*)da->array.data)[x];
 184 }
 185
 186 static void
 187 dyn_array_int_set (DynIntArray *da, int idx, int val)
 188 {
 189         ((int*)da->array.data)[idx] = val;
 190 }
 191
 192 static void
 193 dyn_array_int_ensure_capacity (DynIntArray *da, int capacity)
 194 {
 195         dyn_array_ensure_capacity (&da->array, capacity, sizeof (int));
 196 }
 197
 198 static void
 199 dyn_array_int_set_all (DynIntArray *dst, DynIntArray *src)
 200 {
 201         dyn_array_int_ensure_capacity (dst, src->array.size);
 202         memcpy (dst->array.data, src->array.data, src->array.size * sizeof (int));
 203         dst->array.size = src->array.size;
 204 }
 205
 206 /* ptr */
 207
 208 static void
 209 dyn_array_ptr_init (DynPtrArray *da)
 210 {
 211         dyn_array_init (&da->array);
 212 }
 213
 214 static void
 215 dyn_array_ptr_uninit (DynPtrArray *da)
 216 {
 217         dyn_array_uninit (&da->array, sizeof (void*));
 218 }
 219
 220 static int
 221 dyn_array_ptr_size (DynPtrArray *da)
 222 {
 223         return da->array.size;
 224 }
 225
 226 static void
 227 dyn_array_ptr_set_size (DynPtrArray *da, int size)
 228 {
 229         da->array.size = size;
 230 }
 231
 232 static void*
 233 dyn_array_ptr_get (DynPtrArray *da, int x)
 234 {
 235         return ((void**)da->array.data)[x];
 236 }
 237
 238 static void
 239 dyn_array_ptr_add (DynPtrArray *da, void *ptr)
 240 {
 241         void **p = (void **)dyn_array_add (&da->array, sizeof (void*));
 242         *p = ptr;
 243 }
 244
 245 #define dyn_array_ptr_push dyn_array_ptr_add
 246
 247 static void*
 248 dyn_array_ptr_pop (DynPtrArray *da)
 249 {
 250         void *p;
 251         int size = da->array.size;
 252         g_assert (size > 0);
 253         p = dyn_array_ptr_get (da, size - 1);
 254         --da->array.size;
 255         return p;
 256 }
 257
 258 /*SCC */
 259
 260 static void
 261 dyn_array_scc_init (DynSCCArray *da)
 262 {
 263         dyn_array_init (&da->array);
 264 }
 265
 266 static void
 267 dyn_array_scc_uninit (DynSCCArray *da)
 268 {
 269         dyn_array_uninit (&da->array, sizeof (SCC));
 270 }
 271
 272 static int
 273 dyn_array_scc_size (DynSCCArray *da)
 274 {
 275         return da->array.size;
 276 }
 277
 278 static SCC*
 279 dyn_array_scc_add (DynSCCArray *da)
 280 {
 281         return (SCC *)dyn_array_add (&da->array, sizeof (SCC));
 282 }
 283
 284 static SCC*
 285 dyn_array_scc_get_ptr (DynSCCArray *da, int x)
 286 {
 287         return &((SCC*)da->array.data)[x];
 288 }
 289
 290 /* Merge code*/
 291
 292 static DynIntArray merge_array;
 293
 294 static gboolean
 295 dyn_array_int_contains (DynIntArray *da, int x)
 296 {
 297         int i;
 298         for (i = 0; i < dyn_array_int_size (da); ++i)
 299                 if (dyn_array_int_get (da, i) == x)
 300                         return TRUE;
 301         return FALSE;
 302 }
 303
 304
 305 static void
 306 dyn_array_int_merge (DynIntArray *dst, DynIntArray *src)
 307 {
 308         int i, j;
 309
 310         dyn_array_int_ensure_capacity (&merge_array, dyn_array_int_size (dst) + dyn_array_int_size (src));
 311         dyn_array_int_set_size (&merge_array, 0);
 312
 313         for (i = j = 0; i < dyn_array_int_size (dst) || j < dyn_array_int_size (src); ) {
 314                 if (i < dyn_array_int_size (dst) && j < dyn_array_int_size (src)) {
 315                         int a = dyn_array_int_get (dst, i);
 316                         int b = dyn_array_int_get (src, j);
 317                         if (a < b) {
 318                                 dyn_array_int_add (&merge_array, a);
 319                                 ++i;
 320                         } else if (a == b) {
 321                                 dyn_array_int_add (&merge_array, a);
 322                                 ++i;
 323                                 ++j;
 324                         } else {
 325                                 dyn_array_int_add (&merge_array, b);
 326                                 ++j;
 327                         }
 328                 } else if (i < dyn_array_int_size (dst)) {
 329                         dyn_array_int_add (&merge_array, dyn_array_int_get (dst, i));
 330                         ++i;
 331                 } else {
 332                         dyn_array_int_add (&merge_array, dyn_array_int_get (src, j));
 333                         ++j;
 334                 }
 335         }
 336
 337         if (dyn_array_int_size (&merge_array) > dyn_array_int_size (dst)) {
 338                 dyn_array_int_set_all (dst, &merge_array);
 339         }
 340 }
 341
 342 static void
 343 dyn_array_int_merge_one (DynIntArray *array, int value)
 344 {
 345         int i;
 346         int tmp;
 347         int size = dyn_array_int_size (array);
 348
 349         for (i = 0; i < size; ++i) {
 350                 if (dyn_array_int_get (array, i) == value)
 351                         return;
 352                 else if (dyn_array_int_get (array, i) > value)
 353                         break;
 354         }
 355
 356         dyn_array_int_ensure_capacity (array, size + 1);
 357
 358         if (i < size) {
 359                 tmp = dyn_array_int_get (array, i);
 360                 for (; i < size; ++i) {
 361                         dyn_array_int_set (array, i, value);
 362                         value = tmp;
 363                         tmp = dyn_array_int_get (array, i + 1);
 364                 }
 365                 dyn_array_int_set (array, size, value);
 366         } else {
 367                 dyn_array_int_set (array, size, value);
 368         }
 369
 370         dyn_array_int_set_size (array, size + 1);
 371 }
 372
 373
 374 static void
 375 enable_accounting (void)
 376 {
 377         SgenHashTable table = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_HASH_TABLE, INTERNAL_MEM_BRIDGE_HASH_TABLE_ENTRY, sizeof (HashEntryWithAccounting), mono_aligned_addr_hash, NULL);
 378         bridge_accounting_enabled = TRUE;
 379         hash_table = table;
 380 }
 381
 382 static MonoGCBridgeObjectKind
 383 class_kind (MonoClass *klass)
 384 {
 385         return bridge_callbacks.bridge_class_kind (klass);
 386 }
 387
 388 static HashEntry*
 389 get_hash_entry (GCObject *obj, gboolean *existing)
 390 {
 391         HashEntry *entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
 392         HashEntry new_entry;
 393
 394         if (entry) {
 395                 if (existing)
 396                         *existing = TRUE;
 397                 return entry;
 398         }
 399         if (existing)
 400                 *existing = FALSE;
 401
 402         memset (&new_entry, 0, sizeof (HashEntry));
 403
 404         new_entry.obj = obj;
 405         dyn_array_ptr_init (&new_entry.srcs);
 406         new_entry.finishing_time = -1;
 407         new_entry.scc_index = -1;
 408
 409         sgen_hash_table_replace (&hash_table, obj, &new_entry, NULL);
 410
 411         return (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
 412 }
 413
 414 static void
 415 add_source (HashEntry *entry, HashEntry *src)
 416 {
 417         dyn_array_ptr_add (&entry->srcs, src);
 418 }
 419
 420 static void
 421 free_data (void)
 422 {
 423         GCObject *obj G_GNUC_UNUSED;
 424         HashEntry *entry;
 425         int total_srcs = 0;
 426         int max_srcs = 0;
 427
 428         SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
 429                 int entry_size = dyn_array_ptr_size (&entry->srcs);
 430                 total_srcs += entry_size;
 431                 if (entry_size > max_srcs)
 432                         max_srcs = entry_size;
 433                 dyn_array_ptr_uninit (&entry->srcs);
 434         } SGEN_HASH_TABLE_FOREACH_END;
 435
 436         sgen_hash_table_clean (&hash_table);
 437
 438         dyn_array_int_uninit (&merge_array);
 439         //g_print ("total srcs %d - max %d\n", total_srcs, max_srcs);
 440 }
 441
 442 static HashEntry*
 443 register_bridge_object (GCObject *obj)
 444 {
 445         HashEntry *entry = get_hash_entry (obj, NULL);
 446         entry->is_bridge = TRUE;
 447         return entry;
 448 }
 449
 450 static void
 451 register_finishing_time (HashEntry *entry, int t)
 452 {
 453         g_assert (entry->finishing_time < 0);
 454         entry->finishing_time = t;
 455 }
 456
 457 static gboolean
 458 object_is_live (GCObject **objp)
 459 {
 460         GCObject *obj = *objp;
 461         GCObject *fwd = SGEN_OBJECT_IS_FORWARDED (obj);
 462         if (fwd) {
 463                 *objp = fwd;
 464                 return sgen_hash_table_lookup (&hash_table, fwd) == NULL;
 465         }
 466         if (!sgen_object_is_live (obj))
 467                 return FALSE;
 468         return sgen_hash_table_lookup (&hash_table, obj) == NULL;
 469 }
 470
 471 static DynPtrArray registered_bridges;
 472 static DynPtrArray dfs_stack;
 473
 474 static int dfs1_passes, dfs2_passes;
 475
 476
 477 #undef HANDLE_PTR
 478 #define HANDLE_PTR(ptr,obj)     do {                                    \
 479                 GCObject *dst = (GCObject*)*(ptr);                      \
 480                 if (dst && !object_is_live (&dst)) {                    \
 481                         dyn_array_ptr_push (&dfs_stack, obj_entry);     \
 482                         dyn_array_ptr_push (&dfs_stack, get_hash_entry (dst, NULL)); \
 483                 }                                                       \
 484         } while (0)
 485
 486 static void
 487 dfs1 (HashEntry *obj_entry)
 488 {
 489         HashEntry *src;
 490         g_assert (dyn_array_ptr_size (&dfs_stack) == 0);
 491
 492         dyn_array_ptr_push (&dfs_stack, NULL);
 493         dyn_array_ptr_push (&dfs_stack, obj_entry);
 494
 495         do {
 496                 GCObject *obj;
 497                 ++dfs1_passes;
 498
 499                 obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
 500                 if (obj_entry) {
 501                         char *start;
 502                         mword desc;
 503                         src = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
 504
 505                         obj = obj_entry->obj;
 506                         desc = sgen_obj_get_descriptor_safe (obj);
 507
 508                         if (src) {
 509                                 //g_print ("link %s -> %s\n", sgen_safe_name (src->obj), sgen_safe_name (obj));
 510                                 add_source (obj_entry, src);
 511                         } else {
 512                                 //g_print ("starting with %s\n", sgen_safe_name (obj));
 513                         }
 514
 515                         if (obj_entry->is_visited)
 516                                 continue;
 517
 518                         obj_entry->is_visited = TRUE;
 519
 520                         dyn_array_ptr_push (&dfs_stack, obj_entry);
 521                         /* NULL marks that the next entry is to be finished */
 522                         dyn_array_ptr_push (&dfs_stack, NULL);
 523
 524                         start = (char*)obj;
 525 #include "sgen/sgen-scan-object.h"
 526                 } else {
 527                         obj_entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
 528
 529                         //g_print ("finish %s\n", sgen_safe_name (obj_entry->obj));
 530                         register_finishing_time (obj_entry, current_time++);
 531                 }
 532         } while (dyn_array_ptr_size (&dfs_stack) > 0);
 533 }
 534
 535 static void
 536 scc_add_xref (SCC *src, SCC *dst)
 537 {
 538         g_assert (src != dst);
 539         g_assert (src->index != dst->index);
 540
 541         if (dyn_array_int_contains (&dst->xrefs, src->index))
 542                 return;
 543         if (src->num_bridge_entries) {
 544                 dyn_array_int_merge_one (&dst->xrefs, src->index);
 545         } else {
 546                 int i;
 547                 dyn_array_int_merge (&dst->xrefs, &src->xrefs);
 548                 for (i = 0; i < dyn_array_int_size (&dst->xrefs); ++i)
 549                         g_assert (dyn_array_int_get (&dst->xrefs, i) != dst->index);
 550         }
 551 }
 552
 553 static void
 554 scc_add_entry (SCC *scc, HashEntry *entry)
 555 {
 556         g_assert (entry->scc_index < 0);
 557         entry->scc_index = scc->index;
 558         if (entry->is_bridge)
 559                 ++scc->num_bridge_entries;
 560 }
 561
 562 static DynSCCArray sccs;
 563 static SCC *current_scc;
 564
 565 static void
 566 dfs2 (HashEntry *entry)
 567 {
 568         int i;
 569
 570         g_assert (dyn_array_ptr_size (&dfs_stack) == 0);
 571
 572         dyn_array_ptr_push (&dfs_stack, entry);
 573
 574         do {
 575                 entry = (HashEntry *)dyn_array_ptr_pop (&dfs_stack);
 576                 ++dfs2_passes;
 577
 578                 if (entry->scc_index >= 0) {
 579                         if (entry->scc_index != current_scc->index)
 580                                 scc_add_xref (dyn_array_scc_get_ptr (&sccs, entry->scc_index), current_scc);
 581                         continue;
 582                 }
 583
 584                 scc_add_entry (current_scc, entry);
 585
 586                 for (i = 0; i < dyn_array_ptr_size (&entry->srcs); ++i)
 587                         dyn_array_ptr_push (&dfs_stack, dyn_array_ptr_get (&entry->srcs, i));
 588         } while (dyn_array_ptr_size (&dfs_stack) > 0);
 589 }
 590
 591 static int
 592 compare_hash_entries (const HashEntry *e1, const HashEntry *e2)
 593 {
 594         return e2->finishing_time - e1->finishing_time;
 595 }
 596
 597 DEF_QSORT_INLINE(hash_entries, HashEntry*, compare_hash_entries)
 598
 599 static gint64 step_1, step_2, step_3, step_4, step_5, step_6;
 600 static int fist_pass_links, second_pass_links, sccs_links;
 601 static int max_sccs_links = 0;
 602
 603 static void
 604 register_finalized_object (GCObject *obj)
 605 {
 606         g_assert (sgen_need_bridge_processing ());
 607         dyn_array_ptr_push (&registered_bridges, obj);
 608 }
 609
 610 static void
 611 reset_data (void)
 612 {
 613         dyn_array_ptr_set_size (&registered_bridges, 0);
 614 }
 615
 616 static void
 617 processing_stw_step (void)
 618 {
 619         int i;
 620         int bridge_count;
 621         SGEN_TV_DECLARE (atv);
 622         SGEN_TV_DECLARE (btv);
 623
 624         if (!dyn_array_ptr_size (&registered_bridges))
 625                 return;
 626
 627         SGEN_TV_GETTIME (btv);
 628
 629         /* first DFS pass */
 630
 631         dyn_array_ptr_init (&dfs_stack);
 632         dyn_array_int_init (&merge_array);
 633
 634         current_time = 0;
 635         /*
 636         First we insert all bridges into the hash table and then we do dfs1.
 637
 638         It must be done in 2 steps since the bridge arrays doesn't come in reverse topological order,
 639         which means that we can have entry N pointing to entry N + 1.
 640
 641         If we dfs1 entry N before N + 1 is registered we'll not consider N + 1 for this bridge
 642         pass and not create the required xref between the two.
 643         */
 644         bridge_count = dyn_array_ptr_size (&registered_bridges);
 645         for (i = 0; i < bridge_count ; ++i)
 646                 register_bridge_object ((GCObject *)dyn_array_ptr_get (&registered_bridges, i));
 647
 648         for (i = 0; i < bridge_count; ++i)
 649                 dfs1 (get_hash_entry ((GCObject *)dyn_array_ptr_get (&registered_bridges, i), NULL));
 650
 651         SGEN_TV_GETTIME (atv);
 652         step_2 = SGEN_TV_ELAPSED (btv, atv);
 653 }
 654
 655 static int num_registered_bridges, hash_table_size;
 656
 657 static void
 658 processing_build_callback_data (int generation)
 659 {
 660         int i, j;
 661         int num_sccs, num_xrefs;
 662         int max_entries, max_xrefs;
 663         GCObject *obj G_GNUC_UNUSED;
 664         HashEntry *entry;
 665         HashEntry **all_entries;
 666         MonoGCBridgeSCC **api_sccs;
 667         MonoGCBridgeXRef *api_xrefs;
 668         SGEN_TV_DECLARE (atv);
 669         SGEN_TV_DECLARE (btv);
 670
 671         g_assert (bridge_processor->num_sccs == 0 && bridge_processor->num_xrefs == 0);
 672         g_assert (!bridge_processor->api_sccs && !bridge_processor->api_xrefs);
 673
 674         if (!dyn_array_ptr_size (&registered_bridges))
 675                 return;
 676
 677         g_assert (bridge_processing_in_progress);
 678
 679         SGEN_TV_GETTIME (atv);
 680
 681         /* alloc and fill array of all entries */
 682
 683         all_entries = (HashEntry **)sgen_alloc_internal_dynamic (sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
 684
 685         j = 0;
 686         SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
 687                 g_assert (entry->finishing_time >= 0);
 688                 all_entries [j++] = entry;
 689                 fist_pass_links += dyn_array_ptr_size (&entry->srcs);
 690         } SGEN_HASH_TABLE_FOREACH_END;
 691         g_assert (j == hash_table.num_entries);
 692         hash_table_size = hash_table.num_entries;
 693
 694         /* sort array according to decreasing finishing time */
 695         qsort_hash_entries (all_entries, hash_table.num_entries);
 696
 697         SGEN_TV_GETTIME (btv);
 698         step_3 = SGEN_TV_ELAPSED (atv, btv);
 699
 700         /* second DFS pass */
 701
 702         dyn_array_scc_init (&sccs);
 703         for (i = 0; i < hash_table.num_entries; ++i) {
 704                 HashEntry *entry = all_entries [i];
 705                 if (entry->scc_index < 0) {
 706                         int index = dyn_array_scc_size (&sccs);
 707                         current_scc = dyn_array_scc_add (&sccs);
 708                         current_scc->index = index;
 709                         current_scc->num_bridge_entries = 0;
 710                         current_scc->api_index = -1;
 711                         dyn_array_int_init (&current_scc->xrefs);
 712
 713                         dfs2 (entry);
 714                 }
 715         }
 716
 717         /*
 718          * Compute the weight of each object. The weight of an object is its size plus the size of all
 719          * objects it points do. When the an object is pointed by multiple objects we distribute it's weight
 720          * equally among them. This distribution gives a rough estimate of the real impact of making the object
 721          * go away.
 722          *
 723          * The reasoning for this model is that complex graphs with single roots will have a bridge with very high
 724          * value in comparison to others.
 725          *
 726          * The all_entries array has all objects topologically sorted. To correctly propagate the weights it must be
 727          * done in reverse topological order - so we calculate the weight of the pointed-to objects before processing
 728          * pointer-from objects.
 729          *
 730          * We log those objects in the opposite order for no particular reason. The other constrain is that it should use the same
 731          * direction as the other logging loop that records live/dead information.
 732          */
 733         if (bridge_accounting_enabled) {
 734                 for (i = hash_table.num_entries - 1; i >= 0; --i) {
 735                         double w;
 736                         HashEntryWithAccounting *entry = (HashEntryWithAccounting*)all_entries [i];
 737
 738                         entry->weight += (double)sgen_safe_object_get_size (entry->entry.obj);
 739                         w = entry->weight / dyn_array_ptr_size (&entry->entry.srcs);
 740                         for (j = 0; j < dyn_array_ptr_size (&entry->entry.srcs); ++j) {
 741                                 HashEntryWithAccounting *other = (HashEntryWithAccounting *)dyn_array_ptr_get (&entry->entry.srcs, j);
 742                                 other->weight += w;
 743                         }
 744                 }
 745                 for (i = 0; i < hash_table.num_entries; ++i) {
 746                         HashEntryWithAccounting *entry = (HashEntryWithAccounting*)all_entries [i];
 747                         if (entry->entry.is_bridge) {
 748                                 MonoClass *klass = SGEN_LOAD_VTABLE (entry->entry.obj)->klass;
 749                                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "OBJECT %s::%s (%p) weight %f", klass->name_space, klass->name, entry->entry.obj, entry->weight);
 750                         }
 751                 }
 752         }
 753
 754         for (i = 0; i < hash_table.num_entries; ++i) {
 755                 HashEntry *entry = all_entries [i];
 756                 second_pass_links += dyn_array_ptr_size (&entry->srcs);
 757         }
 758
 759         SGEN_TV_GETTIME (atv);
 760         step_4 = SGEN_TV_ELAPSED (btv, atv);
 761
 762         //g_print ("%d sccs\n", sccs.size);
 763
 764         dyn_array_ptr_uninit (&dfs_stack);
 765
 766         /* init data for callback */
 767
 768         num_sccs = 0;
 769         for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
 770                 SCC *scc = dyn_array_scc_get_ptr (&sccs, i);
 771                 g_assert (scc->index == i);
 772                 if (scc->num_bridge_entries)
 773                         ++num_sccs;
 774                 sccs_links += dyn_array_int_size (&scc->xrefs);
 775                 max_sccs_links = MAX (max_sccs_links, dyn_array_int_size (&scc->xrefs));
 776         }
 777
 778         api_sccs = (MonoGCBridgeSCC **)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC*) * num_sccs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
 779         num_xrefs = 0;
 780         j = 0;
 781         for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
 782                 SCC *scc = dyn_array_scc_get_ptr (&sccs, i);
 783                 if (!scc->num_bridge_entries)
 784                         continue;
 785
 786                 api_sccs [j] = (MonoGCBridgeSCC *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeSCC) + sizeof (MonoObject*) * scc->num_bridge_entries, INTERNAL_MEM_BRIDGE_DATA, TRUE);
 787                 api_sccs [j]->is_alive = FALSE;
 788                 api_sccs [j]->num_objs = scc->num_bridge_entries;
 789                 scc->num_bridge_entries = 0;
 790                 scc->api_index = j++;
 791
 792                 num_xrefs += dyn_array_int_size (&scc->xrefs);
 793         }
 794
 795         SGEN_HASH_TABLE_FOREACH (&hash_table, GCObject *, obj, HashEntry *, entry) {
 796                 if (entry->is_bridge) {
 797                         SCC *scc = dyn_array_scc_get_ptr (&sccs, entry->scc_index);
 798                         api_sccs [scc->api_index]->objs [scc->num_bridge_entries++] = (MonoObject*)entry->obj;
 799                 }
 800         } SGEN_HASH_TABLE_FOREACH_END;
 801
 802         api_xrefs = (MonoGCBridgeXRef *)sgen_alloc_internal_dynamic (sizeof (MonoGCBridgeXRef) * num_xrefs, INTERNAL_MEM_BRIDGE_DATA, TRUE);
 803         j = 0;
 804         for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
 805                 int k;
 806                 SCC *scc = dyn_array_scc_get_ptr (&sccs, i);
 807                 if (!scc->num_bridge_entries)
 808                         continue;
 809                 for (k = 0; k < dyn_array_int_size (&scc->xrefs); ++k) {
 810                         SCC *src_scc = dyn_array_scc_get_ptr (&sccs, dyn_array_int_get (&scc->xrefs, k));
 811                         if (!src_scc->num_bridge_entries)
 812                                 continue;
 813                         api_xrefs [j].src_scc_index = src_scc->api_index;
 814                         api_xrefs [j].dst_scc_index = scc->api_index;
 815                         ++j;
 816                 }
 817         }
 818
 819         SGEN_TV_GETTIME (btv);
 820         step_5 = SGEN_TV_ELAPSED (atv, btv);
 821
 822         /* free data */
 823
 824         j = 0;
 825         max_entries = max_xrefs = 0;
 826         for (i = 0; i < dyn_array_scc_size (&sccs); ++i) {
 827                 SCC *scc = dyn_array_scc_get_ptr (&sccs, i);
 828                 if (scc->num_bridge_entries)
 829                         ++j;
 830                 if (scc->num_bridge_entries > max_entries)
 831                         max_entries = scc->num_bridge_entries;
 832                 if (dyn_array_int_size (&scc->xrefs) > max_xrefs)
 833                         max_xrefs = dyn_array_int_size (&scc->xrefs);
 834                 dyn_array_int_uninit (&scc->xrefs);
 835
 836         }
 837         dyn_array_scc_uninit (&sccs);
 838
 839         sgen_free_internal_dynamic (all_entries, sizeof (HashEntry*) * hash_table.num_entries, INTERNAL_MEM_BRIDGE_DATA);
 840
 841         free_data ();
 842         /* Empty the registered bridges array */
 843         num_registered_bridges = dyn_array_ptr_size (&registered_bridges);
 844         dyn_array_ptr_set_size (&registered_bridges, 0);
 845
 846         SGEN_TV_GETTIME (atv);
 847         step_6 = SGEN_TV_ELAPSED (btv, atv);
 848
 849         //g_print ("%d sccs containing bridges - %d max bridge objects - %d max xrefs\n", j, max_entries, max_xrefs);
 850
 851         bridge_processor->num_sccs = num_sccs;
 852         bridge_processor->api_sccs = api_sccs;
 853         bridge_processor->num_xrefs = num_xrefs;
 854         bridge_processor->api_xrefs = api_xrefs;
 855 }
 856
 857 static void
 858 processing_after_callback (int generation)
 859 {
 860         int i, j;
 861         int num_sccs = bridge_processor->num_sccs;
 862         MonoGCBridgeSCC **api_sccs = bridge_processor->api_sccs;
 863
 864         if (bridge_accounting_enabled) {
 865                 for (i = 0; i < num_sccs; ++i) {
 866                         for (j = 0; j < api_sccs [i]->num_objs; ++j) {
 867                                 GCVTable vtable = SGEN_LOAD_VTABLE (api_sccs [i]->objs [j]);
 868                                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC,
 869                                         "OBJECT %s.%s (%p) SCC [%d] %s",
 870                                                 sgen_client_vtable_get_namespace (vtable), sgen_client_vtable_get_name (vtable), api_sccs [i]->objs [j],
 871                                                 i,
 872                                                 api_sccs [i]->is_alive  ? "ALIVE" : "DEAD");
 873                         }
 874                 }
 875         }
 876
 877         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_OLD_BRIDGE num-objects %d num_hash_entries %d sccs size %d init %.2fms df1 %.2fms sort %.2fms dfs2 %.2fms setup-cb %.2fms free-data %.2fms links %d/%d/%d/%d dfs passes %d/%d",
 878                 num_registered_bridges, hash_table_size, dyn_array_scc_size (&sccs),
 879                 step_1 / 10000.0f,
 880                 step_2 / 10000.0f,
 881                 step_3 / 10000.0f,
 882                 step_4 / 10000.0f,
 883                 step_5 / 10000.0f,
 884                 step_6 / 10000.0f,
 885                 fist_pass_links, second_pass_links, sccs_links, max_sccs_links,
 886                 dfs1_passes, dfs2_passes);
 887
 888         step_1 = 0; /* We must cleanup since this value is used as an accumulator. */
 889         fist_pass_links = second_pass_links = sccs_links = max_sccs_links = 0;
 890         dfs1_passes = dfs2_passes = 0;
 891 }
 892
 893 static void
 894 describe_pointer (GCObject *obj)
 895 {
 896         HashEntry *entry;
 897         int i;
 898
 899         for (i = 0; i < dyn_array_ptr_size (&registered_bridges); ++i) {
 900                 if (obj == dyn_array_ptr_get (&registered_bridges, i)) {
 901                         printf ("Pointer is a registered bridge object.\n");
 902                         break;
 903                 }
 904         }
 905
 906         entry = (HashEntry *)sgen_hash_table_lookup (&hash_table, obj);
 907         if (!entry)
 908                 return;
 909
 910         printf ("Bridge hash table entry %p:\n", entry);
 911         printf ("  is bridge: %d\n", (int)entry->is_bridge);
 912         printf ("  is visited: %d\n", (int)entry->is_visited);
 913 }
 914
 915 void
 916 sgen_old_bridge_init (SgenBridgeProcessor *collector)
 917 {
 918         collector->reset_data = reset_data;
 919         collector->processing_stw_step = processing_stw_step;
 920         collector->processing_build_callback_data = processing_build_callback_data;
 921         collector->processing_after_callback = processing_after_callback;
 922         collector->class_kind = class_kind;
 923         collector->register_finalized_object = register_finalized_object;
 924         collector->describe_pointer = describe_pointer;
 925         collector->enable_accounting = enable_accounting;
 926
 927         bridge_processor = collector;
 928 }
 929
 930 #endif