740 lines
26 KiB
Rust
740 lines
26 KiB
Rust
use std::fmt;
|
|
|
|
// Copyright (C) 2022 Yehowshua Immanuel
|
|
// This program is distributed under both the GPLV3 license
|
|
// and the YEHOWSHUA license, both of which can be found at
|
|
// the root of the folder containing the sources for this program.
|
|
use super::types;
|
|
use super::types::SignalIdx;
|
|
use num::BigUint;
|
|
|
|
// Index to the least significant byte of a timestamp
|
|
// value on the timeline
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct LsbIdxOfTmstmpValOnTmln(pub(super) u32);
|
|
|
|
#[derive(Debug, Eq, PartialEq, Clone)]
|
|
pub enum SignalType {
|
|
Event,
|
|
Integer,
|
|
Parameter,
|
|
Real,
|
|
RealTime,
|
|
Reg,
|
|
Str,
|
|
Supply0,
|
|
Supply1,
|
|
Time,
|
|
Tri,
|
|
TriAnd,
|
|
TriOr,
|
|
TriReg,
|
|
Tri0,
|
|
Tri1,
|
|
WAnd,
|
|
Wire,
|
|
WOr,
|
|
SVLogic,
|
|
SVInt,
|
|
SVShortInt,
|
|
SVLongInt,
|
|
SVChar,
|
|
SVBit,
|
|
SVShortReal,
|
|
}
|
|
|
|
#[derive(Debug, PartialEq)]
|
|
pub enum SignalValue {
|
|
BigUint(BigUint),
|
|
String(String),
|
|
}
|
|
|
|
impl fmt::Display for SignalValue {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
SignalValue::BigUint(num) => { write!(f, "BigUnit: {num}") }
|
|
SignalValue::String(val) => {write!(f, "String: {val}")}
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct QueryResult<T> {
|
|
pub current: Option<(TimeStamp, T)>,
|
|
pub next: Option<TimeStamp>,
|
|
}
|
|
|
|
impl fmt::Display for QueryResult<SignalValue> {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
write!(f, "(current: {:?}, next: {:?})", self.current, self.next)
|
|
}
|
|
}
|
|
|
|
pub struct Signal<'a>(pub(super) &'a SignalEnum);
|
|
|
|
impl<'a> Signal<'a> {
|
|
pub fn name(&self) -> String {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum.name()
|
|
}
|
|
|
|
pub fn name_with_index(&self) -> String {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum.name_with_index()
|
|
}
|
|
|
|
pub fn index(&self) -> Option<String> {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum.index()
|
|
}
|
|
|
|
pub fn path(&self) -> &[String] {
|
|
match self.0 {
|
|
SignalEnum::Data { path, .. } => path,
|
|
SignalEnum::Alias { path, .. } => path,
|
|
}
|
|
}
|
|
|
|
pub fn signal_type(&self) -> Option<&SignalType> {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum.signal_type()
|
|
}
|
|
|
|
pub fn real_idx(&self) -> SignalIdx {
|
|
match self.0 {
|
|
SignalEnum::Data { self_idx, .. } => *self_idx,
|
|
SignalEnum::Alias { signal_alias, .. } => *signal_alias,
|
|
}
|
|
}
|
|
|
|
pub fn num_bits(&self) -> Option<u32> {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum.bits_required()
|
|
}
|
|
|
|
// NOTE: (zoq) I am removing thse because they aren't used in Surfer so I can't test them
|
|
// properly
|
|
/*
|
|
pub fn query_string_val_on_tmln(
|
|
&self,
|
|
desired_time: &BigUint,
|
|
vcd: &types::VCD,
|
|
) -> Result<String, SignalErrors> {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum
|
|
.query_string_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals)
|
|
.map(|QueryResult{current, next: _}| current.map(|c| c.1))
|
|
}
|
|
|
|
pub fn query_num_val_on_tmln(
|
|
&self,
|
|
desired_time: &BigUint,
|
|
vcd: &types::VCD,
|
|
) -> Result<Option<BigUint>, SignalErrors> {
|
|
let Signal(signal_enum) = &self;
|
|
signal_enum
|
|
.query_num_val_on_tmln(desired_time, &vcd.tmstmps_encoded_as_u8s, &vcd.all_signals)
|
|
.map(|QueryResult{current, next: _}| current.map(|c| c.1))
|
|
}
|
|
*/
|
|
|
|
pub fn query_val_on_tmln(
|
|
&self,
|
|
desired_time: &BigUint,
|
|
vcd: &types::VCD,
|
|
) -> Result<QueryResult<SignalValue>, SignalErrors> {
|
|
let Signal(signal_enum) = &self;
|
|
let num_query_out = signal_enum.query_num_val_on_tmln(
|
|
desired_time,
|
|
&vcd.tmstmps_encoded_as_u8s,
|
|
&vcd.all_signals,
|
|
);
|
|
let str_query_out = signal_enum.query_string_val_on_tmln(
|
|
desired_time,
|
|
&vcd.tmstmps_encoded_as_u8s,
|
|
&vcd.all_signals,
|
|
);
|
|
|
|
// Both num and str will return the newest value that is closest to
|
|
// the desired time. If both have valid values, select the most recent
|
|
// one
|
|
match (num_query_out, str_query_out) {
|
|
(Ok(num_result), Ok(str_result)) => {
|
|
let next = match (num_result.next, str_result.next) {
|
|
(Some(n), Some(s)) => Some(n.min(s)),
|
|
(Some(n), None) => Some(n),
|
|
(None, Some(s)) => Some(s),
|
|
(None, None) => None,
|
|
};
|
|
|
|
match (num_result.current, str_result.current) {
|
|
(Some((num_time, num_value)), Some((str_time, str_value))) => {
|
|
if num_time > str_time {
|
|
Ok(QueryResult {
|
|
current: Some((num_time, SignalValue::BigUint(num_value))),
|
|
next,
|
|
})
|
|
} else {
|
|
Ok(QueryResult {
|
|
current: Some((str_time, SignalValue::String(str_value))),
|
|
next,
|
|
})
|
|
}
|
|
}
|
|
(Some((num_time, num_val)), None) => Ok(QueryResult {
|
|
current: Some((num_time, SignalValue::BigUint(num_val))),
|
|
next,
|
|
}),
|
|
(None, Some((str_time, str_value))) => Ok(QueryResult {
|
|
current: Some((str_time, SignalValue::String(str_value))),
|
|
next,
|
|
}),
|
|
(None, None) => Ok(QueryResult {
|
|
current: None,
|
|
next,
|
|
}),
|
|
}
|
|
}
|
|
(_e, Err(e)) => Err(e),
|
|
(Err(e), _e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub(super) enum SignalEnum {
|
|
Data {
|
|
name: String,
|
|
path: Vec<String>,
|
|
signal_type: SignalType,
|
|
/// The optional [start:end] part of the signal name that is sometimes
|
|
/// added to signals
|
|
index: Option<String>,
|
|
/// I've seen a 0 bit signal parameter in a xilinx
|
|
/// simulation before that gets assigned 1 bit values.
|
|
/// I consider this to be bad behavior. We capture such
|
|
/// errors in the following type:
|
|
signal_error: Option<String>,
|
|
num_bits: Option<u32>,
|
|
num_bytes: Option<u16>,
|
|
/// TODO : may be able to remove self_idx
|
|
self_idx: SignalIdx,
|
|
/// A signal may take on a new value and hold that value
|
|
/// for sometime. We only need to record the value of a signal
|
|
/// when it changes(the is what VCDs tend to do).
|
|
/// A signal may need x amount of bytes to record its largest
|
|
/// possible value, so we record every single value of a given
|
|
/// signal as a sequence of x number of u8s.
|
|
/// For example, we might find that `my_signal.
|
|
/// nums_encoded_as_fixed_width_le_u8`
|
|
/// has two 32 bit values, namely, 1 and 2, encoded as follows:
|
|
/// my_signal.nums_encoded_as_fixed_width_le_u8 = vec![1u8, 0u8,
|
|
/// 0u8, 0u8, 2u8, 0u8, 0u8, 0u8];
|
|
nums_encoded_as_fixed_width_le_u8: Vec<u8>,
|
|
string_vals: Vec<String>,
|
|
/// we could do Vec<(LsbIdxOfTmstmpValOnTmln, u8)>, but I
|
|
/// suspect that Vec<LsbIdxOfTmstmpValOnTmln> is more cache
|
|
/// friendly. We use ``LsbIdxOfTmstmpValOnTmln`` to index into
|
|
/// the LSB of a particular timestamp encoded as the
|
|
/// minimum length u8 sequence within
|
|
/// ``vcd.tmstmps_encoded_as_u8s``, and we use the values in
|
|
/// ``byte_len_of_num_tmstmp_vals_on_tmln`` to determine how
|
|
/// many u8 values a particular timestamp is composed of.
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln: Vec<LsbIdxOfTmstmpValOnTmln>,
|
|
byte_len_of_num_tmstmp_vals_on_tmln: Vec<u8>,
|
|
byte_len_of_string_tmstmp_vals_on_tmln: Vec<u8>,
|
|
lsb_indxs_of_string_tmstmp_vals_on_tmln: Vec<LsbIdxOfTmstmpValOnTmln>,
|
|
},
|
|
Alias {
|
|
name: String,
|
|
path: Vec<String>,
|
|
signal_alias: SignalIdx,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum SignalErrors {
|
|
EmptyTimeline,
|
|
TimelineNotMultiple,
|
|
StrTmlnLenMismatch,
|
|
OrderingFailure {
|
|
lhs_time: BigUint,
|
|
mid_time: BigUint,
|
|
rhs_time: BigUint,
|
|
},
|
|
PointsToAlias,
|
|
NoNumBytes,
|
|
Other(String),
|
|
}
|
|
|
|
// these are thin type aliases primarily to make code more readable later on
|
|
type TimeStamp = BigUint;
|
|
type SignalValNum = BigUint;
|
|
|
|
// getter functions
|
|
impl SignalEnum {
|
|
pub fn name(&self) -> String {
|
|
match self {
|
|
SignalEnum::Data { name, .. } => name,
|
|
SignalEnum::Alias { name, .. } => name,
|
|
}
|
|
.clone()
|
|
}
|
|
|
|
pub fn signal_type(&self) -> Option<&SignalType> {
|
|
match self {
|
|
SignalEnum::Data { signal_type, .. } => Some(signal_type),
|
|
// TODO: Follow aliases?
|
|
SignalEnum::Alias { .. } => None,
|
|
}
|
|
.clone()
|
|
}
|
|
|
|
pub fn name_with_index(&self) -> String {
|
|
match self {
|
|
SignalEnum::Data {
|
|
name, index: None, ..
|
|
} => format!("{name}"),
|
|
SignalEnum::Data {
|
|
name,
|
|
index: Some(size),
|
|
..
|
|
} => format!("{name} {size}"),
|
|
SignalEnum::Alias { name, .. } => name.clone(),
|
|
}
|
|
}
|
|
|
|
pub fn index(&self) -> Option<String> {
|
|
match self {
|
|
SignalEnum::Data { index, .. } => index.clone(),
|
|
SignalEnum::Alias { .. } => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
// helper functions ultimately used by Signal's query functions later on
|
|
impl SignalEnum {
|
|
/// Computes the bytes required to store a signal's numerical value
|
|
/// using the num_bits which another function would provide from
|
|
/// the num_bits field of the Signal::Data variant.
|
|
pub(super) fn bytes_required(num_bits: u32, name: &String) -> Result<u16, String> {
|
|
let bytes_required = (num_bits / 8) + if (num_bits % 8) > 0 { 1 } else { 0 };
|
|
let bytes_required = u16::try_from(bytes_required).map_err(|_| {
|
|
format!(
|
|
"Error near {}:{}. Signal {name} of length num_bits requires \
|
|
{bytes_required} > 65536 bytes.",
|
|
file!(),
|
|
line!()
|
|
)
|
|
})?;
|
|
Ok(bytes_required)
|
|
}
|
|
/// This function takes an event_idx which(is used to index into the
|
|
/// global timeline field of a VCD struct instance) and computes
|
|
/// the time pointed at by event_idx.
|
|
/// This function also uses the same idx to index into the
|
|
/// string_vals field of an instance of the Signal::Data variant
|
|
/// and gets a string value.
|
|
/// The function returns a tuple of the timestamp and string value.
|
|
fn time_and_str_val_at_event_idx(
|
|
&self,
|
|
event_idx: usize,
|
|
tmstmps_encoded_as_u8s: &Vec<u8>,
|
|
) -> Result<(TimeStamp, &str), SignalErrors> {
|
|
let (
|
|
string_vals,
|
|
lsb_indxs_of_string_tmstmp_vals_on_tmln,
|
|
byte_len_of_string_tmstmp_vals_on_tmln,
|
|
) = match self {
|
|
SignalEnum::Data {
|
|
string_vals,
|
|
lsb_indxs_of_string_tmstmp_vals_on_tmln,
|
|
byte_len_of_string_tmstmp_vals_on_tmln,
|
|
..
|
|
} => Ok((
|
|
string_vals,
|
|
lsb_indxs_of_string_tmstmp_vals_on_tmln,
|
|
byte_len_of_string_tmstmp_vals_on_tmln,
|
|
)),
|
|
SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
|
|
}?;
|
|
|
|
// get index
|
|
let LsbIdxOfTmstmpValOnTmln(timestamp_idx) =
|
|
lsb_indxs_of_string_tmstmp_vals_on_tmln[event_idx];
|
|
let timestamp_idx = timestamp_idx as usize;
|
|
|
|
if byte_len_of_string_tmstmp_vals_on_tmln.is_empty() {
|
|
return Err(SignalErrors::EmptyTimeline);
|
|
}
|
|
|
|
// form timestamp
|
|
let byte_len = byte_len_of_string_tmstmp_vals_on_tmln[event_idx] as usize;
|
|
let timestamp = &tmstmps_encoded_as_u8s[timestamp_idx..(timestamp_idx + byte_len)];
|
|
let timestamp = BigUint::from_bytes_le(timestamp);
|
|
|
|
// get signal value
|
|
let signal_val = string_vals[event_idx].as_str();
|
|
|
|
Ok((timestamp, signal_val))
|
|
}
|
|
/// This function takes an event_idx which(is used to index into the
|
|
/// global timeline field of a VCD struct instance) and computes
|
|
/// the time pointed at by event_idx.
|
|
/// This function also uses the same idx to index into the
|
|
/// nums_encoded_as_fixed_width_le_u8 and
|
|
/// byte_len_of_num_tmstmp_vals_on_tmln fields of an instance
|
|
/// of the Signal::Data variant to compute the signal's corresponding
|
|
/// numerical value at the time pointed at by event_didx.
|
|
/// The function returns a tuple of the timestamp and numerical
|
|
/// value.
|
|
fn time_and_num_val_at_event_idx(
|
|
&self,
|
|
event_idx: usize,
|
|
tmstmps_encoded_as_u8s: &Vec<u8>,
|
|
) -> Result<(TimeStamp, SignalValNum), SignalErrors> {
|
|
let (
|
|
num_bytes,
|
|
nums_encoded_as_fixed_width_le_u8,
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln,
|
|
byte_len_of_num_tmstmp_vals_on_tmln,
|
|
) = match self {
|
|
SignalEnum::Data {
|
|
num_bytes,
|
|
nums_encoded_as_fixed_width_le_u8,
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln,
|
|
byte_len_of_num_tmstmp_vals_on_tmln,
|
|
..
|
|
} => Ok((
|
|
num_bytes,
|
|
nums_encoded_as_fixed_width_le_u8,
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln,
|
|
byte_len_of_num_tmstmp_vals_on_tmln,
|
|
)),
|
|
SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
|
|
}?;
|
|
|
|
// get index
|
|
let LsbIdxOfTmstmpValOnTmln(timestamp_idx) =
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln[event_idx];
|
|
let timestamp_idx = timestamp_idx as usize;
|
|
|
|
// form timestamp
|
|
let byte_len = byte_len_of_num_tmstmp_vals_on_tmln[event_idx] as usize;
|
|
let timestamp = &tmstmps_encoded_as_u8s[timestamp_idx..(timestamp_idx + byte_len)];
|
|
let timestamp = BigUint::from_bytes_le(timestamp);
|
|
|
|
// get signal value
|
|
let bytes_per_value = num_bytes.ok_or_else(|| SignalErrors::NoNumBytes)?;
|
|
let bytes_per_value = bytes_per_value as usize;
|
|
let start_idx = event_idx * bytes_per_value;
|
|
let end_idx = (event_idx + 1) * bytes_per_value;
|
|
let signal_val = &nums_encoded_as_fixed_width_le_u8[start_idx..end_idx];
|
|
let signal_val = BigUint::from_bytes_le(signal_val);
|
|
|
|
Ok((timestamp, signal_val))
|
|
}
|
|
|
|
fn bits_required(&self) -> Option<u32> {
|
|
match self {
|
|
SignalEnum::Data { num_bits, .. } => *num_bits,
|
|
// TODO: Follow aliases?
|
|
SignalEnum::Alias { .. } => None,
|
|
}
|
|
}
|
|
}
|
|
|
|
// Val and string query functions.
|
|
// Function that take in a desired time on the timeline for a
|
|
// specific signal and return a numerical or string value in a Result,
|
|
// or an error in a Result.
|
|
impl SignalEnum {
|
|
pub fn query_string_val_on_tmln(
|
|
&self,
|
|
desired_time: &BigUint,
|
|
tmstmps_encoded_as_u8s: &Vec<u8>,
|
|
all_signals: &Vec<SignalEnum>,
|
|
) -> Result<QueryResult<String>, SignalErrors> {
|
|
let signal_idx = match self {
|
|
Self::Data { self_idx, .. } => {
|
|
let SignalIdx(idx) = self_idx;
|
|
*idx
|
|
}
|
|
Self::Alias {
|
|
name: _,
|
|
signal_alias,
|
|
path: _,
|
|
} => {
|
|
let SignalIdx(idx) = signal_alias;
|
|
*idx
|
|
}
|
|
};
|
|
|
|
// if the signal idx points to data variant of the signal,
|
|
// extract:
|
|
// 1. the vector of string values
|
|
// 2. the vector of indices into timeline where events occur
|
|
// for this signal
|
|
// else we propagate Err(..).
|
|
let (string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln) = match &all_signals[signal_idx]
|
|
{
|
|
SignalEnum::Data {
|
|
ref string_vals,
|
|
ref lsb_indxs_of_string_tmstmp_vals_on_tmln,
|
|
..
|
|
} => Ok((string_vals, lsb_indxs_of_string_tmstmp_vals_on_tmln)),
|
|
SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
|
|
}?;
|
|
// this signal should at least have some events, otherwise, trying to index into
|
|
// an empty vector later on would fail
|
|
if lsb_indxs_of_string_tmstmp_vals_on_tmln.is_empty() {
|
|
return Ok(QueryResult {
|
|
current: None,
|
|
next: None,
|
|
});
|
|
}
|
|
|
|
// the vector of string timeline lsb indices should have the same
|
|
// length as the vector of string values
|
|
if string_vals.len() != lsb_indxs_of_string_tmstmp_vals_on_tmln.len() {
|
|
return Err(SignalErrors::StrTmlnLenMismatch);
|
|
}
|
|
|
|
// check if we're requesting a value that occurs before the recorded
|
|
// start of the timeline
|
|
let (timeline_start_time, _) =
|
|
self.time_and_str_val_at_event_idx(0, tmstmps_encoded_as_u8s)?;
|
|
if *desired_time < timeline_start_time {
|
|
return Ok(QueryResult {
|
|
current: None,
|
|
next: Some(timeline_start_time),
|
|
});
|
|
}
|
|
|
|
let mut lower_idx = 0usize;
|
|
let mut upper_idx = lsb_indxs_of_string_tmstmp_vals_on_tmln.len() - 1;
|
|
let (timeline_end_time, timeline_end_val) =
|
|
self.time_and_str_val_at_event_idx(upper_idx, tmstmps_encoded_as_u8s)?;
|
|
|
|
// check if we're requesting a value that occurs beyond the end of the timeline,
|
|
// if so, return the last value in this timeline
|
|
if *desired_time > timeline_end_time {
|
|
return Ok(QueryResult {
|
|
current: Some((timeline_end_time, timeline_end_val.to_string())),
|
|
next: None,
|
|
});
|
|
}
|
|
|
|
// This while loop is the meat of the lookup. Performance is log2(n),
|
|
// where n is the number of events on the timeline.
|
|
// We can assume that by the time we get here, that the desired_time
|
|
// is an event that occurs on the timeline, given that we handle any events
|
|
// occuring after or before the recorded tiimeline in the code above.
|
|
while lower_idx <= upper_idx {
|
|
let mid_idx = lower_idx + ((upper_idx - lower_idx) / 2);
|
|
let (curr_time, curr_val) =
|
|
self.time_and_str_val_at_event_idx(mid_idx, tmstmps_encoded_as_u8s)?;
|
|
let ordering = curr_time.cmp(desired_time);
|
|
|
|
match ordering {
|
|
std::cmp::Ordering::Less => {
|
|
lower_idx = mid_idx + 1;
|
|
}
|
|
std::cmp::Ordering::Equal => {
|
|
let next_time = if mid_idx < lsb_indxs_of_string_tmstmp_vals_on_tmln.len() - 1 {
|
|
Some(
|
|
self.time_and_str_val_at_event_idx(
|
|
mid_idx + 1,
|
|
tmstmps_encoded_as_u8s,
|
|
)?
|
|
.0,
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
return Ok(QueryResult {
|
|
current: Some((curr_time, curr_val.to_string())),
|
|
next: next_time,
|
|
});
|
|
}
|
|
std::cmp::Ordering::Greater => {
|
|
upper_idx = mid_idx - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
let (left_time, left_val) =
|
|
self.time_and_str_val_at_event_idx(lower_idx - 1, tmstmps_encoded_as_u8s)?;
|
|
let (right_time, _) =
|
|
self.time_and_str_val_at_event_idx(lower_idx, tmstmps_encoded_as_u8s)?;
|
|
|
|
let ordered_left = left_time < *desired_time;
|
|
let ordered_right = *desired_time < right_time;
|
|
if !(ordered_left && ordered_right) {
|
|
return Err(SignalErrors::OrderingFailure {
|
|
lhs_time: left_time,
|
|
mid_time: desired_time.clone(),
|
|
rhs_time: right_time,
|
|
});
|
|
}
|
|
|
|
Ok(QueryResult {
|
|
current: Some((left_time, left_val.to_string())),
|
|
next: Some(right_time),
|
|
})
|
|
}
|
|
pub fn query_num_val_on_tmln(
|
|
&self,
|
|
desired_time: &BigUint,
|
|
tmstmps_encoded_as_u8s: &Vec<u8>,
|
|
all_signals: &Vec<SignalEnum>,
|
|
) -> Result<QueryResult<BigUint>, SignalErrors> {
|
|
let signal_idx = match self {
|
|
Self::Data { self_idx, .. } => {
|
|
let SignalIdx(idx) = self_idx;
|
|
*idx
|
|
}
|
|
Self::Alias {
|
|
name: _,
|
|
path: _,
|
|
signal_alias,
|
|
} => {
|
|
let SignalIdx(idx) = signal_alias;
|
|
*idx
|
|
}
|
|
};
|
|
|
|
// if the signal idx points to data variant of the signal,
|
|
// extract:
|
|
// 1. the vector of LE u8 compressed values
|
|
// 2. the vector of indices into timeline where events occur
|
|
// for this signal
|
|
// 3. the number of bytes per value for this signal
|
|
// else we propagate Err(..).
|
|
let (nums_encoded_as_fixed_width_le_u8, lsb_indxs_of_num_tmstmp_vals_on_tmln, num_bytes) =
|
|
match &all_signals[signal_idx] {
|
|
SignalEnum::Data {
|
|
num_bytes,
|
|
ref nums_encoded_as_fixed_width_le_u8,
|
|
ref lsb_indxs_of_num_tmstmp_vals_on_tmln,
|
|
..
|
|
} => {
|
|
if num_bytes.is_none() {
|
|
return Err(SignalErrors::NoNumBytes);
|
|
}
|
|
Ok((
|
|
nums_encoded_as_fixed_width_le_u8,
|
|
lsb_indxs_of_num_tmstmp_vals_on_tmln,
|
|
num_bytes,
|
|
))
|
|
}
|
|
SignalEnum::Alias { .. } => Err(SignalErrors::PointsToAlias),
|
|
}?;
|
|
// this signal should at least have some events, otherwise, trying to index into
|
|
// an empty vector later on would fail
|
|
if lsb_indxs_of_num_tmstmp_vals_on_tmln.is_empty() {
|
|
return Ok(QueryResult {
|
|
current: None,
|
|
next: None,
|
|
});
|
|
}
|
|
|
|
// assertion that value_sequence is a proper multiple of
|
|
// timeline_markers
|
|
let bytes_required = num_bytes.ok_or_else(|| {
|
|
SignalErrors::Other(format!(
|
|
"Error near {}:{}. num_bytes empty.",
|
|
file!(),
|
|
line!()
|
|
))
|
|
})?;
|
|
if nums_encoded_as_fixed_width_le_u8.len()
|
|
!= (lsb_indxs_of_num_tmstmp_vals_on_tmln.len() * (bytes_required as usize))
|
|
{
|
|
return Err(SignalErrors::TimelineNotMultiple);
|
|
}
|
|
|
|
// check if we're requesting a value that occurs before the recorded
|
|
// start of the timeline
|
|
let (timeline_start_time, _) =
|
|
self.time_and_num_val_at_event_idx(0, tmstmps_encoded_as_u8s)?;
|
|
if *desired_time < timeline_start_time {
|
|
return Ok(QueryResult {
|
|
current: None,
|
|
next: Some(timeline_start_time),
|
|
});
|
|
}
|
|
|
|
let mut lower_idx = 0usize;
|
|
let mut upper_idx = lsb_indxs_of_num_tmstmp_vals_on_tmln.len() - 1;
|
|
let (timeline_end_time, timeline_end_val) =
|
|
self.time_and_num_val_at_event_idx(upper_idx, tmstmps_encoded_as_u8s)?;
|
|
|
|
// check if we're requesting a value that occurs beyond the end of the timeline,
|
|
// if so, return the last value in this timeline
|
|
if *desired_time > timeline_end_time {
|
|
return Ok(QueryResult {
|
|
current: Some((timeline_end_time, timeline_end_val)),
|
|
next: None,
|
|
});
|
|
}
|
|
|
|
// This while loop is the meat of the lookup. Performance is log2(n),
|
|
// where n is the number of events on the timeline.
|
|
// We can assume that by the time we get here, that the desired_time
|
|
// is an event that occurs on the timeline, given that we handle any events
|
|
// occuring after or before the recorded tiimeline in the code above.
|
|
while lower_idx <= upper_idx {
|
|
let mid_idx = lower_idx + ((upper_idx - lower_idx) / 2);
|
|
let (curr_time, curr_val) =
|
|
self.time_and_num_val_at_event_idx(mid_idx, tmstmps_encoded_as_u8s)?;
|
|
let ordering = curr_time.cmp(desired_time);
|
|
|
|
match ordering {
|
|
std::cmp::Ordering::Less => {
|
|
lower_idx = mid_idx + 1;
|
|
}
|
|
std::cmp::Ordering::Equal => {
|
|
let next_time = if mid_idx < lsb_indxs_of_num_tmstmp_vals_on_tmln.len() - 1 {
|
|
Some(
|
|
self.time_and_num_val_at_event_idx(
|
|
mid_idx + 1,
|
|
tmstmps_encoded_as_u8s,
|
|
)?
|
|
.0,
|
|
)
|
|
} else {
|
|
None
|
|
};
|
|
return Ok(QueryResult {
|
|
current: Some((curr_time, curr_val)),
|
|
next: next_time,
|
|
});
|
|
}
|
|
std::cmp::Ordering::Greater => {
|
|
upper_idx = mid_idx - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
let (left_time, left_val) =
|
|
self.time_and_num_val_at_event_idx(lower_idx - 1, tmstmps_encoded_as_u8s)?;
|
|
let (right_time, _) =
|
|
self.time_and_num_val_at_event_idx(lower_idx, tmstmps_encoded_as_u8s)?;
|
|
|
|
let ordered_left = left_time < *desired_time;
|
|
let ordered_right = *desired_time < right_time;
|
|
if !(ordered_left && ordered_right) {
|
|
return Err(SignalErrors::OrderingFailure {
|
|
lhs_time: left_time,
|
|
mid_time: desired_time.clone(),
|
|
rhs_time: right_time,
|
|
});
|
|
}
|
|
|
|
return Ok(QueryResult {
|
|
current: Some((left_time, left_val)),
|
|
next: Some(right_time),
|
|
});
|
|
}
|
|
}
|