use super::*;
use crate::{Encoding, Error};
mod composition;
pub(super) use composition::Computation;
#[derive(Clone)]
struct State {
value: Value,
changed_at: Option<Time>,
}
#[derive(Clone, Default)]
pub(super) struct Slot {
state: Option<State>,
pending: Option<Value>,
changed: bool,
events: u64,
}
impl Slot {
fn sample(&self, signal: Signal, time: Option<Time>) -> SampleRef<'_> {
if signal.encoding() == Encoding::Event {
return SampleRef::Event {
signal,
occurrences: if time.is_some() { self.events } else { 0 },
};
}
let state = self.state.as_ref();
let value = time
.and(self.pending.as_ref())
.or(state.map(|state| &state.value));
match value {
Some(value) => SampleRef::Value {
signal,
value: value.as_ref(),
changed_at: state.and_then(|state| {
if self.changed {
time.or(state.changed_at)
} else {
state.changed_at
}
}),
},
None => SampleRef::Missing { signal },
}
}
}
#[derive(Clone, Copy)]
enum Position {
Vcd(crate::backends::vcd::Position),
#[cfg(feature = "fsdb-lib")]
Fsdb(Time),
#[cfg(feature = "shm-lib")]
Shm(Time),
#[cfg(feature = "wlf-lib")]
Wlf(Time),
#[cfg(feature = "wdb-lib")]
Wdb(Time),
}
impl Position {
fn time(self) -> Time {
match self {
Self::Vcd(position) => Time::from_ticks(position.time),
#[cfg(feature = "fsdb-lib")]
Self::Fsdb(time) => time,
#[cfg(feature = "shm-lib")]
Self::Shm(time) => time,
#[cfg(feature = "wlf-lib")]
Self::Wlf(time) => time,
#[cfg(feature = "wdb-lib")]
Self::Wdb(time) => time,
}
}
}
pub(super) struct Replay {
position: Position,
start: Time,
end: Time,
time: Option<Time>,
slots: Vec<Slot>,
}
const CHECKPOINT_BYTES: usize = 4 * 1024 * 1024;
fn checkpoint_bytes(slots: &[Slot]) -> usize {
slots.iter().fold(
std::mem::size_of::<Replay>() + std::mem::size_of_val(slots),
|bytes, slot| {
[
slot.state.as_ref().map(|state| &state.value),
slot.pending.as_ref(),
]
.into_iter()
.flatten()
.fold(bytes, |bytes, value| {
bytes.saturating_add(match value.as_ref() {
ValueRef::Bits(bits) => bits.width() as usize,
ValueRef::String(text) => text.len(),
_ => 0,
})
})
},
)
}
fn update(state: &mut Option<State>, value: Value, time: Time) -> bool {
if state
.as_ref()
.is_some_and(|previous| previous.value.as_ref().same_value(value.as_ref()))
{
return false;
}
let changed_at = state.as_ref().map(|_| time);
*state = Some(State { value, changed_at });
true
}
fn validate_indices(len: usize, indices: &[usize]) -> Result<()> {
if let Some(&index) = indices.iter().find(|&&index| index >= len) {
return Err(Error::InvalidSelectionIndex { index, len });
}
Ok(())
}
impl QueryContext<'_> {
pub fn time(&self) -> Time {
self.time
}
pub fn visit_samples<B>(
&self,
time: Time,
indices: &[usize],
mut visitor: impl for<'v> FnMut(usize, SampleRef<'v>) -> Result<ControlFlow<B>>,
) -> Result<ControlFlow<B>> {
let current = time == self.time;
if !current && self.time.ticks().checked_sub(1).map(Time::from_ticks) != Some(time) {
return Err(Error::InvalidQueryTime {
requested: time,
current: self.time,
});
}
validate_indices(self.signals.len(), indices)?;
for &index in indices {
let signal = self.signals[index];
let slot_index = self.slot_indices[index];
let slot = &self.slots[slot_index];
let mut sample = slot.sample(signal, current.then_some(self.time));
if !current && let SampleRef::Event { occurrences, .. } = &mut sample {
*occurrences = if self.previous_tick == Some(time) {
self.previous_events[slot_index]
} else {
0
};
}
if let ControlFlow::Break(value) = visitor(index, sample)? {
return Ok(ControlFlow::Break(value));
}
}
Ok(ControlFlow::Continue(()))
}
}
fn project(value: ValueRef<'_>, signal: Signal) -> ValueRef<'_> {
match value {
ValueRef::Bits(bits) if signal.is_slice() => {
let lsb = signal.lsb();
ValueRef::Bits(bits.slice(lsb + signal.width().expect("bit projection") - 1, lsb))
}
value => value,
}
}
fn initials<B>(
signals: &[Signal],
slots: &[Slot],
slot_indices: &[usize],
visitor: &mut impl for<'v> FnMut(usize, ScanRef<'v>) -> ControlFlow<B>,
) -> ControlFlow<B> {
for (index, signal) in signals.iter().enumerate() {
let slot = &slots[slot_indices[index]];
if let Some(state) = &slot.state
&& let ControlFlow::Break(value) = visitor(
index,
ScanRef::Initial {
signal: *signal,
value: state.value.as_ref(),
changed_at: state.changed_at,
},
)
{
return ControlFlow::Break(value);
}
}
ControlFlow::Continue(())
}
fn scan_tick<B>(
signals: &[Signal],
slots: &[Slot],
slot_indices: &[usize],
time: Time,
range: TimeRange,
emitted_initials: &mut bool,
visitor: &mut impl for<'v> FnMut(usize, ScanRef<'v>) -> ControlFlow<B>,
) -> ControlFlow<B> {
if !*emitted_initials && time >= range.start() {
*emitted_initials = true;
initials(signals, slots, slot_indices, visitor)?;
}
for (index, &signal) in signals.iter().enumerate() {
let slot = &slots[slot_indices[index]];
if let Some(value) = &slot.pending
&& slot.changed
&& time >= range.start()
{
visitor(
index,
ScanRef::Change {
signal,
time,
value: value.as_ref(),
},
)?;
}
let events = slot.events;
if time >= range.start() && events > 0 {
visitor(
index,
ScanRef::Change {
signal,
time,
value: ValueRef::Event {
occurrences: events,
},
},
)?;
}
}
ControlFlow::Continue(())
}
fn complete_tick<B>(
computations: &[Computation],
signals: &[Signal],
slots: &mut [Slot],
active_slots: &mut Vec<usize>,
time: Time,
visit_from: Option<Time>,
visitor: &mut impl FnMut(Time, &[Signal], &[Slot]) -> Result<ControlFlow<B>>,
) -> Result<ControlFlow<B>> {
for computation in computations {
computation.complete(slots, active_slots);
}
for &index in active_slots.iter() {
#[cfg(test)]
streaming_tests::comparison_visit();
let slot = &mut slots[index];
slot.changed = slot.pending.as_ref().is_some_and(|value| {
!slot
.state
.as_ref()
.is_some_and(|state| state.value.as_ref().same_value(value.as_ref()))
});
}
if visit_from.is_none_or(|start| time >= start)
&& let ControlFlow::Break(value) = visitor(time, signals, slots)?
{
return Ok(ControlFlow::Break(value));
}
for index in active_slots.drain(..) {
#[cfg(test)]
streaming_tests::commit_visit();
let slot = &mut slots[index];
if let Some(value) = slot.pending.take()
&& slot.changed
{
slot.state = Some(State {
value,
changed_at: slot.state.as_ref().map(|_| time),
});
}
slot.events = 0;
slot.changed = false;
}
Ok(ControlFlow::Continue(()))
}
impl<'w> Selection<'w> {
pub(crate) fn new(waveform: &'w mut Waveform, signals: &[Signal]) -> Result<Self> {
let plan = composition::Plan::new(waveform, signals)?;
Ok(Self {
waveform,
signals: signals.to_vec(),
bases: plan.bases,
groups: plan.groups,
slot_indices: plan.indices,
retained_signals: plan.retained,
computations: plan.computations,
replay: None,
checkpoint: None,
})
}
pub fn samples_at(&mut self, times: &[Time]) -> Result<Vec<(Time, Vec<Sample>)>> {
let mut rows = times
.iter()
.map(|&time| (time, Vec::new()))
.collect::<Vec<_>>();
if times.is_empty() || self.signals.is_empty() {
return Ok(rows);
}
let mut order = (0..times.len()).collect::<Vec<_>>();
order.sort_unstable_by_key(|&index| times[index]);
let end = times[*order.last().expect("nonempty schedule")];
let indices = self.slot_indices.clone();
let mut slots = vec![Slot::default(); self.retained_signals.len()];
let mut next = 0;
let observe = |signals: &[Signal], slots: &[Slot], tick| {
signals
.iter()
.zip(&indices)
.map(|(&signal, &index)| slots[index].sample(signal, tick).to_owned())
.collect()
};
let start = if matches!(&self.waveform.reader, crate::backends::Reader::Vcd(_)) {
self.replay = None;
self.checkpoint = None;
Some(times[order[0]])
} else {
None
};
let _ = self.read_ticks_from(start, end, &mut slots, true, |time, signals, slots| {
while next < order.len() && times[order[next]] <= time {
let index = order[next];
rows[index].1 = observe(signals, slots, (times[index] == time).then_some(time));
next += 1;
}
Ok(ControlFlow::<()>::Continue(()))
})?;
for &index in &order[next..] {
rows[index].1 = observe(&self.signals, &slots, None);
}
Ok(rows)
}
pub fn query<B>(
&mut self,
range: TimeRange,
drivers: &[usize],
mut visitor: impl FnMut(&QueryContext<'_>) -> Result<ControlFlow<B>>,
) -> Result<ControlFlow<B>> {
validate_indices(self.signals.len(), drivers)?;
let end = range
.end()
.or_else(|| self.waveform.metadata().time_span().map(|span| span.last()))
.unwrap_or(Time::from_ticks(u64::MAX));
if drivers.is_empty() || range.is_empty() || range.start() > end {
return Ok(ControlFlow::Continue(()));
}
let mut slots = (0..self.retained_signals.len())
.map(|_| Slot::default())
.collect::<Vec<_>>();
let mut previous_events = vec![0; self.retained_signals.len()];
let mut previous_tick = None;
let slot_indices = self.slot_indices.clone();
self.read_ticks_from(
range.start().ticks().checked_sub(1).map(Time::from_ticks),
end,
&mut slots,
true,
|time, signals, slots| {
if time >= range.start()
&& drivers.iter().any(|&index| {
let slot = &slots[slot_indices[index]];
slot.pending.is_some() || slot.events > 0
})
{
let context = QueryContext {
time,
signals,
slots,
slot_indices: &slot_indices,
previous_tick,
previous_events: &previous_events,
};
if let ControlFlow::Break(value) = visitor(&context)? {
return Ok(ControlFlow::Break(value));
}
}
for (previous, slot) in previous_events.iter_mut().zip(slots) {
*previous = slot.events;
}
previous_tick = Some(time);
Ok(ControlFlow::Continue(()))
},
)
}
#[cfg(feature = "shm-lib")]
fn shm_point_samples(
&mut self,
time: Time,
prepare_fallback: bool,
) -> Result<Option<Vec<Sample>>> {
let crate::backends::Reader::Shm(reader) = &mut self.waveform.reader else {
unreachable!("SHM point reader");
};
let Some(mut samples) = reader.sample_bits(&self.bases, time, prepare_fallback)? else {
return Ok(None);
};
let missing = samples
.iter()
.enumerate()
.filter_map(|(index, sample)| sample.is_none().then_some(index))
.collect::<Vec<_>>();
if !missing.is_empty() {
let signals = missing
.iter()
.map(|&index| self.bases[index])
.collect::<Vec<_>>();
let fallback = self.waveform.select(&signals)?.samples(time)?;
for (index, sample) in missing.into_iter().zip(fallback) {
samples[index] = Some(sample);
}
}
Ok(Some(samples.into_iter().map(Option::unwrap).collect()))
}
#[cfg(feature = "wdb-lib")]
fn repeats_one_source(&self) -> bool {
let [base] = self.bases.as_slice() else {
return false;
};
let Some(width) = base.width().filter(|width| *width > 0) else {
return false;
};
let aligned = |signal: Signal| {
signal.lsb().is_multiple_of(width)
&& signal
.width()
.is_some_and(|len| len > 0 && len.is_multiple_of(width))
};
!self.computations.is_empty()
&& self.retained_signals.iter().copied().all(aligned)
&& self
.computations
.iter()
.all(|computation| match computation {
Computation::Concat { inputs, .. } => inputs
.iter()
.all(|&(_, len)| len > 0 && len.is_multiple_of(width)),
Computation::Slice { signal, .. } => aligned(*signal),
})
}
#[cfg(feature = "wdb-lib")]
fn repeated_source_slots(&self, source: Option<State>) -> Vec<Slot> {
let mut slots = vec![Slot::default(); self.retained_signals.len()];
let Some(source) = source else {
return slots;
};
for &index in &self.groups[&self.bases[0].index()] {
slots[index].pending = Some(source.value.clone());
}
let mut active = Vec::new();
for computation in &self.computations {
computation.complete(&mut slots, &mut active);
}
for slot in &mut slots {
slot.state = slot.pending.take().map(|value| State {
value,
changed_at: source.changed_at,
});
}
slots
}
#[cfg(any(
feature = "fsdb-lib",
feature = "shm-lib",
feature = "wlf-lib",
feature = "wdb-lib"
))]
fn point_states(
&mut self,
time: Time,
prepare_shm_fallback: bool,
) -> Result<Option<Vec<Option<State>>>> {
#[cfg(not(feature = "shm-lib"))]
let _ = prepare_shm_fallback;
#[cfg(feature = "wdb-lib")]
let repeated_source = matches!(&self.waveform.reader, crate::backends::Reader::Wdb(_))
&& self.repeats_one_source();
#[cfg(not(feature = "wdb-lib"))]
let repeated_source = false;
if (!self.computations.is_empty() && !repeated_source)
|| self.signals.is_empty()
|| !self
.bases
.iter()
.all(|signal| matches!(signal.encoding(), Encoding::Bits { .. }))
{
return Ok(None);
}
match &self.waveform.reader {
#[cfg(feature = "fsdb-lib")]
crate::backends::Reader::Fsdb(_) => {}
#[cfg(feature = "wlf-lib")]
crate::backends::Reader::Wlf(_) => {}
#[cfg(feature = "wdb-lib")]
crate::backends::Reader::Wdb(_) => {}
#[cfg(feature = "shm-lib")]
crate::backends::Reader::Shm(_)
if time.ticks() != u64::MAX
&& self.retained_signals.iter().all(|s| {
!s.is_slice() || s.base().encoding() == Encoding::Bits { width: 1 }
}) => {}
_ => return Ok(None),
}
let next = time.ticks().checked_add(1).map(Time::from_ticks);
if let Some(replay) = self.replay.as_ref().filter(|replay| {
replay.time.is_none() && replay.end == time && Some(replay.start) == next
}) {
return Ok(Some(
self.slot_indices
.iter()
.map(|&index| replay.slots[index].state.clone())
.collect(),
));
}
let eligible = |replay: &Replay| replay.start <= time && replay.end <= time;
if self.replay.as_ref().is_some_and(eligible)
|| self.checkpoint.as_ref().is_some_and(eligible)
{
return Ok(None);
}
self.replay = None;
self.checkpoint = None;
let slots: Vec<_> = match &mut self.waveform.reader {
#[cfg(feature = "wdb-lib")]
crate::backends::Reader::Wdb(reader) => reader
.sample_bits(
&self.bases,
if repeated_source {
&self.bases
} else {
&self.retained_signals
},
time,
)?
.into_iter()
.map(|sample| Slot {
state: match sample {
Sample::Value {
value, changed_at, ..
} => Some(State { value, changed_at }),
Sample::Missing { .. } => None,
Sample::Event { .. } => unreachable!("bit-only point selection"),
},
..Slot::default()
})
.collect(),
#[cfg(feature = "fsdb-lib")]
crate::backends::Reader::Fsdb(reader) => reader
.sample_bits(&self.bases, &self.retained_signals, time)?
.into_iter()
.map(|sample| Slot {
state: match sample {
Sample::Value {
value, changed_at, ..
} => Some(State { value, changed_at }),
Sample::Missing { .. } => None,
Sample::Event { .. } => unreachable!("bit-only point selection"),
},
..Slot::default()
})
.collect(),
#[cfg(feature = "wlf-lib")]
crate::backends::Reader::Wlf(reader) => reader
.sample_bits(&self.bases, &self.retained_signals, time)?
.into_iter()
.map(|sample| Slot {
state: match sample {
Sample::Value {
value, changed_at, ..
} => Some(State { value, changed_at }),
Sample::Missing { .. } => None,
Sample::Event { .. } => unreachable!("bit-only point selection"),
},
..Slot::default()
})
.collect(),
#[cfg(feature = "shm-lib")]
crate::backends::Reader::Shm(_) => {
let Some(samples) = self.shm_point_samples(time, prepare_shm_fallback)? else {
return Ok(None);
};
let mut slots = vec![Slot::default(); self.retained_signals.len()];
for sample in samples {
let signal = sample.signal();
let state = match sample {
Sample::Value {
value, changed_at, ..
} => Some(State { value, changed_at }),
Sample::Missing { .. } => None,
Sample::Event { .. } => unreachable!("bit-only point"),
};
for &index in &self.groups[&signal.index()] {
slots[index].state = state.clone();
}
}
slots
}
_ => unreachable!("point reader was checked above"),
};
#[cfg(feature = "wdb-lib")]
let slots = if repeated_source {
let source = slots.into_iter().next().expect("one repetition source");
self.repeated_source_slots(source.state)
} else {
slots
};
let states = self
.slot_indices
.iter()
.map(|&index| slots[index].state.clone())
.collect();
if let Some(next) = next.filter(|_| checkpoint_bytes(&slots) <= CHECKPOINT_BYTES) {
self.replay = Some(Replay {
position: match &self.waveform.reader {
#[cfg(feature = "fsdb-lib")]
crate::backends::Reader::Fsdb(_) => Position::Fsdb(next),
#[cfg(feature = "wlf-lib")]
crate::backends::Reader::Wlf(_) => Position::Wlf(next),
#[cfg(feature = "wdb-lib")]
crate::backends::Reader::Wdb(_) => Position::Wdb(next),
#[cfg(feature = "shm-lib")]
crate::backends::Reader::Shm(_) => Position::Shm(next),
_ => unreachable!("point reader was checked above"),
},
start: next,
end: time,
time: None,
slots,
});
}
Ok(Some(states))
}
#[cfg(feature = "shm-lib")]
fn shm_replay_sample_visit<B>(
&mut self,
time: Time,
visitor: &mut impl for<'v> FnMut(SampleRef<'v>) -> ControlFlow<B>,
) -> Option<ControlFlow<B>> {
if !self.computations.is_empty()
|| !matches!(self.waveform.reader, crate::backends::Reader::Shm(_))
|| !self
.replay
.as_ref()
.is_some_and(|replay| replay.end == time)
{
return None;
}
let replay = self.replay.take().unwrap();
let checkpoint = self.checkpoint.take();
for (index, &signal) in self.signals.iter().enumerate() {
let slot = &replay.slots[self.slot_indices[index]];
let value = slot
.pending
.as_ref()
.or_else(|| slot.state.as_ref().map(|state| &state.value));
let changed_at = match (slot.pending.as_ref(), slot.state.as_ref()) {
(Some(value), Some(state)) if !state.value.as_ref().same_value(value.as_ref()) => {
replay.time
}
(_, Some(state)) => state.changed_at,
_ => None,
};
let sample = if let Some(value) = value {
SampleRef::Value {
signal,
value: value.as_ref(),
changed_at,
}
} else {
SampleRef::Missing { signal }
};
if let ControlFlow::Break(value) = visitor(sample) {
return Some(ControlFlow::Break(value));
}
}
self.replay = Some(replay);
self.checkpoint = checkpoint;
Some(ControlFlow::Continue(()))
}
pub(super) fn sample_visit<B>(
&mut self,
time: Time,
mut visitor: impl for<'v> FnMut(SampleRef<'v>) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
#[cfg(feature = "shm-lib")]
if let Some(result) = self.shm_replay_sample_visit(time, &mut visitor) {
return Ok(result);
}
#[cfg(any(
feature = "fsdb-lib",
feature = "shm-lib",
feature = "wlf-lib",
feature = "wdb-lib"
))]
let (point_sampled, mut states) = {
let states = self.point_states(time, true)?;
(
states.is_some(),
states.unwrap_or_else(|| vec![None; self.signals.len()]),
)
};
#[cfg(not(any(
feature = "fsdb-lib",
feature = "shm-lib",
feature = "wlf-lib",
feature = "wdb-lib"
)))]
let (point_sampled, mut states) = (false, vec![None; self.signals.len()]);
let mut events = vec![0u64; self.signals.len()];
if !point_sampled {
#[cfg(feature = "shm-lib")]
let seed_point = !matches!(&self.waveform.reader, crate::backends::Reader::Shm(_));
#[cfg(not(feature = "shm-lib"))]
let seed_point = true;
let _ = self.scan_each_with_point_seed(
TimeRange::point(time),
seed_point,
|index, record| {
match record {
ScanRef::Initial {
value, changed_at, ..
} => {
states[index] = Some(State {
value: value.to_owned(),
changed_at,
});
}
ScanRef::Change { time, value, .. } => {
if let ValueRef::Event { occurrences } = value {
events[index] = occurrences;
} else {
update(&mut states[index], value.to_owned(), time);
}
}
}
ControlFlow::<()>::Continue(())
},
)?;
}
let replay = self.replay.take();
let checkpoint = self.checkpoint.take();
for (index, &signal) in self.signals.iter().enumerate() {
let sample = if signal.encoding() == Encoding::Event {
SampleRef::Event {
signal,
occurrences: events[index],
}
} else if let Some(state) = &states[index] {
SampleRef::Value {
signal,
value: state.value.as_ref(),
changed_at: state.changed_at,
}
} else {
SampleRef::Missing { signal }
};
if let ControlFlow::Break(value) = visitor(sample) {
return Ok(ControlFlow::Break(value));
}
}
self.replay = replay;
self.checkpoint = checkpoint;
Ok(ControlFlow::Continue(()))
}
pub fn scan_each<B>(
&mut self,
range: TimeRange,
visitor: impl for<'v> FnMut(usize, ScanRef<'v>) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
self.scan_each_with_point_seed(range, true, visitor)
}
fn scan_each_with_point_seed<B>(
&mut self,
range: TimeRange,
seed_point: bool,
mut visitor: impl for<'v> FnMut(usize, ScanRef<'v>) -> ControlFlow<B>,
) -> Result<ControlFlow<B>> {
let end = range
.end()
.or_else(|| {
self.waveform
.metadata()
.time_span()
.map(|span| span.last().max(range.start()))
})
.unwrap_or(Time::from_ticks(u64::MAX));
if range.is_empty() || range.start() > end || self.signals.is_empty() {
return Ok(ControlFlow::Continue(()));
}
let mut slots = (0..self.retained_signals.len())
.map(|_| Slot::default())
.collect::<Vec<_>>();
let mut emitted_initials = false;
let slot_indices = self.slot_indices.clone();
if let ControlFlow::Break(value) = self.read_ticks_from(
Some(range.start()),
end,
&mut slots,
seed_point,
|time, signals, slots| {
Ok(scan_tick(
signals,
slots,
&slot_indices,
time,
range,
&mut emitted_initials,
&mut visitor,
))
},
)? {
return Ok(ControlFlow::Break(value));
}
if !emitted_initials {
let replay = self.replay.take();
let checkpoint = self.checkpoint.take();
let result = initials(&self.signals, &slots, &slot_indices, &mut visitor);
if result.is_continue() {
self.replay = replay;
self.checkpoint = checkpoint;
}
return Ok(result);
}
Ok(ControlFlow::Continue(()))
}
#[cfg(test)]
fn read_ticks<B>(
&mut self,
end: Time,
slots: &mut [Slot],
visitor: impl FnMut(Time, &[Signal], &[Slot]) -> Result<ControlFlow<B>>,
) -> Result<ControlFlow<B>> {
self.read_ticks_from(None, end, slots, true, visitor)
}
fn read_ticks_from<B>(
&mut self,
start: Option<Time>,
end: Time,
slots: &mut [Slot],
seed_point: bool,
mut visitor: impl FnMut(Time, &[Signal], &[Slot]) -> Result<ControlFlow<B>>,
) -> Result<ControlFlow<B>> {
let eligible =
|replay: &Replay| start.is_some_and(|start| replay.start <= start) && replay.end <= end;
#[cfg(not(any(
feature = "fsdb-lib",
feature = "shm-lib",
feature = "wlf-lib",
feature = "wdb-lib"
)))]
let _ = seed_point;
#[cfg(any(
feature = "fsdb-lib",
feature = "shm-lib",
feature = "wlf-lib",
feature = "wdb-lib"
))]
if seed_point
&& let Some(start) = start.filter(|start| *start > Time::ZERO)
&& !self.replay.as_ref().is_some_and(eligible)
&& !self.checkpoint.as_ref().is_some_and(eligible)
{
self.point_states(Time::from_ticks(start.ticks() - 1), false)?;
}
#[cfg(unix)]
if self.computations.is_empty()
&& !self.replay.as_ref().is_some_and(eligible)
&& !self.checkpoint.as_ref().is_some_and(eligible)
&& let Some(start) = start.filter(|start| *start > Time::ZERO)
&& !self.retained_signals.iter().any(|signal| signal.is_slice())
&& let crate::backends::Reader::Vcd(reader) = &self.waveform.reader
&& let Some((samples, position)) =
reader.parallel_prefix(&self.bases, Time::from_ticks(start.ticks() - 1))
{
let mut initial = vec![Slot::default(); self.retained_signals.len()];
for sample in samples {
if let Sample::Value {
signal,
value,
changed_at,
} = sample
{
for &index in &self.groups[&signal.index()] {
initial[index].state = Some(State {
value: value.clone(),
changed_at,
});
}
}
}
if checkpoint_bytes(&initial) <= CHECKPOINT_BYTES {
self.checkpoint = Some(Replay {
position: Position::Vcd(position),
start,
end: Time::from_ticks(start.ticks() - 1),
time: None,
slots: initial,
});
}
}
let mut checkpoint = self.checkpoint.take();
let retained = self.replay.take().filter(&eligible);
let replay = retained.as_ref().or_else(|| {
checkpoint
.as_ref()
.filter(|checkpoint| eligible(checkpoint))
});
let mut checkpoint_considered = checkpoint
.as_ref()
.is_some_and(|checkpoint| Some(checkpoint.start) == start);
let replay_start = replay.map(|replay| replay.start).unwrap_or(Time::ZERO);
let mut pending_time = replay.and_then(|replay| replay.time);
let position = replay.map(|replay| replay.position);
#[cfg(feature = "shm-lib")]
let shm_resume = replay.is_some_and(|replay| {
matches!(replay.position, Position::Shm(time) if time > Time::ZERO)
&& replay.time.is_none()
&& replay.slots.iter().all(|slot| slot.state.is_some())
});
if let Some(replay) = replay {
slots.clone_from_slice(&replay.slots);
}
#[cfg(test)]
streaming_tests::setup_visits(slots.len());
let mut active_slots = slots
.iter()
.enumerate()
.filter_map(|(index, slot)| {
(slot.pending.is_some() || slot.events > 0).then_some(index)
})
.collect::<Vec<_>>();
drop(retained);
let backend = self.waveform.backend().to_owned();
#[cfg(test)]
let probe = streaming_tests::probe(&self.waveform.reader);
let mut consume = |record: Option<(usize, Result<ValueRef<'_>>)>,
time,
position: Option<Position>| {
let Some((base, value)) = record else {
if let Some(previous) = pending_time {
debug_assert_eq!(previous, time);
match complete_tick(
&self.computations,
&self.signals,
slots,
&mut active_slots,
previous,
start,
&mut visitor,
) {
Ok(ControlFlow::Continue(())) => pending_time = None,
outcome => return ControlFlow::Break(outcome),
}
}
return ControlFlow::Continue(());
};
if let Some(previous) = pending_time
&& previous != time
{
match complete_tick(
&self.computations,
&self.signals,
slots,
&mut active_slots,
previous,
start,
&mut visitor,
) {
Ok(ControlFlow::Continue(())) => (),
outcome => return ControlFlow::Break(outcome),
}
}
let value = match value {
Ok(value) => value,
Err(error) => return ControlFlow::Break(Err(error)),
};
if !checkpoint_considered
&& let (Some(start), Some(position)) = (start, position)
&& time >= start
&& pending_time.is_none_or(|previous| previous < start)
{
checkpoint_considered = true;
checkpoint = (checkpoint_bytes(slots) <= CHECKPOINT_BYTES).then(|| Replay {
position,
start,
end: position.time(),
time: None,
slots: slots.to_vec(),
});
}
pending_time = Some(time);
for &index in &self.groups[&base] {
let slot = &mut slots[index];
if slot.pending.is_none()
&& slot.events == 0
&& !matches!(value, ValueRef::Event { occurrences: 0 })
{
active_slots.push(index);
}
if let ValueRef::Event { occurrences } = value {
let Some(count) = slot.events.checked_add(occurrences) else {
return ControlFlow::Break(Err(Error::Backend {
backend: backend.clone(),
operation: "count events",
message: "event occurrence count exceeds u64::MAX".into(),
}));
};
slot.events = count;
} else {
slot.pending = Some(project(value, self.retained_signals[index]).to_owned());
}
}
debug_assert!(active_slots.len() <= slots.len());
#[cfg(test)]
streaming_tests::observe_pending(&probe, slots);
ControlFlow::Continue(())
};
let result = match &mut self.waveform.reader {
crate::backends::Reader::Vcd(reader) => {
let position = position.map(|position| match position {
Position::Vcd(position) => position,
#[cfg(feature = "fsdb-lib")]
Position::Fsdb(_) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "shm-lib")]
Position::Shm(_) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "wlf-lib")]
Position::Wlf(_) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "wdb-lib")]
Position::Wdb(_) => unreachable!("reader is fixed for a selection"),
});
reader.read_from(&self.bases, end, position, |base, time, value, position| {
consume(Some((base, Ok(value))), time, Some(Position::Vcd(position)))
})
}
crate::backends::Reader::Ghw(reader) => {
reader.read(&self.bases, end, |event| match event {
crate::backends::ghw::Notification::Value { index, time, value } => {
consume(Some((index, Ok(value))), time, None)
}
crate::backends::ghw::Notification::Tick(time) => consume(None, time, None),
})
}
#[cfg(feature = "fsdb-lib")]
crate::backends::Reader::Fsdb(reader) => {
let from = match position {
Some(Position::Fsdb(time)) => time,
None => Time::ZERO,
Some(Position::Vcd(_)) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "shm-lib")]
Some(Position::Shm(_)) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "wlf-lib")]
Some(Position::Wlf(_)) => unreachable!("reader is fixed for a selection"),
#[cfg(feature = "wdb-lib")]
Some(Position::Wdb(_)) => unreachable!("reader is fixed for a selection"),
};
let cacheable = !self.bases.iter().any(|s| s.encoding() == Encoding::Event);
reader.read_from(&self.bases, from, end, |base, time, value| {
consume(
Some((base, Ok(value))),
time,
cacheable.then_some(Position::Fsdb(time)),
)
})
}
#[cfg(feature = "shm-lib")]
crate::backends::Reader::Shm(reader) => {
let from = match position {
Some(Position::Shm(time)) => time,
None => Time::ZERO,
_ => unreachable!("reader is fixed for a selection"),
};
let cacheable = !self.bases.iter().any(|s| s.encoding() == Encoding::Event);
reader.read_from_with_resume(
&self.bases,
from,
end,
shm_resume && cacheable,
|base, time, value| {
consume(
Some((base, value)),
time,
cacheable.then_some(Position::Shm(time)),
)
},
)
}
#[cfg(feature = "wdb-lib")]
crate::backends::Reader::Wdb(reader) => {
let from = match position {
Some(Position::Wdb(time)) => time,
None => Time::ZERO,
_ => unreachable!("reader is fixed for a selection"),
};
let cacheable = !self.bases.iter().any(|s| s.encoding() == Encoding::Event);
reader.read_from(&self.bases, from, end, |base, time, value| {
consume(
Some((base, Ok(value))),
time,
cacheable.then_some(Position::Wdb(time)),
)
})
}
#[cfg(feature = "wlf-lib")]
crate::backends::Reader::Wlf(reader) => {
let from = match position {
Some(Position::Wlf(time)) => time,
None => Time::ZERO,
_ => unreachable!("reader is fixed for a selection"),
};
let cacheable = !self.bases.iter().any(|s| s.encoding() == Encoding::Event);
reader.read_from(&self.bases, from, end, |base, time, value| {
consume(
Some((base, value)),
time,
cacheable.then_some(Position::Wlf(time)),
)
})
}
reader => reader.read(&self.bases, end, |base, time, value| {
consume(Some((base, value)), time, None)
}),
}?;
if let ControlFlow::Break(outcome) = result {
return outcome;
}
let replay = match &self.waveform.reader {
crate::backends::Reader::Vcd(reader) => reader.position().map(|position| Replay {
position: Position::Vcd(position),
start: pending_time.unwrap_or(replay_start),
end,
time: pending_time,
slots: slots.to_vec(),
}),
#[cfg(feature = "fsdb-lib")]
crate::backends::Reader::Fsdb(_)
if !self.bases.iter().any(|s| s.encoding() == Encoding::Event) =>
{
end.ticks().checked_add(1).map(|next| Replay {
position: Position::Fsdb(Time::from_ticks(next)),
start: pending_time.unwrap_or(replay_start),
end,
time: pending_time,
slots: slots.to_vec(),
})
}
#[cfg(feature = "shm-lib")]
crate::backends::Reader::Shm(_)
if !self.bases.iter().any(|s| s.encoding() == Encoding::Event)
&& checkpoint_bytes(slots) <= CHECKPOINT_BYTES =>
{
end.ticks().checked_add(1).map(|next| Replay {
position: Position::Shm(Time::from_ticks(next)),
start: pending_time.unwrap_or(replay_start),
end,
time: pending_time,
slots: slots.to_vec(),
})
}
#[cfg(feature = "wdb-lib")]
crate::backends::Reader::Wdb(_)
if !self.bases.iter().any(|s| s.encoding() == Encoding::Event)
&& checkpoint_bytes(slots) <= CHECKPOINT_BYTES =>
{
end.ticks().checked_add(1).map(|next| Replay {
position: Position::Wdb(Time::from_ticks(next)),
start: pending_time.unwrap_or(replay_start),
end,
time: pending_time,
slots: slots.to_vec(),
})
}
#[cfg(feature = "wlf-lib")]
crate::backends::Reader::Wlf(_)
if !self.bases.iter().any(|s| s.encoding() == Encoding::Event)
&& checkpoint_bytes(slots) <= CHECKPOINT_BYTES =>
{
end.ticks().checked_add(1).map(|next| Replay {
position: Position::Wlf(Time::from_ticks(next)),
start: pending_time.unwrap_or(replay_start),
end,
time: pending_time,
slots: slots.to_vec(),
})
}
_ => None,
};
let result = if let Some(time) = pending_time {
complete_tick(
&self.computations,
&self.signals,
slots,
&mut active_slots,
time,
start,
&mut visitor,
)?
} else {
ControlFlow::Continue(())
};
if result.is_continue() {
self.replay = replay;
self.checkpoint = checkpoint;
}
Ok(result)
}
}
#[cfg(test)]
mod streaming_tests;
#[cfg(test)]
mod tests {
use super::*;
#[cfg(unix)]
#[test]
fn vcd_candidate_times_are_an_activity_superset() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("candidate-times-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = b"$var wire 2 ! a $end $var wire 1 \" b $end $enddefinitions $end \
#0 b00 ! 0\"\n#1 b00 !\n#2 b01 ! 1\"\n#2 b00 !\n#3 b01 !\n#3 b00 ! 1\"\n#4 b01 !\n";
std::fs::write(&path, source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("serial.vcd", source.as_slice().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("a").unwrap();
let reference = serial.hierarchy().signal("a").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(std::fs::File::open(&path).unwrap(), vec![source.len()], 4);
let range = TimeRange::closed(Time::from_ticks(0), Time::from_ticks(4));
let candidates = |selection: &mut crate::Selection<'_>| {
let mut times = Vec::new();
let _ = selection
.scan_candidate_times(range, |time| {
times.push(time.ticks());
ControlFlow::<()>::Continue(())
})
.unwrap();
times
};
let mut selection = wave.select(&[signal]).unwrap();
let superset = candidates(&mut selection);
assert!(superset.windows(2).all(|pair| pair[0] < pair[1]));
assert!(superset.iter().all(|time| *time <= 4));
let mut changes = Vec::new();
let mut last = None;
let mut reference_selection = serial.select(&[reference]).unwrap();
let _ = reference_selection
.scan(range, |record| {
if let ScanRef::Change { time, .. } = record
&& last != Some(time)
{
last = Some(time);
changes.push(time.ticks());
}
ControlFlow::<()>::Continue(())
})
.unwrap();
for time in &changes {
assert!(superset.contains(time), "missing change {time}");
}
assert!(superset.contains(&1));
assert!(!changes.contains(&1));
let mut first = None;
let outcome = selection
.scan_candidate_times(range, |time| {
first = Some(time.ticks());
ControlFlow::Break(())
})
.unwrap();
assert!(outcome.is_break());
assert_eq!(first, Some(0));
assert_eq!(candidates(&mut selection), superset);
drop(selection);
let slice = signal.slice(1, 1).unwrap();
let mut slice_selection = wave.select(&[slice]).unwrap();
let slice_candidates = candidates(&mut slice_selection);
assert!(!slice_candidates.is_empty());
let mut byte_selection = serial.select(&[reference]).unwrap();
assert_eq!(candidates(&mut byte_selection), changes);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_indexed_traversal_keeps_selection_semantics() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("indexed-scan-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = crate::backends::vcd::traversal_test_source();
std::fs::write(&path, &source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("serial.vcd", source.as_slice().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("a").unwrap();
let noise = wave.hierarchy().signal("noise").unwrap();
let reference = serial.hierarchy().signal("a").unwrap();
let reference_noise = serial.hierarchy().signal("noise").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(std::fs::File::open(&path).unwrap(), vec![source.len()], 10);
let mut selection = wave.select(&[signal]).unwrap();
fn value(value: crate::ValueRef<'_>) -> String {
match value {
crate::ValueRef::Bits(bits) => bits.to_string(),
other => format!("{other:?}"),
}
}
let scan = |selection: &mut crate::Selection<'_>| {
let mut records = Vec::new();
let _ = selection
.scan(
TimeRange::closed(Time::from_ticks(5), Time::from_ticks(7)),
|record| {
records.push(match record {
ScanRef::Initial {
value: observed,
changed_at,
..
} => format!("initial:{}@{changed_at:?}", value(observed)),
ScanRef::Change {
time,
value: observed,
..
} => format!("change:{}:{}", time.ticks(), value(observed)),
});
ControlFlow::<()>::Continue(())
},
)
.unwrap();
records
};
let expected = {
let mut reference_selection = serial.select(&[reference]).unwrap();
scan(&mut reference_selection)
};
assert_eq!(
expected,
["initial:01@Some(Time(3))", "change:7:00"],
"the range has no net change at tick 5"
);
let before = selection.vcd_traversal_queries().unwrap();
assert_eq!(scan(&mut selection), expected);
assert!(
selection.vcd_traversal_queries().unwrap() > before,
"a sparse selection must use the indexed traversal"
);
let mut initial = None;
let _ = selection
.scan(
TimeRange::closed(Time::from_ticks(5), Time::from_ticks(7)),
|record| {
if let ScanRef::Initial {
value: observed,
changed_at,
..
} = record
{
initial = Some(format!("{}@{changed_at:?}", value(observed)));
return ControlFlow::Break(());
}
ControlFlow::Continue(())
},
)
.unwrap();
assert_eq!(initial.as_deref(), Some("01@Some(Time(3))"));
let before = selection.vcd_traversal_queries().unwrap();
assert_eq!(scan(&mut selection), expected);
assert!(
selection.vcd_traversal_queries().unwrap() > before,
"a repeat after a stop must traverse again"
);
let mut dense = wave.select(&[signal, noise]).unwrap();
let mut dense_reference = serial.select(&[reference, reference_noise]).unwrap();
let dense_expected = scan(&mut dense_reference);
let before = dense.vcd_traversal_queries().unwrap();
assert_eq!(scan(&mut dense), dense_expected);
assert_eq!(
dense.vcd_traversal_queries().unwrap(),
before,
"a dense selection must keep the walk"
);
let b = wave.hierarchy().signal("b").unwrap();
let reference_b = serial.hierarchy().signal("b").unwrap();
let bus = wave.concat(&[signal, b]).unwrap();
let reference_bus = serial.concat(&[reference, reference_b]).unwrap();
let mut computed = wave.select(&[bus.slice(2, 1).unwrap()]).unwrap();
let mut computed_reference = serial
.select(&[reference_bus.slice(2, 1).unwrap()])
.unwrap();
let computed_expected = scan(&mut computed_reference);
let before = computed.vcd_traversal_queries().unwrap();
assert_eq!(scan(&mut computed), computed_expected);
assert!(
computed.vcd_traversal_queries().unwrap() > before,
"a computed scan reads its sparse bases through the traversal"
);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_full_range_batch_uses_one_traversal() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("full-range-batch-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let mut source = Vec::from(
b"$var wire 1 ! a $end $var wire 1 n noise $end $enddefinitions $end #0 0! " as &[u8],
);
for _ in 0..30_000 {
source.extend_from_slice(b"0n ");
}
source.extend_from_slice(b"\n#1 1!\n");
std::fs::write(&path, &source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("serial.vcd", source.as_slice().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("a").unwrap();
let reference = serial.hierarchy().signal("a").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(std::fs::File::open(&path).unwrap(), vec![source.len()], 1);
let render = |rows: &[(Time, Vec<crate::Sample>)]| {
rows.iter()
.map(|(time, samples)| {
(
time.ticks(),
samples
.iter()
.map(|sample| match sample {
crate::Sample::Value {
value, changed_at, ..
} => format!("{value:?}@{changed_at:?}"),
crate::Sample::Missing { .. } => "missing".into(),
crate::Sample::Event { occurrences, .. } => {
format!("event:{occurrences}")
}
})
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>()
};
let times = [0, 1, 1, 0].map(Time::from_ticks);
let mut selection = wave.select(&[signal]).unwrap();
let mut reference_selection = serial.select(&[reference]).unwrap();
let seeded = selection.vcd_index_queries().unwrap();
let before = selection.vcd_traversal_queries().unwrap();
let rows = selection.samples_at(×).unwrap();
assert_eq!(
selection.vcd_traversal_queries().unwrap() - before,
1,
"one traversal for the whole full-range batch"
);
assert_eq!(selection.vcd_index_queries().unwrap(), seeded);
assert_eq!(
render(&rows),
render(&reference_selection.samples_at(×).unwrap())
);
let before = selection.vcd_traversal_queries().unwrap();
assert_eq!(
render(&selection.samples_at(×).unwrap()),
render(&rows)
);
assert!(selection.vcd_traversal_queries().unwrap() > before);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_bounded_tail_scan_and_batch_use_the_traversal() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("bounded-tail-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = crate::backends::vcd::bounded_tail_test_source();
std::fs::write(&path, &source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("serial.vcd", source.as_slice().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("a").unwrap();
let reference = serial.hierarchy().signal("a").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(std::fs::File::open(&path).unwrap(), vec![source.len()], 10);
fn value(value: crate::ValueRef<'_>) -> String {
match value {
crate::ValueRef::Bits(bits) => bits.to_string(),
other => format!("{other:?}"),
}
}
let scan = |selection: &mut crate::Selection<'_>| {
let mut records = Vec::new();
let _ = selection
.scan(
TimeRange::closed(Time::from_ticks(1), Time::from_ticks(2)),
|record| {
records.push(match record {
ScanRef::Initial {
value: observed,
changed_at,
..
} => format!("initial:{}@{changed_at:?}", value(observed)),
ScanRef::Change {
time,
value: observed,
..
} => format!("change:{}:{}", time.ticks(), value(observed)),
});
ControlFlow::<()>::Continue(())
},
)
.unwrap();
records
};
let handles = [signal; 100];
let references = [reference; 100];
let mut selection = wave.select(&handles).unwrap();
let mut reference_selection = serial.select(&references).unwrap();
let expected = scan(&mut reference_selection);
assert_eq!(expected.len(), 200);
let before = selection.vcd_traversal_queries().unwrap();
assert_eq!(scan(&mut selection), expected);
assert!(
selection.vcd_traversal_queries().unwrap() > before,
"a bounded tail must use the traversal"
);
let before = selection.vcd_traversal_queries().unwrap();
let point = selection.samples(Time::from_ticks(1)).unwrap();
assert_eq!(
selection.vcd_traversal_queries().unwrap(),
before,
"a point keeps the walk"
);
assert_eq!(point.len(), 100);
assert!(point.iter().all(|sample| matches!(
sample,
crate::Sample::Value { value: crate::Value::Bits(bits), .. }
if bits.as_ref().to_string() == "1"
)));
drop(selection);
let times = [0, 1, 2].map(Time::from_ticks);
let mut batch = wave.select(&[signal]).unwrap();
let mut batch_reference = serial.select(&[reference]).unwrap();
let seeded = batch.vcd_index_queries().unwrap();
let before = batch.vcd_traversal_queries().unwrap();
let rows = batch.samples_at(×).unwrap();
assert_eq!(
batch.vcd_traversal_queries().unwrap() - before,
1,
"one traversal for the whole batch"
);
assert_eq!(batch.vcd_index_queries().unwrap(), seeded);
let render = |rows: &[(Time, Vec<crate::Sample>)]| {
rows.iter()
.map(|(time, samples)| {
(
time.ticks(),
samples
.iter()
.map(|sample| match sample {
crate::Sample::Value {
value, changed_at, ..
} => format!("{value:?}@{changed_at:?}"),
crate::Sample::Missing { .. } => "missing".into(),
crate::Sample::Event { occurrences, .. } => {
format!("event:{occurrences}")
}
})
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>()
};
assert_eq!(
render(&rows),
render(&batch_reference.samples_at(×).unwrap())
);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_samples_at_seeds_the_window_without_reusing_replay() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("samples-at-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = b"$var wire 2 ! a $end $enddefinitions $end \
#2 b00 !\n#3 b01 !\n#5 b11 !\n#5 b01 !\n#7 b11 !\n#7 b00 !\n";
std::fs::write(&path, source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("serial.vcd", source.as_slice().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("a").unwrap();
let reference = serial.hierarchy().signal("a").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(std::fs::File::open(&path).unwrap(), vec![source.len()], 10);
let mut selection = wave.select(&[signal]).unwrap();
let render = |rows: &[(Time, Vec<crate::Sample>)]| {
rows.iter()
.map(|(time, samples)| {
let samples = samples
.iter()
.map(|sample| match sample {
crate::Sample::Value {
value, changed_at, ..
} => match value {
crate::Value::Bits(bits) => {
format!("{}@{:?}", bits.as_ref(), changed_at.map(Time::ticks))
}
other => format!("{other:?}@{changed_at:?}"),
},
crate::Sample::Missing { .. } => "missing".into(),
crate::Sample::Event { occurrences, .. } => {
format!("event:{occurrences}")
}
})
.collect::<Vec<_>>();
(time.ticks(), samples)
})
.collect::<Vec<_>>()
};
let _ = selection.samples(Time::from_ticks(7)).unwrap();
let probe = |selection: &crate::Selection<'_>| selection.vcd_index_queries().unwrap();
let seeded = probe(&selection);
let times = [5, 3, 5, 4, 100, 6].map(Time::from_ticks);
let rows = selection.samples_at(×).unwrap();
assert_eq!(
probe(&selection) - seeded,
1,
"one seed for the whole VCD batch"
);
let expected = [
(5, vec!["01@Some(3)".to_string()]),
(3, vec!["01@Some(3)".to_string()]),
(5, vec!["01@Some(3)".to_string()]),
(4, vec!["01@Some(3)".to_string()]),
(100, vec!["00@Some(7)".to_string()]),
(6, vec!["01@Some(3)".to_string()]),
];
assert_eq!(render(&rows), expected);
assert_eq!(
render(&rows),
render(&serial.samples_at(&[reference], ×).unwrap()),
"batch must match the chronological reference"
);
let early = [Time::from_ticks(1), Time::from_ticks(3)];
assert_eq!(
render(&selection.samples_at(&early).unwrap()),
[
(1, vec!["missing".to_string()]),
(3, vec!["01@Some(3)".to_string()])
]
);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_parallel_prefix_preserves_points_and_narrow_traces() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("parallel-query-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = b"$var wire 4 ! a $end $var wire 1 \" b $end $var event 1 # e $end \
$enddefinitions $end #0 b0000 ! 0\" 1#\n#1 b1000 !\n#2 b1100 ! 1\"\n\
#3 b1101 ! 1#\n#4 b1111 !\n#5 b0011 ! 0\" 1#\n#6 b0101 !\n";
std::fs::write(&path, source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("reference.vcd", source.as_slice().into(), "vcd-native")
.unwrap();
let cut = |marker: &[u8]| {
source
.windows(marker.len())
.position(|bytes| bytes == marker)
.unwrap()
+ 1
};
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(
std::fs::File::open(&path).unwrap(),
vec![cut(b"\n#2"), cut(b"\n#4"), source.len()],
6,
);
assert!(reader.has_index());
let names = ["a", "b", "e"];
let selected = names.map(|name| wave.hierarchy().signal(name).unwrap());
let reference = names.map(|name| serial.hierarchy().signal(name).unwrap());
let observe = |samples: Vec<Sample>| {
samples
.into_iter()
.map(|sample| match sample {
Sample::Value {
value, changed_at, ..
} => format!("{value:?}@{changed_at:?}"),
Sample::Event { occurrences, .. } => format!("event:{occurrences}"),
Sample::Missing { .. } => "missing".into(),
})
.collect::<Vec<String>>()
};
for tick in [0, 1, 2, 3, 4, 5, 6, 10] {
let time = Time::from_ticks(tick);
assert_eq!(
observe(wave.samples(&selected[..2], time).unwrap()),
observe(serial.samples(&reference[..2], time).unwrap()),
"point at {tick}",
);
assert_eq!(
observe(wave.samples(&selected, time).unwrap()),
observe(serial.samples(&reference, time).unwrap()),
"mixed event at {tick}",
);
}
let range = TimeRange::closed(Time::from_ticks(4), Time::from_ticks(5));
let observed_trace = |traces: Vec<crate::Trace>| {
traces
.into_iter()
.map(|trace| {
(
trace.initial().map(|initial| {
format!("{:?}@{:?}", initial.value(), initial.changed_at())
}),
trace
.changes()
.iter()
.map(|change| format!("{:?}:{:?}", change.time(), change.value()))
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>()
};
assert_eq!(
observed_trace(wave.traces(&selected[..2], range).unwrap()),
observed_trace(serial.traces(&reference[..2], range).unwrap()),
);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_parallel_full_preserves_order_events_slices_and_early_break() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("parallel-full-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let source = b"$var wire 4 ! a $end $var event 1 # e $end \
$var wire 1 % b $end $enddefinitions $end $dumpvars b0000 ! 1# 0% $end\n\
#0 b0010 ! 1%\n#1 b0011 ! 1# x%\n#2 b0100 ! 1# 0%\n\
#2 b1111 ! 1# 1# 1%\n#3 b1111 !\n#4 b0001 ! 1# z%\n#5 b0011 !\n";
std::fs::write(&path, source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let mut serial =
crate::open_bytes_with("reference.vcd", source.as_slice().into(), "vcd-native")
.unwrap();
let cuts = source
.windows(3)
.enumerate()
.filter_map(|(offset, bytes)| (bytes == b"\n#2").then_some(offset + 1))
.collect::<Vec<_>>();
assert_eq!(cuts.len(), 2);
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(
std::fs::File::open(&path).unwrap(),
vec![cuts[0], cuts[1], source.len()],
5,
);
reader.records_read = 0;
let select = |wave: &crate::Waveform| {
let a = wave.hierarchy().signal("a").unwrap();
[
a,
a.slice(1, 0).unwrap(),
wave.hierarchy().signal("e").unwrap(),
a,
wave.hierarchy().signal("b").unwrap(),
]
};
let selected = select(&wave);
let reference = select(&serial);
let summarize = |traces: Vec<crate::Trace>| {
traces
.into_iter()
.map(|trace| {
(
trace.initial().map(|initial| {
format!("{:?}@{:?}", initial.value(), initial.changed_at())
}),
trace
.changes()
.iter()
.map(|change| format!("{:?}:{:?}", change.time(), change.value()))
.collect::<Vec<_>>(),
)
})
.collect::<Vec<_>>()
};
for (index, range) in [
TimeRange::all(),
TimeRange::closed(Time::ZERO, Time::from_ticks(5)),
TimeRange::closed(Time::from_ticks(2), Time::from_ticks(5)),
]
.into_iter()
.enumerate()
{
let observed = wave.traces(&selected, range).unwrap();
if index == 0 {
let crate::backends::Reader::Vcd(reader) = &wave.reader else {
unreachable!()
};
assert_eq!(
reader.records_read, 0,
"full-range query must use the parallel reader"
);
}
assert_eq!(
summarize(observed),
summarize(serial.traces(&reference, range).unwrap()),
"trace {range:?}",
);
let scan = |wave: &mut crate::Waveform, signals: &[crate::Signal]| {
let mut records = Vec::new();
let _ = wave
.select(signals)
.unwrap()
.scan_each(range, |index, record| {
records.push(match record {
ScanRef::Initial {
value, changed_at, ..
} => {
format!("{index}:initial:{value:?}@{changed_at:?}")
}
ScanRef::Change { time, value, .. } => {
format!("{index}:{time:?}:{value:?}")
}
});
ControlFlow::<()>::Continue(())
})
.unwrap();
records
};
assert_eq!(scan(&mut wave, &selected), scan(&mut serial, &reference));
}
let collect = |wave: &mut crate::Waveform, signals: &[crate::Signal]| {
let mut times = Vec::new();
let _ = wave
.scan_candidate_times(signals, TimeRange::all(), |time| {
times.push(time);
ControlFlow::<()>::Continue(())
})
.unwrap();
times
};
let indexed_candidates = collect(&mut wave, &selected);
let reference_changes = collect(&mut serial, &reference);
assert!(indexed_candidates.windows(2).all(|pair| pair[0] < pair[1]));
for time in &reference_changes {
assert!(
indexed_candidates.contains(time),
"missing candidate {time:?}"
);
}
let first = |wave: &mut crate::Waveform, signals: &[crate::Signal]| {
wave.scan(signals, TimeRange::all(), |record| match record {
ScanRef::Change { time, .. } => ControlFlow::Break(time),
_ => ControlFlow::Continue(()),
})
.unwrap()
};
assert_eq!(first(&mut wave, &selected), first(&mut serial, &reference));
{
let mut prepared = wave.select(&selected).unwrap();
let mut baseline = serial.select(&reference).unwrap();
for range in [
TimeRange::all(),
TimeRange::closed(Time::from_ticks(2), Time::from_ticks(3)),
TimeRange::all(),
] {
assert_eq!(
summarize(prepared.traces(range).unwrap()),
summarize(baseline.traces(range).unwrap()),
"prepared trace {range:?}",
);
}
}
let mut serial_file = crate::open_with(&path, "vcd-native").unwrap();
let mut changed = source.to_vec();
let position = changed
.windows(b"#4 b0001 !".len())
.position(|bytes| bytes == b"#4 b0001 !")
.unwrap();
changed[position + 4] = b'q';
std::fs::write(&path, changed).unwrap();
let invalid_range = TimeRange::all();
let serial_selected = select(&serial_file);
let error = wave
.traces(&selected, invalid_range)
.err()
.expect("invalid value");
let expected = serial_file
.traces(&serial_selected, invalid_range)
.err()
.expect("invalid value");
assert_eq!(format!("{error:?}"), format!("{expected:?}"));
let mut changed = source.to_vec();
let position = changed.windows(2).position(|bytes| bytes == b"x%").unwrap();
changed[position] = b'q';
std::fs::write(&path, changed).unwrap();
let partial = |wave: &mut crate::Waveform, signals: &[crate::Signal]| {
let mut records = Vec::new();
let error = wave
.scan(signals, TimeRange::all(), |record| {
if let ScanRef::Change { time, value, .. } = record {
records.push(format!("{time:?}:{value:?}"));
}
ControlFlow::<()>::Continue(())
})
.expect_err("invalid value");
(records, format!("{error:?}"))
};
assert_eq!(
partial(&mut wave, &selected),
partial(&mut serial_file, &serial_selected)
);
assert_eq!(
first(&mut wave, &selected),
first(&mut serial_file, &serial_selected)
);
std::fs::remove_file(path).unwrap();
}
#[cfg(unix)]
#[test]
fn vcd_full_scan_breaks_with_sparse_selected_activity() {
let path = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
.join("tmp")
.join(format!("sparse-break-{}.vcd", std::process::id()));
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
let mut source = b"$var wire 1 ! selected $end $var wire 1 \" noise $end \
$enddefinitions $end #0 0! 1! 0! 1! 0! 1! 0! 1! 0! "
.to_vec();
source.extend_from_slice(b"0\" ".repeat(100_000).as_slice());
let cut = source.len() + 1;
source.extend_from_slice(b"\n#1 1! ");
source.extend_from_slice(b"1\" ".repeat(100_000).as_slice());
std::fs::write(&path, &source).unwrap();
let mut wave = crate::open_with(&path, "vcd-native").unwrap();
let signal = wave.hierarchy().signal("selected").unwrap();
let crate::backends::Reader::Vcd(reader) = &mut wave.reader else {
unreachable!()
};
reader.force_parallel_for_test(
std::fs::File::open(&path).unwrap(),
vec![cut, source.len()],
1,
);
assert_eq!(
wave.scan(&[signal], TimeRange::all(), |record| match record {
ScanRef::Change { time, .. } => ControlFlow::Break(time),
_ => ControlFlow::Continue(()),
})
.unwrap(),
ControlFlow::Break(Time::ZERO)
);
std::fs::remove_file(path).unwrap();
}
#[cfg(feature = "fsdb-lib")]
#[test]
#[ignore = "requires real FSDB runtime and installed fixtures"]
fn fsdb_checkpoint_preserves_projected_state_and_invalidates() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures");
let path = root.join("fsdb/fsdb0010-history-short/waveform.fsdb");
let Some(mut wave) =
crate::fsdb_compatibility::open(crate::open_with(&path, "fsdb-lib"), &path)
else {
return;
};
let clock = wave.hierarchy().signal("top.clock").unwrap();
let word = wave.hierarchy().signal("top.word_00").unwrap();
let signals = [
clock,
word,
word.slice(0, 0).unwrap(),
word.slice(31, 16).unwrap(),
word,
];
let mut selection = wave.select(&signals).unwrap();
fn count(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Fsdb(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.records_read
}
let time = Time::from_ticks(4000);
let _ = selection
.scan(TimeRange::point(Time::ZERO), |_| {
ControlFlow::<()>::Continue(())
})
.unwrap();
let _ = selection
.scan(TimeRange::point(time), |_| ControlFlow::<()>::Continue(()))
.unwrap();
let expected = format!("{:?}", selection.samples(time).unwrap());
let cold = count(&selection);
assert!(cold > 4000);
assert!(selection.checkpoint.is_some());
assert_eq!(format!("{:?}", selection.samples(time).unwrap()), expected);
assert!(
count(&selection) - cold < 10,
"checkpoint must avoid the source prefix"
);
let sample = selection.samples(time).unwrap();
assert!(matches!(
sample[3],
Sample::Value {
changed_at: None,
..
}
));
selection.samples(Time::from_ticks(3)).unwrap();
assert_eq!(format!("{:?}", selection.samples(time).unwrap()), expected);
let _ = selection
.scan(TimeRange::all(), |_| ControlFlow::Break(()))
.unwrap();
assert!(selection.checkpoint.is_none());
let _ = selection
.scan(TimeRange::point(Time::ZERO), |_| {
ControlFlow::<()>::Continue(())
})
.unwrap();
let before = count(&selection);
let _ = selection
.scan(TimeRange::point(time), |_| ControlFlow::<()>::Continue(()))
.unwrap();
assert_eq!(format!("{:?}", selection.samples(time).unwrap()), expected);
assert!(count(&selection) - before > 4000);
let error = selection.query(TimeRange::all(), &[0], |_| -> Result<ControlFlow<()>> {
Err(Error::Backend {
backend: "test".into(),
operation: "query",
message: "stop".into(),
})
});
assert!(error.is_err());
assert!(selection.checkpoint.is_none());
for sample_callback in [true, false] {
let _ = selection
.scan(TimeRange::point(time), |_| ControlFlow::<()>::Continue(()))
.unwrap();
selection.samples(time).unwrap();
assert!(selection.checkpoint.is_some());
let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
if sample_callback {
let _ = selection.visit_samples(time, |_| -> ControlFlow<()> {
panic!("sample callback after traversal");
});
} else {
let _ = selection.scan(
TimeRange::point(Time::from_ticks(5000)),
|_| -> ControlFlow<()> { panic!("quiet-window initial after traversal") },
);
}
}));
assert!(panic.is_err());
assert!(selection.checkpoint.is_none());
assert!(selection.replay.is_none());
}
}
#[cfg(feature = "fsdb-lib")]
#[test]
#[ignore = "requires real FSDB runtime and installed fixtures"]
fn fsdb_cold_window_matches_chronological_reference() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures");
let path = root.join("fsdb/fsdb0010-history-short/waveform.fsdb");
let Some(mut wave) =
crate::fsdb_compatibility::open(crate::open_with(&path, "fsdb-lib"), &path)
else {
return;
};
let clock = wave.hierarchy().signal("top.clock").unwrap();
let word = wave.hierarchy().signal("top.word_00").unwrap();
let signals = [clock, word, word.slice(31, 16).unwrap(), word];
let range = TimeRange::closed(Time::from_ticks(4000), Time::from_ticks(4001));
let mut chronological = wave.select(&signals).unwrap();
let _ = chronological
.scan(TimeRange::point(Time::ZERO), |_| {
ControlFlow::<()>::Continue(())
})
.unwrap();
let mut expected = Vec::new();
let _ = chronological
.scan_each(range, |index, record| {
expected.push(format!("{index}:{record:?}"));
ControlFlow::<()>::Continue(())
})
.unwrap();
drop(chronological);
let crate::backends::Reader::Fsdb(reader) = &wave.reader else {
unreachable!()
};
let before = (reader.records_read, reader.point_queries);
let mut cold = wave.select(&signals).unwrap();
let mut actual = Vec::new();
let _ = cold
.scan_each(range, |index, record| {
match (index, record) {
(
0,
ScanRef::Initial {
value: ValueRef::Bits(bits),
changed_at,
..
},
) => {
assert_eq!(bits.to_string(), "1");
assert_eq!(changed_at, Some(Time::from_ticks(3999)));
}
(
1 | 3,
ScanRef::Initial {
value: ValueRef::Bits(bits),
changed_at,
..
},
) => {
assert_eq!(bits.to_string(), format!("{:032b}", 249));
assert_eq!(changed_at, Some(Time::from_ticks(3984)));
}
(
2,
ScanRef::Initial {
value: ValueRef::Bits(bits),
changed_at: None,
..
},
) => {
assert_eq!(bits.to_string(), "0000000000000000");
}
(
1 | 3,
ScanRef::Change {
time,
value: ValueRef::Bits(bits),
..
},
) => {
assert_eq!(time, Time::from_ticks(4000));
assert_eq!(bits.to_string(), format!("{:032b}", 250));
}
(
0,
ScanRef::Change {
time,
value: ValueRef::Bits(bits),
..
},
) => {
assert_eq!(
bits.to_string(),
if time.ticks() % 2 == 0 { "0" } else { "1" }
);
}
_ => panic!("unexpected independent window record {index}: {record:?}"),
}
actual.push(format!("{index}:{record:?}"));
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(actual, expected);
let crate::backends::Reader::Fsdb(reader) = &cold.waveform.reader else {
unreachable!()
};
assert!(
reader.point_queries > before.1,
"cold window must seek entering state"
);
assert!(
reader.records_read - before.0 < 100,
"cold window must not replay the prefix: {} records",
reader.records_read - before.0
);
}
#[cfg(feature = "fsdb-lib")]
#[test]
#[ignore = "requires real FSDB runtime and installed fixtures"]
fn fsdb_cold_points_match_chronological_reference() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures");
for fixture in [
"fsdb/fsdb0010-history-short",
"fsdb/fsdb0017-typed-records",
"fsdb/fsdb0019-typed-values",
"fsdb/fsdb0020-nine-state-ranges",
] {
let path = root.join(fixture).join("waveform.fsdb");
let Some(mut wave) = crate::fsdb_compatibility::open(crate::open(&path), &path) else {
continue;
};
let mut signals = Vec::new();
for variable in wave.hierarchy().variables() {
if let Some(signal) = variable.signal()
&& let Encoding::Bits { width } = signal.encoding()
{
signals.push(signal);
signals.push(signal.slice(0, 0).unwrap());
signals.push(signal.slice(width - 1, width - 1).unwrap());
signals.push(signal);
}
}
assert!(!signals.is_empty());
for tick in [0, 1, 3, 4, 5, 16, 2048, 4000, 4001, u64::MAX] {
let time = Time::from_ticks(tick);
let mut expected: Vec<_> = signals
.iter()
.map(|&signal| Sample::Missing { signal })
.collect();
let before = match &wave.reader {
crate::backends::Reader::Fsdb(reader) => reader.point_queries,
_ => unreachable!(),
};
let _ = wave
.select(&signals)
.unwrap()
.scan_each(TimeRange::closed(Time::ZERO, time), |index, record| {
let (value, changed_at) = match record {
ScanRef::Initial {
value, changed_at, ..
} => (value, changed_at),
ScanRef::Change { value, time, .. } => (
value,
matches!(expected[index], Sample::Value { .. }).then_some(time),
),
};
expected[index] = Sample::Value {
signal: signals[index],
value: value.to_owned(),
changed_at,
};
ControlFlow::<()>::Continue(())
})
.unwrap();
let chronological_points = match &wave.reader {
crate::backends::Reader::Fsdb(reader) => reader.point_queries,
_ => unreachable!(),
};
assert_eq!(chronological_points, before, "reference must not seek");
let actual = wave.samples(&signals, time).unwrap();
assert_eq!(
format!("{actual:?}"),
format!("{expected:?}"),
"{fixture} tick {tick}"
);
if tick > 0 && tick < 6001 {
let crate::backends::Reader::Fsdb(reader) = &wave.reader else {
unreachable!()
};
assert!(
reader.point_queries > chronological_points,
"cold point must seek"
);
}
}
if fixture == "fsdb/fsdb0017-typed-records" {
let glitch = wave.hierarchy().signal("top.glitch").unwrap();
let sample = wave.sample(glitch, Time::from_ticks(1024)).unwrap();
assert!(
matches!(sample, Sample::Value { changed_at: None, ref value, .. }
if matches!(value.as_ref(), ValueRef::Bits(bits) if bits.to_string() == "0")),
"independent fixture history returns to the initial zero at tick 1024"
);
}
let range = TimeRange::closed(Time::ZERO, Time::from_ticks(6001));
let mut expected = Vec::new();
let _ = wave
.select(&signals)
.unwrap()
.scan_each(range, |index, record| {
expected.push(format!("{index}:{record:?}"));
ControlFlow::<()>::Continue(())
})
.unwrap();
let mut selection = wave.select(&signals).unwrap();
selection.samples(Time::from_ticks(6000)).unwrap();
selection.samples(Time::from_ticks(6001)).unwrap();
let mut actual = Vec::new();
let _ = selection
.scan_each(range, |index, record| {
actual.push(format!("{index}:{record:?}"));
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(
actual, expected,
"quiet point cache must not be reused as earlier entering state"
);
}
}
#[cfg(feature = "fsdb-lib")]
#[test]
#[ignore = "requires real FSDB runtime and installed fixtures"]
fn fsdb_replay_reuses_completed_point_reads() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures");
let path = root.join("fsdb/fsdb0010-history-short/waveform.fsdb");
let Some(mut wave) =
crate::fsdb_compatibility::open(crate::open_with(&path, "fsdb-lib"), &path)
else {
return;
};
let clock = wave.hierarchy().signal("top.clock").unwrap();
let word = wave.hierarchy().signal("top.word_00").unwrap();
let signals = [
clock,
word.slice(0, 0).unwrap(),
word.slice(31, 16).unwrap(),
];
let mut selection = wave.select(&signals).unwrap();
fn count(selection: &Selection<'_>) -> (usize, usize) {
let crate::backends::Reader::Fsdb(reader) = &selection.waveform.reader else {
unreachable!()
};
(reader.records_read, reader.point_queries)
}
let expected = format!("{:?}", selection.samples(Time::from_ticks(4000)).unwrap());
let before = count(&selection);
assert_eq!(
format!("{:?}", selection.samples(Time::from_ticks(4000)).unwrap()),
expected
);
assert_eq!(
count(&selection),
before,
"repeated point must not enter native traversal"
);
let next = selection.samples(Time::from_ticks(4001)).unwrap();
assert!(count(&selection).0 - before.0 <= 2);
assert!(
matches!(next[1], Sample::Value { changed_at: Some(time), .. } if time == Time::from_ticks(4000))
);
assert!(matches!(
next[2],
Sample::Value {
changed_at: None,
..
}
));
assert_eq!(
format!("{:?}", selection.samples(Time::from_ticks(4000)).unwrap()),
expected
);
selection.samples(Time::from_ticks(u64::MAX)).unwrap();
assert!(selection.replay.is_none());
assert_eq!(
format!("{:?}", selection.samples(Time::from_ticks(4000)).unwrap()),
expected
);
let path = root.join("fsdb/fsdb0017-typed-records/waveform.fsdb");
let Some(mut wave) =
crate::fsdb_compatibility::open(crate::open_with(&path, "fsdb-lib"), &path)
else {
return;
};
let event = wave.hierarchy().signal("top.trigger").unwrap();
let mut selection = wave.select(&[event]).unwrap();
let expected = format!("{:?}", selection.samples(Time::from_ticks(2048)).unwrap());
assert_eq!(
format!("{:?}", selection.samples(Time::from_ticks(2048)).unwrap()),
expected
);
assert!(selection.replay.is_none());
assert!(selection.checkpoint.is_none());
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_replay_preserves_points_and_invalidates() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/shm");
fn observe(samples: Vec<Sample>) -> Vec<String> {
samples
.iter()
.map(|sample| match sample.as_ref() {
SampleRef::Value {
value, changed_at, ..
} => format!("{value:?}@{changed_at:?}"),
SampleRef::Event { occurrences, .. } => format!("event:{occurrences}"),
SampleRef::Missing { .. } => "missing".into(),
})
.collect()
}
fn reads(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Shm(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.native_reads
}
let path = root.join("shm0080-history-short/waveform.shm");
let mut wave = crate::open_with(&path, "shm-lib").unwrap();
let mut reference = crate::open_with(&path, "shm-lib").unwrap();
let signals = |wave: &crate::Waveform| {
let phase = wave.hierarchy().signal("top.phase_0").unwrap();
let step = wave.hierarchy().signal("top.step").unwrap();
[
phase,
step.slice(0, 0).unwrap(),
step.slice(31, 16).unwrap(),
step.slice(0, 0).unwrap(),
]
};
let expected = signals(&reference);
let mut selection = wave.select(&signals(&wave)).unwrap();
for tick in [4090, 4090, 4091, 4089, 4096, 4096, 0, 63] {
let time = Time::from_ticks(tick);
let before = reads(&selection);
assert_eq!(
observe(selection.samples(time).unwrap()),
observe(reference.samples(&expected, time).unwrap())
);
let after = reads(&selection);
assert_eq!(
observe(selection.samples(time).unwrap()),
observe(reference.samples(&expected, time).unwrap())
);
assert_eq!(
reads(&selection),
after,
"repeat must not enter native traversal"
);
assert!(after >= before);
}
selection.samples(Time::from_ticks(4096)).unwrap();
let before = reads(&selection);
for tick in 4089..=4096 {
let time = Time::from_ticks(tick);
assert_eq!(
observe(selection.samples(time).unwrap()),
observe(reference.samples(&expected, time).unwrap())
);
}
assert_eq!(
reads(&selection) - before,
8,
"each query in the eight-point block traverses native histories"
);
selection.samples(Time::from_ticks(u64::MAX)).unwrap();
assert!(
selection.replay.is_none(),
"maximum tick must not wrap its position"
);
assert!(
selection
.scan(TimeRange::all(), |_| ControlFlow::Break(()))
.unwrap()
.is_break()
);
assert!(selection.replay.is_none());
let time = Time::from_ticks(31);
assert_eq!(
observe(selection.samples(time).unwrap()),
observe(reference.samples(&expected, time).unwrap())
);
let mut wave =
crate::open_with(root.join("shm0085-typed-records/waveform.shm"), "shm-lib").unwrap();
let event = wave.hierarchy().signal("top.pulse").unwrap();
let mut selection = wave.select(&[event]).unwrap();
for _ in 0..2 {
assert!(matches!(
selection.samples(Time::from_ticks(3)).unwrap()[0],
Sample::Event { occurrences: 3, .. }
));
assert!(selection.replay.is_none());
assert!(selection.checkpoint.is_none());
}
assert_eq!(reads(&selection), 2);
let mut wave =
crate::open_with(root.join("shm0089-probe-gap/waveform.shm"), "shm-lib").unwrap();
let signal = wave.hierarchy().signal("top.alias_value").unwrap();
let mut selection = wave.select(&[signal]).unwrap();
selection.samples(Time::from_ticks(1)).unwrap();
assert!(selection.samples(Time::from_ticks(10)).is_err());
assert!(selection.replay.is_none());
selection.samples(Time::from_ticks(1)).unwrap();
drop(selection);
let crate::backends::Reader::Shm(reader) = &mut wave.reader else {
unreachable!()
};
assert!(
reader
.read_from(
&[signal],
Time::from_ticks(10),
Time::from_ticks(10),
|_, _, _| { ControlFlow::<()>::Continue(()) }
)
.is_err()
);
assert!(
reader
.read(&[signal], Time::ZERO, |_, _, value| {
value.unwrap();
ControlFlow::<()>::Continue(())
})
.unwrap()
.is_continue()
);
assert_eq!(
reader
.read_from_with_resume(
&[signal],
Time::from_ticks(1),
Time::from_ticks(10),
true,
|_, time, value| {
if let Err(error) = value {
assert!(error.to_string().contains("unavailable recording interval"));
return ControlFlow::Break(time);
}
ControlFlow::Continue(())
},
)
.unwrap(),
ControlFlow::Break(Time::from_ticks(2))
);
assert!(
reader
.read(&[signal], Time::ZERO, |_, _, value| {
value.unwrap();
ControlFlow::<()>::Continue(())
})
.unwrap()
.is_continue()
);
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_cold_points_and_windows_bound_native_collection() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/shm");
fn work(wave: &crate::Waveform) -> crate::backends::shm::Work {
let crate::backends::Reader::Shm(reader) = &wave.reader else {
unreachable!()
};
reader.work()
}
for (fixture, name, tick) in [
(
"shm0001-cadence-rtl-to-gdsii-flow-gate-level-simulation-waves",
"counter_test.scan_out",
90_000,
),
(
"shm0001-cadence-rtl-to-gdsii-flow-gate-level-simulation-waves",
"counter_test.counter1.g705.A",
90_000,
),
(
"shm0006-systolic-array-pre-synthesis-simulation-waves",
"test_tpu.cycle_cnt",
4_600,
),
] {
let mut wave =
crate::open_with(root.join(fixture).join("waveform.shm"), "shm-lib").unwrap();
let signal = wave.hierarchy().signal(name).unwrap();
let repeated = if signal.encoding() == (Encoding::Bits { width: 1 }) {
signal.slice(0, 0).unwrap()
} else {
signal
};
let time = Time::from_ticks(tick);
let before = work(&wave);
let samples = wave.samples(&[signal, repeated, signal], time).unwrap();
let after = work(&wave);
assert_eq!(after.sessions - before.sessions, 1);
assert_eq!(after.histories - before.histories, 0);
assert_eq!(after.history_records - before.history_records, 0);
let reference = wave
.trace(signal, TimeRange::closed(Time::ZERO, time))
.unwrap();
let last = reference.changes().last().unwrap();
let changed = (reference.changes().len() > 1).then_some(last.time());
for sample in &samples {
let SampleRef::Value {
value, changed_at, ..
} = sample.as_ref()
else {
panic!("bits must have a recorded state");
};
assert!(value.same_value(last.value()));
assert_eq!(changed_at, changed);
}
let before = work(&wave);
let mut selection = wave.select(&[signal]).unwrap();
let result = selection
.scan(
TimeRange::closed(time, Time::from_ticks(tick + 100)),
|_| ControlFlow::Break(7),
)
.unwrap();
assert_eq!(result, ControlFlow::Break(7));
drop(selection);
let after = work(&wave);
assert_eq!(after.histories - before.histories, 1);
assert!(
after.history_records - before.history_records <= 3,
"late window must not collect the old prefix: {before:?} -> {after:?}"
);
}
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_selected_queries_avoid_unrelated_hierarchy() {
let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("fixtures/shm/shm0083-topology-many-handles/waveform.shm");
let mut wave = crate::open_with(&path, "shm-lib").unwrap();
let sparse = wave.hierarchy().signal("top.probe_sparse").unwrap();
let constant = wave.hierarchy().signal("top.probe_constant").unwrap();
let work = |wave: &crate::Waveform| {
let crate::backends::Reader::Shm(reader) = &wave.reader else {
unreachable!()
};
reader.work()
};
let opened = work(&wave);
assert!(opened.hierarchy_nodes > 16_384);
for signals in [
&[sparse][..],
&[constant][..],
&[sparse, constant, sparse][..],
] {
let before = work(&wave);
let samples = wave.samples(signals, Time::from_ticks(320)).unwrap();
assert_eq!(samples.len(), signals.len());
let after = work(&wave);
assert_eq!(after.sessions - before.sessions, 1);
assert!(
after.hierarchy_nodes - before.hierarchy_nodes < 32,
"selected access must avoid unrelated declarations: {before:?} -> {after:?}"
);
assert_eq!(after.histories, before.histories);
assert_eq!(after.history_records, before.history_records);
}
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_mixed_points_collect_only_uncertified_histories() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/shm");
let work = |wave: &crate::Waveform| {
let crate::backends::Reader::Shm(reader) = &wave.reader else {
unreachable!()
};
reader.work()
};
for reverse in [false, true] {
let mut wave =
crate::open_with(root.join("shm0080-history-short/waveform.shm"), "shm-lib")
.unwrap();
let phase = wave.hierarchy().signal("top.phase_0").unwrap();
let other = wave.hierarchy().signal("top.phase_1").unwrap();
let step = wave.hierarchy().signal("top.step").unwrap();
let mut signals = vec![phase, step, other, phase.slice(0, 0).unwrap(), step];
if reverse {
signals.reverse();
}
let time = Time::from_ticks(4095);
let before = work(&wave);
let samples = wave.samples(&signals, time).unwrap();
let after = work(&wave);
assert_eq!(after.sessions - before.sessions, 1);
assert_eq!(after.histories - before.histories, 1);
assert_eq!(after.history_records - before.history_records, 4096);
let reference = wave
.traces(&signals, TimeRange::closed(Time::ZERO, time))
.unwrap();
for ((sample, trace), signal) in samples.iter().zip(&reference).zip(signals) {
let SampleRef::Value {
signal: actual,
value,
changed_at,
} = sample.as_ref()
else {
panic!("history must have a value");
};
let last = trace.changes().last().unwrap();
assert_eq!(actual, signal);
assert!(value.same_value(last.value()));
assert_eq!(changed_at, Some(last.time()));
}
}
let mut wave =
crate::open_with(root.join("shm0091-late-history/waveform.shm"), "shm-lib").unwrap();
let marker = wave.hierarchy().signal("top.marker").unwrap();
let late = wave.hierarchy().signal("top.late").unwrap();
for tick in [4, 5, 7] {
let before = work(&wave);
let samples = wave
.samples(&[marker, late, marker], Time::from_ticks(tick))
.unwrap();
let after = work(&wave);
assert_eq!(after.sessions - before.sessions, 1);
assert_eq!(after.histories - before.histories, u64::from(tick == 4));
if tick == 4 {
assert!(matches!(samples[1], Sample::Missing { .. }));
} else {
let Sample::Value { changed_at, .. } = samples[1] else {
panic!("late history must have a value");
};
assert_eq!(changed_at, (tick > 5).then_some(Time::from_ticks(6)));
}
}
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_certified_points_preserve_completed_state() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/shm");
fn reads(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Shm(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.native_reads
}
fn observed(sample: SampleRef<'_>) -> (String, Option<Time>) {
match sample {
SampleRef::Value {
value, changed_at, ..
} => (format!("{value:?}"), changed_at),
SampleRef::Missing { .. } => ("missing".into(), None),
SampleRef::Event { .. } => panic!("persistent scalar"),
}
}
fn reference(
wave: &mut crate::Waveform,
signals: &[Signal],
end: Time,
) -> Vec<(String, Option<Time>)> {
wave.select(signals)
.unwrap()
.traces(TimeRange::closed(Time::ZERO, end))
.unwrap()
.into_iter()
.map(|trace| {
assert!(trace.initial().is_none());
trace
.changes()
.last()
.map_or(("missing".into(), None), |last| {
(
format!("{:?}", last.value()),
(trace.changes().len() > 1).then_some(last.time()),
)
})
})
.collect()
}
let mut wave =
crate::open_with(root.join("shm0085-typed-records/waveform.shm"), "shm-lib").unwrap();
let glitch = wave.hierarchy().signal("top.glitch").unwrap();
let signals = [glitch, glitch.slice(0, 0).unwrap(), glitch];
let time = Time::from_ticks(3);
let expected = reference(&mut wave, &signals, time);
for range in [
TimeRange::point(time),
TimeRange::closed(Time::from_ticks(4), Time::from_ticks(7)),
] {
let mut selection = wave.select(&signals).unwrap();
let samples = selection.samples(time).unwrap();
for (sample, &signal) in samples.iter().zip(&signals) {
assert_eq!(sample.signal(), signal);
}
assert_eq!(
samples
.iter()
.map(|s| observed(s.as_ref()))
.collect::<Vec<_>>(),
expected
);
let mut seen = Vec::new();
let _ = selection
.scan_each(range, |index, record| {
let ScanRef::Initial {
signal,
value: ValueRef::Bits(bits),
changed_at,
} = record
else {
panic!("return-to-initial glitch must emit only entering state");
};
assert_eq!(signal, signals[index]);
assert_eq!(bits.bit(0), Some(crate::Logic::Zero));
assert_eq!(changed_at, None);
seen.push(index);
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(seen, [0, 1, 2]);
}
{
let mut selection = wave.select(&signals).unwrap();
assert_eq!(
selection
.sample_visit(time, |_| ControlFlow::Break(13))
.unwrap(),
ControlFlow::Break(13)
);
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
assert_eq!(
selection
.samples(time)
.unwrap()
.iter()
.map(|s| observed(s.as_ref()))
.collect::<Vec<_>>(),
expected
);
}
{
let mut selection = wave.select(&signals).unwrap();
assert!(
std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = selection.sample_visit(time, |_| -> ControlFlow<()> {
panic!("fresh certified point callback");
});
}))
.is_err()
);
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
assert_eq!(
selection
.samples(time)
.unwrap()
.iter()
.map(|s| observed(s.as_ref()))
.collect::<Vec<_>>(),
expected
);
}
let mut other = crate::open_with(
root.join("shm0000-csce714project-project-sim-waves/waveform.shm"),
"shm-lib",
)
.unwrap();
assert_ne!(wave.metadata().timescale(), other.metadata().timescale());
let clock = other.hierarchy().signal("top.clk").unwrap();
let nested = reference(&mut other, &[clock], Time::ZERO);
{
let mut selection = wave.select(&signals).unwrap();
let mut seen = 0;
let _ = selection
.sample_visit(time, |sample| {
assert_eq!(observed(sample), expected[seen]);
assert_eq!(
observed(other.sample(clock, Time::ZERO).unwrap().as_ref()),
nested[0]
);
seen += 1;
ControlFlow::<()>::Continue(())
})
.unwrap();
assert_eq!(seen, 3);
assert_eq!(
selection
.samples(time)
.unwrap()
.iter()
.map(|s| observed(s.as_ref()))
.collect::<Vec<_>>(),
expected
);
}
let mut gap =
crate::open_with(root.join("shm0089-probe-gap/waveform.shm"), "shm-lib").unwrap();
let scalar = gap.hierarchy().signal("top.glitch").unwrap();
gap.sample(scalar, Time::from_ticks(1)).unwrap();
assert!(gap.sample(scalar, Time::from_ticks(3)).is_err());
gap.sample(scalar, Time::from_ticks(1)).unwrap();
let mut clock_wave =
crate::open_with(root.join("shm0080-history-short/waveform.shm"), "shm-lib").unwrap();
let clock = clock_wave.hierarchy().signal("top.phase_0").unwrap();
for tick in [63, 64] {
let mut selection = clock_wave.select(&[clock]).unwrap();
let sample = selection.samples(Time::from_ticks(63)).unwrap();
assert!(
matches!(sample[0].as_ref(), SampleRef::Value { changed_at: Some(at), .. } if at == Time::from_ticks(63))
);
let mut records = Vec::new();
let _ = selection
.scan(TimeRange::point(Time::from_ticks(tick)), |record| {
records.push(match record {
ScanRef::Initial {
value: ValueRef::Bits(bits),
changed_at,
..
} => (true, changed_at, bits.bit(0).unwrap()),
ScanRef::Change {
time,
value: ValueRef::Bits(bits),
..
} => (false, Some(time), bits.bit(0).unwrap()),
_ => panic!("clock must have bit records"),
});
ControlFlow::<()>::Continue(())
})
.unwrap();
let (before, after) = if tick == 63 {
(crate::Logic::Zero, crate::Logic::One)
} else {
(crate::Logic::One, crate::Logic::Zero)
};
assert_eq!(
records,
[
(true, Some(Time::from_ticks(tick - 1)), before),
(false, Some(Time::from_ticks(tick)), after)
]
);
}
let mut wave =
crate::open_with(root.join("shm0091-late-history/waveform.shm"), "shm-lib").unwrap();
let marker = wave.hierarchy().signal("top.marker").unwrap();
let late = wave.hierarchy().signal("top.late").unwrap();
let signals = [marker, late, marker.slice(0, 0).unwrap()];
for tick in [4, 5, 6, 7, 10] {
let time = Time::from_ticks(tick);
let expected = reference(&mut wave, &signals, time);
let mut selection = wave.select(&signals).unwrap();
for repeat in 0..2 {
let before = reads(&selection);
let samples = selection.samples(time).unwrap();
let expected_reads = if repeat != 0 {
0
} else if (5..=7).contains(&tick) {
1
} else {
2
};
assert_eq!(reads(&selection) - before, expected_reads);
assert_eq!(
samples
.iter()
.map(|s| observed(s.as_ref()))
.collect::<Vec<_>>(),
expected
);
}
}
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_certified_whole_points_preserve_owned_values_and_projections() {
let path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
.join("fixtures/shm/shm0084-wide-compact-toggle/waveform.shm");
let mut wave = crate::open_with(path, "shm-lib").unwrap();
let wide = wave.hierarchy().signal("top.wide").unwrap();
let control = wave.hierarchy().signal("top.control").unwrap();
fn reads(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Shm(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.native_reads
}
fn check(samples: &[Sample], signals: &[Signal], active: &[bool], tick: u64) {
assert_eq!(samples.len(), signals.len());
for ((sample, signal), active) in samples.iter().zip(signals).zip(active) {
let SampleRef::Value {
signal: sampled,
value: ValueRef::Bits(bits),
changed_at,
} = sample.as_ref()
else {
panic!("whole point must have bits");
};
assert_eq!(sampled, *signal);
let Encoding::Bits { width } = signal.encoding() else {
unreachable!()
};
assert_eq!(bits.width(), width);
for bit in 0..width {
assert_eq!(
bits.bit(bit),
Some(if *active && bit == 0 && tick % 2 == 1 {
crate::Logic::One
} else {
crate::Logic::Zero
})
);
}
assert_eq!(
changed_at,
(*active && tick > 0).then_some(Time::from_ticks(tick))
);
}
}
let signals = [wide, control, wide];
for tick in [0, 1, 4088, 4096] {
let mut selection = wave.select(&signals).unwrap();
let before = reads(&selection);
let samples = selection.samples(Time::from_ticks(tick)).unwrap();
assert_eq!(reads(&selection) - before, 1);
check(&samples, &signals, &[true; 3], tick);
drop(selection);
wave.sample(control, Time::from_ticks(2)).unwrap();
check(&samples, &signals, &[true; 3], tick);
}
let mixed = [wide, wide.slice(4095, 1).unwrap()];
let mut selection = wave.select(&mixed).unwrap();
for repeat in 0..2 {
let before = reads(&selection);
let samples = selection.samples(Time::from_ticks(4089)).unwrap();
assert_eq!(reads(&selection) - before, usize::from(repeat == 0));
check(&samples, &mixed, &[true, false], 4089);
}
drop(selection);
for (start, end, expected_initial) in [(4088, 4088, 4087), (4089, 4090, 4088)] {
let mut selection = wave.select(&[wide]).unwrap();
selection.samples(Time::from_ticks(4088)).unwrap();
let mut changes = start;
let mut initials = 0;
let outcome = selection
.scan(
TimeRange::closed(Time::from_ticks(start), Time::from_ticks(end)),
|record| {
let (value, tick) = match record {
ScanRef::Initial {
value, changed_at, ..
} => {
assert_eq!(initials, 0);
initials += 1;
assert_eq!(changed_at, Some(Time::from_ticks(expected_initial)));
(value, expected_initial)
}
ScanRef::Change { value, time, .. } => {
assert_eq!(time.ticks(), changes);
changes += 1;
(value, time.ticks())
}
};
let ValueRef::Bits(bits) = value else {
panic!("whole scan must have bits")
};
assert_eq!(bits.width(), 4096);
for bit in 0..4096 {
assert_eq!(
bits.bit(bit),
Some(if bit == 0 && tick % 2 == 1 {
crate::Logic::One
} else {
crate::Logic::Zero
})
);
}
ControlFlow::<()>::Continue(())
},
)
.unwrap();
assert!(outcome.is_continue());
assert_eq!(initials, 1);
assert_eq!(changes, end + 1);
}
}
#[cfg(feature = "shm-lib")]
#[test]
#[ignore = "requires real SHM runtime and installed fixtures"]
fn shm_cached_points_preserve_types_and_callbacks() {
let root = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fixtures/shm");
fn value(value: ValueRef<'_>) -> String {
match value {
ValueRef::Real(real) => format!("real:{:016x}", real.to_bits()),
_ => format!("{value:?}"),
}
}
fn observe(samples: Vec<Sample>) -> Vec<String> {
samples
.iter()
.map(|sample| match sample.as_ref() {
SampleRef::Value {
value: v,
changed_at,
..
} => format!("{}@{changed_at:?}", value(v)),
SampleRef::Missing { .. } => "missing".into(),
SampleRef::Event { .. } => panic!("persistent selection"),
})
.collect()
}
fn reads(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Shm(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.native_reads
}
fn scanned(
selection: &mut Selection<'_>,
range: TimeRange,
) -> Vec<(usize, bool, Option<Time>, String)> {
let mut records = Vec::new();
let _ = selection
.scan_each(range, |index, record| {
records.push(match record {
ScanRef::Initial {
value: v,
changed_at,
..
} => (index, true, changed_at, value(v)),
ScanRef::Change { time, value: v, .. } => {
(index, false, Some(time), value(v))
}
});
ControlFlow::<()>::Continue(())
})
.unwrap();
records
}
let path = root.join("shm0085-typed-records/waveform.shm");
let mut wave = crate::open_with(&path, "shm-lib").unwrap();
let mut reference = crate::open_with(&path, "shm-lib").unwrap();
let signals = |wave: &crate::Waveform| {
[
"top.glitch",
"top.alias_value",
"top.real_value",
"top.text_short",
"top.text_long",
]
.map(|name| wave.hierarchy().signal(name).unwrap())
};
let expected_signals = signals(&reference);
let mut selection = wave.select(&signals(&wave)).unwrap();
for tick in [0, 3, 4, 5, 6, 7] {
let time = Time::from_ticks(tick);
let expected = observe(reference.samples(&expected_signals, time).unwrap());
assert_eq!(observe(selection.samples(time).unwrap()), expected);
let before = reads(&selection);
let repeated = selection.samples(time).unwrap();
assert_eq!(observe(repeated), expected);
assert_eq!(reads(&selection), before);
if tick == 3 {
assert!(matches!(
selection.samples(time).unwrap()[0],
Sample::Value {
changed_at: None,
..
}
));
}
if tick == 4 {
assert!(
matches!(selection.samples(time).unwrap()[1], Sample::Value { changed_at: Some(t), .. } if t == Time::from_ticks(3))
);
}
}
let time = Time::from_ticks(7);
assert_eq!(
selection
.visit_samples(time, |_| ControlFlow::Break(7))
.unwrap(),
ControlFlow::Break(7)
);
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
selection.samples(time).unwrap();
let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = selection.visit_samples(time, |_| -> ControlFlow<()> {
panic!("cached sample callback")
});
}));
assert!(panic.is_err());
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
assert_eq!(
observe(selection.samples(time).unwrap()),
observe(reference.samples(&expected_signals, time).unwrap())
);
let before = reads(&selection);
selection.samples(time).unwrap();
assert_eq!(reads(&selection), before);
let actual = scanned(&mut selection, TimeRange::point(time));
let expected = scanned(
&mut reference.select(&expected_signals).unwrap(),
TimeRange::point(time),
);
assert_eq!(actual, expected);
let window = TimeRange::closed(Time::from_ticks(3), time);
let expected = scanned(&mut reference.select(&expected_signals).unwrap(), window);
for _ in 0..2 {
assert_eq!(scanned(&mut selection, window), expected);
}
assert!(
selection
.scan(window, |_| ControlFlow::Break(()))
.unwrap()
.is_break()
);
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
assert_eq!(scanned(&mut selection, window), expected);
let panic = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
let _ = selection.scan(window, |_| -> ControlFlow<()> {
panic!("cached scan callback")
});
}));
assert!(panic.is_err());
assert!(selection.replay.is_none() && selection.checkpoint.is_none());
assert_eq!(scanned(&mut selection, window), expected);
let mut wave =
crate::open_with(root.join("shm0091-late-history/waveform.shm"), "shm-lib").unwrap();
let late = wave.hierarchy().signal("top.late").unwrap();
let mut selection = wave.select(&[late]).unwrap();
for (tick, expected, changed) in [
(4, None, None),
(5, Some("0"), None),
(6, Some("1"), Some(Time::from_ticks(6))),
(7, Some("1"), Some(Time::from_ticks(6))),
] {
let time = Time::from_ticks(tick);
selection.samples(time).unwrap();
let before = reads(&selection);
let repeated = selection.samples(time).unwrap();
assert_eq!(reads(&selection), before);
match repeated[0].as_ref() {
SampleRef::Missing { .. } => assert!(expected.is_none()),
SampleRef::Value {
value: ValueRef::Bits(bits),
changed_at,
..
} => {
assert_eq!(Some(bits.to_string().as_str()), expected);
assert_eq!(changed_at, changed);
}
_ => panic!("unexpected delayed sample"),
}
}
}
#[test]
fn vcd_replay_avoids_prefix_and_invalidates_on_stop() {
let mut text = String::from("$var wire 1 ! bit $end $enddefinitions $end ");
for tick in 0..100 {
text.push_str(&format!("#{tick} {}! ", tick % 2));
}
let mut wave =
crate::open_bytes_with("replay.vcd", text.into_bytes().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("bit").unwrap();
let mut selection = wave.select(&[signal]).unwrap();
fn count(selection: &Selection<'_>) -> usize {
let crate::backends::Reader::Vcd(reader) = &selection.waveform.reader else {
unreachable!()
};
reader.records_read
}
let before = count(&selection);
selection.samples(Time::from_ticks(90)).unwrap();
assert_eq!(count(&selection) - before, 91);
let before = count(&selection);
selection.samples(Time::from_ticks(90)).unwrap();
assert_eq!(count(&selection), before);
selection.samples(Time::from_ticks(92)).unwrap();
assert_eq!(count(&selection) - before, 2);
let before = count(&selection);
selection.samples(Time::from_ticks(91)).unwrap();
assert_eq!(count(&selection) - before, 92);
let _ = selection
.visit_samples(Time::from_ticks(92), |_| ControlFlow::Break(()))
.unwrap();
assert!(selection.replay.is_none());
let _ = selection
.query(TimeRange::all(), &[0], |_| Ok(ControlFlow::Break(())))
.unwrap();
assert!(selection.replay.is_none());
let error = selection.query(TimeRange::all(), &[0], |_| -> Result<ControlFlow<()>> {
Err(Error::Backend {
backend: "test".into(),
operation: "query",
message: "stop".into(),
})
});
assert!(error.is_err());
assert!(selection.replay.is_none());
let before = count(&selection);
selection.samples(Time::from_ticks(92)).unwrap();
assert_eq!(count(&selection) - before, 93);
}
#[test]
fn vcd_missing_state_reuses_position_and_initial_break_discards_it() {
let mut text = String::from(
"$var wire 1 ! bit $end $var wire 1 m missing $end $var wire 1 d delayed $end $enddefinitions $end ",
);
for tick in 0..100 {
text.push_str(&format!("#{tick} {}! ", tick % 2));
}
text.push_str("#100 1d");
let mut wave =
crate::open_bytes_with("missing.vcd", text.into_bytes().into(), "vcd-native").unwrap();
let signals = [
wave.hierarchy().signal("missing").unwrap(),
wave.hierarchy().signal("delayed").unwrap(),
];
let mut selection = wave.select(&signals).unwrap();
selection.samples(Time::from_ticks(90)).unwrap();
let count = match &selection.waveform.reader {
crate::backends::Reader::Vcd(reader) => reader.records_read,
_ => unreachable!(),
};
selection.samples(Time::from_ticks(90)).unwrap();
selection.samples(Time::from_ticks(92)).unwrap();
let crate::backends::Reader::Vcd(reader) = &selection.waveform.reader else {
unreachable!()
};
assert_eq!(reader.records_read - count, 2);
let samples = selection.samples(Time::from_ticks(100)).unwrap();
assert!(matches!(samples[0], Sample::Missing { .. }));
assert!(matches!(
samples[1],
Sample::Value {
changed_at: None,
..
}
));
let _ = selection
.scan_each(
TimeRange::closed(Time::from_ticks(101), Time::from_ticks(102)),
|_, _| ControlFlow::Break(()),
)
.unwrap();
assert!(selection.replay.is_none());
selection.samples(Time::from_ticks(102)).unwrap();
assert!(selection.replay.is_some());
}
#[test]
fn vcd_boundary_checkpoint_skips_prefix_and_is_bounded() {
let mut text = String::from("$var wire 1 ! bit $end $enddefinitions $end ");
for tick in 0..1000 {
text.push_str(&format!("#{tick} {}! ", tick % 2));
}
let mut wave =
crate::open_bytes_with("checkpoint.vcd", text.into_bytes().into(), "vcd-native")
.unwrap();
let signal = wave.hierarchy().signal("bit").unwrap();
let mut selection = wave.select(&[signal]).unwrap();
let range = TimeRange::closed(Time::from_ticks(900), Time::from_ticks(910));
selection.traces(range).unwrap();
let bytes = checkpoint_bytes(&selection.checkpoint.as_ref().unwrap().slots);
eprintln!("single-signal checkpoint storage: {bytes} bytes");
assert!(bytes <= CHECKPOINT_BYTES);
let before = match &selection.waveform.reader {
crate::backends::Reader::Vcd(reader) => reader.records_read,
_ => unreachable!(),
};
selection.traces(range).unwrap();
let crate::backends::Reader::Vcd(reader) = &selection.waveform.reader else {
unreachable!()
};
assert_eq!(reader.records_read - before, 11);
assert_eq!(
checkpoint_bytes(&selection.checkpoint.as_ref().unwrap().slots),
bytes
);
let _ = selection
.query(range, &[0], |_| Ok(ControlFlow::Break(())))
.unwrap();
assert!(selection.checkpoint.is_none());
let text = format!(
"$var wire {} ! wide $end $enddefinitions $end #0 b0 ! #1 b1 !",
CHECKPOINT_BYTES
);
let mut wave =
crate::open_bytes_with("budget.vcd", text.into_bytes().into(), "vcd-native").unwrap();
let signal = wave.hierarchy().signal("wide").unwrap();
let mut selection = wave.select(&[signal]).unwrap();
selection.samples(Time::from_ticks(1)).unwrap();
assert!(selection.checkpoint.is_none());
assert!(selection.replay.is_some()); }
#[test]
fn completed_tick_moves_pending_storage_after_the_callback() {
let pending: Box<str> = "x".repeat(4096).into();
let address = pending.as_ptr();
let mut slots = [Slot {
state: Some(State {
value: Value::String("old".into()),
changed_at: None,
}),
pending: Some(Value::String(pending)),
..Slot::default()
}];
let _ = complete_tick(
&[],
&[],
&mut slots,
&mut vec![0],
Time::from_ticks(1),
None,
&mut |_, _, slots| {
assert!(matches!(
slots[0].state.as_ref().unwrap().value.as_ref(),
ValueRef::String("old")
));
assert!(slots[0].changed);
Ok(ControlFlow::<()>::Continue(()))
},
)
.unwrap();
let Value::String(retained) = &slots[0].state.as_ref().unwrap().value else {
panic!("string")
};
assert_eq!(
retained.as_ptr(),
address,
"commit must not copy the pending payload"
);
assert_eq!(
slots[0].state.as_ref().unwrap().changed_at,
Some(Time::from_ticks(1))
);
assert!(slots[0].pending.is_none());
}
#[test]
fn zero_events_do_not_activate_duplicate_slots() {
let mut records = vec![(0, 0, Value::Event { occurrences: 0 }); 100];
records.push((0, 1, Value::Event { occurrences: 2 }));
let mut wave = Waveform::memory(vec![Encoding::Event], records, None);
let signal = wave.hierarchy().signals().next().unwrap();
assert!(matches!(
wave.sample(signal, Time::from_ticks(1)).unwrap(),
Sample::Event { occurrences: 2, .. }
));
}
#[test]
fn completed_tick_callback_reads_before_and_final_state_and_can_fail() {
for fail in [false, true] {
let mut wave = Waveform::memory(
vec![Encoding::Real, Encoding::Event],
vec![
(0, 0, Value::Real(1.0)),
(0, 0, Value::Real(2.0)),
(1, 0, Value::Event { occurrences: 1 }),
(1, 0, Value::Event { occurrences: 1 }),
(0, 3, Value::Real(3.0)),
],
None,
);
let signals = wave.hierarchy().signals().collect::<Vec<_>>();
let mut selection = wave.select(&signals).unwrap();
let mut slots = [Slot::default(), Slot::default()];
let mut ticks = Vec::new();
let result =
selection.read_ticks(Time::from_ticks(3), &mut slots, |time, entries, slots| {
assert_eq!(entries, signals);
ticks.push(time.ticks());
if time == Time::ZERO {
assert!(slots[0].state.is_none());
assert!(matches!(slots[0].pending, Some(Value::Real(2.0))));
assert_eq!(slots[1].events, 2);
} else {
assert!(matches!(
slots[0].state.as_ref().unwrap().value,
Value::Real(2.0)
));
assert!(matches!(slots[0].pending, Some(Value::Real(3.0))));
assert_eq!(slots[1].events, 0);
if fail {
return Err(Error::Backend {
backend: "memory".into(),
operation: "tick visitor",
message: "injected consumer failure".into(),
});
}
}
Ok(ControlFlow::<()>::Continue(()))
});
assert_eq!(ticks, [0, 3]);
if fail {
assert!(matches!(
result,
Err(Error::Backend {
operation: "tick visitor",
..
})
));
assert!(matches!(
slots[0].state.as_ref().unwrap().value,
Value::Real(2.0)
));
} else {
assert_eq!(result.unwrap(), ControlFlow::Continue(()));
assert!(matches!(
slots[0].state.as_ref().unwrap().value,
Value::Real(3.0)
));
}
let mut fresh = [Slot::default(), Slot::default()];
let _ = selection
.read_ticks(Time::from_ticks(3), &mut fresh, |_, _, _| {
Ok(ControlFlow::<()>::Continue(()))
})
.unwrap();
assert!(matches!(
fresh[0].state.as_ref().unwrap().value,
Value::Real(3.0)
));
assert_eq!(
fresh[0].state.as_ref().unwrap().changed_at,
Some(Time::from_ticks(3))
);
}
}
}