int TSIStackAllocator::end_batch_alloc(const bool rollback) { int err = OB_SUCCESS; StackAllocator* allocator = NULL; if (NULL == (allocator = get())) { err = OB_MEM_OVERFLOW; TBSYS_LOG(ERROR, "get_tsi_allocator() failed"); } else { err = allocator->end_batch_alloc(rollback); } return err; }
int TSIStackAllocator::start_batch_alloc() { int err = OB_SUCCESS; StackAllocator* allocator = NULL; if (NULL == (allocator = get())) { err = OB_MEM_OVERFLOW; TBSYS_LOG(ERROR, "get_tsi_allocator() failed"); } else { err = allocator->start_batch_alloc(); } return err; }
int TSIStackAllocator::reserve(const int64_t size) { int err = OB_SUCCESS; StackAllocator* allocator = NULL; if (NULL == (allocator = get())) { err = OB_MEM_OVERFLOW; TBSYS_LOG(ERROR, "get_tsi_allocator() failed"); } else { err = allocator->reserve(size); } return err; }
void* TSIStackAllocator::alloc(const int64_t size) { int err = OB_SUCCESS; StackAllocator* allocator = NULL; void* p = NULL; if (NULL == (allocator = get())) { err = OB_MEM_OVERFLOW; TBSYS_LOG(ERROR, "get_tsi_allocator() failed"); } else if (NULL == (p = allocator->alloc(size))) { err = OB_MEM_OVERFLOW; TBSYS_LOG(ERROR, "allocator->alloc(%ld)=>NULL", size); } return p; }
TEST(StackAllocator, marker) { StackAllocator allocator; void *ptr1 = allocator.Malloc(10); void *ptr2 = allocator.Malloc(20); StackAllocator::Marker makrer_a = allocator.GetMarker(); int remain_size_1 = allocator.remain_size(); void *ptr3 = allocator.Malloc(30); void *ptr4 = allocator.Malloc(400); allocator.FreeToMarker(makrer_a); EXPECT_EQ(remain_size_1, allocator.remain_size()); }
TEST(StackAllocator, basic_malloc_free) { StackAllocator allocator; EXPECT_EQ(allocator.stack_size(), allocator.remain_size()); const int header_size = allocator.GetAllocHeaderSize(); void *ptr1 = allocator.Malloc(10); EXPECT_EQ(allocator.stack_size() - (10 + header_size), allocator.remain_size()); void *ptr2 = allocator.Malloc(20); EXPECT_EQ(allocator.stack_size() - (20 + 10 + header_size * 2), allocator.remain_size()); EXPECT_NE(20, (uchar*)ptr2 - (uchar*)ptr1); allocator.Free(ptr2); EXPECT_EQ(allocator.stack_size() - (10 + header_size), allocator.remain_size()); allocator.Free(ptr1); EXPECT_EQ(allocator.stack_size(), allocator.remain_size()); }
int OOBase::Environment::get_block(const env_table_t& tabEnv, ScopedArrayPtr<wchar_t>& ptr) { if (tabEnv.empty()) return 0; // Copy and widen to UNICODE typedef SharedPtr<wchar_t> temp_wchar_t; // Sort environment block - UNICODE, no-locale, case-insensitive (from MSDN) struct env_sort { bool operator ()(const OOBase::SharedPtr<wchar_t>& s1, const OOBase::SharedPtr<wchar_t>& s2) const { return (_wcsicmp(s1.get(),s2.get()) < 0); } }; StackAllocator<1024> allocator; Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance> wenv(env_sort(),allocator); size_t total_size = 0; for (env_table_t::const_iterator i=tabEnv.begin();i;++i) { int err = Win32::utf8_to_wchar_t(i->first.c_str(),ptr); if (!err) { // Include \0 and optionally '=' length size_t len = wcslen(ptr.get()); total_size += len + 1; temp_wchar_t key = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator); if (!key) return ERROR_OUTOFMEMORY; wcscpy(key.get(),ptr.get()); err = Win32::utf8_to_wchar_t(i->second.c_str(),ptr); if (!err) { temp_wchar_t value; len = wcslen(ptr.get()); if (len) { total_size += len + 1; value = make_shared(static_cast<wchar_t*>(allocator.allocate(len+1,alignment_of<wchar_t>::value)),allocator); if (!value) return ERROR_OUTOFMEMORY; wcscpy(value.get(),ptr.get()); } if (!wenv.insert(key,value)) return ERROR_OUTOFMEMORY; } } if (err) return err; } // And now copy into one giant block if (!ptr.resize(total_size + 2)) return ERROR_OUTOFMEMORY; wchar_t* pout = ptr.get(); for (Table<temp_wchar_t,temp_wchar_t,env_sort,AllocatorInstance>::iterator i=wenv.begin();i;++i) { const wchar_t* p = i->first.get(); while (*p != L'\0') *pout++ = *p++; p = i->second.get(); if (p && *p != L'\0') { *pout++ = L'='; while (*p != L'\0') *pout++ = *p++; } *pout++ = L'\0'; } // Terminate with \0 *pout++ = L'\0'; *pout++ = L'\0'; return 0; }
~stack_tuple() { stack_alloc.deallocate( stack_ctx); }
stack_tuple( StackAllocator const& stack_alloc_, std::size_t size) : stack_ctx(), stack_alloc( stack_alloc_) { stack_alloc.allocate( stack_ctx, size); }