use std::sync::{Arc, Mutex};
use std::thread;
use sensor_db::mock::MockFlash;
use sensor_db::{Error, SensorData, SensorDb};
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
#[derive(Debug, Clone, Copy, PartialEq, FromBytes, IntoBytes, KnownLayout, Immutable)]
#[repr(C)]
struct Temperature {
celsius_x100: i32,
}
impl SensorData for Temperature {
const SENSOR_ID: u16 = 0x01;
}
const PAGE: usize = 256;
const SECTOR: usize = 4096;
const SECTORS: usize = 16;
type Db = SensorDb<MockFlash<PAGE, SECTOR>, PAGE, SECTORS>;
const PER_WRITER: u64 = 250;
const WRITERS: u64 = 2;
fn main() -> Result<(), Error> {
println!("=== sharing one log between threads ===\n");
fn assert_shareable<T: Send + Sync>() {}
assert_shareable::<Db>();
let mut db: Db = SensorDb::new(
MockFlash::new(SECTORS * SECTOR),
0,
SECTORS as u16,
2, )?;
db.format()?;
let db = Arc::new(Mutex::new(db));
let writers: Vec<_> = (0..WRITERS)
.map(|w| {
let db = Arc::clone(&db);
thread::spawn(move || {
for i in 0..PER_WRITER {
let ts = w * PER_WRITER + i;
let mut db = db.lock().unwrap();
db.append_sensor(
ts,
&Temperature {
celsius_x100: 2_000 + ts as i32,
},
)
.unwrap();
}
})
})
.collect();
let reader = {
let db = Arc::clone(&db);
thread::spawn(move || {
let mut observed = 0u32;
for _ in 0..200 {
let mut db = db.lock().unwrap();
let count = db.count_sensor::<Temperature>().unwrap();
assert!(
count >= observed,
"the log is append-only: a count must never go backwards"
);
observed = count;
if let Some((header, value)) = db.latest_sensor::<Temperature>().unwrap() {
assert_eq!(value.celsius_x100, 2_000 + header.timestamp as i32);
}
}
observed
})
};
for w in writers {
w.join().unwrap();
}
let seen_by_reader = reader.join().unwrap();
let mut db = db.lock().unwrap();
db.sync()?;
let total = PER_WRITER * WRITERS;
println!(" {WRITERS} writers x {PER_WRITER} readings = {total}");
println!(" reader observed up to {seen_by_reader} while they ran");
println!(
" stored after join + sync {}",
db.count_sensor::<Temperature>()?
);
assert_eq!(
db.count_sensor::<Temperature>()?,
total as u32,
"every append from every thread must be present"
);
let mut seen = vec![false; total as usize];
db.query_all_sensor::<Temperature, _>(|h, _| {
assert!(!seen[h.timestamp as usize], "no reading may appear twice");
seen[h.timestamp as usize] = true;
true
})?;
assert!(seen.iter().all(|&s| s), "no reading may be missing");
println!(" every timestamp present exactly once");
println!("\nOK");
Ok(())
}