BasedOnStyle: LLVM
AlignTrailingComments: false
SortIncludes: false
----
-# Language: Cpp
-# AccessModifierOffset: -2
-# AlignAfterOpenBracket: Align
-# AlignConsecutiveAssignments: false
-# AlignConsecutiveDeclarations: false
-# AlignEscapedNewlinesLeft: false
-# AlignOperands: false
-# AlignTrailingComments: false
-# AllowAllParametersOfDeclarationOnNextLine: true
-# AllowShortBlocksOnASingleLine: false
-# AllowShortCaseLabelsOnASingleLine: false
-# AllowShortFunctionsOnASingleLine: All
-# AllowShortIfStatementsOnASingleLine: false
-# AllowShortLoopsOnASingleLine: false
-# AlwaysBreakAfterDefinitionReturnType: None
-# AlwaysBreakAfterReturnType: None
-# AlwaysBreakBeforeMultilineStrings: false
-# AlwaysBreakTemplateDeclarations: false
-# BinPackArguments: true
-# BinPackParameters: true
-# BraceWrapping:
-# AfterClass: false
-# AfterControlStatement: false
-# AfterEnum: false
-# AfterFunction: false
-# AfterNamespace: false
-# AfterObjCDeclaration: false
-# AfterStruct: false
-# AfterUnion: false
-# BeforeCatch: false
-# BeforeElse: false
-# IndentBraces: false
-# # BreakBeforeBinaryOperators: None
-# BreakBeforeBraces: Attach
-# BreakBeforeTernaryOperators: true
-# BreakConstructorInitializersBeforeComma: false
-# ColumnLimit: 80
-# CommentPragmas: '^ IWYU pragma:'
-# ConstructorInitializerAllOnOneLineOrOnePerLine: false
-# ConstructorInitializerIndentWidth: 4
-# ContinuationIndentWidth: 4
-# Cpp11BracedListStyle: true
-# DerivePointerAlignment: false
-# DisableFormat: true
-# ExperimentalAutoDetectBinPacking: false
-# ForEachMacros: [ foreach, Q_FOREACH, BOOST_FOREACH ]
-# IncludeCategories:
-# - Regex: '^"(llvm|llvm-c|clang|clang-c)/'
-# Priority: 2
-# - Regex: '^(<|"(gtest|isl|json)/)'
-# Priority: 3
-# - Regex: '.*'
-# Priority: 1
-# IndentCaseLabels: false
-# IndentWidth: 2
-# IndentWrappedFunctionNames: false
-# KeepEmptyLinesAtTheStartOfBlocks: false
-# MacroBlockBegin: ''
-# MacroBlockEnd: ''
-# MaxEmptyLinesToKeep: 2
-# NamespaceIndentation: None
-# ObjCBlockIndentWidth: 2
-# ObjCSpaceAfterProperty: false
-# ObjCSpaceBeforeProtocolList: true
-# PenaltyBreakBeforeFirstCallParameter: 19
-# PenaltyBreakComment: 300
-# PenaltyBreakFirstLessLess: 120
-# PenaltyBreakString: 1000
-# PenaltyExcessCharacter: 1000000
-# PenaltyReturnTypeOnItsOwnLine: 60
-# PointerAlignment: Right
-# ReflowComments: true
-# SpaceAfterCStyleCast: false
-# SpaceBeforeAssignmentOperators: true
-# SpaceBeforeParens: ControlStatements
-# SpaceInEmptyParentheses: false
-# SpacesBeforeTrailingComments: 1
-# SpacesInAngles: false
-# SpacesInContainerLiterals: true
-# SpacesInCStyleCastParentheses: false
-# SpacesInParentheses: false
-# SpacesInSquareBrackets: false
-# Standard: Cpp11
-# TabWidth: 8
-# UseTab: Never
...
* extractExternal.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include <fstream>
#include <iostream>
#include <map>
* kmp.h -- KPTS runtime header file.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_H
#define KMP_H
* kmp_affinity.cpp -- affinity management
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
#include "kmp_i18n.h"
void __kmp_cleanup_hierarchy() { machine_hierarchy.fini(); }
-
void __kmp_get_hierarchy(kmp_uint32 nproc, kmp_bstate_t *thr_bar) {
kmp_uint32 depth;
// The test below is true if affinity is available, but set to "none". Need to
* kmp_affinity.h -- header for affinity management
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_AFFINITY_H
#define KMP_AFFINITY_H
* kmp_alloc.cpp -- private/shared dynamic memory allocation and management
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_io.h"
#include "kmp_wrapper_malloc.h"
* kmp_atomic.cpp -- ATOMIC implementation routines
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_atomic.h"
#include "kmp.h" // TRUE, asm routines prototypes
* kmp_atomic.h - ATOMIC header file
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_ATOMIC_H
#define KMP_ATOMIC_H
* kmp_barrier.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_wait_release.h"
#include "kmp_itt.h"
#include "kmp_os.h"
#include "kmp_stats.h"
-
#if KMP_MIC
#include <immintrin.h>
#define USE_NGO_STORES 1
int nproc = this_thr->th.th_team_nproc;
int i;
// Don't have to worry about sleep bit here or atomic since team setting
- kmp_uint64 new_state =
- team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
+ kmp_uint64 new_state = team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
// Collect all the worker team member threads.
for (i = 1; i < nproc; ++i) {
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_i18n.h"
#include "kmp_io.h"
* kmp_csupport.cpp -- kfront linkage support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "omp.h" /* extern "C" declarations of user-visible routines */
#include "kmp.h"
#include "kmp_error.h"
* kmp_debug.cpp -- debug utilities for the Guide library
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_debug.h" /* really necessary? */
#include "kmp_i18n.h"
* kmp_debug.h -- debug / assertion code for Assure library
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_DEBUG_H
#define KMP_DEBUG_H
* kmp_debugger.cpp -- debugger support.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_lock.h"
#include "kmp_omp.h"
* kmp_debugger.h -- debugger support.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_DEBUGGER_H
#define KMP_DEBUGGER_H
* kmp_dispatch.cpp: dynamic scheduling - iteration initialization and dispatch.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
/* Dynamic scheduling initialization and dispatch.
*
* NOTE: __kmp_nth is a constant inside of any dispatch loop, however
pr->u.p.parm2) { // compare with K*nproc*(chunk+1), K=2 by default
// use dynamic-style shcedule
// atomically inrement iterations, get old value
- init = test_then_add<ST>(
- RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunkspec);
+ init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+ (ST)chunkspec);
remaining = trip - init;
if (remaining <= 0) {
status = 0; // all iterations got by other threads
if ((T)remaining < pr->u.p.parm2) {
// use dynamic-style shcedule
// atomically inrement iterations, get old value
- init = test_then_add<ST>(
- RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunk);
+ init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+ (ST)chunk);
remaining = trip - init;
if (remaining <= 0) {
status = 0; // all iterations got by other threads
* kmp_environment.cpp -- Handle environment variables OS-independently.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
/* We use GetEnvironmentVariable for Windows* OS instead of getenv because the
act of loading a DLL on Windows* OS makes any user-set environment variables
(i.e. with putenv()) unavailable. getenv() apparently gets a clean copy of
* kmp_environment.h -- Handle environment varoiables OS-independently.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_ENVIRONMENT_H
#define KMP_ENVIRONMENT_H
* kmp_error.cpp -- KPTS functions for error checking at runtime
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_error.h"
#include "kmp_i18n.h"
* kmp_error.h -- PTS functions for error checking at runtime.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_ERROR_H
#define KMP_ERROR_H
* kmp_ftn_cdecl.cpp -- Fortran __cdecl linkage support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
* kmp_ftn_entry.h -- Fortran entry linkage support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef FTN_STDCALL
#error The support file kmp_ftn_entry.h should not be compiled by itself.
#endif
#if OMP_40_ENABLED
-
kmp_proc_bind_t FTN_STDCALL xexpand(FTN_GET_PROC_BIND)(void) {
#ifdef KMP_STUB
return __kmps_get_proc_bind();
/* ------------------------------------------------------------------------ */
-
#if OMP_40_ENABLED
/* returns the status of cancellation */
int FTN_STDCALL xexpand(FTN_GET_CANCELLATION)(void) {
* kmp_ftn_extra.cpp -- Fortran 'extra' linkage support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
* kmp_ftn_os.h -- KPTS Fortran defines header file.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_FTN_OS_H
#define KMP_FTN_OS_H
#define FTN_IS_INITIAL_DEVICE omp_is_initial_device_
#endif
-
#if OMP_40_ENABLED
#define FTN_GET_CANCELLATION omp_get_cancellation_
#define FTN_GET_CANCELLATION_STATUS kmp_get_cancellation_status_
#define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE
#endif
-
#if OMP_40_ENABLED
#define FTN_GET_CANCELLATION OMP_GET_CANCELLATION
#define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS
#define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE_
#endif
-
#if OMP_40_ENABLED
#define FTN_GET_CANCELLATION OMP_GET_CANCELLATION_
#define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS_
* kmp_ftn_stdcall.cpp -- Fortran __stdcall linkage support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
// Note: This string is not printed when KMP_VERSION=1.
* kmp_global.cpp -- KPTS global variables for runtime support library
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
int __kmp_allThreadsSpecified = 0;
size_t __kmp_align_alloc = CACHE_LINE;
-
int __kmp_generate_warnings = kmp_warnings_low;
int __kmp_reserve_warn = 0;
int __kmp_xproc = 0;
* kmp_gsupport.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_atomic.h"
* kmp_i18n.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_i18n.h"
#include "kmp.h"
* kmp_i18n.h
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_I18N_H
#define KMP_I18N_H
* kmp_import.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
/* Object generated from this source file is linked to Windows* OS DLL import
library (libompmd.lib) only! It is not a part of regular static or dynamic
OpenMP RTL. Any code that just needs to go in the libompmd.lib (but not in
* kmp_io.cpp -- RTL IO
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
* kmp_io.h -- RTL IO header file.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_IO_H
#define KMP_IO_H
* kmp_itt.cpp -- ITT Notify interface.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_itt.h"
#if KMP_DEBUG
* kmp_itt.h -- ITT Notify interface.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_ITT_H
#define KMP_ITT_H
* kmp_itt.inl -- Inline functions of ITT Notify.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
// Inline function definitions. This file should be included into kmp_itt.h file
// for production build (to let compliler inline functions) or into kmp_itt.c
// file for debug build (to reduce the number of files to recompile and save
* kmp_lock.cpp -- lock-related functions
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include <stddef.h>
#include <atomic>
* kmp_lock.h -- lock header file
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_LOCK_H
#define KMP_LOCK_H
* This is for information about runtime library structures.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
/* THIS FILE SHOULD NOT BE MODIFIED IN IDB INTERFACE LIBRARY CODE
It should instead be modified in the OpenMP runtime and copied to the
interface library code. This way we can minimize the problems that this is
* kmp_os.h -- KPTS runtime header file.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_OS_H
#define KMP_OS_H
#include <windows.h>
static inline int KMP_GET_PAGE_SIZE(void) {
- SYSTEM_INFO si;
- GetSystemInfo(&si);
- return si.dwPageSize;
+ SYSTEM_INFO si;
+ GetSystemInfo(&si);
+ return si.dwPageSize;
}
#else
#define KMP_GET_PAGE_SIZE() getpagesize()
#define KMP_USE_BGET 1
#endif
-
// Switches for OSS builds
#ifndef USE_SYSFS_INFO
#define USE_SYSFS_INFO 0
* kmp_platform.h -- header for determining operating system and architecture
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_PLATFORM_H
#define KMP_PLATFORM_H
* kmp_runtime.cpp -- KPTS runtime support library
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
#include "kmp_atomic.h"
__kmp_store_mxcsr(&mxcsr);
mxcsr &= KMP_X86_MXCSR_MASK;
-// There is no point looking at t_fp_control_saved here.
-// If it is TRUE, we still have to update the values if they are different from
-// those we now have.
-// If it is FALSE we didn't save anything yet, but our objective is the same. We
-// have to ensure that the values in the team are the same as those we have.
-// So, this code achieves what we need whether or not t_fp_control_saved is
-// true. By checking whether the value needs updating we avoid unnecessary
-// writes that would put the cache-line into a written state, causing all
-// threads in the team to have to read it again.
+ // There is no point looking at t_fp_control_saved here.
+ // If it is TRUE, we still have to update the values if they are different
+ // from those we now have. If it is FALSE we didn't save anything yet, but
+ // our objective is the same. We have to ensure that the values in the team
+ // are the same as those we have.
+ // So, this code achieves what we need whether or not t_fp_control_saved is
+ // true. By checking whether the value needs updating we avoid unnecessary
+ // writes that would put the cache-line into a written state, causing all
+ // threads in the team to have to read it again.
KMP_CHECK_UPDATE(team->t.t_x87_fpu_control_word, x87_fpu_control_word);
KMP_CHECK_UPDATE(team->t.t_mxcsr, mxcsr);
// Although we don't use this value, other code in the runtime wants to know
place++;
}
- KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
- "partition = [%d,%d], __kmp_affinity_num_masks: %u\n",
- __kmp_gtid_from_thread(team->t.t_threads[f]),
- team->t.t_id, f, th->th.th_new_place,
- th->th.th_first_place, th->th.th_last_place,
- __kmp_affinity_num_masks));
+ KA_TRACE(100,
+ ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+ "partition = [%d,%d], __kmp_affinity_num_masks: %u\n",
+ __kmp_gtid_from_thread(team->t.t_threads[f]), team->t.t_id,
+ f, th->th.th_new_place, th->th.th_first_place,
+ th->th.th_last_place, __kmp_affinity_num_masks));
}
} else {
/* Having uniform space of available computation places I can create
place of each partition. */
double current = static_cast<double>(masters_place);
double spacing =
- (static_cast<double>(n_places + 1) / static_cast<double>(n_th));
+ (static_cast<double>(n_places + 1) / static_cast<double>(n_th));
int first, last;
kmp_info_t *th;
th->th.th_new_place = place;
th->th.th_last_place = last;
- KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
- "partition = [%d,%d], spacing = %.4f\n",
- __kmp_gtid_from_thread(team->t.t_threads[f]),
- team->t.t_id, f, th->th.th_new_place,
- th->th.th_first_place, th->th.th_last_place,
- spacing));
+ KA_TRACE(100,
+ ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+ "partition = [%d,%d], spacing = %.4f\n",
+ __kmp_gtid_from_thread(team->t.t_threads[f]),
+ team->t.t_id, f, th->th.th_new_place,
+ th->th.th_first_place, th->th.th_last_place, spacing));
}
}
}
return team;
}
-/* reap team if it is too small, then loop back and check the next one */
-// not sure if this is wise, but, will be redone during the hot-teams rewrite.
-/* TODO: Use technique to find the right size hot-team, don't reap them */
+ /* reap team if it is too small, then loop back and check the next one */
+ // not sure if this is wise, but, will be redone during the hot-teams
+ // rewrite.
+ /* TODO: Use technique to find the right size hot-team, don't reap them */
team = __kmp_reap_team(team);
__kmp_team_pool = team;
}
// 2009-09-08 (lev): Other alive roots found. Why do we kill the monitor??
KMP_MB(); /* Flush all pending memory write invalidates. */
-// Need to check that monitor was initialized before reaping it. If we are
-// called form __kmp_atfork_child (which sets __kmp_init_parallel = 0), then
-// __kmp_monitor will appear to contain valid data, but it is only valid in the
-// parent process, not the child.
+ // Need to check that monitor was initialized before reaping it. If we are
+ // called form __kmp_atfork_child (which sets __kmp_init_parallel = 0), then
+ // __kmp_monitor will appear to contain valid data, but it is only valid in
+ // the parent process, not the child.
// New behavior (201008): instead of keying off of the flag
// __kmp_init_parallel, the monitor thread creation is keyed off
// of the new flag __kmp_init_monitor.
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_SAFE_C_API_H
#define KMP_SAFE_C_API_H
* kmp_sched.cpp -- static scheduling -- iteration initialization
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
/* Static scheduling initialization.
NOTE: team->t.t_nproc is a constant inside of any dispatch loop, however
* kmp_settings.cpp -- Initialize environment variables
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
#include "kmp_atomic.h"
#include "kmp_settings.h"
#include "kmp_str.h"
#include "kmp_wrapper_getpid.h"
-#include <ctype.h> // toupper()
+#include <ctype.h> // toupper()
static int __kmp_env_toPrint(char const *name, int flag);
if (value) {
ompc_set_dynamic(__kmp_global.g.g_dynamic);
}
-
}
void __kmp_env_initialize(char const *string) {
}
}
-// We need to know if blocktime was set when processing OMP_WAIT_POLICY
+ // We need to know if blocktime was set when processing OMP_WAIT_POLICY
blocktime_str = __kmp_env_blk_var(&block, "KMP_BLOCKTIME");
// Special case. If we parse environment, not a string, process KMP_WARNINGS
* kmp_settings.h -- Initialize environment variables
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_SETTINGS_H
#define KMP_SETTINGS_H
* Statistics gathering and processing.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_lock.h"
#include "kmp_stats.h"
* Functions for collecting statistics.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_config.h"
#if KMP_STATS_ENABLED
* Timing functions
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include <stdlib.h>
#include <unistd.h>
* Access to real time clock and timers.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_os.h"
#include <limits>
#include <stdint.h>
tsc_tick_count()
: my_count(static_cast<int64_t>(__builtin_readcyclecounter())) {}
#elif KMP_HAVE___RDTSC
- tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())){}
+ tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())) {}
#else
#error Must have high resolution timer defined
#endif
- tsc_tick_count(int64_t value) : my_count(value){}
+ tsc_tick_count(int64_t value) : my_count(value) {}
int64_t getValue() const { return my_count; }
tsc_tick_count later(tsc_tick_count const other) const {
return my_count > other.my_count ? (*this) : other;
* kmp_str.cpp -- String manipulation routines.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp_str.h"
#include <stdarg.h> // va_*
* kmp_str.h -- String manipulation routines.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_STR_H
#define KMP_STR_H
* kmp_stub.cpp -- stub versions of user-callable OpenMP RT functions.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
* kmp_stub.h
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_STUB_H
#define KMP_STUB_H
* kmp_taskdeps.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
//#define KMP_SUPPORT_GRAPH_OUTPUT 1
#include "kmp.h"
* kmp_tasking.cpp -- OpenMP 3.0 tasking support.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_i18n.h"
#include "kmp_itt.h"
* kmp_taskq.cpp -- TASKQ support for OpenMP.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_error.h"
#include "kmp_i18n.h"
* kmp_threadprivate.cpp -- OpenMP threadprivate support library
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_i18n.h"
#include "kmp_itt.h"
* kmp_utility.cpp -- Utility routines for the OpenMP support library.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_i18n.h"
#include "kmp_str.h"
* kmp_version.cpp
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_io.h"
#include "kmp_version.h"
* kmp_version.h -- version number for this release
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_VERSION_H
#define KMP_VERSION_H
* kmp_wait_release.cpp -- Wait/Release implementation
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
* kmp_wait_release.h -- Wait/Release implementation
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_WAIT_RELEASE_H
#define KMP_WAIT_RELEASE_H
* kmp_wrapper_getpid.h -- getpid() declaration.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_WRAPPER_GETPID_H
#define KMP_WRAPPER_GETPID_H
* (malloc(), free(), and others).
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#ifndef KMP_WRAPPER_MALLOC_H
#define KMP_WRAPPER_MALLOC_H
* z_Linux_util.cpp -- platform specific routines.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
#include "kmp_i18n.h"
}
}
-
/* This routine puts the calling thread to sleep after setting the
sleep bit for the indicated flag variable to true. */
template <class C>
* z_Windows_NT-586_util.cpp -- platform specific routines.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
* z_Windows_NT_util.cpp -- platform specific routines.
*/
-
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
//===----------------------------------------------------------------------===//
-
#include "kmp.h"
#include "kmp_affinity.h"
#include "kmp_i18n.h"
projects / platform / upstream / llvm.git / commitdiff