The aether Reference Manual

4.1.1 aether/aether.asd

Source

aether.asd.

Parent Component

aether (system).

ASDF Systems

aether.

---

4.1.2 aether/package.lisp

Source

aether.asd.

Parent Component

aether (system).

Packages

aether.

---

4.1.3 aether/utilities.lisp

Dependency

package.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• destructuring-places (macro).
• dohash (macro).
• ignorant-lambda (macro).
• initialize-and-return (macro).
• peek (function).

Internals

• assoc-default (macro).
• define-global-counter (macro).
• hash-let (macro).
• macro-lambda-list-places (function).

---

4.1.4 aether/queue.lisp

Dependency

utilities.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• make-q (function).
• q-deq (function).
• q-deq-first (function).
• q-deq-when (function).
• q-empty (function).
• q-enq (function).
• q-len (function).
• q-peek (function).
• q-push (function).

---

4.1.5 aether/cheap-heap.lisp

Dependency

queue.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• cheap-heap->list (function).
• cheap-heap-dequeue (function).
• cheap-heap-empty? (function).
• cheap-heap-enqueue (function).
• cheap-heap-peep (function).
• make-cheap-heap (function).

---

4.1.6 aether/debug/logger.lisp

Source

aether.asd.

Parent Component

debug (module).

Public Interface

• *logger* (special variable).
• log-entry (function).
• logger-entries (reader).
• (setf logger-entries) (writer).
• print-log (function).
• print-message-report (function).
• reset-logger (function).
• with-transient-logger (macro).

Internals

• copy-logger (function).
• logger (structure).
• logger-p (function).
• make-logger (function).
• message-log (function).
• message-report (function).
• print-log-entry (generic function).

---

4.1.7 aether/debug/trace.lisp

Dependency

logger.lisp (file).

Source

aether.asd.

Parent Component

debug (module).

Internals

• *message-traces* (special variable).
• copy-tracer (function).
• make-tracer (function).
• print-trace-table (function).
• print-traces (function).
• rotate-trace-table (function).
• sort-traces (function).
• tracer (structure).
• tracer-p (function).
• tracer-store (function).
• tracer-traces (reader).
• (setf tracer-traces) (writer).
• with-traces (macro).

---

4.1.8 aether/event.lisp

Dependency

debug (module).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• canary-all (function).
• canary-any (function).
• canary-process (function).
• canary-timeout (function).
• canary-until (function).
• define-object-handler (macro).
• event (structure).
• make-event (function).
• make-simulation (function).
• now (function).
• schedule (function).
• schedule* (function).
• simulation (structure).
• simulation-add-event (function).
• simulation-horizon (reader).
• (setf simulation-horizon) (writer).
• simulation-run (function).
• with-active-simulation (macro).
• with-scheduling (macro).
• with-simulation (macro).

Internals

• %make-simulation (function).
• *scheduling-accumulator* (special variable).
• *scheduling-clock* (special variable).
• copy-event (function).
• copy-simulation (function).
• event-callback (reader).
• event-p (function).
• event-time (reader).
• handle-object (generic function).
• simulation-contents (reader).
• (setf simulation-contents) (writer).
• simulation-dequeue (function).
• simulation-p (function).
• simulation-peep (function).

---

4.1.9 aether/message.lisp

Dependency

event.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• address (structure).
• address= (function).
• hash-address (function).
• make-message (function).
• make-message-rpc-done (function).
• make-message-rts (function).
• message (structure).
• message-reply-channel (reader).
• (setf message-reply-channel) (writer).
• message-rpc-done (structure).
• message-rpc-done-result (reader).
• (setf message-rpc-done-result) (writer).
• message-rts (structure).
• print-object (method).

Internals

• address-channel (reader).
• (setf address-channel) (writer).
• address-courier (reader).
• (setf address-courier) (writer).
• address-p (function).
• address-secret (reader).
• (setf address-secret) (writer).
• copy-address (function).
• copy-message (function).
• copy-message-rpc-done (function).
• copy-message-rts (function).
• get-message-index (function).
• make-address (function).
• message-message-id (reader).
• (setf message-message-id) (writer).
• message-p (function).
• message-rpc-done-message-id (function).
• (setf message-rpc-done-message-id) (function).
• message-rpc-done-p (function).
• message-rpc-done-reply-channel (function).
• (setf message-rpc-done-reply-channel) (function).
• message-rts-message-id (function).
• (setf message-rts-message-id) (function).
• message-rts-p (function).
• message-rts-reply-channel (function).
• (setf message-rts-reply-channel) (function).
• public-address (function).

---

4.1.10 aether/courier.lisp

Dependency

message.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• *local-courier* (special variable).
• courier (structure).
• courier-processing-clock-rate (reader).
• (setf courier-processing-clock-rate) (writer).
• make-courier (function).
• print-object (method).
• receive-message (macro).
• register (function).
• send-message (function).
• send-message-batch (function).
• unregister (function).
• with-courier (macro).

Internals

• *courier-processing-clock-rate* (special variable).
• *routing-time-step* (special variable).
• check-key-secret (function).
• copy-courier (function).
• courier-asleep-since (reader).
• (setf courier-asleep-since) (writer).
• courier-courier->route (generic function).
• courier-default-routing-time-step (reader).
• (setf courier-default-routing-time-step) (writer).
• courier-id (reader).
• (setf courier-id) (writer).
• courier-inboxes (reader).
• (setf courier-inboxes) (writer).
• courier-listeners (reader).
• (setf courier-listeners) (writer).
• courier-neighbors (reader).
• (setf courier-neighbors) (writer).
• courier-p (function).
• courier-queue (reader).
• (setf courier-queue) (writer).
• courier-secrets (reader).
• (setf courier-secrets) (writer).
• deliver-message (function).
• get-channel-index (function).
• get-courier-index (function).
• get-secret-index (function).
• handle-object (method).
• stash-local-message (function).
• wake-up (generic function).

---

4.1.11 aether/network.lisp

Dependency

courier.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

make-courier-grid (function).

Internals

• %make-courier-gridded (function).
• copy-courier-gridded (function).
• copy-grid-neighbors (function).
• courier-courier->route (method).
• courier-gridded (structure).
• courier-gridded-asleep-since (function).
• (setf courier-gridded-asleep-since) (function).
• courier-gridded-default-routing-time-step (function).
• (setf courier-gridded-default-routing-time-step) (function).
• courier-gridded-id (function).
• (setf courier-gridded-id) (function).
• courier-gridded-inboxes (function).
• (setf courier-gridded-inboxes) (function).
• courier-gridded-listeners (function).
• (setf courier-gridded-listeners) (function).
• courier-gridded-neighbors (function).
• (setf courier-gridded-neighbors) (function).
• courier-gridded-p (function).
• courier-gridded-processing-clock-rate (function).
• (setf courier-gridded-processing-clock-rate) (function).
• courier-gridded-queue (function).
• (setf courier-gridded-queue) (function).
• courier-gridded-secrets (function).
• (setf courier-gridded-secrets) (function).
• grid-neighbors (structure).
• grid-neighbors-down (reader).
• (setf grid-neighbors-down) (writer).
• grid-neighbors-left (reader).
• (setf grid-neighbors-left) (writer).
• grid-neighbors-p (function).
• grid-neighbors-right (reader).
• (setf grid-neighbors-right) (writer).
• grid-neighbors-up (reader).
• (setf grid-neighbors-up) (writer).
• make-courier-gridded (function).
• make-grid-neighbors (function).

---

4.1.12 aether/process/process.lisp

Source

aether.asd.

Parent Component

process (module).

Public Interface

• define-message-dispatch (macro).
• define-message-handler (macro).
• define-process-upkeep (macro).
• finish-handler (function).
• print-object (method).
• process (class).
• process-clock-rate (reader method).
• (setf process-clock-rate) (writer method).
• process-command-stack (reader method).
• (setf process-command-stack) (writer method).
• process-continuation (function).
• process-data-stack (reader method).
• (setf process-data-stack) (writer method).
• process-debug? (reader method).
• (setf process-debug?) (writer method).
• process-exhaust-inbox? (reader method).
• (setf process-exhaust-inbox?) (writer method).
• process-peruse-inbox? (reader method).
• (setf process-peruse-inbox?) (writer method).
• process-public-address (function).

Internals

• %dpu-flet-definitions (function).
• %dpu-macrolet-definitions (function).
• %message-dispatch (generic function).
• define-dpu-flet (macro).
• define-dpu-macro (macro).
• dpu-exit (condition).
• handle-message-rts (method).
• handle-object (method).
• message-dispatch (function).
• process-asleep-since (reader method).
• (setf process-asleep-since) (writer method).
• process-courier (reader method).
• (setf process-courier) (writer method).
• process-key (reader method).
• (setf process-key) (writer method).
• process-upkeep (generic function).
• wake-up (method).

---

4.1.13 aether/process/dpu-helpers.lisp

Dependency

process.lisp (file).

Source

aether.asd.

Parent Component

process (module).

Public Interface

• process-die (function).
• sync-receive (macro).
• wake-on-network (function).
• with-replies (macro).

Internals

• %install-repeat-until (macro).
• process-upkeep (method).

---

4.1.14 aether/process/dereference.lisp

Dependency

dpu-helpers.lisp (file).

Source

aether.asd.

Parent Component

process (module).

Public Interface

• dereference (function).
• spawn-process (function).
• with-address-dereferencing (macro).

Internals

• *dereferencing-table* (special variable).
• record-reference (function).

---

4.1.15 aether/process/emissary.lisp

Dependency

dereference.lisp (file).

Source

aether.asd.

Parent Component

process (module).

Public Interface

define-message-subordinate (macro).

Internals

• %message-dispatch (method).
• process-message-emissary (class).

---

4.1.16 aether/rpc.lisp

Dependency

process (module).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• define-rpc-handler (macro).
• sync-rpc (macro).

---

4.1.17 aether/lock.lisp

Dependency

rpc.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• handle-message-lock (method).
• make-message-lock (function).
• make-message-unlock (function).
• message-lock (structure).
• process-lockable (class).
• process-lockable-aborting? (reader method).
• (setf process-lockable-aborting?) (writer method).
• process-lockable-done-signal (reader method).
• (setf process-lockable-done-signal) (writer method).
• process-lockable-locked? (reader method).
• (setf process-lockable-locked?) (writer method).
• process-lockable-targets (generic function).

Internals

• copy-message-lock (function).
• copy-message-unlock (function).
• message-lock-message-id (function).
• (setf message-lock-message-id) (function).
• message-lock-p (function).
• message-lock-reply-channel (function).
• (setf message-lock-reply-channel) (function).
• message-unlock (structure).
• message-unlock-message-id (function).
• (setf message-unlock-message-id) (function).
• message-unlock-p (function).
• message-unlock-reply-channel (function).
• (setf message-unlock-reply-channel) (function).
• message-unlock-result (reader).
• (setf message-unlock-result) (writer).
• process-upkeep (method).
• process-upkeep (method).
• process-upkeep (method).
• process-upkeep (method).
• process-upkeep (method).

---

4.1.18 aether/cast.lisp

Dependency

lock.lisp (file).

Source

aether.asd.

Parent Component

aether (system).

Public Interface

• broadcast-frame (structure).
• convergecast-frame (structure).
• define-broadcast-handler (macro).
• define-convergecast-handler (macro).
• make-broadcast-frame (function).
• make-convergecast-frame (function).
• push-broadcast-frame (function).
• push-convergecast-frame (function).
• return-from-cast (function).

Internals

• broadcast-frame-aborting? (reader).
• (setf broadcast-frame-aborting?) (writer).
• broadcast-frame-handle-rts? (reader).
• (setf broadcast-frame-handle-rts?) (writer).
• broadcast-frame-message (reader).
• (setf broadcast-frame-message) (writer).
• broadcast-frame-p (function).
• broadcast-frame-targets (reader).
• (setf broadcast-frame-targets) (writer).
• convergecast-frame-aborting? (function).
• (setf convergecast-frame-aborting?) (function).
• convergecast-frame-func (reader).
• (setf convergecast-frame-func) (writer).
• convergecast-frame-handle-rts? (function).
• (setf convergecast-frame-handle-rts?) (function).
• convergecast-frame-input (reader).
• (setf convergecast-frame-input) (writer).
• convergecast-frame-message (function).
• (setf convergecast-frame-message) (function).
• convergecast-frame-p (function).
• convergecast-frame-targets (function).
• (setf convergecast-frame-targets) (function).
• copy-broadcast-frame (function).
• copy-convergecast-frame (function).
• process-upkeep (method).
• process-upkeep (method).
• reduce+ (function).
• reduce-max (function).

---

6.1.1 Special variables

Special Variable: *local-courier* ¶

Bound to the ‘COURIER’ that services this process.

Package

aether.

Source

courier.lisp.

Special Variable: *logger* ¶

Package

aether.

Source

logger.lisp.

---

6.1.2 Macros

Macro: define-broadcast-handler (handler-name ((process process-type) (message message-type)) &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-SCHEDULING’ in order to return from the handler early.

Package

aether.

Source

cast.lisp.

Macro: define-convergecast-handler (handler-name ((process process-type) (message message-type)) &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-SCHEDULING’ in order to return from the handler early.

Package

aether.

Source

cast.lisp.

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.

There is one exception: (CALL-NEXT-METHOD) is also a legal clause, and it references to the message handling table installed via DEFINE-MESSAGE-DISPATCH on this process type’s parent.

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. Additionally, this extra handler is _not_ inherited through (CALL-NEXT-METHOD). + ‘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.

Macro: define-message-handler (handler-name ((process process-type) (message message-type)) &body body) ¶

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

Package

aether.

Source

process.lisp.

Macro: define-message-subordinate (handler-name ((process process-type) (message message-type)) &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.

Macro: define-object-handler (((object-variable object-type)) &body body) ¶

Defines a default event handler for OBJECT-TYPE.

Package

aether.

Source

event.lisp.

Macro: define-process-upkeep (((process-name process-type)) (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.

Macro: define-rpc-handler (handler-name ((process process-type) (message message-type)) &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.

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.

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.

Macro: ignorant-lambda (&body body) ¶

Defines an anonymous function that discards all of its arguments.

Package

aether.

Source

utilities.lisp.

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.

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

courier.lisp.

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.

Macro: sync-rpc (message (result-place-or-list destination &key returned? message-type message-unpacker) &body body) ¶

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

Sends ‘MESSAGE’ to ‘DESTINATION’, waits for a reply (of type ‘MESSAGE-TYPE’), and unpacks the reply (using ‘MESSAGE-UNPACKER’) 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.

Macro: with-active-simulation (simulation &body body) ¶

Binds the simulation special variables to SIMULATION. Useful for sending messages into a simulation from ’outside’ of it.

Package

aether.

Source

event.lisp.

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

Context macro which permits use of DEREFERENCE in its body.

Package

aether.

Source

dereference.lisp.

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

courier.lisp.

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.

Macro: with-scheduling (now &body body) ¶

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

Provides some helper functions: SCHEDULE, SCHEDULE*, and FINISH-WITH-SCHEDULING.

Package

aether.

Source

event.lisp.

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.

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

Initialize a fresh logger. Returns log contents on close.

Package

aether.

Source

logger.lisp.

---

6.1.3 Ordinary functions

Function: address= (left right) ¶

Tests for semantic equality of addresses.

Package

aether.

Source

message.lisp.

Function: canary-all (&rest canaries) ¶

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

Package

aether.

Source

event.lisp.

Function: canary-any (&rest canaries) ¶

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

Package

aether.

Source

event.lisp.

Function: canary-process (process) ¶

Pause a simulation when PROCESS halts.

Package

aether.

Source

event.lisp.

Function: canary-timeout (timeout) ¶

Throw an error when TIMEOUT arrives.

Package

aether.

Source

event.lisp.

Function: canary-until (until) ¶

Pause a simulation after UNTIL passes.

Package

aether.

Source

event.lisp.

Function: cheap-heap->list (heap) ¶

Package

aether.

Source

cheap-heap.lisp.

Function: cheap-heap-dequeue (heap) ¶

Package

aether.

Source

cheap-heap.lisp.

Function: cheap-heap-empty? (heap) ¶

Package

aether.

Source

cheap-heap.lisp.

Function: cheap-heap-enqueue (heap item key) ¶

Package

aether.

Source

cheap-heap.lisp.

Function: cheap-heap-peep (heap) ¶

Package

aether.

Source

cheap-heap.lisp.

Reader: courier-processing-clock-rate (instance) ¶

Writer: (setf courier-processing-clock-rate) (instance) ¶

Package

aether.

Source

courier.lisp.

Target Slot

processing-clock-rate.

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.

Function: finish-handler () ¶

Return from the active aether process handler.

Package

aether.

Source

process.lisp.

Function: hash-address (address) ¶

Package

aether.

Source

message.lisp.

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.

Reader: logger-entries (instance) ¶

Writer: (setf logger-entries) (instance) ¶

Package

aether.

Source

logger.lisp.

Target Slot

entries.

Function: make-broadcast-frame (&key aborting? handle-rts? message targets) ¶

Package

aether.

Source

cast.lisp.

Function: make-cheap-heap () ¶

Package

aether.

Source

cheap-heap.lisp.

Function: make-convergecast-frame (&key aborting? handle-rts? message targets func input) ¶

Package

aether.

Source

cast.lisp.

Function: make-courier (&key queue inboxes secrets processing-clock-rate default-routing-time-step id neighbors asleep-since listeners) ¶

Package

aether.

Source

courier.lisp.

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.

Function: make-event (&key callback time) ¶

Package

aether.

Source

event.lisp.

Function: make-message (&key reply-channel message-id) ¶

Package

aether.

Source

message.lisp.

Function: make-message-lock (&key reply-channel message-id) ¶

Package

aether.

Source

lock.lisp.

Function: make-message-rpc-done (&key reply-channel message-id result) ¶

Package

aether.

Source

message.lisp.

Function: make-message-rts (&key reply-channel message-id) ¶

Package

aether.

Source

message.lisp.

Function: make-message-unlock (&key reply-channel message-id result) ¶

Package

aether.

Source

lock.lisp.

Function: make-q (&rest items) ¶

Package

aether.

Source

queue.lisp.

Function: make-simulation () ¶

Constructs an empty SIMULATION.

Package

aether.

Source

event.lisp.

Reader: message-reply-channel (instance) ¶

Writer: (setf message-reply-channel) (instance) ¶

Package

aether.

Source

message.lisp.

Target Slot

reply-channel.

Reader: message-rpc-done-result (instance) ¶

Writer: (setf message-rpc-done-result) (instance) ¶

Package

aether.

Source

message.lisp.

Target Slot

result.

Function: now () ¶

Returns the current time in the ambient simulation.

Package

aether.

Source

event.lisp.

Function: peek (list) ¶

Synonym for the PEEK operation on a stack.

Package

aether.

Source

utilities.lisp.

Function: print-log (entries &optional stream) ¶

Package

aether.

Source

logger.lisp.

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.

Function: process-continuation (process &rest commands) ¶

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

Package

aether.

Source

process.lisp.

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.

Function: process-public-address (process) ¶

Extracts the public ADDRESS associated to PROCESS.

Package

aether.

Source

process.lisp.

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.

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.

Function: q-deq (q) ¶

Package

aether.

Source

queue.lisp.

Function: q-deq-first (q pred) ¶

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

Package

aether.

Source

queue.lisp.

Function: q-deq-when (q pred) ¶

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

Package

aether.

Source

queue.lisp.

Function: q-empty (q) ¶

Package

aether.

Source

queue.lisp.

Function: q-enq (el q) ¶

Package

aether.

Source

queue.lisp.

Function: q-len (q) ¶

Package

aether.

Source

queue.lisp.

Function: q-peek (q) ¶

Package

aether.

Source

queue.lisp.

Function: q-push (q el) ¶

Package

aether.

Source

queue.lisp.

Function: register (&key courier channel secret) ¶

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

Package

aether.

Source

courier.lisp.

Function: reset-logger (&optional logger) ¶

Empties the current logger of all entries.

Package

aether.

Source

logger.lisp.

Function: return-from-cast (&optional value reason) ¶

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

Package

aether.

Source

cast.lisp.

Function: schedule (fn-or-obj time) ¶

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

Package

aether.

Source

event.lisp.

Function: schedule* (events) ¶

Installs a list of future EVENT objects.

Package

aether.

Source

event.lisp.

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

courier.lisp.

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

courier.lisp.

Function: simulation-add-event (simulation event) ¶

Installs EVENT into SIMULATION for later processing.

Package

aether.

Source

event.lisp.

Reader: simulation-horizon (instance) ¶

Writer: (setf simulation-horizon) (instance) ¶

Package

aether.

Source

event.lisp.

Target Slot

horizon.

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.

Function: spawn-process (class &rest initargs) ¶

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

Package

aether.

Source

dereference.lisp.

Function: unregister (address) ¶

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

Package

aether.

Source

courier.lisp.

Function: wake-on-network (&optional private-mailboxes) ¶

Sets this process to fall asleep, waking when its public mailbox or any of PRIVATE-MAILBOXES has a new message delivered.

NOTE: WAKE-ON-NETWORK is not available outside the body of DEFINE-PROCESS-UPKEEP.

Package

aether.

Source

dpu-helpers.lisp.

---

6.1.4 Generic functions

Generic Function: handle-message-lock (process message) ¶

Package

aether.

Methods

Method: handle-message-lock ((process process-lockable) (message message-lock)) ¶

Attempts to lock PROCESS.

Source

lock.lisp.

Generic Reader: process-clock-rate (object) ¶

Generic Writer: (setf process-clock-rate) (object) ¶

Package

aether.

Methods

Reader Method: process-clock-rate ((process process)) ¶

Writer Method: (setf process-clock-rate) ((process process)) ¶

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

Source

process.lisp.

Target Slot

process-clock-rate.

Generic Reader: process-command-stack (object) ¶

Generic Writer: (setf process-command-stack) (object) ¶

Package

aether.

Methods

Reader Method: process-command-stack ((process process)) ¶

Writer Method: (setf process-command-stack) ((process process)) ¶

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

Source

process.lisp.

Target Slot

process-command-stack.

Generic Reader: process-data-stack (object) ¶

Generic Writer: (setf process-data-stack) (object) ¶

Package

aether.

Methods

Reader Method: process-data-stack ((process process)) ¶

Writer Method: (setf process-data-stack) ((process process)) ¶

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

Source

process.lisp.

Target Slot

process-data-stack.

Generic Reader: process-debug? (object) ¶

Generic Writer: (setf process-debug?) (object) ¶

Package

aether.

Methods

Reader Method: process-debug? ((process process)) ¶

Writer Method: (setf process-debug?) ((process process)) ¶

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

Source

process.lisp.

Target Slot

process-debug?.

Generic Reader: process-exhaust-inbox? (object) ¶

Generic Writer: (setf process-exhaust-inbox?) (object) ¶

Package

aether.

Methods

Reader Method: process-exhaust-inbox? ((process process)) ¶

Writer Method: (setf process-exhaust-inbox?) ((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.

Target Slot

process-exhaust-inbox?.

Generic Reader: process-lockable-aborting? (object) ¶

Package

aether.

Methods

Reader Method: process-lockable-aborting? ((process-lockable process-lockable)) ¶

automatically generated reader method

Source

lock.lisp.

Target Slot

aborting?.

Generic Writer: (setf process-lockable-aborting?) (object) ¶

Package

aether.

Methods

Writer Method: (setf process-lockable-aborting?) ((process-lockable process-lockable)) ¶

automatically generated writer method

Source

lock.lisp.

Target Slot

aborting?.

Generic Reader: process-lockable-done-signal (object) ¶

Package

aether.

Methods

Reader Method: process-lockable-done-signal ((process-lockable process-lockable)) ¶

automatically generated reader method

Source

lock.lisp.

Target Slot

done-signal.

Generic Writer: (setf process-lockable-done-signal) (object) ¶

Package

aether.

Methods

Writer Method: (setf process-lockable-done-signal) ((process-lockable process-lockable)) ¶

automatically generated writer method

Source

lock.lisp.

Target Slot

done-signal.

Generic Reader: process-lockable-locked? (object) ¶

Package

aether.

Methods

Reader Method: process-lockable-locked? ((process-lockable process-lockable)) ¶

automatically generated reader method

Source

lock.lisp.

Target Slot

locked?.

Generic Writer: (setf process-lockable-locked?) (object) ¶

Package

aether.

Methods

Writer Method: (setf process-lockable-locked?) ((process-lockable process-lockable)) ¶

automatically generated writer method

Source

lock.lisp.

Target Slot

locked?.

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.

Generic Reader: process-peruse-inbox? (object) ¶

Generic Writer: (setf process-peruse-inbox?) (object) ¶

Package

aether.

Methods

Reader Method: process-peruse-inbox? ((process process)) ¶

Writer Method: (setf process-peruse-inbox?) ((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.

Target Slot

process-peruse-inbox?.

---

6.1.5 Standalone methods

Method: print-object ((object process) stream) ¶

Source

process.lisp.

Method: print-object ((object courier) stream) ¶

Source

courier.lisp.

Method: print-object ((object address) stream) ¶

Source

message.lisp.

---

6.1.6 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.

Direct superclasses

structure-object.

Direct methods

print-object.

Direct slots

Slot: courier ¶

Initform

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

Readers

address-courier.

Writers

(setf address-courier).

Slot: channel ¶

Readers

address-channel.

Writers

(setf address-channel).

Slot: secret ¶

Readers

address-secret.

Writers

(setf address-secret).

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.

Direct superclasses

structure-object.

Direct subclasses

convergecast-frame.

Direct slots

Slot: aborting? ¶

Type

boolean

Readers

broadcast-frame-aborting?.

Writers

(setf broadcast-frame-aborting?).

Slot: handle-rts? ¶

Type

boolean

Readers

broadcast-frame-handle-rts?.

Writers

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

Slot: message ¶

Type

(or null aether:message)

Readers

broadcast-frame-message.

Writers

(setf broadcast-frame-message).

Slot: targets ¶

Type

list

Readers

broadcast-frame-targets.

Writers

(setf broadcast-frame-targets).

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.

Direct superclasses

broadcast-frame.

Direct slots

Slot: func ¶

Type

(or null function)

Readers

convergecast-frame-func.

Writers

(setf convergecast-frame-func).

Slot: input ¶

Readers

convergecast-frame-input.

Writers

(setf convergecast-frame-input).

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. ‘ASLEEP-SINCE’: Couriers which are not processing inbound messages fall asleep and are temporarily removed from the event heap. This slot records the last time at which this courier had its event handler processed. ‘LISTENERS’: Mapping from inboxes to lists of processes to ‘WAKE-UP’ when a new message arrives.

Package

aether.

Source

courier.lisp.

Direct superclasses

structure-object.

Direct subclasses

courier-gridded.

Direct methods

• courier-courier->route.
• handle-object.
• print-object.
• wake-up.

Direct slots

Slot: queue ¶

Initform

(aether:make-q)

Readers

courier-queue.

Writers

(setf courier-queue).

Slot: inboxes ¶

Initform

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

Readers

courier-inboxes.

Writers

(setf courier-inboxes).

Slot: secrets ¶

Initform

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

Readers

courier-secrets.

Writers

(setf courier-secrets).

Slot: processing-clock-rate ¶

Initform

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

Readers

courier-processing-clock-rate.

Writers

(setf courier-processing-clock-rate).

Slot: default-routing-time-step ¶

Initform

aether::*routing-time-step*

Readers

courier-default-routing-time-step.

Writers

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

Slot: id ¶

Initform

(aether::get-courier-index)

Readers

courier-id.

Writers

(setf courier-id).

Slot: neighbors ¶

Initform

(make-hash-table)

Readers

courier-neighbors.

Writers

(setf courier-neighbors).

Slot: asleep-since ¶

Readers

courier-asleep-since.

Writers

(setf courier-asleep-since).

Slot: listeners ¶

Initform

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

Readers

courier-listeners.

Writers

(setf courier-listeners).

Structure: event ¶

Wrapper for a particular event.

Package

aether.

Source

event.lisp.

Direct superclasses

structure-object.

Direct slots

Slot: callback ¶

Readers

event-callback.

Writers

This slot is read-only.

Slot: time ¶

Package

common-lisp.

Type

(rational 0)

Initform

0

Readers

event-time.

Writers

This slot is read-only.

Structure: message ¶

Base type for messages transmitted along ‘COURIER’s.

Package

aether.

Source

message.lisp.

Direct superclasses

structure-object.

Direct subclasses

• message-lock.
• message-rpc-done.
• message-rts.
• message-unlock.

Direct slots

Slot: reply-channel ¶

Type

(or null aether:address)

Readers

message-reply-channel.

Writers

(setf message-reply-channel).

Slot: message-id ¶

Type

integer

Initform

(aether::get-message-index)

Readers

message-message-id.

Writers

(setf message-message-id).

Structure: message-lock ¶

Sent to establish a lock.

Package

aether.

Source

lock.lisp.

Direct superclasses

message.

Direct methods

handle-message-lock.

Structure: message-rpc-done ¶

Reply when an RPC message finishes.

Package

aether.

Source

message.lisp.

Direct superclasses

message.

Direct slots

Slot: result ¶

Readers

message-rpc-done-result.

Writers

(setf message-rpc-done-result).

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.

Direct superclasses

message.

Direct methods

handle-message-rts.

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.

Direct superclasses

structure-object.

Direct slots

Slot: contents ¶

Type

list

Readers

simulation-contents.

Writers

(setf simulation-contents).

Slot: horizon ¶

Type

(real 0)

Initform

0

Readers

simulation-horizon.

Writers

(setf simulation-horizon).

---

6.1.7 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.

Direct subclasses

• process-lockable.
• process-message-emissary.

Direct methods

• handle-message-rts.
• handle-object.
• print-object.
• (setf process-asleep-since).
• process-asleep-since.
• (setf process-clock-rate).
• process-clock-rate.
• (setf process-command-stack).
• process-command-stack.
• (setf process-courier).
• process-courier.
• (setf process-data-stack).
• process-data-stack.
• (setf process-debug?).
• process-debug?.
• (setf process-exhaust-inbox?).
• process-exhaust-inbox?.
• (setf process-key).
• process-key.
• (setf process-peruse-inbox?).
• process-peruse-inbox?.
• process-upkeep.
• process-upkeep.
• wake-up.

Direct slots

Slot: process-courier ¶

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

Initform

aether:*local-courier*

Initargs

:process-courier

Readers

process-courier.

Writers

(setf process-courier).

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’.)

Initform

(aether:register)

Initargs

:process-key

Readers

process-key.

Writers

(setf process-key).

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.

Writers

(setf process-clock-rate).

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.

Writers

(setf process-command-stack).

Slot: process-data-stack ¶

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

Readers

process-data-stack.

Writers

(setf process-data-stack).

Slot: process-debug? ¶

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

Initargs

:debug?

Readers

process-debug?.

Writers

(setf process-debug?).

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

Initform

t

Initargs

:process-exhaust-inbox?

Readers

process-exhaust-inbox?.

Writers

(setf process-exhaust-inbox?).

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

Initform

t

Initargs

:process-peruse-inbox?

Readers

process-peruse-inbox?.

Writers

(setf process-peruse-inbox?).

Slot: process-asleep-since ¶

FRACTION is the time at which the process was removed from the simulation heap and set for wake-on-network activity. NIL is a process which is currently in the simulation heap.

Type

(or null aether::fraction)

Initargs

:process-asleep-since

Readers

process-asleep-since.

Writers

(setf process-asleep-since).

Class: process-lockable ¶

A PROCESS which supports recursive locking.

Package

aether.

Source

lock.lisp.

Direct superclasses

process.

Direct methods

• handle-message-lock.
• (setf process-lockable-aborting?).
• process-lockable-aborting?.
• (setf process-lockable-done-signal).
• process-lockable-done-signal.
• (setf process-lockable-locked?).
• process-lockable-locked?.
• process-upkeep.
• process-upkeep.
• process-upkeep.
• process-upkeep.
• process-upkeep.

Direct slots

Slot: aborting? ¶

Type

boolean

Readers

process-lockable-aborting?.

Writers

(setf process-lockable-aborting?).

Slot: locked? ¶

Type

boolean

Readers

process-lockable-locked?.

Writers

(setf process-lockable-locked?).

Slot: done-signal ¶

Readers

process-lockable-done-signal.

Writers

(setf process-lockable-done-signal).

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)

---

6.2.1 Special variables

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

Package

aether.

Source

courier.lisp.

Special Variable: *dereferencing-table* ¶

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

Package

aether.

Source

dereference.lisp.

Special Variable: *message-traces* ¶

Houses information related to traces.

Package

aether.

Source

trace.lisp.

Special Variable: *routing-time-step* ¶

Package

aether.

Source

courier.lisp.

Special Variable: *scheduling-accumulator* ¶

Package

aether.

Source

event.lisp.

Special Variable: *scheduling-clock* ¶

Package

aether.

Source

event.lisp.

---