Integrate SimX (https://github.com/ndebuhr/simx) into the core sim repository, as a workspace member

Author: ndebuhr

.github/workflows/ci.yml

@@ -31,7 +31,7 @@ jobs:
         key: ${{ runner.os }}-cargo-${{ matrix.rust }}-${{ hashFiles('./sim/Cargo.lock') }}
     - name: Run Tests
       working-directory: ./sim
-      run: cargo test
+      run: cargo test --all-features -- --nocapture
 
   wasm-pack:
     name: Test (wasm)

.gitignore

@@ -2,6 +2,7 @@
 /target
 /sim/target
 /sim_derive/target
+/simx/target
 
 **/*.rs.bk
 

Cargo.toml

@@ -2,4 +2,5 @@
 members = [
     "sim",
     "sim_derive",
+    "simx",
 ]

sim/Cargo.toml

@@ -29,6 +29,7 @@ serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_yaml = "0.8"
 sim_derive = { version = "0.10", path = "../sim_derive" }
+simx = { version = "0.10", path = "../simx", optional = true }
 thiserror = "1.0"
 wasm-bindgen = "0.2"
 web-sys = { version = "0.3", features = [ "console" ] }

sim/src/models/batcher.rs

@@ -9,6 +9,9 @@ use crate::utils::errors::SimulationError;
 
 use sim_derive::SerializableModel;
 
+#[cfg(feature = "simx")]
+use simx::event_rules;
+
 /// The batching process begins when the batcher receives a job.  It will
 /// then accept additional jobs, adding them to a batch with the first job,
 /// until a max batching time or max batch size is reached - whichever comes
@@ -70,6 +73,7 @@ enum Phase {
     Release,  // Releasing a batch
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl Batcher {
     pub fn new(
         job_in_port: String,
@@ -209,6 +213,7 @@ impl Batcher {
     }
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl DevsModel for Batcher {
     fn events_ext(
         &mut self,

sim/src/models/exclusive_gateway.rs

@@ -10,6 +10,9 @@ use crate::utils::errors::SimulationError;
 
 use sim_derive::SerializableModel;
 
+#[cfg(feature = "simx")]
+use simx::event_rules;
+
 /// The exclusive gateway splits a process flow into a set of possible paths.
 /// The process will only follow one of the possible paths. Path selection is
 /// determined by Weighted Index distribution random variates, so this atomic
@@ -65,6 +68,7 @@ enum Phase {
     Pass,    // Passing a job from input to output
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl ExclusiveGateway {
     pub fn new(
         flow_paths_in: Vec<String>,
@@ -145,6 +149,7 @@ impl ExclusiveGateway {
     }
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl DevsModel for ExclusiveGateway {
     fn events_ext(
         &mut self,

sim/src/models/gate.rs

@@ -9,6 +9,9 @@ use crate::utils::errors::SimulationError;
 
 use sim_derive::SerializableModel;
 
+#[cfg(feature = "simx")]
+use simx::event_rules;
+
 /// The gate model passes or blocks jobs, when it is in the open or closed
 /// state, respectively. The gate can be opened and closed throughout the
 /// course of a simulation. This model contains no stochastic behavior - job
@@ -73,6 +76,7 @@ enum Phase {
     Pass,
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl Gate {
     pub fn new(
         job_in_port: String,
@@ -193,6 +197,7 @@ impl Gate {
     }
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl DevsModel for Gate {
     fn events_ext(
         &mut self,

sim/src/models/generator.rs

@@ -9,6 +9,9 @@ use crate::utils::errors::SimulationError;
 
 use sim_derive::SerializableModel;
 
+#[cfg(feature = "simx")]
+use simx::event_rules;
+
 /// The generator produces jobs based on a configured interarrival
 /// distribution. A normalized thinning function is used to enable
 /// non-stationary job generation. For non-stochastic generation of jobs, a
@@ -69,6 +72,7 @@ enum Phase {
     Generating,
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl Generator {
     pub fn new(
         message_interdeparture_time: ContinuousRandomVariable,
@@ -137,6 +141,7 @@ impl Generator {
     }
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl DevsModel for Generator {
     fn events_ext(
         &mut self,

sim/src/models/load_balancer.rs

@@ -9,6 +9,9 @@ use crate::utils::errors::SimulationError;
 
 use sim_derive::SerializableModel;
 
+#[cfg(feature = "simx")]
+use simx::event_rules;
+
 /// The load balancer routes jobs to a set of possible process paths, using a
 /// round robin strategy. There is no stochastic behavior in this model.
 #[derive(Debug, Clone, Serialize, Deserialize, SerializableModel)]
@@ -61,6 +64,7 @@ enum Phase {
     LoadBalancing,
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl LoadBalancer {
     pub fn new(job_port: String, flow_path_ports: Vec<String>, store_records: bool) -> Self {
         Self {
@@ -124,6 +128,7 @@ impl LoadBalancer {
     }
 }
 
+#[cfg_attr(feature = "simx", event_rules)]
 impl DevsModel for LoadBalancer {
     fn events_ext(
         &mut self,
@@ -137,10 +142,9 @@ impl DevsModel for LoadBalancer {
         &mut self,
         services: &mut Services,
     ) -> Result<Vec<ModelMessage>, SimulationError> {
-        if self.state.jobs.is_empty() {
-            self.passivate()
-        } else {
-            self.send_job(services)
+        match self.state.jobs.len() {
+            0 => self.passivate(),
+            _ => self.send_job(services),
         }
     }
 

sim/src/models/model.rs

@@ -74,6 +74,16 @@ impl DevsModel for Model {
     fn until_next_event(&self) -> f64 {
         self.inner.until_next_event()
     }
+
+    #[cfg(feature = "simx")]
+    fn event_rules_scheduling(&self) -> &str {
+        self.inner.event_rules_scheduling()
+    }
+
+    #[cfg(feature = "simx")]
+    fn event_rules(&self) -> String {
+        self.inner.event_rules()
+    }
 }
 
 impl Reportable for Model {