repository·main·Indexed 12 days ago
https://github.com/facebook/follyA collection of high-performance C++20 components designed to complement the C++ standard library and Boost, optimized for large-scale performance. Includes folly::coro for asynchronous programming with C++20 coroutines, SIMD-accelerated Base64 encoding and decoding, and an Exception Tracer library for runtime stack inspection.
folly::coro is an asynchronous C++ framework built on C++20 coroutines. It provides a developer-friendly way to write asynchronous code with better performance than folly::Future. It is fully compatible with folly::Future and folly::SemiFuture and includes asynchronous synchronization primitives like coro::Baton, coro::Mutex, and coro::SharedMutex.folly::logging is a C++ logging library designed for high-performance applications that require extensive debug logging in production.
Its primary design goals are:
FiberManager.EventBase).Baton) and higher-level ones (await, collectN, mutexes).FiberManager is not thread-safe. It is recommended to maintain one FiberManager per thread.Folly logging is designed for high-performance debug logging with the following features:
folly::to<std::string>() and advanced, type-safe formatting using fmt::format().LogMessage class detects internal newlines, allowing LogHandler implementations to correctly apply log headers to every line of a multi-line message.The Exception Tracer library allows you to inspect the exception stack at runtime. Depending on your requirements for performance, portability, and ease of integration, you can use it in one of three ways:
exception_tracer_base. This provides access to the functions in ExceptionTracer.h without capturing stack traces. It has no runtime overhead and is C++ ABI compliant.exception_tracer library. This automatically installs std::terminate and std::unexpected handlers and captures full stack traces for all exceptions. Note that this adds runtime overhead to throw and catch operations and depends on internal details of GNU's libstdc++.LD_PRELOAD to load libexceptiontracer.so. This provides the same functionality as the full library without requiring link-time changes. However, you must ensure libexceptiontracer.so is compiled with the same compiler and flags as your target binary, and be aware that LD_PRELOAD affects child processes.folly/Synchronized.h provides a simple abstraction for mutex-based concurrency by encapsulating data and its protecting mutex together. This prevents common errors such as accessing data without acquiring its lock, using the wrong lock, or modifying data while holding only a read lock. By using Synchronized<T>, the data is only accessible through a LockedPtr or a callback, ensuring that the lock is always acquired before access.Group Varint is a variable-length encoding scheme for 32-bit and 64-bit integers designed for efficient storage. It encodes integers in groups rather than individually:
uint32_t values is encoded into 5 to 17 bytes. The first byte specifies the length (in bytes) of each integer in the group.uint64_t values is encoded into 7 to 42 bytes. The first two bytes specify the length (in bytes) of each integer in the group.This implementation is optimized for performance; the 32-bit version is significantly faster and can utilize the PSHUFB instruction on platforms supporting SSSE3 to accelerate lookups.
In C++, moving an object typically involves calling a move constructor and destroying the old instance. For many types, this is slower than a simple memcpy.
folly::IsRelocatable<T>::value is a type trait that indicates whether a type T can be safely moved in memory using memcpy without breaking its internal semantics.
When to use it:
folly::fbvector, which requires types to be explicitly marked as relocatable to function correctly.folly::fibers is an asynchronous C++ framework that uses fibers (also known as coroutines) for parallelism. Fibers are lightweight application threads that run on top of a single system thread.
Key characteristics:
FiberManager to execute scheduled tasks.Baton.folly::EventBase.folly::Poly is a class template used to create type-erasing polymorphic object wrappers. Unlike inheritance-based polymorphism (virtual dispatch), folly::Poly provides:
Poly objects can be passed by value, avoiding the slicing issues and complexity of passing abstract base class pointers or references.Poly can store small objects in-situ (in-place) to avoid heap allocation. It handles memory management automatically, leading to cleaner APIs.To define a Poly wrapper, you must define two components:
Interface template (which inherits from a Base parameter) defining the public member functions.Members alias template that maps concrete types to their specific member function implementations.The SIMD implementation of Base64 encoding in Folly optimizes performance by processing data within registers. To avoid expensive output size calculations during the encoding loop, the implementation uses a mathematical guarantee: as long as the Register size is greater than 16 bytes, providing 1.5 * Register of input space is sufficient to guarantee at least one full Register of output space.
This holds true because:
0.5 * Register converts to 3/8 of a register, which is > 0.25 * Register.convertedSize(RegisterSize / 2 - 4) >= RegisterSize / 4 - 1 ensures sufficient space is always available for registers larger than 16 bytes.LogHandler objects can be attached to specific log categories. When a message is admitted at a category, it is passed to all LogHandler objects attached to that category.
Handlers can be used to:
stdout or stderr.By default, handlers process all messages received at the category they are attached to, though they may implement their own additional log level checks.