/* 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));
}
