From 1f2dca0eaa21ec24103290a82d21af12050b4977 Mon Sep 17 00:00:00 2001 From: Islam AbdelRahman Date: Thu, 19 May 2016 15:51:29 -0700 Subject: [PATCH] Add MaxOperator to utilities/merge_operators/ Summary: Introduce MaxOperator a simple merge operator that return the max of all operands. This merge operand help me in benchmarking Test Plan: Add new unitttests Reviewers: sdong, andrewkr, yhchiang Reviewed By: yhchiang Subscribers: andrewkr, dhruba Differential Revision: https://reviews.facebook.net/D57873 --- CMakeLists.txt | 1 + Makefile | 4 ++ src.mk | 1 + utilities/merge_operators.h | 3 + utilities/merge_operators/max.cc | 77 +++++++++++++++++++++++++ utilities/util_merge_operators_test.cc | 80 ++++++++++++++++++++++++++ 6 files changed, 166 insertions(+) create mode 100644 utilities/merge_operators/max.cc create mode 100644 utilities/util_merge_operators_test.cc diff --git a/CMakeLists.txt b/CMakeLists.txt index da9769071..f3a1a7677 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -260,6 +260,7 @@ set(SOURCES utilities/merge_operators/string_append/stringappend.cc utilities/merge_operators/string_append/stringappend2.cc utilities/merge_operators/put.cc + utilities/merge_operators/max.cc utilities/merge_operators/uint64add.cc utilities/options/options_util.cc utilities/redis/redis_lists.cc diff --git a/Makefile b/Makefile index 293cfa0e6..8e2554cda 100644 --- a/Makefile +++ b/Makefile @@ -310,6 +310,7 @@ TESTS = \ memory_test \ merge_test \ merger_test \ + util_merge_operators_test \ options_file_test \ redis_test \ reduce_levels_test \ @@ -1064,6 +1065,9 @@ merge_test: db/merge_test.o $(LIBOBJECTS) $(TESTHARNESS) merger_test: table/merger_test.o $(LIBOBJECTS) $(TESTHARNESS) $(AM_LINK) +util_merge_operators_test: utilities/util_merge_operators_test.o $(LIBOBJECTS) $(TESTHARNESS) + $(AM_LINK) + options_file_test: db/options_file_test.o $(LIBOBJECTS) $(TESTHARNESS) $(AM_LINK) diff --git a/src.mk b/src.mk index 7f7f4030b..ac98fc0ee 100644 --- a/src.mk +++ b/src.mk @@ -126,6 +126,7 @@ LIB_SOURCES = \ utilities/leveldb_options/leveldb_options.cc \ utilities/memory/memory_util.cc \ utilities/merge_operators/put.cc \ + utilities/merge_operators/max.cc \ utilities/merge_operators/string_append/stringappend2.cc \ utilities/merge_operators/string_append/stringappend.cc \ utilities/merge_operators/uint64add.cc \ diff --git a/utilities/merge_operators.h b/utilities/merge_operators.h index eb60ed5cc..1ad5c290f 100644 --- a/utilities/merge_operators.h +++ b/utilities/merge_operators.h @@ -19,6 +19,7 @@ class MergeOperators { static std::shared_ptr CreateUInt64AddOperator(); static std::shared_ptr CreateStringAppendOperator(); static std::shared_ptr CreateStringAppendTESTOperator(); + static std::shared_ptr CreateMaxOperator(); // Will return a different merge operator depending on the string. // TODO: Hook the "name" up to the actual Name() of the MergeOperators? @@ -32,6 +33,8 @@ class MergeOperators { return CreateStringAppendOperator(); } else if (name == "stringappendtest") { return CreateStringAppendTESTOperator(); + } else if (name == "max") { + return CreateMaxOperator(); } else { // Empty or unknown, just return nullptr return nullptr; diff --git a/utilities/merge_operators/max.cc b/utilities/merge_operators/max.cc new file mode 100644 index 000000000..ee05a7cc2 --- /dev/null +++ b/utilities/merge_operators/max.cc @@ -0,0 +1,77 @@ +// Copyright (c) 2011-present, Facebook, Inc. All rights reserved. +// This source code is licensed under the BSD-style license found in the +// LICENSE file in the root directory of this source tree. An additional grant +// of patent rights can be found in the PATENTS file in the same directory. + +#include + +#include "rocksdb/merge_operator.h" +#include "rocksdb/slice.h" +#include "utilities/merge_operators.h" + +using rocksdb::Slice; +using rocksdb::Logger; +using rocksdb::MergeOperator; + +namespace { // anonymous namespace + +// Merge operator that picks the maximum operand, Comparison is based on +// Slice::compare +class MaxOperator : public MergeOperator { + public: + virtual bool FullMerge(const Slice& key, const Slice* existing_value, + const std::deque& operand_list, + std::string* new_value, + Logger* logger) const override { + Slice max; + if (existing_value) { + max = Slice(existing_value->data(), existing_value->size()); + } + + for (const auto& op : operand_list) { + if (max.compare(op) < 0) { + max = Slice(op.data(), op.size()); + } + } + + new_value->assign(max.data(), max.size()); + return true; + } + + virtual bool PartialMerge(const Slice& key, const Slice& left_operand, + const Slice& right_operand, std::string* new_value, + Logger* logger) const override { + if (left_operand.compare(right_operand) >= 0) { + new_value->assign(left_operand.data(), left_operand.size()); + } else { + new_value->assign(right_operand.data(), right_operand.size()); + } + return true; + } + + virtual bool PartialMergeMulti(const Slice& key, + const std::deque& operand_list, + std::string* new_value, + Logger* logger) const override { + Slice max; + for (const auto& operand : operand_list) { + if (max.compare(operand) < 0) { + max = operand; + } + } + + new_value->assign(max.data(), max.size()); + return true; + } + + virtual const char* Name() const override { return "MaxOperator"; } +}; + +} // end of anonymous namespace + +namespace rocksdb { + +std::shared_ptr MergeOperators::CreateMaxOperator() { + return std::make_shared(); +} +} diff --git a/utilities/util_merge_operators_test.cc b/utilities/util_merge_operators_test.cc new file mode 100644 index 000000000..c80ce6ffb --- /dev/null +++ b/utilities/util_merge_operators_test.cc @@ -0,0 +1,80 @@ +// Copyright (c) 2011-present, Facebook, Inc. All rights reserved. +// This source code is licensed under the BSD-style license found in the +// LICENSE file in the root directory of this source tree. An additional grant +// of patent rights can be found in the PATENTS file in the same directory. + +#include "util/testharness.h" +#include "util/testutil.h" +#include "utilities/merge_operators.h" + +namespace rocksdb { + +class UtilMergeOperatorTest : public testing::Test { + public: + UtilMergeOperatorTest() {} + + std::string FullMerge(std::string existing_value, + std::deque operands, + std::string key = "") { + Slice existing_value_slice(existing_value); + std::string result; + + merge_operator_->FullMerge(key, &existing_value_slice, operands, &result, + nullptr); + return result; + } + + std::string FullMerge(std::deque operands, + std::string key = "") { + std::string result; + + merge_operator_->FullMerge(key, nullptr, operands, &result, nullptr); + return result; + } + + std::string PartialMerge(std::string left, std::string right, + std::string key = "") { + std::string result; + + merge_operator_->PartialMerge(key, left, right, &result, nullptr); + return result; + } + + std::string PartialMergeMulti(std::deque operands, + std::string key = "") { + std::string result; + std::deque operands_slice(operands.begin(), operands.end()); + + merge_operator_->PartialMergeMulti(key, operands_slice, &result, nullptr); + return result; + } + + protected: + std::shared_ptr merge_operator_; +}; + +TEST_F(UtilMergeOperatorTest, MaxMergeOperator) { + merge_operator_ = MergeOperators::CreateMaxOperator(); + + EXPECT_EQ("B", FullMerge("B", {"A"})); + EXPECT_EQ("B", FullMerge("A", {"B"})); + EXPECT_EQ("", FullMerge({"", "", ""})); + EXPECT_EQ("A", FullMerge({"A"})); + EXPECT_EQ("ABC", FullMerge({"ABC"})); + EXPECT_EQ("Z", FullMerge({"ABC", "Z", "C", "AXX"})); + EXPECT_EQ("ZZZ", FullMerge({"ABC", "CC", "Z", "ZZZ"})); + EXPECT_EQ("a", FullMerge("a", {"ABC", "CC", "Z", "ZZZ"})); + + EXPECT_EQ("z", PartialMergeMulti({"a", "z", "efqfqwgwew", "aaz", "hhhhh"})); + + EXPECT_EQ("b", PartialMerge("a", "b")); + EXPECT_EQ("z", PartialMerge("z", "azzz")); + EXPECT_EQ("a", PartialMerge("a", "")); +} + +} // namespace rocksdb + +int main(int argc, char** argv) { + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +}