Prevent concurrency issues

[mbr]

There needs to be some mechanism, either at compile- or runtime that prevents some basic errors to be made, like opening two writers to the same database.

Currently, I am thinking of the following semantics:

• Allow 0 or 1 writers at any time, regardless of the number of readers
• Allow any number of readers at any time.

This should be enforced across threads, but not processes (i.e. we're assuming we are the only application using the database, no lock files or similar needed).

Making sure the database is not Sync is probably the first step (it should be Send though?). Then, a runtime check, possibly through a wrapper type that Derefs, should be implemented, ultimately resulting in an instance of utimeseries::err::Error.

An alternative would be just using a Semaphore(1) / Mutex on an internal field to track writers, but that'd make the database a little less flexible down the road.

[reiner-dolp]

I am not sure what the goal is.

• Should there be at most 1 writer that can be shared across threads?
  Or should there be at most 1 writer that is owned by/accessible from a single thread?
• How should syncing between readers and writer behave?

[afck]

I think there should be at most 1 writer that can be shared (i.e. it can be Send) across threads, i.e. each process can have at most 1 writer per time series (i.e. per file). Readers and writers don't need any special synchronization at all: The readers just read what's already on the disk, even if the writer is currently appending.
(Correct me if I'm wrong, @mbr.)

[mbr]

The writer needn't be Sync, but Send. If someone wants to share a writer, they can just put it into a Mutex or similar.

Syncing is not necessary, the data structure is built that it will only ever "see" completed writes while reading and it is append-only.

So, in summary: Max 1 writer, total, not thread-safe but Sendable. Any number of Readers, also Sendable.

[lweberk]

Would RwLock be of any help in that? Its kind of a Mutex which allows to acquire N readers but only 1 writer at a time.