[Polly][MatMul] Make MatMul detection independent of internal isl representations.

[annanay25]

Summary

The pattern recognition for MatMul is restrictive.

The number of "disjuncts" in the isl_map containing constraint information was previously required to be 1 (as per isl_coalesce - which should ideally produce a domain map with a single disjunct, but does not under some circumstances).

This was changed and made more flexible.

[grosser]

Nice. Could you possibly add a test case?

lib/Transform/ScheduleOptimizer.cpp

650 ↗

(On Diff #110173)

Can you pull the MemAccess->getStatement()->getDomain() out?

[Meinersbur]

lib/Transform/ScheduleOptimizer.cpp

570–576 ↗

(On Diff #110173)

[Suggestion] I think we don't need that check that there are exactly 2 constraints per basic_map anymore.

584–607 ↗

(On Diff #110173)

[Suggestion] I think it is possible to make a loop for this:

int FirstDims[] = {0,0,1,1,2,2};
int SecondDims[] = {1,2,2,0,0,1};
for (int i = 0; i <= 6; i+=1)
    PossibleMatMul[i] = Universe.equate(isl::dim::in, FirstDims[i], isl::dim::out, 0).equate(isl::dim::in, SecondDims[i], isl::dim::out, 1);

609 ↗

(On Diff #110173)

[Style] remove commented code.

[gareevroman]

The pattern recognition for MatMul is restrictive.

The number of "disjuncts" in the isl_map containing constraint information was previously required to be 1 (as per isl_coalesce - which should ideally produce a domain map with a single disjunct, but does not under some circumstances).

Could you please show an example of such an isl_map?

lib/Transform/ScheduleOptimizer.cpp

604 ↗

(On Diff #110173)

Could we just drop the constraints not involving the output dimensions:

auto *NewAccMap = isl_map_drop_constraints_not_involving_dims(

isl_map_copy(AccMap), isl_dim_out, 0, 2);

and investigate the new map, using the old code?

if (NewAccMap.foreach_basic_map(Lambda) != isl::stat::ok || DimInPos[0] < 0 ||

[Meinersbur]

lib/Transform/ScheduleOptimizer.cpp

604 ↗

(On Diff #110173)

This is not about constraints of uninvolved dims.

isl does not have unique representation for representing the same sets. An example are the sets

{ Stmt[0] -> MemRef[0]; Stmt[1] -> MemRef[1]; Stmt[2] -> MemRef[2] }
{ Stmt[i0] -> MemRef[i0] : 0 <= i0 < 3 }

which both represent the same logical set. There is isl_map_coalesce which unfortunately does not guaranttee to get to any cannonical form.

It is more robust to use operations that operate on logical sets instead to investigate the internal structure.

[annanay25]

In D36460#835110, @grosser wrote:

Nice. Could you possibly add a test case?

Yes, will do. Thanks!

lib/Transform/ScheduleOptimizer.cpp

584–607 ↗

(On Diff #110173)

Aha! Thanks! Thought I could individually comment the values of FirstPos and SecondPos for each domain.

604 ↗

(On Diff #110173)

Thanks for this discussion. I would also point to my post on the isl-development group for more information (and an example) on this.

Link: https://groups.google.com/forum/#!topic/isl-development/iURXrsSVC28

609 ↗

(On Diff #110173)

Oops.

650 ↗

(On Diff #110173)

Will do.

[annanay25]

lib/Transform/ScheduleOptimizer.cpp

584–607 ↗

(On Diff #110173)

@Meinersbur , should I change it to the loop according to your suggestion? Or should I leave the comments behind for readability?

[gareevroman]

lib/Transform/ScheduleOptimizer.cpp

604 ↗

(On Diff #110173)

This is not about constraints of uninvolved dims.

isl does not have unique representation for representing the same sets. An example are the sets

{ Stmt[0] -> MemRef[0]; Stmt[1] -> MemRef[1]; Stmt[2] -> MemRef[2] }
{ Stmt[i0] -> MemRef[i0] : 0 <= i0 < 3 }

which both represent the same logical set. There is isl_map_coalesce which unfortunately does not guaranttee to get to any cannonical form.

Right. Dropping the constraints would work only if Stmt[0] -> MemRef[0]; is represented as Stmt[i0] -> MemRef[o0] : o0 = i0 and i0 = 1

P.S.: Btw, I'm not sure that it's safe to use optimizeDataLayoutMatrMulPattern in case A and B have constraints, since we build the corresponding AccessRelation from scratch and don't take old constraints into the account. Furthermore, probably, it'd require to modify the isolation algorithm.

[Meinersbur]

lib/Transform/ScheduleOptimizer.cpp

584–607 ↗

(On Diff #110173)

This is up to you, I am ok with both versions. The more important is to have a test case such that we can commit this.

For the long term, I think we should avoid code duplication and make single loop for this and the following code:

// Permutations of the three matmul loops: 3! = 6 possibilities.
int FirstDims[] = {0,0,1,1,2,2};
int SecondDims[] = {1,2,2,0,0,1};

for (int i = 0; i <= 6; i+=1) {
    auto PossibleMatMul = Universe.equate(isl::dim::in, FirstDims[i], isl::dim::out, 0).equate(isl::dim::in, SecondDims[i], isl::dim::out, 1);
    if (computeMatchedDimensions(AccMap, PossibleMatMul, FirstDims[i], SecondDims[i], FirstPos, SecondPos)
      return true;
}
return false;

Some minor speed-up might be possible:

int FirstDims[] = {0,0,1,1,2,2};
int SecondDims[] = {1,2,2,0,0,1};
for (int i = 0; i <= 6; i+=1) {
    if (FirstPos >= 0 && FirstPos != FirstDims[i])
      continue;
    if (SecondPos >= 0 && SecondPos != SecondDims[i])
      continue;

    auto PossibleMatMul = Universe.equate(isl::dim::in, FirstDims[i], isl::dim::out, 0).equate(isl::dim::in, SecondDims[i], isl::dim::out, 1);
    if (computeMatchedDimensions(AccMap, PossibleMatMul, FirstDims[i], SecondDims[i], FirstPos, SecondPos)
      return true;
}
return false;

[annanay25]

lib/Transform/ScheduleOptimizer.cpp

570–576 ↗

(On Diff #110173)

@Meinersbur ;
IMO it is necessary to ensure that there are exactly 2 out-dims. In the sense that, the access is of the form -

Stmt[i0, i1, i2] -> MemRef[o0, o1]

and should have two constraints, one each for o0 and o1. Ex:
o0 = i0 and o1 = i1

604 ↗

(On Diff #110173)

I am not familiar with the usage of optimizeDataLayoutMatrMulPattern function. If you think it is a cleaner way of doing this I will look into it, thanks!

[Meinersbur]

lib/Transform/ScheduleOptimizer.cpp

570–576 ↗

(On Diff #110173)

isl_map_is_equal will test whether "o0 = i0" and "o1 = i1" are true.

Having exactly two constraints is neither a sufficient nor necessary condition. E.g.
{ Stmt[i0, i1, i2] -> MemRef[o0, o1] : o0 = i0 and i1 = 5 and o1= 5 }
fulfills the condition, and
[p0] -> { Stmt[i0, i1, i2] -> MemRef[o0, o1] : o0 = i0 and i1 = p0 }
does not.

[annanay25]

lib/Transform/ScheduleOptimizer.cpp

570–576 ↗

(On Diff #110173)

Yes, okay I agree.

When I remove this check and run check-polly , I get a failing test case (polly/test/ScheduleOptimizer/2012-04-16-Trivially-vectorizable-loops.ll) with AccMap as follows -

{ Stmt_for_body8[i0, i1, i2] -> MemRef_C[o0] : o0 = 1536i0 + i1 }

This is because of the Universe.equate(isl::dim::in, FirstDims[i], isl::dim::out, 0).equate(isl::dim::in, SecondDims[i], isl::dim::out, 1).

[annanay25]

@Meinersbur ;

So the reason I haven't been able to come up with a test case is

(lldb) po isl_map_dump(AccMap.ptr)                                                                                                                                                
{ Stmt_loop_body_reduction[i0, i1, i2] -> MemRef_retval[o0, o1] : (i2 = 783 and o0 = i0 and o1 = i1 and i1 <= 1 - i0 and i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 1) or (i0 = 1 and i1 = 1 and i2 = 783 and o0 = 1 and o1 = 1) }
(lldb) po isl_map_dump(PossibleMatMul.ptr)                                                                                                                                           
{ Stmt_loop_body_reduction[i0, i1, i2] -> MemRef_retval[o0, o1] : o0 = i0 and o1 = i1 and i0 >= 0 and i0 <= 1 and i1 >= 0 and i1 <= 1 and i2 >= 0 and i2 <= 783 }

These two maps are not detected as equal - AccMap.is_equal(PossibleMatMul) is false.

Tried removing extra dims / retaining constraints having only two input dims / etc.

Reason: o0 = 1 and o1 = 1 and i0 = 1 and i1 = 1 != o0 = i0 and o1 = i1.

[annanay25]

[todo] Test case.

[Meinersbur]

Can you add a test case using -polly-import=jscop?

lib/Transform/ScheduleOptimizer.cpp

537 ↗

(On Diff #110692)

nice!

562 ↗

(On Diff #110692)

[Compiler error] RedAccMap is not defined anywhere. Did you mean AccMap?

[annanay25]

Added test case.

[annanay25]

Addressed @Meinersbur's comments.

Removed test case dependency on DeLICM.

[gareevroman]

lib/Transform/ScheduleOptimizer.cpp

604 ↗

(On Diff #110173)

Sorry, for some reason, I haven't received this comment. However, optimizeDataLayoutMatrMulPattern is used by Polly. I'll try to check and, probably, update optimizeDataLayoutMatrMulPattern, when I have time.

P.S.: Btw, I'm not sure that it's safe to use optimizeDataLayoutMatrMulPattern in case A and B have constraints, since we build the corresponding AccessRelation from scratch and don't take old constraints into the account. Furthermore, probably, it'd require to modify the isolation algorithm.

@Meinersbur are you sure that it's always safe to use this detection?

[Meinersbur]

lib/Transform/ScheduleOptimizer.cpp

604 ↗

(On Diff #110173)

Can you elaborate on your concerns? The check should do the same as before, except not requiring inspection of the isl_map's internal representation, thus also accepting internal representations that are equivalent.

If you mean constraints on parameters or domains, then we'd have the same problems as before, because such constraints are gist'ed away for the access relation.

polly/trunk/lib/Transform/ScheduleOptimizer.cpp

for (int i = Dims - 1; i >= 0; i--)
     if (Node.band_member_get_coincident(i)) {
       Node = prevectSchedBand(Node, i, PrevectorWidth);
       break;
     }
 
   return Node;
 }
 
-/// Get the position of a dimension with a non-zero coefficient.
-///
-/// Check that isl constraint @p Constraint has only one non-zero
-/// coefficient for dimensions that have type @p DimType. If this is true,
-/// return the position of the dimension corresponding to the non-zero
-/// coefficient and negative value, otherwise.
-///
-/// @param Constraint The isl constraint to be checked.
-/// @param DimType    The type of the dimensions.
-/// @return           The position of the dimension in case the isl
-///                   constraint satisfies the requirements, a negative
-///                   value, otherwise.
-static int getMatMulConstraintDim(isl::constraint Constraint,
-                                  isl::dim DimType) {
-  int DimPos = -1;
-  auto LocalSpace = Constraint.get_local_space();
-  int LocalSpaceDimNum = LocalSpace.dim(DimType);
-  for (int i = 0; i < LocalSpaceDimNum; i++) {
-    auto Val = Constraint.get_coefficient_val(DimType, i);
-    if (Val.is_zero())
-      continue;
-    if (DimPos >= 0 || (DimType == isl::dim::out && !Val.is_one()) ||
-        (DimType == isl::dim::in && !Val.is_negone()))
-      return -1;
-    DimPos = i;
-  }
-  return DimPos;
-}
-
-/// Check the form of the isl constraint.
-///
-/// Check that the @p DimInPos input dimension of the isl constraint
-/// @p Constraint has a coefficient that is equal to negative one, the @p
-/// DimOutPos has a coefficient that is equal to one and others
-/// have coefficients equal to zero.
-///
-/// @param Constraint The isl constraint to be checked.
-/// @param DimInPos   The input dimension of the isl constraint.
-/// @param DimOutPos  The output dimension of the isl constraint.
-/// @return           isl_stat_ok in case the isl constraint satisfies
-///                   the requirements, isl_stat_error otherwise.
-static isl_stat isMatMulOperandConstraint(isl::constraint Constraint,
-                                          int &DimInPos, int &DimOutPos) {
-  auto Val = Constraint.get_constant_val();
-  if (!isl_constraint_is_equality(Constraint.get()) || !Val.is_zero())
-    return isl_stat_error;
-  DimInPos = getMatMulConstraintDim(Constraint, isl::dim::in);
-  if (DimInPos < 0)
-    return isl_stat_error;
-  DimOutPos = getMatMulConstraintDim(Constraint, isl::dim::out);
-  if (DimOutPos < 0)
-    return isl_stat_error;
-  return isl_stat_ok;
-}
-
 /// Permute the two dimensions of the isl map.
 ///
 /// Permute @p DstPos and @p SrcPos dimensions of the isl map @p Map that
 /// have type @p DimType.
 ///
 /// @param Map     The isl map to be modified.
 /// @param DimType The type of the dimensions.
 /// @param DstPos  The first dimension.

 ///
 /// @param AccMap    The access relation to be checked.
 /// @param FirstPos  The index of the input dimension that is mapped to
 ///                  the first output dimension.
 /// @param SecondPos The index of the input dimension that is mapped to the
 ///                  second output dimension.
 /// @return          True in case @p AccMap has the expected form and false,
 ///                  otherwise.
-static bool isMatMulOperandAcc(isl::map AccMap, int &FirstPos, int &SecondPos) {
-  int DimInPos[] = {FirstPos, SecondPos};
-  auto Lambda = [=, &DimInPos](isl::basic_map BasicMap) -> isl::stat {
-    auto Constraints = BasicMap.get_constraint_list();
-    if (isl_constraint_list_n_constraint(Constraints.get()) != 2)
-      return isl::stat::error;
-    for (int i = 0; i < 2; i++) {
-      auto Constraint =
-          isl::manage(isl_constraint_list_get_constraint(Constraints.get(), i));
-      int InPos, OutPos;
-      if (isMatMulOperandConstraint(Constraint, InPos, OutPos) ==
-              isl_stat_error ||
-          OutPos > 1 || (DimInPos[OutPos] >= 0 && DimInPos[OutPos] != InPos))
-        return isl::stat::error;
-      DimInPos[OutPos] = InPos;
-    }
-    return isl::stat::ok;
-  };
-  if (AccMap.foreach_basic_map(Lambda) != isl::stat::ok || DimInPos[0] < 0 ||
-      DimInPos[1] < 0)
+static bool isMatMulOperandAcc(isl::set Domain, isl::map AccMap, int &FirstPos,
+                               int &SecondPos) {
+
+  isl::space Space = AccMap.get_space();
+  isl::map Universe = isl::map::universe(Space);
+
+  if (Space.dim(isl::dim::out) != 2)
     return false;
-  FirstPos = DimInPos[0];
-  SecondPos = DimInPos[1];
+
+  // MatMul has the form:
+  // for (i = 0; i < N; i++)
+  //   for (j = 0; j < M; j++)
+  //     for (k = 0; k < P; k++)
+  //       C[i, j] += A[i, k] * B[k, j]
+  //
+  // Permutation of three outer loops: 3! = 6 possibilities.
+  int FirstDims[] = {0, 0, 1, 1, 2, 2};
+  int SecondDims[] = {1, 2, 2, 0, 0, 1};
+  for (int i = 0; i < 6; i += 1) {
+    auto PossibleMatMul =
+        Universe.equate(isl::dim::in, FirstDims[i], isl::dim::out, 0)
+            .equate(isl::dim::in, SecondDims[i], isl::dim::out, 1);
+
+    AccMap = AccMap.intersect_domain(Domain);
+    PossibleMatMul = PossibleMatMul.intersect_domain(Domain);
+
+    // If AccMap spans entire domain (Non-partial write),
+    // compute FirstPos and SecondPos.
+    // If AccMap != PossibleMatMul here (the two maps have been gisted at
+    // this point), it means that the writes are not complete, or in other
+    // words, it is a Partial write and Partial writes must be rejected.
+    if (AccMap.is_equal(PossibleMatMul)) {
+      if (FirstPos != -1 && FirstPos != FirstDims[i])
+        continue;
+      FirstPos = FirstDims[i];
+      if (SecondPos != -1 && SecondPos != SecondDims[i])
+        continue;
+      SecondPos = SecondDims[i];
       return true;
     }
+  }
+
+  return false;
+}
 
 /// Does the memory access represent a non-scalar operand of the matrix
 /// multiplication.
 ///
 /// Check that the memory access @p MemAccess is the read access to a non-scalar
 /// operand of the matrix multiplication or its result.
 ///
 /// @param MemAccess The memory access to be checked.
 /// @param MMI       Parameters of the matrix multiplication operands.
 /// @return          True in case the memory access represents the read access
 ///                  to a non-scalar operand of the matrix multiplication and
 ///                  false, otherwise.
 static bool isMatMulNonScalarReadAccess(MemoryAccess *MemAccess,
                                         MatMulInfoTy &MMI) {
   if (!MemAccess->isLatestArrayKind() || !MemAccess->isRead())
     return false;
   auto AccMap = MemAccess->getLatestAccessRelation();
-  if (isMatMulOperandAcc(AccMap, MMI.i, MMI.j) && !MMI.ReadFromC &&
-      isl_map_n_basic_map(AccMap.get()) == 1) {
+  isl::set StmtDomain = MemAccess->getStatement()->getDomain();
+  if (isMatMulOperandAcc(StmtDomain, AccMap, MMI.i, MMI.j) && !MMI.ReadFromC) {
     MMI.ReadFromC = MemAccess;
     return true;
   }
-  if (isMatMulOperandAcc(AccMap, MMI.i, MMI.k) && !MMI.A &&
-      isl_map_n_basic_map(AccMap.get()) == 1) {
+  if (isMatMulOperandAcc(StmtDomain, AccMap, MMI.i, MMI.k) && !MMI.A) {
     MMI.A = MemAccess;
     return true;
   }
-  if (isMatMulOperandAcc(AccMap, MMI.k, MMI.j) && !MMI.B &&
-      isl_map_n_basic_map(AccMap.get()) == 1) {
+  if (isMatMulOperandAcc(StmtDomain, AccMap, MMI.k, MMI.j) && !MMI.B) {
     MMI.B = MemAccess;
     return true;
   }
   return false;
 }
 
 /// Check accesses to operands of the matrix multiplication.
 ///
static bool containsMatrMult(isl::map PartialSchedule, const Dependences *D,
   auto Accesses = getAccessesInOrder(*Stmt);
   for (auto *MemA = Accesses.end() - 1; MemA != Accesses.begin(); MemA--) {
     auto *MemAccessPtr = *MemA;
     if (!MemAccessPtr->isLatestArrayKind())
       continue;
     if (!MemAccessPtr->isWrite())
       return false;
     auto AccMap = MemAccessPtr->getLatestAccessRelation();
-    if (isl_map_n_basic_map(AccMap.get()) != 1 ||
-        !isMatMulOperandAcc(AccMap, MMI.i, MMI.j))
+    if (!isMatMulOperandAcc(Stmt->getDomain(), AccMap, MMI.i, MMI.j))
       return false;
     MMI.WriteToC = MemAccessPtr;
     break;
   }
 
   if (!containsOnlyMatMulDep(PartialSchedule, D, MMI.k))
     return false;
 

polly/trunk/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap.ll

+; RUN: opt %loadPolly -polly-import-jscop -polly-import-jscop-postfix=transformed -polly-opt-isl -debug-only=polly-opt-isl -disable-output < %s 2>&1 | FileCheck %s
+; REQUIRES: asserts
+;
+; void pattern_matching_based_opts_splitmap(double C[static const restrict 2][2], double A[static const restrict 2][784], double B[static const restrict 784][2]) {
+;  for (int i = 0; i < 2; i+=1)
+;    for (int j = 0; j < 2; j+=1)
+;      for (int k = 0; k < 784; k+=1)
+;        C[i][j] += A[i][k] * B[k][j];
+;}
+;
+; Check that the pattern matching detects the matrix multiplication pattern
+; when the AccMap cannot be reduced to a single disjunct.
+;
+; CHECK: The matrix multiplication pattern was detected
+;
+; ModuleID = 'pattern_matching_based_opts_splitmap.ll'
+;
+; Function Attrs: noinline nounwind uwtable
+define void @pattern_matching_based_opts_splitmap([2 x double]* noalias dereferenceable(32) %C, [784 x double]* noalias dereferenceable(12544) %A, [2 x double]* noalias dereferenceable(12544) %B) {
+entry:
+  br label %for.body
+
+for.body:                                         ; preds = %entry, %for.inc21
+  %i = phi i64 [ 0, %entry ], [ %add22, %for.inc21 ]
+  br label %for.body3
+
+for.body3:                                        ; preds = %for.body, %for.inc18
+  %j = phi i64 [ 0, %for.body ], [ %add19, %for.inc18 ]
+  br label %for.body6
+
+for.body6:                                        ; preds = %for.body3, %for.body6
+  %k = phi i64 [ 0, %for.body3 ], [ %add17, %for.body6 ]
+  %arrayidx8 = getelementptr inbounds [784 x double], [784 x double]* %A, i64 %i, i64 %k
+  %tmp6 = load double, double* %arrayidx8, align 8
+  %arrayidx12 = getelementptr inbounds [2 x double], [2 x double]* %B, i64 %k, i64 %j
+  %tmp10 = load double, double* %arrayidx12, align 8
+  %mul = fmul double %tmp6, %tmp10
+  %arrayidx16 = getelementptr inbounds [2 x double], [2 x double]* %C, i64 %i, i64 %j
+  %tmp14 = load double, double* %arrayidx16, align 8
+  %add = fadd double %tmp14, %mul
+  store double %add, double* %arrayidx16, align 8
+  %add17 = add nsw i64 %k, 1
+  %cmp5 = icmp slt i64 %add17, 784
+  br i1 %cmp5, label %for.body6, label %for.inc18
+
+for.inc18:                                        ; preds = %for.body6
+  %add19 = add nsw i64 %j, 1
+  %cmp2 = icmp slt i64 %add19, 2
+  br i1 %cmp2, label %for.body3, label %for.inc21
+
+for.inc21:                                        ; preds = %for.inc18
+  %add22 = add nsw i64 %i, 1
+  %cmp = icmp slt i64 %add22, 2
+  br i1 %cmp, label %for.body, label %for.end23
+
+for.end23:                                        ; preds = %for.inc21
+  ret void
+}
+

polly/trunk/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap___%for.body---%for.end23.jscop

+{
+   "arrays" : [
+      {
+         "name" : "MemRef_A",
+         "sizes" : [ "*", "784" ],
+         "type" : "double"
+      },
+      {
+         "name" : "MemRef_B",
+         "sizes" : [ "*", "2" ],
+         "type" : "double"
+      },
+      {
+         "name" : "MemRef_C",
+         "sizes" : [ "*", "2" ],
+         "type" : "double"
+      }
+   ],
+   "context" : "{  :  }",
+   "name" : "%for.body---%for.end23",
+   "statements" : [
+      {
+         "accesses" : [
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_A[i0, i2] }"
+            },
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_B[i2, i1] }"
+            },
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_C[i0, i1] }"
+            },
+            {
+               "kind" : "write",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_C[i0, i1] }"
+            }
+         ],
+         "domain" : "{ Stmt_for_body6[i0, i1, i2] : 0 <= i0 <= 1 and 0 <= i1 <= 1 and 0 <= i2 <= 783 }",
+         "name" : "Stmt_for_body6",
+         "schedule" : "{ Stmt_for_body6[i0, i1, i2] -> [i0, i1, i2] }"
+      }
+   ]
+}

polly/trunk/test/ScheduleOptimizer/pattern_matching_based_opts_splitmap___%for.body---%for.end23.jscop.transformed

+{
+   "arrays" : [
+      {
+         "name" : "MemRef_A",
+         "sizes" : [ "*", "784" ],
+         "type" : "double"
+      },
+      {
+         "name" : "MemRef_B",
+         "sizes" : [ "*", "2" ],
+         "type" : "double"
+      },
+      {
+         "name" : "MemRef_C",
+         "sizes" : [ "*", "2" ],
+         "type" : "double"
+      }
+   ],
+   "context" : "{  :  }",
+   "name" : "%for.body---%for.end23",
+   "statements" : [
+      {
+         "accesses" : [
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_A[i0, i2] }"
+            },
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_B[i2, i1] }"
+            },
+            {
+               "kind" : "read",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_C[i0, i1] }"
+            },
+            {
+               "kind" : "write",
+               "relation" : "{ Stmt_for_body6[i0, i1, i2] -> MemRef_C[i0, i1] : i2 <= 784 - i0 - i1; Stmt_for_body6[1, 1, 783] -> MemRef_C[1, 1] }"
+            }
+         ],
+         "domain" : "{ Stmt_for_body6[i0, i1, i2] : 0 <= i0 <= 1 and 0 <= i1 <= 1 and 0 <= i2 <= 783 }",
+         "name" : "Stmt_for_body6",
+         "schedule" : "{ Stmt_for_body6[i0, i1, i2] -> [i0, i1, i2] }"
+      }
+   ]
+}