pastk/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

Getting drape statistic after running of test scenarios.

Browse source
This commit is contained in:
Daria Volvenkova 2017-01-16 16:19:45 +03:00
parent 5b3aea0191
commit c6f5a07e7c
25 changed files with 847 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
drape/CMakeLists.txt
View file

@ -40,6 +40,7 @@ set(
${DRAPE_ROOT}/data_buffer_impl.hpp
${DRAPE_ROOT}/debug_rect_renderer.cpp
${DRAPE_ROOT}/debug_rect_renderer.hpp
${DRAPE_ROOT}/drape_diagnostics.hpp
${DRAPE_ROOT}/drape_global.hpp
${DRAPE_ROOT}/dynamic_texture.hpp
${DRAPE_ROOT}/font_texture.cpp

5
drape/debug_rect_renderer.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include "drape/drape_diagnostics.hpp"
#include "drape/gpu_program_manager.hpp"
#include "drape/overlay_tree.hpp"
#include "drape/pointers.hpp"
@ -7,8 +9,6 @@
#include "geometry/rect2d.hpp"
#include "geometry/screenbase.hpp"
//#define RENDER_DEBUG_RECTS
namespace dp
{
@ -39,3 +39,4 @@ private:
};
} // namespace dp

1
drape/drape_common.pri
View file

@ -66,6 +66,7 @@ HEADERS += \
$$DRAPE_DIR/data_buffer.hpp \
$$DRAPE_DIR/data_buffer_impl.hpp \
$$DRAPE_DIR/debug_rect_renderer.hpp \
$$DRAPE_DIR/drape_diagnostics.hpp \
$$DRAPE_DIR/drape_global.hpp \
$$DRAPE_DIR/dynamic_texture.hpp \
$$DRAPE_DIR/font_texture.hpp \

19
drape/drape_diagnostics.hpp Normal file
View file

@ -0,0 +1,19 @@
#pragma once
//#define DRAW_TILE_NET
//#define RENDER_DEBUG_RECTS
//#define COLLECT_DISPLACEMENT_INFO
//#define DRAPE_MEASURER
//#define SCENARIO_ENABLE
#ifdef DRAPE_MEASURER
//#define RENDER_STATISTIC
//#define TILES_STATISTIC
//#define GENERATING_STATISTIC
//#define TRACK_GPU_MEM
//#define TRACK_GLYPH_USAGE
#endif

3
drape/overlay_tree.hpp
View file

@ -1,5 +1,6 @@
#pragma once
#include "drape/drape_diagnostics.hpp"
#include "drape/overlay_handle.hpp"
#include "geometry/screenbase.hpp"
@ -14,8 +15,6 @@
namespace dp
{
//#define COLLECT_DISPLACEMENT_INFO
namespace detail
{

30
drape/utils/glyph_usage_tracker.cpp
View file

@ -9,18 +9,10 @@
namespace dp
{
GlyphUsageTracker & GlyphUsageTracker::Instance()
string GlyphUsageTracker::GlyphUsageStatistic::ToString() const
{
static GlyphUsageTracker s_inst;
return s_inst;
}
string GlyphUsageTracker::Report()
{
lock_guard<mutex> lock(m_mutex);
ostringstream ss;
ss << "\n ===== Glyphs Usage Report ===== \n";
ss << " ----- Glyphs usage report ----- \n";
ss << " Current language = " << languages::GetCurrentOrig() << "\n";
ss << " Invalid glyphs count = " << m_invalidGlyphs.size() << "\n";
ss << " Invalid glyphs: { ";
@ -40,11 +32,23 @@ string GlyphUsageTracker::Report()
ss << "}\n";
}
ss << " }\n";
ss << " ===== Glyphs Usage Report ===== \n";
ss << " ----- Glyphs usage report ----- \n";
return ss.str();
}
GlyphUsageTracker & GlyphUsageTracker::Instance()
{
static GlyphUsageTracker s_inst;
return s_inst;
}
GlyphUsageTracker::GlyphUsageStatistic GlyphUsageTracker::Report()
{
lock_guard<mutex> lock(m_mutex);
return m_glyphStat;
}
void GlyphUsageTracker::AddInvalidGlyph(strings::UniString const & str, strings::UniChar const & c)
{
lock_guard<mutex> lock(m_mutex);
@ -52,7 +56,7 @@ void GlyphUsageTracker::AddInvalidGlyph(strings::UniString const & str, strings:
if (m_processedStrings.find(strings::ToUtf8(str)) != m_processedStrings.end())
return;
++m_invalidGlyphs[c];
++m_glyphStat.m_invalidGlyphs[c];
m_processedStrings.insert(strings::ToUtf8(str));
}
@ -65,7 +69,7 @@ void GlyphUsageTracker::AddUnexpectedGlyph(strings::UniString const & str, strin
if (m_processedStrings.find(strings::ToUtf8(str)) != m_processedStrings.end())
return;
UnexpectedGlyphData & data = m_unexpectedGlyphs[c];
UnexpectedGlyphData & data = m_glyphStat.m_unexpectedGlyphs[c];
++data.m_counter;
data.m_expectedGroups.emplace(expectedGroup);
data.m_group = group;

46
drape/utils/glyph_usage_tracker.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include "drape/drape_diagnostics.hpp"
#include "base/string_utils.hpp"
#include "std/map.hpp"
@ -9,31 +11,12 @@
#include "std/string.hpp"
#include "std/unordered_set.hpp"
//#define TRACK_GLYPH_USAGE
namespace dp
{
class GlyphUsageTracker
{
public:
static GlyphUsageTracker & Instance();
void AddInvalidGlyph(strings::UniString const & str, strings::UniChar const & c);
void AddUnexpectedGlyph(strings::UniString const & str, strings::UniChar const & c,
size_t const group, size_t const expectedGroup);
string Report();
private:
GlyphUsageTracker() = default;
GlyphUsageTracker(GlyphUsageTracker const & rhs) = delete;
GlyphUsageTracker(GlyphUsageTracker && rhs) = delete;
private:
using InvalidGlyphs = map<strings::UniChar, size_t>;
InvalidGlyphs m_invalidGlyphs;
struct UnexpectedGlyphData
{
size_t m_counter = 0;
@ -41,8 +24,31 @@ private:
set<size_t> m_expectedGroups;
};
using UnexpectedGlyphs = map<strings::UniChar, UnexpectedGlyphData>;
UnexpectedGlyphs m_unexpectedGlyphs;
using InvalidGlyphs = map<strings::UniChar, size_t>;
struct GlyphUsageStatistic
{
string ToString() const;
InvalidGlyphs m_invalidGlyphs;
UnexpectedGlyphs m_unexpectedGlyphs;
};
static GlyphUsageTracker & Instance();
void AddInvalidGlyph(strings::UniString const & str, strings::UniChar const & c);
void AddUnexpectedGlyph(strings::UniString const & str, strings::UniChar const & c,
size_t const group, size_t const expectedGroup);
GlyphUsageStatistic Report();
private:
GlyphUsageTracker() = default;
GlyphUsageTracker(GlyphUsageTracker const & rhs) = delete;
GlyphUsageTracker(GlyphUsageTracker && rhs) = delete;
private:
GlyphUsageStatistic m_glyphStat;
unordered_set<string> m_processedStrings;
mutex m_mutex;

66
drape/utils/gpu_mem_tracker.cpp
View file

@ -6,50 +6,58 @@
namespace dp
{
string GPUMemTracker::GPUMemorySnapshot::ToString() const
{
ostringstream ss;
ss << " Summary Allocated = " << m_summaryAllocatedInMb << "Mb\n";
ss << " Summary Used = " << m_summaryUsedInMb << "Mb\n";
ss << " Tags registered = " << m_tagStats.size() << "\n";
for (auto const it : m_tagStats)
{
ss << " Tag = " << it.first << " \n";
ss << " Object count = " << it.second.m_objectsCount << "\n";
ss << " Allocated = " << it.second.m_alocatedInMb << "Mb\n";
ss << " Used = " << it.second.m_usedInMb << "Mb\n";
}
return ss.str();
}
GPUMemTracker & GPUMemTracker::Inst()
{
static GPUMemTracker s_inst;
return s_inst;
}
string GPUMemTracker::Report()
GPUMemTracker::GPUMemorySnapshot GPUMemTracker::GetMemorySnapshot()
{
uint32_t summaryUsed = 0;
uint32_t summaryAllocated = 0;
GPUMemorySnapshot memStat;
typedef tuple<size_t, uint32_t, uint32_t> TTagStat;
map<string, TTagStat> tagStats;
for (auto const it : m_memTracker)
{
TTagStat & stat = tagStats[it.first.first];
get<0>(stat)++;
get<1>(stat) += it.second.first;
get<2>(stat) += it.second.second;
threads::MutexGuard g(m_mutex);
for (auto const it : m_memTracker)
{
TagMemorySnapshot & tagStat = memStat.m_tagStats[it.first.first];
tagStat.m_objectsCount++;
tagStat.m_alocatedInMb += it.second.first;
tagStat.m_usedInMb += it.second.second;
summaryAllocated += it.second.first;
summaryUsed += it.second.second;
memStat.m_summaryAllocatedInMb += it.second.first;
memStat.m_summaryUsedInMb += it.second.second;
}
}
float byteToMb = static_cast<float>(1024 * 1024);
ostringstream ss;
ss << " ===== Mem Report ===== \n";
ss << " Summary Allocated = " << summaryAllocated / byteToMb << "\n";
ss << " Summary Used = " << summaryUsed / byteToMb << "\n";
ss << " Tags registered = " << tagStats.size() << "\n";
for (auto const it : tagStats)
for (auto & it : memStat.m_tagStats)
{
ss << " Tag = " << it.first << " \n";
ss << " Object count = " << get<0>(it.second) << "\n";
ss << " Allocated = " << get<1>(it.second) / byteToMb << "\n";
ss << " Used = " << get<2>(it.second) / byteToMb << "\n";
it.second.m_alocatedInMb /= byteToMb;
it.second.m_usedInMb /= byteToMb;
}
memStat.m_summaryAllocatedInMb /= byteToMb;
memStat.m_summaryUsedInMb /= byteToMb;
ss << " ===== Mem Report ===== \n";
return ss.str();
return memStat;
}
void GPUMemTracker::AddAllocated(string const & tag, uint32_t id, uint32_t size)
@ -63,7 +71,7 @@ void GPUMemTracker::SetUsed(string const & tag, uint32_t id, uint32_t size)
threads::MutexGuard g(m_mutex);
TAlocUsedMem & node = m_memTracker[make_pair(tag, id)];
node.second = size;
ASSERT_LESS_OR_EQUAL(node.second, node.first, ("Can't use more then allocated"));
ASSERT_LESS_OR_EQUAL(node.second, node.first, ("Can't use more than allocated"));
}
void GPUMemTracker::RemoveDeallocated(string const & tag, uint32_t id)

24
drape/utils/gpu_mem_tracker.hpp
View file

@ -1,5 +1,7 @@
#pragma once
#include "drape/drape_diagnostics.hpp"
#include "base/mutex.hpp"
#include "std/map.hpp"
@ -7,18 +9,32 @@
#include "std/string.hpp"
#include "std/utility.hpp"
//#define TRACK_GPU_MEM
namespace dp
{
class GPUMemTracker : private noncopyable
{
public:
struct TagMemorySnapshot
{
uint32_t m_objectsCount = 0;
uint32_t m_alocatedInMb = 0;
uint32_t m_usedInMb = 0;
};
struct GPUMemorySnapshot
{
string ToString() const;
uint32_t m_summaryAllocatedInMb = 0;
uint32_t m_summaryUsedInMb = 0;
map<string, TagMemorySnapshot> m_tagStats;
};
static GPUMemTracker & Inst();
string Report();
GPUMemorySnapshot GetMemorySnapshot();
void AddAllocated(string const & tag, uint32_t id, uint32_t size);
void SetUsed(string const & tag, uint32_t id, uint32_t size);
void RemoveDeallocated(string const & tag, uint32_t id);

2
drape_frontend/CMakeLists.txt
View file

@ -69,6 +69,8 @@ set(
drape_api_renderer.hpp
drape_engine.cpp
drape_engine.hpp
drape_measurer.cpp
drape_measurer.hpp
engine_context.cpp
engine_context.hpp
framebuffer.cpp

15
drape_frontend/backend_renderer.cpp
View file

@ -3,6 +3,7 @@
#include "drape_frontend/backend_renderer.hpp"
#include "drape_frontend/batchers_pool.hpp"
#include "drape_frontend/drape_api_builder.hpp"
#include "drape_frontend/drape_measurer.hpp"
#include "drape_frontend/gps_track_shape.hpp"
#include "drape_frontend/map_shape.hpp"
#include "drape_frontend/message_subclasses.hpp"
@ -204,11 +205,17 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
if (m_requestedTiles->CheckTileKey(tileKey) && m_readManager->CheckTileKey(tileKey))
{
ref_ptr<dp::Batcher> batcher = m_batchersPool->GetBatcher(tileKey);
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().StartShapesGeneration();
#endif
for (drape_ptr<MapShape> const & shape : msg->GetShapes())
{
batcher->SetFeatureMinZoom(shape->GetFeatureMinZoom());
shape->Draw(batcher, m_texMng);
}
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().EndShapesGeneration(static_cast<uint32_t>(msg->GetShapes().size()));
#endif
}
break;
}
@ -221,6 +228,9 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
{
CleanupOverlays(tileKey);
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().StartOverlayShapesGeneration();
#endif
OverlayBatcher batcher(tileKey);
for (drape_ptr<MapShape> const & shape : msg->GetShapes())
batcher.Batch(shape, m_texMng);
@ -232,6 +242,11 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
m_overlays.reserve(m_overlays.size() + renderData.size());
move(renderData.begin(), renderData.end(), back_inserter(m_overlays));
}
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().EndOverlayShapesGeneration(
static_cast<uint32_t>(msg->GetShapes().size()));
#endif
}
break;
}

7
drape_frontend/drape_engine.cpp
View file

@ -574,12 +574,13 @@ void DrapeEngine::SetFontScaleFactor(double scaleFactor)
VisualParams::Instance().SetFontScale(scaleFactor);
}
void DrapeEngine::RunScenario(ScenarioManager::Scenario && scenario,
ScenarioManager::OnFinishHandler const & handler)
void DrapeEngine::RunScenario(ScenarioManager::ScenarioData && scenarioData,
ScenarioManager::ScenarioCallback const & onStartFn,
ScenarioManager::ScenarioCallback const & onFinishFn)
{
auto const & manager = m_frontend->GetScenarioManager();
if (manager != nullptr)
manager->RunScenario(move(scenario), handler);
manager->RunScenario(move(scenarioData), onStartFn, onFinishFn);
}
} // namespace df

5
drape_frontend/drape_engine.hpp
View file

@ -177,8 +177,9 @@ public:
void SetFontScaleFactor(double scaleFactor);
void RunScenario(ScenarioManager::Scenario && scenario,
ScenarioManager::OnFinishHandler const & handler);
void RunScenario(ScenarioManager::ScenarioData && scenarioData,
ScenarioManager::ScenarioCallback const & onStartFn,
ScenarioManager::ScenarioCallback const & onFinishFn);
private:
void AddUserEvent(drape_ptr<UserEvent> && e);

3
drape_frontend/drape_frontend.pro
View file

@ -8,7 +8,6 @@ include($$ROOT_DIR/common.pri)
INCLUDEPATH *= $$ROOT_DIR/3party/protobuf/src
INCLUDEPATH *= $$ROOT_DIR/3party/expat/lib
INCLUDEPATH *= $$ROOT_DIR/3party/freetype/include
#DEFINES += DRAW_INFO
SOURCES += \
$$ROOT_DIR/3party/agg/agg_curves.cpp \
@ -50,6 +49,7 @@ SOURCES += \
drape_api_builder.cpp \
drape_api_renderer.cpp \
drape_engine.cpp \
drape_measurer.cpp \
engine_context.cpp \
framebuffer.cpp \
frontend_renderer.cpp \
@ -150,6 +150,7 @@ HEADERS += \
drape_api_builder.hpp \
drape_api_renderer.hpp \
drape_engine.hpp \
drape_measurer.hpp \
engine_context.hpp \
framebuffer.hpp \
frontend_renderer.hpp \

417
drape_frontend/drape_measurer.cpp Normal file
View file

@ -0,0 +1,417 @@
#include "drape_measurer.hpp"
namespace df
{
DrapeMeasurer & DrapeMeasurer::Instance()
{
static DrapeMeasurer s_inst;
return s_inst;
}
void DrapeMeasurer::StartBenchmark()
{
using namespace std::chrono;
m_isEnabled = true;
auto currentTime = std::chrono::steady_clock::now();
#ifdef GENERATING_STATISTIC
m_startScenePreparingTime = currentTime;
m_maxScenePreparingTime = steady_clock::duration::zero();
m_startShapesGenTime = currentTime;
m_totalShapesGenTime = steady_clock::duration::zero();
m_totalShapesCount = 0;
m_startOverlayShapesGenTime = currentTime;
m_totalOverlayShapesGenTime = steady_clock::duration::zero();
m_totalOverlayShapesCount = 0;
#endif
#ifdef TILES_STATISTIC
{
lock_guard<mutex> lock(m_tilesMutex);
m_tilesReadInfo.clear();
}
#endif
#ifdef RENDER_STATISTIC
m_totalTPF = steady_clock::duration::zero();
m_totalTPFCount = 0;
m_minFPS = std::numeric_limits<uint32_t>::max();
m_totalFPS = 0.0;
m_totalFPSCount = 0;
#endif
#if defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM)
m_startFrameRenderTime = currentTime;
m_totalFrameRenderTime = steady_clock::duration::zero();
m_totalFramesCount = 0;
#endif
#ifdef TRACK_GPU_MEM
m_maxSnapshotValues = dp::GPUMemTracker::GPUMemorySnapshot();
m_summarySnapshotValues = dp::GPUMemTracker::GPUMemorySnapshot();
m_numberOfSnapshots = 0;
#endif
}
void DrapeMeasurer::StopBenchmark()
{
m_isEnabled = false;
}
#ifdef GENERATING_STATISTIC
void DrapeMeasurer::StartScenePreparing()
{
if (!m_isEnabled)
return;
m_startScenePreparingTime = std::chrono::steady_clock::now();
}
void DrapeMeasurer::EndScenePreparing()
{
if (!m_isEnabled)
return;
m_maxScenePreparingTime = max(m_maxScenePreparingTime,
std::chrono::steady_clock::now() - m_startScenePreparingTime);
}
void DrapeMeasurer::StartShapesGeneration()
{
m_startShapesGenTime = std::chrono::steady_clock::now();
}
void DrapeMeasurer::EndShapesGeneration(uint32_t shapesCount)
{
m_totalShapesGenTime += std::chrono::steady_clock::now() - m_startShapesGenTime;
m_totalShapesCount += shapesCount;
}
void DrapeMeasurer::StartOverlayShapesGeneration()
{
m_startOverlayShapesGenTime = std::chrono::steady_clock::now();
}
void DrapeMeasurer::EndOverlayShapesGeneration(uint32_t shapesCount)
{
m_totalOverlayShapesGenTime += std::chrono::steady_clock::now() - m_startOverlayShapesGenTime;
m_totalOverlayShapesCount += shapesCount;
}
std::string DrapeMeasurer::GeneratingStatistic::ToString() const
{
std::ostringstream ss;
ss << " ----- Generation statistic report ----- \n";
ss << " Max scene preparing time, ms = " << m_maxScenePreparingTimeInMs << "\n";
ss << " Shapes total generation time, ms = " << m_shapeGenTimeInMs << "\n";
ss << " Shapes total count = " << m_shapesCount
<< ", (" << static_cast<double>(m_shapeGenTimeInMs) / m_shapesCount << " ms per shape)\n";
ss << " Overlay shapes total generation time, ms = " << m_overlayShapeGenTimeInMs << "\n";
ss << " Overlay shapes total count = " << m_overlayShapesCount
<< ", (" << static_cast<double>(m_overlayShapeGenTimeInMs) / m_overlayShapesCount << " ms per overlay)\n";
ss << " ----- Generation statistic report ----- \n";
return ss.str();
}
DrapeMeasurer::GeneratingStatistic DrapeMeasurer::GetGeneratingStatistic()
{
using namespace std::chrono;
GeneratingStatistic statistic;
statistic.m_shapesCount = m_totalShapesCount;
statistic.m_shapeGenTimeInMs =
static_cast<uint32_t>(duration_cast<milliseconds>(m_totalShapesGenTime).count());
statistic.m_overlayShapesCount = m_totalOverlayShapesCount;
statistic.m_overlayShapeGenTimeInMs =
static_cast<uint32_t>(duration_cast<milliseconds>(m_totalOverlayShapesGenTime).count());
statistic.m_maxScenePreparingTimeInMs =
static_cast<uint32_t>(duration_cast<milliseconds>(m_maxScenePreparingTime).count());
return statistic;
}
#endif
#ifdef RENDER_STATISTIC
std::string DrapeMeasurer::RenderStatistic::ToString() const
{
std::ostringstream ss;
ss << " ----- Render statistic report ----- \n";
ss << " FPS = " << m_FPS << "\n";
ss << " min FPS = " << m_minFPS << "\n";
ss << " Frame render time, ms = " << m_frameRenderTimeInMs << "\n";
ss << " ----- Render statistic report ----- \n";
return ss.str();
}
DrapeMeasurer::RenderStatistic DrapeMeasurer::GetRenderStatistic()
{
using namespace std::chrono;
RenderStatistic statistic;
statistic.m_FPS = m_totalFPS / m_totalFPSCount;
statistic.m_minFPS = m_minFPS;
statistic.m_frameRenderTimeInMs =
static_cast<uint32_t>(duration_cast<milliseconds>(m_totalTPF).count()) / m_totalTPFCount;
return statistic;
}
#endif
#if defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM)
void DrapeMeasurer::BeforeRenderFrame()
{
if (!m_isEnabled)
return;
m_startFrameRenderTime = std::chrono::steady_clock::now();
}
void DrapeMeasurer::AfterRenderFrame()
{
using namespace std::chrono;
if (!m_isEnabled)
return;
++m_totalFramesCount;
m_totalFrameRenderTime += steady_clock::now() - m_startFrameRenderTime;
auto elapsed = duration_cast<milliseconds>(m_totalFrameRenderTime).count();
if (elapsed > 1000)
{
#ifdef RENDER_STATISTIC
double fps = m_totalFramesCount * 1000.0 / elapsed;
m_minFPS = std::min(m_minFPS, static_cast<uint32_t>(fps));
m_totalFPS += fps;
++m_totalFPSCount;
m_totalTPF += m_totalFrameRenderTime / m_totalFramesCount;
++m_totalTPFCount;
#endif
m_totalFramesCount = 0;
m_totalFrameRenderTime = steady_clock::duration::zero();
#ifdef TRACK_GPU_MEM
TakeGPUMemorySnapshot();
#endif
}
}
#endif
#ifdef TILES_STATISTIC
std::string DrapeMeasurer::TileStatistic::ToString() const
{
std::ostringstream ss;
ss << " ----- Tiles read statistic report ----- \n";
ss << " Tile read time, ms = " << m_tileReadTimeInMs << "\n";
ss << " Tiles count = " << m_totalTilesCount << "\n";
ss << " ----- Tiles read statistic report ----- \n";
return ss.str();
}
void DrapeMeasurer::StartTileReading()
{
if (!m_isEnabled)
return;
threads::ThreadID tid = threads::GetCurrentThreadID();
std::shared_ptr<TileReadInfo> tileInfo;
{
lock_guard<mutex> lock(m_tilesMutex);
auto const it = m_tilesReadInfo.find(tid);
if (it != m_tilesReadInfo.end())
{
tileInfo = it->second;
}
else
{
tileInfo = std::make_shared<TileReadInfo>();
m_tilesReadInfo.insert(make_pair(tid, tileInfo));
}
}
auto const currentTime = std::chrono::steady_clock::now();
tileInfo->m_startTileReadTime = currentTime;
}
void DrapeMeasurer::EndTileReading()
{
if (!m_isEnabled)
return;
auto const currentTime = std::chrono::steady_clock::now();
threads::ThreadID tid = threads::GetCurrentThreadID();
std::shared_ptr<TileReadInfo> tileInfo;
{
lock_guard<mutex> lock(m_tilesMutex);
auto const it = m_tilesReadInfo.find(tid);
if (it != m_tilesReadInfo.end())
tileInfo = it->second;
else
return;
}
auto passedTime = currentTime - tileInfo->m_startTileReadTime;
tileInfo->m_totalTileReadTime += passedTime;
++tileInfo->m_totalTilesCount;
}
DrapeMeasurer::TileStatistic DrapeMeasurer::GetTileStatistic()
{
using namespace std::chrono;
TileStatistic statistic;
{
lock_guard<mutex> lock(m_tilesMutex);
for (auto const & it : m_tilesReadInfo)
{
statistic.m_tileReadTimeInMs +=
static_cast<uint32_t>(duration_cast<milliseconds>(it.second->m_totalTileReadTime).count());
statistic.m_totalTilesCount += it.second->m_totalTilesCount;
}
}
if (statistic.m_totalTilesCount > 0)
statistic.m_tileReadTimeInMs /= statistic.m_totalTilesCount;
return statistic;
}
#endif
#ifdef TRACK_GPU_MEM
std::string DrapeMeasurer::GPUMemoryStatistic::ToString() const
{
std::ostringstream ss;
ss << " ----- GPU memory report ----- \n";
ss << " --Max memory values:\n";
ss << m_maxMemoryValues.ToString();
ss << "\n --Average memory values:\n";
ss << m_averageMemoryValues.ToString();
ss << " ----- GPU memory report ----- \n";
return ss.str();
}
void DrapeMeasurer::TakeGPUMemorySnapshot()
{
dp::GPUMemTracker::GPUMemorySnapshot snap = dp::GPUMemTracker::Inst().GetMemorySnapshot();
for (auto const & tagPair : snap.m_tagStats)
{
auto itMax = m_maxSnapshotValues.m_tagStats.find(tagPair.first);
if (itMax != m_maxSnapshotValues.m_tagStats.end())
{
itMax->second.m_objectsCount = std::max(itMax->second.m_objectsCount,
tagPair.second.m_objectsCount);
itMax->second.m_alocatedInMb = std::max(itMax->second.m_alocatedInMb,
tagPair.second.m_alocatedInMb);
itMax->second.m_usedInMb = std::max(itMax->second.m_alocatedInMb,
tagPair.second.m_usedInMb);
}
else
{
m_maxSnapshotValues.m_tagStats.insert(tagPair);
}
auto itSummary = m_summarySnapshotValues.m_tagStats.find(tagPair.first);
if (itSummary != m_summarySnapshotValues.m_tagStats.end())
{
itSummary->second.m_objectsCount += tagPair.second.m_objectsCount;
itSummary->second.m_alocatedInMb += tagPair.second.m_alocatedInMb;
itSummary->second.m_usedInMb += tagPair.second.m_usedInMb;
}
else
{
m_summarySnapshotValues.m_tagStats.insert(tagPair);
}
}
m_maxSnapshotValues.m_summaryAllocatedInMb = std::max(snap.m_summaryAllocatedInMb,
m_maxSnapshotValues.m_summaryAllocatedInMb);
m_maxSnapshotValues.m_summaryUsedInMb = std::max(snap.m_summaryUsedInMb,
m_maxSnapshotValues.m_summaryUsedInMb);
m_summarySnapshotValues.m_summaryAllocatedInMb += snap.m_summaryAllocatedInMb;
m_summarySnapshotValues.m_summaryUsedInMb += snap.m_summaryUsedInMb;
++m_numberOfSnapshots;
}
DrapeMeasurer::GPUMemoryStatistic DrapeMeasurer::GetGPUMemoryStatistic()
{
GPUMemoryStatistic statistic;
statistic.m_maxMemoryValues = m_maxSnapshotValues;
statistic.m_averageMemoryValues = m_summarySnapshotValues;
if (m_numberOfSnapshots > 0)
{
for (auto & tagPair : statistic.m_averageMemoryValues.m_tagStats)
{
tagPair.second.m_objectsCount /= m_numberOfSnapshots;
tagPair.second.m_alocatedInMb /= m_numberOfSnapshots;
tagPair.second.m_usedInMb /= m_numberOfSnapshots;
}
statistic.m_averageMemoryValues.m_summaryAllocatedInMb /= m_numberOfSnapshots;
statistic.m_averageMemoryValues.m_summaryUsedInMb /= m_numberOfSnapshots;
}
return statistic;
}
#endif
std::string DrapeMeasurer::DrapeStatistic::ToString() const
{
std::ostringstream ss;
ss << "\n ===== Drape statistic report ===== \n";
#ifdef RENDER_STATISTIC
ss << "\n" << m_renderStatistic.ToString() << "\n";
#endif
#ifdef TILES_STATISTIC
ss << "\n" << m_tileStatistic.ToString() << "\n";
#endif
#ifdef GENERATING_STATISTIC
ss << "\n" << m_generatingStatistic.ToString() << "\n";
#endif
#ifdef TRACK_GPU_MEM
ss << "\n" << m_gpuMemStatistic.ToString() << "\n";
#endif
#ifdef TRACK_GLYPH_USAGE
ss << "\n" << m_glyphStatistic.ToString() << "\n";
#endif
ss << "\n ===== Drape statistic report ===== \n\n";
return ss.str();
}
DrapeMeasurer::DrapeStatistic DrapeMeasurer::GetDrapeStatistic()
{
DrapeStatistic statistic;
#ifdef RENDER_STATISTIC
statistic.m_renderStatistic = GetRenderStatistic();
#endif
#ifdef TILES_STATISTIC
statistic.m_tileStatistic = GetTileStatistic();
#endif
#ifdef GENERATING_STATISTIC
statistic.m_generatingStatistic = GetGeneratingStatistic();
#endif
#ifdef TRACK_GPU_MEM
statistic.m_gpuMemStatistic = GetGPUMemoryStatistic();
#endif
#ifdef TRACK_GLYPH_USAGE
statistic.m_glyphStatistic = dp::GlyphUsageTracker::Instance().Report();
#endif
return statistic;
}
} // namespace df

175
drape_frontend/drape_measurer.hpp Normal file
View file

@ -0,0 +1,175 @@
#pragma once
#include "drape/drape_diagnostics.hpp"
#include "drape/utils/gpu_mem_tracker.hpp"
#include "drape/utils/glyph_usage_tracker.hpp"
#include "base/thread.hpp"
#include "base/timer.hpp"
#include <chrono>
#include <map>
#include <memory>
#include <mutex>
#include <numeric>
#include <vector>
namespace df
{
class DrapeMeasurer
{
public:
static DrapeMeasurer & Instance();
void StartBenchmark();
void StopBenchmark();
#ifdef RENDER_STATISTIC
struct RenderStatistic
{
std::string ToString() const;
uint32_t m_FPS = 0;
uint32_t m_minFPS = 0;
uint32_t m_frameRenderTimeInMs = 0;
};
RenderStatistic GetRenderStatistic();
#endif
#ifdef TILES_STATISTIC
struct TileStatistic
{
std::string ToString() const;
uint32_t m_totalTilesCount = 0;
uint32_t m_tileReadTimeInMs = 0;
};
void StartTileReading();
void EndTileReading();
TileStatistic GetTileStatistic();
#endif
#ifdef GENERATING_STATISTIC
struct GeneratingStatistic
{
std::string ToString() const;
uint32_t m_maxScenePreparingTimeInMs = 0;
uint32_t m_shapesCount = 0;
uint32_t m_shapeGenTimeInMs = 0;
uint32_t m_overlayShapesCount = 0;
uint32_t m_overlayShapeGenTimeInMs = 0;
};
void StartScenePreparing();
void EndScenePreparing();
void StartShapesGeneration();
void EndShapesGeneration(uint32_t shapesCount);
void StartOverlayShapesGeneration();
void EndOverlayShapesGeneration(uint32_t shapesCount);
GeneratingStatistic GetGeneratingStatistic();
#endif
#ifdef TRACK_GPU_MEM
struct GPUMemoryStatistic
{
std::string ToString() const;
dp::GPUMemTracker::GPUMemorySnapshot m_averageMemoryValues;
dp::GPUMemTracker::GPUMemorySnapshot m_maxMemoryValues;
};
GPUMemoryStatistic GetGPUMemoryStatistic();
#endif
#if defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM)
void BeforeRenderFrame();
void AfterRenderFrame();
#endif
struct DrapeStatistic
{
std::string ToString() const;
#ifdef RENDER_STATISTIC
RenderStatistic m_renderStatistic;
#endif
#ifdef TILES_STATISTIC
TileStatistic m_tileStatistic;
#endif
#ifdef GENERATING_STATISTIC
GeneratingStatistic m_generatingStatistic;
#endif
#ifdef TRACK_GPU_MEM
GPUMemoryStatistic m_gpuMemStatistic;
#endif
#ifdef TRACK_GLYPH_USAGE
dp::GlyphUsageTracker::GlyphUsageStatistic m_glyphStatistic;
#endif
};
DrapeStatistic GetDrapeStatistic();
private:
DrapeMeasurer() = default;
bool m_isEnabled = false;
#ifdef GENERATING_STATISTIC
std::chrono::time_point<std::chrono::steady_clock> m_startScenePreparingTime;
std::chrono::nanoseconds m_maxScenePreparingTime;
std::chrono::time_point<std::chrono::steady_clock> m_startShapesGenTime;
std::chrono::nanoseconds m_totalShapesGenTime;
uint32_t m_totalShapesCount = 0;
std::chrono::time_point<std::chrono::steady_clock> m_startOverlayShapesGenTime;
std::chrono::nanoseconds m_totalOverlayShapesGenTime;
uint32_t m_totalOverlayShapesCount = 0;
#endif
#ifdef TILES_STATISTIC
struct TileReadInfo
{
std::chrono::time_point<std::chrono::steady_clock> m_startTileReadTime;
std::chrono::nanoseconds m_totalTileReadTime;
uint32_t m_totalTilesCount = 0;
};
std::map<threads::ThreadID, std::shared_ptr<TileReadInfo>> m_tilesReadInfo;
std::mutex m_tilesMutex;
#endif
#ifdef RENDER_STATISTIC
std::chrono::nanoseconds m_totalTPF;
uint32_t m_totalTPFCount = 0;
uint32_t m_minFPS = std::numeric_limits<uint32_t>::max();
double m_totalFPS = 0.0;
uint32_t m_totalFPSCount = 0;
#endif
#if defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM)
std::chrono::time_point<std::chrono::steady_clock> m_startFrameRenderTime;
std::chrono::nanoseconds m_totalFrameRenderTime;
uint32_t m_totalFramesCount = 0;
#endif
#ifdef TRACK_GPU_MEM
void TakeGPUMemorySnapshot();
dp::GPUMemTracker::GPUMemorySnapshot m_maxSnapshotValues;
dp::GPUMemTracker::GPUMemorySnapshot m_summarySnapshotValues;
uint32_t m_numberOfSnapshots = 0;
#endif
};
}

63
drape_frontend/frontend_renderer.cpp
View file

@ -2,6 +2,8 @@
#include "drape_frontend/gui/drape_gui.hpp"
#include "drape_frontend/gui/ruler_helper.hpp"
#include "drape_frontend/animation_system.hpp"
#include "drape_frontend/batch_merge_helper.hpp"
#include "drape_frontend/drape_measurer.hpp"
#include "drape_frontend/framebuffer.hpp"
#include "drape_frontend/frontend_renderer.hpp"
#include "drape_frontend/message_subclasses.hpp"
@ -10,7 +12,7 @@
#include "drape_frontend/transparent_layer.hpp"
#include "drape_frontend/visual_params.hpp"
#include "drape_frontend/user_mark_shapes.hpp"
#include "drape_frontend/batch_merge_helper.hpp"
#include "drape/debug_rect_renderer.hpp"
#include "drape/shader_def.hpp"
@ -140,11 +142,6 @@ FrontendRenderer::FrontendRenderer(Params const & params)
, m_scenarioManager(new ScenarioManager(this))
#endif
{
#ifdef DRAW_INFO
m_tpf = 0.0;
m_fps = 0.0;
#endif
#ifdef DEBUG
m_isTeardowned = false;
#endif
@ -174,43 +171,6 @@ void FrontendRenderer::Teardown()
#endif
}
#ifdef DRAW_INFO
void FrontendRenderer::BeforeDrawFrame()
{
m_frameStartTime = m_timer.ElapsedSeconds();
}
void FrontendRenderer::AfterDrawFrame()
{
m_drawedFrames++;
double elapsed = m_timer.ElapsedSeconds();
m_tpfs.push_back(elapsed - m_frameStartTime);
if (elapsed > 1.0)
{
m_timer.Reset();
m_fps = m_drawedFrames / elapsed;
m_drawedFrames = 0;
m_tpf = accumulate(m_tpfs.begin(), m_tpfs.end(), 0.0) / m_tpfs.size();
LOG(LINFO, ("Average Fps : ", m_fps));
LOG(LINFO, ("Average Tpf : ", m_tpf));
#if defined(TRACK_GPU_MEM)
string report = dp::GPUMemTracker::Inst().Report();
LOG(LINFO, (report));
#endif
#if defined(TRACK_GLYPH_USAGE)
string glyphReport = dp::GlyphUsageTracker::Instance().Report();
LOG(LINFO, (glyphReport));
#endif
}
}
#endif
void FrontendRenderer::UpdateCanBeDeletedStatus()
{
m2::RectD const & screenRect = m_userEventStream.GetCurrentScreen().ClipRect();
@ -302,7 +262,12 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
UpdateCanBeDeletedStatus();
if (m_notFinishedTiles.empty())
{
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().EndScenePreparing();
#endif
m_trafficRenderer->OnGeometryReady(m_currentZoomLevel);
}
break;
}
@ -1110,8 +1075,8 @@ void FrontendRenderer::EndUpdateOverlayTree()
void FrontendRenderer::RenderScene(ScreenBase const & modelView)
{
#ifdef DRAW_INFO
BeforeDrawFrame();
#if defined(DRAPE_MEASURER) && (defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM))
DrapeMeasurer::Instance().BeforeRenderFrame();
#endif
GLFunctions::glEnable(gl_const::GLDepthTest);
@ -1174,8 +1139,8 @@ void FrontendRenderer::RenderScene(ScreenBase const & modelView)
dp::DebugRectRenderer::Instance().DrawArrow(modelView, arrow);
#endif
#ifdef DRAW_INFO
AfterDrawFrame();
#if defined(DRAPE_MEASURER) && (defined(RENDER_STATISTIC) || defined(TRACK_GPU_MEM))
DrapeMeasurer::Instance().AfterRenderFrame();
#endif
MergeBuckets();
@ -1620,6 +1585,10 @@ TTilesCollection FrontendRenderer::ResolveTileKeys(ScreenBase const & screen)
m_trafficRenderer->OnUpdateViewport(result, m_currentZoomLevel, tilesToDelete);
#if defined(DRAPE_MEASURER) && defined(GENERATING_STATISTIC)
DrapeMeasurer::Instance().StartScenePreparing();
#endif
return tiles;
}

19
drape_frontend/frontend_renderer.hpp
View file

@ -2,12 +2,6 @@
#include "base/thread.hpp"
#ifdef DRAW_INFO
#include "base/timer.hpp"
#include "std/vector.hpp"
#include "std/numeric.hpp"
#endif
#include "drape_frontend/gui/layer_render.hpp"
#include "drape_frontend/backend_renderer.hpp"
@ -130,19 +124,6 @@ public:
void Teardown();
#ifdef DRAW_INFO
double m_tpf;
double m_fps;
my::Timer m_timer;
double m_frameStartTime;
vector<double> m_tpfs;
int m_drawedFrames;
void BeforeDrawFrame();
void AfterDrawFrame();
#endif
void AddUserEvent(drape_ptr<UserEvent> && event);
/// MyPositionController::Listener

4
drape_frontend/rule_drawer.cpp
View file

@ -6,6 +6,8 @@
#include "drape_frontend/traffic_renderer.hpp"
#include "drape_frontend/visual_params.hpp"
#include "drape/drape_diagnostics.hpp"
#include "indexer/feature.hpp"
#include "indexer/feature_algo.hpp"
#include "indexer/feature_visibility.hpp"
@ -17,8 +19,6 @@
#include "std/bind.hpp"
//#define DRAW_TILE_NET
#ifdef DRAW_TILE_NET
#include "drape_frontend/line_shape.hpp"
#include "drape_frontend/text_shape.hpp"

21
drape_frontend/scenario_manager.cpp
View file

@ -29,7 +29,7 @@ void ScenarioManager::Interrupt()
InterruptImpl();
}
bool ScenarioManager::RunScenario(Scenario && scenario, OnFinishHandler const & handler)
bool ScenarioManager::RunScenario(ScenarioData && scenarioData, ScenarioCallback const & onStartFn, ScenarioCallback const & onFinishFn)
{
std::lock_guard<std::mutex> lock(m_mutex);
if (m_thread != nullptr)
@ -37,11 +37,12 @@ bool ScenarioManager::RunScenario(Scenario && scenario, OnFinishHandler const &
if (m_isFinished)
InterruptImpl();
else
return false; // The only scenatio can be executed currently.
return false; // The only scenario can be executed currently.
}
std::swap(m_scenario, scenario);
m_onFinishHandler = handler;
std::swap(m_scenarioData, scenarioData);
m_onStartHandler = onStartFn;
m_onFinishHandler = onFinishFn;
m_thread = my::make_unique<threads::SimpleThread>(&ScenarioManager::ThreadRoutine, this);
#ifdef DEBUG
m_threadId = m_thread->get_id();
@ -65,7 +66,11 @@ bool ScenarioManager::IsRunning()
void ScenarioManager::ThreadRoutine()
{
for (auto const & action : m_scenario)
string const scenarioName = m_scenarioData.m_name;
if (m_onStartHandler != nullptr)
m_onStartHandler(scenarioName);
for (auto const & action : m_scenarioData.m_scenario)
{
// Interrupt scenario if it's necessary.
{
@ -100,10 +105,10 @@ void ScenarioManager::ThreadRoutine()
}
}
OnFinishHandler handler = nullptr;
ScenarioCallback handler = nullptr;
{
std::lock_guard<std::mutex> lock(m_mutex);
m_scenario.clear();
m_scenarioData.m_scenario.clear();
m_isFinished = true;
if (m_onFinishHandler != nullptr)
{
@ -113,7 +118,7 @@ void ScenarioManager::ThreadRoutine()
}
if (handler != nullptr)
handler();
handler(scenarioName);
}
void ScenarioManager::InterruptImpl()

20
drape_frontend/scenario_manager.hpp
View file

@ -2,6 +2,8 @@
#include "drape_frontend/frontend_renderer.hpp"
#include "drape/drape_diagnostics.hpp"
#include "geometry/point2d.hpp"
#include "base/stl_add.hpp"
@ -13,8 +15,6 @@
#include <mutex>
#include <vector>
#define SCENARIO_ENABLE
namespace df
{
@ -65,12 +65,19 @@ public:
};
using Scenario = std::vector<std::unique_ptr<Action>>;
using OnFinishHandler = std::function<void()>;
using ScenarioCallback = std::function<void(std::string const & name)>;
struct ScenarioData
{
std::string m_name;
Scenario m_scenario;
};
ScenarioManager(FrontendRenderer * frontendRenderer);
~ScenarioManager();
bool RunScenario(Scenario && scenario, OnFinishHandler const & handler);
bool RunScenario(ScenarioData && scenarioData,
ScenarioCallback const & startHandler, ScenarioCallback const & finishHandler);
void Interrupt();
bool IsRunning();
@ -81,10 +88,11 @@ private:
FrontendRenderer * m_frontendRenderer;
std::mutex m_mutex;
Scenario m_scenario;
ScenarioData m_scenarioData;
bool m_needInterrupt;
bool m_isFinished;
OnFinishHandler m_onFinishHandler;
ScenarioCallback m_onStartHandler;
ScenarioCallback m_onFinishHandler;
#ifdef DEBUG
std::thread::id m_threadId;
#endif

7
drape_frontend/tile_info.cpp
View file

@ -1,3 +1,4 @@
#include "drape_frontend/drape_measurer.hpp"
#include "drape_frontend/engine_context.hpp"
#include "drape_frontend/map_data_provider.hpp"
#include "drape_frontend/rule_drawer.hpp"
@ -57,6 +58,9 @@ void TileInfo::ReadFeatureIndex(MapDataProvider const & model)
void TileInfo::ReadFeatures(MapDataProvider const & model)
{
#if defined(DRAPE_MEASURER) && defined(TILES_STATISTIC)
DrapeMeasurer::Instance().StartTileReading();
#endif
m_context->BeginReadTile();
// Reading can be interrupted by exception throwing
@ -73,6 +77,9 @@ void TileInfo::ReadFeatures(MapDataProvider const & model)
make_ref(m_context), m_is3dBuildings, m_trafficEnabled);
model.ReadFeatures(bind<void>(ref(drawer), _1), m_featureInfo);
}
#if defined(DRAPE_MEASURER) && defined(TILES_STATISTIC)
DrapeMeasurer::Instance().EndTileReading();
#endif
}
void TileInfo::Cancel()

56
map/benchmark_tools.cpp
View file

@ -1,6 +1,7 @@
#include "map/benchmark_tools.hpp"
#include "map/framework.hpp"
#include "drape_frontend/drape_measurer.hpp"
#include "drape_frontend/scenario_manager.hpp"
#include "platform/http_client.hpp"
@ -16,28 +17,51 @@
namespace
{
struct ScenarioData
{
std::string m_name;
df::ScenarioManager::Scenario m_scenario;
};
struct BenchmarkHandle
{
std::vector<ScenarioData> m_scenariosRoRun;
std::vector<df::ScenarioManager::ScenarioData> m_scenariosToRun;
size_t m_currentScenario = 0;
std::vector<storage::TCountryId> m_regionsToDownload;
size_t m_regionsToDownloadCounter = 0;
#ifdef DRAPE_MEASURER
std::vector<std::pair<string, df::DrapeMeasurer::DrapeStatistic>> m_drapeStatistic;
#endif
};
void RunScenario(Framework * framework, std::shared_ptr<BenchmarkHandle> handle)
{
if (handle->m_currentScenario >= handle->m_scenariosRoRun.size())
return;
auto & scenarioData = handle->m_scenariosRoRun[handle->m_currentScenario];
framework->GetDrapeEngine()->RunScenario(std::move(scenarioData.m_scenario), [framework, handle]
if (handle->m_currentScenario >= handle->m_scenariosToRun.size())
{
#ifdef DRAPE_MEASURER
for (auto const & it : handle->m_drapeStatistic)
{
LOG(LINFO, ("\n ***** Report for scenario", it.first, "*****\n",
it.second.ToString(),
"\n ***** Report for scenario", it.first, "*****\n"));
}
#endif
return;
}
auto & scenarioData = handle->m_scenariosToRun[handle->m_currentScenario];
framework->GetDrapeEngine()->RunScenario(std::move(scenarioData),
[handle](std::string const & name)
{
#ifdef DRAPE_MEASURER
df::DrapeMeasurer::Instance().StartBenchmark();
#endif
},
[framework, handle](std::string const & name)
{
#ifdef DRAPE_MEASURER
df::DrapeMeasurer::Instance().StopBenchmark();
auto const drapeStatistic = df::DrapeMeasurer::Instance().GetDrapeStatistic();
handle->m_drapeStatistic.push_back(make_pair(name, drapeStatistic));
#endif
GetPlatform().RunOnGuiThread([framework, handle]()
{
handle->m_currentScenario++;
@ -71,18 +95,18 @@ void RunGraphicsBenchmark(Framework * framework)
if (scenariosNode == nullptr || !json_is_array(scenariosNode))
return;
size_t const sz = json_array_size(scenariosNode);
handle->m_scenariosRoRun.resize(sz);
handle->m_scenariosToRun.resize(sz);
for (size_t i = 0; i < sz; ++i)
{
auto scenarioElem = json_array_get(scenariosNode, i);
if (scenarioElem == nullptr)
return;
my::FromJSONObject(scenarioElem, "name", handle->m_scenariosRoRun[i].m_name);
my::FromJSONObject(scenarioElem, "name", handle->m_scenariosToRun[i].m_name);
json_t * stepsNode = json_object_get(scenarioElem, "steps");
if (stepsNode != nullptr && json_is_array(stepsNode))
{
size_t const stepsCount = json_array_size(stepsNode);
auto & scenario = handle->m_scenariosRoRun[i].m_scenario;
auto & scenario = handle->m_scenariosToRun[i].m_scenario;
scenario.reserve(stepsCount);
for (size_t j = 0; j < stepsCount; ++j)
{
@ -121,7 +145,7 @@ void RunGraphicsBenchmark(Framework * framework)
{
return;
}
if (handle->m_scenariosRoRun.empty())
if (handle->m_scenariosToRun.empty())
return;
// Find out regions to download.
@ -159,7 +183,7 @@ void RunGraphicsBenchmark(Framework * framework)
return;
}
// Run scenartios without downloading.
// Run scenarios without downloading.
RunScenario(framework, handle);
#endif
}

4
xcode/drape/drape.xcodeproj/project.pbxproj
View file

@ -105,6 +105,7 @@
6743D3451C3533AE0095054B /* support_manager.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 6743D3431C3533AE0095054B /* support_manager.hpp */; };
675D21991BFB876E00717E4F /* projection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 675D21971BFB876E00717E4F /* projection.cpp */; };
675D219A1BFB876E00717E4F /* projection.hpp in Headers */ = {isa = PBXBuildFile; fileRef = 675D21981BFB876E00717E4F /* projection.hpp */; };
BB035F6C1E3A2A5C00519962 /* drape_diagnostics.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */; };
BB06FBE91DDDFFBE00B41AF0 /* area_vertex_shader.vsh in Sources */ = {isa = PBXBuildFile; fileRef = BB06FBC01DDDFDC300B41AF0 /* area_vertex_shader.vsh */; };
BB06FBEA1DDDFFBE00B41AF0 /* area3d_outline_vertex_shader.vsh in Sources */ = {isa = PBXBuildFile; fileRef = BB06FBC11DDDFDC300B41AF0 /* area3d_outline_vertex_shader.vsh */; };
BB06FBEB1DDDFFBE00B41AF0 /* area3d_vertex_shader.vsh in Sources */ = {isa = PBXBuildFile; fileRef = BB06FBC21DDDFDC300B41AF0 /* area3d_vertex_shader.vsh */; };
@ -278,6 +279,7 @@
6743D3431C3533AE0095054B /* support_manager.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = support_manager.hpp; sourceTree = "<group>"; };
675D21971BFB876E00717E4F /* projection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = projection.cpp; sourceTree = "<group>"; };
675D21981BFB876E00717E4F /* projection.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = projection.hpp; sourceTree = "<group>"; };
BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_diagnostics.hpp; sourceTree = "<group>"; };
BB06FBC01DDDFDC300B41AF0 /* area_vertex_shader.vsh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.glsl; path = area_vertex_shader.vsh; sourceTree = "<group>"; };
BB06FBC11DDDFDC300B41AF0 /* area3d_outline_vertex_shader.vsh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.glsl; path = area3d_outline_vertex_shader.vsh; sourceTree = "<group>"; };
BB06FBC21DDDFDC300B41AF0 /* area3d_vertex_shader.vsh */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.glsl; path = area3d_vertex_shader.vsh; sourceTree = "<group>"; };
@ -391,6 +393,7 @@
6729A50E1A69213A007D5872 /* cpu_buffer.hpp */,
6729A50F1A69213A007D5872 /* data_buffer.cpp */,
6729A5101A69213A007D5872 /* data_buffer.hpp */,
BB035F6B1E3A2A5C00519962 /* drape_diagnostics.hpp */,
6729A5111A69213A007D5872 /* drape_global.hpp */,
347F32F71C45383E009758CC /* debug_rect_renderer.cpp */,
347F32F81C45383E009758CC /* debug_rect_renderer.hpp */,
@ -577,6 +580,7 @@
6729A57F1A69213A007D5872 /* glIncludes.hpp in Headers */,
6729A5A91A69213A007D5872 /* texture_of_colors.hpp in Headers */,
6729A5871A69213A007D5872 /* gpu_buffer.hpp in Headers */,
BB035F6C1E3A2A5C00519962 /* drape_diagnostics.hpp in Headers */,
6729A56E1A69213A007D5872 /* buffer_base.hpp in Headers */,
6729A58F1A69213A007D5872 /* index_buffer.hpp in Headers */,
);

8
xcode/drape_frontend/drape_frontend.xcodeproj/project.pbxproj
View file

@ -208,6 +208,8 @@
67E91C7C1BDFC85E005CEE88 /* selection_shape.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 670947701BDF9BE0005014C0 /* selection_shape.cpp */; };
67E91C7D1BDFC85E005CEE88 /* user_marks_provider.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6709478B1BDF9BE0005014C0 /* user_marks_provider.cpp */; };
67E91C7E1BDFC85E005CEE88 /* visual_params.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6709478F1BDF9BE1005014C0 /* visual_params.cpp */; };
BB035F6F1E3A2AAE00519962 /* drape_measurer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BB035F6D1E3A2AAE00519962 /* drape_measurer.cpp */; };
BB035F701E3A2AAE00519962 /* drape_measurer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = BB035F6E1E3A2AAE00519962 /* drape_measurer.hpp */; };
F6B283101C1B04680081957A /* gps_track_point.hpp in Headers */ = {isa = PBXBuildFile; fileRef = F6B2830B1C1B04680081957A /* gps_track_point.hpp */; };
F6B283111C1B04680081957A /* gps_track_renderer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F6B2830C1C1B04680081957A /* gps_track_renderer.cpp */; };
F6B283121C1B04680081957A /* gps_track_renderer.hpp in Headers */ = {isa = PBXBuildFile; fileRef = F6B2830D1C1B04680081957A /* gps_track_renderer.hpp */; };
@ -421,6 +423,8 @@
675D218B1BFB871D00717E4F /* text_engine.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = text_engine.h; sourceTree = "<group>"; };
677A2DE31C0DD55D00635A00 /* requested_tiles.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = requested_tiles.cpp; sourceTree = "<group>"; };
677A2DE41C0DD55D00635A00 /* requested_tiles.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = requested_tiles.hpp; sourceTree = "<group>"; };
BB035F6D1E3A2AAE00519962 /* drape_measurer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = drape_measurer.cpp; sourceTree = "<group>"; };
BB035F6E1E3A2AAE00519962 /* drape_measurer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = drape_measurer.hpp; sourceTree = "<group>"; };
F6B2830B1C1B04680081957A /* gps_track_point.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = gps_track_point.hpp; sourceTree = "<group>"; };
F6B2830C1C1B04680081957A /* gps_track_renderer.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = gps_track_renderer.cpp; sourceTree = "<group>"; };
F6B2830D1C1B04680081957A /* gps_track_renderer.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = gps_track_renderer.hpp; sourceTree = "<group>"; };
@ -468,6 +472,8 @@
347F520A1DC2334A0064B273 /* drape_api_renderer.hpp */,
347F520B1DC2334A0064B273 /* drape_api.cpp */,
347F520C1DC2334A0064B273 /* drape_api.hpp */,
BB035F6D1E3A2AAE00519962 /* drape_measurer.cpp */,
BB035F6E1E3A2AAE00519962 /* drape_measurer.hpp */,
34C624BF1DABDB0400510300 /* traffic_generator.cpp */,
34C624C01DABDB0400510300 /* traffic_generator.hpp */,
34C624C11DABDB0400510300 /* traffic_renderer.cpp */,
@ -806,6 +812,7 @@
670948751BDF9C7F005014C0 /* geometry_processors.hpp in Headers */,
6709487A1BDF9C7F005014C0 /* icon_info.hpp in Headers */,
670948151BDF9C39005014C0 /* base_interpolator.hpp in Headers */,
BB035F701E3A2AAE00519962 /* drape_measurer.hpp in Headers */,
670947A61BDF9BE1005014C0 /* my_position.hpp in Headers */,
675D21901BFB871D00717E4F /* software_renderer.hpp in Headers */,
670947A81BDF9BE1005014C0 /* navigator.hpp in Headers */,
@ -923,6 +930,7 @@
45580ABA1E28DB2600CD535D /* scenario_manager.cpp in Sources */,
670947C81BDF9BE1005014C0 /* text_shape.cpp in Sources */,
34C624C31DABDB0400510300 /* traffic_generator.cpp in Sources */,
BB035F6F1E3A2AAE00519962 /* drape_measurer.cpp in Sources */,
670947CC1BDF9BE1005014C0 /* tile_info.cpp in Sources */,
34C624C51DABDB0400510300 /* traffic_renderer.cpp in Sources */,
670947961BDF9BE1005014C0 /* line_shape.cpp in Sources */,