FASTER - Fast persistent recoverable log and key-value store + cache, in C# and C++

  •        4261

Managing large application state easily, resiliently, and with high performance is one of the hardest problems in the cloud today. The FASTER project offers two artifacts to help tackle this problem.

FASTER Log is a high-performance concurrent persistent recoverable log, iterator, and random reader library in C#. It supports very frequent commit operations at low latency, and can quickly saturate disk bandwidth. It supports both sync and async interfaces, handles disk errors, and supports checksums.

FASTER KV is a concurrent key-value store + cache (available in C# and C++) that is designed for point lookups and heavy updates. FASTER supports data larger than memory, by leveraging fast external storage (local or cloud). It also supports consistent recovery using a fast non-blocking checkpointing technique that lets applications trade-off performance for commit latency.

https://github.com/Microsoft/FASTER

Tags
Implementation
License
Platform

   




Related Projects

TomP2P - A P2P-based high performance key-value pair storage library

  •    Java

TomP2P is a P2P library and a distributed hash table (DHT) implementation which provides a decentralized key-value infrastructure for distributed applications. Each peer has a table that can be configured either to be disk-based or memory-based to store its values. TomP2P stores key-value pairs in a distributed manner. To find the peers to store the data in the distributed hash table, TomP2P uses an iterative routing to find the closest peers. Since TomP2P uses non-blocking communication, a future object is required to keep track of future results. This key concept is used for all the communication (iterative routing and DHT operations, such as storing a value on multiple peers) in TomP2P and it is also exposed in the API. Thus, an operation such as get or put will return immediately and the user can either block the operation to wait for the completion or add a listener that gets notified when the operation completes.

RocksDB - A persistent key-value store for fast storage environments

  •    C++

RocksDB is an embeddable persistent key-value store for fast storage. RocksDB builds on LevelDB to be scalable to run on servers with many CPU cores, to efficiently use fast storage, to support IO-bound, in-memory and write-once workloads, and to be flexible to allow for innovation. It is especially suited for storing data on flash drives. It has multi-threaded compactions, making it specially suitable for storing multiple terabytes of data in a single database.

Infinispan - Key value NOSQL data store and data grid

  •    Java

Infinispan is an extremely scalable, highly available key/value NoSQL datastore and distributed data grid platform. The purpose of Infinispan is to expose a data structure that is highly concurrent, designed ground-up to make the most of modern multi-processor/multi-core architectures while at the same time providing distributed cache capabilities. Infinispan offers enterprise features such as efficient eviction algorithms to control memory usage as well as JTA compatibility.

Keyv - Simple key-value storage with support for multiple backends

  •    Javascript

Keyv provides a consistent interface for key-value storage across multiple backends via storage adapters. It supports TTL based expiry, making it suitable as a cache or a persistent key-value store. It works with any storage that implements the Map API. It handles all JSON types plus Buffer. It has wide range of efficient, well tested storage adapters.

Caffeine - A high performance caching library for Java 8

  •    Java

Caffeine is a high performance, near optimal caching library based on Java 8. It provides an in-memory cache using a Google Guava inspired API.


Ristretto - A high performance memory-bound Go cache

  •    Go

Ristretto is a fast, concurrent cache library built with a focus on performance and correctness. Its features include Concurrency, High Hit Ratios, Fast Throughput, Cost-Based Eviction, Metrics support.

bigcache - Efficient cache for gigabytes of data written in Go.

  •    Go

Fast, concurrent, evicting in-memory cache written to keep big number of entries without impact on performance. BigCache keeps entries on heap but omits GC for them. To achieve that operations on bytes arrays take place, therefore entries (de)serialization in front of the cache will be needed in most use cases.

membase - distributed key-value database

  •    C

Membase is an distributed, key-value database management system optimized for storing data behind interactive web applications. These applications must service many concurrent users, creating, storing, retrieving, aggregating, manipulating and presenting data in real-time. Supporting these requirements, membase processes data operations with quasi-deterministic low latency and high sustained throughput.

DiskCache - Python disk backed cache (Django-compatible). Faster than Redis and Memcached. Pure-Python

  •    Python

DiskCache is a disk and file backed cache library, written in pure-Python, and compatible with Django. The cloud-based computing of 2021 puts a premium on memory. Gigabytes of empty space is left on disks as processes vie for memory. Among these processes is Memcached (and sometimes Redis) which is used as a cache. It is good to use empty disk space for caching.

FoundationDB - Distributed, Transactional Key-value store

  •    C++

FoundationDB is a distributed database designed to handle large volumes of structured data across clusters of commodity servers. It organizes data as an ordered key-value store and employs ACID transactions for all operations. It is especially well-suited for read/write workloads but also has excellent performance for write-intensive workloads. Users interact with the database using API language binding.

nutsdb - A simple, fast, embeddable, persistent key/value store written in pure Go

  •    Go

NutsDB is a simple, fast, embeddable and persistent key/value store written in pure Go. It supports fully serializable transactions and many data structures such as list、set、sorted set. All operations happen inside a Tx. Tx represents a transaction, which can be read-only or read-write. Read-only transactions can read values for a given bucket and given key or iterate over a set of key-value pairs. Read-write transactions can read, update and delete keys from the DB.

spark-indexedrdd - An efficient updatable key-value store for Apache Spark

  •    Scala

An efficient updatable key-value store for Apache Spark. IndexedRDD extends RDD[(K, V)] by enforcing key uniqueness and pre-indexing the entries for efficient joins and point lookups, updates, and deletions. It is implemented by (1) hash-partitioning the entries by key, (2) maintaining a radix tree (PART) index within each partition, and (3) using this immutable and efficiently updatable data structure to enable efficient modifications and deletions.

sharedhashfile - Share Hash Tables Stored In Memory Mapped Files Between Arbitrary Processes & Threads

  •    C

SharedHashFile is a lightweight NoSQL key value store / hash table, a zero-copy IPC queue, & a multiplexed IPC logging library written in C for Linux. There is no server process. Data is read and written directly from/to shared memory or SSD; no sockets are used between SharedHashFile and the application program. APIs for C, C++, & nodejs. Data is kept in shared memory by default, making all the data accessible to separate processes and/or threads. Up to 4 billion keys can be stored in a single SharedHashFile hash table which is limited in size only by available RAM.

BadgerDB - Fast key-value store in Go.

  •    Go

BadgerDB is an embeddable, persistent, simple and fast key-value (KV) store, written purely in Go. It's meant to be a performant alternative to non Go based key-value stores like RocksDB. It is written out of frustration with existing KV stores which are either written in pure Go and slow, or fast but require usage of Cgo. Badger aims to provide an equal or better speed compared to industry leading KV stores (like RocksDB), while maintaining the entire code base in pure Go.

Cacheonix - Open Source Java Cache

  •    Java

Cacheonix is an Open Source Java cache that allows developers to scale applications horizontally by providing a highly concurrent local cache and a strictly consistent distributed cache. It supports Distributed cache, Web application cache, Distributed lock, Second level (L2) cache.

Chronicle Map - High performance, off-heap, key-value, in memory, persisted data store

  •    Java

Chronicle Map is a high performance, off-heap, key-value, in memory, persisted data store. It works like a standard java map yet it automatically distributes data between processes, these processes can be both on the same server or across your network. In other words its a low latency, huge data key value store, which can store terabytes of data locally to your process.

pogreb - Embedded key-value store for read-heavy workloads written in Go

  •    Go

Pogreb is an embedded key-value store for read-heavy workloads written in Go. The benchmarking code can be found in the pogreb-bench repository.

Hyperdex - A Searchable Distributed Key-Value Store

  •    C++

HyperDex is a distributed, searchable key-value store. HyperDex provides a unique search primitive which enables searches over stored values. By design, HyperDex retains the performance of traditional key-value stores while enabling support for the search operation. It is fast, scalable, Consistent, Fault tolerant.

Akavache - An asynchronous, persistent key-value store

  •    CSharp

Akavache is an asynchronous, persistent (i.e. writes to disk) key-value store created for writing desktop and mobile applications in C#, based on SQLite3. Akavache is great for both storing important data (i.e. user settings) as well as cached local data that expires. Downloading and storing remote data from the internet while still keeping the UI responsive is a task that nearly every modern application needs to do. However, many applications that don't take the consideration of caching into the design from the start often end up with inconsistent, duplicated code for caching different types of objects.

Havalo - Non Distributed NoSQL Key Value Store

  •    Java

A zero configuration, non-distributed NoSQL key-value store that runs in any Servlet 3.0 compatible container. With Havalo, simply drop havalo.war into your favorite Servlet 3.0 compatible container and with almost no configuration you'll have access to a fast and lightweight K,V store backed by any local mount point for persistent storage.






We have large collection of open source products. Follow the tags from Tag Cloud >>


Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.