Explicitly annotate loops we want to run thread-parallel

[grosser]

Summary

We introduces a new flag -polly-parallel and use it to annotate the for-nodes in
the isl ast that we want to execute thread parallel (e.g., using OpenMP). We
previously already emmitted openmp annotations, but we did this for various
kinds of parallel loops, including some which we can not run in parallel.

With this patch we now have three annotations:

1. #pragma known-parallel [reduction]
2. #pragma omp for
3. #pragma simd

meaning:

1. loop has no loop carried dependences
2. loop will be executed thread-parallel
3. loop can possibly be vectorized

This patch introduces 1) and reduces the use of 2) to only the cases where we
know generate thread parallel code.

It is in preparation of openmp code generation in our isl backend.

Legacy:

• We also have a command line option -enable-polly-openmp. This option controls the OpenMP code generation in CLooG. It will become an alias of -polly-parallel after the CLooG code generation has been dropped.

[jdoerfert]

I'm fine with the current version but you can also integrate my comments if you like.

include/polly/CodeGen/IslAst.h

130

Naming convention here seems to be:

isXXX

if a bool is return, thus maybe:

isExecutedInParallel(...)

lib/CodeGen/IslAst.cpp

46

I usually prefere the variable name to be the cmd option without the "-" in camel case, but I don't feel that strong about it.

457

UseThreads should be first as it is the cheapest and we will have no overhead in case no parallel code is generated.

[grosser]

Committed in r221479 with review comments addressed.

include/polly/CodeGen/IslAst.h

public:
   static bool isOutermostParallel(__isl_keep isl_ast_node *Node);
 
   /// @brief Is this loop an innermost parallel loop?
   static bool isInnermostParallel(__isl_keep isl_ast_node *Node);
 
   /// @brief Is this loop a reduction parallel loop?
   static bool isReductionParallel(__isl_keep isl_ast_node *Node);
 
+  /// @brief Will the loop be run as thread parallel?
+  static bool runAsThreadParallel(__isl_keep isl_ast_node *Node);
+
   /// @brief Get the nodes schedule or a nullptr if not available.
   static __isl_give isl_union_map *getSchedule(__isl_keep isl_ast_node *Node);
 
   /// @brief Get minimal dependence distance or nullptr if not available.
   static __isl_give isl_pw_aff *
   getMinimalDependenceDistance(__isl_keep isl_ast_node *Node);
 
   /// @brief Get the nodes broken reductions or a nullptr if not available.

lib/CodeGen/IslAst.cpp

 
 #define DEBUG_TYPE "polly-ast"
 
 using namespace llvm;
 using namespace polly;
 
 using IslAstUserPayload = IslAstInfo::IslAstUserPayload;
 
+static cl::opt<bool>
+    UseThreads("polly-parallel",
+               cl::desc("Generate thread parallel code (isl codegen only)"),
+               cl::init(false), cl::ZeroOrMore, cl::cat(PollyCategory));
+
 static cl::opt<bool> UseContext("polly-ast-use-context",
                                 cl::desc("Use context"), cl::Hidden,
                                 cl::init(false), cl::ZeroOrMore,
                                 cl::cat(PollyCategory));
 
 static cl::opt<bool> DetectParallel("polly-ast-detect-parallel",
                                     cl::desc("Detect parallelism"), cl::Hidden,
                                     cl::init(false), cl::ZeroOrMore,

 
 /// @brief Callback executed for each for node in the ast in order to print it.
 static isl_printer *cbPrintFor(__isl_take isl_printer *Printer,
                                __isl_take isl_ast_print_options *Options,
                                __isl_keep isl_ast_node *Node, void *) {
 
   isl_pw_aff *DD = IslAstInfo::getMinimalDependenceDistance(Node);
   const std::string BrokenReductionsStr = getBrokenReductionsStr(Node);
+  const std::string KnownParallelStr = "#pragma known-parallel";
   const std::string DepDisPragmaStr = "#pragma minimal dependence distance: ";
   const std::string SimdPragmaStr = "#pragma simd";
   const std::string OmpPragmaStr = "#pragma omp parallel for";
 
   if (DD)
     Printer = printLine(Printer, DepDisPragmaStr, DD);
 
   if (IslAstInfo::isInnermostParallel(Node))
     Printer = printLine(Printer, SimdPragmaStr + BrokenReductionsStr);
 
-  if (IslAstInfo::isOutermostParallel(Node))
-    Printer = printLine(Printer, OmpPragmaStr + BrokenReductionsStr);
+  if (IslAstInfo::runAsThreadParallel(Node))
+    Printer = printLine(Printer, OmpPragmaStr);
+  else if (IslAstInfo::isOutermostParallel(Node))
+    Printer = printLine(Printer, KnownParallelStr + BrokenReductionsStr);
 
   isl_pw_aff_free(DD);
   return isl_ast_node_for_print(Node, Printer, Options);
 }
 
 /// @brief Check if the current scheduling dimension is parallel
 ///
 /// In case the dimension is parallel we also check if any reduction
IslAst::IslAst(Scop *Scop, Dependences &D) : S(Scop) {
   else
     Build = isl_ast_build_from_context(isl_set_universe(S->getParamSpace()));
 
   Build = isl_ast_build_set_at_each_domain(Build, AtEachDomain, nullptr);
 
   isl_union_map *Schedule =
       isl_union_map_intersect_domain(S->getSchedule(), S->getDomains());
 
-  if (DetectParallel || PollyVectorizerChoice != VECTORIZER_NONE) {
+  if (UseThreads || DetectParallel ||
+      PollyVectorizerChoice != VECTORIZER_NONE) {
     BuildInfo.Deps = &D;
     BuildInfo.InParallelFor = 0;
 
     Build = isl_ast_build_set_before_each_for(Build, &astBuildBeforeFor,
                                               &BuildInfo);
     Build =
         isl_ast_build_set_after_each_for(Build, &astBuildAfterFor, &BuildInfo);
   }
bool IslAstInfo::isOutermostParallel(__isl_keep isl_ast_node *Node) {
   return Payload && Payload->IsOutermostParallel;
 }
 
 bool IslAstInfo::isReductionParallel(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsReductionParallel;
 }
 
+bool IslAstInfo::runAsThreadParallel(__isl_keep isl_ast_node *Node) {
+  return isOutermostParallel(Node) && !isReductionParallel(Node) && UseThreads;
+}
+
 isl_union_map *IslAstInfo::getSchedule(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload ? isl_ast_build_get_schedule(Payload->Build) : nullptr;
 }
 
 isl_pw_aff *
 IslAstInfo::getMinimalDependenceDistance(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);

test/Isl/Ast/OpenMP/multiple_loops_outer_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 ;
 ;       void jd(int *A) {
 ; CHECK:  #pragma omp parallel for
 ;         for (int i = 0; i < 1024; i++)
 ;           A[i] = 1;
 ; CHECK:  #pragma omp parallel for
 ;         for (int i = 0; i < 1024; i++)
 ;           A[i] = A[i] * 2;

test/Isl/Ast/OpenMP/nested_loop_both_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < 1024; i++)
 ;   for (j = 0; j < 1024; j++)
 ;     A[i][j] = 1;
 
 @A = common global [1024 x [1024 x i32]] zeroinitializer

test/Isl/Ast/OpenMP/nested_loop_both_parallel_parametric.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze -polly-delinearize < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze -polly-delinearize < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 ; int A[1024][1024];
 ; void bar(int n) {
 ;   for (i = 0; i < n; i++)
 ;     for (j = 0; j < n; j++)
 ;       A[i][j] = 1;
 ; }

test/Isl/Ast/OpenMP/nested_loop_inner_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < n; i++)
 ;   for (j = 0; j < n; j++)
 ;     A[j] = 1;
 
 @A = common global [1024 x i32] zeroinitializer

test/Isl/Ast/OpenMP/nested_loop_outer_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < n; i++)
 ;   for (j = 0; j < n; j++)
 ;     A[i] = 1;
 
 @A = common global [1024 x i32] zeroinitializer

test/Isl/Ast/OpenMP/single_loop_param_non_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < n; i++)
 ;   A[0] = i;
 
 @A = common global [1024 x i32] zeroinitializer
 define void @bar(i64 %n) {

test/Isl/Ast/OpenMP/single_loop_param_parallel.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < n; i++)
 ;   A[i] = 1;
 
 @A = common global [1024 x i32] zeroinitializer
 define void @bar(i64 %n) {

test/Isl/Ast/OpenMP/single_loop_param_parallel_computeout.ll

-; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -polly-dependences-computeout=1 -analyze < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-ast -polly-parallel -polly-dependences-computeout=1 -analyze < %s | FileCheck %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
 target triple = "x86_64-pc-linux-gnu"
 
 ; for (i = 0; i < n; i++)
 ;   A[i] = 1;
 
 @A = common global [1024 x i32] zeroinitializer
 define void @bar(i64 %n) {

test/Isl/Ast/reduction_clauses_multidimensional_access.ll

 ; RUN: opt %loadPolly -polly-delinearize -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK: #pragma omp parallel for reduction (^ : sum)
+; CHECK: #pragma known-parallel reduction (^ : sum)
 ;        void f(int N, int M, int P, int sum[P][M]) {
 ;          for (int i = 0; i < N; i++)
 ;            for (int j = 0; j < P; j++)
 ; CHECK:       #pragma simd
 ;              for (int k = 0; k < M; k++)
 ;                sum[j][k] ^= j;
 ;        }
 ;

test/Isl/Ast/reduction_clauses_onedimensional_access.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK: #pragma omp parallel for reduction (^ : sum)
+; CHECK: #pragma known-parallel reduction (^ : sum)
 ;        void f(int N, int M, int *sum) {
 ;          for (int i = 0; i < N; i++)
 ; CHECK:    #pragma simd
 ;            for (int j = 0; j < M; j++)
 ;              sum[j] ^= j;
 ;        }
 ;
 target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-n32-S64"

test/Isl/Ast/reduction_different_reduction_clauses.ll

 ; RUN: opt %loadPolly -basicaa -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; CHECK: #pragma simd reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
-; CHECK: #pragma omp parallel for reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
+; CHECK: #pragma known-parallel reduction (+ : sum{{[1,2]}}, sum{{[1,2]}}) reduction (* : prod) reduction (| : or) reduction (& : and)
 ; CHECK: for (int c1 = 0; c1 < N; c1 += 1)
 ; CHECK:   Stmt_for_body(c1);
 ;
 ;    void f(int N, int *restrict sum1, int *restrict sum2, int *restrict prod,
 ;           int *restrict and, int *restrict or ) {
 ;      for (int i = 0; i < N; i++) {
 ;        *sum1 += i;
 ;        *sum2 += i + 1;

test/Isl/Ast/reduction_in_one_dimension.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; Verify that we won't privatize anything in the outer dimension
 ;
-; CHECK:    #pragma omp parallel for
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 < 2 * n; c1 += 1)
 ; CHECK:      #pragma simd reduction
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:        Stmt_for_body3(c1, c3);
 ;
 ;    void foo(int *A, long n) {
 ;      for (long i = 0; i < 2 * n; i++)
 ;        for (long j = 0; j < 1024; j++)

test/Isl/Ast/reduction_modulo_and_loop_reversal_schedule_2.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK:    #pragma omp parallel for reduction
+; CHECK:    #pragma known-parallel reduction
 ; CHECK:    for (int c0 = 0; c0 <= 2; c0 += 1) {
 ; CHECK:      if (c0 == 2) {
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c1 = 1; c1 < 2 * n; c1 += 2)
 ; CHECK:          Stmt_S0(c1);
 ; CHECK:      } else if (c0 == 1) {
 ; CHECK:        #pragma simd
 ; CHECK:        for (int c1 = 0; c1 < 2 * n; c1 += 1)

test/Isl/Ast/reduction_modulo_schedule_multiple_dimensions.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK:    #pragma omp parallel for
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c0 = 0; c0 <= 1; c0 += 1) {
 ; CHECK:      if (c0 == 1) {
 ; CHECK:        for (int c1 = 1; c1 < 2 * n; c1 += 2)
 ; CHECK:          #pragma simd reduction
 ; CHECK:          for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:            Stmt_for_body3(c1, c3);
 ; CHECK:      } else
 ; CHECK:        for (int c1 = 0; c1 < 2 * n; c1 += 2)

test/Isl/Ast/reduction_modulo_schedule_multiple_dimensions_2.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; Verify that the outer dimension doesnt't carry reduction dependences
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 < 2 * n; c1 += 1) {
 ; CHECK:      if (c1 % 2 == 0) {
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:          Stmt_for_body3(c1, c3);
 ; CHECK:      } else
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c3 = 0; c3 <= 1023; c3 += 1)

test/Isl/Ast/reduction_modulo_schedule_multiple_dimensions_3.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; Verify that the outer dimension doesnt't carry reduction dependences
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 < 2 * n; c1 += 1)
 ; CHECK:      #pragma simd reduction
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1) {
 ; CHECK:        if (c3 % 2 == 0) {
 ; CHECK:          Stmt_for_body3(c1, c3);
 ; CHECK:        } else
 ; CHECK:          Stmt_for_body3(c1, c3);
 ; CHECK:      }

test/Isl/Ast/reduction_modulo_schedule_multiple_dimensions_4.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; Verify that the outer dimension doesnt't carry reduction dependences
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 < 2 * n; c1 += 1)
 ; CHECK:      #pragma simd reduction
 ; CHECK:      for (int c3 = -1023; c3 <= 1023; c3 += 1) {
 ; CHECK:        if (c3 <= 0 && -c3 % 2 == 0) {
 ; CHECK:          Stmt_for_body3(c1, -c3);
 ; CHECK:        } else if (c3 >= 1 && (c3 - 1) % 2 == 0)
 ; CHECK:          Stmt_for_body3(c1, c3);
 ; CHECK:      }

test/Isl/Ast/reduction_modulo_schedule_multiple_dimensions_5.ll

 ; RUN: opt %loadPolly -polly-import-jscop-dir=%S -polly-import-jscop -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
 ; Verify that only the outer dimension needs privatization
 ;
-; CHECK:    #pragma omp parallel for reduction
+; CHECK:    #pragma known-parallel reduction
 ; CHECK:    for (int c1 = 0; c1 <= 1023; c1 += 1) {
 ; CHECK:      if (c1 % 2 == 0) {
 ; CHECK-NOT:    #pragma simd reduction
 ; CHECK:        #pragma simd
 ; CHECK:        for (int c3 = 0; c3 < 2 * n; c3 += 1)
 ; CHECK:          Stmt_for_body3(c3, c1);
 ; CHECK:      } else
 ; CHECK-NOT:    #pragma simd reduction

test/Isl/Ast/reduction_multiple_dimensions.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 <= 2047; c1 += 1)
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c5 = 0; c5 <= 511; c5 += 1)
 ; CHECK:          Stmt_for_body6(c1, c3, c5);
 ;
 ;    void rmd(int *A) {
 ;      for (long i = 0; i < 2048; i++)

test/Isl/Ast/reduction_multiple_dimensions_2.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 <= 2047; c1 += 1)
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c5 = 0; c5 <= 511; c5 += 1)
 ; CHECK:          Stmt_for_body6(c1, c3, c5);
 ;
 ;    void rmd2(int *A) {
 ;      for (long i = 0; i < 2048; i++)

test/Isl/Ast/reduction_multiple_dimensions_3.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 <= 2047; c1 += 1)
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c5 = 0; c5 <= 511; c5 += 1)
 ; CHECK:          Stmt_for_body6(c1, c3, c5);
 ;
 ;    void rmd3(int *A) {
 ;      for (long i = 0; i < 2048; i++)

test/Isl/Ast/reduction_multiple_dimensions_4.ll

 ; RUN: opt %loadPolly -polly-ast -polly-ast-detect-parallel -analyze < %s | FileCheck %s
 ;
-; CHECK-NOT:#pragma omp parallel for reduction
-; CHECK:    #pragma omp parallel for
+; CHECK-NOT:#pragma known-parallel reduction
+; CHECK:    #pragma known-parallel
 ; CHECK:    for (int c1 = 0; c1 <= 2047; c1 += 1)
 ; CHECK:      for (int c3 = 0; c3 <= 1023; c3 += 1)
 ; CHECK:        #pragma simd reduction
 ; CHECK:        for (int c5 = 0; c5 <= 511; c5 += 1)
 ; CHECK:          Stmt_for_body6(c1, c3, c5);
 ;
 ;    void rmd4(int *A) {
 ;      for (long i = 0; i < 2048; i++)

test/Isl/Ast/single_loop_strip_mine.ll

 
 for.end:                                          ; preds = %for.cond
   ret void
 }
 
 ; CHECK: for (int c1 = 0; c1 <= 1023; c1 += 1)
 ; CHECK:     Stmt_for_body(c1);
 
-; CHECK-VECTOR: #pragma omp parallel for
+; CHECK-VECTOR: #pragma known-parallel
 ; CHECK-VECTOR: for (int c0 = 0; c0 <= 1023; c0 += 4)
 ; CHECK-VECTOR:     #pragma simd
 ; CHECK-VECTOR:     for (int c1 = c0; c1 <= c0 + 3; c1 += 1)
 ; CHECK-VECTOR:           Stmt_for_body(c1);
 
 

test/ScheduleOptimizer/prevectorization.ll

for.inc28:                                        ; preds = %for.inc25
   br i1 %exitcond9, label %for.cond1.preheader, label %for.end30
 
 for.end30:                                        ; preds = %for.inc28
   ret void
 }
 
 attributes #0 = { nounwind uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
-; CHECK: #pragma omp parallel for
+; CHECK: #pragma known-parallel
 ; CHECK: for (int c1 = 0; c1 <= 1535; c1 += 32)
 ; CHECK:   for (int c2 = 0; c2 <= 1535; c2 += 32)
 ; CHECK:     for (int c3 = c1; c3 <= c1 + 31; c3 += 1)
 ; CHECK:       for (int c4 = c2; c4 <= c2 + 31; c4 += 4)
 ; CHECK:         #pragma simd
 ; CHECK:         for (int c5 = c4; c5 <= c4 + 3; c5 += 1)
 ; CHECK:           Stmt_for_body3(c3, c5);
-; CHECK: #pragma omp parallel for
+; CHECK: #pragma known-parallel
 ; CHECK: for (int c1 = 0; c1 <= 1535; c1 += 32)
 ; CHECK:   for (int c2 = 0; c2 <= 1535; c2 += 32)
 ; CHECK:     for (int c3 = 0; c3 <= 1535; c3 += 32)
 ; CHECK:       for (int c4 = c1; c4 <= c1 + 31; c4 += 1)
 ; CHECK:         for (int c5 = c2; c5 <= c2 + 31; c5 += 4)
 ; CHECK:           for (int c6 = c3; c6 <= c3 + 31; c6 += 1)
 ; CHECK:             #pragma simd
 ; CHECK:             for (int c7 = c5; c7 <= c5 + 3; c7 += 1)
 ; CHECK:               Stmt_for_body8(c4, c7, c6);
 
 !llvm.ident = !{!0}
 
 !0 = metadata !{metadata !"clang version 3.5.0 "}