//-------------------------------------------------------------------------------------
void MemoryStream::destroyObjPool()
{
DEBUG_MSG(boost::format("MemoryStream::destroyObjPool(): size %1%.\n") %
_g_objPool.size());
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
void Bundle::destroyObjPool()
{
DEBUG_MSG(fmt::format("Bundle::destroyObjPool(): size {}.\n",
_g_objPool.size()));
_g_objPool.destroy();
}
void
add (uint32_t id, char side, uint32_t price, uint32_t size)
{
if (orders.end () != orders.find (id, OrderIdHasher (), OrderIdEqual ()))
{
throw std::runtime_error ("duplicate add");
}
AggregateOrders::iterator found = aggregateOrders.find (std::make_pair (side, price), AggregateOrderLess ());
if (found == aggregateOrders.end ())
{
AggregateOrder *a = aggregateOrderPool.construct (boost::in_place (side, price));
found = aggregateOrders.insert (*a).first;
}
assert(aggregateOrders.end () != found);
Order *order = orderPool.construct (boost::in_place (id, boost::ref (*found)));
assert(order);
bool orderInserted __attribute__((unused)) = orders.insert (*order).second;
assert(orderInserted);
order->size = size;
order->aggregateOrder.size += size;
assert(order->size);
assert(order->aggregateOrder.size);
}
//-------------------------------------------------------------------------------------
void UDPPacketReceiver::destroyObjPool()
{
DEBUG_MSG(boost::format("UDPPacketReceiver::destroyObjPool(): size %1%.\n") %
_g_objPool.size());
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
void UDPPacketReceiver::destroyObjPool()
{
DEBUG_MSG(fmt::format("UDPPacketReceiver::destroyObjPool(): size {}.\n",
_g_objPool.size()));
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
void TCPPacket::destroyObjPool()
{
DEBUG_MSG(fmt::format("TCPPacket::destroyObjPool(): size {}.\n",
_g_objPool.size()));
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
void MemoryStream::destroyObjPool()
{
DEBUG_MSG(fmt::format("MemoryStream::destroyObjPool(): size {}.\n",
_g_objPool.size()));
_g_objPool.destroy();
}
int main(int argc, char **args)
{
ObjectPool<int> pool;
int &a = pool.acquireObject();
pool.releaseObject(a);
return 0;
}
void test1()
{
ObjectPool<SmallObject> op;
SmallObject* s = op.get();
op.put(s);
s = op.get();
s = op.get();
s = op.get();
s = op.get();
printf("++++++++++++++++\n");
}
TEST_F(ObjectPoolTest, MovableObjectPool) {
ObjectPool<int> to;
// Verify a move works correctly when an object has been checked out:
{
ObjectPool<int> from;
auto original = from.Wait();
to = std::move(from);
}
// Now verify that the pooled object returned home to the right place:
ASSERT_EQ(1UL, to.GetCached()) << "Object pool move operation did not correctly relay checked out types";
}
void LexicalReorderingTableTree::auxCacheForSrcPhrase(const Phrase& f)
{
if(m_FactorsE.empty()) {
//f is all of key...
Candidates cands;
m_Table->GetCandidates(MakeTableKey(f,Phrase(ARRAY_SIZE_INCR)),&cands);
m_Cache[MakeCacheKey(f,Phrase(ARRAY_SIZE_INCR))] = cands;
} else {
ObjectPool<PPimp> pool;
PPimp* pPos = m_Table->GetRoot();
//1) goto subtree for f
for(size_t i = 0; i < f.GetSize() && 0 != pPos && pPos->isValid(); ++i) {
/* old code
pPos = m_Table.Extend(pPos, auxClearString(f.GetWord(i).ToString(m_FactorsF)), SourceVocId);
*/
pPos = m_Table->Extend(pPos, f.GetWord(i).GetString(m_FactorsF, false), SourceVocId);
}
if(0 != pPos && pPos->isValid()) {
pPos = m_Table->Extend(pPos, PrefixTreeMap::MagicWord);
}
if(0 == pPos || !pPos->isValid()) {
return;
}
//2) explore whole subtree depth first & cache
std::string cache_key = auxClearString(f.GetStringRep(m_FactorsF)) + "|||";
std::vector<State> stack;
stack.push_back(State(pool.get(PPimp(pPos->ptr()->getPtr(pPos->idx),0,0)),""));
Candidates cands;
while(!stack.empty()) {
if(stack.back().pos->isValid()) {
LabelId w = stack.back().pos->ptr()->getKey(stack.back().pos->idx);
std::string next_path = stack.back().path + " " + m_Table->ConvertWord(w,TargetVocId);
//cache this
m_Table->GetCandidates(*stack.back().pos,&cands);
if(!cands.empty()) {
m_Cache[cache_key + auxClearString(next_path)] = cands;
}
cands.clear();
PPimp* next_pos = pool.get(PPimp(stack.back().pos->ptr()->getPtr(stack.back().pos->idx),0,0));
++stack.back().pos->idx;
stack.push_back(State(next_pos,next_path));
} else {
stack.pop_back();
}
}
}
}
void Channel::destroyObjPool()
{
// DEBUG_MSG(fmt::format("Channel::destroyObjPool(): size {}.\n",
// s_ObjPool.size()));
s_ObjPool.destroy();
}
namespace KBEngine
{
static ObjectPool<MemoryStream> _g_objPool("MemoryStream");
//-------------------------------------------------------------------------------------
ObjectPool<MemoryStream>& MemoryStream::ObjPool()
{
return _g_objPool;
}
//-------------------------------------------------------------------------------------
void MemoryStream::destroyObjPool()
{
DEBUG_MSG(boost::format("MemoryStream::destroyObjPool(): size %1%.\n") %
_g_objPool.size());
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
MemoryStream::SmartPoolObjectPtr MemoryStream::createSmartPoolObj()
{
return SmartPoolObjectPtr(new SmartPoolObject<MemoryStream>(ObjPool().createObject(), _g_objPool));
}
//-------------------------------------------------------------------------------------
}
void MemoryStream::destroyObjPool()
{
// DEBUG_MSG(fmt::format("MemoryStream::destroyObjPool(): size {}.\n",
// s_ObjPool.size()));
s_ObjPool.destroy();
}
void Profiler::Entry::Free()
{
for(vector<Entry*>::iterator it = e.begin(), end = e.end(); it != end; ++it)
(*it)->Free();
e.clear();
entry_pool.Free(this);
}
namespace KBEngine
{
static ObjectPool<MemoryStream> _g_objPool("MemoryStream");
//-------------------------------------------------------------------------------------
ObjectPool<MemoryStream>& MemoryStream::ObjPool()
{
return _g_objPool;
}
//-------------------------------------------------------------------------------------
void MemoryStream::destroyObjPool()
{
DEBUG_MSG(fmt::format("MemoryStream::destroyObjPool(): size {}.\n",
_g_objPool.size()));
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
MemoryStream::SmartPoolObjectPtr MemoryStream::createSmartPoolObj()
{
return SmartPoolObjectPtr(new SmartPoolObject<MemoryStream>(ObjPool().createObject(), _g_objPool));
}
//-------------------------------------------------------------------------------------
size_t MemoryStream::getPoolObjectBytes()
{
size_t bytes = sizeof(rpos_) + sizeof(wpos_) + data_.size();
return bytes;
}
//-------------------------------------------------------------------------------------
}
int main() {
ObjectPool<int32_t, 128, false> pool;
int32_t* a = pool.fetch();
int32_t* b = pool.fetch();
int32_t* c = pool.fetch();
int32_t* d = pool.fetch();
pool.release(b);
int32_t* e = pool.fetch();
fprintf(stdout, "fetch() %p\n", a);
fprintf(stdout, "fetch() %p\n", b);
fprintf(stdout, "fetch() %p\n", c);
fprintf(stdout, "fetch() %p\n", d);
fprintf(stdout, "fetch() %p\n", e);
return 0;
}
void on_close_callback( uv_handle_t *s ) {
ReplayClient *cl = (ReplayClient*)s->data;
print("on_close_callback clid:%d",cl->id);
g_clients.del(cl->id);
delete cl;
if( g_serve_single_client ) {
print("g_serve_single_client is true, quitting.");
exit(0);
}
}
void ObjectPoolTest::testExclusivity()
{
ObjectPool<Serial> myPool;
const size_t numberOfObjectsToRetrieve = 10;
std::vector<ObjectPool<Serial>::Object> retrievedSerials;
std::set<size_t> seenSerialNumbers;
for (size_t i = 0; i < numberOfObjectsToRetrieve; i++) {
auto nextSerial = myPool.acquireObject();
// Add the retrieved Serial to the vector to keep it 'alive',
// and add the serial number to the set.
retrievedSerials.push_back(nextSerial);
seenSerialNumbers.insert(nextSerial->getSerialNumber());
}
// Assert that all retrieved serial numbers are different.
Assert::AreEqual(numberOfObjectsToRetrieve, seenSerialNumbers.size());
}
void Profiler::Push(cstring name)
{
assert(name && started);
Entry* new_e = entry_pool.Get();
new_e->name = name;
timer.Tick();
timer.GetTime(new_e->tick);
stac.back()->e.push_back(new_e);
stac.push_back(new_e);
}
void
reduce (uint32_t id, uint32_t size)
{
Orders::iterator found = orders.find (id, OrderIdHasher (), OrderIdEqual ());
if (found == orders.end ())
{
throw std::runtime_error ("order not found");
}
assert(&*found);
assert(&found->aggregateOrder);
Order &o = *found;
AggregateOrder &a = found->aggregateOrder;
if (size > o.size)
{
throw std::runtime_error ("attempt to over reduce");
}
if (size == o.size)
{
a.size -= o.size;
orders.erase (found);
orderPool.destroy (&o);
if (0 == a.size)
{
aggregateOrders.erase (AggregateOrders::s_iterator_to (a));
aggregateOrderPool.destroy (&a);
}
}
else
{
o.size -= size;
a.size -= size;
assert(o.size);
assert(a.size);
}
}
int main()
{
ObjectPool* pool = ObjectPool::getInstance();
Resource* one;
Resource* two;
one = pool->getResource();
one->setValue(10);
std::cout << "one = " << one->getValue() << " [" << one << "]" << std::endl;
two = pool->getResource();
two->setValue(20);
std::cout << "two = " << two->getValue() << " [" << two << "]" << std::endl;
pool->returnResource(one);
pool->returnResource(two);
one = pool->getResource();
std::cout << "one = " << one->getValue() << " [" << one << "]" << std::endl;
two = pool->getResource();
std::cout << "two = " << two->getValue() << " [" << two << "]" << std::endl;
return 0;
}
TEST_F(ObjectPoolTest, EmptyPoolIssuance) {
ObjectPool<int> pool;
// Create the thread which will hold the shared pointer for awhile:
AutoRequired<HoldsSharedPtrThenQuits> thread;
pool(thread->m_ptr);
std::weak_ptr<int> ptrWeak = thread->m_ptr;
ASSERT_FALSE(ptrWeak.expired()) << "Object pool failed to issue a shared pointer as expected";
// Verify properties now that we've zeroized the limit:
pool.SetOutstandingLimit(0);
EXPECT_ANY_THROW(pool.SetOutstandingLimit(1)) << "An attempt to alter a zeroized outstanding limit did not throw an exception as expected";
EXPECT_ANY_THROW(pool.Wait()) << "An attempt to obtain an element on an empty pool did not throw an exception as expected";
// Now see if we can delay for the thread to back out:
m_create->Initiate();
pool.Rundown();
// Verify that it got released as expected:
ASSERT_TRUE(ptrWeak.expired()) << "Not all shared pointers issued by an object pool expired in a timely fashion";
}
int main(){
queue<int*> q;
ObjectPool<int> op;
int *tmp;
for(int i = 0; i < 10; ++i){
int r = rand()%10000;
for(int j = 0; j < r; ++j){
tmp = op.NewObject();
q.push(tmp);
}
op.ShowCount();
while(q.size() > 0){
tmp = q.front();
q.pop();
op.DeleteObject(tmp);
}
op.ShowCount();
printf("\n");
}
cout << "ok" << endl;
}
void ObjectPoolTest::testRelease()
{
ObjectPool<Serial> myPool;
const size_t numberOfObjectsToRetrieve = 10;
std::vector<ObjectPool<Serial>::Object> retrievedSerials;
for (size_t i = 0; i < numberOfObjectsToRetrieve; i++) {
// Add the retrieved Serial to the vector to keep it 'alive'.
retrievedSerials.push_back(myPool.acquireObject());
}
size_t lastSerialNumber = retrievedSerials.back()->getSerialNumber();
// Release all objects back to the pool.
retrievedSerials.clear();
// The above loop has created ten Serial objects, with serial
// numbers 0-9, and released all ten Serial objects back to the pool.
// The next loop first again retrieves ten Serial objects. The serial
// numbers of these should all be <= lastSerialNumber.
// The Serial object acquired after that should have a new serial number.
bool wronglyNewObjectCreated = false;
for (size_t i = 0; i < numberOfObjectsToRetrieve; i++) {
auto nextSerial = myPool.acquireObject();
if (nextSerial->getSerialNumber() > lastSerialNumber) {
wronglyNewObjectCreated = true;
break;
}
retrievedSerials.push_back(nextSerial);
}
// Acquire one more Serial object, which should have a serial
// number > lastSerialNumber.
auto anotherSerial = myPool.acquireObject();
bool newObjectCreated = (anotherSerial->getSerialNumber() > lastSerialNumber);
Assert::IsFalse(wronglyNewObjectCreated);
Assert::IsTrue(newObjectCreated);
}
void test2()
{
TimeFilm tm("object pool: ");
ObjectPool<SmallObject> op;
SmallObject* s = 0;
//int m = 1000000;
int m = 100;
Random rnd;
const char* hello = "hello";
while (--m)
{
//s = op.get();
s = op.get(m,hello);
#if 1
if (s && rnd(2))
{
printf("put\n");
op.put(s);
}
#endif
}
}
namespace Mercury
{
//-------------------------------------------------------------------------------------
static ObjectPool<UDPPacket> _g_objPool;
ObjectPool<UDPPacket>& UDPPacket::ObjPool()
{
return _g_objPool;
}
//-------------------------------------------------------------------------------------
void UDPPacket::destroyObjPool()
{
DEBUG_MSG(boost::format("UDPPacket::destroyObjPool(): size %1%.\n") %
_g_objPool.size());
_g_objPool.destroy();
}
//-------------------------------------------------------------------------------------
UDPPacket::SmartPoolObjectPtr UDPPacket::createSmartPoolObj()
{
return SmartPoolObjectPtr(new SmartPoolObject<UDPPacket>(ObjPool().createObject(), _g_objPool));
}
//-------------------------------------------------------------------------------------
UDPPacket::UDPPacket(MessageID msgID, size_t res):
Packet(msgID, false, res)
{
data_resize(PACKET_MAX_SIZE_UDP);
wpos(0);
}
//-------------------------------------------------------------------------------------
UDPPacket::~UDPPacket(void)
{
}
//-------------------------------------------------------------------------------------
int UDPPacket::recvFromEndPoint(EndPoint & ep, Address* pAddr)
{
int len = ep.recvfrom(data(), PACKET_MAX_SIZE_UDP,
(u_int16_t*)&pAddr->port, (u_int32_t*)&pAddr->ip);
KBE_ASSERT(rpos() == 0);
wpos(len);
return len;
}
//-------------------------------------------------------------------------------------
}
void on_accept_callback( uv_stream_t *listener, int status ) {
uv_tcp_t *newsock = (uv_tcp_t*) MALLOC( sizeof(uv_tcp_t));
uv_tcp_init( uv_default_loop(), newsock );
if( uv_accept( listener, (uv_stream_t*) newsock ) == 0 ) {
ReplayClient *cl = new ReplayClient( newsock );
newsock->data = cl;
int r = uv_read_start( (uv_stream_t*) newsock, moyai_libuv_alloc_buffer, on_read_callback );
if(r) {
print("uv_read_start: fail. ret:%d", r );
}
g_clients.set(cl->id,cl);
print("on_accept_callback client id:%d",cl->id);
}
}
void Profiler::Start()
{
timer.Start();
e = entry_pool.Get();
e->name = "Start";
timer.GetTime(e->tick);
stac.push_back(e);
started = true;
if(!enabled)
{
frames = 0;
enabled = true;
}
}
namespace kd
{
ObjectPool Objects;
/// KernelObject ////////////////////////////////////////////////////////////
char const * Object::m_object_type = "KernelObject";
Object::Object(char const * name)
{
::memset(m_name, 0, 32);
if (name) ::strncpy(m_name, name, 31);
Objects.Attach(this);
}
Object::~Object()
{
Objects.Detach(this);
}
void Object::GetQuickInfos(char * data, size_t size)
{
::strncpy(data, "-", size-1);
}
void ObjectPool::Dump()
{
unsigned * occupied_entry = occupied;
for (int i = 0, j = 0; i < max_count/32; ++i, ++occupied_entry)
{
unsigned mask = *occupied_entry;
for (unsigned k = 1; k; ++j, k <<= 1)
{
if (mask & k)
{
char buffer[1024];
if (pool[j])
{
pool[j]->GetQuickInfos(buffer, 1024);
forcef(kd, "KernelObject %i: %s \"%s\": %s", j + handle_offset, pool[j]->GetType(), pool[j]->GetName(), buffer);
}
}
}
}
}
}
