unspeaker/tek
1
0
Fork 0
mirror of https://codeberg.org/unspeaker/tek.git synced 2025-12-06 19:56:42 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

this may actually be a performance regression, i'm only profiling once

Browse source
This commit is contained in:
🪞👃🪞 2025-01-20 19:23:33 +01:00
parent 680a841e3f
commit f5d84c2450
2 changed files with 65 additions and 31 deletions
Download patch file Download diff file Expand all files Collapse all files

78
tek/src/lib.rs
View file

@ -151,9 +151,12 @@ impl TekCli {
pub keys_scene: SourceIter<'static>,
pub keys_mix: SourceIter<'static>,
pub fmt_beat: RwLock<String>,
pub fmt_time: RwLock<String>,
pub fmt_bpm: RwLock<String>,
pub fmtd_beat: Arc<RwLock<String>>,
pub fmtd_time: Arc<RwLock<String>>,
pub fmtd_bpm: Arc<RwLock<String>>,
pub fmtd_sr: Arc<RwLock<String>>,
pub fmtd_buf: Arc<RwLock<String>>,
pub fmtd_lat: Arc<RwLock<String>>,
}
has_size!(<TuiOut>|self: Tek|&self.size);
has_clock!(|self: Tek|self.clock);
@ -229,9 +232,12 @@ impl Tek {
keys_track: SourceIter(KEYS_TRACK),
keys_scene: SourceIter(KEYS_SCENE),
keys_mix: SourceIter(KEYS_MIX),
fmt_beat: String::with_capacity(16).into(),
fmt_time: String::with_capacity(16).into(),
fmt_bpm: String::with_capacity(16).into(),
fmtd_beat: Arc::new(RwLock::new(String::with_capacity(16))),
fmtd_time: Arc::new(RwLock::new(String::with_capacity(16))),
fmtd_bpm: Arc::new(RwLock::new(String::with_capacity(16))),
fmtd_sr: Arc::new(RwLock::new(String::with_capacity(16))),
fmtd_buf: Arc::new(RwLock::new(String::with_capacity(16))),
fmtd_lat: Arc::new(RwLock::new(String::with_capacity(16))),
..Default::default()
};
tek.sync_lead(sync_lead);
@ -383,47 +389,57 @@ impl Tek {
let compact = self.size.w() > 80;
let clock = self.clock();
let delta = |start: &Moment|clock.global.usec.get() - start.usec.get();
let mut fmt_beat = self.fmt_beat.write().unwrap();
let mut fmt_time = self.fmt_time.write().unwrap();
let mut fmt_bpm = self.fmt_bpm.write().unwrap();
fmt_beat.clear();
fmt_time.clear();
fmt_bpm.clear();
let mut fmtd_beat = self.fmtd_beat.write().unwrap();
let mut fmtd_time = self.fmtd_time.write().unwrap();
let mut fmtd_bpm = self.fmtd_bpm.write().unwrap();
fmtd_beat.clear();
fmtd_time.clear();
fmtd_bpm.clear();
if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
clock.timebase.format_beats_1_to(&mut*fmt_beat, clock.timebase.usecs_to_pulse(now));
write!(&mut fmt_time, "{:.3}s", now/1000000.);
write!(&mut fmt_bpm, "{:.3}", clock.timebase.bpm.get());
clock.timebase.format_beats_1_to(&mut*fmtd_beat, clock.timebase.usecs_to_pulse(now));
write!(&mut fmtd_time, "{:.3}s", now/1000000.);
write!(&mut fmtd_bpm, "{:.3}", clock.timebase.bpm.get());
} else {
write!(&mut fmt_beat, "-.-.--");
write!(&mut fmt_time, "-.---s");
write!(&mut fmt_bpm, "---.---");
write!(&mut fmtd_beat, "-.-.--");
write!(&mut fmtd_time, "-.---s");
write!(&mut fmtd_bpm, "---.---");
}
let theme = ItemPalette::G[128];
Thunk::new(move||Either::new(compact,
row!(FieldH(theme, "BPM", self.fmt_bpm.read().unwrap()),
FieldH(theme, "Beat", self.fmt_beat.read().unwrap()),
FieldH(theme, "Time", self.fmt_time.read().unwrap())),
row!(FieldV(theme, "BPM", self.fmt_bpm.read().unwrap()),
FieldV(theme, "Beat", self.fmt_beat.read().unwrap()),
FieldV(theme, "Time", self.fmt_time.read().unwrap()))))
row!(FieldH(theme, "BPM", self.fmtd_bpm.clone()),
FieldH(theme, "Beat", self.fmtd_beat.clone()),
FieldH(theme, "Time", self.fmtd_time.clone())),
row!(FieldV(theme, "BPM", self.fmtd_bpm.clone()),
FieldV(theme, "Beat", self.fmtd_beat.clone()),
FieldV(theme, "Time", self.fmtd_time.clone()))))
}
fn view_engine_stats (&self) -> impl Content<TuiOut> + use<'_> {
let compact = self.size.w() > 80;
let clock = self.clock();
let rate = clock.timebase.sr.get();
let chunk = clock.chunk.load(Relaxed);
let sr = move||format!("{}", if compact {format!("{:.1}kHz", rate / 1000.)} else {format!("{:.0}Hz", rate)});
let buf = move||format!("{chunk}");
let latency = move||format!("{:.1}ms", chunk as f64 / rate * 1000.);
let theme = ItemPalette::G[128];
let mut fmtd_sr = self.fmtd_sr.write().unwrap();
let mut fmtd_buf = self.fmtd_buf.write().unwrap();
let mut fmtd_lat = self.fmtd_lat.write().unwrap();
fmtd_sr.clear();
write!(&mut fmtd_sr, "{}", if compact {format!("{:.1}kHz", rate / 1000.)} else {format!("{:.0}Hz", rate)});
fmtd_buf.clear();
write!(&mut fmtd_buf, "{chunk}");
fmtd_lat.clear();
write!(&mut fmtd_lat, "{:.1}ms", chunk as f64 / rate * 1000.);
let theme = ItemPalette::G[128];
Either::new(compact,
row!(FieldH(theme, "SR", sr()), FieldH(theme, "Buf", buf()), FieldH(theme, "Lat", latency())),
row!(FieldV(theme, "SR", sr()), FieldV(theme, "Buf", buf()), FieldV(theme, "Lat", latency())))
row!(FieldH(theme, "SR", self.fmtd_sr.clone()),
FieldH(theme, "Buf", self.fmtd_buf.clone()),
FieldH(theme, "Lat", self.fmtd_lat.clone())),
row!(FieldV(theme, "SR", self.fmtd_sr.clone()),
FieldV(theme, "Buf", self.fmtd_buf.clone()),
FieldV(theme, "Lat", self.fmtd_lat.clone())))
}
fn view_meter <'a> (&'a self, label: &'a str, value: f32) -> impl Content<TuiOut> + 'a {
col!(
FieldH(ItemPalette::G[128], label, format!("{:>+9.3}", value)),
Fixed::xy(if value >= 0.0 { 13 }
Fixed::xy(if value >= 0.0 { 13 }
else if value >= -1.0 { 12 }
else if value >= -2.0 { 11 }
else if value >= -3.0 { 10 }

18
tui/src/tui_content.rs
View file

@ -20,6 +20,24 @@ impl Content<TuiOut> for String {
}
}
impl<T: Content<TuiOut>> Content<TuiOut> for std::sync::Arc<T> {
fn layout (&self, to: [u16;4]) -> [u16;4] {
Content::<TuiOut>::layout(&**self, to)
}
fn render (&self, to: &mut TuiOut) {
Content::<TuiOut>::render(&**self, to)
}
}
impl Content<TuiOut> for std::sync::RwLock<String> {
fn layout (&self, to: [u16;4]) -> [u16;4] {
Content::<TuiOut>::layout(&self.read().unwrap(), to)
}
fn render (&self, to: &mut TuiOut) {
Content::<TuiOut>::render(&self.read().unwrap(), to)
}
}
impl Content<TuiOut> for std::sync::RwLockReadGuard<'_, String> {
fn layout (&self, to: [u16;4]) -> [u16;4] {
Content::<TuiOut>::layout(&**self, to)