package riot

You can search for identifiers within the package.

in-package search v0.2.0

On This Page

Riot

package riot

riot
- CHANGES
- LICENSE
- README
- Library lib_net
  - Lib_net
    
    Socket
    
    Addr
- Library logger
  - Logger
    
    Level
    
    Intf
    
    Namespace
    
    Make
- Library riot
  - Riot
    
    Ref
    
    Pid
    
    Message
    
    Process
    
    Messages
    
    Application
    
    Intf
    
    Gen_server
    
    Impl
    
    Supervisor
    
    Telemetry
    
    Logger
    
    Intf
    
    Namespace
    
    Make
    
    Net
    
    Addr
    
    Socket
    
    Timer
    
    Queue
- Library riot.core
  - Core
    
    Mailbox
    
    Message
    
    Pid
    
    Proc_effect
    
    Proc_queue
    
    Proc_registry
    
    Exn
    
    Proc_set
    
    Proc_state
    
    Proc_table
    
    Process
    
    Messages
    
    Ref
    
    Scheduler_uid
- Library riot.lib
  - Lib
    
    Telemetry
    
    Logger
    
    Level
    
    Intf
    
    Namespace
    
    Make
    
    Formatter
    
    Application
    
    Intf
    
    Gen_server
    
    Impl
    
    Supervisor
    
    Queue
    
    Net
    
    Process
    
    Messages
- Library riot.log
  - Log
- Library riot.net
  - Net
    
    Addr
    
    Io
    
    Socket
- Library riot.runtime
  - Runtime
    
    Log
    
    Net
    
    Mailbox
    
    Message
    
    Pid
    
    Proc_effect
    
    Proc_queue
    
    Proc_registry
    
    Proc_set
    
    Proc_state
    
    Proc_table
    
    Process
    
    Ref
    
    Scheduler_uid
    
    Timer
    
    Dashmap
    
    Fd
    
    Lf_queue
    
    Thread_local
    
    Uid
- Library riot.scheduler
  - Scheduler
    
    Tracer
    
    Uid
    
    Pool
- Library riot.util
  - Util
    
    Dashmap
    
    Fd
    
    Mode
    
    Lf_queue
    
    Thread_local
    
    Uid
- Library time
  - Time
    
    Timer_wheel
    
    Timer
- Sources
  - lib_net
    
    addr.ml
    
    lib_net.ml
    
    lib_net__.ml
    
    socket.ml
  - logger
    
    logger.ml
  - riot
    
    riot.ml
  - riot.core
    
    core.ml
    
    mailbox.ml
    
    message.ml
    
    pid.ml
    
    proc_effect.ml
    
    proc_queue.ml
    
    proc_registry.ml
    
    proc_set.ml
    
    proc_state.ml
    
    proc_table.ml
    
    process.ml
    
    ref.ml
    
    scheduler_uid.ml
  - riot.lib
    
    application.ml
    
    gen_server.ml
    
    lib.ml
    
    lib__.ml
    
    logger_app.ml
    
    process.ml
    
    supervisor.ml
    
    telemetry_app.ml
  - riot.log
    
    log.ml
  - riot.net
    
    addr.ml
    
    io.ml
    
    net.ml
    
    socket.ml
  - riot.runtime
    
    import.ml
    
    rc.ml
    
    runtime.ml
    
    runtime__.ml
  - riot.scheduler
    
    scheduler.ml
    
    scheduler__.ml
    
    tracer.ml
  - riot.util
    
    dashmap.ml
    
    fd.ml
    
    lf_queue.ml
    
    thread_local.ml
    
    uid.ml
    
    util.ml
  - time
    
    time.ml
    
    timer_wheel.ml

Legend:
Page
Library
Module
Module type
Parameter
Class
Class type
Source

Module `Riot`Source

Riot

module Ref : sig ... end

module Pid : sig ... end

module Message : sig ... end

Sourcemodule Process : sig ... end

Sourcemodule Application : sig ... end

A Riot `Application` can be used to encapsulate functionality that must share the same lifecycle. For example, the `Riot.Logger` is an Application.

Sourceval random : unit -> Random.State.t

Returnts the current random state from a scheduler.

Sourceval yield : unit -> unit

Suspends execution of the current process and returns control to the scheduler

Sourceval sleep : float -> unit

sleep t Suspends execution of the current process for at least `t` seconds. `t` is a float so it supports subsecond values: `0.001` is 1 millisecond.

Sourceval self : unit -> Pid.t

Returns the process identifier (pid) for the current process

Sourceval process_flag : Process.process_flag -> unit

Sourceval exit : Pid.t -> Process.exit_reason -> unit

Sends an exit signal to the process pid, to exit with reason exit_reason

Sourceval send : Pid.t -> Message.t -> unit

Sends a message to process with this pid.

Sourceexception Invalid_destination of string

Sourceval send_by_name : name:string -> Message.t -> unit

Sends a message to a process registered with name. If name is not a valid destination for a message, this function raises an Invalid_destination name exception.

Sourceval spawn : (unit -> unit) -> Pid.t

Spawns a new process.

Sourceval spawn_link : (unit -> unit) -> Pid.t

Spawns a new process and links it to the current process before returning.

exception Name_already_registered of string * Pid.t

Sourceval register : string -> Pid.t -> unit

register name pid registers a process by a given name. The name will be uniquely associated to this process and attempting to register the same name twice will result in an exception Name_already_registered being raised.

Sourceval unregister : string -> unit

unregister name frees a name and allows it to be re-registered. If the name was not registered before, this operation does nothing.

Sourceexception Link_no_process of Pid.t

Sourceval link : Pid.t -> unit

Links the current process and the process pid together.

Sourceval monitor : Pid.t -> Pid.t -> unit

Makes pid1 a monitor of pid2. When pid2 terminates, pid1 will receive a message.

Sourceval processes : unit -> (Pid.t * Process.t) Seq.t

`processes ()` will list all the processes currently alive.

Sourceval is_process_alive : Pid.t -> bool

Returns true if the process pid is still alive.

Sourceval wait_pids : Pid.t list -> unit

Await all processes in the list to termimante.

Sourceval receive : ?ref:unit Ref.t -> unit -> Message.t

receive () will return the first message in the process mailbox.

This function will suspend a process that has an empty mailbox, and the process will remain asleep until a message is delivered to it.

### Selective Receive

If a `ref` was passed, then `receive ref ()` will skip all messages created before the creation of this `Ref.t` value, and will only return newer messages.

This is useful to skip the queue, but not remove any of the messages before it. Those messages will be delivered in-order in future calls to `receive ()`.

Sourceval shutdown : unit -> unit

Gracefully shuts down the runtime. Any non-yielding process will block this.

Sourceval run : ?rnd:Random.State.t -> ?workers:int -> (unit -> unit) -> unit

Start the Riot runtime using function main to boot the system

Source

val start : 
  ?rnd:Random.State.t ->
  ?workers:int ->
  apps:(module Application.Intf) list ->
  unit ->
  unit

Start the Riot runtime with a series of applications.

Each application will be started in the same order as specified, and if any application fails to start up, the system will be shutdown.

Once the applications are started, they will all be monitored until they are all terminated. Only then will the runtime shutdown.

Sourceval trace_send : (Pid.t -> Process.t -> Message.t -> unit) -> unit

Sourceval trace_proc_run : (int -> Process.t -> unit) -> unit

Sourcemodule Gen_server : sig ... end

Sourcemodule Supervisor : sig ... end

Sourcemodule Telemetry : sig ... end

Sourcemodule Logger : sig ... end

Sourcemodule Net : sig ... end

Sourcemodule Timer : sig ... end

module Queue : sig ... end

package riot

Module RiotSource

Riot

Module `Riot`Source