From 5e6396ed225be9a9991705de10174b3cf085f8f0 Mon Sep 17 00:00:00 2001 From: tcmal Date: Sun, 25 Aug 2024 17:44:24 +0100 Subject: refactor(skeleton): type phases of queue negotiation --- stockton-skeleton/src/queue_negotiator.rs | 186 +++++++++++++++++------------- 1 file changed, 108 insertions(+), 78 deletions(-) (limited to 'stockton-skeleton/src/queue_negotiator.rs') diff --git a/stockton-skeleton/src/queue_negotiator.rs b/stockton-skeleton/src/queue_negotiator.rs index f3e38fd..b78fe33 100644 --- a/stockton-skeleton/src/queue_negotiator.rs +++ b/stockton-skeleton/src/queue_negotiator.rs @@ -1,70 +1,76 @@ //! Used for requesting appropriate queue families, and sharing/allocating queues as necessary. -//! This is created by `RenderingContext`, and should mostly be accessed from [`crate::draw_passes::IntoDrawPass`]. +//! You'll mostly use these from [`crate::draw_passes::IntoDrawPass`]. //! -//! For example, to use a `TexLoadQueue` in your drawpass: +//! For example, to use a `TexLoadQueue` in your drawpass, first find the family during the init phase: //! ``` -//! # use crate::{types::*, texture::TexLoadQueue}; +//! # use stockton_skeleton::{types::*, texture::TexLoadQueue, queue_negotiator::*}; +//! # use anyhow::Result; //! fn find_aux_queues<'c>( //! adapter: &'c Adapter, -//! queue_negotiator: &mut QueueNegotiator, -//! ) -> Result)>> { -//! queue_negotiator.find(adapter, &TexLoadQueue)?; +//! queue_negotiator: &mut QueueFamilyNegotiator, +//! ) -> Result<()> { +//! queue_negotiator.find(adapter, &TexLoadQueue, 1)?; //! -//! Ok(vec![queue_negotiator -//! .family_spec::(&adapter.queue_families, 1) -//! .ok_or(EnvironmentError::NoSuitableFamilies)?]) +//! Ok(()) //! } //! ``` //! //! Then get your queue in [`crate::draw_passes::IntoDrawPass::init`] +//! //! ``` -//! # use crate::{types::*, context::RenderingContext, texture::TexLoadQueue}; +//! # use stockton_skeleton::{types::*, context::RenderingContext, texture::TexLoadQueue, queue_negotiator::*}; +//! # use anyhow::Result; //! # use stockton_types::Session; -//! fn init( -//! self, -//! session: &mut Session, -//! context: &mut RenderingContext, -//! ) -> Result> { -//! let queue = context.queue_negotiator_mut().get_queue::().unwrap(); -//! } +//! # struct YourDrawPass; +//! # fn init( +//! # context: &mut RenderingContext, +//! # ) -> Result<()> { +//! let queue = context.queue_negotiator_mut().get_queue::()?; +//! // ... +//! # Ok(()) +//! # } //! ``` use crate::{ error::{EnvironmentError, UsageError}, types::*, }; - use anyhow::{bail, Error, Result}; use hal::queue::family::QueueFamilyId; use std::{ any::TypeId, - collections::HashMap, + collections::hash_map::{Entry, HashMap}, sync::{Arc, RwLock}, }; /// A queue, possibly shared between threads. pub type SharedQueue = Arc>; -/// Used to find appropriate queue families and share queues from them as needed. -pub struct QueueNegotiator { - family_ids: HashMap, - already_allocated: HashMap, usize)>, - all: Vec, +/// Used to find appropriate queue families during init phase. +pub struct QueueFamilyNegotiator { + /// Family and count being used for each selector + family_ids: HashMap, } -/// Can be used to select an appropriate queue family -pub trait QueueFamilySelector: 'static { - /// Return true if the given family is suitable - fn is_suitable(&self, family: &QueueFamilyT) -> bool; -} +impl QueueFamilyNegotiator { + /// Create a new, empty, QueueFamilyNegotiator + pub fn new() -> Self { + QueueFamilyNegotiator { + family_ids: HashMap::new(), + } + } -impl QueueNegotiator { /// Attempt to find an appropriate queue family using the given selector. - /// Returns early if the *type* of the selector has already been allocated a family. + /// If T has already been used in a different call for find, it will request the sum of the `count` values from both calls. /// This should usually be called by [`crate::draw_passes::IntoDrawPass::find_aux_queues`]. - pub fn find(&mut self, adapter: &Adapter, filter: &T) -> Result<()> { - if self.family_ids.contains_key(&TypeId::of::()) { - return Ok(()); + pub fn find<'a, T: QueueFamilySelector>( + &mut self, + adapter: &'a Adapter, + filter: &T, + mut count: usize, + ) -> Result<()> { + if let Entry::Occupied(e) = self.family_ids.entry(TypeId::of::()) { + count = count + e.get().0; } let candidates: Vec<&QueueFamilyT> = adapter @@ -80,26 +86,87 @@ impl QueueNegotiator { // Prefer using unique families let family = match candidates .iter() - .find(|x| !self.family_ids.values().any(|y| *y == x.id())) + .find(|x| !self.family_ids.values().any(|y| y.1 == x.id())) { Some(x) => *x, None => candidates[0], }; - self.family_ids.insert(TypeId::of::(), family.id()); + self.family_ids + .insert(TypeId::of::(), (count, family.id())); Ok(()) } + /// Used to get a spec passed to [`hal::adapter::PhysicalDevice::open`] + pub(crate) fn get_open_spec<'a>(&self, adapter: &'a Adapter) -> AdapterOpenSpec<'a> { + // Deduplicate families & convert to specific type. + let mut spec = Vec::with_capacity(self.family_ids.len()); + for (count, qf_id) in self.family_ids.values() { + if let Some(existing_family_spec) = spec + .iter() + .position(|(qf2_id, _): &(&QueueFamilyT, Vec)| qf2_id.id() == *qf_id) + { + for _ in 0..*count { + spec[existing_family_spec].1.push(1.0); + } + } else { + let family = adapter + .queue_families + .iter() + .find(|x| x.id() == *qf_id) + .unwrap(); + spec.push((family, vec![1.0; *count])) + } + } + AdapterOpenSpec(spec.into_boxed_slice()) + } + + /// Finish selecting our queue families, and turn this into a `QueueNegotiator` + pub fn finish<'a>(self, queue_groups: Vec) -> QueueNegotiator { + QueueNegotiator { + family_ids: self.family_ids, + already_allocated: HashMap::new(), + all: queue_groups, + } + } +} + +/// Used internally in calls to [`hal::adapter::PhysicalDevice::open`] +pub(crate) struct AdapterOpenSpec<'a>(Box<[(&'a QueueFamilyT, Vec)]>); + +impl<'a> AdapterOpenSpec<'a> { + pub fn as_vec(&self) -> Vec<(&'a QueueFamilyT, &[f32])> { + let mut v = Vec::with_capacity(self.0.len()); + for (qf, cs) in self.0.iter() { + v.push((*qf, cs.as_slice())); + } + + v + } +} + +/// Used to share queues from families selected during init phase. +pub struct QueueNegotiator { + family_ids: HashMap, + already_allocated: HashMap, usize)>, + all: Vec, +} + +/// Can be used to select an appropriate queue family +pub trait QueueFamilySelector: 'static { + /// Return true if the given family is suitable + fn is_suitable(&self, family: &QueueFamilyT) -> bool; +} + +impl QueueNegotiator { /// Get a (possibly shared) queue. You should prefer to call this once and store the result. - /// You should already have called [`self::QueueNegotiator::find`] and [`self::QueueNegotiator::family_spec`], - /// otherwise this will return an error. + /// You should already have called [`self::QueueFamilyNegotiator::find`], otherwise this will return an error. /// - /// Round-robin allocation is used to try to fairly distribute work between each queue. /// The family of the queue returned is guaranteed to meet the spec of the `QueueFamilySelector` originally used by `find`. pub fn get_queue(&mut self) -> Result>> { let tid = TypeId::of::(); - let family_id = self + let (_, family_id) = self .family_ids .get(&tid) .ok_or(UsageError::QueueNegotiatorMisuse)?; @@ -131,36 +198,9 @@ impl QueueNegotiator { } } - /// Convenience function to get a queue spec for the given selector. - /// You should probably call this from [`crate::draw_passes::IntoDrawPass::find_aux_queues`]. - /// `count` is the maximum number of individual queues to request. You may get less than this, in which case they will be shared. - /// This will return an error if you haven't called [`self::QueueNegotiator::find`] beforehand, or if there were no suitable queue families. - pub fn family_spec<'a, T: QueueFamilySelector>( - &self, - queue_families: &'a [QueueFamilyT], - count: usize, - ) -> Result<(&'a QueueFamilyT, Vec)> { - let qf_id = self - .family::() - .ok_or(UsageError::QueueNegotiatorMisuse)?; - - let qf = queue_families - .iter() - .find(|x| x.id() == qf_id) - .ok_or(EnvironmentError::NoSuitableFamilies)?; - let v = vec![1.0; count]; - - Ok((qf, v)) - } - /// Get the queue family ID being used by the given selector pub fn family(&self) -> Option { - self.family_ids.get(&TypeId::of::()).cloned() - } - - /// Used internally to get the queue groups from the adapter. - pub(crate) fn set_queue_groups(&mut self, queue_groups: Vec) { - self.all = queue_groups + self.family_ids.get(&TypeId::of::()).map(|x| x.1) } /// Used internally to mark that we've started sharing a queue @@ -177,16 +217,6 @@ impl QueueNegotiator { } } -impl Default for QueueNegotiator { - fn default() -> Self { - QueueNegotiator { - family_ids: HashMap::new(), - already_allocated: HashMap::new(), - all: vec![], - } - } -} - /// A queue suitable for drawing to a given surface with. pub struct DrawQueue { pub surface: SurfaceT, -- cgit v1.2.3