*/
const char* sgen_client_description_for_internal_mem_type (int type);
+const char* sgen_client_object_safe_name (MonoObject *obj);
+
void sgen_client_pre_collection_checks (void);
gboolean sgen_client_handle_gc_debug (const char *opt);
sgen_register_moved_object (obj, destination);
obj = destination;
if (queue) {
- SGEN_LOG (9, "Enqueuing gray object %p (%s)", obj, sgen_safe_name (obj));
+ SGEN_LOG (9, "Enqueuing gray object %p (%s)", obj, sgen_client_object_safe_name (obj));
GRAY_OBJECT_ENQUEUE (queue, obj, sgen_vtable_get_descriptor (vt));
}
}
#include "metadata/sgen-protocol.h"
#include "metadata/sgen-memory-governor.h"
#include "metadata/sgen-pinning.h"
+#include "metadata/sgen-client.h"
#include "metadata/threadpool-internals.h"
#define LOAD_VTABLE SGEN_LOAD_VTABLE
#undef HANDLE_PTR
#define HANDLE_PTR(ptr,obj) do { \
if (*(ptr)) { \
- g_assert (sgen_safe_name (*(ptr)) != NULL); \
+ g_assert (sgen_client_object_safe_name (*(ptr)) != NULL); \
} \
} while (0)
#define HANDLE_PTR(ptr,obj) do { \
if ((MonoObject*)*(ptr) == key) { \
g_print ("found ref to %p in object %p (%s) at offset %td\n", \
- key, (obj), sgen_safe_name ((obj)), ((char*)(ptr) - (char*)(obj))); \
+ key, (obj), sgen_client_object_safe_name ((MonoObject*)(obj)), ((char*)(ptr) - (char*)(obj))); \
} \
} while (0)
for (i = 0; i < size / sizeof (mword); ++i) {
if (words [i] == (mword)key) {
g_print ("found possible ref to %p in object %p (%s) at offset %td\n",
- key, start, sgen_safe_name (start), i * sizeof (mword));
+ key, start, sgen_client_object_safe_name ((MonoObject*)start), i * sizeof (mword));
}
}
}
#include "metadata/sgen-gray.h"
#include "metadata/sgen-protocol.h"
#include "metadata/sgen-pointer-queue.h"
+#include "metadata/sgen-client.h"
#include "utils/dtrace.h"
#include "utils/mono-counters.h"
/* insert it into the major hash */
sgen_hash_table_replace (&major_finalizable_hash, tagged_object_apply (copy, tag), NULL, NULL);
- SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_safe_name (copy), object);
+ SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_client_object_safe_name ((MonoObject*)copy), object);
continue;
} else if (copy != (char*)object) {
/* register for reinsertion */
sgen_pointer_queue_add (&moved_fin_objects, tagged_object_apply (copy, tag));
- SGEN_LOG (5, "Updating object for finalization: %p (%s) (was at %p)", copy, sgen_safe_name (copy), object);
+ SGEN_LOG (5, "Updating object for finalization: %p (%s) (was at %p)", copy, sgen_client_object_safe_name ((MonoObject*)copy), object);
continue;
}
num_ready_finalizers++;
sgen_queue_finalization_entry (copy);
/* Make it survive */
- SGEN_LOG (5, "Queueing object for finalization: %p (%s) (was at %p) (%d/%d)", copy, sgen_safe_name (copy), object, num_ready_finalizers, sgen_hash_table_num_entries (hash_table));
+ SGEN_LOG (5, "Queueing object for finalization: %p (%s) (was at %p) (%d/%d)", copy, sgen_client_object_safe_name (copy), object, num_ready_finalizers, sgen_hash_table_num_entries (hash_table));
continue;
} else {
if (hash_table == &minor_finalizable_hash && !ptr_in_nursery (copy)) {
/* insert it into the major hash */
sgen_hash_table_replace (&major_finalizable_hash, tagged_object_apply (copy, tag), NULL, NULL);
- SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_safe_name (copy), object);
+ SGEN_LOG (5, "Promoting finalization of object %p (%s) (was at %p) to major table", copy, sgen_client_object_safe_name (copy), object);
continue;
} else if (copy != object) {
/* register for reinsertion */
sgen_pointer_queue_add (&moved_fin_objects, tagged_object_apply (copy, tag));
- SGEN_LOG (5, "Updating object for finalization: %p (%s) (was at %p)", copy, sgen_safe_name (copy), object);
+ SGEN_LOG (5, "Updating object for finalization: %p (%s) (was at %p)", copy, sgen_client_object_safe_name (copy), object);
continue;
}
/* remove and put in out_array */
SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE);
out_array [count ++] = object;
- SGEN_LOG (5, "Collecting object for finalization: %p (%s) (%d/%d)", object, sgen_safe_name (object), num_ready_finalizers, sgen_hash_table_num_entries (hash_table));
+ SGEN_LOG (5, "Collecting object for finalization: %p (%s) (%d/%d)", object, sgen_client_object_safe_name (object), num_ready_finalizers, sgen_hash_table_num_entries (hash_table));
if (count == out_size)
return count;
continue;
object = tagged_object_get_object (object);
if (mono_object_domain (object) == domain) {
- SGEN_LOG (5, "Unregistering finalizer for object: %p (%s)", object, sgen_safe_name (object));
+ SGEN_LOG (5, "Unregistering finalizer for object: %p (%s)", object, sgen_client_object_safe_name (object));
SGEN_HASH_TABLE_FOREACH_REMOVE (TRUE);
continue;
#define LOAD_VTABLE SGEN_LOAD_VTABLE
-static const char*
-safe_name (void* obj)
-{
- MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (obj);
- return vt->klass->name;
-}
-
gboolean
nursery_canaries_enabled (void)
{
#define safe_object_get_size sgen_safe_object_get_size
-const char*
-sgen_safe_name (void* obj)
-{
- return safe_name (obj);
-}
-
/*
* ######################################################################
* ######## Global data.
GRAY_OBJECT_DEQUEUE (queue, &obj, &desc);
if (!obj)
return TRUE;
- SGEN_LOG (9, "Precise gray object scan %p (%s)", obj, safe_name (obj));
+ SGEN_LOG (9, "Precise gray object scan %p (%s)", obj, sgen_client_object_safe_name ((MonoObject*)obj));
scan_func (obj, desc, queue);
}
} while (max_objs < 0);
scan_func (obj_to_pin, desc, queue);
} else {
SGEN_LOG (4, "Pinned object %p, vtable %p (%s), count %d\n",
- obj_to_pin, *(void**)obj_to_pin, safe_name (obj_to_pin), count);
+ obj_to_pin, *(void**)obj_to_pin, sgen_client_object_safe_name (obj_to_pin), count);
binary_protocol_pin (obj_to_pin,
(gpointer)LOAD_VTABLE (obj_to_pin),
safe_object_get_size (obj_to_pin));
for (fin = list; fin; fin = fin->next) {
if (!fin->object)
continue;
- SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", fin->object, safe_name (fin->object));
+ SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", fin->object, sgen_client_object_safe_name (fin->object));
copy_func (&fin->object, queue);
}
}
if (do_dump_nursery_content) {
if (cur > hole_start)
SGEN_LOG (1, "HOLE [%p %p %d]", hole_start, cur, (int)(cur - hole_start));
- SGEN_LOG (1, "OBJ [%p %p %d %d %s %d]", cur, cur + size, (int)size, (int)ss, sgen_safe_name ((MonoObject*)cur), (gpointer)LOAD_VTABLE (cur) == sgen_client_get_array_fill_vtable ());
+ SGEN_LOG (1, "OBJ [%p %p %d %d %s %d]", cur, cur + size, (int)size, (int)ss, sgen_client_object_safe_name ((MonoObject*)cur), (gpointer)LOAD_VTABLE (cur) == sgen_client_get_array_fill_vtable ());
}
if (nursery_canaries_enabled () && (MonoVTable*)SGEN_LOAD_VTABLE (cur) != sgen_client_get_array_fill_vtable ()) {
CHECK_CANARY_FOR_OBJECT (cur);
if (SGEN_OBJECT_HAS_REFERENCES (bigobj->data))
GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data, sgen_obj_get_descriptor (bigobj->data));
sgen_pin_stats_register_object ((char*) bigobj->data, safe_object_get_size ((MonoObject*) bigobj->data));
- SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data, safe_name (bigobj->data), (unsigned long)sgen_los_object_size (bigobj));
+ SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data, sgen_client_object_safe_name ((MonoObject*)bigobj->data), (unsigned long)sgen_los_object_size (bigobj));
if (profile_roots)
add_profile_gc_root (&root_report, bigobj->data, MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0);
num_ready_finalizers--;
obj = entry->object;
entry->object = NULL;
- SGEN_LOG (7, "Finalizing object %p (%s)", obj, safe_name (obj));
+ SGEN_LOG (7, "Finalizing object %p (%s)", obj, sgen_client_object_safe_name (obj));
}
UNLOCK_GC;
g_assert (entry->object == NULL);
count++;
/* the object is on the stack so it is pinned */
- /*g_print ("Calling finalizer for object: %p (%s)\n", entry->object, safe_name (entry->object));*/
+ /*g_print ("Calling finalizer for object: %p (%s)\n", entry->object, sgen_client_object_safe_name (entry->object));*/
mono_gc_run_finalize (obj, NULL);
}
g_assert (!entry);
void
mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
{
- SGEN_LOG (8, "Wbarrier store at %p to %p (%s)", ptr, value, value ? safe_name (value) : "null");
+ SGEN_LOG (8, "Wbarrier store at %p to %p (%s)", ptr, value, value ? sgen_client_object_safe_name (value) : "null");
SGEN_UPDATE_REFERENCE_ALLOW_NULL (ptr, value);
if (ptr_in_nursery (value))
mono_gc_wbarrier_generic_nostore (ptr);
{
HEAVY_STAT (++stat_wbarrier_generic_store_atomic);
- SGEN_LOG (8, "Wbarrier atomic store at %p to %p (%s)", ptr, value, value ? safe_name (value) : "null");
+ SGEN_LOG (8, "Wbarrier atomic store at %p to %p (%s)", ptr, value, value ? sgen_client_object_safe_name (value) : "null");
InterlockedWritePointer (ptr, value);
return sgen_client_slow_object_get_size ((MonoVTable*)SGEN_LOAD_VTABLE (obj), obj);
}
-const char* sgen_safe_name (void* obj);
-
gboolean sgen_object_is_live (void *obj);
void sgen_init_fin_weak_hash (void);
#include "metadata/sgen-pinning.h"
#include "metadata/sgen-workers.h"
#include "metadata/sgen-thread-pool.h"
+#include "metadata/sgen-client.h"
#if defined(ARCH_MIN_MS_BLOCK_SIZE) && defined(ARCH_MIN_MS_BLOCK_SIZE_SHIFT)
#define MS_BLOCK_SIZE ARCH_MIN_MS_BLOCK_SIZE
}
}
+const char*
+sgen_client_object_safe_name (MonoObject *obj)
+{
+ MonoVTable *vt = (MonoVTable*)SGEN_LOAD_VTABLE (obj);
+ return vt->klass->name;
+}
+
/*
* Initialization
*/
#include "sgen-bridge.h"
#include "sgen-hash-table.h"
#include "sgen-qsort.h"
+#include "sgen-client.h"
#include "tabledefs.h"
#include "utils/mono-logger-internal.h"
#include "utils/mono-time.h"
for (j = 0; j < api_sccs [i]->num_objs; ++j)
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC,
"OBJECT %s (%p) SCC [%d] %s",
- sgen_safe_name (api_sccs [i]->objs [j]), api_sccs [i]->objs [j],
+ sgen_client_object_safe_name (api_sccs [i]->objs [j]), api_sccs [i]->objs [j],
i,
api_sccs [i]->is_alive ? "ALIVE" : "DEAD");
}
SGEN_LOG (1, "Nursery fully pinned");
for (pin_entry = pin_start; pin_entry < pin_end; ++pin_entry) {
void *p = *pin_entry;
- SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_safe_name (p), sgen_safe_object_get_size (p));
+ SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", p, sgen_client_object_safe_name (p), sgen_safe_object_get_size (p));
}
}
return fragment_total;
#include "sgen-bridge.h"
#include "sgen-hash-table.h"
#include "sgen-qsort.h"
+#include "sgen-client.h"
#include "utils/mono-logger-internal.h"
#include "utils/mono-time.h"
#include "utils/mono-compiler.h"
for (j = 0; j < api_sccs [i]->num_objs; ++j)
mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC,
"OBJECT %s (%p) SCC [%d] %s",
- sgen_safe_name (api_sccs [i]->objs [j]), api_sccs [i]->objs [j],
+ sgen_client_object_safe_name (api_sccs [i]->objs [j]), api_sccs [i]->objs [j],
i,
api_sccs [i]->is_alive ? "ALIVE" : "DEAD");
}
#include "metadata/sgen-pinning.h"
#include "metadata/sgen-protocol.h"
#include "metadata/sgen-pointer-queue.h"
+#include "metadata/sgen-client.h"
static SgenPointerQueue pin_queue;
static size_t last_num_pinned = 0;
for (i = 0; i < last_num_pinned; ++i) {
void *ptr = pin_queue.data [i];
- SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_safe_name (ptr), sgen_safe_object_get_size (ptr));
+ SGEN_LOG (3, "Bastard pinning obj %p (%s), size: %zd", ptr, sgen_client_object_safe_name (ptr), sgen_safe_object_get_size (ptr));
}
}
#include "metadata/sgen-gc.h"
#include "metadata/sgen-protocol.h"
#include "metadata/sgen-layout-stats.h"
+#include "metadata/sgen-client.h"
static inline char*
alloc_for_promotion (MonoVTable *vtable, char *obj, size_t objsize, gboolean has_references)
#include "metadata/sgen-gc.h"
#include "metadata/sgen-protocol.h"
#include "metadata/sgen-layout-stats.h"
+#include "metadata/sgen-client.h"
#include "utils/mono-memory-model.h"
/*
projects / mono.git / commitdiff