Gather timing stats for a Task when it completes.

Previously we did this just for workers, now we do it for the main
thread and for forkOS threads too.

diff --git a/rts/Main.c b/rts/Main.c
index 6aef280..5a1ab10 100644 (file)
--- a/rts/Main.c
+++ b/rts/Main.c
@@ -105,6 +105,7 @@ int main(int argc, char *argv[])
        void *cap = rts_lock();
        cap = rts_evalLazyIO(cap,(HaskellObj)(void *)mainIO_closure, NULL);
        status = rts_getSchedStatus(cap);
+       taskTimeStamp(myTask());
        rts_unlock(cap);
     }
 

diff --git a/rts/Schedule.c b/rts/Schedule.c
index 46f575e..bd8ba74 100644 (file)
--- a/rts/Schedule.c
+++ b/rts/Schedule.c
@@ -2800,7 +2800,7 @@ workerStart(Task *task)
 
     // On exit from schedule(), we have a Capability.
     releaseCapability(cap);
-    taskStop(task);
+    workerTaskStop(task);
 }
 #endif
 

diff --git a/rts/Task.c b/rts/Task.c
index 7366480..9923609 100644 (file)
--- a/rts/Task.c
+++ b/rts/Task.c
@@ -99,10 +99,10 @@ newTask (void)
 #if defined(THREADED_RTS)
     currentUserTime = getThreadCPUTime();
     currentElapsedTime = getProcessElapsedTime();
-    task->mut_time = 0.0;
-    task->mut_etime = 0.0;
-    task->gc_time = 0.0;
-    task->gc_etime = 0.0;
+    task->mut_time = 0;
+    task->mut_etime = 0;
+    task->gc_time = 0;
+    task->gc_etime = 0;
     task->muttimestart = currentUserTime;
     task->elapsedtimestart = currentElapsedTime;
 #endif
@@ -193,16 +193,11 @@ discardTask (Task *task)
 }
 
 void
-taskStop (Task *task)
+taskTimeStamp (Task *task USED_IF_THREADS)
 {
 #if defined(THREADED_RTS)
-    OSThreadId id;
     Ticks currentElapsedTime, currentUserTime, elapsedGCTime;
 
-    id = osThreadId();
-    ASSERT(task->id == id);
-    ASSERT(myTask() == task);
-
     currentUserTime = getThreadCPUTime();
     currentElapsedTime = getProcessElapsedTime();
 
@@ -215,10 +210,22 @@ taskStop (Task *task)
     task->mut_etime = 
        currentElapsedTime - task->elapsedtimestart - elapsedGCTime;
 
-    if (task->mut_time < 0.0)  { task->mut_time = 0.0;  }
-    if (task->mut_etime < 0.0) { task->mut_etime = 0.0; }
+    if (task->mut_time  < 0) { task->mut_time  = 0; }
+    if (task->mut_etime < 0) { task->mut_etime = 0; }
+#endif
+}
+
+void
+workerTaskStop (Task *task)
+{
+#if defined(THREADED_RTS)
+    OSThreadId id;
+    id = osThreadId();
+    ASSERT(task->id == id);
+    ASSERT(myTask() == task);
 #endif
 
+    taskTimeStamp(task);
     task->stopped = rtsTrue;
     tasksRunning--;
 }

diff --git a/rts/Task.h b/rts/Task.h
index ca71d28..cc450a7 100644 (file)
--- a/rts/Task.h
+++ b/rts/Task.h
@@ -190,7 +190,13 @@ INLINE_HEADER void taskEnter (Task *task);
 // mainly for stats-gathering purposes.
 // Requires: sched_mutex.
 //
-void taskStop (Task *task);
+void workerTaskStop (Task *task);
+
+// Record the time spent in this Task.
+// This is called by workerTaskStop() but not by boundTaskExiting(),
+// because it would impose an extra overhead on call-in.
+//
+void taskTimeStamp (Task *task);
 
 // Put the task back on the free list, mark it stopped.  Used by
 // forkProcess().

diff --git a/rts/posix/OSThreads.c b/rts/posix/OSThreads.c
index 07bd762..cff3782 100644 (file)
--- a/rts/posix/OSThreads.c
+++ b/rts/posix/OSThreads.c
@@ -16,6 +16,7 @@
 #if defined(THREADED_RTS)
 #include "OSThreads.h"
 #include "RtsUtils.h"
+#include "Task.h"
 
 #if HAVE_STRING_H
 #include <string.h>
@@ -140,6 +141,7 @@ forkOS_createThreadWrapper ( void * entry )
     Capability *cap;
     cap = rts_lock();
     cap = rts_evalStableIO(cap, (HsStablePtr) entry, NULL);
+    taskTimeStamp(myTask());
     rts_unlock(cap);
     return NULL;
 }