1 //===----- CGOpenMPRuntimeNVPTX.h - Interface to OpenMP NVPTX Runtimes ----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This provides a class for OpenMP runtime code generation specialized to NVPTX
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H
16 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H
18 #include "CGOpenMPRuntime.h"
19 #include "CodeGenFunction.h"
20 #include "clang/AST/StmtOpenMP.h"
21 #include "llvm/IR/CallSite.h"
26 class CGOpenMPRuntimeNVPTX : public CGOpenMPRuntime {
28 // Parallel outlined function work for workers to execute.
29 llvm::SmallVector<llvm::Function *, 16> Work;
31 struct EntryFunctionState {
32 llvm::BasicBlock *ExitBB = nullptr;
35 class WorkerFunctionState {
37 llvm::Function *WorkerFn;
38 const CGFunctionInfo *CGFI;
40 WorkerFunctionState(CodeGenModule &CGM);
43 void createWorkerFunction(CodeGenModule &CGM);
46 bool isInSpmdExecutionMode() const;
48 /// \brief Emit the worker function for the current target region.
49 void emitWorkerFunction(WorkerFunctionState &WST);
51 /// \brief Helper for worker function. Emit body of worker loop.
52 void emitWorkerLoop(CodeGenFunction &CGF, WorkerFunctionState &WST);
54 /// \brief Helper for generic target entry function. Guide the master and
55 /// worker threads to their respective locations.
56 void emitGenericEntryHeader(CodeGenFunction &CGF, EntryFunctionState &EST,
57 WorkerFunctionState &WST);
59 /// \brief Signal termination of OMP execution for generic target entry
61 void emitGenericEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST);
63 /// \brief Helper for Spmd mode target directive's entry function.
64 void emitSpmdEntryHeader(CodeGenFunction &CGF, EntryFunctionState &EST,
65 const OMPExecutableDirective &D);
67 /// \brief Signal termination of Spmd mode execution.
68 void emitSpmdEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST);
71 // Base class overrides.
74 /// \brief Creates offloading entry for the provided entry ID \a ID,
75 /// address \a Addr, size \a Size, and flags \a Flags.
76 void createOffloadEntry(llvm::Constant *ID, llvm::Constant *Addr,
77 uint64_t Size, int32_t Flags = 0) override;
79 /// \brief Emit outlined function specialized for the Fork-Join
80 /// programming model for applicable target directives on the NVPTX device.
81 /// \param D Directive to emit.
82 /// \param ParentName Name of the function that encloses the target region.
83 /// \param OutlinedFn Outlined function value to be defined by this call.
84 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
85 /// \param IsOffloadEntry True if the outlined function is an offload entry.
86 /// An outlined function may not be an entry if, e.g. the if clause always
87 /// evaluates to false.
88 void emitGenericKernel(const OMPExecutableDirective &D, StringRef ParentName,
89 llvm::Function *&OutlinedFn,
90 llvm::Constant *&OutlinedFnID, bool IsOffloadEntry,
91 const RegionCodeGenTy &CodeGen);
93 /// \brief Emit outlined function specialized for the Single Program
94 /// Multiple Data programming model for applicable target directives on the
96 /// \param D Directive to emit.
97 /// \param ParentName Name of the function that encloses the target region.
98 /// \param OutlinedFn Outlined function value to be defined by this call.
99 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
100 /// \param IsOffloadEntry True if the outlined function is an offload entry.
101 /// \param CodeGen Object containing the target statements.
102 /// An outlined function may not be an entry if, e.g. the if clause always
103 /// evaluates to false.
104 void emitSpmdKernel(const OMPExecutableDirective &D, StringRef ParentName,
105 llvm::Function *&OutlinedFn,
106 llvm::Constant *&OutlinedFnID, bool IsOffloadEntry,
107 const RegionCodeGenTy &CodeGen);
109 /// \brief Emit outlined function for 'target' directive on the NVPTX
111 /// \param D Directive to emit.
112 /// \param ParentName Name of the function that encloses the target region.
113 /// \param OutlinedFn Outlined function value to be defined by this call.
114 /// \param OutlinedFnID Outlined function ID value to be defined by this call.
115 /// \param IsOffloadEntry True if the outlined function is an offload entry.
116 /// An outlined function may not be an entry if, e.g. the if clause always
117 /// evaluates to false.
118 void emitTargetOutlinedFunction(const OMPExecutableDirective &D,
119 StringRef ParentName,
120 llvm::Function *&OutlinedFn,
121 llvm::Constant *&OutlinedFnID,
123 const RegionCodeGenTy &CodeGen) override;
125 /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
126 /// variables captured in a record which address is stored in \a
128 /// This call is for the Generic Execution Mode.
129 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
130 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
131 /// \param CapturedVars A pointer to the record with the references to
132 /// variables used in \a OutlinedFn function.
133 /// \param IfCond Condition in the associated 'if' clause, if it was
134 /// specified, nullptr otherwise.
135 void emitGenericParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
136 llvm::Value *OutlinedFn,
137 ArrayRef<llvm::Value *> CapturedVars,
140 /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
141 /// variables captured in a record which address is stored in \a
143 /// This call is for a parallel directive within an SPMD target directive.
144 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
145 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
146 /// \param CapturedVars A pointer to the record with the references to
147 /// variables used in \a OutlinedFn function.
148 /// \param IfCond Condition in the associated 'if' clause, if it was
149 /// specified, nullptr otherwise.
151 void emitSpmdParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
152 llvm::Value *OutlinedFn,
153 ArrayRef<llvm::Value *> CapturedVars,
157 /// \brief Get the function name of an outlined region.
158 // The name can be customized depending on the target.
160 StringRef getOutlinedHelperName() const override {
161 return "__omp_outlined__";
165 explicit CGOpenMPRuntimeNVPTX(CodeGenModule &CGM);
167 /// \brief Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32
168 /// global_tid, int proc_bind) to generate code for 'proc_bind' clause.
169 virtual void emitProcBindClause(CodeGenFunction &CGF,
170 OpenMPProcBindClauseKind ProcBind,
171 SourceLocation Loc) override;
173 /// \brief Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32
174 /// global_tid, kmp_int32 num_threads) to generate code for 'num_threads'
176 /// \param NumThreads An integer value of threads.
177 virtual void emitNumThreadsClause(CodeGenFunction &CGF,
178 llvm::Value *NumThreads,
179 SourceLocation Loc) override;
181 /// \brief This function ought to emit, in the general case, a call to
182 // the openmp runtime kmpc_push_num_teams. In NVPTX backend it is not needed
183 // as these numbers are obtained through the PTX grid and block configuration.
184 /// \param NumTeams An integer expression of teams.
185 /// \param ThreadLimit An integer expression of threads.
186 void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams,
187 const Expr *ThreadLimit, SourceLocation Loc) override;
189 /// \brief Emits inlined function for the specified OpenMP parallel
191 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
192 /// kmp_int32 BoundID, struct context_vars*).
193 /// \param D OpenMP directive.
194 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
195 /// \param InnermostKind Kind of innermost directive (for simple directives it
196 /// is a directive itself, for combined - its innermost directive).
197 /// \param CodeGen Code generation sequence for the \a D directive.
199 emitParallelOutlinedFunction(const OMPExecutableDirective &D,
200 const VarDecl *ThreadIDVar,
201 OpenMPDirectiveKind InnermostKind,
202 const RegionCodeGenTy &CodeGen) override;
204 /// \brief Emits inlined function for the specified OpenMP teams
206 /// \a D. This outlined function has type void(*)(kmp_int32 *ThreadID,
207 /// kmp_int32 BoundID, struct context_vars*).
208 /// \param D OpenMP directive.
209 /// \param ThreadIDVar Variable for thread id in the current OpenMP region.
210 /// \param InnermostKind Kind of innermost directive (for simple directives it
211 /// is a directive itself, for combined - its innermost directive).
212 /// \param CodeGen Code generation sequence for the \a D directive.
214 emitTeamsOutlinedFunction(const OMPExecutableDirective &D,
215 const VarDecl *ThreadIDVar,
216 OpenMPDirectiveKind InnermostKind,
217 const RegionCodeGenTy &CodeGen) override;
219 /// \brief Emits code for teams call of the \a OutlinedFn with
220 /// variables captured in a record which address is stored in \a
222 /// \param OutlinedFn Outlined function to be run by team masters. Type of
223 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
224 /// \param CapturedVars A pointer to the record with the references to
225 /// variables used in \a OutlinedFn function.
227 void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D,
228 SourceLocation Loc, llvm::Value *OutlinedFn,
229 ArrayRef<llvm::Value *> CapturedVars) override;
231 /// \brief Emits code for parallel or serial call of the \a OutlinedFn with
232 /// variables captured in a record which address is stored in \a
234 /// \param OutlinedFn Outlined function to be run in parallel threads. Type of
235 /// this function is void(*)(kmp_int32 *, kmp_int32, struct context_vars*).
236 /// \param CapturedVars A pointer to the record with the references to
237 /// variables used in \a OutlinedFn function.
238 /// \param IfCond Condition in the associated 'if' clause, if it was
239 /// specified, nullptr otherwise.
240 void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
241 llvm::Value *OutlinedFn,
242 ArrayRef<llvm::Value *> CapturedVars,
243 const Expr *IfCond) override;
245 /// Emit a code for reduction clause.
247 /// \param Privates List of private copies for original reduction arguments.
248 /// \param LHSExprs List of LHS in \a ReductionOps reduction operations.
249 /// \param RHSExprs List of RHS in \a ReductionOps reduction operations.
250 /// \param ReductionOps List of reduction operations in form 'LHS binop RHS'
251 /// or 'operator binop(LHS, RHS)'.
252 /// \param Options List of options for reduction codegen:
253 /// WithNowait true if parent directive has also nowait clause, false
255 /// SimpleReduction Emit reduction operation only. Used for omp simd
256 /// directive on the host.
257 /// ReductionKind The kind of reduction to perform.
258 virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc,
259 ArrayRef<const Expr *> Privates,
260 ArrayRef<const Expr *> LHSExprs,
261 ArrayRef<const Expr *> RHSExprs,
262 ArrayRef<const Expr *> ReductionOps,
263 ReductionOptionsTy Options) override;
265 /// Returns specified OpenMP runtime function for the current OpenMP
266 /// implementation. Specialized for the NVPTX device.
267 /// \param Function OpenMP runtime function.
268 /// \return Specified function.
269 llvm::Constant *createNVPTXRuntimeFunction(unsigned Function);
271 /// Target codegen is specialized based on two programming models: the
272 /// 'generic' fork-join model of OpenMP, and a more GPU efficient 'spmd'
273 /// model for constructs like 'target parallel' that support it.
275 /// Single Program Multiple Data.
277 /// Generic codegen to support fork-join model.
283 // Track the execution mode when codegening directives within a target
284 // region. The appropriate mode (generic/spmd) is set on entry to the
285 // target region and used by containing directives such as 'parallel'
286 // to emit optimized code.
287 ExecutionMode CurrentExecutionMode;
290 } // CodeGen namespace.
291 } // clang namespace.
293 #endif // LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H