gitbook-docs/knowledge_knowledge/knowledge_aquamarine/hll/knowledge_aquamarine_air.md

AIR

The Aquamarine Intermediate Representation AIR is a low level language to program both distributed networks and the services deployed on them. The language is comprised of a small number of instructions:

• call: : execution
• seq : sequential
• par : parallel
• fold : iteration
• xor : branching & error handling
• null : empty instruction

which operate on peer-id location, service-id, and service method over an argument list, see Figure 1.

Figure 1: AIR Instruction Definition

Instructions

AIR instructions are intended to launch the execution of a service method as follows:

1. The method is executed on the peer specified by the peer id location parameter
2. The peer is expected to have the Wasm service specified by the service id parameter
3. The service must have a callable method specified be the method parameter
4. The arguments specified by the argument list are passed to the method
5. The result of the method returned under the name output name

Figure 2: Sequential Instruction

The seq instruction takes two instructions at most as its arguments and executes them sequentially, one after the other.

Figure 3: Parallel Instruction

The par instruction takes two instructions at most as its arguments and particles may execute on parallel paths iff each service referenced is hosted on a different node otherwise particles execute sequentially

TODO: add better graphic showing the disticntion of branching vs seq.

Figure 4: Fold Instruction

The fold instruction iterates over the elements of an array and workds as follows:

• fold instruction takes three arguments: an array, a variable and an instruction
• At each iteration, the variable is assigned an element of the array and the argument-instruction is executed
• The argument-instruction can access the variable and uses the next statement to trigger the next iteration

Figure 5: Branching Instruction

This instruction is intended for organizing branches in the flow of execution as well as for handling errors:

• The XOR instruction takes two instructions as its arguments
• The first instruction is executed and if the execution is successful, then the second instruction is ignored
• If the first instruction fails, then the second one is executed.

Figure 6: Null Instruction

This is an empty instruction: it takes no arguments and does nothing. The null instruction is useful for generating code.