Event Module

(ev/acquire-lock lock)

Acquire a lock such that this operating system thread is the only thread with access to this resource. This will block this entire thread until the lock becomes available, and will not yield to other fibers on this system thread.

(ev/acquire-rlock rwlock)

Acquire a read lock an a read-write lock.

(ev/acquire-wlock rwlock)

Acquire a write lock on a read-write lock.

(ev/all-tasks)

Get an array of all active fibers that are being used by the scheduler.

(ev/call f & args)

Call a function asynchronously. Returns a fiber that is scheduled to run the function.

(ev/cancel fiber err)

Cancel a suspended fiber in the event loop. Differs from cancel in that it returns the canceled fiber immediately.

(ev/capacity channel)

Get the number of items a channel will store before blocking writers.

(ev/chan &opt capacity)

Create a new channel. capacity is the number of values to queue before blocking writers, defaults to 0 if not provided. Returns a new channel.

(ev/chan-close chan)

Close a channel. A closed channel will cause all pending reads and writes to return nil. Returns the channel.

(ev/chunk stream n &opt buffer timeout)

Same as ev/read, but will not return early if less than n bytes are available. If an end of stream is reached, will also return early with the collected bytes.

(ev/close stream)

Close a stream. This should be the same as calling (:close stream) for all streams.

(ev/count channel)

Get the number of items currently waiting in a channel.

(ev/deadline sec &opt tocancel tocheck)

Schedules the event loop to try to cancel the tocancel task as with ev/cancel. After sec seconds, the event loop will attempt cancellation of tocancel if the tocheck fiber is resumable. sec is a number that can have a fractional part. tocancel defaults to (fiber/root), but if specified, must be a task (root fiber). tocheck defaults to (fiber/current), but if specified, should be a fiber. Returns tocancel immediately.

(ev/do-thread & body)

Run some code in a new thread. Suspends the current fiber until the thread is complete, and evaluates to nil.

(ev/full channel)

Check if a channel is full or not.

(ev/gather & bodies)

Run a number of fibers in parallel on the event loop, and join when they complete. Returns the gathered results in an array.

(ev/give channel value)

Write a value to a channel, suspending the current fiber if the channel is full. Returns the channel if the write succeeded, nil otherwise.

(ev/give-supervisor tag & payload)

Send a message to the current supervisor channel if there is one. The message will be a tuple of all of the arguments combined into a single message, where the first element is tag. By convention, tag should be a keyword indicating the type of message. Returns nil.

(ev/go fiber-or-fun &opt value supervisor)

Put a fiber on the event loop to be resumed later. If a function is used, it is wrapped with fiber/new first. Optionally pass a value to resume with, otherwise resumes with nil. Returns the fiber. An optional core/channel can be provided as a supervisor. When various events occur in the newly scheduled fiber, an event will be pushed to the supervisor. If not provided, the new fiber will inherit the current supervisor.

(ev/lock)

Create a new lock to coordinate threads.

(ev/read stream n &opt buffer timeout)

Read up to n bytes into a buffer asynchronously from a stream. n can also be the keyword :all to read into the buffer until end of stream. Optionally provide a buffer to write into as well as a timeout in seconds after which to cancel the operation and raise an error. Returns the buffer if the read was successful or nil if end-of-stream reached. Will raise an error if there are problems with the IO operation.

(ev/release-lock lock)

Release a lock such that other threads may acquire it.

(ev/release-rlock rwlock)

Release a read lock on a read-write lock

(ev/release-wlock rwlock)

Release a write lock on a read-write lock

(ev/rselect & clauses)

Similar to ev/select, but will try clauses in a random order for fairness.

(ev/rwlock)

Create a new read-write lock to coordinate threads.

(ev/select & clauses)

Block until the first of several channel operations occur. Returns a tuple of the form [:give chan], [:take chan x], or [:close chan], where a :give tuple is the result of a write and a :take tuple is the result of a read. Each clause must be either a channel (for a channel take operation) or a tuple [channel x] (for a channel give operation). Operations are tried in order such that earlier clauses take precedence over later clauses. Both give and take operations can return a [:close chan] tuple, which indicates that the specified channel was closed while waiting, or that the channel was already closed.

(ev/sleep sec)

Suspend the current fiber for sec seconds without blocking the event loop.

(ev/spawn & body)

Run some code in a new fiber. This is shorthand for (ev/go (fn [] ;body)).

(ev/spawn-thread & body)

Run some code in a new thread. Like ev/do-thread, but returns nil immediately.

(ev/take channel)

Read from a channel, suspending the current fiber if no value is available.

(ev/thread main &opt value flags supervisor)

Run main in a new operating system thread, optionally passing value to resume with. The parameter main can either be a fiber, or a function that accepts 0 or 1 arguments. Unlike ev/go, this function will suspend the current fiber until the thread is complete. If you want to run the thread without waiting for a result, pass the :n flag to return nil immediately. Otherwise, returns nil. Available flags:

• :n - return immediately
• :t - set the task-id of the new thread to value. The task-id is passed in messages to the supervisor channel.
• :a - don't copy abstract registry to new thread (performance optimization)
• :c - don't copy cfunction registry to new thread (performance optimization)

(ev/thread-chan &opt limit)

Create a threaded channel. A threaded channel is a channel that can be shared between threads and used to communicate between any number of operating system threads.

(ev/to-file)

Create core/file copy of the stream. This value can be used when blocking IO behavior is needed.

(ev/with-deadline sec & body)

Create a fiber to execute body, schedule the event loop to cancel the task (root fiber) associated with body's fiber, and start body's fiber by resuming it.

The event loop will try to cancel the root fiber if body's fiber has not completed after at least sec seconds.

sec is a number that can have a fractional part.

(ev/with-lock lock & body)

Run a body of code after acquiring a lock. Will automatically release the lock when done.

(ev/with-rlock lock & body)

Run a body of code after acquiring read access to an rwlock. Will automatically release the lock when done.

(ev/with-wlock lock & body)

Run a body of code after acquiring write access to an rwlock. Will automatically release the lock when done.

(ev/write stream data &opt timeout)

Write data to a stream, suspending the current fiber until the write completes. Takes an optional timeout in seconds, after which will return nil. Returns nil, or raises an error if the write failed.