mirror of
https://github.com/arnaucube/poulpy.git
synced 2026-02-10 13:16:44 +01:00
added spqlios as submodule
This commit is contained in:
Jean-Philippe Bossuat
103
rns/benches/ntt.rs
Normal file
103
rns/benches/ntt.rs
Normal file
@@ -0,0 +1,103 @@
|
||||
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
|
||||
use math::modulus::WordOps;
|
||||
use math::poly::Poly;
|
||||
use math::ring::Ring;
|
||||
|
||||
fn ntt(c: &mut Criterion) {
|
||||
fn runner<'a, const INPLACE: bool, const LAZY: bool>(
|
||||
ring: &'a Ring<u64>,
|
||||
) -> Box<dyn FnMut() + 'a> {
|
||||
let mut a: Poly<u64> = ring.new_poly();
|
||||
for i in 0..a.n() {
|
||||
a.0[i] = i as u64;
|
||||
}
|
||||
if INPLACE {
|
||||
Box::new(move || ring.ntt_inplace::<LAZY>(&mut a))
|
||||
} else {
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
Box::new(move || ring.ntt::<LAZY>(&a, &mut b))
|
||||
}
|
||||
}
|
||||
|
||||
let q: u64 = 0x1fffffffffe00001u64;
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("ntt");
|
||||
|
||||
for log_n in 10..17 {
|
||||
let ring = Ring::new(1 << log_n, q, 1);
|
||||
|
||||
let runners: [(String, Box<dyn FnMut()>); 4] = [
|
||||
(format!("inplace=true/LAZY=true/q={}", q.log2()), {
|
||||
runner::<true, true>(&ring)
|
||||
}),
|
||||
(format!("inplace=true/LAZY=false/q={}", q.log2()), {
|
||||
runner::<true, false>(&ring)
|
||||
}),
|
||||
(format!("inplace=false/LAZY=true/q={}", q.log2()), {
|
||||
runner::<false, true>(&ring)
|
||||
}),
|
||||
(format!("inplace=false/LAZY=false/q={}", q.log2()), {
|
||||
runner::<false, false>(&ring)
|
||||
}),
|
||||
];
|
||||
|
||||
for (name, mut runner) in runners {
|
||||
let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n));
|
||||
b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| {
|
||||
b.iter(&mut runner)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn intt(c: &mut Criterion) {
|
||||
fn runner<'a, const INPLACE: bool, const LAZY: bool>(
|
||||
ring: &'a Ring<u64>,
|
||||
) -> Box<dyn FnMut() + 'a> {
|
||||
let mut a: Poly<u64> = ring.new_poly();
|
||||
for i in 0..a.n() {
|
||||
a.0[i] = i as u64;
|
||||
}
|
||||
if INPLACE {
|
||||
Box::new(move || ring.intt_inplace::<LAZY>(&mut a))
|
||||
} else {
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
Box::new(move || ring.intt::<LAZY>(&a, &mut b))
|
||||
}
|
||||
}
|
||||
|
||||
let q: u64 = 0x1fffffffffe00001u64;
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("intt");
|
||||
|
||||
for log_n in 10..17 {
|
||||
let ring = Ring::new(1 << log_n, q, 1);
|
||||
|
||||
let runners: [(String, Box<dyn FnMut()>); 4] = [
|
||||
(format!("inplace=true/LAZY=true/q={}", q.log2()), {
|
||||
runner::<true, true>(&ring)
|
||||
}),
|
||||
(format!("inplace=true/LAZY=false/q={}", q.log2()), {
|
||||
runner::<true, false>(&ring)
|
||||
}),
|
||||
(format!("inplace=false/LAZY=true/q={}", q.log2()), {
|
||||
runner::<false, true>(&ring)
|
||||
}),
|
||||
(format!("inplace=false/LAZY=false/q={}", q.log2()), {
|
||||
runner::<false, false>(&ring)
|
||||
}),
|
||||
];
|
||||
|
||||
for (name, mut runner) in runners {
|
||||
let id: BenchmarkId = BenchmarkId::new(name, format!("n={}", 1 << log_n));
|
||||
b.bench_with_input(id, &(), |b: &mut criterion::Bencher<'_>, _| {
|
||||
b.iter(&mut runner)
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(benches, ntt, intt,);
|
||||
criterion_main!(benches);
|
||||
209
rns/benches/operations.rs
Normal file
209
rns/benches/operations.rs
Normal file
@@ -0,0 +1,209 @@
|
||||
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
|
||||
use math::modulus::montgomery::Montgomery;
|
||||
use math::modulus::{WordOps, ONCE};
|
||||
use math::poly::Poly;
|
||||
use math::ring::Ring;
|
||||
|
||||
fn a_add_b_into_b(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<u64> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = i as u64;
|
||||
b.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
ring.a_add_b_into_b::<ONCE>(&a, &mut b);
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_add_b_into_b");
|
||||
for log_n in 11..17 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let runners = [("prime", { runner(r) })];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn a_mul_b_montgomery_into_a(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<Montgomery<u64>> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = ring.modulus.montgomery.prepare::<ONCE>(i as u64);
|
||||
b.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
ring.a_mul_b_montgomery_into_a::<ONCE>(&a, &mut b);
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_mul_b_montgomery_into_a");
|
||||
for log_n in 11..17 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let runners = [("prime", { runner(r) })];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn a_mul_b_montgomery_into_c(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<Montgomery<u64>> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
let mut c: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = ring.modulus.montgomery.prepare::<ONCE>(i as u64);
|
||||
b.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
ring.a_mul_b_montgomery_into_c::<ONCE>(&a, &b, &mut c);
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_mul_b_montgomery_into_c");
|
||||
for log_n in 11..17 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let r: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let runners = [("prime", { runner(r) })];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn a_ith_digit_unsigned_base_scalar_b_into_c(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>, base: usize, d: usize) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<Montgomery<u64>> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
(0..d).for_each(|i| {
|
||||
ring.a_ith_digit_unsigned_base_scalar_b_into_c(i, &a, &base, &mut b);
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_ith_digit_unsigned_base_scalar_b_into_c");
|
||||
for log_n in 11..12 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let ring: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let base: usize = 7;
|
||||
let logq: usize = ring.modulus.q.log2();
|
||||
let d: usize = (logq + base - 1) / base;
|
||||
let runners = [(format!("prime/logq={}/w={}/d={}", logq, base, d), {
|
||||
runner(ring, base, d)
|
||||
})];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn a_ith_digit_signed_base_scalar_b_into_c_balanced_false(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>, base: usize, d: usize) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<Montgomery<u64>> = ring.new_poly();
|
||||
let mut carry: Poly<u64> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
(0..d).for_each(|i| {
|
||||
ring.a_ith_digit_signed_base_scalar_b_into_c::<false>(
|
||||
i, &a, &base, &mut carry, &mut b,
|
||||
);
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_ith_digit_signed_base_scalar_b_into_c::<BALANCED=false>");
|
||||
for log_n in 11..12 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let ring: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let base: usize = 7;
|
||||
let logq: usize = ring.modulus.q.log2();
|
||||
let d: usize = (logq + base - 1) / base;
|
||||
let runners = [(format!("prime/logq={}/w={}/d={}", logq, base, d), {
|
||||
runner(ring, base, d)
|
||||
})];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn a_ith_digit_signed_base_scalar_b_into_c_balanced_true(c: &mut Criterion) {
|
||||
fn runner(ring: Ring<u64>, base: usize, d: usize) -> Box<dyn FnMut()> {
|
||||
let mut a: Poly<Montgomery<u64>> = ring.new_poly();
|
||||
let mut carry: Poly<u64> = ring.new_poly();
|
||||
let mut b: Poly<u64> = ring.new_poly();
|
||||
for i in 0..ring.n() {
|
||||
a.0[i] = i as u64;
|
||||
}
|
||||
Box::new(move || {
|
||||
(0..d).for_each(|i| {
|
||||
ring.a_ith_digit_signed_base_scalar_b_into_c::<true>(
|
||||
i, &a, &base, &mut carry, &mut b,
|
||||
);
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("a_ith_digit_signed_base_scalar_b_into_c::<BALANCED=true>");
|
||||
for log_n in 11..12 {
|
||||
let n: usize = 1 << log_n as usize;
|
||||
let q_base: u64 = 0x1fffffffffe00001u64;
|
||||
let q_power: usize = 1usize;
|
||||
let ring: Ring<u64> = Ring::<u64>::new(n, q_base, q_power);
|
||||
let base: usize = 7;
|
||||
let logq: usize = ring.modulus.q.log2();
|
||||
let d: usize = (logq + base - 1) / base;
|
||||
let runners = [(format!("prime/logq={}/w={}/d={}", logq, base, d), {
|
||||
runner(ring, base, d)
|
||||
})];
|
||||
for (name, mut runner) in runners {
|
||||
let id = BenchmarkId::new(name, n);
|
||||
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
a_add_b_into_b,
|
||||
a_mul_b_montgomery_into_a,
|
||||
a_mul_b_montgomery_into_c,
|
||||
a_ith_digit_unsigned_base_scalar_b_into_c,
|
||||
a_ith_digit_signed_base_scalar_b_into_c_balanced_false,
|
||||
a_ith_digit_signed_base_scalar_b_into_c_balanced_true,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
38
rns/benches/ring_rns.rs
Normal file
38
rns/benches/ring_rns.rs
Normal file
@@ -0,0 +1,38 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use math::poly::PolyRNS;
|
||||
use math::ring::RingRNS;
|
||||
|
||||
fn div_floor_by_last_modulus_ntt_true(c: &mut Criterion) {
|
||||
fn runner(r: RingRNS<u64>) -> Box<dyn FnMut()> {
|
||||
let a: PolyRNS<u64> = r.new_polyrns();
|
||||
let mut b: [math::poly::Poly<u64>; 2] = [r.new_poly(), r.new_poly()];
|
||||
let mut c: PolyRNS<u64> = r.new_polyrns();
|
||||
|
||||
Box::new(move || r.div_by_last_modulus::<false, true>(&a, &mut b, &mut c))
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("div_floor_by_last_modulus_ntt_true");
|
||||
for log_n in 11..18 {
|
||||
let n = 1 << log_n;
|
||||
let moduli: Vec<u64> = vec![
|
||||
0x1fffffffffe00001u64,
|
||||
0x1fffffffffc80001u64,
|
||||
0x1fffffffffb40001,
|
||||
0x1fffffffff500001,
|
||||
];
|
||||
|
||||
let ring_rns: RingRNS<u64> = RingRNS::new(n, moduli);
|
||||
|
||||
let runners = [(format!("prime/n={}/level={}", n, ring_rns.level()), {
|
||||
runner(ring_rns)
|
||||
})];
|
||||
|
||||
for (name, mut runner) in runners {
|
||||
b.bench_with_input(name, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(benches, div_floor_by_last_modulus_ntt_true);
|
||||
criterion_main!(benches);
|
||||
41
rns/benches/sampling.rs
Normal file
41
rns/benches/sampling.rs
Normal file
@@ -0,0 +1,41 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use math::poly::PolyRNS;
|
||||
use math::ring::RingRNS;
|
||||
use sampling::source::Source;
|
||||
|
||||
fn fill_uniform(c: &mut Criterion) {
|
||||
fn runner(r: RingRNS<u64>) -> Box<dyn FnMut()> {
|
||||
let mut a: PolyRNS<u64> = r.new_polyrns();
|
||||
let seed: [u8; 32] = [0; 32];
|
||||
let mut source: Source = Source::new(seed);
|
||||
|
||||
Box::new(move || {
|
||||
r.fill_uniform(&mut source, &mut a);
|
||||
})
|
||||
}
|
||||
|
||||
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
|
||||
c.benchmark_group("fill_uniform");
|
||||
for log_n in 11..18 {
|
||||
let n = 1 << log_n;
|
||||
let moduli: Vec<u64> = vec![
|
||||
0x1fffffffffe00001u64,
|
||||
0x1fffffffffc80001u64,
|
||||
0x1fffffffffb40001,
|
||||
0x1fffffffff500001,
|
||||
];
|
||||
|
||||
let ring_rns: RingRNS<u64> = RingRNS::new(n, moduli);
|
||||
|
||||
let runners = [(format!("prime/n={}/level={}", n, ring_rns.level()), {
|
||||
runner(ring_rns)
|
||||
})];
|
||||
|
||||
for (name, mut runner) in runners {
|
||||
b.bench_with_input(name, &(), |b, _| b.iter(&mut runner));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(benches, fill_uniform);
|
||||
criterion_main!(benches);
|
||||
Reference in New Issue
Block a user