#define XREFS old_xrefs
#endif
+#define OPTIMIZATION_COPY
+#define OPTIMIZATION_FORWARD
+#define OPTIMIZATION_SINGLETON_DYN_ARRAY
+
typedef struct {
int size;
int capacity; /* if negative, data points to another DynArray's data */
return da->array.size;
}
+#ifdef NEW_XREFS
static void
dyn_array_int_empty (DynIntArray *da)
{
dyn_array_empty (&da->array);
}
+#endif
static void
dyn_array_int_add (DynIntArray *da, int x)
return ((int*)da->array.data)[x];
}
+#ifdef NEW_XREFS
static void
dyn_array_int_set (DynIntArray *da, int idx, int val)
{
((int*)da->array.data)[idx] = val;
}
-
-static void
-dyn_array_int_ensure_capacity (DynIntArray *da, int capacity)
-{
- dyn_array_ensure_capacity (&da->array, capacity, sizeof (int));
-}
+#endif
static void
dyn_array_int_ensure_independent (DynIntArray *da)
static void
dyn_array_ptr_uninit (DynPtrArray *da)
{
+#ifdef OPTIMIZATION_SINGLETON_DYN_ARRAY
if (da->array.capacity == 1)
dyn_array_ptr_init (da);
else
+#endif
dyn_array_uninit (&da->array, sizeof (void*));
}
static void
dyn_array_ptr_empty (DynPtrArray *da)
{
- dyn_array_empty (&da->array);
+#ifdef OPTIMIZATION_SINGLETON_DYN_ARRAY
+ if (da->array.capacity == 1)
+ dyn_array_ptr_init (da);
+ else
+#endif
+ dyn_array_empty (&da->array);
}
static void*
dyn_array_ptr_get (DynPtrArray *da, int x)
{
+#ifdef OPTIMIZATION_SINGLETON_DYN_ARRAY
if (da->array.capacity == 1) {
g_assert (x == 0);
return da->array.data;
}
+#endif
return ((void**)da->array.data)[x];
}
{
void **p;
+#ifdef OPTIMIZATION_SINGLETON_DYN_ARRAY
if (da->array.capacity == 0) {
da->array.capacity = 1;
da->array.size = 1;
p0 = dyn_array_add (&da->array, sizeof (void*));
*p0 = ptr0;
p = dyn_array_add (&da->array, sizeof (void*));
- } else {
+ } else
+#endif
+ {
p = dyn_array_add (&da->array, sizeof (void*));
}
*p = ptr;
int size = da->array.size;
void *p;
g_assert (size > 0);
+#ifdef OPTIMIZATION_SINGLETON_DYN_ARRAY
if (da->array.capacity == 1) {
p = dyn_array_ptr_get (da, 0);
dyn_array_init (&da->array);
- } else {
+ } else
+#endif
+ {
g_assert (da->array.capacity > 1);
dyn_array_ensure_independent (&da->array, sizeof (void*));
p = dyn_array_ptr_get (da, size - 1);
static DynIntArray merge_array;
+#ifdef NEW_XREFS
static gboolean
dyn_array_int_contains (DynIntArray *da, int x)
{
return TRUE;
return FALSE;
}
+#endif
static void
enable_accounting (void)
{
+ SgenHashTable table = SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_HASH_TABLE, INTERNAL_MEM_BRIDGE_HASH_TABLE_ENTRY, sizeof (HashEntryWithAccounting), mono_aligned_addr_hash, NULL);
bridge_accounting_enabled = TRUE;
- hash_table = (SgenHashTable)SGEN_HASH_TABLE_INIT (INTERNAL_MEM_BRIDGE_HASH_TABLE, INTERNAL_MEM_BRIDGE_HASH_TABLE_ENTRY, sizeof (HashEntryWithAccounting), mono_aligned_addr_hash, NULL);
+ hash_table = table;
}
static MonoGCBridgeObjectKind
static HashEntry*
follow_forward (HashEntry *entry)
{
+#ifdef OPTIMIZATION_FORWARD
while (entry->v.dfs1.forwarded_to) {
HashEntry *next = entry->v.dfs1.forwarded_to;
if (next->v.dfs1.forwarded_to)
entry->v.dfs1.forwarded_to = next->v.dfs1.forwarded_to;
entry = next;
}
+#else
+ g_assert (!entry->v.dfs1.forwarded_to);
+#endif
return entry;
}
if (obj_entry) {
/* obj_entry needs to be expanded */
src = dyn_array_ptr_pop (&dfs_stack);
+
if (src)
g_assert (!src->v.dfs1.forwarded_to);
if (!obj_entry->v.dfs1.is_visited) {
int num_links = 0;
+ mword desc = sgen_obj_get_descriptor (start);
obj_entry->v.dfs1.is_visited = 1;
* continuing processing this object, we start over with the
* object it points to.
*/
+#ifdef OPTIMIZATION_FORWARD
if (!obj_entry->is_bridge && num_links == 1) {
HashEntry *dst_entry = dyn_array_ptr_pop (&dfs_stack);
HashEntry *obj_entry_again = dyn_array_ptr_pop (&dfs_stack);
}
goto again;
}
+#endif
}
if (src) {
return;
src->flag = TRUE;
dyn_array_int_add (&dst->old_xrefs, src->index);
+#ifdef OPTIMIZATION_COPY
} else if (dyn_array_int_size (&dst->old_xrefs) == 0) {
dyn_array_int_copy (&dst->old_xrefs, &src->old_xrefs);
+#endif
} else {
int i;
for (i = 0; i < dyn_array_int_size (&src->old_xrefs); ++i) {
MonoObject *obj;
HashEntry *entry;
- int prefix_len = strlen (dump_prefix);
- char filename [prefix_len + 64];
+ size_t prefix_len = strlen (dump_prefix);
+ char *filename = alloca(prefix_len + 64);
FILE *file;
int edge_id = 0;