LXR linux/tools/testing/selftests/sync/sync

   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
  32int 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
  76int 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}
 133