Fix order of maintenace between submission tracking and buffer mapping.

wgpu-core/src/device/life.rs

@@ -109,6 +109,7 @@ impl<B: hal::Backend> NonReferencedResources<B> {
         if !self.buffers.is_empty() {
             let mut heaps = heaps_mutex.lock();
             for (raw, memory) in self.buffers.drain(..) {
+                log::trace!("Buffer {:?} is destroyed with memory {:?}", raw, memory);
                 device.destroy_buffer(raw);
                 heaps.free(device, memory);
             }
@@ -237,10 +238,14 @@ impl<B: hal::Backend> LifetimeTracker<B> {
     }
 
     /// Returns the last submission index that is done.
-    fn check_last_done(
+    pub fn triage_submissions(
         &mut self,
         device: &B::Device,
+        force_wait: bool,
     ) -> SubmissionIndex {
+        if force_wait {
+            self.wait_idle(device);
+        }
         //TODO: enable when `is_sorted_by_key` is stable
         //debug_assert!(self.active.is_sorted_by_key(|a| a.index));
         let done_count = self
@@ -269,22 +274,19 @@ impl<B: hal::Backend> LifetimeTracker<B> {
     pub fn cleanup(
         &mut self,
         device: &B::Device,
-        force_wait: bool,
         heaps_mutex: &Mutex<Heaps<B>>,
         descriptor_allocator_mutex: &Mutex<DescriptorAllocator<B>>,
-    ) -> SubmissionIndex {
-        if force_wait {
-            self.wait_idle(device);
-        }
-        let last_done = self.check_last_done(device);
+    ) {
         unsafe {
             self.free_resources.clean(
                 device,
                 heaps_mutex,
                 descriptor_allocator_mutex,
             );
+            descriptor_allocator_mutex
+                .lock()
+                .cleanup(device);
         }
-        last_done
     }
 }
 
@@ -395,6 +397,7 @@ impl<B: GfxBackend> LifetimeTracker<B> {
                 if trackers.buffers.remove_abandoned(id) {
                     hub.buffers.free_id(id);
                     let res = guard.remove(id).unwrap();
+                    log::debug!("Buffer {:?} is detached", id);
 
                     let submit_index = res.life_guard.submission_index.load(Ordering::Acquire);
                     self.active

wgpu-core/src/device/mod.rs

@@ -288,18 +288,13 @@ impl<B: GfxBackend> Device<B> {
         life_tracker.triage_suspected(global, &self.trackers, token);
         life_tracker.triage_mapped(global, token);
         life_tracker.triage_framebuffers(global, &mut *self.framebuffers.lock(), token);
+        let _last_done = life_tracker.triage_submissions(&self.raw, force_wait);
         let callbacks = life_tracker.handle_mapping(global, &self.raw, &self.trackers, token);
         life_tracker.cleanup(
             &self.raw,
-            force_wait,
             &self.mem_allocator,
             &self.desc_allocator,
         );
-
-        unsafe {
-            self.desc_allocator.lock().cleanup(&self.raw);
-        }
-
         callbacks
     }
 
@@ -493,9 +488,9 @@ impl<B: hal::Backend> Device<B> {
     }
 
     pub(crate) fn dispose(self) {
+        self.life_tracker.lock().triage_submissions(&self.raw, true);
         self.life_tracker.lock().cleanup(
             &self.raw,
-            true,
             &self.mem_allocator,
             &self.desc_allocator,
         );
@@ -534,6 +529,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         let ref_count = buffer.life_guard.add_ref();
 
         let id = hub.buffers.register_identity(id_in, buffer, &mut token);
+        log::info!("Created buffer {:?} with {:?}", id, desc);
         device
             .trackers
             .lock()
@@ -580,6 +576,7 @@ impl<G: GlobalIdentityHandlerFactory> Global<G> {
         };
 
         let id = hub.buffers.register_identity(id_in, buffer, &mut token);
+        log::info!("Created mapped buffer {:?} with {:?}", id, desc);
         device.trackers
             .lock()
             .buffers.init(