Skip to content

Instantly share code, notes, and snippets.

@rust-play
Created December 2, 2019 13:45
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save rust-play/2becef5a620b5e45920c97516890b426 to your computer and use it in GitHub Desktop.
Save rust-play/2becef5a620b5e45920c97516890b426 to your computer and use it in GitHub Desktop.
Code shared from the Rust Playground
#![feature(test)]
extern crate test;
pub struct MatrixMulti(Vec<Vec<Vec<f32>>>);
impl MatrixMulti {
fn new() -> Self {
Self(vec![vec![vec![0f32; 64]; 64]; 64])
}
fn plus(&self, rhs: &Self) -> Self {
Self(
self.0
.iter()
.zip(rhs.0.iter())
.map(|(left, right)| {
left.iter()
.zip(right)
.map(|(left, right)| {
left.iter()
.zip(right)
.map(|(&left, &right)| left + right)
.collect()
})
.collect()
})
.collect(),
)
}
fn plus_into(&self, rhs: &Self, out: &mut Self) {
out.0
.iter_mut()
.zip(self.0.iter().zip(rhs.0.iter()))
.for_each(|(out, (left, right))| {
out.iter_mut()
.zip(left.iter().zip(right))
.for_each(|(out, (left, right))| {
out.iter_mut()
.zip(left.iter().zip(right))
.for_each(|(out, (&left, &right))| *out = left + right)
})
})
}
}
pub struct MatrixSingle(Vec<f32>);
impl MatrixSingle {
fn new() -> Self {
Self(vec![0f32; 64 * 64 * 64])
}
fn plus(&self, rhs: &Self) -> Self {
Self(
self.0
.iter()
.zip(rhs.0.iter())
.map(|(&left, &right)| left + right)
.collect(),
)
}
fn plus_into(&self, rhs: &Self, out: &mut Self) {
out.0
.iter_mut()
.zip(self.0.iter().zip(rhs.0.iter()))
.for_each(|(out, (&left, &right))| *out = left + right)
}
}
#[bench]
fn bench_multi(bencher: &mut test::Bencher) {
let mut a = MatrixMulti::new();
for (i, v) in a.0.iter_mut().enumerate() {
for (j, v) in v.iter_mut().enumerate() {
for (k, v) in v.iter_mut().enumerate() {
*v = (2.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (5.0f32).powf((k as f32) / 64.0);
}
}
}
let mut b = MatrixMulti::new();
for (i, v) in b.0.iter_mut().enumerate() {
for (j, v) in v.iter_mut().enumerate() {
for (k, v) in v.iter_mut().enumerate() {
*v = (5.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (2.0f32).powf((k as f32) / 64.0);
}
}
}
bencher.iter(|| test::black_box(test::black_box(&a).plus(test::black_box(&b))))
}
#[bench]
fn bench_single(bencher: &mut test::Bencher) {
let mut a = MatrixSingle::new();
for i in 0..64 {
for j in 0..64 {
for k in 0..64 {
(a.0)[i * 64 * 64 + j * 64 + k] = (2.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (5.0f32).powf((k as f32) / 64.0);
}
}
}
let mut b = MatrixSingle::new();
for i in 0..64 {
for j in 0..64 {
for k in 0..64 {
(b.0)[i * 64 * 64 + j * 64 + k] = (5.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (2.0f32).powf((k as f32) / 64.0);
}
}
}
bencher.iter(|| test::black_box(test::black_box(&a).plus(test::black_box(&b))))
}
#[bench]
fn bench_multi_into(bencher: &mut test::Bencher) {
let mut a = MatrixMulti::new();
for (i, v) in a.0.iter_mut().enumerate() {
for (j, v) in v.iter_mut().enumerate() {
for (k, v) in v.iter_mut().enumerate() {
*v = (2.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (5.0f32).powf((k as f32) / 64.0);
}
}
}
let mut b = MatrixMulti::new();
for (i, v) in b.0.iter_mut().enumerate() {
for (j, v) in v.iter_mut().enumerate() {
for (k, v) in v.iter_mut().enumerate() {
*v = (5.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (2.0f32).powf((k as f32) / 64.0);
}
}
}
let mut c = MatrixMulti::new();
bencher.iter(|| {
test::black_box(&mut a).plus_into(test::black_box(&mut b), test::black_box(&mut c));
test::black_box(&mut c);
})
}
#[bench]
fn bench_single_into(bencher: &mut test::Bencher) {
let mut a = MatrixSingle::new();
for i in 0..64 {
for j in 0..64 {
for k in 0..64 {
(a.0)[i * 64 * 64 + j * 64 + k] = (2.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (5.0f32).powf((k as f32) / 64.0);
}
}
}
let mut b = MatrixSingle::new();
for i in 0..64 {
for j in 0..64 {
for k in 0..64 {
(b.0)[i * 64 * 64 + j * 64 + k] = (5.0f32).powf((i as f32) / 64.0)
+ (3.0f32).powf((j as f32) / 64.0)
+ (2.0f32).powf((k as f32) / 64.0);
}
}
}
let mut c = MatrixSingle::new();
bencher.iter(|| {
test::black_box(&mut a).plus_into(test::black_box(&mut b), test::black_box(&mut c));
test::black_box(&mut c);
})
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment