deps/libchdr/deps/zstd-1.5.5/lib/common/threading.c

   1 /**
   2  * Copyright (c) 2016 Tino Reichardt
   3  * All rights reserved.
   4  *
   5  * You can contact the author at:
   6  * - zstdmt source repository: https://github.com/mcmilk/zstdmt
   7  *
   8  * This source code is licensed under both the BSD-style license (found in the
   9  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  10  * in the COPYING file in the root directory of this source tree).
  11  * You may select, at your option, one of the above-listed licenses.
  12  */
  13
  14 /**
  15  * This file will hold wrapper for systems, which do not support pthreads
  16  */
  17
  18 #include "threading.h"
  19
  20 /* create fake symbol to avoid empty translation unit warning */
  21 int g_ZSTD_threading_useless_symbol;
  22
  23 #if defined(ZSTD_MULTITHREAD) && defined(_WIN32)
  24
  25 /**
  26  * Windows minimalist Pthread Wrapper
  27  */
  28
  29
  30 /* ===  Dependencies  === */
  31 #include <process.h>
  32 #include <errno.h>
  33
  34
  35 /* ===  Implementation  === */
  36
  37 typedef struct {
  38     void* (*start_routine)(void*);
  39     void* arg;
  40     int initialized;
  41     ZSTD_pthread_cond_t initialized_cond;
  42     ZSTD_pthread_mutex_t initialized_mutex;
  43 } ZSTD_thread_params_t;
  44
  45 static unsigned __stdcall worker(void *arg)
  46 {
  47     void* (*start_routine)(void*);
  48     void* thread_arg;
  49
  50     /* Initialized thread_arg and start_routine and signal main thread that we don't need it
  51      * to wait any longer.
  52      */
  53     {
  54         ZSTD_thread_params_t*  thread_param = (ZSTD_thread_params_t*)arg;
  55         thread_arg = thread_param->arg;
  56         start_routine = thread_param->start_routine;
  57
  58         /* Signal main thread that we are running and do not depend on its memory anymore */
  59         ZSTD_pthread_mutex_lock(&thread_param->initialized_mutex);
  60         thread_param->initialized = 1;
  61         ZSTD_pthread_cond_signal(&thread_param->initialized_cond);
  62         ZSTD_pthread_mutex_unlock(&thread_param->initialized_mutex);
  63     }
  64
  65     start_routine(thread_arg);
  66
  67     return 0;
  68 }
  69
  70 int ZSTD_pthread_create(ZSTD_pthread_t* thread, const void* unused,
  71             void* (*start_routine) (void*), void* arg)
  72 {
  73     ZSTD_thread_params_t thread_param;
  74     (void)unused;
  75
  76     thread_param.start_routine = start_routine;
  77     thread_param.arg = arg;
  78     thread_param.initialized = 0;
  79     *thread = NULL;
  80
  81     /* Setup thread initialization synchronization */
  82     if(ZSTD_pthread_cond_init(&thread_param.initialized_cond, NULL)) {
  83         /* Should never happen on Windows */
  84         return -1;
  85     }
  86     if(ZSTD_pthread_mutex_init(&thread_param.initialized_mutex, NULL)) {
  87         /* Should never happen on Windows */
  88         ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
  89         return -1;
  90     }
  91
  92     /* Spawn thread */
  93     *thread = (HANDLE)_beginthreadex(NULL, 0, worker, &thread_param, 0, NULL);
  94     if (!thread) {
  95         ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
  96         ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
  97         return errno;
  98     }
  99
 100     /* Wait for thread to be initialized */
 101     ZSTD_pthread_mutex_lock(&thread_param.initialized_mutex);
 102     while(!thread_param.initialized) {
 103         ZSTD_pthread_cond_wait(&thread_param.initialized_cond, &thread_param.initialized_mutex);
 104     }
 105     ZSTD_pthread_mutex_unlock(&thread_param.initialized_mutex);
 106     ZSTD_pthread_mutex_destroy(&thread_param.initialized_mutex);
 107     ZSTD_pthread_cond_destroy(&thread_param.initialized_cond);
 108
 109     return 0;
 110 }
 111
 112 int ZSTD_pthread_join(ZSTD_pthread_t thread)
 113 {
 114     DWORD result;
 115
 116     if (!thread) return 0;
 117
 118     result = WaitForSingleObject(thread, INFINITE);
 119     CloseHandle(thread);
 120
 121     switch (result) {
 122     case WAIT_OBJECT_0:
 123         return 0;
 124     case WAIT_ABANDONED:
 125         return EINVAL;
 126     default:
 127         return GetLastError();
 128     }
 129 }
 130
 131 #endif   /* ZSTD_MULTITHREAD */
 132
 133 #if defined(ZSTD_MULTITHREAD) && DEBUGLEVEL >= 1 && !defined(_WIN32)
 134
 135 #define ZSTD_DEPS_NEED_MALLOC
 136 #include "zstd_deps.h"
 137
 138 int ZSTD_pthread_mutex_init(ZSTD_pthread_mutex_t* mutex, pthread_mutexattr_t const* attr)
 139 {
 140     *mutex = (pthread_mutex_t*)ZSTD_malloc(sizeof(pthread_mutex_t));
 141     if (!*mutex)
 142         return 1;
 143     return pthread_mutex_init(*mutex, attr);
 144 }
 145
 146 int ZSTD_pthread_mutex_destroy(ZSTD_pthread_mutex_t* mutex)
 147 {
 148     if (!*mutex)
 149         return 0;
 150     {
 151         int const ret = pthread_mutex_destroy(*mutex);
 152         ZSTD_free(*mutex);
 153         return ret;
 154     }
 155 }
 156
 157 int ZSTD_pthread_cond_init(ZSTD_pthread_cond_t* cond, pthread_condattr_t const* attr)
 158 {
 159     *cond = (pthread_cond_t*)ZSTD_malloc(sizeof(pthread_cond_t));
 160     if (!*cond)
 161         return 1;
 162     return pthread_cond_init(*cond, attr);
 163 }
 164
 165 int ZSTD_pthread_cond_destroy(ZSTD_pthread_cond_t* cond)
 166 {
 167     if (!*cond)
 168         return 0;
 169     {
 170         int const ret = pthread_cond_destroy(*cond);
 171         ZSTD_free(*cond);
 172         return ret;
 173     }
 174 }
 175
 176 #endif