Host interface

Faasm functions can interact with the Faasm runtime and underlying host through the host interface. This lets them do things like manage state and interact with other functions.

The host interface includes:

Function input/ output
Chaining functions
State management
WASI
Dynamic linking
pthreads
MPI
OpenMP

Function input/output and chaining

These cover interactions with serverless functions and their ability to invoke other functions (“chaining”).

Function	Description
`byte* read_call_input()`	Read input data as byte array
`void write_call_output(out_data)`	Write output data for function
`int chain_name(name, args)`	Call function by name and return `call_id`
`int chain_ptr(ptr, args)`	Call function pointer and return `call_id`
`int await_call(call_id)`	Await completion of `call_id`
`byte* await_call_output(call_id)`	Await completion and get output of `call_id`

State

This section of the host interface covers management of state as outlined in the state docs.

Function	Description
`byte* get_state(key, flags)`	Get pointer to state value for `key`
`byte* get_state_offset(key, off, flags)`	Get pointer to state value for `key` at an offset
`void set_state(key, val)`	Set state value for `key`
`void set_state_offset(key, val, len, off)`	Set `len` bytes of state value at offset for `key`
`void push/pull_state(key)`	Push/pull global state value for `key`
`void push/pull_state_offset(key, off)`	Push/pull global state value for `key` at offset
`void append_state(key, val)`	Append data to state value for `key`
`void lock_state_read/write(key)`	Lock local copy of state value for `key`

POSIX-like calls and WASI

Faasm supports WASI, but adds and customises further POSIX-like system calls to support a broader range of legacy applications and libraries (such as CPython).

This is done in part with a modified wasi-libc.

The main additions and modifications are as follows:

Category	Function	Description
Dynamic linking	`void *dlopen/dlsym(...)`	Standard POSIX-like dynamic linking
Dynamic linking	`int dlclose(...)`	As above
Memory	`void* mmap(...), int munmap(...)`	Only permits memory growth and file mapping
File I/O	`int dup(...)`	Necessary for certain legacy applications

Faasm supports standard filesystem syscalls, but provides a serverless-specific implementation. Because functions may be executing on different hosts, all filesystem accesses are global-read-local-write, i.e. functions can access files from any host, but writes are only made locally. This is sufficient to support legacy filesystem use-cases, while any data sharing between functions can be done through state.

As mentioned above, Faasm also supports pthreads, which also introduce a number of extra POSIX syscalls.