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

Benchmarking infrastructure.

Browse source
This commit is contained in:
rachytski 2011-02-11 22:57:24 +02:00 • committed by Alex Zolotarev
parent 43171152f5
commit 48900447a4
12 changed files with 296 additions and 34 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
data/benchmark.txt Normal file
View file

@ -0,0 +1 @@
france_iphone -1.65763 48.7958 4.41623 57.5269

1
iphone/Maps/Platform/IPhonePlatform.hpp
View file

@ -21,6 +21,7 @@ public:
virtual bool DoPeriodicalUpdate() const;
virtual double PeriodicalUpdateInterval() const;
virtual vector<string> GetFontNames() const;
virtual bool IsBenchmarking() const;
private:
string m_skinName;

5
iphone/Maps/Platform/IPhonePlatform.mm
View file

@ -189,6 +189,11 @@ vector<string> IPhonePlatform::GetFontNames() const
return res;
}
bool IPhonePlatform::IsBenchmarking() const
{
return false;
}
Platform & GetPlatform()
{
static IPhonePlatform platform;

81
map/framework.hpp
View file

@ -34,6 +34,7 @@
#include "../std/vector.hpp"
#include "../std/shared_ptr.hpp"
#include "../std/target_os.hpp"
#include "../std/fstream.hpp"
#include "../base/start_mem_debug.hpp"
@ -96,6 +97,12 @@ class FrameWork
model_t m_model;
navigator_t m_navigator;
shared_ptr<window_handle_t> m_windowHandle;
bool m_isBenchmarking;
bool m_isBenchmarkInitialized;
vector<pair<string, m2::RectD> > m_benchmarks;
unsigned m_currentBenchmark;
RenderQueue m_renderQueue;
InformationDisplay m_informationDisplay;
@ -127,12 +134,7 @@ class FrameWork
void SetMaxWorldRect()
{
#ifdef PROFILER_DRAWING
// London
m_navigator.SetFromRect(m2::RectD(-0.423781, 60.0613, 0.210893, 60.5272));
#else
m_navigator.SetFromRect(m_model.GetWorldRect());
#endif
}
threads::Mutex m_modelSyn;
@ -163,25 +165,51 @@ class FrameWork
public:
FrameWork(shared_ptr<window_handle_t> windowHandle, size_t bottomShift)
: m_windowHandle(windowHandle),
m_isBenchmarking(GetPlatform().IsBenchmarking()),
m_isBenchmarkInitialized(false),
m_currentBenchmark(0),
m_renderQueue(GetPlatform().SkinName(),
GetPlatform().IsMultiSampled(),
GetPlatform().DoPeriodicalUpdate(),
GetPlatform().PeriodicalUpdateInterval()),
GetPlatform().PeriodicalUpdateInterval(),
GetPlatform().IsBenchmarking()),
m_isRedrawEnabled(true)
{
m_informationDisplay.setBottomShift(bottomShift);
#ifdef DRAW_TOUCH_POINTS
m_informationDisplay.enableDebugPoints(true);
#endif
m_informationDisplay.enableCenter(true);
m_informationDisplay.enableCenter(false);
m_informationDisplay.enableGlobalRect(!m_isBenchmarking);
m_informationDisplay.enableRuler(true);
#ifdef DEBUG
m_informationDisplay.enableDebugInfo(true);
#endif
m_informationDisplay.enableBenchmarkInfo(m_isBenchmarking);
m_informationDisplay.setVisualScale(GetPlatform().VisualScale());
m_renderQueue.AddWindowHandle(m_windowHandle);
}
void InitBenchmark()
{
ifstream fin(GetPlatform().WritablePathForFile("benchmark.txt").c_str());
while (true)
{
string name;
double x0, y0, x1, y1;
fin >> name >> x0 >> y0 >> x1 >> y1;
if (!fin)
break;
m_navigator.SetFromRect(m2::RectD(x0, y0, x1, y1));
m_renderQueue.AddBenchmarkCommand(boost::bind(&this_type::PaintImpl, this, _1, _2, _3, _4), m_navigator.Screen());
m_benchmarks.push_back(make_pair(name, m2::RectD(x0, y0, x1, y1)));
}
Invalidate();
}
void initializeGL(shared_ptr<yg::gl::RenderContext> const & primaryContext,
shared_ptr<yg::ResourceManager> const & resourceManager)
{
@ -244,6 +272,12 @@ public:
m_navigator.OnSize(ptShift.x, ptShift.y, w, h);
if ((m_isBenchmarking) && (!m_isBenchmarkInitialized))
{
m_isBenchmarkInitialized = true;
InitBenchmark();
}
UpdateNow();
}
@ -321,18 +355,45 @@ public:
DrawerYG * pDrawer = e->drawer().get();
m_informationDisplay.setScreen(m_navigator.Screen());
m_informationDisplay.setDebugInfo(m_renderQueue.renderState().m_duration, GetCurrentScale());
m_informationDisplay.enableRuler(!IsEmptyModel());
m2::PointD const center = m_navigator.Screen().ClipRect().Center();
m_informationDisplay.setGlobalRect(m_navigator.Screen().GlobalRect());
m_informationDisplay.setCenter(m2::PointD(MercatorBounds::YToLat(center.y), MercatorBounds::XToLon(center.x)));
{
threads::MutexGuard guard(*m_renderQueue.renderState().m_mutex.get());
if (m_isBenchmarking)
{
m2::PointD const center = m_renderQueue.renderState().m_actualScreen.ClipRect().Center();
m_informationDisplay.setScreen(m_renderQueue.renderState().m_actualScreen);
m_informationDisplay.setCenter(m2::PointD(MercatorBounds::YToLat(center.y), MercatorBounds::XToLon(center.x)));
if (m_benchmarks.empty())
{
e->drawer()->screen()->beginFrame();
e->drawer()->screen()->clear();
m_informationDisplay.setDisplayRect(m2::RectI(0, 0, 100, 100));
m_informationDisplay.enableRuler(false);
m_informationDisplay.doDraw(e->drawer().get());
e->drawer()->screen()->endFrame();
}
}
if (m_renderQueue.renderState().m_actualTarget.get() != 0)
{
if (m_isBenchmarking
&& !m_benchmarks.empty()
&& m_informationDisplay.addBenchmarkInfo(m_benchmarks[m_currentBenchmark].first,
m_benchmarks[m_currentBenchmark].second,
m_renderQueue.renderState().m_duration))
m_currentBenchmark++;
e->drawer()->screen()->beginFrame();
e->drawer()->screen()->clear(/*yg::Color(255, 0, 0, 255)*/);
@ -342,9 +403,13 @@ public:
OGLCHECK(glPushMatrix());
OGLCHECK(glTranslatef(-ptShift.x, -ptShift.y, 0));
ScreenBase currentScreen = m_navigator.Screen();
if (m_isBenchmarking)
currentScreen = m_renderQueue.renderState().m_actualScreen;
pDrawer->screen()->blit(m_renderQueue.renderState().m_actualTarget,
m_renderQueue.renderState().m_actualScreen,
m_navigator.Screen(),
currentScreen,
yg::Color(0, 255, 0, 255),
m2::RectI(0, 0,
m_renderQueue.renderState().m_actualTarget->width(),

112
map/information_display.cpp
View file

@ -20,6 +20,8 @@ InformationDisplay::InformationDisplay()
enableCenter(false);
enableDebugInfo(false);
enableMemoryWarning(false);
enableBenchmarkInfo(false);
enableGlobalRect(false);
for (int i = 0; i < sizeof(m_DebugPts) / sizeof(m2::PointD); ++i)
m_DebugPts[i] = m2::PointD(0, 0);
@ -287,10 +289,38 @@ void InformationDisplay::setCenter(m2::PointD const & pt)
void InformationDisplay::drawCenter(DrawerYG * drawer)
{
m_yOffset += 20;
ostringstream out;
out << "(" << m_centerPt.x << ", " << m_centerPt.y << ") Scale : " << m_currentScale;
drawer->screen()->drawText(
m2::PointD(m_displayRect.minX(), m_displayRect.minY()) + m2::PointD(10, m_isDebugInfoEnabled ? 40 : 20),
m2::PointD(m_displayRect.minX() + 10, m_displayRect.minY() + m_yOffset),
0, 10,
yg::Color(0, 0, 0, 0),
out.str().c_str(),
true,
yg::Color(255, 255, 255, 255),
yg::maxDepth,
true,
false);
}
void InformationDisplay::enableGlobalRect(bool doEnable)
{
m_isGlobalRectEnabled = doEnable;
}
void InformationDisplay::setGlobalRect(m2::RectD const & r)
{
m_globalRect = r;
}
void InformationDisplay::drawGlobalRect(DrawerYG *pDrawer)
{
m_yOffset += 20;
ostringstream out;
out << "(" << m_globalRect.minX() << ", " << m_globalRect.minY() << ", " << m_globalRect.maxX() << ", " << m_globalRect.maxY() << ") Scale : " << m_currentScale;
pDrawer->screen()->drawText(
m2::PointD(m_displayRect.minX() + 10, m_displayRect.minY() + m_yOffset),
0, 10,
yg::Color(0, 0, 0, 0),
out.str().c_str(),
@ -321,7 +351,11 @@ void InformationDisplay::drawDebugInfo(DrawerYG * drawer)
else
out << " FPS: " << 1.0 / m_frameDuration;
drawer->screen()->drawText(m2::PointD(m_displayRect.minX(), m_displayRect.minY()) + m2::PointD(10, 20),
m_yOffset += 20;
m2::PointD pos = m2::PointD(m_displayRect.minX() + 10, m_displayRect.minY() + m_yOffset);
drawer->screen()->drawText(pos,
0, 10,
yg::Color(0, 0, 0, 0),
out.str().c_str(),
@ -345,11 +379,8 @@ void InformationDisplay::memoryWarning()
void InformationDisplay::drawMemoryWarning(DrawerYG * drawer)
{
m2::PointD pos(m_displayRect.minX() + 10, m_displayRect.minY() + 20);
if (m_isDebugInfoEnabled)
pos += m2::PointD(0, 30);
if (m_isCenterEnabled)
pos += m2::PointD(0, 30);
m_yOffset += 20;
m2::PointD pos(m_displayRect.minX() + 10, m_displayRect.minY() + m_yOffset);
ostringstream out;
out << "MemoryWarning : " << m_lastMemoryWarning.ElapsedSeconds() << " sec. ago.";
@ -368,8 +399,71 @@ void InformationDisplay::drawMemoryWarning(DrawerYG * drawer)
enableMemoryWarning(false);
}
void InformationDisplay::enableBenchmarkInfo(bool doEnable)
{
m_isBenchmarkInfoEnabled = doEnable;
}
bool InformationDisplay::addBenchmarkInfo(string const & name, m2::RectD const & globalRect, double frameDuration)
{
if (frameDuration == 0)
return false;
if ((m_benchmarkInfo.empty())
||(m_benchmarkInfo.back().m_duration != frameDuration))
{
BenchmarkInfo info;
info.m_name = name;
info.m_duration = frameDuration;
info.m_rect = globalRect;
m_benchmarkInfo.push_back(info);
return true;
}
return false;
}
void InformationDisplay::drawBenchmarkInfo(DrawerYG * pDrawer)
{
m_yOffset += 20;
m2::PointD pos(m_displayRect.minX() + 10, m_displayRect.minY() + m_yOffset);
pDrawer->screen()->drawText(pos,
0, 10,
yg::Color(0, 0, 0, 0),
"benchmark info :",
true,
yg::Color(255, 255, 255, 255),
yg::maxDepth,
true,
false);
for (unsigned i = 0; i < m_benchmarkInfo.size(); ++i)
{
ostringstream out;
m2::RectD const & r = m_benchmarkInfo[i].m_rect;
out << " " << m_benchmarkInfo[i].m_name
<< ", " << "rect: (" << r.minX()
<< ", " << r.minY()
<< ", " << r.maxX()
<< ", " << r.maxY()
<< "), duration : " << m_benchmarkInfo[i].m_duration;
m_yOffset += 20;
pos.y += 20;
pDrawer->screen()->drawText(pos,
0, 10,
yg::Color(0, 0, 0, 0),
out.str().c_str(),
true,
yg::Color(255, 255, 255, 255),
yg::maxDepth,
true,
false
);
}
}
void InformationDisplay::doDraw(DrawerYG *drawer)
{
m_yOffset = 0;
if (m_isHeadingEnabled)
drawHeading(drawer);
if (m_isPositionEnabled)
@ -380,8 +474,12 @@ void InformationDisplay::doDraw(DrawerYG *drawer)
drawRuler(drawer);
if (m_isCenterEnabled)
drawCenter(drawer);
if (m_isGlobalRectEnabled)
drawGlobalRect(drawer);
if (m_isDebugInfoEnabled)
drawDebugInfo(drawer);
if (m_isMemoryWarningEnabled)
drawMemoryWarning(drawer);
if (m_isBenchmarkInfoEnabled)
drawBenchmarkInfo(drawer);
}

24
map/information_display.hpp
View file

@ -15,6 +15,7 @@ private:
ScreenBase m_screen;
m2::RectI m_displayRect;
int m_yOffset;
double m_headingOrientation;
@ -39,8 +40,23 @@ private:
m2::PointD m_centerPt;
int m_currentScale;
bool m_isGlobalRectEnabled;
m2::RectD m_globalRect;
bool m_isDebugInfoEnabled;
double m_frameDuration;
bool m_isBenchmarkInfoEnabled;
struct BenchmarkInfo
{
string m_name;
m2::RectD m_rect;
double m_duration;
};
vector<BenchmarkInfo> m_benchmarkInfo;
double m_bottomShift;
double m_visualScale;
@ -77,6 +93,10 @@ public:
void setCenter(m2::PointD const & latLongPt);
void drawCenter(DrawerYG * pDrawer);
void enableGlobalRect(bool doEnable);
void setGlobalRect(m2::RectD const & r);
void drawGlobalRect(DrawerYG * pDrawer);
void enableDebugInfo(bool doEnable);
void setDebugInfo(double frameDuration, int currentScale);
void drawDebugInfo(DrawerYG * pDrawer);
@ -85,5 +105,9 @@ public:
void memoryWarning();
void drawMemoryWarning(DrawerYG * pDrawer);
void enableBenchmarkInfo(bool doEnable);
bool addBenchmarkInfo(string const & name, m2::RectD const & globalRect, double frameDuration);
void drawBenchmarkInfo(DrawerYG * pDrawer);
void doDraw(DrawerYG * drawer);
};

21
map/render_queue.cpp
View file

@ -5,15 +5,27 @@
#include "../yg/render_state.hpp"
#include "../yg/rendercontext.hpp"
RenderQueue::RenderQueue(string const & skinName, bool isMultiSampled, bool doPeriodicalUpdate, double updateInterval)
RenderQueue::RenderQueue(
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking)
: m_renderState(new yg::gl::RenderState())
{
m_renderState->m_surfaceWidth = 100;
m_renderState->m_surfaceHeight = 100;
m_renderState->m_textureWidth = 256;
m_renderState->m_textureHeight = 256;
m_renderState->m_duration = 0;
m_routine = new RenderQueueRoutine(m_renderState, skinName, isMultiSampled, doPeriodicalUpdate, updateInterval);
m_routine = new RenderQueueRoutine(
m_renderState,
skinName,
isMultiSampled,
doPeriodicalUpdate,
updateInterval,
isBenchmarking);
}
void RenderQueue::initializeGL(shared_ptr<yg::gl::RenderContext> const & primaryContext,
@ -37,6 +49,11 @@ void RenderQueue::AddCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenB
m_routine->addCommand(fn, frameScreen);
}
void RenderQueue::AddBenchmarkCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenBase const & frameScreen)
{
m_routine->addBenchmarkCommand(fn, frameScreen);
}
void RenderQueue::SetRedrawAll()
{
m_renderState->m_doRepaintAll = true;

7
map/render_queue.hpp
View file

@ -31,7 +31,11 @@ private:
public:
/// constructor.
RenderQueue(string const & skinName, bool isMultiSampled, bool doPeriodicalUpdate, double updateInterval);
RenderQueue(string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval,
bool isBenchmarking);
/// destructor.
~RenderQueue();
/// set the primary context. it starts the rendering thread.
@ -40,6 +44,7 @@ public:
double ppmScale);
/// add command to the commands queue.
void AddCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenBase const & frameScreen);
void AddBenchmarkCommand(RenderQueueRoutine::render_fn_t const & fn, ScreenBase const & frameScreen);
void SetRedrawAll();

61
map/render_queue_routine.cpp
View file

@ -32,7 +32,8 @@ RenderQueueRoutine::RenderQueueRoutine(shared_ptr<yg::gl::RenderState> const & r
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval)
double updateInterval,
bool isBenchmarking)
{
m_skinName = skinName;
m_visualScale = 0;
@ -41,6 +42,7 @@ RenderQueueRoutine::RenderQueueRoutine(shared_ptr<yg::gl::RenderState> const & r
m_isMultiSampled = isMultiSampled;
m_doPeriodicalUpdate = doPeriodicalUpdate;
m_updateInterval = updateInterval;
m_isBenchmarking = isBenchmarking;
}
void RenderQueueRoutine::Cancel()
@ -209,6 +211,17 @@ void RenderQueueRoutine::setVisualScale(double visualScale)
m_visualScale = visualScale;
}
void RenderQueueRoutine::waitForRenderCommand(list<shared_ptr<RenderModelCommand> > & cmdList,
threads::ConditionGuard & guard)
{
while (cmdList.empty())
{
guard.Wait();
if (IsCancelled())
break;
}
}
void RenderQueueRoutine::Do()
{
m_renderContext->makeCurrent();
@ -244,24 +257,28 @@ void RenderQueueRoutine::Do()
{
threads::ConditionGuard guard(m_hasRenderCommands);
while (m_renderCommands.empty())
{
guard.Wait();
if (IsCancelled())
break;
}
if (m_isBenchmarking)
waitForRenderCommand(m_benchmarkRenderCommands, guard);
else
waitForRenderCommand(m_renderCommands, guard);
if (IsCancelled())
break;
/// Preparing render command for execution.
m_currentRenderCommand = m_renderCommands.front();
m_renderCommands.erase(m_renderCommands.begin());
if (m_isBenchmarking)
{
m_currentRenderCommand = m_benchmarkRenderCommands.front();
m_benchmarkRenderCommands.erase(m_benchmarkRenderCommands.begin());
}
else
{
m_currentRenderCommand = m_renderCommands.front();
m_renderCommands.erase(m_renderCommands.begin());
}
processResize(m_currentRenderCommand->m_frameScreen);
// m_threadDrawer->screen()->setRenderTarget(m_renderState->m_backBufferLayers.front());
m_currentRenderCommand->m_paintEvent = make_shared_ptr(new PaintEvent(m_threadDrawer));
/// this prevents the framework from flooding us with a bunch of RenderCommands with the same screen.
@ -349,8 +366,6 @@ void RenderQueueRoutine::Do()
double duration = timer.ElapsedSeconds();
// LOG(LINFO, ("FrameDuration: ", duration));
if (!IsCancelled())
{
/// We shouldn't update the actual target as it's already happened (through callback function)
@ -399,14 +414,30 @@ void RenderQueueRoutine::addCommand(render_fn_t const & fn, ScreenBase const & f
/// pushing back new RenderCommand.
m_renderCommands.push_back(make_shared_ptr(new RenderModelCommand(frameScreen, fn)));
/// if we are not panning, we should cancel the render command in progress to start a new one
if ((m_currentRenderCommand != 0) && (!IsPanning(m_currentRenderCommand->m_frameScreen, frameScreen)))
/// if we are in benchmarking mode, we shouldn't cancel any render command
/// else, if we are not panning, we should cancel the render command in progress to start a new one
if ((!m_isBenchmarking)
&& (m_currentRenderCommand != 0)
&& (!IsPanning(m_currentRenderCommand->m_frameScreen, frameScreen)))
m_currentRenderCommand->m_paintEvent->setIsCancelled(true);
if (needToSignal)
guard.Signal();
}
void RenderQueueRoutine::addBenchmarkCommand(render_fn_t const & fn, ScreenBase const & frameScreen)
{
/// Command queue modification is syncronized by mutex
threads::ConditionGuard guard(m_hasRenderCommands);
bool needToSignal = m_renderCommands.empty();
m_benchmarkRenderCommands.push_back(make_shared_ptr(new RenderModelCommand(frameScreen, fn)));
if (needToSignal)
guard.Signal();
}
void RenderQueueRoutine::initializeGL(shared_ptr<yg::gl::RenderContext> const & renderContext,
shared_ptr<yg::ResourceManager> const & resourceManager)
{

10
map/render_queue_routine.hpp
View file

@ -63,6 +63,7 @@ private:
threads::Condition m_hasRenderCommands;
shared_ptr<RenderModelCommand> m_currentRenderCommand;
list<shared_ptr<RenderModelCommand> > m_renderCommands;
list<shared_ptr<RenderModelCommand> > m_benchmarkRenderCommands;
shared_ptr<yg::gl::RenderState> m_renderState;
shared_ptr<yg::gl::BaseTexture> m_fakeTarget;
@ -77,13 +78,18 @@ private:
double m_updateInterval;
double m_visualScale;
string m_skinName;
bool m_isBenchmarking;
void waitForRenderCommand(list<shared_ptr<RenderModelCommand> > & cmdList,
threads::ConditionGuard & guard);
public:
RenderQueueRoutine(shared_ptr<yg::gl::RenderState> const & renderState,
string const & skinName,
bool isMultiSampled,
bool doPeriodicalUpdate,
double updateInterval);
double updateInterval,
bool isBenchmarking);
/// initialize GL rendering
/// this function is called just before the thread starts.
void initializeGL(shared_ptr<yg::gl::RenderContext> const & renderContext,
@ -102,6 +108,8 @@ public:
void addWindowHandle(shared_ptr<WindowHandle> window);
/// add model rendering command to rendering queue
void addCommand(render_fn_t const & fn, ScreenBase const & frameScreen);
/// add benchmark rendering command
void addBenchmarkCommand(render_fn_t const & fn, ScreenBase const & frameScreen);
/// set the resolution scale factor to the main thread drawer;
void setVisualScale(double visualScale);
};

2
platform/platform.hpp
View file

@ -70,6 +70,8 @@ public:
virtual double PeriodicalUpdateInterval() const = 0;
virtual vector<string> GetFontNames() const = 0;
virtual bool IsBenchmarking() const = 0;
};
extern "C" Platform & GetPlatform();

5
platform/qtplatform.cpp
View file

@ -379,6 +379,11 @@ public:
return res;
}
bool IsBenchmarking() const
{
return false;
}
};
extern "C" Platform & GetPlatform()