use C99-style array initialisers

[ghc-hetmet.git] / rts / eventlog / EventLog.c

diff --git a/rts/eventlog/EventLog.c b/rts/eventlog/EventLog.c
index 3411235..bd887af 100644 (file)
--- a/rts/eventlog/EventLog.c
+++ b/rts/eventlog/EventLog.c
@@ -8,12 +8,15 @@
 
 #ifdef EVENTLOG
 
+#include "PosixSource.h"
 #include "Rts.h"
+
 #include "EventLog.h"
 #include "Capability.h"
 #include "Trace.h"
 #include "RtsUtils.h"
 #include "Stats.h"
+
 #include <string.h> 
 #include <stdio.h>
 
@@ -36,20 +39,22 @@ typedef struct _EventsBuf {
 EventsBuf *eventsBuf;
 
 char *EventDesc[] = {
-  "Create thread",
-  "Run thread",
-  "Stop thread",
-  "Thread runnable",
-  "Migrate thread",
-  "Run spark",
-  "Steal spark",
-  "Shutdown",
-  "Wakeup thread",
-  "Request sequential GC",
-  "Request parallel GC",
-  "Starting GC",
-  "Finished GC",
-  "Create spark"
+  [EVENT_CREATE_THREAD]       = "Create thread",
+  [EVENT_RUN_THREAD]          = "Run thread",
+  [EVENT_STOP_THREAD]         = "Stop thread",
+  [EVENT_THREAD_RUNNABLE]     = "Thread runnable",
+  [EVENT_MIGRATE_THREAD]      = "Migrate thread",
+  [EVENT_RUN_SPARK]           = "Run spark",
+  [EVENT_STEAL_SPARK]         = "Steal spark",
+  [EVENT_SHUTDOWN]            = "Shutdown",
+  [EVENT_THREAD_WAKEUP]       = "Wakeup thread",
+  [EVENT_GC_START]            = "Starting GC",
+  [EVENT_GC_END]              = "Finished GC",
+  [EVENT_REQUEST_SEQ_GC]      = "Request sequential GC",
+  [EVENT_REQUEST_PAR_GC]      = "Request parallel GC",
+  [EVENT_CREATE_SPARK]        = "Create spark",
+  [EVENT_SPARK_TO_THREAD]     = "Spark to thread", /* DEPRECATED! */
+  [EVENT_CREATE_SPARK_THREAD] = "Create spark thread"
 };
 
 // Event type. 
@@ -105,12 +110,15 @@ static inline void postWord64(EventsBuf *eb, StgWord64 i)
 static inline void postEventTypeNum(EventsBuf *eb, EventTypeNum etNum)
 { postWord16(eb, etNum); }
 
-static inline void postEventTypeID(EventsBuf *eb, StgWord16 etID)
-{ postWord16(eb, etID); }
-
-static inline void postTimestamp(EventsBuf *eb, Timestamp t)
+static inline void postTimestamp(EventsBuf *eb, EventTimestamp t)
 { postWord64(eb,t); }
 
+static inline void postThreadID(EventsBuf *eb, EventThreadID id)
+{ postWord32(eb,id); }
+
+static inline void postCapNo(EventsBuf *eb, EventCapNo no)
+{ postWord16(eb,no); }
+
 static inline void postInt8(EventsBuf *eb, StgInt8 i)
 { postWord8(eb, (StgWord8)i); }
 
@@ -131,7 +139,7 @@ initEventLogging(void)
 
     debugTrace(DEBUG_eventlog, "intiEventLog: start");
 
-    event_log_filename = stgMallocBytes(strlen(prog_name) + 9, 
+    event_log_filename = stgMallocBytes(strlen(prog_name) + 10,
                                         "initEventLogging");
 
     if (sizeof(EventDesc) / sizeof(char*) != NUM_EVENT_TAGS) {
@@ -179,20 +187,20 @@ initEventLogging(void)
         case EVENT_THREAD_RUNNABLE: // (cap, thread)
         case EVENT_CREATE_SPARK:    // (cap, thread)
         case EVENT_RUN_SPARK:       // (cap, thread)
-            eventTypes[t].size = sizeof(CapabilityNum) + sizeof(ThreadID);
+        case EVENT_CREATE_SPARK_THREAD: // (cap, spark_thread)
+            eventTypes[t].size = sizeof(EventCapNo) + sizeof(EventThreadID);
             break;
 
         case EVENT_MIGRATE_THREAD:  // (cap, thread, new_cap)
         case EVENT_STEAL_SPARK:     // (cap, thread, victim_cap)
         case EVENT_THREAD_WAKEUP:   // (cap, thread, other_cap)
             eventTypes[t].size =
-                sizeof(CapabilityNum) + sizeof(ThreadID) +
-                sizeof(CapabilityNum);
+                sizeof(EventCapNo) + sizeof(EventThreadID) + sizeof(EventCapNo);
             break;
 
         case EVENT_STOP_THREAD:     // (cap, thread, status)
             eventTypes[t].size =
-                sizeof(CapabilityNum) + sizeof(ThreadID) + sizeof(StgWord16);
+                sizeof(EventCapNo) + sizeof(EventThreadID) + sizeof(StgWord16);
             break;
 
         case EVENT_SHUTDOWN:        // (cap)
@@ -200,7 +208,7 @@ initEventLogging(void)
         case EVENT_REQUEST_PAR_GC:  // (cap)
         case EVENT_GC_START:        // (cap)
         case EVENT_GC_END:          // (cap)
-            eventTypes[t].size = sizeof(CapabilityNum);
+            eventTypes[t].size = sizeof(EventCapNo);
             break;
         }
 
@@ -279,7 +287,7 @@ freeEventLogging(void)
  * If the buffer is full, prints out the buffer and clears it.
  */
 void
-postEvent_(Capability *cap, EventTypeNum tag, StgThreadID thread, nat other_cap)
+postEvent_(Capability *cap, EventTypeNum tag, StgThreadID thread, StgWord64 other)
 {
     EventsBuf *eb;
 
@@ -294,7 +302,7 @@ postEvent_(Capability *cap, EventTypeNum tag, StgThreadID thread, nat other_cap)
     
     postEventTypeNum(eb, tag);
     postTimestamp(eb, stat_getElapsedTime() * (1000000000LL/TICKS_PER_SECOND));
-    postWord16(eb, cap->no);
+    postCapNo(eb, cap->no);
 
     switch (tag) {
     case EVENT_CREATE_THREAD:   // (cap, thread)
@@ -303,7 +311,13 @@ postEvent_(Capability *cap, EventTypeNum tag, StgThreadID thread, nat other_cap)
     case EVENT_CREATE_SPARK:    // (cap, thread)
     case EVENT_RUN_SPARK:       // (cap, thread)
     {
-        postWord64(eb,thread);
+        postThreadID(eb,thread);
+        break;
+    }
+
+    case EVENT_CREATE_SPARK_THREAD: // (cap, spark_thread)
+    {
+        postThreadID(eb,other /* spark_thread */);
         break;
     }
 
@@ -311,15 +325,15 @@ postEvent_(Capability *cap, EventTypeNum tag, StgThreadID thread, nat other_cap)
     case EVENT_STEAL_SPARK:     // (cap, thread, victim_cap)
     case EVENT_THREAD_WAKEUP:   // (cap, thread, other_cap)
     {
-        postWord64(eb,thread);
-        postWord16(eb,other_cap);
+        postThreadID(eb,thread);
+        postCapNo(eb,other /* new_cap | victim_cap | other_cap */);
         break;
     }
 
     case EVENT_STOP_THREAD:     // (cap, thread, status)
     {
-        postWord64(eb,thread);
-        postWord16(eb,other_cap);
+        postThreadID(eb,thread);
+        postWord16(eb,other /* status */);
         break;
     }
 
@@ -385,7 +399,7 @@ printAndClearEventLog(Capability *cap)
 
 void initEventsBuf(EventsBuf* eb, StgWord64 size)
 {
-    eb->begin = eb->pos = malloc(size);
+    eb->begin = eb->pos = stgMallocBytes(size, "initEventsBuf");
     eb->size = size;
 }
 
@@ -430,7 +444,7 @@ StgBool hasRoomForEvent(EventsBuf *eb, EventTypeNum eNum)
 {
   nat size = 0;
 
-  size += sizeof(EventTypeNum) + sizeof(Timestamp) + eventTypes[eNum].size;
+  size += sizeof(EventTypeNum) + sizeof(EventTimestamp) + eventTypes[eNum].size;
 
   if (eb->pos + size > eb->begin + eb->size) {
       return 0; // Not enough space.