This is an automated email from the ASF dual-hosted git repository.
achennaka pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/kudu.git
The following commit(s) were added to refs/heads/master by this push:
new 63dcd5698 [tablet] modernize MultiColumnWriter's code
63dcd5698 is described below
commit 63dcd56985516e554e8f00474b070b318a598008
Author: Alexey Serbin <[email protected]>
AuthorDate: Mon Nov 13 21:40:01 2023 -0800
[tablet] modernize MultiColumnWriter's code
This patch contain a few micro-optimizations, but it doesn't contain
any functional changes:
* std::unique_ptr replaced raw pointers in the cfile_writers_ array,
so no need to use the STLDeleteElements macro
* replaced CHECK() with DCHECK() where appropriate
* added more DCHECK() macros to enforce logical consistency
* removed virtual base from the class and made it final
* added tablet identifier into status objects and error messages
to make it possible to attribute errors to particular tablets
Change-Id: Ife716bf62338ca896072ce7fce3aea9d5f5204ca
Reviewed-on: http://gerrit.cloudera.org:8080/20702
Tested-by: Alexey Serbin <[email protected]>
Tested-by: Kudu Jenkins
Reviewed-by: Abhishek Chennaka <[email protected]>
---
src/kudu/tablet/multi_column_writer.cc | 98 ++++++++++++++++++----------------
src/kudu/tablet/multi_column_writer.h | 26 ++++-----
2 files changed, 62 insertions(+), 62 deletions(-)
diff --git a/src/kudu/tablet/multi_column_writer.cc
b/src/kudu/tablet/multi_column_writer.cc
index 04efecb9f..1c12b6490 100644
--- a/src/kudu/tablet/multi_column_writer.cc
+++ b/src/kudu/tablet/multi_column_writer.cc
@@ -30,38 +30,41 @@
#include "kudu/fs/block_id.h"
#include "kudu/fs/block_manager.h"
#include "kudu/fs/fs_manager.h"
-#include "kudu/gutil/stl_util.h"
+#include "kudu/gutil/port.h"
#include "kudu/gutil/strings/substitute.h"
+using kudu::cfile::CFileWriter;
+using kudu::fs::BlockCreationTransaction;
+using kudu::fs::CreateBlockOptions;
+using kudu::fs::WritableBlock;
+using std::map;
+using std::string;
+using std::unique_ptr;
+using strings::Substitute;
+
namespace kudu {
namespace tablet {
-using cfile::CFileWriter;
-using fs::BlockCreationTransaction;
-using fs::CreateBlockOptions;
-using fs::WritableBlock;
-using std::unique_ptr;
-
MultiColumnWriter::MultiColumnWriter(FsManager* fs,
const Schema* schema,
- std::string tablet_id)
- : fs_(fs),
- schema_(schema),
- finished_(false),
- tablet_id_(std::move(tablet_id)) {
-}
-
-MultiColumnWriter::~MultiColumnWriter() {
- STLDeleteElements(&cfile_writers_);
+ string tablet_id)
+ : fs_(fs),
+ schema_(DCHECK_NOTNULL(schema)),
+ tablet_id_(std::move(tablet_id)),
+ open_(false),
+ finished_(false) {
+ cfile_writers_.reserve(schema_->num_columns());
+ block_ids_.reserve(schema_->num_columns());
}
Status MultiColumnWriter::Open() {
- CHECK(cfile_writers_.empty());
+ DCHECK(!open_) << "already open";
+ DCHECK(cfile_writers_.empty()); // this method isn't re-entrant after
failures
// Open columns.
const CreateBlockOptions block_opts({ tablet_id_ });
- for (int i = 0; i < schema_->num_columns(); i++) {
- const ColumnSchema &col = schema_->column(i);
+ for (auto i = 0; i < schema_->num_columns(); ++i) {
+ const auto& col = schema_->column(i);
cfile::WriterOptions opts;
@@ -69,7 +72,7 @@ Status MultiColumnWriter::Open() {
// the corresponding rows.
opts.write_posidx = true;
- /// Set the column storage attributes.
+ // Set the column storage attributes.
opts.storage_attributes = col.attributes();
// If the schema has a single PK and this is the PK col
@@ -77,32 +80,32 @@ Status MultiColumnWriter::Open() {
opts.write_validx = true;
}
- // Open file for write.
+ // Open file for writing.
unique_ptr<WritableBlock> block;
RETURN_NOT_OK_PREPEND(fs_->CreateNewBlock(block_opts, &block),
- "Unable to open output file for column " +
col.ToString());
+ Substitute("tablet $0: unable to open output file for column $1",
+ tablet_id_, col.ToString()));
BlockId block_id(block->id());
// Create the CFile writer itself.
unique_ptr<CFileWriter> writer(new CFileWriter(
- std::move(opts),
- col.type_info(),
- col.is_nullable(),
- std::move(block)));
+ std::move(opts), col.type_info(), col.is_nullable(),
std::move(block)));
RETURN_NOT_OK_PREPEND(writer->Start(),
- "Unable to Start() writer for column " +
col.ToString());
-
- cfile_writers_.push_back(writer.release());
- block_ids_.push_back(block_id);
+ Substitute("tablet $0: unable to start writer for column $1",
+ tablet_id_, col.ToString()));
+ cfile_writers_.emplace_back(std::move(writer));
+ block_ids_.emplace_back(block_id);
}
- VLOG(1) << strings::Substitute("Opened CFile writers for $0 column(s)",
- cfile_writers_.size());
+ open_ = true;
+ VLOG(1) << Substitute("Opened CFile writers for $0 column(s)",
+ cfile_writers_.size());
return Status::OK();
}
Status MultiColumnWriter::AppendBlock(const RowBlock& block) {
- for (int i = 0; i < schema_->num_columns(); i++) {
+ DCHECK(open_);
+ for (auto i = 0; i < schema_->num_columns(); ++i) {
ColumnBlock column = block.column_block(i);
if (column.is_nullable()) {
RETURN_NOT_OK(cfile_writers_[i]->AppendNullableEntries(column.non_null_bitmap(),
@@ -116,13 +119,14 @@ Status MultiColumnWriter::AppendBlock(const RowBlock&
block) {
Status MultiColumnWriter::FinishAndReleaseBlocks(
BlockCreationTransaction* transaction) {
- CHECK(!finished_);
- for (int i = 0; i < schema_->num_columns(); i++) {
- CFileWriter *writer = cfile_writers_[i];
- Status s = writer->FinishAndReleaseBlock(transaction);
- if (!s.ok()) {
- LOG(WARNING) << "Unable to Finish writer for column " <<
- schema_->column(i).ToString() << ": " << s.ToString();
+ DCHECK(open_);
+ DCHECK(!finished_);
+ for (auto i = 0; i < schema_->num_columns(); ++i) {
+ auto s = cfile_writers_[i]->FinishAndReleaseBlock(transaction);
+ if (PREDICT_FALSE(!s.ok())) {
+ LOG(ERROR) << Substitute(
+ "tablet $0: unable to finialize writer for column $1",
+ tablet_id_, schema_->column(i).ToString());
return s;
}
}
@@ -130,17 +134,19 @@ Status MultiColumnWriter::FinishAndReleaseBlocks(
return Status::OK();
}
-void MultiColumnWriter::GetFlushedBlocksByColumnId(std::map<ColumnId,
BlockId>* ret) const {
- CHECK(finished_);
- ret->clear();
- for (int i = 0; i < schema_->num_columns(); i++) {
- (*ret)[schema_->column_id(i)] = block_ids_[i];
+void MultiColumnWriter::GetFlushedBlocksByColumnId(map<ColumnId, BlockId>*
ret) const {
+ DCHECK(finished_);
+ auto& r = *ret;
+ r.clear();
+ for (auto i = 0; i < schema_->num_columns(); ++i) {
+ r[schema_->column_id(i)] = block_ids_[i];
}
}
size_t MultiColumnWriter::written_size() const {
+ DCHECK(open_);
size_t size = 0;
- for (const CFileWriter *writer : cfile_writers_) {
+ for (const auto& writer: cfile_writers_) {
size += writer->written_size();
}
return size;
diff --git a/src/kudu/tablet/multi_column_writer.h
b/src/kudu/tablet/multi_column_writer.h
index 259d0bc61..1538035cd 100644
--- a/src/kudu/tablet/multi_column_writer.h
+++ b/src/kudu/tablet/multi_column_writer.h
@@ -14,16 +14,16 @@
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
-#ifndef KUDU_TABLET_MULTI_COLUMN_WRITER_H
-#define KUDU_TABLET_MULTI_COLUMN_WRITER_H
#include <cstddef>
#include <map>
+#include <memory>
#include <string>
#include <vector>
#include <glog/logging.h>
+#include "kudu/cfile/cfile_writer.h"
#include "kudu/fs/block_id.h"
#include "kudu/gutil/macros.h"
#include "kudu/util/status.h"
@@ -35,10 +35,6 @@ class RowBlock;
class Schema;
struct ColumnId;
-namespace cfile {
-class CFileWriter;
-} // namespace cfile
-
namespace fs {
class BlockCreationTransaction;
} // namespace fs
@@ -47,13 +43,13 @@ namespace tablet {
// Wrapper which writes several columns in parallel corresponding to some
// Schema. Written blocks will fall in the tablet_id's data dir group.
-class MultiColumnWriter {
+class MultiColumnWriter final {
public:
MultiColumnWriter(FsManager* fs,
const Schema* schema,
std::string tablet_id);
- virtual ~MultiColumnWriter();
+ ~MultiColumnWriter() = default;
// Open and start writing the columns.
Status Open();
@@ -70,9 +66,9 @@ class MultiColumnWriter {
// Return the number of bytes written so far.
size_t written_size() const;
- cfile::CFileWriter* writer_for_col_idx(int i) {
- DCHECK_LT(i, cfile_writers_.size());
- return cfile_writers_[i];
+ cfile::CFileWriter* writer_for_col_idx(size_t i) {
+ CHECK_LT(i, cfile_writers_.size());
+ return cfile_writers_[i].get();
}
// Return the block IDs of the written columns, keyed by column ID.
@@ -83,17 +79,15 @@ class MultiColumnWriter {
private:
FsManager* const fs_;
const Schema* const schema_;
-
- bool finished_;
-
const std::string tablet_id_;
- std::vector<cfile::CFileWriter *> cfile_writers_;
+ std::vector<std::unique_ptr<cfile::CFileWriter>> cfile_writers_;
std::vector<BlockId> block_ids_;
+ bool open_;
+ bool finished_;
DISALLOW_COPY_AND_ASSIGN(MultiColumnWriter);
};
} // namespace tablet
} // namespace kudu
-#endif /* KUDU_TABLET_MULTI_COLUMN_WRITER_H */
