Using smol executor

gemla/Cargo.toml

@@ -25,5 +25,7 @@ anyhow = "1.0"
 rand = "0.8.4"
 log = "0.4.14"
 env_logger = "0.9.0"
-tokio = { version = "1.12.0", features = ["full"] }
 futures = "0.3.17"
+smol = "1.2.5"
+num_cpus = "1.13.0"
+easy-parallel = "3.1.0"

gemla/src/bin/bin.rs

@@ -18,32 +18,51 @@ use test_state::TestState;
 ///
 /// Use the -h, --h, or --help flag to see usage syntax.
 /// TODO
-#[tokio::main]
+fn main() -> anyhow::Result<()> {
-async fn main() -> anyhow::Result<()> {
     env_logger::init();
     info!("Starting");
 
     let now = Instant::now();
 
-    // Command line arguments are parsed with the clap crate. And this program uses
+    // Obtainning number of threads to use
-    // the yaml method with clap.
+    let num_threads = num_cpus::get().max(1);
-    let yaml = load_yaml!("../../cli.yml");
+    let ex = smol::Executor::new();
-    let matches = App::from_yaml(yaml).get_matches();
+    let (signal, shutdown) = smol::channel::unbounded::<()>();
 
-    // Checking that the first argument <DIRECTORY> is a valid directory
+    // Create an executor thread pool.
-    let file_path = matches.value_of(gemla::constants::args::FILE).unwrap();
+    let (_, result): (
-    let mut gemla = log_error(Gemla::<TestState>::new(
+        Vec<Result<(), smol::channel::RecvError>>,
-        &PathBuf::from(file_path),
+        Result<(), gemla::error::Error>,
-        GemlaConfig {
+    ) = easy_parallel::Parallel::new()
-            generations_per_node: 1,
+        .each(0..num_threads, |_| {
-            overwrite: false,
+            smol::future::block_on(ex.run(shutdown.recv()))
-        },
+        })
-    ))?;
+        .finish(|| {
+            smol::block_on(async {
+                drop(signal);
 
-    log_error(gemla.simulate(100).await)?;
+                // Command line arguments are parsed with the clap crate. And this program uses
+                // the yaml method with clap.
+                let yaml = load_yaml!("../../cli.yml");
+                let matches = App::from_yaml(yaml).get_matches();
 
-    // let mut f = std::fs::File::create("./test")?;
+                // Checking that the first argument <DIRECTORY> is a valid directory
-    // write!(f, "{}", serde_json::to_string(&gemla.data.readonly().0)?)?;
+                let file_path = matches.value_of(gemla::constants::args::FILE).unwrap();
+                let mut gemla = log_error(Gemla::<TestState>::new(
+                    &PathBuf::from(file_path),
+                    GemlaConfig {
+                        generations_per_node: 1,
+                        overwrite: false,
+                    },
+                ))?;
+
+                log_error(gemla.simulate(100).await)?;
+
+                Ok(())
+            })
+        });
+
+    result?;
 
     info!("Finished in {:?}", now.elapsed());
 

gemla/src/core/mod.rs

@@ -91,12 +91,8 @@ where
             if let Some(node) = node_to_process {
                 trace!("Adding node to process list {}", node.get_id());
 
-                // if self.threads.len() > 5 {
+                self.threads
-                //     self.join_threads().await?;
+                    .insert(node.get_id(), Box::pin(Gemla::process_node(node)));
-                // } else {
-                    self.threads
-                        .insert(node.get_id(), Box::pin(Gemla::process_node(node)));
-                // }
             } else {
                 trace!("No node found to process, joining threads");
 
@@ -130,7 +126,6 @@ where
 
                 Ok(())
             })?;
-    
         }
 
         Ok(())