i have solved the interrupt problem

Author: krukah

src/lib.rs

@@ -18,6 +18,10 @@ pub use gameplay::*;
 pub use mccfr::*;
 pub use transport::*;
 pub use wasm::*;
+
+#[cfg(feature = "native")]
+static INTERRUPTED: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false);
+
 /// dimensional analysis types
 type Chips = i16;
 type Equity = f32;
@@ -53,7 +57,7 @@ const CFR_TREE_COUNT_RPS: usize = 8192;
 
 // nlhe mccfr parameters
 const CFR_BATCH_SIZE_NLHE: usize = 64;
-const CFR_TREE_COUNT_NLHE: usize = 0x10000;
+const CFR_TREE_COUNT_NLHE: usize = 0x1000000;
 
 /// profile average sampling parameters
 const SAMPLING_THRESHOLD: Entropy = 1.0;
@@ -74,7 +78,7 @@ pub struct Args {
     pub cluster: bool,
     /// Run the MCCFR training
     #[arg(long)]
-    pub solve: bool,
+    pub trainer: bool,
     /// Publish results to the database
     #[arg(long)]
     pub publish: bool,
@@ -100,15 +104,9 @@ pub fn progress(n: usize) -> indicatif::ProgressBar {
     progress
 }
 
-/// initialize logging and exit on ctrl-c
+/// initialize logging and setup graceful interrupt listener
 #[cfg(feature = "native")]
-pub fn init() {
-    tokio::spawn(async move {
-        tokio::signal::ctrl_c().await.unwrap();
-        println!();
-        log::warn!("forcing exit");
-        std::process::exit(0);
-    });
+pub fn logs() {
     std::fs::create_dir_all("logs").expect("create logs directory");
     let config = simplelog::ConfigBuilder::new()
         .set_location_level(log::LevelFilter::Off)
@@ -145,3 +143,31 @@ pub async fn db() -> std::sync::Arc<tokio_postgres::Client> {
     tokio::spawn(connection);
     std::sync::Arc::new(client)
 }
+
+#[cfg(feature = "native")]
+/// keyboard interruption for training
+/// spawn a thread to listen for 'q' input to gracefully interrupt training
+pub fn interrupts() {
+    // handle ctrl+c for immediate exit
+    tokio::spawn(async move {
+        tokio::signal::ctrl_c().await.unwrap();
+        println!();
+        log::warn!("Ctrl+C received, exiting immediately");
+        std::process::exit(0);
+    });
+    // handle 'q' input for graceful interrupt
+    std::thread::spawn(|| {
+        log::info!("training started. type 'Q + Enter' to gracefully interrupt.");
+        let ref mut buffer = String::new();
+        loop {
+            buffer.clear();
+            if let Ok(_) = std::io::stdin().read_line(buffer) {
+                if buffer.trim().to_uppercase() == "Q" {
+                    log::warn!("graceful interrupt requested, finishing current batch...");
+                    INTERRUPTED.store(true, std::sync::atomic::Ordering::Relaxed);
+                    break;
+                }
+            }
+        }
+    });
+}

src/main.rs

@@ -3,17 +3,19 @@ use robopoker::*;
 
 #[tokio::main]
 async fn main() {
-    crate::init();
-    if crate::Args::parse().cluster {
+    crate::logs();
+    crate::interrupts();
+    let ref arguments = crate::Args::parse();
+    if arguments.cluster {
         crate::clustering::Layer::learn();
     }
-    if crate::Args::parse().solve {
+    if arguments.trainer {
         crate::mccfr::NLHE::train();
     }
-    if crate::Args::parse().publish {
+    if arguments.publish {
         crate::save::Writer::publish().await.unwrap();
     }
-    if crate::Args::parse().analyze {
+    if arguments.analyze {
         crate::analysis::Server::run().await.unwrap();
     }
 }

src/mccfr/traits/blueprint.rs

@@ -8,6 +8,9 @@ use crate::mccfr::structs::infoset::InfoSet;
 use crate::mccfr::structs::tree::Tree;
 use crate::mccfr::types::counterfactual::Counterfactual;
 
+#[cfg(feature = "native")]
+use crate::INTERRUPTED;
+
 /// given access to a Profile and Encoder,
 /// we enapsulate the process of
 /// 1) sampling Trees
@@ -58,18 +61,30 @@ pub trait Blueprint: Send + Sync {
     where
         Self: Sized,
     {
-        let t = Self::iterations();
-        log::info!("beginning training loop ({})", t);
-        for _ in 0..t {
+        'training: for _ in 0..Self::iterations() {
             for ref update in self.batch() {
                 self.update_regret(update);
                 self.update_weight(update);
             }
-            self.advance();
+            if self.interrupted() {
+                break 'training;
+            }
         }
         self
     }
 
+    /// handles interrupt for training process
+    fn interrupted(&mut self) -> bool {
+        if INTERRUPTED.load(std::sync::atomic::Ordering::Relaxed) {
+            let t = self.profile().epochs();
+            log::warn!("training interrupted @ {}", t);
+            true
+        } else {
+            self.advance();
+            false
+        }
+    }
+
     /// Updates accumulated regret values for each edge in the counterfactual.
     fn update_regret(&mut self, cfr: &Counterfactual<Self::E, Self::I>) {
         let ref info = cfr.0.clone();