glretrace: Initialize MetricWriter only when needed.

This object is only needed for profiling.  Global initialization is
unnecessary and it creates temporary file (with mmap_allocator.hpp),
which can be avoided.

5 files changed, 23 insertions, 12 deletions

diff --git a/retrace/glretrace.hpp b/retrace/glretrace.hpp
index c60a74db..40bd0cf8 100644
--- a/retrace/glretrace.hpp
+++ b/retrace/glretrace.hpp
@@ -28,11 +28,12 @@
 #include "glws.hpp"
 #include "retrace.hpp"
 #include "metric_backend.hpp"
-#include "metric_writer.hpp"
 
 #include "os_thread.hpp"
 
 
+class MetricWriter;
+
 namespace glretrace {
 
 class Context
@@ -110,7 +111,7 @@ extern bool profilingBoundaries[QUERY_BOUNDARY_LIST_END];
 extern unsigned profilingBoundariesIndex[QUERY_BOUNDARY_LIST_END];
 extern std::vector<MetricBackend*> metricBackends;
 extern MetricBackend* curMetricBackend;
-extern MetricWriter profiler;
+MetricWriter& profiler();
 
 extern glfeatures::Profile defaultProfile;
 
diff --git a/retrace/glretrace_main.cpp b/retrace/glretrace_main.cpp
index 8d015542..d5c9277b 100755
--- a/retrace/glretrace_main.cpp
+++ b/retrace/glretrace_main.cpp
@@ -38,6 +38,7 @@
 #include "os_time.hpp"
 #include "os_memory.hpp"
 #include "highlight.hpp"
+#include "metric_writer.hpp"
 
 /* Synchronous debug output may reduce performance however,
  * without it the callNo in the callback may be inaccurate
@@ -287,11 +288,11 @@ beginProfile(trace::Call &call, bool isDraw) {
                                                program,
                                                call.sig->name};
                 if (profilingBoundaries[QUERY_BOUNDARY_CALL]) {
-                    profiler.addQuery(QUERY_BOUNDARY_CALL, eventId, &callData);
+                    profiler().addQuery(QUERY_BOUNDARY_CALL, eventId, &callData);
                 }
                 if (isDraw && profilingBoundaries[QUERY_BOUNDARY_DRAWCALL]) {
                     eventId = profilingBoundariesIndex[QUERY_BOUNDARY_DRAWCALL]++;
-                    profiler.addQuery(QUERY_BOUNDARY_DRAWCALL, eventId, &callData);
+                    profiler().addQuery(QUERY_BOUNDARY_DRAWCALL, eventId, &callData);
                 }
             }
         }
@@ -530,10 +531,10 @@ frame_complete(trace::Call &call) {
                 // frame end indicator
                 ProfilerCall::data callData = {true, 0, 0, ""};
                 if (profilingBoundaries[QUERY_BOUNDARY_CALL]) {
-                    profiler.addQuery(QUERY_BOUNDARY_CALL, 0, &callData);
+                    profiler().addQuery(QUERY_BOUNDARY_CALL, 0, &callData);
                 }
                 if (profilingBoundaries[QUERY_BOUNDARY_DRAWCALL]) {
-                    profiler.addQuery(QUERY_BOUNDARY_DRAWCALL, 0, &callData);
+                    profiler().addQuery(QUERY_BOUNDARY_DRAWCALL, 0, &callData);
                 }
             }
         }
@@ -542,7 +543,7 @@ frame_complete(trace::Call &call) {
         }
         if (profilingBoundaries[QUERY_BOUNDARY_FRAME]) {
             if (isLastPass() && curMetricBackend) {
-                profiler.addQuery(QUERY_BOUNDARY_FRAME,
+                profiler().addQuery(QUERY_BOUNDARY_FRAME,
                         profilingBoundariesIndex[QUERY_BOUNDARY_FRAME]++);
             }
         }
@@ -877,7 +878,7 @@ retrace::finishRendering(void) {
     }
     if (glretrace::profilingBoundaries[QUERY_BOUNDARY_FRAME]) {
         if (glretrace::isLastPass() && glretrace::curMetricBackend) {
-            glretrace::profiler.addQuery(QUERY_BOUNDARY_FRAME,
+            glretrace::profiler().addQuery(QUERY_BOUNDARY_FRAME,
                     glretrace::profilingBoundariesIndex[QUERY_BOUNDARY_FRAME]++);
         }
     }
@@ -895,13 +896,13 @@ retrace::finishRendering(void) {
 
         if (glretrace::isLastPass()) {
             if (glretrace::profilingBoundaries[QUERY_BOUNDARY_FRAME]) {
-                glretrace::profiler.writeAll(QUERY_BOUNDARY_FRAME);
+                glretrace::profiler().writeAll(QUERY_BOUNDARY_FRAME);
             }
             if (glretrace::profilingBoundaries[QUERY_BOUNDARY_CALL]) {
-                glretrace::profiler.writeAll(QUERY_BOUNDARY_CALL);
+                glretrace::profiler().writeAll(QUERY_BOUNDARY_CALL);
             }
             if (glretrace::profilingBoundaries[QUERY_BOUNDARY_DRAWCALL]) {
-                glretrace::profiler.writeAll(QUERY_BOUNDARY_DRAWCALL);
+                glretrace::profiler().writeAll(QUERY_BOUNDARY_DRAWCALL);
             }
         }
     }
diff --git a/retrace/metric_backend_amd_perfmon.hpp b/retrace/metric_backend_amd_perfmon.hpp
index d191f7c8..bc0a3b8a 100644
--- a/retrace/metric_backend_amd_perfmon.hpp
+++ b/retrace/metric_backend_amd_perfmon.hpp
@@ -29,6 +29,7 @@
 #include <vector>
 #include <map>
 #include <string>
+#include <queue>
 
 #include "glproc.hpp"
 #include "metric_backend.hpp"
diff --git a/retrace/metric_backend_intel_perfquery.hpp b/retrace/metric_backend_intel_perfquery.hpp
index 1a672df1..aa67b4f9 100644
--- a/retrace/metric_backend_intel_perfquery.hpp
+++ b/retrace/metric_backend_intel_perfquery.hpp
@@ -29,10 +29,12 @@
 #include <vector>
 #include <map>
 #include <string>
+#include <queue>
 
 #include "glproc.hpp"
 #include "metric_backend.hpp"
 #include "glretrace.hpp"
+#include "mmap_allocator.hpp"
 
 #define INTEL_NAME_LENGTH 256 // metric name with max 256 chars
 #define INTEL_DESC_LENGTH 1024 // description max 1024 chars
diff --git a/retrace/metric_helper.cpp b/retrace/metric_helper.cpp
index 5c53db43..cafcf80f 100644
--- a/retrace/metric_helper.cpp
+++ b/retrace/metric_helper.cpp
@@ -45,7 +45,11 @@ bool profilingBoundaries[QUERY_BOUNDARY_LIST_END] = {false};
 unsigned profilingBoundariesIndex[QUERY_BOUNDARY_LIST_END] = {0};
 std::vector<MetricBackend*> metricBackends; // to be populated in initContext()
 MetricBackend* curMetricBackend = nullptr; // backend active in the current pass
-MetricWriter profiler(metricBackends, MmapAllocator<char>());
+
+MetricWriter& profiler() {
+    static MetricWriter writer(metricBackends, MmapAllocator<char>());
+    return writer;
+}
 
 MetricBackend* getBackend(std::string backendName) {
     // allocator for metric storage
@@ -212,6 +216,8 @@ void enableMetricsFromCLI(const char* metrics, QueryBoundary pollingRule) {
         metrics = end + 1;
     }
     parseBackendBlock(pollingRule, metrics, std::strlen(metrics), backendsHash);
+
+    profiler(); // initialize MetricWriter
 }
 
 } /* namespace glretrace */