glossary

A B C D E F G H K L R S T W

agreement

Two implementations agree on a program when its canonical outcomes are equal for the same semantic inputs. The conformance suite measures agreement with the reference.

SPEC-09P.4 3.13

as, as%, as|, as?

x as I32 converts x to I32 and faults when the value does not fit; as% wraps, as| clamps to the range and as? returns an error. No conversion is implicit, not even from a narrower integer type to a wider one.

SPEC-04P.4 6.6

bootstrap

Building the compiler from its source text and a C toolchain alone, with no cint compiler built earlier.

SPEC-09P.4 3.18

boundary

A point of a run at which the state of its context is defined and its state hash is taken, such as the end of an entry.

SPEC-01P.3 3.16

canonical

Chosen by a named, versioned rule as the one representation of a content. Canonical says which bytes are compared, not that they are correct.

SPEC-01P.3 3.1

canonical outcome

What implementations compare for one entry: the output bytes, the kind of outcome, the returned value, the fuel consumed and the fault record.

SPEC-09P.4 3.12

case

A recording that also holds the source text of every module of its program, so the run can be shown, replayed and compared on another machine.

SPEC-01P.3 3.15

checked operator

An operator that gives the exact result when it fits the result type and faults otherwise. Every plain operator is checked: +, -, *, /, %, << and >>.

SPEC-04P.4 3.5

checkpoint

The canonical bytes of a state, in an envelope that names the runtime contract, from which a context can be restored.

SPEC-01P.3 3.11

conformance case

A program, or one operation, together with its expected outcome.

SPEC-09P.4 3.10

context

One instance of a program's state, held by a host program, in which entries run one at a time.

SPEC-04P.4 3.44

digest

A SHA-256 digest, written as 64 lowercase hexadecimal digits. cint names a program, a file or a state by its digest, which the specifications call its identity.

SPEC-06P.3 3.14, SPEC-01P.3 3.12

digest chain

The digest a recording carries in its last event, computed from the state hash of its first checkpoint and of each boundary in turn.

SPEC-01P.3 3.17

dispatch

One call of a kernel over an iteration space.

SPEC-04P.4 3.29

domain string

The string of the form <profile>/<kind>/v<n> that begins every binary encoding and the input of every digest, and names the encoding.

SPEC-01P.3 3.3

emitted C

The C17 source text that the compiler cintc writes for a program.

SPEC-09P.4 3.6

entry

One run of a program from its entry point: the top-level statements of a script, main, a test block or an exported function called from a host program.

SPEC-04P.4 3.20

exact result

The result of an arithmetic operation computed over the unbounded integers, before any check against the range of the result type.

SPEC-04P.4 3.4

execution identity

The canonical form of the semantic inputs of one entry.

SPEC-01P.3 3.22

fault

The stop of a run at an operation that cannot give a correct result, such as an overflow, a division by zero or an index outside an array.

SPEC-04P.4 3.9

fault record

The description of a fault: its fault code, the operation, the operands, the exact result, the bound that was crossed, the source position and the identity of the program. It is the same on every conforming build.

SPEC-04P.4 3.11, SPEC-04P.4 8.1

fixed point

Q<i>.<f>, such as Q16.16: a signed type with i integer bits and f fraction bits, held as an integer count of units of 2^-f.

SPEC-04P.4 6.3.2

fixpoint

The state in which the compiler, built from the C it emitted for its own source, emits that same C again.

SPEC-09P.4 3.19

fuel

A count of the steps an entry is charged as it runs: calls, loop iterations, reductions and kernel dispatches. It is the same on every machine, and an entry faults at the charge that would take it past its allowance.

SPEC-04P.4 3.21

golden

An output saved from a run that was checked once, kept with the program and compared byte for byte with each later run on the same inputs.

SPEC-04P.4 3.32

grant set

The capabilities given to a run, fixed before the program starts, such as fs.read:/data. A call that no grant covers returns the error denied and changes nothing.

SPEC-04P.4 3.49, SPEC-04P.4 6.9.9

helper

A function of the runtime that performs one operation of one type and reports its fault, such as cint_add_i64.

SPEC-09P.4 3.8

kernel

A function that runs once for each point of an iteration space, writing its results to output views that only that point may write, so the points can run in parallel.

SPEC-04P.4 3.28

lane

A packed part of an integer's bit pattern, the width of an unsigned type that divides the integer's width. !lanes(U8) prints a value as its lanes, lane 0 the least significant.

SPEC-04P.4 7.5.4

lean set

The small functions of a module that make no host call, dispatch or fixed-point operation and call only each other. A call between them writes no call site or depth into the context, and every result, fault record and fuel count stays the same.

SPEC-09P.4 7.5

receipt

A canonical JSON file that records one run of a tool: its inputs, its outcome and what it observed. A published figure cites the receipt it came from.

SPEC-09P.4 3.14

receipt identity

The SHA-256 digest of a receipt's inputs and outcome. Two runs with the same receipt identity had the same inputs and the same outcome.

SPEC-09P.4 3.15

recording

A file that holds a program's identity and code, a checkpoint taken when recording began and the events that followed, from which the run can be replayed.

SPEC-01P.3 3.14

refusal

The report that an implementation will not run a valid program, or a dispatch, because it cannot run it exactly. A refused program is never run with a different meaning.

SPEC-04P.4 3.16

replay

Running the entries of a recording again from its initial state with the recorded inputs, and comparing each boundary with the recording.

SPEC-06P.3 3.11

result form

A built-in operation, such as add_result, that returns an error union instead of raising the fault its checked operator would raise.

SPEC-04P.4 3.8

revision

The identity of a program, a digest. Source positions are not part of it, and a fault record names the revision its positions refer to.

SPEC-04P.4 3.31

runtime

The C library cint_rt that emitted C and the interpreter call for checked arithmetic, fuel, call depth and fault records.

SPEC-09P.4 3.7

saturating operator

+|, -| and *|: the exact result clamped to the range of the type. A saturating operator never faults on overflow.

SPEC-04P.4 3.7

semantic input

A value that decides the outcome of an entry: the program, its inputs, the effects the host supplied, the fuel allowance, the call-depth limit and the frame-arena capacity. Host time, scheduling and addresses are not semantic inputs.

SPEC-04P.4 3.24

SIR

The semantic intermediate representation: the form of a checked program that every executor of the toolchain runs.

SPEC-09P.4 3.3

state

The canonical content of a context between entries: its module-level variables, arenas and pools, buffer registry, identifier counters, any fault record it holds and the count of effects it has completed.

SPEC-01P.3 3.10

state hash

The SHA-256 digest of the canonical bytes of a state.

SPEC-01P.3 3.12

the reference

cint_ref, an implementation in Python written to follow the specification directly. Its results are the expected results of the conformance suite.

SPEC-04P.4 3.18

wide integers

I128 to I1024 and U128 to U512, with the same checked operators as the 8- to 64-bit types.

SPEC-04P.4 6.3.1

word

I64, the type of every array length, index and for range bound. A bound of another integer type is diagnosed even when its value fits; as I64 converts it.

SPEC-04P.4 6.3.1

wrapping operator

+%, -%, *% and <<%: the exact result reduced into the range of the type. A wrapping operator never faults.

SPEC-04P.4 3.6