* This class supports using a shared memory api and map that to our address * space. The segments can be created by they corresponding key type. They

* The class defines the range request index, this is used in situation like * HTTP range request. The class can be constructed by either specifying t

Represents the identifier of a @Region.

* Rejects randomly and probability of rejection adjusts real-time to achieve * a target rate. * * Probability = baseProbability * probabilityFactor

* ItemRecord and ItemRecords are used for DestructorCheck in cachebench. * Every new allocated item has an ItemRecord pushed into ItemRecords, the *

Think of it as an array of BF. User does BF operations referencing BF with an index. It solves problem of lots of small BFs: allocated one-by-one BFs

This class creates a Driver that has an entry on its device with a similar situation as hash collision.

* A content can be split and stored in multiple pieces in cache. The class * provides the utility to map content object to pieces. * * This class h

Pairs up key and hash together, reducing the cost of computing hash multiple times, and eliminating possibility to modify one of them independently.

Byte buffer. Manages buffer lifetime.

A wrapper class for functions to collect counters. It can be initialized by either 1. folly::StringPiece, double -> void, or 2. folly::StringPiece, do

FDP specific info and handling This embeds the FDP semantics and specific io-handling. Note: IO with FDP semantics need to be sent through Io_Uring_c

An allocation error. This could be a genuine std::bad_alloc from the global allocator, or it can be an internal allocation error from the backing cach

@RelAddress represents device address as 32-bit region id and 32-bit offset inside that region.

* Utility to serialize operations on keys. * * In order to guarantee linearizability, the cache needs to order reads and * writes to cache items.

Data type for reporting

type of the key for allocations. It is a folly::StringPiece aka Range<const char*> with a custom comparison operator that should do better than folly'

Provides an interface to use the sys-V shared memory API. Segments are * identified through by a key_t generated using ftok. Segments once created *

Wrap the fiber output in an RAII struct; this allows the fiber to run cleanup() if the coroutine doesn't consume the output.

* Same as FlashCacheComponent but provides strong consistency. Shards * operations by key and serializes operations per shard to guarantee * lineari

* A cache component that uses Cachelib's BlockCache flash cache without RAM * cache. * * Cache items are buffered in RAM according to the region co

Hasher object for the hash table.

Exception when cachelib::Map's index has maxed out.

Parse memory tiers configuration from JSON config

Bad arguments were fed into deallocate(). This indicates the alloc argument was invalid, or the size was different from the originally requested size.

stats related to evictions for a pool

Stats for a pool

* A CacheComponent that uses Cachelib's LruAllocator RAM cache without the * flash/NVM cache. * * Although all APIs use coroutines (according to th

used as a read only into a shared cache. The cache is owned by another process and we peek into the items in the cache based on their offsets.

datastructure that helps serialize and deserialize state of objects in Slab*.h

structure to query the stats corresponding to an AllocationClass.

@AbsAddress represents device address as flat 64-bit byte offset of the device.

Generic cache interface. All functions are synchronous, unless stated the opposite.

The mode in which the cache was accessed. This can be used by containers to differentiate between the access modes and do appropriate action.

* Access reference counts indicate wthere there are an outstanding * references, but not who owns it. These control bits are special refcounts *