Dmitry Ilvokhin

This commit introduces a **performance optimization** within the **`folly::IOBuf`** class by relaxing the memory order used for incrementing its reference count. Specifically, the `refcount` increment in methods like `cloneOneImpl` and `cloneOneAsValue` now utilizes `std::memory_order_relaxed` instead of `acq_rel`. This **refactoring** is safe because a reference to the `IOBuf` is already guaranteed, eliminating the need for stronger synchronization with prior writes. The change **improves efficiency** by reducing the overhead associated with atomic operations during `IOBuf` cloning, without compromising correctness or data integrity.

This commit introduces a **performance optimization** for **`folly::AtomicUnorderedInsertMap`** and **`folly::AtomicUnorderedInsertMap64`** by changing their default memory allocator. Previously, `MMapAlloc` directly used `mmap()` and `munmap()`, leading to contention on the kernel's `mmap_lock` in high-concurrency scenarios. The new default, `MallocAlloc`, now utilizes `std::malloc` and `folly::sizedFree`, allowing userspace allocators like jemalloc to manage memory more efficiently. This **refactoring** significantly **reduces contention** and **improves performance** for these concurrent data structures by leveraging better memory caching and arena-based locking.

This commit **refactors** the **`folly::ConcurrentHashMap`** by explicitly **deleting** the `contains()` method from its public interface. This change is a **safety improvement** designed to prevent unsafe concurrent usage patterns that could lead to incorrect behavior or data races. By marking `contains()` as deleted, the API now clearly communicates that this operation is not thread-safe in a way that guarantees correctness, forcing users to implement safer alternatives. This ensures the **thread-safety** and **robustness** of applications utilizing `ConcurrentHashMap` by preventing potential misuse at compile time.

This commit **refactors** the `F14` container tests by replacing `FOLLY_NOINLINE` with `FOLLY_KEEP` for several `codeSize_*` functions within `folly/container/test/F14SmallOverheads.cpp`. This change is made to **enable more effective exploration of codegen** for various `F14` methods. Specifically, the `BUCK` file for the test target is updated to include a dependency on `folly/lang:keep`, and the test file itself now includes the necessary header for `FOLLY_KEEP`. This **maintenance improvement** facilitates deeper analysis of the generated assembly code, aiding in performance optimization and understanding the low-level behavior of **`F14` containers**.

This commit **refactors** the `find` method within **Folly's F14 containers** to optimize its **hot path performance**. It streamlines the conditional logic in `folly/container/detail/F14Table.h`, reducing the number of branches evaluated for container sizes 0 and 1, and eliminating an unnecessary bit shift operation. This **performance optimization** aims to make lookups in `F14Value` and `F14Vector` more efficient, particularly for small container instances, by reducing CPU cycles spent on conditional checks.

This commit introduces a **performance optimization** for the `find` method within **F14 table containers**, specifically in `folly/container/detail/F14Table.h`. It **refactors** the lookup logic to prevent unnecessary hash computations when an `F14Table` is empty or contains only one element. By conditionally skipping expensive `computeHash` calls, this change improves the efficiency of lookups, particularly for small or frequently empty tables. This optimization, however, does not apply to `F14Vector*` containers where direct item iteration is not enabled.

This commit **refactors** the `folly/hash` library by **isolating the Hsieh hash functions** into a new dedicated header file, `folly/hash/HsiehHash.h`. This **maintenance** change aims to **discourage the use** of the Hsieh hash due to its known deficiencies, including undefined behavior, significant bias, and high collision rates. The original `folly/hash/Hash.h` no longer contains these implementations, which are now housed in the new file along with their dedicated test suite in `folly/hash/test/HsiehHashTest.cpp`. This move impacts the **`folly/hash` module** by making the problematic Hsieh hash functions less prominent, subtly guiding developers towards more robust hashing alternatives.

This commit **refactors** the **`folly::hash` library** by **relocating** all FNV hash function implementations from `folly/hash/Hash.h` to a new, dedicated header file, `folly/hash/FnvHash.h`. This strategic move aims to **discourage the use** of FNV hash by making it less prominent and harder to discover, reflecting its suboptimal quality. While `Hash.h` now includes `FnvHash.h` to ensure **backward compatibility**, the primary intent is to signal a shift away from FNV. The **build system** and **unit tests** for FNV hash were also updated and moved to align with this new structure.

This commit **refactors** the **`folly/hash` infrastructure** to resolve a **circular dependency** between `folly::Hash` and `folly::hasher`. It extracts the internal logic for hashing sequences and tuples into new, independent free functions like `hash_sequence` and `hash_tuple` within `folly/hash/Hash.h`. Existing `folly::Hash` and `folly::hasher` specializations are updated to utilize these new helpers, making the change a **behavioral no-op** for users. This **refactoring** improves the modularity of the hashing components, simplifying future downstream changes related to hash randomization and the introduction of a stable `folly::hasher`.

This commit **enhances the `folly::hash` utility** by explicitly marking `std::hash<std::string_view>` as an avalanching hasher. A template specialization for `std::hash<std::basic_string_view>` is added to `folly/hash/Hash.h` to declare this property. This **maintenance and consistency improvement** ensures that `std::string_view` hashing properties align with `std::string` within the `folly` framework, even though it currently has no noticeable performance impact on F14. The change is validated with new **unit tests** and static assertions in `folly/hash/test/HashTest.cpp` to confirm the correct identification of this hash property.

This commit **reverts** a previous change that introduced randomization to `folly::hasher` for string-like types in debug builds, effectively **restoring deterministic hashing behavior**. It removes the `hashBytes` helper function and updates the **Folly library's hashing subsystem** to ensure that string-like hashers, including those for **`folly::Range` types**, directly utilize `SpookyHashV2` with a **fixed seed**. This **rollback** impacts the core `folly::hash` implementation and its build dependencies, ensuring consistent hash values across runs and preventing potential issues caused by non-deterministic hashing in debug environments.

This commit introduces **randomized hashing** for **string-like types** within the **`folly::Hash`** framework, enhancing collision resistance and security. It refactors existing hashers for types like `folly::Range` and `folly::StringPiece` to utilize a new `detail::hashBytes` utility, which incorporates a per-program-run random seed. This ensures that while the hash values are randomized between program executions, they remain consistent for a given input within a single run, adhering to `std::hash` guarantees. The change primarily affects the **`folly` library's core hashing mechanisms** and includes necessary updates to build dependencies in `BUCK` files to support the new random seed.

This commit implements a **workaround** to resolve an **Internal Compiler Error (ICE)** encountered with **MSVC 2019** within the **Thrift C++2 library**. Specifically, it modifies `thrift/lib/cpp2/Adapt.h` to explicitly specify all template arguments for the `fromThriftField` function within the `adapted_field_t` type alias. Although these template types should be deducible, MSVC 2019 failed to correctly infer them, necessitating this **compiler-specific fix**. This ensures the **Thrift adaptation mechanism** compiles successfully on the affected compiler version, preventing build failures.

This commit introduces a **refactoring** and **maintenance improvement** to the core **`folly::Range`** utility by explicitly marking its `swap` member function and corresponding free function overload as `noexcept`. This change ensures the correct exception specification for a widely used type, enhancing its reliability and potentially improving performance in contexts sensitive to exception safety. The modification primarily affects the `folly/Range.h` header, with new tests added to `folly/test/RangeTest.cpp` to verify the `noexcept` guarantee.

This commit **fixes** an issue in the **random seed generation** mechanism within the `folly/hash/detail/RandomSeed.h` module. Previously, the `seed` function used the address of `std::malloc` as a random seed, which was found to provide insufficient per-run randomness due to ASLR limitations and `malloc`'s weak symbol definition. The system now leverages the address of `std::abort` instead, which, as a symbol from a shared library, offers more reliable **per-run randomness** by utilizing ASLR's randomization of shared library load addresses. This **corrective maintenance** ensures better quality random seeds, particularly in debug builds, for any components relying on this utility.

This commit **refactors** the **Folly benchmarking library** by changing the `addBenchmark` and `addBenchmarkImpl` functions to accept `std::string` arguments instead of `StringPiece` for file and name parameters. This modification improves **API clarity** by explicitly indicating that the benchmarking system takes ownership of these strings, simplifying usage for callers by removing the need for manual string lifetime management. The change primarily affects the `folly/Benchmark.h` and `folly/Benchmark.cpp` files, with corresponding updates made to `folly/test/BenchmarkTest.cpp` to align with the new API.

This commit **introduces hash randomization** for **`folly::HeterogeneousAccessHash`** when used with string-like types, enhancing the **`folly::container`** library's flexibility. This **new capability** allows for easier future modifications to hash algorithm implementations by generating a non-deterministic seed for each program invocation. A new **`folly::hash::detail::RandomSeed`** utility is added, which leverages ASLR and the address of `malloc` to produce a robust, platform-independent seed, avoiding issues with shared library boundaries. This change primarily impacts **debug builds** and improves the long-term **maintainability** of Folly's hashing infrastructure.

This commit **refactors** the `addHashBenchmark` function within `folly/hash/test/HashBenchmark.cpp` to **simplify** its internal logic. It **removes redundant storage** by eliminating a `static std::deque` previously used for benchmark names. The `BenchmarkRegistration` mechanism now directly manages name storage via its `std::string` member, making the separate `deque` unnecessary. This **maintenance** change streamlines the **hashing benchmark registration process** without impacting the actual benchmark execution or results.

This commit performs **maintenance** and **refactoring** across `folly::container` and `folly::hash` components. It cleans up `TransparentRangeHash<char>::operator()` in `folly/container/HeterogeneousAccess.h` by removing an outdated comment and updating a C-style cast to `static_cast<std::size_t>`. Additionally, it **fixes a test compilation error** by removing an unused `randomBytes` function from `HeterogeneousAccessTest.cpp` that caused `-Wunused-function` warnings. Finally, it **enhances the testing infrastructure** for `folly::hash` by re-enabling and adding a new stress test in `StdCompatibleHashTest.cpp` for `stdCompatibleHash`, ensuring its continued correctness within `folly::hash::StdHasher`.

This commit **refactors** the `getTimeDelta` function within **`folly/io/async/EventBase.cpp`** to improve efficiency. It **optimizes** the function by ensuring `std::chrono::steady_clock::now()` is called only once and its result is reused, eliminating a redundant system call. While `getTimeDelta` is not on a critical hot path, this change contributes to better code hygiene and minor performance gains within the **`folly` library's asynchronous I/O components**. This is a **maintenance optimization** that streamlines time measurement logic.