An attempt to make a prototype Rust backend

[antanas-kalkauskas-sensmetry]

We have implemented a prototype Rust backend and it is available in this repo.

For code generation, we used a fork of language-rust by Galois except for one piece of code that does not depend on Copilot specification where we simply pasted a string. Manipulation of Rust AST via language-rust is low level. Partially because of this, parts of this prototype backend are quite verbose and could be simplified, refactored, and cleaned up.

This backend is not complete. In particular:

• It does not handle array streams.
• It does not handle struct streams.
• Only a subset of stream binary/unary operations are implemented.
• Almost no testing has been done apart from several manual runs.
• step and internal_step functions have a different shape than I would potentially prefer. Namely, I would like the internal_step not to execute the trigger functions but to return verdicts and arguments for trigger functions to the public Monitor::step function.

Example

The repository contains an example Copilot spec:

module Main where

import Language.Copilot
import Copilot.Compile.Rust

import Prelude hiding ((>), (<), div, sum, (++), (||))

temp :: Stream Word8
temp = extern "temperature" Nothing

ctemp :: Stream Float
ctemp = (unsafeCast temp) * (150.0 / 255.0) - 50.0

window :: Int
window = 5

avgTemp :: Stream Float
avgTemp = sum window
  (replicate window 19.5 ++ ctemp) / fromIntegral window

spec = do
  trigger "heaton"  (ctemp < 18.0) [arg ctemp]
  trigger "heatoff" (ctemp > 21.0) [arg ctemp]
  trigger "temperature_warning" (avgTemp > 21.0 || avgTemp < 18.0) [arg avgTemp]

main = reify spec >>= compile "heater"

Running

cabal run example-spec

from the directory of the repo produces the following Rust code:

#!heater
use std::marker::PhantomData;

pub trait MonitorTriggers {
  fn heaton(&mut self, heaton_arg0: f32);
  fn heatoff(&mut self, heatoff_arg0: f32);
  fn temperature_warning(&mut self, temperature_warning_arg0: f32);
}

pub struct MonitorInput {
  pub temperature: u8,
}

struct MonitorState {
  s0: [f32; 5],
  s0_idx: usize,
}

impl Default for MonitorState {
  fn default() -> Self {
    Self { s0_idx: 0, s0: [ 19.5f32, 19.5f32, 19.5f32, 19.5f32, 19.5f32 ] }
  }
}

fn s0_get(state: &MonitorState, index: usize) -> f32 {
  state.s0[(index + state.s0_idx) % 5]
}

fn s0_gen(input: &MonitorInput, state: &MonitorState) -> f32 {
  return input.temperature as f32 * (150.0f32 / 255.0f32) - 50.0f32;
}

fn heaton_guard(input: &MonitorInput, state: &MonitorState) -> bool {
  return input.temperature as f32 * (150.0f32 / 255.0f32) - 50.0f32 < 18.0f32;
}

fn heaton_arg0(input: &MonitorInput, state: &MonitorState) -> f32 {
  return input.temperature as f32 * (150.0f32 / 255.0f32) - 50.0f32;
}

fn heatoff_guard(input: &MonitorInput, state: &MonitorState) -> bool {
  return input.temperature as f32 * (150.0f32 / 255.0f32) - 50.0f32 > 21.0f32;
}

fn heatoff_arg0(input: &MonitorInput, state: &MonitorState) -> f32 {
  return input.temperature as f32 * (150.0f32 / 255.0f32) - 50.0f32;
}

fn temperature_warning_guard(
  input: &MonitorInput,
  state: &MonitorState,
) -> bool {
  return (s0_get(state, 0) + s0_get(state, 1) + s0_get(state, 2) + s0_get(
    state,
    3,
  ) + s0_get(state, 4)) / 5.0f32 > 21.0f32 || (s0_get(state, 0) + s0_get(
    state,
    1,
  ) + s0_get(state, 2) + s0_get(state, 3) + s0_get(
    state,
    4,
  )) / 5.0f32 < 18.0f32;
}

fn temperature_warning_arg0(input: &MonitorInput, state: &MonitorState) -> f32 {
  return (s0_get(state, 0) + s0_get(state, 1) + s0_get(state, 2) + s0_get(
    state,
    3,
  ) + s0_get(state, 4)) / 5.0f32;
}

fn internal_step<T: MonitorTriggers>(
  input: &MonitorInput,
  state: &mut MonitorState,
  triggers: &mut T,
) -> () {
  if heaton_guard(input, state) { triggers.heaton(heaton_arg0(input, state)); };
  if heatoff_guard(input, state) {
    triggers.heatoff(heatoff_arg0(input, state));
  };
  if temperature_warning_guard(input, state) {
    triggers.temperature_warning(temperature_warning_arg0(input, state));
  };
  let s0_tmp: f32 = s0_gen(input, state);
  state.s0[state.s0_idx] = s0_tmp;
  state.s0_idx = (state.s0_idx + 1) % 5;
}

pub struct Monitor<'a, T: MonitorTriggers> {
    state: MonitorState,
    phantom : PhantomData<&'a T>
}

impl<T: MonitorTriggers> Monitor<'_, T> {
    pub fn new() -> Self {
        Monitor {
            state: MonitorState::default(),
            phantom: PhantomData
        }
    }

    pub fn step(&mut self, input: &MonitorInput, triggers: &mut T) {
        internal_step(input, &mut self.state, triggers);
    }
}

If an appropriate main function is given, the generated code compiles (with some warnings about Rust naming conventions for unused variables as function arguments) and seems to work.