Merge pull request #235 from pscollins/counter-metric2

Export a counter event for block allocations.

Author: shwestrick

mltrace/tracetr.c

@@ -4,6 +4,7 @@
  * See the file MLton-LICENSE for details.
  */
 
+#include <assert.h>
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -83,6 +84,8 @@ static const char *EventKindStrings[] = {
 
   [EVENT_SCHED_SLEEP_ENTER] = "SCHED_SLEEP_ENTER",
   [EVENT_SCHED_SLEEP_LEAVE] = "SCHED_SLEEP_LEAVE",
+
+  [EVENT_LIVE_BLOCK_COUNTER] = "LIVE_BLOCKS",
 };
 
 void processFiles(size_t filecount, FILE **files, void (*func)(struct Event *));
@@ -247,8 +250,9 @@ void printEventKindStripEnterLeave(int kind) {
   buf[99] = '\0';
 
   const char *str = EventKindStrings[kind];
+  strncpy(buf, str, 99);
   size_t len = strlen(str);
-  strncpy(buf, str, len-6);
+  assert(len < 100);
   buf[len-6] = '\0';
 
   printf("%s", buf);
@@ -261,18 +265,33 @@ void printEventKindStripEnterLeave(int kind) {
   * see chrome-tracing-docs.txt
   */
 enum ChromeTracingPhaseType {
-  CT_Begin,    // "B"
-  CT_End,      // "E"
-  CT_Instant   // "i"
+  CT_Begin,     // "B"
+  CT_End,       // "E"
+  CT_Instant,   // "i"
+  CT_Counter    // "C"
 };
 
+bool isCounterEvent(int kind) {
+  switch (kind) {
+  case EVENT_LIVE_BLOCK_COUNTER:
+    return true;
+  default:
+    return false;
+  }
+}
+
 enum ChromeTracingPhaseType
 EventKindChromeTracingPhaseType(int kind)
 {
   // default to "instant" event; most general.
   if (!(kind > 0 && (size_t)kind < EventKindCount))
     return CT_Instant;
 
+  // we explicitly enumerate counter events here
+  if (isCounterEvent(kind)) {
+    return CT_Counter;
+  }
+
   // check for "_ENTER" or "_LEAVE", which is the mltrace convention
   const char *str = EventKindStrings[kind];
   size_t len = strlen(str);
@@ -309,6 +328,18 @@ void printEventTimeNanoseconds(struct Event *event) {
   printf("%llu", ns);
 }
 
+void printEventArgs(struct Event *event) {
+  switch (event->kind) {
+  case EVENT_LIVE_BLOCK_COUNTER:
+    printf("\"args\": { \"count\": %lld } ", event->arg1);
+    break;
+  default:
+    printf("\"args\": { \"1\": %lld, \"2\": %lld, \"3\": %lld }",
+           event->arg1, event->arg2, event->arg3);
+    break;
+  }
+}
+
 void printEventChromeTracingJSON(struct Event *event) {
   printf("{ ");
 
@@ -328,6 +359,11 @@ void printEventChromeTracingJSON(struct Event *event) {
       printf("\"ph\": \"E\", ");
       break;
 
+  case CT_Counter:
+      printf("\"name\": \""); printEventKind(event->kind); printf("\", ");
+      printf("\"ph\": \"C\", ");
+      break;
+
     default:
       printf("\"name\": \""); printEventKind(event->kind); printf("\", ");
       printf("\"ph\": \"i\", ");
@@ -338,8 +374,7 @@ void printEventChromeTracingJSON(struct Event *event) {
   printf("\"pid\": 0, ");
   printf("\"tid\": %"PRIdPTR", ", event->argptr);
   printf("\"ts\": "); printEventTimeMicroseconds(event); printf(", ");
-  printf("\"args\": { \"1\": %lld, \"2\": %lld, \"3\": %lld }",
-    event->arg1, event->arg2, event->arg3);
+  printEventArgs(event);
 
   printf("}");
 }
@@ -436,6 +471,11 @@ void printEventText(struct Event *event) {
            event->arg1, event->arg2, event->arg3);
     break;
 
+  case EVENT_LIVE_BLOCK_COUNTER:
+    printf("live_blocks = %lld",
+           event->arg1);
+    break;
+
   default:
     printf("?1 = %llx, ?2 = %llx, ?3 = %llx",
            event->arg1, event->arg2, event->arg3);

runtime/gc/block-allocator.c

@@ -3,11 +3,27 @@
  * MLton is released under a HPND-style license.
  * See the file MLton-LICENSE for details.
  */
+#include <stdatomic.h>
+#include <stdint.h>
 
 #if (defined (MLTON_GC_INTERNAL_FUNCS))
 
 #define INFO_BUFFER_LEN 256
 
+#ifdef ENABLE_TRACING
+static atomic_int_least64_t live_blocks = 0;
+
+// Track the live block count in a separate atomic so that we can easily export
+// it as a counter.
+static int64_t incLiveBlocks(int numBlocks) {
+  return atomic_fetch_add(&live_blocks, numBlocks);
+}
+
+static int64_t decLiveBlocks(int numBlocks) {
+  return atomic_fetch_sub(&live_blocks, numBlocks);
+}
+#endif // ENABLE_TRACING
+
 static inline size_t SUPERBLOCK_SIZE(GC_state s) {
   return (1 << s->controls->superblockThreshold);
 }
@@ -519,6 +535,7 @@ static MegaBlock mmapNewMegaBlock(GC_state s, size_t numBlocks, enum BlockPurpos
 
 
 Blocks allocateBlocksWithPurpose(GC_state s, size_t numBlocks, enum BlockPurpose purpose) {
+  Trace1(EVENT_LIVE_BLOCK_COUNTER, incLiveBlocks(numBlocks));
   BlockAllocator local = s->blockAllocatorLocal;
   assertBlockAllocatorOkay(s, local);
 
@@ -585,6 +602,7 @@ void freeBlocks(GC_state s, Blocks bs, writeFreedBlockInfoFnClosure f) {
   SuperBlock sb = bs->container;
   enum BlockPurpose purpose = bs->purpose;
   pointer blockStart = (pointer)bs;
+  Trace1(EVENT_LIVE_BLOCK_COUNTER, decLiveBlocks(numBlocks));
 
 #if ASSERT
   if (!s->controls->debugKeepFreeBlocks) {

runtime/trace.h

@@ -81,7 +81,9 @@ enum EventKind {
   EVENT_MANAGE_ENTANGLED_LEAVE = 47,
 
   EVENT_SCHED_SLEEP_ENTER     = 48,
-  EVENT_SCHED_SLEEP_LEAVE     = 49
+  EVENT_SCHED_SLEEP_LEAVE     = 49,
+
+  EVENT_LIVE_BLOCK_COUNTER = 50,
 };
 
 #define EventKindCount (sizeof EventKindStrings / sizeof *EventKindStrings)