paulistrings 0.1.2

Classical simulation of quantum circuits in the Pauli basis, parallel across threads, NUMA domains, MPI ranks and GPUs
Documentation 
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
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use super::*;
use crate::test_support::{and, or, rand_sum_real, LoggingTransport};
use crate::truncation::BuiltinTruncation as T;
use crate::TruncationPolicy;

/// A one-rank group whose `allreduce_sum_u64` calls are counted.
fn one_rank() -> LoggingTransport {
    LoggingTransport::group(1).pop().expect("one rank")
}

fn reductions(t: &LoggingTransport) -> usize {
    t.log.count("allreduce_sum_u64")
}

fn part(input: &crate::PauliSum<1>, tree: &T) -> DevicePartition<1> {
    let mut part = DevicePartition::new(
        GpuSum::from_host(input, 0).expect("upload"),
        GpuLayerOptions::default(),
    )
    .expect("partition");
    part.keep = KeepProgram::lower(tree).expect("lower");
    part
}

/// A device layer pass issues one reduction per reached `ApproxTopN`, as the host's collective form does above one partition, and keeps the host's terms.
#[test]
fn a_layer_pass_issues_the_hosts_collectives() {
    crate::require_cuda!();
    let input = rand_sum_real::<1>(4000, 32, 0xC011);
    let cases = [
        (T::ApproxTopN(1000), 1),
        (and(T::Coefficient(1e-3), T::ApproxTopN(1000)), 1),
        (and(T::ApproxTopN(2000), T::ApproxTopN(500)), 2),
        (or(T::Weight(10), T::Coefficient(1e-3)), 0),
    ];
    for (tree, want) in cases {
        let device = one_rank();
        let mut part = part(&input, &tree);
        PartitionBackend::<1, T>::finalize_layer(&mut part, &tree, &device);
        part.take_error().expect("device layer pass");
        let mut want_sum = input.clone();
        <T as TruncationPolicy<1>>::finalize_layer(&tree, &mut want_sum);
        assert_eq!(reductions(&device), want, "{tree:?}: device");
        assert_eq!(part.len(), want_sum.len(), "{tree:?}: len");
        assert_eq!(
            part.sum().to_host().unwrap().to_arrays(),
            want_sum.to_arrays(),
            "{tree:?}: terms"
        );
    }
}

/// Exact `TopN` on a lone device partition (`group_size == 1`) issues no collective at all, unlike `ApproxTopN`, and keeps the host's terms exactly — alone and composed with `And`/`Or`.
#[test]
fn a_lone_partition_runs_exact_topn_with_no_collective() {
    crate::require_cuda!();
    use crate::truncation::TopN;
    let input = rand_sum_real::<1>(4000, 32, 0xC012);
    let cases = [
        T::TopN(1000),
        and(T::Coefficient(1e-3), T::TopN(1000)),
        and(T::TopN(2000), T::Weight(20)),
        and(T::TopN(1000), or(T::Weight(10), T::Coefficient(1e-3))),
    ];
    for tree in cases {
        let device = one_rank();
        let mut part = part(&input, &tree);
        PartitionBackend::<1, T>::finalize_layer(&mut part, &tree, &device);
        part.take_error().expect("device layer pass");
        assert_eq!(reductions(&device), 0, "{tree:?}: exact TopN has no collective form");
        let mut want_sum = input.clone();
        <T as TruncationPolicy<1>>::finalize_layer(&tree, &mut want_sum);
        assert_eq!(part.len(), want_sum.len(), "{tree:?}: len");
        assert_eq!(
            part.sum().to_host().unwrap().to_arrays(),
            want_sum.to_arrays(),
            "{tree:?}: terms"
        );
    }
    // Sanity: `TopN` alone actually truncates against this input.
    let mut sanity = input.clone();
    TopN(1000).finalize_layer(&mut sanity);
    assert_eq!(sanity.len(), 1000);
}

/// A group member (`group_size > 1`) reports `Unsupported` on an exact `TopN` rather than run a wrong local selection.
#[test]
fn a_group_member_rejects_exact_topn() {
    crate::require_cuda!();
    let input = rand_sum_real::<1>(500, 32, 0xC013);
    let tree = T::TopN(100);
    let mut part = part(&input, &tree);
    part.group_size = 2;
    PartitionBackend::<1, T>::finalize_layer(&mut part, &tree, &one_rank());
    assert!(matches!(part.take_error(), Err(GpuError::Unsupported(_))));
}

/// A partition that already failed still enters every reduction, so a group cannot fall out of step on one device's error.
#[test]
fn a_failed_partition_still_enters_the_reduction() {
    crate::require_cuda!();
    let input = rand_sum_real::<1>(500, 32, 0xFA11);
    let tree = and(T::ApproxTopN(100), T::ApproxTopN(50));
    let mut part = part(&input, &tree);
    part.error = Some(GpuError::Unsupported("injected"));
    let group = one_rank();
    PartitionBackend::<1, T>::finalize_layer(&mut part, &tree, &group);
    assert_eq!(reductions(&group), 2);
    assert!(matches!(part.take_error(), Err(GpuError::Unsupported("injected"))));
    assert_eq!(part.len(), input.len(), "a failed partition keeps its terms");
}