This is a rough design doc for a new ObjectStore implementation design to facilitate higher performance on solid state devices.


SeaStore maximizes the opportunity for confusion (seastar? seashore?) and associated fun. Alternative suggestions welcome.


  • Target NVMe devices. Not primarily concerned with pmem or HDD.

  • make use of SPDK for user-space driven IO

  • Use Seastar futures programming model to facilitate run-to-completion and a sharded memory/processing model

  • Allow zero- (or minimal) data copying on read and write paths when combined with a seastar-based messenger using DPDK

Motivation and background

All flash devices are internally structured in terms of segments that can be written efficiently but must be erased in their entirety. The NVMe device generally has limited knowledge about what data in a segment is still “live” (hasn’t been logically discarded), making the inevitable garbage collection within the device inefficient. We can design an on-disk layout that is friendly to GC at lower layers and drive garbage collection at higher layers.

In principle a fine-grained discard could communicate our intent to the device, but in practice discard is poorly implemented in the device and intervening software layers.


The basic idea is that all data will be stream out sequentially to large segments on the device. In the SSD hardware, segments are likely to be on the order of 100’s of MB to tens of GB.

SeaStore’s logical segments would ideally be perfectly aligned with the hardware segments. In practice, it may be challenging to determine geometry and to sufficiently hint to the device that LBAs being written should be aligned to the underlying hardware. In the worst case, we can structure our logical segments to correspond to e.g. 5x the physical segment size so that we have about ~20% of our data misaligned.

When we reach some utilization threshold, we mix cleaning work in with the ongoing write workload in order to evacuate live data from previously written segments. Once they are completely free we can discard the entire segment so that it can be erased and reclaimed by the device.

The key is to mix a small bit of cleaning work with every write transaction to avoid spikes and variance in write latency.

Data layout basics

One or more cores/shards will be reading and writing to the device at once. Each shard will have its own independent data it is operating on and stream to its own open segments. Devices that support streams can be hinted accordingly so that data from different shards is not mixed on the underlying media.

Global state

There will be a simple global table of segments and their usage/empty status. Each shard will occasionally claim new empty segments for writing as needed, or return cleaned segments to the global free list.

At a high level, all metadata will be structured as a b-tree. The root for the metadata btree will also be stored centrally (along with the segment allocation table).

This is hand-wavey, but it is probably sufficient to update the root pointer for the btree either as each segment is sealed or as a new segment is opened.

Writing segments

Each segment will be written sequentially as a sequence of transactions. Each transaction will be on-disk expression of an ObjectStore::Transaction. It will consist of

  • new data blocks

  • some metadata describing changes to b-tree metadata blocks. This will be written compact as a delta: which keys are removed and which keys/values are inserted into the b-tree block.

As each b-tree block is modified, we update the block in memory and put it on a ‘dirty’ list. However, again, only the (compact) delta is journaled to the segment.

As we approach the end of the segment, the goal is to undirty all of our dirty blocks in memory. Based on the number of dirty blocks and the remaining space, we include a proportional number of dirty blocks in each transaction write so that we undirty some of the b-tree blocks. Eventually, the last transaction written to the segment will include all of the remaining dirty b-tree blocks.

Segment inventory

At the end of each segment, an inventory will be written that includes any metadata needed to test whether blocks in the segment are still live. For data blocks, that means an object id (e.g., ino number) and offset to test whether the block is still reference. For metadata blocks, it would be at least one metadata key that lands in any b-tree block that is modified (via a delta) in the segment–enough for us to do a forward lookup in the b-tree to check whether the b-tree block is still referenced. Once this is written, the segment is sealed and read-only.

Crash recovery

On any crash, we simply “replay” the currently open segment in memory. For any b-tree delta encountered, we load the original block, modify in memory, and mark it dirty. Once we continue writing, the normal “write dirty blocks as we near the end of the segment” behavior will pick up where we left off.

ObjectStore considerations

Splits, merges, and sharding

One of the current ObjectStore requirements is to be able to split a collection (PG) in O(1) time. Starting in mimic, we also need to be able to merge two collections into one (i.e., exactly the reverse of a split).

However, the PGs that we split into would hash to different shards of the OSD in the current sharding scheme. One can imagine replacing that sharding scheme with a temporary mapping directing the smaller child PG to the right shard since we generally then migrate that PG to another OSD anyway, but this wouldn’t help us in the merge case where the constituent pieces may start out on different shards and ultimately need to be handled in the same collection (and be operated on via single transactions).

This suggests that we likely need a way for data written via one shard to “switch ownership” and later be read and managed by a different shard.