tests/viratomictest.c

   1 /*
   2  * Copyright (C) 2011-2013 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library.  If not, see
  16  * <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #include <config.h>
  21
  22 #include <time.h>
  23 #include <sched.h>
  24
  25 #include "testutils.h"
  26
  27 #include "viratomic.h"
  28 #include "virrandom.h"
  29 #include "virthread.h"
  30
  31 static int
  32 testTypes(const void *data ATTRIBUTE_UNUSED)
  33 {
  34     unsigned int u, u2;
  35     int s, s2;
  36     bool res;
  37
  38 #define virAssertCmpInt(a, op, b) \
  39     if (!(a op b)) \
  40         return -1;
  41     virAtomicIntSet(&u, 5);
  42     u2 = virAtomicIntGet(&u);
  43     virAssertCmpInt(u2, ==, 5);
  44
  45     res = virAtomicIntCompareExchange(&u, 6, 7);
  46     if (res)
  47         return -1;
  48     virAssertCmpInt(u, ==, 5);
  49
  50     virAssertCmpInt(virAtomicIntAdd(&u, 1), ==, 5);
  51     virAssertCmpInt(u, ==, 6);
  52
  53     virAssertCmpInt(virAtomicIntInc(&u), ==, 7);
  54     virAssertCmpInt(u, ==, 7);
  55
  56     res = virAtomicIntDecAndTest(&u);
  57     if (res)
  58         return -1;
  59     virAssertCmpInt(u, ==, 6);
  60
  61     u2 = virAtomicIntAnd(&u, 5);
  62     virAssertCmpInt(u2, ==, 6);
  63     virAssertCmpInt(u, ==, 4);
  64
  65     u2 = virAtomicIntOr(&u, 8);
  66     virAssertCmpInt(u2, ==, 4);
  67     virAssertCmpInt(u, ==, 12);
  68
  69     u2 = virAtomicIntXor(&u, 4);
  70     virAssertCmpInt(u2, ==, 12);
  71     virAssertCmpInt(u, ==, 8);
  72
  73     virAtomicIntSet(&s, 5);
  74     s2 = virAtomicIntGet(&s);
  75     virAssertCmpInt(s2, ==, 5);
  76
  77     res = virAtomicIntCompareExchange(&s, 6, 7);
  78     if (res)
  79         return -1;
  80     virAssertCmpInt(s, ==, 5);
  81
  82     virAtomicIntAdd(&s, 1);
  83     virAssertCmpInt(s, ==, 6);
  84
  85     virAtomicIntInc(&s);
  86     virAssertCmpInt(s, ==, 7);
  87
  88     res = virAtomicIntDecAndTest(&s);
  89     if (res)
  90         return -1;
  91     virAssertCmpInt(s, ==, 6);
  92
  93     s2 = virAtomicIntAnd(&s, 5);
  94     virAssertCmpInt(s2, ==, 6);
  95     virAssertCmpInt(s, ==, 4);
  96
  97     s2 = virAtomicIntOr(&s, 8);
  98     virAssertCmpInt(s2, ==, 4);
  99     virAssertCmpInt(s, ==, 12);
 100
 101     s2 = virAtomicIntXor(&s, 4);
 102     virAssertCmpInt(s2, ==, 12);
 103     virAssertCmpInt(s, ==, 8);
 104
 105     return 0;
 106 }
 107
 108 #define THREADS 10
 109 #define ROUNDS 10000
 110
 111 volatile int bucket[THREADS];
 112 volatile int atomic;
 113
 114 static void
 115 thread_func(void *data)
 116 {
 117     int idx = (intptr_t)data;
 118     size_t i;
 119     int d;
 120
 121     for (i = 0; i < ROUNDS; i++) {
 122         d = virRandomBits(7);
 123         bucket[idx] += d;
 124         virAtomicIntAdd(&atomic, d);
 125 #ifdef WIN32
 126         SleepEx(0, 0);
 127 #else
 128         sched_yield();
 129 #endif
 130     }
 131 }
 132
 133 static int
 134 testThreads(const void *data ATTRIBUTE_UNUSED)
 135 {
 136     int sum;
 137     size_t i;
 138     virThread threads[THREADS];
 139
 140     atomic = 0;
 141     for (i = 0; i < THREADS; i++)
 142         bucket[i] = 0;
 143
 144     for (i = 0; i < THREADS; i++) {
 145         if (virThreadCreate(&(threads[i]), true, thread_func, (void*)(intptr_t)i) < 0)
 146             return -1;
 147     }
 148
 149     for (i = 0; i < THREADS; i++)
 150         virThreadJoin(&threads[i]);
 151
 152     sum = 0;
 153     for (i = 0; i < THREADS; i++)
 154         sum += bucket[i];
 155
 156     if (sum != atomic)
 157         return -1;
 158
 159     return 0;
 160 }
 161
 162 static int
 163 mymain(void)
 164 {
 165     int ret = 0;
 166
 167     if (virThreadInitialize() < 0)
 168         return -1;
 169
 170     if (virtTestRun("types", testTypes, NULL) < 0)
 171         ret = -1;
 172     if (virtTestRun("threads", testThreads, NULL) < 0)
 173         ret = -1;
 174
 175     return ret;
 176 }
 177
 178 VIRT_TEST_MAIN(mymain)