The aether Reference Manual

Table of Contents

Next: , Previous: , Up: (dir)   [Contents][Index]

The aether Reference Manual

This is the aether Reference Manual, version 1.0.1, generated automatically by Declt version 3.0 "Montgomery Scott" on Tue Dec 22 11:37:32 2020 GMT+0.


Next: , Previous: , Up: Top   [Contents][Index]

1 Introduction

aether

aether is a Common Lisp framework for emulating an actor-based distributed system housed on a family of emulated devices.

Overview

The purpose of aether is to provide a testbed in which one can design the behaviors of distributed electronics, emulate software running on them, and instrument the emulation to infer software performance characteristics.

The framework is segmented into the following layers:

Each layer comes with standard instances which embody default behaviors. These can be used as-is for "macroscopic", detail-free emulation, and they can be subclassed to permit the injection of detailed, domain-specific behaviors (e.g., faithful emulation of network load). The actor-based DSL can be useful in the specification of both the behavior of the electronics and the behavior of the program: starting with the latter gives information about algorithm performance in the case of "ideal" hardware, and migrating to the latter pins down the performance features specific to that case.

Installation

The simplest installation method is to use Quicklisp: running (ql:quickload "aether") will download aether as well as any project dependencies.

Before aether is available via the Quicklisp index, or to use a bleeding-edge version, clone the aether git repository into your Quicklisp local project directory and then quickload as above.

Example

Here is an example description of a simple processor which responds to external impulses (i.e., messages on the aether network) to compute integer factorials.

(defclass arithmetic-server (process)
  ((process-clock-rate :initform 1))
  (:documentation "Simple server process that handles an arithmetic RPC call."))

;;; processor description / computational primitives

;; all PROCESS instances begin with the command START
(define-process-upkeep ((process arithmetic-server) now) (START)
  "Make the processor sit in an infinite \"listening\" loop."
  (process-continuation process `(START)))

(define-process-upkeep ((process arithmetic-server) now) (PUSH n)
  (push n (process-data-stack process)))

(define-process-upkeep ((process arithmetic-server) now) (MULTIPLY)
  (let ((left (pop (process-data-stack process)))
        (right (pop (process-data-stack process))))
    (push (* left right) (process-data-stack process))))

(define-process-upkeep ((process arithmetic-server) now) (EMIT address)
  (let* ((result (pop (process-data-stack process)))
         (message (make-message-rpc-done :result result)))
    (send-message address message)))

;;; public-facing factorial service

(defstruct (message-factorial (:include message))
  (n   nil :type (integer 0)))

(define-message-handler handle-message-factorial
    ((process arithmetic-server) (message message-factorial) now)
  (process-continuation process
                        `(FACTORIAL ,(message-factorial-n message))
                        `(EMIT ,(message-reply-channel message))))

(define-process-upkeep ((process arithmetic-server) now)
    (FACTORIAL n)
  (cond
    ((zerop n)
     (process-continuation process `(PUSH 1)))
    (t
     (process-continuation process
                           `(FACTORIAL ,(1- n))
                           `(PUSH ,n)
                           `(MULTIPLY)))))

;;; service registry

(define-message-dispatch arithmetic-server
  (message-factorial 'handle-message-factorial))

;;; example: spawning a server and querying it

;; set up the actors
(let* ((simulation (make-simulation))
       (*local-courier* (make-instance 'courier))
       (server (spawn-process 'arithmetic-server))
       (reply-channel (register)))
  (simulation-add-event simulation (make-event :callback server))
  (simulation-add-event simulation (make-event :callback *local-courier*))
  ;; send the factorial request
  (send-message (process-public-address server)
                (make-message-factorial :reply-channel reply-channel
                                        :n 15))
  ;; wait a while for it to complete
  (simulation-run simulation :canary (canary-until 60))
  ;; unpack the reply
  (receive-message (reply-channel done-message)
    (message-rpc-done
     (unregister reply-channel)
     (message-rpc-done-result done-message))))

Further examples can be found under the directory tests/examples/ in the source tree. They primarily demonstrate features of the standard library. These "living" examples are run regularly as part of the test suite.

License

aether is made available under the MIT license. See LICENSE.md in the source tree for more information.

See also


Next: , Previous: , Up: Top   [Contents][Index]

2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 aether

Author

Eric Peterson <peterson.eric.c@gmail.com>

License

MIT (See LICENSE.md)

Description

A DSL for emulating an actor-based distributed system, housed on a family of emulated devices.

Version

1.0.1

Dependencies
Source

aether.asd (file)

Components

Next: , Previous: , Up: Top   [Contents][Index]

3 Modules

Modules are listed depth-first from the system components tree.


Next: , Previous: , Up: Modules   [Contents][Index]

3.1 aether/debug

Dependency

cheap-heap.lisp (file)

Parent

aether (system)

Location

debug/

Components

Previous: , Up: Modules   [Contents][Index]

3.2 aether/process

Dependency

network.lisp (file)

Parent

aether (system)

Location

process/

Components

Next: , Previous: , Up: Top   [Contents][Index]

4 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

4.1 Lisp


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.1 aether.asd

Location

/home/quickref/quicklisp/dists/quicklisp/software/aether-v1.0.1/aether.asd

Systems

aether (system)


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.2 aether/package.lisp

Parent

aether (system)

Location

package.lisp

Packages

aether


Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.3 aether/utilities.lisp

Dependency

package.lisp (file)

Parent

aether (system)

Location

utilities.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.4 aether/queue.lisp

Dependency

utilities.lisp (file)

Parent

aether (system)

Location

queue.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.5 aether/cheap-heap.lisp

Dependency

queue.lisp (file)

Parent

aether (system)

Location

cheap-heap.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.6 aether/debug/logger.lisp

Parent

debug (module)

Location

debug/logger.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.7 aether/debug/trace.lisp

Dependency

logger.lisp (file)

Parent

debug (module)

Location

debug/trace.lisp

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.8 aether/event.lisp

Dependency

debug (module)

Parent

aether (system)

Location

event.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.9 aether/message.lisp

Dependency

event.lisp (file)

Parent

aether (system)

Location

message.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.10 aether/network.lisp

Dependency

message.lisp (file)

Parent

aether (system)

Location

network.lisp

Exported Definitions

make-courier-grid (function)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.11 aether/process/process.lisp

Parent

process (module)

Location

process/process.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.12 aether/process/dpu-helpers.lisp

Dependency

process.lisp (file)

Parent

process (module)

Location

process/dpu-helpers.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.13 aether/process/dereference.lisp

Dependency

dpu-helpers.lisp (file)

Parent

process (module)

Location

process/dereference.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.14 aether/process/emissary.lisp

Dependency

dereference.lisp (file)

Parent

process (module)

Location

process/emissary.lisp

Exported Definitions

define-message-subordinate (macro)

Internal Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.15 aether/rpc.lisp

Dependency

process (module)

Parent

aether (system)

Location

rpc.lisp

Exported Definitions

Next: , Previous: , Up: Lisp files   [Contents][Index]

4.1.16 aether/lock.lisp

Dependency

rpc.lisp (file)

Parent

aether (system)

Location

lock.lisp

Exported Definitions
Internal Definitions

Previous: , Up: Lisp files   [Contents][Index]

4.1.17 aether/cast.lisp

Dependency

lock.lisp (file)

Parent

aether (system)

Location

cast.lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

5 Packages

Packages are listed by definition order.


Previous: , Up: Packages   [Contents][Index]

5.1 aether

Source

package.lisp (file)

Use List

common-lisp

Exported Definitions
Internal Definitions

Next: , Previous: , Up: Top   [Contents][Index]

6 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

6.1 Exported definitions


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.1 Special variables

Special Variable: *local-courier*

Bound to the ‘COURIER’ that services this process.

Package

aether

Source

message.lisp (file)

Special Variable: *logger*
Package

aether

Source

logger.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.2 Macros

Macro: define-broadcast-handler HANDLER-NAME ((PROCESS PROCESS-TYPE) (MESSAGE MESSAGE-TYPE) NOW) &body BODY

This macro augments ‘DEFINE-MESSAGE-HANDLER’, by pushing a ‘BROADCAST’ command onto the ‘PROCESS’s command stack. This command takes no arguments, but expects a ‘BROADCAST-FRAME’ to be on the data stack when it is called. Thus, either the handler must prepare the data frame, or it must be prepared by whatever script is pushed onto the command stack by the handler. Additionally, inside the context of ‘DEFINE-BROADCAST-HANDLER’ we have access to a pair of helper functions:

1. ‘PUSH-BROADCAST-FRAME’, which creates a ‘BROADCAST-FRAME’ and pushes it onto the data stack. If no ‘MESSAGE’ is provided to the function, it defaults to the ‘MESSAGE’ currently being handled. If a user calls ‘PUSH-BROADCAST-FRAME’ twice in the same handler, an error will be raised.
2. ‘RETURN-FROM-CAST’, which allows the user to terminate the broadcast operation early by sending up an acknowledgement (optionally specifying its contents) to the original sender of ‘MESSAGE’.

WARNING: ‘RETURN-FROM-CAST’ calls ‘PUSH-BROADCAST-FRAME’ as part of the aborting process. If a frame has already been pushed onto the data stack, we instead alter that frame rather than pushing an additional one (which could have strange consequences). Additionally, it is important to note that ‘RETURN-FROM-CAST’ uses ‘FINISH-WITH-FUTURES’ in order to return from the handler early.

Package

aether

Source

cast.lisp (file)

Macro: define-convergecast-handler HANDLER-NAME ((PROCESS PROCESS-TYPE) (MESSAGE MESSAGE-TYPE) NOW) &body BODY

This macro augments ‘DEFINE-MESSAGE-HANDLER’, by pushing a ‘CONVERGECAST’ command onto the ‘PROCESS’s command stack. This command takes no arguments, but expects a ‘CONVERGECAST-FRAME’ to be on the data stack when it is called. Thus, either the handler must prepare the data frame, or it must be prepared by whatever script is pushed onto the command stack by the handler. Additionally, inside the context of ‘DEFINE-CONVERGECAST-HANDLER’ we have access to a pair of helper functions:

1. ‘PUSH-CONVERGECAST-FRAME’, which creates a ‘CONVERGECAST-FRAME’ and pushes it onto the data stack. If no ‘MESSAGE’ is provided to the function, it defaults to the ‘MESSAGE’ currently being handled. If a user calls ‘PUSH-BROADCAST-FRAME’ twice in the same handler, an error will be raised.
2. ‘RETURN-FROM-CAST’, which allows the user to terminate the convergecast operation early by sending up an acknowledgement (optionally specifying its contents) to the original sender of ‘MESSAGE’. It is recommended that a value is provided when returning from a convergecast, as it will be passed to a function (the function provided to the ‘CONVERGECAST-FRAME’) when received by the original sender.

WARNING: ‘RETURN-FROM-CAST’ calls ‘PUSH-CONVERGECAST-FRAME’ as part of the aborting process. If a frame has already been pushed onto the data stack, we instead alter that frame rather than pushing an additional one (which could have strange consequences). Additionally, it is important to note that ‘RETURN-FROM-CAST’ uses ‘FINISH-WITH-FUTURES’ in order to return from the handler early.

Package

aether

Source

cast.lisp (file)

Macro: define-message-dispatch NODE-TYPE &body CLAUSES

Defines "automatic" message handlers associated to a particular subtype of ‘PROCESS’. Each handler is specified by a tuple of form (MESSAGE-TYPE MESSAGE-HANDLER &OPTIONAL GUARD). As with ‘RECEIVE-MESSAGE’, each clause is processed in turn, according to the following rules:

+ If supplied, ‘GUARD’ is evaluated with the ‘PROCESS’ in question bound to the place ‘PROCESS-TYPE’. If ‘GUARD’ evaluates to NIL, proceed to the next clause.
+ Check the message queue at the public address for an item of type ‘MESSAGE-TYPE’. If such a message is found, call the associated ‘MESSAGE-HANDLER’ with lambda triple (PROCESS MESSAGE TIME). Otherwise, proceed to the next clause.

NOTES:
+ If no clause is matched, execution proceeds to the semantics specified by ‘DEFINE-PROCESS-UPKEEP’.
+ Automatically appends a ‘MESSAGE-RTS’ clause which calls ‘HANDLE-MESSAGE-RTS’ and results in an error. Because of this, we set ‘CATCH-RTS?’ to NIL when processing clauses and building ‘RECEIVE-MESSAGE’ blocks. Otherwise, it would be impossible to override the default handling of ‘MESSAGE-RTS’es. + ‘PROCESS-PERUSE-INBOX?’ is passed along to ‘RECEIVE-MESSAGE’, where it determines how we search for a message to handle.

WARNING: These actions are to be thought of as "interrupts". Accordingly, you will probably stall the underlying ‘PROCESS’ if you perform some waiting action here, like the analogue of a ‘SYNC-RECEIVE’.

Package

aether

Source

process.lisp (file)

Macro: define-message-handler HANDLER-NAME ((PROCESS PROCESS-TYPE) (MESSAGE MESSAGE-TYPE) TIME) &body BODY

Defines a function to be invoked by DEFINE-MESSAGE-DISPATCH.

Package

aether

Source

process.lisp (file)

Macro: define-message-subordinate HANDLER-NAME ((PROCESS PROCESS-TYPE) (MESSAGE MESSAGE-TYPE) NOW) &body BODY

Interrupt-based RPC handlers are expected to emit a reply to the caller. This macro augments DEFINE-MESSAGE-HANDLER to reply to the caller with the last evaluated form.

Package

aether

Source

emissary.lisp (file)

Macro: define-object-handler ((OBJECT-VARIABLE OBJECT-TYPE) TIME-VARIABLE) &body BODY

Defines a default event handler for OBJECT-TYPE.

Package

aether

Source

event.lisp (file)

Macro: define-process-upkeep ((PROCESS-NAME PROCESS-TYPE) NOW) (COMMAND &rest COMMAND-ARGS) &body BODY

Defines the behavior of a particular PROCESS (of type PROCESS-TYPE) as it enacts a COMMAND.

PROCESS is COMMAND is a KEYWORD, and COMMAND-ARGS is a DESTRUCTURING-BIND-LAMBDA-LIST.

Locally enables the use of the function PROCESS-DIE and the special form SYNC-RECEIVE.

Package

aether

Source

process.lisp (file)

Macro: define-rpc-handler HANDLER-NAME ((PROCESS PROCESS-TYPE) (MESSAGE MESSAGE-TYPE) NOW) &body BODY

Interrupt-based RPC handlers are expected to emit a reply to the caller. This macro augments DEFINE-MESSAGE-HANDLER to reply to the caller with the last evaluated form.

Package

aether

Source

rpc.lisp (file)

Macro: destructuring-places LAMBDA-LIST EXPRESSION &body BODY

A variant of DESTRUCTURING-BIND that provides SETFs in the style of WITH-SLOTS, but it can only handle the required part of a DESTRUCTURING-LAMBDA-LIST.

Package

aether

Source

utilities.lisp (file)

Macro: dohash ((KEY VALUE) HASH-TABLE &optional RETURN-FORM) &body BODY

Iterates over HASH-TABLE, defining a lexical binding KEY and a place VALUE for each iteration of BODY. Optionally evaluates RETURN-FORM at termination and returns its result; otherwise returns NIL.

WARNING: This routine is based on MAPHASH, which has undefined behavior if the structure of HASH-TABLE is modified during iteration (e.g., the addition of new entries, or the modification of any entry not currently being processed).

Package

aether

Source

utilities.lisp (file)

Macro: ignorant-lambda &body BODY

Defines an anonymous function that discards all of its arguments.

Package

aether

Source

utilities.lisp (file)

Macro: initialize-and-return (&rest BINDINGS) &body BODY

Returns (in reverse order, as VALUES) the contents of BINDINGS after the evaluation of BODY.

Package

aether

Source

utilities.lisp (file)

Macro: receive-message (ADDRESS MESSAGE &key TIMEOUT CATCH-RTS? PERUSE-INBOX? &allow-other-keys) &body CLAUSES

Peruses the mailbox at ‘ADDRESS’ for a ‘MESSAGE’ which matches one of the provided ‘CLAUSES’. Each clause has the form (MESSAGE-TYPE &BODY BODY). Clauses are processed according to the following Erlang-ian rules:

+ Each clause is processed in the order supplied.
+ If a clause is matched, no further clauses are processed.
+ When ‘PERUSE-INBOX?’ is T, each clause (processed in order) searches the whole inbox(in latest-to-most-recent order) for a ‘MESSAGE-TYPE’ match. When NIL, each clause just looks at the first message in the inbox for a ‘MESSAGE-TYPE’ match. + If a waiting message of the appropriate type is found, it is bound to ‘MESSAGE’ and ‘BODY’ is processed.

NOTES:

When ‘CATCH-RTS?’ is T, we append a ‘MESSAGE-RTS’ clause that throws an error.

Permits a clause with head ‘OTHERWISE’ which is executed when no such waiting message is found.

Returns as a secondary value whether a message was processed. (An ‘OTHERWISE’ clause also results in a secondary value of NIL.)

Package

aether

Source

message.lisp (file)

Macro: sync-receive (SYNC-CHANNEL SYNC-MESSAGE-PLACE) &body SYNC-CLAUSES

Models a blocking ‘RECEIVE-MESSAGE’ command.

IMPORTANT WARNING: ‘SYNC-RECEIVE’ returns after it finishes executing its body. Any code following a ‘SYNC-RECEIVE’ **will not** be executed.

NOTE: ‘MESSAGE-RTS’ replies must be explicitly handled. Otherwise, the default behavior is to throw an error, which can be seen in the definition of ‘RECEIVE-MESSAGE’.

NOTE: SYNC-RECEIVE is not available outside the body of DEFINE-PROCESS-UPKEEP.

Package

aether

Source

dpu-helpers.lisp (file)

Macro: sync-rpc MESSAGE (RESULT-PLACE-OR-LIST DESTINATION &key RETURNED?) &body BODY

Performs a synchronized RPC call. Only allowed inside the body of DEFINE-PROCESS-UPKEEP.

Sends ‘MESSAGE’ to ‘DESTINATION’, waits for a reply, and unpacks the reply into ‘RESULT-PLACE-OR-LIST’.

If ‘RETURNED?’ is supplied and this call generates a ‘MESSAGE-RTS’ reply, then ‘RETURNED?’ will be flagged and control resumes. Otherwise, controlled is interrupted by an error.

Package

aether

Source

rpc.lisp (file)

Macro: with-address-dereferencing () &body BODY

Context macro which permits use of DEREFERENCE in its body.

Package

aether

Source

dereference.lisp (file)

Macro: with-courier (&rest KEYWORD-ARGUMENTS) &body BODY

Initializes the ‘*LOCAL-COURIER*’ parameter as a fresh ‘COURIER’. Also takes a list of ‘KEYWORD-ARGUMENT’s (e.g. :processing-clock-rate 20) that are passed along to the constructor.

Package

aether

Source

message.lisp (file)

Macro: with-futures &body BODY

Stores an implicit set of EVENT objects to return when exiting the WITH-FUTURE block.

Provides some helper functions: FUTURE, FUTURE*, and FINISH-WITH-FUTURES.

Package

aether

Source

event.lisp (file)

Macro: with-replies (REPLIES &key RETURNED? CLOSE? MESSAGE-TYPE MESSAGE-UNPACKER) ADDRESSES &body BODY

Amasses results from ‘MESSAGE-RPC-DONE’ messages received on ‘ADDRESSES’ into a list stored in ‘REPLIES’. This list is sorted in the same order as ‘ADDRESSES’. Execution of ‘BODY’ resumes when each address has received such a message.

If ‘RETURNED?’ is supplied, then in the event of a ‘MESSAGE-RTS’, this flag is set. If it is not supplied, this raises an error.

Typical use looks like:

(with-replies
(replies :returned? returned?)
(send-message-batch #’make-blossom-msg-scan targets)
(let ((reply (reduce #’unify-pongs replies)))
(send-message reply-channel reply)))

NOTE: WITH-REPLIES is not available outside the body of DEFINE-PROCESS-UPKEEP.

Package

aether

Source

dpu-helpers.lisp (file)

Macro: with-simulation (NAME (&rest STARTING-OBJECTS)) &body BODY

Initializes a new SIMULATION bound to name NAME using MAKE-SIMULATION and adds an EVENT to the SIMULATION at time 0 for every object in STARTING-OBJECTs.

Package

aether

Source

event.lisp (file)

Macro: with-transient-logger () &body BODY

Initialize a fresh logger. Returns log contents on close.

Package

aether

Source

logger.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.3 Functions

Function: address= LEFT RIGHT

Tests for semantic equality of addresses.

Package

aether

Source

message.lisp (file)

Function: canary-all &rest CANARIES

Announce a trigger when all of the CANARIES are simultaneously triggered.

Package

aether

Source

event.lisp (file)

Function: canary-any &rest CANARIES

Announce a trigger when any one of the CANARIES is triggered.

Package

aether

Source

event.lisp (file)

Function: canary-process PROCESS

Pause a simulation when PROCESS halts.

Package

aether

Source

event.lisp (file)

Function: canary-timeout TIMEOUT

Throw an error when TIMEOUT arrives.

Package

aether

Source

event.lisp (file)

Function: canary-until UNTIL

Pause a simulation after UNTIL passes.

Package

aether

Source

event.lisp (file)

Function: cheap-heap-dequeue HEAP
Package

aether

Source

cheap-heap.lisp (file)

Function: cheap-heap-enqueue HEAP ITEM KEY
Package

aether

Source

cheap-heap.lisp (file)

Function: cheap-heap-peep HEAP
Package

aether

Source

cheap-heap.lisp (file)

Function: courier-processing-clock-rate INSTANCE
Function: (setf courier-processing-clock-rate) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: dereference ADDRESS

Looks up the Lisp PROCESS object which owns the provided public ADDRESS. Only functions within WITH-ADDRESS-DEREFERENCING, not hardware-realistic, only for use during debugging.

Package

aether

Source

dereference.lisp (file)

Function: finish-with-futures &optional EVENT-LIST

Breaks out of WITH-FUTURE. If EVENTS is supplied, returns EVENTS in place of the implicit event list.

Package

aether

Source

event.lisp (file)

Function: future FN-OR-OBJ TIME

Installs a future EVENT object, which invokes FN-OR-OBJ at the specified TIME.

Package

aether

Source

event.lisp (file)

Function: future* EVENT-LIST

Installs a list of future EVENT objects.

Package

aether

Source

event.lisp (file)

Function: hash-address ADDRESS
Package

aether

Source

message.lisp (file)

Function: log-entry &rest INITARGS &key LOGGER SOURCE SOURCE-TYPE TIME ENTRY-TYPE &allow-other-keys

Injects a log entry.

Package

aether

Source

logger.lisp (file)

Function: logger-entries INSTANCE
Function: (setf logger-entries) VALUE INSTANCE
Package

aether

Source

logger.lisp (file)

Function: make-broadcast-frame &key (ABORTING? ABORTING?) (HANDLE-RTS? HANDLE-RTS?) (MESSAGE MESSAGE) (TARGETS TARGETS)
Package

aether

Source

cast.lisp (file)

Function: make-cheap-heap ()
Package

aether

Source

cheap-heap.lisp (file)

Function: make-convergecast-frame &key (ABORTING? ABORTING?) (HANDLE-RTS? HANDLE-RTS?) (MESSAGE MESSAGE) (TARGETS TARGETS) (FUNC FUNC) (INPUT INPUT)
Package

aether

Source

cast.lisp (file)

Function: make-courier &key (QUEUE QUEUE) (INBOXES INBOXES) (SECRETS SECRETS) (PROCESSING-CLOCK-RATE PROCESSING-CLOCK-RATE) (DEFAULT-ROUTING-TIME-STEP DEFAULT-ROUTING-TIME-STEP) (ID ID) (NEIGHBORS NEIGHBORS)
Package

aether

Source

message.lisp (file)

Function: make-courier-grid SIZE-I SIZE-J

Constructs a (size-i x size-j) grid of COURIER-GRIDDED instances.

Package

aether

Source

network.lisp (file)

Function: make-event &key (CALLBACK CALLBACK) (TIME TIME)
Package

aether

Source

event.lisp (file)

Function: make-message &key (REPLY-CHANNEL REPLY-CHANNEL) (MESSAGE-ID MESSAGE-ID)
Package

aether

Source

message.lisp (file)

Function: make-message-lock &key (REPLY-CHANNEL REPLY-CHANNEL) (MESSAGE-ID MESSAGE-ID)
Package

aether

Source

lock.lisp (file)

Function: make-message-rpc-done &key (REPLY-CHANNEL REPLY-CHANNEL) (MESSAGE-ID MESSAGE-ID) (RESULT RESULT)
Package

aether

Source

message.lisp (file)

Function: make-message-rts &key (REPLY-CHANNEL REPLY-CHANNEL) (MESSAGE-ID MESSAGE-ID)
Package

aether

Source

message.lisp (file)

Function: make-message-unlock &key (REPLY-CHANNEL REPLY-CHANNEL) (MESSAGE-ID MESSAGE-ID) (RESULT RESULT)
Package

aether

Source

lock.lisp (file)

Function: make-q &rest ITEMS
Package

aether

Source

queue.lisp (file)

Function: make-simulation ()

Constructs an empty SIMULATION.

Package

aether

Source

event.lisp (file)

Function: message-reply-channel INSTANCE
Function: (setf message-reply-channel) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-rpc-done-result INSTANCE
Function: (setf message-rpc-done-result) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: peek LIST

Synonym for the PEEK operation on a stack.

Package

aether

Source

utilities.lisp (file)

Function: print-log ENTRIES &optional STREAM
Package

aether

Source

logger.lisp (file)

Function: print-message-report &optional LOGGER

Print a report of the different types of messages sent in ‘LOGGER’, and a count for each. Calls ‘MESSAGE-LOG’ and ‘MESSAGE-REPORT’.

Package

aether

Source

logger.lisp (file)

Function: process-continuation PROCESS &rest COMMANDS

Installs ‘COMMANDS’ to be executed as next steps by ‘PROCESS’.

Package

aether

Source

process.lisp (file)

Function: process-die ()

PROCESS-DIE causes the current PROCESS to release its public mailbox and exit the parent SIMULATION loop.

NOTE: PROCESS-DIE is not available outside the body of DEFINE-PROCESS-UPKEEP.

Package

aether

Source

dpu-helpers.lisp (file)

Function: process-public-address PROCESS

Extracts the public ADDRESS associated to PROCESS.

Package

aether

Source

process.lisp (file)

Function: push-broadcast-frame &key ABORTING? HANDLE-RTS? MESSAGE TARGETS

Convenience function for creating a ‘BROADCAST-FRAME’ and pushing it onto the ‘PROCESS-DATA-STACK’.

Package

aether

Source

cast.lisp (file)

Function: push-convergecast-frame &key ABORTING? HANDLE-RTS? FUNC INPUT MESSAGE TARGETS

Convenience function for creating a ‘CONVERGECAST-FRAME’ and pushing it onto the ‘PROCESS-DATA-STACK’.

Package

aether

Source

cast.lisp (file)

Function: q-deq Q
Package

aether

Source

queue.lisp (file)

Function: q-deq-first Q PRED

Dequeue the first message in ‘Q’ that satisfies ‘PRED’.

Package

aether

Source

queue.lisp (file)

Function: q-deq-when Q PRED

Dequeue the message at the front of ‘Q’ when ‘PRED’ is T.

Package

aether

Source

queue.lisp (file)

Function: q-empty Q
Package

aether

Source

queue.lisp (file)

Function: q-enq EL Q
Package

aether

Source

queue.lisp (file)

Function: q-len Q
Package

aether

Source

queue.lisp (file)

Function: q-peek Q
Package

aether

Source

queue.lisp (file)

Function: q-push Q EL
Package

aether

Source

queue.lisp (file)

Function: register &key COURIER CHANNEL SECRET

Registers a fresh channel over which messages can be transmitted and received.

Package

aether

Source

message.lisp (file)

Function: reset-logger &optional LOGGER

Empties the current logger of all entries.

Package

aether

Source

logger.lisp (file)

Function: return-from-cast &optional VALUE REASON

Allows the user to return early from a broadcast or convergecast operation.

Package

aether

Source

cast.lisp (file)

Function: send-message DESTINATION PAYLOAD

Sends the message ‘PAYLOAD’ to be received at ‘DESTINATION’, an ‘ADDRESS’. Returns the ‘REPLY-CHANNEL’ of the ‘PAYLOAD’, if any.

Package

aether

Source

message.lisp (file)

Function: send-message-batch PAYLOAD-CONSTRUCTOR DESTINATIONS &key REPLIES?

Sends a batch of messages to the ‘ADDRESS’es housed in ‘DESTINATIONS’. Each message is constructed afresh using ‘PAYLOAD-CONSTRUCTOR’, supplied with a freshly registered reply channel, and the list of reply channels is returned as a result.

Package

aether

Source

message.lisp (file)

Function: simulation-add-event SIMULATION EVENT

Installs EVENT into SIMULATION for later processing.

Package

aether

Source

event.lisp (file)

Function: simulation-run SIMULATION &key CANARY

Processes EVENTs belonging to SIMULATION, until either SIMULATION is exhausted or CANARY evaluates to T.

Package

aether

Source

event.lisp (file)

Function: spawn-process CLASS &rest INITARGS

Preferred mechanism for instantiating an object inherting from PROCESS. Contains debug hooks.

Package

aether

Source

dereference.lisp (file)

Function: unregister ADDRESS

Unregisters a channel, so that messages can no longer be transmitted or received over it.

Package

aether

Source

message.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.4 Generic functions

Generic Function: handle-message-lock PROCESS MESSAGE NOW
Package

aether

Methods
Method: handle-message-lock (PROCESS process-lockable) (MESSAGE message-lock) NOW

Attempts to lock PROCESS.

Source

lock.lisp (file)

Generic Function: process-clock-rate OBJECT
Generic Function: (setf process-clock-rate) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-clock-rate (PROCESS process)
Method: (setf process-clock-rate) NEW-VALUE (PROCESS process)

The number of times per unit of ‘SIMULATION’ time that this ‘PROCESS’ gets to act.

Source

process.lisp (file)

Generic Function: process-command-stack OBJECT
Generic Function: (setf process-command-stack) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-command-stack (PROCESS process)
Method: (setf process-command-stack) NEW-VALUE (PROCESS process)

A stack populated with the instructions yet to be executed by this PROCESS. Modify this using ‘PROCESS-CONTINUATION’.

Source

process.lisp (file)

Generic Function: process-data-stack OBJECT
Generic Function: (setf process-data-stack) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-data-stack (PROCESS process)
Method: (setf process-data-stack) NEW-VALUE (PROCESS process)

A stack populated with data, typically "data frames" pushed and popped by sequences of related commands.

Source

process.lisp (file)

Generic Function: process-debug? OBJECT
Generic Function: (setf process-debug?) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-debug? (PROCESS process)
Method: (setf process-debug?) NEW-VALUE (PROCESS process)

A boolean flag. If T, debug messages are logged.

Source

process.lisp (file)

Generic Function: process-exhaust-inbox? OBJECT
Generic Function: (setf process-exhaust-inbox?) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-exhaust-inbox? (PROCESS process)
Method: (setf process-exhaust-inbox?) NEW-VALUE (PROCESS process)

Defaults to T, which means that the ‘PROCESS’ will go through its entire message queue in a single clock tick, and then (in the same tick) take an action specified by the command stack. Otherwise, the ‘PROCESS’ will immediately execute a command after handling either zero or one message(s).

Source

process.lisp (file)

Generic Function: process-lockable-aborting? OBJECT
Generic Function: (setf process-lockable-aborting?) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-lockable-aborting? (PROCESS-LOCKABLE process-lockable)

automatically generated reader method

Source

lock.lisp (file)

Method: (setf process-lockable-aborting?) NEW-VALUE (PROCESS-LOCKABLE process-lockable)

automatically generated writer method

Source

lock.lisp (file)

Generic Function: process-lockable-done-signal OBJECT
Generic Function: (setf process-lockable-done-signal) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-lockable-done-signal (PROCESS-LOCKABLE process-lockable)

automatically generated reader method

Source

lock.lisp (file)

Method: (setf process-lockable-done-signal) NEW-VALUE (PROCESS-LOCKABLE process-lockable)

automatically generated writer method

Source

lock.lisp (file)

Generic Function: process-lockable-locked? OBJECT
Generic Function: (setf process-lockable-locked?) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-lockable-locked? (PROCESS-LOCKABLE process-lockable)

automatically generated reader method

Source

lock.lisp (file)

Method: (setf process-lockable-locked?) NEW-VALUE (PROCESS-LOCKABLE process-lockable)

automatically generated writer method

Source

lock.lisp (file)

Generic Function: process-lockable-targets PROCESS-LOCKABLE

Calculates the list of ADDRESSes to acquire recursive locks from when PROCESS-LOCKABLE receives a lock request.

Package

aether

Source

lock.lisp (file)

Generic Function: process-peruse-inbox? OBJECT
Generic Function: (setf process-peruse-inbox?) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-peruse-inbox? (PROCESS process)
Method: (setf process-peruse-inbox?) NEW-VALUE (PROCESS process)

Defaults to T, which means that the ‘PROCESS’ will search through the whole inbox when trying to find a match for clause. Otherwise, the ‘PROCESS’ will only look at the first message in the inbox. Essentially toggles between clause-order precedence and inbox-order predence.

Source

process.lisp (file)


Next: , Previous: , Up: Exported definitions   [Contents][Index]

6.1.5 Structures

Structure: address ()

Signifies a channel over which objects can communicate.

NOTE: The SECRET field is "optional", in that only processes that possess the secret can receive on and unregister the channel, but all processes—including those without the secret—can send on the channel.

Package

aether

Source

message.lisp (file)

Direct superclasses

structure-object (structure)

Direct methods

print-object (method)

Direct slots
Slot: courier
Initform

(aether::courier-id aether:*local-courier*)

Readers

address-courier (function)

Writers

(setf address-courier) (function)

Slot: channel
Readers

address-channel (function)

Writers

(setf address-channel) (function)

Slot: secret
Readers

address-secret (function)

Writers

(setf address-secret) (function)

Structure: broadcast-frame ()

Data frame for a ‘BROADCAST’ operation. The ‘ABORTING?’ flag is used to signal to a ‘BROADCAST’ or ‘CONVERGECAST’ command to terminate immediately. If the operation doesn’t abort, the ‘MESSAGE’ is broadcasted to ‘TARGETS’. If we are awaiting replies from the broadcast, we can set ‘HANDLE-RTS?’ to T if we want to pass a ‘:RETURNED?’ keyword argument to ‘WITH-REPLIES’ (and thus handle RTSes gracefully).

Package

aether

Source

cast.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

convergecast-frame (structure)

Direct slots
Slot: aborting?
Type

boolean

Readers

broadcast-frame-aborting? (function)

Writers

(setf broadcast-frame-aborting?) (function)

Slot: handle-rts?
Type

boolean

Readers

broadcast-frame-handle-rts? (function)

Writers

(setf broadcast-frame-handle-rts?) (function)

Slot: message
Type

(or null aether:message)

Readers

broadcast-frame-message (function)

Writers

(setf broadcast-frame-message) (function)

Slot: targets
Type

list

Readers

broadcast-frame-targets (function)

Writers

(setf broadcast-frame-targets) (function)

Structure: convergecast-frame ()

Data frame for a ‘CONVERGECAST’ operation. The ‘INPUT’ is the value calculated at the current level of recursion, to be passed to ‘FUNC’ along with the ‘REPLIES’ from the subsequent level of recursion. The value V passed up is determined as V = (FUNCALL FUNC INPUT REPLIES), and thus the definition of ‘FUNC’ should be something like:

DEFUN FUNC INPUT REPLIES

Where ‘REPLIES’ is assumed to be a ‘LIST’. Additionally, when ‘HANDLE-RTS?’ is true, ‘FUNC’ should be constructed to handle NIL values in ‘INPUT’ or ‘REPLIES’ gracefully. Inherits from ‘BROADCAST-FRAME’.

Package

aether

Source

cast.lisp (file)

Direct superclasses

broadcast-frame (structure)

Direct slots
Slot: func
Type

(or null function)

Readers

convergecast-frame-func (function)

Writers

(setf convergecast-frame-func) (function)

Slot: input
Readers

convergecast-frame-input (function)

Writers

(setf convergecast-frame-input) (function)

Structure: courier ()

A component in the message-passing apparatus.

‘QUEUE’: The receive queue of messages which have not yet been forwarded or stored. Each entry is of the form (COURIER-ID CHANNEL &REST PAYLOAD).
‘INBOXES’: A hash table mapping channels serviced by this courier to mailbox queues.
‘SECRETS’: A hash table mapping channels serviced by this courier to the private sigils used to distinguish mailbox owners.
‘ID’: A unique identifier for this courier. WARNING: Expect subclasses of ‘COURIER’ to require specific types and values here.
‘NEIGHBORS’: Used to store routing information. WARNING: By default, this is a hash mapping courier ‘ID’s in the network to their object instances. Expect subclasses of ‘COURIER’ to install different types and values here.

Package

aether

Source

message.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses

courier-gridded (structure)

Direct methods
Direct slots
Slot: queue
Initform

(aether:make-q)

Readers

courier-queue (function)

Writers

(setf courier-queue) (function)

Slot: inboxes
Initform

(make-hash-table :test (quote eq))

Readers

courier-inboxes (function)

Writers

(setf courier-inboxes) (function)

Slot: secrets
Initform

(make-hash-table :test (quote eq))

Readers

courier-secrets (function)

Writers

(setf courier-secrets) (function)

Slot: processing-clock-rate
Initform

aether::*courier-processing-clock-rate*

Readers

courier-processing-clock-rate (function)

Writers

(setf courier-processing-clock-rate) (function)

Slot: default-routing-time-step
Initform

aether::*routing-time-step*

Readers

courier-default-routing-time-step (function)

Writers

(setf courier-default-routing-time-step) (function)

Slot: id
Initform

(gensym)

Readers

courier-id (function)

Writers

(setf courier-id) (function)

Slot: neighbors
Initform

(make-hash-table)

Readers

courier-neighbors (function)

Writers

(setf courier-neighbors) (function)

Structure: event ()

Wrapper for a particular event.

Package

aether

Source

event.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: callback
Readers

event-callback (function)

Writers

(setf event-callback) (function)

Slot: time
Type

(rational 0)

Initform

0

Readers

event-time (function)

Writers

(setf event-time) (function)

Structure: message ()

Base type for messages transmitted along ‘COURIER’s.

Package

aether

Source

message.lisp (file)

Direct superclasses

structure-object (structure)

Direct subclasses
Direct slots
Slot: reply-channel
Type

(or null aether:address)

Readers

message-reply-channel (function)

Writers

(setf message-reply-channel) (function)

Slot: message-id
Type

symbol

Initform

(gensym "message")

Readers

message-message-id (function)

Writers

(setf message-message-id) (function)

Structure: message-lock ()

Sent to establish a lock.

Package

aether

Source

lock.lisp (file)

Direct superclasses

message (structure)

Direct methods

handle-message-lock (method)

Structure: message-rpc-done ()

Reply when an RPC message finishes.

Package

aether

Source

message.lisp (file)

Direct superclasses

message (structure)

Direct slots
Slot: result
Readers

message-rpc-done-result (function)

Writers

(setf message-rpc-done-result) (function)

Structure: message-rts ()

This message is generated as a fresh automatic response when an original message is sent to a nonexistent (or closing) mailbox.

If the original message’s REPLY-CHANNEL is not set, no MESSAGE-RTS object is built.

NOTE: "RTS" is short for "Return To Sender".

Package

aether

Source

message.lisp (file)

Direct superclasses

message (structure)

Direct methods

handle-message-rts (method)

Structure: simulation ()

Container for a set of EVENTs to be processed as part of a simulation.

CONTENTS: The set of EVENTs. This field is not for direct access; instead, add events using SIMULATION-ADD-EVENT.

HORIZON: The timestamp before which all events have been simulated. Ensures that a SIMULATION has a fixed history.

Package

aether

Source

event.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: contents
Type

list

Readers

simulation-contents (function)

Writers

(setf simulation-contents) (function)

Slot: horizon
Type

(real 0)

Initform

0

Readers

simulation-horizon (function)

Writers

(setf simulation-horizon) (function)


Previous: , Up: Exported definitions   [Contents][Index]

6.1.6 Classes

Class: process ()

Models an individual concurrently-executing process. On each tick, a ‘PROCESS’ first checks its public mailbox for messages matched by ‘DEFINE-MESSAGE-DISPATCH’ and, if an appropriate message is found, that message is processed. If no matching message is found, the first command in ‘PROCESS-COMMAND-STACK’ is processed instead, according to the semantics defined by ‘DEFINE-PROCESS-UPKEEP’.

IMPORTANT NOTE: Use #’SPAWN-PROCESS to generate a new PROCESS object.

Package

aether

Source

process.lisp (file)

Direct superclasses

standard-object (class)

Direct subclasses
Direct methods
Direct slots
Slot: process-courier

Holds a reference to the ‘COURIER’ which services this ‘PROCESS’.

Initargs

:process-courier

Initform

aether:*local-courier*

Readers

process-courier (generic function)

Writers

(setf process-courier) (generic function)

Slot: process-key

Holds the ‘PROCESS’s ‘ADDRESS’ on which it receives messages. (Use ‘PROCESS-PUBLIC-ADDRESS’ to extract an ‘ADDRESS’ to be used to send messages to this ‘PROCESS’.)

Initargs

:process-key

Initform

(aether:register)

Readers

process-key (generic function)

Writers

(setf process-key) (generic function)

Slot: process-clock-rate

The number of times per unit of ‘SIMULATION’ time that this ‘PROCESS’ gets to act.

Initargs

:process-clock-rate

Readers

process-clock-rate (generic function)

Writers

(setf process-clock-rate) (generic function)

Slot: process-command-stack

A stack populated with the instructions yet to be executed by this PROCESS. Modify this using ‘PROCESS-CONTINUATION’.

Initform

(sb-int:quasiquote ((aether:start)))

Readers

process-command-stack (generic function)

Writers

(setf process-command-stack) (generic function)

Slot: process-data-stack

A stack populated with data, typically "data frames" pushed and popped by sequences of related commands.

Readers

process-data-stack (generic function)

Writers

(setf process-data-stack) (generic function)

Slot: process-debug?

A boolean flag. If T, debug messages are logged.

Initargs

:debug?

Readers

process-debug? (generic function)

Writers

(setf process-debug?) (generic function)

Slot: process-exhaust-inbox?

Defaults to T, which means that the ‘PROCESS’ will go through its entire message queue in a single clock tick, and then (in the same tick) take an action specified by the command stack. Otherwise, the ‘PROCESS’ will immediately execute a command after handling either zero or one message(s).

Type

boolean

Initargs

:process-exhaust-inbox?

Initform

t

Readers

process-exhaust-inbox? (generic function)

Writers

(setf process-exhaust-inbox?) (generic function)

Slot: process-peruse-inbox?

Defaults to T, which means that the ‘PROCESS’ will search through the whole inbox when trying to find a match for clause. Otherwise, the ‘PROCESS’ will only look at the first message in the inbox. Essentially toggles between clause-order precedence and inbox-order predence.

Type

boolean

Initargs

:process-peruse-inbox?

Initform

t

Readers

process-peruse-inbox? (generic function)

Writers

(setf process-peruse-inbox?) (generic function)

Class: process-lockable ()

A PROCESS which supports recursive locking.

Package

aether

Source

lock.lisp (file)

Direct superclasses

process (class)

Direct methods
Direct slots
Slot: aborting?
Type

boolean

Readers

process-lockable-aborting? (generic function)

Writers

(setf process-lockable-aborting?) (generic function)

Slot: locked?
Type

boolean

Readers

process-lockable-locked? (generic function)

Writers

(setf process-lockable-locked?) (generic function)

Slot: done-signal
Readers

process-lockable-done-signal (generic function)

Writers

(setf process-lockable-done-signal) (generic function)

Slot: downward-rx-latches
Type

list

Slot: downward-tx-latches
Type

list

Slot: upward-rx-latch
Type

(or null aether:address)

Slot: upward-tx-latch
Type

(or null aether:address)


Previous: , Up: Definitions   [Contents][Index]

6.2 Internal definitions


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.1 Special variables

Special Variable: *courier-processing-clock-rate*
Package

aether

Source

message.lisp (file)

Special Variable: *dereferencing-table*

Holds a hash map from ADDRESS objects to the Lisp objects that own them.

Package

aether

Source

dereference.lisp (file)

Special Variable: *message-traces*

Houses information related to traces.

Package

aether

Source

trace.lisp (file)

Special Variable: *routing-time-step*
Package

aether

Source

message.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.2 Macros

Macro: %install-repeat-until (&body REPEATER-BODY) (&body FINALIZER-BODY)

Irreversibly transfers control from the current command by replacing it with a ‘:REPEAT-UNTIL’ command with the indicated ‘REPEATER’ and ‘FINALIZER’.

NOTE: %INSTALL-REPEAT-UNTIL is not available outside the body of DEFINE-PROCESS-UPKEEP.

Package

aether

Source

dpu-helpers.lisp (file)

Macro: assoc-default ITEM ALIST-PLACE DEFAULT-FORM &rest KWARGS
Package

aether

Source

utilities.lisp (file)

Macro: define-dpu-flet FUNCTION-NAME ARGUMENT-LIST &body BODY

Defines a local function to be used inside of DEFINE-PROCESS-UPKEEP.

NOTE: Automatically binds ACTIVE?, NOW, and PROCESS-NAME to their values from within D-P-U.

Package

aether

Source

process.lisp (file)

Macro: define-dpu-macro MACRO-NAME ARGUMENT-LIST &body BODY

Defines a local macro to be used inside of DEFINE-PROCESS-UPKEEP.

NOTE: Automatically binds PROCESS-NAME and NOW to their values from within D-P-U.

Package

aether

Source

process.lisp (file)

Macro: hash-let (BINDING KEY TABLE DEFAULT-FORM) &body BODY

Like GETHASH, except modifies the table.

Package

aether

Source

utilities.lisp (file)

Macro: with-traces () &body BODY

Enable tracing over a region of code.

Package

aether

Source

trace.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.3 Functions

Function: %dpu-flet-definitions &key ACTIVE? NOW PROCESS-NAME

This function produces a list of local function (re)definitions to be supplied in the body of DEFINE-PROCESS-UPKEEP.

NOTE: LOG-ENTRY is treated separately.

Package

aether

Source

process.lisp (file)

Function: %dpu-macrolet-definitions &key PROCESS-NAME NOW

This function produces a list of local macro definitions to be supplied in the body of DEFINE-PROCESS-UPKEEP.

Package

aether

Source

process.lisp (file)

Function: %make-courier-gridded &key (QUEUE QUEUE) (INBOXES INBOXES) (SECRETS SECRETS) (PROCESSING-CLOCK-RATE PROCESSING-CLOCK-RATE) (DEFAULT-ROUTING-TIME-STEP DEFAULT-ROUTING-TIME-STEP) (ID ID) (NEIGHBORS NEIGHBORS)
Package

aether

Source

network.lisp (file)

Function: %make-simulation &key (CONTENTS CONTENTS) (HORIZON HORIZON)
Package

aether

Source

event.lisp (file)

Function: address-channel INSTANCE
Function: (setf address-channel) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: address-courier INSTANCE
Function: (setf address-courier) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: address-p OBJECT
Package

aether

Source

message.lisp (file)

Function: address-secret INSTANCE
Function: (setf address-secret) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: broadcast-frame-aborting? INSTANCE
Function: (setf broadcast-frame-aborting?) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: broadcast-frame-handle-rts? INSTANCE
Function: (setf broadcast-frame-handle-rts?) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: broadcast-frame-message INSTANCE
Function: (setf broadcast-frame-message) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: broadcast-frame-p OBJECT
Package

aether

Source

cast.lisp (file)

Function: broadcast-frame-targets INSTANCE
Function: (setf broadcast-frame-targets) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: check-key-secret ADDRESS

Asserts that the SECRET stored in ADDRESS matches that recorded by the attendant COURIER.

Package

aether

Source

message.lisp (file)

Function: convergecast-frame-aborting? INSTANCE
Function: (setf convergecast-frame-aborting?) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-func INSTANCE
Function: (setf convergecast-frame-func) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-handle-rts? INSTANCE
Function: (setf convergecast-frame-handle-rts?) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-input INSTANCE
Function: (setf convergecast-frame-input) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-message INSTANCE
Function: (setf convergecast-frame-message) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-p OBJECT
Package

aether

Source

cast.lisp (file)

Function: convergecast-frame-targets INSTANCE
Function: (setf convergecast-frame-targets) VALUE INSTANCE
Package

aether

Source

cast.lisp (file)

Function: copy-address INSTANCE
Package

aether

Source

message.lisp (file)

Function: copy-broadcast-frame INSTANCE
Package

aether

Source

cast.lisp (file)

Function: copy-convergecast-frame INSTANCE
Package

aether

Source

cast.lisp (file)

Function: copy-courier INSTANCE
Package

aether

Source

message.lisp (file)

Function: copy-courier-gridded INSTANCE
Package

aether

Source

network.lisp (file)

Function: copy-event INSTANCE
Package

aether

Source

event.lisp (file)

Function: copy-grid-neighbors INSTANCE
Package

aether

Source

network.lisp (file)

Function: copy-logger INSTANCE
Package

aether

Source

logger.lisp (file)

Function: copy-message INSTANCE
Package

aether

Source

message.lisp (file)

Function: copy-message-lock INSTANCE
Package

aether

Source

lock.lisp (file)

Function: copy-message-rpc-done INSTANCE
Package

aether

Source

message.lisp (file)

Function: copy-message-rts INSTANCE
Package

aether

Source

message.lisp (file)

Function: copy-message-unlock INSTANCE
Package

aether

Source

lock.lisp (file)

Function: copy-simulation INSTANCE
Package

aether

Source

event.lisp (file)

Function: copy-tracer INSTANCE
Package

aether

Source

trace.lisp (file)

Function: courier-default-routing-time-step INSTANCE
Function: (setf courier-default-routing-time-step) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: courier-gridded-default-routing-time-step INSTANCE
Function: (setf courier-gridded-default-routing-time-step) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-id INSTANCE
Function: (setf courier-gridded-id) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-inboxes INSTANCE
Function: (setf courier-gridded-inboxes) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-neighbors INSTANCE
Function: (setf courier-gridded-neighbors) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-p OBJECT
Package

aether

Source

network.lisp (file)

Function: courier-gridded-processing-clock-rate INSTANCE
Function: (setf courier-gridded-processing-clock-rate) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-queue INSTANCE
Function: (setf courier-gridded-queue) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-gridded-secrets INSTANCE
Function: (setf courier-gridded-secrets) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: courier-id INSTANCE
Function: (setf courier-id) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: courier-inboxes INSTANCE
Function: (setf courier-inboxes) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: courier-neighbors INSTANCE
Function: (setf courier-neighbors) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: courier-p OBJECT
Package

aether

Source

message.lisp (file)

Function: courier-queue INSTANCE
Function: (setf courier-queue) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: courier-secrets INSTANCE
Function: (setf courier-secrets) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: deliver-message PROCESSING-COURIER MESSAGE

Used to simulate the transmission of a message to the next COURIER.

Package

aether

Source

message.lisp (file)

Function: event-callback INSTANCE
Package

aether

Source

event.lisp (file)

Function: event-p OBJECT
Package

aether

Source

event.lisp (file)

Function: event-time INSTANCE
Package

aether

Source

event.lisp (file)

Function: grid-neighbors-down INSTANCE
Function: (setf grid-neighbors-down) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: grid-neighbors-left INSTANCE
Function: (setf grid-neighbors-left) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: grid-neighbors-p OBJECT
Package

aether

Source

network.lisp (file)

Function: grid-neighbors-right INSTANCE
Function: (setf grid-neighbors-right) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: grid-neighbors-up INSTANCE
Function: (setf grid-neighbors-up) VALUE INSTANCE
Package

aether

Source

network.lisp (file)

Function: logger-p OBJECT
Package

aether

Source

logger.lisp (file)

Function: macro-lambda-list-places LAMBDA-LIST

Collect the places that a macro lambda-list might bind.

Package

aether

Source

utilities.lisp (file)

Function: make-address &key (COURIER COURIER) (CHANNEL CHANNEL) (SECRET SECRET)
Package

aether

Source

message.lisp (file)

Function: make-courier-gridded &rest INITARGS
Package

aether

Source

network.lisp (file)

Function: make-grid-neighbors &key (LEFT LEFT) (RIGHT RIGHT) (UP UP) (DOWN DOWN)
Package

aether

Source

network.lisp (file)

Function: make-logger &key (ENTRIES ENTRIES)
Package

aether

Source

logger.lisp (file)

Function: make-tracer &key (TRACES TRACES)
Package

aether

Source

trace.lisp (file)

Function: message-lock-message-id INSTANCE
Function: (setf message-lock-message-id) VALUE INSTANCE
Package

aether

Source

lock.lisp (file)

Function: message-lock-p OBJECT
Package

aether

Source

lock.lisp (file)

Function: message-lock-reply-channel INSTANCE
Function: (setf message-lock-reply-channel) VALUE INSTANCE
Package

aether

Source

lock.lisp (file)

Function: message-log LOGGER

Given a ‘LOGGER’, filter it so that it only contains ‘SEND-MESSAGE’ entries. Re-sends are not included.

Package

aether

Source

logger.lisp (file)

Function: message-message-id INSTANCE
Function: (setf message-message-id) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-p OBJECT
Package

aether

Source

message.lisp (file)

Function: message-report MESSAGE-LOG

Given a ‘MESSAGE-LOG’, which is a LIST of log entries filtered such that they only contain message-related logs, build an ALIST of the different types of sent messages it contains, and a count for each.

Package

aether

Source

logger.lisp (file)

Function: message-rpc-done-message-id INSTANCE
Function: (setf message-rpc-done-message-id) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-rpc-done-p OBJECT
Package

aether

Source

message.lisp (file)

Function: message-rpc-done-reply-channel INSTANCE
Function: (setf message-rpc-done-reply-channel) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-rts-message-id INSTANCE
Function: (setf message-rts-message-id) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-rts-p OBJECT
Package

aether

Source

message.lisp (file)

Function: message-rts-reply-channel INSTANCE
Function: (setf message-rts-reply-channel) VALUE INSTANCE
Package

aether

Source

message.lisp (file)

Function: message-unlock-message-id INSTANCE
Function: (setf message-unlock-message-id) VALUE INSTANCE
Package

aether

Source

lock.lisp (file)

Function: message-unlock-p OBJECT
Package

aether

Source

lock.lisp (file)

Function: message-unlock-reply-channel INSTANCE
Function: (setf message-unlock-reply-channel) VALUE INSTANCE
Package

aether

Source

lock.lisp (file)

Function: message-unlock-result INSTANCE
Function: (setf message-unlock-result) VALUE INSTANCE
Package

aether

Source

lock.lisp (file)

Function: print-trace-table TABLE &optional STREAM

Prints TABLE, an ALIST associating code distances to TRACER objects, to STREAM.

Package

aether

Source

trace.lisp (file)

Function: print-traces &optional STREAM

Dump the contents of *MESSAGE-TRACES* to STREAM.

Package

aether

Source

trace.lisp (file)

Function: public-address ADDRESS

Extracts the public (i.e., secret-free) address from a potentially private (i.e., secret-ful) address.

Package

aether

Source

message.lisp (file)

Function: record-reference PROCESS

If appropriate, creates a debug record that PROCESS owns its public address.

Package

aether

Source

dereference.lisp (file)

Function: reduce+ INPUT REPLIES

Sum the ‘INPUT’ and all the ‘REPLIES’.

Package

aether

Source

cast.lisp (file)

Function: reduce-max INPUT REPLIES

Find the ‘MAX’ of the ‘INPUT’ and all the ‘REPLIES’.

Package

aether

Source

cast.lisp (file)

Function: rotate-trace-table TABLE

Takes TABLE, an ALIST associating code distances to TRACER objects, and produces a TRACER-type nested ALIST whose innermost nesting is an ALIST associating code distances to triples (AVERAGE MAX COUNT).

Package

aether

Source

trace.lisp (file)

Function: simulation-contents INSTANCE
Function: (setf simulation-contents) VALUE INSTANCE
Package

aether

Source

event.lisp (file)

Function: simulation-dequeue SIMULATION

Removes the next EVENT from SIMULATION and returns it.

Package

aether

Source

event.lisp (file)

Function: simulation-horizon INSTANCE
Function: (setf simulation-horizon) VALUE INSTANCE
Package

aether

Source

event.lisp (file)

Function: simulation-p OBJECT
Package

aether

Source

event.lisp (file)

Function: simulation-peep SIMULATION

Reveals the next EVENT that SIMULATION will return upon DEQUEUE.

Package

aether

Source

event.lisp (file)

Function: sort-traces ()

Sort the contents of a TRACER object. Useful for printing.

Package

aether

Source

trace.lisp (file)

Function: stash-local-message MESSAGE

Attempts to store ‘MESSAGE’ into a mailbox at ‘*LOCAL-COURIER*’. Returns NIL if ‘MESSAGE’ is not bound for ‘*LOCAL-COURIER*’, T otherwise.

Package

aether

Source

message.lisp (file)

Function: tracer-p OBJECT
Package

aether

Source

trace.lisp (file)

Function: tracer-store &rest INITARGS

Add an entry to the set of traces.

Package

aether

Source

trace.lisp (file)

Function: tracer-traces INSTANCE
Function: (setf tracer-traces) VALUE INSTANCE
Package

aether

Source

trace.lisp (file)


Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.4 Generic functions

Generic Function: courier-courier->route PROCESSING-COURIER DESTINATION-ADDRESS

Calculates the next step from ‘PROCESSING-COURIER’ to ‘DESTINATION-ADDRESS’. Returns as an optional second value the time delay between transmission at ‘PROCESSING-COURIER’ to receipt by the next hop.

Package

aether

Source

message.lisp (file)

Methods
Method: courier-courier->route (PROCESSING-COURIER courier-gridded) DESTINATION-COURIER-ID
Source

network.lisp (file)

Method: courier-courier->route (PROCESSING-COURIER courier) DESTINATION-ADDRESS
Generic Function: handle-message-rts PROCESS MESSAGE TIME
Package

aether

Methods
Method: handle-message-rts (PROCESS process) (MESSAGE message-rts) TIME

Default handler for when a ‘PROCESS’ receives a ‘MESSAGE-RTS’. Throws an error.

Source

process.lisp (file)

Generic Function: handle-object OBJECT TIME

Describes the generic behavior of OBJECTs of a particular type, as occuring at a particular TIME.

Package

aether

Source

event.lisp (file)

Methods
Method: handle-object (PROCESS process) TIME
Source

process.lisp (file)

Method: handle-object (COURIER courier) TIME
Source

message.lisp (file)

Generic Function: message-dispatch NODE TIME

Use DEFINE-MESSAGE-DISPATCH to install methods here.

Package

aether

Source

process.lisp (file)

Methods
Method: message-dispatch (NODE0 process-message-emissary) TIME2
Source

emissary.lisp (file)

Generic Function: print-log-entry ENTRY SOURCE-TYPE ENTRY-TYPE &optional STREAM

Pretty-prints a log entry to STREAM.

Package

aether

Source

logger.lisp (file)

Methods
Method: print-log-entry ENTRY SOURCE-TYPE (ENTRY-TYPE (eql send-message)) &optional STREAM
Method: print-log-entry ENTRY SOURCE-TYPE ENTRY-TYPE &optional STREAM
Generic Function: process-courier OBJECT
Generic Function: (setf process-courier) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-courier (PROCESS process)
Method: (setf process-courier) NEW-VALUE (PROCESS process)

Holds a reference to the ‘COURIER’ which services this ‘PROCESS’.

Source

process.lisp (file)

Generic Function: process-key OBJECT
Generic Function: (setf process-key) NEW-VALUE OBJECT
Package

aether

Methods
Method: process-key (PROCESS process)
Method: (setf process-key) NEW-VALUE (PROCESS process)

Holds the ‘PROCESS’s ‘ADDRESS’ on which it receives messages. (Use ‘PROCESS-PUBLIC-ADDRESS’ to extract an ‘ADDRESS’ to be used to send messages to this ‘PROCESS’.)

Source

process.lisp (file)

Generic Function: process-upkeep SERVER TIME COMMAND COMMAND-ARGS

If a PROCESS has no pending requests to service, it may want to perform some computation of its own, which happens in this routine. Such computations typically include sending messages and listening on private channels for responses.

Package

aether

Source

process.lisp (file)

Methods
Method: process-upkeep (PROCESS process) NOW (COMMAND-PLACE0 (eql convergecast)) ARGUMENT-LIST1

Pops a frame off of the ‘PROCESS’s data stack, and after checking that it is in fact a ‘CONVERGECAST-FRAME’, unpacks ‘ABORTING?’, ‘FUNC’, ‘INPUT’, ‘MESSAGE’, and ‘TARGETS’ from the frame. Unless ‘ABORTING?’ is T, forwards along a copy of ‘MESSAGE’ to all ‘TARGETS’ and awaits replies. While awaiting replies, we handle RTSes gracefully if ‘HANDLE-RTS?’ is T. Then, calculates a value to return by feeding the ‘INPUT’ and all ‘REPLIES’ to ‘FUNC’ as (FUNCALL FUNC INPUT REPLIES). Finally, sends the computed result back to ‘REPLY-CHANNEL’ if it is not null.

Source

cast.lisp (file)

Method: process-upkeep (PROCESS process) NOW (COMMAND-PLACE0 (eql broadcast)) ARGUMENT-LIST1

Pops a frame off of the ‘PROCESS’s data stack, and after checking that it is in fact a ‘BROADCAST-FRAME’, unpacks ‘ABORTING?’, ‘HANDLE-RTS?’, ‘MESSAGE’ and ‘TARGETS’ from the frame. Unless ‘ABORTING?’ is T, forwards along a copy of ‘MESSAGE’ to all ‘TARGETS’ and optionally awaits a reply and sends back an acknowledgement back to the ‘MESSAGE’s ‘REPLY-CHANNEL’ if the reply channel is not null. While awaiting replies, we handle RTSes gracefully if ‘HANDLE-RTS?’ is T.

Source

cast.lisp (file)

Method: process-upkeep (PROCESS process-lockable) NOW (COMMAND-PLACE0 (eql %finish-unlock)) ARGUMENT-LIST1

Cleans up after START-LOCK.

Source

lock.lisp (file)

Method: process-upkeep (PROCESS process-lockable) NOW (COMMAND-PLACE0 (eql broadcast-unlock)) ARGUMENT-LIST1

Cleans up after BROADCAST-LOCK.

Source

lock.lisp (file)

Method: process-upkeep (PROCESS process-lockable) NOW (COMMAND-PLACE0 (eql %wait-for-unlock)) ARGUMENT-LIST1

Waits for a release signal to arrive via ‘UPWARD-RX-LATCH’.

Source

lock.lisp (file)

Method: process-upkeep (PROCESS process-lockable) NOW (COMMAND-PLACE0 (eql broadcast-lock)) ARGUMENT-LIST1

Establishes locks on ‘TARGETS’.

Source

lock.lisp (file)

Method: process-upkeep (PROCESS process-lockable) NOW (COMMAND-PLACE0 (eql start-lock)) ARGUMENT-LIST1

Locks ‘PROCESS’. ‘REPLY-CHANNEL’ indicates the address (if any) on which to signal whether the lock was / was not established.

Source

lock.lisp (file)

Method: process-upkeep PROCESS TIME (COMMAND-PLACE0 (eql repeat-until)) ARGUMENT-LIST1

Repeatedly calls CALLBACK: (TIME) –> (VALUES FUTURES DONE?) until DONE? is non-NIL. Then, calls FINALIZE: (TIME) –> (FUTURES) once.

Source

dpu-helpers.lisp (file)

Method: process-upkeep SERVER TIME COMMAND COMMAND-ARGS

Next: , Previous: , Up: Internal definitions   [Contents][Index]

6.2.5 Structures

Structure: courier-gridded ()

A ‘COURIER’ instance networked to other couriers in a grid.

NOTE: Expects ‘ID’ to be a list and ‘NEIGHBORS’ to be a ‘GRID-NEIGHBORS’.

Package

aether

Source

network.lisp (file)

Direct superclasses

courier (structure)

Direct methods

courier-courier->route (method)

Structure: grid-neighbors ()

A structure for storing the neighbors of a courier participating in a grid.

Package

aether

Source

network.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: left
Readers

grid-neighbors-left (function)

Writers

(setf grid-neighbors-left) (function)

Slot: right
Readers

grid-neighbors-right (function)

Writers

(setf grid-neighbors-right) (function)

Slot: up
Readers

grid-neighbors-up (function)

Writers

(setf grid-neighbors-up) (function)

Slot: down
Readers

grid-neighbors-down (function)

Writers

(setf grid-neighbors-down) (function)

Structure: logger ()
Package

aether

Source

logger.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: entries
Type

list

Readers

logger-entries (function)

Writers

(setf logger-entries) (function)

Structure: message-unlock ()

Sent to release a lock.

Package

aether

Source

lock.lisp (file)

Direct superclasses

message (structure)

Direct slots
Slot: result
Readers

message-unlock-result (function)

Writers

(setf message-unlock-result) (function)

Structure: tracer ()

Collects trace information.

TRACES: ORIGIN-TYPE –ALIST-> MESSAGE-TYPE –ALIST-> D-COUNT –ALIST-> DELTAs.

Package

aether

Source

trace.lisp (file)

Direct superclasses

structure-object (structure)

Direct slots
Slot: traces
Readers

tracer-traces (function)

Writers

(setf tracer-traces) (function)


Previous: , Up: Internal definitions   [Contents][Index]

6.2.6 Classes

Class: process-message-emissary ()

Dummy PROCESS used to host nonblocking message handlers.

Package

aether

Source

emissary.lisp (file)

Direct superclasses

process (class)

Direct methods

message-dispatch (method)


Previous: , Up: Top   [Contents][Index]

Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts

Jump to:   A   F   L   M  
Index Entry  Section

A
aether.asd: The aether․asd file
aether/cast.lisp: The aether/cast․lisp file
aether/cheap-heap.lisp: The aether/cheap-heap․lisp file
aether/debug: The aether/debug module
aether/debug/logger.lisp: The aether/debug/logger․lisp file
aether/debug/trace.lisp: The aether/debug/trace․lisp file
aether/event.lisp: The aether/event․lisp file
aether/lock.lisp: The aether/lock․lisp file
aether/message.lisp: The aether/message․lisp file
aether/network.lisp: The aether/network․lisp file
aether/package.lisp: The aether/package․lisp file
aether/process: The aether/process module
aether/process/dereference.lisp: The aether/process/dereference․lisp file
aether/process/dpu-helpers.lisp: The aether/process/dpu-helpers․lisp file
aether/process/emissary.lisp: The aether/process/emissary․lisp file
aether/process/process.lisp: The aether/process/process․lisp file
aether/queue.lisp: The aether/queue․lisp file
aether/rpc.lisp: The aether/rpc․lisp file
aether/utilities.lisp: The aether/utilities․lisp file

F
File, Lisp, aether.asd: The aether․asd file
File, Lisp, aether/cast.lisp: The aether/cast․lisp file
File, Lisp, aether/cheap-heap.lisp: The aether/cheap-heap․lisp file
File, Lisp, aether/debug/logger.lisp: The aether/debug/logger․lisp file
File, Lisp, aether/debug/trace.lisp: The aether/debug/trace․lisp file
File, Lisp, aether/event.lisp: The aether/event․lisp file
File, Lisp, aether/lock.lisp: The aether/lock․lisp file
File, Lisp, aether/message.lisp: The aether/message․lisp file
File, Lisp, aether/network.lisp: The aether/network․lisp file
File, Lisp, aether/package.lisp: The aether/package․lisp file
File, Lisp, aether/process/dereference.lisp: The aether/process/dereference․lisp file
File, Lisp, aether/process/dpu-helpers.lisp: The aether/process/dpu-helpers․lisp file
File, Lisp, aether/process/emissary.lisp: The aether/process/emissary․lisp file
File, Lisp, aether/process/process.lisp: The aether/process/process․lisp file
File, Lisp, aether/queue.lisp: The aether/queue․lisp file
File, Lisp, aether/rpc.lisp: The aether/rpc․lisp file
File, Lisp, aether/utilities.lisp: The aether/utilities․lisp file

L
Lisp File, aether.asd: The aether․asd file
Lisp File, aether/cast.lisp: The aether/cast․lisp file
Lisp File, aether/cheap-heap.lisp: The aether/cheap-heap․lisp file
Lisp File, aether/debug/logger.lisp: The aether/debug/logger․lisp file
Lisp File, aether/debug/trace.lisp: The aether/debug/trace․lisp file
Lisp File, aether/event.lisp: The aether/event․lisp file
Lisp File, aether/lock.lisp: The aether/lock․lisp file
Lisp File, aether/message.lisp: The aether/message․lisp file
Lisp File, aether/network.lisp: The aether/network․lisp file
Lisp File, aether/package.lisp: The aether/package․lisp file
Lisp File, aether/process/dereference.lisp: The aether/process/dereference․lisp file
Lisp File, aether/process/dpu-helpers.lisp: The aether/process/dpu-helpers․lisp file
Lisp File, aether/process/emissary.lisp: The aether/process/emissary․lisp file
Lisp File, aether/process/process.lisp: The aether/process/process․lisp file
Lisp File, aether/queue.lisp: The aether/queue․lisp file
Lisp File, aether/rpc.lisp: The aether/rpc․lisp file
Lisp File, aether/utilities.lisp: The aether/utilities․lisp file

M
Module, aether/debug: The aether/debug module
Module, aether/process: The aether/process module

Jump to:   A   F   L   M  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   P   Q   R   S   T   U   W  
Index Entry  Section

%
%dpu-flet-definitions: Internal functions
%dpu-macrolet-definitions: Internal functions
%install-repeat-until: Internal macros
%make-courier-gridded: Internal functions
%make-simulation: Internal functions

(
(setf address-channel): Internal functions
(setf address-courier): Internal functions
(setf address-secret): Internal functions
(setf broadcast-frame-aborting?): Internal functions
(setf broadcast-frame-handle-rts?): Internal functions
(setf broadcast-frame-message): Internal functions
(setf broadcast-frame-targets): Internal functions
(setf convergecast-frame-aborting?): Internal functions
(setf convergecast-frame-func): Internal functions
(setf convergecast-frame-handle-rts?): Internal functions
(setf convergecast-frame-input): Internal functions
(setf convergecast-frame-message): Internal functions
(setf convergecast-frame-targets): Internal functions
(setf courier-default-routing-time-step): Internal functions
(setf courier-gridded-default-routing-time-step): Internal functions
(setf courier-gridded-id): Internal functions
(setf courier-gridded-inboxes): Internal functions
(setf courier-gridded-neighbors): Internal functions
(setf courier-gridded-processing-clock-rate): Internal functions
(setf courier-gridded-queue): Internal functions
(setf courier-gridded-secrets): Internal functions
(setf courier-id): Internal functions
(setf courier-inboxes): Internal functions
(setf courier-neighbors): Internal functions
(setf courier-processing-clock-rate): Exported functions
(setf courier-queue): Internal functions
(setf courier-secrets): Internal functions
(setf grid-neighbors-down): Internal functions
(setf grid-neighbors-left): Internal functions
(setf grid-neighbors-right): Internal functions
(setf grid-neighbors-up): Internal functions
(setf logger-entries): Exported functions
(setf message-lock-message-id): Internal functions
(setf message-lock-reply-channel): Internal functions
(setf message-message-id): Internal functions
(setf message-reply-channel): Exported functions
(setf message-rpc-done-message-id): Internal functions
(setf message-rpc-done-reply-channel): Internal functions
(setf message-rpc-done-result): Exported functions
(setf message-rts-message-id): Internal functions
(setf message-rts-reply-channel): Internal functions
(setf message-unlock-message-id): Internal functions
(setf message-unlock-reply-channel): Internal functions
(setf message-unlock-result): Internal functions
(setf process-clock-rate): Exported generic functions
(setf process-clock-rate): Exported generic functions
(setf process-command-stack): Exported generic functions
(setf process-command-stack): Exported generic functions
(setf process-courier): Internal generic functions
(setf process-courier): Internal generic functions
(setf process-data-stack): Exported generic functions
(setf process-data-stack): Exported generic functions
(setf process-debug?): Exported generic functions
(setf process-debug?): Exported generic functions
(setf process-exhaust-inbox?): Exported generic functions
(setf process-exhaust-inbox?): Exported generic functions
(setf process-key): Internal generic functions
(setf process-key): Internal generic functions
(setf process-lockable-aborting?): Exported generic functions
(setf process-lockable-aborting?): Exported generic functions
(setf process-lockable-done-signal): Exported generic functions
(setf process-lockable-done-signal): Exported generic functions
(setf process-lockable-locked?): Exported generic functions
(setf process-lockable-locked?): Exported generic functions
(setf process-peruse-inbox?): Exported generic functions
(setf process-peruse-inbox?): Exported generic functions
(setf simulation-contents): Internal functions
(setf simulation-horizon): Internal functions
(setf tracer-traces): Internal functions

A
address-channel: Internal functions
address-courier: Internal functions
address-p: Internal functions
address-secret: Internal functions
address=: Exported functions
assoc-default: Internal macros

B
broadcast-frame-aborting?: Internal functions
broadcast-frame-handle-rts?: Internal functions
broadcast-frame-message: Internal functions
broadcast-frame-p: Internal functions
broadcast-frame-targets: Internal functions

C
canary-all: Exported functions
canary-any: Exported functions
canary-process: Exported functions
canary-timeout: Exported functions
canary-until: Exported functions
cheap-heap-dequeue: Exported functions
cheap-heap-enqueue: Exported functions
cheap-heap-peep: Exported functions
check-key-secret: Internal functions
convergecast-frame-aborting?: Internal functions
convergecast-frame-func: Internal functions
convergecast-frame-handle-rts?: Internal functions
convergecast-frame-input: Internal functions
convergecast-frame-message: Internal functions
convergecast-frame-p: Internal functions
convergecast-frame-targets: Internal functions
copy-address: Internal functions
copy-broadcast-frame: Internal functions
copy-convergecast-frame: Internal functions
copy-courier: Internal functions
copy-courier-gridded: Internal functions
copy-event: Internal functions
copy-grid-neighbors: Internal functions
copy-logger: Internal functions
copy-message: Internal functions
copy-message-lock: Internal functions
copy-message-rpc-done: Internal functions
copy-message-rts: Internal functions
copy-message-unlock: Internal functions
copy-simulation: Internal functions
copy-tracer: Internal functions
courier-courier->route: Internal generic functions
courier-courier->route: Internal generic functions
courier-courier->route: Internal generic functions
courier-default-routing-time-step: Internal functions
courier-gridded-default-routing-time-step: Internal functions
courier-gridded-id: Internal functions
courier-gridded-inboxes: Internal functions
courier-gridded-neighbors: Internal functions
courier-gridded-p: Internal functions
courier-gridded-processing-clock-rate: Internal functions
courier-gridded-queue: Internal functions
courier-gridded-secrets: Internal functions
courier-id: Internal functions
courier-inboxes: Internal functions
courier-neighbors: Internal functions
courier-p: Internal functions
courier-processing-clock-rate: Exported functions
courier-queue: Internal functions
courier-secrets: Internal functions

D
define-broadcast-handler: Exported macros
define-convergecast-handler: Exported macros
define-dpu-flet: Internal macros
define-dpu-macro: Internal macros
define-message-dispatch: Exported macros
define-message-handler: Exported macros
define-message-subordinate: Exported macros
define-object-handler: Exported macros
define-process-upkeep: Exported macros
define-rpc-handler: Exported macros
deliver-message: Internal functions
dereference: Exported functions
destructuring-places: Exported macros
dohash: Exported macros

E
event-callback: Internal functions
event-p: Internal functions
event-time: Internal functions

F
finish-with-futures: Exported functions
Function, %dpu-flet-definitions: Internal functions
Function, %dpu-macrolet-definitions: Internal functions
Function, %make-courier-gridded: Internal functions
Function, %make-simulation: Internal functions
Function, (setf address-channel): Internal functions
Function, (setf address-courier): Internal functions
Function, (setf address-secret): Internal functions
Function, (setf broadcast-frame-aborting?): Internal functions
Function, (setf broadcast-frame-handle-rts?): Internal functions
Function, (setf broadcast-frame-message): Internal functions
Function, (setf broadcast-frame-targets): Internal functions
Function, (setf convergecast-frame-aborting?): Internal functions
Function, (setf convergecast-frame-func): Internal functions
Function, (setf convergecast-frame-handle-rts?): Internal functions
Function, (setf convergecast-frame-input): Internal functions
Function, (setf convergecast-frame-message): Internal functions
Function, (setf convergecast-frame-targets): Internal functions
Function, (setf courier-default-routing-time-step): Internal functions
Function, (setf courier-gridded-default-routing-time-step): Internal functions
Function, (setf courier-gridded-id): Internal functions
Function, (setf courier-gridded-inboxes): Internal functions
Function, (setf courier-gridded-neighbors): Internal functions
Function, (setf courier-gridded-processing-clock-rate): Internal functions
Function, (setf courier-gridded-queue): Internal functions
Function, (setf courier-gridded-secrets): Internal functions
Function, (setf courier-id): Internal functions
Function, (setf courier-inboxes): Internal functions
Function, (setf courier-neighbors): Internal functions
Function, (setf courier-processing-clock-rate): Exported functions
Function, (setf courier-queue): Internal functions
Function, (setf courier-secrets): Internal functions
Function, (setf grid-neighbors-down): Internal functions
Function, (setf grid-neighbors-left): Internal functions
Function, (setf grid-neighbors-right): Internal functions
Function, (setf grid-neighbors-up): Internal functions
Function, (setf logger-entries): Exported functions
Function, (setf message-lock-message-id): Internal functions
Function, (setf message-lock-reply-channel): Internal functions
Function, (setf message-message-id): Internal functions
Function, (setf message-reply-channel): Exported functions
Function, (setf message-rpc-done-message-id): Internal functions
Function, (setf message-rpc-done-reply-channel): Internal functions
Function, (setf message-rpc-done-result): Exported functions
Function, (setf message-rts-message-id): Internal functions
Function, (setf message-rts-reply-channel): Internal functions
Function, (setf message-unlock-message-id): Internal functions
Function, (setf message-unlock-reply-channel): Internal functions
Function, (setf message-unlock-result): Internal functions
Function, (setf simulation-contents): Internal functions
Function, (setf simulation-horizon): Internal functions
Function, (setf tracer-traces): Internal functions
Function, address-channel: Internal functions
Function, address-courier: Internal functions
Function, address-p: Internal functions
Function, address-secret: Internal functions
Function, address=: Exported functions
Function, broadcast-frame-aborting?: Internal functions
Function, broadcast-frame-handle-rts?: Internal functions
Function, broadcast-frame-message: Internal functions
Function, broadcast-frame-p: Internal functions
Function, broadcast-frame-targets: Internal functions
Function, canary-all: Exported functions
Function, canary-any: Exported functions
Function, canary-process: Exported functions
Function, canary-timeout: Exported functions
Function, canary-until: Exported functions
Function, cheap-heap-dequeue: Exported functions
Function, cheap-heap-enqueue: Exported functions
Function, cheap-heap-peep: Exported functions
Function, check-key-secret: Internal functions
Function, convergecast-frame-aborting?: Internal functions
Function, convergecast-frame-func: Internal functions
Function, convergecast-frame-handle-rts?: Internal functions
Function, convergecast-frame-input: Internal functions
Function, convergecast-frame-message: Internal functions
Function, convergecast-frame-p: Internal functions
Function, convergecast-frame-targets: Internal functions
Function, copy-address: Internal functions
Function, copy-broadcast-frame: Internal functions
Function, copy-convergecast-frame: Internal functions
Function, copy-courier: Internal functions
Function, copy-courier-gridded: Internal functions
Function, copy-event: Internal functions
Function, copy-grid-neighbors: Internal functions
Function, copy-logger: Internal functions
Function, copy-message: Internal functions
Function, copy-message-lock: Internal functions
Function, copy-message-rpc-done: Internal functions
Function, copy-message-rts: Internal functions
Function, copy-message-unlock: Internal functions
Function, copy-simulation: Internal functions
Function, copy-tracer: Internal functions
Function, courier-default-routing-time-step: Internal functions
Function, courier-gridded-default-routing-time-step: Internal functions
Function, courier-gridded-id: Internal functions
Function, courier-gridded-inboxes: Internal functions
Function, courier-gridded-neighbors: Internal functions
Function, courier-gridded-p: Internal functions
Function, courier-gridded-processing-clock-rate: Internal functions
Function, courier-gridded-queue: Internal functions
Function, courier-gridded-secrets: Internal functions
Function, courier-id: Internal functions
Function, courier-inboxes: Internal functions
Function, courier-neighbors: Internal functions
Function, courier-p: Internal functions
Function, courier-processing-clock-rate: Exported functions
Function, courier-queue: Internal functions
Function, courier-secrets: Internal functions
Function, deliver-message: Internal functions
Function, dereference: Exported functions
Function, event-callback: Internal functions
Function, event-p: Internal functions
Function, event-time: Internal functions
Function, finish-with-futures: Exported functions
Function, future: Exported functions
Function, future*: Exported functions
Function, grid-neighbors-down: Internal functions
Function, grid-neighbors-left: Internal functions
Function, grid-neighbors-p: Internal functions
Function, grid-neighbors-right: Internal functions
Function, grid-neighbors-up: Internal functions
Function, hash-address: Exported functions
Function, log-entry: Exported functions
Function, logger-entries: Exported functions
Function, logger-p: Internal functions
Function, macro-lambda-list-places: Internal functions
Function, make-address: Internal functions
Function, make-broadcast-frame: Exported functions
Function, make-cheap-heap: Exported functions
Function, make-convergecast-frame: Exported functions
Function, make-courier: Exported functions
Function, make-courier-grid: Exported functions
Function, make-courier-gridded: Internal functions
Function, make-event: Exported functions
Function, make-grid-neighbors: Internal functions
Function, make-logger: Internal functions
Function, make-message: Exported functions
Function, make-message-lock: Exported functions
Function, make-message-rpc-done: Exported functions
Function, make-message-rts: Exported functions
Function, make-message-unlock: Exported functions
Function, make-q: Exported functions
Function, make-simulation: Exported functions
Function, make-tracer: Internal functions
Function, message-lock-message-id: Internal functions
Function, message-lock-p: Internal functions
Function, message-lock-reply-channel: Internal functions
Function, message-log: Internal functions
Function, message-message-id: Internal functions
Function, message-p: Internal functions
Function, message-reply-channel: Exported functions
Function, message-report: Internal functions
Function, message-rpc-done-message-id: Internal functions
Function, message-rpc-done-p: Internal functions
Function, message-rpc-done-reply-channel: Internal functions
Function, message-rpc-done-result: Exported functions
Function, message-rts-message-id: Internal functions
Function, message-rts-p: Internal functions
Function, message-rts-reply-channel: Internal functions
Function, message-unlock-message-id: Internal functions
Function, message-unlock-p: Internal functions
Function, message-unlock-reply-channel: Internal functions
Function, message-unlock-result: Internal functions
Function, peek: Exported functions
Function, print-log: Exported functions
Function, print-message-report: Exported functions
Function, print-trace-table: Internal functions
Function, print-traces: Internal functions
Function, process-continuation: Exported functions
Function, process-die: Exported functions
Function, process-public-address: Exported functions
Function, public-address: Internal functions
Function, push-broadcast-frame: Exported functions
Function, push-convergecast-frame: Exported functions
Function, q-deq: Exported functions
Function, q-deq-first: Exported functions
Function, q-deq-when: Exported functions
Function, q-empty: Exported functions
Function, q-enq: Exported functions
Function, q-len: Exported functions
Function, q-peek: Exported functions
Function, q-push: Exported functions
Function, record-reference: Internal functions
Function, reduce+: Internal functions
Function, reduce-max: Internal functions
Function, register: Exported functions
Function, reset-logger: Exported functions
Function, return-from-cast: Exported functions
Function, rotate-trace-table: Internal functions
Function, send-message: Exported functions
Function, send-message-batch: Exported functions
Function, simulation-add-event: Exported functions
Function, simulation-contents: Internal functions
Function, simulation-dequeue: Internal functions
Function, simulation-horizon: Internal functions
Function, simulation-p: Internal functions
Function, simulation-peep: Internal functions
Function, simulation-run: Exported functions
Function, sort-traces: Internal functions
Function, spawn-process: Exported functions
Function, stash-local-message: Internal functions
Function, tracer-p: Internal functions
Function, tracer-store: Internal functions
Function, tracer-traces: Internal functions
Function, unregister: Exported functions
future: Exported functions
future*: Exported functions

G
Generic Function, (setf process-clock-rate): Exported generic functions
Generic Function, (setf process-command-stack): Exported generic functions
Generic Function, (setf process-courier): Internal generic functions
Generic Function, (setf process-data-stack): Exported generic functions
Generic Function, (setf process-debug?): Exported generic functions
Generic Function, (setf process-exhaust-inbox?): Exported generic functions
Generic Function, (setf process-key): Internal generic functions
Generic Function, (setf process-lockable-aborting?): Exported generic functions
Generic Function, (setf process-lockable-done-signal): Exported generic functions
Generic Function, (setf process-lockable-locked?): Exported generic functions
Generic Function, (setf process-peruse-inbox?): Exported generic functions
Generic Function, courier-courier->route: Internal generic functions
Generic Function, handle-message-lock: Exported generic functions
Generic Function, handle-message-rts: Internal generic functions
Generic Function, handle-object: Internal generic functions
Generic Function, message-dispatch: Internal generic functions
Generic Function, print-log-entry: Internal generic functions
Generic Function, process-clock-rate: Exported generic functions
Generic Function, process-command-stack: Exported generic functions
Generic Function, process-courier: Internal generic functions
Generic Function, process-data-stack: Exported generic functions
Generic Function, process-debug?: Exported generic functions
Generic Function, process-exhaust-inbox?: Exported generic functions
Generic Function, process-key: Internal generic functions
Generic Function, process-lockable-aborting?: Exported generic functions
Generic Function, process-lockable-done-signal: Exported generic functions
Generic Function, process-lockable-locked?: Exported generic functions
Generic Function, process-lockable-targets: Exported generic functions
Generic Function, process-peruse-inbox?: Exported generic functions
Generic Function, process-upkeep: Internal generic functions
grid-neighbors-down: Internal functions
grid-neighbors-left: Internal functions
grid-neighbors-p: Internal functions
grid-neighbors-right: Internal functions
grid-neighbors-up: Internal functions

H
handle-message-lock: Exported generic functions
handle-message-lock: Exported generic functions
handle-message-rts: Internal generic functions
handle-message-rts: Internal generic functions
handle-object: Internal generic functions
handle-object: Internal generic functions
handle-object: Internal generic functions
hash-address: Exported functions
hash-let: Internal macros

I
ignorant-lambda: Exported macros
initialize-and-return: Exported macros

L
log-entry: Exported functions
logger-entries: Exported functions
logger-p: Internal functions

M
Macro, %install-repeat-until: Internal macros
Macro, assoc-default: Internal macros
Macro, define-broadcast-handler: Exported macros
Macro, define-convergecast-handler: Exported macros
Macro, define-dpu-flet: Internal macros
Macro, define-dpu-macro: Internal macros
Macro, define-message-dispatch: Exported macros
Macro, define-message-handler: Exported macros
Macro, define-message-subordinate: Exported macros
Macro, define-object-handler: Exported macros
Macro, define-process-upkeep: Exported macros
Macro, define-rpc-handler: Exported macros
Macro, destructuring-places: Exported macros
Macro, dohash: Exported macros
Macro, hash-let: Internal macros
Macro, ignorant-lambda: Exported macros
Macro, initialize-and-return: Exported macros
Macro, receive-message: Exported macros
Macro, sync-receive: Exported macros
Macro, sync-rpc: Exported macros
Macro, with-address-dereferencing: Exported macros
Macro, with-courier: Exported macros
Macro, with-futures: Exported macros
Macro, with-replies: Exported macros
Macro, with-simulation: Exported macros
Macro, with-traces: Internal macros
Macro, with-transient-logger: Exported macros
macro-lambda-list-places: Internal functions
make-address: Internal functions
make-broadcast-frame: Exported functions
make-cheap-heap: Exported functions
make-convergecast-frame: Exported functions
make-courier: Exported functions
make-courier-grid: Exported functions
make-courier-gridded: Internal functions
make-event: Exported functions
make-grid-neighbors: Internal functions
make-logger: Internal functions
make-message: Exported functions
make-message-lock: Exported functions
make-message-rpc-done: Exported functions
make-message-rts: Exported functions
make-message-unlock: Exported functions
make-q: Exported functions
make-simulation: Exported functions
make-tracer: Internal functions
message-dispatch: Internal generic functions
message-dispatch: Internal generic functions
message-lock-message-id: Internal functions
message-lock-p: Internal functions
message-lock-reply-channel: Internal functions
message-log: Internal functions
message-message-id: Internal functions
message-p: Internal functions
message-reply-channel: Exported functions
message-report: Internal functions
message-rpc-done-message-id: Internal functions
message-rpc-done-p: Internal functions
message-rpc-done-reply-channel: Internal functions
message-rpc-done-result: Exported functions
message-rts-message-id: Internal functions
message-rts-p: Internal functions
message-rts-reply-channel: Internal functions
message-unlock-message-id: Internal functions
message-unlock-p: Internal functions
message-unlock-reply-channel: Internal functions
message-unlock-result: Internal functions
Method, (setf process-clock-rate): Exported generic functions
Method, (setf process-command-stack): Exported generic functions
Method, (setf process-courier): Internal generic functions
Method, (setf process-data-stack): Exported generic functions
Method, (setf process-debug?): Exported generic functions
Method, (setf process-exhaust-inbox?): Exported generic functions
Method, (setf process-key): Internal generic functions
Method, (setf process-lockable-aborting?): Exported generic functions
Method, (setf process-lockable-done-signal): Exported generic functions
Method, (setf process-lockable-locked?): Exported generic functions
Method, (setf process-peruse-inbox?): Exported generic functions
Method, courier-courier->route: Internal generic functions
Method, courier-courier->route: Internal generic functions
Method, handle-message-lock: Exported generic functions
Method, handle-message-rts: Internal generic functions
Method, handle-object: Internal generic functions
Method, handle-object: Internal generic functions
Method, message-dispatch: Internal generic functions
Method, print-log-entry: Internal generic functions
Method, print-log-entry: Internal generic functions
Method, process-clock-rate: Exported generic functions
Method, process-command-stack: Exported generic functions
Method, process-courier: Internal generic functions
Method, process-data-stack: Exported generic functions
Method, process-debug?: Exported generic functions
Method, process-exhaust-inbox?: Exported generic functions
Method, process-key: Internal generic functions
Method, process-lockable-aborting?: Exported generic functions
Method, process-lockable-done-signal: Exported generic functions
Method, process-lockable-locked?: Exported generic functions
Method, process-peruse-inbox?: Exported generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions
Method, process-upkeep: Internal generic functions

P
peek: Exported functions
print-log: Exported functions
print-log-entry: Internal generic functions
print-log-entry: Internal generic functions
print-log-entry: Internal generic functions
print-message-report: Exported functions
print-trace-table: Internal functions
print-traces: Internal functions
process-clock-rate: Exported generic functions
process-clock-rate: Exported generic functions
process-command-stack: Exported generic functions
process-command-stack: Exported generic functions
process-continuation: Exported functions
process-courier: Internal generic functions
process-courier: Internal generic functions
process-data-stack: Exported generic functions
process-data-stack: Exported generic functions
process-debug?: Exported generic functions
process-debug?: Exported generic functions
process-die: Exported functions
process-exhaust-inbox?: Exported generic functions
process-exhaust-inbox?: Exported generic functions
process-key: Internal generic functions
process-key: Internal generic functions
process-lockable-aborting?: Exported generic functions
process-lockable-aborting?: Exported generic functions
process-lockable-done-signal: Exported generic functions
process-lockable-done-signal: Exported generic functions
process-lockable-locked?: Exported generic functions
process-lockable-locked?: Exported generic functions
process-lockable-targets: Exported generic functions
process-peruse-inbox?: Exported generic functions
process-peruse-inbox?: Exported generic functions
process-public-address: Exported functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
process-upkeep: Internal generic functions
public-address: Internal functions
push-broadcast-frame: Exported functions
push-convergecast-frame: Exported functions

Q
q-deq: Exported functions
q-deq-first: Exported functions
q-deq-when: Exported functions
q-empty: Exported functions
q-enq: Exported functions
q-len: Exported functions
q-peek: Exported functions
q-push: Exported functions

R
receive-message: Exported macros
record-reference: Internal functions
reduce+: Internal functions
reduce-max: Internal functions
register: Exported functions
reset-logger: Exported functions
return-from-cast: Exported functions
rotate-trace-table: Internal functions

S
send-message: Exported functions
send-message-batch: Exported functions
simulation-add-event: Exported functions
simulation-contents: Internal functions
simulation-dequeue: Internal functions
simulation-horizon: Internal functions
simulation-p: Internal functions
simulation-peep: Internal functions
simulation-run: Exported functions
sort-traces: Internal functions
spawn-process: Exported functions
stash-local-message: Internal functions
sync-receive: Exported macros
sync-rpc: Exported macros

T
tracer-p: Internal functions
tracer-store: Internal functions
tracer-traces: Internal functions

U
unregister: Exported functions

W
with-address-dereferencing: Exported macros
with-courier: Exported macros
with-futures: Exported macros
with-replies: Exported macros
with-simulation: Exported macros
with-traces: Internal macros
with-transient-logger: Exported macros

Jump to:   %   (  
A   B   C   D   E   F   G   H   I   L   M   P   Q   R   S   T   U   W  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *  
A   C   D   E   F   H   I   L   M   N   P   Q   R   S   T   U  
Index Entry  Section

*
*courier-processing-clock-rate*: Internal special variables
*dereferencing-table*: Internal special variables
*local-courier*: Exported special variables
*logger*: Exported special variables
*message-traces*: Internal special variables
*routing-time-step*: Internal special variables

A
aborting?: Exported structures
aborting?: Exported classes

C
callback: Exported structures
channel: Exported structures
contents: Exported structures
courier: Exported structures

D
default-routing-time-step: Exported structures
done-signal: Exported classes
down: Internal structures
downward-rx-latches: Exported classes
downward-tx-latches: Exported classes

E
entries: Internal structures

F
func: Exported structures

H
handle-rts?: Exported structures
horizon: Exported structures

I
id: Exported structures
inboxes: Exported structures
input: Exported structures

L
left: Internal structures
locked?: Exported classes

M
message: Exported structures
message-id: Exported structures

N
neighbors: Exported structures

P
process-clock-rate: Exported classes
process-command-stack: Exported classes
process-courier: Exported classes
process-data-stack: Exported classes
process-debug?: Exported classes
process-exhaust-inbox?: Exported classes
process-key: Exported classes
process-peruse-inbox?: Exported classes
processing-clock-rate: Exported structures

Q
queue: Exported structures

R
reply-channel: Exported structures
result: Exported structures
result: Internal structures
right: Internal structures

S
secret: Exported structures
secrets: Exported structures
Slot, aborting?: Exported structures
Slot, aborting?: Exported classes
Slot, callback: Exported structures
Slot, channel: Exported structures
Slot, contents: Exported structures
Slot, courier: Exported structures
Slot, default-routing-time-step: Exported structures
Slot, done-signal: Exported classes
Slot, down: Internal structures
Slot, downward-rx-latches: Exported classes
Slot, downward-tx-latches: Exported classes
Slot, entries: Internal structures
Slot, func: Exported structures
Slot, handle-rts?: Exported structures
Slot, horizon: Exported structures
Slot, id: Exported structures
Slot, inboxes: Exported structures
Slot, input: Exported structures
Slot, left: Internal structures
Slot, locked?: Exported classes
Slot, message: Exported structures
Slot, message-id: Exported structures
Slot, neighbors: Exported structures
Slot, process-clock-rate: Exported classes
Slot, process-command-stack: Exported classes
Slot, process-courier: Exported classes
Slot, process-data-stack: Exported classes
Slot, process-debug?: Exported classes
Slot, process-exhaust-inbox?: Exported classes
Slot, process-key: Exported classes
Slot, process-peruse-inbox?: Exported classes
Slot, processing-clock-rate: Exported structures
Slot, queue: Exported structures
Slot, reply-channel: Exported structures
Slot, result: Exported structures
Slot, result: Internal structures
Slot, right: Internal structures
Slot, secret: Exported structures
Slot, secrets: Exported structures
Slot, targets: Exported structures
Slot, time: Exported structures
Slot, traces: Internal structures
Slot, up: Internal structures
Slot, upward-rx-latch: Exported classes
Slot, upward-tx-latch: Exported classes
Special Variable, *courier-processing-clock-rate*: Internal special variables
Special Variable, *dereferencing-table*: Internal special variables
Special Variable, *local-courier*: Exported special variables
Special Variable, *logger*: Exported special variables
Special Variable, *message-traces*: Internal special variables
Special Variable, *routing-time-step*: Internal special variables

T
targets: Exported structures
time: Exported structures
traces: Internal structures

U
up: Internal structures
upward-rx-latch: Exported classes
upward-tx-latch: Exported classes

Jump to:   *  
A   C   D   E   F   H   I   L   M   N   P   Q   R   S   T   U  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   A   B   C   E   G   L   M   P   S   T  
Index Entry  Section

A
address: Exported structures
aether: The aether system
aether: The aether package

B
broadcast-frame: Exported structures

C
Class, process: Exported classes
Class, process-lockable: Exported classes
Class, process-message-emissary: Internal classes
convergecast-frame: Exported structures
courier: Exported structures
courier-gridded: Internal structures

E
event: Exported structures

G
grid-neighbors: Internal structures

L
logger: Internal structures

M
message: Exported structures
message-lock: Exported structures
message-rpc-done: Exported structures
message-rts: Exported structures
message-unlock: Internal structures

P
Package, aether: The aether package
process: Exported classes
process-lockable: Exported classes
process-message-emissary: Internal classes

S
simulation: Exported structures
Structure, address: Exported structures
Structure, broadcast-frame: Exported structures
Structure, convergecast-frame: Exported structures
Structure, courier: Exported structures
Structure, courier-gridded: Internal structures
Structure, event: Exported structures
Structure, grid-neighbors: Internal structures
Structure, logger: Internal structures
Structure, message: Exported structures
Structure, message-lock: Exported structures
Structure, message-rpc-done: Exported structures
Structure, message-rts: Exported structures
Structure, message-unlock: Internal structures
Structure, simulation: Exported structures
Structure, tracer: Internal structures
System, aether: The aether system

T
tracer: Internal structures

Jump to:   A   B   C   E   G   L   M   P   S   T