dev/perf-runtime-telemetry-hot-path (#13)
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good
Reviewed-on: #13 Co-authored-by: bQUARKz <bquarkz@gmail.com> Co-committed-by: bQUARKz <bquarkz@gmail.com>
This commit was merged in pull request #13.
This commit is contained in:
@@ -12,14 +12,22 @@ use prometeu_hal::sample::Sample;
|
||||
use prometeu_hal::sound_bank::SoundBank;
|
||||
use std::collections::HashMap;
|
||||
use std::io::Read;
|
||||
use std::sync::atomic::{AtomicUsize, Ordering};
|
||||
use std::sync::{Arc, Mutex, RwLock};
|
||||
use std::thread;
|
||||
use std::time::Instant;
|
||||
|
||||
type ResidentMap<T> = HashMap<AssetId, ResidentEntry<T>>;
|
||||
type StagedValue<T> = (Arc<T>, usize);
|
||||
type StagingMap<T> = HashMap<HandleId, StagedValue<T>>;
|
||||
|
||||
type AssetTable = HashMap<AssetId, AssetEntry>;
|
||||
type HandleTable = HashMap<HandleId, LoadHandleInfo>;
|
||||
|
||||
const GLYPH_BANK_PALETTE_COUNT_V1: usize = 64;
|
||||
const GLYPH_BANK_COLORS_PER_PALETTE: usize = 16;
|
||||
const GLYPH_BANK_PALETTE_BYTES_V1: usize =
|
||||
GLYPH_BANK_PALETTE_COUNT_V1 * GLYPH_BANK_COLORS_PER_PALETTE * std::mem::size_of::<u16>();
|
||||
GLYPH_BANK_PALETTE_COUNT_V1 * GLYPH_BANK_COLORS_PER_PALETTE * size_of::<u16>();
|
||||
|
||||
/// Resident metadata for a decoded/materialized asset inside a BankPolicy.
|
||||
#[derive(Debug)]
|
||||
@@ -53,10 +61,26 @@ impl<T> ResidentEntry<T> {
|
||||
/// This is internal to the AssetManager and not visible to peripherals.
|
||||
pub struct BankPolicy<T> {
|
||||
/// Dedup table: asset_id -> resident entry (value + telemetry).
|
||||
resident: Arc<RwLock<HashMap<AssetId, ResidentEntry<T>>>>,
|
||||
pub resident: Arc<RwLock<ResidentMap<T>>>,
|
||||
|
||||
/// Staging area: handle -> value ready to commit.
|
||||
staging: Arc<RwLock<HashMap<HandleId, Arc<T>>>>,
|
||||
pub staging: Arc<RwLock<StagingMap<T>>>,
|
||||
|
||||
/// Total bytes currently in resident storage.
|
||||
pub used_bytes: Arc<AtomicUsize>,
|
||||
/// Bytes in staging awaiting commit.
|
||||
pub inflight_bytes: Arc<AtomicUsize>,
|
||||
}
|
||||
|
||||
impl<T> Clone for BankPolicy<T> {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
resident: Arc::clone(&self.resident),
|
||||
staging: Arc::clone(&self.staging),
|
||||
used_bytes: Arc::clone(&self.used_bytes),
|
||||
inflight_bytes: Arc::clone(&self.inflight_bytes),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> BankPolicy<T> {
|
||||
@@ -64,6 +88,8 @@ impl<T> BankPolicy<T> {
|
||||
Self {
|
||||
resident: Arc::new(RwLock::new(HashMap::new())),
|
||||
staging: Arc::new(RwLock::new(HashMap::new())),
|
||||
used_bytes: Arc::new(AtomicUsize::new(0)),
|
||||
inflight_bytes: Arc::new(AtomicUsize::new(0)),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -87,30 +113,38 @@ impl<T> BankPolicy<T> {
|
||||
None => {
|
||||
let entry = ResidentEntry::new(Arc::clone(&value), bytes);
|
||||
map.insert(asset_id, entry);
|
||||
self.used_bytes.fetch_add(bytes, Ordering::Relaxed);
|
||||
value
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Place a value into staging for a given handle.
|
||||
pub fn stage(&self, handle: HandleId, value: Arc<T>) {
|
||||
self.staging.write().unwrap().insert(handle, value);
|
||||
pub fn stage(&self, handle: HandleId, value: Arc<T>, bytes: usize) {
|
||||
self.staging.write().unwrap().insert(handle, (value, bytes));
|
||||
self.inflight_bytes.fetch_add(bytes, Ordering::Relaxed);
|
||||
}
|
||||
|
||||
/// Take staged value (used by commit path).
|
||||
pub fn take_staging(&self, handle: HandleId) -> Option<Arc<T>> {
|
||||
self.staging.write().unwrap().remove(&handle)
|
||||
pub fn take_staging(&self, handle: HandleId) -> Option<StagedValue<T>> {
|
||||
let entry = self.staging.write().unwrap().remove(&handle);
|
||||
if let Some((_, bytes)) = entry.as_ref() {
|
||||
self.inflight_bytes.fetch_sub(*bytes, Ordering::Relaxed);
|
||||
}
|
||||
entry
|
||||
}
|
||||
|
||||
pub fn clear(&self) {
|
||||
self.resident.write().unwrap().clear();
|
||||
self.staging.write().unwrap().clear();
|
||||
self.used_bytes.store(0, Ordering::Relaxed);
|
||||
self.inflight_bytes.store(0, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
pub struct AssetManager {
|
||||
assets: Arc<RwLock<HashMap<AssetId, AssetEntry>>>,
|
||||
handles: Arc<RwLock<HashMap<HandleId, LoadHandleInfo>>>,
|
||||
assets: Arc<RwLock<AssetTable>>,
|
||||
handles: Arc<RwLock<HandleTable>>,
|
||||
next_handle_id: Mutex<HandleId>,
|
||||
assets_data: Arc<RwLock<AssetsPayloadSource>>,
|
||||
|
||||
@@ -127,6 +161,11 @@ pub struct AssetManager {
|
||||
/// Residency policy for sound banks.
|
||||
sound_policy: BankPolicy<SoundBank>,
|
||||
|
||||
/// Count of occupied slots for GFX.
|
||||
gfx_slots_occupied: AtomicUsize,
|
||||
/// Count of occupied slots for sounds.
|
||||
sound_slots_occupied: AtomicUsize,
|
||||
|
||||
// Commits that are ready to be applied at the next frame boundary.
|
||||
pending_commits: Mutex<Vec<HandleId>>,
|
||||
}
|
||||
@@ -263,6 +302,8 @@ impl AssetManager {
|
||||
sound_slots: Arc::new(RwLock::new(std::array::from_fn(|_| None))),
|
||||
gfx_policy: BankPolicy::new(),
|
||||
sound_policy: BankPolicy::new(),
|
||||
gfx_slots_occupied: AtomicUsize::new(0),
|
||||
sound_slots_occupied: AtomicUsize::new(0),
|
||||
handles: Arc::new(RwLock::new(HashMap::new())),
|
||||
next_handle_id: Mutex::new(1),
|
||||
assets_data: Arc::new(RwLock::new(assets_data)),
|
||||
@@ -379,7 +420,7 @@ impl AssetManager {
|
||||
let already_resident = match entry.bank_type {
|
||||
BankType::GLYPH => {
|
||||
if let Some(bank) = self.gfx_policy.get_resident(asset_id) {
|
||||
self.gfx_policy.stage(handle_id, bank);
|
||||
self.gfx_policy.stage(handle_id, bank, entry.decoded_size as usize);
|
||||
true
|
||||
} else {
|
||||
false
|
||||
@@ -387,7 +428,7 @@ impl AssetManager {
|
||||
}
|
||||
BankType::SOUNDS => {
|
||||
if let Some(bank) = self.sound_policy.get_resident(asset_id) {
|
||||
self.sound_policy.stage(handle_id, bank);
|
||||
self.sound_policy.stage(handle_id, bank, entry.decoded_size as usize);
|
||||
true
|
||||
} else {
|
||||
false
|
||||
@@ -414,10 +455,8 @@ impl AssetManager {
|
||||
let entry_clone = entry.clone();
|
||||
|
||||
// Capture policies for the worker thread
|
||||
let gfx_policy_resident = Arc::clone(&self.gfx_policy.resident);
|
||||
let gfx_policy_staging = Arc::clone(&self.gfx_policy.staging);
|
||||
let sound_policy_resident = Arc::clone(&self.sound_policy.resident);
|
||||
let sound_policy_staging = Arc::clone(&self.sound_policy.staging);
|
||||
let gfx_policy = self.gfx_policy.clone();
|
||||
let sound_policy = self.sound_policy.clone();
|
||||
|
||||
thread::spawn(move || {
|
||||
// Update status to LOADING
|
||||
@@ -439,22 +478,17 @@ impl AssetManager {
|
||||
let result = Self::perform_load_glyph_bank(&entry_clone, assets_data);
|
||||
if let Ok(tilebank) = result {
|
||||
let bank_arc = Arc::new(tilebank);
|
||||
let resident_arc = {
|
||||
let mut map = gfx_policy_resident.write().unwrap();
|
||||
if let Some(existing) = map.get_mut(&asset_id) {
|
||||
existing.last_used = Instant::now();
|
||||
existing.loads += 1;
|
||||
Arc::clone(&existing.value)
|
||||
} else {
|
||||
let entry = ResidentEntry::new(
|
||||
Arc::clone(&bank_arc),
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
map.insert(asset_id, entry);
|
||||
bank_arc
|
||||
}
|
||||
};
|
||||
gfx_policy_staging.write().unwrap().insert(handle_id, resident_arc);
|
||||
let resident_arc = gfx_policy.put_resident(
|
||||
asset_id,
|
||||
bank_arc,
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
gfx_policy.stage(
|
||||
handle_id,
|
||||
resident_arc,
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
|
||||
let mut handles_map = handles.write().unwrap();
|
||||
if let Some(h) = handles_map.get_mut(&handle_id) {
|
||||
if h.status == LoadStatus::LOADING {
|
||||
@@ -472,22 +506,17 @@ impl AssetManager {
|
||||
let result = Self::perform_load_sound_bank(&entry_clone, assets_data);
|
||||
if let Ok(soundbank) = result {
|
||||
let bank_arc = Arc::new(soundbank);
|
||||
let resident_arc = {
|
||||
let mut map = sound_policy_resident.write().unwrap();
|
||||
if let Some(existing) = map.get_mut(&asset_id) {
|
||||
existing.last_used = Instant::now();
|
||||
existing.loads += 1;
|
||||
Arc::clone(&existing.value)
|
||||
} else {
|
||||
let entry = ResidentEntry::new(
|
||||
Arc::clone(&bank_arc),
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
map.insert(asset_id, entry);
|
||||
bank_arc
|
||||
}
|
||||
};
|
||||
sound_policy_staging.write().unwrap().insert(handle_id, resident_arc);
|
||||
let resident_arc = sound_policy.put_resident(
|
||||
asset_id,
|
||||
bank_arc,
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
sound_policy.stage(
|
||||
handle_id,
|
||||
resident_arc,
|
||||
entry_clone.decoded_size as usize,
|
||||
);
|
||||
|
||||
let mut handles_map = handles.write().unwrap();
|
||||
if let Some(h) = handles_map.get_mut(&handle_id) {
|
||||
if h.status == LoadStatus::LOADING {
|
||||
@@ -699,20 +728,26 @@ impl AssetManager {
|
||||
if h.status == LoadStatus::READY {
|
||||
match h.slot.asset_type {
|
||||
BankType::GLYPH => {
|
||||
if let Some(bank) = self.gfx_policy.take_staging(handle_id) {
|
||||
if let Some((bank, _)) = self.gfx_policy.take_staging(handle_id) {
|
||||
self.gfx_installer.install_glyph_bank(h.slot.index, bank);
|
||||
let mut slots = self.gfx_slots.write().unwrap();
|
||||
if h.slot.index < slots.len() {
|
||||
if slots[h.slot.index].is_none() {
|
||||
self.gfx_slots_occupied.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
slots[h.slot.index] = Some(h._asset_id);
|
||||
}
|
||||
h.status = LoadStatus::COMMITTED;
|
||||
}
|
||||
}
|
||||
BankType::SOUNDS => {
|
||||
if let Some(bank) = self.sound_policy.take_staging(handle_id) {
|
||||
if let Some((bank, _)) = self.sound_policy.take_staging(handle_id) {
|
||||
self.sound_installer.install_sound_bank(h.slot.index, bank);
|
||||
let mut slots = self.sound_slots.write().unwrap();
|
||||
if h.slot.index < slots.len() {
|
||||
if slots[h.slot.index].is_none() {
|
||||
self.sound_slots_occupied.fetch_add(1, Ordering::Relaxed);
|
||||
}
|
||||
slots[h.slot.index] = Some(h._asset_id);
|
||||
}
|
||||
h.status = LoadStatus::COMMITTED;
|
||||
@@ -727,38 +762,9 @@ impl AssetManager {
|
||||
pub fn bank_info(&self, kind: BankType) -> BankStats {
|
||||
match kind {
|
||||
BankType::GLYPH => {
|
||||
let mut used_bytes = 0;
|
||||
{
|
||||
let resident = self.gfx_policy.resident.read().unwrap();
|
||||
for entry in resident.values() {
|
||||
used_bytes += entry.bytes;
|
||||
}
|
||||
}
|
||||
|
||||
let mut inflight_bytes = 0;
|
||||
{
|
||||
let staging = self.gfx_policy.staging.read().unwrap();
|
||||
let assets = self.assets.read().unwrap();
|
||||
let handles = self.handles.read().unwrap();
|
||||
|
||||
for (handle_id, _) in staging.iter() {
|
||||
if let Some(h) = handles.get(handle_id) {
|
||||
if let Some(entry) = assets.get(&h._asset_id) {
|
||||
inflight_bytes += entry.decoded_size as usize;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut slots_occupied = 0;
|
||||
{
|
||||
let slots = self.gfx_slots.read().unwrap();
|
||||
for s in slots.iter() {
|
||||
if s.is_some() {
|
||||
slots_occupied += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let used_bytes = self.gfx_policy.used_bytes.load(Ordering::Relaxed);
|
||||
let inflight_bytes = self.gfx_policy.inflight_bytes.load(Ordering::Relaxed);
|
||||
let slots_occupied = self.gfx_slots_occupied.load(Ordering::Relaxed);
|
||||
|
||||
BankStats {
|
||||
total_bytes: 16 * 1024 * 1024,
|
||||
@@ -770,38 +776,9 @@ impl AssetManager {
|
||||
}
|
||||
}
|
||||
BankType::SOUNDS => {
|
||||
let mut used_bytes = 0;
|
||||
{
|
||||
let resident = self.sound_policy.resident.read().unwrap();
|
||||
for entry in resident.values() {
|
||||
used_bytes += entry.bytes;
|
||||
}
|
||||
}
|
||||
|
||||
let mut inflight_bytes = 0;
|
||||
{
|
||||
let staging = self.sound_policy.staging.read().unwrap();
|
||||
let assets = self.assets.read().unwrap();
|
||||
let handles = self.handles.read().unwrap();
|
||||
|
||||
for (handle_id, _) in staging.iter() {
|
||||
if let Some(h) = handles.get(handle_id) {
|
||||
if let Some(entry) = assets.get(&h._asset_id) {
|
||||
inflight_bytes += entry.decoded_size as usize;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut slots_occupied = 0;
|
||||
{
|
||||
let slots = self.sound_slots.read().unwrap();
|
||||
for s in slots.iter() {
|
||||
if s.is_some() {
|
||||
slots_occupied += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
let used_bytes = self.sound_policy.used_bytes.load(Ordering::Relaxed);
|
||||
let inflight_bytes = self.sound_policy.inflight_bytes.load(Ordering::Relaxed);
|
||||
let slots_occupied = self.sound_slots_occupied.load(Ordering::Relaxed);
|
||||
|
||||
BankStats {
|
||||
total_bytes: 32 * 1024 * 1024,
|
||||
@@ -865,6 +842,8 @@ impl AssetManager {
|
||||
pub fn shutdown(&self) {
|
||||
self.gfx_policy.clear();
|
||||
self.sound_policy.clear();
|
||||
self.gfx_slots_occupied.store(0, Ordering::Relaxed);
|
||||
self.sound_slots_occupied.store(0, Ordering::Relaxed);
|
||||
self.handles.write().unwrap().clear();
|
||||
self.pending_commits.lock().unwrap().clear();
|
||||
self.gfx_slots.write().unwrap().fill(None);
|
||||
@@ -1049,8 +1028,8 @@ mod tests {
|
||||
assert_eq!(am.status(handle2), LoadStatus::READY);
|
||||
|
||||
let staging = am.gfx_policy.staging.read().unwrap();
|
||||
let bank1 = staging.get(&handle1).unwrap();
|
||||
let bank2 = staging.get(&handle2).unwrap();
|
||||
let bank1 = &staging.get(&handle1).unwrap().0;
|
||||
let bank2 = &staging.get(&handle2).unwrap().0;
|
||||
assert!(Arc::ptr_eq(bank1, bank2));
|
||||
}
|
||||
|
||||
@@ -1208,4 +1187,60 @@ mod tests {
|
||||
assert_eq!(am.status(handle), LoadStatus::CANCELED);
|
||||
assert_eq!(am.commit(handle), AssetOpStatus::InvalidState);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_asset_telemetry_incremental() {
|
||||
let banks = Arc::new(MemoryBanks::new());
|
||||
let gfx_installer = Arc::clone(&banks) as Arc<dyn GlyphBankPoolInstaller>;
|
||||
let sound_installer = Arc::clone(&banks) as Arc<dyn SoundBankPoolInstaller>;
|
||||
|
||||
let width = 16;
|
||||
let height = 16;
|
||||
let decoded_bytes = expected_glyph_decoded_size(width, height);
|
||||
let data = test_glyph_asset_data();
|
||||
|
||||
let am = AssetManager::new(
|
||||
vec![test_glyph_asset_entry("test_glyphs", width, height)],
|
||||
AssetsPayloadSource::from_bytes(data),
|
||||
gfx_installer,
|
||||
sound_installer,
|
||||
);
|
||||
|
||||
// Initially zero
|
||||
let info = am.bank_info(BankType::GLYPH);
|
||||
assert_eq!(info.used_bytes, 0);
|
||||
assert_eq!(info.inflight_bytes, 0);
|
||||
assert_eq!(info.slots_occupied, 0);
|
||||
|
||||
// Loading
|
||||
let handle = am.load(0, 0).expect("load must allocate handle");
|
||||
|
||||
// While LOADING or READY, it should be in inflight_bytes
|
||||
let start = Instant::now();
|
||||
while am.status(handle) != LoadStatus::READY && start.elapsed().as_secs() < 5 {
|
||||
thread::sleep(std::time::Duration::from_millis(10));
|
||||
}
|
||||
|
||||
let info = am.bank_info(BankType::GLYPH);
|
||||
// Note: put_resident happens in worker thread, then stage happens.
|
||||
assert_eq!(info.used_bytes, decoded_bytes);
|
||||
assert_eq!(info.inflight_bytes, decoded_bytes);
|
||||
assert_eq!(info.slots_occupied, 0);
|
||||
|
||||
// Commit
|
||||
am.commit(handle);
|
||||
am.apply_commits();
|
||||
|
||||
let info = am.bank_info(BankType::GLYPH);
|
||||
assert_eq!(info.used_bytes, decoded_bytes);
|
||||
assert_eq!(info.inflight_bytes, 0);
|
||||
assert_eq!(info.slots_occupied, 1);
|
||||
|
||||
// Shutdown resets
|
||||
am.shutdown();
|
||||
let info = am.bank_info(BankType::GLYPH);
|
||||
assert_eq!(info.used_bytes, 0);
|
||||
assert_eq!(info.inflight_bytes, 0);
|
||||
assert_eq!(info.slots_occupied, 0);
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user