refactor(skeleton): type phases of queue negotiation

1 files changed, 108 insertions, 78 deletions

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<Vec<(&'c QueueFamilyT, Vec<f32>)>> {
-//!     queue_negotiator.find(adapter, &TexLoadQueue)?;
+//!    queue_negotiator: &mut QueueFamilyNegotiator,
+//! ) -> Result<()> {
+//!     queue_negotiator.find(adapter, &TexLoadQueue, 1)?;
 //!
-//!     Ok(vec![queue_negotiator
-//!         .family_spec::<TexLoadQueue>(&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<LevelDrawPass<'a, M>> {
-//!     let queue = context.queue_negotiator_mut().get_queue::<TexLoadQueue>().unwrap();
-//! }
+//! # struct YourDrawPass;
+//! # fn init(
+//! #    context: &mut RenderingContext,
+//! # ) -> Result<()> {
+//! let queue = context.queue_negotiator_mut().get_queue::<TexLoadQueue>()?;
+//!  // ...
+//! # 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<RwLock<QueueT>>;
 
-/// Used to find appropriate queue families and share queues from them as needed.
-pub struct QueueNegotiator {
-    family_ids: HashMap<TypeId, QueueFamilyId>,
-    already_allocated: HashMap<TypeId, (Vec<SharedQueue>, usize)>,
-    all: Vec<QueueGroup>,
+/// Used to find appropriate queue families during init phase.
+pub struct QueueFamilyNegotiator {
+    /// Family and count being used for each selector
+    family_ids: HashMap<TypeId, (usize, QueueFamilyId)>,
 }
 
-/// 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<T: QueueFamilySelector>(&mut self, adapter: &Adapter, filter: &T) -> Result<()> {
-        if self.family_ids.contains_key(&TypeId::of::<T>()) {
-            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::<T>()) {
+            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::<T>(), family.id());
+        self.family_ids
+            .insert(TypeId::of::<T>(), (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<f32>)| 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<QueueGroup>) -> 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<f32>)]>);
+
+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<TypeId, (usize, QueueFamilyId)>,
+    already_allocated: HashMap<TypeId, (Vec<SharedQueue>, usize)>,
+    all: Vec<QueueGroup>,
+}
+
+/// 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<T: QueueFamilySelector>(&mut self) -> Result<Arc<RwLock<QueueT>>> {
         let tid = TypeId::of::<T>();
-        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<f32>)> {
-        let qf_id = self
-            .family::<T>()
-            .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<T: QueueFamilySelector>(&self) -> Option<QueueFamilyId> {
-        self.family_ids.get(&TypeId::of::<T>()).cloned()
-    }
-
-    /// Used internally to get the queue groups from the adapter.
-    pub(crate) fn set_queue_groups(&mut self, queue_groups: Vec<QueueGroup>) {
-        self.all = queue_groups
+        self.family_ids.get(&TypeId::of::<T>()).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,