X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Ftrace_profiler.cpp;h=642ba6e88325560e235dd1d9cab0bc2aa6e023d2;hb=56ad11c7849c7e6ca0ad66558cb1a99c58d4cd3d;hp=38ad6dd93534671ac4c6b7fe78d46f2b5227d317;hpb=27af35ae3464ad0cd891d301c9b821951334e71d;p=apitrace

diff --git a/common/trace_profiler.cpp b/common/trace_profiler.cpp
index 38ad6dd..642ba6e 100644
--- a/common/trace_profiler.cpp
+++ b/common/trace_profiler.cpp
@@ -24,16 +24,16 @@
  **************************************************************************/
 
 #include "trace_profiler.hpp"
+#include "os_time.hpp"
 #include <iostream>
 #include <string.h>
-#include <assert.h>
 #include <sstream>
-#include "os_time.hpp"
 
 namespace trace {
 Profiler::Profiler()
     : baseGpuTime(0),
       baseCpuTime(0),
+      minCpuTime(1000),
       cpuTimes(false),
       gpuTimes(true),
       pixelsDrawn(false)
@@ -50,37 +50,56 @@ void Profiler::setup(bool cpuTimes_, bool gpuTimes_, bool pixelsDrawn_)
     gpuTimes = gpuTimes_;
     pixelsDrawn = pixelsDrawn_;
 
-    std::cout << "# frame_begin no gpu_start cpu_start" << std::endl;
-    std::cout << "# frame_end no gpu_end gpu_dura cpu_end cpu_dura" << std::endl;
     std::cout << "# call no gpu_start gpu_dura cpu_start cpu_dura pixels program name" << std::endl;
 }
 
+int64_t Profiler::getBaseCpuTime()
+{
+    return baseCpuTime;
+}
+
+int64_t Profiler::getBaseGpuTime()
+{
+    return baseGpuTime;
+}
+
+void Profiler::setBaseCpuTime(int64_t cpuStart)
+{
+    baseCpuTime = cpuStart;
+}
+
+void Profiler::setBaseGpuTime(int64_t gpuStart)
+{
+    baseGpuTime = gpuStart;
+}
+
+bool Profiler::hasBaseTimes()
+{
+    return baseCpuTime != 0 || baseGpuTime != 0;
+}
+
 void Profiler::addCall(unsigned no,
                        const char *name,
                        unsigned program,
-                       uint64_t pixels,
-                       uint64_t gpuStart, uint64_t gpuDuration,
-                       uint64_t cpuStart, uint64_t cpuDuration)
+                       int64_t pixels,
+                       int64_t gpuStart, int64_t gpuDuration,
+                       int64_t cpuStart, int64_t cpuDuration)
 {
-    if (baseGpuTime == 0) {
-        baseGpuTime = gpuStart;
-    }
-
-    if (baseCpuTime == 0) {
-        baseCpuTime = cpuStart;
-    }
-
-    if (gpuTimes) {
+    if (gpuTimes && gpuStart) {
         gpuStart -= baseGpuTime;
     } else {
         gpuStart = 0;
         gpuDuration = 0;
     }
 
-    if (cpuTimes) {
+    if (cpuTimes && cpuStart) {
         double cpuTimeScale = 1.0E9 / os::timeFrequency;
         cpuStart = (cpuStart - baseCpuTime) * cpuTimeScale;
         cpuDuration = cpuDuration * cpuTimeScale;
+
+        if (cpuDuration < minCpuTime) {
+            return;
+        }
     } else {
         cpuStart = 0;
         cpuDuration = 0;
@@ -102,114 +121,81 @@ void Profiler::addCall(unsigned no,
               << std::endl;
 }
 
-void Profiler::addFrameStart(unsigned no, uint64_t gpuStart, uint64_t cpuStart)
-{
-    if (baseGpuTime == 0) {
-        baseGpuTime = gpuStart;
-    }
-
-    if (baseCpuTime == 0) {
-        baseCpuTime = cpuStart;
-    }
-        
-    lastFrame.no = no;
-    lastFrame.gpuStart = gpuStart;
-    lastFrame.cpuStart = cpuStart;
-
-    if (gpuTimes) {
-        gpuStart = gpuStart - baseGpuTime;
-    } else {
-        gpuStart = 0;
-    }
-
-    if (cpuTimes) {
-        double cpuTimeScale = 1.0E9 / os::timeFrequency;
-        cpuStart = (cpuStart - baseCpuTime) * cpuTimeScale;
-    } else {
-        cpuStart = 0;
-    }
-
-    std::cout << "frame_begin"
-              << " " << no
-              << " " << gpuStart
-              << " " << cpuStart
-              << std::endl;
-}
-
-void Profiler::addFrameEnd(uint64_t gpuEnd, uint64_t cpuEnd)
+void Profiler::addFrameEnd()
 {
-    uint64_t gpuDuration, cpuDuration;
-
-    if (gpuTimes) {
-        gpuDuration = gpuEnd - lastFrame.gpuStart;
-        gpuEnd = gpuEnd - baseGpuTime;
-    } else {
-        gpuEnd = 0;
-        gpuDuration = 0;
-    }
-
-    if (cpuTimes) {
-        double cpuTimeScale = 1.0E9 / os::timeFrequency;
-        cpuDuration = (cpuEnd - lastFrame.cpuStart) * cpuTimeScale;
-        cpuEnd = (cpuEnd - baseCpuTime) * cpuTimeScale;
-    } else {
-        cpuEnd = 0;
-        cpuDuration = 0;
-    }
-
-    std::cout << "frame_end"
-              << " " << lastFrame.no
-              << " " << gpuEnd
-              << " " << gpuDuration
-              << " " << cpuEnd
-              << " " << cpuDuration
-              << std::endl;
+    std::cout << "frame_end" << std::endl;
 }
 
 void Profiler::parseLine(const char* in, Profile* profile)
 {
     std::stringstream line(in, std::ios_base::in);
     std::string type;
+    static int64_t lastGpuTime;
+    static int64_t lastCpuTime;
 
-    if (in[0] == '#' || strlen(in) < 12)
+    if (in[0] == '#' || strlen(in) < 4)
         return;
 
+    if (profile->programs.size() == 0 && profile->cpuCalls.size() == 0 && profile->frames.size() == 0) {
+        lastGpuTime = 0;
+        lastCpuTime = 0;
+    }
+
     line >> type;
 
     if (type.compare("call") == 0) {
-        assert(profile->frames.size());
-        Profile::Call call;
-
-        line >> call.no
-             >> call.gpuStart
-             >> call.gpuDuration
-             >> call.cpuStart
-             >> call.cpuDuration
-             >> call.pixels
-             >> call.program
-             >> call.name;
-
-        profile->frames.back().calls.push_back(call);
-    } else if (type.compare("frame_begin") == 0) {
+        Profile::DrawCall draw;
+        unsigned program;
+
+        line >> draw.no
+             >> draw.gpuStart
+             >> draw.gpuDuration
+             >> draw.cpuStart
+             >> draw.cpuDuration
+             >> draw.pixels
+             >> program
+             >> draw.name;
+
+        if (lastGpuTime < draw.gpuStart + draw.gpuDuration) {
+            lastGpuTime = draw.gpuStart + draw.gpuDuration;
+        }
+
+        if (lastCpuTime < draw.cpuStart + draw.cpuDuration) {
+            lastCpuTime = draw.cpuStart + draw.cpuDuration;
+        }
+
+        if (draw.pixels >= 0) {
+            if (profile->programs.size() <= program) {
+                profile->programs.resize(program + 1);
+            }
+
+            profile->programs[program].cpuTotal += draw.cpuDuration;
+            profile->programs[program].gpuTotal += draw.gpuDuration;
+            profile->programs[program].pixelTotal += draw.pixels;
+            profile->programs[program].drawCalls.push_back(draw);
+        }
+
+        Profile::CpuCall call;
+        call.no          = draw.no;
+        call.name        = draw.name;
+        call.cpuStart    = draw.cpuStart;
+        call.cpuDuration = draw.cpuDuration;
+        profile->cpuCalls.push_back(call);
+    } else if (type.compare("frame_end") == 0) {
         Profile::Frame frame;
-        frame.gpuDuration = 0;
-        frame.cpuDuration = 0;
-
-        line >> frame.no
-             >> frame.gpuStart
-             >> frame.cpuStart;
-
+        frame.no = profile->frames.size();
+
+        if (frame.no == 0) {
+            frame.gpuStart = 0;
+            frame.cpuStart = 0;
+        } else {
+            frame.gpuStart = profile->frames.back().gpuStart + profile->frames.back().gpuDuration;
+            frame.cpuStart = profile->frames.back().cpuStart + profile->frames.back().cpuDuration;
+        }
+
+        frame.gpuDuration = lastGpuTime - frame.gpuStart;
+        frame.cpuDuration = lastCpuTime - frame.cpuStart;
         profile->frames.push_back(frame);
-    } else if (type.compare("frame_end") == 0) {
-        assert(profile->frames.size());
-        Profile::Frame& frame = profile->frames.back();
-        int64_t skipi64;
-
-        line >> frame.no
-             >> skipi64
-             >> frame.gpuDuration
-             >> skipi64
-             >> frame.cpuDuration;
     }
 }
 }