240 lines
7.8 KiB
C++
240 lines
7.8 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#define USING_LOG_PREFIX SHARE
|
|
#include <gtest/gtest.h>
|
|
#define private public
|
|
#define protected public
|
|
#include "lib/rc/context.h"
|
|
#undef private
|
|
#undef protected
|
|
#include "lib/alloc/ob_malloc_allocator.h"
|
|
#include "lib/thread_local/ob_tsi_factory.h"
|
|
#include "lib/alloc/memory_dump.h"
|
|
#include "lib/thread/thread_mgr.h"
|
|
#include "lib/allocator/ob_mem_leak_checker.h"
|
|
|
|
using namespace oceanbase;
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::lib;
|
|
|
|
static bool has_unfree = false;
|
|
void has_unfree_callback(char *)
|
|
{
|
|
has_unfree = true;
|
|
}
|
|
|
|
class TestContext: public ::testing::Test
|
|
{
|
|
public:
|
|
virtual void SetUp() {}
|
|
virtual void TearDown() {}
|
|
};
|
|
|
|
TEST_F(TestContext, Basic)
|
|
{
|
|
// There must be a Flow pointing to root on each thread
|
|
auto &context = Flow::current_ctx();
|
|
auto &flow = Flow::current_flow();
|
|
ASSERT_EQ(MemoryContext::root(), context);
|
|
ASSERT_TRUE(flow.prev_ == flow.next_ && flow.prev_ == nullptr);
|
|
ASSERT_TRUE(context->tree_node_.parent_ == context->tree_node_.child_ &&
|
|
context->tree_node_.parent_ == context->tree_node_.next_ &&
|
|
context->tree_node_.parent_ == nullptr);
|
|
uint64_t tenant_id = 1001;
|
|
uint64_t ctx_id = ObCtxIds::WORK_AREA;
|
|
ObMallocAllocator *ma = ObMallocAllocator::get_instance();
|
|
ASSERT_EQ(OB_SUCCESS, ma->create_tenant_ctx_allocator(tenant_id, ctx_id));
|
|
|
|
ObPageManager g_pm;
|
|
ObPageManager::set_thread_local_instance(g_pm);
|
|
g_pm.set_tenant_ctx(tenant_id, ctx_id);
|
|
g_pm.set_max_chunk_cache_cnt(0);
|
|
MemoryContext &root = MemoryContext::root();
|
|
ContextParam param;
|
|
param.set_mem_attr(tenant_id, "Context", ctx_id);
|
|
ContextTLOptGuard guard(true);
|
|
param.properties_ = USE_TL_PAGE_OPTIONAL;
|
|
MemoryContext mem_context;
|
|
int ret = root->CREATE_CONTEXT(mem_context, param);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_EQ(&mem_context->get_allocator(), &mem_context->get_arena_allocator());
|
|
int64_t used = g_pm.used_;
|
|
ASSERT_EQ(0, used);
|
|
void *ptr = nullptr;
|
|
WITH_CONTEXT(mem_context) {
|
|
ptr = ctxalp(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
MEMSET(ptr, 0, 100);
|
|
ASSERT_GT(g_pm.used_, used);
|
|
|
|
auto &P_MCTX = CURRENT_CONTEXT;
|
|
auto &P_MFLOW = Flow::current_flow();
|
|
CREATE_WITH_TEMP_CONTEXT_P(false, param) {
|
|
ASSERT_EQ(&CURRENT_CONTEXT, &P_MCTX);
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
CREATE_WITH_TEMP_CONTEXT_P(true, param) {
|
|
ASSERT_NE(&CURRENT_CONTEXT, &P_MCTX);
|
|
ASSERT_EQ(Flow::current_flow().prev_, &P_MFLOW);
|
|
ASSERT_EQ(Flow::current_flow().next_, nullptr);
|
|
int64_t p_hold = P_MCTX->hold();
|
|
int64_t hold = CURRENT_CONTEXT->hold();
|
|
for (int i = 0; i < 64; ++i) {
|
|
ptr = ctxalp(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
}
|
|
ASSERT_GT(g_pm.used_, used);
|
|
ASSERT_EQ(p_hold, P_MCTX->hold());
|
|
ASSERT_LT(hold, CURRENT_CONTEXT->hold());
|
|
int64_t orig_pm_used = g_pm.used_;
|
|
has_unfree = false;
|
|
CREATE_WITH_TEMP_CONTEXT(param) {
|
|
for (int i = 0; i < 64; ++i) {
|
|
ptr = ctxalp(1024);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ptr = ctxalf(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ObArenaAllocator &arena_alloc = CURRENT_CONTEXT->get_arena_allocator();
|
|
ptr = arena_alloc.alloc(1024);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ObIAllocator &alloc = CURRENT_CONTEXT->get_malloc_allocator();
|
|
int64_t ori_used = CURRENT_CONTEXT->used();
|
|
ptr = alloc.alloc(1024);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ASSERT_GT(CURRENT_CONTEXT->used(), ori_used);
|
|
alloc.free(ptr);
|
|
ASSERT_EQ(CURRENT_CONTEXT->used(), ori_used);
|
|
}
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
ASSERT_TRUE(has_unfree);
|
|
ASSERT_EQ(orig_pm_used, g_pm.used_);
|
|
CREATE_WITH_TEMP_CONTEXT(param) {
|
|
{
|
|
// In order to allow the object_set inside current_ctx to allocate free_list in advance
|
|
// Don't let the memory occupied by free_list affect subsequent verification
|
|
ctxalf(8192 - 1000);
|
|
ptr = ctxalf(2000);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ctxfree(ptr);
|
|
}
|
|
int sub_cnt = 8;
|
|
MemoryContext subs[sub_cnt];
|
|
for (int i = 0; i < sub_cnt; ++i) {
|
|
param.properties_ = USE_TL_PAGE_OPTIONAL |
|
|
RETURN_MALLOC_DEFAULT;
|
|
ret = CURRENT_CONTEXT->CREATE_CONTEXT(subs[i], param);
|
|
ASSERT_EQ(OB_SUCCESS, ret);
|
|
ASSERT_EQ(&subs[i]->get_allocator(), &subs[i]->get_malloc_allocator());
|
|
ptr = subs[i]->allocp(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ptr = subs[i]->get_arena_allocator().alloc(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
WITH_CONTEXT(subs[i]) {
|
|
ASSERT_EQ(subs[i], CURRENT_CONTEXT);
|
|
ptr = ctxalp(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
ptr = CURRENT_CONTEXT->get_arena_allocator().alloc(100);
|
|
ASSERT_NE(ptr, nullptr);
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
}
|
|
ASSERT_GT(g_pm.used_, orig_pm_used);
|
|
for (int i = 0; i < sub_cnt/2; ++i) {
|
|
DESTROY_CONTEXT(subs[i]);
|
|
}
|
|
ASSERT_GT(g_pm.used_, orig_pm_used);
|
|
// check child num
|
|
int child_cnt = 0;
|
|
for (auto cur = CURRENT_CONTEXT->tree_node_.child_;cur;cur=cur->next_,child_cnt++);
|
|
ASSERT_EQ(child_cnt, sub_cnt/2);
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
ASSERT_EQ(g_pm.used_, orig_pm_used);
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
} else {
|
|
ASSERT_TRUE(false);
|
|
}
|
|
ASSERT_GT(g_pm.used_, used);
|
|
DESTROY_CONTEXT(mem_context);
|
|
ASSERT_EQ(g_pm.used_, used);
|
|
|
|
{
|
|
get_mem_leak_checker().init();
|
|
reset_mem_leak_checker_label("test1");
|
|
ob_malloc(100, "test1");
|
|
ob_malloc(100, common::ObNewModIds::OB_COMMON_ARRAY);
|
|
get_mem_leak_checker().print();
|
|
|
|
reset_mem_leak_checker_label("OB_COMMON_ARRAY");
|
|
ob_malloc(100, "test1");
|
|
void *ptr = ob_malloc(100, common::ObNewModIds::OB_COMMON_ARRAY);
|
|
get_mem_leak_checker().print();
|
|
ob_free(ptr);
|
|
get_mem_leak_checker().print();
|
|
|
|
reset_mem_leak_checker_label("");
|
|
ob_malloc(100, "test1");
|
|
ob_malloc(100, common::ObNewModIds::OB_COMMON_ARRAY);
|
|
get_mem_leak_checker().print();
|
|
|
|
reset_mem_leak_checker_label("NONE");
|
|
ob_malloc(100, "test1");
|
|
ob_malloc(100, common::ObNewModIds::OB_COMMON_ARRAY);
|
|
get_mem_leak_checker().print();
|
|
|
|
// test rate
|
|
reset_mem_leak_checker_label("test2");
|
|
int i = 20;
|
|
while (i--) {
|
|
ob_malloc(100, "test2");
|
|
}
|
|
get_mem_leak_checker().print();
|
|
|
|
usleep(1000 * 1000);
|
|
i = 20;
|
|
while (i--) {
|
|
ob_malloc(100, "test2");
|
|
}
|
|
get_mem_leak_checker().print();
|
|
}
|
|
|
|
// Based on testing needs, this code is temporarily retained
|
|
ob_malloc(10000000, ObNewModIds::OB_COMMON_ARRAY);
|
|
ObMemoryDump::get_instance().init();
|
|
auto task = ObMemoryDump::get_instance().alloc_task();
|
|
task->type_ = DUMP_CHUNK;
|
|
task->dump_all_ = true;
|
|
ObMemoryDump::get_instance().push(task);
|
|
|
|
task = ObMemoryDump::get_instance().alloc_task();
|
|
task->type_ = STAT_LABEL;
|
|
ObMemoryDump::get_instance().push(task);
|
|
usleep(1000000);
|
|
ObMallocAllocator::get_instance()->get_tenant_ctx_allocator(500, ObCtxIds::DEFAULT_CTX_ID)->print_memory_usage();
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
oceanbase::common::ObLogger::get_logger().set_log_level("INFO");
|
|
OB_LOGGER.set_log_level("INFO");
|
|
testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|