contrib/processor-trace/include/windows/threads.h

   1 /*
   2  * Copyright (c) 2014-2018, Intel Corporation
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  *  * Redistributions of source code must retain the above copyright notice,
   8  *    this list of conditions and the following disclaimer.
   9  *  * Redistributions in binary form must reproduce the above copyright notice,
  10  *    this list of conditions and the following disclaimer in the documentation
  11  *    and/or other materials provided with the distribution.
  12  *  * Neither the name of Intel Corporation nor the names of its contributors
  13  *    may be used to endorse or promote products derived from this software
  14  *    without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  20  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  21  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  22  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  23  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  24  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  25  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  26  * POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  *
  29  * It looks like there is still no support for C11's threads.h.
  30  *
  31  * We implement the few features we actually need hoping that this file will
  32  * soon go away.
  33  */
  34
  35 #ifndef THREADS_H
  36 #define THREADS_H
  37
  38 #include "windows.h"
  39
  40
  41 enum {
  42         thrd_success    = 1,
  43         thrd_error
  44 };
  45
  46
  47 struct pt_thread {
  48         HANDLE handle;
  49 };
  50 typedef struct pt_thread thrd_t;
  51
  52 typedef int (*thrd_start_t)(void *);
  53
  54
  55 struct thrd_args {
  56         thrd_start_t fun;
  57         void *arg;
  58 };
  59
  60 static DWORD WINAPI thrd_routine(void *arg)
  61 {
  62         struct thrd_args *args;
  63         int result;
  64
  65         args = (struct thrd_args *) arg;
  66         if (!args)
  67                 return (DWORD) -1;
  68
  69         result = -1;
  70         if (args->fun)
  71                 result = args->fun(args->arg);
  72
  73         free(args);
  74
  75         return (DWORD) result;
  76 }
  77
  78 static inline int thrd_create(thrd_t *thrd, thrd_start_t fun, void *arg)
  79 {
  80         struct thrd_args *args;
  81         HANDLE handle;
  82
  83         if (!thrd || !fun)
  84                 return thrd_error;
  85
  86         args = malloc(sizeof(*args));
  87         if (!args)
  88                 return thrd_error;
  89
  90         args->fun = fun;
  91         args->arg = arg;
  92
  93         handle = CreateThread(NULL, 0, thrd_routine, args, 0, NULL);
  94         if (!handle) {
  95                 free(args);
  96                 return thrd_error;
  97         }
  98
  99         thrd->handle = handle;
 100         return thrd_success;
 101 }
 102
 103 static inline int thrd_join(thrd_t *thrd, int *res)
 104 {
 105         DWORD status;
 106         BOOL success;
 107
 108         if (!thrd)
 109                 return thrd_error;
 110
 111         status = WaitForSingleObject(thrd->handle, INFINITE);
 112         if (status)
 113                 return thrd_error;
 114
 115         if (res) {
 116                 DWORD result;
 117
 118                 success = GetExitCodeThread(thrd->handle, &result);
 119                 if (!success) {
 120                         (void) CloseHandle(thrd->handle);
 121                         return thrd_error;
 122                 }
 123
 124                 *res = (int) result;
 125         }
 126
 127         success = CloseHandle(thrd->handle);
 128         if (!success)
 129                 return thrd_error;
 130
 131         return thrd_success;
 132 }
 133
 134 struct pt_mutex {
 135         CRITICAL_SECTION cs;
 136 };
 137 typedef struct pt_mutex mtx_t;
 138
 139 enum {
 140         mtx_plain
 141 };
 142
 143 static inline int mtx_init(mtx_t *mtx, int type)
 144 {
 145         if (!mtx || type != mtx_plain)
 146                 return thrd_error;
 147
 148         InitializeCriticalSection(&mtx->cs);
 149
 150         return thrd_success;
 151 }
 152
 153 static inline void mtx_destroy(mtx_t *mtx)
 154 {
 155         if (mtx)
 156                 DeleteCriticalSection(&mtx->cs);
 157 }
 158
 159 static inline int mtx_lock(mtx_t *mtx)
 160 {
 161         if (!mtx)
 162                 return thrd_error;
 163
 164         EnterCriticalSection(&mtx->cs);
 165
 166         return thrd_success;
 167 }
 168
 169 static inline int mtx_unlock(mtx_t *mtx)
 170 {
 171         if (!mtx)
 172                 return thrd_error;
 173
 174         LeaveCriticalSection(&mtx->cs);
 175
 176         return thrd_success;
 177 }
 178
 179
 180 struct pt_cond {
 181         CONDITION_VARIABLE cond;
 182 };
 183 typedef struct pt_cond cnd_t;
 184
 185 static inline int cnd_init(cnd_t *cnd)
 186 {
 187         if (!cnd)
 188                 return thrd_error;
 189
 190         InitializeConditionVariable(&cnd->cond);
 191
 192         return thrd_success;
 193 }
 194
 195 static inline int cnd_destroy(cnd_t *cnd)
 196 {
 197         if (!cnd)
 198                 return thrd_error;
 199
 200         /* Nothing to do. */
 201
 202         return thrd_success;
 203 }
 204
 205 static inline int cnd_signal(cnd_t *cnd)
 206 {
 207         if (!cnd)
 208                 return thrd_error;
 209
 210         WakeConditionVariable(&cnd->cond);
 211
 212         return thrd_success;
 213 }
 214
 215 static inline int cnd_broadcast(cnd_t *cnd)
 216 {
 217         if (!cnd)
 218                 return thrd_error;
 219
 220         WakeAllConditionVariable(&cnd->cond);
 221
 222         return thrd_success;
 223 }
 224
 225 static inline int cnd_wait(cnd_t *cnd, mtx_t *mtx)
 226 {
 227         BOOL success;
 228
 229         if (!cnd || !mtx)
 230                 return thrd_error;
 231
 232         success = SleepConditionVariableCS(&cnd->cond, &mtx->cs, INFINITE);
 233         if (!success)
 234                 return thrd_error;
 235
 236         return thrd_success;
 237 }
 238
 239 #endif /* THREADS_H */