/* LOCKING: assumes the GC lock is held */ static void rehash_dislink (DisappearingLinkHashTable *hash_table) { DisappearingLink **disappearing_link_hash = hash_table->table; int disappearing_link_hash_size = hash_table->size; int i; unsigned int hash; DisappearingLink **new_hash; DisappearingLink *entry, *next; int new_size = g_spaced_primes_closest (hash_table->num_links); new_hash = mono_sgen_alloc_internal_dynamic (new_size * sizeof (DisappearingLink*), INTERNAL_MEM_DISLINK_TABLE); for (i = 0; i < disappearing_link_hash_size; ++i) { for (entry = disappearing_link_hash [i]; entry; entry = next) { hash = mono_aligned_addr_hash (entry->link) % new_size; next = entry->next; entry->next = new_hash [hash]; new_hash [hash] = entry; } } mono_sgen_free_internal_dynamic (disappearing_link_hash, disappearing_link_hash_size * sizeof (DisappearingLink*), INTERNAL_MEM_DISLINK_TABLE); hash_table->table = new_hash; hash_table->size = new_size; }
gboolean sgen_cement_lookup_or_register (char *obj, gboolean concurrent_cementing) { int i; CementHashEntry *hash; if (!cement_enabled) return FALSE; if (concurrent_cementing) SGEN_ASSERT (5, cement_concurrent, "Cementing wasn't inited with concurrent flag"); if (concurrent_cementing) hash = cement_hash_concurrent; else hash = cement_hash; /* * We use modulus hashing, which is fine with constants as gcc * can optimize them to multiplication, but with variable * values it would be a bad idea given armv7 has no hardware * for division, making it 20x slower than a multiplication. * * This code path can be quite hot, depending on the workload, * so if we make the hash size user-adjustable we should * figure out something not involving division. */ i = mono_aligned_addr_hash (obj) % SGEN_CEMENT_HASH_SIZE; SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Can only cement pointers to nursery objects"); if (!hash [i].obj) { SGEN_ASSERT (5, !hash [i].count, "Cementing hash inconsistent"); hash [i].obj = obj; } else if (hash [i].obj != obj) { return FALSE; } if (hash [i].count >= SGEN_CEMENT_THRESHOLD) return TRUE; ++hash [i].count; if (hash [i].count == SGEN_CEMENT_THRESHOLD) { if (G_UNLIKELY (MONO_GC_OBJ_CEMENTED_ENABLED())) { MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj); MONO_GC_OBJ_CEMENTED ((mword)obj, sgen_safe_object_get_size ((MonoObject*)obj), vt->klass->name_space, vt->klass->name); } #ifdef SGEN_BINARY_PROTOCOL binary_protocol_cement (obj, (gpointer)SGEN_LOAD_VTABLE (obj), sgen_safe_object_get_size ((MonoObject*)obj)); #endif } return FALSE; }
gboolean sgen_cement_lookup_or_register (char *obj) { guint hv; int i; CementHashEntry *hash; gboolean concurrent_cementing = sgen_concurrent_collection_in_progress (); if (!cement_enabled) return FALSE; if (concurrent_cementing) SGEN_ASSERT (5, cement_concurrent, "Cementing wasn't inited with concurrent flag"); if (concurrent_cementing) hash = cement_hash_concurrent; else hash = cement_hash; hv = mono_aligned_addr_hash (obj); i = SGEN_CEMENT_HASH (hv); SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Can only cement pointers to nursery objects"); if (!hash [i].obj) { SGEN_ASSERT (5, !hash [i].count, "Cementing hash inconsistent"); hash [i].obj = obj; } else if (hash [i].obj != obj) { return FALSE; } if (hash [i].count >= SGEN_CEMENT_THRESHOLD) return TRUE; ++hash [i].count; if (hash [i].count == SGEN_CEMENT_THRESHOLD) { SGEN_ASSERT (9, SGEN_OBJECT_IS_PINNED (obj), "Can only cement pinned objects"); SGEN_CEMENT_OBJECT (obj); if (G_UNLIKELY (MONO_GC_OBJ_CEMENTED_ENABLED())) { MonoVTable *vt G_GNUC_UNUSED = (MonoVTable*)SGEN_LOAD_VTABLE (obj); MONO_GC_OBJ_CEMENTED ((mword)obj, sgen_safe_object_get_size ((MonoObject*)obj), vt->klass->name_space, vt->klass->name); } binary_protocol_cement (obj, (gpointer)SGEN_LOAD_VTABLE (obj), (int)sgen_safe_object_get_size ((MonoObject*)obj)); } return FALSE; }
gboolean sgen_cement_lookup (char *obj) { int i = mono_aligned_addr_hash (obj) % SGEN_CEMENT_HASH_SIZE; SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Looking up cementing for non-nursery objects makes no sense"); if (!cement_enabled) return FALSE; if (!cement_hash [i].obj) return FALSE; if (cement_hash [i].obj != obj) return FALSE; return cement_hash [i].count >= SGEN_CEMENT_THRESHOLD; }
/* LOCKING: assumes the GC lock is held */ static void add_or_remove_disappearing_link (MonoObject *obj, void **link, int generation) { DisappearingLinkHashTable *hash_table = get_dislink_hash_table (generation); DisappearingLink *entry, *prev; unsigned int hash; DisappearingLink **disappearing_link_hash = hash_table->table; int disappearing_link_hash_size = hash_table->size; if (hash_table->num_links >= disappearing_link_hash_size * 2) { rehash_dislink (hash_table); disappearing_link_hash = hash_table->table; disappearing_link_hash_size = hash_table->size; } /* FIXME: add check that link is not in the heap */ hash = mono_aligned_addr_hash (link) % disappearing_link_hash_size; entry = disappearing_link_hash [hash]; prev = NULL; for (; entry; entry = entry->next) { /* link already added */ if (link == entry->link) { /* NULL obj means remove */ if (obj == NULL) { if (prev) prev->next = entry->next; else disappearing_link_hash [hash] = entry->next; hash_table->num_links--; DEBUG (5, fprintf (gc_debug_file, "Removed dislink %p (%d) from %s table\n", entry, hash_table->num_links, generation_name (generation))); mono_sgen_free_internal (entry, INTERNAL_MEM_DISLINK); } return; } prev = entry; } if (obj == NULL) return; entry = mono_sgen_alloc_internal (INTERNAL_MEM_DISLINK); entry->link = link; entry->next = disappearing_link_hash [hash]; disappearing_link_hash [hash] = entry; hash_table->num_links++; DEBUG (5, fprintf (gc_debug_file, "Added dislink %p for object: %p (%s) at %p to %s table\n", entry, obj, obj->vtable->klass->name, link, generation_name (generation))); }
static int tagged_object_hash (MonoObject *o) { return mono_aligned_addr_hash (tagged_object_get_object (o)); }