{"repo_name": "3FS", "file_name": "/3FS/src/common/utils/CoLockManager.h", "inference_info": {"prefix_code": "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Shards.h\"\n\nnamespace hf3fs {\n\ntemplate \nclass CoLockManager {\n struct State {\n std::string tag;\n folly::coro::Baton &baton;\n };\n using Queue = std::queue;\n using Map = std::unordered_map;\n using It = typename Map::iterator;\n\n public:\n struct Guard {\n static constexpr auto kInvalidPos = std::numeric_limits::max();\n Guard(CoLockManager &manager, folly::coro::Baton &baton, std::size_t pos, It it, std::string currentTag)\n : manager_(manager),\n baton_(baton),\n pos_(pos),\n it_(it),\n currentTag_(std::move(currentTag)) {}\n Guard(const Guard &) = delete;\n Guard(Guard &&o)\n : manager_(o.manager_),\n baton_(o.baton_),\n pos_(std::exchange(o.pos_, kInvalidPos)),\n it_(o.it_),\n currentTag_(std::move(o.currentTag_)) {}\n ~Guard() {\n if (pos_ != kInvalidPos) {\n if (!locked()) {\n folly::coro::blockingWait(lock());\n }\n manager_.unlock(baton_, pos_, it_);\n }\n }\n\n // check locked or not.\n bool locked() const { return baton_.ready(); }\n\n // get current locked tag.\n auto ¤tTag() const { return currentTag_; }\n\n // lock.\n [[nodiscard]] CoTask lock() { co_await baton_; }\n\n private:\n CoLockManager &manager_;\n folly::coro::Baton &baton_;\n std::size_t pos_;\n It it_;\n std::string currentTag_;\n };\n\n auto lock(folly::coro::Baton &baton, const std::string &key, const std::string &tag = \"\") {\n auto pos = shards_.position(key);\n auto [it, succ, currentTag] = shards_.withLockAt(\n [&](Map &map) {\n auto [it, succ] = map.emplace(key, Queue{});\n it->second.push({tag, baton});\n return std::make_tuple(it, succ, it->second.front().tag);\n },\n pos);\n if (succ) {\n baton.post();\n }\n return Guard{*this, baton, pos, it, std::move(currentTag)};\n }\n\n auto tryLock(folly::coro::Baton &baton, const std::string &key, const std::string &tag = \"\") {\n auto pos = shards_.position(key);\n auto [it, succ, currentTag] = shards_.withLockAt(\n [&](Map &map) {\n auto [it, succ] = map.emplace(key, Queue{});\n if (succ) {\n it->second.push({tag, baton});\n }\n return std::make_tuple(it, succ, succ ? std::string{} : it->second.front().tag);\n },\n pos);\n if (succ) {\n baton.post();\n }\n return Guard{*this, baton, succ ? pos : Guard::kInvalidPos, it, std::move(currentTag)};\n }\n\n protected:\n ", "suffix_code": "\n\n private:\n Shards shards_;\n};\n\n} // namespace hf3fs\n", "middle_code": "void unlock(folly::coro::Baton &baton, size_t pos, It it) {\n shards_.withLockAt(\n [&](Map &map) {\n auto &queue = it->second;\n if (UNLIKELY(queue.empty() || &queue.front().baton != &baton)) {\n assert(false);\n }\n queue.pop();\n if (!queue.empty()) {\n queue.front().baton.post();\n } else {\n map.erase(it);\n }\n },\n pos);\n }", "code_description": null, "fill_type": "FUNCTION_TYPE", "language_type": "cpp", "sub_task_type": null}, "context_code": [["/3FS/src/common/utils/ConcurrencyLimiter.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Shards.h\"\n\nnamespace hf3fs {\n\nclass ConcurrencyLimiterConfig : public ConfigBase {\n CONFIG_HOT_UPDATED_ITEM(max_concurrency, 1u, ConfigCheckers::checkPositive);\n};\n\ntemplate \nclass ConcurrencyLimiter {\n private:\n struct State {\n uint32_t concurrency{};\n std::queue> queue{};\n };\n using Map = std::unordered_map;\n using It = typename Map::iterator;\n const ConcurrencyLimiterConfig &config_;\n Shards shards_;\n\n public:\n ConcurrencyLimiter(const ConcurrencyLimiterConfig &config)\n : config_(config) {}\n\n struct Guard {\n Guard(ConcurrencyLimiter &limiter, std::size_t pos, It it)\n : limiter_(&limiter),\n pos_(pos),\n it_(it) {}\n Guard(const Guard &) = delete;\n Guard(Guard &&o)\n : limiter_(std::exchange(o.limiter_, nullptr)),\n pos_(o.pos_),\n it_(o.it_) {}\n ~Guard() { limiter_ == nullptr ? void() : limiter_->unlock(pos_, it_); }\n\n private:\n ConcurrencyLimiter *limiter_;\n std::size_t pos_;\n It it_;\n };\n\n CoTask lock(const Key &key) {\n folly::coro::Baton baton;\n auto pos = shards_.position(key);\n auto [it, succ] = shards_.withLockAt(\n [&](Map &map) {\n auto [it, succ] = map.emplace(key, State{});\n auto &state = it->second;\n if (state.concurrency < config_.max_concurrency()) {\n ++state.concurrency;\n return std::make_pair(it, true);\n }\n state.queue.push(std::ref(baton));\n return std::make_pair(it, false);\n },\n pos);\n if (!succ) {\n co_await baton;\n }\n co_return Guard{*this, pos, it};\n }\n\n private:\n void unlock(size_t pos, It it) {\n shards_.withLockAt(\n [&](Map &map) {\n auto &state = it->second;\n assert(state.concurrency > 0);\n if (!state.queue.empty()) {\n if (state.concurrency <= config_.max_concurrency()) {\n // wake up the next waiting baton.\n auto next = std::move(state.queue.front());\n state.queue.pop();\n next.get().post();\n } else {\n // give up.\n --state.concurrency;\n }\n } else if (--state.concurrency == 0) {\n // remove current state.\n map.erase(it);\n }\n },\n pos);\n }\n};\n\n} // namespace hf3fs\n"], ["/3FS/src/common/net/Waiter.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/net/Network.h\"\n#include \"common/net/RDMAControl.h\"\n#include \"common/net/Transport.h\"\n#include \"common/serde/MessagePacket.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/RobinHood.h\"\n#include \"common/utils/Shards.h\"\n#include \"common/utils/Status.h\"\n\nnamespace hf3fs::net {\n\n// Wake up the waiting caller.\nclass Waiter {\n public:\n // is singleton.\n static Waiter &instance();\n ~Waiter();\n\n struct Item {\n folly::coro::Baton baton;\n IOBufPtr buf;\n serde::MessagePacket<> packet;\n Status status = Status::OK;\n TransportPtr transport;\n RDMATransmissionLimiterPtr limiter;\n RelativeTime timestamp = RelativeTime::now();\n };\n\n size_t bind(Item &item) {\n thread_local size_t start = 0, end = 0;\n if (UNLIKELY(start >= end)) {\n start = uuid_idx_.fetch_add(kShardsSize);\n end = start + kShardsSize;\n }\n\n auto uuid = start++;\n shards_.withLock([&](Map &map) { map.emplace(uuid, item); }, uuid);\n return uuid;\n }\n\n bool setTransport(size_t uuid, TransportPtr transport) {\n return shards_.withLock(\n [&](Map &map) {\n auto it = map.find(uuid);\n if (it == map.end()) {\n return false;\n }\n it->second.transport = std::move(transport);\n return true;\n },\n uuid);\n }\n\n std::optional setTransmissionLimiterPtr(size_t uuid,\n const RDMATransmissionLimiterPtr &limiter,\n RelativeTime startTime) {\n return shards_.withLock(\n [&](Map &map) -> std::optional {\n auto it = map.find(uuid);\n if (it == map.end() || it->second.limiter) {\n return std::nullopt;\n }\n it->second.limiter = limiter;\n return startTime - std::exchange(it->second.timestamp, RelativeTime::now());\n },\n uuid);\n }\n\n void post(const serde::MessagePacket<> &packet, IOBufPtr buff) {\n auto item = find(packet.uuid);\n if (item) {\n item->buf = std::move(buff);\n item->packet = packet;\n if (item->limiter) {\n item->limiter->signal(RelativeTime::now() - item->timestamp);\n }\n item->baton.post();\n }\n }\n\n static void error(Item *item, Status status) {\n if (item) {\n item->status = status;\n if (item->limiter) {\n item->limiter->signal(RelativeTime::now() - item->timestamp);\n }\n item->baton.post();\n }\n }\n\n bool contains(size_t uuid) {\n return shards_.withLock([&](Map &map) { return map.contains(uuid); }, uuid);\n }\n\n void timeout(size_t uuid) { error(find(uuid), Status(RPCCode::kTimeout)); }\n void sendFail(size_t uuid) { error(find(uuid), Status(RPCCode::kSendFailed)); }\n\n void clearPendingRequestsOnTransportFailure(Transport *tr) {\n shards_.iterate([tr](Map &map) {\n for (auto it = map.begin(); it != map.end();) {\n Item *item = &it->second;\n if (item->transport.get() == tr) {\n error(item, Status(RPCCode::kTimeout));\n it = map.erase(it);\n } else {\n ++it;\n }\n }\n });\n }\n\n void schedule(uint64_t uuid, std::chrono::milliseconds timeout);\n\n private:\n Waiter();\n\n Item *find(size_t uuid) {\n return shards_.withLock(\n [&](Map &map) -> Item * {\n auto it = map.find(uuid);\n if (it == map.end()) {\n return nullptr;\n }\n auto item = &it->second;\n map.erase(it);\n return item;\n },\n uuid);\n }\n\n void run();\n\n private:\n std::atomic uuid_idx_{0};\n\n constexpr static auto kShardsBit = 8u;\n constexpr static auto kShardsSize = (1u << kShardsBit);\n using Map = robin_hood::unordered_map;\n Shards shards_;\n\n // for timer.\n struct Task {\n uint64_t uuid;\n int64_t runTime;\n bool operator<(const Task &o) const { return runTime > o.runTime; }\n };\n\n class TaskShard {\n public:\n bool schedule(uint64_t uuid, int64_t runTime);\n void exchangeTasks(std::vector &out);\n\n private:\n std::mutex mutex_;\n int64_t nearestRunTime_ = std::numeric_limits::max();\n std::vector tasks_;\n };\n\n std::atomic stop_ = false;\n constexpr static auto kTaskShardNum = 13u;\n std::array taskShards_;\n\n std::mutex mutex_;\n std::condition_variable cond_;\n int64_t nearestRunTime_ = std::numeric_limits::max();\n std::vector reserved_;\n\n std::jthread thread_;\n};\n\n} // namespace hf3fs::net\n"], ["/3FS/src/meta/store/BatchContext.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Result.h\"\n#include \"fbs/meta/Common.h\"\n#include \"fbs/meta/Schema.h\"\n#include \"meta/store/DirEntry.h\"\n#include \"meta/store/Inode.h\"\nnamespace hf3fs::meta::server {\n\nclass BatchContext : public folly::RequestData {\n public:\n template \n struct SharedFuture : folly::NonCopyableNonMovable {\n Result value = makeError(StatusCode::kUnknown);\n folly::coro::Baton baton;\n };\n\n template \n struct LoadGuard {\n bool needLoad;\n std::shared_ptr> future;\n\n LoadGuard(bool needLoad, std::shared_ptr> future)\n : needLoad(needLoad),\n future(future) {}\n\n ~LoadGuard() {\n if (needLoad && !future->baton.ready()) {\n future->value = makeError(StatusCode::kUnknown, \"load failed in BatchContext\");\n future->baton.post();\n }\n }\n\n void set(const Result &r) {\n assert(!future->baton.ready());\n future->value = r;\n future->baton.post();\n }\n\n CoTryTask coAwait() {\n co_await future->baton;\n co_return future->value;\n }\n };\n\n static folly::ShallowCopyRequestContextScopeGuard create() {\n return folly::ShallowCopyRequestContextScopeGuard{token(), std::make_unique()};\n }\n\n static inline BatchContext *get() {\n auto requestContext = folly::RequestContext::try_get();\n if (LIKELY(requestContext == nullptr)) {\n return nullptr;\n }\n return dynamic_cast(requestContext->getContextData(token()));\n }\n\n LoadGuard> loadInode(InodeId inodeId) {\n return loadImpl>(inodes_, inodeId);\n }\n\n LoadGuard> loadDirEntry(InodeId parent, std::string name) {\n return loadImpl, std::optional>(entries_, {parent, std::move(name)});\n }\n\n bool hasCallback() override { return false; }\n\n private:\n static constexpr const char *kTokenName = \"hf3fs::meta::server::BatchContext\";\n\n static folly::RequestToken const &token() {\n static folly::RequestToken const token(kTokenName);\n return token;\n }\n\n template \n using SynchronizedFutureMap = folly::Synchronized>>, std::mutex>;\n\n template \n LoadGuard loadImpl(SynchronizedFutureMap &map, K key) {\n auto guard = map.lock();\n auto iter = guard->find(key);\n if (iter != guard->end()) {\n return LoadGuard(false, iter->second);\n }\n auto future = std::make_shared>();\n guard->emplace(std::move(key), future);\n return LoadGuard(true, future);\n }\n\n SynchronizedFutureMap> inodes_;\n SynchronizedFutureMap, std::optional> entries_;\n};\n\n} // namespace hf3fs::meta::server"], ["/3FS/src/common/utils/ConfigBase.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/utils/AtomicValue.h\"\n#include \"common/utils/MagicEnum.hpp\"\n#include \"common/utils/Path.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/RobinHood.h\"\n#include \"common/utils/Toml.hpp\"\n#include \"common/utils/TypeTraits.h\"\n\nDECLARE_string(cfg);\n\nnamespace hf3fs {\n\n/*\n * ConfigBase class with macro.\n * The supported value types:\n * - std::string\n * - int64_t\n * - double\n * - bool\n * - enum\n * - std::vector of above types\n */\n\n#define CONFIG_OBJ(name, cls, ...) /* optional parameter: initializer */ \\\n public: \\\n cls &name() { return name##_; } \\\n const cls &name() const { return name##_; } \\\n \\\n private: \\\n cls name##_; \\\n [[maybe_unused]] bool name##Insert_ = [this]() { \\\n using Self = std::decay_t; \\\n ConfigBase::sections_[#name] = reinterpret_cast<::hf3fs::config::IConfig Self::*>(&Self::name##_); \\\n __VA_OPT__(__VA_ARGS__(name##_);) \\\n return true; \\\n }()\n\n#define CONFIG_OBJ_ARRAY(name, cls, cap, ...) /* optional parameter: initializer */ \\\n public: \\\n cls &name(size_t idx) { return name##_[idx]; } \\\n const cls &name(size_t idx) const { return name##_[idx]; } \\\n size_t name##_length() const { \\\n auto lock = std::unique_lock(mutex_); \\\n return name##Length_; \\\n } \\\n void set_##name##_length(size_t len) { \\\n auto lock = std::unique_lock(mutex_); \\\n if (len < k_capacity_##name) { \\\n name##Length_ = len; \\\n } \\\n } \\\n \\\n private: \\\n static constexpr size_t k_capacity_##name{cap}; \\\n static_assert(k_capacity_##name <= 4096u, \"array cap should less than 4096\"); \\\n std::array name##_; \\\n size_t name##Length_ = [this]() { \\\n using Self = std::decay_t; \\\n ConfigBase::lengths_[#name] = reinterpret_cast(&Self::name##Length_); \\\n auto base = reinterpret_cast<::hf3fs::config::IConfig Self::*>(&Self::name##_); \\\n static_assert(sizeof(base) == sizeof(uintptr_t), \"sizeof(base) != sizeof(uintptr_t)\"); \\\n for (auto i = 0ul; i < k_capacity_##name; ++i) { \\\n ConfigBase::sections_[fmt::format(#name \"#{}\", i)] = base; \\\n *reinterpret_cast(&base) += sizeof(cls); \\\n } \\\n auto length = 1ul; \\\n __VA_OPT__(length = __VA_ARGS__(name##_);) \\\n return length; \\\n }()\n\n#define CONFIG_SECT(name, section) \\\n protected: \\\n struct T##name : public ConfigBase section; \\\n CONFIG_OBJ(name, T##name)\n\n#define CONFIG_ADD_ITEM(name, defaultValue, supportHotUpdated, ...) /* optional parameter: checker */ \\\n private: \\\n using T##name = ::hf3fs::config::ValueType>; \\\n using R##name = ::hf3fs::config::ReturnType; \\\n \\\n public: \\\n auto name##_getter() const { \\\n return [this] { return name(); }; \\\n } \\\n R##name name() const { return name##_.value(); } \\\n bool set_##name(R##name value) { return name##_.checkAndSet(value); } \\\n \\\n private: \\\n ::hf3fs::config::Item name##_ = ::hf3fs::config::Item(#name, defaultValue, [this] { \\\n using Self = std::decay_t; \\\n ConfigBase::items_[#name] = reinterpret_cast<::hf3fs::config::IItem Self::*>(&Self::name##_); \\\n return supportHotUpdated; \\\n }() __VA_OPT__(, ) __VA_ARGS__)\n\n#define CONFIG_ITEM(name, defaultValue, ...) CONFIG_ADD_ITEM(name, defaultValue, false, __VA_ARGS__)\n#define CONFIG_HOT_UPDATED_ITEM(name, defaultValue, ...) CONFIG_ADD_ITEM(name, defaultValue, true, __VA_ARGS__)\n\n#define CONFIG_VARIANT_TYPE(defaultType) \\\n CONFIG_ITEM(type, std::string{defaultType}, [this](const std::string &name) { \\\n using Self = std::decay_t; \\\n return ConfigBase::sections_.count(name); \\\n }); \\\n \\\n public: \\\n constexpr static inline bool is_variant_type() { return true; }\n\nnamespace config {\n\nstruct IItem {\n virtual ~IItem() = default;\n virtual Result validate(const std::string &path) const = 0;\n virtual Result update(const toml::node &node, bool isHotUpdate, const std::string &path) = 0;\n virtual void toToml(toml::table &table) const = 0;\n virtual bool isParsedFromString() const = 0;\n virtual bool operator==(const IItem &other) const = 0;\n virtual String toString() const = 0;\n};\n\nclass ConfigCallbackGuard;\n\nusing KeyValue = std::pair;\n\ninline std::string tomlToString(const toml::node &node) {\n std::stringstream ss;\n ss << toml::toml_formatter(node, toml::toml_formatter::default_flags & ~toml::format_flags::indentation);\n return ss.str();\n}\n\nstruct IConfig {\n virtual ~IConfig() = default;\n\n virtual std::unique_ptr clonePtr() const = 0;\n\n // return a default constructed object\n virtual std::unique_ptr defaultPtr() const = 0;\n\n // validate configuration items one by one.\n virtual Result validate(const std::string &path = {}) const = 0;\n\n // validate configuration items as a whole.\n virtual Result overallValidate() const { return Void{}; }\n\n // update configuration. [thread safe]\n virtual Result update(const toml::table &table, bool isHotUpdate = true, const std::string &path = {}) = 0;\n\n // update configuration from a string. [thread safe]\n Result update(std::string_view str, bool isHotUpdate);\n\n // update configuration from a file. [thread safe]\n Result update(const Path &path, bool isHotUpdate);\n\n // update configuration from a series of key-values. [thread safe]\n Result update(const std::vector &updates, bool isHotUpdate);\n\n // remove callback guard.\n virtual void removeCallbackGuard(ConfigCallbackGuard *guard) const = 0;\n\n // convert configuration to TOML. [thread safe]\n virtual toml::table toToml() const = 0;\n\n // convert configuration of specific section/item to TOML. [thread safe]\n virtual Result toToml(std::string_view key) const = 0;\n\n // find item by a key.\n virtual Result find(std::string_view key) = 0;\n\n virtual bool operator==(const IConfig &other) const = 0;\n\n struct ItemDiff {\n String key;\n String left;\n String right;\n };\n\n size_t diffWith(const IConfig &other, std::span diffs, size_t pos = 0) const {\n return diffWith(other, {}, diffs, pos);\n }\n\n virtual size_t diffWith(const IConfig &other, String path, std::span diffs, size_t pos) const = 0;\n\n virtual Result atomicallyUpdate(std::string_view str, bool isHotUpdate) = 0;\n Result atomicallyUpdate(std::string_view str) { return atomicallyUpdate(str, /*isHotUpdate=*/true); }\n\n virtual Result atomicallyUpdate(const Path &path, bool isHotUpdate) = 0;\n Result atomicallyUpdate(const Path &path) { return atomicallyUpdate(path, /*isHotUpdate=*/true); }\n\n virtual Result atomicallyUpdate(const std::vector &updates, bool isHotUpdate) = 0;\n Result atomicallyUpdate(const std::vector &updates) {\n return atomicallyUpdate(updates, /*isHotUpdate=*/true);\n }\n\n virtual Result validateUpdate(std::string_view str, bool isHotUpdate) = 0;\n Result validateUpdate(std::string_view str) { return validateUpdate(str, /*isHotUpdate=*/true); }\n\n // convert configuration to string. [thread safe]\n std::string toString() const { return tomlToString(toToml()); }\n\n // initialize config from command line and config files.\n Result init(int *argc, char ***argv, bool follyInit = true);\n};\n\ntemplate \nstruct ConfigValueToTomlNode {\n template \n auto operator()(V &&v) {\n if constexpr (std::is_enum_v) {\n return magic_enum::enum_name(std::forward(v));\n } else if constexpr (std::is_same_v) {\n return static_cast(v);\n } else if constexpr (std::is_same_v) {\n return v.string();\n } else if constexpr (std::derived_from) {\n return v.toToml();\n } else if constexpr (requires { std::string(v.toString()); }) {\n return v.toString();\n } else {\n return std::forward(v);\n }\n }\n};\n\nResult> parseFlags(std::string_view prefix, int &argc, char *argv[]);\n\nclass ConfigCallbackGuard {\n public:\n explicit ConfigCallbackGuard(const config::IConfig *cfg, auto &&...f)\n : cfg_(cfg),\n func_(std::forward(f)...) {}\n ~ConfigCallbackGuard() { dismiss(); }\n\n void setCallback(auto &&f) { func_ = std::forward(f); }\n void callCallback() { func_ ? func_() : void(); }\n void dismiss() { cfg_ ? std::exchange(cfg_, nullptr)->removeCallbackGuard(this) : void(); }\n\n private:\n const config::IConfig *cfg_;\n std::function func_;\n};\n\ntemplate \nclass TLSStore {\n public:\n TLSStore(T &&value)\n : ptr_(std::make_shared(std::move(value))) {}\n TLSStore(const TLSStore &o)\n : ptr_(o.ptr_.load(std::memory_order_acquire)) {}\n\n const T &value() const {\n auto &cache = *tlsCache_;\n size_t latest = version_.load(std::memory_order_acquire);\n if (UNLIKELY(cache.version != latest)) {\n cache.ptr = ptr_.load(std::memory_order_acquire);\n cache.version = latest;\n }\n return *cache.ptr;\n }\n\n template \n void setValue(V &&value) {\n ptr_.store(std::make_shared(std::forward(value)));\n ++version_;\n }\n\n TLSStore &operator=(const TLSStore &o) {\n ptr_.store(o.ptr_.load(std::memory_order_acquire));\n ++version_;\n return *this;\n }\n\n private:\n std::atomic version_ = 1;\n folly::atomic_shared_ptr ptr_{std::make_shared()};\n struct Cache {\n std::shared_ptr ptr;\n uint64_t version = 0;\n };\n folly::ThreadLocal tlsCache_;\n};\n\ntemplate \nusing RemoveOptional = typename std::conditional_t, T, std::optional>::value_type;\ntemplate \ninline constexpr bool IsPrimitive = std::is_trivially_copyable_v && sizeof(T) <= 8;\ntemplate \nusing ReturnType = std::conditional_t, T, const T &>;\ntemplate \nusing StoreType = std::conditional_t, AtomicValue, TLSStore>;\ntemplate \nusing ValueType = std::conditional_t, std::string, T>;\n\ntemplate \ninline Result tomlNodeToValue(const toml::node &node) {\n return node.visit([&](auto &&el) -> Result {\n using TE = std::decay_t;\n if constexpr (!toml::is_value) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"{} isn't value\", typeid(TE).name()));\n } else {\n using E = typename TE::value_type;\n\n if constexpr (std::is_same_v) {\n return *el;\n } else if constexpr (std::is_same_v) {\n // do not allow any implicit conversion to bool\n return makeError(StatusCode::kConfigInvalidType,\n fmt::format(\"implicit conversion from {} to bool is not allowed\", typeid(E).name()));\n } else if constexpr (std::is_floating_point_v) {\n if constexpr (std::is_same_v || std::is_floating_point_v) {\n return *el;\n } else {\n return makeError(StatusCode::kConfigInvalidType,\n fmt::format(\"{} is not int64_t or floating types\", typeid(E).name()));\n }\n } else if constexpr (std::is_enum_v) {\n if constexpr (std::is_same_v) {\n auto opt = magic_enum::enum_cast(*el);\n if (opt) {\n return opt.value();\n } else {\n return makeError(StatusCode::kConfigInvalidValue, fmt::format(\"Value {}\", *el));\n }\n } else {\n return makeError(StatusCode::kConfigInvalidType,\n fmt::format(\"{} is enum but {} is not string\", typeid(T).name(), typeid(E).name()));\n }\n } else if constexpr (requires { Result{T::from(*el)}; }) {\n return T::from(*el);\n } else if constexpr (std::is_constructible_v) {\n try {\n return T(*el);\n } catch (const std::exception &e) {\n return makeError(\n StatusCode::kConfigInvalidType,\n fmt::format(\"Throws when constructing T ({}), E is {}: \", typeid(T).name(), typeid(E).name(), e.what()));\n }\n } else {\n return makeError(StatusCode::kConfigInvalidType,\n fmt::format(\"T is {}, E is {}\", typeid(T).name(), typeid(E).name()));\n }\n }\n });\n}\n\ntemplate \nclass Item : public IItem {\n public:\n Item(std::string name, T defaultValue, bool supportHotUpdate, std::function)> checker = nullptr)\n : value_(std::move(defaultValue)),\n name_(std::move(name)),\n supportHotUpdate_(supportHotUpdate),\n checker_(checker ? std::move(checker) : [](ReturnType) { return true; }) {}\n\n ReturnType value() const { return value_.value(); }\n\n template \n void setValue(V &&value) {\n value_.setValue(std::forward(value));\n }\n\n bool operator==(const IItem &other) const final {\n if (typeid(*this) != typeid(other)) {\n return false;\n }\n return *this == *reinterpret_cast(&other);\n }\n\n bool operator==(const Item &other) const { return this == std::addressof(other) || value() == other.value(); }\n\n bool operator==(const T &val) const { return value() == val; }\n\n String toString() const final {\n toml::table table;\n toToml(table);\n auto *view = table.get(name_);\n if constexpr (is_optional_v) {\n return view ? tomlToString(*view) : \"nullopt\";\n } else {\n return tomlToString(*view);\n }\n }\n\n bool checkAndSet(ReturnType value) {\n if (checker_(value)) {\n setValue(value);\n return true;\n }\n return false;\n }\n\n Result update(const toml::node &node, bool isHotUpdate, const std::string &path) final {\n try {\n bool enableUpdate = supportHotUpdate_ || !isHotUpdate;\n if constexpr (is_vector_v || is_set_v) {\n return updateVectorOrSet(node, enableUpdate, path);\n } else if constexpr (is_map_v) {\n return updateMap(node, enableUpdate, path);\n } else {\n return updateNormal(node, enableUpdate, path);\n }\n } catch (const std::exception &e) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"name: {}, error: {}\", path, e.what()));\n }\n }\n\n Result validate(const std::string &path) const final {\n if (!checker_(value())) {\n return makeError(StatusCode::kConfigValidateFailed, fmt::format(\"Check failed: {}\", path));\n }\n return Void{};\n }\n\n void toToml(toml::table &table) const override {\n if constexpr (is_vector_v || is_set_v) {\n toml::array array;\n for (const auto &item : value()) {\n array.emplace_back(ConfigValueToTomlNode{}(item));\n }\n table.insert_or_assign(name_, std::move(array));\n } else if constexpr (is_map_v) {\n toml::table inlineTable;\n for (const auto &pair : value()) {\n inlineTable.emplace(pair.first, ConfigValueToTomlNode{}(pair.second));\n }\n inlineTable.is_inline(true);\n table.insert_or_assign(name_, std::move(inlineTable));\n } else if constexpr (is_optional_v) {\n if (value().has_value()) {\n table.insert_or_assign(name_, ConfigValueToTomlNode>{}(value().value()));\n }\n } else {\n table.insert_or_assign(name_, ConfigValueToTomlNode{}(value()));\n }\n }\n\n bool isParsedFromString() const override {\n return std::is_constructible_v, std::string> || std::is_enum_v>;\n }\n\n protected:\n Result updateNormal(const toml::node &node, bool enableUpdate, const std::string &path) {\n try {\n auto res = tomlNodeToValue>(node);\n if (res.hasError()) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"name: {}, error: {}\", path, res.error()));\n }\n if (!checker_(res.value())) {\n return makeError(StatusCode::kConfigValidateFailed, fmt::format(\"Check failed: {}\", path));\n }\n if (res.value() != value()) {\n if (enableUpdate) {\n setValue(std::move(res.value()));\n } else {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"Not support hot update: {}\", path));\n }\n }\n return Void{};\n } catch (const std::exception &e) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"throws when update {}: {}\", path, e.what()));\n }\n }\n\n Result updateVectorOrSet(const toml::node &node, bool enableUpdate, const std::string &path) {\n using I = typename T::value_type;\n\n if (!node.is_array()) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not array: {}\", path));\n }\n auto arr = node.as_array();\n if (arr == nullptr) {\n return makeError(StatusCode::kConfigInvalidValue, fmt::format(\"Empty array: {}\", path));\n }\n\n T tmp;\n for (size_t i = 0; i < arr->size(); ++i) {\n const auto &e = (*arr)[i];\n auto res = [&]() -> Result {\n if constexpr (std::derived_from) {\n if (!e.is_table()) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not table: {}[{}]\", path, i));\n }\n I v;\n RETURN_ON_ERROR(v.update(*e.as_table(), /*isHotUpdate=*/false));\n return v;\n } else {\n return tomlNodeToValue>(e);\n }\n }();\n if (res.hasError()) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"name: {}, error: {}\", path, res.error()));\n }\n if constexpr (is_set_v) {\n auto [it, succ] = tmp.emplace(std::move(res.value()));\n if (!succ) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"name: {}, set value repeats\", path));\n }\n } else {\n tmp.push_back(std::move(res.value()));\n }\n }\n if (!checker_(tmp)) {\n return makeError(StatusCode::kConfigValidateFailed, fmt::format(\"Array check failed: {}\", path));\n }\n if (tmp != value()) {\n if (enableUpdate) {\n value_.setValue(std::move(tmp));\n } else {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"Not support hot update: {}\", path));\n }\n }\n return Void{};\n }\n\n Result updateMap(const toml::node &node, bool enableUpdate, const std::string &path) {\n using I = typename T::mapped_type;\n\n if (!node.is_table()) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not map: {}\", path));\n }\n auto table = node.as_table();\n if (table == nullptr) {\n return makeError(StatusCode::kConfigInvalidValue, fmt::format(\"Empty map: {}\", path));\n }\n\n T tmp;\n for (const auto &e : *table) {\n auto res = tomlNodeToValue(e.second);\n if (res.hasError()) {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"name: {}, error: {}\", path, res.error()));\n }\n auto [it, succ] = tmp.emplace(std::string{e.first.str()}, std::move(res.value()));\n if (!succ) {\n return makeError(StatusCode::kConfigRedundantKey,\n fmt::format(\"name: {}, redundant key: {}\", path, e.first.str()));\n }\n }\n if (!checker_(tmp)) {\n return makeError(StatusCode::kConfigValidateFailed, fmt::format(\"Array check failed: {}\", path));\n }\n if (tmp != value()) {\n if (enableUpdate) {\n value_.setValue(std::move(tmp));\n } else {\n return makeError(StatusCode::kConfigUpdateFailed, fmt::format(\"Not support hot update: {}\", path));\n }\n }\n return Void{};\n }\n\n private:\n StoreType value_;\n std::string name_;\n bool supportHotUpdate_ = false;\n std::function)> checker_;\n};\n\ninline std::string concat(const std::string &a, const std::string &b) { return a.empty() ? b : a + \".\" + b; }\n\n} // namespace config\n\nusing config::ConfigCallbackGuard;\n\ntemplate \nclass ConfigBase : public config::IConfig {\n protected:\n ConfigBase() = default;\n ConfigBase(const ConfigBase &o)\n : sections_(o.sections_),\n items_(o.items_),\n lengths_(o.lengths_) {}\n ConfigBase &operator=(const ConfigBase &) { return *this; }\n\n public:\n using config::IConfig::update;\n Result update(const toml::table &table, bool isHotUpdate = true, const std::string &path = {}) final {\n auto self = reinterpret_cast(this);\n auto lock = std::unique_lock(mutex_);\n\n for (auto &pair : table) {\n auto name = std::string(pair.first.str());\n auto &node = pair.second;\n\n if (lengths().count(name)) {\n if (!(node.is_array_of_tables() || (node.is_array() && node.as_array()->empty()))) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not array of table: {}\", name));\n }\n auto array = node.as_array();\n auto size = array->size();\n for (auto i = 0ul; i < size; ++i) {\n auto itemName = fmt::format(\"{}#{}\", name, i);\n auto itemTable = array->get_as(i);\n if (itemTable == nullptr) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not a table: {}\", itemName));\n }\n if (!sections().count(itemName)) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Array length exceed: {}\", itemName));\n }\n RETURN_ON_ERROR(\n (self->*(sections().at(itemName))).update(*itemTable, isHotUpdate, config::concat(path, itemName)));\n }\n self->*(lengths().at(name)) = size;\n } else if (sections().count(name)) {\n if (!node.is_table()) {\n return makeError(StatusCode::kConfigInvalidType, fmt::format(\"Not table: {}\", name));\n }\n RETURN_ON_ERROR(\n (self->*(sections().at(name))).update(*node.as_table(), isHotUpdate, config::concat(path, name)));\n } else if (items().count(name)) {\n RETURN_ON_ERROR((self->*(items().at(name))).update(node, isHotUpdate, config::concat(path, name)));\n } else {\n return makeError(StatusCode::kConfigRedundantKey, fmt::format(\"Invalid key: {}\", config::concat(path, name)));\n }\n }\n\n // call callbacks after update.\n for (auto &callback : callbacks_) {\n callback->callCallback();\n }\n return overallValidate();\n }\n\n toml::table toToml() const final {\n auto lock = std::unique_lock(mutex_);\n\n auto self = reinterpret_cast(this);\n toml::table table;\n for (auto &pair : items()) {\n (self->*pair.second).toToml(table);\n }\n if constexpr (requires { Parent::is_variant_type; }) {\n auto it = sections().find(self->type());\n if (it != sections().end()) {\n table.insert_or_assign(it->first, (self->*it->second).toToml());\n }\n return table;\n }\n for (auto &pair : sections()) {\n if (pair.first.find('#') != std::string::npos) {\n continue;\n }\n table.insert_or_assign(pair.first, (self->*pair.second).toToml());\n }\n for (auto &pair : lengths()) {\n toml::array array;\n for (auto i = 0ul; i < self->*pair.second; ++i) {\n array.emplace_back((self->*sections().at(fmt::format(\"{}#{}\", pair.first, i))).toToml());\n }\n table.insert_or_assign(pair.first, std::move(array));\n }\n return table;\n }\n\n Result toToml(std::string_view key) const final {\n if (key.empty()) return toToml();\n\n auto self = reinterpret_cast(this);\n\n auto pos = key.find('.');\n if (pos == std::string_view::npos) {\n auto iit = items().find(key);\n if (iit != items().end()) {\n toml::table table;\n (self->*(iit->second)).toToml(table);\n return table;\n }\n auto sit = sections().find(key);\n if (sit != sections().end()) {\n return (self->*(sit->second)).toToml();\n }\n return makeError(StatusCode::kConfigKeyNotFound, key);\n } else {\n auto section = key.substr(0, pos);\n key.remove_prefix(pos + 1);\n auto it = sections().find(section);\n if (it != sections().end()) {\n return (self->*(it->second)).toToml(key);\n }\n return makeError(StatusCode::kConfigKeyNotFound, section);\n }\n }\n\n Result find(std::string_view key) final {\n auto self = reinterpret_cast(this);\n\n auto pos = key.find('.');\n if (pos == std::string_view::npos) {\n auto it = items().find(std::string{key});\n if (it == items().end()) {\n return makeError(StatusCode::kConfigValidateFailed);\n }\n return &(self->*(it->second));\n } else {\n auto section = key.substr(0, pos);\n key.remove_prefix(pos + 1);\n auto it = sections().find(std::string{section});\n if (it == sections().end()) {\n return makeError(StatusCode::kConfigValidateFailed);\n }\n return (self->*(it->second)).find(key);\n }\n }\n\n std::unique_ptr clonePtr() const final { return std::make_unique(clone()); }\n\n std::unique_ptr defaultPtr() const final { return std::make_unique(); }\n\n // clone current configuration. [thread safe]\n Parent clone() const {\n auto lock = std::unique_lock(mutex_);\n return reinterpret_cast(*this);\n }\n\n // copy from another configuration. [thread safe]\n void copy(const Parent &o) {\n std::scoped_lock lock(mutex_, o.mutex_);\n reinterpret_cast(*this) = o;\n }\n\n // atomically update configuration from a string.\n using IConfig::atomicallyUpdate;\n Result atomicallyUpdate(std::string_view str, bool isHotUpdate) final {\n Parent newConfig = clone();\n RETURN_ON_ERROR(newConfig.update(str, isHotUpdate));\n auto res = update(str, isHotUpdate);\n XLOGF_IF(FATAL, !res, \"Unexpected update error: {}\", res.error());\n return Void{};\n }\n\n // atomically update configuration from a file.\n Result atomicallyUpdate(const Path &path, bool isHotUpdate) final {\n Parent newConfig = clone();\n RETURN_ON_ERROR(newConfig.IConfig::update(path, isHotUpdate));\n auto res = update(path, isHotUpdate);\n XLOGF_IF(FATAL, !res, \"Unexpected update error: {}\", res.error());\n return Void{};\n }\n\n Result atomicallyUpdate(const std::vector &updates, bool isHotUpdate) final {\n Parent newConfig = clone();\n RETURN_ON_ERROR(newConfig.IConfig::update(updates, isHotUpdate));\n auto res = update(updates, isHotUpdate);\n XLOGF_IF(FATAL, !res, \"Unexpected update error: {}\", res.error());\n return Void{};\n }\n\n Result validateUpdate(std::string_view str, bool isHotUpdate) final {\n Parent newConfig = clone();\n RETURN_ON_ERROR(newConfig.IConfig::update(str, isHotUpdate));\n return Void{};\n }\n\n Result validate(const std::string &path = {}) const final {\n auto self = reinterpret_cast(this);\n for (auto &pair : sections()) {\n RETURN_ON_ERROR((self->*pair.second).validate(config::concat(path, pair.first)));\n }\n for (auto &pair : items()) {\n RETURN_ON_ERROR((self->*pair.second).validate(config::concat(path, pair.first)));\n }\n return overallValidate();\n }\n\n // add callback guard.\n std::unique_ptr addCallbackGuard(auto &&...func) const {\n auto guard = std::make_unique(this, std::forward(func)...);\n auto lock = std::unique_lock(mutex_);\n callbacks_.insert(guard.get());\n return guard;\n }\n\n bool operator==(const config::IConfig &other) const final {\n if (typeid(*this) != typeid(other)) {\n return false;\n }\n if (this == std::addressof(other)) {\n return true;\n }\n return *this == *reinterpret_cast(&other);\n }\n\n bool operator==(const Parent &other) const {\n ItemDiff diffs[1];\n return diffWith(other, std::span(diffs)) == 0;\n }\n\n using config::IConfig::diffWith;\n size_t diffWith(const config::IConfig &other, String path, std::span diffs, size_t pos) const final {\n XLOGF_IF(FATAL,\n typeid(*this) != typeid(other),\n \"Call diffWith on different config types: {} and {}\",\n typeid(*this).name(),\n typeid(other).name());\n if (this == std::addressof(other)) {\n return pos;\n }\n return diffWith(*reinterpret_cast(&other), std::move(path), diffs, pos);\n }\n\n size_t diffWith(const Parent &other, String path, std::span diffs, size_t pos) const {\n auto &self = *reinterpret_cast(this);\n auto makePath = [&path](const String &name) { return path.empty() ? name : fmt::format(\"{}.{}\", path, name); };\n\n for (const auto &[name, item] : items()) {\n auto &selfItem = self.*item;\n auto &otherItem = other.*item;\n if (!(selfItem == otherItem)) {\n diffs[pos++] = ItemDiff{makePath(name), selfItem.toString(), otherItem.toString()};\n if (pos >= diffs.size()) return pos;\n }\n }\n for (const auto &[name, sec] : sections()) {\n auto &selfSec = self.*sec;\n auto &otherSec = other.*sec;\n pos = selfSec.diffWith(otherSec, makePath(name), diffs, pos);\n if (pos >= diffs.size()) return pos;\n }\n return pos;\n }\n\n protected:\n // remove callback guard.\n void removeCallbackGuard(ConfigCallbackGuard *guard) const final {\n auto lock = std::unique_lock(mutex_);\n callbacks_.erase(guard);\n }\n\n const auto §ions() const noexcept { return sections_; }\n const auto &items() const noexcept { return items_; }\n const auto &lengths() const noexcept { return lengths_; }\n\n protected:\n mutable std::mutex mutex_;\n // offsets of sections.\n std::map> sections_;\n // offsets of items.\n std::map> items_;\n // length of section arrays.\n std::map> lengths_;\n // callbacks after update.\n mutable std::set> callbacks_;\n};\n\nnamespace ConfigCheckers {\ntemplate \nconcept Arithmetic = std::is_arithmetic_v;\n\ntemplate \nconcept Container = requires(T t) {\n t.empty();\n t.size();\n};\n\ntemplate \ninline bool checkGE(T val) {\n return val >= threshold;\n}\n\nstruct CheckPositive {\n template \n bool operator()(T val) const {\n return val > 0;\n }\n};\n\ninline constexpr CheckPositive checkPositive;\n\ntemplate \ninline bool isPositivePrime(T n) {\n if (n < 2) return false;\n for (T f = 2; f * f <= n; f++)\n if (n % f == 0) return false;\n return true;\n}\n\ntemplate \ninline bool checkNotNegative(T val) {\n return val >= 0;\n}\n\nstruct CheckNotEmpty {\n template \n bool operator()(const C &c) const {\n return !c.empty();\n }\n};\n\ninline constexpr CheckNotEmpty checkNotEmpty;\n\ntemplate \ninline bool checkEmpty(const C &c) {\n return c.empty();\n}\n} // namespace ConfigCheckers\n\n} // namespace hf3fs\n\nFMT_BEGIN_NAMESPACE\n\ntemplate <>\nstruct formatter : formatter {\n template \n auto format(const hf3fs::config::IConfig &config, FormatContext &ctx) const {\n return formatter::format(config.toString(), ctx);\n }\n};\n\nFMT_END_NAMESPACE\n"], ["/3FS/src/meta/service/MetaOperator.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"client/mgmtd/ICommonMgmtdClient.h\"\n#include \"client/mgmtd/IMgmtdClientForServer.h\"\n#include \"client/storage/StorageClient.h\"\n#include \"common/kv/IKVEngine.h\"\n#include \"common/kv/ITransaction.h\"\n#include \"common/kv/WithTransaction.h\"\n#include \"common/utils/BackgroundRunner.h\"\n#include \"common/utils/CPUExecutorGroup.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/CoroutinesPool.h\"\n#include \"common/utils/Result.h\"\n#include \"core/user/UserStoreEx.h\"\n#include \"fbs/meta/Common.h\"\n#include \"fbs/meta/Service.h\"\n#include \"fdb/FDBRetryStrategy.h\"\n#include \"meta/base/Config.h\"\n#include \"meta/components/ChainAllocator.h\"\n#include \"meta/components/Distributor.h\"\n#include \"meta/components/FileHelper.h\"\n#include \"meta/components/Forward.h\"\n#include \"meta/components/GcManager.h\"\n#include \"meta/components/SessionManager.h\"\n#include \"meta/store/Inode.h\"\n#include \"meta/store/MetaStore.h\"\n#include \"meta/store/ops/BatchOperation.h\"\n\nnamespace hf3fs::meta::server {\n\nclass BatchedOp;\n\nclass MetaOperator : public folly::NonCopyableNonMovable {\n public:\n MetaOperator(const Config &cfg,\n flat::NodeId nodeId,\n std::shared_ptr kvEngine,\n std::shared_ptr mgmtdClient,\n std::shared_ptr storageClient,\n std::unique_ptr forward);\n\n CoTryTask init(std::optional rootLayout);\n\n void start(CPUExecutorGroup &exec);\n void beforeStop();\n void afterStop();\n\n CoTryTask authenticate(AuthReq req);\n\n CoTryTask statFs(StatFsReq req);\n\n CoTryTask stat(StatReq req);\n\n CoTryTask getRealPath(GetRealPathReq req);\n\n CoTryTask open(OpenReq req);\n\n CoTryTask close(CloseReq req);\n\n CoTryTask create(CreateReq req);\n\n CoTryTask mkdirs(MkdirsReq req);\n\n CoTryTask symlink(SymlinkReq req);\n\n CoTryTask remove(RemoveReq req);\n\n CoTryTask rename(RenameReq req);\n\n CoTryTask list(ListReq req);\n\n CoTryTask truncate(TruncateReq req);\n\n CoTryTask sync(SyncReq req);\n\n CoTryTask hardLink(HardLinkReq req);\n\n CoTryTask setAttr(SetAttrReq req);\n\n CoTryTask pruneSession(PruneSessionReq req);\n\n CoTryTask dropUserCache(DropUserCacheReq req);\n\n CoTryTask lockDirectory(LockDirectoryReq req);\n\n CoTryTask testRpc(TestRpcReq req);\n\n CoTryTask batchStat(BatchStatReq req);\n\n CoTryTask batchStatByPath(BatchStatByPathReq req);\n\n private:\n friend class MockMeta;\n\n template \n FRIEND_TEST(TestBatchOp, batch);\n\n template \n FRIEND_TEST(TestCreate, batch);\n\n class Batch {\n public:\n void setNext(BatchedOp *op, folly::coro::Baton *baton) {\n next = op;\n nextBaton = baton;\n }\n\n bool wakeupNext() {\n if (!next) {\n return false;\n }\n nextBaton->post();\n next = nullptr;\n nextBaton = nullptr;\n return true;\n }\n\n BatchedOp *getNext() const { return next; }\n\n private:\n BatchedOp *next = nullptr;\n folly::coro::Baton *nextBaton = nullptr;\n };\n\n kv::FDBRetryStrategy::Config createRetryConfig() const;\n kv::FDBRetryStrategy createRetryStrategy() const { return kv::FDBRetryStrategy(createRetryConfig()); }\n\n template \n auto runOp(Func &&func, Arg &&arg)\n -> CoTryTask::element_type::RspT>;\n\n template \n std::unique_ptr addBatchReq(InodeId inodeId, BatchedOp::Waiter &waiter) {\n auto func = [&](auto &map) {\n auto [iter, inserted] = map.try_emplace(inodeId);\n auto &batch = iter->second;\n if (inserted) {\n assert(!batch.getNext());\n auto op = std::make_unique(*metaStore_, inodeId);\n op->add(waiter);\n waiter.baton.post();\n return op;\n } else if (!batch.getNext()) {\n auto op = std::make_unique(*metaStore_, inodeId);\n op->add(waiter);\n batch.setNext(op.get(), &waiter.baton);\n return op;\n } else {\n auto next = batch.getNext();\n auto num_reqs = next->numReqs();\n if (UNLIKELY(config_.max_batch_operations() != 0 && num_reqs >= config_.max_batch_operations())) {\n auto msg = fmt::format(\"too many batch operations on {}\", inodeId);\n XLOG(WARN, msg);\n waiter.result = makeError(MetaCode::kBusy, std::move(msg));\n waiter.baton.post();\n } else {\n if (num_reqs && num_reqs % 1024 == 0) {\n XLOGF(WARN, \"{} batch operations on {}\", num_reqs, inodeId);\n }\n next->add(waiter);\n }\n return std::unique_ptr();\n }\n };\n return batches_.withLock(func, inodeId);\n }\n\n CoTryTask runBatch(InodeId inodeId,\n std::unique_ptr op,\n std::optional deadline = std::nullopt);\n\n template \n CoTryTask runInBatch(InodeId inodeId, Req req);\n\n CoTryTask authenticate(UserInfo &userInfo);\n\n const Config &config_;\n flat::NodeId nodeId_;\n analytics::StructuredTraceLog metaEventTraceLog_;\n std::shared_ptr kvEngine_;\n std::shared_ptr mgmtd_;\n std::shared_ptr distributor_;\n std::shared_ptr userStore_;\n std::shared_ptr inodeIdAlloc_;\n std::shared_ptr chainAlloc_;\n std::shared_ptr fileHelper_;\n std::shared_ptr sessionManager_;\n std::shared_ptr gcManager_;\n std::unique_ptr forward_;\n\n std::unique_ptr metaStore_;\n\n Shards, 63> batches_;\n\n std::atomic_bool stop_{false};\n std::unique_ptr bgRunner_;\n};\n} // namespace hf3fs::meta::server\n"], ["/3FS/src/storage/store/StorageTarget.h", "#pragma once\n\n#include \n#include \n\n#include \"chunk_engine/src/cxx.rs.h\"\n#include \"common/monitor/Recorder.h\"\n#include \"common/utils/CoLockManager.h\"\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/LockManager.h\"\n#include \"common/utils/Path.h\"\n#include \"storage/aio/BatchReadJob.h\"\n#include \"storage/store/ChunkEngine.h\"\n#include \"storage/store/ChunkStore.h\"\n#include \"storage/store/PhysicalConfig.h\"\n#include \"storage/update/UpdateJob.h\"\n\nnamespace hf3fs::storage {\n\nclass StorageTarget : public enable_shared_from_this {\n protected:\n StorageTarget(const ChunkStore::Config &config,\n GlobalFileStore &globalFileStore,\n uint32_t diskIndex,\n chunk_engine::Engine *engine);\n\n public:\n using Config = ChunkStore::Config;\n\n ~StorageTarget();\n\n // create storage target.\n Result create(const PhysicalConfig &config);\n\n // load storage target.\n Result load(const Path &path);\n\n // add new chunk size.\n Result addChunkSize(const std::vector &sizeList);\n\n // get target id. [guaranteed loaded]\n TargetId targetId() const { return TargetId{targetConfig_.target_id}; }\n\n // get chain id. [guaranteed loaded]\n ChainId chainId() const { return ChainId{targetConfig_.chain_id}; }\n\n // set chain id.\n Result setChainId(ChainId chainId);\n\n // get disk index.\n uint32_t diskIndex() const { return diskIndex_; }\n\n // get target path. [guaranteed loaded]\n Path path() const { return targetConfig_.path; }\n\n // get all chunk metadata\n Result getAllMetadata(ChunkMetaVector &metadataVec);\n Result getAllMetadataMap(std::unordered_map &metas);\n\n // lock chunk.\n auto lockChunk(folly::coro::Baton &baton, const ChunkId &chunk, const std::string &tag) {\n return chunkLocks_.lock(baton, chunk.data(), tag);\n }\n\n // try lock channel.\n auto tryLockChannel(folly::coro::Baton &baton, const std::string &key) { return channelLocks_.tryLock(baton, key); }\n\n // prepare aio read.\n Result aioPrepareRead(AioReadJob &job);\n\n // finish aio read.\n Result aioFinishRead(AioReadJob &job);\n\n // update chunk (write/remove/truncate).\n void updateChunk(UpdateJob &job, folly::CPUThreadPoolExecutor &executor);\n\n // query chunks: the chunk ids in result are in reverse lexicographical order\n Result>> queryChunks(const ChunkIdRange &chunkIdRange);\n\n // query chunk.\n Result queryChunk(const ChunkId &chunkId);\n\n // recycle a batch of chunks. return true if all holes are punched.\n Result punchHole() {\n if (useChunkEngine()) {\n return true;\n } else {\n return chunkStore_.punchHole();\n }\n }\n\n // sync meta kv.\n Result sync() {\n if (useChunkEngine()) {\n return Void{};\n } else {\n return chunkStore_.sync();\n }\n }\n\n // report unrecycled size.\n Result reportUnrecycledSize();\n\n // get used size.\n uint64_t usedSize() const {\n if (useChunkEngine()) {\n return ChunkEngine::chainUsedSize(*engine_, ChainId{targetConfig_.chain_id});\n } else {\n return chunkStore_.usedSize();\n }\n }\n\n // get unused size.\n uint64_t unusedSize() const { return unusedSize_; }\n\n // get all uncommitted chunk ids.\n Result> uncommitted() {\n if (useChunkEngine()) {\n return ChunkEngine::queryUncommittedChunks(*engine_, chainId());\n } else {\n return chunkStore_.uncommitted();\n }\n }\n\n // reset uncommitted chunk to committed state.\n Result resetUncommitted(ChainVer chainVer) {\n if (useChunkEngine()) {\n return ChunkEngine::resetUncommittedChunks(*engine_, chainId(), chainVer);\n } else {\n return chunkStore_.resetUncommitted(chainVer);\n }\n }\n\n // enable or disable emergency recycling.\n void setEmergencyRecycling(bool enable) {\n if (useChunkEngine()) {\n return;\n } else {\n return chunkStore_.setEmergencyRecycling(enable);\n }\n }\n\n // record real read.\n void recordRealRead(uint32_t bytes, Duration latency) const;\n\n // disk monitor tag.\n auto &tag() const { return diskTag_; }\n\n // check alive or not.\n std::weak_ptr aliveWeakPtr() const { return alive_; }\n\n // global serial number.\n auto generationId() const { return generationId_; }\n\n // release self.\n Result release() {\n released_ = true;\n return sync();\n }\n\n // check if chunk engine is used.\n inline bool useChunkEngine() const { return targetConfig_.only_chunk_engine; }\n\n private:\n const Config &config_;\n std::shared_ptr alive_ = std::make_shared();\n uint32_t diskIndex_;\n uint32_t generationId_;\n chunk_engine::Engine *engine_{};\n std::atomic unusedSize_{};\n monitor::TagSet diskTag_;\n monitor::TagSet targetTag_;\n monitor::Recorder::TagRef readCountPerDisk_;\n monitor::Recorder::TagRef readBytesPerDisk_;\n monitor::Recorder::TagRef readSuccBytesPerDisk_;\n monitor::Recorder::TagRef readSuccLatencyPerDisk_;\n monitor::Recorder::TagRef targetUsedSize_;\n monitor::Recorder::TagRef targetReservedSize_;\n monitor::Recorder::TagRef targetUnrecycledSize_;\n PhysicalConfig targetConfig_;\n ChunkStore chunkStore_;\n CoLockManager<> chunkLocks_;\n CoLockManager<> channelLocks_;\n folly::Synchronized, std::mutex> chunkSizeList_;\n bool released_ = false;\n};\n\n} // namespace hf3fs::storage\n"], ["/3FS/src/common/kv/mem/MemKV.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/kv/ITransaction.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/StatusCode.h\"\n#include \"common/utils/String.h\"\n\nnamespace hf3fs::kv::mem {\n\ninline int32_t memKvDefaultLimit = 25;\n\nclass MemKV : public folly::MoveOnly {\n public:\n struct VersionstampedKV {\n std::string key;\n std::string value;\n bool onKey;\n uint32_t offset;\n\n static VersionstampedKV versionstampedKey(std::string key, uint32_t offset, std::string value) {\n return {key, value, true, offset};\n }\n\n static VersionstampedKV versionstampedValue(std::string key, std::string value, uint32_t offset) {\n return {key, value, false, offset};\n }\n };\n\n Result> get(std::string_view key, int64_t readVersion) const {\n std::shared_lock lock(mutex_);\n\n auto it = map_.find(String(key));\n if (it == map_.end()) {\n return std::optional();\n }\n\n auto version_it = it->second.upper_bound(readVersion);\n if (version_it != it->second.begin()) {\n --version_it;\n if (version_it->second.has_value()) {\n return std::make_optional(version_it->second.value());\n }\n }\n return std::optional();\n }\n\n Result getRange(const IReadOnlyTransaction::KeySelector &begin,\n const IReadOnlyTransaction::KeySelector &end,\n int32_t limit,\n int64_t readVersion) const {\n if (limit < 1) {\n limit = memKvDefaultLimit;\n }\n std::shared_lock lock(mutex_);\n\n std::vector kvs;\n\n if (begin.key > end.key || (begin.key == end.key && !(begin.inclusive && end.inclusive))) {\n return IReadOnlyTransaction::GetRangeResult(std::move(kvs), false);\n }\n\n auto begin_it = begin.inclusive ? map_.lower_bound(begin.key) : map_.upper_bound(begin.key);\n auto end_it = end.inclusive ? map_.upper_bound(end.key) : map_.lower_bound(end.key);\n while (begin_it != end_it && kvs.size() < (size_t)limit) {\n auto version_it = begin_it->second.upper_bound(readVersion);\n if (version_it != begin_it->second.begin()) {\n --version_it;\n if (version_it->second.has_value()) {\n kvs.emplace_back(begin_it->first, version_it->second.value());\n }\n }\n ++begin_it;\n }\n\n return IReadOnlyTransaction::GetRangeResult(std::move(kvs), begin_it != end_it);\n }\n\n Result commit(int64_t readVersion,\n const std::unordered_set &readKeys,\n const std::vector> readRanges,\n const std::vector>> changes,\n const std::vector versionstampedChanges,\n const std::set writeConflicts) {\n // if transaction contains no updates, don't need commit.\n if (changes.empty() && versionstampedChanges.empty() && writeConflicts.empty()) {\n return -1; // return a invalid version\n }\n if (readVersion < 0) {\n return makeError(TransactionCode::kFailed, \"MemKV transaction invalid version!\");\n }\n\n std::unique_lock lock(mutex_);\n\n // check conflict\n for (auto &key : readKeys) {\n auto it = map_.find(key);\n if (it != map_.end()) {\n auto version_it = it->second.upper_bound(readVersion);\n if (version_it != it->second.end()) {\n return makeError(TransactionCode::kConflict, \"MemKV transaction conflicts!\");\n }\n }\n }\n for (auto &range : readRanges) {\n auto it = map_.lower_bound(range.first);\n while (it != map_.end() && it->first < range.second) {\n auto version_it = it->second.upper_bound(readVersion);\n if (version_it != it->second.end()) {\n return makeError(TransactionCode::kConflict, \"MemKV transaction conflicts!\");\n }\n it++;\n }\n }\n\n auto version = ++version_;\n uint16_t seq = 0;\n for (auto change : versionstampedChanges) {\n Versionstamp(version, seq++).update(change);\n XLOGF_IF(FATAL, change.onKey && map_.contains(change.key), \"shouldn't happen\");\n map_[change.key][version] = change.value;\n }\n for (auto &change : changes) {\n if (change.second.has_value()) {\n map_[change.first][version] = change.second.value();\n } else {\n map_[change.first][version] = std::nullopt;\n }\n }\n for (const auto &conflict : writeConflicts) {\n if (map_.contains(conflict)) {\n auto value = map_[conflict].rbegin()->second;\n map_[conflict][version] = value;\n } else {\n map_[conflict][version] = std::nullopt;\n }\n }\n return version;\n }\n\n int64_t version() const {\n std::shared_lock lock(mutex_);\n return version_;\n }\n\n void backup() { states_.lock()->push(version()); }\n\n void restore() {\n auto guard = states_.lock();\n auto version = guard->front();\n guard->pop();\n restore(version);\n }\n\n private:\n struct Versionstamp {\n std::array version;\n std::array seq;\n\n Versionstamp(uint64_t version, uint16_t seq)\n : version(folly::bit_cast>(folly::Endian::big64(version))),\n seq(folly::bit_cast>(folly::Endian::big16(seq))) {}\n\n void update(VersionstampedKV &kv) const {\n auto &str = kv.onKey ? kv.key : kv.value;\n auto offset = kv.offset;\n XLOGF_IF(FATAL, offset + 10 > str.size(), \"{} {}\", offset, str.size());\n memcpy(str.data() + offset, (char *)this, 10);\n }\n };\n static_assert(sizeof(Versionstamp) == 10);\n\n void restore(int64_t version) {\n std::unique_lock lock(mutex_);\n version_ = version;\n\n // remove all modification after version\n auto iter = map_.begin();\n while (iter != map_.end()) {\n auto &values = iter->second;\n auto pos = values.lower_bound(version_ + 1);\n if (pos != values.end()) {\n values.erase(pos, values.end());\n }\n if (values.empty()) {\n map_.erase(iter++);\n } else {\n iter++;\n }\n }\n }\n\n void clear() {\n std::unique_lock lock(mutex_);\n map_.clear();\n version_ = 0;\n }\n\n private:\n mutable std::shared_mutex mutex_;\n folly::Synchronized, std::mutex> states_;\n std::map>, std::less<>> map_;\n int64_t version_ = 0;\n};\n\n} // namespace hf3fs::kv::mem\n"], ["/3FS/src/common/monitor/Recorder.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"DigestBuilder.h\"\n#include \"common/monitor/Sample.h\"\n#include \"common/utils/Address.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/RobinHood.h\"\n#include \"common/utils/Size.h\"\n#include \"common/utils/UtcTime.h\"\n\nnamespace hf3fs::monitor {\n\nclass MonitorInstance;\nclass Collector;\n\nclass Recorder {\n public:\n Recorder(std::string_view name, std::optional tag, MonitorInstance &monitor)\n : register_(false),\n monitor_(monitor) {\n if (tag.has_value()) {\n name_ = name;\n tag_ = tag.value();\n } else {\n name_ = name;\n }\n }\n virtual ~Recorder();\n\n const std::string &name() { return name_; }\n\n virtual void collectAndClean(std::vector &samples, bool cleanInactive);\n\n virtual void collect(std::vector &samples) = 0;\n\n static void setHostname(std::string hostname, std::string podname);\n\n public:\n using ConcurrentMap = folly::ConcurrentHashMap,\n folly::HeterogeneousAccessHash,\n folly::HeterogeneousAccessEqualTo>;\n\n template \n class TagRef : public ConcurrentMap::ConstIterator {\n public:\n TagRef(ConcurrentMap::ConstIterator &&iter)\n : ConcurrentMap::ConstIterator(std::move(iter)) {}\n\n T *operator->() const {\n auto ptr = ConcurrentMap::ConstIterator::operator->()->second.get();\n return static_cast(ptr);\n }\n };\n\n // Expose recorder associated with a tag set\n template \n TagRef getRecorderWithTag(const TagSet &tag);\n\n protected:\n friend class Collector;\n friend bool checkRecorderHasTag(const Recorder &rec, const TagSet &tag);\n\n protected:\n void registerRecorder();\n void unregisterRecorder();\n\n protected:\n std::string name_;\n TagSet tag_;\n bool register_;\n bool logPer30s_ = true;\n UtcTime lastLogTime_;\n bool active_ = true;\n\n ConcurrentMap map_;\n MonitorInstance &monitor_;\n};\n\ntemplate \nclass CountRecorderWithTLSTag final : public Recorder {\n public:\n CountRecorderWithTLSTag(std::string_view name, bool resetWhenCollect)\n : CountRecorderWithTLSTag(name, std::nullopt, resetWhenCollect) {}\n\n CountRecorderWithTLSTag(std::string_view name,\n std::optional tag = std::nullopt,\n bool resetWhenCollect = true);\n CountRecorderWithTLSTag(MonitorInstance &monitor,\n std::string_view name,\n std::optional tag = std::nullopt,\n bool resetWhenCollect = true)\n : CountRecorderWithTLSTag(monitor, name, tag, resetWhenCollect, true) {}\n CountRecorderWithTLSTag(CountRecorderWithTLSTag &parent, const TagSet &tag)\n : CountRecorderWithTLSTag(parent.monitor_, parent.name(), tag, parent.resetWhenCollect_, false) {}\n ~CountRecorderWithTLSTag() final { unregisterRecorder(); }\n\n void collectAndClean(std::vector &samples, bool cleanInactive) final;\n void collect(std::vector &samples) final;\n void addSample(int64_t val) { tls_->addSample(val); }\n void addSample(int64_t val, const TagSet &tag);\n\n TagRef getRecorderWithTag(const TagSet &tag) {\n return Recorder::getRecorderWithTag(tag);\n }\n\n private:\n CountRecorderWithTLSTag(MonitorInstance &monitor,\n std::string_view name,\n std::optional tag,\n bool resetWhenCollect,\n bool needRegister)\n : Recorder(name, tag, monitor),\n resetWhenCollect_(resetWhenCollect) {\n if (needRegister) {\n registerRecorder();\n }\n }\n\n struct TLS {\n TLS(CountRecorderWithTLSTag *parent)\n : parent_(parent) {}\n ~TLS() { parent_->sum_ += exchange(); }\n void addSample(int64_t val) { val_ += val; }\n int64_t exchange() { return val_.exchange(0); }\n int64_t load() { return val_.load(std::memory_order_acquire); }\n\n private:\n CountRecorderWithTLSTag *parent_ = nullptr;\n std::atomic val_{0};\n };\n\n std::atomic sum_{0};\n folly::ThreadLocal tls_{[this] { return new TLS(this); }};\n\n bool resetWhenCollect_;\n int64_t cumulativeVal_ = 0;\n};\n\nstruct SharedThreadLocalTag {};\nstruct AllocatedMemoryCounterTag {};\n\nusing CountRecorder = CountRecorderWithTLSTag;\n\nclass DistributionRecorder : public Recorder {\n public:\n DistributionRecorder(std::string_view name, std::optional tag = std::nullopt);\n DistributionRecorder(MonitorInstance &monitor, std::string_view name, std::optional tag = std::nullopt)\n : DistributionRecorder(monitor, name, tag, true) {}\n DistributionRecorder(DistributionRecorder &parent, const TagSet &tag)\n : DistributionRecorder(parent.monitor_, parent.name(), tag, false) {}\n ~DistributionRecorder() override { unregisterRecorder(); }\n\n void collect(std::vector &samples) override;\n void addSample(double value) { tdigest_.append(value); }\n void addSample(double val, const TagSet &tag);\n virtual void logPer30s(const folly::TDigest &digest);\n\n TagRef getRecorderWithTag(const TagSet &tag) {\n return Recorder::getRecorderWithTag(tag);\n }\n\n protected:\n DistributionRecorder(MonitorInstance &monitor, std::string_view name, std::optional tag, bool needRegister)\n : Recorder(name, tag, monitor) {\n if (needRegister) {\n registerRecorder();\n }\n }\n\n static constexpr size_t kDigestMaxSize = 512;\n static constexpr size_t kDigestBufferSize = 128_KB;\n folly::DigestBuilder tdigest_{kDigestBufferSize, kDigestMaxSize};\n std::vector cumulativeDigests_;\n};\n\nclass LatencyRecorder : public DistributionRecorder {\n public:\n LatencyRecorder(std::string_view name, std::optional tag = std::nullopt);\n LatencyRecorder(LatencyRecorder &parent, const TagSet &tag);\n ~LatencyRecorder() override { unregisterRecorder(); }\n\n void addSample(double value) = delete;\n void addSample(uint64_t val, const TagSet &tag) = delete;\n\n void addSample(std::chrono::nanoseconds duration) { tdigest_.append(duration.count()); }\n void addSample(std::chrono::nanoseconds duration, const TagSet &tag);\n void logPer30s(const folly::TDigest &digest) override;\n\n TagRef getRecorderWithTag(const TagSet &tag) {\n return Recorder::getRecorderWithTag(tag);\n }\n};\n\nclass SimpleDistributionRecorder : public Recorder {\n public:\n SimpleDistributionRecorder(std::string_view name, std::optional tag = std::nullopt);\n SimpleDistributionRecorder(MonitorInstance &monitor, std::string_view name, std::optional tag = std::nullopt)\n : SimpleDistributionRecorder(monitor, name, tag, true) {}\n SimpleDistributionRecorder(SimpleDistributionRecorder &parent, const TagSet &tag)\n : SimpleDistributionRecorder(parent.monitor_, parent.name(), tag, false) {}\n ~SimpleDistributionRecorder() override { unregisterRecorder(); }\n\n void collect(std::vector &samples) override;\n void addSample(int64_t val) { tls_->addSample(val); }\n void addSample(int64_t val, const TagSet &tag);\n\n void addSample(std::chrono::nanoseconds duration) { addSample(duration.count()); }\n void addSample(std::chrono::nanoseconds duration, const TagSet &tag) { addSample(duration.count(), tag); }\n\n TagRef getRecorderWithTag(const TagSet &tag) {\n return Recorder::getRecorderWithTag(tag);\n }\n\n protected:\n SimpleDistributionRecorder(MonitorInstance &monitor,\n std::string_view name,\n std::optional tag,\n bool needRegister)\n : Recorder(name, tag, monitor) {\n if (needRegister) {\n registerRecorder();\n }\n }\n\n struct Tls {\n Tls(SimpleDistributionRecorder *parent)\n : parent_(parent) {}\n\n ~Tls() {\n parent_->sum_.fetch_add(exchangeSum(), std::memory_order_relaxed);\n parent_->count_.fetch_add(exchangeCount(), std::memory_order_relaxed);\n parent_->min_.store(std::min(parent_->min_.load(std::memory_order_relaxed), exchangeMin()),\n std::memory_order_relaxed);\n parent_->max_.store(std::max(parent_->max_.load(std::memory_order_relaxed), exchangeMax()),\n std::memory_order_relaxed);\n }\n\n void addSample(int64_t val) {\n sum_.fetch_add(val, std::memory_order_relaxed);\n count_.fetch_add(1, std::memory_order_relaxed);\n min_.store(std::min(min_.load(std::memory_order_relaxed), val), std::memory_order_relaxed);\n max_.store(std::max(max_.load(std::memory_order_relaxed), val), std::memory_order_relaxed);\n }\n\n int64_t exchangeSum() { return sum_.exchange(0); }\n int64_t exchangeCount() { return count_.exchange(0); }\n int64_t exchangeMin() { return min_.exchange(std::numeric_limits::max()); }\n int64_t exchangeMax() { return max_.exchange(0); }\n\n private:\n SimpleDistributionRecorder *parent_ = nullptr;\n std::atomic sum_{0};\n std::atomic count_{0};\n std::atomic min_{std::numeric_limits::max()};\n std::atomic max_{0};\n };\n\n struct TlsTag {};\n\n std::atomic sum_{0};\n std::atomic count_{0};\n std::atomic min_{std::numeric_limits::max()};\n std::atomic max_{0};\n folly::ThreadLocal tls_{[this] { return new Tls(this); }};\n};\n\ntemplate \nclass OperationRecorderT {\n public:\n OperationRecorderT(std::string_view name, std::optional tag = std::nullopt, bool recordErrorCode = false);\n\n struct Guard {\n explicit Guard(OperationRecorderT &recorder)\n : recorder_(recorder) {}\n Guard(OperationRecorderT &recorder, const TagSet &tags)\n : recorder_(recorder),\n tags_(tags) {}\n ~Guard() { report(false); }\n\n void reportWithCode(status_code_t code);\n void report(bool success) {\n if (success) {\n reportWithCode(StatusCode::kOK);\n } else {\n reportWithCode(StatusCode::kUnknown);\n }\n }\n void succ() { success_ = true; }\n std::optional latency() const { return latency_; }\n Duration ellipse() const { return RelativeTime::now() - startTime_; }\n void dismiss() {\n if (!std::exchange(reported_, true)) {\n if (tags_.has_value()) {\n recorder_.current_.addSample(-1, *tags_);\n } else {\n recorder_.current_.addSample(-1);\n }\n }\n }\n RelativeTime startTime() const { return startTime_; }\n\n private:\n OperationRecorderT &recorder_;\n RelativeTime startTime_ = RelativeTime::now();\n std::optional tags_;\n bool success_ = false;\n bool reported_ = false;\n std::optional latency_;\n };\n\n [[nodiscard]] Guard record() {\n total_.addSample(1);\n current_.addSample(1);\n return Guard(*this);\n }\n [[nodiscard]] Guard record(const TagSet &tag) {\n total_.addSample(1, tag);\n current_.addSample(1, tag);\n return Guard(*this, tag);\n }\n\n private:\n CountRecorder total_;\n CountRecorder fails_;\n CountRecorder current_;\n LatencyRecorderT succ_latencies_;\n LatencyRecorderT fail_latencies_;\n bool recordErrorCode_;\n};\n\nusing OperationRecorder = OperationRecorderT;\nusing SimpleOperationRecorder = OperationRecorderT;\n\nclass ValueRecorder : public Recorder {\n public:\n ValueRecorder(std::string_view name, std::optional tag = std::nullopt, bool resetWhenCollect = true);\n ValueRecorder(MonitorInstance &monitor,\n std::string_view name,\n std::optional tag = std::nullopt,\n bool resetWhenCollect = true)\n : ValueRecorder(monitor, name, tag, true, resetWhenCollect) {}\n ValueRecorder(ValueRecorder &parent, const TagSet &tag)\n : ValueRecorder(parent.monitor_, parent.name(), tag, false, parent.resetWhenCollect_) {}\n ~ValueRecorder() override { unregisterRecorder(); }\n\n void collectAndClean(std::vector &samples, bool cleanInactive) override;\n void collect(std::vector &samples) override;\n void set(int64_t val) { val_.store(val, std::memory_order_release); }\n void set(int64_t val, const TagSet &tag);\n auto value() { return val_.load(); }\n\n TagRef getRecorderWithTag(const TagSet &tag) { return Recorder::getRecorderWithTag(tag); }\n\n private:\n ValueRecorder(MonitorInstance &monitor,\n std::string_view name,\n std::optional tag,\n bool needRegister,\n bool resetWhenCollect)\n : Recorder(name, tag, monitor),\n resetWhenCollect_(resetWhenCollect) {\n if (needRegister) {\n registerRecorder();\n }\n }\n\n std::atomic val_{0};\n bool resetWhenCollect_;\n};\n\nclass LambdaRecorder : public Recorder {\n public:\n LambdaRecorder(std::string_view name, std::optional tag = std::nullopt);\n ~LambdaRecorder() override {\n unregisterRecorder();\n reset();\n }\n\n void setLambda(auto &&f) {\n auto lock = std::unique_lock(mutex_);\n getter_ = std::forward(f);\n }\n\n void reset() {\n auto lock = std::unique_lock(mutex_);\n getter_ = [] { return 0; };\n }\n\n void collect(std::vector &samples) override;\n\n private:\n std::mutex mutex_;\n std::function getter_ = [] { return 0; };\n};\n\n} // namespace hf3fs::monitor\n"], ["/3FS/src/lib/common/PerProcTable.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"common/utils/Result.h\"\n#include \"common/utils/RobinHood.h\"\n\nnamespace hf3fs::lib {\ntemplate \nclass PerProcTable {\n public:\n using Item = T;\n using ItemPtr = std::shared_ptr;\n\n PerProcTable() = delete;\n PerProcTable(int p, int pp, size_t cap)\n : pid_(p),\n ppid_(pp),\n table_(cap) {\n free_.reserve(cap);\n }\n PerProcTable(const PerProcTable &rhs, int p, int pp, size_t cap)\n : pid_(p),\n ppid_(pp) {\n if (ppid_ == rhs.pid_) {\n {\n std::shared_lock lock(rhs.mtx_);\n std::vector t(std::max(rhs.table_.size(), cap));\n nextAvail_ = rhs.nextAvail_;\n for (int i = 0; i < nextAvail_; ++i) {\n t[i] = rhs.table_[i].load();\n }\n swap(t, table_);\n free_ = rhs.free_;\n }\n if (table_.size() < cap) { // we don't shrink the table or items may drop out\n free_.reserve(cap);\n }\n } else { // rhs is not our parent proc, so do not copy its fd table\n std::vector t(cap);\n swap(t, table_);\n }\n }\n int pid() const { return pid_; }\n int ppid() const { return ppid_; }\n hf3fs::Result at(int idx, bool check = true) {\n if (idx < 0) {\n XLOGF(DBG, \"bad index {}\", idx);\n return makeError(KeyError,\n fmt::format(\"invalid index {} to lookup in table for proc {} parent {}\", idx, pid_, ppid_));\n } else {\n {\n // std::shared_lock lock(mtx_);\n if (table_.size() < (size_t)idx) {\n XLOGF(DBG, \"invalid index {}\", idx);\n return makeError(KeyError, fmt::format(\"invalid index {} in table for proc {} parent {}\", idx, pid_, ppid_));\n } else {\n auto p = table_[idx].load();\n if (check && !p) {\n XLOGF(DBG, \"no item at index {}\", idx);\n return makeError(KeyError,\n fmt::format(\"index {} not found in table for proc {} parent {}\", idx, pid_, ppid_));\n }\n\n return p;\n }\n }\n }\n }\n void setAt(int idx, const ItemPtr &v) {\n std::unique_lock lock(mtx_);\n auto p = table_[idx].load();\n XLOGF(DBG,\n \"before set at idx {} table idx {} next avail {} free size {}\",\n idx,\n (void *)p.get(),\n nextAvail_,\n free_.size());\n if (!p) { // add to specific place\n if (idx >= nextAvail_) {\n for (auto i = nextAvail_; i < idx; ++i) {\n free_.push_back(i);\n }\n std::ranges::make_heap(free_, std::greater());\n nextAvail_ = idx + 1;\n } else {\n if (free_.size() == 1) {\n assert(free_[0] == idx);\n free_.clear();\n } else {\n *std::ranges::find(free_, idx) = free_.back();\n free_.pop_back();\n std::ranges::make_heap(free_, std::greater());\n }\n }\n }\n table_[idx] = v;\n }\n hf3fs::Result add(const ItemPtr &v) {\n std::unique_lock lock(mtx_);\n auto useFree = !free_.empty();\n if (!useFree && (size_t)nextAvail_ >= table_.size()) {\n return makeError(OverflowError,\n fmt::format(\"no free slot in table for proc {} parent {} table size {} next avail {}\",\n pid_,\n ppid_,\n table_.size(),\n nextAvail_));\n }\n auto idx = useFree ? free_.front() : nextAvail_++;\n if (useFree) {\n std::ranges::pop_heap(free_, std::greater());\n free_.pop_back();\n }\n auto p = table_[idx].load();\n\n XLOGF(DBG,\n \"idx {} use free {} next avail {} free size {} table idx {}\",\n idx,\n useFree,\n nextAvail_,\n free_.size(),\n (void *)p.get());\n assert(!p);\n table_[idx] = v;\n return idx;\n }\n void resetAt(int idx) {\n std::unique_lock lock(mtx_);\n table_[idx] = ItemPtr{};\n free_.push_back(idx);\n std::ranges::push_heap(free_, std::greater());\n XLOGF(DBG, \"reset idx {} next avail {} free size {} first free {}\", idx, nextAvail_, free_.size(), free_.front());\n }\n size_t size() const {\n std::shared_lock lock(mtx_);\n return (size_t)nextAvail_ - free_.size();\n }\n std::vector allUsed() const {\n std::vector used;\n used.reserve(table_.size());\n\n std::shared_lock lock(mtx_);\n for (int i = 1; i < (int)table_.size(); ++i) {\n if (table_[i].load()) {\n used.push_back(i);\n }\n }\n\n return used;\n }\n std::unique_lock lock() const { return std::unique_lock(mtx_); }\n\n private:\n int pid_;\n int ppid_;\n mutable std::shared_mutex mtx_;\n using AtomicItemPtr = folly::atomic_shared_ptr;\n std::vector table_;\n int nextAvail_ = 0;\n std::vector free_;\n};\n\ntemplate \nclass AllProcMap {\n public:\n using Table = PerProcTable;\n using TablePtr = std::shared_ptr;\n using ItemPtr = typename Table::ItemPtr;\n\n TablePtr procTable(int pid, int ppid, size_t cap) {\n TablePtr parentTable;\n {\n std::shared_lock lock(mtx_);\n auto it = map_.find(pid);\n if (it != map_.end()) {\n if (ppid == it->second->ppid()) {\n return it->second;\n } // else, same pid but diff proc, old proc must have died\n } else {\n auto it = map_.find(ppid);\n if (it != map_.end()) {\n parentTable = it->second;\n }\n }\n }\n\n TablePtr newTable;\n if (parentTable) {\n newTable = std::make_shared
(*parentTable, pid, ppid, cap);\n } else {\n newTable = std::make_shared
(pid, ppid, cap);\n }\n\n std::unique_lock lock(mtx_);\n return map_[pid] = std::move(newTable);\n }\n\n void removeProc(int pid) {\n std::unique_lock lock(mtx_);\n map_.erase(pid);\n }\n\n std::vector> allProcs() const {\n std::vector> procs;\n std::shared_lock lock(mtx_);\n procs.reserve(map_.size());\n for (auto &&p : map_) {\n if (p.first != 0) {\n procs.emplace_back(std::make_pair(p.first, p.second->ppid()));\n }\n }\n\n return procs;\n }\n\n private:\n mutable std::shared_mutex mtx_;\n robin_hood::unordered_map map_;\n};\n} // namespace hf3fs::lib\n"], ["/3FS/src/common/utils/CoroutinesPool.h", "#pragma once\n\n#include \n#include \n#include \n#include \n\n#include \"common/utils/BoundedQueue.h\"\n#include \"common/utils/CPUExecutorGroup.h\"\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/Coroutine.h\"\n\nnamespace hf3fs {\n\nstruct CoroutinesPoolBase {\n class Config : public ConfigBase {\n CONFIG_ITEM(coroutines_num, 64u);\n CONFIG_ITEM(queue_size, 1024u);\n CONFIG_ITEM(enable_work_stealing, false);\n\n public:\n Config() = default;\n Config(uint32_t coroutinesNum, uint32_t queueSize, bool enableWorkStealing = false) {\n set_coroutines_num(coroutinesNum);\n set_queue_size(queueSize);\n set_enable_work_stealing(enableWorkStealing);\n }\n };\n};\n\ntemplate \nclass CoroutinesPool : public CoroutinesPoolBase {\n public:\n CoroutinesPool(const Config &config, std::optional> executor = std::nullopt)\n : config_(config),\n executor_(std::move(executor)) {\n if (config_.enable_work_stealing()) {\n auto coroutinesNum = config_.coroutines_num();\n auto queueSizePerCoroutine = (config_.queue_size() + coroutinesNum - 1) / coroutinesNum;\n for (auto i = 0u; i < coroutinesNum; ++i) {\n funcQueues_.push_back(std::make_unique(queueSizePerCoroutine));\n }\n } else {\n funcQueues_.push_back(std::make_unique(config_.queue_size()));\n }\n }\n ~CoroutinesPool() { stopAndJoin(); }\n\n using Handler = std::function(Job job)>;\n Result start(Handler handler) {\n if (UNLIKELY(!executor_.has_value())) {\n auto msg = fmt::format(\"CoroutinesPool@{} does not have an executor\", fmt::ptr(this));\n XLOG(ERR, msg);\n return makeError(StatusCode::kInvalidConfig, std::move(msg));\n }\n auto coroutinesNum = config_.coroutines_num();\n for (auto i = 0u; i < coroutinesNum; ++i) {\n futures_.push_back(run(handler, i).scheduleOn(*executor_).start());\n }\n return Void{};\n }\n\n Result start(Handler handler, CPUExecutorGroup &executor) {\n auto coroutinesNum = config_.coroutines_num();\n for (auto i = 0u; i < coroutinesNum; ++i) {\n futures_.push_back(run(handler, i).scheduleOn(&executor.pickNext()).start());\n }\n return Void{};\n }\n\n void stopAndJoin() {\n if (stopped_.test_and_set()) {\n XLOGF(DBG, \"coroutines pool {} is already stopped.\", fmt::ptr(this));\n return;\n }\n cancel_.requestCancellation();\n for (auto &future : futures_) {\n future.wait();\n }\n futures_.clear();\n if (executor_.has_value()) {\n executor_->reset();\n }\n XLOGF(INFO, \"coroutines pool {} is stopped\", fmt::ptr(this));\n }\n\n void enqueueSync(Job job) { pickQueue().enqueue(std::move(job)); }\n CoTask enqueue(Job job) { co_await pickQueue().co_enqueue(std::move(job)); }\n\n protected:\n using Queue = BoundedQueue;\n using QueuePtr = std::unique_ptr;\n\n Queue &pickQueue() {\n auto n = folly::Random::rand32(0, funcQueues_.size());\n return *funcQueues_[n];\n }\n\n struct WorkStealingJobTaker {\n WorkStealingJobTaker(bool enableWorkStealing,\n size_t selfIndex,\n size_t totalRunners,\n const std::vector &qs)\n : self(enableWorkStealing ? selfIndex : 0),\n queues(qs) {\n if (enableWorkStealing) {\n for (size_t i = 0; i < totalRunners; ++i) {\n if (i != selfIndex) {\n others.push_back(i);\n }\n }\n std::shuffle(others.begin(), others.end(), folly::ThreadLocalPRNG{});\n }\n }\n\n CoTask take() {\n if (others.empty()) {\n co_return co_await queues[self]->co_dequeue();\n }\n\n while (true) {\n if (auto maybeJob = co_await timedWait(*queues[self]); maybeJob) {\n co_return std::move(*maybeJob);\n }\n\n auto otherIndex = others[nextIndex++ % others.size()];\n if (auto maybeJob = queues[otherIndex]->try_dequeue(); maybeJob) {\n co_return std::move(*maybeJob);\n }\n }\n __builtin_unreachable();\n }\n\n CoTask> timedWait(Queue &queue) {\n static constexpr auto timeout = std::chrono::milliseconds(5);\n auto [sleepResult, dequeueResult] =\n co_await folly::coro::collectAnyNoDiscard(folly::coro::sleep(timeout), queue.co_dequeue());\n if (!dequeueResult.hasValue() && !dequeueResult.hasException()) {\n co_return std::nullopt;\n }\n co_return std::move(*dequeueResult);\n }\n\n size_t self;\n size_t nextIndex = 0;\n std::vector others;\n const std::vector &queues;\n };\n\n CoTask run(Handler handler, size_t queueIndex) {\n WorkStealingJobTaker taker(config_.enable_work_stealing(), queueIndex, config_.coroutines_num(), funcQueues_);\n while (true) {\n auto result = co_await co_awaitTry(co_withCancellation(cancel_.getToken(), taker.take()));\n if (UNLIKELY(result.template hasException())) {\n XLOGF(DBG, \"a coroutine in pool {} is stopped\", fmt::ptr(this));\n break;\n } else if (result.hasException()) {\n XLOGF(ERR, \"a coroutine in pool {} is stopped (exception: {})\", fmt::ptr(this), result.exception().what());\n break;\n }\n co_await handler(std::move(*result));\n }\n }\n\n private:\n const Config &config_;\n std::optional> executor_;\n std::vector funcQueues_;\n\n CancellationSource cancel_;\n std::vector> futures_;\n std::atomic_flag stopped_{false};\n};\n\n} // namespace hf3fs\n"], ["/3FS/src/common/utils/ArgParse.h", "/*\n __ _ _ __ __ _ _ __ __ _ _ __ ___ ___\n / _` | '__/ _` | '_ \\ / _` | '__/ __|/ _ \\ Argument Parser for Modern C++\n| (_| | | | (_| | |_) | (_| | | \\__ \\ __/ http://github.com/p-ranav/argparse\n \\__,_|_| \\__, | .__/ \\__,_|_| |___/\\___|\n |___/|_|\n\nLicensed under the MIT License .\nSPDX-License-Identifier: MIT\nCopyright (c) 2019-2022 Pranav Srinivas Kumar \nand other contributors.\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in all\ncopies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\nSOFTWARE.\n*/\n#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace argparse {\n\nnamespace details { // namespace for helper methods\n\ntemplate \nstruct HasContainerTraits : std::false_type {};\n\ntemplate <>\nstruct HasContainerTraits : std::false_type {};\n\ntemplate <>\nstruct HasContainerTraits : std::false_type {};\n\ntemplate \nstruct HasContainerTraits().begin()),\n decltype(std::declval().end()),\n decltype(std::declval().size())>> : std::true_type {};\n\ntemplate \nstatic constexpr bool IsContainer = HasContainerTraits::value;\n\ntemplate \nstruct HasStreamableTraits : std::false_type {};\n\ntemplate \nstruct HasStreamableTraits() << std::declval())>>\n : std::true_type {};\n\ntemplate \nstatic constexpr bool IsStreamable = HasStreamableTraits::value;\n\nconstexpr std::size_t repr_max_container_size = 5;\n\ntemplate \nstd::string repr(T const &val) {\n if constexpr (std::is_same_v) {\n return val ? \"true\" : \"false\";\n } else if constexpr (std::is_convertible_v) {\n return '\"' + std::string{std::string_view{val}} + '\"';\n } else if constexpr (IsContainer) {\n std::stringstream out;\n out << \"{\";\n const auto size = val.size();\n if (size > 1) {\n out << repr(*val.begin());\n std::for_each(std::next(val.begin()),\n std::next(val.begin(),\n static_cast(\n std::min(size, repr_max_container_size) - 1)),\n [&out](const auto &v) { out << \" \" << repr(v); });\n if (size <= repr_max_container_size) {\n out << \" \";\n } else {\n out << \"...\";\n }\n }\n if (size > 0) {\n out << repr(*std::prev(val.end()));\n }\n out << \"}\";\n return out.str();\n } else if constexpr (IsStreamable) {\n std::stringstream out;\n out << val;\n return out.str();\n } else {\n return \"\";\n }\n}\n\nnamespace {\n\ntemplate \nconstexpr bool standard_signed_integer = false;\ntemplate <>\nconstexpr bool standard_signed_integer = true;\ntemplate <>\nconstexpr bool standard_signed_integer = true;\ntemplate <>\nconstexpr bool standard_signed_integer = true;\ntemplate <>\nconstexpr bool standard_signed_integer = true;\ntemplate <>\nconstexpr bool standard_signed_integer = true;\n\ntemplate \nconstexpr bool standard_unsigned_integer = false;\ntemplate <>\nconstexpr bool standard_unsigned_integer = true;\ntemplate <>\nconstexpr bool standard_unsigned_integer = true;\ntemplate <>\nconstexpr bool standard_unsigned_integer = true;\ntemplate <>\nconstexpr bool standard_unsigned_integer = true;\ntemplate <>\nconstexpr bool standard_unsigned_integer = true;\n\n} // namespace\n\nconstexpr int radix_8 = 8;\nconstexpr int radix_10 = 10;\nconstexpr int radix_16 = 16;\n\ntemplate \nconstexpr bool standard_integer = standard_signed_integer || standard_unsigned_integer;\n\ntemplate \nconstexpr decltype(auto) apply_plus_one_impl(F &&f, Tuple &&t, Extra &&x, std::index_sequence /*unused*/) {\n return std::invoke(std::forward(f), std::get(std::forward(t))..., std::forward(x));\n}\n\ntemplate \nconstexpr decltype(auto) apply_plus_one(F &&f, Tuple &&t, Extra &&x) {\n return details::apply_plus_one_impl(std::forward(f),\n std::forward(t),\n std::forward(x),\n std::make_index_sequence>>{});\n}\n\nconstexpr auto pointer_range(std::string_view s) noexcept { return std::tuple(s.data(), s.data() + s.size()); }\n\ntemplate \nconstexpr bool starts_with(std::basic_string_view prefix,\n std::basic_string_view s) noexcept {\n return s.substr(0, prefix.size()) == prefix;\n}\n\nenum class chars_format { scientific = 0x1, fixed = 0x2, hex = 0x4, general = fixed | scientific };\n\nstruct ConsumeHexPrefixResult {\n bool is_hexadecimal;\n std::string_view rest;\n};\n\nusing namespace std::literals;\n\nconstexpr auto consume_hex_prefix(std::string_view s) -> ConsumeHexPrefixResult {\n if (starts_with(\"0x\"sv, s) || starts_with(\"0X\"sv, s)) {\n s.remove_prefix(2);\n return {true, s};\n }\n return {false, s};\n}\n\ntemplate \ninline auto do_from_chars(std::string_view s) -> T {\n T x;\n auto [first, last] = pointer_range(s);\n auto [ptr, ec] = std::from_chars(first, last, x, Param);\n if (ec == std::errc()) {\n if (ptr == last) {\n return x;\n }\n throw std::invalid_argument{\"pattern does not match to the end\"};\n }\n if (ec == std::errc::invalid_argument) {\n throw std::invalid_argument{\"pattern not found\"};\n }\n if (ec == std::errc::result_out_of_range) {\n throw std::range_error{\"not representable\"};\n }\n return x; // unreachable\n}\n\ntemplate \nstruct parse_number {\n auto operator()(std::string_view s) -> T { return do_from_chars(s); }\n};\n\ntemplate \nstruct parse_number {\n auto operator()(std::string_view s) -> T {\n if (auto [ok, rest] = consume_hex_prefix(s); ok) {\n return do_from_chars(rest);\n }\n throw std::invalid_argument{\"pattern not found\"};\n }\n};\n\ntemplate \nstruct parse_number {\n auto operator()(std::string_view s) -> T {\n auto [ok, rest] = consume_hex_prefix(s);\n if (ok) {\n return do_from_chars(rest);\n }\n if (starts_with(\"0\"sv, s)) {\n return do_from_chars(rest);\n }\n return do_from_chars(rest);\n }\n};\n\nnamespace {\n\ntemplate \ninline const auto generic_strtod = nullptr;\ntemplate <>\ninline const auto generic_strtod = strtof;\ntemplate <>\ninline const auto generic_strtod = strtod;\ntemplate <>\ninline const auto generic_strtod = strtold;\n\n} // namespace\n\ntemplate \ninline auto do_strtod(std::string const &s) -> T {\n if (isspace(static_cast(s[0])) || s[0] == '+') {\n throw std::invalid_argument{\"pattern not found\"};\n }\n\n auto [first, last] = pointer_range(s);\n char *ptr;\n\n errno = 0;\n auto x = generic_strtod(first, &ptr);\n if (errno == 0) {\n if (ptr == last) {\n return x;\n }\n throw std::invalid_argument{\"pattern does not match to the end\"};\n }\n if (errno == ERANGE) {\n throw std::range_error{\"not representable\"};\n }\n return x; // unreachable\n}\n\ntemplate \nstruct parse_number {\n auto operator()(std::string const &s) -> T {\n if (auto r = consume_hex_prefix(s); r.is_hexadecimal) {\n throw std::invalid_argument{\"chars_format::general does not parse hexfloat\"};\n }\n\n return do_strtod(s);\n }\n};\n\ntemplate \nstruct parse_number {\n auto operator()(std::string const &s) -> T {\n if (auto r = consume_hex_prefix(s); !r.is_hexadecimal) {\n throw std::invalid_argument{\"chars_format::hex parses hexfloat\"};\n }\n\n return do_strtod(s);\n }\n};\n\ntemplate \nstruct parse_number {\n auto operator()(std::string const &s) -> T {\n if (auto r = consume_hex_prefix(s); r.is_hexadecimal) {\n throw std::invalid_argument{\"chars_format::scientific does not parse hexfloat\"};\n }\n if (s.find_first_of(\"eE\") == std::string::npos) {\n throw std::invalid_argument{\"chars_format::scientific requires exponent part\"};\n }\n\n return do_strtod(s);\n }\n};\n\ntemplate \nstruct parse_number {\n auto operator()(std::string const &s) -> T {\n if (auto r = consume_hex_prefix(s); r.is_hexadecimal) {\n throw std::invalid_argument{\"chars_format::fixed does not parse hexfloat\"};\n }\n if (s.find_first_of(\"eE\") != std::string::npos) {\n throw std::invalid_argument{\"chars_format::fixed does not parse exponent part\"};\n }\n\n return do_strtod(s);\n }\n};\n\ntemplate \nstd::string join(StrIt first, StrIt last, const std::string &separator) {\n if (first == last) {\n return \"\";\n }\n std::stringstream value;\n value << *first;\n ++first;\n while (first != last) {\n value << separator << *first;\n ++first;\n }\n return value.str();\n}\n\n} // namespace details\n\nenum class nargs_pattern { optional, any, at_least_one };\n\nenum class default_arguments : unsigned int {\n none = 0,\n help = 1,\n version = 2,\n all = help | version,\n};\n\ninline default_arguments operator&(const default_arguments &a, const default_arguments &b) {\n return static_cast(static_cast::type>(a) &\n static_cast::type>(b));\n}\n\nclass ArgumentParser;\n\nclass Argument {\n friend class ArgumentParser;\n friend auto operator<<(std::ostream &stream, const ArgumentParser &parser) -> std::ostream &;\n\n template \n explicit Argument(std::string_view prefix_chars,\n std::array &&a,\n std::index_sequence /*unused*/)\n : m_is_optional((is_optional(a[I], prefix_chars) || ...)),\n m_is_required(false),\n m_is_repeatable(false),\n m_is_used(false),\n m_prefix_chars(prefix_chars) {\n ((void)m_names.emplace_back(a[I]), ...);\n std::sort(m_names.begin(), m_names.end(), [](const auto &lhs, const auto &rhs) {\n return lhs.size() == rhs.size() ? lhs < rhs : lhs.size() < rhs.size();\n });\n }\n\n public:\n template \n explicit Argument(std::string_view prefix_chars, std::array &&a)\n : Argument(prefix_chars, std::move(a), std::make_index_sequence{}) {}\n\n Argument &help(std::string help_text) {\n m_help = std::move(help_text);\n return *this;\n }\n\n Argument &metavar(std::string metavar) {\n m_metavar = std::move(metavar);\n return *this;\n }\n\n template \n Argument &default_value(T &&value) {\n m_default_value_repr = details::repr(value);\n m_default_value = std::forward(value);\n return *this;\n }\n\n Argument &required() {\n m_is_required = true;\n return *this;\n }\n\n Argument &implicit_value(std::any value) {\n m_implicit_value = std::move(value);\n m_num_args_range = NArgsRange{0, 0};\n return *this;\n }\n\n template \n auto action(F &&callable, Args &&...bound_args)\n -> std::enable_if_t, Argument &> {\n using action_type = std::\n conditional_t>, void_action, valued_action>;\n if constexpr (sizeof...(Args) == 0) {\n m_action.emplace(std::forward(callable));\n } else {\n m_action.emplace(\n [f = std::forward(callable), tup = std::make_tuple(std::forward(bound_args)...)](\n std::string const &opt) mutable { return details::apply_plus_one(f, tup, opt); });\n }\n return *this;\n }\n\n auto &append() {\n m_is_repeatable = true;\n return *this;\n }\n\n template \n auto scan() -> std::enable_if_t, Argument &> {\n static_assert(!(std::is_const_v || std::is_volatile_v), \"T should not be cv-qualified\");\n auto is_one_of = [](char c, auto... x) constexpr { return ((c == x) || ...); };\n\n if constexpr (is_one_of(Shape, 'd') && details::standard_integer) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'i') && details::standard_integer) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'u') && details::standard_unsigned_integer) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'o') && details::standard_unsigned_integer) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'x', 'X') && details::standard_unsigned_integer) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'a', 'A') && std::is_floating_point_v) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'e', 'E') && std::is_floating_point_v) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'f', 'F') && std::is_floating_point_v) {\n action(details::parse_number());\n } else if constexpr (is_one_of(Shape, 'g', 'G') && std::is_floating_point_v) {\n action(details::parse_number());\n } else {\n static_assert(alignof(T) == 0, \"No scan specification for T\");\n }\n\n return *this;\n }\n\n Argument &nargs(std::size_t num_args) {\n m_num_args_range = NArgsRange{num_args, num_args};\n return *this;\n }\n\n Argument &nargs(std::size_t num_args_min, std::size_t num_args_max) {\n m_num_args_range = NArgsRange{num_args_min, num_args_max};\n return *this;\n }\n\n Argument &nargs(nargs_pattern pattern) {\n switch (pattern) {\n case nargs_pattern::optional:\n m_num_args_range = NArgsRange{0, 1};\n break;\n case nargs_pattern::any:\n m_num_args_range = NArgsRange{0, std::numeric_limits::max()};\n break;\n case nargs_pattern::at_least_one:\n m_num_args_range = NArgsRange{1, std::numeric_limits::max()};\n break;\n }\n return *this;\n }\n\n Argument &remaining() {\n m_accepts_optional_like_value = true;\n return nargs(nargs_pattern::any);\n }\n\n template \n Iterator consume(Iterator start, Iterator end, std::string_view used_name = {}) {\n if (!m_is_repeatable && m_is_used) {\n throw std::runtime_error(\"Duplicate argument\");\n }\n m_is_used = true;\n m_used_name = used_name;\n\n const auto num_args_max = m_num_args_range.get_max();\n const auto num_args_min = m_num_args_range.get_min();\n std::size_t dist = 0;\n if (num_args_max == 0) {\n m_values.emplace_back(m_implicit_value);\n std::visit([](const auto &f) { f({}); }, m_action);\n return start;\n }\n if ((dist = static_cast(std::distance(start, end))) >= num_args_min) {\n if (num_args_max < dist) {\n end = std::next(start, static_cast(num_args_max));\n }\n if (!m_accepts_optional_like_value) {\n end = std::find_if(start, end, std::bind(is_optional, std::placeholders::_1, m_prefix_chars));\n dist = static_cast(std::distance(start, end));\n if (dist < num_args_min) {\n throw std::runtime_error(\"Too few arguments\");\n }\n }\n\n struct ActionApply {\n void operator()(valued_action &f) { std::transform(first, last, std::back_inserter(self.m_values), f); }\n\n void operator()(void_action &f) {\n std::for_each(first, last, f);\n if (!self.m_default_value.has_value()) {\n if (!self.m_accepts_optional_like_value) {\n self.m_values.resize(static_cast(std::distance(first, last)));\n }\n }\n }\n\n Iterator first, last;\n Argument &self;\n };\n std::visit(ActionApply{start, end, *this}, m_action);\n return end;\n }\n if (m_default_value.has_value()) {\n return start;\n }\n throw std::runtime_error(\"Too few arguments for '\" + std::string(m_used_name) + \"'.\");\n }\n\n /*\n * @throws std::runtime_error if argument values are not valid\n */\n void validate() const {\n if (m_is_optional) {\n // TODO: check if an implicit value was programmed for this argument\n if (!m_is_used && !m_default_value.has_value() && m_is_required) {\n throw_required_arg_not_used_error();\n }\n if (m_is_used && m_is_required && m_values.empty()) {\n throw_required_arg_no_value_provided_error();\n }\n } else {\n if (!m_num_args_range.contains(m_values.size()) && !m_default_value.has_value()) {\n throw_nargs_range_validation_error();\n }\n }\n }\n\n std::string get_inline_usage() const {\n std::stringstream usage;\n // Find the longest variant to show in the usage string\n std::string longest_name = m_names.front();\n for (const auto &s : m_names) {\n if (s.size() > longest_name.size()) {\n longest_name = s;\n }\n }\n if (!m_is_required) {\n usage << \"[\";\n }\n usage << longest_name;\n const std::string metavar = !m_metavar.empty() ? m_metavar : \"VAR\";\n if (m_num_args_range.get_max() > 0) {\n usage << \" \" << metavar;\n if (m_num_args_range.get_max() > 1) {\n usage << \"...\";\n }\n }\n if (!m_is_required) {\n usage << \"]\";\n }\n return usage.str();\n }\n\n std::size_t get_arguments_length() const {\n std::size_t names_size =\n std::accumulate(std::begin(m_names), std::end(m_names), std::size_t(0), [](const auto &sum, const auto &s) {\n return sum + s.size();\n });\n\n if (is_positional(m_names.front(), m_prefix_chars)) {\n // A set metavar means this replaces the names\n if (!m_metavar.empty()) {\n // Indent and metavar\n return 2 + m_metavar.size();\n }\n\n // Indent and space-separated\n return 2 + names_size + (m_names.size() - 1);\n }\n // Is an option - include both names _and_ metavar\n // size = text + (\", \" between names)\n std::size_t size = names_size + 2 * (m_names.size() - 1);\n if (!m_metavar.empty() && m_num_args_range == NArgsRange{1, 1}) {\n size += m_metavar.size() + 1;\n }\n return size + 2; // indent\n }\n\n friend std::ostream &operator<<(std::ostream &stream, const Argument &argument) {\n std::stringstream name_stream;\n name_stream << \" \"; // indent\n if (argument.is_positional(argument.m_names.front(), argument.m_prefix_chars)) {\n if (!argument.m_metavar.empty()) {\n name_stream << argument.m_metavar;\n } else {\n name_stream << details::join(argument.m_names.begin(), argument.m_names.end(), \" \");\n }\n } else {\n name_stream << details::join(argument.m_names.begin(), argument.m_names.end(), \", \");\n // If we have a metavar, and one narg - print the metavar\n if (!argument.m_metavar.empty() && argument.m_num_args_range == NArgsRange{1, 1}) {\n name_stream << \" \" << argument.m_metavar;\n }\n }\n stream << name_stream.str() << \"\\t\" << argument.m_help;\n\n // print nargs spec\n if (!argument.m_help.empty()) {\n stream << \" \";\n }\n stream << argument.m_num_args_range;\n\n if (argument.m_default_value.has_value() && argument.m_num_args_range != NArgsRange{0, 0}) {\n stream << \"[default: \" << argument.m_default_value_repr << \"]\";\n } else if (argument.m_is_required) {\n stream << \"[required]\";\n }\n stream << \"\\n\";\n return stream;\n }\n\n template \n bool operator!=(const T &rhs) const {\n return !(*this == rhs);\n }\n\n /*\n * Compare to an argument value of known type\n * @throws std::logic_error in case of incompatible types\n */\n template \n bool operator==(const T &rhs) const {\n if constexpr (!details::IsContainer) {\n return get() == rhs;\n } else {\n auto lhs = get();\n return std::equal(std::begin(lhs),\n std::end(lhs),\n std::begin(rhs),\n std::end(rhs),\n [](const auto &a, const auto &b) { return a == b; });\n }\n }\n\n private:\n class NArgsRange {\n std::size_t m_min;\n std::size_t m_max;\n\n public:\n NArgsRange(std::size_t minimum, std::size_t maximum)\n : m_min(minimum),\n m_max(maximum) {\n if (minimum > maximum) {\n throw std::logic_error(\"Range of number of arguments is invalid\");\n }\n }\n\n bool contains(std::size_t value) const { return value >= m_min && value <= m_max; }\n\n bool is_exact() const { return m_min == m_max; }\n\n bool is_right_bounded() const { return m_max < std::numeric_limits::max(); }\n\n std::size_t get_min() const { return m_min; }\n\n std::size_t get_max() const { return m_max; }\n\n // Print help message\n friend auto operator<<(std::ostream &stream, const NArgsRange &range) -> std::ostream & {\n if (range.m_min == range.m_max) {\n if (range.m_min != 0 && range.m_min != 1) {\n stream << \"[nargs: \" << range.m_min << \"] \";\n }\n } else {\n if (range.m_max == std::numeric_limits::max()) {\n stream << \"[nargs: \" << range.m_min << \" or more] \";\n } else {\n stream << \"[nargs=\" << range.m_min << \"..\" << range.m_max << \"] \";\n }\n }\n return stream;\n }\n\n bool operator==(const NArgsRange &rhs) const { return rhs.m_min == m_min && rhs.m_max == m_max; }\n\n bool operator!=(const NArgsRange &rhs) const { return !(*this == rhs); }\n };\n\n void throw_nargs_range_validation_error() const {\n std::stringstream stream;\n if (!m_used_name.empty()) {\n stream << m_used_name << \": \";\n } else {\n stream << m_names.front() << \": \";\n }\n if (m_num_args_range.is_exact()) {\n stream << m_num_args_range.get_min();\n } else if (m_num_args_range.is_right_bounded()) {\n stream << m_num_args_range.get_min() << \" to \" << m_num_args_range.get_max();\n } else {\n stream << m_num_args_range.get_min() << \" or more\";\n }\n stream << \" argument(s) expected. \" << m_values.size() << \" provided.\";\n throw std::runtime_error(stream.str());\n }\n\n void throw_required_arg_not_used_error() const {\n std::stringstream stream;\n stream << m_names.front() << \": required.\";\n throw std::runtime_error(stream.str());\n }\n\n void throw_required_arg_no_value_provided_error() const {\n std::stringstream stream;\n stream << m_used_name << \": no value provided.\";\n throw std::runtime_error(stream.str());\n }\n\n static constexpr int eof = std::char_traits::eof();\n\n static auto lookahead(std::string_view s) -> int {\n if (s.empty()) {\n return eof;\n }\n return static_cast(static_cast(s[0]));\n }\n\n /*\n * decimal-literal:\n * '0'\n * nonzero-digit digit-sequence_opt\n * integer-part fractional-part\n * fractional-part\n * integer-part '.' exponent-part_opt\n * integer-part exponent-part\n *\n * integer-part:\n * digit-sequence\n *\n * fractional-part:\n * '.' post-decimal-point\n *\n * post-decimal-point:\n * digit-sequence exponent-part_opt\n *\n * exponent-part:\n * 'e' post-e\n * 'E' post-e\n *\n * post-e:\n * sign_opt digit-sequence\n *\n * sign: one of\n * '+' '-'\n */\n static bool is_decimal_literal(std::string_view s) {\n auto is_digit = [](auto c) constexpr {\n switch (c) {\n case '0':\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7':\n case '8':\n case '9':\n return true;\n default:\n return false;\n }\n };\n\n // precondition: we have consumed or will consume at least one digit\n auto consume_digits = [=](std::string_view sd) {\n // NOLINTNEXTLINE(readability-qualified-auto)\n auto it = std::find_if_not(std::begin(sd), std::end(sd), is_digit);\n return sd.substr(static_cast(it - std::begin(sd)));\n };\n\n switch (lookahead(s)) {\n case '0': {\n s.remove_prefix(1);\n if (s.empty()) {\n return true;\n }\n goto integer_part;\n }\n case '1':\n case '2':\n case '3':\n case '4':\n case '5':\n case '6':\n case '7':\n case '8':\n case '9': {\n s = consume_digits(s);\n if (s.empty()) {\n return true;\n }\n goto integer_part_consumed;\n }\n case '.': {\n s.remove_prefix(1);\n goto post_decimal_point;\n }\n default:\n return false;\n }\n\n integer_part:\n s = consume_digits(s);\n integer_part_consumed:\n switch (lookahead(s)) {\n case '.': {\n s.remove_prefix(1);\n if (is_digit(lookahead(s))) {\n goto post_decimal_point;\n } else {\n goto exponent_part_opt;\n }\n }\n case 'e':\n case 'E': {\n s.remove_prefix(1);\n goto post_e;\n }\n default:\n return false;\n }\n\n post_decimal_point:\n if (is_digit(lookahead(s))) {\n s = consume_digits(s);\n goto exponent_part_opt;\n }\n return false;\n\n exponent_part_opt:\n switch (lookahead(s)) {\n case eof:\n return true;\n case 'e':\n case 'E': {\n s.remove_prefix(1);\n goto post_e;\n }\n default:\n return false;\n }\n\n post_e:\n switch (lookahead(s)) {\n case '-':\n case '+':\n s.remove_prefix(1);\n }\n if (is_digit(lookahead(s))) {\n s = consume_digits(s);\n return s.empty();\n }\n return false;\n }\n\n static bool is_optional(std::string_view name, std::string_view prefix_chars) {\n return !is_positional(name, prefix_chars);\n }\n\n /*\n * positional:\n * _empty_\n * '-'\n * '-' decimal-literal\n * !'-' anything\n */\n static bool is_positional(std::string_view name, std::string_view prefix_chars) {\n auto first = lookahead(name);\n\n if (first == eof) {\n return true;\n } else if (prefix_chars.find(static_cast(first)) != std::string_view::npos) {\n name.remove_prefix(1);\n if (name.empty()) {\n return true;\n }\n return is_decimal_literal(name);\n }\n return true;\n }\n\n /*\n * Get argument value given a type\n * @throws std::logic_error in case of incompatible types\n */\n template \n auto get() const -> std::conditional_t, T, const T &> {\n if (!m_values.empty()) {\n if constexpr (details::IsContainer) {\n return any_cast_container(m_values);\n } else {\n return *std::any_cast(&m_values.front());\n }\n }\n if (m_default_value.has_value()) {\n return *std::any_cast(&m_default_value);\n }\n if constexpr (details::IsContainer) {\n if (!m_accepts_optional_like_value) {\n return any_cast_container(m_values);\n }\n }\n\n throw std::logic_error(\"No value provided for '\" + m_names.back() + \"'.\");\n }\n\n /*\n * Get argument value given a type.\n * @pre The object has no default value.\n * @returns The stored value if any, std::nullopt otherwise.\n */\n template \n auto present() const -> std::optional {\n if (m_default_value.has_value()) {\n throw std::logic_error(\"Argument with default value always presents\");\n }\n if (m_values.empty()) {\n return std::nullopt;\n }\n if constexpr (details::IsContainer) {\n return any_cast_container(m_values);\n }\n return std::any_cast(m_values.front());\n }\n\n template \n static auto any_cast_container(const std::vector &operand) -> T {\n using ValueType = typename T::value_type;\n\n T result;\n std::transform(std::begin(operand), std::end(operand), std::back_inserter(result), [](const auto &value) {\n return *std::any_cast(&value);\n });\n return result;\n }\n\n std::vector m_names;\n std::string_view m_used_name;\n std::string m_help;\n std::string m_metavar;\n std::any m_default_value;\n std::string m_default_value_repr;\n std::any m_implicit_value;\n using valued_action = std::function;\n using void_action = std::function;\n std::variant m_action{std::in_place_type,\n [](const std::string &value) { return value; }};\n std::vector m_values;\n NArgsRange m_num_args_range{1, 1};\n bool m_accepts_optional_like_value = false;\n bool m_is_optional : true;\n bool m_is_required : true;\n bool m_is_repeatable : true;\n bool m_is_used : true; // True if the optional argument is used by user\n std::string_view m_prefix_chars; // ArgumentParser has the prefix_chars\n};\n\nclass ArgumentParser {\n public:\n explicit ArgumentParser(std::string program_name = {},\n std::string version = \"1.0\",\n default_arguments add_args = default_arguments::none)\n : m_program_name(std::move(program_name)),\n m_version(std::move(version)),\n m_parser_path(m_program_name) {\n if ((add_args & default_arguments::help) == default_arguments::help) {\n add_argument(\"-h\", \"--help\")\n .action([&](const auto & /*unused*/) {\n std::cout << help().str();\n std::exit(0);\n })\n .default_value(false)\n .help(\"shows help message and exits\")\n .implicit_value(true)\n .nargs(0);\n }\n if ((add_args & default_arguments::version) == default_arguments::version) {\n add_argument(\"-v\", \"--version\")\n .action([&](const auto & /*unused*/) {\n std::cout << m_version << std::endl;\n std::exit(0);\n })\n .default_value(false)\n .help(\"prints version information and exits\")\n .implicit_value(true)\n .nargs(0);\n }\n }\n\n ArgumentParser(ArgumentParser &&) noexcept = default;\n ArgumentParser &operator=(ArgumentParser &&) = default;\n\n ArgumentParser(const ArgumentParser &other)\n : m_program_name(other.m_program_name),\n m_version(other.m_version),\n m_description(other.m_description),\n m_epilog(other.m_epilog),\n m_prefix_chars(other.m_prefix_chars),\n m_assign_chars(other.m_assign_chars),\n m_is_parsed(other.m_is_parsed),\n m_positional_arguments(other.m_positional_arguments),\n m_optional_arguments(other.m_optional_arguments),\n m_parser_path(other.m_parser_path),\n m_subparsers(other.m_subparsers) {\n for (auto it = std::begin(m_positional_arguments); it != std::end(m_positional_arguments); ++it) {\n index_argument(it);\n }\n for (auto it = std::begin(m_optional_arguments); it != std::end(m_optional_arguments); ++it) {\n index_argument(it);\n }\n for (auto it = std::begin(m_subparsers); it != std::end(m_subparsers); ++it) {\n m_subparser_map.insert_or_assign(it->get().m_program_name, it);\n m_subparser_used.insert_or_assign(it->get().m_program_name, false);\n }\n }\n\n ~ArgumentParser() = default;\n\n ArgumentParser &operator=(const ArgumentParser &other) {\n auto tmp = other;\n std::swap(*this, tmp);\n return *this;\n }\n\n explicit operator bool() const {\n auto arg_used =\n std::any_of(m_argument_map.cbegin(), m_argument_map.cend(), [](auto &it) { return it.second->m_is_used; });\n auto subparser_used =\n std::any_of(m_subparser_used.cbegin(), m_subparser_used.cend(), [](auto &it) { return it.second; });\n\n return m_is_parsed && (arg_used || subparser_used);\n }\n\n // Parameter packing\n // Call add_argument with variadic number of string arguments\n template \n Argument &add_argument(Targs... f_args) {\n using array_of_sv = std::array;\n auto argument =\n m_optional_arguments.emplace(std::cend(m_optional_arguments), m_prefix_chars, array_of_sv{f_args...});\n\n if (!argument->m_is_optional) {\n m_positional_arguments.splice(std::cend(m_positional_arguments), m_optional_arguments, argument);\n }\n\n index_argument(argument);\n return *argument;\n }\n\n // Parameter packed add_parents method\n // Accepts a variadic number of ArgumentParser objects\n template \n ArgumentParser &add_parents(const Targs &...f_args) {\n for (const ArgumentParser &parent_parser : {std::ref(f_args)...}) {\n for (const auto &argument : parent_parser.m_positional_arguments) {\n auto it = m_positional_arguments.insert(std::cend(m_positional_arguments), argument);\n index_argument(it);\n }\n for (const auto &argument : parent_parser.m_optional_arguments) {\n auto it = m_optional_arguments.insert(std::cend(m_optional_arguments), argument);\n index_argument(it);\n }\n }\n return *this;\n }\n\n ArgumentParser &add_description(std::string description) {\n m_description = std::move(description);\n return *this;\n }\n\n ArgumentParser &add_epilog(std::string epilog) {\n m_epilog = std::move(epilog);\n return *this;\n }\n\n /* Getter for arguments and subparsers.\n * @throws std::logic_error in case of an invalid argument or subparser name\n */\n template \n T &at(std::string_view name) {\n if constexpr (std::is_same_v) {\n return (*this)[name];\n } else {\n auto subparser_it = m_subparser_map.find(name);\n if (subparser_it != m_subparser_map.end()) {\n return subparser_it->second->get();\n }\n throw std::logic_error(\"No such subparser: \" + std::string(name));\n }\n }\n\n ArgumentParser &set_prefix_chars(std::string prefix_chars) {\n m_prefix_chars = std::move(prefix_chars);\n return *this;\n }\n\n ArgumentParser &set_assign_chars(std::string assign_chars) {\n m_assign_chars = std::move(assign_chars);\n return *this;\n }\n\n /* Call parse_args_internal - which does all the work\n * Then, validate the parsed arguments\n * This variant is used mainly for testing\n * @throws std::runtime_error in case of any invalid argument\n */\n void parse_args(const std::vector &arguments) {\n parse_args_internal(arguments);\n // Check if all arguments are parsed\n for ([[maybe_unused]] const auto &[unused, argument] : m_argument_map) {\n argument->validate();\n }\n }\n\n /* Call parse_known_args_internal - which does all the work\n * Then, validate the parsed arguments\n * This variant is used mainly for testing\n * @throws std::runtime_error in case of any invalid argument\n */\n std::vector parse_known_args(const std::vector &arguments) {\n auto unknown_arguments = parse_known_args_internal(arguments);\n // Check if all arguments are parsed\n for ([[maybe_unused]] const auto &[unused, argument] : m_argument_map) {\n argument->validate();\n }\n return unknown_arguments;\n }\n\n /* Main entry point for parsing command-line arguments using this\n * ArgumentParser\n * @throws std::runtime_error in case of any invalid argument\n */\n // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays)\n void parse_args(int argc, const char *const argv[]) { parse_args({argv, argv + argc}); }\n\n /* Main entry point for parsing command-line arguments using this\n * ArgumentParser\n * @throws std::runtime_error in case of any invalid argument\n */\n // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays)\n auto parse_known_args(int argc, const char *const argv[]) { return parse_known_args({argv, argv + argc}); }\n\n /* Getter for options with default values.\n * @throws std::logic_error if parse_args() has not been previously called\n * @throws std::logic_error if there is no such option\n * @throws std::logic_error if the option has no value\n * @throws std::bad_any_cast if the option is not of type T\n */\n template \n auto get(std::string_view arg_name) const -> std::conditional_t, T, const T &> {\n if (!m_is_parsed) {\n throw std::logic_error(\"Nothing parsed, no arguments are available.\");\n }\n return (*this)[arg_name].get();\n }\n\n /* Getter for options without default values.\n * @pre The option has no default value.\n * @throws std::logic_error if there is no such option\n * @throws std::bad_any_cast if the option is not of type T\n */\n template \n auto present(std::string_view arg_name) const -> std::optional {\n return (*this)[arg_name].present();\n }\n\n /* Getter that returns true for user-supplied options. Returns false if not\n * user-supplied, even with a default value.\n */\n auto is_used(std::string_view arg_name) const { return (*this)[arg_name].m_is_used; }\n\n /* Getter that returns true if a subcommand is used.\n */\n auto is_subcommand_used(std::string_view subcommand_name) const { return m_subparser_used.at(subcommand_name); }\n\n /* Getter that returns true if a subcommand is used.\n */\n auto is_subcommand_used(const ArgumentParser &subparser) const {\n return is_subcommand_used(subparser.m_program_name);\n }\n\n /* Indexing operator. Return a reference to an Argument object\n * Used in conjunction with Argument.operator== e.g., parser[\"foo\"] == true\n * @throws std::logic_error in case of an invalid argument name\n */\n Argument &operator[](std::string_view arg_name) const {\n auto it = m_argument_map.find(arg_name);\n if (it != m_argument_map.end()) {\n return *(it->second);\n }\n if (!is_valid_prefix_char(arg_name.front())) {\n std::string name(arg_name);\n const auto legal_prefix_char = get_any_valid_prefix_char();\n const auto prefix = std::string(1, legal_prefix_char);\n\n // \"-\" + arg_name\n name = prefix + name;\n it = m_argument_map.find(name);\n if (it != m_argument_map.end()) {\n return *(it->second);\n }\n // \"--\" + arg_name\n name = prefix + name;\n it = m_argument_map.find(name);\n if (it != m_argument_map.end()) {\n return *(it->second);\n }\n }\n throw std::logic_error(\"No such argument: \" + std::string(arg_name));\n }\n\n // Print help message\n friend auto operator<<(std::ostream &stream, const ArgumentParser &parser) -> std::ostream & {\n stream.setf(std::ios_base::left);\n\n auto longest_arg_length = parser.get_length_of_longest_argument();\n\n stream << parser.usage() << \"\\n\\n\";\n\n if (!parser.m_description.empty()) {\n stream << parser.m_description << \"\\n\\n\";\n }\n\n if (!parser.m_positional_arguments.empty()) {\n stream << \"Positional arguments:\\n\";\n }\n\n for (const auto &argument : parser.m_positional_arguments) {\n stream.width(static_cast(longest_arg_length));\n stream << argument;\n }\n\n if (!parser.m_optional_arguments.empty()) {\n stream << (parser.m_positional_arguments.empty() ? \"\" : \"\\n\") << \"Optional arguments:\\n\";\n }\n\n for (const auto &argument : parser.m_optional_arguments) {\n stream.width(static_cast(longest_arg_length));\n stream << argument;\n }\n\n if (!parser.m_subparser_map.empty()) {\n stream << (parser.m_positional_arguments.empty() ? (parser.m_optional_arguments.empty() ? \"\" : \"\\n\") : \"\\n\")\n << \"Subcommands:\\n\";\n for (const auto &[command, subparser] : parser.m_subparser_map) {\n stream << std::setw(2) << \" \";\n stream << std::setw(static_cast(longest_arg_length - 2)) << command;\n stream << \" \" << subparser->get().m_description << \"\\n\";\n }\n }\n\n if (!parser.m_epilog.empty()) {\n stream << '\\n';\n stream << parser.m_epilog << \"\\n\\n\";\n }\n\n return stream;\n }\n\n const std::string &program_name() const { return m_program_name; }\n\n // Format help message\n auto help() const -> std::stringstream {\n std::stringstream out;\n out << *this;\n return out;\n }\n\n // Format usage part of help only\n auto usage() const -> std::string {\n std::stringstream stream;\n\n stream << \"Usage: \" << this->m_program_name;\n\n // Add any options inline here\n for (const auto &argument : this->m_optional_arguments) {\n stream << \" \" << argument.get_inline_usage();\n }\n // Put positional arguments after the optionals\n for (const auto &argument : this->m_positional_arguments) {\n if (!argument.m_metavar.empty()) {\n stream << \" \" << argument.m_metavar;\n } else {\n stream << \" \" << argument.m_names.front();\n }\n }\n // Put subcommands after positional arguments\n if (!m_subparser_map.empty()) {\n stream << \" {\";\n std::size_t i{0};\n for (const auto &[command, unused] : m_subparser_map) {\n if (i == 0) {\n stream << command;\n } else {\n stream << \",\" << command;\n }\n ++i;\n }\n stream << \"}\";\n }\n\n return stream.str();\n }\n\n // Printing the one and only help message\n // I've stuck with a simple message format, nothing fancy.\n [[deprecated(\"Use cout << program; instead. See also help().\")]] std::string print_help() const {\n auto out = help();\n std::cout << out.rdbuf();\n return out.str();\n }\n\n void add_subparser(ArgumentParser &parser) {\n parser.m_parser_path = m_program_name + \" \" + parser.m_program_name;\n auto it = m_subparsers.emplace(std::cend(m_subparsers), parser);\n m_subparser_map.insert_or_assign(parser.m_program_name, it);\n m_subparser_used.insert_or_assign(parser.m_program_name, false);\n }\n\n private:\n bool is_valid_prefix_char(char c) const { return m_prefix_chars.find(c) != std::string::npos; }\n\n char get_any_valid_prefix_char() const { return m_prefix_chars[0]; }\n\n /*\n * Pre-process this argument list. Anything starting with \"--\", that\n * contains an =, where the prefix before the = has an entry in the\n * options table, should be split.\n */\n std::vector preprocess_arguments(const std::vector &raw_arguments) const {\n std::vector arguments{};\n for (const auto &arg : raw_arguments) {\n const auto argument_starts_with_prefix_chars = [this](const std::string &a) -> bool {\n if (!a.empty()) {\n const auto legal_prefix = [this](char c) -> bool { return m_prefix_chars.find(c) != std::string::npos; };\n\n // Windows-style\n // if '/' is a legal prefix char\n // then allow single '/' followed by argument name, followed by an\n // assign char, e.g., ':' e.g., 'test.exe /A:Foo'\n const auto windows_style = legal_prefix('/');\n\n if (windows_style) {\n if (legal_prefix(a[0])) {\n return true;\n }\n } else {\n // Slash '/' is not a legal prefix char\n // For all other characters, only support long arguments\n // i.e., the argument must start with 2 prefix chars, e.g,\n // '--foo' e,g, './test --foo=Bar -DARG=yes'\n if (a.size() > 1) {\n return (legal_prefix(a[0]) && legal_prefix(a[1]));\n }\n }\n }\n return false;\n };\n\n // Check that:\n // - We don't have an argument named exactly this\n // - The argument starts with a prefix char, e.g., \"--\"\n // - The argument contains an assign char, e.g., \"=\"\n auto assign_char_pos = arg.find_first_of(m_assign_chars);\n\n if (m_argument_map.find(arg) == m_argument_map.end() && argument_starts_with_prefix_chars(arg) &&\n assign_char_pos != std::string::npos) {\n // Get the name of the potential option, and check it exists\n std::string opt_name = arg.substr(0, assign_char_pos);\n if (m_argument_map.find(opt_name) != m_argument_map.end()) {\n // This is the name of an option! Split it into two parts\n arguments.push_back(std::move(opt_name));\n arguments.push_back(arg.substr(assign_char_pos + 1));\n continue;\n }\n }\n // If we've fallen through to here, then it's a standard argument\n arguments.push_back(arg);\n }\n return arguments;\n }\n\n /*\n * @throws std::runtime_error in case of any invalid argument\n */\n void parse_args_internal(const std::vector &raw_arguments) {\n auto arguments = preprocess_arguments(raw_arguments);\n if (m_program_name.empty() && !arguments.empty()) {\n m_program_name = arguments.front();\n }\n auto end = std::end(arguments);\n auto positional_argument_it = std::begin(m_positional_arguments);\n for (auto it = std::next(std::begin(arguments)); it != end;) {\n const auto ¤t_argument = *it;\n if (Argument::is_positional(current_argument, m_prefix_chars)) {\n if (positional_argument_it == std::end(m_positional_arguments)) {\n std::string_view maybe_command = current_argument;\n\n // Check sub-parsers\n auto subparser_it = m_subparser_map.find(maybe_command);\n if (subparser_it != m_subparser_map.end()) {\n // build list of remaining args\n const auto unprocessed_arguments = std::vector(it, end);\n\n // invoke subparser\n m_is_parsed = true;\n m_subparser_used[maybe_command] = true;\n return subparser_it->second->get().parse_args(unprocessed_arguments);\n }\n\n throw std::runtime_error(\"Maximum number of positional arguments exceeded\");\n }\n auto argument = positional_argument_it++;\n it = argument->consume(it, end);\n continue;\n }\n\n auto arg_map_it = m_argument_map.find(current_argument);\n if (arg_map_it != m_argument_map.end()) {\n auto argument = arg_map_it->second;\n it = argument->consume(std::next(it), end, arg_map_it->first);\n } else if (const auto &compound_arg = current_argument; compound_arg.size() > 1 &&\n is_valid_prefix_char(compound_arg[0]) &&\n !is_valid_prefix_char(compound_arg[1])) {\n ++it;\n for (std::size_t j = 1; j < compound_arg.size(); j++) {\n auto hypothetical_arg = std::string{'-', compound_arg[j]};\n auto arg_map_it2 = m_argument_map.find(hypothetical_arg);\n if (arg_map_it2 != m_argument_map.end()) {\n auto argument = arg_map_it2->second;\n it = argument->consume(it, end, arg_map_it2->first);\n } else {\n throw std::runtime_error(\"Unknown argument: \" + current_argument);\n }\n }\n } else {\n throw std::runtime_error(\"Unknown argument: \" + current_argument);\n }\n }\n m_is_parsed = true;\n }\n\n /*\n * Like parse_args_internal but collects unused args into a vector\n */\n std::vector parse_known_args_internal(const std::vector &raw_arguments) {\n auto arguments = preprocess_arguments(raw_arguments);\n\n std::vector unknown_arguments{};\n\n if (m_program_name.empty() && !arguments.empty()) {\n m_program_name = arguments.front();\n }\n auto end = std::end(arguments);\n auto positional_argument_it = std::begin(m_positional_arguments);\n for (auto it = std::next(std::begin(arguments)); it != end;) {\n const auto ¤t_argument = *it;\n if (Argument::is_positional(current_argument, m_prefix_chars)) {\n if (positional_argument_it == std::end(m_positional_arguments)) {\n std::string_view maybe_command = current_argument;\n\n // Check sub-parsers\n auto subparser_it = m_subparser_map.find(maybe_command);\n if (subparser_it != m_subparser_map.end()) {\n // build list of remaining args\n const auto unprocessed_arguments = std::vector(it, end);\n\n // invoke subparser\n m_is_parsed = true;\n m_subparser_used[maybe_command] = true;\n return subparser_it->second->get().parse_known_args_internal(unprocessed_arguments);\n }\n\n // save current argument as unknown and go to next argument\n unknown_arguments.push_back(current_argument);\n ++it;\n } else {\n // current argument is the value of a positional argument\n // consume it\n auto argument = positional_argument_it++;\n it = argument->consume(it, end);\n }\n continue;\n }\n\n auto arg_map_it = m_argument_map.find(current_argument);\n if (arg_map_it != m_argument_map.end()) {\n auto argument = arg_map_it->second;\n it = argument->consume(std::next(it), end, arg_map_it->first);\n } else if (const auto &compound_arg = current_argument; compound_arg.size() > 1 &&\n is_valid_prefix_char(compound_arg[0]) &&\n !is_valid_prefix_char(compound_arg[1])) {\n ++it;\n for (std::size_t j = 1; j < compound_arg.size(); j++) {\n auto hypothetical_arg = std::string{'-', compound_arg[j]};\n auto arg_map_it2 = m_argument_map.find(hypothetical_arg);\n if (arg_map_it2 != m_argument_map.end()) {\n auto argument = arg_map_it2->second;\n it = argument->consume(it, end, arg_map_it2->first);\n } else {\n unknown_arguments.push_back(current_argument);\n break;\n }\n }\n } else {\n // current argument is an optional-like argument that is unknown\n // save it and move to next argument\n unknown_arguments.push_back(current_argument);\n ++it;\n }\n }\n m_is_parsed = true;\n return unknown_arguments;\n }\n\n // Used by print_help.\n std::size_t get_length_of_longest_argument() const {\n if (m_argument_map.empty()) {\n return 0;\n }\n std::size_t max_size = 0;\n for ([[maybe_unused]] const auto &[unused, argument] : m_argument_map) {\n max_size = std::max(max_size, argument->get_arguments_length());\n }\n for ([[maybe_unused]] const auto &[command, unused] : m_subparser_map) {\n max_size = std::max(max_size, command.size());\n }\n return max_size;\n }\n\n using argument_it = std::list::iterator;\n using argument_parser_it = std::list>::iterator;\n\n void index_argument(argument_it it) {\n for (const auto &name : std::as_const(it->m_names)) {\n m_argument_map.insert_or_assign(name, it);\n }\n }\n\n std::string m_program_name;\n std::string m_version;\n std::string m_description;\n std::string m_epilog;\n std::string m_prefix_chars{\"-\"};\n std::string m_assign_chars{\"=\"};\n bool m_is_parsed = false;\n std::list m_positional_arguments;\n std::list m_optional_arguments;\n std::map m_argument_map;\n std::string m_parser_path;\n std::list> m_subparsers;\n std::map m_subparser_map;\n std::map m_subparser_used;\n};\n\n} // namespace argparse\n"], ["/3FS/src/kv/MemDBStore.h", "#pragma once\n\n#include \n#include \n\n#include \"kv/KVStore.h\"\n\nnamespace hf3fs::kv {\n\nclass MemDBStore : public KVStore {\n public:\n MemDBStore(const Config &config)\n : config_(config) {}\n\n // get value corresponding to key.\n Result get(std::string_view key) final {\n auto lock = std::unique_lock(mutex_);\n auto it = map_.find(std::string{key});\n if (it == map_.end()) {\n return makeError(StatusCode::kKVStoreNotFound);\n }\n return it->second;\n }\n\n // get the first key which is greater than input key.\n Result iterateKeysWithPrefix(std::string_view prefix,\n uint32_t limit,\n IterateFunc func,\n std::optional *nextValidKey = nullptr) final {\n auto lock = std::unique_lock(mutex_);\n auto it = map_.lower_bound(std::string{prefix});\n for (auto i = 0u; i < limit && it != map_.end(); ++i, ++it) {\n if (it->first.starts_with(prefix)) {\n RETURN_ON_ERROR(func(it->first, it->second));\n } else {\n break;\n }\n }\n if (nextValidKey && it != map_.end() && it->first.starts_with(prefix)) {\n *nextValidKey = it->first;\n }\n return Void{};\n }\n\n // put a key-value pair.\n Result put(std::string_view key, std::string_view value, bool) final {\n auto lock = std::unique_lock(mutex_);\n map_[std::string{key}] = value;\n return Void{};\n }\n\n // remove a key-value pair.\n Result remove(std::string_view key) final {\n auto lock = std::unique_lock(mutex_);\n map_.erase(std::string{key});\n return Void{};\n }\n\n // batch operations.\n class MemBatchOperations : public BatchOperations {\n public:\n MemBatchOperations(MemDBStore &db)\n : db_(db) {}\n // put a key-value pair.\n void put(std::string_view key, std::string_view value) override {\n writeBatch_.emplace_back(std::string{key}, std::string{value});\n }\n // remove a key.\n void remove(std::string_view key) override { writeBatch_.emplace_back(std::string{key}, std::nullopt); }\n // clear a batch operations.\n void clear() override { writeBatch_.clear(); }\n // commit a batch of operations.\n Result commit() override {\n auto lock = std::unique_lock(db_.mutex_);\n for (auto &pair : writeBatch_) {\n if (pair.second.has_value()) {\n db_.map_[std::string{pair.first}] = pair.second.value();\n } else {\n db_.map_.erase(std::string{pair.first});\n }\n }\n return Void{};\n }\n // destroy self.\n void destroy() override { delete this; }\n\n private:\n MemDBStore &db_;\n std::vector>> writeBatch_;\n };\n BatchOptionsPtr createBatchOps() override {\n return BatchOptionsPtr{std::make_unique(*this).release()};\n }\n\n // iterator.\n class MemIterator : public Iterator {\n public:\n MemIterator(MemDBStore &db)\n : lock_(db.mutex_),\n map_(db.map_),\n iterator_(map_.end()) {}\n void seek(std::string_view key) override { iterator_ = map_.lower_bound(std::string{key}); }\n void seekToFirst() override { iterator_ = map_.begin(); }\n void seekToLast() override { iterator_ = --map_.end(); }\n void next() override { ++iterator_; }\n Result status() const override { return Void{}; }\n bool valid() const override { return iterator_ != map_.end(); }\n std::string_view key() const override { return iterator_->first; }\n std::string_view value() const override { return iterator_->second; }\n void destroy() override { delete this; }\n\n private:\n std::unique_lock lock_;\n std::map &map_;\n std::map::iterator iterator_;\n };\n IteratorPtr createIterator() override { return IteratorPtr{std::make_unique(*this).release()}; }\n\n private:\n [[maybe_unused]] const Config &config_;\n std::mutex mutex_;\n std::map map_;\n};\n\n} // namespace hf3fs::kv\n"], ["/3FS/src/analytics/StructuredTraceLog.h", "#pragma once\n\n#include \n#include \n#include \n\n#include \"SerdeObjectWriter.h\"\n#include \"common/monitor/Recorder.h\"\n#include \"common/monitor/ScopedMetricsWriter.h\"\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/Path.h\"\n#include \"common/utils/SysResource.h\"\n#include \"common/utils/UtcTime.h\"\n\nnamespace hf3fs::analytics {\n\ntemplate \nclass StructuredTraceLog : public folly::MoveOnly {\n struct TraceMeta {\n SERDE_STRUCT_FIELD(timestamp, std::time_t{});\n SERDE_STRUCT_FIELD(hostname, String{});\n };\n\n struct StructuredTrace {\n SERDE_STRUCT_FIELD(trace_meta, TraceMeta{});\n SERDE_STRUCT_FIELD(_, SerdeType{});\n };\n\n using WriterType = SerdeObjectWriter;\n using WriterPtr = std::shared_ptr;\n\n public:\n class Config : public hf3fs::ConfigBase {\n public:\n CONFIG_ITEM(trace_file_dir, Path{\".\"});\n#ifndef NDEBUG\n CONFIG_HOT_UPDATED_ITEM(enabled, false);\n CONFIG_HOT_UPDATED_ITEM(dump_interval, 60_min);\n#else\n CONFIG_HOT_UPDATED_ITEM(enabled, true);\n CONFIG_HOT_UPDATED_ITEM(dump_interval, 30_s);\n#endif\n CONFIG_HOT_UPDATED_ITEM(max_num_writers, size_t{1}, ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(max_row_group_length, size_t{100'000});\n };\n\n public:\n StructuredTraceLog(const Config &config)\n : config_(config),\n enabled_(config.enabled()),\n typename_(nameof::nameof_short_type()),\n hostname_(SysResource::hostname().value_or(\"unknown_host\")),\n latencyTagSet_({{\"tag\", typename_}, {\"instance\", fmt::to_string(fmt::ptr(this))}}),\n createLatency_(\"trace_log.create_latency\", latencyTagSet_),\n appendLatency_(\"trace_log.append_latency\", latencyTagSet_),\n flushLatency_(\"trace_log.flush_latency\", latencyTagSet_),\n maxNumWriters_(config.max_num_writers()) {\n onConfigUpdated_ = config_.addCallbackGuard([this]() {\n bool enabled = config_.enabled();\n if (enabled_ != enabled) {\n enableTraceLog(enabled);\n if (!enabled) flush(false /*async*/);\n }\n\n if (maxNumWriters_ != config_.max_num_writers()) {\n updateMaxNumWriters(config_.max_num_writers());\n }\n });\n\n uint64_t secsUntilFirstDump =\n folly::Random::rand64(config_.dump_interval().asSec().count() / 2, config_.dump_interval().asSec().count());\n nextDumpTime_ = microsecondsSinceEpoch(UtcClock::now() + std::chrono::seconds{secsUntilFirstDump});\n }\n\n ~StructuredTraceLog() { close(); }\n\n bool open() {\n auto writer = getOrCreateWriter();\n if (!writer) return false;\n writerPool_.enqueue(writer);\n return true;\n }\n\n std::shared_ptr newEntry(const SerdeType &init = SerdeType{}) {\n auto ptr = new SerdeType(init);\n return std::shared_ptr(ptr, [this](SerdeType *ptr) {\n this->append(*ptr);\n delete ptr;\n });\n }\n\n void append(const SerdeType &msg) {\n if (!enabled_) return;\n\n {\n monitor::ScopedLatencyWriter appendLatency(appendLatency_);\n StructuredTrace trace{\n .trace_meta = TraceMeta{.timestamp = UtcClock::secondsSinceEpoch(), .hostname = hostname_},\n ._ = msg,\n };\n\n WriterPtr writer = getOrCreateWriter();\n\n if (UNLIKELY(writer == nullptr)) {\n XLOGF(CRITICAL, \"Cannot get a writer of {} trace log in directory {}\", typename_, config_.trace_file_dir());\n enableTraceLog(false);\n return;\n }\n\n *writer << trace;\n auto writerOk = writer->ok();\n writerPool_.enqueue(std::move(writer));\n if (UNLIKELY(!writerOk)) enableTraceLog(false);\n }\n\n auto currentTime = microsecondsSinceEpoch(UtcClock::now());\n\n if (UNLIKELY(currentTime >= nextDumpTime_)) {\n nextDumpTime_ = currentTime + config_.dump_interval().asUs().count();\n flush(true /*async*/);\n }\n }\n\n void flush(bool async, bool shutdown = false) {\n auto running = dumpingTrace_.test_and_set();\n if (running) return;\n\n monitor::ScopedLatencyWriter flushLatency(flushLatency_);\n if (asyncFlush_.valid()) asyncFlush_.wait();\n\n asyncFlush_ = std::async(\n std::launch::async,\n [this](bool shutdown) {\n size_t numWritersToClose = numWriters_.load();\n auto now = UtcClock::now();\n\n XLOGF(INFO,\n \"Flushing {} {} log writers in directory {}\",\n numWritersToClose,\n typename_,\n config_.trace_file_dir());\n\n for (size_t i = 0; numWritersToClose > 0; i++) {\n // give up flushing old writers after trying for too many loops\n if (i >= 10 * maxNumWriters_) {\n break;\n }\n\n auto writer = writerPool_.dequeue();\n if (!writer) continue;\n\n if (writer->createTime() > now) {\n writerPool_.enqueue(writer);\n continue;\n }\n\n if (writer->ok()) {\n // add an empty trace at the end of log\n *writer << StructuredTrace{\n .trace_meta = {.timestamp = UtcClock::secondsSinceEpoch(), .hostname = hostname_}};\n }\n\n try {\n writer.reset();\n } catch (const std::exception &ex) {\n XLOGF(ERR,\n \"Failed to close {} log writer in directory {}, error: {}\",\n typename_,\n config_.trace_file_dir(),\n ex.what());\n }\n\n if (shutdown)\n numWriters_--;\n else\n writerPool_.enqueue(createNewWriter());\n\n numWritersToClose--;\n }\n\n if (numWritersToClose > 0) {\n XLOGF(WARN,\n \"Still have {} {} log writers not closed in directory {}\",\n numWritersToClose,\n typename_,\n config_.trace_file_dir());\n } else {\n XLOGF(INFO, \"Flushed {} trace log in directory {}\", typename_, config_.trace_file_dir());\n }\n },\n shutdown);\n\n if (!async) asyncFlush_.wait();\n dumpingTrace_.clear();\n }\n\n void close() {\n enableTraceLog(false);\n flush(false /*async*/, true /*shutdown*/);\n XLOGF(INFO, \"Closed {} trace log in directory {}\", typename_, config_.trace_file_dir());\n }\n\n private:\n uint64_t microsecondsSinceEpoch(const UtcTime &time) const {\n return std::chrono::duration_cast((time).time_since_epoch()).count();\n }\n\n WriterPtr getOrCreateWriter() {\n WriterPtr writer;\n if (writerPool_.try_dequeue(writer)) return writer;\n\n auto currentNumWriters = numWriters_.load();\n if (currentNumWriters < maxNumWriters_) {\n bool create = numWriters_.compare_exchange_strong(currentNumWriters, currentNumWriters + 1);\n if (create) return createNewWriter();\n }\n\n return writerPool_.dequeue();\n }\n\n WriterPtr createNewWriter() {\n monitor::ScopedLatencyWriter createLatency(createLatency_);\n auto timestamp = fmt::localtime(UtcClock::to_time_t(UtcClock::now()));\n Path logfilePath =\n config_.trace_file_dir() / Path{fmt::format(\"{:%Y-%m-%d}\", timestamp)} / Path{hostname_} /\n Path{\n fmt::format(\"{}.{}.{:%Y-%m-%d-%H-%M-%S}.{}.parquet\", typename_, hostname_, timestamp, nextLogFileIndex_++)};\n\n if (!boost::filesystem::exists(logfilePath.parent_path())) {\n boost::system::error_code err{};\n boost::filesystem::create_directories(logfilePath.parent_path(), err);\n if (UNLIKELY(err.failed())) {\n XLOGF(CRITICAL, \"Failed to create directory {}, error: {}\", logfilePath.parent_path(), err.message());\n return nullptr;\n }\n }\n\n XLOGF(INFO, \"Opening {} trace log: {}\", typename_, logfilePath);\n return WriterType::open(logfilePath, false /*append*/, config_.max_row_group_length());\n }\n\n void enableTraceLog(bool enable) {\n enabled_ = enable;\n XLOGF(INFO,\n \"{} {} trace log in directory {}\",\n enable ? \"Enabled\" : \"Disabled\",\n typename_,\n config_.trace_file_dir());\n }\n\n void updateMaxNumWriters(size_t newMaxNumWriters) {\n XLOGF(INFO,\n \"Update max num of writers from {} to {} for {} trace log in directory {}\",\n maxNumWriters_.load(),\n newMaxNumWriters,\n typename_,\n config_.trace_file_dir());\n bool doFlush = maxNumWriters_ > newMaxNumWriters;\n maxNumWriters_ = newMaxNumWriters;\n if (doFlush) flush(false /*async*/);\n }\n\n private:\n const Config &config_;\n bool enabled_ = false;\n const std::string typename_;\n const std::string hostname_;\n\n const monitor::TagSet latencyTagSet_;\n monitor::LatencyRecorder createLatency_;\n monitor::LatencyRecorder appendLatency_;\n monitor::LatencyRecorder flushLatency_;\n\n std::unique_ptr onConfigUpdated_;\n std::atomic_size_t maxNumWriters_;\n std::atomic_size_t numWriters_ = 0;\n std::atomic_size_t nextLogFileIndex_ = 1;\n folly::UnboundedQueue writerPool_;\n\n std::atomic_uint64_t nextDumpTime_;\n std::atomic_flag dumpingTrace_;\n std::future asyncFlush_;\n};\n\n} // namespace hf3fs::analytics\n"], ["/3FS/src/common/net/ib/IBSocket.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/monitor/Sample.h\"\n#include \"common/net/EventLoop.h\"\n#include \"common/net/Network.h\"\n#include \"common/net/Socket.h\"\n#include \"common/net/WriteItem.h\"\n#include \"common/net/ib/IBConnect.h\"\n#include \"common/net/ib/IBDevice.h\"\n#include \"common/net/ib/RDMABuf.h\"\n#include \"common/utils/Address.h\"\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/FdWrapper.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/StatusCode.h\"\n#include \"common/utils/UtcTime.h\"\n\nnamespace hf3fs {\n\nnamespace serde {\nclass ClientContext;\n};\n\nnamespace net {\nclass IBConnectService;\nclass IBSocketManager;\n\nclass IBSocket : public Socket, folly::MoveOnly {\n public:\n struct Config : public ConfigBase {\n // for recorder\n CONFIG_HOT_UPDATED_ITEM(record_bytes_per_peer, false);\n CONFIG_HOT_UPDATED_ITEM(record_latency_per_peer, false);\n\n // connection param\n CONFIG_HOT_UPDATED_ITEM(pkey_index, std::optional());\n CONFIG_HOT_UPDATED_ITEM(roce_pkey_index, std::optional()); // RoCE pkey should be 0\n CONFIG_HOT_UPDATED_ITEM(sl, (uint8_t)0);\n CONFIG_HOT_UPDATED_ITEM(traffic_class, std::optional()); // for RoCE\n // CONFIG_HOT_UPDATED_ITEM(gid_index, std::optional()); // for RoCE\n\n CONFIG_HOT_UPDATED_ITEM(start_psn, (uint32_t)0);\n CONFIG_HOT_UPDATED_ITEM(min_rnr_timer, (uint8_t)1);\n CONFIG_HOT_UPDATED_ITEM(timeout, (uint8_t)14); // ibv_qp_attr.timeout\n CONFIG_HOT_UPDATED_ITEM(retry_cnt, (uint8_t)7);\n CONFIG_HOT_UPDATED_ITEM(rnr_retry, (uint8_t)0);\n\n CONFIG_HOT_UPDATED_ITEM(max_sge, 16u, ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(max_rdma_wr, 128u, ConfigCheckers::checkPositive); // max number of RDMA WRs in send queue\n CONFIG_HOT_UPDATED_ITEM(max_rdma_wr_per_post,\n 32u,\n ConfigCheckers::checkPositive); // max number of RDMA WRs per ibv_post_send\n CONFIG_HOT_UPDATED_ITEM(max_rd_atomic, 16u, ConfigCheckers::checkPositive); // ibv_qp_attr.max_rd_atomic\n\n CONFIG_HOT_UPDATED_ITEM(buf_size, (16u * 1024), ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(send_buf_cnt, 32u, ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(buf_ack_batch, 8u, ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(buf_signal_batch, 8u, ConfigCheckers::checkPositive);\n CONFIG_HOT_UPDATED_ITEM(event_ack_batch, 128u, ConfigCheckers::checkPositive);\n\n CONFIG_HOT_UPDATED_ITEM(drain_timeout, 5_s);\n CONFIG_HOT_UPDATED_ITEM(drop_connections, 0u);\n\n public:\n mutable folly::Synchronized> roundRobin_;\n IBConnectConfig toIBConnectConfig(bool roce) const;\n };\n\n using Ptr = std::unique_ptr;\n\n IBSocket(const Config &config, IBPort port = {});\n ~IBSocket() override;\n\n CoTryTask connect(serde::ClientContext &ctx, Duration timeout);\n Result accept(folly::IPAddressV4 ip, const IBConnectReq &req, Duration acceptTimeout = 15_s);\n\n std::string describe() override { return *describe_.rlock(); };\n std::string describe() const { return *describe_.rlock(); }\n folly::IPAddressV4 peerIP() override { return peerIP_; };\n\n int fd() const override { return channel_->fd; }\n\n Result poll(uint32_t events) override;\n\n Result send(folly::ByteRange buf);\n Result send(struct iovec *iov, uint32_t cnt) override;\n Result flush() override;\n Result recv(folly::MutableByteRange buf) override;\n\n CoTask close();\n\n // Send a empty message to check the liveness of the socket.\n // - if socket is known to be broken, return corresponding error.\n // - else send check message and return immediately\n // - if the message cannot be delivered, an error will be returned in future during poll.\n Result check() override;\n\n // Socket should already turn from ACCEPTED state to READY or ERROR state\n bool checkConnectFinished() const;\n\n /** RDMA operations. */\n CoTryTask rdmaRead(const RDMARemoteBuf &remoteBuf, RDMABuf &localBuf) {\n co_return co_await rdmaRead(remoteBuf, std::span(&localBuf, 1));\n }\n CoTryTask rdmaRead(const RDMARemoteBuf &remoteBuf, std::span localBufs) {\n co_return co_await rdma(IBV_WR_RDMA_READ, remoteBuf, localBufs);\n }\n\n CoTryTask rdmaWrite(const RDMARemoteBuf &remoteBuf, RDMABuf &localBuf) {\n co_return co_await rdmaWrite(remoteBuf, std::span(&localBuf, 1));\n }\n CoTryTask rdmaWrite(const RDMARemoteBuf &remoteBuf, std::span localBufs) {\n co_return co_await rdma(IBV_WR_RDMA_WRITE, remoteBuf, localBufs);\n }\n\n private:\n struct RDMAReq {\n uint64_t raddr;\n uint32_t rkey;\n uint32_t localBufFirst;\n uint32_t localBufCnt;\n\n RDMAReq()\n : RDMAReq(0, 0, 0, 0) {}\n RDMAReq(uint64_t raddr, uint32_t rkey, uint32_t localBufFirst, uint32_t localBufCnt)\n : raddr(raddr),\n rkey(rkey),\n localBufFirst(localBufFirst),\n localBufCnt(localBufCnt) {}\n };\n\n public:\n class RDMAReqBatch {\n public:\n RDMAReqBatch()\n : RDMAReqBatch(nullptr, ibv_wr_opcode(-1)) {}\n RDMAReqBatch(IBSocket *socket, ibv_wr_opcode opcode)\n : socket_(socket),\n opcode_(opcode),\n reqs_(),\n localBufs_() {}\n\n Result add(const RDMARemoteBuf &remoteBuf, RDMABuf localBuf);\n Result add(RDMARemoteBuf remoteBuf, std::span localBufs);\n\n void reserve(size_t numReqs, size_t numLocalBufs) {\n reqs_.reserve(numReqs);\n localBufs_.reserve(numLocalBufs);\n }\n\n void clear() {\n reqs_.clear();\n localBufs_.clear();\n waitLatency_ = std::chrono::nanoseconds(0);\n transferLatency_ = std::chrono::nanoseconds(0);\n }\n\n ibv_wr_opcode opcode() const { return opcode_; }\n CoTryTask post() {\n co_return co_await socket_->rdmaBatch(opcode_, reqs_, localBufs_, waitLatency_, transferLatency_);\n }\n\n std::chrono::nanoseconds waitLatency() const { return waitLatency_; };\n std::chrono::nanoseconds transferLatency() const { return transferLatency_; };\n\n private:\n IBSocket *socket_;\n ibv_wr_opcode opcode_;\n std::vector reqs_;\n std::vector localBufs_;\n std::chrono::nanoseconds waitLatency_;\n std::chrono::nanoseconds transferLatency_;\n };\n\n RDMAReqBatch rdmaReadBatch() { return RDMAReqBatch(this, IBV_WR_RDMA_READ); }\n RDMAReqBatch rdmaWriteBatch() { return RDMAReqBatch(this, IBV_WR_RDMA_WRITE); }\n\n const IBDevice *device() const { return port_.dev(); }\n\n private:\n static constexpr size_t kRDMAPostBatch = 8;\n\n enum class State {\n INIT,\n CONNECTING,\n ACCEPTED,\n READY,\n CLOSE,\n ERROR,\n };\n\n struct RDMAPostCtx {\n std::optional> sem;\n std::optional waiter;\n\n ibv_wr_opcode opcode;\n std::span reqs;\n std::span localBufs;\n size_t bytes = 0;\n\n folly::coro::Baton baton;\n ibv_wc_status status = IBV_WC_SUCCESS;\n std::chrono::steady_clock::time_point postBegin;\n std::chrono::steady_clock::time_point postEnd;\n\n CoTask waitSem() {\n if (waiter.has_value()) {\n co_await waiter->baton;\n }\n }\n\n bool setError(ibv_wc_status error) {\n if (status == IBV_WC_SUCCESS) {\n status = error;\n return true;\n }\n return false;\n }\n\n __attribute__((no_sanitize(\"thread\"))) void finish() {\n postEnd = std::chrono::steady_clock::now();\n baton.post();\n }\n };\n\n enum class WRType : uint16_t { SEND, RECV, ACK, RDMA, RDMA_LAST, CLOSE, CHECK };\n\n public: // note: public to formatter\n struct WRId : private folly::StampedPtr {\n using Base = folly::StampedPtr;\n\n static uint64_t send(uint32_t signalCount) { return WRId::pack(signalCount, WRType::SEND); }\n static uint64_t recv(uint32_t bufIndex) { return WRId::pack(bufIndex, WRType::RECV); }\n static uint64_t ack() { return WRId::pack(nullptr, WRType::ACK); }\n static uint64_t rdma(RDMAPostCtx *ptr, bool last) {\n return WRId::pack(ptr, last ? WRType::RDMA_LAST : WRType::RDMA);\n }\n static uint64_t close() { return WRId::pack(nullptr, WRType::CLOSE); }\n static uint64_t check() { return WRId::pack(nullptr, WRType::CHECK); }\n\n static uint64_t pack(uint32_t val, WRType type) { return Base::pack((void *)(uint64_t)val, (uint16_t)type); }\n static uint64_t pack(void *ptr, WRType type) { return Base::pack(ptr, (uint16_t)type); }\n\n WRId(uint64_t raw)\n : Base{raw} {}\n\n WRType type() const { return static_cast(stamp()); }\n\n uint32_t sendSignalCount() const {\n assert(type() == WRType::SEND);\n return (uint32_t)(uint64_t)ptr();\n }\n uint32_t recvBufIndex() const {\n assert(type() == WRType::RECV);\n return (uint32_t)(uint64_t)ptr();\n }\n RDMAPostCtx *rdmaPostCtx() const {\n assert(type() == WRType::RDMA || type() == WRType::RDMA_LAST);\n return (RDMAPostCtx *)ptr();\n }\n\n std::string describe() const {\n switch (type()) {\n case WRType::SEND:\n return fmt::format(\"[WRType::SEND, signal {}]\", sendSignalCount());\n case WRType::RECV:\n return fmt::format(\"[WRType::RECV, bufIndex {}]\", recvBufIndex());\n case WRType::ACK:\n return fmt::format(\"[WRType::ACK]\");\n case WRType::RDMA:\n return fmt::format(\"[WRType::RDMA, ctx {}]\", ptr());\n case WRType::RDMA_LAST:\n return fmt::format(\"[WRTpe::RDMA_LAST, ctx {}]\", ptr());\n case WRType::CLOSE:\n return fmt::format(\"[WRType::CLOSE]\");\n case WRType::CHECK:\n return fmt::format(\"[WRType::CHECK]\");\n }\n assert(false);\n return fmt::format(\"[INVALID 0x{:016x}]\", raw);\n }\n\n bool operator==(const WRId &other) const { return raw == other.raw; }\n };\n\n class ImmData {\n static constexpr size_t kTypeOffset = 24;\n static constexpr uint32_t kValMax = (1 << kTypeOffset) - 1;\n static constexpr uint32_t kValMask = kValMax;\n uint32_t val;\n\n public:\n enum class Type : uint8_t {\n ACK,\n CLOSE,\n };\n\n ImmData(__be32 val = 0)\n : val(folly::Endian::big32(val)) {}\n\n static ImmData ack(uint32_t count) { return create(Type::ACK, count); }\n static ImmData close() { return create(Type::CLOSE, 0); }\n static ImmData create(Type type, uint32_t val) {\n assert(type == Type::ACK || type == Type::CLOSE);\n assert(val <= kValMax);\n return folly::Endian::big32(((uint8_t)type << kTypeOffset) | val);\n }\n\n Type type() const { return Type(val >> kTypeOffset); }\n uint32_t data() const { return val & kValMask; }\n\n std::string describe() const {\n switch (type()) {\n case Type::ACK:\n return fmt::format(\"[ACK, count {}]\", data());\n case Type::CLOSE:\n return fmt::format(\"[CLOSE]\");\n default:\n return fmt::format(\"[INVALID 0x{:08x}]\", val);\n }\n }\n\n operator __be32() const { return folly::Endian::big(val); }\n };\n static_assert(sizeof(ImmData) == sizeof(__be32));\n\n private:\n struct BufferMem : folly::MoveOnly {\n const IBDevice *dev = nullptr;\n int64_t total = 0;\n uint8_t *ptr = nullptr;\n ibv_mr *mr = nullptr;\n\n static Result create(const IBDevice *dev, size_t bufSize, size_t bufCnt, unsigned int flags);\n BufferMem() = default;\n BufferMem(BufferMem &&o)\n : dev(std::exchange(o.dev, nullptr)),\n total(std::exchange(o.total, 0)),\n ptr(std::exchange(o.ptr, nullptr)),\n mr(std::exchange(o.mr, nullptr)) {}\n ~BufferMem();\n };\n\n class Buffers {\n public:\n void init(uint8_t *ptr, ibv_mr *mr, size_t bufSize, size_t bufCnt) {\n ptr_ = ptr;\n mr_ = mr;\n bufSize_ = bufSize;\n bufCnt_ = bufCnt;\n }\n\n uint8_t *getBuf(size_t idx) { return ptr_ + idx * bufSize_; }\n ibv_mr *getMr() { return mr_; }\n size_t getBufCnt() const { return bufCnt_; }\n size_t getBufSize() const { return bufSize_; }\n\n protected:\n uint8_t *ptr_ = nullptr;\n ibv_mr *mr_ = nullptr;\n size_t bufSize_ = 0;\n size_t bufCnt_ = 0;\n };\n\n class SendBuffers : public Buffers {\n public:\n void init(uint8_t *ptr, ibv_mr *mr, size_t bufSize, size_t bufCnt);\n void push(size_t cnts);\n bool empty();\n std::pair front();\n void pop();\n\n private:\n alignas(folly::hardware_destructive_interference_size) std::atomic tailIdx_{0};\n alignas(folly::hardware_destructive_interference_size) std::atomic frontIdx_{0};\n std::pair front_;\n };\n\n class RecvBuffers : public Buffers {\n public:\n void init(uint8_t *ptr, ibv_mr *mr, size_t bufSize, size_t bufCnt);\n void push(uint32_t idx, uint32_t len);\n bool empty();\n std::pair front();\n bool pop();\n\n private:\n folly::MPMCQueue> queue_;\n std::optional> front_;\n };\n\n friend class IBConnectService;\n\n int checkConfig() const;\n Result checkPort() const;\n Result getConnectInfo() const;\n void setPeerInfo(folly::IPAddressV4 ip, const IBConnectInfo &info);\n\n // ibv_create_qp & ibv_modify_qp\n [[nodiscard]] int qpCreate();\n [[nodiscard]] int qpInit();\n [[nodiscard]] int qpReadyToRecv();\n [[nodiscard]] int qpReadyToSend();\n void qpError();\n\n Result checkState();\n\n void cqPoll(Events &events);\n int cqGetEvent();\n int cqRequestNotify();\n void wcError(const ibv_wc &wc);\n int wcSuccess(const ibv_wc &wc, Events &events);\n int onSended(const ibv_wc &wc, Events &events);\n int onRecved(const ibv_wc &wc, Events &events);\n int onAckSended(const ibv_wc &wc, Events &events);\n int onRDMAFinished(const ibv_wc &wc, Events &events);\n int onImmData(ImmData imm, Events &events);\n\n int initBufs();\n int postSend(uint32_t idx, size_t len, uint32_t flags = 0);\n int postRecv(uint32_t idx);\n int postAck();\n\n friend class IBSocketManager;\n class Drainer : public EventLoop::EventHandler, public std::enable_shared_from_this {\n public:\n using Ptr = std::shared_ptr;\n using WeakPtr = std::weak_ptr;\n\n static Ptr create(IBSocket::Ptr socket, std::weak_ptr manager);\n\n Drainer(IBSocket::Ptr socket, std::weak_ptr manager);\n ~Drainer() override;\n\n std::string describe() const { return socket_->describe(); }\n\n int fd() const override { return socket_->fd(); }\n void handleEvents(uint32_t /* epollEvents */) override;\n\n private:\n IBSocket::Ptr socket_;\n std::weak_ptr manager_;\n };\n bool closeGracefully();\n bool drain();\n\n CoTryTask rdma(ibv_wr_opcode opcode, const RDMARemoteBuf &remoteBuf, std::span localBufs) {\n RDMAReqBatch batch(this, opcode);\n CO_RETURN_ON_ERROR(batch.add(remoteBuf, localBufs));\n co_return co_await batch.post();\n }\n\n CoTryTask rdmaBatch(ibv_wr_opcode opcode,\n const std::span reqs,\n const std::span localBufs,\n std::chrono::nanoseconds &waitLatency,\n std::chrono::nanoseconds &transferLatency);\n CoTryTask rdmaPost(RDMAPostCtx &ctx);\n int rdmaPostWR(RDMAPostCtx &ctx);\n\n const Config &config_;\n IBConnectConfig connectConfig_;\n\n IBPort port_;\n std::unique_ptr channel_;\n std::unique_ptr cq_;\n std::unique_ptr qp_;\n\n folly::IPAddressV4 peerIP_; // IP of TCP socket to setup connection\n IBConnectInfo peerInfo_;\n folly::Synchronized describe_;\n\n monitor::TagSet tag_;\n monitor::TagSet peerTag_;\n\n SteadyTime acceptTimeout_;\n std::atomic state_ = State::INIT;\n std::atomic closed_ = false;\n std::atomic closeMsgSended_ = false;\n size_t unackedEvents_ = 0;\n\n // memory\n std::optional mem_;\n\n // socket send\n SendBuffers sendBufs_;\n size_t sendNotSignaled_ = 0;\n size_t sendSignaled_ = 0;\n size_t sendAcked_ = 0;\n std::atomic sendWaitBufBegin_ = 0;\n\n // socket recv\n RecvBuffers recvBufs_;\n uint32_t recvNotAcked_ = 0;\n std::atomic ackBufAvailable_ = 0;\n\n // RDMA\n folly::fibers::BatchSemaphore rdmaSem_{0};\n\n // check\n std::atomic checkMsgSended_ = false;\n};\n\nclass IBSocketManager : public EventLoop::EventHandler, public std::enable_shared_from_this {\n public:\n static std::shared_ptr create();\n\n IBSocketManager(int fd)\n : timer_(fd) {}\n\n void stopAndJoin();\n\n void close(IBSocket::Ptr socket);\n\n int fd() const override { return timer_; }\n void handleEvents(uint32_t /* events */) override;\n\n private:\n friend class IBSocket::Drainer;\n void remove(const IBSocket::Drainer::Ptr &drainer) { drainers_.lock()->erase(drainer); }\n\n FdWrapper timer_;\n folly::Synchronized, std::mutex> drainers_;\n folly::Synchronized, std::mutex> deadlines_;\n};\n\n} // namespace net\n} // namespace hf3fs\n"], ["/3FS/benchmarks/storage_bench/StorageBench.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/logging/LogInit.h\"\n#include \"common/net/ib/IBDevice.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/SysResource.h\"\n#include \"tests/lib/UnitTestFabric.h\"\n\nnamespace hf3fs::storage::benchmark {\n\nusing namespace hf3fs::storage::client;\n\nclass StorageBench : public test::UnitTestFabric {\n public:\n struct Options {\n const size_t numChunks;\n const size_t readSize;\n const size_t writeSize;\n const size_t batchSize;\n const uint64_t numReadSecs;\n const uint64_t numWriteSecs;\n const uint64_t clientTimeoutMS;\n const size_t numCoroutines;\n const size_t numTestThreads;\n const uint32_t randSeed = 0;\n const uint16_t chunkIdPrefix = 0xFFFF;\n const bool benchmarkNetwork = false;\n const bool benchmarkStorage = false;\n const bool ignoreIOError = false;\n const bool injectRandomServerError = false;\n const bool injectRandomClientError = false;\n const bool retryPermanentError = false;\n const bool verifyReadData = false;\n const bool verifyReadChecksum = false;\n const bool verifyWriteChecksum = true;\n const bool randomShuffleChunkIds = true;\n const bool generateTestData = true;\n const bool sparseChunkIds = true;\n const std::string statsFilePath = \"./perfstats.csv\";\n const std::vector ibvDevices = {};\n const std::vector ibnetZones = {};\n const std::vector mgmtdEndpoints = {};\n const std::string clusterId = kClusterId;\n const uint32_t chainTableId = 0;\n const uint32_t chainTableVersion = 0;\n const std::vector chainIds = {};\n const std::vector storageNodeIds = {};\n const size_t memoryAlignment = 1;\n const size_t readOffAlignment = 0;\n const size_t defaultPKeyIndex = 1;\n size_t readBatchSize = 0;\n size_t writeBatchSize = 0;\n size_t removeBatchSize = 0;\n };\n\n private:\n static constexpr uint32_t kTDigestMaxSize = 1000;\n\n struct ChunkInfo {\n ChainId chainId;\n ChunkId chunkId;\n size_t size;\n };\n\n Options benchOptions_;\n std::vector writeLatencyDigests_;\n std::vector readLatencyDigests_;\n folly::CPUThreadPoolExecutor testExecutor_;\n std::atomic_uint64_t numWriteBytes_;\n std::atomic_uint64_t numReadBytes_;\n folly::Random::DefaultGenerator randGen_;\n std::vector> chunkInfos_;\n std::vector numCreatedChunks_;\n size_t totalNumChunks_;\n double totalChunkGiB_;\n\n public:\n StorageBench(const test::SystemSetupConfig &setupConfig, const Options &options)\n : UnitTestFabric(setupConfig),\n benchOptions_(options),\n writeLatencyDigests_(benchOptions_.numCoroutines, folly::TDigest(kTDigestMaxSize)),\n readLatencyDigests_(benchOptions_.numCoroutines, folly::TDigest(kTDigestMaxSize)),\n testExecutor_(benchOptions_.numTestThreads),\n numWriteBytes_(0),\n numReadBytes_(0),\n randGen_(folly::Random::create()),\n chunkInfos_(benchOptions_.numCoroutines),\n numCreatedChunks_(benchOptions_.numCoroutines) {\n if (benchOptions_.readBatchSize == 0) benchOptions_.readBatchSize = benchOptions_.batchSize;\n if (benchOptions_.writeBatchSize == 0) benchOptions_.writeBatchSize = benchOptions_.batchSize;\n if (benchOptions_.removeBatchSize == 0) benchOptions_.removeBatchSize = benchOptions_.batchSize;\n }\n\n void generateChunkIds() {\n static_assert(sizeof(benchOptions_.chunkIdPrefix) == 2);\n uint64_t chunkIdPrefix64 = ((uint64_t)benchOptions_.chunkIdPrefix) << (UINT64_WIDTH - UINT16_WIDTH);\n std::sort(chainIds_.begin(), chainIds_.end());\n static thread_local std::mt19937 generator;\n randGen_.seed(benchOptions_.randSeed);\n\n XLOGF(WARN,\n \"Generating {} chunk ids with prefix {:08X} and random seed {}...\",\n totalNumChunks_,\n chunkIdPrefix64,\n benchOptions_.randSeed);\n\n for (auto &chunkInfos : chunkInfos_) {\n uint64_t instancePrefix = chunkIdPrefix64 | folly::Random::rand64(randGen_);\n XLOGF(DBG3, \"Random chunk id prefix {:08X}\", instancePrefix);\n\n chunkInfos.reserve(chainIds_.size() * benchOptions_.numChunks);\n\n for (auto chainId : chainIds_) {\n for (size_t chunkIndex = 0; chunkIndex < benchOptions_.numChunks; chunkIndex++) {\n if (benchOptions_.sparseChunkIds) {\n uint64_t chunkIdHigh = chunkIdPrefix64 | (folly::Random::rand64(randGen_) & 0x000000FFFFFFFFFF);\n uint64_t chunkIdLow = (folly::Random::rand64(randGen_) << UINT32_WIDTH) + chunkIndex;\n chunkInfos.push_back({chainId, ChunkId(chunkIdHigh, chunkIdLow), 0});\n } else {\n chunkInfos.push_back({chainId, ChunkId(instancePrefix, chunkIndex), 0});\n }\n }\n }\n\n if (benchOptions_.randomShuffleChunkIds) std::shuffle(chunkInfos.begin(), chunkInfos.end(), generator);\n }\n }\n\n bool connect() {\n XLOGF(INFO, \"Start to connect...\");\n\n if (!setupIBSock()) {\n return false;\n }\n\n mgmtdClientConfig_.set_mgmtd_server_addresses(benchOptions_.mgmtdEndpoints);\n mgmtdClientConfig_.set_enable_auto_refresh(true);\n mgmtdClientConfig_.set_enable_auto_heartbeat(false);\n mgmtdClientConfig_.set_enable_auto_extend_client_session(true);\n mgmtdClientConfig_.set_auto_refresh_interval(3_s);\n mgmtdClientConfig_.set_auto_heartbeat_interval(3_s);\n mgmtdClientConfig_.set_auto_extend_client_session_interval(3_s);\n mgmtdClientConfig_.set_accept_incomplete_routing_info_during_mgmtd_bootstrapping(false);\n\n if (!client_.start()) {\n XLOGF(ERR, \"Failed to start net client for mgmtd client\");\n return false;\n }\n\n XLOGF(INFO, \"Creating mgmtd client...\");\n\n auto stubFactory = std::make_unique>(\n stubs::ClientContextCreator{[this](net::Address addr) { return client_.serdeCtx(addr); }});\n auto mgmtdClient = std::make_unique(benchOptions_.clusterId,\n std::move(stubFactory),\n mgmtdClientConfig_);\n\n auto physicalHostnameRes = SysResource::hostname(/*physicalMachineName=*/true);\n if (!physicalHostnameRes) {\n XLOGF(ERR, \"getHostname(true) failed: {}\", physicalHostnameRes.error());\n return false;\n }\n\n auto containerHostnameRes = SysResource::hostname(/*physicalMachineName=*/false);\n if (!containerHostnameRes) {\n XLOGF(ERR, \"getHostname(false) failed: {}\", containerHostnameRes.error());\n return false;\n }\n\n mgmtdClient->setClientSessionPayload({clientId_.uuid.toHexString(),\n flat::NodeType::CLIENT,\n flat::ClientSessionData::create(\n /*universalId=*/*physicalHostnameRes,\n /*description=*/fmt::format(\"StorageBench: {}\", *containerHostnameRes),\n /*serviceGroups=*/std::vector{},\n flat::ReleaseVersion::fromVersionInfo()),\n flat::UserInfo{}});\n folly::coro::blockingWait(mgmtdClient->start(&client_.tpg().bgThreadPool().randomPick()));\n mgmtdForClient_ = std::move(mgmtdClient);\n\n // get routing info\n\n for (size_t retry = 0; retry < 15; retry++) {\n auto routingInfo = mgmtdForClient_->getRoutingInfo();\n\n if (routingInfo == nullptr || routingInfo->raw()->chains.empty()) {\n XLOGF(WARN, \"Empty routing info, #{} retry...\", retry + 1);\n std::this_thread::sleep_for(std::chrono::milliseconds(1000));\n } else {\n for (const auto &[tableId, tableVersions] : routingInfo->raw()->chainTables) {\n if (tableId == benchOptions_.chainTableId) {\n if (tableVersions.empty()) {\n XLOGF(WARN, \"No version found for chain table with id {}\", tableId);\n return false;\n }\n\n XLOGF(INFO, \"Found {} version(s) of chain table {}\", tableVersions.size(), benchOptions_.chainTableId);\n\n flat::ChainTable chainTable;\n\n if (benchOptions_.chainTableVersion > 0) {\n flat::ChainTableVersion tableVersion(benchOptions_.chainTableVersion);\n auto tableIter = tableVersions.find(tableVersion);\n\n if (tableIter == tableVersions.end()) {\n XLOGF(WARN, \"Version {} not found in chain table with id {}\", tableVersion, tableId);\n return false;\n }\n\n chainTable = tableIter->second;\n XLOGF(INFO,\n \"Found version {} of chain table {}: {}\",\n benchOptions_.chainTableVersion,\n benchOptions_.chainTableId,\n chainTable.chainTableVersion);\n } else {\n const auto iter = --tableVersions.cend();\n const auto &latestTable = iter->second;\n chainTable = latestTable;\n XLOGF(INFO,\n \"Found latest version of chain table {}: {}\",\n benchOptions_.chainTableId,\n chainTable.chainTableVersion);\n }\n\n XLOGF(WARN,\n \"Selected chain table: {}@{} [{}] {} chains\",\n chainTable.chainTableId,\n chainTable.chainTableVersion,\n chainTable.desc,\n chainTable.chains.size());\n\n if (!benchOptions_.storageNodeIds.empty()) {\n for (const auto &chainId : chainTable.chains) {\n const auto chainInfo = routingInfo->raw()->getChain(chainId);\n for (const auto &target : chainInfo->targets) {\n const auto targetInfo = routingInfo->raw()->getTarget(target.targetId);\n auto nodeIter = std::find(benchOptions_.storageNodeIds.begin(),\n benchOptions_.storageNodeIds.end(),\n *targetInfo->nodeId);\n if (nodeIter != benchOptions_.storageNodeIds.end()) {\n chainIds_.push_back(chainId);\n break;\n }\n }\n }\n } else if (!benchOptions_.chainIds.empty()) {\n for (const auto &chainId : chainTable.chains) {\n auto chainIter = std::find(benchOptions_.chainIds.begin(), benchOptions_.chainIds.end(), chainId);\n if (chainIter != benchOptions_.chainIds.end()) {\n chainIds_.push_back(chainId);\n }\n }\n } else {\n chainIds_ = chainTable.chains;\n }\n\n break;\n }\n }\n\n if (!chainIds_.empty()) break;\n }\n }\n\n if (chainIds_.empty()) {\n XLOGF(ERR, \"Failed to get chain table with id {}\", benchOptions_.chainTableId);\n return false;\n } else {\n XLOGF(WARN, \"Selected {} replication chains for benchmark\", chainIds_.size());\n }\n\n // create storage client\n\n if (setupConfig_.client_config().empty()) {\n XLOGF(ERR, \"Storage client config not specified\");\n return false;\n }\n\n auto configRes = clientConfig_.atomicallyUpdate(setupConfig_.client_config(), false /*isHotUpdate*/);\n if (!configRes) {\n XLOGF(ERR, \"Cannot load client config from {}, error: {}\", setupConfig_.client_config(), configRes.error());\n return false;\n }\n\n totalNumChunks_ = chainIds_.size() * benchOptions_.numCoroutines * benchOptions_.numChunks;\n totalChunkGiB_ = (double)totalNumChunks_ * setupConfig_.chunk_size() / 1_GB;\n clientConfig_.retry().set_max_retry_time(Duration(std::chrono::milliseconds(benchOptions_.clientTimeoutMS)));\n clientConfig_.net_client().io_worker().ibsocket().set_sl(setupConfig_.service_level());\n\n XLOGF(INFO, \"Creating storage client...\");\n storageClient_ = client::StorageClient::create(clientId_, clientConfig_, *mgmtdForClient_);\n\n return true;\n }\n\n bool setupIBSock() {\n XLOGF(WARN, \"Setting up IB socket...\");\n\n std::vector subnets;\n\n for (const auto &ibnetZoneStr : benchOptions_.ibnetZones) {\n std::vector ibnetZoneSubnet;\n boost::split(ibnetZoneSubnet, ibnetZoneStr, boost::is_any_of(\":\"));\n\n if (ibnetZoneSubnet.size() != 2) {\n XLOGF(CRITICAL, \"Invalid IB zone subnet: {}\", ibnetZoneStr);\n return false;\n }\n\n auto zone = boost::trim_copy(ibnetZoneSubnet[0]);\n auto subnet = boost::trim_copy(ibnetZoneSubnet[1]);\n\n if (zone.empty() || subnet.empty()) {\n XLOGF(CRITICAL, \"Invalid IB zone subnet: {}\", ibnetZoneStr);\n return false;\n }\n\n subnets.emplace_back();\n subnets.back().set_network_zones({zone});\n subnets.back().set_subnet(*net::IBConfig::Network::from(subnet));\n XLOGF(WARN, \"Add IB network zone: {} -- {}\", zone, subnet);\n }\n\n net::IBConfig ibConfig;\n ibConfig.set_subnets(subnets);\n ibConfig.set_allow_unknown_zone(false);\n ibConfig.set_default_network_zone(\"$HF3FS_NETWORK_ZONE\");\n ibConfig.set_device_filter(benchOptions_.ibvDevices);\n ibConfig.set_default_pkey_index(benchOptions_.defaultPKeyIndex);\n\n auto ibResult = net::IBManager::start(ibConfig);\n if (ibResult.hasError()) {\n XLOGF(CRITICAL, \"Cannot initialize IB device: {}\", ibResult.error());\n return false;\n }\n\n return true;\n }\n\n bool setup() {\n XLOGF(WARN, \"Setting up benchmark...\");\n\n if (!setupIBSock()) {\n return false;\n }\n\n bool ok = setUpStorageSystem();\n\n totalNumChunks_ = chainIds_.size() * benchOptions_.numCoroutines * benchOptions_.numChunks;\n totalChunkGiB_ = (double)totalNumChunks_ * setupConfig_.chunk_size() / 1_GB;\n clientConfig_.retry().set_max_retry_time(Duration(std::chrono::milliseconds(benchOptions_.clientTimeoutMS)));\n\n return ok;\n }\n\n void teardown() {\n tearDownStorageSystem();\n net::IBManager::stop();\n }\n\n void printThroughput(hf3fs::SteadyClock::duration elapsedMicro, double totalGiB) {\n auto elapsedMilli = std::chrono::duration_cast(elapsedMicro);\n double throughput = totalGiB / (elapsedMilli.count() / 1000.0);\n XLOGF(WARN, \"Average throughput: {:.3f}GiB/s, total {:.3f} GiB\", throughput, totalGiB);\n }\n\n void printLatencyDigest(const folly::TDigest &digest) {\n XLOGF(WARN, \"latency summary ({} samples)\", digest.count());\n XLOGF(WARN, \"min: {:10.1f}us\", digest.min());\n XLOGF(WARN, \"max: {:10.1f}us\", digest.max());\n XLOGF(WARN, \"avg: {:10.1f}us\", digest.mean());\n for (double p : {0.1, 0.2, 0.5, 0.9, 0.95, 0.99}) {\n XLOGF(WARN, \"{}%: {:10.1f}us\", p * 100.0, digest.estimateQuantile(p));\n }\n }\n\n void dumpPerfStats(const std::string &testName,\n const folly::TDigest &digest,\n hf3fs::SteadyClock::duration elapsedTime,\n double totalGiB,\n bool readIO) {\n if (benchOptions_.statsFilePath.empty()) return;\n\n boost::filesystem::path outFilePath(benchOptions_.statsFilePath);\n\n if (!boost::filesystem::exists(outFilePath) || boost::filesystem::is_empty(outFilePath)) {\n XLOGF(INFO, \"Create a file for perfermance stats at {}\", outFilePath);\n std::ofstream outFile(outFilePath);\n if (!outFile) {\n throw std::runtime_error(\"Failed to open file: \" + outFilePath.string());\n }\n\n outFile << \"test name,#storages,#chains,#replicas,concurrency,batch size,\"\n \"io size (bytes),effective batch size (batch size / #replicas),elapsed time (us),\"\n \"QPS,IOPS,bandwidth (MB/s),latency samples,min latency (us),max latency (us),avg latency (us),\"\n \"latency P50 (us),latency P75 (us),latency P90 (us),latency P95 (us),latency P99 (us)\\n\";\n\n if (!outFile) {\n throw std::runtime_error(\"Failed to write to file: \" + outFilePath.string());\n }\n\n outFile.close();\n }\n\n auto elapsedMicro = std::chrono::duration_cast(elapsedTime);\n double bandwidthMBps = totalGiB * 1024.0 / (elapsedMicro.count() / 1'000'000.0);\n size_t ioSize = readIO ? benchOptions_.readSize : benchOptions_.writeSize;\n size_t batchSize = readIO ? benchOptions_.readBatchSize : benchOptions_.writeBatchSize;\n double iops = bandwidthMBps * 1024.0 * 1024.0 / ioSize;\n double qps = bandwidthMBps * 1024.0 * 1024.0 / (batchSize * ioSize);\n\n boost::filesystem::ofstream fout(outFilePath, std::ios_base::app);\n\n fout << fmt::format(\"{},{},{},{},{},{},{},{:.1f},{},{:.1f},{:.1f},{:.3f},{},{:.1f},{:.1f},{:.1f}\",\n testName,\n setupConfig_.num_storage_nodes(),\n setupConfig_.num_chains(),\n setupConfig_.num_replicas(),\n benchOptions_.numCoroutines,\n batchSize,\n ioSize,\n double(batchSize) / setupConfig_.num_storage_nodes(),\n elapsedMicro.count(),\n qps,\n iops,\n bandwidthMBps,\n digest.count(),\n digest.min(),\n digest.max(),\n digest.mean());\n\n for (double p : {0.5, 0.75, 0.9, 0.95, 0.99}) {\n fout << fmt::format(\",{:.1f}\", digest.estimateQuantile(p));\n }\n\n fout << \"\\n\";\n fout.close();\n }\n\n CoTask batchWrite(uint32_t instanceId, size_t writeBatchSize, size_t writeSize, uint32_t numWriteSecs) {\n // create an aligned memory block\n size_t memoryBlockSize = ALIGN_UPPER(setupConfig_.chunk_size(), benchOptions_.memoryAlignment);\n auto memoryBlock = (uint8_t *)folly::aligned_malloc(memoryBlockSize, sysconf(_SC_PAGESIZE));\n auto deleter = [](uint8_t *ptr) { folly::aligned_free(ptr); };\n std::unique_ptr memoryBlockPtr(memoryBlock, deleter);\n std::memset(memoryBlock, 0xFF, memoryBlockSize);\n\n if (benchOptions_.verifyReadData) {\n for (size_t byteIndex = 0; byteIndex < memoryBlockSize; byteIndex++) {\n memoryBlock[byteIndex] = byteIndex;\n }\n }\n\n // register a block of memory\n auto regRes = storageClient_->registerIOBuffer(memoryBlock, memoryBlockSize);\n\n if (regRes.hasError()) {\n co_return regRes.error().code();\n }\n\n // create write IOs\n\n auto ioBuffer = std::move(*regRes);\n\n WriteOptions options;\n options.set_enableChecksum(benchOptions_.verifyWriteChecksum);\n options.debug().set_bypass_disk_io(benchOptions_.benchmarkNetwork);\n options.debug().set_bypass_rdma_xmit(benchOptions_.benchmarkStorage);\n options.debug().set_inject_random_server_error(benchOptions_.injectRandomServerError);\n options.debug().set_inject_random_client_error(benchOptions_.injectRandomClientError);\n options.retry().set_retry_permanent_error(benchOptions_.retryPermanentError);\n\n std::vector elapsedMicroSecs;\n uint64_t numWriteBytes = 0;\n\n std::vector writeIOs;\n writeIOs.reserve(writeBatchSize);\n\n auto benchStart = hf3fs::SteadyClock::now();\n std::vector &chunkInfos = chunkInfos_[instanceId];\n size_t &numCreatedChunks = numCreatedChunks_[instanceId];\n size_t seqChunkIndex = 0;\n\n while (true) {\n if (numWriteSecs) {\n auto accumElapsedSecs =\n std::chrono::duration_cast(hf3fs::SteadyClock::now() - benchStart);\n if (accumElapsedSecs >= std::chrono::seconds(numWriteSecs)) break;\n } else {\n if (numCreatedChunks >= chunkInfos.size()) break;\n }\n\n writeIOs.clear();\n\n for (size_t writeIndex = 0; writeIndex < writeBatchSize; writeIndex++) {\n auto &[chainId, chunkId, chunkSize] = chunkInfos[seqChunkIndex++ % chunkInfos.size()];\n size_t writeOffset = 0;\n size_t writeLength = 0;\n\n if (chunkSize < setupConfig_.chunk_size()) {\n writeOffset = chunkSize;\n writeLength = std::min(writeSize, setupConfig_.chunk_size() - writeOffset);\n chunkSize += writeLength;\n numCreatedChunks += chunkSize == setupConfig_.chunk_size();\n } else {\n writeOffset = folly::Random::rand32(0, setupConfig_.chunk_size() - writeSize);\n writeLength = writeSize;\n }\n\n auto writeIO = storageClient_->createWriteIO(chainId,\n chunkId,\n writeOffset,\n writeLength,\n setupConfig_.chunk_size(),\n &memoryBlock[writeOffset],\n &ioBuffer);\n writeIOs.push_back(std::move(writeIO));\n numWriteBytes += writeLength;\n }\n\n auto rpcStart = hf3fs::SteadyClock::now();\n\n co_await storageClient_->batchWrite(writeIOs, flat::UserInfo(), options);\n\n auto elapsedMicro = std::chrono::duration_cast(hf3fs::SteadyClock::now() - rpcStart);\n elapsedMicroSecs.push_back(elapsedMicro.count());\n\n if (!benchOptions_.ignoreIOError) {\n for (const auto &writeIO : writeIOs) {\n if (writeIO.result.lengthInfo.hasError()) {\n XLOGF(ERR, \"Error in write result: {}\", writeIO.result);\n co_return writeIO.result.lengthInfo.error().code();\n }\n if (writeIO.length != *writeIO.result.lengthInfo) {\n XLOGF(ERR, \"Unexpected write length: {} != {}\", *writeIO.result.lengthInfo, writeIO.length);\n co_return StorageClientCode::kRemoteIOError;\n }\n }\n }\n }\n\n folly::TDigest digest;\n writeLatencyDigests_[instanceId] = digest.merge(elapsedMicroSecs);\n numWriteBytes_ += numWriteBytes;\n\n co_return StatusCode::kOK;\n }\n\n CoTask batchRead(uint32_t instanceId) {\n // create an aligned memory block\n size_t alignedBufSize = ALIGN_UPPER(std::max(size_t(1), benchOptions_.readSize), benchOptions_.memoryAlignment);\n size_t memoryBlockSize = alignedBufSize * benchOptions_.readBatchSize;\n auto memoryBlock = (uint8_t *)folly::aligned_malloc(memoryBlockSize, sysconf(_SC_PAGESIZE));\n auto deleter = [](uint8_t *ptr) { folly::aligned_free(ptr); };\n std::unique_ptr memoryBlockPtr(memoryBlock, deleter);\n std::memset(memoryBlock, 0, memoryBlockSize);\n\n // register a block of memory\n auto regRes = storageClient_->registerIOBuffer(memoryBlock, memoryBlockSize);\n\n if (regRes.hasError()) {\n co_return regRes.error().code();\n }\n\n std::vector expectedChunkData(setupConfig_.chunk_size());\n\n if (benchOptions_.verifyReadData) {\n for (size_t byteIndex = 0; byteIndex < expectedChunkData.size(); byteIndex++) {\n expectedChunkData[byteIndex] = byteIndex;\n }\n }\n\n // create read IOs\n\n auto ioBuffer = std::move(*regRes);\n\n ReadOptions options;\n options.set_enableChecksum(benchOptions_.verifyReadChecksum);\n options.debug().set_bypass_disk_io(benchOptions_.benchmarkNetwork);\n options.debug().set_bypass_rdma_xmit(benchOptions_.benchmarkStorage);\n options.debug().set_inject_random_server_error(benchOptions_.injectRandomServerError);\n options.debug().set_inject_random_client_error(benchOptions_.injectRandomClientError);\n options.retry().set_retry_permanent_error(benchOptions_.retryPermanentError);\n\n std::vector elapsedMicroSecs;\n uint64_t numReadBytes = 0;\n size_t offsetAlignment =\n benchOptions_.readOffAlignment ? benchOptions_.readOffAlignment : std::max(size_t(1), benchOptions_.readSize);\n\n std::vector readIOs;\n readIOs.reserve(benchOptions_.readBatchSize);\n\n auto benchStart = hf3fs::SteadyClock::now();\n std::vector &chunkInfos = chunkInfos_[instanceId];\n\n while (true) {\n auto accumElapsedSecs = std::chrono::duration_cast(hf3fs::SteadyClock::now() - benchStart);\n if (accumElapsedSecs >= std::chrono::seconds(benchOptions_.numReadSecs)) break;\n\n readIOs.clear();\n\n for (size_t readIndex = 0; readIndex < benchOptions_.readBatchSize; readIndex++) {\n uint64_t randChunkIndex = folly::Random::rand64(0, chunkInfos.size());\n const auto &[chainId, chunkId, chunkSize] = chunkInfos[randChunkIndex];\n uint32_t offset = folly::Random::rand32(0, setupConfig_.chunk_size() - benchOptions_.readSize);\n uint32_t alignedOffset = ALIGN_LOWER(offset, offsetAlignment);\n auto readIO = storageClient_->createReadIO(chainId,\n chunkId,\n alignedOffset /*offset*/,\n benchOptions_.readSize /*length*/,\n &memoryBlock[readIndex * alignedBufSize],\n &ioBuffer);\n readIOs.push_back(std::move(readIO));\n numReadBytes += benchOptions_.readSize;\n }\n\n auto rpcStart = hf3fs::SteadyClock::now();\n\n co_await storageClient_->batchRead(readIOs, flat::UserInfo(), options);\n\n auto elapsedMicro = std::chrono::duration_cast(hf3fs::SteadyClock::now() - rpcStart);\n elapsedMicroSecs.push_back(elapsedMicro.count());\n\n if (!benchOptions_.ignoreIOError) {\n for (const auto &readIO : readIOs) {\n if (readIO.result.lengthInfo.hasError()) {\n XLOGF(ERR, \"Error in read result: {}\", readIO.result);\n co_return readIO.result.lengthInfo.error().code();\n }\n if (readIO.length != *readIO.result.lengthInfo) {\n XLOGF(ERR, \"Unexpected read length: {} != {}\", *readIO.result.lengthInfo, readIO.length);\n co_return StorageClientCode::kRemoteIOError;\n }\n }\n }\n\n if (benchOptions_.verifyReadData) {\n for (const auto &readIO : readIOs) {\n auto diffPos = std::mismatch(&readIO.data[0], &readIO.data[readIO.length], &expectedChunkData[readIO.offset]);\n uint32_t byteIndex = diffPos.first - &readIO.data[0];\n if (byteIndex < readIO.length) {\n XLOGF(ERR,\n \"Wrong data at bytes index {} and chunk offset {}: data {:#x} != expected {:#x}\",\n byteIndex,\n readIO.offset + byteIndex,\n *diffPos.first,\n *diffPos.second);\n co_return StorageClientCode::kFoundBug;\n }\n }\n }\n }\n\n folly::TDigest digest;\n readLatencyDigests_[instanceId] = digest.merge(elapsedMicroSecs);\n numReadBytes_ += numReadBytes;\n\n co_return StatusCode::kOK;\n }\n\n uint32_t generateChunks() {\n XLOGF(WARN, \"Generating {} test chunks ({:.3f} GiB)...\", totalNumChunks_, totalChunkGiB_);\n\n auto testStart = hf3fs::SteadyClock::now();\n std::vector> writeTasks;\n numWriteBytes_ = 0;\n\n size_t writeBatchSize =\n std::max(benchOptions_.writeBatchSize,\n clientConfig_.traffic_control().write().max_concurrent_requests() / benchOptions_.numCoroutines);\n\n for (size_t instanceId = 0; instanceId < benchOptions_.numCoroutines; instanceId++) {\n writeTasks.push_back(batchWrite(instanceId, writeBatchSize, setupConfig_.chunk_size(), 0 /*numWriteSecs*/)\n .scheduleOn(folly::Executor::getKeepAliveToken(testExecutor_))\n .start());\n }\n\n auto results = folly::coro::blockingWait(folly::coro::collectAllRange(std::move(writeTasks)));\n\n for (auto res : results) {\n if (res != StatusCode::kOK) {\n XLOGF(WARN, \"Test task failed with status code: {}\", res);\n return res;\n }\n }\n\n auto elapsedTime = hf3fs::SteadyClock::now() - testStart;\n double totalGiB = (double)numWriteBytes_ / 1_GB;\n printThroughput(elapsedTime, totalGiB);\n\n auto mergedDigest = folly::TDigest::merge(writeLatencyDigests_);\n printLatencyDigest(mergedDigest);\n\n return StatusCode::kOK;\n }\n\n uint32_t runWriteBench() {\n XLOGF(WARN,\n \"Running write benchmark ({} secs, {} chunks, {:.3f} GiB)...\",\n benchOptions_.numWriteSecs,\n totalNumChunks_,\n totalChunkGiB_);\n\n auto testStart = hf3fs::SteadyClock::now();\n std::vector> writeTasks;\n numWriteBytes_ = 0;\n\n for (size_t instanceId = 0; instanceId < benchOptions_.numCoroutines; instanceId++) {\n writeTasks.push_back(\n batchWrite(instanceId, benchOptions_.writeBatchSize, benchOptions_.writeSize, benchOptions_.numWriteSecs)\n .scheduleOn(folly::Executor::getKeepAliveToken(testExecutor_))\n .start());\n }\n\n auto results = folly::coro::blockingWait(folly::coro::collectAllRange(std::move(writeTasks)));\n\n for (auto res : results) {\n if (res != StatusCode::kOK) {\n XLOGF(WARN, \"Test task failed with status code: {}\", res);\n return res;\n }\n }\n\n auto elapsedTime = hf3fs::SteadyClock::now() - testStart;\n double totalGiB = (double)numWriteBytes_ / 1_GB;\n printThroughput(elapsedTime, totalGiB);\n\n auto mergedDigest = folly::TDigest::merge(writeLatencyDigests_);\n printLatencyDigest(mergedDigest);\n\n dumpPerfStats(\"batch write\", mergedDigest, elapsedTime, totalGiB, false /*readIO*/);\n\n return StatusCode::kOK;\n }\n\n uint32_t runReadBench() {\n XLOGF(WARN, \"Running read benchmark ({} secs)...\", benchOptions_.numReadSecs);\n\n auto testStart = hf3fs::SteadyClock::now();\n std::vector> readTasks;\n numReadBytes_ = 0;\n\n for (size_t instanceId = 0; instanceId < benchOptions_.numCoroutines; instanceId++) {\n readTasks.push_back(batchRead(instanceId).scheduleOn(folly::Executor::getKeepAliveToken(testExecutor_)).start());\n }\n\n auto results = folly::coro::blockingWait(folly::coro::collectAllRange(std::move(readTasks)));\n\n for (auto res : results) {\n if (res != StatusCode::kOK) {\n XLOGF(WARN, \"Test task failed with status code: {}\", res);\n return res;\n }\n }\n\n auto elapsedTime = hf3fs::SteadyClock::now() - testStart;\n double totalGiB = (double)numReadBytes_ / 1_GB;\n printThroughput(elapsedTime, totalGiB);\n\n auto mergedDigest = folly::TDigest::merge(readLatencyDigests_);\n printLatencyDigest(mergedDigest);\n\n dumpPerfStats(\"batch read\", mergedDigest, elapsedTime, totalGiB, false /*readIO*/);\n\n return StatusCode::kOK;\n }\n\n uint32_t cleanup() {\n XLOGF(WARN, \"Clean up chunks...\");\n\n std::vector> removeTasks;\n\n for (size_t instanceId = 0; instanceId < benchOptions_.numCoroutines; instanceId++) {\n auto batchRemove = [this](size_t instanceId) -> folly::coro::Task {\n std::vector removeOps;\n size_t totalNumChunksRemoved = 0;\n\n for (const auto &[chainId, chunkId, chunkSize] : chunkInfos_[instanceId]) {\n removeOps.push_back(storageClient_->createRemoveOp(chainId, chunkId, ChunkId(chunkId, 1)));\n\n if (removeOps.size() >= benchOptions_.removeBatchSize) {\n WriteOptions options;\n options.debug().set_inject_random_server_error(benchOptions_.injectRandomServerError);\n options.debug().set_inject_random_client_error(benchOptions_.injectRandomClientError);\n options.retry().set_retry_permanent_error(benchOptions_.retryPermanentError);\n\n co_await storageClient_->removeChunks(removeOps, flat::UserInfo(), options);\n\n for (const auto &removeOp : removeOps) {\n if (removeOp.result.statusCode.hasError()) {\n XLOGF(WARN, \"Remove operation failed with error: {}\", removeOp.result.statusCode.error());\n co_return removeOp.result.statusCode.error().code();\n }\n\n XLOGF_IF(DBG5,\n removeOp.result.numChunksRemoved != 1,\n \"{} chunks removed in range {}\",\n removeOp.result.numChunksRemoved,\n removeOp.chunkRange());\n totalNumChunksRemoved += removeOp.result.numChunksRemoved;\n }\n\n removeOps.clear();\n }\n }\n\n XLOGF(WARN, \"{} chunks removed by instance #{}\", totalNumChunksRemoved, instanceId);\n co_return StatusCode::kOK;\n };\n\n removeTasks.push_back(\n batchRemove(instanceId).scheduleOn(folly::Executor::getKeepAliveToken(testExecutor_)).start());\n }\n\n auto results = folly::coro::blockingWait(folly::coro::collectAllRange(std::move(removeTasks)));\n\n for (auto res : results) {\n if (res != StatusCode::kOK) {\n XLOGF(WARN, \"Test task failed with status code: {}\", res);\n return res;\n }\n }\n\n return StatusCode::kOK;\n };\n\n uint32_t truncate() {\n XLOGF(WARN, \"Truncate chunks...\");\n\n std::vector> truncateTasks;\n\n for (size_t instanceId = 0; instanceId < benchOptions_.numCoroutines; instanceId++) {\n auto batchTruncate = [this](size_t instanceId) -> folly::coro::Task {\n std::vector truncateOps;\n\n for (const auto &[chainId, chunkId, chunkSize] : chunkInfos_[instanceId]) {\n truncateOps.push_back(storageClient_->createTruncateOp(chainId, chunkId, 0, setupConfig_.chunk_size()));\n\n if (truncateOps.size() >= benchOptions_.writeBatchSize) {\n WriteOptions options;\n options.debug().set_inject_random_server_error(benchOptions_.injectRandomServerError);\n options.debug().set_inject_random_client_error(benchOptions_.injectRandomClientError);\n options.retry().set_retry_permanent_error(benchOptions_.retryPermanentError);\n\n co_await storageClient_->truncateChunks(truncateOps, flat::UserInfo(), options);\n\n for (const auto &truncateOp : truncateOps) {\n if (truncateOp.result.lengthInfo.hasError()) {\n XLOGF(WARN, \"Truncate operation failed with error: {}\", truncateOp.result.lengthInfo.error());\n co_return truncateOp.result.lengthInfo.error().code();\n }\n }\n\n truncateOps.clear();\n }\n }\n\n co_return StatusCode::kOK;\n };\n\n truncateTasks.push_back(\n batchTruncate(instanceId).scheduleOn(folly::Executor::getKeepAliveToken(testExecutor_)).start());\n }\n\n auto results = folly::coro::blockingWait(folly::coro::collectAllRange(std::move(truncateTasks)));\n\n for (auto res : results) {\n if (res != StatusCode::kOK) {\n XLOGF(WARN, \"Test task failed with status code: {}\", res);\n return res;\n }\n }\n\n return StatusCode::kOK;\n };\n\n bool run() {\n if (benchOptions_.numWriteSecs > 0)\n if (runWriteBench() != StatusCode::kOK) return false;\n if (benchOptions_.generateTestData)\n if (generateChunks() != StatusCode::kOK) return false;\n if (benchOptions_.numReadSecs > 0)\n if (runReadBench() != StatusCode::kOK) return false;\n return true;\n }\n\n uint64_t getWriteBytes() { return numWriteBytes_; }\n\n uint64_t getReadBytes() { return numReadBytes_; }\n};\n\n} // namespace hf3fs::storage::benchmark\n"], ["/3FS/src/storage/update/UpdateJob.h", "#pragma once\n\n#include \n\n#include \"chunk_engine/src/cxx.rs.h\"\n#include \"fbs/storage/Common.h\"\n#include \"storage/store/ChunkMetadata.h\"\n#include \"storage/store/ChunkStore.h\"\n\nnamespace hf3fs::storage {\n\nclass StorageTarget;\n\nclass ChunkEngineUpdateJob {\n public:\n ChunkEngineUpdateJob() = default;\n ChunkEngineUpdateJob(const ChunkEngineUpdateJob &) = delete;\n ChunkEngineUpdateJob(ChunkEngineUpdateJob &&other)\n : engine_(std::exchange(other.engine_, nullptr)),\n chunk_(std::exchange(other.chunk_, nullptr)) {}\n\n void set(chunk_engine::Engine &engine, chunk_engine::WritingChunk *chunk) {\n reset();\n engine_ = &engine;\n chunk_ = chunk;\n }\n\n auto release() { return std::exchange(engine_, nullptr); }\n auto chunk() const { return chunk_; }\n\n void reset() {\n if (engine_ && chunk_) {\n release()->release_writing_chunk(chunk_);\n }\n }\n\n ~ChunkEngineUpdateJob() { reset(); }\n\n private:\n chunk_engine::Engine *engine_{};\n chunk_engine::WritingChunk *chunk_{};\n};\n\nclass UpdateJob {\n public:\n UpdateJob(ServiceRequestContext &requestCtx,\n const UpdateIO &updateIO,\n const UpdateOptions &options,\n ChunkEngineUpdateJob &chunkEngineJob,\n std::shared_ptr target,\n bool allowToAllocate = true)\n : requestCtx_(requestCtx),\n type_(updateIO.updateType),\n chunkId_(updateIO.key.chunkId),\n target_(std::move(target)),\n updateIO_(updateIO),\n chunkEngineJob_(chunkEngineJob),\n options_(options),\n allowToAllocate_(allowToAllocate) {}\n\n UpdateJob(ServiceRequestContext &requestCtx,\n const CommitIO &commitIO,\n const UpdateOptions &options,\n ChunkEngineUpdateJob &chunkEngineJob,\n std::shared_ptr target)\n : requestCtx_(requestCtx),\n type_(UpdateType::COMMIT),\n chunkId_(commitIO.key.chunkId),\n target_(std::move(target)),\n commitIO_(commitIO),\n chunkEngineJob_(chunkEngineJob),\n options_(options) {}\n\n auto &requestCtx() { return requestCtx_; }\n auto type() const { return type_; }\n const auto &chunkId() const { return chunkId_; }\n auto &target() const { return target_; }\n auto &updateIO() { return updateIO_; }\n auto &commitIO() { return commitIO_; }\n auto &chunkEngineJob() { return chunkEngineJob_; }\n auto &options() { return options_; }\n auto &result() { return result_; }\n auto &state() { return state_; }\n auto allowToAllocate() const { return allowToAllocate_; }\n ChainVer commitChainVer() const {\n if (options_.isSyncing) {\n return options_.commitChainVer;\n } else if (type() == UpdateType::COMMIT) {\n return commitIO_.commitChainVer;\n } else {\n return updateIO_.key.vChainId.chainVer;\n }\n }\n\n CoTask complete() const { co_await baton_; }\n void setResult(Result result) {\n result_.lengthInfo = std::move(result);\n baton_.post();\n }\n\n protected:\n ServiceRequestContext &requestCtx_;\n UpdateType type_;\n ChunkId chunkId_;\n std::shared_ptr target_;\n UpdateIO updateIO_;\n CommitIO commitIO_;\n ChunkEngineUpdateJob &chunkEngineJob_;\n UpdateOptions options_;\n IOResult result_;\n folly::coro::Baton baton_;\n struct State {\n const uint8_t *data = nullptr;\n } state_;\n bool allowToAllocate_ = true;\n};\n\n} // namespace hf3fs::storage\n"], ["/3FS/src/fbs/meta/Utils.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/app/NodeId.h\"\n#include \"common/monitor/Recorder.h\"\n#include \"common/monitor/Sample.h\"\n#include \"common/serde/Serde.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/MurmurHash3.h\"\n#include \"common/utils/Reflection.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/SerDeser.h\"\n#include \"common/utils/Status.h\"\n#include \"common/utils/StatusCode.h\"\n#include \"common/utils/TypeTraits.h\"\n#include \"common/utils/Uuid.h\"\n#include \"fbs/core/user/User.h\"\n#include \"fbs/meta/Common.h\"\n#include \"fbs/meta/Schema.h\"\n#include \"fbs/meta/Service.h\"\n#include \"fbs/mgmtd/ChainRef.h\"\n#include \"fbs/mgmtd/RoutingInfo.h\"\n#include \"fmt/core.h\"\n\nnamespace hf3fs::meta {\n\nstruct ErrorHandling {\n static bool success(const auto &result) { return !result.hasError() || success(result.error()); }\n\n // The operation was performed successfully, or an expected error code was returned\n static bool success(const Status &status) {\n auto code = status.code();\n switch (StatusCode::typeOf(code)) {\n case StatusCodeType::Common:\n switch (code) {\n case StatusCode::kOK:\n case StatusCode::kInvalidArg:\n case StatusCode::kAuthenticationFail:\n return true;\n default:\n return false;\n }\n case StatusCodeType::Meta:\n switch (code) {\n case MetaCode::kNotFound:\n case MetaCode::kNotEmpty:\n case MetaCode::kNotDirectory:\n case MetaCode::kTooManySymlinks:\n case MetaCode::kIsDirectory:\n case MetaCode::kExists:\n case MetaCode::kNoPermission:\n case MetaCode::kNotFile:\n case MetaCode::kInvalidFileLayout:\n case MetaCode::kMoreChunksToRemove:\n case MetaCode::kNameTooLong:\n return true;\n default:\n return (code >= MetaCode::kExpected && code < MetaCode::kRetryable);\n }\n default:\n return false;\n }\n }\n\n static bool retryable(const Status &status) {\n auto code = status.code();\n switch (StatusCode::typeOf(code)) {\n case StatusCodeType::Common:\n return false;\n case StatusCodeType::Meta:\n switch (code) {\n case MetaCode::kNotFound:\n case MetaCode::kNotEmpty:\n case MetaCode::kNotDirectory:\n case MetaCode::kTooManySymlinks:\n case MetaCode::kIsDirectory:\n case MetaCode::kExists:\n case MetaCode::kNoPermission:\n case MetaCode::kInconsistent:\n case MetaCode::kNotFile:\n case MetaCode::kBadFileSystem:\n case MetaCode::kInvalidFileLayout:\n case MetaCode::kFileHasHole:\n case MetaCode::kNameTooLong:\n case MetaCode::kRequestCanceled:\n case MetaCode::kFoundBug:\n return false;\n case MetaCode::kOTruncFailed:\n case MetaCode::kMoreChunksToRemove:\n case MetaCode::kBusy:\n case MetaCode::kInodeIdAllocFailed:\n return true;\n default:\n return code < MetaCode::kNotRetryable;\n }\n case StatusCodeType::StorageClient:\n switch (code) {\n case StorageClientCode::kChunkNotFound:\n case StorageClientCode::kChecksumMismatch:\n case StorageClientCode::kReadOnlyServer:\n case StorageClientCode::kFoundBug:\n return false;\n default:\n return true;\n }\n default:\n return code != RPCCode::kInvalidMethodID;\n }\n }\n\n static bool serverError(const Status &status) {\n switch (StatusCode::typeOf(status.code())) {\n case StatusCodeType::Transaction:\n return status.code() == TransactionCode::kNetworkError;\n case StatusCodeType::RPC:\n return true;\n default:\n return false;\n }\n }\n\n static bool needPruneSession(const Status &error) {\n auto code = error.code();\n switch (StatusCode::typeOf(code)) {\n case StatusCodeType::Transaction:\n return code == TransactionCode::kMaybeCommitted;\n case StatusCodeType::Meta:\n return code == MetaCode::kOTruncFailed;\n case StatusCodeType::RPC:\n switch (code) {\n case RPCCode::kSendFailed:\n case RPCCode::kConnectFailed:\n case RPCCode::kIBInitFailed:\n case RPCCode::kInvalidMethodID:\n return false;\n default:\n return true;\n }\n default:\n return false;\n }\n }\n};\n\nclass OperationRecorder {\n public:\n OperationRecorder(std::string_view prefix)\n : total_(fmt::format(\"{}_total\", prefix)),\n failed_(fmt::format(\"{}_failed\", prefix)),\n running_(fmt::format(\"{}_running\", prefix), false),\n code_(fmt::format(\"{}_code\", prefix)),\n latency_(fmt::format(\"{}_latency\", prefix)),\n retry_(fmt::format(\"{}_retry\", prefix)),\n idempotent_(fmt::format(\"{}_idempotent\", prefix)),\n duplicate_(fmt::format(\"{}_duplicate\", prefix)) {}\n\n static OperationRecorder &server() {\n static OperationRecorder recorder(\"meta_server.op\");\n return recorder;\n }\n\n static OperationRecorder &client() {\n static OperationRecorder recorder(\"meta_client.op\");\n return recorder;\n }\n\n class Guard {\n public:\n Guard(OperationRecorder &recorder, std::string_view op, flat::Uid user)\n : recorder_(recorder),\n op_(\"instance\", std::string(op)),\n user_(\"uid\", folly::to((int32_t)user.toUnderType())),\n begin_(RelativeTime::now()) {\n begin_ = RelativeTime::now();\n recorder_.running_.addSample(1, {{op_}});\n }\n\n ~Guard() {\n auto op = monitor::TagSet{op_};\n auto opUser = monitor::TagSet{{op_, user_}};\n auto latency = RelativeTime::now() - begin_;\n recorder_.total_.addSample(1, opUser);\n if (!succ_) {\n recorder_.failed_.addSample(1, opUser);\n recorder_.code_.addSample(1, {{\"tag\", folly::to(code_.value_or(0))}, user_});\n } else {\n if (code_) {\n recorder_.code_.addSample(1, {{\"tag\", folly::to(*code_)}, user_});\n }\n }\n recorder_.running_.addSample(-1, op);\n recorder_.latency_.addSample(latency, op);\n recorder_.retry_.addSample(retry_, op);\n if (duplicate_) {\n recorder_.duplicate_.addSample(1, op);\n }\n }\n\n void finish(const auto &result, bool duplicate = false) {\n duplicate_ = duplicate;\n succ_ = ErrorHandling::success(result);\n code_ = result.hasError() ? result.error().code() : 0;\n }\n\n void finish(const Status &status, bool duplicate = false) {\n duplicate_ = duplicate;\n succ_ = ErrorHandling::success(status) || status.code() == MetaCode::kRequestCanceled;\n code_ = status.code();\n }\n\n int &retry() { return retry_; }\n\n private:\n using Tag = std::pair;\n OperationRecorder &recorder_;\n Tag op_;\n Tag user_;\n RelativeTime begin_;\n std::optional code_;\n bool succ_ = false;\n int retry_ = 1;\n bool duplicate_ = false;\n };\n\n void addIdempotentCount() { idempotent_.addSample(1); }\n\n private:\n monitor::CountRecorder total_;\n monitor::CountRecorder failed_;\n monitor::CountRecorder running_;\n monitor::CountRecorder code_;\n monitor::LatencyRecorder latency_;\n monitor::DistributionRecorder retry_;\n monitor::CountRecorder idempotent_;\n monitor::CountRecorder duplicate_;\n};\n\nstruct Weight : std::array {\n static Weight calculate(flat::NodeId node, InodeId inodeId) {\n // Note: don't change this\n auto key = Serializer::serRawArgs((uint64_t)node.toUnderType(), inodeId.u64());\n return hash(key.data(), key.size());\n }\n\n static flat::NodeId select(const std::vector &nodes, InodeId inodeId) {\n return selectImpl(nodes, inodeId);\n }\n\n static Weight calculate(flat::NodeId node, Uuid clientId) {\n // todo: maybe should change to client host name?\n auto key = Serializer::serRawArgs((uint64_t)node.toUnderType(), clientId.data);\n return hash(key.data(), key.size());\n }\n\n static flat::NodeId select(const std::vector &nodes, Uuid clientId) {\n return selectImpl(nodes, clientId);\n }\n\n private:\n static Weight hash(void *key, size_t len) {\n // NOTE: don't change this\n Weight w;\n MurmurHash3_x64_128(key, len, 0, &w);\n return w;\n }\n\n static flat::NodeId selectImpl(const std::vector &nodes, auto &key) {\n if (nodes.empty()) {\n return flat::NodeId(0); // flat::NodeId(0) is invalid\n }\n\n auto node = nodes.at(0);\n auto weight = calculate(node, key);\n for (size_t i = 1; i < nodes.size(); i++) {\n auto n = nodes.at(i);\n auto w = calculate(n, key);\n if (w > weight) {\n node = n;\n weight = w;\n }\n }\n return node;\n }\n};\nstatic_assert(sizeof(Weight) == 16);\n\nstruct RoutingInfoChecker {\n template \n static constexpr bool hasInode() {\n return false;\n }\n\n template \n requires serde::SerdeType\n static constexpr bool hasInode() {\n if constexpr (std::is_same_v) {\n return true;\n }\n bool inode = false;\n refl::Helper::iterate([&](auto info) {\n using Item = std::remove_reference_t().*info.getter)>;\n inode |= hasInode();\n });\n return inode;\n }\n\n template \n requires is_variant_v\n static constexpr bool hasInode() { return variantHasInode(); }\n\n template \n static constexpr bool variantHasInode() {\n if constexpr (I < std::variant_size_v) {\n if constexpr (hasInode>()) {\n return true;\n }\n return variantHasInode();\n }\n return false;\n }\n\n template \n requires is_vector_v || is_set_v\n static constexpr bool hasInode() { return hasInode(); }\n\n template \n requires is_map_v\n static constexpr bool hasInode() { return hasInode() || hasInode(); }\n\n template \n requires is_optional_v\n static constexpr bool hasInode() { return hasInode(); }\n\n static bool checkRoutingInfo(const Inode &inode, const flat::RoutingInfo &routing) {\n if (inode.isFile()) {\n auto table = inode.asFile().layout.tableId;\n auto tableVer = inode.asFile().layout.tableVersion;\n switch (inode.asFile().layout.type()) {\n case Layout::Type::ChainRange:\n XLOGF_IF(DFATAL, (!table || !tableVer), \"File {}, invalid layout\", inode);\n if (!routing.getChainTable(table, tableVer)) {\n XLOGF(WARN, \"File {}, chain table {} version {}, not found in RoutingInfo\", inode.id, table, tableVer);\n return false;\n }\n break;\n case Layout::Type::ChainList:\n if (table && tableVer && !routing.getChainTable(table, tableVer)) {\n XLOGF(WARN, \"File {}, chain table {} version {}, not found in RoutingInfo\", inode.id, table, tableVer);\n return false;\n }\n break;\n case Layout::Type::Empty:\n break;\n }\n }\n return true;\n }\n\n template \n static bool checkRoutingInfo(const T &, const flat::RoutingInfo &) {\n return true;\n }\n\n template \n requires serde::SerdeType\n static bool checkRoutingInfo(const T &t, const flat::RoutingInfo &routing) {\n if constexpr (!hasInode()) {\n return true;\n }\n\n bool succ = true;\n refl::Helper::iterate([&](auto info) { succ &= checkRoutingInfo(t.*info.getter, routing); });\n return succ;\n }\n\n template \n requires is_variant_v\n static bool checkRoutingInfo(const T &t, const flat::RoutingInfo &routing) {\n if constexpr (!hasInode()) {\n return true;\n }\n return std::visit([&](const auto &v) { return checkRoutingInfo(v, routing); }, t);\n }\n\n template \n requires is_vector_v || is_set_v\n static bool checkRoutingInfo(const T &t, const flat::RoutingInfo &routing) {\n if constexpr (!hasInode()) {\n return true;\n }\n for (auto &i : t) {\n if (!checkRoutingInfo(i, routing)) {\n return false;\n }\n }\n return true;\n }\n\n template \n requires is_map_v\n static bool checkRoutingInfo(const T &t, const flat::RoutingInfo &routing) {\n if constexpr (!hasInode()) {\n return true;\n }\n for (auto &[k, v] : t) {\n if (!checkRoutingInfo(k, routing) || !checkRoutingInfo(v, routing)) {\n return false;\n }\n }\n return true;\n }\n\n template \n requires is_optional_v\n static bool checkRoutingInfo(const T &t, const flat::RoutingInfo &routing) {\n if constexpr (!hasInode()) {\n return true;\n }\n return t ? checkRoutingInfo(*t, routing) : true;\n }\n};\n\nstatic_assert(RoutingInfoChecker::hasInode());\nstatic_assert(RoutingInfoChecker::hasInode>());\nstatic_assert(RoutingInfoChecker::hasInode>());\nstatic_assert(RoutingInfoChecker::hasInode>());\nstatic_assert(RoutingInfoChecker::hasInode>());\nstatic_assert(RoutingInfoChecker::hasInode>());\nstatic_assert(RoutingInfoChecker::hasInode());\nstatic_assert(RoutingInfoChecker::hasInode());\nstatic_assert(RoutingInfoChecker::hasInode());\nstatic_assert(RoutingInfoChecker::hasInode());\nstatic_assert(RoutingInfoChecker::hasInode());\n} // namespace hf3fs::meta\n"], ["/3FS/src/common/utils/LruCache.h", "#pragma once\n\n#include \n\n#include \"common/utils/RobinHood.h\"\n\nnamespace hf3fs {\n\ntemplate \nclass LruCache {\n public:\n using key_type = K;\n using mapped_type = V;\n using value_type = std::pair;\n using list_type = std::list;\n using size_type = typename list_type::size_type;\n using iterator = typename list_type::iterator;\n using const_iterator = typename list_type::const_iterator;\n\n public:\n LruCache(size_t capacity, bool autoRemove = true)\n : capacity_(capacity),\n autoRemove_(autoRemove) {}\n\n iterator begin() { return least_.begin(); }\n const_iterator begin() const { return least_.begin(); }\n iterator end() { return least_.end(); }\n const_iterator end() const { return least_.end(); }\n bool empty() const { return least_.empty(); }\n size_t size() const { return least_.size(); }\n value_type &front() { return least_.front(); }\n const value_type &front() const { return least_.front(); }\n value_type &back() { return least_.back(); }\n const value_type &back() const { return least_.back(); }\n size_t getMaxSize() const { return capacity_; }\n void setMaxSize(size_t capacity) { capacity_ = capacity; }\n void clear() { used_.clear(), least_.clear(); }\n\n iterator find(const key_type &key) {\n auto it = used_.find(key);\n if (it == used_.end()) {\n return end();\n }\n return it->second;\n }\n const_iterator find(const key_type &key) const {\n auto it = used_.find(key);\n if (it == used_.end()) {\n return end();\n }\n return it->second;\n }\n\n void promote(const_iterator it) { least_.splice(least_.begin(), least_, it); }\n void obsolete(const_iterator it) { least_.splice(least_.end(), least_, it); }\n\n iterator erase(const key_type &key) {\n auto it = used_.find(key);\n if (it != used_.end()) {\n return erase(it->second);\n }\n return end();\n }\n iterator erase(const_iterator it) {\n used_.erase(it->first);\n return least_.erase(it);\n }\n\n size_t evictObsoleted() {\n if (least_.size() <= capacity_) {\n return 0;\n }\n auto evictingSize = least_.size() - capacity_;\n for (size_t i = 0; i < evictingSize; ++i) {\n used_.erase(back().first);\n least_.pop_back();\n }\n return evictingSize;\n }\n template \n size_t evictObsoletedIf(Predicate &&p) {\n if (least_.size() <= capacity_) {\n return 0;\n }\n auto evictingSize = least_.size() - capacity_;\n for (size_t i = 0; i < evictingSize && p(back().first, back().second); ++i) {\n used_.erase(back().first);\n least_.pop_back();\n }\n\n return evictingSize;\n }\n\n template \n std::pair emplace(const key_type &key, T &&value) {\n auto [it, succ] = used_.emplace(key, iterator{});\n if (succ) {\n least_.emplace_front(key, std::forward(value));\n it->second = least_.begin();\n if (autoRemove_) {\n evictObsoleted();\n }\n } else {\n promote(it->second);\n }\n return std::make_pair(it->second, succ);\n }\n\n mapped_type &operator[](const key_type &key) { return emplace(key, mapped_type{}).first->second; }\n\n private:\n size_t capacity_;\n bool autoRemove_;\n list_type least_;\n robin_hood::unordered_map used_;\n};\n\n} // namespace hf3fs\n"], ["/3FS/src/common/serde/Serde.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/net/Allocator.h\"\n#include \"common/serde/TypeName.h\"\n#include \"common/utils/DownwardBytes.h\"\n#include \"common/utils/MagicEnum.hpp\"\n#include \"common/utils/NameWrapper.h\"\n#include \"common/utils/Path.h\"\n#include \"common/utils/Reflection.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/Thief.h\"\n#include \"common/utils/TypeTraits.h\"\n#include \"common/utils/Varint32.h\"\n#include \"common/utils/Varint64.h\"\n\n#define SERDE_CLASS_TYPED_FIELD(TYPE, NAME, DEFAULT, ...) \\\n private: \\\n friend struct ::hf3fs::refl::Helper; \\\n struct T##NAME : std::type_identity {}; \\\n TYPE NAME##_ = DEFAULT; \\\n \\\n public: \\\n auto &NAME() { return NAME##_; } \\\n const auto &NAME() const { return NAME##_; } \\\n \\\n protected: \\\n constexpr auto T##NAME()->::hf3fs::thief::steal>; \\\n REFL_ADD_SAFE( \\\n (::hf3fs::serde::FieldInfo<#NAME, \\\n &::hf3fs::thief::retrieve::NAME##_ __VA_OPT__(, __VA_ARGS__)>{}), \\\n typename T##NAME::type)\n\n#define SERDE_STRUCT_TYPED_FIELD(TYPE, NAME, DEFAULT, ...) \\\n private: \\\n friend struct ::hf3fs::refl::Helper; \\\n struct T##NAME : std::type_identity {}; \\\n \\\n public: \\\n TYPE NAME = DEFAULT; \\\n \\\n protected: \\\n constexpr auto T##NAME()->::hf3fs::thief::steal>; \\\n REFL_ADD_SAFE( \\\n (::hf3fs::serde::FieldInfo<#NAME, &::hf3fs::thief::retrieve::NAME __VA_OPT__(, __VA_ARGS__)>{}), \\\n typename T##NAME::type)\n\n#define SERDE_CLASS_FIELD(NAME, DEFAULT, ...) \\\n SERDE_CLASS_TYPED_FIELD(std::decay_t, NAME, DEFAULT __VA_OPT__(, __VA_ARGS__))\n\n#define SERDE_STRUCT_FIELD(NAME, DEFAULT, ...) \\\n SERDE_STRUCT_TYPED_FIELD(std::decay_t, NAME, DEFAULT __VA_OPT__(, __VA_ARGS__))\n\nnamespace hf3fs::serde {\n\ntemplate \nstruct FieldInfo {\n static constexpr std::string_view name = Name;\n static constexpr auto getter = Getter;\n static constexpr auto checker = Checker;\n};\n\ntemplate \nconstexpr inline std::true_type is_field_info(FieldInfo);\ntemplate \nconstexpr inline bool is_field_infos = false;\ntemplate \nconstexpr inline bool is_field_infos> = (requires { is_field_info(std::declval()); } && ...);\n\ntemplate \nconcept SerdeType = bool(refl::Helper::Size) && is_field_infos>;\n\ntemplate \nconcept SerdeCopyable =\n std::is_same_v || std::is_integral_v || std::is_floating_point_v || std::is_enum_v || requires {\n typename T::is_serde_copyable;\n};\n\ntemplate \nconstexpr inline auto count() {\n return refl::Helper::Size;\n}\ntemplate \nconstexpr inline auto name() {\n return refl::Helper::FieldInfo::name;\n}\ntemplate \nconstexpr inline auto getter() {\n return refl::Helper::FieldInfo::getter;\n}\nconstexpr inline auto count(auto &&o) { return count>(); }\ntemplate \nconstexpr inline auto name(auto &&o) {\n return name, Index>();\n}\ntemplate \nconstexpr inline auto &value(auto &&o) {\n return o.*getter, Index>();\n}\n\ntemplate \nconstexpr inline auto iterate(auto &&f, auto &&o, auto &&...args) {\n return refl::Helper::iterate>(\n [&](auto type) { return f(type.name, o.*type.getter, args...); });\n}\n\ntemplate \nstruct SerdeMethod {\n static auto serialize(const T &o, auto &out) = delete;\n static auto serializeReadable(const T &o, auto &out) = delete;\n static auto deserialize(T &o, auto &in) = delete;\n static Result deserializeReadable(T &o, auto &out) = delete;\n\n static auto serdeTo(const T &t) = delete;\n static auto serdeToReadable(const T &o) = delete;\n static Result serdeFrom(auto) = delete;\n static Result serdeFromReadable(auto) = delete;\n};\n\ntemplate \nstruct DefaultConstructor {\n static T construct() { return T{}; }\n};\n\ntemplate <>\nstruct DefaultConstructor {\n static Status construct() { return Status::OK; }\n};\n\ntemplate \nstruct DefaultConstructor> {\n static Result construct() { return T{}; }\n};\n} // namespace hf3fs::serde\n\ntemplate <>\nstruct hf3fs::serde::SerdeMethod {\n static auto serialize(const Varint32 &o, auto &out) {\n constexpr int B = 128;\n uint8_t buf[5];\n auto ptr = buf;\n if (o < (1 << 7)) {\n *(ptr++) = o;\n } else if (o < (1 << 14)) {\n *(ptr++) = o | B;\n *(ptr++) = o >> 7;\n } else if (o < (1 << 21)) {\n *(ptr++) = o | B;\n *(ptr++) = (o >> 7) | B;\n *(ptr++) = o >> 14;\n } else if (o < (1 << 28)) {\n *(ptr++) = o | B;\n *(ptr++) = (o >> 7) | B;\n *(ptr++) = (o >> 14) | B;\n *(ptr++) = o >> 21;\n } else {\n *(ptr++) = o | B;\n *(ptr++) = (o >> 7) | B;\n *(ptr++) = (o >> 14) | B;\n *(ptr++) = (o >> 21) | B;\n *(ptr++) = o >> 28;\n }\n out.append(buf, ptr - buf);\n }\n\n static Result deserialize(Varint32 &o, auto &in) {\n o.value = 0;\n for (uint32_t shift = 0; shift <= 28 && !in.str().empty(); shift += 7) {\n uint32_t byte = static_cast(in.str()[0]);\n in.str().remove_prefix(1);\n if (byte & 128) {\n // More bytes are present\n o.value |= ((byte & 127) << shift);\n } else {\n o.value |= (byte << shift);\n return Void{};\n }\n }\n return makeError(StatusCode::kSerdeInsufficientLength, fmt::format(\"varint32 is short\"));\n }\n\n static uint32_t serdeToReadable(Varint32 o) { return o; }\n};\n\ntemplate <>\nstruct hf3fs::serde::SerdeMethod {\n static auto serialize(const Varint64 &o, auto &out) {\n static const int B = 128;\n uint8_t buf[10];\n auto ptr = reinterpret_cast(buf);\n\n uint64_t v = o;\n while (v >= B) {\n *(ptr++) = o | B;\n v >>= 7;\n }\n *(ptr++) = static_cast(v);\n out.append(buf, ptr - buf);\n }\n\n static Result deserialize(Varint64 &o, auto &in) {\n o.value = 0;\n for (uint32_t shift = 0; shift <= 63 && !in.str().empty(); shift += 7) {\n uint64_t byte = static_cast(in.str()[0]);\n in.str().remove_prefix(1);\n if (byte & 128) {\n // More bytes are present\n o.value |= ((byte & 127) << shift);\n } else {\n o.value |= (byte << shift);\n return Void{};\n }\n }\n return makeError(StatusCode::kSerdeInsufficientLength, fmt::format(\"varint64 is short\"));\n }\n\n static uint64_t serdeToReadable(Varint64 o) { return o; }\n};\n\nnamespace hf3fs::serde {\n\nenum class Optional : uint8_t { NullOpt, HasValue };\nstruct VariantIndex {\n uint8_t index;\n};\n\ntemplate \nclass Out {\n public:\n auto tableBegin(bool isInline); // begin a table.\n void tableEnd(auto); // end a table.\n void arrayBegin(); // begin an array.\n void arrayEnd(uint32_t size); // end an array.\n void key(std::string_view key); // prepare the key in a key-value pair.\n void value(auto &&value); // prepare the value in a key-value pair or an array.\n};\n\ntemplate \nclass In {\n public:\n auto parseKey(std::string_view);\n auto parseTable();\n\n // for binary.\n Result parseCopyable(auto &o);\n\n // for Json/Toml.\n Result parseBoolean();\n Result parseInteger();\n Result parseFloat();\n\n // for both.\n Result parseString();\n Result parseOptional(Optional &optional);\n Result> parseVariant();\n};\n\ntemplate \ninline void serialize(auto &&o, Out &out) {\n using T = std::decay_t;\n constexpr bool isBinaryOut = requires { typename Out::is_binary_out; };\n if constexpr (requires { o.serdeToReadable(); } && !isBinaryOut) {\n serialize(o.serdeToReadable(), out);\n } else if constexpr (requires { SerdeMethod::serializeReadable(o, out); } && !isBinaryOut) {\n SerdeMethod::serializeReadable(o, out);\n } else if constexpr (requires { SerdeMethod::serdeToReadable(o); } && !isBinaryOut) {\n serialize(SerdeMethod::serdeToReadable(o), out);\n } else if constexpr (requires { SerdeMethod::serialize(o, out); }) {\n static_assert(requires(T t, In in) { Result{SerdeMethod::deserialize(t, in)}; });\n SerdeMethod::serialize(o, out);\n } else if constexpr (requires { SerdeMethod::serdeTo(o); }) {\n static_assert(requires { SerdeMethod::serdeFrom(SerdeMethod::serdeTo(o)); });\n serialize(SerdeMethod::serdeTo(o), out);\n } else if constexpr (SerdeType) {\n auto start = out.tableBegin(false);\n if constexpr (isBinaryOut) {\n refl::Helper::iterate([&](auto type) { serialize(o.*type.getter, out); },\n [&] { out.tableEnd(start), start = out.tableBegin(false); });\n } else {\n refl::Helper::iterate([&](auto type) { out.key(type.name), serialize(o.*type.getter, out); });\n }\n out.tableEnd(start);\n } else if constexpr (std::is_same_v) {\n out.value(o);\n } else if constexpr (std::is_convertible_v) {\n out.value(std::string_view(o));\n } else if constexpr (is_optional_v) {\n if (o.has_value()) {\n serialize(o.value(), out);\n out.value(Optional::HasValue);\n } else {\n out.value(Optional::NullOpt);\n }\n } else if constexpr (is_unique_ptr_v || is_shared_ptr_v) {\n if (o) {\n serialize(*o, out);\n out.value(Optional::HasValue);\n } else {\n out.value(Optional::NullOpt);\n }\n } else if constexpr (is_variant_v && isBinaryOut) {\n static_assert(std::variant_size_v <= std::numeric_limits::max());\n std::visit(\n [&out](auto &&v) {\n serialize(v, out);\n serialize(type_name_v>, out);\n },\n o);\n } else if constexpr (is_variant_v) {\n static_assert(std::variant_size_v <= std::numeric_limits::max());\n auto start = out.tableBegin(true);\n out.key(\"type\");\n std::visit(\n [&out](auto &&v) {\n serialize(type_name_v>, out);\n out.key(\"value\");\n serialize(v, out);\n },\n o);\n out.tableEnd(start);\n } else if constexpr (is_generic_pair_v && isBinaryOut) {\n serialize(o.second, out);\n serialize(o.first, out);\n } else if constexpr (Container && isBinaryOut) {\n out.arrayBegin();\n if constexpr (requires { o.rbegin(); }) {\n for (auto it = o.rbegin(); it != o.rend(); ++it) {\n serialize(*it, out);\n }\n } else {\n for (auto &item : o) {\n serialize(item, out);\n }\n }\n out.arrayEnd(o.size());\n } else if constexpr (is_vector_v && std::is_arithmetic_v && isBinaryOut) {\n out.value(o);\n } else if constexpr (is_vector_v || is_set_v) {\n out.arrayBegin();\n for (const auto &item : o) {\n serialize(item, out);\n }\n out.arrayEnd(o.size());\n } else if constexpr (is_map_v) {\n auto start = out.tableBegin(true);\n for (const auto &pair : o) {\n if constexpr (requires { out.key(pair.first); }) {\n out.key(pair.first);\n } else if constexpr (requires { pair.first.toUnderType(); }) {\n out.key(fmt::format(\"{}\", pair.first.toUnderType()));\n } else {\n out.key(fmt::format(\"{}\", pair.first));\n }\n serialize(pair.second, out);\n }\n out.tableEnd(start);\n } else if constexpr (isBinaryOut && SerdeCopyable) {\n out.value(o);\n } else if constexpr (std::is_same_v) {\n out.value(o);\n } else if constexpr (std::is_integral_v) {\n out.value(int64_t(o));\n } else if constexpr (std::is_floating_point_v) {\n out.value(double(o));\n } else if constexpr (std::is_enum_v) {\n out.value(magic_enum::enum_name(o));\n } else {\n return notSupportToSerialize(o);\n }\n}\n\nstruct JsonObject;\nstruct TomlObject;\n\ntemplate \nconcept IsJsonOrToml = std::is_same_v || std::is_same_v;\ntemplate \nconcept IsBinaryOut = std::is_same_v || is_specialization_of_v;\n\ntemplate \nclass Out {\n public:\n Out();\n ~Out();\n int tableBegin(bool);\n void tableEnd(auto) { end(); }\n void arrayBegin();\n void arrayEnd(uint32_t) { end(); }\n void end();\n\n void key(std::string_view key) { add(key); }\n void value(bool value) { add(value); }\n void value(int64_t value) { add(value); }\n void value(double value) { add(value); }\n void value(std::string &&str) { add(std::move(str)); }\n void value(std::string_view str) { add(str); }\n void value(Optional);\n void value(VariantIndex) {}\n\n std::string toString(bool sortKeys = false, bool prettyFormatting = false);\n\n protected:\n void add(auto &&v);\n bool inTable();\n bool inArray();\n\n private:\n std::vector root_;\n};\n\ntemplate \nclass Out {\n public:\n using is_binary_out = void;\n\n uint32_t tableBegin(bool) { return out_.size(); }\n void tableEnd(uint32_t start) { serde::serialize(Varint32(out_.size() - start), *this); }\n void arrayBegin() {}\n void arrayEnd(uint32_t size) { serde::serialize(Varint32(size), *this); }\n\n inline void key(std::string_view) {} // ignore key.\n void value(auto &&value) requires(std::is_trivially_copyable_v>) {\n append(&value, sizeof(value));\n }\n void value(std::string_view str) {\n append(str.data(), str.size());\n serde::serialize(Varint32(str.size()), *this);\n }\n template \n requires(std::is_arithmetic_v) void value(const std::vector &vec) {\n append(vec.data(), vec.size() * sizeof(V));\n serde::serialize(Varint32(vec.size()), *this);\n }\n\n auto &bytes() { return out_; }\n\n inline void append(auto *data, size_t size) { out_.append(reinterpret_cast(data), size); }\n\n private:\n T out_;\n};\n\nstruct UnknownVariantType {\n SERDE_STRUCT_FIELD(type, String{});\n // TODO: add serializedBytes\n};\n\ntemplate \nusing AutoFallbackVariant = std::variant;\n\ntemplate \nconstexpr bool is_auto_fallback_variant_v = false;\n\ntemplate \nconstexpr bool is_auto_fallback_variant_v> = true;\n\ninline Result deserialize(auto &o, auto &&in) requires is_specialization, In> {\n using T = std::decay_t;\n using I = std::decay_t;\n constexpr bool isBinaryIn = requires { typename I::is_binary_in; };\n if constexpr (!isBinaryIn && requires { function_first_parameter_t<&T::serdeFromReadable>{}; }) {\n // 0. custom serde impl.\n function_first_parameter_t<&T::serdeFromReadable> from{};\n RETURN_AND_LOG_ON_ERROR(deserialize(from, in));\n auto result = T::serdeFromReadable(from);\n RETURN_AND_LOG_ON_ERROR(result);\n o = std::move(*result);\n return Void{};\n } else if constexpr (!isBinaryIn && requires { function_first_parameter_t<&SerdeMethod::serdeFromReadable>{}; }) {\n function_first_parameter_t<&SerdeMethod::serdeFromReadable> from{};\n RETURN_AND_LOG_ON_ERROR(deserialize(from, in));\n auto result = SerdeMethod::serdeFromReadable(from);\n RETURN_AND_LOG_ON_ERROR(result);\n o = std::move(*result);\n return Void{};\n } else if constexpr (requires { function_first_parameter_t<&SerdeMethod::serdeFrom>{}; }) {\n // 0. custom serde impl.\n function_first_parameter_t<&SerdeMethod::serdeFrom> from{};\n RETURN_AND_LOG_ON_ERROR(deserialize(from, in));\n auto result = SerdeMethod::serdeFrom(from);\n RETURN_AND_LOG_ON_ERROR(result);\n o = std::move(*result);\n return Void{};\n } else if constexpr (!isBinaryIn && requires { SerdeMethod::deserializeReadable(o, in); }) {\n return SerdeMethod::deserializeReadable(o, in);\n } else if constexpr (requires { SerdeMethod::deserialize(o, in); }) {\n return SerdeMethod::deserialize(o, in);\n } else if constexpr (SerdeType) {\n auto table = in.parseTable();\n RETURN_AND_LOG_ON_ERROR(table);\n if constexpr (isBinaryIn) {\n return refl::Helper::iterate(\n [&](auto type) -> Result {\n if (LIKELY(*table)) {\n return deserialize(o.*type.getter, *table);\n }\n // Missing fields at the end are acceptable.\n return Void{};\n },\n [&]() -> Result {\n table = in.parseTable();\n RETURN_AND_LOG_ON_ERROR(table);\n return Void{};\n });\n } else {\n return refl::Helper::iterate([&](auto type) -> Result {\n auto value = table->parseKey(type.name);\n if (LIKELY(bool(value))) {\n return deserialize(o.*type.getter, *value);\n } else {\n using ItemType = std::decay_t;\n if constexpr (is_optional_v) {\n o.*type.getter = std::nullopt;\n } else if constexpr (is_unique_ptr_v || is_shared_ptr_v) {\n o.*type.getter = nullptr;\n }\n }\n return Void{};\n });\n }\n } else if constexpr (std::is_same_v || std::is_same_v) {\n auto result = in.parseString();\n RETURN_AND_LOG_ON_ERROR(result);\n o = *result;\n return Void{};\n } else if constexpr (is_optional_v) {\n Optional optional;\n RETURN_AND_LOG_ON_ERROR(in.parseOptional(optional));\n if (optional == Optional::HasValue) {\n std::remove_cv_t value;\n RETURN_AND_LOG_ON_ERROR(deserialize(value, in));\n o = std::move(value);\n } else {\n o = std::nullopt;\n }\n return Void{};\n } else if constexpr (is_unique_ptr_v || is_shared_ptr_v) {\n Optional optional;\n RETURN_AND_LOG_ON_ERROR(in.parseOptional(optional));\n if (optional == Optional::HasValue) {\n if constexpr (is_unique_ptr_v) {\n o = std::make_unique();\n } else {\n o = std::make_shared();\n }\n RETURN_AND_LOG_ON_ERROR(deserialize(*o, in));\n } else {\n o = nullptr;\n }\n return Void{};\n } else if constexpr (is_variant_v) {\n auto variant = in.parseVariant();\n RETURN_AND_LOG_ON_ERROR(variant);\n return callByIdx>(\n [&](auto type) -> Result {\n if constexpr (std::is_same_v) {\n if constexpr (is_auto_fallback_variant_v) {\n UnknownVariantType uvt;\n uvt.type = variant->first;\n o = std::move(uvt);\n return Void{};\n } else {\n return makeError(StatusCode::kSerdeVariantIndexExceeded);\n }\n } else {\n RETURN_AND_LOG_ON_ERROR(deserialize(type, variant->second));\n o = std::move(type);\n return Void{};\n }\n },\n variantTypeNameToIndex(variant->first));\n return Void{};\n } else if constexpr (is_generic_pair_v && isBinaryIn) {\n RETURN_AND_LOG_ON_ERROR(deserialize(o.first, in));\n RETURN_AND_LOG_ON_ERROR(deserialize(o.second, in));\n return Void{};\n } else if constexpr (Container && isBinaryIn) {\n Varint64 size = 0;\n RETURN_AND_LOG_ON_ERROR(deserialize(size, in));\n o.clear();\n if constexpr (requires { o.reserve(size); }) {\n o.reserve(size);\n }\n auto inserter = std::inserter(o, o.end());\n for (uint32_t i = 0; i < size; ++i) {\n if constexpr (is_generic_pair_v) {\n std::remove_cv_t first;\n RETURN_AND_LOG_ON_ERROR(deserialize(first, in));\n std::remove_cv_t second;\n RETURN_AND_LOG_ON_ERROR(deserialize(second, in));\n inserter++ = typename T::value_type{std::move(first), std::move(second)};\n } else {\n auto value = DefaultConstructor>::construct();\n RETURN_AND_LOG_ON_ERROR(deserialize(value, in));\n inserter++ = std::move(value);\n }\n }\n return Void{};\n } else if constexpr (is_vector_v || is_set_v || is_map_v) {\n auto containerResult = in.parseContainer();\n RETURN_AND_LOG_ON_ERROR(containerResult);\n auto size = containerResult->first;\n auto it = std::move(containerResult->second);\n o.clear();\n if constexpr (requires { o.reserve(size); }) {\n o.reserve(size);\n }\n auto inserter = std::inserter(o, o.end());\n for (uint32_t i = 0; i < size; ++i) {\n if constexpr (is_map_v) {\n auto keyResult = in.fetchKey(it);\n RETURN_AND_LOG_ON_ERROR(keyResult);\n std::string_view key = *keyResult;\n using KeyType = std::remove_cv_t;\n KeyType first;\n if constexpr (requires { first = KeyType{key}; }) {\n first = KeyType{key};\n } else if constexpr (requires { scn::scan(key, \"{}\", first); }) {\n auto result = scn::scan(key, \"{}\", first);\n if (!result) {\n return makeError(StatusCode::kInvalidArg);\n }\n } else if constexpr (requires { scn::scan(key, \"{}\", first.toUnderType()); }) {\n auto result = scn::scan(key, \"{}\", first.toUnderType());\n if (!result) {\n return makeError(StatusCode::kInvalidArg);\n }\n } else {\n return makeError(StatusCode::kInvalidArg);\n }\n std::remove_cv_t second;\n RETURN_AND_LOG_ON_ERROR(deserialize(second, in.fetchValue(it)));\n inserter++ = typename T::value_type{std::move(first), std::move(second)};\n in.next(it);\n } else {\n std::remove_cv_t value;\n RETURN_AND_LOG_ON_ERROR(deserialize(value, in.fetchAndNext(it)));\n inserter++ = std::move(value);\n }\n }\n return Void{};\n } else if constexpr (isBinaryIn && SerdeCopyable) {\n return in.parseCopyable(o);\n } else if constexpr (std::is_same_v) {\n auto result = in.parseBoolean();\n RETURN_AND_LOG_ON_ERROR(result);\n o = *result;\n return Void{};\n } else if constexpr (std::is_integral_v) {\n auto result = in.parseInteger();\n RETURN_AND_LOG_ON_ERROR(result);\n o = *result;\n return Void{};\n } else if constexpr (std::is_floating_point_v) {\n auto result = in.parseFloat();\n RETURN_AND_LOG_ON_ERROR(result);\n o = *result;\n return Void{};\n } else if constexpr (std::is_enum_v) {\n std::string_view str;\n RETURN_AND_LOG_ON_ERROR(deserialize(str, in));\n auto result = magic_enum::enum_cast(str);\n if (result.has_value()) {\n o = *result;\n return Void{};\n }\n return makeError(StatusCode::kSerdeUnknownEnumValue,\n fmt::format(\"unknown enum value {} for type {}\", str, nameof::nameof_full_type()));\n } else {\n return notSupportToDeserialize(o, in);\n }\n}\n\ntemplate <>\nclass In {\n public:\n using is_binary_in = void;\n\n In(std::string_view str)\n : str_(str) {}\n\n operator bool() const { return !str_.empty(); }\n\n Result parseTable() {\n Varint64 length;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(length, *this));\n if (UNLIKELY(length > str_.length())) {\n return makeError(StatusCode::kSerdeInsufficientLength,\n fmt::format(\"string short {} > {}\", length, str_.length()));\n }\n auto table = In{str_.substr(0, length)};\n str_.remove_prefix(length);\n return table;\n }\n\n Result parseString() {\n Varint64 length;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(length, *this));\n if (UNLIKELY(length > str_.length())) {\n return makeError(StatusCode::kSerdeInsufficientLength,\n fmt::format(\"string short {} > {}\", length, str_.length()));\n }\n auto value = str_.substr(0, length);\n str_.remove_prefix(length);\n return value;\n }\n\n Result> parseVariant() {\n std::string_view typeName;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(typeName, *this));\n return std::pair(typeName, *this);\n }\n\n Result parseOptional(Optional &optional) { return serde::deserialize(optional, *this); }\n\n Result parseCopyable(auto &o) {\n if (UNLIKELY(sizeof(o) > str_.length())) {\n return makeError(StatusCode::kSerdeInsufficientLength,\n fmt::format(\"trivially copyable {} > {}\", sizeof(o), str_.length()));\n }\n std::memcpy(&o, str_.data(), sizeof(o));\n str_.remove_prefix(sizeof(o));\n return Void{};\n }\n\n auto &str() { return str_; }\n\n private:\n std::string_view str_;\n};\n\ntemplate <>\nclass In {\n public:\n In(const JsonObject &obj)\n : obj_(obj) {}\n template \n In(const T &obj);\n static Result parse(std::string_view str, std::function(const JsonObject &)> func);\n\n Result parseKey(std::string_view key) const;\n Result parseTable() const;\n\n Result parseBoolean() const;\n Result parseInteger() const;\n Result parseFloat() const;\n\n Result parseString() const;\n Result> parseVariant() const;\n\n Result parseOptional(Optional &optional) const;\n\n Result>> parseContainer() const;\n\n In fetchAndNext(std::unique_ptr &it) const;\n Result fetchKey(std::unique_ptr &it) const;\n In fetchValue(std::unique_ptr &it) const;\n void next(std::unique_ptr &it) const;\n\n private:\n const JsonObject &obj_;\n};\n\ntemplate <>\nclass In {\n public:\n In(const TomlObject &obj)\n : obj_(obj) {}\n template \n In(const T &obj);\n static Result parse(std::string_view str, std::function(const TomlObject &)> func);\n static Result parseFile(const Path &path, std::function(const TomlObject &)> func);\n\n Result parseKey(std::string_view key) const;\n Result parseTable() const;\n\n Result parseBoolean() const;\n Result parseInteger() const;\n Result parseFloat() const;\n\n Result parseString() const;\n Result> parseVariant() const;\n\n Result parseOptional(Optional &optional) const;\n\n Result>> parseContainer() const;\n\n In fetchAndNext(std::unique_ptr &it) const;\n Result fetchKey(std::unique_ptr &it) const;\n In fetchValue(std::unique_ptr &it) const;\n void next(std::unique_ptr &it) const;\n\n private:\n const TomlObject &obj_;\n};\n\ninline std::string serialize(const auto &o) {\n Out>> out;\n serialize(o, out);\n return out.bytes().toString();\n}\n\ninline DownwardBytes> serializeBytes(const auto &o) {\n Out>> out;\n serialize(o, out);\n return std::move(out.bytes());\n}\n\ninline void serializeToUserBuffer(const auto &o, uint8_t *data, uint32_t capacity) {\n Out> out;\n out.bytes().setBuffer(data, capacity);\n serialize(o, out);\n}\n\ninline auto serializeLength(const auto &o) {\n Out> out;\n serialize(o, out);\n return out.bytes().size();\n}\n\ninline Result deserialize(auto &o, std::string_view str) {\n serde::In in(str);\n return deserialize(o, in);\n}\n\ninline std::string toTomlString(const auto &o) {\n Out out;\n serialize(o, out);\n return out.toString();\n}\n\ninline std::string toJsonString(const auto &o, bool sortKeys = false, bool prettyFormatting = false) {\n Out out;\n serialize(o, out);\n return out.toString(sortKeys, prettyFormatting);\n}\n\ninline Result fromJsonString(auto &o, std::string_view str) {\n return In::parse(str, [&](const JsonObject &obj) { return deserialize(o, In(obj)); });\n}\n\ninline Result fromTomlString(auto &o, std::string_view str) {\n return In::parse(str, [&](const TomlObject &obj) { return deserialize(o, In(obj)); });\n}\n\ninline Result fromTomlFile(auto &o, const Path &path) {\n return In::parseFile(path, [&](const TomlObject &obj) { return deserialize(o, In(obj)); });\n}\n\ntemplate \nconcept SerializableToBytes = requires(const T &o) {\n serialize(o);\n};\n\ntemplate \nconcept SerializableToToml = requires(const T &o) {\n toTomlString(o);\n};\n\ntemplate \nconcept SerializableToJson = requires(const T &o) {\n toJsonString(o);\n};\n\ntemplate \nconcept Serializable = requires(const T &o) {\n serialize(o);\n toJsonString(o);\n};\n\n} // namespace hf3fs::serde\n\ntemplate <>\nstruct ::hf3fs::serde::SerdeMethod<::hf3fs::Void> {\n static constexpr auto serialize(Void, auto &&) {} // DO NOTHING.\n static Result deserialize(Void, auto &) { return Void{}; } // DO NOTHING.\n static constexpr std::string_view serdeToReadable(Void) { return \"Void\"; };\n};\n\ntemplate <>\nstruct ::hf3fs::serde::SerdeMethod<::hf3fs::Status> {\n static constexpr auto serialize(const Status &status, auto &out) {\n std::optional msg = std::nullopt;\n if (!status.message().empty()) {\n msg = status.message();\n }\n serde::serialize(msg, out);\n serde::serialize(status.code(), out);\n }\n\n static Result deserialize(Status &status, auto &&in) {\n status_code_t code;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(code, in));\n std::optional msg;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(msg, in));\n if (msg.has_value()) {\n status = Status(code, msg.value());\n } else {\n status = Status(code);\n }\n return Void{};\n }\n\n struct InnerStatus {\n SERDE_STRUCT_FIELD(code, uint16_t{});\n SERDE_STRUCT_FIELD(msg, std::string{});\n };\n\n static auto serdeToReadable(const Status &status) {\n return InnerStatus{status.code(), std::string(status.message())};\n }\n\n static Result serdeFromReadable(const InnerStatus &inner) {\n if (inner.msg.empty()) {\n return folly::makeExpected(Status{inner.code});\n } else {\n return folly::makeExpected(Status{inner.code, inner.msg});\n }\n }\n};\n\ntemplate \nstruct ::hf3fs::serde::SerdeMethod<::hf3fs::Result> {\n static auto serialize(const ::hf3fs::Result &result, auto &out) {\n bool hasValue = result.hasValue();\n if (hasValue) {\n serde::serialize(result.value(), out);\n } else {\n serde::serialize(result.error(), out);\n }\n out.value(hasValue);\n }\n\n static auto serializeReadable(const ::hf3fs::Result &result, auto &out) {\n auto start = out.tableBegin(false);\n {\n if (result.hasValue()) {\n out.key(\"value\");\n serde::serialize(result.value(), out);\n } else {\n out.key(\"error\");\n serde::serialize(result.error(), out);\n }\n }\n out.tableEnd(start);\n }\n\n static Result deserialize(::hf3fs::Result &result, auto &&in) {\n bool hasValue = false;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(hasValue, in));\n if (hasValue) {\n T value;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(value, in));\n result = std::move(value);\n } else {\n Status status = Status::OK;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(status, in));\n result = makeError(std::move(status));\n }\n return Void{};\n }\n};\n\ntemplate <>\nstruct hf3fs::serde::SerdeMethod {\n static auto serdeTo(const hf3fs::Path &p) { return p.string(); }\n static Result serdeFrom(std::string_view str) { return hf3fs::Path{std::string{str}}; }\n};\n\nFMT_BEGIN_NAMESPACE\n\ntemplate <::hf3fs::serde::SerdeType T>\nrequires(::hf3fs::serde::SerializableToJson) struct formatter : formatter {\n detail::dynamic_format_specs specs_;\n /* Copy from https://fmt.dev/latest/api.html#formatting-user-defined-types */\n template \n constexpr auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {\n auto end = detail::parse_format_specs(ctx.begin(), ctx.end(), specs_, ctx, detail::type::char_type);\n detail::check_char_specs(specs_);\n return end;\n }\n\n template \n auto format(const T &t, FormatContext &ctx) const {\n bool debug = specs_.type == presentation_type::debug;\n return formatter::format(\n hf3fs::serde::toJsonString(t, debug /*sortKeys*/, debug /*prettyFormatting*/),\n ctx);\n }\n};\n\nFMT_END_NAMESPACE\n"], ["/3FS/src/common/kv/mem/MemTransaction.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/kv/ITransaction.h\"\n#include \"common/kv/mem/MemKV.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/FaultInjection.h\"\n#include \"common/utils/RandomUtils.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/Status.h\"\n#include \"common/utils/String.h\"\n\n#define FAULT_INJECTION_ON_GET(op_name) \\\n do { \\\n if (FAULT_INJECTION()) { \\\n auto delayMs = folly::Random::rand32(10, 100); \\\n auto errCode = \\\n hf3fs::RandomUtils::randomSelect(std::vector{TransactionCode::kThrottled, TransactionCode::kTooOld}); \\\n XLOGF(WARN, \"Inject fault on \" #op_name \", errCode: {}, delayMs: {}.\", errCode, delayMs); \\\n co_await folly::coro::sleep(std::chrono::milliseconds(delayMs)); \\\n co_return makeError(errCode, \"Inject fault on \" #op_name); \\\n } \\\n } while (0)\n\n#define FAULT_INJECTION_ON_COMMIT(db_name, injectMaybeCommitted) \\\n do { \\\n if (FAULT_INJECTION()) { \\\n auto delayMs = folly::Random::rand32(10, 100); \\\n auto errCode = hf3fs::RandomUtils::randomSelect( \\\n std::vector{TransactionCode::kConflict, TransactionCode::kTooOld, TransactionCode::kMaybeCommitted}); \\\n XLOGF(WARN, \"Inject fault on commit, errCode: {}, delayMs: {}.\", errCode, delayMs); \\\n if (errCode == TransactionCode::kMaybeCommitted && folly::Random::oneIn(2)) { \\\n injectMaybeCommitted = true; \\\n XLOGF(WARN, \"Inject maybeCommitted on commit, commit transaction in \" #db_name \".\"); \\\n } else { \\\n co_return makeError(errCode, \"Inject fault on commit.\"); \\\n } \\\n } \\\n } while (0)\n\nnamespace hf3fs::kv {\n\nclass MemTransaction : public IReadWriteTransaction {\n public:\n MemTransaction(mem::MemKV &mem)\n : mem_(mem),\n readVersion_(mem.version()) {}\n\n CoTryTask> snapshotGet(std::string_view key) override {\n FAULT_INJECTION_ON_GET(snapshotGet);\n co_return getImpl(key, true);\n }\n\n CoTryTask snapshotGetRange(const KeySelector &begin, const KeySelector &end, int32_t limit) override {\n FAULT_INJECTION_ON_GET(snapshotGetRange);\n co_return getRangeImpl(begin, end, limit, true);\n }\n\n CoTryTask cancel() override {\n std::scoped_lock guard(mutex_);\n canceled_ = true;\n co_return Void{};\n }\n\n CoTryTask addReadConflict(std::string_view key) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n if (changes_.contains(key)) {\n co_return Void{};\n }\n readKeys_.insert(String(key));\n co_return Void{};\n }\n\n CoTryTask addReadConflictRange(std::string_view begin, std::string_view end) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n readRanges_.push_back({std::string(begin), std::string(end)});\n co_return Void{};\n }\n\n CoTryTask> get(std::string_view key) override {\n FAULT_INJECTION_ON_GET(get);\n co_return getImpl(key, false);\n }\n\n CoTryTask getRange(const KeySelector &begin, const KeySelector &end, int32_t limit) override {\n FAULT_INJECTION_ON_GET(getRange);\n co_return getRangeImpl(begin, end, limit, false);\n }\n\n CoTryTask set(std::string_view key, std::string_view value) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n changes_[String(key)] = value;\n co_return Void{};\n }\n\n CoTryTask setVersionstampedKey(std::string_view key, uint32_t offset, std::string_view value) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n if (offset + sizeof(kv::Versionstamp) > key.size()) {\n co_return makeError(\n StatusCode::kInvalidArg,\n fmt::format(\"setVersionstampedKey: {} + sizeof(kv::Versionstamp) > key.size {}\", offset, key.size()));\n }\n versionstampedChanges_.push_back(\n mem::MemKV::VersionstampedKV::versionstampedKey(std::string(key), offset, std::string(value)));\n co_return Void{};\n }\n\n CoTryTask setVersionstampedValue(std::string_view key, std::string_view value, uint32_t offset) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n if (offset + sizeof(kv::Versionstamp) > value.size()) {\n co_return makeError(\n StatusCode::kInvalidArg,\n fmt::format(\"setVersionstampedValue: {} + sizeof(kv::Versionstamp) > value.size {}\", offset, value.size()));\n }\n versionstampedChanges_.push_back(\n mem::MemKV::VersionstampedKV::versionstampedValue(std::string(key), std::string(value), offset));\n co_return Void{};\n }\n\n // Check given keys are in transaction's conflict set.\n bool checkConflictSet(const std::vector &readConflict,\n const std::vector &writeConflict,\n bool exactly = false) {\n std::scoped_lock guard(mutex_);\n for (auto &key : readConflict) {\n if (!readKeys_.contains(key)) {\n XLOGF(ERR, \"Read conflict set doesn't contains key {}\", key);\n return false;\n }\n }\n for (auto &key : writeConflict) {\n auto iter = std::find_if(changes_.begin(), changes_.end(), [&](auto &iter) -> bool { return iter.first == key; });\n if (iter == changes_.end()) {\n XLOGF(ERR, \"Write conflict set doesn't contains key {}\", key);\n return false;\n }\n }\n if (!exactly) {\n return true;\n }\n\n // transaction's conflict set should only given keys\n for (auto &key : readKeys_) {\n if (std::find(readConflict.begin(), readConflict.end(), key) == readConflict.end()) {\n XLOGF(ERR, \"Read conflict contains unexpected key {}\", key);\n return false;\n }\n }\n for (auto &change : changes_) {\n if (std::find(writeConflict.begin(), writeConflict.end(), change.first) == writeConflict.end()) {\n XLOGF(ERR, \"Write conflict contains unexpected key {}\", change.first);\n return false;\n }\n }\n return true;\n }\n\n CoTryTask clear(std::string_view key) override {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n changes_[String(key)] = std::optional();\n co_return Void{};\n }\n\n CoTryTask commit() override {\n bool injectMaybeCommitted = false;\n FAULT_INJECTION_ON_COMMIT(MemKV, injectMaybeCommitted);\n\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n co_return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n\n std::vector>> vec;\n vec.reserve(changes_.size());\n for (auto iter : changes_) {\n vec.emplace_back(iter.first, iter.second);\n }\n auto result = mem_.commit(readVersion(), readKeys_, readRanges_, vec, versionstampedChanges_, writeConflicts_);\n if (UNLIKELY(injectMaybeCommitted)) {\n XLOGF(ERR,\n \"Inject mayebeCommitted error after commit, MemKV commit result is {}.\",\n result.hasError() ? result.error().describe() : \"OK\");\n co_return makeError(TransactionCode::kMaybeCommitted, \"Fault injection commit unknown result.\");\n }\n CO_RETURN_ON_ERROR(result);\n commitVersion_ = *result;\n co_return Void{};\n }\n\n void setReadVersion(int64_t version) override {\n std::scoped_lock guard(mutex_);\n if (version >= 0) {\n readVersion_ = version;\n }\n }\n\n int64_t getCommittedVersion() override {\n std::scoped_lock guard(mutex_);\n return commitVersion_;\n };\n\n void reset() override {\n std::scoped_lock guard(mutex_);\n readVersion_ = -1;\n commitVersion_ = -1;\n canceled_ = false;\n readKeys_.clear();\n readRanges_.clear();\n changes_.clear();\n versionstampedChanges_.clear();\n writeConflicts_.clear();\n }\n\n // check txn1 updated txn2's read set\n static bool checkConflict(MemTransaction &txn1, MemTransaction &txn2) {\n std::scoped_lock guard1(txn1.mutex_);\n std::scoped_lock guard2(txn2.mutex_);\n\n for (auto &change : txn1.changes_) {\n auto &key = change.first;\n if (std::find(txn2.readKeys_.begin(), txn2.readKeys_.end(), key) != txn2.readKeys_.end()) {\n return true;\n }\n for (auto &range : txn2.readRanges_) {\n if (key >= range.first && key < range.second) {\n return true;\n }\n }\n }\n return false;\n }\n\n mem::MemKV &kv() { return mem_; }\n\n private:\n int64_t readVersion() {\n if (readVersion_ < 0) {\n readVersion_ = mem_.version();\n }\n return readVersion_;\n }\n\n Result> getImpl(std::string_view key, bool snapshot) {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n\n if (changes_.count(key)) {\n return changes_.at(String(key));\n }\n if (!snapshot) {\n readKeys_.insert(String(key));\n }\n return mem_.get(key, readVersion());\n }\n\n Result getRangeImpl(const KeySelector &begin, const KeySelector &end, int32_t limit, bool snapshot) {\n std::scoped_lock guard(mutex_);\n if (canceled_) {\n return makeError(TransactionCode::kCanceled, \"Canceled transaction!\");\n }\n // always get all kvs in range\n auto result = mem_.getRange(begin, end, std::numeric_limits::max(), readVersion());\n RETURN_ON_ERROR(result);\n\n auto changeIt = changes_.lower_bound(begin.key);\n if (changeIt != changes_.end() && !begin.inclusive) ++changeIt;\n\n if (changeIt != changes_.end()) {\n std::vector newKvs;\n auto originIt = result->kvs.begin();\n auto originEnded = [&] { return originIt == result->kvs.end(); };\n auto changeEnded = [&] {\n if (changeIt == changes_.end()) return true;\n if (end.inclusive && changeIt->first > end.key) return true;\n if (!end.inclusive && changeIt->first >= end.key) return true;\n if (result->hasMore) {\n assert(!result->kvs.empty());\n if (changeIt->first > result->kvs.back().key) return true;\n }\n return false;\n };\n auto pushChange = [&] {\n if (changeIt->second.has_value()) newKvs.emplace_back(changeIt->first, *changeIt->second);\n };\n for (;;) {\n if (originEnded() || changeEnded()) break;\n if (originIt->key < changeIt->first) {\n newKvs.push_back(*originIt);\n ++originIt;\n } else if (originIt->key > changeIt->first) {\n pushChange();\n ++changeIt;\n } else {\n pushChange();\n ++changeIt;\n ++originIt;\n }\n }\n for (; !originEnded(); ++originIt) {\n newKvs.push_back(*originIt);\n }\n for (; !changeEnded(); ++changeIt) {\n pushChange();\n }\n result->kvs = std::move(newKvs);\n }\n\n if (limit < 1) {\n limit = mem::memKvDefaultLimit;\n }\n if (result->kvs.size() > (size_t)limit) {\n result->kvs = std::vector(&result->kvs[0], &result->kvs[(size_t)limit]);\n result->hasMore = true;\n assert(result->kvs.size() == (size_t)limit);\n }\n\n String rangeBegin = begin.inclusive ? String(begin.key) : TransactionHelper::keyAfter(begin.key);\n String rangeEnd;\n if (result->hasMore) {\n rangeEnd = TransactionHelper::keyAfter(result->kvs.end()[-1].key);\n } else {\n rangeEnd = end.inclusive ? TransactionHelper::keyAfter(end.key) : String(end.key);\n }\n if (!snapshot) {\n readRanges_.push_back({rangeBegin, rangeEnd});\n }\n\n return result;\n }\n\n std::mutex mutex_;\n mem::MemKV &mem_;\n bool canceled_ = false;\n int64_t readVersion_ = -1;\n int64_t commitVersion_ = -1;\n std::unordered_set readKeys_;\n std::vector> readRanges_;\n std::map, std::less<>> changes_;\n std::vector versionstampedChanges_;\n std::set writeConflicts_;\n};\n\n} // namespace hf3fs::kv\n"], ["/3FS/src/core/user/UserCache.h", "#pragma once\n\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/LockManager.h\"\n#include \"common/utils/RobinHood.h\"\n#include \"common/utils/UtcTime.h\"\n#include \"fbs/core/user/User.h\"\n\nnamespace hf3fs::core {\nusing flat::Gid;\nusing flat::Uid;\nusing flat::UserAttr;\nusing flat::UserInfo;\n\nclass UserCache {\n public:\n struct Config : ConfigBase {\n CONFIG_ITEM(buckets, 127u, ConfigCheckers::isPositivePrime);\n CONFIG_HOT_UPDATED_ITEM(exist_ttl, 5_min);\n CONFIG_HOT_UPDATED_ITEM(inexist_ttl, 10_s);\n };\n\n explicit UserCache(const Config &cfg)\n : cfg_(cfg),\n lockManager_(cfg.buckets()),\n buckets_(cfg.buckets()) {}\n\n struct GetResult {\n std::optional attr;\n bool marked = false;\n\n static GetResult unmarkedNotExist() { return {std::nullopt, false}; }\n static GetResult markedNotExist() { return {std::nullopt, true}; }\n static GetResult exist(UserAttr attr) { return {std::move(attr), false}; }\n };\n\n GetResult get(Uid id) {\n auto lock = lockManager_.lock(id);\n auto now = SteadyClock::now();\n auto &bucket = buckets_[lockManager_.idx(id)];\n\n auto it = bucket.find(id);\n if (it == bucket.end()) return GetResult::unmarkedNotExist();\n\n auto &entry = it->second;\n if (expired(entry, now)) {\n bucket.erase(it);\n return GetResult::unmarkedNotExist();\n }\n\n if (entry.attr)\n return GetResult::exist(*entry.attr);\n else\n return GetResult::markedNotExist();\n }\n\n void set(Uid id, std::optional attr) {\n auto lock = lockManager_.lock(id);\n auto &bucket = buckets_[lockManager_.idx(id)];\n auto &entry = bucket[id];\n auto now = SteadyClock::now();\n entry.setTs = now;\n entry.attr = std::move(attr);\n }\n\n void clear(Uid id) {\n auto lock = lockManager_.lock(id);\n auto &bucket = buckets_[lockManager_.idx(id)];\n bucket.erase(id);\n }\n\n void clear() {\n for (uint32_t i = 0; i < lockManager_.numBuckets(); ++i) {\n auto lock = lockManager_.lock_at(i);\n auto &bucket = buckets_[i];\n bucket.clear();\n }\n }\n\n void clearRetired() {\n std::vector uids;\n for (uint32_t i = 0; i < lockManager_.numBuckets(); ++i) {\n auto lock = lockManager_.lock_at(i);\n auto &bucket = buckets_[i];\n auto now = SteadyClock::now();\n for (const auto &[id, entry] : bucket) {\n if (expired(entry, now)) uids.push_back(id);\n }\n }\n if (!uids.empty()) {\n for (uint32_t i = 0; i < lockManager_.numBuckets(); ++i) {\n auto lock = lockManager_.lock_at(i);\n auto &bucket = buckets_[i];\n auto now = SteadyClock::now();\n for (auto id : uids) {\n auto it = bucket.find(id);\n if (expired(it->second, now)) bucket.erase(it);\n }\n }\n }\n }\n\n private:\n struct Entry {\n std::optional attr;\n SteadyTime setTs;\n };\n\n bool expired(const Entry &entry, SteadyTime now) const {\n auto timeout = entry.attr ? cfg_.exist_ttl().asUs() : cfg_.inexist_ttl().asUs();\n return now - entry.setTs >= timeout;\n }\n\n using Bucket = robin_hood::unordered_node_map;\n\n const Config &cfg_;\n UniqueLockManager lockManager_;\n std::vector buckets_;\n};\n} // namespace hf3fs::core\n"], ["/3FS/src/storage/aio/BatchReadJob.h", "#pragma once\n\n#include \n#include \n\n#include \"chunk_engine/src/cxx.rs.h\"\n#include \"common/net/ib/IBSocket.h\"\n#include \"common/serde/CallContext.h\"\n#include \"common/utils/Duration.h\"\n#include \"fbs/storage/Common.h\"\n#include \"storage/store/ChunkMetadata.h\"\n\nnamespace hf3fs::storage {\n\nclass BatchReadJob;\nclass StorageTarget;\n\nclass ChunkEngineReadJob {\n public:\n ChunkEngineReadJob() = default;\n ChunkEngineReadJob(const ChunkEngineReadJob &) = delete;\n ChunkEngineReadJob(ChunkEngineReadJob &&other)\n : engine_(std::exchange(other.engine_, nullptr)),\n chunk_(std::exchange(other.chunk_, nullptr)) {}\n\n void set(chunk_engine::Engine *engine, const chunk_engine::Chunk *chunk) {\n reset();\n engine_ = engine;\n chunk_ = chunk;\n }\n\n void reset() {\n if (engine_ && chunk_) {\n std::exchange(engine_, nullptr)->release_raw_chunk(chunk_);\n }\n }\n\n auto chunk() const { return chunk_; }\n\n bool has_chunk() const { return chunk_ != nullptr; }\n\n ~ChunkEngineReadJob() { reset(); }\n\n private:\n chunk_engine::Engine *engine_{};\n const chunk_engine::Chunk *chunk_{};\n};\n\nclass AioReadJob {\n public:\n AioReadJob(const ReadIO &readIO, IOResult &result, BatchReadJob &batch);\n\n auto &readIO() { return readIO_; }\n auto &result() { return result_; }\n auto &batch() { return batch_; }\n auto &state() { return state_; }\n\n void setResult(Result lengthInfo);\n\n uint32_t alignedOffset() const { return readIO_.offset - state_.headLength; }\n uint32_t alignedLength() const { return readIO_.length + state_.headLength + state_.tailLength; }\n\n auto startTime() const { return startTime_; }\n void resetStartTime() { startTime_ = RelativeTime::now(); }\n\n private:\n const ReadIO &readIO_;\n IOResult &result_;\n BatchReadJob &batch_;\n struct State {\n net::RDMABuf localbuf{};\n StorageTarget *storageTarget = nullptr;\n ChunkEngineReadJob chunkEngineJob{};\n SERDE_STRUCT_FIELD(headLength, uint32_t{});\n SERDE_STRUCT_FIELD(tailLength, uint32_t{});\n SERDE_STRUCT_FIELD(readLength, uint32_t{}); // after cropping.\n SERDE_STRUCT_FIELD(readFd, int32_t{});\n SERDE_STRUCT_FIELD(readOffset, uint64_t{});\n SERDE_STRUCT_FIELD(chunkLen, uint32_t{});\n SERDE_STRUCT_FIELD(bufferIndex, uint32_t{});\n SERDE_STRUCT_FIELD(fdIndex, std::optional{});\n SERDE_STRUCT_FIELD(chunkChecksum, ChecksumInfo{});\n SERDE_STRUCT_FIELD(readUncommitted, false);\n } state_;\n static_assert(serde::Serializable);\n RelativeTime startTime_{};\n};\n\nclass BatchReadJob {\n public:\n BatchReadJob(std::span readIOs, std::span results, ChecksumType checksumType);\n BatchReadJob(const ReadIO &readIO, StorageTarget *target, IOResult &result, ChecksumType checksumType)\n : BatchReadJob(std::span(&readIO, 1), std::span(&result, 1), checksumType) {\n jobs_.back().state().storageTarget = target;\n }\n CoTask complete() { co_await baton_; }\n size_t addBufferToBatch(serde::CallContext::RDMATransmission &batch);\n size_t copyToRespBuffer(std::vector &buffer);\n void finish(AioReadJob *job);\n auto checksumType() const { return checksumType_; }\n bool recalculateChecksum() const { return recalculateChecksum_; }\n void setRecalculateChecksum(bool value = true) { recalculateChecksum_ = value; }\n auto &front() { return jobs_.front(); }\n auto &front() const { return jobs_.front(); }\n auto startTime() const { return startTime_.load(); }\n void resetStartTime() { startTime_ = RelativeTime::now(); }\n\n private:\n friend class AioReadJobIterator;\n std::vector jobs_;\n folly::coro::Baton baton_;\n std::atomic finishedCount_{};\n std::atomic startTime_ = RelativeTime::now();\n const ChecksumType checksumType_;\n bool recalculateChecksum_ = false;\n};\n\nclass AioReadJobIterator {\n public:\n AioReadJobIterator() = default;\n AioReadJobIterator(BatchReadJob *batch)\n : batch_(batch),\n end_(batch->jobs_.size()) {}\n AioReadJobIterator(BatchReadJob *batch, uint32_t start, uint32_t size)\n : batch_(batch),\n begin_(start),\n end_(std::min((uint32_t)batch->jobs_.size(), start + size)) {}\n\n operator bool() const { return begin_ < end_; }\n bool isNull() const { return batch_ == nullptr; }\n AioReadJob &operator*() { return batch_->jobs_[begin_]; }\n AioReadJob *operator->() { return &batch_->jobs_[begin_]; }\n AioReadJob *operator++(int) { return &batch_->jobs_[begin_++]; }\n\n auto startTime() const { return startTime_; }\n auto resetStartTime() { startTime_ = RelativeTime::now(); }\n\n private:\n BatchReadJob *batch_ = nullptr;\n uint32_t begin_ = 0;\n uint32_t end_ = 0;\n RelativeTime startTime_ = RelativeTime::now();\n};\n\n} // namespace hf3fs::storage\n"], ["/3FS/src/common/utils/CountDownLatch.h", "#pragma once\n\n#include \n#include \n\n#include \"common/utils/Coroutine.h\"\n\nnamespace hf3fs {\ntemplate \nclass CountDownLatch {\n public:\n explicit CountDownLatch(int64_t count = 0)\n : count_(count) {}\n\n void countDown(int64_t n = 1) {\n auto remaining = count_.fetch_sub(n, std::memory_order_acq_rel);\n assert(remaining >= n);\n if (remaining == n) {\n baton_.post();\n }\n }\n\n int64_t increase(int64_t n = 1) { return count_.fetch_add(n, std::memory_order_acq_rel); }\n\n CoTask wait() {\n if (count_.load(std::memory_order_acquire) > 0) co_await baton_;\n }\n\n bool tryWait() { return count_.load(std::memory_order_acquire) == 0; }\n\n void reset() { baton_.reset(); }\n\n private:\n std::atomic count_;\n BatonType baton_;\n};\n} // namespace hf3fs\n"], ["/3FS/src/meta/components/InodeIdAllocator.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/kv/IKVEngine.h\"\n#include \"common/monitor/Recorder.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/FaultInjection.h\"\n#include \"common/utils/IdAllocator.h\"\n#include \"common/utils/Result.h\"\n#include \"fbs/meta/Common.h\"\n#include \"fdb/FDBRetryStrategy.h\"\n\nnamespace hf3fs::meta::server {\n\n/**\n * Generate InodeId range from 0x00000000_00001000 to 0x01ffffff_ffffffff.\n *\n * Generated InodeId format: [ high 52bits: generated by IdAllocator ][ low 12 bits: local generated ].\n * InodeIdAllocator first use IdAllocator to generate a 52bits value, then left shift 12 bits and generate lower 12 bits\n * locally. So it only need to access the FoundationDB after generate 4096 InodeIds.\n */\nclass InodeIdAllocator : public std::enable_shared_from_this {\n // These values are used in FoundationDB\n static std::string kAllocatorKeyPrefix;\n static constexpr size_t kAllocatorShard = 32; // avoid txn conflictation\n static constexpr uint64_t kAllocatorShift = 12; // shift 12 bit\n static constexpr uint64_t kAllocatorBit =\n 64 - kAllocatorShift; // IdAllocator generated values only have 52bits valid.\n static constexpr uint64_t kAllocatorMask = (1ULL << kAllocatorBit) - 1;\n static constexpr uint64_t kAllocateBatch = 1 << kAllocatorShift;\n\n struct Tag {};\n\n public:\n InodeIdAllocator(Tag, std::shared_ptr kvEngine)\n : engine_(std::move(kvEngine)),\n allocator_(*engine_, createRetryStrategy(), kAllocatorKeyPrefix, kAllocatorShard),\n allocating_(false),\n queue_(2 * kAllocateBatch) {}\n\n static std::shared_ptr create(std::shared_ptr kvEngine) {\n return std::make_shared(Tag{}, std::move(kvEngine));\n }\n\n CoTryTask allocate(std::chrono::microseconds timeout = std::chrono::seconds(2)) {\n static monitor::CountRecorder failed(\"meta_inodeid_alloc_failed\");\n\n auto id = queue_.try_dequeue();\n if (LIKELY(id.has_value())) {\n if (queue_.size() < kAllocateBatch / 2) {\n tryStartAllocateTask(co_await folly::coro::co_current_executor);\n }\n co_return id.value();\n }\n auto result = co_await allocateSlow(timeout);\n if (result.hasError()) {\n failed.addSample(1);\n co_return result;\n }\n if (result->u64() >= InodeId::kNewChunkEngineMask) {\n failed.addSample(1);\n XLOGF(DFATAL, \"InodeId {} is larger than\", *result, InodeId(InodeId::kNewChunkEngineMask));\n co_return makeError(MetaCode::kInodeIdAllocFailed, \"InodeId too large, shouldn't happen\");\n }\n co_return result;\n }\n\n private:\n static kv::FDBRetryStrategy createRetryStrategy() { return kv::FDBRetryStrategy({.retryMaybeCommitted = true}); }\n\n static CoTask allocateTask(std::weak_ptr weak,\n std::optional delay = std::nullopt) {\n if (delay.has_value()) {\n co_await folly::coro::sleep(delay.value());\n }\n\n auto ptr = weak.lock();\n if (ptr) {\n co_await ptr->allocateFromDB();\n }\n co_return;\n }\n\n void tryStartAllocateTask(folly::Executor *exec) {\n if (!allocating_.exchange(true)) {\n startAllocateTask(exec);\n }\n }\n\n void startAllocateTask(folly::Executor *exec) {\n folly::RequestContextScopeGuard guard;\n allocateTask(weak_from_this()).scheduleOn(exec).start();\n }\n\n CoTryTask allocateSlow(std::chrono::microseconds timeout);\n CoTask allocateFromDB();\n\n std::shared_ptr engine_;\n IdAllocator allocator_;\n std::atomic allocating_;\n folly::coro::BoundedQueue queue_;\n};\n\n} // namespace hf3fs::meta::server\n"], ["/3FS/src/common/utils/WorkStealingBlockingQueue.h", "#pragma once\n\n#include \n#include \n#include \n\n#include \"common/utils/SimpleSemaphore.h\"\n\nnamespace hf3fs {\nnamespace details {\ntemplate \nclass EndValueHolder {\n public:\n explicit EndValueHolder(EndPredicate predicate)\n : isEndPredicate_(std::move(predicate)) {}\n\n bool add(T &&item) {\n if (UNLIKELY(isEndPredicate_(item))) {\n {\n auto guard = endValue_.lock();\n *guard = std::move(item);\n }\n isEnd_.store(true, std::memory_order_release);\n return true;\n }\n return false;\n }\n\n bool hasValue() const { return isEnd_.load(std::memory_order_acquire); }\n\n T forceTake() {\n auto guard = endValue_.lock();\n return std::move(**guard);\n }\n\n folly::Optional take() {\n if (UNLIKELY(isEnd_.load(std::memory_order_acquire))) {\n auto guard = endValue_.lock();\n return std::move(**guard);\n }\n return {};\n }\n\n private:\n EndPredicate isEndPredicate_;\n std::atomic isEnd_{false};\n folly::Synchronized, std::mutex> endValue_;\n};\n\ntemplate \nclass SharedNothingQueueStrategy {\n public:\n using ItemType = T;\n using Queue = folly::UnboundedBlockingQueue;\n using QueuePtr = std::shared_ptr;\n\n struct SharedState {\n explicit SharedState(size_t count) {\n queues.reserve(count);\n for (uint32_t i = 0; i < count; ++i) queues.push_back(std::make_shared());\n }\n\n std::vector queues;\n };\n\n SharedNothingQueueStrategy(const std::shared_ptr &state, uint32_t selfPos)\n : self_(state->queues[selfPos]) {}\n\n void add(T &&item) { self_->add(std::move(item)); }\n\n size_t queueSize() const { return self_->size(); }\n\n template \n folly::Optional tryTake(std::chrono::milliseconds time, EndValueHolder &endValue) {\n if (auto item = self_->try_take_for(time); item) {\n return item;\n }\n return endValue.take();\n }\n\n private:\n QueuePtr self_;\n};\n\ntemplate \nclass WorkStealingQueueStrategy {\n public:\n using ItemType = T;\n using Queue = folly::UnboundedBlockingQueue;\n using QueuePtr = std::shared_ptr;\n\n struct SharedState {\n explicit SharedState(size_t count) {\n queues.reserve(count);\n for (uint32_t i = 0; i < count; ++i) queues.push_back(std::make_shared());\n }\n\n std::vector queues;\n };\n\n WorkStealingQueueStrategy(const std::shared_ptr &state, uint32_t selfPos)\n : self_(state->queues[selfPos]),\n siblings_(state->queues) {\n siblings_.erase(siblings_.begin() + selfPos);\n std::shuffle(siblings_.begin(), siblings_.end(), folly::ThreadLocalPRNG{});\n }\n\n void add(T &&item) { self_->add(std::move(item)); }\n\n size_t queueSize() const { return self_->size(); }\n\n template \n folly::Optional tryTake(std::chrono::milliseconds time, EndValueHolder &endValue) {\n static thread_local size_t called = 0;\n if (LIKELY(called++ % 5 != 4)) {\n if (auto item = self_->try_take_for(time); item) {\n return std::move(item);\n }\n\n if (auto item = endValue.take(); item) {\n return std::move(item);\n }\n }\n\n if (!siblings_.empty()) {\n static thread_local size_t next = folly::Random::rand32();\n return siblings_[next++ % siblings_.size()]->try_take();\n }\n\n return {};\n }\n\n private:\n QueuePtr self_;\n std::vector siblings_;\n};\n\ntemplate \nclass RoundRobinQueueStrategy {\n public:\n using ItemType = T;\n using Queue = folly::UnboundedBlockingQueue;\n using QueuePtr = std::shared_ptr;\n\n struct SharedState {\n explicit SharedState(size_t count) {\n queues.reserve(count);\n for (uint32_t i = 0; i < count; ++i) queues.push_back(std::make_shared());\n }\n\n std::atomic next{0};\n std::vector queues;\n };\n\n RoundRobinQueueStrategy(const std::shared_ptr &state, uint32_t selfPos)\n : state_(state),\n selfPos_(selfPos) {\n for (size_t i = 0; i < 4 && i < state->queues.size(); ++i) {\n queues_.push_back(state->queues[(selfPos + i) % state->queues.size()]);\n }\n std::shuffle(queues_.begin() + 1, queues_.end(), folly::ThreadLocalPRNG{});\n }\n\n void add(T &&item) { queues_[0]->add(std::move(item)); }\n\n size_t queueSize() const { return queues_[0]->size(); }\n\n template \n folly::Optional tryTake(std::chrono::milliseconds time, EndValueHolder &endValue) {\n static thread_local uint64_t called = 0;\n static thread_local uint64_t next = 0;\n if (LIKELY(called++ % 5 != 4)) {\n for (size_t i = 0; i < queues_.size(); ++i, ++next) {\n auto pos = next % queues_.size();\n if (auto item = queues_[pos]->try_take(); item) {\n return std::move(item);\n }\n\n if (UNLIKELY(pos == 0 && endValue.hasValue())) {\n return endValue.forceTake();\n }\n }\n }\n\n ++next;\n return queues_[0]->try_take_for(time);\n }\n\n private:\n std::shared_ptr state_;\n std::vector queues_;\n const size_t selfPos_;\n};\n\n// NOTE: BlockingQueueBase should be used as a MPSC queue\ntemplate \nclass BlockingQueueBase : public folly::BlockingQueue {\n public:\n using StrategyType = Strategy;\n using SharedState = typename Strategy::SharedState;\n using T = typename Strategy::ItemType;\n\n BlockingQueueBase(const std::shared_ptr &state, uint32_t selfPos, EndPredicate isEnd)\n : strategy_(state, selfPos),\n endValue_(std::move(isEnd)) {}\n\n folly::BlockingQueueAddResult add(T item) override {\n if (!endValue_.add(std::move(item))) {\n strategy_.add(std::move(item));\n }\n return true;\n }\n\n T take() override {\n for (;;) {\n if (auto item = strategy_.tryTake(timeout_, endValue_); item) {\n return std::move(*item);\n }\n }\n __builtin_unreachable();\n }\n\n folly::Optional try_take_for(std::chrono::milliseconds time) override {\n auto start = std::chrono::steady_clock::now();\n auto deadline = start + time;\n time = std::min(time, timeout_);\n for (;;) {\n if (auto item = strategy_.tryTake(time, endValue_); item) {\n return std::move(item);\n }\n if (std::chrono::steady_clock::now() >= deadline) {\n return {};\n }\n }\n __builtin_unreachable();\n }\n\n size_t size() override { return strategy_.queueSize(); }\n\n private:\n static constexpr auto timeout_ = std::chrono::milliseconds(1);\n\n Strategy strategy_;\n EndValueHolder endValue_;\n};\n} // namespace details\n\ntemplate \nusing SharedNothingBlockingQueue = details::BlockingQueueBase, EndPredicate>;\n\ntemplate \nusing WorkStealingBlockingQueue = details::BlockingQueueBase, EndPredicate>;\n\ntemplate \nusing RoundRobinBlockingQueue = details::BlockingQueueBase, EndPredicate>;\n} // namespace hf3fs\n"], ["/3FS/src/meta/components/GcManager.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"client/mgmtd/ICommonMgmtdClient.h\"\n#include \"client/mgmtd/MgmtdClient.h\"\n#include \"client/storage/StorageClient.h\"\n#include \"common/app/ApplicationBase.h\"\n#include \"common/app/NodeId.h\"\n#include \"common/kv/IKVEngine.h\"\n#include \"common/kv/ITransaction.h\"\n#include \"common/utils/BackgroundRunner.h\"\n#include \"common/utils/CPUExecutorGroup.h\"\n#include \"common/utils/ConfigBase.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/CoroutinesPool.h\"\n#include \"common/utils/CountDownLatch.h\"\n#include \"common/utils/Duration.h\"\n#include \"common/utils/PriorityCoroutinePool.h\"\n#include \"common/utils/Result.h\"\n#include \"common/utils/Semaphore.h\"\n#include \"common/utils/UtcTime.h\"\n#include \"core/user/UserStoreEx.h\"\n#include \"fbs/core/user/User.h\"\n#include \"fbs/meta/Common.h\"\n#include \"fdb/FDBRetryStrategy.h\"\n#include \"fmt/core.h\"\n#include \"meta/base/Config.h\"\n#include \"meta/components/InodeIdAllocator.h\"\n#include \"meta/components/SessionManager.h\"\n#include \"meta/event/Event.h\"\n#include \"meta/store/DirEntry.h\"\n#include \"meta/store/FileSession.h\"\n#include \"scn/scan/scan.h\"\n\nnamespace hf3fs::meta::server {\n\nclass FileHelper;\nusing hf3fs::client::ICommonMgmtdClient;\n\nclass GcManager {\n public:\n static Result> parseGcEntry(std::string_view entry) {\n char prefix;\n uint64_t timestamp;\n uint64_t inode;\n auto ret = scn::scan(entry, \"{}-{}-{:i}\", prefix, timestamp, inode);\n if (!ret) {\n return makeError(StatusCode::kInvalidArg);\n }\n return std::pair{UtcTime::fromMicroseconds(timestamp), InodeId(inode)};\n }\n\n static std::string formatGcEntry(char prefix, UtcTime timestamp, InodeId inode) {\n return fmt::format(\"{}-{:020d}-{}\", prefix, (uint64_t)timestamp.toMicroseconds(), inode.toHexString());\n }\n\n GcManager(const Config &config,\n flat::NodeId nodeId,\n analytics::StructuredTraceLog &metaEventTraceLog,\n std::shared_ptr kvEngine,\n std::shared_ptr mgmtd,\n std::shared_ptr idAlloc,\n std::shared_ptr fileHelper,\n std::shared_ptr sessionManager,\n std::shared_ptr userStore)\n : config_(config),\n nodeId_(nodeId),\n metaEventTraceLog_(metaEventTraceLog),\n kvEngine_(kvEngine),\n mgmtd_(mgmtd),\n idAlloc_(idAlloc),\n fileHelper_(fileHelper),\n sessionManager_(sessionManager),\n userStore_(userStore),\n concurrentGcDirSemaphore_(config_.gc().gc_directory_concurrent()),\n concurrentGcFileSemaphore_(config_.gc().gc_file_concurrent()) {\n XLOGF_IF(FATAL, !nodeId_, \"invalid node id {}\", nodeId_);\n guard_ = config_.gc().addCallbackGuard([&]() {\n auto dirConcurrent = config_.gc().gc_directory_concurrent();\n if (dirConcurrent != 0 && dirConcurrent != concurrentGcDirSemaphore_.getUsableTokens()) {\n XLOGF(INFO, \"GcManager set gc directory concurrent to {}\", dirConcurrent);\n concurrentGcDirSemaphore_.changeUsableTokens(dirConcurrent);\n XLOGF(INFO, \"GcManager finished update gc directory concurrent\");\n }\n auto fileConcurrent = config_.gc().gc_file_concurrent();\n if (fileConcurrent != 0 && fileConcurrent != concurrentGcFileSemaphore_.getUsableTokens()) {\n XLOGF(INFO, \"GcManager set gc directory concurrent to {}\", fileConcurrent);\n concurrentGcFileSemaphore_.changeUsableTokens(fileConcurrent);\n XLOGF(INFO, \"GcManager finished update gc file concurrent\");\n }\n });\n }\n\n CoTryTask init();\n\n void start(CPUExecutorGroup &exec);\n void stopAndJoin();\n\n auto &getEventTraceLog() { return metaEventTraceLog_; }\n\n CoTryTask removeEntry(IReadWriteTransaction &txn, const DirEntry &entry, Inode &inode, GcInfo gcInfo);\n\n private:\n template \n FRIEND_TEST(TestRemove, GC);\n\n enum GcEntryType {\n DIRECTORY = 0,\n FILE_MEDIUM,\n FILE_LARGE,\n FILE_SMALL,\n MAX,\n };\n\n class GcDirectory;\n\n struct GcTask {\n std::shared_ptr gcDir;\n GcEntryType type;\n DirEntry taskEntry;\n\n GcTask(std::shared_ptr gcDir, GcEntryType type, DirEntry entry)\n : gcDir(std::move(gcDir)),\n type(type),\n taskEntry(std::move(entry)) {}\n\n static CoTryTask getUserAttr(GcManager &manager, flat::Uid uid);\n\n CoTryTask run(GcManager &manager);\n CoTryTask gcDirectory(GcManager &manager);\n CoTryTask gcFile(GcManager &manager);\n\n CoTryTask removeEntry(GcManager &manager,\n IReadWriteTransaction &txn,\n const DirEntry &entry,\n const flat::UserAttr &user);\n CoTryTask removeGcEntryAndInode(GcManager &manager, IReadWriteTransaction &txn);\n CoTryTask createOrphanEntry(GcManager &manager,\n IReadWriteTransaction &txn,\n const DirEntry &entry,\n const Inode &inode,\n const flat::UserAttr &user);\n };\n\n class GcDirectory : folly::MoveOnly, public std::enable_shared_from_this {\n public:\n using Ptr = std::shared_ptr;\n\n static char prefixOf(GcEntryType type) {\n switch (type) {\n case DIRECTORY:\n return 'd';\n case FILE_MEDIUM:\n return 'f';\n case FILE_LARGE:\n return 'L';\n case FILE_SMALL:\n return 'S';\n default:\n XLOGF(FATAL, \"invalid type {}\", (int)type);\n }\n }\n\n int8_t priorityOf(GcEntryType type) {\n switch (type) {\n case DIRECTORY:\n return folly::Executor::MID_PRI;\n case FILE_MEDIUM:\n return folly::Executor::MID_PRI;\n case FILE_LARGE:\n return folly::Executor::HI_PRI;\n case FILE_SMALL:\n return folly::Executor::LO_PRI;\n default:\n XLOGF(FATAL, \"invalid type {}\", (int)type);\n }\n }\n\n static std::string nameOf(flat::NodeId nodeId, size_t idx) {\n return idx == 0 ? fmt::format(\"GC-Node-{}\", (uint32_t)nodeId)\n : fmt::format(\"GC-Node-{}.{}\", (uint32_t)nodeId, idx);\n }\n\n GcDirectory(DirEntry entry)\n : entry_(std::move(entry)) {}\n ~GcDirectory() { stopAndJoin(); }\n\n void start(GcManager &manager, CPUExecutorGroup &exec);\n void stopAndJoin();\n\n auto dirId() const { return entry_.id; }\n std::string name() const { return entry_.name; }\n\n CoTryTask add(auto &txn, const Inode &inode, const GcConfig &config, GcInfo gcInfo);\n void finish(const GcTask &task);\n\n CoTryTask moveToTail(auto &txn, const GcTask &task, Duration delay);\n\n private:\n struct QueueState {\n folly::Synchronized, std::mutex> queued;\n folly::Synchronized, std::mutex> finished;\n std::atomic counter{0};\n };\n\n CoTask scan(GcManager &manager, GcEntryType type);\n CoTryTask scan(GcManager &manager,\n GcEntryType type,\n Duration delay,\n size_t limit,\n std::optional &prev);\n CoTryTask addFile(auto &txn, const Inode &inode, const GcConfig &config);\n CoTryTask addDirectory(auto &txn, const Inode &inode, GcInfo gcInfo);\n\n DirEntry entry_; // entry points to this GcDirectory\n std::array states_;\n CancellationSource cancel_;\n CountDownLatch<> latch_;\n };\n\n const std::vector &currGcDirectories() const { return currGcDirectories_; }\n\n GcDirectory::Ptr pickGcDirectory() {\n XLOGF_IF(FATAL, currGcDirectories_.empty(), \"currGcDirectories_.empty()\");\n if (config_.gc().distributed_gc()) {\n auto guard = allGcDirectories_.rlock();\n if (!guard->empty()) {\n return guard->at(folly::Random::rand64(guard->size()));\n }\n }\n if (currGcDirectories_.size() == 1) {\n return currGcDirectories_[0];\n } else {\n return currGcDirectories_[folly::Random::rand32(1, currGcDirectories_.size())];\n }\n }\n\n bool enableGcDelay() const;\n\n CoTryTask checkFs();\n CoTryTask> openGcDirectory(size_t idx, bool create);\n CoTryTask scanAllGcDirectories();\n\n CoTask runGcTask(GcTask task);\n\n template \n std::invoke_result_t runReadOnly(H &&handler) {\n auto retry = kv::FDBRetryStrategy({1_s, 10, true});\n co_return co_await kv::WithTransaction(retry).run(kvEngine_->createReadonlyTransaction(), std::forward(handler));\n }\n\n template \n std::invoke_result_t runReadWrite(H &&handler) {\n auto retry = kv::FDBRetryStrategy({1_s, 10, true});\n co_return co_await kv::WithTransaction(retry).run(kvEngine_->createReadWriteTransaction(),\n std::forward(handler));\n }\n\n const Config &config_;\n std::unique_ptr guard_;\n flat::NodeId nodeId_;\n analytics::StructuredTraceLog &metaEventTraceLog_;\n std::shared_ptr kvEngine_;\n std::shared_ptr mgmtd_;\n std::shared_ptr idAlloc_;\n std::shared_ptr fileHelper_;\n std::shared_ptr sessionManager_;\n std::shared_ptr userStore_;\n\n std::vector currGcDirectories_;\n folly::Synchronized> allGcDirectories_;\n\n std::unique_ptr gcRunner_;\n std::unique_ptr> gcWorkers_;\n Semaphore concurrentGcDirSemaphore_;\n Semaphore concurrentGcFileSemaphore_;\n};\n\n} // namespace hf3fs::meta::server\n"], ["/3FS/src/common/net/ib/RDMABuf.h", "#pragma once\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common/net/ib/IBDevice.h\"\n#include \"common/serde/Serde.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Result.h\"\n\nnamespace hf3fs::net {\n\nusing RDMABufMR = ibv_mr *;\n\nclass RDMARemoteBuf {\n struct Rkey {\n uint32_t rkey = 0;\n int devId = -1;\n\n bool operator==(const Rkey &) const = default;\n };\n\n public:\n RDMARemoteBuf()\n : addr_(0),\n length_(0),\n rkeys_() {}\n\n RDMARemoteBuf(uint64_t addr, size_t length, std::array rkeys)\n : addr_(addr),\n length_(length),\n rkeys_(rkeys) {}\n\n ~RDMARemoteBuf() = default;\n\n uint64_t addr() const { return addr_; }\n size_t size() const { return length_; }\n\n std::optional getRkey(int devId) const {\n for (auto &rkey : rkeys_) {\n if (rkey.devId == devId) {\n return rkey.rkey;\n }\n }\n return std::nullopt;\n }\n\n bool advance(size_t len) {\n if (UNLIKELY(length_ < len)) {\n return false;\n }\n addr_ += len;\n length_ -= len;\n return true;\n }\n bool subtract(size_t n) {\n if (UNLIKELY(n > size())) {\n return false;\n }\n length_ -= n;\n return true;\n }\n\n RDMARemoteBuf subrange(size_t offset, size_t len) const {\n if (UNLIKELY(offset + len > length_)) {\n return RDMARemoteBuf();\n }\n RDMARemoteBuf remote = *this;\n remote.addr_ = addr_ + offset;\n remote.length_ = len;\n return remote;\n }\n\n RDMARemoteBuf first(size_t len) const { return subrange(0, len); }\n RDMARemoteBuf takeFirst(size_t len) {\n auto buf = first(len);\n advance(len);\n return buf;\n }\n\n RDMARemoteBuf last(size_t len) const {\n if (UNLIKELY(len > length_)) {\n return RDMARemoteBuf();\n }\n return subrange(length_ - len, len);\n }\n RDMARemoteBuf takeLast(size_t len) {\n auto buf = last(len);\n subtract(len);\n return buf;\n }\n\n bool valid() const { return addr_ != 0; }\n explicit operator bool() const { return valid(); }\n\n bool operator==(const RDMARemoteBuf &o) const = default;\n\n auto &rkeys() { return rkeys_; }\n const auto &rkeys() const { return rkeys_; }\n\n private:\n friend class RDMABuf;\n FRIEND_TEST(TestRDMARemoteBuf, Basic);\n FRIEND_TEST(TestIBSocket, RDMAFailure);\n\n uint64_t addr_;\n uint64_t length_;\n std::array rkeys_;\n};\n\nclass RDMABufPool;\n\nclass RDMABuf {\n public:\n RDMABuf()\n : RDMABuf(nullptr, nullptr, 0) {}\n\n RDMABuf(const RDMABuf &) = default;\n RDMABuf(RDMABuf &&) = default;\n\n RDMABuf &operator=(const RDMABuf &) = default;\n RDMABuf &operator=(RDMABuf &&) = default;\n\n static RDMABuf allocate(size_t size) { return allocate(size, {}); }\n\n bool valid() const { return buf_ != nullptr; }\n explicit operator bool() const { return valid(); }\n auto raw() const { return buf_.get(); }\n\n const uint8_t *ptr() const { return begin_; }\n uint8_t *ptr() { return begin_; }\n\n size_t capacity() const { return buf_ ? buf_->capacity() : 0; }\n size_t size() const { return length_; }\n bool empty() const { return size() == 0; }\n\n bool contains(const uint8_t *data, uint32_t len) const { return ptr() <= data && data + len <= ptr() + capacity(); }\n\n void resetRange() {\n if (LIKELY(buf_ != nullptr)) {\n begin_ = buf_->ptr();\n length_ = buf_->capacity();\n }\n }\n\n bool advance(size_t n) {\n if (UNLIKELY(n > size())) {\n return false;\n }\n begin_ += n;\n length_ -= n;\n return true;\n }\n bool subtract(size_t n) {\n if (UNLIKELY(n > size())) {\n return false;\n }\n length_ -= n;\n return true;\n }\n\n RDMABuf subrange(size_t offset, size_t length) const {\n if (UNLIKELY(offset + length > size())) {\n return RDMABuf();\n }\n return RDMABuf(buf_, begin_ + offset, length);\n }\n\n RDMABuf first(size_t length) const { return subrange(0, length); }\n RDMABuf takeFirst(size_t length) {\n auto buf = first(length);\n advance(length);\n return buf;\n }\n\n RDMABuf last(size_t length) const {\n if (UNLIKELY(length > size())) {\n return RDMABuf();\n }\n return subrange(size() - length, length);\n }\n RDMABuf takeLast(size_t length) {\n auto buf = last(length);\n subtract(length);\n return buf;\n }\n\n RDMABufMR getMR(int dev) const {\n if (UNLIKELY(buf_ == nullptr)) {\n return RDMABufMR();\n }\n return buf_->getMR(dev);\n }\n\n RDMARemoteBuf toRemoteBuf() const {\n std::array rkeys;\n if (UNLIKELY(!buf_ || !buf_->getRkeys(rkeys))) {\n return RDMARemoteBuf();\n }\n return RDMARemoteBuf((uint64_t)begin_, length_, rkeys);\n }\n\n operator RDMARemoteBuf() { return toRemoteBuf(); }\n\n operator std::span() const { return {ptr(), size()}; }\n operator std::span() { return {ptr(), size()}; }\n\n operator folly::MutableByteRange() { return {ptr(), size()}; }\n operator folly::ByteRange() const { return {ptr(), size()}; }\n\n bool operator==(const RDMABuf &o) const = default;\n\n private:\n friend class RDMABufPool;\n\n class Inner : folly::MoveOnly {\n public:\n static constexpr int kAccessFlags =\n IBV_ACCESS_LOCAL_WRITE | IBV_ACCESS_REMOTE_WRITE | IBV_ACCESS_REMOTE_READ | IBV_ACCESS_RELAXED_ORDERING;\n\n Inner(size_t capacity)\n : Inner(std::weak_ptr(), capacity) {}\n\n Inner(std::weak_ptr pool, size_t capacity)\n : pool_(std::move(pool)),\n ptr_(nullptr),\n capacity_(capacity),\n mrs_(),\n userBuffer_(false) {}\n\n Inner(uint8_t *buf, size_t len)\n : pool_(std::weak_ptr()),\n ptr_(buf),\n capacity_(len),\n mrs_(),\n userBuffer_(true) {}\n\n Inner(Inner &&o)\n : pool_(std::move(o.pool_)),\n ptr_(std::exchange(o.ptr_, nullptr)),\n capacity_(std::exchange(o.capacity_, 0)),\n mrs_(std::exchange(o.mrs_, std::array())),\n userBuffer_(std::exchange(o.userBuffer_, false)) {}\n\n ~Inner();\n\n static void deallocate(Inner *ptr);\n\n int init();\n int allocateMemory();\n int registerMemory();\n\n RDMABufMR getMR(int dev) const;\n bool getRkeys(std::array &rkeys) const;\n\n const uint8_t *ptr() const { return ptr_; }\n uint8_t *ptr() { return ptr_; }\n size_t capacity() const { return capacity_; }\n\n private:\n std::weak_ptr pool_;\n uint8_t *ptr_;\n size_t capacity_;\n std::array mrs_;\n bool userBuffer_;\n };\n\n static RDMABuf allocate(size_t size, std::weak_ptr pool);\n\n public:\n RDMABuf(Inner *buf)\n : RDMABuf(std::shared_ptr(buf, Inner::deallocate)) {}\n\n RDMABuf(std::shared_ptr buf)\n : buf_(std::move(buf)) {\n begin_ = buf_->ptr();\n length_ = buf_->capacity();\n }\n\n RDMABuf(std::shared_ptr buf, uint8_t *begin, size_t length)\n : buf_(std::move(buf)),\n begin_(begin),\n length_(length) {}\n\n static RDMABuf createFromUserBuffer(uint8_t *buf, size_t len);\n\n private:\n std::shared_ptr buf_;\n uint8_t *begin_;\n size_t length_;\n};\n\nclass RDMABufPool : public std::enable_shared_from_this, folly::MoveOnly {\n struct PrivateTag {};\n\n public:\n RDMABufPool(PrivateTag, size_t bufSize, size_t bufCnt)\n : bufSize_(bufSize),\n bufAllocated_(0),\n sem_(bufCnt),\n mutex_(),\n freeList_() {}\n\n ~RDMABufPool();\n\n static std::shared_ptr create(size_t bufSize, size_t bufCnt) {\n return std::make_shared(PrivateTag(), bufSize, bufCnt);\n }\n\n CoTask allocate(std::optional timeout = std::nullopt);\n void deallocate(RDMABuf::Inner *buf);\n\n size_t bufSize() const { return bufSize_; }\n size_t freeCnt() const { return sem_.getAvailableTokens(); }\n size_t totalCnt() const { return sem_.getCapacity(); }\n\n private:\n size_t bufSize_;\n std::atomic bufAllocated_;\n\n folly::fibers::Semaphore sem_;\n std::mutex mutex_;\n std::deque freeList_;\n};\n\n} // namespace hf3fs::net\n\ntemplate <>\nstruct ::hf3fs::serde::SerdeMethod<::hf3fs::net::RDMARemoteBuf> {\n static constexpr auto serialize(const net::RDMARemoteBuf &buf, auto &out) {\n uint8_t len = 0;\n for (auto &rkey : buf.rkeys()) {\n if (rkey.devId == -1) {\n break;\n } else {\n ++len;\n }\n }\n\n for (int8_t i = len - 1; i >= 0; --i) {\n serde::serialize(buf.rkeys()[i].devId, out);\n serde::serialize(buf.rkeys()[i].rkey, out);\n }\n serde::serialize(len, out);\n\n serde::serialize(buf.size(), out);\n serde::serialize(buf.addr(), out);\n }\n\n static Result deserialize(net::RDMARemoteBuf &buf, auto &&in) {\n uint64_t addr;\n uint64_t size;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(addr, in));\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(size, in));\n\n int8_t len;\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(len, in));\n\n auto rkeys = buf.rkeys();\n for (auto &rkey : rkeys) {\n if (len-- > 0) {\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(rkey.rkey, in));\n RETURN_AND_LOG_ON_ERROR(serde::deserialize(rkey.devId, in));\n } else {\n rkey.devId = -1;\n }\n }\n buf = net::RDMARemoteBuf(addr, size, rkeys);\n return Void{};\n }\n\n static auto serializeReadable(const net::RDMARemoteBuf &buf, auto &out) {\n auto start = out.tableBegin(false);\n {\n out.key(\"addr\");\n serde::serialize(buf.addr(), out);\n out.key(\"size\");\n serde::serialize(buf.size(), out);\n\n out.key(\"rkeys\");\n out.arrayBegin();\n {\n for (auto &rkey : buf.rkeys()) {\n if (rkey.devId == -1) {\n break;\n }\n\n auto start = out.tableBegin(false);\n out.key(\"rkey\");\n serde::serialize(rkey.rkey, out);\n out.key(\"devId\");\n serde::serialize(rkey.devId, out);\n out.tableEnd(start);\n }\n }\n out.arrayEnd(0);\n }\n out.tableEnd(start);\n };\n\n static std::string serdeToReadable(const net::RDMARemoteBuf &rdmabuf) { return serde::toJsonString(rdmabuf); }\n\n static Result serdeFromReadable(const std::string &str) {\n net::RDMARemoteBuf rdmabuf;\n auto result = serde::fromJsonString(rdmabuf, str);\n if (result) return rdmabuf;\n return makeError(result.error());\n }\n};\n"], ["/3FS/src/common/serde/CallContext.h", "#pragma once\n\n#include \"common/net/Transport.h\"\n#include \"common/net/ib/IBSocket.h\"\n#include \"common/serde/MessagePacket.h\"\n#include \"common/utils/Coroutine.h\"\n#include \"common/utils/Size.h\"\n#include \"common/utils/Tracing.h\"\n#include \"common/utils/VersionInfo.h\"\n\nnamespace hf3fs::serde {\n\nclass CallContext {\n public:\n using MethodType = CoTask (CallContext::*)();\n using OnErrorType = Status (CallContext::*)(Status);\n struct ServiceWrapper {\n using MethodGetter = MethodType (*)(uint16_t);\n MethodGetter getter = &CallContext::invalidServiceId;\n OnErrorType onError = &CallContext::serviceOnError;\n void *object = nullptr;\n std::shared_ptr alive = nullptr;\n };\n\n CallContext(MessagePacket<> &packet, net::TransportPtr tr, ServiceWrapper &service)\n : packet_(packet),\n tr_(std::move(tr)),\n service_(service) {}\n\n const auto &packet() { return packet_; }\n auto &transport() const { return tr_; }\n auto &responseOptions() { return responseOptions_; }\n std::string peer() { return LIKELY(tr_ != nullptr) ? tr_->peerIP().str() : std::string{\"null\"}; }\n\n CoTask handle() {\n auto method = service_.getter(packet_.methodId);\n co_await (this->*method)();\n }\n\n CoTask invalidId() {\n XLOGF(INFO, \"method {}:{} not found!\", packet_.serviceId, packet_.methodId);\n onError(makeError(RPCCode::kInvalidMethodID));\n co_return;\n }\n\n template \n CoTask call() {\n // deserialize payload.\n if (packet_.timestamp) {\n packet_.timestamp->serverWaked = UtcClock::now().time_since_epoch().count();\n }\n typename F::ReqType req;\n auto deserializeResult = serde::deserialize(req, packet_.payload);\n if (UNLIKELY(!deserializeResult)) {\n onDeserializeFailed();\n co_return;\n }\n\n // call method.\n auto obj = reinterpret_cast(service_.object);\n auto result = co_await folly::coro::co_awaitTry((obj->*F::method)(*this, req));\n if (UNLIKELY(result.hasException())) {\n XLOGF(FATAL,\n \"Processor has exception: {}, request {}:{} {}\",\n result.exception().what(),\n packet_.serviceId,\n packet_.methodId,\n serde::toJsonString(req));\n co_return;\n }\n if (packet_.timestamp) {\n packet_.timestamp->serverProcessed = UtcClock::now().time_since_epoch().count();\n }\n makeResponse(result.value());\n co_return;\n }\n\n void onError(folly::Unexpected &&status) {\n makeResponse(Result(makeError((this->*service_.onError)(std::move(status.error())))));\n }\n\n Status serviceOnError(Status status) { return status; }\n\n template \n Status customOnError(Status status) {\n auto obj = reinterpret_cast(service_.object);\n return (obj->*Method)(std::move(status));\n }\n\n void onDeserializeFailed();\n\n tracing::Points &tracingPoints() { return tracingPoints_; }\n\n class RDMATransmission {\n public:\n RDMATransmission(CallContext &ctx, ibv_wr_opcode opcode)\n : ctx_(ctx),\n batch_(ctx_.tr_->ibSocket(), opcode) {}\n\n Result add(const net::RDMARemoteBuf &remoteBuf, net::RDMABuf localBuf) {\n return batch_.add(remoteBuf, localBuf);\n }\n\n CoTask applyTransmission(Duration timeout);\n\n CoTryTask post() { return batch_.post(); }\n\n private:\n CallContext &ctx_;\n net::IBSocket::RDMAReqBatch batch_;\n };\n\n RDMATransmission readTransmission() { return RDMATransmission{*this, IBV_WR_RDMA_READ}; }\n RDMATransmission writeTransmission() { return RDMATransmission{*this, IBV_WR_RDMA_WRITE}; }\n\n private:\n static MethodType invalidServiceId(uint16_t) { return &CallContext::invalidId; }\n\n void makeResponse(const auto &payload) {\n MessagePacket send(payload);\n send.uuid = packet_.uuid;\n send.serviceId = packet_.serviceId;\n send.methodId = packet_.methodId;\n send.flags = 0;\n send.version = packet_.version;\n send.timestamp = packet_.timestamp;\n tr_->send(net::WriteList(net::WriteItem::createMessage(send, responseOptions_)));\n }\n\n private:\n MessagePacket<> &packet_;\n net::TransportPtr tr_;\n ServiceWrapper &service_;\n\n net::CoreRequestOptions responseOptions_;\n tracing::Points tracingPoints_;\n};\n\n} // namespace hf3fs::serde\n"], ["/3FS/src/common/utils/RobinHood.h", "// ______ _____ ______ _________\n// ______________ ___ /_ ___(_)_______ ___ /_ ______ ______ ______ /\n// __ ___/_ __ \\__ __ \\__ / __ __ \\ __ __ \\_ __ \\_ __ \\_ __ /\n// _ / / /_/ /_ /_/ /_ / _ / / / _ / / // /_/ // /_/ // /_/ /\n// /_/ \\____/ /_.___/ /_/ /_/ /_/ ________/_/ /_/ \\____/ \\____/ \\__,_/\n// _/_____/\n//\n// Fast & memory efficient hashtable based on robin hood hashing for C++11/14/17/20\n// https://github.com/martinus/robin-hood-hashing\n//\n// Licensed under the MIT License .\n// SPDX-License-Identifier: MIT\n// Copyright (c) 2018-2021 Martin Ankerl \n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef ROBIN_HOOD_H_INCLUDED\n#define ROBIN_HOOD_H_INCLUDED\n\n// see https://semver.org/\n#define ROBIN_HOOD_VERSION_MAJOR 3 // for incompatible API changes\n#define ROBIN_HOOD_VERSION_MINOR 11 // for adding functionality in a backwards-compatible manner\n#define ROBIN_HOOD_VERSION_PATCH 5 // for backwards-compatible bug fixes\n\n#include \n#include \n#include \n#include \n#include \n#include // only to support hash of smart pointers\n#include \n#include \n#include \n#include \n\n#include \"memory/common/GlobalMemoryAllocator.h\"\n\n#if __cplusplus >= 201703L\n#include \n#endif\n\n// #define ROBIN_HOOD_LOG_ENABLED\n#ifdef ROBIN_HOOD_LOG_ENABLED\n#include \n#define ROBIN_HOOD_LOG(...) std::cout << __FUNCTION__ << \"@\" << __LINE__ << \": \" << __VA_ARGS__ << std::endl;\n#else\n#define ROBIN_HOOD_LOG(x)\n#endif\n\n// #define ROBIN_HOOD_TRACE_ENABLED\n#ifdef ROBIN_HOOD_TRACE_ENABLED\n#include \n#define ROBIN_HOOD_TRACE(...) std::cout << __FUNCTION__ << \"@\" << __LINE__ << \": \" << __VA_ARGS__ << std::endl;\n#else\n#define ROBIN_HOOD_TRACE(x)\n#endif\n\n// #define ROBIN_HOOD_COUNT_ENABLED\n#ifdef ROBIN_HOOD_COUNT_ENABLED\n#include \n#define ROBIN_HOOD_COUNT(x) ++counts().x;\nnamespace robin_hood {\nstruct Counts {\n uint64_t shiftUp{};\n uint64_t shiftDown{};\n};\ninline std::ostream &operator<<(std::ostream &os, Counts const &c) {\n return os << c.shiftUp << \" shiftUp\" << std::endl << c.shiftDown << \" shiftDown\" << std::endl;\n}\n\nstatic Counts &counts() {\n static Counts counts{};\n return counts;\n}\n} // namespace robin_hood\n#else\n#define ROBIN_HOOD_COUNT(x)\n#endif\n\n// all non-argument macros should use this facility. See\n// https://www.fluentcpp.com/2019/05/28/better-macros-better-flags/\n#define ROBIN_HOOD(x) ROBIN_HOOD_PRIVATE_DEFINITION_##x()\n\n// mark unused members with this macro\n#define ROBIN_HOOD_UNUSED(identifier)\n\n// bitness\n#if SIZE_MAX == UINT32_MAX\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BITNESS() 32\n#elif SIZE_MAX == UINT64_MAX\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BITNESS() 64\n#else\n#error Unsupported bitness\n#endif\n\n// endianess\n#ifdef _MSC_VER\n#define ROBIN_HOOD_PRIVATE_DEFINITION_LITTLE_ENDIAN() 1\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BIG_ENDIAN() 0\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_LITTLE_ENDIAN() (__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BIG_ENDIAN() (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)\n#endif\n\n// inline\n#ifdef _MSC_VER\n#define ROBIN_HOOD_PRIVATE_DEFINITION_NOINLINE() __declspec(noinline)\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_NOINLINE() __attribute__((noinline))\n#endif\n\n// exceptions\n#if !defined(__cpp_exceptions) && !defined(__EXCEPTIONS) && !defined(_CPPUNWIND)\n#define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_EXCEPTIONS() 0\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_EXCEPTIONS() 1\n#endif\n\n// count leading/trailing bits\n#if !defined(ROBIN_HOOD_DISABLE_INTRINSICS)\n#ifdef _MSC_VER\n#if ROBIN_HOOD(BITNESS) == 32\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BITSCANFORWARD() _BitScanForward\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BITSCANFORWARD() _BitScanForward64\n#endif\n#include \n#pragma intrinsic(ROBIN_HOOD(BITSCANFORWARD))\n#define ROBIN_HOOD_COUNT_TRAILING_ZEROES(x) \\\n [](size_t mask) noexcept -> int { \\\n unsigned long index; \\\n return ROBIN_HOOD(BITSCANFORWARD)(&index, mask) ? static_cast(index) : ROBIN_HOOD(BITNESS); \\\n }(x)\n#else\n#if ROBIN_HOOD(BITNESS) == 32\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CTZ() __builtin_ctzl\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CLZ() __builtin_clzl\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CTZ() __builtin_ctzll\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CLZ() __builtin_clzll\n#endif\n#define ROBIN_HOOD_COUNT_LEADING_ZEROES(x) ((x) ? ROBIN_HOOD(CLZ)(x) : ROBIN_HOOD(BITNESS))\n#define ROBIN_HOOD_COUNT_TRAILING_ZEROES(x) ((x) ? ROBIN_HOOD(CTZ)(x) : ROBIN_HOOD(BITNESS))\n#endif\n#endif\n\n// fallthrough\n#ifndef __has_cpp_attribute // For backwards compatibility\n#define __has_cpp_attribute(x) 0\n#endif\n#if __has_cpp_attribute(clang::fallthrough)\n#define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH() [[clang::fallthrough]]\n#elif __has_cpp_attribute(gnu::fallthrough)\n#define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH() [[gnu::fallthrough]]\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_FALLTHROUGH()\n#endif\n\n// likely/unlikely\n#ifdef _MSC_VER\n#define ROBIN_HOOD_LIKELY(condition) condition\n#define ROBIN_HOOD_UNLIKELY(condition) condition\n#else\n#define ROBIN_HOOD_LIKELY(condition) __builtin_expect(condition, 1)\n#define ROBIN_HOOD_UNLIKELY(condition) __builtin_expect(condition, 0)\n#endif\n\n// detect if native wchar_t type is availiable in MSVC\n#ifdef _MSC_VER\n#ifdef _NATIVE_WCHAR_T_DEFINED\n#define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 1\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 0\n#endif\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_HAS_NATIVE_WCHART() 1\n#endif\n\n// detect if MSVC supports the pair(std::piecewise_construct_t,...) consructor being constexpr\n#ifdef _MSC_VER\n#if _MSC_VER <= 1900\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 1\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 0\n#endif\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_BROKEN_CONSTEXPR() 0\n#endif\n\n// helpers for C++ versions, see https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX() __cplusplus\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX98() 199711L\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX11() 201103L\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX14() 201402L\n#define ROBIN_HOOD_PRIVATE_DEFINITION_CXX17() 201703L\n\n#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX17)\n#define ROBIN_HOOD_PRIVATE_DEFINITION_NODISCARD() [[nodiscard]]\n#else\n#define ROBIN_HOOD_PRIVATE_DEFINITION_NODISCARD()\n#endif\n\nnamespace robin_hood {\n\n#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX14)\n#define ROBIN_HOOD_STD std\n#else\n\n// c++11 compatibility layer\nnamespace ROBIN_HOOD_STD {\ntemplate \nstruct alignment_of : std::integral_constant::type)> {};\n\ntemplate \nclass integer_sequence {\n public:\n using value_type = T;\n static_assert(std::is_integral::value, \"not integral type\");\n static constexpr std::size_t size() noexcept { return sizeof...(Ints); }\n};\ntemplate \nusing index_sequence = integer_sequence;\n\nnamespace detail_ {\ntemplate \nstruct IntSeqImpl {\n using TValue = T;\n static_assert(std::is_integral::value, \"not integral type\");\n static_assert(Begin >= 0 && Begin < End, \"unexpected argument (Begin<0 || Begin<=End)\");\n\n template \n struct IntSeqCombiner;\n\n template \n struct IntSeqCombiner, integer_sequence> {\n using TResult = integer_sequence;\n };\n\n using TResult = typename IntSeqCombiner<\n typename IntSeqImpl::TResult,\n typename IntSeqImpl::TResult>::TResult;\n};\n\ntemplate \nstruct IntSeqImpl {\n using TValue = T;\n static_assert(std::is_integral::value, \"not integral type\");\n static_assert(Begin >= 0, \"unexpected argument (Begin<0)\");\n using TResult = integer_sequence;\n};\n\ntemplate \nstruct IntSeqImpl {\n using TValue = T;\n static_assert(std::is_integral::value, \"not integral type\");\n static_assert(Begin >= 0, \"unexpected argument (Begin<0)\");\n using TResult = integer_sequence;\n};\n} // namespace detail_\n\ntemplate \nusing make_integer_sequence = typename detail_::IntSeqImpl::TResult;\n\ntemplate \nusing make_index_sequence = make_integer_sequence;\n\ntemplate \nusing index_sequence_for = make_index_sequence;\n\n} // namespace ROBIN_HOOD_STD\n\n#endif\n\nnamespace detail {\n\n// make sure we static_cast to the correct type for hash_int\n#if ROBIN_HOOD(BITNESS) == 64\nusing SizeT = uint64_t;\n#else\nusing SizeT = uint32_t;\n#endif\n\ntemplate \nT rotr(T x, unsigned k) {\n return (x >> k) | (x << (8U * sizeof(T) - k));\n}\n\n// This cast gets rid of warnings like \"cast from 'uint8_t*' {aka 'unsigned char*'} to\n// 'uint64_t*' {aka 'long unsigned int*'} increases required alignment of target type\". Use with\n// care!\ntemplate \ninline T reinterpret_cast_no_cast_align_warning(void *ptr) noexcept {\n return reinterpret_cast(ptr);\n}\n\ntemplate \ninline T reinterpret_cast_no_cast_align_warning(void const *ptr) noexcept {\n return reinterpret_cast(ptr);\n}\n\n// make sure this is not inlined as it is slow and dramatically enlarges code, thus making other\n// inlinings more difficult. Throws are also generally the slow path.\ntemplate \n[[noreturn]] ROBIN_HOOD(NOINLINE)\n#if ROBIN_HOOD(HAS_EXCEPTIONS)\n void doThrow(Args &&...args) {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)\n throw E(std::forward(args)...);\n}\n#else\n void doThrow(Args &&...ROBIN_HOOD_UNUSED(args) /*unused*/) {\n abort();\n}\n#endif\n\ntemplate \nT *assertNotNull(T *t, Args &&...args) {\n if (ROBIN_HOOD_UNLIKELY(nullptr == t)) {\n doThrow(std::forward(args)...);\n }\n return t;\n}\n\ntemplate \ninline T unaligned_load(void const *ptr) noexcept {\n // using memcpy so we don't get into unaligned load problems.\n // compiler should optimize this very well anyways.\n T t;\n std::memcpy(&t, ptr, sizeof(T));\n return t;\n}\n\n// Allocates bulks of memory for objects of type T. This deallocates the memory in the destructor,\n// and keeps a linked list of the allocated memory around. Overhead per allocation is the size of a\n// pointer.\ntemplate \nclass BulkPoolAllocator {\n public:\n BulkPoolAllocator() noexcept = default;\n\n // does not copy anything, just creates a new allocator.\n BulkPoolAllocator(const BulkPoolAllocator &ROBIN_HOOD_UNUSED(o) /*unused*/) noexcept\n : mHead(nullptr),\n mListForFree(nullptr) {}\n\n BulkPoolAllocator(BulkPoolAllocator &&o) noexcept\n : mHead(o.mHead),\n mListForFree(o.mListForFree) {\n o.mListForFree = nullptr;\n o.mHead = nullptr;\n }\n\n BulkPoolAllocator &operator=(BulkPoolAllocator &&o) noexcept {\n reset();\n mHead = o.mHead;\n mListForFree = o.mListForFree;\n o.mListForFree = nullptr;\n o.mHead = nullptr;\n return *this;\n }\n\n BulkPoolAllocator &\n // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)\n operator=(const BulkPoolAllocator &ROBIN_HOOD_UNUSED(o) /*unused*/) noexcept {\n // does not do anything\n return *this;\n }\n\n ~BulkPoolAllocator() noexcept { reset(); }\n\n // Deallocates all allocated memory.\n void reset() noexcept {\n while (mListForFree) {\n T *tmp = *mListForFree;\n ROBIN_HOOD_LOG(\"hf3fs::memory::deallocate\")\n hf3fs::memory::deallocate(mListForFree);\n mListForFree = reinterpret_cast_no_cast_align_warning(tmp);\n }\n mHead = nullptr;\n }\n\n // allocates, but does NOT initialize. Use in-place new constructor, e.g.\n // T* obj = pool.allocate();\n // ::new (static_cast(obj)) T();\n T *allocate() {\n T *tmp = mHead;\n if (!tmp) {\n tmp = performAllocation();\n }\n\n mHead = *reinterpret_cast_no_cast_align_warning(tmp);\n return tmp;\n }\n\n // does not actually deallocate but puts it in store.\n // make sure you have already called the destructor! e.g. with\n // obj->~T();\n // pool.deallocate(obj);\n void deallocate(T *obj) noexcept {\n *reinterpret_cast_no_cast_align_warning(obj) = mHead;\n mHead = obj;\n }\n\n // Adds an already allocated block of memory to the allocator. This allocator is from now on\n // responsible for freeing the data (with free()). If the provided data is not large enough to\n // make use of, it is immediately freed. Otherwise it is reused and freed in the destructor.\n void addOrFree(void *ptr, const size_t numBytes) noexcept {\n // calculate number of available elements in ptr\n if (numBytes < ALIGNMENT + ALIGNED_SIZE) {\n // not enough data for at least one element. Free and return.\n ROBIN_HOOD_LOG(\"hf3fs::memory::deallocate\")\n hf3fs::memory::deallocate(ptr);\n } else {\n ROBIN_HOOD_LOG(\"add to buffer\")\n add(ptr, numBytes);\n }\n }\n\n void swap(BulkPoolAllocator &other) noexcept {\n using std::swap;\n swap(mHead, other.mHead);\n swap(mListForFree, other.mListForFree);\n }\n\n private:\n // iterates the list of allocated memory to calculate how many to alloc next.\n // Recalculating this each time saves us a size_t member.\n // This ignores the fact that memory blocks might have been added manually with addOrFree. In\n // practice, this should not matter much.\n ROBIN_HOOD(NODISCARD) size_t calcNumElementsToAlloc() const noexcept {\n auto tmp = mListForFree;\n size_t numAllocs = MinNumAllocs;\n\n while (numAllocs * 2 <= MaxNumAllocs && tmp) {\n auto x = reinterpret_cast(tmp);\n tmp = *x;\n numAllocs *= 2;\n }\n\n return numAllocs;\n }\n\n // WARNING: Underflow if numBytes < ALIGNMENT! This is guarded in addOrFree().\n void add(void *ptr, const size_t numBytes) noexcept {\n const size_t numElements = (numBytes - ALIGNMENT) / ALIGNED_SIZE;\n\n auto data = reinterpret_cast(ptr);\n\n // link free list\n auto x = reinterpret_cast(data);\n *x = mListForFree;\n mListForFree = data;\n\n // create linked list for newly allocated data\n auto *const headT = reinterpret_cast_no_cast_align_warning(reinterpret_cast(ptr) + ALIGNMENT);\n\n auto *const head = reinterpret_cast(headT);\n\n // Visual Studio compiler automatically unrolls this loop, which is pretty cool\n for (size_t i = 0; i < numElements; ++i) {\n *reinterpret_cast_no_cast_align_warning(head + i * ALIGNED_SIZE) = head + (i + 1) * ALIGNED_SIZE;\n }\n\n // last one points to 0\n *reinterpret_cast_no_cast_align_warning(head + (numElements - 1) * ALIGNED_SIZE) = mHead;\n mHead = headT;\n }\n\n // Called when no memory is available (mHead == 0).\n // Don't inline this slow path.\n ROBIN_HOOD(NOINLINE) T *performAllocation() {\n size_t const numElementsToAlloc = calcNumElementsToAlloc();\n\n // alloc new memory: [prev |T, T, ... T]\n size_t const bytes = ALIGNMENT + ALIGNED_SIZE * numElementsToAlloc;\n ROBIN_HOOD_LOG(\"hf3fs::memory::allocate \" << bytes << \" = \" << ALIGNMENT << \" + \" << ALIGNED_SIZE << \" * \"\n << numElementsToAlloc)\n add(assertNotNull(hf3fs::memory::allocate(bytes)), bytes);\n return mHead;\n }\n\n // enforce byte alignment of the T's\n#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX14)\n static constexpr size_t ALIGNMENT = (std::max)(std::alignment_of::value, std::alignment_of::value);\n#else\n static const size_t ALIGNMENT = (ROBIN_HOOD_STD::alignment_of::value > ROBIN_HOOD_STD::alignment_of::value)\n ? ROBIN_HOOD_STD::alignment_of::value\n : +ROBIN_HOOD_STD::alignment_of::value; // the + is for walkarround\n#endif\n\n static constexpr size_t ALIGNED_SIZE = ((sizeof(T) - 1) / ALIGNMENT + 1) * ALIGNMENT;\n\n static_assert(MinNumAllocs >= 1, \"MinNumAllocs\");\n static_assert(MaxNumAllocs >= MinNumAllocs, \"MaxNumAllocs\");\n static_assert(ALIGNED_SIZE >= sizeof(T *), \"ALIGNED_SIZE\");\n static_assert(0 == (ALIGNED_SIZE % sizeof(T *)), \"ALIGNED_SIZE mod\");\n static_assert(ALIGNMENT >= sizeof(T *), \"ALIGNMENT\");\n\n T *mHead{nullptr};\n T **mListForFree{nullptr};\n};\n\ntemplate \nstruct NodeAllocator;\n\n// dummy allocator that does nothing\ntemplate \nstruct NodeAllocator {\n // we are not using the data, so just free it.\n void addOrFree(void *ptr, size_t ROBIN_HOOD_UNUSED(numBytes) /*unused*/) noexcept {\n ROBIN_HOOD_LOG(\"hf3fs::memory::deallocate\")\n hf3fs::memory::deallocate(ptr);\n }\n};\n\ntemplate \nstruct NodeAllocator : public BulkPoolAllocator {};\n\n// c++14 doesn't have is_nothrow_swappable, and clang++ 6.0.1 doesn't like it either, so I'm making\n// my own here.\nnamespace swappable {\n#if ROBIN_HOOD(CXX) < ROBIN_HOOD(CXX17)\nusing std::swap;\ntemplate \nstruct nothrow {\n static const bool value = noexcept(swap(std::declval(), std::declval()));\n};\n#else\ntemplate \nstruct nothrow {\n static const bool value = std::is_nothrow_swappable::value;\n};\n#endif\n} // namespace swappable\n\n} // namespace detail\n\nstruct is_transparent_tag {};\n\n// A custom pair implementation is used in the map because std::pair is not is_trivially_copyable,\n// which means it would not be allowed to be used in std::memcpy. This struct is copyable, which is\n// also tested.\ntemplate \nstruct pair {\n using first_type = T1;\n using second_type = T2;\n\n template ::value &&\n std::is_default_constructible::value>::type>\n constexpr pair() noexcept(noexcept(U1()) &&noexcept(U2()))\n : first(),\n second() {}\n\n // pair constructors are explicit so we don't accidentally call this ctor when we don't have to.\n explicit constexpr pair(std::pair const &o) noexcept(\n noexcept(T1(std::declval())) &&noexcept(T2(std::declval())))\n : first(o.first),\n second(o.second) {}\n\n // pair constructors are explicit so we don't accidentally call this ctor when we don't have to.\n explicit constexpr pair(std::pair &&o) noexcept(\n noexcept(T1(std::move(std::declval()))) &&noexcept(T2(std::move(std::declval()))))\n : first(std::move(o.first)),\n second(std::move(o.second)) {}\n\n constexpr pair(T1 &&a, T2 &&b) noexcept(\n noexcept(T1(std::move(std::declval()))) &&noexcept(T2(std::move(std::declval()))))\n : first(std::move(a)),\n second(std::move(b)) {}\n\n template \n constexpr pair(U1 &&a, U2 &&b) noexcept(\n noexcept(T1(std::forward(std::declval()))) &&noexcept(T2(std::forward(std::declval()))))\n : first(std::forward(a)),\n second(std::forward(b)) {}\n\n template \n // MSVC 2015 produces error \"C2476: ‘constexpr’ constructor does not initialize all members\"\n // if this constructor is constexpr\n#if !ROBIN_HOOD(BROKEN_CONSTEXPR)\n constexpr\n#endif\n pair(std::piecewise_construct_t /*unused*/,\n std::tuple a,\n std::tuple b) noexcept(noexcept(pair(std::declval &>(),\n std::declval &>(),\n ROBIN_HOOD_STD::index_sequence_for(),\n ROBIN_HOOD_STD::index_sequence_for())))\n : pair(a, b, ROBIN_HOOD_STD::index_sequence_for(), ROBIN_HOOD_STD::index_sequence_for()) {\n }\n\n // constructor called from the std::piecewise_construct_t ctor\n template \n pair(std::tuple &a,\n std::tuple &b,\n ROBIN_HOOD_STD::index_sequence /*unused*/,\n ROBIN_HOOD_STD::index_sequence<\n I2...> /*unused*/) noexcept(noexcept(T1(std::forward(std::get(std::declval\n &>()))...))\n &&noexcept(T2(\n std::forward(std::get(std::declval &>()))...)))\n : first(std::forward(std::get(a))...),\n second(std::forward(std::get(b))...) {\n // make visual studio compiler happy about warning about unused a & b.\n // Visual studio's pair implementation disables warning 4100.\n (void)a;\n (void)b;\n }\n\n void swap(pair &o) noexcept((detail::swappable::nothrow::value) &&\n (detail::swappable::nothrow::value)) {\n using std::swap;\n swap(first, o.first);\n swap(second, o.second);\n }\n\n T1 first; // NOLINT(misc-non-private-member-variables-in-classes)\n T2 second; // NOLINT(misc-non-private-member-variables-in-classes)\n};\n\ntemplate \ninline void swap(pair &a,\n pair &b) noexcept(noexcept(std::declval &>().swap(std::declval &>()))) {\n a.swap(b);\n}\n\ntemplate \ninline constexpr bool operator==(pair const &x, pair const &y) {\n return (x.first == y.first) && (x.second == y.second);\n}\ntemplate \ninline constexpr bool operator!=(pair const &x, pair const &y) {\n return !(x == y);\n}\ntemplate \ninline constexpr bool operator<(pair const &x, pair const &y) noexcept(\n noexcept(std::declval() < std::declval()) &&noexcept(std::declval() <\n std::declval())) {\n return x.first < y.first || (!(y.first < x.first) && x.second < y.second);\n}\ntemplate \ninline constexpr bool operator>(pair const &x, pair const &y) {\n return y < x;\n}\ntemplate \ninline constexpr bool operator<=(pair const &x, pair const &y) {\n return !(x > y);\n}\ntemplate \ninline constexpr bool operator>=(pair const &x, pair const &y) {\n return !(x < y);\n}\n\ninline size_t hash_bytes(void const *ptr, size_t len) noexcept {\n static constexpr uint64_t m = UINT64_C(0xc6a4a7935bd1e995);\n static constexpr uint64_t seed = UINT64_C(0xe17a1465);\n static constexpr unsigned int r = 47;\n\n auto const *const data64 = static_cast(ptr);\n uint64_t h = seed ^ (len * m);\n\n size_t const n_blocks = len / 8;\n for (size_t i = 0; i < n_blocks; ++i) {\n auto k = detail::unaligned_load(data64 + i);\n\n k *= m;\n k ^= k >> r;\n k *= m;\n\n h ^= k;\n h *= m;\n }\n\n auto const *const data8 = reinterpret_cast(data64 + n_blocks);\n switch (len & 7U) {\n case 7:\n h ^= static_cast(data8[6]) << 48U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 6:\n h ^= static_cast(data8[5]) << 40U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 5:\n h ^= static_cast(data8[4]) << 32U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 4:\n h ^= static_cast(data8[3]) << 24U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 3:\n h ^= static_cast(data8[2]) << 16U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 2:\n h ^= static_cast(data8[1]) << 8U;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n case 1:\n h ^= static_cast(data8[0]);\n h *= m;\n ROBIN_HOOD(FALLTHROUGH); // FALLTHROUGH\n default:\n break;\n }\n\n h ^= h >> r;\n\n // not doing the final step here, because this will be done by keyToIdx anyways\n // h *= m;\n // h ^= h >> r;\n return static_cast(h);\n}\n\ninline size_t hash_int(uint64_t x) noexcept {\n // tried lots of different hashes, let's stick with murmurhash3. It's simple, fast, well tested,\n // and doesn't need any special 128bit operations.\n x ^= x >> 33U;\n x *= UINT64_C(0xff51afd7ed558ccd);\n x ^= x >> 33U;\n\n // not doing the final step here, because this will be done by keyToIdx anyways\n // x *= UINT64_C(0xc4ceb9fe1a85ec53);\n // x ^= x >> 33U;\n return static_cast(x);\n}\n\n// A thin wrapper around std::hash, performing an additional simple mixing step of the result.\ntemplate \nstruct hash : public std::hash {\n size_t operator()(T const &obj) const\n noexcept(noexcept(std::declval>().operator()(std::declval()))) {\n // call base hash\n auto result = std::hash::operator()(obj);\n // return mixed of that, to be save against identity has\n return hash_int(static_cast(result));\n }\n};\n\ntemplate \nstruct hash> {\n size_t operator()(std::basic_string const &str) const noexcept {\n return hash_bytes(str.data(), sizeof(CharT) * str.size());\n }\n};\n\n#if ROBIN_HOOD(CXX) >= ROBIN_HOOD(CXX17)\ntemplate \nstruct hash> {\n size_t operator()(std::basic_string_view const &sv) const noexcept {\n return hash_bytes(sv.data(), sizeof(CharT) * sv.size());\n }\n};\n#endif\n\ntemplate \nstruct hash {\n size_t operator()(T *ptr) const noexcept { return hash_int(reinterpret_cast(ptr)); }\n};\n\ntemplate \nstruct hash> {\n size_t operator()(std::unique_ptr const &ptr) const noexcept {\n return hash_int(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash> {\n size_t operator()(std::shared_ptr const &ptr) const noexcept {\n return hash_int(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash::value>::type> {\n size_t operator()(Enum e) const noexcept {\n using Underlying = typename std::underlying_type::type;\n return hash{}(static_cast(e));\n }\n};\n\n#define ROBIN_HOOD_HASH_INT(T) \\\n template <> \\\n struct hash { \\\n size_t operator()(T const &obj) const noexcept { return hash_int(static_cast(obj)); } \\\n }\n\n#if defined(__GNUC__) && !defined(__clang__)\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wuseless-cast\"\n#endif\n// see https://en.cppreference.com/w/cpp/utility/hash\nROBIN_HOOD_HASH_INT(bool);\nROBIN_HOOD_HASH_INT(char);\nROBIN_HOOD_HASH_INT(signed char);\nROBIN_HOOD_HASH_INT(unsigned char);\nROBIN_HOOD_HASH_INT(char16_t);\nROBIN_HOOD_HASH_INT(char32_t);\n#if ROBIN_HOOD(HAS_NATIVE_WCHART)\nROBIN_HOOD_HASH_INT(wchar_t);\n#endif\nROBIN_HOOD_HASH_INT(short);\nROBIN_HOOD_HASH_INT(unsigned short);\nROBIN_HOOD_HASH_INT(int);\nROBIN_HOOD_HASH_INT(unsigned int);\nROBIN_HOOD_HASH_INT(long);\nROBIN_HOOD_HASH_INT(long long);\nROBIN_HOOD_HASH_INT(unsigned long);\nROBIN_HOOD_HASH_INT(unsigned long long);\n#if defined(__GNUC__) && !defined(__clang__)\n#pragma GCC diagnostic pop\n#endif\nnamespace detail {\n\ntemplate \nstruct void_type {\n using type = void;\n};\n\ntemplate \nstruct has_is_transparent : public std::false_type {};\n\ntemplate \nstruct has_is_transparent::type> : public std::true_type {};\n\n// using wrapper classes for hash and key_equal prevents the diamond problem when the same type\n// is used. see https://stackoverflow.com/a/28771920/48181\ntemplate \nstruct WrapHash : public T {\n WrapHash() = default;\n explicit WrapHash(T const &o) noexcept(noexcept(T(std::declval())))\n : T(o) {}\n};\n\ntemplate \nstruct WrapKeyEqual : public T {\n WrapKeyEqual() = default;\n explicit WrapKeyEqual(T const &o) noexcept(noexcept(T(std::declval())))\n : T(o) {}\n};\n\n// A highly optimized hashmap implementation, using the Robin Hood algorithm.\n//\n// In most cases, this map should be usable as a drop-in replacement for std::unordered_map, but\n// be about 2x faster in most cases and require much less allocations.\n//\n// This implementation uses the following memory layout:\n//\n// [Node, Node, ... Node | info, info, ... infoSentinel ]\n//\n// * Node: either a DataNode that directly has the std::pair as member,\n// or a DataNode with a pointer to std::pair. Which DataNode representation to use\n// depends on how fast the swap() operation is. Heuristically, this is automatically choosen\n// based on sizeof(). there are always 2^n Nodes.\n//\n// * info: Each Node in the map has a corresponding info byte, so there are 2^n info bytes.\n// Each byte is initialized to 0, meaning the corresponding Node is empty. Set to 1 means the\n// corresponding node contains data. Set to 2 means the corresponding Node is filled, but it\n// actually belongs to the previous position and was pushed out because that place is already\n// taken.\n//\n// * infoSentinel: Sentinel byte set to 1, so that iterator's ++ can stop at end() without the\n// need for a idx variable.\n//\n// According to STL, order of templates has effect on throughput. That's why I've moved the\n// boolean to the front.\n// https://www.reddit.com/r/cpp/comments/ahp6iu/compile_time_binary_size_reductions_and_cs_future/eeguck4/\ntemplate \nclass Table\n : public WrapHash,\n public WrapKeyEqual,\n detail::NodeAllocator<\n typename std::conditional::value,\n Key,\n robin_hood::pair::type, T>>::type,\n 4,\n 16384,\n IsFlat> {\n public:\n static constexpr bool is_flat = IsFlat;\n static constexpr bool is_map = !std::is_void::value;\n static constexpr bool is_set = !is_map;\n static constexpr bool is_transparent = has_is_transparent::value && has_is_transparent::value;\n\n using key_type = Key;\n using mapped_type = T;\n using value_type = typename std::\n conditional::type, T>>::type;\n using size_type = size_t;\n using hasher = Hash;\n using key_equal = KeyEqual;\n using Self = Table;\n\n private:\n static_assert(MaxLoadFactor100 > 10 && MaxLoadFactor100 < 100, \"MaxLoadFactor100 needs to be >10 && < 100\");\n\n using WHash = WrapHash;\n using WKeyEqual = WrapKeyEqual;\n\n // configuration defaults\n\n // make sure we have 8 elements, needed to quickly rehash mInfo\n static constexpr size_t InitialNumElements = sizeof(uint64_t);\n static constexpr uint32_t InitialInfoNumBits = 5;\n static constexpr uint8_t InitialInfoInc = 1U << InitialInfoNumBits;\n static constexpr size_t InfoMask = InitialInfoInc - 1U;\n static constexpr uint8_t InitialInfoHashShift = 0;\n using DataPool = detail::NodeAllocator;\n\n // type needs to be wider than uint8_t.\n using InfoType = uint32_t;\n\n // DataNode ////////////////////////////////////////////////////////\n\n // Primary template for the data node. We have special implementations for small and big\n // objects. For large objects it is assumed that swap() is fairly slow, so we allocate these\n // on the heap so swap merely swaps a pointer.\n template \n class DataNode {};\n\n // Small: just allocate on the stack.\n template \n class DataNode final {\n public:\n template \n explicit DataNode(M &ROBIN_HOOD_UNUSED(map) /*unused*/,\n Args &&...args) noexcept(noexcept(value_type(std::forward(args)...)))\n : mData(std::forward(args)...) {}\n\n DataNode(M &ROBIN_HOOD_UNUSED(map) /*unused*/,\n DataNode &&n) noexcept(std::is_nothrow_move_constructible::value)\n : mData(std::move(n.mData)) {}\n\n // doesn't do anything\n void destroy(M &ROBIN_HOOD_UNUSED(map) /*unused*/) noexcept {}\n void destroyDoNotDeallocate() noexcept {}\n\n value_type const *operator->() const noexcept { return &mData; }\n value_type *operator->() noexcept { return &mData; }\n\n const value_type &operator*() const noexcept { return mData; }\n\n value_type &operator*() noexcept { return mData; }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() noexcept {\n return mData.first;\n }\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() noexcept {\n return mData;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() const noexcept {\n return mData.first;\n }\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() const noexcept {\n return mData;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getSecond() noexcept {\n return mData.second;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getSecond() const noexcept {\n return mData.second;\n }\n\n void swap(DataNode &o) noexcept(noexcept(std::declval().swap(std::declval()))) {\n mData.swap(o.mData);\n }\n\n private:\n value_type mData;\n };\n\n // big object: allocate on heap.\n template \n class DataNode {\n public:\n template \n explicit DataNode(M &map, Args &&...args)\n : mData(map.allocate()) {\n ::new (static_cast(mData)) value_type(std::forward(args)...);\n }\n\n DataNode(M &ROBIN_HOOD_UNUSED(map) /*unused*/, DataNode &&n) noexcept\n : mData(std::move(n.mData)) {}\n\n void destroy(M &map) noexcept {\n // don't deallocate, just put it into list of datapool.\n mData->~value_type();\n map.deallocate(mData);\n }\n\n void destroyDoNotDeallocate() noexcept { mData->~value_type(); }\n\n value_type const *operator->() const noexcept { return mData; }\n\n value_type *operator->() noexcept { return mData; }\n\n const value_type &operator*() const { return *mData; }\n\n value_type &operator*() { return *mData; }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() noexcept {\n return mData->first;\n }\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() noexcept {\n return *mData;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() const noexcept {\n return mData->first;\n }\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getFirst() const noexcept {\n return *mData;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getSecond() noexcept {\n return mData->second;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::type getSecond() const noexcept {\n return mData->second;\n }\n\n void swap(DataNode &o) noexcept {\n using std::swap;\n swap(mData, o.mData);\n }\n\n private:\n value_type *mData;\n };\n\n using Node = DataNode;\n\n // helpers for insertKeyPrepareEmptySpot: extract first entry (only const required)\n ROBIN_HOOD(NODISCARD) key_type const &getFirstConst(Node const &n) const noexcept { return n.getFirst(); }\n\n // in case we have void mapped_type, we are not using a pair, thus we just route k through.\n // No need to disable this because it's just not used if not applicable.\n ROBIN_HOOD(NODISCARD) key_type const &getFirstConst(key_type const &k) const noexcept { return k; }\n\n // in case we have non-void mapped_type, we have a standard robin_hood::pair\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::value, key_type const &>::type\n getFirstConst(value_type const &vt) const noexcept {\n return vt.first;\n }\n\n // Cloner //////////////////////////////////////////////////////////\n\n template \n struct Cloner;\n\n // fast path: Just copy data, without allocating anything.\n template \n struct Cloner {\n void operator()(M const &source, M &target) const {\n auto const *const src = reinterpret_cast(source.mKeyVals);\n auto *tgt = reinterpret_cast(target.mKeyVals);\n auto const numElementsWithBuffer = target.calcNumElementsWithBuffer(target.mMask + 1);\n std::copy(src, src + target.calcNumBytesTotal(numElementsWithBuffer), tgt);\n }\n };\n\n template \n struct Cloner {\n void operator()(M const &s, M &t) const {\n auto const numElementsWithBuffer = t.calcNumElementsWithBuffer(t.mMask + 1);\n std::copy(s.mInfo, s.mInfo + t.calcNumBytesInfo(numElementsWithBuffer), t.mInfo);\n\n for (size_t i = 0; i < numElementsWithBuffer; ++i) {\n if (t.mInfo[i]) {\n ::new (static_cast(t.mKeyVals + i)) Node(t, *s.mKeyVals[i]);\n }\n }\n }\n };\n\n // Destroyer ///////////////////////////////////////////////////////\n\n template \n struct Destroyer {};\n\n template \n struct Destroyer {\n void nodes(M &m) const noexcept { m.mNumElements = 0; }\n\n void nodesDoNotDeallocate(M &m) const noexcept { m.mNumElements = 0; }\n };\n\n template \n struct Destroyer {\n void nodes(M &m) const noexcept {\n m.mNumElements = 0;\n // clear also resets mInfo to 0, that's sometimes not necessary.\n auto const numElementsWithBuffer = m.calcNumElementsWithBuffer(m.mMask + 1);\n\n for (size_t idx = 0; idx < numElementsWithBuffer; ++idx) {\n if (0 != m.mInfo[idx]) {\n Node &n = m.mKeyVals[idx];\n n.destroy(m);\n n.~Node();\n }\n }\n }\n\n void nodesDoNotDeallocate(M &m) const noexcept {\n m.mNumElements = 0;\n // clear also resets mInfo to 0, that's sometimes not necessary.\n auto const numElementsWithBuffer = m.calcNumElementsWithBuffer(m.mMask + 1);\n for (size_t idx = 0; idx < numElementsWithBuffer; ++idx) {\n if (0 != m.mInfo[idx]) {\n Node &n = m.mKeyVals[idx];\n n.destroyDoNotDeallocate();\n n.~Node();\n }\n }\n }\n };\n\n // Iter ////////////////////////////////////////////////////////////\n\n struct fast_forward_tag {};\n\n // generic iterator for both const_iterator and iterator.\n template \n // NOLINTNEXTLINE(hicpp-special-member-functions,cppcoreguidelines-special-member-functions)\n class Iter {\n private:\n using NodePtr = typename std::conditional::type;\n\n public:\n using difference_type = std::ptrdiff_t;\n using value_type = typename Self::value_type;\n using reference = typename std::conditional::type;\n using pointer = typename std::conditional::type;\n using iterator_category = std::forward_iterator_tag;\n\n // default constructed iterator can be compared to itself, but WON'T return true when\n // compared to end().\n Iter() = default;\n\n // Rule of zero: nothing specified. The conversion constructor is only enabled for\n // iterator to const_iterator, so it doesn't accidentally work as a copy ctor.\n\n // Conversion constructor from iterator to const_iterator.\n template ::type>\n // NOLINTNEXTLINE(hicpp-explicit-conversions)\n Iter(Iter const &other) noexcept\n : mKeyVals(other.mKeyVals),\n mInfo(other.mInfo) {}\n\n Iter(NodePtr valPtr, uint8_t const *infoPtr) noexcept\n : mKeyVals(valPtr),\n mInfo(infoPtr) {}\n\n Iter(NodePtr valPtr, uint8_t const *infoPtr, fast_forward_tag ROBIN_HOOD_UNUSED(tag) /*unused*/) noexcept\n : mKeyVals(valPtr),\n mInfo(infoPtr) {\n fastForward();\n }\n\n template ::type>\n Iter &operator=(Iter const &other) noexcept {\n mKeyVals = other.mKeyVals;\n mInfo = other.mInfo;\n return *this;\n }\n\n // prefix increment. Undefined behavior if we are at end()!\n Iter &operator++() noexcept {\n mInfo++;\n mKeyVals++;\n fastForward();\n return *this;\n }\n\n Iter operator++(int) noexcept {\n Iter tmp = *this;\n ++(*this);\n return tmp;\n }\n\n reference operator*() const { return **mKeyVals; }\n\n pointer operator->() const { return &**mKeyVals; }\n\n template \n bool operator==(Iter const &o) const noexcept {\n return mKeyVals == o.mKeyVals;\n }\n\n template \n bool operator!=(Iter const &o) const noexcept {\n return mKeyVals != o.mKeyVals;\n }\n\n private:\n // fast forward to the next non-free info byte\n // I've tried a few variants that don't depend on intrinsics, but unfortunately they are\n // quite a bit slower than this one. So I've reverted that change again. See map_benchmark.\n void fastForward() noexcept {\n size_t n = 0;\n while (0U == (n = detail::unaligned_load(mInfo))) {\n mInfo += sizeof(size_t);\n mKeyVals += sizeof(size_t);\n }\n#if defined(ROBIN_HOOD_DISABLE_INTRINSICS)\n // we know for certain that within the next 8 bytes we'll find a non-zero one.\n if (ROBIN_HOOD_UNLIKELY(0U == detail::unaligned_load(mInfo))) {\n mInfo += 4;\n mKeyVals += 4;\n }\n if (ROBIN_HOOD_UNLIKELY(0U == detail::unaligned_load(mInfo))) {\n mInfo += 2;\n mKeyVals += 2;\n }\n if (ROBIN_HOOD_UNLIKELY(0U == *mInfo)) {\n mInfo += 1;\n mKeyVals += 1;\n }\n#else\n#if ROBIN_HOOD(LITTLE_ENDIAN)\n auto inc = ROBIN_HOOD_COUNT_TRAILING_ZEROES(n) / 8;\n#else\n auto inc = ROBIN_HOOD_COUNT_LEADING_ZEROES(n) / 8;\n#endif\n mInfo += inc;\n mKeyVals += inc;\n#endif\n }\n\n friend class Table;\n NodePtr mKeyVals{nullptr};\n uint8_t const *mInfo{nullptr};\n };\n\n ////////////////////////////////////////////////////////////////////\n\n // highly performance relevant code.\n // Lower bits are used for indexing into the array (2^n size)\n // The upper 1-5 bits need to be a reasonable good hash, to save comparisons.\n template \n void keyToIdx(HashKey &&key, size_t *idx, InfoType *info) const {\n // In addition to whatever hash is used, add another mul & shift so we get better hashing.\n // This serves as a bad hash prevention, if the given data is\n // badly mixed.\n auto h = static_cast(WHash::operator()(key));\n\n h *= mHashMultiplier;\n h ^= h >> 33U;\n\n // the lower InitialInfoNumBits are reserved for info.\n *info = mInfoInc + static_cast((h & InfoMask) >> mInfoHashShift);\n *idx = (static_cast(h) >> InitialInfoNumBits) & mMask;\n }\n\n // forwards the index by one, wrapping around at the end\n void next(InfoType *info, size_t *idx) const noexcept {\n *idx = *idx + 1;\n *info += mInfoInc;\n }\n\n void nextWhileLess(InfoType *info, size_t *idx) const noexcept {\n // unrolling this by hand did not bring any speedups.\n while (*info < mInfo[*idx]) {\n next(info, idx);\n }\n }\n\n // Shift everything up by one element. Tries to move stuff around.\n void shiftUp(size_t startIdx, size_t const insertion_idx) noexcept(std::is_nothrow_move_assignable::value) {\n auto idx = startIdx;\n ::new (static_cast(mKeyVals + idx)) Node(std::move(mKeyVals[idx - 1]));\n while (--idx != insertion_idx) {\n mKeyVals[idx] = std::move(mKeyVals[idx - 1]);\n }\n\n idx = startIdx;\n while (idx != insertion_idx) {\n ROBIN_HOOD_COUNT(shiftUp)\n mInfo[idx] = static_cast(mInfo[idx - 1] + mInfoInc);\n if (ROBIN_HOOD_UNLIKELY(mInfo[idx] + mInfoInc > 0xFF)) {\n mMaxNumElementsAllowed = 0;\n }\n --idx;\n }\n }\n\n void shiftDown(size_t idx) noexcept(std::is_nothrow_move_assignable::value) {\n // until we find one that is either empty or has zero offset.\n // TODO(martinus) we don't need to move everything, just the last one for the same\n // bucket.\n mKeyVals[idx].destroy(*this);\n\n // until we find one that is either empty or has zero offset.\n while (mInfo[idx + 1] >= 2 * mInfoInc) {\n ROBIN_HOOD_COUNT(shiftDown)\n mInfo[idx] = static_cast(mInfo[idx + 1] - mInfoInc);\n mKeyVals[idx] = std::move(mKeyVals[idx + 1]);\n ++idx;\n }\n\n mInfo[idx] = 0;\n // don't destroy, we've moved it\n // mKeyVals[idx].destroy(*this);\n mKeyVals[idx].~Node();\n }\n\n // copy of find(), except that it returns iterator instead of const_iterator.\n template \n ROBIN_HOOD(NODISCARD)\n size_t findIdx(Other const &key) const {\n size_t idx{};\n InfoType info{};\n keyToIdx(key, &idx, &info);\n\n do {\n // unrolling this twice gives a bit of a speedup. More unrolling did not help.\n if (info == mInfo[idx] && ROBIN_HOOD_LIKELY(WKeyEqual::operator()(key, mKeyVals[idx].getFirst()))) {\n return idx;\n }\n next(&info, &idx);\n if (info == mInfo[idx] && ROBIN_HOOD_LIKELY(WKeyEqual::operator()(key, mKeyVals[idx].getFirst()))) {\n return idx;\n }\n next(&info, &idx);\n } while (info <= mInfo[idx]);\n\n // nothing found!\n return mMask == 0\n ? 0\n : static_cast(std::distance(mKeyVals, reinterpret_cast_no_cast_align_warning(mInfo)));\n }\n\n void cloneData(const Table &o) { Cloner::value>()(o, *this); }\n\n // inserts a keyval that is guaranteed to be new, e.g. when the hashmap is resized.\n // @return True on success, false if something went wrong\n void insert_move(Node &&keyval) {\n // we don't retry, fail if overflowing\n // don't need to check max num elements\n if (0 == mMaxNumElementsAllowed && !try_increase_info()) {\n throwOverflowError();\n }\n\n size_t idx{};\n InfoType info{};\n keyToIdx(keyval.getFirst(), &idx, &info);\n\n // skip forward. Use <= because we are certain that the element is not there.\n while (info <= mInfo[idx]) {\n idx = idx + 1;\n info += mInfoInc;\n }\n\n // key not found, so we are now exactly where we want to insert it.\n auto const insertion_idx = idx;\n auto const insertion_info = static_cast(info);\n if (ROBIN_HOOD_UNLIKELY(insertion_info + mInfoInc > 0xFF)) {\n mMaxNumElementsAllowed = 0;\n }\n\n // find an empty spot\n while (0 != mInfo[idx]) {\n next(&info, &idx);\n }\n\n auto &l = mKeyVals[insertion_idx];\n if (idx == insertion_idx) {\n ::new (static_cast(&l)) Node(std::move(keyval));\n } else {\n shiftUp(idx, insertion_idx);\n l = std::move(keyval);\n }\n\n // put at empty spot\n mInfo[insertion_idx] = insertion_info;\n\n ++mNumElements;\n }\n\n public:\n using iterator = Iter;\n using const_iterator = Iter;\n\n Table() noexcept(noexcept(Hash()) &&noexcept(KeyEqual()))\n : WHash(),\n WKeyEqual() {\n ROBIN_HOOD_TRACE(this)\n }\n\n // Creates an empty hash map. Nothing is allocated yet, this happens at the first insert.\n // This tremendously speeds up ctor & dtor of a map that never receives an element. The\n // penalty is payed at the first insert, and not before. Lookup of this empty map works\n // because everybody points to DummyInfoByte::b. parameter bucket_count is dictated by the\n // standard, but we can ignore it.\n explicit Table(size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/,\n const Hash &h = Hash{},\n const KeyEqual &equal = KeyEqual{}) noexcept(noexcept(Hash(h)) &&noexcept(KeyEqual(equal)))\n : WHash(h),\n WKeyEqual(equal) {\n ROBIN_HOOD_TRACE(this)\n }\n\n template \n Table(Iter first,\n Iter last,\n size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/ = 0,\n const Hash &h = Hash{},\n const KeyEqual &equal = KeyEqual{})\n : WHash(h),\n WKeyEqual(equal) {\n ROBIN_HOOD_TRACE(this)\n insert(first, last);\n }\n\n Table(std::initializer_list initlist,\n size_t ROBIN_HOOD_UNUSED(bucket_count) /*unused*/ = 0,\n const Hash &h = Hash{},\n const KeyEqual &equal = KeyEqual{})\n : WHash(h),\n WKeyEqual(equal) {\n ROBIN_HOOD_TRACE(this)\n insert(initlist.begin(), initlist.end());\n }\n\n Table(Table &&o) noexcept\n : WHash(std::move(static_cast(o))),\n WKeyEqual(std::move(static_cast(o))),\n DataPool(std::move(static_cast(o))) {\n ROBIN_HOOD_TRACE(this)\n if (o.mMask) {\n mHashMultiplier = std::move(o.mHashMultiplier);\n mKeyVals = std::move(o.mKeyVals);\n mInfo = std::move(o.mInfo);\n mNumElements = std::move(o.mNumElements);\n mMask = std::move(o.mMask);\n mMaxNumElementsAllowed = std::move(o.mMaxNumElementsAllowed);\n mInfoInc = std::move(o.mInfoInc);\n mInfoHashShift = std::move(o.mInfoHashShift);\n // set other's mask to 0 so its destructor won't do anything\n o.init();\n }\n }\n\n Table &operator=(Table &&o) noexcept {\n ROBIN_HOOD_TRACE(this)\n if (&o != this) {\n if (o.mMask) {\n // only move stuff if the other map actually has some data\n destroy();\n mHashMultiplier = std::move(o.mHashMultiplier);\n mKeyVals = std::move(o.mKeyVals);\n mInfo = std::move(o.mInfo);\n mNumElements = std::move(o.mNumElements);\n mMask = std::move(o.mMask);\n mMaxNumElementsAllowed = std::move(o.mMaxNumElementsAllowed);\n mInfoInc = std::move(o.mInfoInc);\n mInfoHashShift = std::move(o.mInfoHashShift);\n WHash::operator=(std::move(static_cast(o)));\n WKeyEqual::operator=(std::move(static_cast(o)));\n DataPool::operator=(std::move(static_cast(o)));\n\n o.init();\n\n } else {\n // nothing in the other map => just clear us.\n clear();\n }\n }\n return *this;\n }\n\n Table(const Table &o)\n : WHash(static_cast(o)),\n WKeyEqual(static_cast(o)),\n DataPool(static_cast(o)) {\n ROBIN_HOOD_TRACE(this)\n if (!o.empty()) {\n // not empty: create an exact copy. it is also possible to just iterate through all\n // elements and insert them, but copying is probably faster.\n\n auto const numElementsWithBuffer = calcNumElementsWithBuffer(o.mMask + 1);\n auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);\n\n ROBIN_HOOD_LOG(\"hf3fs::memory::allocate \" << numBytesTotal << \" = calcNumBytesTotal(\" << numElementsWithBuffer\n << \")\")\n mHashMultiplier = o.mHashMultiplier;\n mKeyVals = static_cast(detail::assertNotNull(hf3fs::memory::allocate(numBytesTotal)));\n // no need for calloc because clonData does memcpy\n mInfo = reinterpret_cast(mKeyVals + numElementsWithBuffer);\n mNumElements = o.mNumElements;\n mMask = o.mMask;\n mMaxNumElementsAllowed = o.mMaxNumElementsAllowed;\n mInfoInc = o.mInfoInc;\n mInfoHashShift = o.mInfoHashShift;\n cloneData(o);\n }\n }\n\n // Creates a copy of the given map. Copy constructor of each entry is used.\n // Not sure why clang-tidy thinks this doesn't handle self assignment, it does\n // NOLINTNEXTLINE(bugprone-unhandled-self-assignment,cert-oop54-cpp)\n Table &operator=(Table const &o) {\n ROBIN_HOOD_TRACE(this)\n if (&o == this) {\n // prevent assigning of itself\n return *this;\n }\n\n // we keep using the old allocator and not assign the new one, because we want to keep\n // the memory available. when it is the same size.\n if (o.empty()) {\n if (0 == mMask) {\n // nothing to do, we are empty too\n return *this;\n }\n\n // not empty: destroy what we have there\n // clear also resets mInfo to 0, that's sometimes not necessary.\n destroy();\n init();\n WHash::operator=(static_cast(o));\n WKeyEqual::operator=(static_cast(o));\n DataPool::operator=(static_cast(o));\n\n return *this;\n }\n\n // clean up old stuff\n Destroyer::value>{}.nodes(*this);\n\n if (mMask != o.mMask) {\n // no luck: we don't have the same array size allocated, so we need to realloc.\n if (0 != mMask) {\n // only deallocate if we actually have data!\n ROBIN_HOOD_LOG(\"hf3fs::memory::deallocate\")\n hf3fs::memory::deallocate(mKeyVals);\n }\n\n auto const numElementsWithBuffer = calcNumElementsWithBuffer(o.mMask + 1);\n auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);\n ROBIN_HOOD_LOG(\"hf3fs::memory::allocate \" << numBytesTotal << \" = calcNumBytesTotal(\" << numElementsWithBuffer\n << \")\")\n mKeyVals = static_cast(detail::assertNotNull(hf3fs::memory::allocate(numBytesTotal)));\n\n // no need for calloc here because cloneData performs a memcpy.\n mInfo = reinterpret_cast(mKeyVals + numElementsWithBuffer);\n // sentinel is set in cloneData\n }\n WHash::operator=(static_cast(o));\n WKeyEqual::operator=(static_cast(o));\n DataPool::operator=(static_cast(o));\n mHashMultiplier = o.mHashMultiplier;\n mNumElements = o.mNumElements;\n mMask = o.mMask;\n mMaxNumElementsAllowed = o.mMaxNumElementsAllowed;\n mInfoInc = o.mInfoInc;\n mInfoHashShift = o.mInfoHashShift;\n cloneData(o);\n\n return *this;\n }\n\n // Swaps everything between the two maps.\n void swap(Table &o) {\n ROBIN_HOOD_TRACE(this)\n using std::swap;\n swap(o, *this);\n }\n\n // Clears all data, without resizing.\n void clear() {\n ROBIN_HOOD_TRACE(this)\n if (empty()) {\n // don't do anything! also important because we don't want to write to\n // DummyInfoByte::b, even though we would just write 0 to it.\n return;\n }\n\n Destroyer::value>{}.nodes(*this);\n\n auto const numElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);\n // clear everything, then set the sentinel again\n uint8_t const z = 0;\n std::fill(mInfo, mInfo + calcNumBytesInfo(numElementsWithBuffer), z);\n mInfo[numElementsWithBuffer] = 1;\n\n mInfoInc = InitialInfoInc;\n mInfoHashShift = InitialInfoHashShift;\n }\n\n // Destroys the map and all it's contents.\n ~Table() {\n ROBIN_HOOD_TRACE(this)\n destroy();\n }\n\n // Checks if both tables contain the same entries. Order is irrelevant.\n bool operator==(const Table &other) const {\n ROBIN_HOOD_TRACE(this)\n if (other.size() != size()) {\n return false;\n }\n for (auto const &otherEntry : other) {\n if (!has(otherEntry)) {\n return false;\n }\n }\n\n return true;\n }\n\n bool operator!=(const Table &other) const {\n ROBIN_HOOD_TRACE(this)\n return !operator==(other);\n }\n\n template \n typename std::enable_if::value, Q &>::type operator[](const key_type &key) {\n ROBIN_HOOD_TRACE(this)\n auto idxAndState = insertKeyPrepareEmptySpot(key);\n switch (idxAndState.second) {\n case InsertionState::key_found:\n break;\n\n case InsertionState::new_node:\n ::new (static_cast(&mKeyVals[idxAndState.first]))\n Node(*this, std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple());\n break;\n\n case InsertionState::overwrite_node:\n mKeyVals[idxAndState.first] =\n Node(*this, std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple());\n break;\n\n case InsertionState::overflow_error:\n throwOverflowError();\n }\n\n return mKeyVals[idxAndState.first].getSecond();\n }\n\n template \n typename std::enable_if::value, Q &>::type operator[](key_type &&key) {\n ROBIN_HOOD_TRACE(this)\n auto idxAndState = insertKeyPrepareEmptySpot(key);\n switch (idxAndState.second) {\n case InsertionState::key_found:\n break;\n\n case InsertionState::new_node:\n ::new (static_cast(&mKeyVals[idxAndState.first]))\n Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::forward_as_tuple());\n break;\n\n case InsertionState::overwrite_node:\n mKeyVals[idxAndState.first] =\n Node(*this, std::piecewise_construct, std::forward_as_tuple(std::move(key)), std::forward_as_tuple());\n break;\n\n case InsertionState::overflow_error:\n throwOverflowError();\n }\n\n return mKeyVals[idxAndState.first].getSecond();\n }\n\n template \n void insert(Iter first, Iter last) {\n for (; first != last; ++first) {\n // value_type ctor needed because this might be called with std::pair's\n insert(value_type(*first));\n }\n }\n\n void insert(std::initializer_list ilist) {\n for (auto &&vt : ilist) {\n insert(std::move(vt));\n }\n }\n\n template \n std::pair emplace(Args &&...args) {\n ROBIN_HOOD_TRACE(this)\n Node n{*this, std::forward(args)...};\n auto idxAndState = insertKeyPrepareEmptySpot(getFirstConst(n));\n switch (idxAndState.second) {\n case InsertionState::key_found:\n n.destroy(*this);\n break;\n\n case InsertionState::new_node:\n ::new (static_cast(&mKeyVals[idxAndState.first])) Node(*this, std::move(n));\n break;\n\n case InsertionState::overwrite_node:\n mKeyVals[idxAndState.first] = std::move(n);\n break;\n\n case InsertionState::overflow_error:\n n.destroy(*this);\n throwOverflowError();\n break;\n }\n\n return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),\n InsertionState::key_found != idxAndState.second);\n }\n\n template \n iterator emplace_hint(const_iterator position, Args &&...args) {\n (void)position;\n return emplace(std::forward(args)...).first;\n }\n\n template \n std::pair try_emplace(const key_type &key, Args &&...args) {\n return try_emplace_impl(key, std::forward(args)...);\n }\n\n template \n std::pair try_emplace(key_type &&key, Args &&...args) {\n return try_emplace_impl(std::move(key), std::forward(args)...);\n }\n\n template \n iterator try_emplace(const_iterator hint, const key_type &key, Args &&...args) {\n (void)hint;\n return try_emplace_impl(key, std::forward(args)...).first;\n }\n\n template \n iterator try_emplace(const_iterator hint, key_type &&key, Args &&...args) {\n (void)hint;\n return try_emplace_impl(std::move(key), std::forward(args)...).first;\n }\n\n template \n std::pair insert_or_assign(const key_type &key, Mapped &&obj) {\n return insertOrAssignImpl(key, std::forward(obj));\n }\n\n template \n std::pair insert_or_assign(key_type &&key, Mapped &&obj) {\n return insertOrAssignImpl(std::move(key), std::forward(obj));\n }\n\n template \n iterator insert_or_assign(const_iterator hint, const key_type &key, Mapped &&obj) {\n (void)hint;\n return insertOrAssignImpl(key, std::forward(obj)).first;\n }\n\n template \n iterator insert_or_assign(const_iterator hint, key_type &&key, Mapped &&obj) {\n (void)hint;\n return insertOrAssignImpl(std::move(key), std::forward(obj)).first;\n }\n\n std::pair insert(const value_type &keyval) {\n ROBIN_HOOD_TRACE(this)\n return emplace(keyval);\n }\n\n iterator insert(const_iterator hint, const value_type &keyval) {\n (void)hint;\n return emplace(keyval).first;\n }\n\n std::pair insert(value_type &&keyval) { return emplace(std::move(keyval)); }\n\n iterator insert(const_iterator hint, value_type &&keyval) {\n (void)hint;\n return emplace(std::move(keyval)).first;\n }\n\n // Returns 1 if key is found, 0 otherwise.\n size_t count(const key_type &key) const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n auto kv = mKeyVals + findIdx(key);\n if (kv != reinterpret_cast_no_cast_align_warning(mInfo)) {\n return 1;\n }\n return 0;\n }\n\n template \n // NOLINTNEXTLINE(modernize-use-nodiscard)\n typename std::enable_if::type count(const OtherKey &key) const {\n ROBIN_HOOD_TRACE(this)\n auto kv = mKeyVals + findIdx(key);\n if (kv != reinterpret_cast_no_cast_align_warning(mInfo)) {\n return 1;\n }\n return 0;\n }\n\n bool contains(const key_type &key) const { // NOLINT(modernize-use-nodiscard)\n return 1U == count(key);\n }\n\n template \n // NOLINTNEXTLINE(modernize-use-nodiscard)\n typename std::enable_if::type contains(const OtherKey &key) const {\n return 1U == count(key);\n }\n\n // Returns a reference to the value found for key.\n // Throws std::out_of_range if element cannot be found\n template \n // NOLINTNEXTLINE(modernize-use-nodiscard)\n typename std::enable_if::value, Q &>::type at(key_type const &key) {\n ROBIN_HOOD_TRACE(this)\n auto kv = mKeyVals + findIdx(key);\n if (kv == reinterpret_cast_no_cast_align_warning(mInfo)) {\n doThrow(\"key not found\");\n }\n return kv->getSecond();\n }\n\n // Returns a reference to the value found for key.\n // Throws std::out_of_range if element cannot be found\n template \n // NOLINTNEXTLINE(modernize-use-nodiscard)\n typename std::enable_if::value, Q const &>::type at(key_type const &key) const {\n ROBIN_HOOD_TRACE(this)\n auto kv = mKeyVals + findIdx(key);\n if (kv == reinterpret_cast_no_cast_align_warning(mInfo)) {\n doThrow(\"key not found\");\n }\n return kv->getSecond();\n }\n\n const_iterator find(const key_type &key) const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return const_iterator{mKeyVals + idx, mInfo + idx};\n }\n\n template \n const_iterator find(const OtherKey &key, is_transparent_tag /*unused*/) const {\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return const_iterator{mKeyVals + idx, mInfo + idx};\n }\n\n template \n typename std::enable_if::type // NOLINT(modernize-use-nodiscard)\n find(const OtherKey &key) const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return const_iterator{mKeyVals + idx, mInfo + idx};\n }\n\n iterator find(const key_type &key) {\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return iterator{mKeyVals + idx, mInfo + idx};\n }\n\n template \n iterator find(const OtherKey &key, is_transparent_tag /*unused*/) {\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return iterator{mKeyVals + idx, mInfo + idx};\n }\n\n template \n typename std::enable_if::type find(const OtherKey &key) {\n ROBIN_HOOD_TRACE(this)\n const size_t idx = findIdx(key);\n return iterator{mKeyVals + idx, mInfo + idx};\n }\n\n iterator begin() {\n ROBIN_HOOD_TRACE(this)\n if (empty()) {\n return end();\n }\n return iterator(mKeyVals, mInfo, fast_forward_tag{});\n }\n const_iterator begin() const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return cbegin();\n }\n const_iterator cbegin() const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n if (empty()) {\n return cend();\n }\n return const_iterator(mKeyVals, mInfo, fast_forward_tag{});\n }\n\n iterator end() {\n ROBIN_HOOD_TRACE(this)\n // no need to supply valid info pointer: end() must not be dereferenced, and only node\n // pointer is compared.\n return iterator{reinterpret_cast_no_cast_align_warning(mInfo), nullptr};\n }\n const_iterator end() const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return cend();\n }\n const_iterator cend() const { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return const_iterator{reinterpret_cast_no_cast_align_warning(mInfo), nullptr};\n }\n\n iterator erase(const_iterator pos) {\n ROBIN_HOOD_TRACE(this)\n // its safe to perform const cast here\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)\n return erase(iterator{const_cast(pos.mKeyVals), const_cast(pos.mInfo)});\n }\n\n // Erases element at pos, returns iterator to the next element.\n iterator erase(iterator pos) {\n ROBIN_HOOD_TRACE(this)\n // we assume that pos always points to a valid entry, and not end().\n auto const idx = static_cast(pos.mKeyVals - mKeyVals);\n\n shiftDown(idx);\n --mNumElements;\n\n if (*pos.mInfo) {\n // we've backward shifted, return this again\n return pos;\n }\n\n // no backward shift, return next element\n return ++pos;\n }\n\n size_t erase(const key_type &key) {\n ROBIN_HOOD_TRACE(this)\n size_t idx{};\n InfoType info{};\n keyToIdx(key, &idx, &info);\n\n // check while info matches with the source idx\n do {\n if (info == mInfo[idx] && WKeyEqual::operator()(key, mKeyVals[idx].getFirst())) {\n shiftDown(idx);\n --mNumElements;\n return 1;\n }\n next(&info, &idx);\n } while (info <= mInfo[idx]);\n\n // nothing found to delete\n return 0;\n }\n\n // reserves space for the specified number of elements. Makes sure the old data fits.\n // exactly the same as reserve(c).\n void rehash(size_t c) {\n // forces a reserve\n reserve(c, true);\n }\n\n // reserves space for the specified number of elements. Makes sure the old data fits.\n // Exactly the same as rehash(c). Use rehash(0) to shrink to fit.\n void reserve(size_t c) {\n // reserve, but don't force rehash\n reserve(c, false);\n }\n\n // If possible reallocates the map to a smaller one. This frees the underlying table.\n // Does not do anything if load_factor is too large for decreasing the table's size.\n void compact() {\n ROBIN_HOOD_TRACE(this)\n auto newSize = InitialNumElements;\n while (calcMaxNumElementsAllowed(newSize) < mNumElements && newSize != 0) {\n newSize *= 2;\n }\n if (ROBIN_HOOD_UNLIKELY(newSize == 0)) {\n throwOverflowError();\n }\n\n ROBIN_HOOD_LOG(\"newSize > mMask + 1: \" << newSize << \" > \" << mMask << \" + 1\")\n\n // only actually do anything when the new size is bigger than the old one. This prevents to\n // continuously allocate for each reserve() call.\n if (newSize < mMask + 1) {\n rehashPowerOfTwo(newSize, true);\n }\n }\n\n size_type size() const noexcept { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return mNumElements;\n }\n\n size_type max_size() const noexcept { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return static_cast(-1);\n }\n\n ROBIN_HOOD(NODISCARD) bool empty() const noexcept {\n ROBIN_HOOD_TRACE(this)\n return 0 == mNumElements;\n }\n\n float max_load_factor() const noexcept { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return MaxLoadFactor100 / 100.0F;\n }\n\n // Average number of elements per bucket. Since we allow only 1 per bucket\n float load_factor() const noexcept { // NOLINT(modernize-use-nodiscard)\n ROBIN_HOOD_TRACE(this)\n return static_cast(size()) / static_cast(mMask + 1);\n }\n\n ROBIN_HOOD(NODISCARD) size_t mask() const noexcept {\n ROBIN_HOOD_TRACE(this)\n return mMask;\n }\n\n ROBIN_HOOD(NODISCARD) size_t calcMaxNumElementsAllowed(size_t maxElements) const noexcept {\n if (ROBIN_HOOD_LIKELY(maxElements <= (std::numeric_limits::max)() / 100)) {\n return maxElements * MaxLoadFactor100 / 100;\n }\n\n // we might be a bit inprecise, but since maxElements is quite large that doesn't matter\n return (maxElements / 100) * MaxLoadFactor100;\n }\n\n ROBIN_HOOD(NODISCARD) size_t calcNumBytesInfo(size_t numElements) const noexcept {\n // we add a uint64_t, which houses the sentinel (first byte) and padding so we can load\n // 64bit types.\n return numElements + sizeof(uint64_t);\n }\n\n ROBIN_HOOD(NODISCARD)\n size_t calcNumElementsWithBuffer(size_t numElements) const noexcept {\n auto maxNumElementsAllowed = calcMaxNumElementsAllowed(numElements);\n return numElements + (std::min)(maxNumElementsAllowed, (static_cast(0xFF)));\n }\n\n // calculation only allowed for 2^n values\n ROBIN_HOOD(NODISCARD) size_t calcNumBytesTotal(size_t numElements) const {\n#if ROBIN_HOOD(BITNESS) == 64\n return numElements * sizeof(Node) + calcNumBytesInfo(numElements);\n#else\n // make sure we're doing 64bit operations, so we are at least safe against 32bit overflows.\n auto const ne = static_cast(numElements);\n auto const s = static_cast(sizeof(Node));\n auto const infos = static_cast(calcNumBytesInfo(numElements));\n\n auto const total64 = ne * s + infos;\n auto const total = static_cast(total64);\n\n if (ROBIN_HOOD_UNLIKELY(static_cast(total) != total64)) {\n throwOverflowError();\n }\n return total;\n#endif\n }\n\n private:\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::value, bool>::type has(const value_type &e) const {\n ROBIN_HOOD_TRACE(this)\n auto it = find(e.first);\n return it != end() && it->second == e.second;\n }\n\n template \n ROBIN_HOOD(NODISCARD)\n typename std::enable_if::value, bool>::type has(const value_type &e) const {\n ROBIN_HOOD_TRACE(this)\n return find(e) != end();\n }\n\n void reserve(size_t c, bool forceRehash) {\n ROBIN_HOOD_TRACE(this)\n auto const minElementsAllowed = (std::max)(c, mNumElements);\n auto newSize = InitialNumElements;\n while (calcMaxNumElementsAllowed(newSize) < minElementsAllowed && newSize != 0) {\n newSize *= 2;\n }\n if (ROBIN_HOOD_UNLIKELY(newSize == 0)) {\n throwOverflowError();\n }\n\n ROBIN_HOOD_LOG(\"newSize > mMask + 1: \" << newSize << \" > \" << mMask << \" + 1\")\n\n // only actually do anything when the new size is bigger than the old one. This prevents to\n // continuously allocate for each reserve() call.\n if (forceRehash || newSize > mMask + 1) {\n rehashPowerOfTwo(newSize, false);\n }\n }\n\n // reserves space for at least the specified number of elements.\n // only works if numBuckets if power of two\n // True on success, false otherwise\n void rehashPowerOfTwo(size_t numBuckets, bool forceFree) {\n ROBIN_HOOD_TRACE(this)\n\n Node *const oldKeyVals = mKeyVals;\n uint8_t const *const oldInfo = mInfo;\n\n const size_t oldMaxElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);\n\n // resize operation: move stuff\n initData(numBuckets);\n if (oldMaxElementsWithBuffer > 1) {\n for (size_t i = 0; i < oldMaxElementsWithBuffer; ++i) {\n if (oldInfo[i] != 0) {\n // might throw an exception, which is really bad since we are in the middle of\n // moving stuff.\n insert_move(std::move(oldKeyVals[i]));\n // destroy the node but DON'T destroy the data.\n oldKeyVals[i].~Node();\n }\n }\n\n // this check is not necessary as it's guarded by the previous if, but it helps\n // silence g++'s overeager \"attempt to free a non-heap object 'map'\n // [-Werror=free-nonheap-object]\" warning.\n if (oldKeyVals != reinterpret_cast_no_cast_align_warning(&mMask)) {\n // don't destroy old data: put it into the pool instead\n if (forceFree) {\n hf3fs::memory::deallocate(oldKeyVals);\n } else {\n DataPool::addOrFree(oldKeyVals, calcNumBytesTotal(oldMaxElementsWithBuffer));\n }\n }\n }\n }\n\n ROBIN_HOOD(NOINLINE) void throwOverflowError() const {\n#if ROBIN_HOOD(HAS_EXCEPTIONS)\n throw std::overflow_error(\"robin_hood::map overflow\");\n#else\n abort();\n#endif\n }\n\n template \n std::pair try_emplace_impl(OtherKey &&key, Args &&...args) {\n ROBIN_HOOD_TRACE(this)\n auto idxAndState = insertKeyPrepareEmptySpot(key);\n switch (idxAndState.second) {\n case InsertionState::key_found:\n break;\n\n case InsertionState::new_node:\n ::new (static_cast(&mKeyVals[idxAndState.first]))\n Node(*this,\n std::piecewise_construct,\n std::forward_as_tuple(std::forward(key)),\n std::forward_as_tuple(std::forward(args)...));\n break;\n\n case InsertionState::overwrite_node:\n mKeyVals[idxAndState.first] = Node(*this,\n std::piecewise_construct,\n std::forward_as_tuple(std::forward(key)),\n std::forward_as_tuple(std::forward(args)...));\n break;\n\n case InsertionState::overflow_error:\n throwOverflowError();\n break;\n }\n\n return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),\n InsertionState::key_found != idxAndState.second);\n }\n\n template \n std::pair insertOrAssignImpl(OtherKey &&key, Mapped &&obj) {\n ROBIN_HOOD_TRACE(this)\n auto idxAndState = insertKeyPrepareEmptySpot(key);\n switch (idxAndState.second) {\n case InsertionState::key_found:\n mKeyVals[idxAndState.first].getSecond() = std::forward(obj);\n break;\n\n case InsertionState::new_node:\n ::new (static_cast(&mKeyVals[idxAndState.first]))\n Node(*this,\n std::piecewise_construct,\n std::forward_as_tuple(std::forward(key)),\n std::forward_as_tuple(std::forward(obj)));\n break;\n\n case InsertionState::overwrite_node:\n mKeyVals[idxAndState.first] = Node(*this,\n std::piecewise_construct,\n std::forward_as_tuple(std::forward(key)),\n std::forward_as_tuple(std::forward(obj)));\n break;\n\n case InsertionState::overflow_error:\n throwOverflowError();\n break;\n }\n\n return std::make_pair(iterator(mKeyVals + idxAndState.first, mInfo + idxAndState.first),\n InsertionState::key_found != idxAndState.second);\n }\n\n void initData(size_t max_elements) {\n mNumElements = 0;\n mMask = max_elements - 1;\n mMaxNumElementsAllowed = calcMaxNumElementsAllowed(max_elements);\n\n auto const numElementsWithBuffer = calcNumElementsWithBuffer(max_elements);\n\n // malloc & zero mInfo. Faster than calloc everything.\n auto const numBytesTotal = calcNumBytesTotal(numElementsWithBuffer);\n ROBIN_HOOD_LOG(\"std::calloc \" << numBytesTotal << \" = calcNumBytesTotal(\" << numElementsWithBuffer << \")\")\n mKeyVals = reinterpret_cast(detail::assertNotNull(hf3fs::memory::allocate(numBytesTotal)));\n mInfo = reinterpret_cast(mKeyVals + numElementsWithBuffer);\n std::memset(mInfo, 0, numBytesTotal - numElementsWithBuffer * sizeof(Node));\n\n // set sentinel\n mInfo[numElementsWithBuffer] = 1;\n\n mInfoInc = InitialInfoInc;\n mInfoHashShift = InitialInfoHashShift;\n }\n\n enum class InsertionState { overflow_error, key_found, new_node, overwrite_node };\n\n // Finds key, and if not already present prepares a spot where to pot the key & value.\n // This potentially shifts nodes out of the way, updates mInfo and number of inserted\n // elements, so the only operation left to do is create/assign a new node at that spot.\n template \n std::pair insertKeyPrepareEmptySpot(OtherKey &&key) {\n for (int i = 0; i < 256; ++i) {\n size_t idx{};\n InfoType info{};\n keyToIdx(key, &idx, &info);\n nextWhileLess(&info, &idx);\n\n // while we potentially have a match\n while (info == mInfo[idx]) {\n if (WKeyEqual::operator()(key, mKeyVals[idx].getFirst())) {\n // key already exists, do NOT insert.\n // see http://en.cppreference.com/w/cpp/container/unordered_map/insert\n return std::make_pair(idx, InsertionState::key_found);\n }\n next(&info, &idx);\n }\n\n // unlikely that this evaluates to true\n if (ROBIN_HOOD_UNLIKELY(mNumElements >= mMaxNumElementsAllowed)) {\n if (!increase_size()) {\n return std::make_pair(size_t(0), InsertionState::overflow_error);\n }\n continue;\n }\n\n // key not found, so we are now exactly where we want to insert it.\n auto const insertion_idx = idx;\n auto const insertion_info = info;\n if (ROBIN_HOOD_UNLIKELY(insertion_info + mInfoInc > 0xFF)) {\n mMaxNumElementsAllowed = 0;\n }\n\n // find an empty spot\n while (0 != mInfo[idx]) {\n next(&info, &idx);\n }\n\n if (idx != insertion_idx) {\n shiftUp(idx, insertion_idx);\n }\n // put at empty spot\n mInfo[insertion_idx] = static_cast(insertion_info);\n ++mNumElements;\n return std::make_pair(insertion_idx,\n idx == insertion_idx ? InsertionState::new_node : InsertionState::overwrite_node);\n }\n\n // enough attempts failed, so finally give up.\n return std::make_pair(size_t(0), InsertionState::overflow_error);\n }\n\n bool try_increase_info() {\n ROBIN_HOOD_LOG(\"mInfoInc=\" << mInfoInc << \", numElements=\" << mNumElements\n << \", maxNumElementsAllowed=\" << calcMaxNumElementsAllowed(mMask + 1))\n if (mInfoInc <= 2) {\n // need to be > 2 so that shift works (otherwise undefined behavior!)\n return false;\n }\n // we got space left, try to make info smaller\n mInfoInc = static_cast(mInfoInc >> 1U);\n\n // remove one bit of the hash, leaving more space for the distance info.\n // This is extremely fast because we can operate on 8 bytes at once.\n ++mInfoHashShift;\n auto const numElementsWithBuffer = calcNumElementsWithBuffer(mMask + 1);\n\n for (size_t i = 0; i < numElementsWithBuffer; i += 8) {\n auto val = unaligned_load(mInfo + i);\n val = (val >> 1U) & UINT64_C(0x7f7f7f7f7f7f7f7f);\n std::memcpy(mInfo + i, &val, sizeof(val));\n }\n // update sentinel, which might have been cleared out!\n mInfo[numElementsWithBuffer] = 1;\n\n mMaxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);\n return true;\n }\n\n // True if resize was possible, false otherwise\n bool increase_size() {\n // nothing allocated yet? just allocate InitialNumElements\n if (0 == mMask) {\n initData(InitialNumElements);\n return true;\n }\n\n auto const maxNumElementsAllowed = calcMaxNumElementsAllowed(mMask + 1);\n if (mNumElements < maxNumElementsAllowed && try_increase_info()) {\n return true;\n }\n\n ROBIN_HOOD_LOG(\"mNumElements=\" << mNumElements << \", maxNumElementsAllowed=\" << maxNumElementsAllowed << \", load=\"\n << (static_cast(mNumElements) * 100.0 / (static_cast(mMask) + 1)))\n\n if (mNumElements * 2 < calcMaxNumElementsAllowed(mMask + 1)) {\n // we have to resize, even though there would still be plenty of space left!\n // Try to rehash instead. Delete freed memory so we don't steadyily increase mem in case\n // we have to rehash a few times\n nextHashMultiplier();\n rehashPowerOfTwo(mMask + 1, true);\n } else {\n // we've reached the capacity of the map, so the hash seems to work nice. Keep using it.\n rehashPowerOfTwo((mMask + 1) * 2, false);\n }\n return true;\n }\n\n void nextHashMultiplier() {\n // adding an *even* number, so that the multiplier will always stay odd. This is necessary\n // so that the hash stays a mixing function (and thus doesn't have any information loss).\n mHashMultiplier += UINT64_C(0xc4ceb9fe1a85ec54);\n }\n\n void destroy() {\n if (0 == mMask) {\n // don't deallocate!\n return;\n }\n\n Destroyer::value>{}.nodesDoNotDeallocate(*this);\n\n // This protection against not deleting mMask shouldn't be needed as it's sufficiently\n // protected with the 0==mMask check, but I have this anyways because g++ 7 otherwise\n // reports a compile error: attempt to free a non-heap object 'fm'\n // [-Werror=free-nonheap-object]\n if (mKeyVals != reinterpret_cast_no_cast_align_warning(&mMask)) {\n ROBIN_HOOD_LOG(\"hf3fs::memory::deallocate\")\n hf3fs::memory::deallocate(mKeyVals);\n }\n }\n\n void init() noexcept {\n mKeyVals = reinterpret_cast_no_cast_align_warning(&mMask);\n mInfo = reinterpret_cast(&mMask);\n mNumElements = 0;\n mMask = 0;\n mMaxNumElementsAllowed = 0;\n mInfoInc = InitialInfoInc;\n mInfoHashShift = InitialInfoHashShift;\n }\n\n // members are sorted so no padding occurs\n uint64_t mHashMultiplier = UINT64_C(0xc4ceb9fe1a85ec53); // 8 byte 8\n Node *mKeyVals = reinterpret_cast_no_cast_align_warning(&mMask); // 8 byte 16\n uint8_t *mInfo = reinterpret_cast(&mMask); // 8 byte 24\n size_t mNumElements = 0; // 8 byte 32\n size_t mMask = 0; // 8 byte 40\n size_t mMaxNumElementsAllowed = 0; // 8 byte 48\n InfoType mInfoInc = InitialInfoInc; // 4 byte 52\n InfoType mInfoHashShift = InitialInfoHashShift; // 4 byte 56\n // 16 byte 56 if NodeAllocator\n};\n\n} // namespace detail\n\n// map\n\ntemplate ,\n typename KeyEqual = std::equal_to,\n size_t MaxLoadFactor100 = 80>\nusing unordered_flat_map = detail::Table;\n\ntemplate ,\n typename KeyEqual = std::equal_to,\n size_t MaxLoadFactor100 = 80>\nusing unordered_node_map = detail::Table;\n\ntemplate ,\n typename KeyEqual = std::equal_to,\n size_t MaxLoadFactor100 = 80>\nusing unordered_map = detail::Table) <= sizeof(size_t) * 6 &&\n std::is_nothrow_move_constructible>::value &&\n std::is_nothrow_move_assignable>::value,\n MaxLoadFactor100,\n Key,\n T,\n Hash,\n KeyEqual>;\n\n// set\n\ntemplate , typename KeyEqual = std::equal_to, size_t MaxLoadFactor100 = 80>\nusing unordered_flat_set = detail::Table;\n\ntemplate , typename KeyEqual = std::equal_to, size_t MaxLoadFactor100 = 80>\nusing unordered_node_set = detail::Table;\n\ntemplate , typename KeyEqual = std::equal_to, size_t MaxLoadFactor100 = 80>\nusing unordered_set =\n detail::Table::value &&\n std::is_nothrow_move_assignable::value,\n MaxLoadFactor100,\n Key,\n void,\n Hash,\n KeyEqual>;\n\n} // namespace robin_hood\n\n#endif\n"], ["/3FS/src/common/utils/UnorderedDense.h", "///////////////////////// ankerl::unordered_dense::{map, set} /////////////////////////\n\n// A fast & densely stored hashmap and hashset based on robin-hood backward shift deletion.\n// Version 2.0.1\n// https://github.com/martinus/unordered_dense\n//\n// Licensed under the MIT License .\n// SPDX-License-Identifier: MIT\n// Copyright (c) 2022 Martin Leitner-Ankerl \n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in all\n// copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n// SOFTWARE.\n\n#ifndef ANKERL_UNORDERED_DENSE_H\n#define ANKERL_UNORDERED_DENSE_H\n\n// see https://semver.org/spec/v2.0.0.html\n#define ANKERL_UNORDERED_DENSE_VERSION_MAJOR 2 // NOLINT(cppcoreguidelines-macro-usage) incompatible API changes\n#define ANKERL_UNORDERED_DENSE_VERSION_MINOR \\\n 0 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible functionality\n#define ANKERL_UNORDERED_DENSE_VERSION_PATCH 1 // NOLINT(cppcoreguidelines-macro-usage) backwards compatible bug fixes\n\n// API versioning with inline namespace, see https://www.foonathan.net/2018/11/inline-namespaces/\n#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch) v##major##_##minor##_##patch\n#define ANKERL_UNORDERED_DENSE_VERSION_CONCAT(major, minor, patch) \\\n ANKERL_UNORDERED_DENSE_VERSION_CONCAT1(major, minor, patch)\n#define ANKERL_UNORDERED_DENSE_NAMESPACE \\\n ANKERL_UNORDERED_DENSE_VERSION_CONCAT(ANKERL_UNORDERED_DENSE_VERSION_MAJOR, \\\n ANKERL_UNORDERED_DENSE_VERSION_MINOR, \\\n ANKERL_UNORDERED_DENSE_VERSION_PATCH)\n\n#if defined(_MSVC_LANG)\n#define ANKERL_UNORDERED_DENSE_CPP_VERSION _MSVC_LANG\n#else\n#define ANKERL_UNORDERED_DENSE_CPP_VERSION __cplusplus\n#endif\n\n#if defined(__GNUC__)\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_PACK(decl) decl __attribute__((__packed__))\n#elif defined(_MSC_VER)\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_PACK(decl) __pragma(pack(push, 1)) decl __pragma(pack(pop))\n#endif\n\n#if ANKERL_UNORDERED_DENSE_CPP_VERSION < 201703L\n#error ankerl::unordered_dense requires C++17 or higher\n#else\n#include // for array\n#include // for uint64_t, uint32_t, uint8_t, UINT64_C\n#include // for size_t, memcpy, memset\n#include // for equal_to, hash\n#include // for initializer_list\n#include // for pair, distance\n#include // for numeric_limits\n#include // for allocator, allocator_traits, shared_ptr\n#include // for out_of_range\n#include // for basic_string\n#include // for basic_string_view, hash\n#include // for forward_as_tuple\n#include // for enable_if_t, declval, conditional_t, ena...\n#include // for forward, exchange, pair, as_const, piece...\n#include // for vector\n\n#define ANKERL_UNORDERED_DENSE_PMR 0 // NOLINT(cppcoreguidelines-macro-usage)\n#if defined(__has_include)\n#if __has_include()\n#undef ANKERL_UNORDERED_DENSE_PMR\n#define ANKERL_UNORDERED_DENSE_PMR 1 // NOLINT(cppcoreguidelines-macro-usage)\n#include // for polymorphic_allocator\n#endif\n#endif\n\n#if defined(_MSC_VER) && defined(_M_X64)\n#include \n#pragma intrinsic(_umul128)\n#endif\n\n#if defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__clang__)\n#define ANKERL_UNORDERED_DENSE_LIKELY(x) __builtin_expect(x, 1) // NOLINT(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_UNLIKELY(x) __builtin_expect(x, 0) // NOLINT(cppcoreguidelines-macro-usage)\n#else\n#define ANKERL_UNORDERED_DENSE_LIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_UNLIKELY(x) (x) // NOLINT(cppcoreguidelines-macro-usage)\n#endif\n\nnamespace ankerl::unordered_dense {\ninline namespace ANKERL_UNORDERED_DENSE_NAMESPACE {\n\n// hash ///////////////////////////////////////////////////////////////////////\n\n// This is a stripped-down implementation of wyhash: https://github.com/wangyi-fudan/wyhash\n// No big-endian support (because different values on different machines don't matter),\n// hardcodes seed and the secret, reformattes the code, and clang-tidy fixes.\nnamespace detail::wyhash {\n\nstatic inline void mum(uint64_t *a, uint64_t *b) {\n#if defined(__SIZEOF_INT128__)\n __uint128_t r = *a;\n r *= *b;\n *a = static_cast(r);\n *b = static_cast(r >> 64U);\n#elif defined(_MSC_VER) && defined(_M_X64)\n *a = _umul128(*a, *b, b);\n#else\n uint64_t ha = *a >> 32U;\n uint64_t hb = *b >> 32U;\n uint64_t la = static_cast(*a);\n uint64_t lb = static_cast(*b);\n uint64_t hi{};\n uint64_t lo{};\n uint64_t rh = ha * hb;\n uint64_t rm0 = ha * lb;\n uint64_t rm1 = hb * la;\n uint64_t rl = la * lb;\n uint64_t t = rl + (rm0 << 32U);\n auto c = static_cast(t < rl);\n lo = t + (rm1 << 32U);\n c += static_cast(lo < t);\n hi = rh + (rm0 >> 32U) + (rm1 >> 32U) + c;\n *a = lo;\n *b = hi;\n#endif\n}\n\n// multiply and xor mix function, aka MUM\n[[nodiscard]] static inline auto mix(uint64_t a, uint64_t b) -> uint64_t {\n mum(&a, &b);\n return a ^ b;\n}\n\n// read functions. WARNING: we don't care about endianness, so results are different on big endian!\n[[nodiscard]] static inline auto r8(const uint8_t *p) -> uint64_t {\n uint64_t v{};\n std::memcpy(&v, p, 8U);\n return v;\n}\n\n[[nodiscard]] static inline auto r4(const uint8_t *p) -> uint64_t {\n uint32_t v{};\n std::memcpy(&v, p, 4);\n return v;\n}\n\n// reads 1, 2, or 3 bytes\n[[nodiscard]] static inline auto r3(const uint8_t *p, size_t k) -> uint64_t {\n return (static_cast(p[0]) << 16U) | (static_cast(p[k >> 1U]) << 8U) | p[k - 1];\n}\n\n[[maybe_unused]] [[nodiscard]] static inline auto hash(void const *key, size_t len) -> uint64_t {\n static constexpr auto secret = std::array{UINT64_C(0xa0761d6478bd642f),\n UINT64_C(0xe7037ed1a0b428db),\n UINT64_C(0x8ebc6af09c88c6e3),\n UINT64_C(0x589965cc75374cc3)};\n\n auto const *p = static_cast(key);\n uint64_t seed = secret[0];\n uint64_t a{};\n uint64_t b{};\n if (ANKERL_UNORDERED_DENSE_LIKELY(len <= 16)) {\n if (ANKERL_UNORDERED_DENSE_LIKELY(len >= 4)) {\n a = (r4(p) << 32U) | r4(p + ((len >> 3U) << 2U));\n b = (r4(p + len - 4) << 32U) | r4(p + len - 4 - ((len >> 3U) << 2U));\n } else if (ANKERL_UNORDERED_DENSE_LIKELY(len > 0)) {\n a = r3(p, len);\n b = 0;\n } else {\n a = 0;\n b = 0;\n }\n } else {\n size_t i = len;\n if (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 48)) {\n uint64_t see1 = seed;\n uint64_t see2 = seed;\n do {\n seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);\n see1 = mix(r8(p + 16) ^ secret[2], r8(p + 24) ^ see1);\n see2 = mix(r8(p + 32) ^ secret[3], r8(p + 40) ^ see2);\n p += 48;\n i -= 48;\n } while (ANKERL_UNORDERED_DENSE_LIKELY(i > 48));\n seed ^= see1 ^ see2;\n }\n while (ANKERL_UNORDERED_DENSE_UNLIKELY(i > 16)) {\n seed = mix(r8(p) ^ secret[1], r8(p + 8) ^ seed);\n i -= 16;\n p += 16;\n }\n a = r8(p + i - 16);\n b = r8(p + i - 8);\n }\n\n return mix(secret[1] ^ len, mix(a ^ secret[1], b ^ seed));\n}\n\n[[nodiscard]] static inline auto hash(uint64_t x) -> uint64_t {\n return detail::wyhash::mix(x, UINT64_C(0x9E3779B97F4A7C15));\n}\n\n} // namespace detail::wyhash\n\ntemplate \nstruct hash {\n auto operator()(T const &obj) const\n noexcept(noexcept(std::declval>().operator()(std::declval()))) -> uint64_t {\n return std::hash{}(obj);\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::basic_string const &str) const noexcept -> uint64_t {\n return detail::wyhash::hash(str.data(), sizeof(CharT) * str.size());\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::basic_string_view const &sv) const noexcept -> uint64_t {\n return detail::wyhash::hash(sv.data(), sizeof(CharT) * sv.size());\n }\n};\n\ntemplate \nstruct hash {\n using is_avalanching = void;\n auto operator()(T *ptr) const noexcept -> uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr));\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::unique_ptr const &ptr) const noexcept -> uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash> {\n using is_avalanching = void;\n auto operator()(std::shared_ptr const &ptr) const noexcept -> uint64_t {\n // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)\n return detail::wyhash::hash(reinterpret_cast(ptr.get()));\n }\n};\n\ntemplate \nstruct hash::value>::type> {\n using is_avalanching = void;\n auto operator()(Enum e) const noexcept -> uint64_t {\n using underlying = typename std::underlying_type_t;\n return detail::wyhash::hash(static_cast(e));\n }\n};\n\n// NOLINTNEXTLINE(cppcoreguidelines-macro-usage)\n#define ANKERL_UNORDERED_DENSE_HASH_STATICCAST(T) \\\n template <> \\\n struct hash { \\\n using is_avalanching = void; \\\n auto operator()(T const &obj) const noexcept -> uint64_t { \\\n return detail::wyhash::hash(static_cast(obj)); \\\n } \\\n }\n\n#if defined(__GNUC__) && !defined(__clang__)\n#pragma GCC diagnostic push\n#pragma GCC diagnostic ignored \"-Wuseless-cast\"\n#endif\n// see https://en.cppreference.com/w/cpp/utility/hash\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(bool);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(signed char);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned char);\n#if ANKERL_UNORDERED_DENSE_CPP_VERSION >= 202002L\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char8_t);\n#endif\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char16_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(char32_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(wchar_t);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(short);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned short);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(int);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned int);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(long long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long);\nANKERL_UNORDERED_DENSE_HASH_STATICCAST(unsigned long long);\n\n#if defined(__GNUC__) && !defined(__clang__)\n#pragma GCC diagnostic pop\n#endif\n\n// bucket_type //////////////////////////////////////////////////////////\n\nnamespace bucket_type {\n\nstruct standard {\n static constexpr uint32_t dist_inc = 1U << 8U; // skip 1 byte fingerprint\n static constexpr uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint\n\n uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash\n uint32_t m_value_idx; // index into the m_values vector.\n};\n\nANKERL_UNORDERED_DENSE_PACK(struct big {\n static constexpr uint32_t dist_inc = 1U << 8U; // skip 1 byte fingerprint\n static constexpr uint32_t fingerprint_mask = dist_inc - 1; // mask for 1 byte of fingerprint\n\n uint32_t m_dist_and_fingerprint; // upper 3 byte: distance to original bucket. lower byte: fingerprint from hash\n size_t m_value_idx; // index into the m_values vector.\n});\n\n} // namespace bucket_type\n\nnamespace detail {\n\nstruct nonesuch {};\n\ntemplate class Op, class... Args>\nstruct detector {\n using value_t = std::false_type;\n using type = Default;\n};\n\ntemplate class Op, class... Args>\nstruct detector>, Op, Args...> {\n using value_t = std::true_type;\n using type = Op;\n};\n\ntemplate