clang  5.0.0
CGOpenMPRuntimeNVPTX.h
Go to the documentation of this file.
1 //===----- CGOpenMPRuntimeNVPTX.h - Interface to OpenMP NVPTX Runtimes ----===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This provides a class for OpenMP runtime code generation specialized to NVPTX
11 // targets.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H
16 #define LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H
17 
18 #include "CGOpenMPRuntime.h"
19 #include "CodeGenFunction.h"
20 #include "clang/AST/StmtOpenMP.h"
21 #include "llvm/IR/CallSite.h"
22 
23 namespace clang {
24 namespace CodeGen {
25 
27 private:
28  // Parallel outlined function work for workers to execute.
30 
31  struct EntryFunctionState {
32  llvm::BasicBlock *ExitBB = nullptr;
33  };
34 
35  class WorkerFunctionState {
36  public:
37  llvm::Function *WorkerFn;
38  const CGFunctionInfo *CGFI;
39 
40  WorkerFunctionState(CodeGenModule &CGM);
41 
42  private:
43  void createWorkerFunction(CodeGenModule &CGM);
44  };
45 
46  bool isInSpmdExecutionMode() const;
47 
48  /// \brief Emit the worker function for the current target region.
49  void emitWorkerFunction(WorkerFunctionState &WST);
50 
51  /// \brief Helper for worker function. Emit body of worker loop.
52  void emitWorkerLoop(CodeGenFunction &CGF, WorkerFunctionState &WST);
53 
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);
58 
59  /// \brief Signal termination of OMP execution for generic target entry
60  /// function.
61  void emitGenericEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST);
62 
63  /// \brief Helper for Spmd mode target directive's entry function.
64  void emitSpmdEntryHeader(CodeGenFunction &CGF, EntryFunctionState &EST,
65  const OMPExecutableDirective &D);
66 
67  /// \brief Signal termination of Spmd mode execution.
68  void emitSpmdEntryFooter(CodeGenFunction &CGF, EntryFunctionState &EST);
69 
70  //
71  // Base class overrides.
72  //
73 
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;
78 
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);
92 
93  /// \brief Emit outlined function specialized for the Single Program
94  /// Multiple Data programming model for applicable target directives on the
95  /// NVPTX device.
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);
108 
109  /// \brief Emit outlined function for 'target' directive on the NVPTX
110  /// device.
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,
122  bool IsOffloadEntry,
123  const RegionCodeGenTy &CodeGen) override;
124 
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
127  /// CapturedStruct.
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,
138  const Expr *IfCond);
139 
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
142  /// CapturedStruct.
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.
150  ///
151  void emitSpmdParallelCall(CodeGenFunction &CGF, SourceLocation Loc,
152  llvm::Value *OutlinedFn,
153  ArrayRef<llvm::Value *> CapturedVars,
154  const Expr *IfCond);
155 
156 protected:
157  /// \brief Get the function name of an outlined region.
158  // The name can be customized depending on the target.
159  //
160  StringRef getOutlinedHelperName() const override {
161  return "__omp_outlined__";
162  }
163 
164 public:
166 
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;
172 
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'
175  /// clause.
176  /// \param NumThreads An integer value of threads.
177  virtual void emitNumThreadsClause(CodeGenFunction &CGF,
178  llvm::Value *NumThreads,
179  SourceLocation Loc) override;
180 
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;
188 
189  /// \brief Emits inlined function for the specified OpenMP parallel
190  // directive.
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.
198  llvm::Value *
200  const VarDecl *ThreadIDVar,
201  OpenMPDirectiveKind InnermostKind,
202  const RegionCodeGenTy &CodeGen) override;
203 
204  /// \brief Emits inlined function for the specified OpenMP teams
205  // directive.
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.
213  llvm::Value *
215  const VarDecl *ThreadIDVar,
216  OpenMPDirectiveKind InnermostKind,
217  const RegionCodeGenTy &CodeGen) override;
218 
219  /// \brief Emits code for teams call of the \a OutlinedFn with
220  /// variables captured in a record which address is stored in \a
221  /// CapturedStruct.
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.
226  ///
228  SourceLocation Loc, llvm::Value *OutlinedFn,
229  ArrayRef<llvm::Value *> CapturedVars) override;
230 
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
233  /// CapturedStruct.
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.
241  llvm::Value *OutlinedFn,
242  ArrayRef<llvm::Value *> CapturedVars,
243  const Expr *IfCond) override;
244 
245  /// Emit a code for reduction clause.
246  ///
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
254  /// otherwise.
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,
260  ArrayRef<const Expr *> LHSExprs,
261  ArrayRef<const Expr *> RHSExprs,
262  ArrayRef<const Expr *> ReductionOps,
263  ReductionOptionsTy Options) override;
264 
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);
270 
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.
280  };
281 
282 private:
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;
288 };
289 
290 } // CodeGen namespace.
291 } // clang namespace.
292 
293 #endif // LLVM_CLANG_LIB_CODEGEN_CGOPENMPRUNTIMENVPTX_H
Generic codegen to support fork-join model.
llvm::Value * emitParallelOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits inlined function for the specified OpenMP parallel.
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:758
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
virtual void emitNumThreadsClause(CodeGenFunction &CGF, llvm::Value *NumThreads, SourceLocation Loc) override
Emits call to void __kmpc_push_num_threads(ident_t *loc, kmp_int32 global_tid, kmp_int32 num_threads)...
void emitNumTeamsClause(CodeGenFunction &CGF, const Expr *NumTeams, const Expr *ThreadLimit, SourceLocation Loc) override
This function ought to emit, in the general case, a call to.
Expr - This represents one expression.
Definition: Expr.h:105
OpenMPProcBindClauseKind
OpenMP attributes for 'proc_bind' clause.
Definition: OpenMPKinds.h:51
virtual void emitReduction(CodeGenFunction &CGF, SourceLocation Loc, ArrayRef< const Expr * > Privates, ArrayRef< const Expr * > LHSExprs, ArrayRef< const Expr * > RHSExprs, ArrayRef< const Expr * > ReductionOps, ReductionOptionsTy Options) override
Emit a code for reduction clause.
llvm::Value * emitTeamsOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits inlined function for the specified OpenMP teams.
const MatchFinder::MatchFinderOptions & Options
Encodes a location in the source.
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
const std::string ID
StringRef getOutlinedHelperName() const override
Get the function name of an outlined region.
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
void emitParallelCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars, const Expr *IfCond) override
Emits code for parallel or serial call of the OutlinedFn with variables captured in a record which ad...
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
llvm::Constant * createNVPTXRuntimeFunction(unsigned Function)
Returns specified OpenMP runtime function for the current OpenMP implementation.
This file defines OpenMP AST classes for executable directives and clauses.
ExecutionMode
Target codegen is specialized based on two programming models: the 'generic' fork-join model of OpenM...
Privates[]
Gets the list of initial values for linear variables.
Definition: OpenMPClause.h:136
virtual void emitProcBindClause(CodeGenFunction &CGF, OpenMPProcBindClauseKind ProcBind, SourceLocation Loc) override
Emit call to void __kmpc_push_proc_bind(ident_t *loc, kmp_int32 global_tid, int proc_bind) to generat...
void emitTeamsCall(CodeGenFunction &CGF, const OMPExecutableDirective &D, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value * > CapturedVars) override
Emits code for teams call of the OutlinedFn with variables captured in a record which address is stor...