LLVM OpenMP* Runtime Library
kmp_stub.cpp
1 /*
2  * kmp_stub.cpp -- stub versions of user-callable OpenMP RT functions.
3  */
4 
5 
6 //===----------------------------------------------------------------------===//
7 //
8 // The LLVM Compiler Infrastructure
9 //
10 // This file is dual licensed under the MIT and the University of Illinois Open
11 // Source Licenses. See LICENSE.txt for details.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 
16 #include <errno.h>
17 #include <limits.h>
18 #include <stdlib.h>
19 
20 #include "kmp.h" // KMP_DEFAULT_STKSIZE
21 #include "kmp_stub.h"
22 #include "omp.h" // Function renamings.
23 
24 #if KMP_OS_WINDOWS
25 #include <windows.h>
26 #else
27 #include <sys/time.h>
28 #endif
29 
30 // Moved from omp.h
31 #define omp_set_max_active_levels ompc_set_max_active_levels
32 #define omp_set_schedule ompc_set_schedule
33 #define omp_get_ancestor_thread_num ompc_get_ancestor_thread_num
34 #define omp_get_team_size ompc_get_team_size
35 
36 #define omp_set_num_threads ompc_set_num_threads
37 #define omp_set_dynamic ompc_set_dynamic
38 #define omp_set_nested ompc_set_nested
39 #define kmp_set_stacksize kmpc_set_stacksize
40 #define kmp_set_stacksize_s kmpc_set_stacksize_s
41 #define kmp_set_blocktime kmpc_set_blocktime
42 #define kmp_set_library kmpc_set_library
43 #define kmp_set_defaults kmpc_set_defaults
44 #define kmp_set_disp_num_buffers kmpc_set_disp_num_buffers
45 #define kmp_malloc kmpc_malloc
46 #define kmp_aligned_malloc kmpc_aligned_malloc
47 #define kmp_calloc kmpc_calloc
48 #define kmp_realloc kmpc_realloc
49 #define kmp_free kmpc_free
50 
51 static double frequency = 0.0;
52 
53 // Helper functions.
54 static size_t __kmps_init() {
55  static int initialized = 0;
56  static size_t dummy = 0;
57  if (!initialized) {
58  // TODO: Analyze KMP_VERSION environment variable, print
59  // __kmp_version_copyright and __kmp_version_build_time.
60  // WARNING: Do not use "fprintf(stderr, ...)" because it will cause
61  // unresolved "__iob" symbol (see C70080). We need to extract __kmp_printf()
62  // stuff from kmp_runtime.cpp and use it.
63 
64  // Trick with dummy variable forces linker to keep __kmp_version_copyright
65  // and __kmp_version_build_time strings in executable file (in case of
66  // static linkage). When KMP_VERSION analysis is implemented, dummy
67  // variable should be deleted, function should return void.
68  dummy = __kmp_version_copyright - __kmp_version_build_time;
69 
70 #if KMP_OS_WINDOWS
71  LARGE_INTEGER freq;
72  BOOL status = QueryPerformanceFrequency(&freq);
73  if (status) {
74  frequency = double(freq.QuadPart);
75  }; // if
76 #endif
77 
78  initialized = 1;
79  }; // if
80  return dummy;
81 }; // __kmps_init
82 
83 #define i __kmps_init();
84 
85 /* set API functions */
86 void omp_set_num_threads(omp_int_t num_threads) { i; }
87 void omp_set_dynamic(omp_int_t dynamic) {
88  i;
89  __kmps_set_dynamic(dynamic);
90 }
91 void omp_set_nested(omp_int_t nested) {
92  i;
93  __kmps_set_nested(nested);
94 }
95 void omp_set_max_active_levels(omp_int_t max_active_levels) { i; }
96 void omp_set_schedule(omp_sched_t kind, omp_int_t modifier) {
97  i;
98  __kmps_set_schedule((kmp_sched_t)kind, modifier);
99 }
100 int omp_get_ancestor_thread_num(omp_int_t level) {
101  i;
102  return (level) ? (-1) : (0);
103 }
104 int omp_get_team_size(omp_int_t level) {
105  i;
106  return (level) ? (-1) : (1);
107 }
108 int kmpc_set_affinity_mask_proc(int proc, void **mask) {
109  i;
110  return -1;
111 }
112 int kmpc_unset_affinity_mask_proc(int proc, void **mask) {
113  i;
114  return -1;
115 }
116 int kmpc_get_affinity_mask_proc(int proc, void **mask) {
117  i;
118  return -1;
119 }
120 
121 /* kmp API functions */
122 void kmp_set_stacksize(omp_int_t arg) {
123  i;
124  __kmps_set_stacksize(arg);
125 }
126 void kmp_set_stacksize_s(size_t arg) {
127  i;
128  __kmps_set_stacksize(arg);
129 }
130 void kmp_set_blocktime(omp_int_t arg) {
131  i;
132  __kmps_set_blocktime(arg);
133 }
134 void kmp_set_library(omp_int_t arg) {
135  i;
136  __kmps_set_library(arg);
137 }
138 void kmp_set_defaults(char const *str) { i; }
139 void kmp_set_disp_num_buffers(omp_int_t arg) { i; }
140 
141 /* KMP memory management functions. */
142 void *kmp_malloc(size_t size) {
143  i;
144  return malloc(size);
145 }
146 void *kmp_aligned_malloc(size_t sz, size_t a) {
147  i;
148 #if KMP_OS_WINDOWS
149  errno = ENOSYS; // not supported
150  return NULL; // no standard aligned allocator on Windows (pre - C11)
151 #else
152  void *res;
153  int err;
154  if (err = posix_memalign(&res, a, sz)) {
155  errno = err; // can be EINVAL or ENOMEM
156  return NULL;
157  }
158  return res;
159 #endif
160 }
161 void *kmp_calloc(size_t nelem, size_t elsize) {
162  i;
163  return calloc(nelem, elsize);
164 }
165 void *kmp_realloc(void *ptr, size_t size) {
166  i;
167  return realloc(ptr, size);
168 }
169 void kmp_free(void *ptr) {
170  i;
171  free(ptr);
172 }
173 
174 static int __kmps_blocktime = INT_MAX;
175 
176 void __kmps_set_blocktime(int arg) {
177  i;
178  __kmps_blocktime = arg;
179 } // __kmps_set_blocktime
180 
181 int __kmps_get_blocktime(void) {
182  i;
183  return __kmps_blocktime;
184 } // __kmps_get_blocktime
185 
186 static int __kmps_dynamic = 0;
187 
188 void __kmps_set_dynamic(int arg) {
189  i;
190  __kmps_dynamic = arg;
191 } // __kmps_set_dynamic
192 
193 int __kmps_get_dynamic(void) {
194  i;
195  return __kmps_dynamic;
196 } // __kmps_get_dynamic
197 
198 static int __kmps_library = 1000;
199 
200 void __kmps_set_library(int arg) {
201  i;
202  __kmps_library = arg;
203 } // __kmps_set_library
204 
205 int __kmps_get_library(void) {
206  i;
207  return __kmps_library;
208 } // __kmps_get_library
209 
210 static int __kmps_nested = 0;
211 
212 void __kmps_set_nested(int arg) {
213  i;
214  __kmps_nested = arg;
215 } // __kmps_set_nested
216 
217 int __kmps_get_nested(void) {
218  i;
219  return __kmps_nested;
220 } // __kmps_get_nested
221 
222 static size_t __kmps_stacksize = KMP_DEFAULT_STKSIZE;
223 
224 void __kmps_set_stacksize(int arg) {
225  i;
226  __kmps_stacksize = arg;
227 } // __kmps_set_stacksize
228 
229 int __kmps_get_stacksize(void) {
230  i;
231  return __kmps_stacksize;
232 } // __kmps_get_stacksize
233 
234 static kmp_sched_t __kmps_sched_kind = kmp_sched_default;
235 static int __kmps_sched_modifier = 0;
236 
237 void __kmps_set_schedule(kmp_sched_t kind, int modifier) {
238  i;
239  __kmps_sched_kind = kind;
240  __kmps_sched_modifier = modifier;
241 } // __kmps_set_schedule
242 
243 void __kmps_get_schedule(kmp_sched_t *kind, int *modifier) {
244  i;
245  *kind = __kmps_sched_kind;
246  *modifier = __kmps_sched_modifier;
247 } // __kmps_get_schedule
248 
249 #if OMP_40_ENABLED
250 
251 static kmp_proc_bind_t __kmps_proc_bind = proc_bind_false;
252 
253 void __kmps_set_proc_bind(kmp_proc_bind_t arg) {
254  i;
255  __kmps_proc_bind = arg;
256 } // __kmps_set_proc_bind
257 
258 kmp_proc_bind_t __kmps_get_proc_bind(void) {
259  i;
260  return __kmps_proc_bind;
261 } // __kmps_get_proc_bind
262 
263 #endif /* OMP_40_ENABLED */
264 
265 double __kmps_get_wtime(void) {
266  // Elapsed wall clock time (in second) from "sometime in the past".
267  double wtime = 0.0;
268  i;
269 #if KMP_OS_WINDOWS
270  if (frequency > 0.0) {
271  LARGE_INTEGER now;
272  BOOL status = QueryPerformanceCounter(&now);
273  if (status) {
274  wtime = double(now.QuadPart) / frequency;
275  }; // if
276  }; // if
277 #else
278  // gettimeofday() returns seconds and microseconds since the Epoch.
279  struct timeval tval;
280  int rc;
281  rc = gettimeofday(&tval, NULL);
282  if (rc == 0) {
283  wtime = (double)(tval.tv_sec) + 1.0E-06 * (double)(tval.tv_usec);
284  } else {
285  // TODO: Assert or abort here.
286  }; // if
287 #endif
288  return wtime;
289 }; // __kmps_get_wtime
290 
291 double __kmps_get_wtick(void) {
292  // Number of seconds between successive clock ticks.
293  double wtick = 0.0;
294  i;
295 #if KMP_OS_WINDOWS
296  {
297  DWORD increment;
298  DWORD adjustment;
299  BOOL disabled;
300  BOOL rc;
301  rc = GetSystemTimeAdjustment(&adjustment, &increment, &disabled);
302  if (rc) {
303  wtick = 1.0E-07 * (double)(disabled ? increment : adjustment);
304  } else {
305  // TODO: Assert or abort here.
306  wtick = 1.0E-03;
307  }; // if
308  }
309 #else
310  // TODO: gettimeofday() returns in microseconds, but what the precision?
311  wtick = 1.0E-06;
312 #endif
313  return wtick;
314 }; // __kmps_get_wtick
315 
316 // end of file //