That's it. Fifo present mode halts until the next time the screen is refreshed. Mailbox will replace the lined up image if the refresh period has not been reached

src/main.rs

@@ -175,7 +175,8 @@ fn main() {
         //canvas.draw(&compu_sprite1);
         {
             let g = hprof::enter("Run");
-            (frame_future) = processor.run(&surface, frame_future,
+            processor.run(&surface,
+                                           //frame_future,
                                            canvas,
                                            compu_frame);
         }

src/vkprocessor.rs

@@ -15,6 +15,7 @@ use crate::canvas::{CanvasState, CanvasTextureHandle, CanvasShaderHandle, Canvas
 use crate::canvas_frame::CanvasFrame;
 use crate::compu_kernel::{CompuKernel, CompuKernelHandle};
 use crate::compu_buffer::{CompuBuffers, CompuBufferHandle};
+use std::time::Duration;
 
 pub struct VkProcessor<'a> {
     // Vulkan state fields
@@ -94,7 +95,7 @@ impl<'a> VkProcessor<'a> {
 
             Swapchain::new(self.device.clone(),
                            surface.clone(),
-                           capabilities.min_image_count, // number of attachment images
+                           capabilities.min_image_count + 10, // number of attachment images
                            format,
                            initial_dimensions,
                            1, // Layers
@@ -102,13 +103,12 @@ impl<'a> VkProcessor<'a> {
                            &self.queue,
                            SurfaceTransform::Identity,
                            alpha,
-                           PresentMode::Fifo, true, None).unwrap()
+                           PresentMode::Mailbox, true, None).unwrap()
         };
 
         self.swapchain = Some(swapchain);
         self.swapchain_images = Some(images);
     }
-
     // On resizes we have to recreate the swapchain
     pub fn recreate_swapchain(&mut self, surface: &'a Arc<Surface<Window>>) {
         let dimensions = if let Some(dimensions) = surface.window().get_inner_size() {
@@ -174,22 +174,23 @@ impl<'a> VkProcessor<'a> {
 
     pub fn run(&mut self,
                surface: &'a Arc<Surface<Window>>,
-               mut frame_future: Box<dyn GpuFuture>,
+    //           mut frame_future: Box<dyn GpuFuture>,
                canvas_frame: CanvasFrame,
                compute_frame: CompuFrame,
     )
-               -> Box<dyn GpuFuture> {
+    //      -> Box<dyn GpuFuture> {
+    {
         {
             let g = hprof::enter("Waiting at queue");
             self.queue.wait();
         }
 
-
+        let g = hprof::enter("Frame buffer, future, swapchain recreate");
         let mut framebuffers =
             self.canvas.window_size_dependent_setup(&self.swapchain_images.clone().unwrap().clone());
 
         // The docs said to call this on each loop.
-        frame_future.cleanup_finished();
+   //     frame_future.cleanup_finished();
 
         // Whenever the window resizes we need to recreate everything dependent on the window size.
         // In this example that includes the swapchain, the framebuffers and the dynamic state viewport.
@@ -200,18 +201,29 @@ impl<'a> VkProcessor<'a> {
             self.swapchain_recreate_needed = false;
         }
 
+
         // This function can block if no image is available. The parameter is an optional timeout
         // after which the function call will return an error.
-        let (image_num, acquire_future) = match vulkano::swapchain::acquire_next_image(self.swapchain.clone().unwrap().clone(), None) {
+        let (image_num, acquire_future) =
-            Ok(r) => r,
+            match vulkano::swapchain::acquire_next_image(
-            Err(AcquireError::OutOfDate) => {
+                self.swapchain.clone().unwrap().clone(),
-                self.swapchain_recreate_needed = true;
+                //Some(Duration::from_millis(3)),
-                return Box::new(sync::now(self.device.clone())) as Box<_>;
+                None,
-            }
+            ) {
-            Err(err) => panic!("{:?}", err)
+                Ok(r) => r,
-        };
+                Err(AcquireError::OutOfDate) => {
+                    self.swapchain_recreate_needed = true;
+                    //return Box::new(sync::now(self.device.clone())) as Box<_>;
+                    return;
+                }
+                Err(err) => panic!("{:?}", err)
+            };
+        drop(g);
+
+        let g = hprof::enter("Joining the future");
+     //   let future = frame_future.join(acquire_future);
+        drop(g);
 
-        let future = frame_future.join(acquire_future);
         {
             let g = hprof::enter("Canvas creates GPU buffers");
             // take the canvas frame and create the vertex buffers
@@ -224,36 +236,41 @@ impl<'a> VkProcessor<'a> {
 
         let g = hprof::enter("Push compute commands to command buffer");
         // Add the compute commands
-      //  let mut command_buffer = self.compute_state.compute_commands(compute_frame, command_buffer, &self.canvas);
+        //  let mut command_buffer = self.compute_state.compute_commands(compute_frame, command_buffer, &self.canvas);
         drop(g);
 
         let g = hprof::enter("Push draw commands to command buffer");
         // Add the draw commands
-     //   let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num);
+        //   let mut command_buffer = self.canvas.draw_commands(command_buffer, framebuffers, image_num);
         drop(g);
 
         // And build
         let command_buffer = command_buffer.build().unwrap();
 
         // Wait on the previous frame, then execute the command buffer and present the image
-
+        {
-        let future = future //frame_future.join(acquire_future)
+            let g = hprof::enter("Mussing with the frame future");
-            .then_execute(self.queue.clone(), command_buffer).unwrap()
+
-            .then_swapchain_present(self.queue.clone(), self.swapchain.clone().unwrap().clone(), image_num)
+            //let future = future //frame_future.join(acquire_future)
-            .then_signal_fence_and_flush();
+            let future = sync::now(self.device.clone())
-
+                .then_execute(self.queue.clone(), command_buffer).unwrap()
-        match future {
+                .then_swapchain_present(self.queue.clone(), self.swapchain.clone().unwrap().clone(), image_num)
-            Ok(future) => {
+                .then_signal_fence_and_flush();
-                (Box::new(future) as Box<_>)
+            future.unwrap().wait(None).unwrap();
-            }
+
-            Err(FlushError::OutOfDate) => {
+//            match future {
-                self.swapchain_recreate_needed = true;
+//                Ok(future) => {
-                (Box::new(sync::now(self.device.clone())) as Box<_>)
+//                    (Box::new(future) as Box<_>)
-            }
+//                }
-            Err(e) => {
+//                Err(FlushError::OutOfDate) => {
-                println!("{:?}", e);
+//                    self.swapchain_recreate_needed = true;
-                (Box::new(sync::now(self.device.clone())) as Box<_>)
+//                    (Box::new(sync::now(self.device.clone())) as Box<_>)
-            }
+//                }
+//                Err(e) => {
+//                    println!("{:?}", e);
+//                    (Box::new(sync::now(self.device.clone())) as Box<_>)
+//                }
+//            }
         }
     }
 }
@@ -275,4 +292,3 @@ impl<'a> VkProcessor<'a> {
 
 
 
-