1 

     2 /**

     3  * Copyright (c) 2016 Tino Reichardt

     4  * All rights reserved.

     5  *

     6  * This source code is licensed under the BSD-style license found in the

     7  * LICENSE file in the root directory of this source tree. An additional grant

     8  * of patent rights can be found in the PATENTS file in the same directory.

     9  *

    10  * You can contact the author at:

    11  * - zstdmt source repository: https://github.com/mcmilk/zstdmt

    12  */

    13 

    14 /**

    15  * This file will hold wrapper for systems, which do not support pthreads

    16  */

    17 

    18 /* ======   Compiler specifics   ====== */

    19 #if defined(_MSC_VER)

    20 #  pragma warning(disable : 4206)        /* disable: C4206: translation unit is empty (when ZSTD_MULTITHREAD is not defined) */

    21 #endif

    22 

    23 

    24 #if defined(ZSTD_MULTITHREAD) && defined(_WIN32)

    25 

    26 /**

    27  * Windows minimalist Pthread Wrapper, based on :

    28  * http://www.cse.wustl.edu/~schmidt/win32-cv-1.html

    29  */

    30 

    31 

    32 /* ===  Dependencies  === */

    33 #include <process.h>

    34 #include <errno.h>

    35 #include "threading.h"

    36 

    37 

    38 /* ===  Implementation  === */

    39 

    40 static unsigned __stdcall worker(void *arg)

    41 {

    42     pthread_t* const thread = (pthread_t*) arg;

    43     thread->arg = thread->start_routine(thread->arg);

    44     return 0;

    45 }

    46 

    47 int pthread_create(pthread_t* thread, const void* unused,

    48             void* (*start_routine) (void*), void* arg)

    49 {

    50     (void)unused;

    51     thread->arg = arg;

    52     thread->start_routine = start_routine;

    53     thread->handle = (HANDLE) _beginthreadex(NULL, 0, worker, thread, 0, NULL);

    54 

    55     if (!thread->handle)

    56         return errno;

    57     else

    58         return 0;

    59 }

    60 

    61 int _pthread_join(pthread_t * thread, void **value_ptr)

    62 {

    63     DWORD result;

    64 

    65     if (!thread->handle) return 0;

    66 

    67     result = WaitForSingleObject(thread->handle, INFINITE);

    68     switch (result) {

    69     case WAIT_OBJECT_0:

    70         if (value_ptr) *value_ptr = thread->arg;

    71         return 0;

    72     case WAIT_ABANDONED:

    73         return EINVAL;

    74     default:

    75         return GetLastError();

    76     }

    77 }

    78 

    79 #endif   /* ZSTD_MULTITHREAD */