X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=common%2Ftrace_profiler.cpp;h=14edd35477aaac782a9e437a08b0030ccaa58dd3;hb=HEAD;hp=8a3b137bbbe8d94bb32a8dd3b0f943af3b6d1274;hpb=fc4f55a3193269f86c142219f5593dd8b8e9b3c8;p=apitrace

diff --git a/common/trace_profiler.cpp b/common/trace_profiler.cpp
index 8a3b137..14edd35 100644
--- a/common/trace_profiler.cpp
+++ b/common/trace_profiler.cpp
@@ -1,6 +1,7 @@
 /**************************************************************************
  *
  * Copyright 2012 VMware, Inc.
+ * Copyright 2013 Intel, Inc.
  * All Rights Reserved.
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy
@@ -24,18 +25,22 @@
  **************************************************************************/
 
 #include "trace_profiler.hpp"
+#include "os_time.hpp"
 #include <iostream>
 #include <string.h>
-#include <assert.h>
-#include <stdio.h>
+#include <sstream>
 
 namespace trace {
 Profiler::Profiler()
     : baseGpuTime(0),
       baseCpuTime(0),
+      minCpuTime(1000),
+      baseVsizeUsage(0),
+      baseRssUsage(0),
       cpuTimes(false),
       gpuTimes(true),
-      pixelsDrawn(false)
+      pixelsDrawn(false),
+      memoryUsage(false)
 {
 }
 
@@ -43,41 +48,83 @@ Profiler::~Profiler()
 {
 }
 
-void Profiler::setup(bool cpuTimes_, bool gpuTimes_, bool pixelsDrawn_)
+void Profiler::setup(bool cpuTimes_, bool gpuTimes_, bool pixelsDrawn_, bool memoryUsage_)
 {
     cpuTimes = cpuTimes_;
     gpuTimes = gpuTimes_;
     pixelsDrawn = pixelsDrawn_;
+    memoryUsage = memoryUsage_;
 
-    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;
+    std::cout << "# call no gpu_start gpu_dura cpu_start cpu_dura vsize_start vsize_dura rss_start rss_dura pixels program name" << std::endl;
+}
+
+int64_t Profiler::getBaseCpuTime()
+{
+    return baseCpuTime;
+}
+
+int64_t Profiler::getBaseGpuTime()
+{
+    return baseGpuTime;
+}
+
+int64_t Profiler::getBaseVsizeUsage()
+{
+    return baseVsizeUsage;
+}
+
+int64_t Profiler::getBaseRssUsage()
+{
+    return baseRssUsage;
+}
+
+void Profiler::setBaseCpuTime(int64_t cpuStart)
+{
+    baseCpuTime = cpuStart;
+}
+
+void Profiler::setBaseGpuTime(int64_t gpuStart)
+{
+    baseGpuTime = gpuStart;
+}
+
+void Profiler::setBaseVsizeUsage(int64_t vsizeStart)
+{
+    baseVsizeUsage = vsizeStart;
+}
+
+void Profiler::setBaseRssUsage(int64_t rssStart)
+{
+    baseRssUsage = rssStart;
+}
+
+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,
+                       int64_t vsizeStart, int64_t vsizeDuration,
+                       int64_t rssStart, int64_t rssDuration)
 {
-    if (baseGpuTime == 0) {
-        baseGpuTime = gpuStart;
-    }
-
-    if (baseCpuTime == 0) {
-        baseCpuTime = cpuStart;
-    }
-
-    if (gpuTimes) {
+    if (gpuTimes && gpuStart) {
         gpuStart -= baseGpuTime;
     } else {
         gpuStart = 0;
         gpuDuration = 0;
     }
 
-    if (cpuTimes) {
-        cpuStart -= baseCpuTime;
+    if (cpuTimes && cpuStart) {
+        cpuStart = cpuStart - baseCpuTime;
+
+        if (cpuDuration < minCpuTime) {
+            return;
+        }
     } else {
         cpuStart = 0;
         cpuDuration = 0;
@@ -87,105 +134,127 @@ void Profiler::addCall(unsigned no,
         pixels = 0;
     }
 
+    if (!memoryUsage || !vsizeStart || !rssStart) {
+        vsizeStart = 0;
+        vsizeDuration = 0;
+        rssStart = 0;
+        rssDuration = 0;
+    }
+
     std::cout << "call"
               << " " << no
               << " " << gpuStart
               << " " << gpuDuration
               << " " << cpuStart
               << " " << cpuDuration
+              << " " << vsizeStart
+              << " " << vsizeDuration
+              << " " << rssStart
+              << " " << rssDuration
               << " " << pixels
               << " " << program
               << " " << name
               << std::endl;
 }
 
-void Profiler::addFrameStart(unsigned no, uint64_t gpuStart, uint64_t cpuStart)
+void Profiler::addFrameEnd()
 {
-    if (baseGpuTime == 0) {
-        baseGpuTime = gpuStart;
-    }
+    std::cout << "frame_end" << std::endl;
+}
 
-    if (baseCpuTime == 0) {
-        baseCpuTime = cpuStart;
-    }
+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;
+    static int64_t lastVsizeUsage;
+    static int64_t lastRssUsage;
 
-    if (gpuTimes) {
-        lastFrame.gpuStart = gpuStart - baseGpuTime;
-    } else {
-        lastFrame.gpuStart = 0;
-    }
+    if (in[0] == '#' || strlen(in) < 4)
+        return;
 
-    if (cpuTimes) {
-        lastFrame.cpuStart = cpuStart - baseCpuTime;
-    } else {
-        lastFrame.cpuStart = 0;
+    if (profile->programs.size() == 0 && profile->calls.size() == 0 && profile->frames.size() == 0) {
+        lastGpuTime = 0;
+        lastCpuTime = 0;
+        lastVsizeUsage = 0;
+        lastRssUsage = 0;
     }
 
-    lastFrame.no = no;
+    line >> type;
 
-    std::cout << "frame_begin"
-              << " " << lastFrame.no
-              << " " << lastFrame.gpuStart
-              << " " << lastFrame.cpuStart
-              << std::endl;
-}
+    if (type.compare("call") == 0) {
+        Profile::Call call;
 
-void Profiler::addFrameEnd(uint64_t gpuEnd, uint64_t cpuEnd)
-{
-    uint64_t gpuDuration, cpuDuration;
+        line >> call.no
+             >> call.gpuStart
+             >> call.gpuDuration
+             >> call.cpuStart
+             >> call.cpuDuration
+             >> call.vsizeStart
+             >> call.vsizeDuration
+             >> call.rssStart
+             >> call.rssDuration
+             >> call.pixels
+             >> call.program
+             >> call.name;
 
-    if (gpuTimes) {
-        gpuEnd -= baseGpuTime;
-        gpuDuration = gpuEnd - lastFrame.gpuStart;
-    } else {
-        gpuEnd = 0;
-        gpuDuration = 0;
-    }
+        if (lastGpuTime < call.gpuStart + call.gpuDuration) {
+            lastGpuTime = call.gpuStart + call.gpuDuration;
+        }
 
-    if (cpuTimes) {
-        cpuEnd -= baseCpuTime;
-        cpuDuration = cpuEnd - lastFrame.cpuStart;
-    } else {
-        cpuEnd = 0;
-        cpuDuration = 0;
-    }
+        if (lastCpuTime < call.cpuStart + call.cpuDuration) {
+            lastCpuTime = call.cpuStart + call.cpuDuration;
+        }
 
-    std::cout << "frame_end"
-              << " " << lastFrame.no
-              << " " << gpuEnd
-              << " " << gpuDuration
-              << " " << cpuEnd
-              << " " << cpuDuration
-              << std::endl;
-}
+        if (lastVsizeUsage < call.vsizeStart + call.vsizeDuration) {
+            lastVsizeUsage = call.vsizeStart + call.vsizeDuration;
+        }
 
-void Profiler::parseLine(const char* line, Profile* profile)
-{
-    char name[64];
+        if (lastRssUsage < call.rssStart + call.rssDuration) {
+            lastRssUsage = call.rssStart + call.rssDuration;
+        }
 
-    if (line[0] == '#' || strlen(line) < 12)
-        return;
+        profile->calls.push_back(call);
 
-    if (strncmp(line, "call ", 5) == 0) {
-        assert(profile->frames.size());
+        if (call.pixels >= 0) {
+            if (profile->programs.size() <= call.program) {
+                profile->programs.resize(call.program + 1);
+            }
 
-        Profile::Call call;
-        sscanf(line, "call %u %li %li %li %li %li %u %s", &call.no, &call.gpuStart, &call.gpuDuration, &call.cpuStart, &call.cpuDuration, &call.pixels, &call.program, name);
-        call.name = name;
-        profile->frames.back().calls.push_back(call);
-    } else if (strncmp(line, "frame_begin ", 12) == 0) {
+            Profile::Program& program = profile->programs[call.program];
+            program.cpuTotal += call.cpuDuration;
+            program.gpuTotal += call.gpuDuration;
+            program.pixelTotal += call.pixels;
+            program.vsizeTotal += call.vsizeDuration;
+            program.rssTotal += call.rssDuration;
+            program.calls.push_back(profile->calls.size() - 1);
+        }
+    } else if (type.compare("frame_end") == 0) {
         Profile::Frame frame;
-        frame.gpuDuration = 0;
-        frame.gpuDuration = 0;
-        sscanf(line, "frame_begin %u %li %li", &frame.no, &frame.gpuStart, &frame.cpuStart);
-        profile->frames.push_back(frame);
-    } else if (strncmp(line, "frame_end ", 10) == 0) {
-        assert(profile->frames.size());
+        frame.no = profile->frames.size();
 
-        Profile::Frame& frame = profile->frames.back();
-        unsigned no;
-        sscanf(line, "frame_end %u %*li %li %*li %li", &no, &frame.gpuDuration, &frame.cpuDuration);
-        assert(no == frame.no);
+        if (frame.no == 0) {
+            frame.gpuStart = 0;
+            frame.cpuStart = 0;
+            frame.vsizeStart = 0;
+            frame.rssStart = 0;
+            frame.calls.begin = 0;
+        } else {
+            frame.gpuStart = profile->frames.back().gpuStart + profile->frames.back().gpuDuration;
+            frame.cpuStart = profile->frames.back().cpuStart + profile->frames.back().cpuDuration;
+            frame.vsizeStart = profile->frames.back().vsizeStart + profile->frames.back().vsizeDuration;
+            frame.rssStart = profile->frames.back().rssStart + profile->frames.back().rssDuration;
+            frame.calls.begin = profile->frames.back().calls.end + 1;
+        }
+
+        frame.gpuDuration = lastGpuTime - frame.gpuStart;
+        frame.cpuDuration = lastCpuTime - frame.cpuStart;
+        frame.vsizeDuration = lastVsizeUsage - frame.vsizeStart;
+        frame.rssDuration = lastRssUsage - frame.rssStart;
+        frame.calls.end = profile->calls.size() - 1;
+
+        profile->frames.push_back(frame);
     }
 }
 }