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

dec the sizeof(Obsharedblockreadhandle)

Browse Source
This commit is contained in:
obdev
2023-06-28 07:47:59 +00:00
committed by ob-robot
parent bfd07cbbc0
commit be38e3cb78
4 changed files with 43 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

46
src/storage/blockstore/ob_shared_block_reader_writer.cpp
View File

@ -246,9 +246,13 @@ bool ObSharedBlockWriteHandle::is_valid() const
bool ObSharedBlockReadHandle::is_valid() const
{
return macro_handles_.count() > 0 && addrs_.count() == 1;
return macro_handle_.is_valid();
}
bool ObSharedBlockReadHandle::is_empty() const
{
return macro_handle_.is_empty();
}
ObSharedBlockReadHandle::ObSharedBlockReadHandle(const ObSharedBlockReadHandle &other)
{
*this = other;
@ -257,18 +261,21 @@ ObSharedBlockReadHandle::ObSharedBlockReadHandle(const ObSharedBlockReadHandle &
ObSharedBlockReadHandle &ObSharedBlockReadHandle::operator=(const ObSharedBlockReadHandle &other)
{
if (&other != this) {
addrs_ = other.addrs_;
macro_handles_ = other.macro_handles_;
macro_handle_ = other.macro_handle_;
}
return *this;
}
int ObSharedBlockReadHandle::wait()
int ObSharedBlockReadHandle::wait(const int64_t timeout_ms)
{
// TODO(zhuixin.gsy) use timeout_ms to wait
int ret = OB_SUCCESS;
if (OB_FAIL(ObSharedBlockBaseHandle::wait())) {
LOG_WARN("Fail to wait io finish", K(ret));
const int64_t io_timeout_ms = timeout_ms > 0
? timeout_ms : MAX(GCONF._data_storage_io_timeout / 1000, DEFAULT_IO_WAIT_TIME_MS);
if (OB_UNLIKELY(!macro_handle_.is_valid())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected read handle", K(ret), K_(macro_handle));
} else if (OB_FAIL(macro_handle_.wait(io_timeout_ms))) {
LOG_WARN("Failt to wait macro handle finish", K(ret), K(macro_handle_), K(io_timeout_ms));
}
return ret;
}
@ -276,12 +283,11 @@ int ObSharedBlockReadHandle::wait()
int ObSharedBlockReadHandle::get_data(ObIAllocator &allocator, char *&buf, int64_t &buf_len)
{
int ret = OB_SUCCESS;
if (OB_FAIL(ObSharedBlockBaseHandle::wait())) {
if (OB_FAIL(wait())) {
LOG_WARN("Fail to wait io finish", K(ret));
} else {
ObMacroBlockHandle &macro_handle = macro_handles_.at(0);
const char *data_buf = macro_handle.get_buffer();
const int64_t data_size = macro_handle.get_data_size();
const char *data_buf = macro_handle_.get_buffer();
const int64_t data_size = macro_handle_.get_data_size();
int64_t header_size = 0;
if (OB_FAIL(verify_checksum(data_buf, data_size, header_size, buf_len))) {
LOG_WARN("fail to verify checksum", K(ret), KP(data_buf), K(data_size), K(header_size), K(buf_len));
@ -341,6 +347,18 @@ int ObSharedBlockReadHandle::verify_checksum(
return ret;
}
int ObSharedBlockReadHandle::set_macro_handle(const ObMacroBlockHandle &macro_handle)
{
int ret = OB_SUCCESS;
if (OB_UNLIKELY(!macro_handle.is_valid())) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid args", K(ret), K(macro_handle));
} else {
macro_handle_ = macro_handle;
}
return ret;
}
int ObSharedBlockWriteHandle::get_write_ctx(ObSharedBlocksWriteCtx &write_ctx)
{
int ret = OB_SUCCESS;
@ -455,7 +473,7 @@ int ObSharedBlockLinkIter::get_next(ObIAllocator &allocator, char *&buf, int64_t
} else if (OB_FAIL(block_handle.get_data(allocator, buf, buf_len))) {
LOG_WARN("Fail to get data", K(ret), K(block_handle));
} else {
ObMacroBlockHandle &macro_handle = block_handle.macro_handles_.at(0);
ObMacroBlockHandle &macro_handle = block_handle.macro_handle_;
const ObSharedBlockHeader *header =
reinterpret_cast<const ObSharedBlockHeader *>(macro_handle.get_buffer());
cur_ = header->prev_addr_;
@ -856,10 +874,8 @@ int ObSharedBlockReaderWriter::async_read(
LOG_WARN("Fail to get block addr", K(ret), K(read_info));
} else if (OB_FAIL(macro_handle.async_read(macro_read_info))) {
LOG_WARN("Fail to async read block", K(ret), K(macro_read_info));
} else if (OB_FAIL(block_handle.add_macro_handle(macro_handle))) {
} else if (OB_FAIL(block_handle.set_macro_handle(macro_handle))) {
LOG_WARN("Fail to add macro handle", K(ret), K(macro_read_info));
} else if (OB_FAIL(block_handle.add_meta_addr(read_info.addr_))) {
LOG_WARN("Fail to add meta addr", K(ret));
}
return ret;
}

12
src/storage/blockstore/ob_shared_block_reader_writer.h
View File

@ -127,18 +127,21 @@ protected:
};
class ObSharedBlockReadHandle final : public ObSharedBlockBaseHandle
class ObSharedBlockReadHandle final
{
friend class ObSharedBlockReaderWriter;
friend class ObSharedBlockLinkIter;
public:
ObSharedBlockReadHandle() = default;
~ObSharedBlockReadHandle() = default;
ObSharedBlockReadHandle(const ObSharedBlockReadHandle &other);
ObSharedBlockReadHandle &operator=(const ObSharedBlockReadHandle &other);
bool is_valid() const;
int wait();
bool is_empty() const;
int wait(const int64_t timeout_ms = -1);
int get_data(ObIAllocator &allocator, char *&buf, int64_t &buf_len);
void reset() { macro_handle_.reset(); }
TO_STRING_KV(K_(macro_handle));
public:
static int parse_data(
const char *data_buf,
@ -152,6 +155,9 @@ private:
const int64_t data_size,
int64_t &header_size,
int64_t &buf_len);
int set_macro_handle(const blocksstable::ObMacroBlockHandle &macro_handle);
private:
blocksstable::ObMacroBlockHandle macro_handle_;
};
class ObSharedBlockWriteHandle final : public ObSharedBlockBaseHandle

6
src/storage/meta_mem/ob_storage_meta_cache.cpp
View File

@ -425,7 +425,7 @@ ObStorageMetaHandle::~ObStorageMetaHandle()
int ObStorageMetaHandle::get_value(const ObStorageMetaValue *&value)
{
int ret = OB_SUCCESS;
if (OB_FAIL(wait(GCONF._data_storage_io_timeout / 1000L))) {
if (!io_handle_.is_empty() && OB_FAIL(wait(GCONF._data_storage_io_timeout / 1000L))) { /*wait if not hit cache*/
LOG_WARN("fail to wait", K(ret), KPC(this));
} else {
value = cache_handle_.get_cache_value()->value_;
@ -463,12 +463,10 @@ bool ObStorageMetaHandle::is_valid() const
int ObStorageMetaHandle::wait(const int64_t timeout_ms)
{
int ret = OB_SUCCESS;
UNUSED(timeout_ms);
// TODO(zhuixin.gsy) use timeout_ms to wait
if (OB_UNLIKELY(!phy_addr_.is_block())) {
ret = OB_ERR_UNEXPECTED;
LOG_WARN("unexpected meta address", K(ret), K_(phy_addr));
} else if (OB_FAIL(io_handle_.wait())) {
} else if (OB_FAIL(io_handle_.wait(timeout_ms))) {
LOG_WARN("fail to wait io handle", K(ret), K(io_handle_));
}
return ret;

2
src/storage/tablet/ob_full_tablet_creator.cpp
View File

@ -203,7 +203,7 @@ int ObFullTabletCreator::persist_tablet()
ret = OB_ERR_UNEXPECTED;
LOG_ERROR("unexpected not memory tablet addr", K(ret), K(key), K(addr), K(old_handle), K(old_tablet->is_empty_shell()));
} else if (addr != old_addr) {
if (addr.is_block()) {
if (addr.is_disked()) {
LOG_INFO("full tablet has been persisted, skip this", K(ret), K(key), K(old_addr), K(addr));
} else {
ret = OB_NOT_THE_OBJECT; // create_memtable may change the addr, push back to queue