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 */
21int 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
37typedef 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
45static 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
70int 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
112int 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
138int 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
146int 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
157int 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
165int 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
177