This is an archive of the discontinued LLVM Phabricator instance.

Differential D37692

[Polly] Unroll and separate the remaining parts of isolation
ClosedPublic

Authored by gareevroman on Sep 11 2017, 8:04 AM.

Details

Reviewers
grosser
Meinersbur
jdoerfert
bollu
Commits
rG925ce50f1bf7: Unroll and separate the remaining parts of isolation
rPLO312929: Unroll and separate the remaining parts of isolation
rL312929: Unroll and separate the remaining parts of isolation
Summary

The remaining parts produced by the full partial tile isolation can contain hot spots that are worth to be optimized. Currently, we rely on the simple loop unrolling pass, LiCM and the SLP vectorizer to optimize such parts. However, the approach can suffer from the lack of the information about aliasing that Polly provides using additional alias metadata or/and the lack of the information required by simple loop unrolling pass.

This patch is the first step to optimize the remaining parts. To do it, we unroll and separate them. In case of, for instance, Intel Kaby Lake, it helps to increase the performance of the generated code from 39.87 GFlop/s to 49.23 GFlop/s.

The next possible step is to avoid unrolling performed by Polly in case of isolated and remaining parts and rely only on simple loop unrolling pass and the Loop vectorizer.

Diff Detail

Repository
rL LLVM

Event Timeline

gareevroman created this revision.Sep 11 2017, 8:04 AM
Herald added a reviewer: bollu. · View Herald TranscriptSep 11 2017, 8:04 AM
grosser accepted this revision.Sep 11 2017, 8:47 AM

LGTM.

This revision is now accepted and ready to land.Sep 11 2017, 8:47 AM
Closed by commit rL312929: Unroll and separate the remaining parts of isolation (authored by romangareev). · Explain WhySep 11 2017, 10:48 AM
This revision was automatically updated to reflect the committed changes.

Revision Contents

Diff 114636

polly/trunk/lib/Transform/ScheduleOptimizer.cpp

Show First 20 Lines • Show All 317 Lines • ▼ Show 20 Linesstatic isl::union_set getIsolateOptions(isl::set IsolateDomain,
IsolateRelation = IsolateRelation.move_dims(isl::dim::out, 0, isl::dim::in, IsolateRelation = IsolateRelation.move_dims(isl::dim::out, 0, isl::dim::in,
Dims - OutDimsNum, OutDimsNum); Dims - OutDimsNum, OutDimsNum);
isl::set IsolateOption = IsolateRelation.wrap(); isl::set IsolateOption = IsolateRelation.wrap();
isl::id Id = isl::id::alloc(IsolateOption.get_ctx(), "isolate", nullptr); isl::id Id = isl::id::alloc(IsolateOption.get_ctx(), "isolate", nullptr);
IsolateOption = IsolateOption.set_tuple_id(Id); IsolateOption = IsolateOption.set_tuple_id(Id);
return isl::union_set(IsolateOption); return isl::union_set(IsolateOption);
} }
/// Create an isl::union_set, which describes the atomic option for the namespace {
/// Create an isl::union_set, which describes the specified option for the
/// dimension of the current node. /// dimension of the current node.
/// ///
/// It may help to reduce the size of generated code.
///
/// @param Ctx An isl::ctx, which is used to create the isl::union_set. /// @param Ctx An isl::ctx, which is used to create the isl::union_set.
static isl::union_set getAtomicOptions(isl::ctx Ctx) { /// @param Option The name of the option.
isl::union_set getDimOptions(isl::ctx Ctx, const char *Option) {
isl::space Space(Ctx, 0, 1); isl::space Space(Ctx, 0, 1);
isl::set AtomicOption = isl::set::universe(Space); auto DimOption = isl::set::universe(Space);
isl::id Id = isl::id::alloc(Ctx, "atomic", nullptr); auto Id = isl::id::alloc(Ctx, Option, nullptr);
AtomicOption = AtomicOption.set_tuple_id(Id); DimOption = DimOption.set_tuple_id(Id);
return isl::union_set(AtomicOption); return isl::union_set(DimOption);
} }
} // namespace
/// Create an isl::union_set, which describes the option of the form /// Create an isl::union_set, which describes the option of the form
/// [isolate[] -> unroll[x]]. /// [isolate[] -> unroll[x]].
/// ///
/// @param Ctx An isl::ctx, which is used to create the isl::union_set. /// @param Ctx An isl::ctx, which is used to create the isl::union_set.
static isl::union_set getUnrollIsolatedSetOptions(isl::ctx Ctx) { static isl::union_set getUnrollIsolatedSetOptions(isl::ctx Ctx) {
isl::space Space = isl::space(Ctx, 0, 0, 1); isl::space Space = isl::space(Ctx, 0, 0, 1);
isl::map UnrollIsolatedSetOption = isl::map::universe(Space); isl::map UnrollIsolatedSetOption = isl::map::universe(Space);
Show All 39 Lines
ScheduleTreeOptimizer::isolateFullPartialTiles(isl::schedule_node Node, ScheduleTreeOptimizer::isolateFullPartialTiles(isl::schedule_node Node,
int VectorWidth) { int VectorWidth) {
assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band); assert(isl_schedule_node_get_type(Node.get()) == isl_schedule_node_band);
Node = Node.child(0).child(0); Node = Node.child(0).child(0);
isl::union_map SchedRelUMap = Node.get_prefix_schedule_relation(); isl::union_map SchedRelUMap = Node.get_prefix_schedule_relation();
isl::map ScheduleRelation = isl::map::from_union_map(SchedRelUMap); isl::map ScheduleRelation = isl::map::from_union_map(SchedRelUMap);
isl::set ScheduleRange = ScheduleRelation.range(); isl::set ScheduleRange = ScheduleRelation.range();
isl::set IsolateDomain = getPartialTilePrefixes(ScheduleRange, VectorWidth); isl::set IsolateDomain = getPartialTilePrefixes(ScheduleRange, VectorWidth);
isl::union_set AtomicOption = getAtomicOptions(IsolateDomain.get_ctx()); auto AtomicOption = getDimOptions(IsolateDomain.get_ctx(), "atomic");
isl::union_set IsolateOption = getIsolateOptions(IsolateDomain, 1); isl::union_set IsolateOption = getIsolateOptions(IsolateDomain, 1);
Node = Node.parent().parent(); Node = Node.parent().parent();
isl::union_set Options = IsolateOption.unite(AtomicOption); isl::union_set Options = IsolateOption.unite(AtomicOption);
Node = Node.band_set_ast_build_options(Options); Node = Node.band_set_ast_build_options(Options);
return Node; return Node;
} }
isl::schedule_node ScheduleTreeOptimizer::prevectSchedBand( isl::schedule_node ScheduleTreeOptimizer::prevectSchedBand(
▲ Show 20 Lines • Show All 799 Lines • ▼ Show 20 LinesisolateAndUnrollMatMulInnerLoops(isl::schedule_node Node,
unsigned Dims = Prefix.dim(isl::dim::set); unsigned Dims = Prefix.dim(isl::dim::set);
Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1); Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1);
Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr); Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr);
Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr); Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr);
isl::union_set IsolateOption = isl::union_set IsolateOption =
getIsolateOptions(Prefix.add_dims(isl::dim::set, 3), 3); getIsolateOptions(Prefix.add_dims(isl::dim::set, 3), 3);
isl::ctx Ctx = Node.get_ctx(); isl::ctx Ctx = Node.get_ctx();
isl::union_set AtomicOption = getAtomicOptions(Ctx); auto Options = IsolateOption.unite(getDimOptions(Ctx, "unroll"));
isl::union_set Options = IsolateOption.unite(AtomicOption);
Options = Options.unite(getUnrollIsolatedSetOptions(Ctx)); Options = Options.unite(getUnrollIsolatedSetOptions(Ctx));
Node = Node.band_set_ast_build_options(Options); Node = Node.band_set_ast_build_options(Options);
Node = Node.parent().parent().parent(); Node = Node.parent().parent().parent();
IsolateOption = getIsolateOptions(Prefix, 3); IsolateOption = getIsolateOptions(Prefix, 3);
Options = IsolateOption.unite(AtomicOption); Options = IsolateOption.unite(getDimOptions(Ctx, "separate"));
Node = Node.band_set_ast_build_options(Options); Node = Node.band_set_ast_build_options(Options);
Node = Node.child(0).child(0).child(0); Node = Node.child(0).child(0).child(0);
return Node; return Node;
} }
/// Mark @p BasePtr with "Inter iteration alias-free" mark node. /// Mark @p BasePtr with "Inter iteration alias-free" mark node.
/// ///
/// @param Node The child of the mark node to be inserted. /// @param Node The child of the mark node to be inserted.
▲ Show 20 Lines • Show All 448 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/pattern-matching-based-opts_12.ll

Show First 20 Lines • Show All 281 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 26, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 27, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 28, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 29, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 30, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 31, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: if (c2 == 2) ; CHECK-NEXT: if (c2 == 2)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 <= 3; c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= 31; c7 += 1) ; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(c6 + 1016, 32 * c3 + c7, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1016, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1017, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1018, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 1, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 2, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 3, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 4, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 5, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 6, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 7, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 8, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 9, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 10, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 11, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 12, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 13, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 14, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 15, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 16, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 17, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 18, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 19, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 20, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 21, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 22, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 23, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 24, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 25, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 26, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 27, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 28, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 29, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 30, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(1019, 32 * c3 + 31, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: for (int c4 = 0; c4 <= min(47, -48 * c2 + 127); c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= min(47, -48 * c2 + 127); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(511, -512 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 <= min(7, -384 * c2 - 8 * c4 + 1019); c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= 27; c7 += 1) ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + c6, c7 + 992, 512 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 1, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 2, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 3, 1019, 512 * c1 + c5);
; CHECK-NEXT: if (48 * c2 + c4 <= 126) {
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 4, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 5, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 6, 1019, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 992, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 993, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 994, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 995, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 996, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 997, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 998, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 999, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1000, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1001, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1002, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1003, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1004, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1005, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1006, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1007, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1008, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1009, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1010, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1011, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1012, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1013, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1014, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1015, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1016, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1017, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1018, 512 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(384 * c2 + 8 * c4 + 7, 1019, 512 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, i8 signext %alpha, i8 signext %beta, [1020 x i8]* %C, [1020 x i8]* %A, [1020 x i8]* %B) { define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, i8 signext %alpha, i8 signext %beta, [1020 x i8]* %C, [1020 x i8]* %A, [1020 x i8]* %B) {
entry: entry:
br label %entry.split br label %entry.split
Show All 39 Lines

polly/trunk/test/ScheduleOptimizer/pattern-matching-based-opts_13.ll

; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \ ; RUN: opt %loadPolly -polly-opt-isl -polly-pattern-matching-based-opts=true \
; RUN: -polly-target-throughput-vector-fma=2 \ ; RUN: -polly-target-throughput-vector-fma=2 \
; RUN: -polly-target-latency-vector-fma=8 \ ; RUN: -polly-target-latency-vector-fma=8 \
; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \ ; RUN: -analyze -polly-ast -polly-target-1st-cache-level-associativity=8 \
; RUN: -polly-target-2nd-cache-level-associativity=8 \ ; RUN: -polly-target-2nd-cache-level-associativity=8 \
; RUN: -polly-target-1st-cache-level-size=32768 \ ; RUN: -polly-target-1st-cache-level-size=32768 \
; RUN: -polly-target-vector-register-bitwidth=128 \ ; RUN: -polly-target-vector-register-bitwidth=128 \
; RUN: -polly-target-2nd-cache-level-size=262144 < %s \ ; RUN: -polly-target-2nd-cache-level-size=262144 < %s \
; RUN: | FileCheck %s ; RUN: | FileCheck %s
; ;
; Test whether isolation works as expected. ; Test whether isolation works as expected.
; ;
; CHECK: // Inter iteration alias-free ; CHECK: // Inter iteration alias-free
; CHECK-NEXT: // 1st level tiling - Tiles ; CHECK-NEXT: // 1st level tiling - Tiles
; CHECK-NEXT: for (int c0 = 0; c0 <= 1; c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 <= 1; c0 += 1)
; CHECK-NEXT: for (int c1 = 0; c1 <= 6; c1 += 1) { ; CHECK-NEXT: for (int c1 = 0; c1 <= 6; c1 += 1) {
; CHECK-NEXT: for (int c3 = 1536 * c0; c3 <= min(1999, 1536 * c0 + 1535); c3 += 1) ; CHECK-NEXT: for (int c3 = 1536 * c0; c3 <= min(1999, 1536 * c0 + 1535); c3 += 1)
; CHECK-NEXT: for (int c4 = 307 * c1; c4 <= min(1999, 307 * c1 + 306); c4 += 1) ; CHECK-NEXT: for (int c4 = 307 * c1; c4 <= min(1999, 307 * c1 + 306); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4); ; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= 24; c2 += 1) { ; CHECK-NEXT: for (int c2 = 0; c2 <= 24; c2 += 1) {
; CHECK-NEXT: if (c0 == 0) ; CHECK-NEXT: if (c0 == 0)
; CHECK-NEXT: for (int c3 = 80 * c2; c3 <= 80 * c2 + 79; c3 += 1) ; CHECK-NEXT: for (int c3 = 80 * c2; c3 <= 80 * c2 + 79; c3 += 1)
; CHECK-NEXT: for (int c5 = 307 * c1; c5 <= min(1999, 307 * c1 + 306); c5 += 1) ; CHECK-NEXT: for (int c5 = 307 * c1; c5 <= min(1999, 307 * c1 + 306); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5); ; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: // 1st level tiling - Points ; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles ; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: { ; CHECK-NEXT: {
; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + 332); c3 += 1) ; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + 332); c3 += 1)
; CHECK-NEXT: for (int c4 = 0; c4 <= 15; c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= 15; c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(306, -307 * c1 + 1999); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(306, -307 * c1 + 1999); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: { ; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 1, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 2, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 3, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 4, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1536 * c0 + 6 * c3 + 5, 307 * c1 + c5);
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: if (c0 == 1) ; CHECK-NEXT: if (c0 == 1)
; CHECK-NEXT: for (int c4 = 0; c4 <= 15; c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= 15; c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(306, -307 * c1 + 1999); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(306, -307 * c1 + 1999); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 <= 4; c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= 1; c7 += 1) ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1998, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + c6, c7 + 1998, 307 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4, 1999, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1998, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 1, 1999, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1998, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 2, 1999, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1998, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 3, 1999, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1998, 307 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(80 * c2 + 5 * c4 + 4, 1999, 307 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu" target triple = "x86_64-unknown-linux-gnu"
define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, [2000 x double]* %C, [2000 x double]* %A, [2000 x double]* %B) { define internal void @kernel_gemm(i32 %ni, i32 %nj, i32 %nk, double %alpha, double %beta, [2000 x double]* %C, [2000 x double]* %A, [2000 x double]* %B) {
entry: entry:
br label %entry.split br label %entry.split
Show All 39 Lines

polly/trunk/test/ScheduleOptimizer/pattern-matching-based-opts_5.ll

Show All 30 Lines
; to the vectorized code with sunk and hoisted memory accesses. */ ; to the vectorized code with sunk and hoisted memory accesses. */
; ;
; /* C := A * B + C */ ; /* C := A * B + C */
; for (i = 0; i < _PB_NI; i++) ; for (i = 0; i < _PB_NI; i++)
; for (j = 0; j < _PB_NJ; j++) ; for (j = 0; j < _PB_NJ; j++)
; for (k = 0; k < _PB_NK; ++k) ; for (k = 0; k < _PB_NK; ++k)
; C[i][j] += A[i][k] * B[k][j]; ; C[i][j] += A[i][k] * B[k][j];
; ;
; CHECK: if (ni >= 1) { ; CHECK: if (ni >= 1) {
; CHECK-NEXT: // Inter iteration alias-free ; CHECK-NEXT: // Inter iteration alias-free
; CHECK-NEXT: // 1st level tiling - Tiles ; CHECK-NEXT: // 1st level tiling - Tiles
; CHECK-NEXT: for (int c0 = 0; c0 <= floord(nj - 1, 2048); c0 += 1) ; CHECK-NEXT: for (int c0 = 0; c0 <= floord(nj - 1, 2048); c0 += 1)
; CHECK-NEXT: for (int c1 = 0; c1 <= floord(nk - 1, 256); c1 += 1) { ; CHECK-NEXT: for (int c1 = 0; c1 <= floord(nk - 1, 256); c1 += 1) {
; CHECK-NEXT: for (int c3 = 2048 * c0; c3 <= min(nj - 1, 2048 * c0 + 2047); c3 += 1) ; CHECK-NEXT: for (int c3 = 2048 * c0; c3 <= min(nj - 1, 2048 * c0 + 2047); c3 += 1)
; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= min(nk - 1, 256 * c1 + 255); c4 += 1) ; CHECK-NEXT: for (int c4 = 256 * c1; c4 <= min(nk - 1, 256 * c1 + 255); c4 += 1)
; CHECK-NEXT: CopyStmt_0(0, c3, c4); ; CHECK-NEXT: CopyStmt_0(0, c3, c4);
; CHECK-NEXT: for (int c2 = 0; c2 <= floord(ni - 1, 96); c2 += 1) { ; CHECK-NEXT: for (int c2 = 0; c2 <= floord(ni - 1, 96); c2 += 1) {
; CHECK-NEXT: if (c0 == 0) ; CHECK-NEXT: if (c0 == 0)
; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= min(ni - 1, 96 * c2 + 95); c3 += 1) ; CHECK-NEXT: for (int c3 = 96 * c2; c3 <= min(ni - 1, 96 * c2 + 95); c3 += 1)
; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= min(nk - 1, 256 * c1 + 255); c5 += 1) ; CHECK-NEXT: for (int c5 = 256 * c1; c5 <= min(nk - 1, 256 * c1 + 255); c5 += 1)
; CHECK-NEXT: CopyStmt_1(c3, 0, c5); ; CHECK-NEXT: CopyStmt_1(c3, 0, c5);
; CHECK-NEXT: // 1st level tiling - Points ; CHECK-NEXT: // 1st level tiling - Points
; CHECK-NEXT: // Register tiling - Tiles ; CHECK-NEXT: // Register tiling - Tiles
; CHECK-NEXT: { ; CHECK-NEXT: {
; CHECK-NEXT: if (ni >= 96 * c2 + 4) ; CHECK-NEXT: if (ni >= 96 * c2 + 4)
; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + nj / 8 - 1); c3 += 1) { ; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + nj / 8 - 1); c3 += 1) {
; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + ni / 4 - 1); c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + ni / 4 - 1); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: { ; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: if (96 * c2 + 95 >= ni) ; CHECK-NEXT: if (96 * c2 + 95 >= ni && ni % 4 >= 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 < ni % 4; c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= 7; c7 += 1) ; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + c6, 2048 * c0 + 8 * c3 + c7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: if (ni % 4 >= 2) {
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(-((ni + 4) % 4) + ni + 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: if ((ni + 1) % 4 == 0) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: if (96 * c2 + 3 >= ni || (2048 * c0 + 2047 >= nj && nj % 8 >= 1)) ; CHECK-NEXT: if (96 * c2 + 3 >= ni || (2048 * c0 + 2047 >= nj && nj % 8 >= 1)) {
; CHECK-NEXT: if (96 * c2 + 3 >= ni) {
; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + (nj - 1) / 8); c3 += 1) ; CHECK-NEXT: for (int c3 = 0; c3 <= min(255, -256 * c0 + (nj - 1) / 8); c3 += 1)
; CHECK-NEXT: if (96 * c2 + 3 >= ni || 2048 * c0 + 8 * c3 + 7 >= nj) ; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 7) {
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 8)
; CHECK-NEXT: Stmt_for_body6(96 * c2, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (ni >= 96 * c2 + 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 7) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 8)
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (96 * c2 + 3 == ni) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 2) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 3) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 4) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 5) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 6) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 7) {
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: if (nj >= 2048 * c0 + 8 * c3 + 8)
; CHECK-NEXT: Stmt_for_body6(ni - 1, 2048 * c0 + 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: } else {
; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + (ni - 1) / 4); c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + (ni - 1) / 4); c4 += 1)
; CHECK-NEXT: if ((ni >= 96 * c2 + 4 && 2048 * c0 + 8 * c3 + 7 >= nj) || 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, nk - 256 * c1 - 1); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 <= min(3, ni - 96 * c2 - 4 * c4 - 1); c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= min(7, nj - 2048 * c0 - 8 * c3 - 1); c7 += 1) ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + c6, 2048 * c0 + 8 * c3 + c7, 256 * c1 + c5); ; CHECK-NEXT: if (nj % 8 >= 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, -(nj % 8) + nj + 5, 256 * c1 + c5);
; CHECK-NEXT: if ((nj + 1) % 8 == 0)
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, nj - 1, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (ni >= 96 * c2 + 4 * c4 + 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, -(nj % 8) + nj + 5, 256 * c1 + c5);
; CHECK-NEXT: if ((nj + 1) % 8 == 0)
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, nj - 1, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (ni >= 96 * c2 + 4 * c4 + 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, -(nj % 8) + nj + 5, 256 * c1 + c5);
; CHECK-NEXT: if ((nj + 1) % 8 == 0)
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, nj - 1, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: if (ni >= 96 * c2 + 4 * c4 + 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 2) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj + 1, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 3) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj + 2, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 4) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj + 3, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 5) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj + 4, 256 * c1 + c5);
; CHECK-NEXT: if (nj % 8 >= 6) {
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, -(nj % 8) + nj + 5, 256 * c1 + c5);
; CHECK-NEXT: if ((nj + 1) % 8 == 0)
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, nj - 1, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; AUTO-VECTORIZATION: fmul <4 x double> ; AUTO-VECTORIZATION: fmul <4 x double>
; AUTO-VECTORIZATION: fadd <4 x double> ; AUTO-VECTORIZATION: fadd <4 x double>
; AUTO-VECTORIZATION: 36 SLP - Number of vector instructions generated ; AUTO-VECTORIZATION: 36 SLP - Number of vector instructions generated
; AUTO-VECTORIZATION: 453 licm - Number of instructions hoisted out of loop ; AUTO-VECTORIZATION: 453 licm - Number of instructions hoisted out of loop
; AUTO-VECTORIZATION: 2 licm - Number of load insts hoisted or sunk ; AUTO-VECTORIZATION: 2 licm - Number of load insts hoisted or sunk
▲ Show 20 Lines • Show All 74 Lines • Show Last 20 Lines

polly/trunk/test/ScheduleOptimizer/pattern-matching-based-opts_6.ll

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Lines
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 2, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 2, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 3, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 3, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 4, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 4, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 5, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 5, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 6, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 6, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 7, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 8 * c3 + 7, 256 * c1 + c5);
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + 254); c4 += 1) ; CHECK-NEXT: for (int c4 = 0; c4 <= min(23, -24 * c2 + 254); c4 += 1)
; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, -256 * c1 + 1019); c5 += 1) { ; CHECK-NEXT: for (int c5 = 0; c5 <= min(255, -256 * c1 + 1019); c5 += 1) {
; CHECK-NEXT: // Loop Vectorizer Disabled ; CHECK-NEXT: // Loop Vectorizer Disabled
; CHECK-NEXT: // Register tiling - Points ; CHECK-NEXT: // Register tiling - Points
; CHECK-NEXT: for (int c6 = 0; c6 <= 3; c6 += 1) ; CHECK-NEXT: {
; CHECK-NEXT: for (int c7 = 0; c7 <= 3; c7 += 1) ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 1016, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + c6, c7 + 1016, 256 * c1 + c5); ; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 1017, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 1018, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4, 1019, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 1016, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 1017, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 1018, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 1, 1019, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 1016, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 1017, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 1018, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 2, 1019, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 1016, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 1017, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 1018, 256 * c1 + c5);
; CHECK-NEXT: Stmt_for_body6(96 * c2 + 4 * c4 + 3, 1019, 256 * c1 + c5);
; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; CHECK-NEXT: } ; CHECK-NEXT: }
; ;
; AUTO-VECTORIZATION: fmul <4 x double> ; AUTO-VECTORIZATION: fmul <4 x double>
; AUTO-VECTORIZATION: fadd <4 x double> ; AUTO-VECTORIZATION: fadd <4 x double>
; AUTO-VECTORIZATION: 36 SLP - Number of vector instructions generated ; AUTO-VECTORIZATION: 36 SLP - Number of vector instructions generated
; AUTO-VECTORIZATION: 146 licm - Number of instructions hoisted out of loop ; AUTO-VECTORIZATION: 146 licm - Number of instructions hoisted out of loop
; AUTO-VECTORIZATION: 1 licm - Number of load insts hoisted or sunk ; AUTO-VECTORIZATION: 1 licm - Number of load insts hoisted or sunk
; AUTO-VECTORIZATION: 32 licm - Number of memory locations promoted to registers ; AUTO-VECTORIZATION: 32 licm - Number of memory locations promoted to registers
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines