NextGraph
/
rocksdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Refactor Option obj address from char* to void* (#8295)

Browse Source 
Summary:
And replace `reinterpret_cast` with `static_cast` or no cast.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/8295

Test Plan: `make check`

Reviewed By: mrambacher

Differential Revision: D28420303

Pulled By: jay-zhuang

fbshipit-source-id: 645be123a0df624dc2bea37cd54a35403fc494fa
main
Jay Zhuang 4 years ago committed by Facebook GitHub Bot
parent d76c46e6a0
commit d15fbae449
8 changed files with 177 additions and 194 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 6
      cache/cache.cc
  2. 35
      db/compaction/compaction_job.cc
  3. 93
      include/rocksdb/utilities/options_type.h
  4. 34
      options/cf_options.cc
  5. 9
      options/db_options.cc
  6. 144
      options/options_helper.cc
  7. 19
      options/options_test.cc
  8. 31
      table/block_based/block_based_table_factory.cc

6
cache/cache.cc vendored
Unescape View File

@ -44,9 +44,9 @@ Status Cache::CreateFromString(const ConfigOptions& config_options,
} else { } else {
#ifndef ROCKSDB_LITE #ifndef ROCKSDB_LITE
LRUCacheOptions cache_opts; LRUCacheOptions cache_opts;
status = OptionTypeInfo::ParseStruct( status = OptionTypeInfo::ParseStruct(config_options, "",
config_options, "", &lru_cache_options_type_info, "", value, &lru_cache_options_type_info, "",
reinterpret_cast<char*>(&cache_opts)); value, &cache_opts);
if (status.ok()) { if (status.ok()) {
cache = NewLRUCache(cache_opts); cache = NewLRUCache(cache_opts);
} }

35
db/compaction/compaction_job.cc
Unescape View File

@ -2102,27 +2102,24 @@ static std::unordered_map<std::string, OptionTypeInfo> cfd_type_info = {
{offset_of(&ColumnFamilyDescriptor::options), OptionType::kConfigurable, {offset_of(&ColumnFamilyDescriptor::options), OptionType::kConfigurable,
OptionVerificationType::kNormal, OptionTypeFlags::kNone, OptionVerificationType::kNormal, OptionTypeFlags::kNone,
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto cf_options = reinterpret_cast<ColumnFamilyOptions*>(addr); auto cf_options = static_cast<ColumnFamilyOptions*>(addr);
return GetColumnFamilyOptionsFromString(opts, ColumnFamilyOptions(), return GetColumnFamilyOptionsFromString(opts, ColumnFamilyOptions(),
value, cf_options); value, cf_options);
}, },
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const char* addr, std::string* value) { const void* addr, std::string* value) {
const auto cf_options = const auto cf_options = static_cast<const ColumnFamilyOptions*>(addr);
reinterpret_cast<const ColumnFamilyOptions*>(addr);
std::string result; std::string result;
auto status = auto status =
GetStringFromColumnFamilyOptions(opts, *cf_options, &result); GetStringFromColumnFamilyOptions(opts, *cf_options, &result);
*value = "{" + result + "}"; *value = "{" + result + "}";
return status; return status;
}, },
[](const ConfigOptions& opts, const std::string& name, const char* addr1, [](const ConfigOptions& opts, const std::string& name, const void* addr1,
const char* addr2, std::string* mismatch) { const void* addr2, std::string* mismatch) {
const auto this_one = const auto this_one = static_cast<const ColumnFamilyOptions*>(addr1);
reinterpret_cast<const ColumnFamilyOptions*>(addr1); const auto that_one = static_cast<const ColumnFamilyOptions*>(addr2);
const auto that_one =
reinterpret_cast<const ColumnFamilyOptions*>(addr2);
auto this_conf = CFOptionsAsConfigurable(*this_one); auto this_conf = CFOptionsAsConfigurable(*this_one);
auto that_conf = CFOptionsAsConfigurable(*that_one); auto that_conf = CFOptionsAsConfigurable(*that_one);
std::string mismatch_opt; std::string mismatch_opt;
@ -2145,22 +2142,22 @@ static std::unordered_map<std::string, OptionTypeInfo> cs_input_type_info = {
{offset_of(&CompactionServiceInput::db_options), OptionType::kConfigurable, {offset_of(&CompactionServiceInput::db_options), OptionType::kConfigurable,
OptionVerificationType::kNormal, OptionTypeFlags::kNone, OptionVerificationType::kNormal, OptionTypeFlags::kNone,
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto options = reinterpret_cast<DBOptions*>(addr); auto options = static_cast<DBOptions*>(addr);
return GetDBOptionsFromString(opts, DBOptions(), value, options); return GetDBOptionsFromString(opts, DBOptions(), value, options);
}, },
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const char* addr, std::string* value) { const void* addr, std::string* value) {
const auto options = reinterpret_cast<const DBOptions*>(addr); const auto options = static_cast<const DBOptions*>(addr);
std::string result; std::string result;
auto status = GetStringFromDBOptions(opts, *options, &result); auto status = GetStringFromDBOptions(opts, *options, &result);
*value = "{" + result + "}"; *value = "{" + result + "}";
return status; return status;
}, },
[](const ConfigOptions& opts, const std::string& name, const char* addr1, [](const ConfigOptions& opts, const std::string& name, const void* addr1,
const char* addr2, std::string* mismatch) { const void* addr2, std::string* mismatch) {
const auto this_one = reinterpret_cast<const DBOptions*>(addr1); const auto this_one = static_cast<const DBOptions*>(addr1);
const auto that_one = reinterpret_cast<const DBOptions*>(addr2); const auto that_one = static_cast<const DBOptions*>(addr2);
auto this_conf = DBOptionsAsConfigurable(*this_one); auto this_conf = DBOptionsAsConfigurable(*this_one);
auto that_conf = DBOptionsAsConfigurable(*that_one); auto that_conf = DBOptionsAsConfigurable(*that_one);
std::string mismatch_opt; std::string mismatch_opt;

93
include/rocksdb/utilities/options_type.h
Unescape View File

@ -177,7 +177,7 @@ bool VectorsAreEqual(const ConfigOptions& config_options,
// @param addr Pointer to the object // @param addr Pointer to the object
using ParseFunc = std::function<Status( using ParseFunc = std::function<Status(
const ConfigOptions& /*opts*/, const std::string& /*name*/, const ConfigOptions& /*opts*/, const std::string& /*name*/,
const std::string& /*value*/, char* /*addr*/)>; const std::string& /*value*/, void* /*addr*/)>;
// Function for converting an option "addr" into its string representation. // Function for converting an option "addr" into its string representation.
// On success, Status::OK is returned and value is the serialized form. // On success, Status::OK is returned and value is the serialized form.
@ -188,7 +188,7 @@ using ParseFunc = std::function<Status(
// @param value The result of the serialization. // @param value The result of the serialization.
using SerializeFunc = std::function<Status( using SerializeFunc = std::function<Status(
const ConfigOptions& /*opts*/, const std::string& /*name*/, const ConfigOptions& /*opts*/, const std::string& /*name*/,
const char* /*addr*/, std::string* /*value*/)>; const void* /*addr*/, std::string* /*value*/)>;
// Function for comparing two option values // Function for comparing two option values
// If they are not equal, updates "mismatch" with the name of the bad option // If they are not equal, updates "mismatch" with the name of the bad option
@ -200,7 +200,7 @@ using SerializeFunc = std::function<Status(
// first differs // first differs
using EqualsFunc = std::function<bool( using EqualsFunc = std::function<bool(
const ConfigOptions& /*opts*/, const std::string& /*name*/, const ConfigOptions& /*opts*/, const std::string& /*name*/,
const char* /*addr1*/, const char* /*addr2*/, std::string* mismatch)>; const void* /*addr1*/, const void* /*addr2*/, std::string* mismatch)>;
// A struct for storing constant option information such as option name, // A struct for storing constant option information such as option name,
// option type, and offset. // option type, and offset.
@ -273,10 +273,10 @@ class OptionTypeInfo {
// @return OK if the value is found in the map // @return OK if the value is found in the map
// @return InvalidArgument if the value is not found in the map // @return InvalidArgument if the value is not found in the map
[map](const ConfigOptions&, const std::string& name, [map](const ConfigOptions&, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
if (map == nullptr) { if (map == nullptr) {
return Status::NotSupported("No enum mapping ", name); return Status::NotSupported("No enum mapping ", name);
} else if (ParseEnum<T>(*map, value, reinterpret_cast<T*>(addr))) { } else if (ParseEnum<T>(*map, value, static_cast<T*>(addr))) {
return Status::OK(); return Status::OK();
} else { } else {
return Status::InvalidArgument("No mapping for enum ", name); return Status::InvalidArgument("No mapping for enum ", name);
@ -287,11 +287,11 @@ class OptionTypeInfo {
// value is updated to the corresponding string value in the map. // value is updated to the corresponding string value in the map.
// @return OK if the enum is found in the map // @return OK if the enum is found in the map
// @return InvalidArgument if the enum is not found in the map // @return InvalidArgument if the enum is not found in the map
[map](const ConfigOptions&, const std::string& name, const char* addr, [map](const ConfigOptions&, const std::string& name, const void* addr,
std::string* value) { std::string* value) {
if (map == nullptr) { if (map == nullptr) {
return Status::NotSupported("No enum mapping ", name); return Status::NotSupported("No enum mapping ", name);
} else if (SerializeEnum<T>(*map, (*reinterpret_cast<const T*>(addr)), } else if (SerializeEnum<T>(*map, (*static_cast<const T*>(addr)),
value)) { value)) {
return Status::OK(); return Status::OK();
} else { } else {
@ -300,10 +300,10 @@ class OptionTypeInfo {
}, },
// Casts addr1 and addr2 to the enum type and returns true if // Casts addr1 and addr2 to the enum type and returns true if
// they are equal, false otherwise. // they are equal, false otherwise.
[](const ConfigOptions&, const std::string&, const char* addr1, [](const ConfigOptions&, const std::string&, const void* addr1,
const char* addr2, std::string*) { const void* addr2, std::string*) {
return (*reinterpret_cast<const T*>(addr1) == return (*static_cast<const T*>(addr1) ==
*reinterpret_cast<const T*>(addr2)); *static_cast<const T*>(addr2));
}); });
} // End OptionTypeInfo::Enum } // End OptionTypeInfo::Enum
@ -338,20 +338,20 @@ class OptionTypeInfo {
// Parses the struct and updates the fields at addr // Parses the struct and updates the fields at addr
[struct_name, struct_map](const ConfigOptions& opts, [struct_name, struct_map](const ConfigOptions& opts,
const std::string& name, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
return ParseStruct(opts, struct_name, struct_map, name, value, addr); return ParseStruct(opts, struct_name, struct_map, name, value, addr);
}, },
// Serializes the struct options into value // Serializes the struct options into value
[struct_name, struct_map](const ConfigOptions& opts, [struct_name, struct_map](const ConfigOptions& opts,
const std::string& name, const char* addr, const std::string& name, const void* addr,
std::string* value) { std::string* value) {
return SerializeStruct(opts, struct_name, struct_map, name, addr, return SerializeStruct(opts, struct_name, struct_map, name, addr,
value); value);
}, },
// Compares the struct fields of addr1 and addr2 for equality // Compares the struct fields of addr1 and addr2 for equality
[struct_name, struct_map](const ConfigOptions& opts, [struct_name, struct_map](const ConfigOptions& opts,
const std::string& name, const char* addr1, const std::string& name, const void* addr1,
const char* addr2, std::string* mismatch) { const void* addr2, std::string* mismatch) {
return StructsAreEqual(opts, struct_name, struct_map, name, addr1, return StructsAreEqual(opts, struct_name, struct_map, name, addr1,
addr2, mismatch); addr2, mismatch);
}); });
@ -364,14 +364,14 @@ class OptionTypeInfo {
return OptionTypeInfo( return OptionTypeInfo(
offset, OptionType::kStruct, verification, flags, parse_func, offset, OptionType::kStruct, verification, flags, parse_func,
[struct_name, struct_map](const ConfigOptions& opts, [struct_name, struct_map](const ConfigOptions& opts,
const std::string& name, const char* addr, const std::string& name, const void* addr,
std::string* value) { std::string* value) {
return SerializeStruct(opts, struct_name, struct_map, name, addr, return SerializeStruct(opts, struct_name, struct_map, name, addr,
value); value);
}, },
[struct_name, struct_map](const ConfigOptions& opts, [struct_name, struct_map](const ConfigOptions& opts,
const std::string& name, const char* addr1, const std::string& name, const void* addr1,
const char* addr2, std::string* mismatch) { const void* addr2, std::string* mismatch) {
return StructsAreEqual(opts, struct_name, struct_map, name, addr1, return StructsAreEqual(opts, struct_name, struct_map, name, addr1,
addr2, mismatch); addr2, mismatch);
}); });
@ -387,23 +387,23 @@ class OptionTypeInfo {
_offset, OptionType::kVector, _verification, _flags, _offset, OptionType::kVector, _verification, _flags,
[elem_info, separator](const ConfigOptions& opts, [elem_info, separator](const ConfigOptions& opts,
const std::string& name, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto result = reinterpret_cast<std::vector<T>*>(addr); auto result = static_cast<std::vector<T>*>(addr);
return ParseVector<T>(opts, elem_info, separator, name, value, return ParseVector<T>(opts, elem_info, separator, name, value,
result); result);
}, },
[elem_info, separator](const ConfigOptions& opts, [elem_info, separator](const ConfigOptions& opts,
const std::string& name, const char* addr, const std::string& name, const void* addr,
std::string* value) { std::string* value) {
const auto& vec = *(reinterpret_cast<const std::vector<T>*>(addr)); const auto& vec = *(static_cast<const std::vector<T>*>(addr));
return SerializeVector<T>(opts, elem_info, separator, name, vec, return SerializeVector<T>(opts, elem_info, separator, name, vec,
value); value);
}, },
[elem_info](const ConfigOptions& opts, const std::string& name, [elem_info](const ConfigOptions& opts, const std::string& name,
const char* addr1, const char* addr2, const void* addr1, const void* addr2,
std::string* mismatch) { std::string* mismatch) {
const auto& vec1 = *(reinterpret_cast<const std::vector<T>*>(addr1)); const auto& vec1 = *(static_cast<const std::vector<T>*>(addr1));
const auto& vec2 = *(reinterpret_cast<const std::vector<T>*>(addr2)); const auto& vec2 = *(static_cast<const std::vector<T>*>(addr2));
return VectorsAreEqual<T>(opts, elem_info, name, vec1, vec2, return VectorsAreEqual<T>(opts, elem_info, name, vec1, vec2,
mismatch); mismatch);
}); });
@ -435,8 +435,8 @@ class OptionTypeInfo {
offset, OptionType::kCustomizable, ovt, offset, OptionType::kCustomizable, ovt,
flags | OptionTypeFlags::kShared, flags | OptionTypeFlags::kShared,
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto* shared = reinterpret_cast<std::shared_ptr<T>*>(addr); auto* shared = static_cast<std::shared_ptr<T>*>(addr);
return T::CreateFromString(opts, value, shared); return T::CreateFromString(opts, value, shared);
}, },
serialize_func, equals_func); serialize_func, equals_func);
@ -468,8 +468,8 @@ class OptionTypeInfo {
offset, OptionType::kCustomizable, ovt, offset, OptionType::kCustomizable, ovt,
flags | OptionTypeFlags::kUnique, flags | OptionTypeFlags::kUnique,
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto* unique = reinterpret_cast<std::unique_ptr<T>*>(addr); auto* unique = static_cast<std::unique_ptr<T>*>(addr);
return T::CreateFromString(opts, value, unique); return T::CreateFromString(opts, value, unique);
}, },
serialize_func, equals_func); serialize_func, equals_func);
@ -499,8 +499,8 @@ class OptionTypeInfo {
offset, OptionType::kCustomizable, ovt, offset, OptionType::kCustomizable, ovt,
flags | OptionTypeFlags::kRawPointer, flags | OptionTypeFlags::kRawPointer,
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto** pointer = reinterpret_cast<T**>(addr); auto** pointer = static_cast<T**>(addr);
return T::CreateFromString(opts, value, pointer); return T::CreateFromString(opts, value, pointer);
}, },
serialize_func, equals_func); serialize_func, equals_func);
@ -596,20 +596,20 @@ class OptionTypeInfo {
if (base_addr == nullptr) { if (base_addr == nullptr) {
return nullptr; return nullptr;
} }
const auto opt_addr = reinterpret_cast<const char*>(base_addr) + offset_; const void* opt_addr = static_cast<const char*>(base_addr) + offset_;
if (IsUniquePtr()) { if (IsUniquePtr()) {
const std::unique_ptr<T>* ptr = const std::unique_ptr<T>* ptr =
reinterpret_cast<const std::unique_ptr<T>*>(opt_addr); static_cast<const std::unique_ptr<T>*>(opt_addr);
return ptr->get(); return ptr->get();
} else if (IsSharedPtr()) { } else if (IsSharedPtr()) {
const std::shared_ptr<T>* ptr = const std::shared_ptr<T>* ptr =
reinterpret_cast<const std::shared_ptr<T>*>(opt_addr); static_cast<const std::shared_ptr<T>*>(opt_addr);
return ptr->get(); return ptr->get();
} else if (IsRawPtr()) { } else if (IsRawPtr()) {
const T* const* ptr = reinterpret_cast<const T* const*>(opt_addr); const T* const* ptr = static_cast<const T* const*>(opt_addr);
return *ptr; return *ptr;
} else { } else {
return reinterpret_cast<const T*>(opt_addr); return static_cast<const T*>(opt_addr);
} }
} }
@ -620,18 +620,18 @@ class OptionTypeInfo {
if (base_addr == nullptr) { if (base_addr == nullptr) {
return nullptr; return nullptr;
} }
auto opt_addr = reinterpret_cast<char*>(base_addr) + offset_; void* opt_addr = static_cast<char*>(base_addr) + offset_;
if (IsUniquePtr()) { if (IsUniquePtr()) {
std::unique_ptr<T>* ptr = reinterpret_cast<std::unique_ptr<T>*>(opt_addr); std::unique_ptr<T>* ptr = static_cast<std::unique_ptr<T>*>(opt_addr);
return ptr->get(); return ptr->get();
} else if (IsSharedPtr()) { } else if (IsSharedPtr()) {
std::shared_ptr<T>* ptr = reinterpret_cast<std::shared_ptr<T>*>(opt_addr); std::shared_ptr<T>* ptr = static_cast<std::shared_ptr<T>*>(opt_addr);
return ptr->get(); return ptr->get();
} else if (IsRawPtr()) { } else if (IsRawPtr()) {
T** ptr = reinterpret_cast<T**>(opt_addr); T** ptr = static_cast<T**>(opt_addr);
return *ptr; return *ptr;
} else { } else {
return reinterpret_cast<T*>(opt_addr); return static_cast<T*>(opt_addr);
} }
} }
@ -704,7 +704,7 @@ class OptionTypeInfo {
static Status ParseStruct( static Status ParseStruct(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* map, const std::unordered_map<std::string, OptionTypeInfo>* map,
const std::string& opt_name, const std::string& value, char* opt_addr); const std::string& opt_name, const std::string& value, void* opt_addr);
// Serializes the values from opt_addr using the rules in type_map. // Serializes the values from opt_addr using the rules in type_map.
// Returns the serialized form in result. // Returns the serialized form in result.
@ -721,7 +721,7 @@ class OptionTypeInfo {
static Status SerializeStruct( static Status SerializeStruct(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* map, const std::unordered_map<std::string, OptionTypeInfo>* map,
const std::string& opt_name, const char* opt_addr, std::string* value); const std::string& opt_name, const void* opt_addr, std::string* value);
// Compares the values in this_addr and that_addr using the rules in type_map. // Compares the values in this_addr and that_addr using the rules in type_map.
// If the values are equal, returns true // If the values are equal, returns true
@ -740,8 +740,8 @@ class OptionTypeInfo {
static bool StructsAreEqual( static bool StructsAreEqual(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* map, const std::unordered_map<std::string, OptionTypeInfo>* map,
const std::string& opt_name, const char* this_offset, const std::string& opt_name, const void* this_offset,
const char* that_offset, std::string* mismatch); const void* that_offset, std::string* mismatch);
// Finds the entry for the opt_name in the opt_map, returning // Finds the entry for the opt_name in the opt_map, returning
// nullptr if not found. // nullptr if not found.
@ -831,8 +831,7 @@ Status ParseVector(const ConfigOptions& config_options,
status = OptionTypeInfo::NextToken(value, separator, start, &end, &token); status = OptionTypeInfo::NextToken(value, separator, start, &end, &token);
if (status.ok()) { if (status.ok()) {
T elem; T elem;
status = status = elem_info.Parse(copy, name, token, &elem);
elem_info.Parse(copy, name, token, reinterpret_cast<char*>(&elem));
if (status.ok()) { if (status.ok()) {
result->emplace_back(elem); result->emplace_back(elem);
} else if (config_options.ignore_unsupported_options && } else if (config_options.ignore_unsupported_options &&

34
options/cf_options.cc
Unescape View File

@ -364,7 +364,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
offsetof(struct MutableCFOptions, compaction_options_fifo), offsetof(struct MutableCFOptions, compaction_options_fifo),
OptionVerificationType::kNormal, OptionTypeFlags::kMutable, OptionVerificationType::kNormal, OptionTypeFlags::kMutable,
[](const ConfigOptions& opts, const std::string& name, [](const ConfigOptions& opts, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
// This is to handle backward compatibility, where // This is to handle backward compatibility, where
// compaction_options_fifo could be assigned a single scalar // compaction_options_fifo could be assigned a single scalar
// value, say, like "23", which would be assigned to // value, say, like "23", which would be assigned to
@ -372,7 +372,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
if (name == "compaction_options_fifo" && if (name == "compaction_options_fifo" &&
value.find("=") == std::string::npos) { value.find("=") == std::string::npos) {
// Old format. Parse just a single uint64_t value. // Old format. Parse just a single uint64_t value.
auto options = reinterpret_cast<CompactionOptionsFIFO*>(addr); auto options = static_cast<CompactionOptionsFIFO*>(addr);
options->max_table_files_size = ParseUint64(value); options->max_table_files_size = ParseUint64(value);
return Status::OK(); return Status::OK();
} else { } else {
@ -433,13 +433,12 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionVerificationType::kNormal, OptionVerificationType::kNormal,
(OptionTypeFlags::kMutable | OptionTypeFlags::kCompareNever), (OptionTypeFlags::kMutable | OptionTypeFlags::kCompareNever),
[](const ConfigOptions& opts, const std::string& name, [](const ConfigOptions& opts, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
// This is to handle backward compatibility, where // This is to handle backward compatibility, where
// compression_options was a ":" separated list. // compression_options was a ":" separated list.
if (name == kOptNameCompOpts && if (name == kOptNameCompOpts &&
value.find("=") == std::string::npos) { value.find("=") == std::string::npos) {
auto* compression = auto* compression = static_cast<CompressionOptions*>(addr);
reinterpret_cast<CompressionOptions*>(addr);
return ParseCompressionOptions(value, name, *compression); return ParseCompressionOptions(value, name, *compression);
} else { } else {
return OptionTypeInfo::ParseStruct( return OptionTypeInfo::ParseStruct(
@ -454,13 +453,12 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionVerificationType::kNormal, OptionVerificationType::kNormal,
(OptionTypeFlags::kMutable | OptionTypeFlags::kCompareNever), (OptionTypeFlags::kMutable | OptionTypeFlags::kCompareNever),
[](const ConfigOptions& opts, const std::string& name, [](const ConfigOptions& opts, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
// This is to handle backward compatibility, where // This is to handle backward compatibility, where
// compression_options was a ":" separated list. // compression_options was a ":" separated list.
if (name == kOptNameBMCompOpts && if (name == kOptNameBMCompOpts &&
value.find("=") == std::string::npos) { value.find("=") == std::string::npos) {
auto* compression = auto* compression = static_cast<CompressionOptions*>(addr);
reinterpret_cast<CompressionOptions*>(addr);
return ParseCompressionOptions(value, name, *compression); return ParseCompressionOptions(value, name, *compression);
} else { } else {
return OptionTypeInfo::ParseStruct( return OptionTypeInfo::ParseStruct(
@ -542,8 +540,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kCompareLoose, OptionTypeFlags::kCompareLoose,
// Parses the string and sets the corresponding comparator // Parses the string and sets the corresponding comparator
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto old_comparator = reinterpret_cast<const Comparator**>(addr); auto old_comparator = static_cast<const Comparator**>(addr);
const Comparator* new_comparator = *old_comparator; const Comparator* new_comparator = *old_comparator;
Status status = Status status =
opts.registry->NewStaticObject(value, &new_comparator); opts.registry->NewStaticObject(value, &new_comparator);
@ -568,12 +566,12 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kNone, OptionTypeFlags::kNone,
// Parses the value string and updates the memtable_factory // Parses the value string and updates the memtable_factory
[](const ConfigOptions& /*opts*/, const std::string& /*name*/, [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
std::unique_ptr<MemTableRepFactory> new_mem_factory; std::unique_ptr<MemTableRepFactory> new_mem_factory;
Status s = GetMemTableRepFactoryFromString(value, &new_mem_factory); Status s = GetMemTableRepFactoryFromString(value, &new_mem_factory);
if (s.ok()) { if (s.ok()) {
auto memtable_factory = auto memtable_factory =
reinterpret_cast<std::shared_ptr<MemTableRepFactory>*>(addr); static_cast<std::shared_ptr<MemTableRepFactory>*>(addr);
memtable_factory->reset(new_mem_factory.release()); memtable_factory->reset(new_mem_factory.release());
} }
return s; return s;
@ -590,10 +588,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose, OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose,
// Parses the input value and creates a BlockBasedTableFactory // Parses the input value and creates a BlockBasedTableFactory
[](const ConfigOptions& opts, const std::string& name, [](const ConfigOptions& opts, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
BlockBasedTableOptions* old_opts = nullptr; BlockBasedTableOptions* old_opts = nullptr;
auto table_factory = auto table_factory =
reinterpret_cast<std::shared_ptr<TableFactory>*>(addr); static_cast<std::shared_ptr<TableFactory>*>(addr);
if (table_factory->get() != nullptr) { if (table_factory->get() != nullptr) {
old_opts = old_opts =
table_factory->get()->GetOptions<BlockBasedTableOptions>(); table_factory->get()->GetOptions<BlockBasedTableOptions>();
@ -622,10 +620,10 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose, OptionTypeFlags::kShared | OptionTypeFlags::kCompareLoose,
// Parses the input value and creates a PlainTableFactory // Parses the input value and creates a PlainTableFactory
[](const ConfigOptions& opts, const std::string& name, [](const ConfigOptions& opts, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
PlainTableOptions* old_opts = nullptr; PlainTableOptions* old_opts = nullptr;
auto table_factory = auto table_factory =
reinterpret_cast<std::shared_ptr<TableFactory>*>(addr); static_cast<std::shared_ptr<TableFactory>*>(addr);
if (table_factory->get() != nullptr) { if (table_factory->get() != nullptr) {
old_opts = table_factory->get()->GetOptions<PlainTableOptions>(); old_opts = table_factory->get()->GetOptions<PlainTableOptions>();
} }
@ -662,8 +660,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kCompareLoose, OptionTypeFlags::kCompareLoose,
// Parses the input value as a MergeOperator, updating the value // Parses the input value as a MergeOperator, updating the value
[](const ConfigOptions& opts, const std::string& /*name*/, [](const ConfigOptions& opts, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto mop = reinterpret_cast<std::shared_ptr<MergeOperator>*>(addr); auto mop = static_cast<std::shared_ptr<MergeOperator>*>(addr);
Status status = Status status =
opts.registry->NewSharedObject<MergeOperator>(value, mop); opts.registry->NewSharedObject<MergeOperator>(value, mop);
// Only support static comparator for now. // Only support static comparator for now.

9
options/db_options.cc
Unescape View File

@ -403,9 +403,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
(OptionTypeFlags::kDontSerialize | OptionTypeFlags::kCompareNever), (OptionTypeFlags::kDontSerialize | OptionTypeFlags::kCompareNever),
// Parse the input value as a RateLimiter // Parse the input value as a RateLimiter
[](const ConfigOptions& /*opts*/, const std::string& /*name*/, [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto limiter = auto limiter = static_cast<std::shared_ptr<RateLimiter>*>(addr);
reinterpret_cast<std::shared_ptr<RateLimiter>*>(addr);
limiter->reset(NewGenericRateLimiter( limiter->reset(NewGenericRateLimiter(
static_cast<int64_t>(ParseUint64(value)))); static_cast<int64_t>(ParseUint64(value))));
return Status::OK(); return Status::OK();
@ -416,8 +415,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
(OptionTypeFlags::kDontSerialize | OptionTypeFlags::kCompareNever), (OptionTypeFlags::kDontSerialize | OptionTypeFlags::kCompareNever),
// Parse the input value as an Env // Parse the input value as an Env
[](const ConfigOptions& /*opts*/, const std::string& /*name*/, [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto old_env = reinterpret_cast<Env**>(addr); // Get the old value auto old_env = static_cast<Env**>(addr); // Get the old value
Env* new_env = *old_env; // Set new to old Env* new_env = *old_env; // Set new to old
Status s = Env::LoadEnv(value, &new_env); // Update new value Status s = Env::LoadEnv(value, &new_env); // Update new value
if (s.ok()) { // It worked if (s.ok()) { // It worked

144
options/options_helper.cc
Unescape View File

@ -417,69 +417,66 @@ bool ParseSliceTransform(
return false; return false;
} }
static bool ParseOptionHelper(char* opt_address, const OptionType& opt_type, static bool ParseOptionHelper(void* opt_address, const OptionType& opt_type,
const std::string& value) { const std::string& value) {
switch (opt_type) { switch (opt_type) {
case OptionType::kBoolean: case OptionType::kBoolean:
*reinterpret_cast<bool*>(opt_address) = ParseBoolean("", value); *static_cast<bool*>(opt_address) = ParseBoolean("", value);
break; break;
case OptionType::kInt: case OptionType::kInt:
*reinterpret_cast<int*>(opt_address) = ParseInt(value); *static_cast<int*>(opt_address) = ParseInt(value);
break; break;
case OptionType::kInt32T: case OptionType::kInt32T:
*reinterpret_cast<int32_t*>(opt_address) = ParseInt32(value); *static_cast<int32_t*>(opt_address) = ParseInt32(value);
break; break;
case OptionType::kInt64T: case OptionType::kInt64T:
PutUnaligned(reinterpret_cast<int64_t*>(opt_address), ParseInt64(value)); PutUnaligned(static_cast<int64_t*>(opt_address), ParseInt64(value));
break; break;
case OptionType::kUInt: case OptionType::kUInt:
*reinterpret_cast<unsigned int*>(opt_address) = ParseUint32(value); *static_cast<unsigned int*>(opt_address) = ParseUint32(value);
break; break;
case OptionType::kUInt32T: case OptionType::kUInt32T:
*reinterpret_cast<uint32_t*>(opt_address) = ParseUint32(value); *static_cast<uint32_t*>(opt_address) = ParseUint32(value);
break; break;
case OptionType::kUInt64T: case OptionType::kUInt64T:
PutUnaligned(reinterpret_cast<uint64_t*>(opt_address), ParseUint64(value)); PutUnaligned(static_cast<uint64_t*>(opt_address), ParseUint64(value));
break; break;
case OptionType::kSizeT: case OptionType::kSizeT:
PutUnaligned(reinterpret_cast<size_t*>(opt_address), ParseSizeT(value)); PutUnaligned(static_cast<size_t*>(opt_address), ParseSizeT(value));
break; break;
case OptionType::kString: case OptionType::kString:
*reinterpret_cast<std::string*>(opt_address) = value; *static_cast<std::string*>(opt_address) = value;
break; break;
case OptionType::kDouble: case OptionType::kDouble:
*reinterpret_cast<double*>(opt_address) = ParseDouble(value); *static_cast<double*>(opt_address) = ParseDouble(value);
break; break;
case OptionType::kCompactionStyle: case OptionType::kCompactionStyle:
return ParseEnum<CompactionStyle>( return ParseEnum<CompactionStyle>(
compaction_style_string_map, value, compaction_style_string_map, value,
reinterpret_cast<CompactionStyle*>(opt_address)); static_cast<CompactionStyle*>(opt_address));
case OptionType::kCompactionPri: case OptionType::kCompactionPri:
return ParseEnum<CompactionPri>( return ParseEnum<CompactionPri>(compaction_pri_string_map, value,
compaction_pri_string_map, value, static_cast<CompactionPri*>(opt_address));
reinterpret_cast<CompactionPri*>(opt_address));
case OptionType::kCompressionType: case OptionType::kCompressionType:
return ParseEnum<CompressionType>( return ParseEnum<CompressionType>(
compression_type_string_map, value, compression_type_string_map, value,
reinterpret_cast<CompressionType*>(opt_address)); static_cast<CompressionType*>(opt_address));
case OptionType::kSliceTransform: case OptionType::kSliceTransform:
return ParseSliceTransform( return ParseSliceTransform(
value, reinterpret_cast<std::shared_ptr<const SliceTransform>*>( value,
opt_address)); static_cast<std::shared_ptr<const SliceTransform>*>(opt_address));
case OptionType::kChecksumType: case OptionType::kChecksumType:
return ParseEnum<ChecksumType>( return ParseEnum<ChecksumType>(checksum_type_string_map, value,
checksum_type_string_map, value, static_cast<ChecksumType*>(opt_address));
reinterpret_cast<ChecksumType*>(opt_address));
case OptionType::kEncodingType: case OptionType::kEncodingType:
return ParseEnum<EncodingType>( return ParseEnum<EncodingType>(encoding_type_string_map, value,
encoding_type_string_map, value, static_cast<EncodingType*>(opt_address));
reinterpret_cast<EncodingType*>(opt_address));
case OptionType::kCompactionStopStyle: case OptionType::kCompactionStopStyle:
return ParseEnum<CompactionStopStyle>( return ParseEnum<CompactionStopStyle>(
compaction_stop_style_string_map, value, compaction_stop_style_string_map, value,
reinterpret_cast<CompactionStopStyle*>(opt_address)); static_cast<CompactionStopStyle*>(opt_address));
case OptionType::kEncodedString: { case OptionType::kEncodedString: {
std::string* output_addr = reinterpret_cast<std::string*>(opt_address); std::string* output_addr = static_cast<std::string*>(opt_address);
(Slice(value)).DecodeHex(output_addr); (Slice(value)).DecodeHex(output_addr);
break; break;
} }
@ -489,70 +486,69 @@ static bool ParseOptionHelper(char* opt_address, const OptionType& opt_type,
return true; return true;
} }
bool SerializeSingleOptionHelper(const char* opt_address, bool SerializeSingleOptionHelper(const void* opt_address,
const OptionType opt_type, const OptionType opt_type,
std::string* value) { std::string* value) {
assert(value); assert(value);
switch (opt_type) { switch (opt_type) {
case OptionType::kBoolean: case OptionType::kBoolean:
*value = *(reinterpret_cast<const bool*>(opt_address)) ? "true" : "false"; *value = *(static_cast<const bool*>(opt_address)) ? "true" : "false";
break; break;
case OptionType::kInt: case OptionType::kInt:
*value = ToString(*(reinterpret_cast<const int*>(opt_address))); *value = ToString(*(static_cast<const int*>(opt_address)));
break; break;
case OptionType::kInt32T: case OptionType::kInt32T:
*value = ToString(*(reinterpret_cast<const int32_t*>(opt_address))); *value = ToString(*(static_cast<const int32_t*>(opt_address)));
break; break;
case OptionType::kInt64T: case OptionType::kInt64T:
{ {
int64_t v; int64_t v;
GetUnaligned(reinterpret_cast<const int64_t*>(opt_address), &v); GetUnaligned(static_cast<const int64_t*>(opt_address), &v);
*value = ToString(v); *value = ToString(v);
} }
break; break;
case OptionType::kUInt: case OptionType::kUInt:
*value = ToString(*(reinterpret_cast<const unsigned int*>(opt_address))); *value = ToString(*(static_cast<const unsigned int*>(opt_address)));
break; break;
case OptionType::kUInt32T: case OptionType::kUInt32T:
*value = ToString(*(reinterpret_cast<const uint32_t*>(opt_address))); *value = ToString(*(static_cast<const uint32_t*>(opt_address)));
break; break;
case OptionType::kUInt64T: case OptionType::kUInt64T:
{ {
uint64_t v; uint64_t v;
GetUnaligned(reinterpret_cast<const uint64_t*>(opt_address), &v); GetUnaligned(static_cast<const uint64_t*>(opt_address), &v);
*value = ToString(v); *value = ToString(v);
} }
break; break;
case OptionType::kSizeT: case OptionType::kSizeT:
{ {
size_t v; size_t v;
GetUnaligned(reinterpret_cast<const size_t*>(opt_address), &v); GetUnaligned(static_cast<const size_t*>(opt_address), &v);
*value = ToString(v); *value = ToString(v);
} }
break; break;
case OptionType::kDouble: case OptionType::kDouble:
*value = ToString(*(reinterpret_cast<const double*>(opt_address))); *value = ToString(*(static_cast<const double*>(opt_address)));
break; break;
case OptionType::kString: case OptionType::kString:
*value = EscapeOptionString( *value =
*(reinterpret_cast<const std::string*>(opt_address))); EscapeOptionString(*(static_cast<const std::string*>(opt_address)));
break; break;
case OptionType::kCompactionStyle: case OptionType::kCompactionStyle:
return SerializeEnum<CompactionStyle>( return SerializeEnum<CompactionStyle>(
compaction_style_string_map, compaction_style_string_map,
*(reinterpret_cast<const CompactionStyle*>(opt_address)), value); *(static_cast<const CompactionStyle*>(opt_address)), value);
case OptionType::kCompactionPri: case OptionType::kCompactionPri:
return SerializeEnum<CompactionPri>( return SerializeEnum<CompactionPri>(
compaction_pri_string_map, compaction_pri_string_map,
*(reinterpret_cast<const CompactionPri*>(opt_address)), value); *(static_cast<const CompactionPri*>(opt_address)), value);
case OptionType::kCompressionType: case OptionType::kCompressionType:
return SerializeEnum<CompressionType>( return SerializeEnum<CompressionType>(
compression_type_string_map, compression_type_string_map,
*(reinterpret_cast<const CompressionType*>(opt_address)), value); *(static_cast<const CompressionType*>(opt_address)), value);
case OptionType::kSliceTransform: { case OptionType::kSliceTransform: {
const auto* slice_transform_ptr = const auto* slice_transform_ptr =
reinterpret_cast<const std::shared_ptr<const SliceTransform>*>( static_cast<const std::shared_ptr<const SliceTransform>*>(
opt_address); opt_address);
*value = slice_transform_ptr->get() ? slice_transform_ptr->get()->Name() *value = slice_transform_ptr->get() ? slice_transform_ptr->get()->Name()
: kNullptrString; : kNullptrString;
@ -560,7 +556,7 @@ bool SerializeSingleOptionHelper(const char* opt_address,
} }
case OptionType::kComparator: { case OptionType::kComparator: {
// it's a const pointer of const Comparator* // it's a const pointer of const Comparator*
const auto* ptr = reinterpret_cast<const Comparator* const*>(opt_address); const auto* ptr = static_cast<const Comparator* const*>(opt_address);
// Since the user-specified comparator will be wrapped by // Since the user-specified comparator will be wrapped by
// InternalKeyComparator, we should persist the user-specified one // InternalKeyComparator, we should persist the user-specified one
// instead of InternalKeyComparator. // instead of InternalKeyComparator.
@ -578,43 +574,42 @@ bool SerializeSingleOptionHelper(const char* opt_address,
case OptionType::kCompactionFilter: { case OptionType::kCompactionFilter: {
// it's a const pointer of const CompactionFilter* // it's a const pointer of const CompactionFilter*
const auto* ptr = const auto* ptr =
reinterpret_cast<const CompactionFilter* const*>(opt_address); static_cast<const CompactionFilter* const*>(opt_address);
*value = *ptr ? (*ptr)->Name() : kNullptrString; *value = *ptr ? (*ptr)->Name() : kNullptrString;
break; break;
} }
case OptionType::kCompactionFilterFactory: { case OptionType::kCompactionFilterFactory: {
const auto* ptr = const auto* ptr =
reinterpret_cast<const std::shared_ptr<CompactionFilterFactory>*>( static_cast<const std::shared_ptr<CompactionFilterFactory>*>(
opt_address); opt_address);
*value = ptr->get() ? ptr->get()->Name() : kNullptrString; *value = ptr->get() ? ptr->get()->Name() : kNullptrString;
break; break;
} }
case OptionType::kMemTableRepFactory: { case OptionType::kMemTableRepFactory: {
const auto* ptr = const auto* ptr =
reinterpret_cast<const std::shared_ptr<MemTableRepFactory>*>( static_cast<const std::shared_ptr<MemTableRepFactory>*>(opt_address);
opt_address);
*value = ptr->get() ? ptr->get()->Name() : kNullptrString; *value = ptr->get() ? ptr->get()->Name() : kNullptrString;
break; break;
} }
case OptionType::kMergeOperator: { case OptionType::kMergeOperator: {
const auto* ptr = const auto* ptr =
reinterpret_cast<const std::shared_ptr<MergeOperator>*>(opt_address); static_cast<const std::shared_ptr<MergeOperator>*>(opt_address);
*value = ptr->get() ? ptr->get()->Name() : kNullptrString; *value = ptr->get() ? ptr->get()->Name() : kNullptrString;
break; break;
} }
case OptionType::kFilterPolicy: { case OptionType::kFilterPolicy: {
const auto* ptr = const auto* ptr =
reinterpret_cast<const std::shared_ptr<FilterPolicy>*>(opt_address); static_cast<const std::shared_ptr<FilterPolicy>*>(opt_address);
*value = ptr->get() ? ptr->get()->Name() : kNullptrString; *value = ptr->get() ? ptr->get()->Name() : kNullptrString;
break; break;
} }
case OptionType::kChecksumType: case OptionType::kChecksumType:
return SerializeEnum<ChecksumType>( return SerializeEnum<ChecksumType>(
checksum_type_string_map, checksum_type_string_map,
*reinterpret_cast<const ChecksumType*>(opt_address), value); *static_cast<const ChecksumType*>(opt_address), value);
case OptionType::kFlushBlockPolicyFactory: { case OptionType::kFlushBlockPolicyFactory: {
const auto* ptr = const auto* ptr =
reinterpret_cast<const std::shared_ptr<FlushBlockPolicyFactory>*>( static_cast<const std::shared_ptr<FlushBlockPolicyFactory>*>(
opt_address); opt_address);
*value = ptr->get() ? ptr->get()->Name() : kNullptrString; *value = ptr->get() ? ptr->get()->Name() : kNullptrString;
break; break;
@ -622,13 +617,13 @@ bool SerializeSingleOptionHelper(const char* opt_address,
case OptionType::kEncodingType: case OptionType::kEncodingType:
return SerializeEnum<EncodingType>( return SerializeEnum<EncodingType>(
encoding_type_string_map, encoding_type_string_map,
*reinterpret_cast<const EncodingType*>(opt_address), value); *static_cast<const EncodingType*>(opt_address), value);
case OptionType::kCompactionStopStyle: case OptionType::kCompactionStopStyle:
return SerializeEnum<CompactionStopStyle>( return SerializeEnum<CompactionStopStyle>(
compaction_stop_style_string_map, compaction_stop_style_string_map,
*reinterpret_cast<const CompactionStopStyle*>(opt_address), value); *static_cast<const CompactionStopStyle*>(opt_address), value);
case OptionType::kEncodedString: { case OptionType::kEncodedString: {
const auto* ptr = reinterpret_cast<const std::string*>(opt_address); const auto* ptr = static_cast<const std::string*>(opt_address);
*value = (Slice(*ptr)).ToString(true); *value = (Slice(*ptr)).ToString(true);
break; break;
} }
@ -980,7 +975,7 @@ Status OptionTypeInfo::Parse(const ConfigOptions& config_options,
return Status::OK(); return Status::OK();
} }
try { try {
char* opt_addr = reinterpret_cast<char*>(opt_ptr) + offset_; void* opt_addr = static_cast<char*>(opt_ptr) + offset_;
const std::string& opt_value = config_options.input_strings_escaped const std::string& opt_value = config_options.input_strings_escaped
? UnescapeOptionString(value) ? UnescapeOptionString(value)
: value; : value;
@ -1061,7 +1056,7 @@ Status OptionTypeInfo::ParseType(
Status OptionTypeInfo::ParseStruct( Status OptionTypeInfo::ParseStruct(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* struct_map, const std::unordered_map<std::string, OptionTypeInfo>* struct_map,
const std::string& opt_name, const std::string& opt_value, char* opt_addr) { const std::string& opt_name, const std::string& opt_value, void* opt_addr) {
assert(struct_map); assert(struct_map);
Status status; Status status;
if (opt_name == struct_name || EndsWith(opt_name, "." + struct_name)) { if (opt_name == struct_name || EndsWith(opt_name, "." + struct_name)) {
@ -1103,7 +1098,7 @@ Status OptionTypeInfo::Serialize(const ConfigOptions& config_options,
std::string* opt_value) const { std::string* opt_value) const {
// If the option is no longer used in rocksdb and marked as deprecated, // If the option is no longer used in rocksdb and marked as deprecated,
// we skip it in the serialization. // we skip it in the serialization.
const char* opt_addr = reinterpret_cast<const char*>(opt_ptr) + offset_; const void* opt_addr = static_cast<const char*>(opt_ptr) + offset_;
if (opt_addr == nullptr || IsDeprecated()) { if (opt_addr == nullptr || IsDeprecated()) {
return Status::OK(); return Status::OK();
} else if (IsEnabled(OptionTypeFlags::kDontSerialize)) { } else if (IsEnabled(OptionTypeFlags::kDontSerialize)) {
@ -1162,7 +1157,7 @@ Status OptionTypeInfo::SerializeType(
Status OptionTypeInfo::SerializeStruct( Status OptionTypeInfo::SerializeStruct(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* struct_map, const std::unordered_map<std::string, OptionTypeInfo>* struct_map,
const std::string& opt_name, const char* opt_addr, std::string* value) { const std::string& opt_name, const void* opt_addr, std::string* value) {
assert(struct_map); assert(struct_map);
Status status; Status status;
if (EndsWith(opt_name, struct_name)) { if (EndsWith(opt_name, struct_name)) {
@ -1204,17 +1199,16 @@ Status OptionTypeInfo::SerializeStruct(
} }
template <typename T> template <typename T>
bool IsOptionEqual(const char* offset1, const char* offset2) { bool IsOptionEqual(const void* offset1, const void* offset2) {
return (*reinterpret_cast<const T*>(offset1) == return (*static_cast<const T*>(offset1) == *static_cast<const T*>(offset2));
*reinterpret_cast<const T*>(offset2));
} }
static bool AreEqualDoubles(const double a, const double b) { static bool AreEqualDoubles(const double a, const double b) {
return (fabs(a - b) < 0.00001); return (fabs(a - b) < 0.00001);
} }
static bool AreOptionsEqual(OptionType type, const char* this_offset, static bool AreOptionsEqual(OptionType type, const void* this_offset,
const char* that_offset) { const void* that_offset) {
switch (type) { switch (type) {
case OptionType::kBoolean: case OptionType::kBoolean:
return IsOptionEqual<bool>(this_offset, that_offset); return IsOptionEqual<bool>(this_offset, that_offset);
@ -1226,29 +1220,29 @@ static bool AreOptionsEqual(OptionType type, const char* this_offset,
return IsOptionEqual<int32_t>(this_offset, that_offset); return IsOptionEqual<int32_t>(this_offset, that_offset);
case OptionType::kInt64T: { case OptionType::kInt64T: {
int64_t v1, v2; int64_t v1, v2;
GetUnaligned(reinterpret_cast<const int64_t*>(this_offset), &v1); GetUnaligned(static_cast<const int64_t*>(this_offset), &v1);
GetUnaligned(reinterpret_cast<const int64_t*>(that_offset), &v2); GetUnaligned(static_cast<const int64_t*>(that_offset), &v2);
return (v1 == v2); return (v1 == v2);
} }
case OptionType::kUInt32T: case OptionType::kUInt32T:
return IsOptionEqual<uint32_t>(this_offset, that_offset); return IsOptionEqual<uint32_t>(this_offset, that_offset);
case OptionType::kUInt64T: { case OptionType::kUInt64T: {
uint64_t v1, v2; uint64_t v1, v2;
GetUnaligned(reinterpret_cast<const uint64_t*>(this_offset), &v1); GetUnaligned(static_cast<const uint64_t*>(this_offset), &v1);
GetUnaligned(reinterpret_cast<const uint64_t*>(that_offset), &v2); GetUnaligned(static_cast<const uint64_t*>(that_offset), &v2);
return (v1 == v2); return (v1 == v2);
} }
case OptionType::kSizeT: { case OptionType::kSizeT: {
size_t v1, v2; size_t v1, v2;
GetUnaligned(reinterpret_cast<const size_t*>(this_offset), &v1); GetUnaligned(static_cast<const size_t*>(this_offset), &v1);
GetUnaligned(reinterpret_cast<const size_t*>(that_offset), &v2); GetUnaligned(static_cast<const size_t*>(that_offset), &v2);
return (v1 == v2); return (v1 == v2);
} }
case OptionType::kString: case OptionType::kString:
return IsOptionEqual<std::string>(this_offset, that_offset); return IsOptionEqual<std::string>(this_offset, that_offset);
case OptionType::kDouble: case OptionType::kDouble:
return AreEqualDoubles(*reinterpret_cast<const double*>(this_offset), return AreEqualDoubles(*static_cast<const double*>(this_offset),
*reinterpret_cast<const double*>(that_offset)); *static_cast<const double*>(that_offset));
case OptionType::kCompactionStyle: case OptionType::kCompactionStyle:
return IsOptionEqual<CompactionStyle>(this_offset, that_offset); return IsOptionEqual<CompactionStyle>(this_offset, that_offset);
case OptionType::kCompactionStopStyle: case OptionType::kCompactionStopStyle:
@ -1277,8 +1271,8 @@ bool OptionTypeInfo::AreEqual(const ConfigOptions& config_options,
if (!config_options.IsCheckEnabled(level)) { if (!config_options.IsCheckEnabled(level)) {
return true; // If the sanity level is not being checked, skip it return true; // If the sanity level is not being checked, skip it
} }
const auto this_addr = reinterpret_cast<const char*>(this_ptr) + offset_; const void* this_addr = static_cast<const char*>(this_ptr) + offset_;
const auto that_addr = reinterpret_cast<const char*>(that_ptr) + offset_; const void* that_addr = static_cast<const char*>(that_ptr) + offset_;
if (this_addr == nullptr || that_addr == nullptr) { if (this_addr == nullptr || that_addr == nullptr) {
if (this_addr == that_addr) { if (this_addr == that_addr) {
return true; return true;
@ -1335,7 +1329,7 @@ bool OptionTypeInfo::TypesAreEqual(
bool OptionTypeInfo::StructsAreEqual( bool OptionTypeInfo::StructsAreEqual(
const ConfigOptions& config_options, const std::string& struct_name, const ConfigOptions& config_options, const std::string& struct_name,
const std::unordered_map<std::string, OptionTypeInfo>* struct_map, const std::unordered_map<std::string, OptionTypeInfo>* struct_map,
const std::string& opt_name, const char* this_addr, const char* that_addr, const std::string& opt_name, const void* this_addr, const void* that_addr,
std::string* mismatch) { std::string* mismatch) {
assert(struct_map); assert(struct_map);
bool matches = true; bool matches = true;

19
options/options_test.cc
Unescape View File

@ -3707,8 +3707,8 @@ TEST_F(OptionTypeInfoTest, TestInvalidArgs) {
OptionVerificationType::kNormal, OptionVerificationType::kNormal,
OptionTypeFlags::kNone, OptionTypeFlags::kNone,
[](const ConfigOptions&, const std::string&, [](const ConfigOptions&, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto ptr = reinterpret_cast<int*>(addr); auto ptr = static_cast<int*>(addr);
*ptr = ParseInt(value); *ptr = ParseInt(value);
return Status::OK(); return Status::OK();
}); });
@ -3721,8 +3721,8 @@ TEST_F(OptionTypeInfoTest, TestParseFunc) {
0, OptionType::kUnknown, OptionVerificationType::kNormal, 0, OptionType::kUnknown, OptionVerificationType::kNormal,
OptionTypeFlags::kNone, OptionTypeFlags::kNone,
[](const ConfigOptions& /*opts*/, const std::string& name, [](const ConfigOptions& /*opts*/, const std::string& name,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto ptr = reinterpret_cast<std::string*>(addr); auto ptr = static_cast<std::string*>(addr);
if (name == "Oops") { if (name == "Oops") {
return Status::InvalidArgument(value); return Status::InvalidArgument(value);
} else { } else {
@ -3742,7 +3742,7 @@ TEST_F(OptionTypeInfoTest, TestSerializeFunc) {
0, OptionType::kString, OptionVerificationType::kNormal, 0, OptionType::kString, OptionVerificationType::kNormal,
OptionTypeFlags::kNone, nullptr, OptionTypeFlags::kNone, nullptr,
[](const ConfigOptions& /*opts*/, const std::string& name, [](const ConfigOptions& /*opts*/, const std::string& name,
const char* /*addr*/, std::string* value) { const void* /*addr*/, std::string* value) {
if (name == "Oops") { if (name == "Oops") {
return Status::InvalidArgument(name); return Status::InvalidArgument(name);
} else { } else {
@ -3764,9 +3764,9 @@ TEST_F(OptionTypeInfoTest, TestEqualsFunc) {
0, OptionType::kInt, OptionVerificationType::kNormal, 0, OptionType::kInt, OptionVerificationType::kNormal,
OptionTypeFlags::kNone, nullptr, nullptr, OptionTypeFlags::kNone, nullptr, nullptr,
[](const ConfigOptions& /*opts*/, const std::string& name, [](const ConfigOptions& /*opts*/, const std::string& name,
const char* addr1, const char* addr2, std::string* mismatch) { const void* addr1, const void* addr2, std::string* mismatch) {
auto i1 = *(reinterpret_cast<const int*>(addr1)); auto i1 = *(static_cast<const int*>(addr1));
auto i2 = *(reinterpret_cast<const int*>(addr2)); auto i2 = *(static_cast<const int*>(addr2));
if (name == "LT") { if (name == "LT") {
return i1 < i2; return i1 < i2;
} else if (name == "GT") { } else if (name == "GT") {
@ -3820,8 +3820,7 @@ TEST_F(OptionTypeInfoTest, TestOptionFlags) {
// An alias can change the value via parse, but does nothing on serialize on // An alias can change the value via parse, but does nothing on serialize on
// match // match
std::string result; std::string result;
ASSERT_OK(opt_alias.Parse(config_options, "Alias", "Alias", ASSERT_OK(opt_alias.Parse(config_options, "Alias", "Alias", &base));
reinterpret_cast<char*>(&base)));
ASSERT_OK(opt_alias.Serialize(config_options, "Alias", &base, &result)); ASSERT_OK(opt_alias.Serialize(config_options, "Alias", &base, &result));
ASSERT_TRUE( ASSERT_TRUE(
opt_alias.AreEqual(config_options, "Alias", &base, &comp, &result)); opt_alias.AreEqual(config_options, "Alias", &base, &comp, &result));

31
table/block_based/block_based_table_factory.cc
Unescape View File

@ -306,17 +306,16 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionTypeFlags::kNone, OptionTypeFlags::kNone,
// Parses the Filter policy // Parses the Filter policy
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto* policy = auto* policy =
reinterpret_cast<std::shared_ptr<const FilterPolicy>*>(addr); static_cast<std::shared_ptr<const FilterPolicy>*>(addr);
return FilterPolicy::CreateFromString(opts, value, policy); return FilterPolicy::CreateFromString(opts, value, policy);
}, },
// Converts the FilterPolicy to its string representation // Converts the FilterPolicy to its string representation
[](const ConfigOptions&, const std::string&, const char* addr, [](const ConfigOptions&, const std::string&, const void* addr,
std::string* value) { std::string* value) {
const auto* policy = const auto* policy =
reinterpret_cast<const std::shared_ptr<const FilterPolicy>*>( static_cast<const std::shared_ptr<const FilterPolicy>*>(addr);
addr);
if (policy->get()) { if (policy->get()) {
*value = (*policy)->Name(); *value = (*policy)->Name();
} else { } else {
@ -325,15 +324,13 @@ static std::unordered_map<std::string, OptionTypeInfo>
return Status::OK(); return Status::OK();
}, },
// Compares two FilterPolicy objects for equality // Compares two FilterPolicy objects for equality
[](const ConfigOptions&, const std::string&, const char* addr1, [](const ConfigOptions&, const std::string&, const void* addr1,
const char* addr2, std::string*) { const void* addr2, std::string*) {
const auto* policy1 = const auto* policy1 =
reinterpret_cast<const std::shared_ptr<const FilterPolicy>*>( static_cast<const std::shared_ptr<const FilterPolicy>*>(addr1)
addr1)
->get(); ->get();
const auto* policy2 = const auto* policy2 =
reinterpret_cast<const std::shared_ptr<FilterPolicy>*>(addr2) static_cast<const std::shared_ptr<FilterPolicy>*>(addr2)->get();
->get();
if (policy1 == policy2) { if (policy1 == policy2) {
return true; return true;
} else if (policy1 != nullptr && policy2 != nullptr) { } else if (policy1 != nullptr && policy2 != nullptr) {
@ -362,7 +359,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
OptionType::kUInt32T, OptionVerificationType::kNormal, OptionType::kUInt32T, OptionVerificationType::kNormal,
OptionTypeFlags::kNone, OptionTypeFlags::kNone,
[](const ConfigOptions& /*opts*/, const std::string& /*name*/, [](const ConfigOptions& /*opts*/, const std::string& /*name*/,
const std::string& value, char* addr) { const std::string& value, void* addr) {
// A workaround to fix a bug in 6.10, 6.11, 6.12, 6.13 // A workaround to fix a bug in 6.10, 6.11, 6.12, 6.13
// and 6.14. The bug will write out 8 bytes to OPTIONS file from the // and 6.14. The bug will write out 8 bytes to OPTIONS file from the
// starting address of BlockBasedTableOptions.read_amp_bytes_per_bit // starting address of BlockBasedTableOptions.read_amp_bytes_per_bit
@ -373,7 +370,7 @@ static std::unordered_map<std::string, OptionTypeInfo>
// generated by affected releases before the fix, we need to // generated by affected releases before the fix, we need to
// manually parse read_amp_bytes_per_bit with this special hack. // manually parse read_amp_bytes_per_bit with this special hack.
uint64_t read_amp_bytes_per_bit = ParseUint64(value); uint64_t read_amp_bytes_per_bit = ParseUint64(value);
*(reinterpret_cast<uint32_t*>(addr)) = *(static_cast<uint32_t*>(addr)) =
static_cast<uint32_t>(read_amp_bytes_per_bit); static_cast<uint32_t>(read_amp_bytes_per_bit);
return Status::OK(); return Status::OK();
}}}, }}},
@ -401,8 +398,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
(OptionTypeFlags::kCompareNever | OptionTypeFlags::kDontSerialize), (OptionTypeFlags::kCompareNever | OptionTypeFlags::kDontSerialize),
// Parses the input vsalue as a Cache // Parses the input vsalue as a Cache
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto* cache = reinterpret_cast<std::shared_ptr<Cache>*>(addr); auto* cache = static_cast<std::shared_ptr<Cache>*>(addr);
return Cache::CreateFromString(opts, value, cache); return Cache::CreateFromString(opts, value, cache);
}}}, }}},
{"block_cache_compressed", {"block_cache_compressed",
@ -411,8 +408,8 @@ static std::unordered_map<std::string, OptionTypeInfo>
(OptionTypeFlags::kCompareNever | OptionTypeFlags::kDontSerialize), (OptionTypeFlags::kCompareNever | OptionTypeFlags::kDontSerialize),
// Parses the input vsalue as a Cache // Parses the input vsalue as a Cache
[](const ConfigOptions& opts, const std::string&, [](const ConfigOptions& opts, const std::string&,
const std::string& value, char* addr) { const std::string& value, void* addr) {
auto* cache = reinterpret_cast<std::shared_ptr<Cache>*>(addr); auto* cache = static_cast<std::shared_ptr<Cache>*>(addr);
return Cache::CreateFromString(opts, value, cache); return Cache::CreateFromString(opts, value, cache);
}}}, }}},
{"max_auto_readahead_size", {"max_auto_readahead_size",

Write Preview
Loading…
Cancel
Save