Support taskwait with dependencies in/out/inout

Closes llvm#15

Author: mikaoP

clang/include/clang/AST/StmtOmpSs.h

@@ -236,32 +236,39 @@ class OSSTaskwaitDirective : public OSSExecutableDirective {
   ///
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending location of the directive.
+  /// \param NumClauses Number of clauses.
   ///
-  OSSTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc)
+  OSSTaskwaitDirective(SourceLocation StartLoc, SourceLocation EndLoc, unsigned NumClauses)
       : OSSExecutableDirective(this, OSSTaskwaitDirectiveClass, OSSD_taskwait,
-                               StartLoc, EndLoc, 0, 0) {}
+                               StartLoc, EndLoc, NumClauses, 0) {}
 
   /// Build an empty directive.
   ///
-  explicit OSSTaskwaitDirective()
+  /// \param NumClauses Number of clauses.
+  ///
+  explicit OSSTaskwaitDirective(unsigned NumClauses)
       : OSSExecutableDirective(this, OSSTaskwaitDirectiveClass, OSSD_taskwait,
-                               SourceLocation(), SourceLocation(), 0, 0) {}
+                               SourceLocation(), SourceLocation(), NumClauses, 0) {}
 
 public:
   /// Creates directive.
   ///
   /// \param C AST context.
   /// \param StartLoc Starting location of the directive kind.
   /// \param EndLoc Ending Location of the directive.
+  /// \param Clauses List of clauses.
   ///
   static OSSTaskwaitDirective *
-  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc);
+  Create(const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
+         ArrayRef<OSSClause *> Clauses);
 
   /// Creates an empty directive.
   ///
   /// \param C AST context.
+  /// \param NumClauses Number of clauses.
   ///
-  static OSSTaskwaitDirective *CreateEmpty(const ASTContext &C, EmptyShell);
+  static OSSTaskwaitDirective *CreateEmpty(const ASTContext &C, unsigned NumClauses,
+                                           EmptyShell);
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == OSSTaskwaitDirectiveClass;

clang/include/clang/Basic/OmpSsKinds.def

@@ -24,6 +24,9 @@
 #ifndef OMPSS_TASK_CLAUSE
 #  define OMPSS_TASK_CLAUSE(Name)
 #endif
+#ifndef OMPSS_TASKWAIT_CLAUSE
+#  define OMPSS_TASKWAIT_CLAUSE(Name)
+#endif
 #ifndef OMPSS_DECLARE_TASK_CLAUSE
 #  define OMPSS_DECLARE_TASK_CLAUSE(Name)
 #endif
@@ -105,6 +108,12 @@ OMPSS_TASK_CLAUSE(weakinout)
 OMPSS_TASK_CLAUSE(weakcommutative)
 OMPSS_TASK_CLAUSE(weakreduction)
 
+// Clauses allowed for OmpSs directive 'taskwait'.
+OMPSS_TASKWAIT_CLAUSE(depend)
+OMPSS_TASKWAIT_CLAUSE(in)
+OMPSS_TASKWAIT_CLAUSE(out)
+OMPSS_TASKWAIT_CLAUSE(inout)
+
 // Clauses allowed for OmpSs directive 'task' declaration/outline.
 OMPSS_DECLARE_TASK_CLAUSE(if)
 OMPSS_DECLARE_TASK_CLAUSE(final)
@@ -128,4 +137,5 @@ OMPSS_DECLARE_TASK_CLAUSE(weakcommutative)
 #undef OMPSS_CLAUSE_ALIAS
 #undef OMPSS_CLAUSE
 #undef OMPSS_DECLARE_TASK_CLAUSE
+#undef OMPSS_TASKWAIT_CLAUSE
 #undef OMPSS_TASK_CLAUSE

clang/include/clang/Sema/Sema.h

@@ -10882,7 +10882,8 @@ class Sema final {
       OmpSsDirectiveKind Kind, Stmt *AStmt, SourceLocation StartLoc, SourceLocation EndLoc);
 
   /// Called on well-formed '\#pragma oss taskwait'.
-  StmtResult ActOnOmpSsTaskwaitDirective(SourceLocation StartLoc,
+  StmtResult ActOnOmpSsTaskwaitDirective(ArrayRef<OSSClause *> Clauses,
+                                         SourceLocation StartLoc,
                                          SourceLocation EndLoc);
 
   /// Called on well-formed '\#pragma omp task' after parsing of the

clang/lib/AST/StmtOmpSs.cpp

@@ -23,18 +23,23 @@ void OSSExecutableDirective::setClauses(ArrayRef<OSSClause *> Clauses) {
   std::copy(Clauses.begin(), Clauses.end(), getClauses().begin());
 }
 
-OSSTaskwaitDirective *OSSTaskwaitDirective::Create(const ASTContext &C,
-                                                   SourceLocation StartLoc,
-                                                   SourceLocation EndLoc) {
-  void *Mem = C.Allocate(sizeof(OSSTaskwaitDirective));
-  OSSTaskwaitDirective *Dir = new (Mem) OSSTaskwaitDirective(StartLoc, EndLoc);
+OSSTaskwaitDirective *
+OSSTaskwaitDirective::Create(const ASTContext &C, SourceLocation StartLoc,
+                             SourceLocation EndLoc, ArrayRef<OSSClause *> Clauses) {
+  unsigned Size = llvm::alignTo(sizeof(OSSTaskwaitDirective), alignof(OSSClause *));
+  void *Mem = C.Allocate(Size + sizeof(OSSClause *) * Clauses.size());
+  OSSTaskwaitDirective *Dir =
+      new (Mem) OSSTaskwaitDirective(StartLoc, EndLoc, Clauses.size());
+  Dir->setClauses(Clauses);
   return Dir;
 }
 
 OSSTaskwaitDirective *OSSTaskwaitDirective::CreateEmpty(const ASTContext &C,
+                                                        unsigned NumClauses,
                                                         EmptyShell) {
-  void *Mem = C.Allocate(sizeof(OSSTaskwaitDirective));
-  return new (Mem) OSSTaskwaitDirective();
+  unsigned Size = llvm::alignTo(sizeof(OSSTaskwaitDirective), alignof(OSSClause *));
+  void *Mem = C.Allocate(Size + sizeof(OSSClause *) * NumClauses);
+  return new (Mem) OSSTaskwaitDirective(NumClauses);
 }
 
 OSSTaskDirective *

clang/lib/Basic/OmpSsKinds.cpp

@@ -181,6 +181,15 @@ bool clang::isAllowedClauseForDirective(OmpSsDirectiveKind DKind,
     }
     break;
   case OSSD_taskwait:
+    switch (CKind) {
+#define OMPSS_TASKWAIT_CLAUSE(Name)                                           \
+  case OSSC_##Name:                                                            \
+    return true;
+#include "clang/Basic/OmpSsKinds.def"
+    default:
+      break;
+    }
+    break;
   case OSSD_declare_reduction:
   case OSSD_unknown:
     break;

clang/lib/CodeGen/CGOmpSsRuntime.cpp

@@ -1819,16 +1819,48 @@ void CGOmpSsRuntime::EmitReduction(
 }
 
 void CGOmpSsRuntime::emitTaskwaitCall(CodeGenFunction &CGF,
-                                      SourceLocation Loc) {
-  llvm::Function *Callee = CGM.getIntrinsic(llvm::Intrinsic::directive_marker);
-  CGF.Builder.CreateCall(
-      Callee, {},
-      {
-        llvm::OperandBundleDef(
-          std::string(getBundleStr(OSSB_directive)),
-          llvm::ConstantDataArray::getString(
-            CGM.getLLVMContext(), getBundleStr(OSSB_taskwait)))
-      });
+                                      SourceLocation Loc,
+                                      const OSSTaskDataTy &Data) {
+  if (Data.empty()) {
+    // Regular taskwait
+    llvm::Function *Callee = CGM.getIntrinsic(llvm::Intrinsic::directive_marker);
+    CGF.Builder.CreateCall(
+        Callee, {},
+        {
+          llvm::OperandBundleDef(
+            std::string(getBundleStr(OSSB_directive)),
+            llvm::ConstantDataArray::getString(
+              CGM.getLLVMContext(), getBundleStr(OSSB_taskwait)))
+        });
+  } else {
+    // taskwait with deps -> task with deps if(0)
+    llvm::Function *EntryCallee = CGM.getIntrinsic(llvm::Intrinsic::directive_region_entry);
+    llvm::Function *ExitCallee = CGM.getIntrinsic(llvm::Intrinsic::directive_region_exit);
+    SmallVector<llvm::OperandBundleDef, 8> TaskInfo;
+    TaskInfo.emplace_back(
+        getBundleStr(OSSB_directive),
+        llvm::ConstantDataArray::getString(CGM.getLLVMContext(), getBundleStr(OSSB_task)));
+
+    // Add if(0) flag
+    llvm::Type *Int1Ty = CGF.ConvertType(CGF.getContext().BoolTy);
+    TaskInfo.emplace_back(getBundleStr(OSSB_if), llvm::ConstantInt::getSigned(Int1Ty, 0));
+
+    // Push Task Stack
+    TaskStack.push_back(TaskContext());
+    CaptureMapStack.push_back(CaptureMapTy());
+
+    InTaskEmission = true;
+    EmitTaskData(CGF, Data, TaskInfo);
+    InTaskEmission = false;
+
+    llvm::Instruction *Result =
+      CGF.Builder.CreateCall(EntryCallee, {}, llvm::makeArrayRef(TaskInfo));
+    CGF.Builder.CreateCall(ExitCallee, Result);
+
+    // Pop Task Stack
+    TaskStack.pop_back();
+    CaptureMapStack.pop_back();
+  }
 }
 
 // We're in task body context once we set InsertPt
@@ -1909,6 +1941,85 @@ static void EmitIfUsed(CodeGenFunction &CGF, llvm::BasicBlock *BB) {
   delete BB;
 }
 
+void CGOmpSsRuntime::EmitTaskData(
+    CodeGenFunction &CGF,
+    const OSSTaskDataTy &Data,
+    SmallVectorImpl<llvm::OperandBundleDef> &TaskInfo) {
+
+  SmallVector<llvm::Value*, 4> CapturedList;
+  for (const Expr *E : Data.DSAs.Shareds) {
+    EmitDSAShared(CGF, E, TaskInfo, CapturedList);
+  }
+  for (const OSSDSAPrivateDataTy &PDataTy : Data.DSAs.Privates) {
+    EmitDSAPrivate(CGF, PDataTy, TaskInfo, CapturedList);
+  }
+  for (const OSSDSAFirstprivateDataTy &FpDataTy : Data.DSAs.Firstprivates) {
+    EmitDSAFirstprivate(CGF, FpDataTy, TaskInfo, CapturedList);
+  }
+
+  if (Data.Cost) {
+    llvm::Value *V = CGF.EmitScalarExpr(Data.Cost);
+    CapturedList.push_back(V);
+    TaskInfo.emplace_back(getBundleStr(OSSB_cost), V);
+  }
+  if (Data.Priority) {
+    llvm::Value *V = CGF.EmitScalarExpr(Data.Priority);
+    CapturedList.push_back(V);
+    TaskInfo.emplace_back(getBundleStr(OSSB_priority), V);
+  }
+
+  if (!CapturedList.empty())
+    TaskInfo.emplace_back(getBundleStr(OSSB_captured), CapturedList);
+
+  for (const OSSDepDataTy &Dep : Data.Deps.Ins) {
+    EmitDependency(getBundleStr(OSSB_in), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.Outs) {
+    EmitDependency(getBundleStr(OSSB_out), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.Inouts) {
+    EmitDependency(getBundleStr(OSSB_inout), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.Concurrents) {
+    EmitDependency(getBundleStr(OSSB_concurrent), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.Commutatives) {
+    EmitDependency(getBundleStr(OSSB_commutative), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.WeakIns) {
+    EmitDependency(getBundleStr(OSSB_weakin), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.WeakOuts) {
+    EmitDependency(getBundleStr(OSSB_weakout), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.WeakInouts) {
+    EmitDependency(getBundleStr(OSSB_weakinout), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.WeakConcurrents) {
+    EmitDependency(getBundleStr(OSSB_weakconcurrent), CGF, Dep, TaskInfo);
+  }
+  for (const OSSDepDataTy &Dep : Data.Deps.WeakCommutatives) {
+    EmitDependency(getBundleStr(OSSB_weakcommutative), CGF, Dep, TaskInfo);
+  }
+  for (const OSSReductionDataTy &Red : Data.Reductions.RedList) {
+    EmitReduction(getBundleStr(OSSB_reduction),
+                  getBundleStr(OSSB_redinit),
+                  getBundleStr(OSSB_redcomb),
+                  CGF, Red, TaskInfo);
+  }
+  for (const OSSReductionDataTy &Red : Data.Reductions.WeakRedList) {
+    EmitReduction(getBundleStr(OSSB_weakreduction),
+                  getBundleStr(OSSB_redinit),
+                  getBundleStr(OSSB_redcomb),
+                  CGF, Red, TaskInfo);
+  }
+
+  if (Data.If)
+    TaskInfo.emplace_back(getBundleStr(OSSB_if), CGF.EvaluateExprAsBool(Data.If));
+  if (Data.Final)
+    TaskInfo.emplace_back(getBundleStr(OSSB_final), CGF.EvaluateExprAsBool(Data.Final));
+}
+
 RValue CGOmpSsRuntime::emitTaskFunction(CodeGenFunction &CGF,
                                         const FunctionDecl *FD,
                                         const CallExpr *CE,
@@ -2215,90 +2326,17 @@ void CGOmpSsRuntime::emitTaskCall(CodeGenFunction &CGF,
       getBundleStr(OSSB_directive),
       llvm::ConstantDataArray::getString(CGM.getLLVMContext(), getBundleStr(OSSB_task)));
 
-  SmallVector<llvm::Value*, 4> CapturedList;
-
+  // Push Task Stack
   TaskStack.push_back(TaskContext());
   CaptureMapStack.push_back(CaptureMapTy());
 
   InTaskEmission = true;
-  for (const Expr *E : Data.DSAs.Shareds) {
-    EmitDSAShared(CGF, E, TaskInfo, CapturedList);
-  }
-  for (const OSSDSAPrivateDataTy &PDataTy : Data.DSAs.Privates) {
-    EmitDSAPrivate(CGF, PDataTy, TaskInfo, CapturedList);
-  }
-  for (const OSSDSAFirstprivateDataTy &FpDataTy : Data.DSAs.Firstprivates) {
-    EmitDSAFirstprivate(CGF, FpDataTy, TaskInfo, CapturedList);
-  }
-
-  if (Data.Cost) {
-    llvm::Value *V = CGF.EmitScalarExpr(Data.Cost);
-    CapturedList.push_back(V);
-    TaskInfo.emplace_back(getBundleStr(OSSB_cost), V);
-  }
-  if (Data.Priority) {
-    llvm::Value *V = CGF.EmitScalarExpr(Data.Priority);
-    CapturedList.push_back(V);
-    TaskInfo.emplace_back(getBundleStr(OSSB_priority), V);
-  }
-
-  if (!CapturedList.empty())
-    TaskInfo.emplace_back(getBundleStr(OSSB_captured), CapturedList);
-
-  for (const OSSDepDataTy &Dep : Data.Deps.Ins) {
-    EmitDependency(getBundleStr(OSSB_in), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.Outs) {
-    EmitDependency(getBundleStr(OSSB_out), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.Inouts) {
-    EmitDependency(getBundleStr(OSSB_inout), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.Concurrents) {
-    EmitDependency(getBundleStr(OSSB_concurrent), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.Commutatives) {
-    EmitDependency(getBundleStr(OSSB_commutative), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.WeakIns) {
-    EmitDependency(getBundleStr(OSSB_weakin), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.WeakOuts) {
-    EmitDependency(getBundleStr(OSSB_weakout), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.WeakInouts) {
-    EmitDependency(getBundleStr(OSSB_weakinout), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.WeakConcurrents) {
-    EmitDependency(getBundleStr(OSSB_weakconcurrent), CGF, Dep, TaskInfo);
-  }
-  for (const OSSDepDataTy &Dep : Data.Deps.WeakCommutatives) {
-    EmitDependency(getBundleStr(OSSB_weakcommutative), CGF, Dep, TaskInfo);
-  }
-  for (const OSSReductionDataTy &Red : Data.Reductions.RedList) {
-    EmitReduction(getBundleStr(OSSB_reduction),
-                  getBundleStr(OSSB_redinit),
-                  getBundleStr(OSSB_redcomb),
-                  CGF, Red, TaskInfo);
-  }
-  for (const OSSReductionDataTy &Red : Data.Reductions.WeakRedList) {
-    EmitReduction(getBundleStr(OSSB_weakreduction),
-                  getBundleStr(OSSB_redinit),
-                  getBundleStr(OSSB_redcomb),
-                  CGF, Red, TaskInfo);
-  }
-
-  if (Data.If)
-    TaskInfo.emplace_back(getBundleStr(OSSB_if), CGF.EvaluateExprAsBool(Data.If));
-  if (Data.Final)
-    TaskInfo.emplace_back(getBundleStr(OSSB_final), CGF.EvaluateExprAsBool(Data.Final));
-
+  EmitTaskData(CGF, Data, TaskInfo);
   InTaskEmission = false;
 
   llvm::Instruction *Result =
     CGF.Builder.CreateCall(EntryCallee, {}, llvm::makeArrayRef(TaskInfo));
 
-  // Push Task Stack
   llvm::Value *Undef = llvm::UndefValue::get(CGF.Int32Ty);
   llvm::Instruction *TaskAllocaInsertPt = new llvm::BitCastInst(Undef, CGF.Int32Ty, "taskallocapt", Result->getParent());
   setTaskInsertPt(TaskAllocaInsertPt);