LLVM OpenMP* Runtime Library
kmp_stub.c
1 /*
2  * kmp_stub.c -- 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 <stdlib.h>
17 #include <limits.h>
18 #include <errno.h>
19 
20 #include "omp.h" // Function renamings.
21 #include "kmp.h" // KMP_DEFAULT_STKSIZE
22 #include "kmp_stub.h"
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_malloc kmpc_malloc
45 #define kmp_calloc kmpc_calloc
46 #define kmp_realloc kmpc_realloc
47 #define kmp_free kmpc_free
48 
49 static double frequency = 0.0;
50 
51 // Helper functions.
52 static size_t __kmps_init() {
53  static int initialized = 0;
54  static size_t dummy = 0;
55  if ( ! initialized ) {
56 
57  // TODO: Analyze KMP_VERSION environment variable, print __kmp_version_copyright and
58  // __kmp_version_build_time.
59  // WARNING: Do not use "fprintf( stderr, ... )" because it will cause unresolved "__iob"
60  // symbol (see C70080). We need to extract __kmp_printf() stuff from kmp_runtime.c and use
61  // it.
62 
63  // Trick with dummy variable forces linker to keep __kmp_version_copyright and
64  // __kmp_version_build_time strings in executable file (in case of static linkage).
65  // When KMP_VERSION analyze is implemented, dummy variable should be deleted, function
66  // should return void.
67  dummy = __kmp_version_copyright - __kmp_version_build_time;
68 
69  #if KMP_OS_WINDOWS
70  LARGE_INTEGER freq;
71  BOOL status = QueryPerformanceFrequency( & freq );
72  if ( status ) {
73  frequency = double( freq.QuadPart );
74  }; // if
75  #endif
76 
77  initialized = 1;
78  }; // if
79  return dummy;
80 }; // __kmps_init
81 
82 #define i __kmps_init();
83 
84 /* set API functions */
85 void omp_set_num_threads( omp_int_t num_threads ) { i; }
86 void omp_set_dynamic( omp_int_t dynamic ) { i; __kmps_set_dynamic( dynamic ); }
87 void omp_set_nested( omp_int_t nested ) { i; __kmps_set_nested( nested ); }
88 void omp_set_max_active_levels( omp_int_t max_active_levels ) { i; }
89 void omp_set_schedule( omp_sched_t kind, omp_int_t modifier ) { i; __kmps_set_schedule( (kmp_sched_t)kind, modifier ); }
90 int omp_get_ancestor_thread_num( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 0 ); }
91 int omp_get_team_size( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 1 ); }
92 int kmpc_set_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
93 int kmpc_unset_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
94 int kmpc_get_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
95 
96 /* kmp API functions */
97 void kmp_set_stacksize( omp_int_t arg ) { i; __kmps_set_stacksize( arg ); }
98 void kmp_set_stacksize_s( size_t arg ) { i; __kmps_set_stacksize( arg ); }
99 void kmp_set_blocktime( omp_int_t arg ) { i; __kmps_set_blocktime( arg ); }
100 void kmp_set_library( omp_int_t arg ) { i; __kmps_set_library( arg ); }
101 void kmp_set_defaults( char const * str ) { i; }
102 
103 /* KMP memory management functions. */
104 void * kmp_malloc( size_t size ) { i; return malloc( size ); }
105 void * kmp_calloc( size_t nelem, size_t elsize ) { i; return calloc( nelem, elsize ); }
106 void * kmp_realloc( void *ptr, size_t size ) { i; return realloc( ptr, size ); }
107 void kmp_free( void * ptr ) { i; free( ptr ); }
108 
109 static int __kmps_blocktime = INT_MAX;
110 
111 void __kmps_set_blocktime( int arg ) {
112  i;
113  __kmps_blocktime = arg;
114 } // __kmps_set_blocktime
115 
116 int __kmps_get_blocktime( void ) {
117  i;
118  return __kmps_blocktime;
119 } // __kmps_get_blocktime
120 
121 static int __kmps_dynamic = 0;
122 
123 void __kmps_set_dynamic( int arg ) {
124  i;
125  __kmps_dynamic = arg;
126 } // __kmps_set_dynamic
127 
128 int __kmps_get_dynamic( void ) {
129  i;
130  return __kmps_dynamic;
131 } // __kmps_get_dynamic
132 
133 static int __kmps_library = 1000;
134 
135 void __kmps_set_library( int arg ) {
136  i;
137  __kmps_library = arg;
138 } // __kmps_set_library
139 
140 int __kmps_get_library( void ) {
141  i;
142  return __kmps_library;
143 } // __kmps_get_library
144 
145 static int __kmps_nested = 0;
146 
147 void __kmps_set_nested( int arg ) {
148  i;
149  __kmps_nested = arg;
150 } // __kmps_set_nested
151 
152 int __kmps_get_nested( void ) {
153  i;
154  return __kmps_nested;
155 } // __kmps_get_nested
156 
157 static size_t __kmps_stacksize = KMP_DEFAULT_STKSIZE;
158 
159 void __kmps_set_stacksize( int arg ) {
160  i;
161  __kmps_stacksize = arg;
162 } // __kmps_set_stacksize
163 
164 int __kmps_get_stacksize( void ) {
165  i;
166  return __kmps_stacksize;
167 } // __kmps_get_stacksize
168 
169 static kmp_sched_t __kmps_sched_kind = kmp_sched_default;
170 static int __kmps_sched_modifier = 0;
171 
172  void __kmps_set_schedule( kmp_sched_t kind, int modifier ) {
173  i;
174  __kmps_sched_kind = kind;
175  __kmps_sched_modifier = modifier;
176  } // __kmps_set_schedule
177 
178  void __kmps_get_schedule( kmp_sched_t *kind, int *modifier ) {
179  i;
180  *kind = __kmps_sched_kind;
181  *modifier = __kmps_sched_modifier;
182  } // __kmps_get_schedule
183 
184 #if OMP_40_ENABLED
185 
186 static kmp_proc_bind_t __kmps_proc_bind = proc_bind_false;
187 
188 void __kmps_set_proc_bind( kmp_proc_bind_t arg ) {
189  i;
190  __kmps_proc_bind = arg;
191 } // __kmps_set_proc_bind
192 
193 kmp_proc_bind_t __kmps_get_proc_bind( void ) {
194  i;
195  return __kmps_proc_bind;
196 } // __kmps_get_proc_bind
197 
198 #endif /* OMP_40_ENABLED */
199 
200 double __kmps_get_wtime( void ) {
201  // Elapsed wall clock time (in second) from "sometime in the past".
202  double wtime = 0.0;
203  i;
204  #if KMP_OS_WINDOWS
205  if ( frequency > 0.0 ) {
206  LARGE_INTEGER now;
207  BOOL status = QueryPerformanceCounter( & now );
208  if ( status ) {
209  wtime = double( now.QuadPart ) / frequency;
210  }; // if
211  }; // if
212  #else
213  // gettimeofday() returns seconds and microseconds since the Epoch.
214  struct timeval tval;
215  int rc;
216  rc = gettimeofday( & tval, NULL );
217  if ( rc == 0 ) {
218  wtime = (double)( tval.tv_sec ) + 1.0E-06 * (double)( tval.tv_usec );
219  } else {
220  // TODO: Assert or abort here.
221  }; // if
222  #endif
223  return wtime;
224 }; // __kmps_get_wtime
225 
226 double __kmps_get_wtick( void ) {
227  // Number of seconds between successive clock ticks.
228  double wtick = 0.0;
229  i;
230  #if KMP_OS_WINDOWS
231  {
232  DWORD increment;
233  DWORD adjustment;
234  BOOL disabled;
235  BOOL rc;
236  rc = GetSystemTimeAdjustment( & adjustment, & increment, & disabled );
237  if ( rc ) {
238  wtick = 1.0E-07 * (double)( disabled ? increment : adjustment );
239  } else {
240  // TODO: Assert or abort here.
241  wtick = 1.0E-03;
242  }; // if
243  }
244  #else
245  // TODO: gettimeofday() returns in microseconds, but what the precision?
246  wtick = 1.0E-06;
247  #endif
248  return wtick;
249 }; // __kmps_get_wtick
250 
251 // end of file //
252