283 lines
9.0 KiB
C++
283 lines
9.0 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#include "ob_disk_log_buffer.h"
|
|
#include "ob_log_block.h"
|
|
#include "ob_log_define.h"
|
|
|
|
namespace oceanbase {
|
|
using namespace common;
|
|
namespace clog {
|
|
|
|
ObCLogItem::ObCLogItem() : host_(NULL), buffer_task_(NULL), batch_buffer_(NULL)
|
|
{}
|
|
|
|
ObCLogItem::~ObCLogItem()
|
|
{}
|
|
|
|
int ObCLogItem::init(ObLogWriterWrapper* host, ObIBatchBufferTask* buffer_task, ObBatchBuffer* batch_buffer)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(host) || OB_ISNULL(buffer_task) || OB_ISNULL(batch_buffer)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else {
|
|
host_ = host;
|
|
buffer_task_ = buffer_task;
|
|
batch_buffer_ = batch_buffer;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObCLogItem::reset()
|
|
{
|
|
host_ = NULL;
|
|
buffer_task_ = NULL;
|
|
batch_buffer_ = NULL;
|
|
}
|
|
|
|
bool ObCLogItem::is_valid() const
|
|
{
|
|
return NULL != host_ && NULL != buffer_task_ && NULL != batch_buffer_;
|
|
}
|
|
|
|
char* ObCLogItem::get_buf()
|
|
{
|
|
return NULL == buffer_task_ ? NULL : buffer_task_->get_batch_buffer();
|
|
}
|
|
|
|
const char* ObCLogItem::get_buf() const
|
|
{
|
|
return NULL == buffer_task_ ? NULL : buffer_task_->get_batch_buffer();
|
|
}
|
|
|
|
int64_t ObCLogItem::get_data_len() const
|
|
{
|
|
return NULL == buffer_task_ ? 0 : buffer_task_->get_batch_size();
|
|
}
|
|
|
|
int ObCLogItem::after_flushed(
|
|
const file_id_t file_id, const offset_t offset, const int error_code, const ObLogWritePoolType type)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int tmp_ret = OB_SUCCESS;
|
|
if (OB_IS_INVALID_FILE_ID(file_id) || OB_IS_INVALID_OFFSET(offset) || OB_ISNULL(buffer_task_) || OB_ISNULL(host_)) {
|
|
CLOG_LOG(WARN, "invalid argument", K(file_id), K(offset), K_(buffer_task), K_(host));
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else {
|
|
ObIBufferTask* curr_task = buffer_task_->get_header_task();
|
|
const int64_t seq = buffer_task_->get_seq();
|
|
int64_t task_num = 0;
|
|
if (OB_SUCCESS != (tmp_ret = buffer_task_->st_handle_callback_list(error_code, task_num))) {
|
|
CLOG_LOG(ERROR, "st_handle_callback_list failed", K(tmp_ret));
|
|
}
|
|
buffer_task_->reuse();
|
|
host_->add_group_size(task_num, type);
|
|
const int64_t next_flush_block_id = seq + 1;
|
|
batch_buffer_->update_next_flush_block_id(next_flush_block_id);
|
|
if (OB_SUCCESS != (tmp_ret = batch_buffer_->try_freeze(next_flush_block_id))) {
|
|
CLOG_LOG(ERROR, "batch_buffer try_freeze failed", K(tmp_ret));
|
|
}
|
|
if (CLOG_WRITE_POOL == type) {
|
|
bool curr_is_aggre_task = false;
|
|
bool last_is_aggre_task = false;
|
|
ObLogWriterWrapper::CallbackTask* cb = NULL;
|
|
for (int64_t i = 0; i < task_num; i++) {
|
|
curr_is_aggre_task = curr_task->is_aggre_task();
|
|
if (i % MAX_TASK_NUM_PER_CB == 0 || curr_is_aggre_task || last_is_aggre_task) {
|
|
if (NULL != cb) {
|
|
if (OB_SUCCESS != (tmp_ret = host_->after_consume(*cb))) {
|
|
CLOG_LOG(ERROR, "after_consume failed", K(tmp_ret));
|
|
}
|
|
}
|
|
while (NULL == (cb = op_alloc(ObLogWriterWrapper::CallbackTask))) {
|
|
CLOG_LOG(WARN, "alloc callback task fail");
|
|
usleep(100);
|
|
}
|
|
cb->cursor_.file_id_ = file_id;
|
|
cb->cursor_.offset_ = offset;
|
|
cb->error_code_ = error_code;
|
|
cb->before_push_cb_ts_ = ObTimeUtility::current_time();
|
|
cb->header_task_ = curr_task;
|
|
cb->task_num_ = 0;
|
|
}
|
|
last_is_aggre_task = curr_is_aggre_task;
|
|
curr_task = curr_task->next_;
|
|
cb->task_num_++;
|
|
}
|
|
if (NULL != cb && OB_SUCCESS != (tmp_ret = host_->after_consume(*cb))) {
|
|
CLOG_LOG(ERROR, "after_consume failed", K(tmp_ret));
|
|
}
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObLogWriterWrapper::CallbackTask::reset()
|
|
{
|
|
cursor_.reset();
|
|
error_code_ = common::OB_SUCCESS;
|
|
before_push_cb_ts_ = OB_INVALID_TIMESTAMP;
|
|
header_task_ = NULL;
|
|
task_num_ = 0;
|
|
}
|
|
|
|
int ObLogWriterWrapper::CallbackTask::callback()
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
int tmp_ret = OB_SUCCESS;
|
|
if (OB_ISNULL(header_task_) || task_num_ <= 0) {
|
|
CLOG_LOG(ERROR, "invalid arguments", KP_(header_task), K_(task_num));
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else {
|
|
ObIBufferTask* curr_task = header_task_;
|
|
ObIBufferTask* next_task = NULL;
|
|
int64_t processed_cnt = 0;
|
|
while (processed_cnt < task_num_) {
|
|
next_task = curr_task->next_;
|
|
if (OB_SUCCESS != (tmp_ret = curr_task->after_consume(error_code_, (void*)&cursor_, before_push_cb_ts_))) {
|
|
CLOG_LOG(WARN, "after_consume failed", K(tmp_ret), K_(error_code), K_(cursor));
|
|
}
|
|
curr_task = next_task;
|
|
processed_cnt++;
|
|
}
|
|
op_free(this);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObLogWriterWrapper::init(
|
|
ObCLogWriter* log_writer, ObICallbackHandler* callback_handler, ObBatchBuffer* batch_buffer)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(log_writer) || OB_ISNULL(callback_handler) || OB_ISNULL(batch_buffer)) {
|
|
CLOG_LOG(WARN, "invalid argument", K(log_writer), K(callback_handler), K(batch_buffer));
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else if (is_inited_) {
|
|
ret = OB_INIT_TWICE;
|
|
} else {
|
|
log_writer_ = log_writer;
|
|
callback_handler_ = callback_handler;
|
|
batch_buffer_ = batch_buffer;
|
|
is_inited_ = true;
|
|
}
|
|
if (OB_SUCCESS != ret && !is_inited_) {
|
|
destroy();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObLogWriterWrapper::destroy()
|
|
{
|
|
log_writer_ = NULL;
|
|
callback_handler_ = NULL;
|
|
batch_buffer_ = NULL;
|
|
is_inited_ = false;
|
|
}
|
|
|
|
int ObLogWriterWrapper::submit(Task* task)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (IS_NOT_INIT) {
|
|
ret = OB_NOT_INIT;
|
|
} else if (OB_ISNULL(task) || OB_ISNULL(log_writer_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else if (OB_FAIL(task->init(this))) {
|
|
CLOG_LOG(WARN, "flush task init failed", K(ret));
|
|
} else {
|
|
// const int64_t begin_ts = ObTimeUtility::current_time();
|
|
ObICLogItem* flush_task = task->get_flush_task();
|
|
if (OB_FAIL(log_writer_->append_log(*flush_task, DEFAULT_CLOG_APPEND_TIMEOUT_US))) {
|
|
CLOG_LOG(WARN, "submit_flush_log_task failed", K(ret));
|
|
}
|
|
// const int64_t end_ts = ObTimeUtility::current_time();
|
|
// append_log_his_.Add(static_cast<double>(end_ts - begin_ts));
|
|
// if (REACH_TIME_INTERVAL(10 * 1000 * 1000)) {
|
|
// CLOG_LOG(INFO, "ObLogWriterWrapper::submit append_log", "histogram", append_log_his_.ToString().c_str());
|
|
// append_log_his_.Clear();
|
|
// }
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObLogWriterWrapper::after_consume(ObICallback& task)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (IS_NOT_INIT) {
|
|
ret = OB_NOT_INIT;
|
|
} else if (OB_ISNULL(callback_handler_)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else {
|
|
ret = callback_handler_->handle_callback(&task);
|
|
}
|
|
if (OB_FAIL(ret)) {
|
|
// async callback failed, use writer thread to callback directly
|
|
ret = task.callback();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
void ObLogWriterWrapper::add_group_size(const int64_t task_num, const ObLogWritePoolType type)
|
|
{
|
|
UNUSED(task_num);
|
|
UNUSED(type);
|
|
#ifdef USE_HISTOGRAM
|
|
his_.Add(static_cast<double>(task_num));
|
|
if (REACH_TIME_INTERVAL(1000 * 1000)) {
|
|
if (CLOG_WRITE_POOL == type) {
|
|
CLOG_LOG(INFO, "clog batch group size", "clog", his_.ToString().c_str());
|
|
his_.Clear();
|
|
} else {
|
|
CLOG_LOG(INFO, "ilog batch group size", "ilog", his_.ToString().c_str());
|
|
his_.Clear();
|
|
}
|
|
}
|
|
#endif // USE_HISTOGRAM
|
|
}
|
|
|
|
int ObDiskLogBuffer::submit(ObIBufferTask* task)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
if (OB_ISNULL(task)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else {
|
|
ret = batch_buffer_.submit(task);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
int ObDiskLogBuffer::init(
|
|
const int64_t buffer_size, const int64_t buffer_cnt, ObCLogWriter* log_writer, ObICallbackHandler* callback_handler)
|
|
{
|
|
int ret = OB_SUCCESS;
|
|
ObLogBlockMetaV2 meta;
|
|
int64_t header_size = meta.get_serialize_size();
|
|
int64_t min_padding_size = 1024 - header_size; // assume header_size + padding_entry_size < 1K
|
|
int64_t trailer_size = min_padding_size; // pending
|
|
if (buffer_size <= 0 || buffer_cnt <= 0 || OB_ISNULL(log_writer) || OB_ISNULL(callback_handler)) {
|
|
ret = OB_INVALID_ARGUMENT;
|
|
} else if (OB_SUCCESS !=
|
|
(ret = buffer_arena_.init(
|
|
ObModIds::OB_CLOG_MGR, CLOG_DIO_ALIGN_SIZE, header_size, trailer_size, buffer_size, buffer_cnt))) {
|
|
CLOG_LOG(WARN, "buffer_pool init failed", K(ret), K(buffer_size), K(buffer_cnt));
|
|
} else if (OB_SUCCESS != (ret = log_writer_.init(log_writer, callback_handler, &batch_buffer_))) {
|
|
CLOG_LOG(WARN, "log_writer init failed", K(ret));
|
|
} else if (OB_SUCCESS != (ret = batch_buffer_.init(&buffer_arena_, &log_writer_))) {
|
|
CLOG_LOG(WARN, "batch_buffer init failed", K(ret));
|
|
} else {
|
|
log_buffer_cnt_ = buffer_cnt;
|
|
}
|
|
CLOG_LOG(INFO, "disk_log_buffer init finished", K(buffer_size), K(buffer_cnt), K(header_size), K(ret));
|
|
return ret;
|
|
}
|
|
}; // end namespace clog
|
|
}; // end namespace oceanbase
|