test with only guarded last fence wait and submit

diff --git a/src/vkvg_context.c b/src/vkvg_context.c
index 152bbb17578cc68678b24924086bdd502e9b8e9f..f0549c2b261f04d16b4af3b2338dac45e36e08a2 100644 (file)
--- a/src/vkvg_context.c
+++ b/src/vkvg_context.c
@@ -235,7 +235,8 @@ void vkvg_destroy (VkvgContext ctx)
 
 #endif
 
-       vkDestroyFence          (dev, ctx->flushFence,NULL);
+       _vkvg_device_destroy_fence (ctx->pSurf->dev, ctx->flushFence);
+
        vkFreeCommandBuffers(dev, ctx->cmdPool, 2, ctx->cmdBuffers);
        vkDestroyCommandPool(dev, ctx->cmdPool, NULL);
 

diff --git a/src/vkvg_context_internal.c b/src/vkvg_context_internal.c
index c191c4e98d55106af6720728cef8325a0ac73fa7..33039447f2fe73953e808021ee8c8dda2dca0c5c 100644 (file)
--- a/src/vkvg_context_internal.c
+++ b/src/vkvg_context_internal.c
@@ -416,10 +416,6 @@ bool _wait_flush_fence (VkvgContext ctx) {
        ctx->status = VKVG_STATUS_TIMEOUT;
        return false;
 }
-void _reset_flush_fence (VkvgContext ctx) {
-       LOG(VKVG_LOG_INFO, "CTX: _reset_flush_fence\n");
-       ResetFences (ctx->pSurf->dev->vkDev, 1, &ctx->flushFence);
-}
 bool _wait_and_submit_cmd (VkvgContext ctx){
        if (!ctx->cmdStarted)//current cmd buff is empty, be aware that wait is also canceled!!
                return true;
@@ -428,8 +424,7 @@ bool _wait_and_submit_cmd (VkvgContext ctx){
 
        if (!_wait_flush_fence (ctx))
                return false;
-       _reset_flush_fence(ctx);
-
+       _vkvg_device_reset_fence(ctx->pSurf->dev, ctx->flushFence);
        _submit_cmd (ctx->pSurf->dev, &ctx->cmd, ctx->flushFence);
 
        if (ctx->cmd == ctx->cmdBuffers[0])

diff --git a/src/vkvg_context_internal.h b/src/vkvg_context_internal.h
index 6747d7d8e19de1944d633236bdc8160f33dbfbb2..24da3b2da1751a56103c57f26082c91965427f3a 100644 (file)
--- a/src/vkvg_context_internal.h
+++ b/src/vkvg_context_internal.h
@@ -299,7 +299,6 @@ void _flush_cmd_buff                (VkvgContext ctx);
 void _emit_draw_cmd_undrawn_vertices(VkvgContext ctx);
 void _flush_cmd_until_vx_base (VkvgContext ctx);
 bool _wait_flush_fence         (VkvgContext ctx);
-void _reset_flush_fence                (VkvgContext ctx);
 bool _wait_and_submit_cmd      (VkvgContext ctx);
 void _update_push_constants (VkvgContext ctx);
 void _update_cur_pattern       (VkvgContext ctx, VkvgPattern pat);

diff --git a/src/vkvg_device.c b/src/vkvg_device.c
index da5820dcd5f39c2f38856311a6e4c5e6730928da..64afd9cfba172a9245f3a2d8ea236c5ba98e5da6 100644 (file)
--- a/src/vkvg_device.c
+++ b/src/vkvg_device.c
@@ -328,8 +328,8 @@ void vkvg_device_get_dpy (VkvgDevice dev, int* hdpy, int* vdpy) {
        *vdpy = dev->vdpi;
 }
 void vkvg_device_set_queue_guards (VkvgDevice dev, vkvg_queue_guard before_submit, vkvg_queue_guard after_submit, void* user_data) {
-       dev->gQBeforeSubmitGuard = before_submit;
-       dev->gQAfterSubmitGuard = after_submit;
+       dev->gQLockGuard = before_submit;
+       dev->gQUnlockGuard = after_submit;
        dev->gQGuardUserData = user_data;
 }
 #if VKVG_DBG_STATS

diff --git a/src/vkvg_device_internal.c b/src/vkvg_device_internal.c
index d66df4c74bca88e231ec34418246c2d61adee041..38f6e55f83b3883f52d667814912aa7fb5cc9de5 100644 (file)
--- a/src/vkvg_device_internal.c
+++ b/src/vkvg_device_internal.c
@@ -424,15 +424,49 @@ void _wait_idle (VkvgDevice dev) {
 }
 void _wait_and_reset_device_fence (VkvgDevice dev) {
        vkWaitForFences (dev->vkDev, 1, &dev->fence, VK_TRUE, UINT64_MAX);
-       vkResetFences (dev->vkDev, 1, &dev->fence);
+       _vkvg_device_reset_fence(dev, dev->fence);
+}
+
+void _vkvg_device_destroy_fence (VkvgDevice dev, VkFence fence) {
+       if (dev->gQLockGuard)
+               dev->gQLockGuard (dev->gQGuardUserData);
+
+       if (dev->gQLastFence == fence)
+               dev->gQLastFence = VK_NULL_HANDLE;
+
+       vkDestroyFence (dev->vkDev, fence, NULL);
+
+       if (dev->gQUnlockGuard)
+               dev->gQUnlockGuard (dev->gQGuardUserData);
+}
+void _vkvg_device_reset_fence (VkvgDevice dev, VkFence fence){
+       if (dev->gQLockGuard)
+               dev->gQLockGuard (dev->gQGuardUserData);
+
+       if (dev->gQLastFence == fence)
+               dev->gQLastFence = VK_NULL_HANDLE;
+
+       ResetFences (dev->vkDev, 1, &fence);
+
+       if (dev->gQUnlockGuard)
+               dev->gQUnlockGuard (dev->gQGuardUserData);
+}
+void _vkvg_device_wait_fence                   (VkvgDevice dev, VkFence fence){
+
+}
+void _vkvg_device_wait_and_reset_fence (VkvgDevice dev, VkFence fence){
+
 }
 
 void _submit_cmd (VkvgDevice dev, VkCommandBuffer* cmd, VkFence fence) {
-       if (dev->gQBeforeSubmitGuard)
-               dev->gQBeforeSubmitGuard (dev->gQGuardUserData);
+       if (dev->gQLockGuard)
+               dev->gQLockGuard (dev->gQGuardUserData);
+       if (dev->gQLastFence != VK_NULL_HANDLE)
+               WaitForFences (dev->vkDev, 1, &dev->gQLastFence, VK_TRUE, VKVG_FENCE_TIMEOUT);
        vkh_cmd_submit (dev->gQueue, cmd, fence);
-       if (dev->gQAfterSubmitGuard)
-               dev->gQAfterSubmitGuard (dev->gQGuardUserData);
+       dev->gQLastFence = fence;
+       if (dev->gQUnlockGuard)
+               dev->gQUnlockGuard (dev->gQGuardUserData);
 }
 
 bool _init_function_pointers (VkvgDevice dev) {

diff --git a/src/vkvg_device_internal.h b/src/vkvg_device_internal.h
index 376b9c28ae125f73af71c786b8d22b94a38c34ea..02da52415c005604e3ad1b0544dc6a3155795523 100644 (file)
--- a/src/vkvg_device_internal.h
+++ b/src/vkvg_device_internal.h
@@ -63,10 +63,11 @@ typedef struct _vkvg_device_t{
        VkFormat                                pngStagFormat;                  /**< Supported vulkan image format png write staging img */
        VkImageTiling                   pngStagTiling;                  /**< tiling for the blit operation */
 
-       vkvg_queue_guard                gQBeforeSubmitGuard;
-       vkvg_queue_guard                gQAfterSubmitGuard;
+       vkvg_queue_guard                gQLockGuard;
+       vkvg_queue_guard                gQUnlockGuard;
        void*                                   gQGuardUserData;
        VkhQueue                                gQueue;                                 /**< Vulkan Queue with Graphic flag */
+       VkFence                                 gQLastFence;
 
        VkRenderPass                    renderPass;                             /**< Vulkan render pass, common for all surfaces */
        VkRenderPass                    renderPass_ClearStencil;/**< Vulkan render pass for first draw with context, stencil has to be cleared */
@@ -125,4 +126,9 @@ void _flush_all_contexes            (VkvgDevice dev);
 void _wait_idle                                        (VkvgDevice dev);
 void _wait_and_reset_device_fence (VkvgDevice dev);
 void _submit_cmd                               (VkvgDevice dev, VkCommandBuffer* cmd, VkFence fence);
+
+void _vkvg_device_destroy_fence                        (VkvgDevice dev, VkFence fence);
+void _vkvg_device_reset_fence                  (VkvgDevice dev, VkFence fence);
+void _vkvg_device_wait_fence                   (VkvgDevice dev, VkFence fence);
+void _vkvg_device_wait_and_reset_fence (VkvgDevice dev, VkFence fence);
 #endif

diff --git a/src/vkvg_fonts.c b/src/vkvg_fonts.c
index d4ed5fd5246aa107b2845a13edb5d5cd2df6ec38..88f341fcf2202a0f2483d5949e6e71edbe7d5dec 100644 (file)
--- a/src/vkvg_fonts.c
+++ b/src/vkvg_fonts.c
@@ -104,8 +104,9 @@ void _increase_font_tex_array (VkvgDevice dev){
        _font_cache_t* cache = dev->fontCache;
 
        vkWaitForFences         (dev->vkDev, 1, &cache->uploadFence, VK_TRUE, UINT64_MAX);
+       _vkvg_device_reset_fence (dev, cache->uploadFence);
+
        vkResetCommandBuffer(cache->cmd, 0);
-       vkResetFences           (dev->vkDev, 1, &cache->uploadFence);
 
        uint8_t newSize = cache->texLength + FONT_CACHE_INIT_LAYERS;
        VkhImage newImg = vkh_tex2d_array_create ((VkhDevice)dev, cache->texFormat, FONT_PAGE_SIZE, FONT_PAGE_SIZE,
@@ -241,8 +242,8 @@ void _flush_chars_to_tex (VkvgDevice dev, _vkvg_font_t* f) {
 
        LOG(VKVG_LOG_INFO, "_flush_chars_to_tex pen(%d, %d)\n",f->curLine.penX, f->curLine.penY);
        vkWaitForFences         (dev->vkDev,1,&cache->uploadFence,VK_TRUE,UINT64_MAX);
+       _vkvg_device_reset_fence (dev, cache->uploadFence);
        vkResetCommandBuffer(cache->cmd,0);
-       vkResetFences           (dev->vkDev,1,&cache->uploadFence);
 
        memcpy(cache->buff.allocInfo.pMappedData, cache->hostBuff, (uint64_t)f->curLine.height * FONT_PAGE_SIZE * cache->texPixelSize);
 

diff --git a/tests/common/test.c b/tests/common/test.c
index 6271063477896cf22311b39c54360e29d52d8f19..cc04584ed414f0e80d778c260d4f437f64a21ac1 100644 (file)
--- a/tests/common/test.c
+++ b/tests/common/test.c
@@ -647,7 +647,6 @@ void perform_test_onscreen (void(*testfunc)(void), const char *testName, int arg
 #ifdef VKVG_TEST_DIRECT_DRAW
        for (uint32_t i=0; i<r->imgCount;i++)
                vkvg_surface_destroy (surfaces[i]);
-
        free (surfaces);
 #else
        vkvg_surface_destroy    (surf);

diff --git a/tests/multithreading/multithreaded.c b/tests/multithreading/multithreaded.c
index cc4aa0a35ac33d3d4245fd8de0a2802d2ece5296..5e6620aaf9a52c0a8460d7c764dc287e0cb7c5c0 100644 (file)
--- a/tests/multithreading/multithreaded.c
+++ b/tests/multithreading/multithreaded.c
@@ -1,11 +1,11 @@
 #include "test.h"
 #include "tinycthread.h"
 
-#define THREAD_COUNT 2
+#define THREAD_COUNT 8
 
 
 static int finishedThreadCount = 0;
-static mtx_t mutex;
+static mtx_t* pmutex;
 
 void drawRandomRect (VkvgContext ctx, float s) {
        float w = (float)test_width;
@@ -25,9 +25,6 @@ void _after_submit (void* data) {
 }
 
 int drawRectsThread () {
-       mtx_t gQMutex;
-       mtx_init (&gQMutex, mtx_plain);
-       vkvg_device_set_queue_guards (device, _before_submit, _after_submit, &gQMutex);
 
        VkvgSurface s = vkvg_surface_create(device, test_width, test_height);
        VkvgContext ctx = vkvg_create(s);
@@ -37,26 +34,31 @@ int drawRectsThread () {
        }
        vkvg_destroy(ctx);
 
-       mtx_lock(&mutex);
-
-       finishedThreadCount++;
+       mtx_lock(pmutex);
 
        ctx = vkvg_create(surf);
                vkvg_set_source_surface (ctx, s, 0, 0);
                vkvg_paint(ctx);
        vkvg_destroy(ctx);
 
-       mtx_unlock(&mutex);
+       finishedThreadCount++;
+       mtx_unlock(pmutex);
 
        vkvg_surface_destroy (s);
-       vkvg_device_set_queue_guards (device, NULL, NULL, NULL);
-       mtx_destroy (&gQMutex);
        return 0;
 }
 void fixedSizeRects(){
+       mtx_t gQMutex, mutex;
+       mtx_t* pgQMutex = &gQMutex;
+       pmutex = &mutex;
+
+       mtx_init (pgQMutex, mtx_plain);
+       vkvg_device_set_queue_guards (device, _before_submit, _after_submit, pgQMutex);
+
        thrd_t threads[THREAD_COUNT];
+
        finishedThreadCount = 0;
-       mtx_init (&mutex,mtx_plain);
+       mtx_init (pmutex, mtx_plain);
        for (uint32_t i=0; i<THREAD_COUNT; i++) {
                thrd_create (&threads[i], drawRectsThread, NULL);
        }
@@ -65,7 +67,14 @@ void fixedSizeRects(){
        while (finishedThreadCount < THREAD_COUNT)
                thrd_sleep(&ts, NULL);
 
-       mtx_destroy(&mutex);
+       mtx_lock(pmutex);
+       mtx_unlock(pmutex);
+       mtx_destroy (pmutex);
+       pmutex = NULL;
+
+       vkvg_device_set_queue_guards (device, NULL, NULL, NULL);
+       mtx_destroy (pgQMutex);
+       pgQMutex = NULL;
 }
 
 int main(int argc, char *argv[]) {