package moonpool

You can search for identifiers within the package.

in-package search v0.2.0

moonpool
- Moonpool
  - Atomic
  - Blocking_queue
  - Fut
    
    INFIX
    
    Infix
    
    _
    
    Infix_local
  - Pool

Legend:
Library
Module
Module type
Parameter
Class
Class type

A simple blocking queue.

This queue is quite basic and will not behave well under heavy contention. However, it can be sufficient for many practical use cases.

NOTE: this queue will typically block the caller thread in case the operation (push/pop) cannot proceed. Be wary of deadlocks when using the queue from a pool when you expect the other end to also be produced/consumed from the same pool.

See discussion on Fut.wait_block for more details on deadlocks and how to mitigate the risk of running into them.

More scalable queues can be found in Lockfree (https://github.com/ocaml-multicore/lockfree/)

type 'a t

Unbounded blocking queue.

This queue is thread-safe and will block when calling pop on it when it's empty.

val create : unit -> _ t

Create a new unbounded queue.

val size : _ t -> int

Number of items currently in the queue. Note that pop might still block if this returns a non-zero number, since another thread might have consumed the items in the mean time.

since 0.2

exception Closed

val push : 'a t -> 'a -> unit

push q x pushes x into q, and returns ().

In the current implementation, push q will never block for a long time, it will only block while waiting for a lock so it can push the element.

raises Closed
if the queue is closed (by a previous call to close q)

val pop : 'a t -> 'a

pop q pops the next element in q. It might block until an element comes.

raises Closed
if the queue was closed before a new element was available.

val close : _ t -> unit

Close the queue, meaning there won't be any more push allowed, ie push will raise Closed.

pop will keep working and will return the elements present in the queue, until it's entirely drained; then pop will also raise Closed.