2014-05-06 18:08:46 +08:00
|
|
|
//===----- CGOpenMPRuntime.h - Interface to OpenMP Runtimes -----*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This provides a class for OpenMP runtime code generation.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2014-08-14 00:25:19 +08:00
|
|
|
#ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
|
|
|
|
#define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIME_H
|
2014-05-06 18:08:46 +08:00
|
|
|
|
2014-12-15 15:07:06 +08:00
|
|
|
#include "clang/Basic/OpenMPKinds.h"
|
2015-01-14 19:29:14 +08:00
|
|
|
#include "clang/Basic/SourceLocation.h"
|
2014-05-06 18:08:46 +08:00
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2014-11-11 12:05:39 +08:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
2014-09-22 18:01:53 +08:00
|
|
|
#include "llvm/ADT/StringMap.h"
|
2014-11-11 12:05:39 +08:00
|
|
|
#include "llvm/IR/ValueHandle.h"
|
2014-05-06 18:08:46 +08:00
|
|
|
|
2014-10-10 20:19:54 +08:00
|
|
|
namespace llvm {
|
|
|
|
class ArrayType;
|
|
|
|
class Constant;
|
|
|
|
class Function;
|
|
|
|
class FunctionType;
|
2014-11-11 12:05:39 +08:00
|
|
|
class GlobalVariable;
|
2014-10-10 20:19:54 +08:00
|
|
|
class StructType;
|
|
|
|
class Type;
|
|
|
|
class Value;
|
|
|
|
} // namespace llvm
|
2014-10-08 22:01:46 +08:00
|
|
|
|
2014-10-10 20:19:54 +08:00
|
|
|
namespace clang {
|
2014-11-20 12:34:54 +08:00
|
|
|
class Expr;
|
2014-10-10 20:19:54 +08:00
|
|
|
class OMPExecutableDirective;
|
|
|
|
class VarDecl;
|
2014-10-08 22:01:46 +08:00
|
|
|
|
2014-10-10 20:19:54 +08:00
|
|
|
namespace CodeGen {
|
2014-10-08 22:01:46 +08:00
|
|
|
|
2014-10-10 20:19:54 +08:00
|
|
|
class CodeGenFunction;
|
|
|
|
class CodeGenModule;
|
2014-05-06 18:08:46 +08:00
|
|
|
|
|
|
|
class CGOpenMPRuntime {
|
|
|
|
public:
|
2014-12-03 20:11:24 +08:00
|
|
|
|
|
|
|
private:
|
2014-05-06 18:08:46 +08:00
|
|
|
enum OpenMPRTLFunction {
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \brief Call to void __kmpc_fork_call(ident_t *loc, kmp_int32 argc,
|
|
|
|
/// kmpc_micro microtask, ...);
|
2014-05-06 18:08:46 +08:00
|
|
|
OMPRTL__kmpc_fork_call,
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \brief Call to void *__kmpc_threadprivate_cached(ident_t *loc,
|
|
|
|
/// kmp_int32 global_tid, void *data, size_t size, void ***cache);
|
|
|
|
OMPRTL__kmpc_threadprivate_cached,
|
|
|
|
/// \brief Call to void __kmpc_threadprivate_register( ident_t *,
|
|
|
|
/// void *data, kmpc_ctor ctor, kmpc_cctor cctor, kmpc_dtor dtor);
|
|
|
|
OMPRTL__kmpc_threadprivate_register,
|
2014-09-22 18:01:53 +08:00
|
|
|
// Call to __kmpc_int32 kmpc_global_thread_num(ident_t *loc);
|
|
|
|
OMPRTL__kmpc_global_thread_num,
|
2014-09-22 20:32:31 +08:00
|
|
|
// Call to void __kmpc_critical(ident_t *loc, kmp_int32 global_tid,
|
|
|
|
// kmp_critical_name *crit);
|
2014-09-22 18:01:53 +08:00
|
|
|
OMPRTL__kmpc_critical,
|
2014-09-22 20:32:31 +08:00
|
|
|
// Call to void __kmpc_end_critical(ident_t *loc, kmp_int32 global_tid,
|
|
|
|
// kmp_critical_name *crit);
|
2014-10-08 22:01:46 +08:00
|
|
|
OMPRTL__kmpc_end_critical,
|
2014-12-05 12:09:23 +08:00
|
|
|
// Call to kmp_int32 __kmpc_cancel_barrier(ident_t *loc, kmp_int32
|
|
|
|
// global_tid);
|
|
|
|
OMPRTL__kmpc_cancel_barrier,
|
2014-12-15 15:07:06 +08:00
|
|
|
// Calls for static scheduling 'omp for' loops.
|
|
|
|
OMPRTL__kmpc_for_static_init_4,
|
|
|
|
OMPRTL__kmpc_for_static_init_4u,
|
|
|
|
OMPRTL__kmpc_for_static_init_8,
|
|
|
|
OMPRTL__kmpc_for_static_init_8u,
|
|
|
|
OMPRTL__kmpc_for_static_fini,
|
[OPENMP] Codegen for 'if' clause in 'parallel' directive.
Adds codegen for 'if' clause. Currently only for 'if' clause used with the 'parallel' directive.
If condition evaluates to true, the code executes parallel version of the code by calling __kmpc_fork_call(loc, 1, microtask, captured_struct/*context*/), where loc - debug location, 1 - number of additional parameters after "microtask" argument, microtask - is outlined finction for the code associated with the 'parallel' directive, captured_struct - list of variables captured in this outlined function.
If condition evaluates to false, the code executes serial version of the code by executing the following code:
global_thread_id.addr = alloca i32
store i32 global_thread_id, global_thread_id.addr
zero.addr = alloca i32
store i32 0, zero.addr
kmpc_serialized_parallel(loc, global_thread_id);
microtask(global_thread_id.addr, zero.addr, captured_struct/*context*/);
kmpc_end_serialized_parallel(loc, global_thread_id);
Where loc - debug location, global_thread_id - global thread id, returned by __kmpc_global_thread_num() call or passed as a first parameter in microtask() call, global_thread_id.addr - address of the variable, where stored global_thread_id value, zero.addr - implicit bound thread id (should be set to 0 for serial call), microtask() and captured_struct are the same as in parallel call.
Also this patch checks if the condition is constant and if it is constant it evaluates its value and then generates either parallel version of the code (if the condition evaluates to true), or the serial version of the code (if the condition evaluates to false).
Differential Revision: http://reviews.llvm.org/D4716
llvm-svn: 219597
2014-10-13 14:02:40 +08:00
|
|
|
// Call to void __kmpc_serialized_parallel(ident_t *loc, kmp_int32
|
|
|
|
// global_tid);
|
|
|
|
OMPRTL__kmpc_serialized_parallel,
|
|
|
|
// Call to void __kmpc_end_serialized_parallel(ident_t *loc, kmp_int32
|
|
|
|
// global_tid);
|
2014-10-13 16:23:51 +08:00
|
|
|
OMPRTL__kmpc_end_serialized_parallel,
|
|
|
|
// Call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid,
|
|
|
|
// kmp_int32 num_threads);
|
2014-11-20 12:34:54 +08:00
|
|
|
OMPRTL__kmpc_push_num_threads,
|
2015-02-24 20:55:09 +08:00
|
|
|
// Call to void __kmpc_flush(ident_t *loc);
|
2014-12-04 15:23:53 +08:00
|
|
|
OMPRTL__kmpc_flush,
|
|
|
|
// Call to kmp_int32 __kmpc_master(ident_t *, kmp_int32 global_tid);
|
|
|
|
OMPRTL__kmpc_master,
|
|
|
|
// Call to void __kmpc_end_master(ident_t *, kmp_int32 global_tid);
|
|
|
|
OMPRTL__kmpc_end_master,
|
2015-02-05 13:57:51 +08:00
|
|
|
// Call to kmp_int32 __kmpc_omp_taskyield(ident_t *, kmp_int32 global_tid,
|
|
|
|
// int end_part);
|
|
|
|
OMPRTL__kmpc_omp_taskyield,
|
2015-02-05 14:35:41 +08:00
|
|
|
// Call to kmp_int32 __kmpc_single(ident_t *, kmp_int32 global_tid);
|
|
|
|
OMPRTL__kmpc_single,
|
|
|
|
// Call to void __kmpc_end_single(ident_t *, kmp_int32 global_tid);
|
|
|
|
OMPRTL__kmpc_end_single,
|
2014-05-06 18:08:46 +08:00
|
|
|
};
|
|
|
|
|
2014-12-05 12:09:23 +08:00
|
|
|
/// \brief Values for bit flags used in the ident_t to describe the fields.
|
|
|
|
/// All enumeric elements are named and described in accordance with the code
|
|
|
|
/// from http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
|
|
|
|
enum OpenMPLocationFlags {
|
|
|
|
/// \brief Use trampoline for internal microtask.
|
|
|
|
OMP_IDENT_IMD = 0x01,
|
|
|
|
/// \brief Use c-style ident structure.
|
|
|
|
OMP_IDENT_KMPC = 0x02,
|
|
|
|
/// \brief Atomic reduction option for kmpc_reduce.
|
|
|
|
OMP_ATOMIC_REDUCE = 0x10,
|
|
|
|
/// \brief Explicit 'barrier' directive.
|
|
|
|
OMP_IDENT_BARRIER_EXPL = 0x20,
|
|
|
|
/// \brief Implicit barrier in code.
|
|
|
|
OMP_IDENT_BARRIER_IMPL = 0x40,
|
|
|
|
/// \brief Implicit barrier in 'for' directive.
|
|
|
|
OMP_IDENT_BARRIER_IMPL_FOR = 0x40,
|
|
|
|
/// \brief Implicit barrier in 'sections' directive.
|
|
|
|
OMP_IDENT_BARRIER_IMPL_SECTIONS = 0xC0,
|
|
|
|
/// \brief Implicit barrier in 'single' directive.
|
|
|
|
OMP_IDENT_BARRIER_IMPL_SINGLE = 0x140
|
|
|
|
};
|
2014-05-06 18:08:46 +08:00
|
|
|
CodeGenModule &CGM;
|
|
|
|
/// \brief Default const ident_t object used for initialization of all other
|
|
|
|
/// ident_t objects.
|
|
|
|
llvm::Constant *DefaultOpenMPPSource;
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \brief Map of flags and corresponding default locations.
|
2014-05-07 14:18:01 +08:00
|
|
|
typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDefaultLocMapTy;
|
|
|
|
OpenMPDefaultLocMapTy OpenMPDefaultLocMap;
|
2014-05-06 18:08:46 +08:00
|
|
|
llvm::Value *GetOrCreateDefaultOpenMPLocation(OpenMPLocationFlags Flags);
|
|
|
|
/// \brief Describes ident structure that describes a source location.
|
|
|
|
/// All descriptions are taken from
|
|
|
|
/// http://llvm.org/svn/llvm-project/openmp/trunk/runtime/src/kmp.h
|
|
|
|
/// Original structure:
|
|
|
|
/// typedef struct ident {
|
|
|
|
/// kmp_int32 reserved_1; /**< might be used in Fortran;
|
|
|
|
/// see above */
|
|
|
|
/// kmp_int32 flags; /**< also f.flags; KMP_IDENT_xxx flags;
|
|
|
|
/// KMP_IDENT_KMPC identifies this union
|
|
|
|
/// member */
|
|
|
|
/// kmp_int32 reserved_2; /**< not really used in Fortran any more;
|
|
|
|
/// see above */
|
|
|
|
///#if USE_ITT_BUILD
|
|
|
|
/// /* but currently used for storing
|
|
|
|
/// region-specific ITT */
|
|
|
|
/// /* contextual information. */
|
|
|
|
///#endif /* USE_ITT_BUILD */
|
|
|
|
/// kmp_int32 reserved_3; /**< source[4] in Fortran, do not use for
|
|
|
|
/// C++ */
|
|
|
|
/// char const *psource; /**< String describing the source location.
|
|
|
|
/// The string is composed of semi-colon separated
|
|
|
|
// fields which describe the source file,
|
|
|
|
/// the function and a pair of line numbers that
|
|
|
|
/// delimit the construct.
|
|
|
|
/// */
|
|
|
|
/// } ident_t;
|
|
|
|
enum IdentFieldIndex {
|
|
|
|
/// \brief might be used in Fortran
|
|
|
|
IdentField_Reserved_1,
|
|
|
|
/// \brief OMP_IDENT_xxx flags; OMP_IDENT_KMPC identifies this union member.
|
|
|
|
IdentField_Flags,
|
|
|
|
/// \brief Not really used in Fortran any more
|
|
|
|
IdentField_Reserved_2,
|
|
|
|
/// \brief Source[4] in Fortran, do not use for C++
|
|
|
|
IdentField_Reserved_3,
|
|
|
|
/// \brief String describing the source location. The string is composed of
|
|
|
|
/// semi-colon separated fields which describe the source file, the function
|
|
|
|
/// and a pair of line numbers that delimit the construct.
|
|
|
|
IdentField_PSource
|
|
|
|
};
|
|
|
|
llvm::StructType *IdentTy;
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \brief Map for SourceLocation and OpenMP runtime library debug locations.
|
2014-05-30 13:48:40 +08:00
|
|
|
typedef llvm::DenseMap<unsigned, llvm::Value *> OpenMPDebugLocMapTy;
|
|
|
|
OpenMPDebugLocMapTy OpenMPDebugLocMap;
|
2014-05-06 18:08:46 +08:00
|
|
|
/// \brief The type for a microtask which gets passed to __kmpc_fork_call().
|
|
|
|
/// Original representation is:
|
|
|
|
/// typedef void (kmpc_micro)(kmp_int32 global_tid, kmp_int32 bound_tid,...);
|
|
|
|
llvm::FunctionType *Kmpc_MicroTy;
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \brief Stores debug location and ThreadID for the function.
|
|
|
|
struct DebugLocThreadIdTy {
|
|
|
|
llvm::Value *DebugLoc;
|
|
|
|
llvm::Value *ThreadID;
|
|
|
|
};
|
|
|
|
/// \brief Map of local debug location, ThreadId and functions.
|
|
|
|
typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
|
|
|
|
OpenMPLocThreadIDMapTy;
|
|
|
|
OpenMPLocThreadIDMapTy OpenMPLocThreadIDMap;
|
2014-09-22 18:01:53 +08:00
|
|
|
/// \brief Type kmp_critical_name, originally defined as typedef kmp_int32
|
|
|
|
/// kmp_critical_name[8];
|
|
|
|
llvm::ArrayType *KmpCriticalNameTy;
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \brief An ordered map of auto-generated variables to their unique names.
|
|
|
|
/// It stores variables with the following names: 1) ".gomp_critical_user_" +
|
|
|
|
/// <critical_section_name> + ".var" for "omp critical" directives; 2)
|
|
|
|
/// <mangled_name_for_global_var> + ".cache." for cache for threadprivate
|
|
|
|
/// variables.
|
|
|
|
llvm::StringMap<llvm::AssertingVH<llvm::Constant>, llvm::BumpPtrAllocator>
|
|
|
|
InternalVars;
|
2014-05-06 18:08:46 +08:00
|
|
|
|
|
|
|
/// \brief Emits object of ident_t type with info for source location.
|
|
|
|
/// \param Flags Flags for OpenMP location.
|
|
|
|
///
|
|
|
|
llvm::Value *
|
|
|
|
EmitOpenMPUpdateLocation(CodeGenFunction &CGF, SourceLocation Loc,
|
|
|
|
OpenMPLocationFlags Flags = OMP_IDENT_KMPC);
|
|
|
|
|
[OPENMP] Codegen for 'if' clause in 'parallel' directive.
Adds codegen for 'if' clause. Currently only for 'if' clause used with the 'parallel' directive.
If condition evaluates to true, the code executes parallel version of the code by calling __kmpc_fork_call(loc, 1, microtask, captured_struct/*context*/), where loc - debug location, 1 - number of additional parameters after "microtask" argument, microtask - is outlined finction for the code associated with the 'parallel' directive, captured_struct - list of variables captured in this outlined function.
If condition evaluates to false, the code executes serial version of the code by executing the following code:
global_thread_id.addr = alloca i32
store i32 global_thread_id, global_thread_id.addr
zero.addr = alloca i32
store i32 0, zero.addr
kmpc_serialized_parallel(loc, global_thread_id);
microtask(global_thread_id.addr, zero.addr, captured_struct/*context*/);
kmpc_end_serialized_parallel(loc, global_thread_id);
Where loc - debug location, global_thread_id - global thread id, returned by __kmpc_global_thread_num() call or passed as a first parameter in microtask() call, global_thread_id.addr - address of the variable, where stored global_thread_id value, zero.addr - implicit bound thread id (should be set to 0 for serial call), microtask() and captured_struct are the same as in parallel call.
Also this patch checks if the condition is constant and if it is constant it evaluates its value and then generates either parallel version of the code (if the condition evaluates to true), or the serial version of the code (if the condition evaluates to false).
Differential Revision: http://reviews.llvm.org/D4716
llvm-svn: 219597
2014-10-13 14:02:40 +08:00
|
|
|
/// \brief Returns pointer to ident_t type.
|
2014-05-06 18:08:46 +08:00
|
|
|
llvm::Type *getIdentTyPointerTy();
|
|
|
|
|
[OPENMP] Codegen for 'if' clause in 'parallel' directive.
Adds codegen for 'if' clause. Currently only for 'if' clause used with the 'parallel' directive.
If condition evaluates to true, the code executes parallel version of the code by calling __kmpc_fork_call(loc, 1, microtask, captured_struct/*context*/), where loc - debug location, 1 - number of additional parameters after "microtask" argument, microtask - is outlined finction for the code associated with the 'parallel' directive, captured_struct - list of variables captured in this outlined function.
If condition evaluates to false, the code executes serial version of the code by executing the following code:
global_thread_id.addr = alloca i32
store i32 global_thread_id, global_thread_id.addr
zero.addr = alloca i32
store i32 0, zero.addr
kmpc_serialized_parallel(loc, global_thread_id);
microtask(global_thread_id.addr, zero.addr, captured_struct/*context*/);
kmpc_end_serialized_parallel(loc, global_thread_id);
Where loc - debug location, global_thread_id - global thread id, returned by __kmpc_global_thread_num() call or passed as a first parameter in microtask() call, global_thread_id.addr - address of the variable, where stored global_thread_id value, zero.addr - implicit bound thread id (should be set to 0 for serial call), microtask() and captured_struct are the same as in parallel call.
Also this patch checks if the condition is constant and if it is constant it evaluates its value and then generates either parallel version of the code (if the condition evaluates to true), or the serial version of the code (if the condition evaluates to false).
Differential Revision: http://reviews.llvm.org/D4716
llvm-svn: 219597
2014-10-13 14:02:40 +08:00
|
|
|
/// \brief Returns pointer to kmpc_micro type.
|
2014-05-06 18:08:46 +08:00
|
|
|
llvm::Type *getKmpc_MicroPointerTy();
|
|
|
|
|
|
|
|
/// \brief Returns specified OpenMP runtime function.
|
|
|
|
/// \param Function OpenMP runtime function.
|
|
|
|
/// \return Specified function.
|
|
|
|
llvm::Constant *CreateRuntimeFunction(OpenMPRTLFunction Function);
|
2014-09-22 18:01:53 +08:00
|
|
|
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \brief If the specified mangled name is not in the module, create and
|
|
|
|
/// return threadprivate cache object. This object is a pointer's worth of
|
|
|
|
/// storage that's reserved for use by the OpenMP runtime.
|
2014-11-11 15:58:06 +08:00
|
|
|
/// \param VD Threadprivate variable.
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \return Cache variable for the specified threadprivate.
|
|
|
|
llvm::Constant *getOrCreateThreadPrivateCache(const VarDecl *VD);
|
|
|
|
|
[OPENMP] Codegen for 'if' clause in 'parallel' directive.
Adds codegen for 'if' clause. Currently only for 'if' clause used with the 'parallel' directive.
If condition evaluates to true, the code executes parallel version of the code by calling __kmpc_fork_call(loc, 1, microtask, captured_struct/*context*/), where loc - debug location, 1 - number of additional parameters after "microtask" argument, microtask - is outlined finction for the code associated with the 'parallel' directive, captured_struct - list of variables captured in this outlined function.
If condition evaluates to false, the code executes serial version of the code by executing the following code:
global_thread_id.addr = alloca i32
store i32 global_thread_id, global_thread_id.addr
zero.addr = alloca i32
store i32 0, zero.addr
kmpc_serialized_parallel(loc, global_thread_id);
microtask(global_thread_id.addr, zero.addr, captured_struct/*context*/);
kmpc_end_serialized_parallel(loc, global_thread_id);
Where loc - debug location, global_thread_id - global thread id, returned by __kmpc_global_thread_num() call or passed as a first parameter in microtask() call, global_thread_id.addr - address of the variable, where stored global_thread_id value, zero.addr - implicit bound thread id (should be set to 0 for serial call), microtask() and captured_struct are the same as in parallel call.
Also this patch checks if the condition is constant and if it is constant it evaluates its value and then generates either parallel version of the code (if the condition evaluates to true), or the serial version of the code (if the condition evaluates to false).
Differential Revision: http://reviews.llvm.org/D4716
llvm-svn: 219597
2014-10-13 14:02:40 +08:00
|
|
|
/// \brief Emits address of the word in a memory where current thread id is
|
|
|
|
/// stored.
|
|
|
|
virtual llvm::Value *EmitThreadIDAddress(CodeGenFunction &CGF,
|
|
|
|
SourceLocation Loc);
|
|
|
|
|
2014-10-08 22:01:46 +08:00
|
|
|
/// \brief Gets thread id value for the current thread.
|
|
|
|
///
|
|
|
|
llvm::Value *GetOpenMPThreadID(CodeGenFunction &CGF, SourceLocation Loc);
|
|
|
|
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \brief Gets (if variable with the given name already exist) or creates
|
|
|
|
/// internal global variable with the specified Name. The created variable has
|
|
|
|
/// linkage CommonLinkage by default and is initialized by null value.
|
|
|
|
/// \param Ty Type of the global variable. If it is exist already the type
|
|
|
|
/// must be the same.
|
|
|
|
/// \param Name Name of the variable.
|
|
|
|
llvm::Constant *GetOrCreateInternalVariable(llvm::Type *Ty,
|
|
|
|
const llvm::Twine &Name);
|
|
|
|
|
|
|
|
/// \brief Set of threadprivate variables with the generated initializer.
|
|
|
|
llvm::DenseSet<const VarDecl *> ThreadPrivateWithDefinition;
|
|
|
|
|
|
|
|
/// \brief Emits initialization code for the threadprivate variables.
|
|
|
|
/// \param VDAddr Address of the global variable \a VD.
|
|
|
|
/// \param Ctor Pointer to a global init function for \a VD.
|
|
|
|
/// \param CopyCtor Pointer to a global copy function for \a VD.
|
|
|
|
/// \param Dtor Pointer to a global destructor function for \a VD.
|
|
|
|
/// \param Loc Location of threadprivate declaration.
|
|
|
|
void EmitOMPThreadPrivateVarInit(CodeGenFunction &CGF, llvm::Value *VDAddr,
|
|
|
|
llvm::Value *Ctor, llvm::Value *CopyCtor,
|
|
|
|
llvm::Value *Dtor, SourceLocation Loc);
|
|
|
|
|
2014-12-01 19:32:38 +08:00
|
|
|
/// \brief Returns corresponding lock object for the specified critical region
|
|
|
|
/// name. If the lock object does not exist it is created, otherwise the
|
|
|
|
/// reference to the existing copy is returned.
|
|
|
|
/// \param CriticalName Name of the critical region.
|
|
|
|
///
|
|
|
|
llvm::Value *GetCriticalRegionLock(StringRef CriticalName);
|
|
|
|
|
2014-10-08 22:01:46 +08:00
|
|
|
public:
|
|
|
|
explicit CGOpenMPRuntime(CodeGenModule &CGM);
|
|
|
|
virtual ~CGOpenMPRuntime() {}
|
|
|
|
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \brief Emits outlined function for the specified OpenMP directive \a D
|
|
|
|
/// (required for parallel and task directives). This outlined function has
|
|
|
|
/// type void(*)(kmp_int32 /*ThreadID*/, kmp_int32 /*BoundID*/, struct
|
|
|
|
/// context_vars*).
|
|
|
|
/// \param D OpenMP directive.
|
|
|
|
/// \param ThreadIDVar Variable for thread id in the current OpenMP region.
|
|
|
|
///
|
|
|
|
virtual llvm::Value *
|
|
|
|
EmitOpenMPOutlinedFunction(const OMPExecutableDirective &D,
|
|
|
|
const VarDecl *ThreadIDVar);
|
|
|
|
|
2014-10-08 22:01:46 +08:00
|
|
|
/// \brief Cleans up references to the objects in finished function.
|
|
|
|
///
|
|
|
|
void FunctionFinished(CodeGenFunction &CGF);
|
|
|
|
|
|
|
|
/// \brief Emits code for parallel call of the \a OutlinedFn with variables
|
|
|
|
/// captured in a record which address is stored in \a CapturedStruct.
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \param OutlinedFn Outlined function to be run in parallel threads. Type of
|
|
|
|
/// this function is void(*)(kmp_int32, kmp_int32, struct context_vars*).
|
2014-10-08 22:01:46 +08:00
|
|
|
/// \param CapturedStruct A pointer to the record with the references to
|
|
|
|
/// variables used in \a OutlinedFn function.
|
|
|
|
///
|
|
|
|
virtual void EmitOMPParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
|
|
|
|
llvm::Value *OutlinedFn,
|
|
|
|
llvm::Value *CapturedStruct);
|
|
|
|
|
[OPENMP] Codegen for 'if' clause in 'parallel' directive.
Adds codegen for 'if' clause. Currently only for 'if' clause used with the 'parallel' directive.
If condition evaluates to true, the code executes parallel version of the code by calling __kmpc_fork_call(loc, 1, microtask, captured_struct/*context*/), where loc - debug location, 1 - number of additional parameters after "microtask" argument, microtask - is outlined finction for the code associated with the 'parallel' directive, captured_struct - list of variables captured in this outlined function.
If condition evaluates to false, the code executes serial version of the code by executing the following code:
global_thread_id.addr = alloca i32
store i32 global_thread_id, global_thread_id.addr
zero.addr = alloca i32
store i32 0, zero.addr
kmpc_serialized_parallel(loc, global_thread_id);
microtask(global_thread_id.addr, zero.addr, captured_struct/*context*/);
kmpc_end_serialized_parallel(loc, global_thread_id);
Where loc - debug location, global_thread_id - global thread id, returned by __kmpc_global_thread_num() call or passed as a first parameter in microtask() call, global_thread_id.addr - address of the variable, where stored global_thread_id value, zero.addr - implicit bound thread id (should be set to 0 for serial call), microtask() and captured_struct are the same as in parallel call.
Also this patch checks if the condition is constant and if it is constant it evaluates its value and then generates either parallel version of the code (if the condition evaluates to true), or the serial version of the code (if the condition evaluates to false).
Differential Revision: http://reviews.llvm.org/D4716
llvm-svn: 219597
2014-10-13 14:02:40 +08:00
|
|
|
/// \brief Emits code for serial call of the \a OutlinedFn with variables
|
|
|
|
/// captured in a record which address is stored in \a CapturedStruct.
|
|
|
|
/// \param OutlinedFn Outlined function to be run in serial mode.
|
|
|
|
/// \param CapturedStruct A pointer to the record with the references to
|
|
|
|
/// variables used in \a OutlinedFn function.
|
|
|
|
///
|
|
|
|
virtual void EmitOMPSerialCall(CodeGenFunction &CGF, SourceLocation Loc,
|
|
|
|
llvm::Value *OutlinedFn,
|
|
|
|
llvm::Value *CapturedStruct);
|
|
|
|
|
2014-12-01 19:32:38 +08:00
|
|
|
/// \brief Emits a critical region.
|
2014-10-10 20:19:54 +08:00
|
|
|
/// \param CriticalName Name of the critical region.
|
2014-12-01 19:32:38 +08:00
|
|
|
/// \param CriticalOpGen Generator for the statement associated with the given
|
|
|
|
/// critical region.
|
|
|
|
virtual void EmitOMPCriticalRegion(CodeGenFunction &CGF,
|
|
|
|
StringRef CriticalName,
|
|
|
|
const std::function<void()> &CriticalOpGen,
|
|
|
|
SourceLocation Loc);
|
2014-10-08 22:01:46 +08:00
|
|
|
|
2014-12-04 15:23:53 +08:00
|
|
|
/// \brief Emits a master region.
|
|
|
|
/// \param MasterOpGen Generator for the statement associated with the given
|
|
|
|
/// master region.
|
|
|
|
virtual void EmitOMPMasterRegion(CodeGenFunction &CGF,
|
|
|
|
const std::function<void()> &MasterOpGen,
|
|
|
|
SourceLocation Loc);
|
|
|
|
|
2015-02-05 13:57:51 +08:00
|
|
|
/// \brief Emits code for a taskyield directive.
|
|
|
|
virtual void EmitOMPTaskyieldCall(CodeGenFunction &CGF, SourceLocation Loc);
|
|
|
|
|
2015-02-05 14:35:41 +08:00
|
|
|
/// \brief Emits a single region.
|
|
|
|
/// \param SingleOpGen Generator for the statement associated with the given
|
|
|
|
/// single region.
|
|
|
|
virtual void EmitOMPSingleRegion(CodeGenFunction &CGF,
|
|
|
|
const std::function<void()> &SingleOpGen,
|
|
|
|
SourceLocation Loc);
|
|
|
|
|
2014-12-05 12:09:23 +08:00
|
|
|
/// \brief Emits explicit barrier for OpenMP threads.
|
|
|
|
/// \param IsExplicit true, if it is explicitly specified barrier.
|
2014-10-08 22:01:46 +08:00
|
|
|
///
|
|
|
|
virtual void EmitOMPBarrierCall(CodeGenFunction &CGF, SourceLocation Loc,
|
2014-12-05 12:09:23 +08:00
|
|
|
bool IsExplicit = true);
|
2014-10-13 16:23:51 +08:00
|
|
|
|
2014-12-15 15:07:06 +08:00
|
|
|
/// \brief Check if the specified \a ScheduleKind is static non-chunked.
|
|
|
|
/// This kind of worksharing directive is emitted without outer loop.
|
|
|
|
/// \param ScheduleKind Schedule kind specified in the 'schedule' clause.
|
|
|
|
/// \param Chunked True if chunk is specified in the clause.
|
|
|
|
///
|
|
|
|
virtual bool isStaticNonchunked(OpenMPScheduleClauseKind ScheduleKind,
|
|
|
|
bool Chunked) const;
|
|
|
|
|
2015-01-22 16:49:35 +08:00
|
|
|
/// \brief Check if the specified \a ScheduleKind is dynamic.
|
|
|
|
/// This kind of worksharing directive is emitted without outer loop.
|
|
|
|
/// \param ScheduleKind Schedule Kind specified in the 'schedule' clause.
|
|
|
|
///
|
|
|
|
virtual bool isDynamic(OpenMPScheduleClauseKind ScheduleKind) const;
|
|
|
|
|
2014-12-15 15:07:06 +08:00
|
|
|
/// \brief Call the appropriate runtime routine to initialize it before start
|
|
|
|
/// of loop.
|
|
|
|
///
|
|
|
|
/// Depending on the loop schedule, it is nesessary to call some runtime
|
|
|
|
/// routine before start of the OpenMP loop to get the loop upper / lower
|
|
|
|
/// bounds \a LB and \a UB and stride \a ST.
|
|
|
|
///
|
|
|
|
/// \param CGF Reference to current CodeGenFunction.
|
|
|
|
/// \param Loc Clang source location.
|
2014-12-17 22:47:06 +08:00
|
|
|
/// \param SchedKind Schedule kind, specified by the 'schedule' clause.
|
2014-12-15 15:07:06 +08:00
|
|
|
/// \param IVSize Size of the iteration variable in bits.
|
|
|
|
/// \param IVSigned Sign of the interation variable.
|
|
|
|
/// \param IL Address of the output variable in which the flag of the
|
|
|
|
/// last iteration is returned.
|
|
|
|
/// \param LB Address of the output variable in which the lower iteration
|
|
|
|
/// number is returned.
|
|
|
|
/// \param UB Address of the output variable in which the upper iteration
|
|
|
|
/// number is returned.
|
|
|
|
/// \param ST Address of the output variable in which the stride value is
|
|
|
|
/// returned nesessary to generated the static_chunked scheduled loop.
|
|
|
|
/// \param Chunk Value of the chunk for the static_chunked scheduled loop.
|
|
|
|
/// For the default (nullptr) value, the chunk 1 will be used.
|
|
|
|
///
|
|
|
|
virtual void EmitOMPForInit(CodeGenFunction &CGF, SourceLocation Loc,
|
|
|
|
OpenMPScheduleClauseKind SchedKind,
|
|
|
|
unsigned IVSize, bool IVSigned, llvm::Value *IL,
|
|
|
|
llvm::Value *LB, llvm::Value *UB, llvm::Value *ST,
|
|
|
|
llvm::Value *Chunk = nullptr);
|
|
|
|
|
|
|
|
/// \brief Call the appropriate runtime routine to notify that we finished
|
|
|
|
/// all the work with current loop.
|
|
|
|
///
|
|
|
|
/// \param CGF Reference to current CodeGenFunction.
|
|
|
|
/// \param Loc Clang source location.
|
|
|
|
/// \param ScheduleKind Schedule kind, specified by the 'schedule' clause.
|
|
|
|
///
|
|
|
|
virtual void EmitOMPForFinish(CodeGenFunction &CGF, SourceLocation Loc,
|
|
|
|
OpenMPScheduleClauseKind ScheduleKind);
|
|
|
|
|
2014-10-13 16:23:51 +08:00
|
|
|
/// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
|
|
|
|
/// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
|
|
|
|
/// clause.
|
|
|
|
/// \param NumThreads An integer value of threads.
|
|
|
|
virtual void EmitOMPNumThreadsClause(CodeGenFunction &CGF,
|
|
|
|
llvm::Value *NumThreads,
|
|
|
|
SourceLocation Loc);
|
2014-11-11 12:05:39 +08:00
|
|
|
|
|
|
|
/// \brief Returns address of the threadprivate variable for the current
|
|
|
|
/// thread.
|
2014-11-11 15:58:06 +08:00
|
|
|
/// \param VD Threadprivate variable.
|
2014-11-11 12:05:39 +08:00
|
|
|
/// \param VDAddr Address of the global variable \a VD.
|
|
|
|
/// \param Loc Location of the reference to threadprivate var.
|
|
|
|
/// \return Address of the threadprivate variable for the current thread.
|
|
|
|
virtual llvm::Value *getOMPAddrOfThreadPrivate(CodeGenFunction &CGF,
|
|
|
|
const VarDecl *VD,
|
|
|
|
llvm::Value *VDAddr,
|
|
|
|
SourceLocation Loc);
|
|
|
|
|
|
|
|
/// \brief Emit a code for initialization of threadprivate variable. It emits
|
|
|
|
/// a call to runtime library which adds initial value to the newly created
|
|
|
|
/// threadprivate variable (if it is not constant) and registers destructor
|
|
|
|
/// for the variable (if any).
|
|
|
|
/// \param VD Threadprivate variable.
|
|
|
|
/// \param VDAddr Address of the global variable \a VD.
|
|
|
|
/// \param Loc Location of threadprivate declaration.
|
|
|
|
/// \param PerformInit true if initialization expression is not constant.
|
|
|
|
virtual llvm::Function *
|
|
|
|
EmitOMPThreadPrivateVarDefinition(const VarDecl *VD, llvm::Value *VDAddr,
|
|
|
|
SourceLocation Loc, bool PerformInit,
|
|
|
|
CodeGenFunction *CGF = nullptr);
|
2014-11-20 12:34:54 +08:00
|
|
|
|
|
|
|
/// \brief Emit flush of the variables specified in 'omp flush' directive.
|
|
|
|
/// \param Vars List of variables to flush.
|
|
|
|
virtual void EmitOMPFlush(CodeGenFunction &CGF, ArrayRef<const Expr *> Vars,
|
|
|
|
SourceLocation Loc);
|
2014-05-06 18:08:46 +08:00
|
|
|
};
|
2014-06-18 15:08:49 +08:00
|
|
|
} // namespace CodeGen
|
|
|
|
} // namespace clang
|
2014-05-06 18:08:46 +08:00
|
|
|
|
|
|
|
#endif
|