clang  6.0.0svn
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.
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  /// Translates the native parameter of outlined function if this is required
272  /// for target.
273  /// \param FD Field decl from captured record for the paramater.
274  /// \param NativeParam Parameter itself.
275  const VarDecl *translateParameter(const FieldDecl *FD,
276  const VarDecl *NativeParam) const override;
277 
278  /// Gets the address of the native argument basing on the address of the
279  /// target-specific parameter.
280  /// \param NativeParam Parameter itself.
281  /// \param TargetParam Corresponding target-specific parameter.
282  Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam,
283  const VarDecl *TargetParam) const override;
284 
285  /// Emits call of the outlined function with the provided arguments,
286  /// translating these arguments to correct target-specific arguments.
288  CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn,
289  ArrayRef<llvm::Value *> Args = llvm::None) const override;
290 
291  /// Target codegen is specialized based on two programming models: the
292  /// 'generic' fork-join model of OpenMP, and a more GPU efficient 'spmd'
293  /// model for constructs like 'target parallel' that support it.
295  /// Single Program Multiple Data.
297  /// Generic codegen to support fork-join model.
300  };
301 
302 private:
303  // Track the execution mode when codegening directives within a target
304  // region. The appropriate mode (generic/spmd) is set on entry to the
305  // target region and used by containing directives such as 'parallel'
306  // to emit optimized code.
307  ExecutionMode CurrentExecutionMode;
308 
309  /// Map between an outlined function and its wrapper.
310  llvm::DenseMap<llvm::Function *, llvm::Function *> WrapperFunctionsMap;
311 
312  /// Emit function which wraps the outline parallel region
313  /// and controls the parameters which are passed to this function.
314  /// The wrapper ensures that the outlined function is called
315  /// with the correct arguments when data is shared.
316  llvm::Function *
317  createDataSharingWrapper(llvm::Function *OutlinedParallelFn,
318  const OMPExecutableDirective &D);
319 };
320 
321 } // CodeGen namespace.
322 } // clang namespace.
323 
324 #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.
Address getParameterAddress(CodeGenFunction &CGF, const VarDecl *NativeParam, const VarDecl *TargetParam) const override
Gets the address of the native argument basing on the address of the target-specific parameter...
VarDecl - An instance of this class is created to represent a variable declaration or definition...
Definition: Decl.h:807
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
FieldDecl - An instance of this class is created by Sema::ActOnField to represent a member of a struc...
Definition: Decl.h:2461
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.
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...
Expr - This represents one expression.
Definition: Expr.h:106
OpenMPProcBindClauseKind
OpenMP attributes for &#39;proc_bind&#39; clause.
Definition: OpenMPKinds.h:51
llvm::Value * emitTeamsOutlinedFunction(const OMPExecutableDirective &D, const VarDecl *ThreadIDVar, OpenMPDirectiveKind InnermostKind, const RegionCodeGenTy &CodeGen) override
Emits inlined function for the specified OpenMP teams.
void emitOutlinedFunctionCall(CodeGenFunction &CGF, SourceLocation Loc, llvm::Value *OutlinedFn, ArrayRef< llvm::Value *> Args=llvm::None) const override
Emits call of the outlined function with the provided arguments, translating these arguments to corre...
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...
Encodes a location in the source.
This is a basic class for representing single OpenMP executable directive.
Definition: StmtOpenMP.h:33
StringRef getOutlinedHelperName() const override
Get the function name of an outlined region.
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
An aligned address.
Definition: Address.h:25
const VarDecl * translateParameter(const FieldDecl *FD, const VarDecl *NativeParam) const override
Translates the native parameter of outlined function if this is required for target.
CGFunctionInfo - Class to encapsulate the information about a function definition.
This class organizes the cross-function state that is used while generating LLVM code.
Dataflow Directional Tag Classes.
Class provides a way to call simple version of codegen for OpenMP region, or an advanced with possibl...
virtual void emitTargetOutlinedFunction(const OMPExecutableDirective &D, StringRef ParentName, llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID, bool IsOffloadEntry, const RegionCodeGenTy &CodeGen)
Emit outilined function for &#39;target&#39; directive.
llvm::Constant * createNVPTXRuntimeFunction(unsigned Function)
Returns specified OpenMP runtime function for the current OpenMP implementation.
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.
This file defines OpenMP AST classes for executable directives and clauses.
ExecutionMode
Target codegen is specialized based on two programming models: the &#39;generic&#39; 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...