Hash table from picos

[lyrm]

Import Picos hash table in Saturn. Some changes:

• using the size module
• a safe and an unsafe version. Issue : the size module uses Obj.magic

TODO :

• Dscheck tests are taking too long
• the safe and the unsafe implementation are the same except for the use of Transparent_atomic and Multicore_magic.Atomic_array. Could we avoid duplicating the code somehow ?

[polytypic]

BTW, I'm adding a couple of operations to the Picos Htbl:

val try_set : ('k, 'v) t -> 'k -> 'v -> bool
(** [try_set htbl key value] tries to update an existing binding of [key] to
    [value].  Returns [true] on success and [false] in case the hash table did
    not contain a binding for [key]. *)

val try_compare_and_set : ('k, 'v) t -> 'k -> 'v -> 'v -> bool
(** [try_compare_and_set htbl key before after] tries to update an existing
    binding of [key] from the [before] value to the [after] value.  The values
    are compared using physical equality, i.e. the [==] operator.  Returns
    [true] on success and [false] in case the hash table did not contain a
    binding of [key] to the [before] value. *)

val try_compare_and_remove : ('k, 'v) t -> 'k -> 'v -> bool
(** [try_compare_and_remove htbl key before] tries to remove a binding of [key]
    to the [before] value.  Values are compared using physical equality,
    i.e. the [==] operator.  Returns [true] on success and [false] in case the
    hash table did not contain a binding of [key] to the [before] value. *)

These are currently in a draft PR, Add Awaitable atomic locations, but I will likely move the Htbl changes to a separate PR soon.

There is a reason for adding operations with the above kind of semantics. The reason being that those operations allow consensus among arbitrarily many processes. In practical terms, it means that you can create new non-blocking operations using those operations as building blocks. If you look at the Stdlib Hashtbl, then many of the operations it provides, such as

val add : ('a, 'b) t -> 'a -> 'b -> unit
val remove : ('a, 'b) t -> 'a -> unit
val replace : ('a, 'b) t -> 'a -> 'b -> unit

do not, by themselves, allow consensus among arbitrarily many processes and are therefore limited in their use as building blocks of new non-blocking operations.

For example, in the PR, there is an (internal) lock-free operation

let rec add_awaiter t (one : Awaiters.is1) =
  match Htbl.find_exn awaiters (Packed t) with
  | before ->
      let many = Awaiters.snoc before one in
      if not (Htbl.try_compare_and_set awaiters (Packed t) before (Min1 many))
      then add_awaiter t one
  | exception Not_found ->
      if not (Htbl.try_add awaiters (Packed t) (Min1 one)) then
        add_awaiter t one

that adds an awaiter (one is a node for single awaiter) to a queue in the awaiters hash table. Notice how the operations provided by the Htbl allow one to write that using a very familiar lock-free retry pattern.

[lyrm]

This PR is ready. I have began squashing the commits to make it more readable if additional people want to have a look before it is merged.