Design

Krati is mainly designed for serving simple reads and writes (e.g., key-value access) from memory and providing persistency in the meanwhile. It is intended for read-write-intensive applications with relaxed transactional semantics.

Design Considerations:

• Simple Data Model:
  • Varying-length data array
  • Key-value data store
• Multi-Reader and Single Writer
  • Append-only writes
  • Concurrent reads and writes
• Persistency:
  • Write-ahead redo log
  • Periodic checkpointing
  • Writes persisted to disk in batch
• Performance:
  • Low read/write latency
  • High read/write throughput
• Hash-based indexing
• Fast equality search
• Random reads and writes
• Automatic data compaction
• Java-based:
  • Java Nio-enabled
  • Java GC friendly

Architectural Overview:

The conceptual architecture of Krati is composed of three layers. The top layer is the content data store service API, which includes array-like set/get methods and standard key-value store get/put/delete methods. The bottom layer provides Java NIO-based persistency to back up data segments, indexes, and meta data via disk files.

The layer in the middle manages data segments, data indexes, and write-ahead redo logic. Segment Manager is responsible for segment creation, recycle and compaction. Index Manager uses hash functions to map keys to memory-resident array indexes. It does automatic batch-based flushing to sync data, indexes, and meta data to disk files. Data Handler allows customization of data to put into segments.

Krati segments can be thought of pure data blocks backed by files on disk. Every segment contains a number of data elements. The index manager provides logic for retrieving indexes to data elements in a segment. Krati always keeps indexes in memory for better performance. Krati supports three types of segments:

• MemorySegement: Memory resident and designed for extremely fast reads and writes. It works for small data sets that fit into memory.
• MappedSegement: I/O page cache resident via Java/NIO mmap and designed for relatively fast reads and writes. It works for relatively large data sets that do not fit into memory.
• ChannelSegement: I/O page cache resident and designed for relatively slow reads and writes. It works for very large data sets that cannot fit into memory.

The following diagram shows the internal implementation of the Krati main class SimpleDataArray. Multiple readers can issue concurrent reads via DataArray get methods. There is one and only one writer, which does append-only writes to data segments via DataArray set methods. The writer periodically starts a compactor to perform segment compaction and reclaim wasted data space.