#[cfg(target_arch = "x86_64")]
mod run {
use corundum::measure;
use corundum::default::{*, Journal};
use corundum::stat::*;
use corundum::open_flags::*;
use corundum::stm::{Log, Logger, Notifier};
type P = Allocator;
const CNT: usize = 50000;
macro_rules! datalog {
($cnt:expr,$s:expr) => {
P::transaction(|j| unsafe {
let mut bvec = Vec::with_capacity($cnt);
for _ in 0..$cnt {
bvec.push(Pbox::new([0u8;$s], j));
}
for i in 0..$cnt {
let m = &*bvec[i];
measure!(format!("DataLog({})", $s), {
m.create_log(j, Notifier::None);
});
}
j.ignore();
}).unwrap();
};
}
fn main() {
use std::env;
use std::vec::Vec as StdVec;
let args: StdVec<String> = env::args().collect();
if args.len() < 2 {
println!("usage: {} file-name", args[0]);
return;
}
let sizes = vec![512, 128, 32, 8, 1];
struct Root {
bx: PRefCell<PVec<Option<Pbox<i32>>>>,
rc: PRefCell<PVec<Option<Prc<i32>>>>,
arc: PRefCell<PVec<Option<Parc<i32>>>>,
}
impl RootObj<P> for Root {
fn init(j: &Journal) -> Self {
let mut b = PVec::with_capacity(CNT, j);
for _ in 0..CNT {
b.push(None, j);
}
let mut r = PVec::with_capacity(CNT, j);
for _ in 0..CNT {
r.push(None, j);
}
let mut a = PVec::with_capacity(CNT, j);
for _ in 0..CNT {
a.push(None, j);
}
Self {
bx: PRefCell::new(b),
rc: PRefCell::new(r),
arc: PRefCell::new(a),
}
}
}
let root = P::open::<Root>(&args[1], O_CF | O_32GB).unwrap();
let cnt = CNT;
for _ in 0..cnt {
let s = 8 + rand::random::<usize>() % 5000;
unsafe { P::alloc(s); }
}
for _ in 0..cnt {
measure!("TxNop".to_string(), {
P::transaction(|_| {unsafe { asm!("nop"); }}).unwrap();
});
}
for s in &sizes {
let s = *s * 8;
let mut vec = Vec::with_capacity(cnt);
for _ in 0..cnt {
vec.push(measure!(format!("Alloc({})", s), {
unsafe{ P::alloc(s) }
}));
}
for i in 0..cnt {
measure!(format!("Dealloc({})", s), {
unsafe{ P::dealloc(vec[i].0, s); }
});
}
}
{
let b = &*root.bx.borrow();
for i in 0..cnt {
let b = &b[i];
measure!("Pbox:AtomicInit".to_string(), {
Pbox::initialize(b, 10)
}).unwrap();
}
let r = &*root.rc.borrow();
for i in 0..cnt {
let r = &r[i];
measure!("Prc:AtomicInit".to_string(), {
Prc::initialize(r, 10)
}).unwrap();
}
let a = &*root.arc.borrow();
for i in 0..cnt {
let a = &a[i];
measure!("Parc:AtomicInit".to_string(), {
Parc::initialize(a, 10)
}).unwrap();
}
}
for _ in 0 .. CNT/50 {
let cnt = 50;
P::transaction(|j| {
let mut bvec = Vec::with_capacity(cnt);
for _ in 0..cnt {
bvec.push(Pbox::new(PRefCell::new(10), j));
}
let mut pvec = Vec::with_capacity(cnt);
for i in 0..cnt {
pvec.push(bvec[i].borrow_mut(j));
}
for i in 0..cnt {
measure!("DerefMut(1st)".to_string(), {
*pvec[i] = 20;
});
}
}).unwrap();
P::transaction(|j| {
let b = Pbox::new(10, j);
let mut v = 0;
measure!("Deref".to_string(), cnt, {
for _ in 0..cnt {
v = *b;
}
});
if v < 0 {
println!("unreachable {}", v);
}
}).unwrap();
P::transaction(|j| {
let b = Pbox::new(Pbox::new(10, j), j);
let mut b = &**b;
let mut m = &mut b;
measure!("DerefMut(!1st)".to_string(), cnt, {
for _ in 0..cnt {
m = &mut b;
}
});
if **m < 0 {
println!("unreachable {}", m);
}
}).unwrap();
datalog!(cnt, 8);
datalog!(cnt, 64);
datalog!(cnt, 256);
datalog!(cnt, 1024);
datalog!(cnt, 4096);
for s in [8, 64, 2048, 8192, 32768].iter() {
P::transaction(|j| unsafe {
let mut vec = Vec::with_capacity(cnt);
for _ in 0..cnt {
let m = P::alloc(*s);
if m.0.is_null() {
panic!("Could not alloc(2) mem size {}", s);
}
vec.push(m);
}
for i in 0..cnt {
let (_, off, len) = vec[i];
measure!(format!("DropLog({})", s), {
Log::drop_on_commit(off, len, j);
});
}
}).unwrap();
}
P::transaction(|j| {
let b = Pbox::new(0u64, j);
let mut vec = Vec::with_capacity(cnt);
for _ in 0..cnt {
vec.push(measure!("Pbox:clone".to_string(), {
b.pclone(j)
}));
}
}).unwrap();
P::transaction(|j| {
let b = Prc::new(0u64, j);
let mut vec = Vec::with_capacity(cnt);
measure!("Prc:clone".to_string(), cnt, {
for _ in 0..cnt {
vec.push(b.pclone(j));
}
});
}).unwrap();
P::transaction(|j| {
let b = Parc::new(0u64, j);
let mut vec = Vec::with_capacity(cnt);
for _ in 0..cnt {
vec.push(measure!("Parc:clone".to_string(), { b.pclone(j) }));
}
}).unwrap();
P::transaction(|j| {
let b = Parc::new(0u64, j);
let mut pvec = Vec::<parc::PWeak<u64>>::with_capacity(cnt);
for _ in 0..cnt {
pvec.push(measure!("Parc:downgrade".to_string(), { Parc::downgrade(&b, j) }));
}
let mut ppvec = Vec::with_capacity(cnt);
for i in 0..cnt {
ppvec.push(measure!("Parc:upgrade".to_string(), { pvec[i].upgrade(j) }))
}
}).unwrap();
P::transaction(|j| {
let b = Parc::new(0u64, j);
let mut vvec = Vec::with_capacity(cnt);
unsafe {
for _ in 0..cnt {
vvec.push(measure!("Parc:demote".to_string(), { Parc::unsafe_demote(&b) }));
}
}
let mut pvec = Vec::with_capacity(cnt);
for i in 0..cnt {
pvec.push(measure!("Parc:promote".to_string(), { vvec[i].promote(j) }));
}
}).unwrap();
}
P::transaction(|j| {
let b = Prc::new(0u64, j);
let mut pvec = Vec::with_capacity(cnt);
measure!("Prc:downgrade".to_string(), cnt, {
for _ in 0..cnt {
pvec.push(Prc::downgrade(&b, j));
}
});
let mut bvec = Vec::with_capacity(cnt);
measure!("Prc:upgrade".to_string(), cnt, {
for i in 0..cnt {
bvec.push(pvec[i].upgrade(j))
}
});
}).unwrap();
P::transaction(|j| {
let b = Prc::new(0u64, j);
let mut vvec = Vec::<prc::VWeak<u64>>::with_capacity(cnt);
unsafe {
measure!("Prc:demote".to_string(), cnt, {
for _ in 0..cnt {
vvec.push(Prc::unsafe_demote(&b));
}
})
}
let mut bvec = Vec::with_capacity(cnt);
measure!("Prc:promote".to_string(), cnt, {
for i in 0..cnt {
bvec.push(vvec[i].promote(j));
}
});
}).unwrap();
for s in &sizes {
let layout = std::alloc::Layout::from_size_align(*s * 8, 4).unwrap();
measure!(format!("malloc({})", *s * 8), cnt, {
for _ in 0..cnt {
unsafe{ std::alloc::alloc(layout); }
}
});
}
let mut vec = Vec::with_capacity(cnt);
measure!(" *Vec::push".to_string(), cnt, {
for i in 0..cnt {
vec.push(i as u128);
}
});
let mut m = 0;
measure!(" ^Vec::deref".to_string(), cnt, {
for i in 0..cnt {
m = vec[i];
}
});
if m == cnt as u128 + 1 {
println!("unreachable {}", m)
}
measure!(" for".to_string(), cnt, {
for _ in 0..cnt {
unsafe { asm!("nop"); }
}
});
if m == cnt as u128 + 1 {
println!("unreachable {}", m);
}
for _ in 0..cnt {
measure!(" nop".to_string(), {
unsafe { asm!("nop"); }
});
}
println!("{}", report());
let _=save_histograms("hist");
}
}
fn main() {
#[cfg(target_arch = "x86_64")]
run::main()
}