Remove benchmarking calls from non benchmarking mode.

map/coverage_generator.cpp

@@ -36,7 +36,8 @@ CoverageGenerator::CoverageGenerator(
     m_fenceManager(2),
     m_currentFenceID(-1),
     m_doForceUpdate(false),
-    m_isPaused(false)
+    m_isPaused(false),
+    m_isBenchmarking(false)
 {
   g_coverageGeneratorDestroyed = false;
 
@@ -49,6 +50,8 @@ CoverageGenerator::CoverageGenerator(
   m_queue.AddFinCommand(bind(&CoverageGenerator::FinalizeThreadGL, this));
 
   m_queue.Start();
+
+  Settings::Get("IsBenchmarking", m_isBenchmarking);
 }
 
 ScreenCoverage * CoverageGenerator::CreateCoverage()
@@ -69,7 +72,10 @@ ScreenCoverage * CoverageGenerator::CreateCoverage()
 
   shared_ptr<graphics::Screen> screen(new graphics::Screen(params));
 
-  return new ScreenCoverage(m_tileRenderer, this, screen);
+  ScreenCoverage * screenCoverage = new ScreenCoverage(m_tileRenderer, this, screen);
+  screenCoverage->SetBenchmarkingFlag(m_isBenchmarking);
+
+  return screenCoverage;
 }
 
 void CoverageGenerator::InitializeThreadGL()
@@ -172,18 +178,21 @@ void CoverageGenerator::AddCoverScreenTask(ScreenBase const & screen, bool doFor
 
 int CoverageGenerator::InsertBenchmarkFence()
 {
+  ASSERT(m_isBenchmarking, ("Only in benchmarking mode!"));
   m_currentFenceID = m_fenceManager.insertFence();
   return m_currentFenceID;
 }
 
 void CoverageGenerator::JoinBenchmarkFence(int fenceID)
 {
+  ASSERT(m_isBenchmarking, ("Only in benchmarking mode!"));
   CHECK(fenceID == m_currentFenceID, ("InsertBenchmarkFence without corresponding SignalBenchmarkFence detected"));
   m_fenceManager.joinFence(fenceID);
 }
 
 void CoverageGenerator::SignalBenchmarkFence()
 {
+  ASSERT(m_isBenchmarking, ("Only in benchmarking mode!"));
   if (m_currentFenceID != -1)
     m_fenceManager.signalFence(m_currentFenceID);
 }
@@ -269,9 +278,7 @@ void CoverageGenerator::MergeTile(core::CommandsQueue::Environment const & env,
 
   m_workCoverage->Clear();
 
-  bool isBenchmarking = false;
-  Settings::Get("IsBenchmarking", isBenchmarking);
-  if (!isBenchmarking)
+  if (!m_isBenchmarking)
     m_windowHandle->invalidate();
 }
 
@@ -320,6 +327,7 @@ void CoverageGenerator::AddDecrementTileCountTask(int sequenceID)
 
 void CoverageGenerator::DecrementTileCounter(int sequenceID)
 {
+  ASSERT(m_isBenchmarking, ("Only in benchmarking mode!"));
   m_benchmarkBarrier.DecrementTileCounter(sequenceID);
   m_windowHandle->invalidate();
 }
@@ -346,6 +354,7 @@ void CoverageGenerator::SetSequenceID(int sequenceID)
 
 void CoverageGenerator::StartTileDrawingSession(int sequenceID, unsigned tileCount)
 {
+  ASSERT(m_isBenchmarking, ("Only in benchmarking mode!"));
   m_benchmarkBarrier.m_sequenceID = sequenceID;
   m_benchmarkBarrier.m_tilesCount = tileCount;
 }

map/coverage_generator.hpp

@@ -82,6 +82,7 @@ private:
 
   bool m_doForceUpdate;
   bool m_isPaused;
+  bool m_isBenchmarking;
 
   ScreenCoverage * CreateCoverage();
 

map/screen_coverage.cpp

@@ -22,7 +22,8 @@ ScreenCoverage::ScreenCoverage()
     m_overlay(new graphics::Overlay()),
     m_isEmptyDrawingCoverage(false),
     m_isEmptyModelAtCoverageCenter(true),
-    m_leafTilesToRender(0)
+    m_leafTilesToRender(0),
+    m_isBenchmarking(false)
 {
   m_overlay->setCouldOverlap(false);
 }
@@ -36,7 +37,8 @@ ScreenCoverage::ScreenCoverage(TileRenderer * tileRenderer,
     m_isEmptyDrawingCoverage(false),
     m_isEmptyModelAtCoverageCenter(true),
     m_leafTilesToRender(0),
-    m_cacheScreen(cacheScreen)
+    m_cacheScreen(cacheScreen),
+    m_isBenchmarking(false)
 {
   m_overlay->setCouldOverlap(false);
 }
@@ -323,7 +325,9 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
   // filtering out rects that are fully covered by its descedants
 
   int curNewTile = 0;
-  m_coverageGenerator->StartTileDrawingSession(GetSequenceID(), newRectsCount);
+
+  if (m_isBenchmarking)
+    m_coverageGenerator->StartTileDrawingSession(GetSequenceID(), newRectsCount);
 
   // adding commands for tiles which aren't in cache
   for (size_t i = 0; i < firstClassTiles.size(); ++i, ++curNewTile)
@@ -337,9 +341,12 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
                           ri,
                           GetSequenceID()));
 
-    chain.addCommand(bind(&CoverageGenerator::AddDecrementTileCountTask,
-                          m_coverageGenerator,
-                          GetSequenceID()));
+    if (m_isBenchmarking)
+    {
+      chain.addCommand(bind(&CoverageGenerator::AddDecrementTileCountTask,
+                            m_coverageGenerator,
+                            GetSequenceID()));
+    }
 
     m_tileRenderer->AddCommand(ri, GetSequenceID(),
                                chain);
@@ -360,9 +367,12 @@ void ScreenCoverage::SetScreen(ScreenBase const & screen)
                           m_tileRenderer,
                           ri));
 
-    chain.addCommand(bind(&CoverageGenerator::AddDecrementTileCountTask,
-                          m_coverageGenerator,
-                          GetSequenceID()));
+    if (m_isBenchmarking)
+    {
+      chain.addCommand(bind(&CoverageGenerator::AddDecrementTileCountTask,
+                            m_coverageGenerator,
+                            GetSequenceID()));
+    }
 
     m_tileRenderer->AddCommand(ri, GetSequenceID(), chain);
   }
@@ -480,3 +490,8 @@ void ScreenCoverage::MergeOverlay()
     }
   }
 }
+
+void ScreenCoverage::SetBenchmarkingFlag(bool isBenchmarking)
+{
+  m_isBenchmarking = isBenchmarking;
+}

map/screen_coverage.hpp

@@ -55,6 +55,7 @@ private:
   shared_ptr<graphics::Overlay> m_overlay;
 
   /// State flags
+  bool m_isBenchmarking;
 
   /// Does the all leaf tiles in this coverage are empty?
   bool m_isEmptyDrawingCoverage;
@@ -133,4 +134,6 @@ public:
   /// Unlock and remove tiles which intersect the specified rect
   /// and deeper or equal than specified scale
   void RemoveTiles(m2::AnyRectD const & r, int startScale);
+
+  void SetBenchmarkingFlag(bool isBenchmarking);
 };