VKVG_TEST_OFFSCREEN cmake option to perform offscreen tests

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4a41f680045ec0045bdee1c3814a1c00faeb23c9..4c3640579f7982b3ada0e609e90ba5474b95cfd8 100644 (file)
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,10 +40,17 @@ ELSE()
                SET(CMAKE_${LANG}_FLAGS "/TC /W0")
        ENDIF()
 ENDIF()
+
 OPTION(VKVG_TEST_DIRECT_DRAW "(Experimental)Draw directly on backend surface, if off surface is blitted." OFF)
 IF (VKVG_TEST_DIRECT_DRAW)
        ADD_DEFINITIONS (-DVKVG_TEST_DIRECT_DRAW)
 ENDIF ()
+
+OPTION(VKVG_TEST_OFFSCREEN "Draw offscreen without presenting result." OFF)
+IF (VKVG_TEST_OFFSCREEN)
+       ADD_DEFINITIONS (-DVKVG_TEST_OFFSCREEN)
+ENDIF ()
+
 OPTION(VKVG_PREMULT_ALPHA "use premultiplied alpha for internal rendering" ON)
 IF (VKVG_PREMULT_ALPHA)
        ADD_DEFINITIONS (-DVKVG_PREMULT_ALPHA)
@@ -218,7 +225,7 @@ FUNCTION (buildtest TEST_NAME)
 ENDFUNCTION (buildtest)
 
 if (VKVG_BUILD_TESTS)
-    ADD_LIBRARY("tests_common" STATIC tests/common/vkengine.c tests/common/test.c)
+       ADD_LIBRARY("tests_common" STATIC tests/common/vkengine.c tests/common/test.c)
        TARGET_INCLUDE_DIRECTORIES(tests_common PRIVATE
                ${Vulkan_INCLUDE_DIRS}
                ${GLFW3_INCLUDE_DIR}
@@ -228,11 +235,11 @@ if (VKVG_BUILD_TESTS)
                ${CMAKE_CURRENT_SOURCE_DIR}/vkh/include
                ${CMAKE_CURRENT_SOURCE_DIR}/vkh/src
        )
-    TARGET_LINK_LIBRARIES(tests_common
-        ${Vulkan_LIBRARIES}
-        ${GLFW3_LIBRARY}
-        vkvg_static
-    )
+       TARGET_LINK_LIBRARIES(tests_common
+               ${Vulkan_LIBRARIES}
+               ${GLFW3_LIBRARY}
+               vkvg_static
+       )
 
        file(GLOB_RECURSE DATAS RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/tests" "tests/data/*")
        FOREACH(DATA_FILE ${DATAS})
@@ -268,6 +275,9 @@ MESSAGE(STATUS "Build tests\t\t= true.")
 ELSE ()
 MESSAGE(STATUS "Build tests\t\t= false.")
 ENDIF ()
+IF (VKVG_TEST_OFFSCREEN)
+MESSAGE(STATUS "Offscreen\t\t= true.")
+ENDIF ()
 IF (ENABLE_VALIDATION)
        MESSAGE(STATUS "Validation\t\t= enabled.")
 ELSE ()

diff --git a/tests/common/test.c b/tests/common/test.c
index 9a4b1bf7a998109e5a5f6cc1c8ee3ca762f1444a..733670aaed2b79aa3ece94c16881ada4de9ff059 100644 (file)
--- a/tests/common/test.c
+++ b/tests/common/test.c
@@ -163,6 +163,136 @@ void clear_test () {
 VkvgSurface* surfaces;
 #endif
 
+void perform_test_offscreen (void(*testfunc)(void), const char *testName, int argc, char* argv[]) {
+       //init random gen
+       struct timeval currentTime;
+       gettimeofday(&currentTime, NULL);
+       srand((unsigned) currentTime.tv_usec);
+
+       //dumpLayerExts();
+       if (argc > 1)
+               iterations = atoi (argv[1]);
+       if (argc > 2)
+               test_size = atoi (argv[2]);
+       if (iterations == 0 || test_size == 0) {
+               printf("usage: test [iterations] [size]\n");
+               return;
+       }
+
+       char* whoami;
+       (whoami = strrchr(argv[0], '/')) ? ++whoami : (whoami = argv[0]);
+
+       uint32_t enabledExtsCount = 0, phyCount = 0;
+       const char* enabledExts [10];
+#ifdef VKVG_USE_RENDERDOC
+       const uint32_t enabledLayersCount = 2;
+       const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation", "VK_LAYER_RENDERDOC_Capture"};
+#elif defined (VKVG_USE_VALIDATION)
+       const uint32_t enabledLayersCount = 1;
+       const char* enabledLayers[] = {"VK_LAYER_KHRONOS_validation"};
+#else
+       const uint32_t enabledLayersCount = 0;
+       const char* enabledLayers[] = {NULL};
+#endif
+#ifdef DEBUG
+       enabledExts[enabledExtsCount] = "VK_EXT_debug_utils";
+       enabledExtsCount++;
+#endif
+
+       VkhApp app = vkh_app_create("vkvgTest", enabledLayersCount, enabledLayers, enabledExtsCount, enabledExts);
+#ifdef DEBUG
+       vkh_app_enable_debug_messenger(app
+                                                                  , VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT
+                                                                  | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT
+                                                                  | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT
+                                                                  , VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT
+                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT
+                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT
+                                                                  | VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT
+                                                                  , NULL);
+#endif
+       bool deferredResolve = false;
+       VkhPhyInfo* phys = vkh_app_get_phyinfos (app, &phyCount, VK_NULL_HANDLE);
+       VkhPhyInfo pi = 0;
+       for (uint32_t i=0; i<phyCount; i++){
+               pi = phys[i];
+               if (pi->properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU)
+                       break;
+       }
+
+       uint32_t qCount = 0;
+       float qPriorities[] = {0.0};
+       VkDeviceQueueCreateInfo pQueueInfos[] = { {0},{0},{0} };
+       if (vkh_phyinfo_create_queues (pi, pi->gQueue, 1, qPriorities, &pQueueInfos[qCount]))
+               qCount++;
+       VkPhysicalDeviceFeatures enabledFeatures = {
+               .fillModeNonSolid = true,
+       };
+
+       VkDeviceCreateInfo device_info = { .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
+                                                                          .queueCreateInfoCount = qCount,
+                                                                          .pQueueCreateInfos = (VkDeviceQueueCreateInfo*)&pQueueInfos,
+                                                                          .pEnabledFeatures = &enabledFeatures};
+
+       VkhDevice dev = vkh_device_create(app, pi, &device_info);
+
+
+       device  = vkvg_device_create_multisample(vkh_app_get_inst(app), dev->phy, dev->dev, pi->gQueue, 0, samples, deferredResolve);
+       vkvg_device_set_dpy(device, 96, 96);
+
+       vkh_app_free_phyinfos (phyCount, phys);
+
+       surf = vkvg_surface_create(device, test_width, test_height);
+
+       double start_time = 0.0, stop_time = 0.0, run_time = 0.0, run_total = 0.0, min_run_time = -1, max_run_time = 0.0;
+       double* run_time_values = (double*)malloc(iterations*sizeof(double));
+
+       uint32_t i = 0;
+       while (i < iterations) {
+               start_time = get_tick();
+
+               testfunc();
+
+               if (deferredResolve)
+                       vkvg_multisample_surface_resolve(surf);
+
+               stop_time = get_tick();
+               run_time = stop_time - start_time;
+               run_time_values[i] = run_time;
+
+               if (min_run_time < 0)
+                       min_run_time = run_time;
+               else
+                       min_run_time = MIN(run_time, min_run_time);
+               max_run_time = MAX(run_time, max_run_time);
+               run_total += run_time;
+               i++;
+       }
+
+       double avg_run_time = run_total / (double)i;
+       double med_run_time = median_run_time (run_time_values, i);
+       double standard_dev = standard_deviation (run_time_values, i, avg_run_time);
+       double avg_frames_per_second = (1.0 / avg_run_time);
+       avg_frames_per_second = (avg_frames_per_second<9999) ? avg_frames_per_second:9999;
+
+       free (run_time_values);
+
+       //printf ("size:%d iter:%d  avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev);
+       printf ("| %-15s | %-25s | ",whoami + 5, testName);
+       printf ("%4d | %4d | %7.2f | %6.5f | %6.5f | %6.5f |\n",
+                       test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev);
+
+       //printf ("%s size:%d iter:%d  avgFps: %f avg: %4.2f%% med: %4.2f%% sd: %4.2f%% \n", whoami+5, test_size, i, avg_frames_per_second, avg_run_time, med_run_time, standard_dev);
+
+       vkDeviceWaitIdle(dev->dev);
+
+       vkvg_surface_destroy    (surf);
+       vkvg_device_destroy     (device);
+
+       vkh_device_destroy (dev);
+       vkh_app_destroy (app);
+}
+
 void perform_test (void(*testfunc)(void), const char *testName, int argc, char* argv[]) {
        //init random gen
        struct timeval currentTime;

diff --git a/tests/common/test.h b/tests/common/test.h
index 91b6393a0880ed0d7fea09b1cafae1cba20e0bd2..a0d558dd2fd633cae87af1d2f66b2b9ca42e2a72 100644 (file)
--- a/tests/common/test.h
+++ b/tests/common/test.h
@@ -9,6 +9,7 @@
 
 #include "vkh_device.h"
 #include "vkh_presenter.h"
+#include "vkh_phyinfo.h"
 
 #define M_PIF               3.14159265359f /* float pi */
 #define M_PIF_MULT_2        6.28318530718f
@@ -20,8 +21,11 @@
 #ifndef MAX
 # define MAX(a,b) (((a) > (b)) ? (a) : (b))
 #endif
-
+#ifdef VKVG_TEST_OFFSCREEN
+#define PERFORM_TEST(testName, argc, argv) perform_test_offscreen(testName, #testName, argc, argv);
+#else
 #define PERFORM_TEST(testName, argc, argv) perform_test(testName, #testName, argc, argv);
+#endif
 #if defined(_WIN32) || defined(_WIN64)
        #define WIN32_LEAN_AND_MEAN
        #define NOMINMAX
@@ -87,6 +91,7 @@ extern VkvgSurface surf;
 
 //run test in one step
 void perform_test (void(*testfunc)(), const char* testName, int argc, char *argv[]);
+void perform_test_offscreen (void(*testfunc)(void), const char *testName, int argc, char* argv[]);
 
 void randomize_color   (VkvgContext ctx);
 void draw_random_shape (VkvgContext ctx, shape_t shape, float sizeFact);