From dae6454fb9ba33cda835ec30a14244e7e44ba014 Mon Sep 17 00:00:00 2001 From: Srinath Kailasa Date: Thu, 2 Jan 2025 22:45:40 +0000 Subject: [PATCH 1/2] Add direct benches --- kifmm/Cargo.toml | 8 ++ kifmm/benches/laplace_direct_f32.rs | 171 +++++++++++++++++++++++++++ kifmm/benches/laplace_direct_f64.rs | 175 ++++++++++++++++++++++++++++ 3 files changed, 354 insertions(+) create mode 100644 kifmm/benches/laplace_direct_f32.rs create mode 100644 kifmm/benches/laplace_direct_f64.rs diff --git a/kifmm/Cargo.toml b/kifmm/Cargo.toml index 7fc6a33a..8b6664e4 100644 --- a/kifmm/Cargo.toml +++ b/kifmm/Cargo.toml @@ -59,6 +59,14 @@ harness = false name = "laplace_f64" harness = false +[[bench]] +name = "laplace_direct_f64" +harness = false + +[[bench]] +name = "laplace_direct_f32" +harness = false + [package.metadata.docs.rs] cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"] rustdoc-args = [ "--html-in-header", "./src/docs-header.html" ] diff --git a/kifmm/benches/laplace_direct_f32.rs b/kifmm/benches/laplace_direct_f32.rs new file mode 100644 index 00000000..6114f7d6 --- /dev/null +++ b/kifmm/benches/laplace_direct_f32.rs @@ -0,0 +1,171 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; +use green_kernels::traits::Kernel; +use green_kernels::{laplace_3d::Laplace3dKernel, types::GreenKernelEvalType}; +use kifmm::tree::helpers::points_fixture; +use rlst::{rlst_dynamic_array2, RawAccess, RawAccessMut}; + +fn multithreaded_f32(c: &mut Criterion) { + let mut group = c.benchmark_group("Multi Threaded Direct f32"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 100000; + let ntargets = 100000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 500000; + let ntargets = 500000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +fn singlethreaded_f32(c: &mut Criterion) { + let mut group = c.benchmark_group("Single Threaded Direct f32"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 5000; + let ntargets = 5000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +criterion_group!(d_f32, multithreaded_f32, singlethreaded_f32); +criterion_main!(d_f32); \ No newline at end of file diff --git a/kifmm/benches/laplace_direct_f64.rs b/kifmm/benches/laplace_direct_f64.rs new file mode 100644 index 00000000..be2f9400 --- /dev/null +++ b/kifmm/benches/laplace_direct_f64.rs @@ -0,0 +1,175 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; +use green_kernels::traits::Kernel; +use green_kernels::{laplace_3d::Laplace3dKernel, types::GreenKernelEvalType}; +use kifmm::tree::helpers::points_fixture; +use rlst::{rlst_dynamic_array2, RawAccess, RawAccessMut}; + +extern crate blas_src; +extern crate lapack_src; + +fn multithreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Multi Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 100000; + let ntargets = 100000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 500000; + let ntargets = 500000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +fn singlethreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Single Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 5000; + let ntargets = 5000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![1.0; nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(f64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + + let kernel = Laplace3dKernel::new(); + + let mut result = rlst_dynamic_array2!(f64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +criterion_group!(d_f64, multithreaded_direct_f64, singlethreaded_direct_f64); + +criterion_main!(d_f64); \ No newline at end of file From 57e8b5df6fbd4aa2555b21da78a2e4bcebf700c1 Mon Sep 17 00:00:00 2001 From: Srinath Kailasa Date: Fri, 3 Jan 2025 10:22:13 +0000 Subject: [PATCH 2/2] Add benchmarks --- kifmm/Cargo.toml | 8 ++ kifmm/benches/helmholtz_direct_f32.rs | 179 ++++++++++++++++++++++++++ kifmm/benches/helmholtz_direct_f64.rs | 179 ++++++++++++++++++++++++++ kifmm/benches/laplace_direct_f64.rs | 2 - 4 files changed, 366 insertions(+), 2 deletions(-) create mode 100644 kifmm/benches/helmholtz_direct_f32.rs create mode 100644 kifmm/benches/helmholtz_direct_f64.rs diff --git a/kifmm/Cargo.toml b/kifmm/Cargo.toml index 8b6664e4..2f98c914 100644 --- a/kifmm/Cargo.toml +++ b/kifmm/Cargo.toml @@ -67,6 +67,14 @@ harness = false name = "laplace_direct_f32" harness = false +[[bench]] +name = "helmholtz_direct_f64" +harness = false + +[[bench]] +name = "helmholtz_direct_f32" +harness = false + [package.metadata.docs.rs] cargo-args = ["-Zunstable-options", "-Zrustdoc-scrape-examples"] rustdoc-args = [ "--html-in-header", "./src/docs-header.html" ] diff --git a/kifmm/benches/helmholtz_direct_f32.rs b/kifmm/benches/helmholtz_direct_f32.rs new file mode 100644 index 00000000..047ac11a --- /dev/null +++ b/kifmm/benches/helmholtz_direct_f32.rs @@ -0,0 +1,179 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; +use green_kernels::traits::Kernel; +use green_kernels::{helmholtz_3d::Helmholtz3dKernel, types::GreenKernelEvalType}; +use kifmm::tree::helpers::points_fixture; +use num::{Complex, One}; +use rlst::{c32, c64, rlst_dynamic_array2, RawAccess, RawAccessMut}; + + +fn multithreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Multi Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f32; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 100000; + let ntargets = 100000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber =1f32; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 500000; + let ntargets = 500000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f32; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +fn singlethreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Single Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 5000; + let ntargets = 5000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f32; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c32, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f32; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c32, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +criterion_group!(d_f64, multithreaded_direct_f64, singlethreaded_direct_f64); + +criterion_main!(d_f64); \ No newline at end of file diff --git a/kifmm/benches/helmholtz_direct_f64.rs b/kifmm/benches/helmholtz_direct_f64.rs new file mode 100644 index 00000000..c1f764c5 --- /dev/null +++ b/kifmm/benches/helmholtz_direct_f64.rs @@ -0,0 +1,179 @@ +use std::time::Duration; + +use criterion::{criterion_group, criterion_main, Criterion}; +use green_kernels::traits::Kernel; +use green_kernels::{helmholtz_3d::Helmholtz3dKernel, types::GreenKernelEvalType}; +use kifmm::tree::helpers::points_fixture; +use num::{Complex, One}; +use rlst::{c64, rlst_dynamic_array2, RawAccess, RawAccessMut}; + + +fn multithreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Multi Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f64; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 100000; + let ntargets = 100000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber =1f64; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 500000; + let ntargets = 500000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f64; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_mt( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +fn singlethreaded_direct_f64(c: &mut Criterion) { + let mut group = c.benchmark_group("Single Threaded Direct f64"); + + group + .sample_size(10) + .measurement_time(Duration::from_secs(15)); + + { + let nsources = 5000; + let ntargets = 5000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f64; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } + + { + let nsources = 20000; + let ntargets = 20000; + let sources = points_fixture::(nsources, None, None, Some(0)); + let targets = points_fixture::(ntargets, None, None, Some(1)); + + // FFT based M2L for a vector of charges + let nvecs = 1; + let tmp = vec![Complex::one(); nsources * nvecs]; + let mut charges = rlst_dynamic_array2!(c64, [nsources, nvecs]); + charges.data_mut().copy_from_slice(&tmp); + let wavenumber = 1f64; + + let kernel = Helmholtz3dKernel::new(wavenumber); + + let mut result = rlst_dynamic_array2!(c64, [nsources, nvecs]); + + group.bench_function(format!("N={nsources}"), |b| { + b.iter(|| { + kernel.evaluate_st( + GreenKernelEvalType::Value, + sources.data(), + targets.data(), + charges.data(), + result.data_mut(), + ) + }) + }); + } +} + +criterion_group!(d_f64, multithreaded_direct_f64, singlethreaded_direct_f64); + +criterion_main!(d_f64); \ No newline at end of file diff --git a/kifmm/benches/laplace_direct_f64.rs b/kifmm/benches/laplace_direct_f64.rs index be2f9400..98b03822 100644 --- a/kifmm/benches/laplace_direct_f64.rs +++ b/kifmm/benches/laplace_direct_f64.rs @@ -6,8 +6,6 @@ use green_kernels::{laplace_3d::Laplace3dKernel, types::GreenKernelEvalType}; use kifmm::tree::helpers::points_fixture; use rlst::{rlst_dynamic_array2, RawAccess, RawAccessMut}; -extern crate blas_src; -extern crate lapack_src; fn multithreaded_direct_f64(c: &mut Criterion) { let mut group = c.benchmark_group("Multi Threaded Direct f64");