hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Fix CtxBlockPl leak

Browse Source
This commit is contained in:
obdev
2024-02-09 22:18:25 +00:00
committed by ob-robot
parent 44f16d964c
commit d969ad5db0
7 changed files with 169 additions and 81 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
src/storage/blocksstable/cs_encoding/ob_micro_block_cs_decoder.cpp
View File

@ -82,12 +82,12 @@ void ObCSDecoderCtxArray::reset()
ObDecodeResourcePool *decode_res_pool = MTL(ObDecodeResourcePool*);
if (OB_ISNULL(decode_res_pool)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("NULL tenant decode resource pool", K(ret));
LOG_ERROR("NULL tenant decode resource pool", K(ret));
} else {
FOREACH(it, ctx_blocks_) {
ObColumnCSDecoderCtxBlock *ctx_block = *it;
if (OB_FAIL(decode_res_pool->free(ctx_block))) {
LOG_WARN("failed to free cs decoder ctx block", K(ret));
LOG_WARN("failed to free cs decoder ctx block", K(ret), KP(ctx_block));
}
}
ctx_blocks_.reset();
@ -118,16 +118,27 @@ int ObCSDecoderCtxArray::get_ctx_array(ObColumnCSDecoderCtx **&ctxs, int64_t siz
if (OB_FAIL(decode_res_pool->alloc(ctx_block))) {
LOG_WARN("alloc cs decoder ctx block failed", K(ret), K(i), K(need_block_count));
} else if (OB_FAIL(ctx_blocks_.push_back(ctx_block))) {
LOG_WARN("cs ctx block array push back failed", K(ret));
LOG_WARN("cs ctx block array push back failed", K(ret), KP(ctx_block));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < ObColumnCSDecoderCtxBlock::CS_CTX_NUMS; ++j) {
if (OB_FAIL(ctxs_.push_back(&ctx_block->ctxs_[j]))) {
LOG_WARN("cs ctx array push back failed", K(ret));
LOG_WARN("cs ctx array push back failed", K(ret), K(j));
}
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(ret)) {
if (NULL != ctx_block) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(decode_res_pool->free(ctx_block))) {
LOG_ERROR("failed to free decoder cs ctx block", K(tmp_ret), KP(ctx_block));
} else {
ctx_block = NULL;
}
}
reset();
} else {
ctxs = &ctxs_.at(0);
}
} else {
@ -216,7 +227,7 @@ int ObColumnCSDecoder::quick_compare(const ObStorageDatum &left,
/////////////////////// acquire decoder from local ///////////////////////
typedef int (*local_decode_acquire_func)(ObCSDecoderPool &local_decoder_pool,
const ObIColumnCSDecoder *&decoder);
typedef void(*local_decode_release_func)(ObCSDecoderPool &local_decoder_pool,
typedef int(*local_decode_release_func)(ObCSDecoderPool &local_decoder_pool,
ObIColumnCSDecoder *decoder);
static local_decode_acquire_func acquire_local_funcs_[ObCSColumnHeader::MAX_TYPE] = {
@ -252,15 +263,20 @@ int acquire_local_decoder(ObCSDecoderPool &local_decoder_pool, const ObIColumnCS
}
template <class Decoder>
void release_local_decoder(ObCSDecoderPool &local_decoder_pool, ObIColumnCSDecoder *decoder)
int release_local_decoder(ObCSDecoderPool &local_decoder_pool, ObIColumnCSDecoder *decoder)
{
int ret = OB_SUCCESS;
Decoder *d = nullptr;
if (nullptr == decoder) {
//do nothing
} else if (FALSE_IT(d = static_cast<Decoder *>(decoder))) {
} else if (OB_FAIL(local_decoder_pool.free<Decoder>(d))) {
LOG_ERROR("failed to free cs decoder", K(ret), "type", decoder->get_type(), KP(d));
} else {
Decoder* d = static_cast<Decoder *>(decoder);
local_decoder_pool.free<Decoder>(d);
d = nullptr;
decoder = nullptr;
}
return ret;
}
//////////////////////////ObIEncodeBlockGetReader/////////////////////////
@ -280,7 +296,7 @@ ObICSEncodeBlockReader::ObICSEncodeBlockReader()
ObICSEncodeBlockReader::~ObICSEncodeBlockReader()
{
free_decoders();
(void)free_decoders();
ctx_array_.reset();
if (NULL != local_decoder_pool_) {
local_decoder_pool_->reset();
@ -290,7 +306,7 @@ ObICSEncodeBlockReader::~ObICSEncodeBlockReader()
void ObICSEncodeBlockReader::reuse()
{
free_decoders();
(void)free_decoders();
cached_decocer_ = nullptr;
request_cnt_ = 0;
decoders_ = nullptr;
@ -305,7 +321,7 @@ void ObICSEncodeBlockReader::reuse()
void ObICSEncodeBlockReader::reset()
{
free_decoders();
(void)free_decoders();
cached_decocer_ = NULL;
request_cnt_ = 0;
decoders_ = nullptr;
@ -324,16 +340,23 @@ void ObICSEncodeBlockReader::reset()
buf_allocator_.reset();
}
void ObICSEncodeBlockReader::free_decoders()
int ObICSEncodeBlockReader::free_decoders()
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
if (nullptr != need_release_decoders_) {
for (int64_t i = 0; i < need_release_decoder_cnt_; ++i) {
release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnCSDecoder *>(need_release_decoders_[i]));
if (OB_TMP_FAIL(release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnCSDecoder *>(need_release_decoders_[i])))) {
ret = tmp_ret;
LOG_ERROR("failed to free cs decoder", K(tmp_ret), K(i), K(need_release_decoder_cnt_),
"type", need_release_decoders_[i]->get_type(), KP(need_release_decoders_[i]));
}
}
need_release_decoders_ = nullptr;
}
need_release_decoder_cnt_ = 0;
return ret;
}
int ObICSEncodeBlockReader::prepare(const uint64_t tenant_id, const int64_t column_cnt)
@ -805,19 +828,26 @@ int ObMicroBlockCSDecoder::acquire(const int64_t store_idx, const ObIColumnCSDec
return ret;
}
void ObMicroBlockCSDecoder::free_decoders()
int ObMicroBlockCSDecoder::free_decoders()
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
for (int64_t i = 0; i < need_release_decoder_cnt_; ++i) {
release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnCSDecoder *>(need_release_decoders_[i]));
if (OB_TMP_FAIL(release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnCSDecoder *>(need_release_decoders_[i])))) {
ret = tmp_ret;
LOG_ERROR("failed to free cs decoder", K(tmp_ret), K(i), K(need_release_decoder_cnt_),
"type", need_release_decoders_[i]->get_type(), KP(need_release_decoders_[i]));
}
}
need_release_decoders_.clear();
need_release_decoder_cnt_ = 0;
return ret;
}
void ObMicroBlockCSDecoder::inner_reset()
{
free_decoders();
(void)free_decoders();
cached_decoder_ = nullptr;
ctxs_ = NULL;
column_count_ = 0;
@ -883,7 +913,10 @@ int ObMicroBlockCSDecoder::init_decoders()
}
if (OB_FAIL(ret)) {
free_decoders();
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(free_decoders())) {
LOG_ERROR("fail to free cs decoders", K(tmp_ret));
}
}
}

6
src/storage/blocksstable/cs_encoding/ob_micro_block_cs_decoder.h
View File

@ -89,7 +89,7 @@ private:
template <class Decoder>
static int acquire_local_decoder(ObCSDecoderPool &local_decoder_pool, const ObIColumnCSDecoder *&decoder);
template <class Decoder>
static void release_local_decoder(ObCSDecoderPool &local_decoder_pool, ObIColumnCSDecoder *decoder);
static int release_local_decoder(ObCSDecoderPool &local_decoder_pool, ObIColumnCSDecoder *decoder);
class ObICSEncodeBlockReader
{
@ -104,7 +104,7 @@ protected:
int do_init(const ObMicroBlockData &block_data, const int64_t request_cnt);
int init_decoders();
int add_decoder(const int64_t store_idx, const ObObjMeta &obj_meta, ObColumnCSDecoder &dest);
void free_decoders();
int free_decoders();
int acquire(int64_t store_idx, const ObIColumnCSDecoder *&decoder);
protected:
@ -277,7 +277,7 @@ private:
int do_init(const ObMicroBlockData &block_data);
int init_decoders();
int add_decoder(const int64_t store_idx, const ObObjMeta &obj_meta, ObColumnCSDecoder &dest);
void free_decoders();
int free_decoders();
int get_stream_data_buf(const int64_t stream_idx, const char *&buf);
int decode_cells(
const uint64_t row_id, const int64_t col_begin, const int64_t col_end, ObStorageDatum *datums);

81
src/storage/blocksstable/encoding/ob_micro_block_decoder.cpp
View File

@ -74,12 +74,12 @@ void ObDecoderCtxArray::reset()
ObDecodeResourcePool *decode_res_pool = MTL(ObDecodeResourcePool*);
if (OB_ISNULL(decode_res_pool)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("NULL tenant decode resource pool", K(ret));
LOG_ERROR("NULL tenant decode resource pool", K(ret));
} else {
FOREACH(it, ctx_blocks_) {
ObColumnDecoderCtxBlock *ctx_block = *it;
if (OB_FAIL(decode_res_pool->free(ctx_block))) {
LOG_WARN("failed to free decoder ctx block", K(ret));
LOG_ERROR("failed to free decoder ctx block", K(ret), KP(ctx_block));
}
}
ctx_blocks_.reset();
@ -110,16 +110,27 @@ int ObDecoderCtxArray::get_ctx_array(ObDecoderCtx **&ctxs, int64_t size)
if (OB_FAIL(decode_res_pool->alloc(ctx_block))) {
LOG_WARN("alloc decoder ctx block failed", K(ret), K(i), K(need_block_count));
} else if (OB_FAIL(ctx_blocks_.push_back(ctx_block))) {
LOG_WARN("ctx block array push back failed", K(ret));
LOG_WARN("ctx block array push back failed", K(ret), KP(ctx_block));
} else {
for (int64_t j = 0; OB_SUCC(ret) && j < ObColumnDecoderCtxBlock::CTX_NUMS; ++j) {
if (OB_FAIL(ctxs_.push_back(&ctx_block->ctxs_[j]))) {
LOG_WARN("ctx array push back failed", K(ret));
LOG_WARN("ctx array push back failed", K(ret), K(j));
}
}
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(ret)) {
if (NULL != ctx_block) {
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(decode_res_pool->free(ctx_block))) {
LOG_ERROR("failed to free decoder ctx block", K(tmp_ret), KP(ctx_block));
} else {
ctx_block = NULL;
}
}
reset();
} else {
ctxs = &ctxs_.at(0);
}
} else {
@ -227,7 +238,7 @@ typedef int (*local_decode_acquire_func)(ObDecoderPool &local_decoder_pool,
const ObColumnHeader &col_header,
const char *meta_data,
const ObIColumnDecoder *&decoder);
typedef void(*local_decode_release_func)(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder);
typedef int(*local_decode_release_func)(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder);
static local_decode_acquire_func acquire_local_funcs_[ObColumnHeader::MAX_TYPE] =
{
@ -278,23 +289,32 @@ int acquire_local_decoder(ObDecoderPool &local_decoder_pool,
}
if (OB_FAIL(ret) && nullptr != d) {
local_decoder_pool.free<Decoder>(d);
decoder = nullptr;
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(local_decoder_pool.free<Decoder>(d))) {
LOG_ERROR("failed to free decoder", K(tmp_ret), "type", decoder->get_type(), KP(d));
} else {
d = nullptr;
decoder = nullptr;
}
}
return ret;
}
template <class Decoder>
void release_local_decoder(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder)
int release_local_decoder(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder)
{
int ret = OB_SUCCESS;
Decoder *d = nullptr;
if (nullptr == decoder) {
//do nothing
} else if (FALSE_IT(d = static_cast<Decoder *>(decoder))) {
} else if (OB_FAIL(local_decoder_pool.free<Decoder>(d))) {
LOG_ERROR("failed to free decoder", K(ret), "type", decoder->get_type(), KP(d));
} else {
Decoder* d = static_cast<Decoder *>(decoder);
local_decoder_pool.free<Decoder>(d);
d = nullptr;
decoder = nullptr;
}
return ret;
}
//////////////////////////ObIEncodeBlockGetReader/////////////////////////
@ -317,7 +337,7 @@ ObIEncodeBlockReader::ObIEncodeBlockReader()
ObIEncodeBlockReader::~ObIEncodeBlockReader()
{
free_decoders();
(void)free_decoders();
ctx_array_.reset();
if (NULL != local_decoder_pool_) {
local_decoder_pool_->reset();
@ -327,7 +347,7 @@ ObIEncodeBlockReader::~ObIEncodeBlockReader()
void ObIEncodeBlockReader::reuse()
{
free_decoders();
(void)free_decoders();
cached_decocer_ = nullptr;
header_ = nullptr;
request_cnt_ = 0;
@ -344,7 +364,7 @@ void ObIEncodeBlockReader::reuse()
void ObIEncodeBlockReader::reset()
{
free_decoders();
(void)free_decoders();
cached_decocer_ = NULL;
header_ = NULL;
request_cnt_ = 0;
@ -365,16 +385,23 @@ void ObIEncodeBlockReader::reset()
buf_allocator_.reset();
}
void ObIEncodeBlockReader::free_decoders()
int ObIEncodeBlockReader::free_decoders()
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
if (nullptr != need_release_decoders_) {
for (int64_t i = 0; i < need_release_decoder_cnt_; ++i) {
release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnDecoder *>(need_release_decoders_[i]));
if (OB_TMP_FAIL(release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnDecoder *>(need_release_decoders_[i])))) {
ret = tmp_ret;
LOG_ERROR("failed to free decoder", K(tmp_ret), K(i), K(need_release_decoder_cnt_),
"type", need_release_decoders_[i]->get_type(), KP(need_release_decoders_[i]));
}
}
need_release_decoders_ = nullptr;
}
need_release_decoder_cnt_ = 0;
return ret;
}
int ObIEncodeBlockReader::prepare(const uint64_t tenant_id, const int64_t column_cnt)
@ -1075,19 +1102,26 @@ int ObMicroBlockDecoder::acquire(const int64_t store_idx, const ObIColumnDecoder
}
void ObMicroBlockDecoder::free_decoders()
int ObMicroBlockDecoder::free_decoders()
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
for (int64_t i = 0; i < need_release_decoder_cnt_; ++i) {
release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnDecoder *>(need_release_decoders_[i]));
if (OB_TMP_FAIL(release_local_funcs_[need_release_decoders_[i]->get_type()]
(*local_decoder_pool_, const_cast<ObIColumnDecoder *>(need_release_decoders_[i])))) {
ret = tmp_ret;
LOG_ERROR("failed to free decoder", K(tmp_ret), K(i), K(need_release_decoder_cnt_),
"type", need_release_decoders_[i]->get_type(), KP(need_release_decoders_[i]));
}
}
need_release_decoders_.clear();
need_release_decoder_cnt_ = 0;
return ret;
}
void ObMicroBlockDecoder::inner_reset()
{
free_decoders();
(void)free_decoders();
cached_decoder_ = NULL;
header_ = NULL;
col_header_ = NULL;
@ -1169,7 +1203,10 @@ int ObMicroBlockDecoder::init_decoders()
}
if (OB_FAIL(ret)) {
free_decoders();
int tmp_ret = OB_SUCCESS;
if (OB_TMP_FAIL(free_decoders())) {
LOG_ERROR("fail to free decoders", K(tmp_ret));
}
}
}
return ret;

6
src/storage/blocksstable/encoding/ob_micro_block_decoder.h
View File

@ -111,7 +111,7 @@ static int acquire_local_decoder(ObDecoderPool &local_decoder_pool,
const char *meta_data,
const ObIColumnDecoder *&decoder);
template <class Decoder>
static void release_local_decoder(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder);
static int release_local_decoder(ObDecoderPool &local_decoder_pool, ObIColumnDecoder *decoder);
class ObIEncodeBlockReader
{
public:
@ -130,7 +130,7 @@ protected:
int do_init(const ObMicroBlockData &block_data, const int64_t request_cnt);
int init_decoders();
int add_decoder(const int64_t store_idx, const common::ObObjMeta &obj_meta, ObColumnDecoder &dest);
void free_decoders();
int free_decoders();
int acquire(const int64_t store_idx, const ObIColumnDecoder *&decoder);
int setup_row(const uint64_t row_id, int64_t &row_len, const char *&row_data);
protected:
@ -373,7 +373,7 @@ private:
int add_decoder(const int64_t store_idx,
const common::ObObjMeta &obj_meta,
ObColumnDecoder &dest);
void free_decoders();
int free_decoders();
int decode_cells(const uint64_t row_id,
const int64_t row_len,
const char *row_data,

30
src/storage/blocksstable/ob_decode_resource_pool.cpp
View File

@ -209,18 +209,18 @@ void ObDecoderPool::reset()
ObDecodeResourcePool *decode_res_pool = MTL(ObDecodeResourcePool*);
if (OB_ISNULL(decode_res_pool)) {
int ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "NULL tenant decode resource pool", K(ret));
STORAGE_LOG(ERROR, "NULL tenant decode resource pool", K(ret));
} else {
free_decoders<ObRawDecoder>(*decode_res_pool, ObColumnHeader::RAW);
free_decoders<ObDictDecoder>(*decode_res_pool, ObColumnHeader::DICT);
free_decoders<ObRLEDecoder>(*decode_res_pool, ObColumnHeader::RLE);
free_decoders<ObConstDecoder>(*decode_res_pool, ObColumnHeader::CONST);
free_decoders<ObIntegerBaseDiffDecoder>(*decode_res_pool, ObColumnHeader::INTEGER_BASE_DIFF);
free_decoders<ObStringDiffDecoder>(*decode_res_pool, ObColumnHeader::STRING_DIFF);
free_decoders<ObHexStringDecoder>(*decode_res_pool, ObColumnHeader::HEX_PACKING);
free_decoders<ObStringPrefixDecoder>(*decode_res_pool, ObColumnHeader::STRING_PREFIX);
free_decoders<ObColumnEqualDecoder>(*decode_res_pool, ObColumnHeader::COLUMN_EQUAL);
free_decoders<ObInterColSubStrDecoder>(*decode_res_pool, ObColumnHeader::COLUMN_SUBSTR);
(void)free_decoders<ObRawDecoder>(*decode_res_pool, ObColumnHeader::RAW);
(void)free_decoders<ObDictDecoder>(*decode_res_pool, ObColumnHeader::DICT);
(void)free_decoders<ObRLEDecoder>(*decode_res_pool, ObColumnHeader::RLE);
(void)free_decoders<ObConstDecoder>(*decode_res_pool, ObColumnHeader::CONST);
(void)free_decoders<ObIntegerBaseDiffDecoder>(*decode_res_pool, ObColumnHeader::INTEGER_BASE_DIFF);
(void)free_decoders<ObStringDiffDecoder>(*decode_res_pool, ObColumnHeader::STRING_DIFF);
(void)free_decoders<ObHexStringDecoder>(*decode_res_pool, ObColumnHeader::HEX_PACKING);
(void)free_decoders<ObStringPrefixDecoder>(*decode_res_pool, ObColumnHeader::STRING_PREFIX);
(void)free_decoders<ObColumnEqualDecoder>(*decode_res_pool, ObColumnHeader::COLUMN_EQUAL);
(void)free_decoders<ObInterColSubStrDecoder>(*decode_res_pool, ObColumnHeader::COLUMN_SUBSTR);
}
}
@ -244,10 +244,10 @@ void ObCSDecoderPool::reset()
int ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "NULL tenant decode resource pool", K(ret));
} else {
free_decoders<ObIntegerColumnDecoder>(*decode_res_pool, ObCSColumnHeader::INTEGER);
free_decoders<ObStringColumnDecoder>(*decode_res_pool, ObCSColumnHeader::STRING);
free_decoders<ObIntDictColumnDecoder>(*decode_res_pool, ObCSColumnHeader::INT_DICT);
free_decoders<ObStrDictColumnDecoder>(*decode_res_pool, ObCSColumnHeader::STR_DICT);
(void)free_decoders<ObIntegerColumnDecoder>(*decode_res_pool, ObCSColumnHeader::INTEGER);
(void)free_decoders<ObStringColumnDecoder>(*decode_res_pool, ObCSColumnHeader::STRING);
(void)free_decoders<ObIntDictColumnDecoder>(*decode_res_pool, ObCSColumnHeader::INT_DICT);
(void)free_decoders<ObStrDictColumnDecoder>(*decode_res_pool, ObCSColumnHeader::STR_DICT);
}
}

8
src/storage/blocksstable/ob_decode_resource_pool.h
View File

@ -100,7 +100,7 @@ public:
template <typename T>
inline int alloc(T *&item);
template <typename T>
inline void free(T *item);
inline int free(T *item);
void reset();
private:
constexpr static int16_t MAX_CNTS[] = {MAX_FREE_CNT, MAX_FREE_CNT,
@ -114,7 +114,7 @@ private:
inline void pop_decoder(const ObColumnHeader::Type &type, T *&item);
inline void push_decoder(const ObColumnHeader::Type &type, ObIColumnDecoder *item);
template <typename T>
inline void free_decoders(ObDecodeResourcePool &decode_res_pool,
inline int free_decoders(ObDecodeResourcePool &decode_res_pool,
const ObColumnHeader::Type &type);
ObIColumnDecoder* raw_pool_[MAX_CNTS[ObColumnHeader::RAW]];
ObIColumnDecoder* dict_pool_[MAX_CNTS[ObColumnHeader::DICT]];
@ -140,7 +140,7 @@ public:
template <typename T>
inline int alloc(T *&item);
template <typename T>
inline void free(T *item);
inline int free(T *item);
void reset();
private:
constexpr static int16_t MAX_CS_CNTS[ObCSColumnHeader::MAX_TYPE] =
@ -153,7 +153,7 @@ private:
inline void pop_decoder(const ObCSColumnHeader::Type &type, T *&item);
inline void push_decoder(const ObCSColumnHeader::Type &type, ObIColumnCSDecoder *item);
template <typename T>
inline void free_decoders(ObDecodeResourcePool &decode_res_pool,
inline int free_decoders(ObDecodeResourcePool &decode_res_pool,
const ObCSColumnHeader::Type &type);
ObIColumnCSDecoder* cs_integer_pool_[MAX_CS_CNTS[ObCSColumnHeader::INTEGER]];
ObIColumnCSDecoder* cs_string_pool_[MAX_CS_CNTS[ObCSColumnHeader::STRING]];

46
src/storage/blocksstable/ob_decode_resource_pool.ipp
View File

@ -32,11 +32,11 @@ int ObDecodeResourcePool::free(T *item)
int ret = OB_SUCCESS;
if (IS_NOT_INIT) {
ret = common::OB_NOT_INIT;
STORAGE_LOG(WARN, "decode resource pool is not inited", K(ret));
STORAGE_LOG(ERROR, "decode resource pool is not inited", K(ret));
} else if (NULL != item) {
ObSmallObjPool<T> &obj_pool = get_pool<T>();
if(OB_FAIL(obj_pool.free(item))) {
STORAGE_LOG(WARN, "decode resource pool failed to free", K(ret));
STORAGE_LOG(ERROR, "decode resource pool failed to free", K(ret), KP(item));
} else {
item = NULL;
}
@ -46,16 +46,22 @@ int ObDecodeResourcePool::free(T *item)
////////////////////////// decoder pool ///////////////////////////////////////
template <typename T>
inline void ObDecoderPool::free_decoders(ObDecodeResourcePool &decode_res_pool,
inline int ObDecoderPool::free_decoders(ObDecodeResourcePool &decode_res_pool,
const ObColumnHeader::Type &type)
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
int16_t &free_cnt_ = free_cnts_[type];
while (free_cnt_ > 0) {
T* d = static_cast<T *>(pools_[type][free_cnt_ - 1]);
decode_res_pool.free<T>(d);
if (OB_TMP_FAIL(decode_res_pool.free<T>(d))) {
ret = tmp_ret;
STORAGE_LOG(ERROR, "decode resource pool failed to free", K(tmp_ret), K(type), KP(d));
}
pools_[type][free_cnt_ - 1] = NULL;
--free_cnt_;
}
return ret;
}
template<typename T>
@ -88,8 +94,9 @@ inline int ObDecoderPool::alloc_miss_cache(T *&item)
template<typename T>
inline void ObDecoderPool::free(T *item)
inline int ObDecoderPool::free(T *item)
{
int ret = OB_SUCCESS;
if (NULL != item) {
const ObColumnHeader::Type &type = T::type_;
if (not_reach_limit(type)) {
@ -100,14 +107,16 @@ inline void ObDecoderPool::free(T *item)
ObDecodeResourcePool *decode_res_pool = MTL(ObDecodeResourcePool*);
if (OB_ISNULL(decode_res_pool)) {
int ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "NULL tenant decode resource pool", K(ret));
STORAGE_LOG(ERROR, "NULL tenant decode resource pool", K(ret));
} else if (FALSE_IT(item->reuse())) {
} else if (OB_FAIL(decode_res_pool->free(item))) {
STORAGE_LOG(ERROR, "decode resource pool failed to free", K(ret), K(type), KP(item));
} else {
item->reuse();
decode_res_pool->free(item);
item = NULL;
}
}
}
return ret;
}
inline bool ObDecoderPool::has_decoder(const ObColumnHeader::Type &type) const
@ -134,16 +143,22 @@ inline void ObDecoderPool::push_decoder(const ObColumnHeader::Type &type,
////////////////////////// cs decoder pool ///////////////////////////////////////
template <typename T>
inline void ObCSDecoderPool::free_decoders(ObDecodeResourcePool &decode_res_pool,
inline int ObCSDecoderPool::free_decoders(ObDecodeResourcePool &decode_res_pool,
const ObCSColumnHeader::Type &type)
{
int ret = OB_SUCCESS;
int tmp_ret = OB_SUCCESS;
int16_t &free_cnt_ = free_cnts_[type];
while (free_cnt_ > 0) {
T* d = static_cast<T *>(pools_[type][free_cnt_ - 1]);
decode_res_pool.free<T>(d);
if (OB_TMP_FAIL(decode_res_pool.free<T>(d))) {
ret = tmp_ret;
STORAGE_LOG(ERROR, "decode resource pool failed to free", K(ret), K(type), KP(d));
}
pools_[type][free_cnt_ - 1] = NULL;
--free_cnt_;
}
return ret;
}
template<typename T>
@ -177,8 +192,9 @@ int ObCSDecoderPool::alloc_miss_cache(T *&item)
template<typename T>
inline void ObCSDecoderPool::free(T *item)
inline int ObCSDecoderPool::free(T *item)
{
int ret = OB_SUCCESS;
if (NULL != item) {
const ObCSColumnHeader::Type type = T::type_;
if (not_reach_limit(type)) {
@ -189,14 +205,16 @@ inline void ObCSDecoderPool::free(T *item)
ObDecodeResourcePool *decode_res_pool = MTL(ObDecodeResourcePool*);
if (OB_ISNULL(decode_res_pool)) {
int ret = OB_ERR_UNEXPECTED;
STORAGE_LOG(WARN, "NULL tenant decode resource pool", K(ret));
STORAGE_LOG(ERROR, "NULL tenant decode resource pool", K(ret));
} else if (FALSE_IT(item->reuse())) {
} else if (OB_FAIL(decode_res_pool->free(item))) {
STORAGE_LOG(ERROR, "decode resource pool failed to free", K(ret), K(type), KP(item));
} else {
item->reuse();
decode_res_pool->free(item);
item = NULL;
}
}
}
return ret;
}
inline bool ObCSDecoderPool::has_decoder(const ObCSColumnHeader::Type &type) const