mirror of
https://github.com/logos-storage/logos-storage-nim.git
synced 2026-01-02 21:43:11 +00:00
99a78a41ee
For minimal correctness, we must ensure that buffers that cross the thread boundary are allocated and deallocated within the same thread and that there is no reference counting going on during the computation. To get there with minimal changes: * Preallocate a buffer for the outcome of the merkle tree computation * Pass pointers instead of `ref` types between threads * Avoid relying on isolation - this is an ORC-only feature * Add `SharedBuf` as a simple "view" type that allows working with a set of values while at the same time avoiding allocations and refcounts - the view checks for out-of-bounds acccess much like a seq, but the user is responsible for managing lifetime (which in this case is simple since all that needs to happen is for the task to complete) * In order not to upset the code too much, use a simple linear packer for the hashes that simply copies the values back and forth * Block cancellation and panic if the thread signalling mechanism fails - cancelling the task itself would require inserting cancellation points in the computation The worker task relies on a nuance, namely that calling a closure procedure does not count as a reference-counting event - while this works, it can be brittle in "general" code since it's easy to make copy of the closure itself by accident - the refactoring necessary for addressing this point is beyond the scope of this change however.
25 lines
646 B
Nim
25 lines
646 B
Nim
import stew/ptrops
|
|
|
|
type SharedBuf*[T] = object
|
|
payload*: ptr UncheckedArray[T]
|
|
len*: int
|
|
|
|
proc view*[T](_: type SharedBuf, v: openArray[T]): SharedBuf[T] =
|
|
if v.len > 0:
|
|
SharedBuf[T](payload: makeUncheckedArray(addr v[0]), len: v.len)
|
|
else:
|
|
default(SharedBuf[T])
|
|
|
|
template checkIdx(v: SharedBuf, i: int) =
|
|
doAssert i > 0 and i <= v.len
|
|
|
|
proc `[]`*[T](v: SharedBuf[T], i: int): var T =
|
|
v.checkIdx(i)
|
|
v.payload[i]
|
|
|
|
template toOpenArray*[T](v: SharedBuf[T]): var openArray[T] =
|
|
v.payload.toOpenArray(0, v.len - 1)
|
|
|
|
template toOpenArray*[T](v: SharedBuf[T], s, e: int): var openArray[T] =
|
|
v.toOpenArray().toOpenArray(s, e)
|