Skip to content

Releases: arshc0der/VoltCache

VoltCache v1.0.0 - Initial Stable Release

04 Mar 18:48
@arshc0der arshc0der
v1.0.0
fc86f4d

Choose a tag to compare

View all tags
VoltCache v1.0.0 - Initial Stable Release Latest
Latest

⚡ VoltCache v1.0.0 – Initial Stable Release

VoltCache is a high-performance, thread-safe, in-memory Key-Value engine built in C++17.
This release marks the first production-stable version featuring full concurrency control and crash-safe durability via Write-Ahead Logging.

🚀 Release Highlights

🧵 Multithreaded Concurrency Engine

  • Reader-Writer lock architecture using std::shared_mutex
  • Parallel read scalability with std::shared_lock
  • Exclusive write guarantees via std::unique_lock
  • RAII-based lock lifecycle management for safety
  • Designed for high read-heavy workloads

💾 Durable Write-Ahead Logging (WAL)

  • All write operations are flushed to disk before memory mutation
  • Append-only log structure
  • Deterministic crash recovery
  • Log replay mechanism on engine restart
  • Protection against recursive re-logging during recovery

🌐 TCP Socket Server

  • Custom-built TCP server
  • Handles multiple client connections
  • Lightweight command protocol
  • Designed for extensibility and future replication support

⚙ Modern C++17 Architecture

  • Zero third-party dependencies
  • CMake-based cross-platform build
  • Clear modular separation:
    • Engine layer
    • Networking layer
    • Testing suite

🏗 System Architecture Overview

Core components:

  • Storage Engine: std::unordered_map
  • Concurrency Model: Reader-Writer lock pattern
  • Persistence Layer: Append-only Write-Ahead Log
  • Recovery Strategy: Log replay at startup
  • Networking: Socket-based command handling

VoltCache is inspired by production systems like Redis, but implemented using a true multithreaded C++ model to explore parallel execution and lock-based scaling.

🔄 Crash Recovery Model

On startup:

  1. Engine checks for existing data/volt.log
  2. WAL is parsed sequentially
  3. Commands are injected directly into memory
  4. Logging is disabled during recovery phase
  5. Full state is reconstructed safely

This guarantees durability across unexpected shutdowns.

📦 Release Package Contents

Included in:
VoltCache-v1.0.0-windows-x86_64.zip

  • VoltCache.exe — Statically linked standalone engine
  • data/ — Required directory for WAL persistence (empty by default)
  • test_volt.py — Python integration test suite
  • README.txt — Quick start instructions

🧪 Tested Environment

  • OS: Windows (64-bit)
  • Compiler: GCC (C++17 standard)
  • Build: Release mode (-O2 optimization)
  • Threading: std::shared_mutex
  • Validation: Python-based integration testing

📊 Performance Characteristics

  • O(1) average lookup time
  • High read parallelism under multi-threaded load
  • Synchronous WAL for strong durability guarantees
  • Deterministic recovery behavior

⚠ Known Limitations

  • No eviction policy (LRU planned)
  • No snapshotting mechanism
  • No clustering / replication
  • WAL is synchronous (async mode planned)

🗺 Roadmap

Upcoming versions will include:

  • LRU eviction policy (O(1) implementation)
  • Lock striping (sharded buckets for reduced contention)
  • Snapshot persistence (RDB-style)
  • Benchmark harness with percentile latency metrics
  • Optional asynchronous WAL mode

📜 License

Released under the MIT License.

🎯 Significance of v1.0.0

This release demonstrates:

  • Advanced C++17 concurrency design
  • Crash-consistent storage architecture
  • Thread-safe data structure management
  • File I/O durability modeling
  • End-to-end product packaging and delivery

VoltCache v1.0.0 transitions the project from development prototype to stable engine release.

Assets 3
Loading