One cursor in, (int, cursor') out

Write int at cursor, and return a cursor

One cursor in, (tag,cursor) out

Write Tag at Cursor, and return a cursor

Create a tagged cursor

Write a tagged cursor

Reads and returns a tagged cursor at Var

Reads and returns the cursor at Var

Write a cursor, and return a cursor

Read a pointer to a linked list

Write a pointer to a linked list

Read a pointer to a vector

Write a pointer to a vector

Add a constant offset to a cursor variable

Pointer subtraction

Create a new buffer, and return a cursor

Create a temporary scoped buffer, and return a cursor

Create a new buffer for parallel allocations, and return a cursor

Create a temporary scoped buffer for parallel allocations, and return a cursor

Takes in start and end cursors, and returns an Int we'll probably represent (sizeof x) as (end_x - start_x) / INT

sizeof(var)

Bytes required, region, write cursor

Do one of the following: (1) If it's a old-to-young indirection, record it in the remembered set. (2) Otherwise, bump the refcount and update the outset.

Given an arena and end-of-region ptr, add a reference from the arena to the region

Constant null cursor value (hack?). Used for dict lookup, which returns a packed value but no end witness.

Analogous to L2's RetE.

Translates to __cilkrts_get_worker_number().

These variables are available to use before the join point

Analogous to L2's extension.

Analogous to L2's extension.

Marks the beginning of tag allocation.

Marks the end of tag allocation.

Marks the beginning of scalar allocation.

Marks the end of scalar allocation.

Translates to assert statements in C. ^ Analogous to L2's extensions.

May need more numeric primitives...

Integer division and modulus

Exponentiation

Generate a random number. Translates to 'rand()' in C.

Equality on Int

(and () for Int's

and=

Translates to 'tan()' in C.

Equality on Sym

Zero argument constructor.

Zero argument constructor.

crash and issue a static error message. To avoid needing inference, this is labeled with a return type.

Check the size of constructors with size.

Return the number of processors

Print an integer to standard out

Print a character to standard out

Print a floating point number to standard out

Print a boolean to standard out

Print a symbol to standard out

Read an int from standard in

takes dict, k,v; annotated with element type

takes dict,k errors if absent; annotated with element type

annotated with element type to avoid ambiguity

takes dict,k; returns a Bool, annotated with element type

Creates an empty set

Inserts a symbol into a set of symbols

Queries if a symbol is in a set

Create empty hash table of symbols

Insert a symbol into a hash table

Look up a symbol in a hash table (takes default symbol)

Queries if a symbol is in a hash

Create empty hash table of integers

Insert an integer into a hash table

Look up a integer in a hash table (takes default integer)

annotated with element type to avoid ambiguity

takes dict, k, v; annotated with element type

takes dict, k. errors if absent; annotated with element type

takes dict,k; returns a Bool, annotated with element type

takes dict; returns thread safe safe dicts.

takes 2 dicts; returns a merged dict.

Free the list, and it's data.

Free list struct, but not it's data.

Copy the list node.

Allocate a vector

Free a vector, and it's data.

Free the vector struct, but not it's data.

Length of the vector

Fetch the nth element

An efficient slice operation

Update ith element of the vector

Flatten a vector

A sort primop that accepts a function pointer

A sort primop that sorts the array in place

ASSUMPTION: the vectors being merged have the same underlying mutable array. This assumption is checked at the type level with a Rank-2 type variable. But this evidence is erased (by the desugarer) by the time we get to L0.

Read (mmap) a binary file containing packed data. This must be annotated with the type of the file being read. The Ty tracks the type as the program evolvels (first PackedTy then CursorTy). The TyCon tracks the original type name. The variable represents the region that this file will be mapped to, and is set by InferLocations.

Write a packed value to a file. To enable re-reading this packed value with Gibbon, this primitive gets rid of any absolute pointers in the value. First, it inlines (by copying) any regions pointed to by the packed value. Next, random access nodes are eliminated. We could change them to relative pointers (numeric offsets), but for a first version we can simplify things by getting rid of them completely.

Parse a file into a Vector. This is decorated with the element type. If the element type is a struct, like (Int, Int) for example, each line must contain 2 numbers separated by a space. The Int is the number of lines in the file.

Conveys a demand for the "end of" some packed value, which is fulfilled by Cursorize. N.B. the argument must be a VarE that refers to a packed value.

Like RequestEndOf but gets the size of a packed value. Assume that the value is written in a contiguous region, and size = end_v - v.