dymokomi/luce-prism
Source of release 0.6.1
0.6.1 / src / wal / engine.lucb
## Native shared state. Only this layer crosses application-worker boundaries.
import memory
import sync
import wal.tree
import wal.journal
import wal.writers
import wal.storage_io
from wal.bytes import Buffer, valid_key, max_value, max_frame, invalid, limit, closed, conflict, uncertain
pub struct Store:
var references: @u64
var views: @u64
var head_lock: sync.Mutex
var writer: writers.Queue
var root: tree.Node*?
var generation: u64
var published_bytes: i64
var conflicted_commits: @u64
var poisoned: bool
var log: journal.Journal
pub func open(path: str, controls: storage_io.Controls = storage_io.Controls()) -> Store*!:
var log = try journal.open(path, controls)
errdefer log.close()
var root: tree.Node*?
errdefer tree.drop(root)
var generation: u64
try journal.replay(&log, &root, &generation)
let store = try new Store(root = root, generation = generation, published_bytes = log.position, log = log) in memory.heap
store.references.store(1, .relaxed)
return store
pub func hold(store: Store*):
_ = store.references.add(1, .relaxed)
pub func drop(store: Store*):
if store.references.sub(1, .acq_rel) == 1:
tree.drop(store.root)
store.log.close()
free(store) in memory.heap
pub struct Statistics:
pub let generation: i64
pub let records: i64
pub let journal_bytes: i64
pub let needs_reopen: bool
pub let active_views: i64
pub let waiting_writers: i64
pub let peak_waiting_writers: i64
pub let queued_attempts: i64
pub let busy_returns: i64
pub let timed_out_attempts: i64
pub let conflicted_commits: i64
pub func statistics(store: Store*) -> Statistics:
store.head_lock.lock()
let generation = (i64)store.generation
let records = (i64)tree.count(store.root)
let position = store.published_bytes
let poisoned = store.poisoned
store.head_lock.unlock()
let admission = store.writer.statistics()
return Statistics(generation, records, position, poisoned, (i64)store.views.load(.acquire),
admission.waiting, admission.peak, admission.enqueued, admission.busy_returns,
admission.timeouts, (i64)store.conflicted_commits.load(.acquire))
pub struct View:
pub var store: Store*?
pub var root: tree.Node*?
pub var generation: u64
pub func close():
let store = self.store else return
tree.drop(self.root)
self.root = none
self.store = none
_ = store.views.sub(1, .acq_rel)
drop(store)
pub func ensure_open() -> !:
if self.store == none: error(closed, "database view is closed")
## Borrowed until this view is changed/closed. Facades retain returned values.
pub func get(key: str) -> tree.Entry*?!:
try self.ensure_open()
try valid_key(key)
return tree.find(self.root, key.bytes)
pub func snapshot(store: Store*) -> View!:
if store.views.add(1, .acq_rel) >= 1024:
_ = store.views.sub(1, .acq_rel)
error(limit, "database has 1024 active snapshots/transactions")
store.head_lock.lock()
defer store.head_lock.unlock()
if store.poisoned:
_ = store.views.sub(1, .acq_rel)
error(uncertain, "database needs reopen after uncertain I/O")
hold(store)
return View(store = store, root = tree.hold(store.root), generation = store.generation)
pub struct Transaction:
pub var view: View
var payload: Buffer
var operations: usize
pub func close():
self.payload.close()
self.view.close()
pub func put(key: str, value: const u8[], only_new: bool = false) -> !:
try self.view.ensure_open()
try valid_key(key)
if value.length > max_value: error(limit, "value exceeds 1 MiB")
if only_new and tree.find(self.view.root, key.bytes) != none:
error(conflict, "key already exists")
if self.operations >= 65536 or self.payload.count + 9 + key.length + value.length > max_frame - 32:
error(limit, "transaction is full")
let item = try tree.entry(key.bytes, value)
defer tree.drop_entry(item)
let root = try tree.put(self.view.root, item)
errdefer tree.drop(root)
try journal.operation(&self.payload, key, value, false)
tree.drop(self.view.root)
self.view.root = root
self.operations += 1
pub func remove(key: str) -> !:
try self.view.ensure_open()
try valid_key(key)
if self.operations >= 65536 or self.payload.count + 9 + key.length > max_frame - 32:
error(limit, "transaction is full")
let root = try tree.remove(self.view.root, key.bytes)
errdefer tree.drop(root)
try journal.operation(&self.payload, key, b"", true)
tree.drop(self.view.root)
self.view.root = root
self.operations += 1
pub func commit(wait_ms: i64 = 0) -> u64!:
let store = self.view.store else error(closed, "transaction is closed")
## Retain through queue release, even after closing the last view.
hold(store)
defer drop(store)
try store.writer.enter(wait_ms)
defer store.writer.leave()
store.head_lock.lock()
let poisoned = store.poisoned
let current = store.generation
store.head_lock.unlock()
if poisoned: error(uncertain, "database needs reopen after uncertain I/O")
if current != self.view.generation:
_ = store.conflicted_commits.add(1, .relaxed)
error(conflict, "snapshot changed; restart the transaction")
if self.operations == 0:
self.close()
return current
if current >= 9223372036854775807: error(limit, "database generation exhausted")
var frame = try journal.encode_frame(self.payload.span(), current + 1, self.operations)
defer frame.close()
if (i64)frame.count > journal.max_journal - store.log.position:
error(limit, "journal reached 256 MiB; export to a fresh database")
store.log.append(frame.span()) catch failure:
store.head_lock.lock()
store.poisoned = true
store.head_lock.unlock()
error(uncertain, "commit I/O failed; outcome uncertain, close all handles and reopen")
store.head_lock.lock()
let old = store.root
store.root = tree.hold(self.view.root)
store.generation = current + 1
store.published_bytes = store.log.position
store.head_lock.unlock()
tree.drop(old)
self.close()
return current + 1
pub func transaction(store: Store*) -> Transaction!:
return Transaction(view = try snapshot(store))
pub func checkpoint(store: Store*, wait_ms: i64 = 0) -> u64!:
hold(store)
defer drop(store)
try store.writer.enter(wait_ms)
defer store.writer.leave()
store.head_lock.lock()
let poisoned = store.poisoned
let generation = store.generation
let root = tree.hold(store.root)
store.head_lock.unlock()
defer tree.drop(root)
if poisoned: error(uncertain, "database needs reopen after uncertain I/O")
store.log.compact(root, generation) catch failure:
if failure.code == uncertain:
store.head_lock.lock()
store.poisoned = true
store.head_lock.unlock()
error(failure.code, failure.message)
store.head_lock.lock()
store.published_bytes = store.log.position
store.head_lock.unlock()
return generation