303 lines
9.1 KiB
Rust
303 lines
9.1 KiB
Rust
use futures_util::Future;
|
|
use futures_util::FutureExt;
|
|
use futures_util::Stream;
|
|
use items_0::container::ByteEstimate;
|
|
use items_0::streamitem::sitem_data;
|
|
use items_0::streamitem::RangeCompletableItem;
|
|
use items_0::streamitem::Sitemty;
|
|
use items_0::streamitem::StreamItem;
|
|
use items_0::Appendable;
|
|
use items_0::Empty;
|
|
use items_0::WithLen;
|
|
use items_2::channelevents::ChannelEvents;
|
|
use items_2::eventsdim0::EventsDim0;
|
|
use items_2::eventsdim1::EventsDim1;
|
|
use netpod::log::*;
|
|
use netpod::range::evrange::SeriesRange;
|
|
use netpod::timeunits::MS;
|
|
use std::f64::consts::PI;
|
|
use std::pin::Pin;
|
|
use std::task::Context;
|
|
use std::task::Poll;
|
|
use std::time::Duration;
|
|
|
|
pub struct GenerateI32 {
|
|
ts: u64,
|
|
dts: u64,
|
|
tsend: u64,
|
|
#[allow(unused)]
|
|
c1: u64,
|
|
timeout: Option<Pin<Box<dyn Future<Output = ()> + Send>>>,
|
|
done: bool,
|
|
done_range_final: bool,
|
|
}
|
|
|
|
impl GenerateI32 {
|
|
pub fn new(node_ix: u64, node_count: u64, range: SeriesRange) -> Self {
|
|
let range = match range {
|
|
SeriesRange::TimeRange(k) => k,
|
|
SeriesRange::PulseRange(_) => todo!(),
|
|
};
|
|
let dts = MS * 1000 * node_count as u64;
|
|
let ts = (range.beg / dts + node_ix) * dts;
|
|
let tsend = range.end;
|
|
Self {
|
|
ts,
|
|
dts,
|
|
tsend,
|
|
c1: 0,
|
|
timeout: None,
|
|
done: false,
|
|
done_range_final: false,
|
|
}
|
|
}
|
|
|
|
fn make_batch(&mut self) -> Sitemty<ChannelEvents> {
|
|
type T = i32;
|
|
let mut item = EventsDim0::empty();
|
|
let mut ts = self.ts;
|
|
loop {
|
|
if self.ts >= self.tsend || item.byte_estimate() > 200 {
|
|
break;
|
|
}
|
|
let pulse = ts;
|
|
let value = (ts / (MS * 100) % 1000) as T;
|
|
item.push(ts, pulse, value);
|
|
ts += self.dts;
|
|
}
|
|
self.ts = ts;
|
|
let w = ChannelEvents::Events(Box::new(item) as _);
|
|
let w = sitem_data(w);
|
|
w
|
|
}
|
|
}
|
|
|
|
impl Stream for GenerateI32 {
|
|
type Item = Sitemty<ChannelEvents>;
|
|
|
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
|
|
use Poll::*;
|
|
loop {
|
|
break if self.done_range_final {
|
|
Ready(None)
|
|
} else if self.ts >= self.tsend {
|
|
self.done = true;
|
|
self.done_range_final = true;
|
|
Ready(Some(Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete))))
|
|
} else if false {
|
|
// To use the generator without throttling, use this scope
|
|
Ready(Some(self.make_batch()))
|
|
} else if let Some(fut) = self.timeout.as_mut() {
|
|
match fut.poll_unpin(cx) {
|
|
Ready(()) => {
|
|
self.timeout = None;
|
|
Ready(Some(self.make_batch()))
|
|
}
|
|
Pending => Pending,
|
|
}
|
|
} else {
|
|
self.timeout = Some(Box::pin(tokio::time::sleep(Duration::from_millis(2))));
|
|
continue;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct GenerateI32V01 {
|
|
ivl: u64,
|
|
ts: u64,
|
|
dts: u64,
|
|
tsend: u64,
|
|
#[allow(unused)]
|
|
c1: u64,
|
|
node_ix: u64,
|
|
timeout: Option<Pin<Box<dyn Future<Output = ()> + Send>>>,
|
|
done: bool,
|
|
done_range_final: bool,
|
|
}
|
|
|
|
impl GenerateI32V01 {
|
|
pub fn new(node_ix: u64, node_count: u64, range: SeriesRange, one_before_range: bool) -> Self {
|
|
let range = match range {
|
|
SeriesRange::TimeRange(k) => k,
|
|
SeriesRange::PulseRange(_) => todo!(),
|
|
};
|
|
let ivl = MS * 500;
|
|
let dts = ivl * node_count as u64;
|
|
let ts = (range.beg / ivl + node_ix - if one_before_range { 1 } else { 0 }) * ivl;
|
|
let tsend = range.end;
|
|
info!(
|
|
"START GENERATOR GenerateI32V01 ivl {} dts {} ts {} one_before_range {}",
|
|
ivl, dts, ts, one_before_range
|
|
);
|
|
Self {
|
|
ivl,
|
|
ts,
|
|
dts,
|
|
tsend,
|
|
c1: 0,
|
|
node_ix,
|
|
timeout: None,
|
|
done: false,
|
|
done_range_final: false,
|
|
}
|
|
}
|
|
|
|
fn make_batch(&mut self) -> Sitemty<ChannelEvents> {
|
|
type T = i32;
|
|
let mut item = EventsDim0::empty();
|
|
let mut ts = self.ts;
|
|
loop {
|
|
if self.ts >= self.tsend || item.byte_estimate() > 400 {
|
|
break;
|
|
}
|
|
let pulse = ts;
|
|
let value = (ts / self.ivl) as T;
|
|
if true {
|
|
info!(
|
|
"v01 node {} made event ts {} pulse {} value {}",
|
|
self.node_ix, ts, pulse, value
|
|
);
|
|
}
|
|
item.push(ts, pulse, value);
|
|
ts += self.dts;
|
|
}
|
|
self.ts = ts;
|
|
let w = ChannelEvents::Events(Box::new(item) as _);
|
|
let w = sitem_data(w);
|
|
w
|
|
}
|
|
}
|
|
|
|
impl Stream for GenerateI32V01 {
|
|
type Item = Sitemty<ChannelEvents>;
|
|
|
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
|
|
use Poll::*;
|
|
loop {
|
|
break if self.done_range_final {
|
|
Ready(None)
|
|
} else if self.ts >= self.tsend {
|
|
self.done = true;
|
|
self.done_range_final = true;
|
|
Ready(Some(Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete))))
|
|
} else if false {
|
|
// To use the generator without throttling, use this scope
|
|
Ready(Some(self.make_batch()))
|
|
} else if let Some(fut) = self.timeout.as_mut() {
|
|
match fut.poll_unpin(cx) {
|
|
Ready(()) => {
|
|
self.timeout = None;
|
|
Ready(Some(self.make_batch()))
|
|
}
|
|
Pending => Pending,
|
|
}
|
|
} else {
|
|
self.timeout = Some(Box::pin(tokio::time::sleep(Duration::from_millis(2))));
|
|
continue;
|
|
};
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct GenerateF64V00 {
|
|
ivl: u64,
|
|
ts: u64,
|
|
dts: u64,
|
|
tsend: u64,
|
|
node_ix: u64,
|
|
timeout: Option<Pin<Box<dyn Future<Output = ()> + Send>>>,
|
|
done: bool,
|
|
done_range_final: bool,
|
|
}
|
|
|
|
impl GenerateF64V00 {
|
|
pub fn new(node_ix: u64, node_count: u64, range: SeriesRange, one_before_range: bool) -> Self {
|
|
let range = match range {
|
|
SeriesRange::TimeRange(k) => k,
|
|
SeriesRange::PulseRange(_) => todo!(),
|
|
};
|
|
let ivl = MS * 100;
|
|
let dts = ivl * node_count as u64;
|
|
let ts = (range.beg / ivl + node_ix - if one_before_range { 1 } else { 0 }) * ivl;
|
|
let tsend = range.end;
|
|
info!(
|
|
"START GENERATOR GenerateF64V00 ivl {} dts {} ts {} one_before_range {}",
|
|
ivl, dts, ts, one_before_range
|
|
);
|
|
Self {
|
|
ivl,
|
|
ts,
|
|
dts,
|
|
tsend,
|
|
node_ix,
|
|
timeout: None,
|
|
done: false,
|
|
done_range_final: false,
|
|
}
|
|
}
|
|
|
|
fn make_batch(&mut self) -> Sitemty<ChannelEvents> {
|
|
type T = f64;
|
|
let mut item = EventsDim1::empty();
|
|
let mut ts = self.ts;
|
|
loop {
|
|
if self.ts >= self.tsend || item.byte_estimate() > 1024 * 4 {
|
|
break;
|
|
}
|
|
let pulse = ts;
|
|
let ampl = ((ts / self.ivl) as T).sin() + 2.;
|
|
let mut value = Vec::new();
|
|
let pi = PI;
|
|
for i in 0..21 {
|
|
let x = ((-pi + (2. * pi / 20.) * i as f64).cos() + 1.1) * ampl;
|
|
value.push(x);
|
|
}
|
|
if false {
|
|
info!(
|
|
"v01 node {} made event ts {} pulse {} value {:?}",
|
|
self.node_ix, ts, pulse, value
|
|
);
|
|
}
|
|
item.push(ts, pulse, value);
|
|
ts += self.dts;
|
|
}
|
|
self.ts = ts;
|
|
info!("generated len {}", item.len());
|
|
let w = ChannelEvents::Events(Box::new(item) as _);
|
|
let w = sitem_data(w);
|
|
w
|
|
}
|
|
}
|
|
|
|
impl Stream for GenerateF64V00 {
|
|
type Item = Sitemty<ChannelEvents>;
|
|
|
|
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
|
|
use Poll::*;
|
|
loop {
|
|
break if self.done_range_final {
|
|
Ready(None)
|
|
} else if self.ts >= self.tsend {
|
|
self.done = true;
|
|
self.done_range_final = true;
|
|
Ready(Some(Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete))))
|
|
} else if false {
|
|
// To use the generator without throttling, use this scope
|
|
Ready(Some(self.make_batch()))
|
|
} else if let Some(fut) = self.timeout.as_mut() {
|
|
match fut.poll_unpin(cx) {
|
|
Ready(()) => {
|
|
self.timeout = None;
|
|
Ready(Some(self.make_batch()))
|
|
}
|
|
Pending => Pending,
|
|
}
|
|
} else {
|
|
self.timeout = Some(Box::pin(tokio::time::sleep(Duration::from_millis(2))));
|
|
continue;
|
|
};
|
|
}
|
|
}
|
|
}
|