arnaucube/poulpy
1
0
Fork 0
mirror of https://github.com/arnaucube/poulpy.git synced 2026-02-10 05:06:44 +01:00
Code Issues Packages Projects Releases Wiki Activity

fmt

Browse Source
This commit is contained in:
Jean-Philippe Bossuat
2025-01-06 14:10:28 +01:00
parent 681268c28e
commit a074886b3e
29 changed files with 1650 additions and 928 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
math/benches/ntt.rs
View File

@@ -1,31 +1,25 @@
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use math::{modulus::prime::Prime,dft::ntt::Table};
use math::dft::DFT;
use math::{dft::ntt::Table, modulus::prime::Prime};
fn forward_inplace(c: &mut Criterion) {
fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
for i in 0..a.len(){
for i in 0..a.len() {
a[i] = i as u64;
}
Box::new(move || {
ntt_table.forward_inplace::<false>(&mut a)
})
Box::new(move || ntt_table.forward_inplace::<false>(&mut a))
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("forward_inplace");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("forward_inplace");
for log_nth_root in 11..18 {
let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
let runners = [
("prime", {
runner(prime_instance, 1<<log_nth_root)
}),
];
let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })];
for (name, mut runner) in runners {
let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
let id = BenchmarkId::new(name, 1 << (log_nth_root - 1));
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
}
}
@@ -35,26 +29,20 @@ fn forward_inplace_lazy(c: &mut Criterion) {
fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
for i in 0..a.len(){
for i in 0..a.len() {
a[i] = i as u64;
}
Box::new(move || {
ntt_table.forward_inplace_lazy(&mut a)
})
Box::new(move || ntt_table.forward_inplace_lazy(&mut a))
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("forward_inplace_lazy");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("forward_inplace_lazy");
for log_nth_root in 11..17 {
let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
let runners = [
("prime", {
runner(prime_instance, 1<<log_nth_root)
}),
];
let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })];
for (name, mut runner) in runners {
let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
let id = BenchmarkId::new(name, 1 << (log_nth_root - 1));
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
}
}
@@ -64,26 +52,20 @@ fn backward_inplace(c: &mut Criterion) {
fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
for i in 0..a.len(){
for i in 0..a.len() {
a[i] = i as u64;
}
Box::new(move || {
ntt_table.backward_inplace::<false>(&mut a)
})
Box::new(move || ntt_table.backward_inplace::<false>(&mut a))
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("backward_inplace");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("backward_inplace");
for log_nth_root in 11..18 {
let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
let runners = [
("prime", {
runner(prime_instance, 1<<log_nth_root)
}),
];
let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })];
for (name, mut runner) in runners {
let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
let id = BenchmarkId::new(name, 1 << (log_nth_root - 1));
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
}
}
@@ -93,30 +75,30 @@ fn backward_inplace_lazy(c: &mut Criterion) {
fn runner(prime_instance: Prime<u64>, nth_root: u64) -> Box<dyn FnMut()> {
let ntt_table: Table<u64> = Table::<u64>::new(prime_instance, nth_root);
let mut a: Vec<u64> = vec![0; (nth_root >> 1) as usize];
for i in 0..a.len(){
for i in 0..a.len() {
a[i] = i as u64;
}
Box::new(move || {
ntt_table.backward_inplace::<true>(&mut a)
})
Box::new(move || ntt_table.backward_inplace::<true>(&mut a))
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("backward_inplace_lazy");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("backward_inplace_lazy");
for log_nth_root in 11..17 {
let prime_instance: Prime<u64> = Prime::<u64>::new(0x1fffffffffe00001, 1);
let runners = [
("prime", {
runner(prime_instance, 1<<log_nth_root)
}),
];
let runners = [("prime", { runner(prime_instance, 1 << log_nth_root) })];
for (name, mut runner) in runners {
let id = BenchmarkId::new(name, 1<<(log_nth_root-1));
let id = BenchmarkId::new(name, 1 << (log_nth_root - 1));
b.bench_with_input(id, &(), |b, _| b.iter(&mut runner));
}
}
}
criterion_group!(benches, forward_inplace, forward_inplace_lazy, backward_inplace, backward_inplace_lazy);
criterion_group!(
benches,
forward_inplace,
forward_inplace_lazy,
backward_inplace,
backward_inplace_lazy
);
criterion_main!(benches);

62
math/benches/operations.rs
View File

@@ -1,16 +1,15 @@
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use math::ring::Ring;
use math::modulus::VectorOperations;
use math::modulus::montgomery::Montgomery;
use math::modulus::VectorOperations;
use math::modulus::ONCE;
use math::ring::Ring;
use math::CHUNK;
fn va_add_vb_into_vb(c: &mut Criterion) {
fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
let mut p0: math::poly::Poly<u64> = r.new_poly();
let mut p1: math::poly::Poly<u64> = r.new_poly();
for i in 0..p0.n(){
for i in 0..p0.n() {
p0.0[i] = i as u64;
p1.0[i] = i as u64;
}
@@ -19,18 +18,14 @@ fn va_add_vb_into_vb(c: &mut Criterion) {
})
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("va_add_vb_into_vb");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("va_add_vb_into_vb");
for log_n in 11..17 {
let n: usize = 1<<log_n as usize;
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)
}),
];
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));
@@ -40,30 +35,26 @@ fn va_add_vb_into_vb(c: &mut Criterion) {
fn va_mont_mul_vb_into_vb(c: &mut Criterion) {
fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
let mut p0: math::poly::Poly<Montgomery<u64>> = r.new_poly();
let mut p1: math::poly::Poly<u64> = r.new_poly();
for i in 0..p0.n(){
for i in 0..p0.n() {
p0.0[i] = r.modulus.montgomery.prepare::<ONCE>(i as u64);
p1.0[i] = i as u64;
}
Box::new(move || {
r.modulus.va_mont_mul_vb_into_vb::<CHUNK, ONCE>(&p0.0, &mut p1.0);
r.modulus
.va_mont_mul_vb_into_vb::<CHUNK, ONCE>(&p0.0, &mut p1.0);
})
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("va_mont_mul_vb_into_vb");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("va_mont_mul_vb_into_vb");
for log_n in 11..17 {
let n: usize = 1<<log_n as usize;
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)
}),
];
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));
@@ -73,31 +64,27 @@ fn va_mont_mul_vb_into_vb(c: &mut Criterion) {
fn va_mont_mul_vb_into_vc(c: &mut Criterion) {
fn runner(r: Ring<u64>) -> Box<dyn FnMut()> {
let mut p0: math::poly::Poly<Montgomery<u64>> = r.new_poly();
let mut p1: math::poly::Poly<u64> = r.new_poly();
let mut p2: math::poly::Poly<u64> = r.new_poly();
for i in 0..p0.n(){
for i in 0..p0.n() {
p0.0[i] = r.modulus.montgomery.prepare::<ONCE>(i as u64);
p1.0[i] = i as u64;
}
Box::new(move || {
r.modulus.va_mont_mul_vb_into_vc::<CHUNK,ONCE>(&p0.0, & p1.0, &mut p2.0);
r.modulus
.va_mont_mul_vb_into_vc::<CHUNK, ONCE>(&p0.0, &p1.0, &mut p2.0);
})
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("va_mont_mul_vb_into_vc");
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> =
c.benchmark_group("va_mont_mul_vb_into_vc");
for log_n in 11..17 {
let n: usize = 1<<log_n as usize;
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)
}),
];
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));
@@ -105,5 +92,10 @@ fn va_mont_mul_vb_into_vc(c: &mut Criterion) {
}
}
criterion_group!(benches, va_add_vb_into_vb, va_mont_mul_vb_into_vb, va_mont_mul_vb_into_vc);
criterion_group!(
benches,
va_add_vb_into_vb,
va_mont_mul_vb_into_vb,
va_mont_mul_vb_into_vc
);
criterion_main!(benches);

30
math/benches/ring_rns.rs
View File

@@ -1,33 +1,33 @@
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use math::ring::{Ring, RingRNS};
use math::ring::impl_u64::ring_rns::new_rings;
use math::poly::PolyRNS;
use math::ring::impl_u64::ring_rns::new_rings;
use math::ring::{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: PolyRNS<u64> = r.new_polyrns();
let mut c: PolyRNS<u64> = r.new_polyrns();
Box::new(move || {
r.div_floor_by_last_modulus::<true>(&a, &mut b, &mut c)
})
Box::new(move || r.div_floor_by_last_modulus::<true>(&a, &mut b, &mut c))
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("div_floor_by_last_modulus_ntt_true");
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 n = 1 << log_n;
let moduli: Vec<u64> = vec![
0x1fffffffffe00001u64,
0x1fffffffffc80001u64,
0x1fffffffffb40001,
0x1fffffffff500001,
];
let rings: Vec<Ring<u64>> = new_rings(n, moduli);
let ring_rns: RingRNS<'_, u64> = RingRNS::new(&rings);
let runners = [
(format!("prime/n={}/level={}", n, ring_rns.level()), {
runner(ring_rns)
}),
];
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));

28
math/benches/sampling.rs
View File

@@ -1,14 +1,13 @@
use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
use math::ring::{Ring, RingRNS};
use math::ring::impl_u64::ring_rns::new_rings;
use math::poly::PolyRNS;
use math::ring::impl_u64::ring_rns::new_rings;
use math::ring::{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 seed: [u8; 32] = [0; 32];
let mut source: Source = Source::new(seed);
Box::new(move || {
@@ -16,19 +15,22 @@ fn fill_uniform(c: &mut Criterion) {
})
}
let mut b: criterion::BenchmarkGroup<'_, criterion::measurement::WallTime> = c.benchmark_group("fill_uniform");
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 n = 1 << log_n;
let moduli: Vec<u64> = vec![
0x1fffffffffe00001u64,
0x1fffffffffc80001u64,
0x1fffffffffb40001,
0x1fffffffff500001,
];
let rings: Vec<Ring<u64>> = new_rings(n, moduli);
let ring_rns: RingRNS<'_, u64> = RingRNS::new(&rings);
let runners = [
(format!("prime/n={}/level={}", n, ring_rns.level()), {
runner(ring_rns)
}),
];
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));