Merge pull request #22 from jlapeyre/gjl-allow-clear-cache

Support clearing caches and running tests serially
    
    * The diophantine solver uses static caches. For reproducibility and other
      reasons we need to be able to clear these caches.
    
    * In any case, code, including tests that use static caches can't be run
      concurrently, without incorrect results. We need to run some of these tests serially.
    
    The commit adds `clear_caches`, and introduces a dependency on `serial_test`.
    These are both tested in the test suite.

Author: jlapeyre

Cargo.toml

@@ -34,6 +34,7 @@ log = "0.4"
 env_logger = "0.11"
 
 [dev-dependencies]
+serial_test = "*"
 
 [profile.release]
 opt-level = 3

src/diophantine.rs

@@ -838,6 +838,27 @@ fn diophantine(
 type DiophantineCacheType = LazyLock<Mutex<HashMap<(IBig, IBig), Option<DOmega>>>>;
 static DIOPHANTINE_CACHE: DiophantineCacheType = LazyLock::new(|| Mutex::new(HashMap::new()));
 
+pub fn clear_caches() {
+    if let Ok(mut cache) = PRIMALITY_CACHE.try_lock() {
+        cache.clear();
+    //        println!("cleared primality cache");
+    } else {
+        //        println!("Can't clear primality cache");
+    }
+    if let Ok(mut cache) = SQRT_CACHE.try_lock() {
+        cache.clear();
+        //        println!("cleared sqrt cache");
+    }
+    if let Ok(mut cache) = FACTOR_CACHE.try_lock() {
+        cache.clear();
+        //        println!("cleared factor cache");
+    }
+    if let Ok(mut cache) = DIOPHANTINE_CACHE.try_lock() {
+        cache.clear();
+        //        println!("cleared diophantine cache");
+    }
+}
+
 pub(crate) fn diophantine_dyadic(
     xi: DRootTwo,
     diophantine_data: &mut DiophantineData,

src/lib.rs

@@ -15,3 +15,5 @@ pub mod synthesis_of_clifford_t;
 pub mod tdgp;
 pub mod to_upright;
 pub mod unitary;
+
+pub use diophantine::clear_caches;

tests/integration_test.rs

@@ -1,41 +1,34 @@
+use rsgridsynth::clear_caches;
 use rsgridsynth::config::config_from_theta_epsilon;
 use rsgridsynth::gridsynth::gridsynth_gates;
+use serial_test::serial;
 
 #[test]
-#[ignore]
+#[serial]
 fn simple_test() {
     let pi = std::f64::consts::PI;
     let theta = pi / 8.0; // ≈ 0.39269908169872414
     let epsilon = 1e-10;
-    let seed = 1234;
-    let verbose = false;
-    let mut gridsynth_config = config_from_theta_epsilon(theta, epsilon, seed, verbose);
-    let gates = gridsynth_gates(&mut gridsynth_config);
-    let expected_gates = "HTHTSHTSHTHTSHTHTSHTHTHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTSHTHTSHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTHTHTSHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTHTSHTHTHTSHTSHTSHTHTSHTSHTHTSHTHTSHTSHTHTSHTHTHTSHTSHTSHTSHTHTHTHTSHTHTHTSHTHTSHTHTHTSHTHTSHTHTSHTXSSWWW";
-    assert_eq!(gates, expected_gates);
-}
 
-#[test]
-#[ignore]
-fn simple_test2() {
-    let pi = std::f64::consts::PI;
-    let theta = pi / 8.0; // ≈ 0.39269908169872414
-    let epsilon = 1e-10;
+    let gates_1234 = "HTHTSHTSHTHTSHTHTSHTHTHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTSHTHTSHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTHTHTSHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTHTSHTHTHTSHTSHTSHTHTSHTSHTHTSHTHTSHTSHTHTSHTHTHTSHTSHTSHTSHTHTHTHTSHTHTHTSHTHTSHTHTHTSHTHTSHTHTSHTXSSWWW";
+
+    let gates_101 = "HTSHTSHTSHTHTHTSHTHTHTSHTSHTHTHTHTHTHTSHTHTHTHTSHTSHTHTSHTHTHTHTHTHTHTHTSHTHTHTHTSHTHTSHTSHTSHTSHTHTSHTSHTHTSHTSHTHTSHTHTHTSHTSHTHTHTHTSHTHTSHTHTSHTHTHTSHTSHTHTHTHTHTSHTHTSHTSHTHTHTHTSHTHTHTSHTHTHTHTSHTHTSHTSHTHTSHTHTSHTHTHTHTHTHTHTHTSHTHTHTSHTSSSWW";
 
-    let gates1 = "HTHTSHTSHTHTSHTHTSHTHTHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTSHTHTSHTSHTSHTHTHTHTHTHTSHTSHTHTSHTSHTSHTHTHTSHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTSHTSHTSHTSHTSHTHTHTHTHTSHTHTSHTHTHTSHTSHTSHTHTSHTSHTHTSHTHTSHTSHTHTSHTHTHTSHTSHTSHTSHTHTHTHTSHTHTHTSHTHTSHTHTHTSHTHTSHTHTSHTXSSWWW";
+    let gates_1 = "HTSHTHTHTSHTHTHTHTHTHTHTHTSHTHTSHTHTSHTSHTHTSHTHTHTHTSHTHTHTSHTHTHTHTSHTSHTHTSHTHTHTHTHTSHTSHTHTHTSHTHTSHTHTSHTHTHTHTSHTSHTHTHTSHTHTSHTSHTHTSHTSHTHTSHTSHTSHTSHTHTSHTHTHTHTSHTHTHTHTHTHTHTHTSHTHTSHTSHTHTHTHTSHTHTHTHTHTHTSHTSHTHTHTSHTHTHTSHTSHTSHTSSSWW";
 
-    let test_inputs = vec![(1234, gates1), (101, gates1), (1, gates1)];
+    let test_inputs = vec![(1234, gates_1234), (101, gates_101), (1, gates_1)];
 
     let verbose = false;
     for (seed, expected_gates) in test_inputs {
+        clear_caches();
         let mut gridsynth_config = config_from_theta_epsilon(theta, epsilon, seed, verbose);
         let gates = gridsynth_gates(&mut gridsynth_config);
         assert_eq!(gates, expected_gates, "Test failed for seed: {}", seed);
     }
 }
 
-//#[ignore]
 #[test]
+#[serial]
 fn pi_over_two_test() {
     let pi = std::f64::consts::PI;
     let theta = pi / 2.0;
@@ -44,8 +37,9 @@ fn pi_over_two_test() {
 
     let verbose = false;
     for epsilon in epsilons {
-        let seeds = 100..300;
+        let seeds = 10..50;
         for seed in seeds {
+            clear_caches();
             let mut gridsynth_config = config_from_theta_epsilon(theta, epsilon, seed, verbose);
             let gates = gridsynth_gates(&mut gridsynth_config);
             let expected_gates = "SWWWWWWW";