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

Using of object pool for storing batchers

Browse source
This commit is contained in:
Roman Sorokin 2014-08-08 15:09:05 +03:00 • committed by Alex Zolotarev
parent a3bb1eb71c
commit 8f4fd55d8a
2 changed files with 34 additions and 58 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

69
drape_frontend/batchers_pool.cpp
View file

@ -4,16 +4,19 @@
#include "../drape/batcher.hpp"
#include "../base/assert.hpp"
#include "../base/logging.hpp"
#include "../std/bind.hpp"
namespace df
{
using dp::Batcher;
namespace
{
void FlushGeometry(BatchersPool::send_message_fn const & sendMessage,
void FlushGeometry(BatchersPool::TSendMessageFn const & sendMessage,
TileKey const & key,
dp::GLState const & state,
dp::TransferPointer<dp::RenderBucket> buffer)
@ -24,71 +27,45 @@ void FlushGeometry(BatchersPool::send_message_fn const & sendMessage,
} // namespace
BatchersPool::BatchersPool(int initBatcherCount, send_message_fn const & sendMessageFn)
BatchersPool::BatchersPool(int initBatcherCount, TSendMessageFn const & sendMessageFn)
: m_sendMessageFn(sendMessageFn)
{
for (int i = 0; i < initBatcherCount; ++i)
m_batchers.push(dp::MasterPointer<dp::Batcher>(new dp::Batcher()));
}
, m_factory()
, m_pool(initBatcherCount, m_factory)
{}
BatchersPool::~BatchersPool()
{
for (reserved_batchers_t::iterator it = m_reservedBatchers.begin();
it != m_reservedBatchers.end(); ++it)
{
it->second.first.Destroy();
}
m_reservedBatchers.clear();
while (!m_batchers.empty())
{
m_batchers.top().Destroy();
m_batchers.pop();
}
}
BatchersPool::~BatchersPool() {}
void BatchersPool::ReserveBatcher(TileKey const & key)
{
reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
if (it != m_reservedBatchers.end())
TIterator it = m_batchs.find(key);
if (it != m_batchs.end())
{
it->second.second++;
return;
}
dp::MasterPointer<dp::Batcher> reserved;
if (m_batchers.empty())
reserved.Reset(new dp::Batcher());
else
{
reserved = m_batchers.top();
m_batchers.pop();
}
reserved->StartSession(bind(&FlushGeometry, m_sendMessageFn, key, _1, _2));
VERIFY(m_reservedBatchers.insert(make_pair(key, make_pair(reserved, 1))).second, ());
Batcher * B = m_pool.Get();
m_batchs.insert(make_pair(key, make_pair(B, 1)));
B->StartSession(bind(&FlushGeometry, m_sendMessageFn, key, _1, _2));
}
dp::RefPointer<dp::Batcher> BatchersPool::GetTileBatcher(TileKey const & key)
{
reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
ASSERT(it != m_reservedBatchers.end(), ());
return it->second.first.GetRefPointer();
TIterator it = m_batchs.find(key);
ASSERT(it != m_batchs.end(), ());
return dp::MakeStackRefPointer(it->second.first);
}
void BatchersPool::ReleaseBatcher(TileKey const & key)
{
reserved_batchers_t::iterator it = m_reservedBatchers.find(key);
ASSERT(it != m_reservedBatchers.end(), ());
TIterator it = m_batchs.find(key);
ASSERT(it != m_batchs.end(), ());
ASSERT_GREATER(it->second.second, 0, ());
if ((--it->second.second)== 0)
{
dp::MasterPointer<dp::Batcher> batcher = it->second.first;
batcher->EndSession();
m_reservedBatchers.erase(it);
m_batchers.push(batcher);
Batcher * B = it->second.first;
B->EndSession();
m_pool.Return(B);
m_batchs.erase(it);
}
}

23
drape_frontend/batchers_pool.hpp
View file

@ -3,13 +3,13 @@
#include "tile_info.hpp"
#include "../drape/pointers.hpp"
#include "../drape/object_pool.hpp"
#include "../drape/batcher.hpp"
#include "../std/map.hpp"
#include "../std/stack.hpp"
#include "../std/function.hpp"
namespace dp { class Batcher; }
namespace df
{
@ -18,9 +18,9 @@ class Message;
class BatchersPool
{
public:
typedef function<void (dp::TransferPointer<Message>)> send_message_fn;
typedef function<void (dp::TransferPointer<Message>)> TSendMessageFn;
BatchersPool(int initBatcherCount, send_message_fn const & sendMessageFn);
BatchersPool(int initBatcherCount, TSendMessageFn const & sendMessageFn);
~BatchersPool();
void ReserveBatcher(TileKey const & key);
@ -28,15 +28,14 @@ public:
void ReleaseBatcher(TileKey const & key);
private:
typedef dp::MasterPointer<dp::Batcher> batcher_ptr;
typedef stack<batcher_ptr> batchers_pool_t;
typedef pair<batcher_ptr, int> counted_batcher_t;
typedef map<TileKey, counted_batcher_t> reserved_batchers_t;
typedef pair<dp::Batcher *, int> TBatcherPair;
typedef map<TileKey, TBatcherPair> TBatcherMap;
typedef TBatcherMap::iterator TIterator;
TSendMessageFn m_sendMessageFn;
batchers_pool_t m_batchers;
reserved_batchers_t m_reservedBatchers;
send_message_fn m_sendMessageFn;
dp::BatcherFactory m_factory;
ObjectPool<dp::Batcher, dp::BatcherFactory> m_pool;
TBatcherMap m_batchs;
};
} // namespace df