root/tools/testing/selftests/sync/sync_fence.c

DEFINITIONS

1. test_fence_one_timeline_wait
2. test_fence_one_timeline_merge

   1 /*
   2  *  sync fence tests with one timeline
   3  *  Copyright 2015-2016 Collabora Ltd.
   4  *
   5  *  Based on the implementation from the Android Open Source Project,
   6  *
   7  *  Copyright 2012 Google, Inc
   8  *
   9  *  Permission is hereby granted, free of charge, to any person obtaining a
  10  *  copy of this software and associated documentation files (the "Software"),
  11  *  to deal in the Software without restriction, including without limitation
  12  *  the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  *  and/or sell copies of the Software, and to permit persons to whom the
  14  *  Software is furnished to do so, subject to the following conditions:
  15  *
  16  *  The above copyright notice and this permission notice shall be included in
  17  *  all copies or substantial portions of the Software.
  18  *
  19  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  *  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  *  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  22  *  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  23  *  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  24  *  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  25  *  OTHER DEALINGS IN THE SOFTWARE.
  26  */
  27 
  28 #include "sync.h"
  29 #include "sw_sync.h"
  30 #include "synctest.h"
  31 
  32 int test_fence_one_timeline_wait(void)
  33 {
  34         int fence, valid, ret;
  35         int timeline = sw_sync_timeline_create();
  36 
  37         valid = sw_sync_timeline_is_valid(timeline);
  38         ASSERT(valid, "Failure allocating timeline\n");
  39 
  40         fence = sw_sync_fence_create(timeline, "allocFence", 5);
  41         valid = sw_sync_fence_is_valid(fence);
  42         ASSERT(valid, "Failure allocating fence\n");
  43 
  44         /* Wait on fence until timeout */
  45         ret = sync_wait(fence, 0);
  46         ASSERT(ret == 0, "Failure waiting on fence until timeout\n");
  47 
  48         /* Advance timeline from 0 -> 1 */
  49         ret = sw_sync_timeline_inc(timeline, 1);
  50         ASSERT(ret == 0, "Failure advancing timeline\n");
  51 
  52         /* Wait on fence until timeout */
  53         ret = sync_wait(fence, 0);
  54         ASSERT(ret == 0, "Failure waiting on fence until timeout\n");
  55 
  56         /* Signal the fence */
  57         ret = sw_sync_timeline_inc(timeline, 4);
  58         ASSERT(ret == 0, "Failure signaling the fence\n");
  59 
  60         /* Wait successfully */
  61         ret = sync_wait(fence, 0);
  62         ASSERT(ret > 0, "Failure waiting on fence\n");
  63 
  64         /* Go even further, and confirm wait still succeeds */
  65         ret = sw_sync_timeline_inc(timeline, 10);
  66         ASSERT(ret == 0, "Failure going further\n");
  67         ret = sync_wait(fence, 0);
  68         ASSERT(ret > 0, "Failure waiting ahead\n");
  69 
  70         sw_sync_fence_destroy(fence);
  71         sw_sync_timeline_destroy(timeline);
  72 
  73         return 0;
  74 }
  75 
  76 int test_fence_one_timeline_merge(void)
  77 {
  78         int a, b, c, d, valid;
  79         int timeline = sw_sync_timeline_create();
  80 
  81         /* create fence a,b,c and then merge them all into fence d */
  82         a = sw_sync_fence_create(timeline, "allocFence", 1);
  83         b = sw_sync_fence_create(timeline, "allocFence", 2);
  84         c = sw_sync_fence_create(timeline, "allocFence", 3);
  85 
  86         valid = sw_sync_fence_is_valid(a) &&
  87                 sw_sync_fence_is_valid(b) &&
  88                 sw_sync_fence_is_valid(c);
  89         ASSERT(valid, "Failure allocating fences\n");
  90 
  91         d = sync_merge("mergeFence", b, a);
  92         d = sync_merge("mergeFence", c, d);
  93         valid = sw_sync_fence_is_valid(d);
  94         ASSERT(valid, "Failure merging fences\n");
  95 
  96         /* confirm all fences have one active point (even d) */
  97         ASSERT(sync_fence_count_with_status(a, FENCE_STATUS_ACTIVE) == 1,
  98                "a has too many active fences!\n");
  99         ASSERT(sync_fence_count_with_status(a, FENCE_STATUS_ACTIVE) == 1,
 100                "b has too many active fences!\n");
 101         ASSERT(sync_fence_count_with_status(a, FENCE_STATUS_ACTIVE) == 1,
 102                "c has too many active fences!\n");
 103         ASSERT(sync_fence_count_with_status(a, FENCE_STATUS_ACTIVE) == 1,
 104                "d has too many active fences!\n");
 105 
 106         /* confirm that d is not signaled until the max of a,b,c */
 107         sw_sync_timeline_inc(timeline, 1);
 108         ASSERT(sync_fence_count_with_status(a, FENCE_STATUS_SIGNALED) == 1,
 109                "a did not signal!\n");
 110         ASSERT(sync_fence_count_with_status(d, FENCE_STATUS_ACTIVE) == 1,
 111                "d signaled too early!\n");
 112 
 113         sw_sync_timeline_inc(timeline, 1);
 114         ASSERT(sync_fence_count_with_status(b, FENCE_STATUS_SIGNALED) == 1,
 115                "b did not signal!\n");
 116         ASSERT(sync_fence_count_with_status(d, FENCE_STATUS_ACTIVE) == 1,
 117                "d signaled too early!\n");
 118 
 119         sw_sync_timeline_inc(timeline, 1);
 120         ASSERT(sync_fence_count_with_status(c, FENCE_STATUS_SIGNALED) == 1,
 121                "c did not signal!\n");
 122         ASSERT(sync_fence_count_with_status(d, FENCE_STATUS_ACTIVE) == 0 &&
 123                sync_fence_count_with_status(d, FENCE_STATUS_SIGNALED) == 1,
 124                "d did not signal!\n");
 125 
 126         sw_sync_fence_destroy(d);
 127         sw_sync_fence_destroy(c);
 128         sw_sync_fence_destroy(b);
 129         sw_sync_fence_destroy(a);
 130         sw_sync_timeline_destroy(timeline);
 131         return 0;
 132 }