Er, s/Mirage_kv\.S/Mirage_kv.RW/g below. :sweat_smile:
On 1/2/22 16:13, Mindy wrote:
Hi all,
I've been working on a block-backed Mirage_kv.S implementation
inspired by (and largely interoperable with) littlefs[1] . I'm
approaching readiness for release, but there remains one large
unimplemented piece of Mirage_kv.S : `batch`. The relevant excerpt of
mirage_kv.mli is reproduced below:
```
val batch: t -> ?retries:int -> (t -> 'a Lwt.t) -> 'a Lwt.t
(** [batch t f] run [f] in batch. Ensure the durability of
operations.
Since a batch is applied at once, the readings inside a batch
will return the state before the entire batch. Concurrent
operations will not affect other ones executed during the batch.
Batch applications can fail to apply if other operations are
happening concurrently. In case of failure, [f] will run again
with the most recent version of [t]. The result is
[Error `Too_many_retries] if [f] is run for more then [retries]
attemps
(default is [13]). *)
```
I confess to being uncertain how to implement the "readings inside a
batch" portion of this. Given an arbitrary function `t -> 'a Lwt.t`,
how is the implementer expected to differentiate between operations
within such a function, possibly implemented as a series of sequential
binds?
Currently my implementation simply runs the given function against the
filesystem, but this is clearly semantically wrong given the
explanation in the docstring.
I see `wodan` implements this by differentiating between a `t` used
for read operations and one used for write operations[2] , but I lack
the understanding of `wodan` necessary to understand how this can work
for a `t -> 'a Lwt.t` that mixes read and write operations, which I
think the docstring implies to be an expected use of `batch`.
Thanks for your help,
Mindy
[1] https://github.com/littlefs-project/littlefs
[2]
https://github.com/mirage/wodan/blob/main/src/wodan-irmin/wodan_irmin.ml#L345
