Crate aluvm

Source
Expand description

Rust implementation of AluVM (arithmetic logic unit virtual machine) and assembler from Alu Assembly language into bytecode.

AluVM is a pure functional register-based highly deterministic & exception-less instruction set architecture (ISA) and virtual machine (VM) without random memory access, capable of performing arithmetic operations, including operations on elliptic curves. The AluVM ISA can be extended by the environment running the virtual machine (host environment), providing an ability to load data to the VM registers and support application-specific instructions (like SIMD).

The main purpose for ALuVM is to be used in distributed systems whether robustness, platform-independent determinism are more important than the speed of computation. The main area of AluVM applications (using appropriate ISA extensions) is blockchain environments, consensus-critical computations, multiparty computing (including deterministic machine learning), client-side-validation, sandboxed Internet2 computing, and genetic algorithms.

For more details on AluVM, please check the specification

§Design

The robustness lies at the very core of AluVM. It is designed to avoid any undefined behavior. Specifically,

  • All registers may be in the undefined statel
  • Impossible/incorrect operations put destination register into a special undefined state;
  • Code always extended to 2^16 bytes with zeros, which corresponds to no-operation;
  • There are no invalid jump operations;
  • There are no invalid instructions;
  • Cycles & jumps are counted with 2^16 limit (bounded-time execution);
  • No ambiguity: any two distinct byte strings always represent strictly distinct programs;
  • Code is always signed;
  • Data segment is always signed;
  • Code commits to the used ISA extensions;
  • Libraries identified by the signature;
  • Code does not run if not all libraries are present;

Comparison table

§Instruction Set Architecture

Instruction set architecture

§Instruction opcodes

One will find all opcode implementation details documented in isa::Instr API docs.

  • RISC: only 256 instructions
  • 3 families of core instructions:
    • Control flow
    • Data load / movement between registers
    • ALU (including cryptography)
  • Extensible with ISA extensions: 127 of the operations are reserved for extensions
    • More cryptography
    • Custom data I/O (blockchain, LN, client-side-validation)
    • Genetic algorithms / code self-modification

The arithmetic ISA is designed with strong robustness goals:

  • Impossible arithmetic operation (0/0, Inf/inf) always sets the destination register into undefined state (unlike NaN in IEEE-754 it has only a single unique value)
  • Operation resulting in the value which can’t fit the bit dimensions under a used encoding, including representation of infinity for integer encodings (x/0 if x != 0) results in:
    • for float underflows, subnormally encoded number,
    • for x/0 if x != 0 on float numbers, ±Inf float value,
    • for overflows in integer checked operations and floats: undefined value, setting CK to false,
    • for overflows in integer wrapped operations, modulo division on the maximum register value

Most of the arithmetic operations has to be provided with flags specifying which of the encoding and exception handling should be used:

  • Integer encodings have two flags:
    • one for signed/unsigned variant of the encoding
    • one for checked or wrapped variant of exception handling
  • Float encoding has 4 variants of rounding, matching IEEE-754 options

Thus, many arithmetic instructions have 8 variants, indicating the used encoding (unsigned, signed integer or float) and operation behavior in a situation when resulting value does not fit into the register (overflow or wrap for integers and one of four rounding options for floats).

Check the specification for the details.

§Registers

ALU registers: 8 blocks of 32 registers

  • Integer arithmetic (A-registers) blocks: 8, 16, 32, 64, 128, 256, 512, 1024 bits
  • Float arithmetic (F-registers) blocks:
    • IEEE: binary-half, single, double, quad, oct precision
    • IEEE extension: 80-bit X87 register
    • BFloat16 register, used in Machine learning
  • Cryptographic operations (R-registers) blocks: 128, 160, 256, 512, 1024, 2048, 4096, 8192 bits
  • String registers (S-registers): 1 block of 256 registers, 64kb each

Control flow registers:

  • Status (CK), boolean (one bit)
  • Cycle counter (CY), 16 bits
  • Instruction complexity accumulator (CA), 16 bits
  • Call stack register (CS), 3*2^16 bits (192kB block)
  • Call stack pointer register (CP), 16 bits

Re-exports§

pub use isa::ExecStep;
pub use isa::IsaId;
pub use isa::ISA_ID_MAX_LEN;

Modules§

isa
AluVM instruction set architecture.
regs
Module providing register information
stlstl
Strict types library generator methods.

Macros§

aluasm
Macro compiler for AluVM assembler.
isa
Macro for constructing ISA identifiers

Structs§

CompiledLib
The compiled AluVM library containing information about the routines.
Core
Registers of a single CPU/VM core.
CoreConfig
Configuration for Core initialization.
Lib
An AluVM library, which can be executed on a VM instance.
LibId
Unique identifier for an AluVM library.
LibSite
Location inside the instruction sequence which can be executed by the core.
Marshaller
Marshals instructions to and from bytecode representation.
NoExt
Helper data structure for base core which has no ISA extensions.
Site
Location inside the instruction sequence which can be executed by the core.
Vm
Alu virtual machine providing single-core execution environment

Enums§

AssemblerError
Errors while assembling lib-old from the instruction set.
CompilerError
Errors generated during the library compilation.
LibArmorErrorarmor
Errors while deserializing lib-old from an ASCII Armor.
MarshallError
Errors write operations
NoRegs
Default Register implementation for ISA extensions providing no new registers.

Constants§

LIB_NAME_ALUVM
Name of the strict types library for AluVM.

Traits§

CoreExt
Extension to the AluVM core provided by an ISA.
Register
A trait for a set of registers provided by an ISA extension.
SiteId
Trait for program identifiers.
Supercore
A trait for the external part of AluVM core which can operate with core ISA extensions.

Type Aliases§

LibsSeg
Library segment inside AluVM library which stores references to the external library ids for the external calls made within the library.