moonlab 1.2.0

Safe, idiomatic Rust bindings for the Moonlab quantum simulator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

//! Concurrency-ceiling binding parity (v0.9.0).  Confirms the
//! wrapper method drives the new C API and that the cap is observed
//! end-to-end by scraping METRICS.

use moonlab::control_plane::{submit_circuit, submit_metrics, ControlPlaneServer};
use moonlab::qgtl::{GateType, QgtlCircuit};
use std::sync::{mpsc, Arc, Barrier};
use std::thread;

#[test]
fn set_max_concurrent_via_wrapper() {
    let srv = ControlPlaneServer::open("127.0.0.1", 0).unwrap();
    srv.set_max_concurrent(4).expect("set_max_concurrent");
    drop(srv);
}

#[test]
fn cap_rejects_some_of_six_parallel() {
    let srv = ControlPlaneServer::open("127.0.0.1", 0).unwrap();
    srv.set_max_concurrent(2).expect("set_max_concurrent");
    let port = srv.port();

    let mut c = QgtlCircuit::new(2).unwrap();
    c.add_gate(GateType::H, 0, -1, &[]).unwrap();
    c.add_gate(GateType::Cnot, 1, 0, &[]).unwrap();
    let text = c.serialize().unwrap();

    let (tx, rx) = mpsc::channel();
    /* Barrier ensures all 6 threads connect within microseconds of
     * each other.  Without it, threads can serialise: the first
     * submission completes before the second connects, so the cap
     * is never observed and the test flakes.  With the barrier, all
     * 6 are guaranteed in-flight simultaneously, forcing at least
     * (6 - cap) rejections. */
    let barrier = Arc::new(Barrier::new(6));
    for _ in 0..6 {
        let tx = tx.clone();
        let text = text.clone();
        let barrier = barrier.clone();
        thread::spawn(move || {
            barrier.wait();
            let r = submit_circuit("127.0.0.1", port, &text);
            tx.send(r.is_ok()).unwrap();
        });
    }
    let mut ok = 0;
    let mut denied = 0;
    for _ in 0..6 {
        if rx.recv().unwrap() { ok += 1; } else { denied += 1; }
    }
    assert_eq!(ok + denied, 6);
    assert!(denied >= 1, "cap=2 with 6 parallel must reject some");

    let body = submit_metrics("127.0.0.1", port).expect("METRICS scrape");
    let counter_line = body
        .lines()
        .find(|line| line.starts_with("moonlab_control_max_concurrent_rejected_total "))
        .expect("counter present");
    let value: u64 = counter_line
        .split_whitespace()
        .last()
        .unwrap()
        .parse()
        .unwrap();
    assert!(value >= denied as u64, "counter={value}, denied={denied}");
    drop(srv);
}