Remote command sink in Metal

src/backend/gl/src/native.rs

@@ -174,15 +174,11 @@ pub struct DescriptorSet {
 pub struct DescriptorPool {}
 
 impl pso::DescriptorPool<Backend> for DescriptorPool {
-    fn allocate_sets<I>(&mut self, layouts: I) -> Vec<Result<DescriptorSet, pso::AllocationError>>
-    where
-        I: IntoIterator,
-        I::Item: Borrow<DescriptorSetLayout>,
-    {
-        layouts.into_iter().map(|layout| Ok(DescriptorSet {
-            layout: layout.borrow().clone(),
+    fn allocate_set(&mut self, layout: &DescriptorSetLayout) -> Result<DescriptorSet, pso::AllocationError> {
+        Ok(DescriptorSet {
+            layout: layout.clone(),
             bindings: Arc::new(Mutex::new(Vec::new())),
-        })).collect()
+        })
     }
 
     fn free_sets<I>(&mut self, _descriptor_sets: I)

src/backend/vulkan/src/native.rs

@@ -95,7 +95,9 @@ pub struct DescriptorPool {
 }
 
 impl pso::DescriptorPool<Backend> for DescriptorPool {
-    fn allocate_sets<I>(&mut self, layout_iter: I) -> Vec<Result<DescriptorSet, pso::AllocationError>>
+    fn allocate_sets<I>(
+        &mut self, layout_iter: I, output: &mut Vec<DescriptorSet>
+    ) -> Result<(), pso::AllocationError>
     where
         I: IntoIterator,
         I::Item: Borrow<DescriptorSetLayout>,
@@ -117,27 +119,21 @@ impl pso::DescriptorPool<Backend> for DescriptorPool {
             p_set_layouts: raw_layouts.as_ptr(),
         };
 
-        let descriptor_sets = unsafe {
-            self.device.0.allocate_descriptor_sets(&info)
-        };
-
-        match descriptor_sets {
-            Ok(sets) => {
-                sets.into_iter()
-                    .zip(layout_bindinds.into_iter())
-                    .map(|(raw, bindings)| {
-                        Ok(DescriptorSet { raw, bindings })
-                    })
-                    .collect()
-            }
-            Err(err) => vec![Err(match err {
+        unsafe { self.device.0.allocate_descriptor_sets(&info) }
+            .map(|sets| {
+                output.extend(sets
+                    .into_iter()
+                    .zip(layout_bindinds)
+                    .map(|(raw, bindings)| DescriptorSet { raw, bindings })
+                )
+            })
+            .map_err(|err| match err {
                 vk::Result::ErrorOutOfHostMemory => pso::AllocationError::OutOfHostMemory,
                 vk::Result::ErrorOutOfDeviceMemory => pso::AllocationError::OutOfDeviceMemory,
                 // TODO: Uncomment when ash updates to include VK_ERROR_OUT_OF_POOL_MEMORY(_KHR)
                 // vk::Result::ErrorOutOfPoolMemory => pso::AllocationError::OutOfPoolMemory,
                 _ => pso::AllocationError::FragmentedPool,
-            })]
-        }
+            })
     }
 
     fn free_sets<I>(&mut self, descriptor_sets: I)

src/hal/src/pso/descriptor.rs

@@ -119,23 +119,32 @@ pub trait DescriptorPool<B: Backend>: Send + Sync + fmt::Debug {
     /// Descriptors will become invalid once the pool is reset. Usage of invalidated descriptor sets results
     /// in undefined behavior.
     fn allocate_set(&mut self, layout: &B::DescriptorSetLayout) -> Result<B::DescriptorSet, AllocationError> {
-        self.allocate_sets(Some(layout)).remove(0)
+        let mut sets = Vec::with_capacity(1);
+        self.allocate_sets(Some(layout), &mut sets)
+            .map(|_| sets.remove(0))
     }
 
     /// Allocate one or multiple descriptor sets from the pool.
     ///
     /// Each descriptor set will be allocated from the pool according to the corresponding set layout.
     /// Descriptors will become invalid once the pool is reset. Usage of invalidated descriptor sets results
     /// in undefined behavior.
-    fn allocate_sets<I>(&mut self, layouts: I) -> Vec<Result<B::DescriptorSet, AllocationError>>
+    fn allocate_sets<I>(&mut self, layouts: I, sets: &mut Vec<B::DescriptorSet>) -> Result<(), AllocationError>
     where
         I: IntoIterator,
         I::Item: Borrow<B::DescriptorSetLayout>,
     {
-        layouts
-            .into_iter()
-            .map(|layout| self.allocate_set(layout.borrow()))
-            .collect()
+        let base = sets.len();
+        for layout in layouts {
+            match self.allocate_set(layout.borrow()) {
+                Ok(set) => sets.push(set),
+                Err(e) => {
+                    self.free_sets(sets.drain(base ..));
+                    return Err(e)
+                }
+            }
+        }
+        Ok(())
     }
 
     /// Free the given descriptor sets provided as an iterator.