forked from OSchip/llvm-project
255 lines
7.9 KiB
C
255 lines
7.9 KiB
C
/*
|
|
* kmp_stub.c -- stub versions of user-callable OpenMP RT functions.
|
|
* $Revision: 42951 $
|
|
* $Date: 2014-01-21 14:41:41 -0600 (Tue, 21 Jan 2014) $
|
|
*/
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
// Source Licenses. See LICENSE.txt for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
#include <stdlib.h>
|
|
#include <limits.h>
|
|
#include <errno.h>
|
|
|
|
#include "omp.h" // Function renamings.
|
|
#include "kmp.h" // KMP_DEFAULT_STKSIZE
|
|
#include "kmp_stub.h"
|
|
|
|
#if KMP_OS_WINDOWS
|
|
#include <windows.h>
|
|
#else
|
|
#include <sys/time.h>
|
|
#endif
|
|
|
|
// Moved from omp.h
|
|
#define omp_set_max_active_levels ompc_set_max_active_levels
|
|
#define omp_set_schedule ompc_set_schedule
|
|
#define omp_get_ancestor_thread_num ompc_get_ancestor_thread_num
|
|
#define omp_get_team_size ompc_get_team_size
|
|
|
|
#define omp_set_num_threads ompc_set_num_threads
|
|
#define omp_set_dynamic ompc_set_dynamic
|
|
#define omp_set_nested ompc_set_nested
|
|
#define kmp_set_stacksize kmpc_set_stacksize
|
|
#define kmp_set_stacksize_s kmpc_set_stacksize_s
|
|
#define kmp_set_blocktime kmpc_set_blocktime
|
|
#define kmp_set_library kmpc_set_library
|
|
#define kmp_set_defaults kmpc_set_defaults
|
|
#define kmp_malloc kmpc_malloc
|
|
#define kmp_calloc kmpc_calloc
|
|
#define kmp_realloc kmpc_realloc
|
|
#define kmp_free kmpc_free
|
|
|
|
static double frequency = 0.0;
|
|
|
|
// Helper functions.
|
|
static size_t __kmps_init() {
|
|
static int initialized = 0;
|
|
static size_t dummy = 0;
|
|
if ( ! initialized ) {
|
|
|
|
// TODO: Analyze KMP_VERSION environment variable, print __kmp_version_copyright and
|
|
// __kmp_version_build_time.
|
|
// WARNING: Do not use "fprintf( stderr, ... )" because it will cause unresolved "__iob"
|
|
// symbol (see C70080). We need to extract __kmp_printf() stuff from kmp_runtime.c and use
|
|
// it.
|
|
|
|
// Trick with dummy variable forces linker to keep __kmp_version_copyright and
|
|
// __kmp_version_build_time strings in executable file (in case of static linkage).
|
|
// When KMP_VERSION analyze is implemented, dummy variable should be deleted, function
|
|
// should return void.
|
|
dummy = __kmp_version_copyright - __kmp_version_build_time;
|
|
|
|
#if KMP_OS_WINDOWS
|
|
LARGE_INTEGER freq;
|
|
BOOL status = QueryPerformanceFrequency( & freq );
|
|
if ( status ) {
|
|
frequency = double( freq.QuadPart );
|
|
}; // if
|
|
#endif
|
|
|
|
initialized = 1;
|
|
}; // if
|
|
return dummy;
|
|
}; // __kmps_init
|
|
|
|
#define i __kmps_init();
|
|
|
|
/* set API functions */
|
|
void omp_set_num_threads( omp_int_t num_threads ) { i; }
|
|
void omp_set_dynamic( omp_int_t dynamic ) { i; __kmps_set_dynamic( dynamic ); }
|
|
void omp_set_nested( omp_int_t nested ) { i; __kmps_set_nested( nested ); }
|
|
void omp_set_max_active_levels( omp_int_t max_active_levels ) { i; }
|
|
void omp_set_schedule( omp_sched_t kind, omp_int_t modifier ) { i; __kmps_set_schedule( (kmp_sched_t)kind, modifier ); }
|
|
int omp_get_ancestor_thread_num( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 0 ); }
|
|
int omp_get_team_size( omp_int_t level ) { i; return ( level ) ? ( -1 ) : ( 1 ); }
|
|
int kmpc_set_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
|
|
int kmpc_unset_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
|
|
int kmpc_get_affinity_mask_proc( int proc, void **mask ) { i; return -1; }
|
|
|
|
/* kmp API functions */
|
|
void kmp_set_stacksize( omp_int_t arg ) { i; __kmps_set_stacksize( arg ); }
|
|
void kmp_set_stacksize_s( size_t arg ) { i; __kmps_set_stacksize( arg ); }
|
|
void kmp_set_blocktime( omp_int_t arg ) { i; __kmps_set_blocktime( arg ); }
|
|
void kmp_set_library( omp_int_t arg ) { i; __kmps_set_library( arg ); }
|
|
void kmp_set_defaults( char const * str ) { i; }
|
|
|
|
/* KMP memory management functions. */
|
|
void * kmp_malloc( size_t size ) { i; return malloc( size ); }
|
|
void * kmp_calloc( size_t nelem, size_t elsize ) { i; return calloc( nelem, elsize ); }
|
|
void * kmp_realloc( void *ptr, size_t size ) { i; return realloc( ptr, size ); }
|
|
void kmp_free( void * ptr ) { i; free( ptr ); }
|
|
|
|
static int __kmps_blocktime = INT_MAX;
|
|
|
|
void __kmps_set_blocktime( int arg ) {
|
|
i;
|
|
__kmps_blocktime = arg;
|
|
} // __kmps_set_blocktime
|
|
|
|
int __kmps_get_blocktime( void ) {
|
|
i;
|
|
return __kmps_blocktime;
|
|
} // __kmps_get_blocktime
|
|
|
|
static int __kmps_dynamic = 0;
|
|
|
|
void __kmps_set_dynamic( int arg ) {
|
|
i;
|
|
__kmps_dynamic = arg;
|
|
} // __kmps_set_dynamic
|
|
|
|
int __kmps_get_dynamic( void ) {
|
|
i;
|
|
return __kmps_dynamic;
|
|
} // __kmps_get_dynamic
|
|
|
|
static int __kmps_library = 1000;
|
|
|
|
void __kmps_set_library( int arg ) {
|
|
i;
|
|
__kmps_library = arg;
|
|
} // __kmps_set_library
|
|
|
|
int __kmps_get_library( void ) {
|
|
i;
|
|
return __kmps_library;
|
|
} // __kmps_get_library
|
|
|
|
static int __kmps_nested = 0;
|
|
|
|
void __kmps_set_nested( int arg ) {
|
|
i;
|
|
__kmps_nested = arg;
|
|
} // __kmps_set_nested
|
|
|
|
int __kmps_get_nested( void ) {
|
|
i;
|
|
return __kmps_nested;
|
|
} // __kmps_get_nested
|
|
|
|
static size_t __kmps_stacksize = KMP_DEFAULT_STKSIZE;
|
|
|
|
void __kmps_set_stacksize( int arg ) {
|
|
i;
|
|
__kmps_stacksize = arg;
|
|
} // __kmps_set_stacksize
|
|
|
|
int __kmps_get_stacksize( void ) {
|
|
i;
|
|
return __kmps_stacksize;
|
|
} // __kmps_get_stacksize
|
|
|
|
static kmp_sched_t __kmps_sched_kind = kmp_sched_default;
|
|
static int __kmps_sched_modifier = 0;
|
|
|
|
void __kmps_set_schedule( kmp_sched_t kind, int modifier ) {
|
|
i;
|
|
__kmps_sched_kind = kind;
|
|
__kmps_sched_modifier = modifier;
|
|
} // __kmps_set_schedule
|
|
|
|
void __kmps_get_schedule( kmp_sched_t *kind, int *modifier ) {
|
|
i;
|
|
*kind = __kmps_sched_kind;
|
|
*modifier = __kmps_sched_modifier;
|
|
} // __kmps_get_schedule
|
|
|
|
#if OMP_40_ENABLED
|
|
|
|
static kmp_proc_bind_t __kmps_proc_bind = proc_bind_false;
|
|
|
|
void __kmps_set_proc_bind( kmp_proc_bind_t arg ) {
|
|
i;
|
|
__kmps_proc_bind = arg;
|
|
} // __kmps_set_proc_bind
|
|
|
|
kmp_proc_bind_t __kmps_get_proc_bind( void ) {
|
|
i;
|
|
return __kmps_proc_bind;
|
|
} // __kmps_get_proc_bind
|
|
|
|
#endif /* OMP_40_ENABLED */
|
|
|
|
double __kmps_get_wtime( void ) {
|
|
// Elapsed wall clock time (in second) from "sometime in the past".
|
|
double wtime = 0.0;
|
|
i;
|
|
#if KMP_OS_WINDOWS
|
|
if ( frequency > 0.0 ) {
|
|
LARGE_INTEGER now;
|
|
BOOL status = QueryPerformanceCounter( & now );
|
|
if ( status ) {
|
|
wtime = double( now.QuadPart ) / frequency;
|
|
}; // if
|
|
}; // if
|
|
#else
|
|
// gettimeofday() returns seconds and microseconds sinse the Epoch.
|
|
struct timeval tval;
|
|
int rc;
|
|
rc = gettimeofday( & tval, NULL );
|
|
if ( rc == 0 ) {
|
|
wtime = (double)( tval.tv_sec ) + 1.0E-06 * (double)( tval.tv_usec );
|
|
} else {
|
|
// TODO: Assert or abort here.
|
|
}; // if
|
|
#endif
|
|
return wtime;
|
|
}; // __kmps_get_wtime
|
|
|
|
double __kmps_get_wtick( void ) {
|
|
// Number of seconds between successive clock ticks.
|
|
double wtick = 0.0;
|
|
i;
|
|
#if KMP_OS_WINDOWS
|
|
{
|
|
DWORD increment;
|
|
DWORD adjustment;
|
|
BOOL disabled;
|
|
BOOL rc;
|
|
rc = GetSystemTimeAdjustment( & adjustment, & increment, & disabled );
|
|
if ( rc ) {
|
|
wtick = 1.0E-07 * (double)( disabled ? increment : adjustment );
|
|
} else {
|
|
// TODO: Assert or abort here.
|
|
wtick = 1.0E-03;
|
|
}; // if
|
|
}
|
|
#else
|
|
// TODO: gettimeofday() returns in microseconds, but what the precision?
|
|
wtick = 1.0E-06;
|
|
#endif
|
|
return wtick;
|
|
}; // __kmps_get_wtick
|
|
|
|
// end of file //
|
|
|