static gboolean
is_match (gpointer ptr, int type, void *data)
{
switch (TYPE (type)) {
case SGEN_PROTOCOL_ALLOC:
case SGEN_PROTOCOL_ALLOC_PINNED:
case SGEN_PROTOCOL_ALLOC_DEGRADED: {
SGenProtocolAlloc *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_COPY: {
SGenProtocolCopy *entry = data;
return matches_interval (ptr, entry->from, entry->size) || matches_interval (ptr, entry->to, entry->size);
}
case SGEN_PROTOCOL_PIN: {
SGenProtocolPin *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_MARK: {
SGenProtocolMark *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_SCAN_BEGIN: {
SGenProtocolScanBegin *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_SCAN_VTYPE_BEGIN: {
SGenProtocolScanVTypeBegin *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_WBARRIER: {
SGenProtocolWBarrier *entry = data;
return ptr == entry->ptr || ptr == entry->value;
}
case SGEN_PROTOCOL_GLOBAL_REMSET: {
SGenProtocolGlobalRemset *entry = data;
return ptr == entry->ptr || ptr == entry->value;
}
case SGEN_PROTOCOL_PTR_UPDATE: {
SGenProtocolPtrUpdate *entry = data;
return ptr == entry->ptr ||
matches_interval (ptr, entry->old_value, entry->size) ||
matches_interval (ptr, entry->new_value, entry->size);
}
case SGEN_PROTOCOL_CLEANUP: {
SGenProtocolCleanup *entry = data;
return matches_interval (ptr, entry->ptr, entry->size);
}
case SGEN_PROTOCOL_EMPTY: {
SGenProtocolEmpty *entry = data;
return matches_interval (ptr, entry->start, entry->size);
}
case SGEN_PROTOCOL_MISSING_REMSET: {
SGenProtocolMissingRemset *entry = data;
return ptr == entry->obj || ptr == entry->value || ptr == (char*)entry->obj + entry->offset;
}
case SGEN_PROTOCOL_CARD_SCAN: {
SGenProtocolCardScan *entry = data;
return matches_interval (ptr, entry->start, entry->size);
}
case SGEN_PROTOCOL_CEMENT: {
SGenProtocolCement *entry = data;
return matches_interval (ptr, entry->obj, entry->size);
}
case SGEN_PROTOCOL_DISLINK_UPDATE: {
SGenProtocolDislinkUpdate *entry = data;
return ptr == entry->obj || ptr == entry->link;
}
case SGEN_PROTOCOL_DISLINK_UPDATE_STAGED: {
SGenProtocolDislinkUpdateStaged *entry = data;
return ptr == entry->obj || ptr == entry->link;
}
case SGEN_PROTOCOL_DISLINK_PROCESS_STAGED: {
SGenProtocolDislinkProcessStaged *entry = data;
return ptr == entry->obj || ptr == entry->link;
}
default:
if (is_always_match (type))
return TRUE;
assert (0);
}
}
int
main (int argc, char *argv[])
{
int type;
void *data = g_malloc0 (MAX_ENTRY_SIZE);
int num_args = argc - 1;
int num_nums = 0;
int num_vtables = 0;
int i;
long nums [num_args];
long vtables [num_args];
gboolean dump_all = FALSE;
gboolean pause_times = FALSE;
gboolean pause_times_stopped = FALSE;
gboolean pause_times_concurrent = FALSE;
gboolean pause_times_finish = FALSE;
gboolean color_output = FALSE;
long long pause_times_ts = 0;
const char *input_path = NULL;
int input_file;
EntryStream stream;
unsigned long long entry_index;
unsigned long long first_entry_to_consider = 0;
for (i = 0; i < num_args; ++i) {
char *arg = argv [i + 1];
char *next_arg = argv [i + 2];
if (!strcmp (arg, "--all")) {
dump_all = TRUE;
} else if (!strcmp (arg, "--pause-times")) {
pause_times = TRUE;
} else if (!strcmp (arg, "-v") || !strcmp (arg, "--vtable")) {
vtables [num_vtables++] = strtoul (next_arg, NULL, 16);
++i;
} else if (!strcmp (arg, "-s") || !strcmp (arg, "--start-at")) {
first_entry_to_consider = strtoull (next_arg, NULL, 10);
++i;
} else if (!strcmp (arg, "-c") || !strcmp (arg, "--color")) {
color_output = TRUE;
} else if (!strcmp (arg, "-i") || !strcmp (arg, "--input")) {
input_path = next_arg;
++i;
} else {
nums [num_nums++] = strtoul (arg, NULL, 16);
}
}
if (dump_all)
assert (!pause_times);
if (pause_times)
assert (!dump_all);
input_file = input_path ? open (input_path, O_RDONLY) : STDIN_FILENO;
init_stream (&stream, input_file);
entry_index = 0;
while ((type = read_entry (&stream, data)) != SGEN_PROTOCOL_EOF) {
if (entry_index < first_entry_to_consider)
goto next_entry;
if (pause_times) {
switch (type) {
case PROTOCOL_ID (binary_protocol_world_stopping): {
PROTOCOL_STRUCT (binary_protocol_world_stopping) *entry = data;
assert (!pause_times_stopped);
pause_times_concurrent = FALSE;
pause_times_finish = FALSE;
pause_times_ts = entry->timestamp;
pause_times_stopped = TRUE;
break;
}
case PROTOCOL_ID (binary_protocol_concurrent_finish):
pause_times_finish = TRUE;
case PROTOCOL_ID (binary_protocol_concurrent_start):
case PROTOCOL_ID (binary_protocol_concurrent_update):
pause_times_concurrent = TRUE;
break;
case PROTOCOL_ID (binary_protocol_world_restarted): {
PROTOCOL_STRUCT (binary_protocol_world_restarted) *entry = data;
assert (pause_times_stopped);
printf ("pause-time %d %d %d %lld %lld\n",
entry->generation,
pause_times_concurrent,
pause_times_finish,
entry->timestamp - pause_times_ts,
pause_times_ts);
pause_times_stopped = FALSE;
break;
}
}
} else {
int match_indices [num_nums + 1];
gboolean match = is_always_match (type);
match_indices [num_nums] = num_nums == 0 ? match_index (NULL, type, data) : BINARY_PROTOCOL_NO_MATCH;
match = match_indices [num_nums] != BINARY_PROTOCOL_NO_MATCH;
for (i = 0; i < num_nums; ++i) {
match_indices [i] = match_index ((gpointer) nums [i], type, data);
match = match || match_indices [i] != BINARY_PROTOCOL_NO_MATCH;
}
if (!match) {
for (i = 0; i < num_vtables; ++i) {
if (is_vtable_match ((gpointer) vtables [i], type, data)) {
match = TRUE;
break;
}
}
}
if (match || dump_all)
printf ("%12lld ", entry_index);
if (dump_all)
printf (match ? "* " : " ");
if (match || dump_all)
print_entry (type, data, num_nums, match_indices, color_output);
}
next_entry:
++entry_index;
}
close_stream (&stream);
if (input_path)
close (input_file);
g_free (data);
return 0;
}
static void
print_entry (int type, void *data)
{
const char *always_prefix = is_always_match (type) ? " " : "";
printf ("%s%s ", WORKER_PREFIX (type), always_prefix);
switch (TYPE (type)) {
case SGEN_PROTOCOL_COLLECTION_FORCE: {
SGenProtocolCollectionForce *entry = data;
printf ("collection force generation %d\n", entry->generation);
break;
}
case SGEN_PROTOCOL_COLLECTION_BEGIN: {
SGenProtocolCollection *entry = data;
printf ("collection begin %d generation %d\n", entry->index, entry->generation);
break;
}
case SGEN_PROTOCOL_COLLECTION_END: {
SGenProtocolCollection *entry = data;
printf ("collection end %d generation %d\n", entry->index, entry->generation);
break;
}
case SGEN_PROTOCOL_CONCURRENT_START: {
printf ("concurrent start\n");
break;
}
case SGEN_PROTOCOL_CONCURRENT_UPDATE_FINISH: {
printf ("concurrent update or finish\n");
break;
}
case SGEN_PROTOCOL_WORLD_STOPPING: {
SGenProtocolWorldStopping *entry = data;
printf ("world stopping timestamp %lld\n", entry->timestamp);
break;
}
case SGEN_PROTOCOL_WORLD_STOPPED: {
SGenProtocolWorldStopped *entry = data;
long long total = entry->total_major_cards + entry->total_los_cards;
long long marked = entry->marked_major_cards + entry->marked_los_cards;
printf ("world stopped timestamp %lld total %lld marked %lld %0.2f%%\n", entry->timestamp, total, marked, 100.0 * (double) marked / (double) total);
break;
}
case SGEN_PROTOCOL_WORLD_RESTARTING: {
SGenProtocolWorldRestarting *entry = data;
long long total = entry->total_major_cards + entry->total_los_cards;
long long marked = entry->marked_major_cards + entry->marked_los_cards;
printf ("world restarting generation %d timestamp %lld total %lld marked %lld %0.2f%%\n", entry->generation, entry->timestamp, total, marked, 100.0 * (double) marked / (double) total);
break;
}
case SGEN_PROTOCOL_WORLD_RESTARTED: {
SGenProtocolWorldRestarted *entry = data;
printf ("world restarted generation %d timestamp %lld\n", entry->generation, entry->timestamp);
break;
}
case SGEN_PROTOCOL_ALLOC: {
SGenProtocolAlloc *entry = data;
printf ("alloc obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_ALLOC_PINNED: {
SGenProtocolAlloc *entry = data;
printf ("alloc pinned obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_ALLOC_DEGRADED: {
SGenProtocolAlloc *entry = data;
printf ("alloc degraded obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_COPY: {
SGenProtocolCopy *entry = data;
printf ("copy from %p to %p vtable %p size %d\n", entry->from, entry->to, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_PIN: {
SGenProtocolPin *entry = data;
printf ("pin obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_MARK: {
SGenProtocolMark *entry = data;
printf ("mark obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_SCAN_BEGIN: {
SGenProtocolScanBegin *entry = data;
printf ("scan_begin obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_SCAN_VTYPE_BEGIN: {
SGenProtocolScanVTypeBegin *entry = data;
printf ("scan_vtype_begin obj %p size %d\n", entry->obj, entry->size);
break;
}
case SGEN_PROTOCOL_WBARRIER: {
SGenProtocolWBarrier *entry = data;
printf ("wbarrier ptr %p value %p value_vtable %p\n", entry->ptr, entry->value, entry->value_vtable);
break;
}
case SGEN_PROTOCOL_GLOBAL_REMSET: {
SGenProtocolGlobalRemset *entry = data;
printf ("global_remset ptr %p value %p value_vtable %p\n", entry->ptr, entry->value, entry->value_vtable);
break;
}
case SGEN_PROTOCOL_PTR_UPDATE: {
SGenProtocolPtrUpdate *entry = data;
printf ("ptr_update ptr %p old_value %p new_value %p vtable %p size %d\n",
entry->ptr, entry->old_value, entry->new_value, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_CLEANUP: {
SGenProtocolCleanup *entry = data;
printf ("cleanup ptr %p vtable %p size %d\n", entry->ptr, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_EMPTY: {
SGenProtocolEmpty *entry = data;
printf ("empty start %p size %d\n", entry->start, entry->size);
break;
}
case SGEN_PROTOCOL_THREAD_SUSPEND: {
SGenProtocolThreadSuspend *entry = data;
printf ("thread_suspend thread %p ip %p\n", entry->thread, entry->stopped_ip);
break;
}
case SGEN_PROTOCOL_THREAD_RESTART: {
SGenProtocolThreadRestart *entry = data;
printf ("thread_restart thread %p\n", entry->thread);
break;
}
case SGEN_PROTOCOL_THREAD_REGISTER: {
SGenProtocolThreadRegister *entry = data;
printf ("thread_register thread %p\n", entry->thread);
break;
}
case SGEN_PROTOCOL_THREAD_UNREGISTER: {
SGenProtocolThreadUnregister *entry = data;
printf ("thread_unregister thread %p\n", entry->thread);
break;
}
case SGEN_PROTOCOL_MISSING_REMSET: {
SGenProtocolMissingRemset *entry = data;
printf ("missing_remset obj %p obj_vtable %p offset %d value %p value_vtable %p value_pinned %d\n",
entry->obj, entry->obj_vtable, entry->offset, entry->value, entry->value_vtable, entry->value_pinned);
break;
}
case SGEN_PROTOCOL_CARD_SCAN: {
SGenProtocolCardScan *entry = data;
printf ("card_scan start %p size %d\n", entry->start, entry->size);
break;
}
case SGEN_PROTOCOL_CEMENT: {
SGenProtocolCement *entry = data;
printf ("cement obj %p vtable %p size %d\n", entry->obj, entry->vtable, entry->size);
break;
}
case SGEN_PROTOCOL_CEMENT_RESET: {
printf ("cement_reset\n");
break;
}
case SGEN_PROTOCOL_DISLINK_UPDATE: {
SGenProtocolDislinkUpdate *entry = data;
printf ("dislink_update link %p obj %p staged %d", entry->link, entry->obj, entry->staged);
if (entry->obj)
printf (" track %d\n", entry->track);
else
printf ("\n");
break;
}
case SGEN_PROTOCOL_DISLINK_UPDATE_STAGED: {
SGenProtocolDislinkUpdateStaged *entry = data;
printf ("dislink_update_staged link %p obj %p index %d", entry->link, entry->obj, entry->index);
if (entry->obj)
printf (" track %d\n", entry->track);
else
printf ("\n");
break;
}
case SGEN_PROTOCOL_DISLINK_PROCESS_STAGED: {
SGenProtocolDislinkProcessStaged *entry = data;
printf ("dislink_process_staged link %p obj %p index %d\n", entry->link, entry->obj, entry->index);
break;
}
case SGEN_PROTOCOL_DOMAIN_UNLOAD_BEGIN: {
SGenProtocolDomainUnload *entry = data;
printf ("dislink_unload_begin domain %p\n", entry->domain);
break;
}
case SGEN_PROTOCOL_DOMAIN_UNLOAD_END: {
SGenProtocolDomainUnload *entry = data;
printf ("dislink_unload_end domain %p\n", entry->domain);
break;
}
default:
assert (0);
}
}
static void
print_entry (int type, void *data, int num_nums, int *match_indices, gboolean color_output)
{
const char *always_prefix = is_always_match (type) ? " " : "";
printf ("%s%s ", WORKER_PREFIX (type), always_prefix);
switch (TYPE (type)) {
#define BEGIN_PROTOCOL_ENTRY0(method) \
case PROTOCOL_ID(method): { \
const int pes_size G_GNUC_UNUSED = 0; \
PrintEntry pes [1] G_GNUC_UNUSED; \
printf ("%s", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY1(method,t1,f1) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 1; \
PrintEntry pes [1] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY2(method,t1,f1,t2,f2) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 2; \
PrintEntry pes [2] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
pes [1].type = t2; \
pes [1].name = #f2; \
pes [1].data = &entry->f2; \
pes [1].color = index_color(1, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY3(method,t1,f1,t2,f2,t3,f3) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 3; \
PrintEntry pes [3] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
pes [1].type = t2; \
pes [1].name = #f2; \
pes [1].data = &entry->f2; \
pes [1].color = index_color(1, num_nums, match_indices); \
pes [2].type = t3; \
pes [2].name = #f3; \
pes [2].data = &entry->f3; \
pes [2].color = index_color(2, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY4(method,t1,f1,t2,f2,t3,f3,t4,f4) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 4; \
PrintEntry pes [4] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
pes [1].type = t2; \
pes [1].name = #f2; \
pes [1].data = &entry->f2; \
pes [1].color = index_color(1, num_nums, match_indices); \
pes [2].type = t3; \
pes [2].name = #f3; \
pes [2].data = &entry->f3; \
pes [2].color = index_color(2, num_nums, match_indices); \
pes [3].type = t4; \
pes [3].name = #f4; \
pes [3].data = &entry->f4; \
pes [3].color = index_color(3, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY5(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 5; \
PrintEntry pes [5] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
pes [1].type = t2; \
pes [1].name = #f2; \
pes [1].data = &entry->f2; \
pes [1].color = index_color(1, num_nums, match_indices); \
pes [2].type = t3; \
pes [2].name = #f3; \
pes [2].data = &entry->f3; \
pes [2].color = index_color(2, num_nums, match_indices); \
pes [3].type = t4; \
pes [3].name = #f4; \
pes [3].data = &entry->f4; \
pes [3].color = index_color(3, num_nums, match_indices); \
pes [4].type = t5; \
pes [4].name = #f5; \
pes [4].data = &entry->f5; \
pes [4].color = index_color(4, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY6(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5,t6,f6) \
case PROTOCOL_ID(method): { \
PROTOCOL_STRUCT (method) *entry = data; \
const int pes_size G_GNUC_UNUSED = 6; \
PrintEntry pes [6] G_GNUC_UNUSED; \
pes [0].type = t1; \
pes [0].name = #f1; \
pes [0].data = &entry->f1; \
pes [0].color = index_color(0, num_nums, match_indices); \
pes [1].type = t2; \
pes [1].name = #f2; \
pes [1].data = &entry->f2; \
pes [1].color = index_color(1, num_nums, match_indices); \
pes [2].type = t3; \
pes [2].name = #f3; \
pes [2].data = &entry->f3; \
pes [2].color = index_color(2, num_nums, match_indices); \
pes [3].type = t4; \
pes [3].name = #f4; \
pes [3].data = &entry->f4; \
pes [3].color = index_color(3, num_nums, match_indices); \
pes [4].type = t5; \
pes [4].name = #f5; \
pes [4].data = &entry->f5; \
pes [4].color = index_color(4, num_nums, match_indices); \
pes [5].type = t6; \
pes [5].name = #f6; \
pes [5].data = &entry->f6; \
pes [5].color = index_color(5, num_nums, match_indices); \
printf ("%s ", #method + strlen ("binary_protocol_"));
#define BEGIN_PROTOCOL_ENTRY_HEAVY0(method) \
BEGIN_PROTOCOL_ENTRY0 (method)
#define BEGIN_PROTOCOL_ENTRY_HEAVY1(method,t1,f1) \
BEGIN_PROTOCOL_ENTRY1 (method,t1,f1)
#define BEGIN_PROTOCOL_ENTRY_HEAVY2(method,t1,f1,t2,f2) \
BEGIN_PROTOCOL_ENTRY2 (method,t1,f1,t2,f2)
#define BEGIN_PROTOCOL_ENTRY_HEAVY3(method,t1,f1,t2,f2,t3,f3) \
BEGIN_PROTOCOL_ENTRY3 (method,t1,f1,t2,f2,t3,f3)
#define BEGIN_PROTOCOL_ENTRY_HEAVY4(method,t1,f1,t2,f2,t3,f3,t4,f4) \
BEGIN_PROTOCOL_ENTRY4 (method,t1,f1,t2,f2,t3,f3,t4,f4)
#define BEGIN_PROTOCOL_ENTRY_HEAVY5(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5) \
BEGIN_PROTOCOL_ENTRY5 (method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5)
#define BEGIN_PROTOCOL_ENTRY_HEAVY6(method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5,t6,f6) \
BEGIN_PROTOCOL_ENTRY6 (method,t1,f1,t2,f2,t3,f3,t4,f4,t5,f5,t6,f6)
#define FLUSH()
#define DEFAULT_PRINT() \
print_entry_content (pes_size, pes, color_output);
#define CUSTOM_PRINT(print) \
print;
#define IS_ALWAYS_MATCH(_)
#define MATCH_INDEX(_)
#define IS_VTABLE_MATCH(_)
#define END_PROTOCOL_ENTRY \
printf ("\n"); \
break; \
}
#define END_PROTOCOL_ENTRY_HEAVY \
END_PROTOCOL_ENTRY
#include <mono/metadata/sgen-protocol-def.h>
default: assert (0);
}
}