X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=retrace%2Fretrace_main.cpp;h=f9eabcb3b5cfe26729f17e28ab3fbb39bad02ab7;hb=58167d7abcd4159c5524ceca67f0ec58c96b0af7;hp=5f5e095a9cbe875b5bc96fa4ae97dbe06e863d71;hpb=6d92327e88d2bb4c03a1b84663e50497f99fc24f;p=apitrace

diff --git a/retrace/retrace_main.cpp b/retrace/retrace_main.cpp
index 5f5e095..f9eabcb 100644
--- a/retrace/retrace_main.cpp
+++ b/retrace/retrace_main.cpp
@@ -29,6 +29,7 @@
 
 #include "os_binary.hpp"
 #include "os_time.hpp"
+#include "os_thread.hpp"
 #include "image.hpp"
 #include "trace_callset.hpp"
 #include "trace_dump.hpp"
@@ -44,6 +45,8 @@ static trace::CallSet compareFrequency;
 
 static unsigned dumpStateCallNo = ~0;
 
+retrace::Retracer retracer;
+
 
 namespace retrace {
 
@@ -65,6 +68,7 @@ bool profilingCpuTimes = false;
 bool profilingPixelsDrawn = false;
 
 unsigned frameNo = 0;
+unsigned callNo = 0;
 
 
 void
@@ -119,55 +123,240 @@ takeSnapshot(unsigned call_no) {
 }
 
 
+class RelayRunner;
+
+
 static void
-mainLoop() {
-    retrace::Retracer retracer;
+retraceCall(trace::Call *call) {
+    bool swapRenderTarget = call->flags &
+        trace::CALL_FLAG_SWAP_RENDERTARGET;
+    bool doSnapshot = snapshotFrequency.contains(*call) ||
+        compareFrequency.contains(*call);
+
+    // For calls which cause rendertargets to be swaped, we take the
+    // snapshot _before_ swapping the rendertargets.
+    if (doSnapshot && swapRenderTarget) {
+        if (call->flags & trace::CALL_FLAG_END_FRAME) {
+            // For swapbuffers/presents we still use this
+            // call number, spite not have been executed yet.
+            takeSnapshot(call->no);
+        } else {
+            // Whereas for ordinate fbo/rendertarget changes we
+            // use the previous call's number.
+            takeSnapshot(call->no - 1);
+        }
+    }
 
-    addCallbacks(retracer);
+    callNo = call->no;
+    retracer.retrace(*call);
 
-    long long startTime = 0; 
-    frameNo = 0;
+    if (doSnapshot && !swapRenderTarget)
+        takeSnapshot(call->no);
 
-    startTime = os::getTime();
-    trace::Call *call;
+    if (call->no >= dumpStateCallNo &&
+        dumpState(std::cout)) {
+        exit(0);
+    }
+}
 
-    while ((call = retrace::parser.parse_call())) {
-        bool swapRenderTarget = call->flags & trace::CALL_FLAG_SWAP_RENDERTARGET;
-        bool doSnapshot =
-            snapshotFrequency.contains(*call) ||
-            compareFrequency.contains(*call)
-        ;
-
-        // For calls which cause rendertargets to be swaped, we take the
-        // snapshot _before_ swapping the rendertargets.
-        if (doSnapshot && swapRenderTarget) {
-            if (call->flags & trace::CALL_FLAG_END_FRAME) {
-                // For swapbuffers/presents we still use this call number,
-                // spite not have been executed yet.
-                takeSnapshot(call->no);
-            } else {
-                // Whereas for ordinate fbo/rendertarget changes we use the
-                // previous call's number.
-                takeSnapshot(call->no - 1);
+
+class RelayRace
+{
+public:
+    std::vector<RelayRunner*> runners;
+
+    RelayRace();
+
+    RelayRunner *
+    getRunner(unsigned leg);
+
+    void
+    startRace(void);
+
+    void
+    passBaton(trace::Call *call);
+
+    void
+    finishRace();
+};
+
+
+class RelayRunner
+{
+public:
+    RelayRace *race;
+    unsigned leg;
+    os::mutex mutex;
+    os::condition_variable wake_cond;
+
+    bool finished;
+    trace::Call *baton;
+    os::thread *thread;
+
+    static void *
+    runnerThread(RelayRunner *_this);
+
+    RelayRunner(RelayRace *race, unsigned _leg) :
+        race(race),
+        leg(_leg),
+        finished(false),
+        baton(0),
+        thread(0)
+    {
+        if (leg) {
+            thread = new os::thread(runnerThread, this);
+        }
+    }
+
+    void
+    runRace(void) {
+        os::unique_lock<os::mutex> lock(mutex);
+
+        while (1) {
+            while (!finished && !baton) {
+                wake_cond.wait(lock);
             }
+
+            if (finished) {
+                break;
+            }
+
+            assert(baton);
+            trace::Call *call = baton;
+            baton = 0;
+
+            runLeg(call);
         }
 
-        retracer.retrace(*call);
+        if (0) std::cerr << "leg " << leg << " actually finishing\n";
 
-        if (doSnapshot && !swapRenderTarget) {
-            takeSnapshot(call->no);
+        if (leg == 0) {
+            std::vector<RelayRunner*>::iterator it;
+            for (it = race->runners.begin() + 1; it != race->runners.end(); ++it) {
+                RelayRunner* runner = *it;
+                runner->finishRace();
+            }
         }
+    }
 
-        if (call->no >= dumpStateCallNo &&
-            dumpState(std::cout)) {
-            exit(0);
+    void runLeg(trace::Call *call) {
+        do {
+            assert(call);
+            assert(call->thread_id == leg);
+            retraceCall(call);
+            delete call;
+            call = parser.parse_call();
+        } while (call && call->thread_id == leg);
+
+        if (call) {
+            assert(call->thread_id != leg);
+            flushRendering();
+            race->passBaton(call);
+        } else {
+            if (0) std::cerr << "finished on leg " << leg << "\n";
+            if (leg) {
+                race->finishRace();
+            } else {
+                finished = true;
+            }
         }
+    }
+
+    void receiveBaton(trace::Call *call) {
+        assert (call->thread_id == leg);
 
-        delete call;
+        mutex.lock();
+        baton = call;
+        mutex.unlock();
+
+        wake_cond.signal();
     }
 
-    // Reached the end of trace
-    flushRendering();
+    void finishRace() {
+        if (0) std::cerr << "notify finish to leg " << leg << "\n";
+
+        mutex.lock();
+        finished = true;
+        mutex.unlock();
+
+        wake_cond.signal();
+    }
+};
+
+void *
+RelayRunner::runnerThread(RelayRunner *_this) {
+    _this->runRace();
+    return 0;
+}
+
+
+RelayRace::RelayRace() {
+    runners.push_back(new RelayRunner(this, 0));
+}
+
+RelayRunner *
+RelayRace::getRunner(unsigned leg) {
+    RelayRunner *runner;
+
+    if (leg >= runners.size()) {
+        runners.resize(leg + 1);
+        runner = 0;
+    } else {
+        runner = runners[leg];
+    }
+    if (!runner) {
+        runner = new RelayRunner(this, leg);
+        runners[leg] = runner;
+    }
+    return runner;
+}
+
+void
+RelayRace::startRace(void) {
+    trace::Call *call;
+    call = parser.parse_call();
+
+    if (!call) {
+        return;
+    }
+
+    assert(call->thread_id == 0);
+
+    RelayRunner *foreRunner = getRunner(0);
+    if (call->thread_id == 0) {
+        foreRunner->baton = call;
+    } else {
+        passBaton(call);
+    }
+
+    foreRunner->runRace();
+}
+
+void
+RelayRace::passBaton(trace::Call *call) {
+    if (0) std::cerr << "switching to thread " << call->thread_id << "\n";
+    RelayRunner *runner = getRunner(call->thread_id);
+    runner->receiveBaton(call);
+}
+
+void
+RelayRace::finishRace(void) {
+    RelayRunner *runner = getRunner(0);
+    runner->finishRace();
+}
+
+
+static void
+mainLoop() {
+    addCallbacks(retracer);
+
+    long long startTime = 0; 
+    frameNo = 0;
+
+    startTime = os::getTime();
+
+    RelayRace race;
+    race.startRace();
 
     long long endTime = os::getTime();
     float timeInterval = (endTime - startTime) * (1.0 / os::timeFrequency);