hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
5700951d2879e8e445a8dcd53d91dce26eefcbd8
oceanbase/src/sql/engine/basic/ob_chunk_datum_store.cpp

2793 lines
88 KiB
C++
Raw Blame History

/**
* 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 SQL_ENG
#include "sql/engine/basic/ob_chunk_datum_store.h"
#include "sql/engine/ob_exec_context.h"
// for ObChunkStoreUtil
#include "sql/engine/basic/ob_chunk_row_store.h"
#include "lib/container/ob_se_array_iterator.h"
#include "lib/utility/ob_tracepoint.h"
#include "share/config/ob_server_config.h"
namespace oceanbase
{
using namespace common;
namespace sql
{
int ObChunkDatumStore::BlockBuffer::init(char *buf, const int64_t buf_size)
{
int ret = OB_SUCCESS;
if (NULL == buf || buf_size <= 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret));
} else {
data_ = buf;
cur_pos_ = 0;
cap_ = buf_size - sizeof(BlockBuffer);
}
return ret;
}
namespace chunk_datum_store {
template <typename T, typename B>
void pointer2off(T *&pointer, B *base)
{
pointer = reinterpret_cast<T *>(
reinterpret_cast<const char *>(pointer) - reinterpret_cast<const char *>(base));
}
template <typename T, typename B>
void off2pointer(T *&pointer, B *base)
{
pointer = reinterpret_cast<T *>(
reinterpret_cast<intptr_t>(pointer) + reinterpret_cast<char *>(base));
}
template <typename T, typename B>
void point2pointer(T *&dst_pointer, B *dst_base, T *src_pointer, const B *src_base, int64_t len)
{
dst_pointer = reinterpret_cast<T *>(reinterpret_cast<char *>(dst_base) +
reinterpret_cast<intptr_t>(src_pointer) - reinterpret_cast<const char *>(src_base) - len);
}
}
int ObChunkDatumStore::StoredRow::to_expr(const common::ObIArray<ObExpr*> &exprs,
ObEvalCtx &ctx,
int64_t count) const
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(cnt_ < count || exprs.count() < count)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("datum count mismatch", K(ret), K(cnt_), K(exprs.count()), K(count));
} else {
for (uint32_t i = 0; i < count; ++i) {
if (exprs.at(i)->is_const_expr()) {
continue;
} else {
exprs.at(i)->locate_expr_datum(ctx) = cells()[i];
exprs.at(i)->set_evaluated_projected(ctx);
}
}
}
return ret;
}
int ObChunkDatumStore::StoredRow::assign(const StoredRow *sr)
{
int ret = OB_SUCCESS;
MEMCPY(this, static_cast<const void*>(sr), sr->row_size_);
ObDatum* src_cells = const_cast<ObDatum*>(sr->cells());
for (int64_t i = 0; i < cnt_; ++i) {
chunk_datum_store::point2pointer(*(const char **)&cells()[i].ptr_,
this,
*(const char **)&src_cells[i].ptr_, sr, 0);
}
LOG_DEBUG("trace unswizzling", K(ret), K(this));
return ret;
}
// only for LastStoredRow to use
// set null for the nth_col column
int ObChunkDatumStore::StoredRow::set_null(int64_t nth_col)
{
int ret = OB_SUCCESS;
int64_t len = 0;
int64_t move_len = 0;
for (int64_t i = 0; i < cnt_; ++i) {
if (i == nth_col) {
len = cells()[i].len_;
if (0 < len) {
move_len = row_size_ - (reinterpret_cast<const char *>(cells()[i].ptr_) - reinterpret_cast<const char *>(payload_)) - len;
LOG_DEBUG("chunk store mem move", K(move_len));
if (0 < move_len) {
MEMMOVE(const_cast<char *>(cells()[i].ptr_),
const_cast<char *>(cells()[i].ptr_) + len,
move_len);
}
}
cells()[i].set_null();
} else {
chunk_datum_store::point2pointer(*(const char **)&cells()[i].ptr_,
this,
*(const char **)&cells()[i].ptr_, this, len);
}
}
row_size_ -= len;
LOG_DEBUG("trace unswizzling", K(ret), K(this));
return ret;
}
void ObChunkDatumStore::StoredRow::unswizzling(char *base/*= NULL*/)
{
if (NULL == base) {
base = (char *)this;
}
unswizzling_datum(cells(), cnt_, base);
LOG_DEBUG("trace unswizzling", K(this));
}
void ObChunkDatumStore::StoredRow::unswizzling_datum(ObDatum *datum, uint32_t cnt, char *base)
{
for (int64_t i = 0; i < cnt; ++i) {
chunk_datum_store::pointer2off(*(const char **)(&(datum[i].ptr_)), base);
}
}
void ObChunkDatumStore::StoredRow::swizzling(char *base/*= NULL*/)
{
if (NULL == base) {
base = (char *)this;
}
for (int64_t i = 0; i < cnt_; ++i) {
chunk_datum_store::off2pointer(*(const char **)&cells()[i].ptr_, base);
}
}
template <bool UNSWIZZLING, bool IS_VECTOR_ROW>
int ObChunkDatumStore::StoredRow::do_build(StoredRow *&sr,
const ObExprPtrIArray &exprs,
ObEvalCtx &ctx,
char *buf,
const int64_t buf_len,
const uint32_t extra_size,
int64_t vector_row_idx)
{
int ret = OB_SUCCESS;
sr = reinterpret_cast<StoredRow *>(buf);
int64_t pos = sizeof(*sr) + sizeof(ObDatum) * exprs.count() + extra_size;
if (pos > buf_len) {
ret = OB_BUF_NOT_ENOUGH;
} else {
sr->cnt_ = exprs.count();
ObDatum *datums = sr->cells();
for (int64_t i = 0; i < exprs.count() && OB_SUCC(ret); i++) {
ObExpr *expr = exprs.at(i);
if (OB_UNLIKELY(NULL == expr)) {
// Set datum to NULL for NULL expr
datums[i].set_null();
} else if (IS_VECTOR_ROW) {
// TODO: shanting2.0 remove later.
if (OB_UNLIKELY(VEC_INVALID == expr->get_format(ctx))) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("expr not evaluated before", K(ret), KPC(expr));
} else {
ObIVector *vec = expr->get_vector(ctx);
const char *payload = NULL;
ObLength len = 0;
vec->get_payload(vector_row_idx, payload, len);
ObDatum in_datum(payload, len, vec->is_null(vector_row_idx));
ret = UNSWIZZLING
? deep_copy_unswizzling(in_datum, &datums[i], buf, buf_len, pos)
: datums[i].deep_copy(in_datum, buf, buf_len, pos);
}
} else {
ObDatum *in_datum = NULL;
if (OB_FAIL(expr->eval(ctx, in_datum))) {
LOG_WARN("expression evaluate failed", K(ret));
} else {
ret = UNSWIZZLING
? deep_copy_unswizzling(*in_datum, &datums[i], buf, buf_len, pos)
: datums[i].deep_copy(*in_datum, buf, buf_len, pos);
}
}
}
if (OB_SUCC(ret)) {
sr->row_size_ = static_cast<int32_t>(pos);
}
}
return ret;
}
int ObChunkDatumStore::StoredRow::build(StoredRow *&sr,
const ObExprPtrIArray &exprs,
ObEvalCtx &ctx,
char *buf,
const int64_t buf_len,
const uint32_t extra_size, /* = 0 */
const bool unswizzling /* = false */,
int64_t vector_row_idx /* OB_INVALID_ID */)
{
bool is_vector_row = OB_INVALID_ID != vector_row_idx;
return unswizzling
? (is_vector_row
? do_build<true, true>(sr, exprs, ctx, buf, buf_len, extra_size, vector_row_idx)
: do_build<true, false>(sr, exprs, ctx, buf, buf_len, extra_size, vector_row_idx))
: (is_vector_row
? do_build<false, true>(sr, exprs, ctx, buf, buf_len, extra_size, vector_row_idx)
: do_build<false, false>(sr, exprs, ctx, buf, buf_len, extra_size, vector_row_idx));
}
int ObChunkDatumStore::StoredRow::build(StoredRow *&sr,
const ObExprPtrIArray &exprs,
ObEvalCtx &ctx,
common::ObIAllocator &alloc,
const uint32_t extra_size /* = 0 */)
{
int ret = OB_SUCCESS;
int64_t size = 0;
char *buf = NULL;
if (OB_FAIL(Block::row_store_size(exprs, ctx, size, extra_size))) {
LOG_WARN("get row store size failed", K(ret));
} else if (NULL == (buf = static_cast<char *>(alloc.alloc(size)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret), K(size));
} else if (OB_FAIL(build(sr, exprs, ctx, buf, size, extra_size))) {
LOG_WARN("build stored row failed", K(ret));
}
return ret;
}
int ObChunkDatumStore::Block::add_row(const common::ObIArray<ObExpr*> &exprs, ObEvalCtx &ctx,
const int64_t row_size, uint32_t row_extend_size, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
BlockBuffer *buf = get_buffer();
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf), K(row_size));
} else if (row_size > buf->remain()) {
ret = OB_BUF_NOT_ENOUGH;
LOG_WARN("buffer not enough", K(row_size), "remain", buf->remain());
} else {
StoredRow *sr = NULL;
if (OB_FAIL(StoredRow::build(sr, exprs, ctx, buf->head(), row_size, row_extend_size))) {
LOG_WARN("build stored row failed", K(ret));
} else if (OB_FAIL(buf->advance(sr->row_size_))) {
LOG_WARN("fill buffer head failed", K(ret), K(buf), K(row_size));
} else {
rows_++;
if (NULL != stored_row) {
*stored_row = sr;
}
}
}
return ret;
}
int ObChunkDatumStore::BlockBufferWrap::append_row(
const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx, int64_t row_extend_size,
int64_t vector_row_idx)
{
int ret = OB_SUCCESS;
OB_ASSERT(is_inited());
int64_t max_size = remain();
int64_t pos = sizeof(ObDatum) * exprs.count() + row_extend_size + sizeof(StoredRow);
if (pos > max_size) {
ret = OB_BUF_NOT_ENOUGH;
} else {
StoredRow *sr = (StoredRow*)head();
sr->cnt_ = static_cast<uint32_t>(exprs.count());
for (int64_t i = 0; OB_SUCC(ret) && i < sr->cnt_; ++i) {
ObDatum *datum = new (&sr->cells()[i])ObDatum();
// Attension : can't print dst datum after deep_copy_unswizzling
if (OB_INVALID_ID == vector_row_idx) {
ret = deep_copy_unswizzling(static_cast<ObDatum&>(exprs.at(i)->locate_expr_datum(*ctx)),
datum, head(), max_size, pos);
} else {
const ObIVector *vec = exprs.at(i)->get_vector(*ctx);
const char *payload = NULL;
ObLength len = 0;
vec->get_payload(vector_row_idx, payload, len);
ObDatum in_datum(payload, len, vec->is_null(vector_row_idx));
ret = deep_copy_unswizzling(in_datum, datum, head(), max_size, pos);
}
if (OB_FAIL(ret)) {
if (OB_BUF_NOT_ENOUGH != ret) {
LOG_WARN("failed to copy datum", K(ret), K(i), K(pos),
K(max_size));
}
} else {
LOG_DEBUG("succ to copy_datums", K(sr->cnt_), K(i), K(max_size), K(pos));
}
}
if (OB_SUCC(ret)) {
sr->row_size_ = static_cast<int32_t>(pos);
fast_advance(pos);
rows_++;
}
}
return ret;
}
int ObChunkDatumStore::Block::append_row(
const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx,
BlockBuffer *buf, int64_t row_extend_size, StoredRow **stored_row, const bool unswizzling,
int64_t vector_row_idx)
{
int ret = OB_SUCCESS;
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf));
} else {
StoredRow *sr = NULL;
if (OB_FAIL(StoredRow::build(sr, exprs, *ctx, buf->head(), buf->remain(),
row_extend_size, unswizzling, vector_row_idx))) {
if (OB_BUF_NOT_ENOUGH != ret) {
LOG_WARN("build stored row failed", K(ret));
}
} else if (OB_FAIL(buf->advance(sr->row_size_))) {
LOG_WARN("buffer advance failed", K(ret));
} else {
++rows_;
if (NULL != stored_row) {
*stored_row = sr;
}
}
}
return ret;
}
int ObChunkDatumStore::Block::copy_stored_row(const StoredRow &stored_row, StoredRow **dst_sr)
{
int ret = OB_SUCCESS;
BlockBuffer *buf = get_buffer();
int64_t row_size = stored_row.row_size_;
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf), K(row_size));
} else {
StoredRow *sr = new (buf->head())StoredRow;
sr->assign(&stored_row);
if (OB_FAIL(buf->advance(row_size))) {
LOG_WARN("fill buffer head failed", K(ret), K(buf), K(row_size));
} else {
rows_++;
if (nullptr != dst_sr) {
*dst_sr = sr;
}
}
}
return ret;
}
int ObChunkDatumStore::Block::copy_datums(const ObDatum *datums, const int64_t cnt,
const int64_t extra_size, StoredRow **dst_sr)
{
int ret = OB_SUCCESS;
BlockBuffer *buf = get_buffer();
int64_t head_size = sizeof(StoredRow);
int64_t datum_size = sizeof(ObDatum) * cnt;
int64_t row_size = head_size + sizeof(ObDatum) * cnt + extra_size;
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf), K(row_size));
} else {
StoredRow *sr = new (buf->head())StoredRow;
sr->cnt_ = cnt;
MEMCPY(sr->payload_, static_cast<const void*>(datums), datum_size);
char* data_start = sr->payload_ + datum_size + extra_size;
int64_t pos = 0;
for (int64_t i = 0; i < cnt; ++i) {
MEMCPY(data_start + pos, datums[i].ptr_, datums[i].len_);
sr->cells()[i].ptr_ = data_start + pos;
pos += datums[i].len_;
row_size += datums[i].len_;
}
sr->row_size_ = row_size;
if (OB_FAIL(buf->advance(row_size))) {
LOG_WARN("fill buffer head failed", K(ret), K(buf), K(row_size));
} else {
rows_++;
if (nullptr != dst_sr) {
*dst_sr = sr;
}
}
}
return ret;
}
int ObChunkDatumStore::Block::copy_storage_datums(const blocksstable::ObStorageDatum *storage_datums, const int64_t cnt,
const int64_t extra_size, StoredRow **dst_sr)
{
int ret = OB_SUCCESS;
BlockBuffer *buf = get_buffer();
int64_t head_size = sizeof(StoredRow);
int64_t datum_size = sizeof(ObDatum) * cnt;
int64_t row_size = head_size + sizeof(ObDatum) * cnt + extra_size;
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf), K(row_size));
} else {
StoredRow *sr = new (buf->head())StoredRow;
sr->cnt_ = cnt;
for (int64_t i = 0; i < cnt; ++i) {
const ObDatum *tmp_datum = static_cast<const ObDatum *>(&storage_datums[i]);
MEMCPY(sr->payload_ + i * sizeof(ObDatum), tmp_datum, sizeof(ObDatum));
}
char* data_start = sr->payload_ + datum_size + extra_size;
int64_t pos = 0;
for (int64_t i = 0; i < cnt; ++i) {
MEMCPY(data_start + pos, storage_datums[i].ptr_, storage_datums[i].len_);
sr->cells()[i].ptr_ = data_start + pos;
pos += storage_datums[i].len_;
row_size += storage_datums[i].len_;
}
sr->row_size_ = row_size;
if (OB_FAIL(buf->advance(row_size))) {
LOG_WARN("fill buffer head failed", K(ret), K(buf), K(row_size));
} else {
rows_++;
if (nullptr != dst_sr) {
*dst_sr = sr;
}
}
}
return ret;
}
//the memory of shadow stored row is not continuous,
//so you cannot directly copy the memory of the entire stored row,
//and you should make a deep copy of each datum in turn
int ObChunkDatumStore::Block::add_shadow_stored_row(const StoredRow &stored_row,
const uint32_t row_extend_size,
StoredRow **dst_sr)
{
int ret = OB_SUCCESS;
BlockBuffer *buf = get_buffer();
int64_t row_size = stored_row.row_size_ + row_extend_size;
if (!buf->is_inited()) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(buf), K(row_size));
} else {
StoredRow *sr = new (buf->head()) StoredRow;
char *datum_buf = sr->payload_;
int64_t buf_size = row_size - ROW_HEAD_SIZE;
if (OB_FAIL(sr->copy_shadow_datums(stored_row.cells(), stored_row.cnt_,
datum_buf, buf_size, row_size, row_extend_size))) {
LOG_WARN("copy shadow datums failed", K(ret));
} else if (OB_FAIL(buf->advance(row_size))) {
LOG_WARN("fill buffer head failed", K(ret), K(buf), K(row_size));
} else {
rows_++;
if (nullptr != dst_sr) {
*dst_sr = sr;
}
}
}
return ret;
}
int ObChunkDatumStore::Block::get_store_row(int64_t &cur_pos, const StoredRow *&sr)
{
int ret = OB_SUCCESS;
if (cur_pos >= blk_size_) {
ret = OB_INDEX_OUT_OF_RANGE;
LOG_WARN("invalid index", K(ret), K(cur_pos), K_(rows));
} else {
StoredRow *row = reinterpret_cast<StoredRow *>(&payload_[cur_pos]);
cur_pos += row->row_size_;
sr = row;
}
return ret;
}
int ObChunkDatumStore::Block::gen_unswizzling_payload(char *unswizzling_payload, uint32_t size)
{
int ret = OB_SUCCESS;
int64_t cur_pos = 0;
uint32_t i = 0;
const int64_t payload_size = get_buffer()->head() - payload_;
if (OB_ISNULL(unswizzling_payload) || size < payload_size) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(size), K(payload_size), KP(unswizzling_payload));
} else {
MEMCPY(unswizzling_payload, payload_, payload_size);
}
while (OB_SUCC(ret) && cur_pos < payload_size && i < rows_) {
StoredRow *sr = reinterpret_cast<StoredRow *>(unswizzling_payload + cur_pos);
sr->unswizzling(payload_ + cur_pos);
cur_pos += sr->row_size_;
i++;
}
return ret;
}
int ObChunkDatumStore::Block::unswizzling()
{
int ret = OB_SUCCESS;
int64_t cur_pos = 0;
uint32_t i = 0;
while (OB_SUCC(ret) && cur_pos < blk_size_ && i < rows_) {
StoredRow *sr = reinterpret_cast<StoredRow *>(payload_ + cur_pos);
sr->unswizzling();
cur_pos += sr->row_size_;
i++;
}
return ret;
}
int ObChunkDatumStore::Block::swizzling(int64_t *col_cnt)
{
int ret = OB_SUCCESS;
int64_t cur_pos = 0;
uint32_t i = 0;
StoredRow *sr = NULL;
while (OB_SUCC(ret) && cur_pos < blk_size_ && i < rows_) {
sr = reinterpret_cast<StoredRow *>(&payload_[cur_pos]);
sr->swizzling();
cur_pos += sr->row_size_;
i++;
}
if (OB_SUCC(ret) && NULL != sr && NULL != col_cnt) {
*col_cnt = sr->cnt_;
}
return ret;
}
ObChunkDatumStore::ObChunkDatumStore(const ObLabel &label, common::ObIAllocator *alloc /* = NULL */)
: inited_(false), tenant_id_(0), label_(label),
ctx_id_(0), mem_limit_(0), cur_blk_(NULL), cur_blk_buffer_(nullptr),
max_blk_size_(0), min_blk_size_(INT64_MAX),
default_block_size_(BLOCK_SIZE),
n_blocks_(0), row_cnt_(0), col_count_(-1),
enable_dump_(true), has_dumped_(false), dumped_row_cnt_(0),
io_event_observer_(nullptr), file_size_(0), n_block_in_file_(0),
mem_hold_(0), mem_used_(0), max_hold_mem_(0),
allocator_(NULL == alloc ? &inner_allocator_ : alloc),
row_extend_size_(0), callback_(nullptr), batch_ctx_(NULL),
tmp_dump_blk_(nullptr)
{
io_.fd_ = -1;
io_.dir_id_ = -1;
}
int ObChunkDatumStore::init(int64_t mem_limit,
uint64_t tenant_id /* = common::OB_SERVER_TENANT_ID */,
int64_t mem_ctx_id /* = common::ObCtxIds::DEFAULT_CTX_ID */,
const char *label /* = common::ObModIds::OB_SQL_CHUNK_ROW_STORE) */,
bool enable_dump /* = true */,
uint32_t row_extend_size /* = 0 */,
int64_t default_block_size /* = BLOCK_SIZE */
)
{
int ret = OB_SUCCESS;
enable_dump_ = enable_dump;
tenant_id_ = tenant_id;
ctx_id_ = mem_ctx_id;
UNUSED(label_);
if (0 == GCONF._chunk_row_store_mem_limit) {
mem_limit_ = mem_limit;
} else {
mem_limit_ = GCONF._chunk_row_store_mem_limit;
}
inited_ = true;
default_block_size_ = std::max(static_cast<int64_t>(MIN_BLOCK_SIZE), default_block_size);
max_blk_size_ = default_block_size_;
min_blk_size_ = INT64_MAX;
io_.fd_ = -1;
row_extend_size_ = row_extend_size;
return ret;
}
void ObChunkDatumStore::reset()
{
int ret = OB_SUCCESS;
if (is_file_open()) {
aio_write_handle_.reset();
if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.remove(io_.fd_))) {
LOG_WARN("remove file failed", K(ret), K_(io_.fd));
} else {
LOG_INFO("close file success", K(ret), K_(io_.fd));
}
io_.fd_ = -1;
}
file_size_ = 0;
n_block_in_file_ = 0;
while (!blocks_.is_empty()) {
Block *item = blocks_.remove_first();
mem_hold_ -= item->get_buffer()->mem_size();
mem_used_ -= item->get_buffer()->mem_size();
if (nullptr != callback_) {
callback_->free(item->get_buffer()->mem_size());
}
if (NULL != item) {
allocator_->free(item);
}
}
blocks_.reset();
cur_blk_ = NULL;
cur_blk_buffer_ = nullptr;
free_tmp_dump_blk(); // just in case, not necessary. tmp block always freed instantly after use
while (!free_list_.is_empty()) {
Block *item = free_list_.remove_first();
mem_hold_ -= item->get_buffer()->mem_size();
if (nullptr != callback_) {
callback_->free(item->get_buffer()->mem_size());
}
allocator_->free(item);
}
if (NULL != batch_ctx_) {
allocator_->free(batch_ctx_);
batch_ctx_ = NULL;
}
LOG_DEBUG("mem usage after free", K(mem_hold_), K(mem_used_), K(blocks_.get_size()));
mem_hold_ = 0;
mem_used_ = mem_hold_;
max_blk_size_ = default_block_size_;
n_blocks_ = 0;
row_cnt_ = 0;
}
void *ObChunkDatumStore::alloc_blk_mem(const int64_t size, const bool for_iterator)
{
void *blk = NULL;
int ret = OB_SUCCESS;
if (size < 0) {
LOG_WARN("invalid argument", K(size));
} else {
ObMemAttr attr(tenant_id_, label_, ctx_id_);
void *mem = allocator_->alloc(size, attr);
if (NULL == mem) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("alloc memory failed", K(ret), K(size), KP(mem),
K(label_), K(ctx_id_), K(mem_limit_), K(enable_dump_), K(mem_hold_), K(mem_used_));
} else {
blk = static_cast<char *>(mem);
if (!for_iterator) {
mem_hold_ += size;
max_hold_mem_ = max(max_hold_mem_, mem_hold_);
}
if (nullptr != callback_) {
callback_->alloc(size);
}
}
}
return blk;
}
void ObChunkDatumStore::free_blk_mem(void *mem, const int64_t size /* = 0 */)
{
if (NULL != mem) {
LOG_DEBUG("free blk memory", K(size), KP(mem));
allocator_->free(mem);
mem_hold_ -= size;
if (nullptr != callback_) {
callback_->free(size);
}
}
}
void ObChunkDatumStore::free_block(Block *item)
{
if (NULL != item) {
BlockBuffer* buffer = item->get_buffer();
if (!buffer->is_empty()) {
mem_used_ -= buffer->mem_size();
}
mem_hold_ -= buffer->mem_size();
if (nullptr != callback_) {
callback_->free(buffer->mem_size());
}
allocator_->free(item);
}
}
void ObChunkDatumStore::free_blk_list()
{
Block* item = blocks_.remove_first();
while (item != NULL) {
free_block(item);
item = blocks_.remove_first();
}
blocks_.reset();
}
//free mem of specified size
bool ObChunkDatumStore::shrink_block(int64_t size)
{
int64_t freed_size = 0;
bool succ = false;
int ret = OB_SUCCESS;
if ((0 == blocks_.get_size() && 0 == free_list_.get_size()) || 0 == size) {
LOG_DEBUG("RowStore no need to shrink", K(size), K(blocks_.get_size()));
} else {
Block* item = free_list_.remove_first();
//free those blocks haven't been used yet
while (NULL != item) {
freed_size += item->get_buffer()->mem_size();
LOG_DEBUG("RowStore shrink free empty", K(size), K(freed_size), K_(item->blk_size));
free_block(item);
item = free_list_.remove_first();
}
item = blocks_.remove_first();
while (OB_SUCC(ret) && NULL != item) {
if (OB_FAIL(dump_one_block(item->get_buffer()))) {
LOG_WARN("dump failed when shrink blk", K(ret), K(item),
K(item->get_buffer()->data_size()), K(item->get_buffer()->mem_size()), K(size));
}
dumped_row_cnt_ += item->rows();
// 不论成功与否，都需要释放内存
freed_size += item->get_buffer()->mem_size();
LOG_DEBUG("RowStore shrink dump and free", K(size), K(freed_size),
K(item->get_buffer()->mem_size()), K(item));
free_block(item);
item = blocks_.remove_first();
}
free_tmp_dump_blk();
}
LOG_DEBUG("RowStore shrink_block", K(ret), K(freed_size), K(size));
if (freed_size >= size) {
succ = true;
}
return succ;
}
int ObChunkDatumStore::init_block_buffer(void* mem, const int64_t size, Block *&block)
{
int ret = OB_SUCCESS;
block = new(mem)Block;
BlockBuffer* blkbuf = new(static_cast<char *>(mem) + size - sizeof(BlockBuffer))BlockBuffer;
if (OB_FAIL(blkbuf->init(static_cast<char *>(mem), size))) {
LOG_WARN("init shrink buffer failed", K(ret));
} else {
if (OB_FAIL(blkbuf->advance(sizeof(Block)))) {
LOG_WARN("fill buffer head failed", K(ret), K(static_cast<void*>(blkbuf->data())),
K(sizeof(Block)));
} else {
block->set_block_size(static_cast<uint32_t>(blkbuf->capacity()));
block->next_ = NULL;
block->rows_ = 0;
}
}
return ret;
}
int ObChunkDatumStore::alloc_block_buffer(Block *&block, const int64_t data_size,
const int64_t min_size, const bool for_iterator)
{
int ret = OB_SUCCESS;
int64_t size = std::max(min_size, data_size);
size = next_pow2(size);
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
void *mem = alloc_blk_mem(size, for_iterator);
if (OB_ISNULL(mem)) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("alloc memory failed", K(ret), K(size), K(mem_hold_), K(mem_used_));
} else if (OB_FAIL(ObChunkDatumStore::init_block_buffer(mem, size, block))){
free_blk_mem(mem, size);
} else if (!for_iterator) {
if (size > max_blk_size_) {
max_blk_size_ = size;
}//这里需要同时设置max_blk_size_和min_blk_size
//否则当chunk只add一行的时候min_blk_size是个未初始化的值
if (size < min_blk_size_) {
min_blk_size_ = size;
}
}
LOG_DEBUG("RowStore alloc block",
K(ret), K_(max_blk_size), K(data_size), K(min_size), K(for_iterator));
}
return ret;
}
int ObChunkDatumStore::alloc_block_buffer(Block *&block, const int64_t data_size,
const bool for_iterator)
{
return alloc_block_buffer(block, data_size, default_block_size_, for_iterator);
}
inline int ObChunkDatumStore::dump_one_block(BlockBuffer *item)
{
int ret = OB_SUCCESS;
uint64_t begin_io_dump_time = rdtsc();
int64_t min_block_size = default_block_size_ - sizeof(BlockBuffer);
if (item->cur_pos_ <= 0) {
LOG_WARN("unexpected: dump zero", K(item), K(item->cur_pos_));
}
item->block->magic_ = Block::MAGIC;
if (OB_FAIL(item->get_block()->unswizzling())) {
LOG_WARN("convert block to copyable failed", K(ret));
} else if (item->capacity() < min_block_size) {
if (OB_ISNULL(tmp_dump_blk_)) {
if (OB_FAIL(alloc_block_buffer(tmp_dump_blk_, default_block_size_, false))) {
LOG_WARN("failed to alloc block buffer", K(ret));
}
}
CK(min_block_size == tmp_dump_blk_->get_buffer()->capacity());
if (OB_SUCC(ret)) {
tmp_dump_blk_->get_buffer()->reuse();
tmp_dump_blk_->magic_ = Block::MAGIC;
MEMCPY(tmp_dump_blk_->payload_, item->get_block()->payload_,
item->get_block()->blk_size_);
tmp_dump_blk_->rows_ = item->get_block()->rows_;
tmp_dump_blk_->get_buffer()->fast_advance(item->data_size() - BlockBuffer::HEAD_SIZE);
if (OB_FAIL(write_file(tmp_dump_blk_->get_buffer()->data(),
tmp_dump_blk_->get_buffer()->capacity()))) {
LOG_WARN("write block to file failed");
}
}
} else if (OB_FAIL(write_file(item->data(), item->capacity()))) {
LOG_WARN("write block to file failed");
}
if (OB_SUCC(ret)) {
n_block_in_file_++;
LOG_DEBUG("RowStore Dumpped block", K_(item->block->rows),
K_(item->cur_pos), K(item->capacity()));
}
if (OB_LIKELY(nullptr != io_event_observer_)) {
io_event_observer_->on_write_io(rdtsc() - begin_io_dump_time);
}
return ret;
}
// only clean memory data
int ObChunkDatumStore::clean_memory_data(bool reuse)
{
int ret = OB_SUCCESS;
Block* cur = blocks_.remove_first();
BlockBuffer* buf = NULL;
while (OB_SUCC(ret) && NULL != cur) {
buf = cur->get_buffer();
if (!buf->is_empty()) {
mem_used_ -= buf->mem_size();
row_cnt_ -= cur->rows();
}
if (reuse && buf->mem_size() <= default_block_size_) {
buf->reuse();
free_list_.add_last(cur);
} else {
mem_hold_ -= buf->mem_size();
if (nullptr != callback_) {
callback_->free(buf->mem_size());
}
allocator_->free(cur);
}
cur = blocks_.remove_first();
}
if (mem_used_ != 0 || (!reuse && mem_hold_ != 0) || blocks_.get_size() != 0) {
SQL_ENG_LOG(WARN, "hold mem after clean_memory_data", K_(mem_used), K(reuse), K_(mem_hold),
K(blocks_.get_size()), K(free_list_.get_size()));
}
if (OB_SUCC(ret)) {
cur_blk_ = NULL;
cur_blk_buffer_ = nullptr;
}
return ret;
}
// 添加一种模式，dump时候只dump已经写满的block,剩下最后一个block
int ObChunkDatumStore::dump(bool reuse, bool all_dump, int64_t dumped_size)
{
int ret = OB_SUCCESS;
BlockBuffer* buf = NULL;
if (!enable_dump_) {
ret = OB_EXCEED_MEM_LIMIT;
LOG_DEBUG("ChunkRowStore exceed mem limit and dump is disabled");
// } else if (OB_FAIL(blocks_.prefetch())) {
// LOG_WARN("failed to prefetch", K(ret));
} else {
dumped_size = all_dump ? INT64_MAX : dumped_size;
int64_t n_block = blocks_.get_size();
int64_t tmp_dumped_size = 0;
const int64_t org_n_block = n_block;
Block* cur = nullptr;
while (OB_SUCC(ret) && 0 < n_block && (all_dump || 1 < n_block) && tmp_dumped_size < dumped_size) {
cur = blocks_.remove_first();
--n_block;
if (OB_ISNULL(cur)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("cur block is null", K(ret));
} else {
buf = cur->get_buffer();
int64_t tmp_size = buf->mem_size();
LOG_DEBUG("dumping", K(cur), K(*cur), K(*buf));
if (buf->is_empty() || OB_FAIL(dump_one_block(buf))) {
LOG_WARN("failed to dump block", K(ret));
}
if (!buf->is_empty()) {
mem_used_ -= buf->mem_size();
dumped_row_cnt_ += cur->rows();
}
if (reuse && buf->mem_size() <= default_block_size_) {
buf->reuse();
free_list_.add_last(cur);
} else {
mem_hold_ -= buf->mem_size();
if (nullptr != callback_) {
callback_->free(buf->mem_size());
}
allocator_->free(cur);
}
tmp_dumped_size += tmp_size;
}
}
free_tmp_dump_blk();
if (all_dump && (mem_used_ != 0 || (!reuse && mem_hold_ != 0) || blocks_.get_size() != 0)) {
LOG_WARN("hold mem after dump", K_(mem_used), K(reuse), K_(mem_hold),
K(blocks_.get_size()), K(free_list_.get_size()));
}
if (OB_SUCC(ret)) {
if (all_dump) {
cur_blk_ = NULL;
cur_blk_buffer_ = nullptr;
}
if (!has_dumped_) {
has_dumped_ = (org_n_block != blocks_.get_size());
}
}
LOG_DEBUG("dumped block", K(n_block), K(org_n_block), K(blocks_.get_size()));
}
return ret;
}
bool ObChunkDatumStore::find_block_can_hold(const int64_t size, bool &need_shrink)
{
bool found = false;
need_shrink = false;
if (NULL != cur_blk_ && size <= cur_blk_->get_buffer()->remain()) {
found = true;
} else if (free_list_.get_size() > 0 && default_block_size_ >= size) {
Block* next = free_list_.remove_first();
LOG_DEBUG("reuse block", K(next), K(*next), K(next->get_buffer()), K(*next->get_buffer()));
found = true;
use_block(next);
blocks_.add_last(next);
n_blocks_++;
} else if (mem_limit_ > 0 && mem_hold_ > mem_used_ && mem_hold_ + size > mem_limit_) {
need_shrink = true;
LOG_DEBUG("RowStore need shrink", K(size), K(mem_hold_));
}
return found;
}
int ObChunkDatumStore::switch_block(const int64_t min_size)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (min_size <= 0 || OB_ISNULL(cur_blk_)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), K(min_size));
} else if (need_dump(min_size) && OB_FAIL(dump(true, false, default_block_size_))) {
if (OB_EXCEED_MEM_LIMIT != ret) {
LOG_WARN("got error when dump blocks", K(ret));
}
} else {
LOG_DEBUG("RowStore switch block", K(min_size));
Block *new_block = NULL;
bool need_shrink = false;
bool can_find = find_block_can_hold(min_size, need_shrink);
LOG_DEBUG("RowStore switch block", K(can_find), K(need_shrink), K(min_size));
if (need_shrink) {
if (shrink_block(min_size)) {
LOG_DEBUG("RowStore shrink succ", K(min_size));
}
}
if (!can_find) { // need alloc new block
if (OB_FAIL(alloc_block_buffer(new_block, min_size, false))) {
LOG_WARN("alloc block failed", K(ret), K(min_size), K(new_block));
}
if (!can_find && OB_SUCC(ret)){
blocks_.add_last(new_block);
n_blocks_++;
use_block(new_block);
LOG_DEBUG("RowStore switch block", K(new_block), K(*new_block), K(new_block->get_buffer()),
K(n_blocks_), K(min_size));
}
}
}
return ret;
}
inline int ObChunkDatumStore::ensure_write_blk(const int64_t row_size)
{
int ret = OB_SUCCESS;
if (NULL == cur_blk_) {
Block *new_blk = nullptr;
if (OB_FAIL(alloc_block_buffer(new_blk, Block::min_buf_size(row_size), false))) {
LOG_WARN("alloc block failed", K(ret));
} else {
use_block(new_blk);
blocks_.add_last(cur_blk_);
n_blocks_++;
}
} else if (row_size > cur_blk_buffer_->remain()) {
if (OB_FAIL(switch_block(Block::min_buf_size(row_size))) && OB_EXCEED_MEM_LIMIT != ret) {
LOG_WARN("switch block failed", K(ret), K(row_size));
}
}
return ret;
}
int ObChunkDatumStore::add_row(const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx,
const int64_t row_size, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (OB_FAIL(ensure_write_blk(row_size))) {
LOG_WARN("ensure write blk failed", K(ret));
} else if (OB_FAIL(cur_blk_->add_row(exprs, *ctx, row_size, row_extend_size_, stored_row))) {
LOG_WARN("add row to block failed", K(ret), K(row_size));
} else {
row_cnt_++;
if (OB_UNLIKELY(0 > col_count_)) {
col_count_ = exprs.count();
}
}
return ret;
}
int ObChunkDatumStore::add_row(
const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
if (NULL == cur_blk_) {
int64_t min_buf_size = 0;
Block *new_blk = nullptr;
if (OB_FAIL(Block::min_buf_size(exprs, row_extend_size_, *ctx, min_buf_size))) {
} else if (OB_FAIL(alloc_block_buffer(new_blk, min_buf_size, false))) {
LOG_WARN("alloc block failed", K(ret));
} else {
use_block(new_blk);
blocks_.add_last(cur_blk_);
n_blocks_++;
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(cur_blk_->append_row(
exprs, ctx, cur_blk_buffer_, row_extend_size_, stored_row, false))) {
if (OB_BUF_NOT_ENOUGH == ret) {
int64_t min_buf_size = 0;
if (OB_FAIL(Block::min_buf_size(exprs, row_extend_size_, *ctx, min_buf_size))) {
} else if (OB_FAIL(switch_block(min_buf_size))) {
if (OB_EXCEED_MEM_LIMIT != ret) {
LOG_WARN("switch block failed", K(ret));
}
} else if (OB_FAIL(cur_blk_->append_row(
exprs, ctx, cur_blk_buffer_, row_extend_size_, stored_row, false))) {
} else {
row_cnt_++;
if (OB_UNLIKELY(0 > col_count_)) {
col_count_ = exprs.count();
}
}
} else {
LOG_WARN("add row to block failed", K(ret));
}
} else {
row_cnt_++;
if (OB_UNLIKELY(0 > col_count_)) {
col_count_ = exprs.count();
}
}
}
}
return ret;
}
int ObChunkDatumStore::try_add_row(const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx,
const int64_t memory_limit, bool &row_added)
{
int ret = OB_SUCCESS;
int64_t row_size = 0;
if (OB_FAIL(Block::row_store_size(exprs, *ctx, row_size, row_extend_size_))) {
LOG_WARN("failed to calc store size");
} else if (row_size + get_mem_used() > memory_limit) {
row_added = false;
} else if (OB_FAIL(add_row(exprs, ctx, row_size, NULL))) {
LOG_WARN("add row failed", K(ret));
} else {
row_added = true;
}
return ret;
}
int ObChunkDatumStore::try_add_row(const ShadowStoredRow &sr,
const int64_t memory_limit,
bool &row_added,
StoredRow **stored_sr)
{
int ret = OB_SUCCESS;
const StoredRow *real_sr = sr.get_store_row();
int64_t row_size = sr.get_store_row()->row_size_;
if (row_size + get_mem_used() > memory_limit) {
row_added = false;
} else if (OB_FAIL(add_row(sr, stored_sr))) {
LOG_WARN("add row failed", K(ret));
} else {
row_added = true;
}
return ret;
}
int ObChunkDatumStore::try_add_row(const StoredRow &sr, const int64_t memory_limit, bool &row_added)
{
int ret = OB_SUCCESS;
int64_t row_size = sr.row_size_;
if (row_size + get_mem_used() > memory_limit) {
row_added = false;
} else if (OB_FAIL(add_row(sr))) {
LOG_WARN("add row failed", K(ret));
} else {
row_added = true;
}
return ret;
}
int ObChunkDatumStore::try_add_batch(const StoredRow ** stored_rows,
const int64_t batch_size,
const int64_t memory_limit,
bool &batch_added)
{
int ret = OB_SUCCESS;
int64_t rows_size = 0;
batch_added = false;
for (int64_t i = 0; OB_SUCC(ret) && i < batch_size; ++i) {
rows_size += stored_rows[i]->row_size_;
}
if (OB_FAIL(ret)) {
// do nothing
} else if (rows_size + get_mem_used() > memory_limit) {
batch_added = false;
} else {
for (int64_t i = 0; OB_SUCC(ret) && i < batch_size; ++i) {
if (OB_FAIL(add_row(*stored_rows[i]))) {
LOG_WARN("add row failed", KR(ret), K(i));
}
}
if (OB_SUCC(ret)) {
batch_added = true;
}
}
return ret;
}
int ObChunkDatumStore::try_add_batch(const common::ObIArray<ObExpr*> &exprs, ObEvalCtx *ctx,
const int64_t batch_size, const int64_t memory_limit,
bool &batch_added)
{
int ret = OB_SUCCESS;
int64_t rows_size = 0;
{
ObEvalCtx::BatchInfoScopeGuard guard(*ctx);
guard.set_batch_idx(0);
for (int64_t i = 0; OB_SUCC(ret) && i < batch_size; ++i) {
int64_t curr_size = 0;
guard.set_batch_idx(i);
if (OB_FAIL(Block::row_store_size(exprs, *ctx, curr_size, row_extend_size_))) {
LOG_WARN("failed to calc store size", K(ret), K(i));
} else {
rows_size += curr_size;
}
}
}
if (OB_FAIL(ret)) {
} else if (rows_size + get_mem_used() > memory_limit) {
batch_added = false;
} else {
int64_t count = 0;
ObEvalCtx::TempAllocGuard alloc_guard(*ctx);
ObIAllocator &alloc = alloc_guard.get_allocator();
void *mem = nullptr;
if (OB_ISNULL(mem = alloc.alloc(ObBitVector::memory_size(batch_size)))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("failed to alloc memory for skip", K(ret), K(batch_size), K(mem_hold_), K(mem_used_));
} else {
ObBitVector *skip = to_bit_vector(mem);
skip->reset(batch_size);
if (OB_FAIL(add_batch(exprs, *ctx, *skip, batch_size, count))) {
LOG_WARN("failed to add batch", K(ret));
} else {
batch_added = true;
}
}
}
return ret;
}
// 该函数用于适配ObSortOpImpl::add_row()这个模板函数
int ObChunkDatumStore::add_row(
const StoredRow &src_stored_row, ObEvalCtx *eval_ctx, StoredRow **stored_row)
{
UNUSED(eval_ctx);
return add_row(src_stored_row, stored_row);
}
/*
* 从ObChunkDatumStore读出数据，然后再写入ObChunkDatumStore时，使用copy_row
* 从operator的ObExpr的ObDatum中写入到ObChunkDatumStore时，使用add_row
* 理论上只有这两个接口
*/
int ObChunkDatumStore::add_row(
const StoredRow &src_stored_row, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
const int64_t row_size = src_stored_row.row_size_;
if (OB_FAIL(ensure_write_blk(row_size))) {
LOG_WARN("ensure write block failed", K(ret));
} else if (OB_FAIL(cur_blk_->copy_stored_row(src_stored_row, stored_row))) {
LOG_WARN("add row to block failed", K(ret), K(src_stored_row), K(row_size));
} else {
row_cnt_++;
if (col_count_ < 0) {
col_count_ = src_stored_row.cnt_;
}
}
}
return ret;
}
int ObChunkDatumStore::add_row(const ObDatum *datums, const int64_t cnt,
const int64_t extra_size, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
int64_t head_size = sizeof(StoredRow);
int64_t datum_size = sizeof(ObDatum) * cnt;
int64_t data_size = 0;
for (int64_t i = 0; i < cnt; ++i) {
data_size += datums[i].len_;
}
const int64_t row_size = head_size + datum_size + extra_size + data_size;
if (OB_FAIL(ensure_write_blk(row_size))) {
LOG_WARN("ensure write block failed", K(ret));
} else if (OB_FAIL(cur_blk_->copy_datums(datums, cnt, extra_size, stored_row))) {
LOG_WARN("add row to block failed", K(ret), K(datums), K(cnt), K(extra_size), K(row_size));
} else {
row_cnt_++;
if (col_count_ < 0) {
col_count_ = cnt;
}
}
}
return ret;
}
int ObChunkDatumStore::add_row(const blocksstable::ObStorageDatum *storage_datums, const int64_t cnt,
const int64_t extra_size, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
int64_t head_size = sizeof(StoredRow);
int64_t datum_size = sizeof(ObDatum) * cnt;
int64_t data_size = 0;
for (int64_t i = 0; i < cnt; ++i) {
data_size += storage_datums[i].len_;
}
const int64_t row_size = head_size + datum_size + extra_size + data_size;
if (OB_FAIL(ensure_write_blk(row_size))) {
LOG_WARN("ensure write block failed", K(ret));
} else if (OB_FAIL(cur_blk_->copy_storage_datums(storage_datums, cnt, extra_size, stored_row))) {
LOG_WARN("add row to block failed", K(ret), K(storage_datums), K(cnt), K(extra_size), K(row_size));
} else {
row_cnt_++;
if (col_count_ < 0) {
col_count_ = cnt;
}
}
}
return ret;
}
int ObChunkDatumStore::add_row(const ShadowStoredRow &sr, StoredRow **stored_row)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else {
const StoredRow *lsr = sr.get_store_row();
const int64_t row_size = lsr->row_size_ + row_extend_size_;
if (OB_FAIL(ensure_write_blk(row_size))) {
LOG_WARN("ensure write block failed", K(ret));
} else if (OB_FAIL(cur_blk_->add_shadow_stored_row(*lsr, row_extend_size_, stored_row))) {
LOG_WARN("add row to block failed", K(ret), KPC(lsr), K(row_size));
} else {
row_cnt_++;
if (col_count_ < 0) {
col_count_ = lsr->cnt_;
}
}
}
return ret;
}
int ObChunkDatumStore::add_batch(
const common::ObIArray<ObExpr *> &exprs, ObEvalCtx &ctx,
const ObBitVector &skip, const int64_t batch_size,
int64_t &stored_rows_count,
StoredRow **stored_rows,
const int64_t start_pos /* 0 */)
{
int ret = OB_SUCCESS;
// FIXME bin.lb: adapt to selector version currently,
// may be need an optimized implementation for no skip.
CK(is_inited());
OZ(init_batch_ctx(exprs.count(), ctx.max_batch_size_));
int64_t size = 0;
if (OB_SUCC(ret)) {
for (int64_t i = start_pos; i < batch_size; i++) {
if (skip.at(i)) {
continue;
} else {
batch_ctx_->selector_[size++] = i;
}
}
}
if (OB_SUCC(ret)) {
stored_rows_count = size;
if (OB_FAIL(add_batch(exprs, ctx, skip, batch_size,
batch_ctx_->selector_, size, stored_rows))) {
LOG_WARN("add batch failed");
}
}
return ret;
}
int ObChunkDatumStore::add_batch(const common::ObIArray<ObExpr *> &exprs, ObEvalCtx &ctx,
const ObBitVector &skip, const int64_t batch_size,
const uint16_t selector[], const int64_t size,
StoredRow **stored_rows)
{
int ret = OB_SUCCESS;
CK(is_inited());
OZ(init_batch_ctx(exprs.count(), ctx.max_batch_size_));
const bool reuse_block = true;
const bool dump_last_block = false;
if (OB_SUCC(ret) && need_dump(0) && OB_FAIL(dump(reuse_block, dump_last_block))) {
LOG_WARN("dump failed", K(ret));
}
DisableDumpGuard disable_dump(*this);
bool all_batch_res = true;
for (int64_t i = 0; i < exprs.count() && OB_SUCC(ret); i++) {
ObExpr *e = exprs.at(i);
if (OB_ISNULL(e)) {
batch_ctx_->datums_[i] = nullptr;
} else if (OB_FAIL(e->eval_batch(ctx, skip, batch_size))) {
LOG_WARN("evaluate batch failed", K(ret));
} else {
if (!e->is_batch_result()) {
all_batch_res = false;
break;
} else {
batch_ctx_->datums_[i] = e->locate_batch_datums(ctx);
}
}
}
if (OB_SUCC(ret) && !all_batch_res) {
if (OB_FAIL(add_batch_fallback(exprs, ctx, skip, batch_size, selector, size, stored_rows))) {
LOG_WARN("add batch fallback failed", K(batch_size), K(size));
}
}
if (OB_SUCC(ret) && all_batch_res) {
if (OB_FAIL(inner_add_batch(batch_ctx_->datums_, exprs, selector, size,
NULL == stored_rows ? batch_ctx_->stored_rows_ : stored_rows))) {
LOG_WARN("inner add batch failed", K(ret), K(batch_size), K(size));
}
}
return ret;
}
template <typename T>
static void assign_datums(const ObDatum **datums, const uint16_t selector[], const int64_t size,
ObChunkDatumStore::StoredRow **stored_rows, int64_t col_idx)
{
const ObDatum *cur_datums = datums[col_idx];
for (int64_t i = 0; i < size; i++) {
ObChunkDatumStore::StoredRow *srow = stored_rows[i];
const ObDatum &src = cur_datums[selector[i]];
ObDatum &dst = srow->cells()[col_idx];
dst.pack_ = src.pack_;
dst.ptr_ = reinterpret_cast<char *>(srow) + srow->row_size_;
if (!src.is_null()) {
T::assign_datum_value((void *)dst.ptr_, src.ptr_, src.len_);
}
srow->row_size_ += src.len_;
}
}
int ObChunkDatumStore::inner_add_batch(const ObDatum **datums,
const common::ObIArray<ObExpr *> &exprs,
const uint16_t selector[],
const int64_t size, StoredRow **stored_rows)
{
int ret = OB_SUCCESS;
// calc row size
uint32_t *size_array = batch_ctx_->row_size_array_;
int64_t col_cnt = exprs.count();
const int64_t base_row_size = Block::ROW_HEAD_SIZE
+ sizeof(ObDatum) * col_cnt + row_extend_size_;
for (int64_t i = 0; i < size; i++) {
size_array[i] = base_row_size;
}
for (int64_t col_idx = 0; col_idx < col_cnt; col_idx++) {
if (OB_ISNULL(datums[col_idx])) {
continue;
}
const ObDatum *cur_datums = datums[col_idx];
for (int64_t i = 0; i < size; i++) {
size_array[i] += cur_datums[selector[i]].len_;
}
}
// allocate block and assign stored rows
int64_t idx = 0;
while (idx < size && OB_SUCC(ret)) {
if (OB_FAIL(ensure_write_blk(size_array[idx]))) {
LOG_WARN("ensure write block failed", K(ret), K(size_array[idx]), K(col_cnt), K(size));
for (int64_t col_idx = 0; col_idx < col_cnt; col_idx++) {
if (OB_ISNULL(datums[col_idx])) {
continue;
}
const ObDatum *cur_datums = datums[col_idx];
}
} else {
int64_t data_size = 0;
const int64_t remain = cur_blk_buffer_->remain();
char *buf = cur_blk_buffer_->head();
int64_t rows = 0;
for (int64_t i = idx; i < size; i++) {
if (data_size + size_array[i] <= remain) {
StoredRow *srow = reinterpret_cast<StoredRow *>(buf + data_size);
stored_rows[i] = srow;
srow->cnt_ = col_cnt;
srow->row_size_ = base_row_size;
rows += 1;
data_size += size_array[i];
} else {
break;
}
}
cur_blk_buffer_->fast_advance(data_size);
cur_blk_->rows_ += rows;
idx += rows;
}
}
// copy data
// FIXME bin.lb:
// 1. try row style loop?
if (OB_SUCC(ret)) {
for (int64_t col_idx = 0; col_idx < col_cnt; col_idx++) {
if (OB_ISNULL(exprs.at(col_idx))) {
for (int64_t i = 0; i < size; i++) {
stored_rows[i]->cells()[col_idx].set_null();
}
continue;
}
ObObjType meta_type = exprs.at(col_idx)->datum_meta_.type_;
const ObObjDatumMapType datum_map_type = ObDatum::get_obj_datum_map_type(meta_type);
switch (datum_map_type) {
case OBJ_DATUM_NUMBER:
assign_datums<AssignNumberDatumValue>(datums, selector, size, stored_rows, col_idx);
break;
case OBJ_DATUM_DECIMALINT:
switch (get_decimalint_type(exprs.at(col_idx)->datum_meta_.precision_)) {
case DECIMAL_INT_32:
assign_datums<AssignFixedLenDatumValue<4>>(datums, selector, size, stored_rows, col_idx);
break;
case DECIMAL_INT_64:
assign_datums<AssignFixedLenDatumValue<8>>(datums, selector, size, stored_rows, col_idx);
break;
case DECIMAL_INT_128:
assign_datums<AssignFixedLenDatumValue<16>>(datums, selector, size, stored_rows, col_idx);
break;
case DECIMAL_INT_256:
assign_datums<AssignFixedLenDatumValue<32>>(datums, selector, size, stored_rows, col_idx);
break;
case DECIMAL_INT_512:
assign_datums<AssignFixedLenDatumValue<64>>(datums, selector, size, stored_rows, col_idx);
break;
default:
assign_datums<AssignDefaultDatumValue>(datums, selector, size, stored_rows, col_idx);
break;
}
break;
case OBJ_DATUM_8BYTE_DATA:
assign_datums<AssignFixedLenDatumValue<8>>(datums, selector, size, stored_rows, col_idx);
break;
case OBJ_DATUM_4BYTE_DATA:
assign_datums<AssignFixedLenDatumValue<4>>(datums, selector, size, stored_rows, col_idx);
break;
case OBJ_DATUM_1BYTE_DATA:
assign_datums<AssignFixedLenDatumValue<1>>(datums, selector, size, stored_rows, col_idx);
break;
default:
assign_datums<AssignDefaultDatumValue>(datums, selector, size, stored_rows, col_idx);
break;
}
}
}
if (OB_SUCC(ret)) {
row_cnt_ += size;
}
#ifndef NDEBUG
if (OB_SUCC(ret)) {
for (int64_t i = 0; i < size; i++) {
if (size_array[i] != stored_rows[i]->row_size_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("row size not match", K(ret), K(i),
K(size_array[i]), K(stored_rows[i]->row_size_));
}
}
}
#endif
return ret;
}
int ObChunkDatumStore::add_batch_fallback(
const common::ObIArray<ObExpr *> &exprs, ObEvalCtx &ctx,
const ObBitVector &, const int64_t batch_size,
const uint16_t selector[], const int64_t size,
StoredRow **stored_rows)
{
int ret = OB_SUCCESS;
ObEvalCtx::BatchInfoScopeGuard batch_info_guard(ctx);
batch_info_guard.set_batch_size(batch_size);
for (int64_t i = 0; i < size && OB_SUCC(ret); i++) {
int64_t idx = selector[i];
batch_info_guard.set_batch_idx(idx);
StoredRow *srow = NULL;
if (OB_FAIL(add_row(exprs, &ctx, &srow))) {
LOG_WARN("add row failed", K(ret), K(i), K(idx));
} else {
if (NULL != stored_rows) {
stored_rows[i] = srow;
}
}
}
return ret;
}
int ObChunkDatumStore::finish_add_row(bool need_dump)
{
int ret = OB_SUCCESS;
int64_t timeout_ms = 0;
if (free_list_.get_size() > 0) {
Block *block = free_list_.remove_first();
while (NULL != block) {
mem_hold_ -= block->get_buffer()->mem_size();
if (nullptr != callback_) {
callback_->free(block->get_buffer()->mem_size());
}
allocator_->free(block);
block = free_list_.remove_first();
}
free_list_.reset();
}
if (is_file_open()) {
if (need_dump && OB_FAIL(dump(false, true)) && OB_EXCEED_MEM_LIMIT != ret) {
LOG_WARN("finish_add_row dump error", K(ret));
} else {
uint64_t begin_io_dump_time = rdtsc();
if (OB_FAIL(get_timeout(timeout_ms))) {
LOG_WARN("get timeout failed", K(ret));
} else if (OB_FAIL(aio_write_handle_.wait())) { // last buffer
LOG_WARN("failed to wait write", K(ret));
} else if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.sync(io_.fd_, timeout_ms))) {
LOG_WARN("sync file failed", K(ret), K_(io_.fd), K(timeout_ms));
}
if (OB_LIKELY(nullptr != get_io_event_observer())) {
get_io_event_observer()->on_write_io(rdtsc() - begin_io_dump_time);
}
}
} else {
LOG_DEBUG("finish_add_row no need to dump", K(ret));
}
return ret;
}
//add block manually, this block must be initialized by init_block_buffer()
//and must be removed by remove_added_block before ObChunkDatumStore<>::reset()
int ObChunkDatumStore::add_block(Block* block, bool need_swizzling, bool *added)
{
int ret = OB_SUCCESS;
int64_t col_cnt = 0;
bool need_add = true;
if (need_swizzling) {
//for iterate
if (block->rows_ <= 0) {
need_add = false;
} else if (OB_FAIL(block->swizzling(&col_cnt))) {
LOG_WARN("add block failed", K(block), K(need_swizzling));
} else if (-1 != this->col_count_ && this->col_count_ != col_cnt) {
LOG_WARN("add block failed col cnt not match", K(block), K(need_swizzling),
K(col_cnt), K_(col_count));
}
}
if (need_add) {
this->row_cnt_ += block->rows_;
this->n_blocks_++;
if (nullptr != added) {
*added = true;
}
blocks_.add_last(block);
if (NULL == cur_blk_) {
//cur_blk_ point to the first added block
cur_blk_ = block;
cur_blk_buffer_ = cur_blk_->get_buffer();
}
}
return ret;
}
int ObChunkDatumStore::append_block(char *buf, int size, bool need_swizzling)
{
int ret = OB_SUCCESS;
Block *src_block = reinterpret_cast<Block*>(buf);
int64_t block_data_size = size;
Block *new_block = nullptr;
bool added = false;
int64_t actual_size = block_data_size + sizeof(BlockBuffer);
if (OB_FAIL(alloc_block_buffer(new_block, actual_size, actual_size, false))) {
LOG_WARN("failed to alloc block buffer", K(ret));
} else {
MEMCPY(new_block->payload_, src_block->payload_, block_data_size - sizeof(Block));
new_block->rows_ = src_block->rows_;
BlockBuffer *block_buffer = new_block->get_buffer();
use_block(new_block);
if (block_data_size == sizeof(Block)) {
// 空block，忽略
free_blk_mem(new_block, block_buffer->mem_size());
} else if (OB_FAIL(block_buffer->advance(block_data_size - sizeof(Block)))) {
LOG_WARN("failed to advanced buffer", K(ret));
} else if (block_buffer->data_size() != block_data_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status: data size is not match", K(ret),
K(block_buffer->data_size()), K(block_data_size));
} else if (OB_FAIL(add_block(new_block, need_swizzling, &added))) {
LOG_WARN("fail to add block", K(ret));
} else {
LOG_TRACE("trace append block", K(src_block->rows_), K(size), K(mem_used_), K(mem_hold_));
}
if (OB_FAIL(ret) && !added) {
free_blk_mem(new_block, block_buffer->mem_size());
}
}
// dump data if mem used > 16MB
const int64_t dump_threshold = 1 << 24;
if (OB_SUCC(ret) && mem_used_ > dump_threshold) {
if (OB_FAIL(dump(false /* reuse */, true /* all_dump */))) {
LOG_WARN("dump failed", K(ret));
}
}
return ret;
}
// Append part of a block. Only payload is given, without Block header.
int ObChunkDatumStore::append_block_payload(char *payload, int size, int rows, bool need_swizzling)
{
int ret = OB_SUCCESS;
int64_t block_data_size = size + sizeof(Block);
Block *new_block = nullptr;
bool added = false;
int64_t actual_size = block_data_size + sizeof(BlockBuffer);
if (OB_FAIL(alloc_block_buffer(new_block, actual_size, actual_size, false))) {
LOG_WARN("failed to alloc block buffer", K(ret));
} else {
MEMCPY(new_block->payload_, payload, block_data_size - sizeof(Block));
new_block->rows_ = rows;
BlockBuffer *block_buffer = new_block->get_buffer();
use_block(new_block);
if (block_data_size == sizeof(Block)) {
// 空block，忽略
free_blk_mem(new_block, block_buffer->mem_size());
} else if (OB_FAIL(block_buffer->advance(block_data_size - sizeof(Block)))) {
LOG_WARN("failed to advanced buffer", K(ret));
} else if (block_buffer->data_size() != block_data_size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status: data size is not match", K(ret),
K(block_buffer->data_size()), K(block_data_size));
} else if (OB_FAIL(add_block(new_block, need_swizzling, &added))) {
LOG_WARN("fail to add block", K(ret));
} else {
LOG_TRACE("trace append block", K(rows), K(size), K(mem_used_), K(mem_hold_));
}
if (OB_FAIL(ret) && !added) {
free_blk_mem(new_block, block_buffer->mem_size());
}
}
// dump data if mem used > 1MB
// This function is called when use px_batch_rescan, which may write a lot of dtl interm results,
// so the threshold is smaller.
const int64_t dump_threshold = 1 << 20;
if (OB_SUCC(ret) && mem_used_ > dump_threshold) {
if (OB_FAIL(dump(false /* reuse */, true /* all_dump */))) {
LOG_WARN("dump failed", K(ret));
}
}
return ret;
}
void ObChunkDatumStore::remove_added_blocks()
{
blocks_.reset();
n_blocks_ = 0;
row_cnt_ = 0;
}
int ObChunkDatumStore::get_store_row(RowIterator &it, const StoredRow *&sr)
{
int ret = OB_SUCCESS;
if (!is_inited() || NULL == it.cur_iter_blk_) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret), K_(it.cur_iter_blk));
} else {
if (OB_UNLIKELY(!it.cur_blk_has_next())) {
if (OB_UNLIKELY(Block::MAGIC == it.cur_iter_blk_->magic_)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid next ptr", K(ret), K(common::lbt()));
} else if (it.cur_iter_blk_->get_next() != NULL) {
it.cur_iter_blk_ = it.cur_iter_blk_->get_next();
it.cur_row_in_blk_ = 0;
it.cur_pos_in_blk_ = 0;
it.cur_nth_block_++;
} else if (it.cur_nth_block_ != it.n_blocks_ - 1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("load block failed", K(ret), K_(it.cur_row_in_blk), K_(it.cur_pos_in_blk),
K_(it.cur_nth_block), K_(it.n_blocks));
} else {
ret = OB_ITER_END;
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(it.cur_iter_blk_->get_store_row(it.cur_pos_in_blk_, sr))) {
LOG_WARN("get row from block failed", K(ret), K_(it.cur_row_in_blk),
K(*it.cur_iter_blk_));
} else {
it.cur_row_in_blk_++;
}
}
}
return ret;
}
////////////////////////////////////////////////////////////////
ObChunkDatumStore::RowIterator::RowIterator()
: store_(NULL),
cur_iter_blk_(NULL),
cur_row_in_blk_(0),
cur_pos_in_blk_(0),
n_blocks_(0),
cur_nth_block_(0)
{
}
ObChunkDatumStore::RowIterator::RowIterator(ObChunkDatumStore *row_store)
: store_(row_store),
cur_iter_blk_(NULL),
cur_row_in_blk_(0),
cur_pos_in_blk_(0),
n_blocks_(0),
cur_nth_block_(0)
{
}
int ObChunkDatumStore::RowIterator::init(ObChunkDatumStore *store)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(store)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret));
} else {
store_ = store;
}
return ret;
}
int ObChunkDatumStore::Iterator::init(ObChunkDatumStore *store,
const IterationAge *age /* = NULL */)
{
reset();
int ret = OB_SUCCESS;
store_ = store;
age_ = age;
default_block_size_ = store->default_block_size_;
if (OB_FAIL(row_it_.init(store))) {
LOG_WARN("row iterator init failed", K(ret));
}
return ret;
}
/*
* from StoredRow to NewRow
* 这里暂时没有对datums的有效性做检查，理论上需要传入datums的个数cnt
*/
int ObChunkDatumStore::Iterator::convert_to_row(const StoredRow *sr, common::ObDatum **datums)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(sr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status: store row is null", K(ret));
} else {
for (uint32_t i = 0; i < sr->cnt_; ++i) {
*datums[i] = sr->cells()[i];
}
}
return ret;
}
/*
* 上层operator直接传入需要计算的ObExpr来获取ObDatum
*/
int ObChunkDatumStore::Iterator::get_next_row(const common::ObIArray<ObExpr*> &exprs,
ObEvalCtx &ctx,
const StoredRow **sr/*NULL*/)
{
int ret = OB_SUCCESS;
const StoredRow *tmp_sr = NULL;
if (OB_FAIL(get_next_row(tmp_sr))) {
if (OB_ITER_END != ret) {
LOG_WARN("get next stored row failed", K(ret));
}
} else if (OB_FAIL(convert_to_row(tmp_sr, exprs, ctx))) {
LOG_WARN("convert row failed", K(ret), K_(row_it));
} else if (NULL != sr) {
*sr = tmp_sr;
}
return ret;
}
/*
* 上层operator等，通过绑定ObExpr的ObDatum或者构造ObDatum的数组
* 当获取到一行时，直接写入datums，这样上层就可以直接拿到数据，对于operator由于已经指向了真是地址
* 所以相当于写入了数据，不需要额外再做处理
*/
int ObChunkDatumStore::Iterator::get_next_row(common::ObDatum **datums)
{
int ret = OB_SUCCESS;
const StoredRow *sr = NULL;
if (nullptr == datums) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("invalid argments: datums is null", K(datums), K(ret));
} else if (OB_FAIL(get_next_row(sr))) {
if (OB_ITER_END != ret) {
LOG_WARN("get next stored row failed", K(ret));
}
} else if (OB_FAIL(convert_to_row(sr, datums))) {
LOG_WARN("convert row failed", K(ret), K_(row_it));
}
return ret;
}
/*
* 直接获取这行数据的原始datum，没有添加任何修饰
* 可以通过convert_to_row将 StoredRow 转化成 Datums 数据
*/
int ObChunkDatumStore::Iterator::get_next_row(const StoredRow *&sr)
{
int ret = OB_SUCCESS;
if (!start_iter_) {
if (OB_FAIL(load_next_block(row_it_))) {
if (OB_ITER_END != ret) {
LOG_WARN("Iterator load chunk failed", K(ret));
}
} else {
start_iter_ = true;
}
}
if (OB_SUCC(ret) && OB_FAIL(row_it_.get_next_row(sr))) {
if (OB_ITER_END == ret) {
if (OB_FAIL(load_next_block(row_it_))) {
if (OB_ITER_END != ret) {
LOG_WARN("Iterator load chunk failed", K(ret));
}
} else if (OB_FAIL(row_it_.get_next_row(sr))) {
LOG_WARN("get next row failed", K(ret));
}
}
}
return ret;
}
int ObChunkDatumStore::Iterator::get_next_batch(const StoredRow **rows,
const int64_t max_rows,
int64_t &read_rows)
{
int ret = OB_SUCCESS;
if (NULL == rows || max_rows <= 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), KP(rows), K(read_rows));
} else {
if (!start_iter_) {
if (OB_FAIL(load_next_block(row_it_))) {
if (OB_ITER_END != ret) {
LOG_WARN("Iterator load chunk failed", K(ret));
}
} else {
start_iter_ = true;
}
}
}
if (OB_SUCC(ret)) {
// free cached blocks first, which are cached for previous batch
begin_new_batch();
for (read_rows = 0; read_rows < max_rows && OB_SUCC(ret); ) {
int64_t tmp_read_rows = 0;
if (OB_FAIL(row_it_.get_next_batch(rows + read_rows,
max_rows - read_rows,
tmp_read_rows))) {
if (OB_ITER_END == ret) {
read_rows += tmp_read_rows;
if (NULL == chunk_mem_ || 0 == read_rows + tmp_read_rows) {
// read next block if not in chunk iterate and already got row.
if (OB_FAIL(load_next_block(row_it_))) {
if (OB_ITER_END != ret) {
LOG_WARN("Iterator load chunk failed", K(ret));
}
}
}
} else {
LOG_WARN("read row failed", K(ret));
}
} else {
read_rows += tmp_read_rows;
}
}
// return success if got row
if (OB_ITER_END == ret && read_rows != 0) {
ret = OB_SUCCESS;
}
}
return ret;
};
int ObChunkDatumStore::RowIterator::convert_to_row(
const StoredRow *sr, const common::ObIArray<ObExpr*> &exprs, ObEvalCtx &ctx)
{
int ret = OB_SUCCESS;
if (OB_ISNULL(sr)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status: store row is null", K(ret));
} else if (OB_FAIL(sr->to_expr(exprs, ctx))) {
LOG_WARN("convert store row to expr value failed", K(ret));
}
return ret;
}
int ObChunkDatumStore::RowIterator::get_next_row(const StoredRow *&sr)
{
int ret = OB_SUCCESS;
if (OB_FAIL(store_->get_store_row(*this, sr))) {
if (OB_ITER_END != ret) {
LOG_WARN("get store row failed", K(ret), K_(cur_nth_block), K_(cur_pos_in_blk),
K_(cur_row_in_blk));
}
}
return ret;
}
int ObChunkDatumStore::RowIterator::get_next_batch(const StoredRow **rows,
const int64_t max_rows, int64_t &read_rows)
{
int ret = OB_SUCCESS;
read_rows = 0;
if (NULL == rows || max_rows <= 0) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(ret), KP(rows), K(read_rows));
} else {
while (read_rows < max_rows && OB_SUCC(ret)) {
if (OB_FAIL(get_next_row(rows[read_rows]))) {
if (OB_ITER_END != ret) {
LOG_WARN("read row failed", K(ret));
}
} else {
read_rows += 1;
}
}
}
if (OB_ITER_END == ret && read_rows != 0) {
ret = OB_SUCCESS;
}
return ret;
}
int ObChunkDatumStore::RowIterator::get_next_batch(const common::ObIArray<ObExpr*> &exprs,
ObEvalCtx &ctx, const int64_t max_rows, int64_t &read_rows, const StoredRow **rows)
{
int ret = OB_SUCCESS;
read_rows = 0;
if (OB_FAIL(get_next_batch(rows, max_rows, read_rows))) {
if (OB_ITER_END != ret) {
LOG_WARN("get next batch failed", K(ret), K(max_rows));
}
}
if (OB_SUCC(ret)) {
for (int64_t col_idx = 0; col_idx < exprs.count(); col_idx++) {
ObExpr *e = exprs.at(col_idx);
if (e->is_const_expr()) {
continue;
} else {
ObDatum *datums = e->locate_batch_datums(ctx);
if (!e->is_batch_result()) {
datums[0] = rows[0]->cells()[col_idx];
} else {
for (int64_t i = 0; i < read_rows; i++) {
datums[i] = rows[i]->cells()[col_idx];
}
}
e->set_evaluated_projected(ctx);
ObEvalInfo &info = e->get_eval_info(ctx);
info.notnull_ = false;
info.point_to_frame_ = false;
}
}
}
return ret;
}
int ObChunkDatumStore::get_timeout(int64_t &timeout_ms)
{
int ret = OB_SUCCESS;
const int64_t timeout_us = THIS_WORKER.get_timeout_remain();
if (timeout_us / 1000 <= 0) {
ret = OB_TIMEOUT;
LOG_WARN("query is timeout", K(ret), K(timeout_us));
} else {
timeout_ms = timeout_us / 1000;
}
return ret;
}
int ObChunkDatumStore::alloc_dir_id()
{
int ret = OB_SUCCESS;
if (-1 == io_.dir_id_ && OB_FAIL(ObChunkStoreUtil::alloc_dir_id(io_.dir_id_))) {
LOG_WARN("allocate file directory failed", K(ret));
}
return ret;
}
int ObChunkDatumStore::write_file(void *buf, int64_t size)
{
int ret = OB_SUCCESS;
int64_t timeout_ms = 0;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (size < 0 || (size > 0 && NULL == buf)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(size), KP(buf));
} else if (OB_FAIL(get_timeout(timeout_ms))) {
LOG_WARN("get timeout failed", K(ret));
} else {
if (!is_file_open()) {
if (-1 == io_.dir_id_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("temp file dir id is not init", K(ret), K(io_.dir_id_));
} else if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.open(io_.fd_, io_.dir_id_))) {
LOG_WARN("open file failed", K(ret));
} else {
file_size_ = 0;
io_.tenant_id_ = tenant_id_;
io_.io_desc_.set_wait_event(ObWaitEventIds::ROW_STORE_DISK_WRITE);
io_.io_timeout_ms_ = timeout_ms;
LOG_INFO("open file success", K_(io_.fd), K_(io_.dir_id));
}
}
ret = OB_E(EventTable::EN_8) ret;
}
if (OB_SUCC(ret) && size > 0) {
set_io(size, static_cast<char *>(buf));
if (aio_write_handle_.is_valid() && OB_FAIL(aio_write_handle_.wait())) {
LOG_WARN("failed to wait write", K(ret));
} else if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.aio_write(io_, aio_write_handle_))) {
LOG_WARN("write to file failed", K(ret), K_(io), K(timeout_ms));
}
}
if (OB_SUCC(ret)) {
file_size_ += size;
if (nullptr != callback_) {
callback_->dumped(size);
}
}
return ret;
}
int ObChunkDatumStore::read_file(
void *buf,
const int64_t size,
const int64_t offset,
blocksstable::ObTmpFileIOHandle &handle,
const int64_t file_size,
const int64_t cur_pos,
int64_t &tmp_file_size)
{
int ret = OB_SUCCESS;
int64_t timeout_ms = 0;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (offset < 0 || size < 0 || (size > 0 && NULL == buf)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(size), K(offset), KP(buf));
} else if (OB_FAIL(get_timeout(timeout_ms))) {
LOG_WARN("get timeout failed", K(ret));
} else if (!handle.is_valid()) {
if (OB_FAIL(aio_write_handle_.wait())) {
LOG_WARN("failed to wait write", K(ret));
}
}
int64_t read_size = file_size - cur_pos;
if (OB_FAIL(ret)) {
} else if (0 >= size) {
CK (cur_pos >= file_size);
OX (ret = OB_ITER_END);
} else {
blocksstable::ObTmpFileIOInfo tmp_io = io_;
set_io(size, static_cast<char *>(buf), tmp_io);
tmp_io.io_desc_.set_wait_event(ObWaitEventIds::ROW_STORE_DISK_READ);
tmp_io.io_timeout_ms_ = timeout_ms;
if (0 == read_size
&& OB_FAIL(FILE_MANAGER_INSTANCE_V2.get_tmp_file_size(tmp_io.fd_, tmp_file_size))) {
LOG_WARN("failed to get tmp file size", K(ret));
} else if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.pread(tmp_io, offset, handle))) {
if (OB_ITER_END != ret) {
LOG_WARN("read form file failed", K(ret), K(tmp_io), K(offset), K(timeout_ms));
}
} else if (handle.get_data_size() != size) {
ret = OB_INNER_STAT_ERROR;
LOG_WARN("read data less than expected",
K(ret), K(tmp_io), "read_size", handle.get_data_size());
}
}
return ret;
}
int ObChunkDatumStore::aio_read_file(
void *buf,
const int64_t size,
const int64_t offset,
blocksstable::ObTmpFileIOHandle &handle)
{
int ret = OB_SUCCESS;
if (!is_inited()) {
ret = OB_NOT_INIT;
LOG_WARN("not init", K(ret));
} else if (offset < 0 || size < 0 || (size > 0 && NULL == buf)) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid argument", K(size), K(offset), KP(buf));
} else if (size > 0) {
blocksstable::ObTmpFileIOInfo tmp_io = io_;
set_io(size, static_cast<char *>(buf), tmp_io);
tmp_io.io_desc_.set_wait_event(ObWaitEventIds::ROW_STORE_DISK_READ);
if (OB_FAIL(get_timeout(tmp_io.io_timeout_ms_))) {
LOG_WARN("get timeout failed", K(ret));
} else if (OB_FAIL(FILE_MANAGER_INSTANCE_V2.aio_pread(tmp_io, offset, handle))) {
if (OB_ITER_END != ret) {
LOG_WARN("read form file failed", K(ret), K(tmp_io), K(offset));
}
}
}
return ret;
}
bool ObChunkDatumStore::need_dump(int64_t extra_size)
{
bool dump = false;
if (!GCONF.is_sql_operator_dump_enabled()) {
// no dump
} else if (mem_limit_ > 0) {
if (mem_used_ + extra_size > mem_limit_) {
dump = true;
}
}
return dump;
}
int ObChunkDatumStore::append_datum_store(const ObChunkDatumStore &other_store)
{
int ret = OB_SUCCESS;
if (other_store.get_row_cnt() > 0) {
ObChunkDatumStore::Iterator store_iter;
if (OB_FAIL(const_cast<ObChunkDatumStore &>(other_store).begin(store_iter))) {
SQL_ENG_LOG(WARN, "fail to get store_iter", K(ret));
} else {
const StoredRow *store_row = NULL;
while (OB_SUCC(ret)) {
if (OB_FAIL(store_iter.get_next_row(store_row))) {
if (OB_ITER_END == ret) {
// do nothing
} else {
SQL_ENG_LOG(WARN, "fail to get next row", K(ret));
}
} else if (OB_ISNULL(store_row)) {
ret = OB_INVALID_ARGUMENT;
SQL_ENG_LOG(WARN, "fail to get next row", K(ret));
} else if (OB_FAIL(add_row(*store_row))) {
SQL_ENG_LOG(WARN, "fail to add row", K(ret));
}
}
if (OB_ITER_END == ret) {
ret = OB_SUCCESS;
}
}
}
return ret;
}
int ObChunkDatumStore::assign(const ObChunkDatumStore &other_store)
{
int ret = OB_SUCCESS;
reset();
if (OB_FAIL(append_datum_store(other_store))) {
LOG_WARN("fail to append datum store", K(ret));
}
return ret;
}
OB_DEF_SERIALIZE(ObChunkDatumStore)
{
int ret = OB_SUCCESS;
if (inited_ && enable_dump_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("chunk datum store not support serialize if enable dump", K(ret));
}
int64_t ser_ctx_id = ctx_id_;
if (GET_MIN_CLUSTER_VERSION() < CLUSTER_VERSION_4_2_0_0) {
if (ObCtxIds::DEFAULT_CTX_ID == ser_ctx_id) {
// do nothing
} else if (ObCtxIds::WORK_AREA == ser_ctx_id) {
ser_ctx_id = OLD_WORK_AREA_ID;
} else {
LOG_WARN_RET(OB_ERR_UNEXPECTED, "unexpected ctx id", K(ser_ctx_id), K(lbt()));
}
}
LST_DO_CODE(OB_UNIS_ENCODE,
tenant_id_,
ser_ctx_id,
mem_limit_,
default_block_size_,
col_count_,
enable_dump_,
row_extend_size_);
int64_t count = blocks_.get_size();
OB_UNIS_ENCODE(count);
if (OB_SUCC(ret)) {
Block *block = blocks_.get_first();
while (NULL != block && OB_SUCC(ret)) {
// serialize data_buf_size
const int64_t payload_size = block->get_buffer()->head() - block->payload_;
OB_UNIS_ENCODE(payload_size);
OB_UNIS_ENCODE(block->rows_);
if (OB_SUCC(ret)) {
// serialize block data
if (buf_len - pos < payload_size) {
ret = OB_SIZE_OVERFLOW;
} else if (OB_FAIL(block->gen_unswizzling_payload(buf + pos, payload_size))) {
LOG_WARN("fail to unswizzling", K(ret));
} else {
pos += payload_size;
// serialize next block
block = block->get_next();
}
}
} //end while
}
return ret;
}
OB_DEF_DESERIALIZE(ObChunkDatumStore)
{
int ret = OB_SUCCESS;
LST_DO_CODE(OB_UNIS_DECODE,
tenant_id_,
ctx_id_,
mem_limit_);
if (ObCtxIds::DEFAULT_CTX_ID == ctx_id_
|| ObCtxIds::WORK_AREA == ctx_id_) {
// do nothing
} else if (OLD_WORK_AREA_ID == ctx_id_) {
ctx_id_ = ObCtxIds::WORK_AREA;
} else {
LOG_WARN_RET(OB_ERR_UNEXPECTED, "unexpected ctx id", K(ctx_id_), K(lbt()));
}
if (!is_inited()) {
if (OB_FAIL(init(mem_limit_, tenant_id_,
ctx_id_, label_, false/*enable_dump*/))) {
LOG_WARN("fail to init chunk row store", K(ret));
}
}
LST_DO_CODE(OB_UNIS_DECODE,
default_block_size_,
col_count_,
enable_dump_,
row_extend_size_);
if (OB_SUCC(ret)) {
Block *block = NULL;
int64_t payload_size = 0;
int64_t row_cnt = 0;
int64_t blk_cnt = 0;
OB_UNIS_DECODE(blk_cnt);
for (int64_t i = 0; i < blk_cnt && OB_SUCC(ret); ++i) {
OB_UNIS_DECODE(payload_size);
OB_UNIS_DECODE(row_cnt);
int64_t blk_size = Block::min_buf_size(payload_size);
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(alloc_block_buffer(block, blk_size, false /*for_iterator*/))) {
LOG_WARN("alloc block failed", K(ret), K(blk_size), KP(block));
} else {
MEMCPY(block->payload_, buf + pos, payload_size);
block->rows_ = row_cnt;
block->get_buffer()->advance(payload_size);
pos += payload_size;
if (OB_FAIL(add_block(block, true /*+need_swizzling*/))) {
LOG_WARN("fail to add block", K(ret));
}
}
}
}
return ret;
}
OB_DEF_SERIALIZE_SIZE(ObChunkDatumStore)
{
int64_t len = 0;
LST_DO_CODE(OB_UNIS_ADD_LEN,
tenant_id_,
ctx_id_,
mem_limit_,
default_block_size_,
col_count_,
enable_dump_,
row_extend_size_);
int64_t count = blocks_.get_size();
OB_UNIS_ADD_LEN(count);
Block *block = blocks_.get_first();
while (NULL != block) {
const int64_t payload_size = block->get_buffer()->head() - block->payload_;
OB_UNIS_ADD_LEN(payload_size);
OB_UNIS_ADD_LEN(block->rows_);
len += payload_size;
block = block->get_next();
} //end while
return len;
}
int ObChunkDatumStore::init_batch_ctx(const int64_t col_cnt, const int64_t max_batch_size)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(NULL == batch_ctx_)) {
const int64_t size = sizeof(*batch_ctx_)
+ sizeof(ObDatum *) * col_cnt
+ sizeof(*batch_ctx_->row_size_array_) * max_batch_size
+ sizeof(*batch_ctx_->selector_) * max_batch_size
+ sizeof(*batch_ctx_->stored_rows_) * max_batch_size;
char *mem = static_cast<char *>(allocator_->alloc(size));
if (OB_UNLIKELY(max_batch_size <= 0)) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("max batch size is not positive when init batch ctx", K(ret), K(max_batch_size));
} else if (NULL == mem) {
ret = OB_ALLOCATE_MEMORY_FAILED;
LOG_WARN("allocate memory failed", K(ret), K(size), K(col_cnt), K(max_batch_size),
K(mem_hold_), K(mem_used_));
} else {
auto begin = mem;
batch_ctx_ = reinterpret_cast<BatchCtx *>(mem);
mem += sizeof(*batch_ctx_);
#define SET_BATCH_CTX_FIELD(X, N) \
batch_ctx_->X = reinterpret_cast<typeof(batch_ctx_->X)>(mem); \
mem += sizeof(*batch_ctx_->X) * N;
SET_BATCH_CTX_FIELD(datums_, col_cnt);
SET_BATCH_CTX_FIELD(stored_rows_, max_batch_size);
SET_BATCH_CTX_FIELD(row_size_array_, max_batch_size);
SET_BATCH_CTX_FIELD(selector_, max_batch_size);
#undef SET_BATCH_CTX_FIELD
if (mem - begin != size) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("size mismatch", K(ret), K(mem - begin), K(size), K(col_cnt), K(max_batch_size));
}
}
}
return ret;
}
void ObChunkDatumStore::free_tmp_dump_blk()
{
if (NULL != tmp_dump_blk_) {
free_block(tmp_dump_blk_);
tmp_dump_blk_ = nullptr;
}
}
void ObChunkDatumStore::Iterator::reset_cursor(const int64_t file_size)
{
file_size_ = file_size;
if (chunk_mem_ != NULL) {
store_->allocator_->free(chunk_mem_);
chunk_mem_ = NULL;
cur_iter_blk_ = NULL;
store_->callback_free(0);
if (read_file_iter_end()) {
LOG_ERROR_RET(OB_ERR_UNEXPECTED, "unexpect status: chunk mem is allocated, but don't free");
}
}
aio_read_handle_.reset();
const bool force_free = true;
if (NULL != aio_blk_) {
free_block(aio_blk_, aio_blk_buf_->mem_size(), force_free);
}
if (NULL != read_blk_) {
free_block(read_blk_, read_blk_buf_->mem_size(), force_free);
}
aio_blk_ = NULL;
aio_blk_buf_ = NULL;
read_blk_ = NULL;
read_blk_buf_ = NULL;
while (NULL != icached_.get_first()) {
free_block(icached_.remove_first(), default_block_size_, force_free);
}
while (NULL != ifree_list_.get_first()) {
free_block(ifree_list_.remove_first(), default_block_size_, force_free);
}
if (nullptr != blk_holder_ptr_) {
if (blk_holder_ptr_->block_list_.get_size() > 0) {
blk_holder_ptr_->release();
blk_holder_ptr_ = nullptr;
}
}
cur_iter_blk_ = nullptr;
cur_nth_blk_ = -1;
cur_iter_pos_ = 0;
iter_end_flag_ = IterEndState::PROCESSING;
}
int ObChunkDatumStore::Iterator::load_next_block(RowIterator& it)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!is_valid())) {
ret = OB_NOT_INIT;
LOG_WARN("chunk store not init", K(ret));
} else if (store_->n_blocks_ <= 0 || cur_nth_blk_ >= store_->n_blocks_ - 1) {
ret = OB_ITER_END;
} else {
CK(store_->is_inited());
if (OB_SUCC(ret) && file_size_ != store_->file_size_) {
reset_cursor(store_->file_size_);
}
if (OB_FAIL(ret)) {
} else if (cur_nth_blk_ < -1 || cur_nth_blk_ >= store_->n_blocks_) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("row should be saved", K(ret), K_(cur_nth_blk), K_(store_->n_blocks));
} else if (store_->is_file_open() && !read_file_iter_end()) {
uint64_t begin_io_read_time = rdtsc();
// return at least one block when read file not end (!read_file_iter_end())
if (OB_FAIL(read_next_blk())) {
LOG_WARN("read next blk failed", K(ret));
} else {
if (cur_iter_pos_ >= file_size_) {
set_read_file_iter_end();
} else {
if (OB_FAIL(prefetch_next_blk())) {
LOG_WARN("prefetch next blk failed", K(ret));
}
}
}
} else {
ret = OB_ITER_END;
}
if (OB_ITER_END == ret) {
ret = OB_SUCCESS;
set_read_file_iter_end();
if (NULL == store_->blocks_.get_first()) {
set_read_mem_iter_end();
ret = OB_ITER_END;
} else {
cur_iter_blk_ = store_->blocks_.get_first();
cur_chunk_n_blocks_ = store_->blocks_.get_size();
cur_nth_blk_ += cur_chunk_n_blocks_;
chunk_n_rows_ = store_->get_row_cnt_in_memory();
if (cur_nth_blk_ != store_->n_blocks_ - 1) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected status",
K(ret), K(cur_nth_blk_), K(store_->n_blocks_), K(store_->blocks_.get_size()));
}
}
}
}
if (OB_SUCC(ret)) {
it.store_ = store_;
it.cur_iter_blk_ = cur_iter_blk_;
it.cur_pos_in_blk_ = 0;
it.cur_row_in_blk_ = 0;
it.n_blocks_ = cur_chunk_n_blocks_;
it.cur_nth_block_ = 0;
}
return ret;
}
int ObChunkDatumStore::Iterator::read_next_blk()
{
int ret = OB_SUCCESS;
if (NULL == aio_blk_) {
if (OB_FAIL(prefetch_next_blk())) {
LOG_WARN("prefetch next blk failed", K(ret));
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(aio_wait())) {
LOG_WARN("aio wait failed", K(ret));
}
}
if (OB_SUCC(ret) && !aio_blk_->magic_check()) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("read corrupt data", K(ret), K(aio_blk_->magic_),
K(store_->file_size_), K(cur_iter_pos_));
}
if (OB_SUCC(ret)) {
// data block is larger than min block
const int64_t loaded_len = aio_blk_buf_->capacity();
if (aio_blk_->blk_size_ > loaded_len) {
Block *blk= NULL;
if (OB_FAIL(alloc_block(blk, aio_blk_->blk_size_ + sizeof(BlockBuffer)))) {
LOG_WARN("alloc block failed", K(ret), K(aio_blk_->blk_size_));
} else {
BlockBuffer *blk_buf = blk->get_buffer();
MEMCPY(blk, aio_blk_, loaded_len);
free_block(aio_blk_, aio_blk_buf_->mem_size());
aio_blk_ = blk;
aio_blk_buf_ = blk_buf;
if (OB_FAIL(aio_read((char *)aio_blk_ + loaded_len,
aio_blk_->blk_size_ - loaded_len))) {
LOG_WARN("aio read failed", K(ret));
} else if (OB_FAIL(aio_wait())) {
LOG_WARN("aio wait failed", K(ret));
}
}
}
}
if (OB_SUCC(ret)) {
// move aio block to read block
if (NULL != read_blk_) {
free_block(read_blk_, read_blk_buf_->mem_size());
}
read_blk_ = aio_blk_;
read_blk_buf_ = aio_blk_buf_;
aio_blk_ = NULL;
aio_blk_buf_ = NULL;
if (OB_FAIL(read_blk_->swizzling(NULL))) {
LOG_WARN("swizzling failed", K(ret));
} else {
cur_chunk_n_blocks_ = 1;
cur_nth_blk_ += 1;
read_blk_->next_ = NULL;
cur_iter_blk_ = read_blk_;
chunk_n_rows_ = cur_iter_blk_->rows_;
}
}
return ret;
}
int ObChunkDatumStore::Iterator::prefetch_next_blk()
{
int ret = OB_SUCCESS;
CK(NULL == aio_blk_);
const int64_t block_size = store_->min_blk_size_;
if (OB_FAIL(alloc_block(aio_blk_, block_size))) {
LOG_WARN("allocate block buffer failed", K(ret));
} else {
aio_blk_buf_ = aio_blk_->get_buffer();
if (OB_FAIL(aio_read((char *)aio_blk_, aio_blk_buf_->capacity()))) {
LOG_WARN("aio read failed", K(ret));
}
}
return ret;
}
int ObChunkDatumStore::Iterator::alloc_block(Block *&blk, const int64_t size)
{
int ret = OB_SUCCESS;
try_free_cached_blocks();
int64_t actual_size = store_->min_blk_size(size);
if (actual_size == default_block_size_ && NULL != ifree_list_.get_first()) {
blk = ifree_list_.remove_first();
ObChunkDatumStore::init_block_buffer(blk, actual_size, blk);
} else if (OB_FAIL(store_->alloc_block_buffer(blk, actual_size, true))) {
LOG_WARN("alloc block buffer failed", K(ret), K(actual_size));
}
return ret;
}
void ObChunkDatumStore::Iterator::free_block(Block *blk, const int64_t size,
const bool force_free)
{
if (NULL != blk) {
bool do_phy_free = force_free;
if (!force_free) {
try_free_cached_blocks();
if (NULL != blk_holder_ptr_) {
// fill iter ptr at pos of age, since we do not use age in shared cache
*((int64_t *)((char *)blk + size - sizeof(int64_t))) = reinterpret_cast<int64_t> (this);
blk_holder_ptr_->block_list_.add_last(blk);
blk->blk_size_ = size;
} else if (NULL != age_) {
STATIC_ASSERT(sizeof(BlockBuffer) >= sizeof(int64_t), "unexpected block buffer size");
// Save age to the tail of the block, we always allocate one BlockBuffer in tail of block,
// it's safe to write it here.
*((int64_t *)((char *)blk + size - sizeof(int64_t))) = age_->get();
// Save memory size to %blk_size_
blk->blk_size_ = size;
icached_.add_last(blk);
} else {
if (size == default_block_size_ && !force_free) {
#ifndef NDEBUG
memset((char *)blk + sizeof(*blk), 0xAA, size - sizeof(*blk));
#endif
ifree_list_.add_last(blk);
} else {
do_phy_free = true;
}
}
}
if (do_phy_free) {
#ifndef NDEBUG
memset(blk, 0xAA, size);
#endif
store_->allocator_->free(blk);
store_->callback_free(size);
}
}
}
void ObChunkDatumStore::Iterator::try_free_cached_blocks()
{
const int64_t read_age = NULL == age_ ? INT64_MAX : age_->get();
// try free age expired blocks
while (NULL != icached_.get_first()) {
Block *b = icached_.get_first();
// age is stored in tail of block, see free_block()
const int64_t age = *((int64_t *)((char *)b + b->blk_size_ - sizeof(int64_t)));
if (age < read_age) {
b = icached_.remove_first();
if (b->blk_size_ == default_block_size_) {
#ifndef NDEBUG
memset((char *)b + sizeof(*b), 0xAA, b->blk_size_ - sizeof(*b));
#endif
ifree_list_.add_last(b);
} else {
const bool force_free = true;
free_block(b, b->blk_size_, force_free);
}
} else {
break;
}
}
}
int ObChunkDatumStore::Iterator::aio_read(char *buf, const int64_t size)
{
int ret = OB_SUCCESS;
if (!aio_read_handle_.is_valid()) {
// first read, wait write finish
int64_t timeout_ms = 0;
OZ(store_->get_timeout(timeout_ms));
OZ(store_->aio_write_handle_.wait());
}
if (OB_SUCC(ret)) {
if (size <= 0 || cur_iter_pos_ >= file_size_) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected read offset", K(ret), K(size), K(cur_iter_pos_), K(file_size_));
} else {
int64_t read_size = std::min(file_size_ - cur_iter_pos_, size);
if (OB_FAIL(store_->aio_read_file(buf, read_size, cur_iter_pos_, aio_read_handle_))) {
LOG_WARN("aio read file failed", K(ret), K(read_size));
} else {
cur_iter_pos_ += size;
}
}
}
return ret;
}
int ObChunkDatumStore::Iterator::aio_wait()
{
int ret = OB_SUCCESS;
int64_t timeout_ms = 0;
OZ(store_->get_timeout(timeout_ms));
if (OB_SUCC(ret)) {
if (OB_FAIL(aio_read_handle_.wait())) {
LOG_WARN("aio wait failed", K(ret), K(timeout_ms));
}
}
return ret;
}
void ObChunkDatumStore::IteratedBlockHolder::release()
{
while (block_list_.get_size() > 0) {
Block *blk = block_list_.remove_first();
Iterator *iter = reinterpret_cast<Iterator *> (*((int64_t *)((char *)blk + blk->blk_size_ - sizeof(int64_t))));
if (OB_NOT_NULL(blk) && OB_NOT_NULL(iter)) {
iter->free_block(blk, blk->blk_size_, true);
} else {
LOG_ERROR_RET(OB_ERR_UNEXPECTED, "get unexpected block pair", KP(iter), KP(blk));
}
}
}
} // end namespace sql
} // end namespace oceanbase
Reference in New Issue View Git Blame Copy Permalink