[package]

name = "reowolf_rs"

authors = [

	"Christopher Esterhuyse <esterhuy@cwi.nl, christopher.esterhuyse@gmail.com>",

	"Hans-Dieter Hiep <hdh@cwi.nl>"

]

edition = "2018"

[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.2.1"

serde = { version = "1.0.112", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

take_mut = "0.2.2"

indexmap = "1.3.0" # hashsets/hashmaps with efficient arbitrary element removal

replace_with = "0.1.5"

# network

integer-encoding = "1.0.7"

byteorder = "1.3.2"

# mio = "0.6.21"

mio-extras = "2.0.6"

mio = { version = "0.7.0", package = "mio", features = ["tcp", "os-poll"] }

# protocol

# id-arena = "2.2.1"

backtrace = "0.3"

[dev-dependencies]

test-generator = "0.3.0"

crossbeam-utils = "0.7.0"

lazy_static = "1.4.0"

[lib]

# compile target: dynamically linked library using C ABI

crate-type = ["cdylib"]

[features]

default = ["ffi"]

ffi = [] # no feature dependencies

# Reowolf 1.0 Implementation

## Compilation instructions

1. Install the latest stable Rust toolchain using Rustup. See https://rustup.rs/ for further instructions.

2. Run `cargo build --release` to download source dependencies, and compile the library with release-level optimizations. 

	- The resulting dylib can be found in target/release/, to be used with the header file reowolf.h.

	- Note: A list of immediate ancestor dependencies is visible in Cargo.toml.

	- Note: Run `cargo test --release` to run unit tests with release-level optimizations.

mod communication;

mod endpoints;

pub mod error;

mod logging;

mod setup;

#[cfg(test)]

mod tests;

use crate::common::*;

use error::*;

#[derive(Debug)]

pub struct RoundOk {

    batch_index: usize,

    gotten: HashMap<PortId, Payload>,

}

#[derive(Debug)]

pub struct VecSet<T: std::cmp::Ord> {

    // invariant: ordered, deduplicated

    vec: Vec<T>,

}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]

pub enum ComponentId {

    Native,

    Proto(ProtoComponentId),

}

#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]

pub enum Route {

    LocalComponent(ComponentId),

    Endpoint { index: usize },

}

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]

pub struct MyPortInfo {

    polarity: Polarity,

    port: PortId,

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub enum Decision {

    Failure,

    Success(Predicate),

}

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]

pub enum Msg {

    SetupMsg(SetupMsg),

    CommMsg(CommMsg),

}

#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]

pub enum SetupMsg {

    MyPortInfo(MyPortInfo),

    LeaderWave { wave_leader: ConnectorId },

#[derive(Debug)]

pub struct ConnectorCommunication {

    round_index: usize,

    endpoint_manager: EndpointManager,

    neighborhood: Neighborhood,

    mem_inbox: Vec<MemInMsg>,

    native_batches: Vec<NativeBatch>,

    round_result: Result<Option<RoundOk>, SyncError>,

}

#[derive(Debug)]

pub struct ConnectorUnphased {

    proto_description: Arc<ProtocolDescription>,

    proto_components: HashMap<ProtoComponentId, ProtoComponent>,

    logger: Box<dyn Logger>,

    id_manager: IdManager,

    native_ports: HashSet<PortId>,

    port_info: PortInfo,

}

#[derive(Debug)]

pub enum ConnectorPhased {

    Setup { endpoint_setups: Vec<(PortId, EndpointSetup)>, surplus_sockets: u16 },

    Communication(ConnectorCommunication),

}

#[derive(Default, Clone, Eq, PartialEq, Hash, serde::Serialize, serde::Deserialize)]

pub struct Predicate {

    pub assigned: BTreeMap<FiringVar, bool>,

}

#[derive(Debug, Default)]

pub struct NativeBatch {

    // invariant: putters' and getters' polarities respected

    to_put: HashMap<PortId, Payload>,

    to_get: HashSet<PortId>,

}

pub struct NonsyncProtoContext<'a> {

    logger: &'a mut dyn Logger,

    proto_component_id: ProtoComponentId,

    port_info: &'a mut PortInfo,

    id_manager: &'a mut IdManager,

    proto_component_ports: &'a mut HashSet<PortId>,

    unrun_components: &'a mut Vec<(ProtoComponentId, ProtoComponent)>,

}

pub struct SyncProtoContext<'a> {

    logger: &'a mut dyn Logger,

    predicate: &'a Predicate,

    port_info: &'a PortInfo,

    inbox: &'a HashMap<PortId, Payload>,

}

////////////////

pub fn would_block(err: &std::io::Error) -> bool {

    err.kind() == std::io::ErrorKind::WouldBlock

}

impl<T: std::cmp::Ord> VecSet<T> {

    fn iter(&self) -> std::slice::Iter<T> {

        self.vec.iter()

    }

    fn contains(&self, element: &T) -> bool {

        self.vec.binary_search(element).is_ok()

    }

    fn new(mut vec: Vec<T>) -> Self {

        vec.sort();

        vec.dedup();

        Self { vec }

    }

}

impl PortInfo {

    fn firing_var_for(&self, port: PortId) -> FiringVar {

        FiringVar(match self.polarities.get(&port).unwrap() {

            Getter => port,

            Putter => *self.peers.get(&port).unwrap(),

        })

    }

}

impl IdManager {

    fn new(connector_id: ConnectorId) -> Self {

        Self {

            connector_id,

            port_suffix_stream: Default::default(),

            proto_component_suffix_stream: Default::default(),

        }

    }

    fn new_port_id(&mut self) -> PortId {

        Id { connector_id: self.connector_id, u32_suffix: self.port_suffix_stream.next() }.into()

    }

    fn new_proto_component_id(&mut self) -> ProtoComponentId {

        Id {

            connector_id: self.connector_id,

            u32_suffix: self.proto_component_suffix_stream.next(),

        }

        .into()

    }

}

impl Drop for Connector {

    fn drop(&mut self) {

        log!(&mut *self.unphased.logger, "Connector dropping. Goodbye!");

    }

}