minimal example of 15ms lag

src/main.rs

@@ -9,6 +9,7 @@ extern crate nalgebra as na;
 extern crate rand;
 extern crate sfml;
 extern crate time;
+extern crate hprof;
 
 use sfml::system::*;
 use vulkano::sync;
@@ -38,6 +39,7 @@ mod sprite;
 mod canvas;
 mod canvas_frame;
 mod canvas_shader;
+mod canvas_buffer;
 
 mod compu_state;
 mod compu_frame;
@@ -45,6 +47,7 @@ mod compu_sprite;
 mod compu_kernel;
 mod compu_buffer;
 
+
 /*
 
 Alright, what the hell do I do next...
@@ -55,6 +58,10 @@ Canvas works, but I want to use CPU accessible buffer instead of immutable buffe
 
 fn main() {
 
+    hprof::start_frame();
+
+    let q1 = hprof::enter("setup");
+
     let instance = {
         let extensions = vulkano_win::required_extensions();
         Instance::new(None, &extensions, None).unwrap()
@@ -67,11 +74,16 @@ fn main() {
     let mut window = surface.window();
 
     let mut processor = vkprocessor::VkProcessor::new(&instance, &surface);
-    processor.create_swapchain(&surface);
+    {
+        let g = hprof::enter("vulkan preload");
+        processor.create_swapchain(&surface);
 
-    processor.preload_kernels();
-    processor.preload_shaders();
-    processor.preload_textures();
+        processor.preload_kernels();
+        processor.preload_shaders();
+        processor.preload_textures();
+    }
+
+    let q2 = hprof::enter("Game Objects");
 
     let mut timer = Timer::new();
     let mut frame_future = Box::new(sync::now(processor.device.clone())) as Box<dyn GpuFuture>;
@@ -84,10 +96,6 @@ fn main() {
 
     let mut mouse_xy = Vector2i::new(0,0);
 
-
-
-
-
     let sprite = Sprite::new_with_color((0.,0.), (0.1,0.1), (1.,0.,0.,1.));
     let sprite2 = Sprite::new_with_color((-1.,-0.5), (0.1,0.1), (0.,1.,0.,1.));
 
@@ -105,9 +113,14 @@ fn main() {
 
     let sprite3 = Sprite::new_with_texture((0.3, 0.5), (0.1,0.1), handle.clone());
 
+    drop(q2);
+    drop(q1);
+
+    let l = hprof::enter("Loop");
+
+    let mut exit = false;
 
     while let Some(p) = window.get_position() {
-
         elapsed_time = timer.elap_time();
         delta_time = elapsed_time - current_time;
         current_time = elapsed_time;
@@ -120,9 +133,7 @@ fn main() {
             accumulator_time -= step_size;
         }
 
-        println!("{}", delta_time);
-
-        let mut exit = false;
+        //  println!("{}", delta_time);
         events_loop.poll_events(|event| {
             match event {
                 Event::WindowEvent { event: WindowEvent::CloseRequested, .. } =>
@@ -133,11 +144,10 @@ fn main() {
                     processor.recreate_swapchain(&surface);
                 },
                 Event::DeviceEvent { event: DeviceEvent::Key(keyboard_input), .. } => {
-
                     match keyboard_input.virtual_keycode.unwrap() {
                         VirtualKeyCode::A => {
                             if keyboard_input.state == ElementState::Pressed {
-                               // processor.save_edges_image();
+                                // processor.save_edges_image();
                             }
                         }
                         _ => ()
@@ -151,23 +161,30 @@ fn main() {
         });
 
         if exit {
-            return;
+            break;
         }
 
         let mut compu_frame = CompuFrame::new();
-        compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
-        compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
+       // compu_frame.add(compute_buffer.clone(), compute_kernel.clone());
+       // compu_frame.add_with_image_swap(compute_buffer.clone(), compute_kernel.clone(), &compu_sprite1);
 
         let mut canvas = CanvasFrame::new();
         canvas.draw(&sprite);
-        canvas.draw(&sprite2);
-        canvas.draw(&sprite3);
-        canvas.draw(&compu_sprite1);
-
-        (frame_future) = processor.run(&surface, frame_future,
-                                       canvas,
-                                       compu_frame);
+        //canvas.draw(&sprite2);
+        //canvas.draw(&sprite3);
+        //canvas.draw(&compu_sprite1);
+        {
+            let g = hprof::enter("Run");
+            (frame_future) = processor.run(&surface, frame_future,
+                                           canvas,
+                                           compu_frame);
+        }
     }
+
+    drop(l);
+
+    hprof::end_frame();
+    hprof::profiler().print_timing();
 }