[Matrix] Add info about number of operations to remarks.

[fhahn]

Summary

This patch updates the remark to also include a summary of the number of
vector operations generated for each matrix expression.

[merge_guards_bot]

Unit tests: fail. 61731 tests passed, 1 failed and 779 were skipped.

failed: LLVM.Transforms/LowerMatrixIntrinsics/remarks.ll

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[fhahn]

Handle re-used expressions.

[merge_guards_bot]

Unit tests: pass. 61764 tests passed, 0 failed and 780 were skipped.

clang-tidy: fail. Please fix clang-tidy findings.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[fhahn]

ping

[andreadb]

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

150–156

So, you are creating a copy of Other.
Then modifying that copy.
Then returning it by copy. So, there are two copies involved in this computation.

Did you mean this to be a non mutating function? If so, then it should be marked as const. Otherwise, if the intention was to mutate the this fields then you don't need those copies.

I am writing this because - at least for what I can see - the only use of add() is at line 1208

OpInfoTy Count = CM->second.getOpInfo();
for (Value *Op : cast<Instruction>(Root)->operand_values())
  Count = Count.add(sumOpInfos(Op, ReusedExprs));
return Count;

Since Count is assigned to by each iteration, you end up with yet another "copy".
But more importantly, maybe the intention was to make add() a mutating function.
In which case you could use a += operator instead.

[andreadb]

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

150–156

Sorry, the first sentence is incorrect. It should have been "So, you are creating a copy of this".

[fhahn]

Replace OpInfoTy::add with a += operator implementation.

[fhahn]

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

150–156

Thanks for taking a look! You are right, having a += operator would make more sense. I've updated the patch.

[merge_guards_bot]

Unit tests: pass. 61931 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[fhahn]

ping

[anemet]

LGTM!

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

142

Add a comment please.

llvm/lib/Transforms/Scalar/LowerMatrixIntrinsics.cpp

 ///    obsolete instructions.
 ///
 class LowerMatrixIntrinsics {
   Function &Func;
   const DataLayout &DL;
   const TargetTransformInfo &TTI;
   OptimizationRemarkEmitter &ORE;
 
+  struct OpInfoTy {
+    /// Number of stores emitted to generate this matrix.
+    unsigned NumStores = 0;
+    /// Number of loads emitted to generate this matrix.
+    unsigned NumLoads = 0;
+    /// Number of compute operations emitted to generate this matrix.
+    unsigned NumComputeOps = 0;
+
+    OpInfoTy &operator+=(const OpInfoTy &RHS) {
+      NumStores += RHS.NumStores;
+      NumLoads += RHS.NumLoads;
+      NumComputeOps += RHS.NumComputeOps;
+      return *this;
+    }
+  };
+
   /// Wrapper class representing a matrix as a set of column vectors.
   /// All column vectors must have the same vector type.
   class ColumnMatrixTy {
     SmallVector<Value *, 16> Columns;
 
+    OpInfoTy OpInfo;
+
   public:
     ColumnMatrixTy() : Columns() {}
     ColumnMatrixTy(ArrayRef<Value *> Cols)
         : Columns(Cols.begin(), Cols.end()) {}
 
     Value *getColumn(unsigned i) const { return Columns[i]; }
 
     void setColumn(unsigned i, Value *V) { Columns[i] = V; }
 
     size_t getNumColumns() const { return Columns.size(); }
     size_t getNumRows() const {
       assert(Columns.size() > 0 && "Cannot call getNumRows without columns");
       return cast<VectorType>(Columns[0]->getType())->getNumElements();
     }
 
     const SmallVectorImpl<Value *> &getColumnVectors() const { return Columns; }
 
     SmallVectorImpl<Value *> &getColumnVectors() { return Columns; }
 
     void addColumn(Value *V) { Columns.push_back(V); }
 
+    VectorType *getColumnTy() {
+      return cast<VectorType>(Columns[0]->getType());
+    }
+
     iterator_range<SmallVector<Value *, 8>::iterator> columns() {
       return make_range(Columns.begin(), Columns.end());
     }
 
     /// Embed the columns of the matrix into a flat vector by concatenating
     /// them.
     Value *embedInVector(IRBuilder<> &Builder) const {
       return Columns.size() == 1 ? Columns[0]
                                  : concatenateVectors(Builder, Columns);
     }
+
+    ColumnMatrixTy &addNumLoads(unsigned N) {
+      OpInfo.NumLoads += N;
+      return *this;
+    }
+
+    void setNumLoads(unsigned N) { OpInfo.NumLoads = N; }
+
+    ColumnMatrixTy &addNumStores(unsigned N) {
+      OpInfo.NumStores += N;
+      return *this;
+    }
+
+    ColumnMatrixTy &addNumComputeOps(unsigned N) {
+      OpInfo.NumComputeOps += N;
+      return *this;
+    }
+
+    unsigned getNumStores() const { return OpInfo.NumStores; }
+    unsigned getNumLoads() const { return OpInfo.NumLoads; }
+    unsigned getNumComputeOps() const { return OpInfo.NumComputeOps; }
+
+    const OpInfoTy &getOpInfo() const { return OpInfo; }
   };
 
   struct ShapeInfo {
     unsigned NumRows;
     unsigned NumColumns;
 
     ShapeInfo(unsigned NumRows = 0, unsigned NumColumns = 0)
         : NumRows(NumRows), NumColumns(NumColumns) {}
class LowerMatrixIntrinsics {
   /// Map from instructions to their produced column matrix.
   MapVector<Value *, ColumnMatrixTy> Inst2ColumnMatrix;
 
 public:
   LowerMatrixIntrinsics(Function &F, TargetTransformInfo &TTI,
                         OptimizationRemarkEmitter &ORE)
       : Func(F), DL(F.getParent()->getDataLayout()), TTI(TTI), ORE(ORE) {}
 
+  unsigned getNumOps(Type *VT) {
+    assert(isa<VectorType>(VT) && "Expected vector type");
+    return getNumOps(VT->getScalarType(),
+                     cast<VectorType>(VT)->getNumElements());
+  }
+
+  //
+  /// Return the estimated number of vector ops required for an operation on
+  /// \p VT * N.
+  unsigned getNumOps(Type *ST, unsigned N) {
+    return std::ceil((ST->getPrimitiveSizeInBits() * N).getFixedSize() /
+                     double(TTI.getRegisterBitWidth(true)));
+  }
+
   /// Return the set of column vectors that a matrix value is lowered to.
   ///
   /// If we lowered \p MatrixVal, just return the cache result column matrix.
   /// Otherwie split the flat vector \p MatrixVal containing a matrix with
   /// shape \p SI into column vectors.
   ColumnMatrixTy getMatrix(Value *MatrixVal, const ShapeInfo &SI,
                            IRBuilder<> Builder) {
     VectorType *VType = dyn_cast<VectorType>(MatrixVal->getType());
void LowerLoad(Instruction *Inst, Value *Ptr, Value *Stride,
     for (unsigned C = 0, E = Shape.NumColumns; C < E; ++C) {
       Value *GEP =
           computeColumnAddr(EltPtr, Builder.getInt32(C), Stride, Shape.NumRows,
                             VType->getElementType(), Builder);
       Value *Column = createColumnLoad(GEP, VType->getElementType(), Builder);
       Result.addColumn(Column);
     }
 
-    finalizeLowering(Inst, Result, Builder);
+    finalizeLowering(Inst,
+                     Result.addNumLoads(getNumOps(Result.getColumnTy()) *
+                                        Result.getNumColumns()),
+                     Builder);
   }
 
   /// Lowers llvm.matrix.columnwise.load.
   ///
   /// The intrinsic loads a matrix from memory using a stride between columns.
   void LowerColumnwiseLoad(CallInst *Inst) {
     Value *Ptr = Inst->getArgOperand(0);
     Value *Stride = Inst->getArgOperand(1);
     LowerLoad(Inst, Ptr, Stride,
               {Inst->getArgOperand(2), Inst->getArgOperand(3)});
   }
 
   void LowerStore(Instruction *Inst, Value *Matrix, Value *Ptr, Value *Stride,
                   ShapeInfo Shape) {
     IRBuilder<> Builder(Inst);
     auto VType = cast<VectorType>(Matrix->getType());
     Value *EltPtr = createElementPtr(Ptr, VType->getElementType(), Builder);
     auto LM = getMatrix(Matrix, Shape, Builder);
     for (auto C : enumerate(LM.columns())) {
       Value *GEP =
           computeColumnAddr(EltPtr, Builder.getInt32(C.index()), Stride,
                             Shape.NumRows, VType->getElementType(), Builder);
       createColumnStore(C.value(), GEP, VType->getElementType(), Builder);
     }
-    Inst2ColumnMatrix[Inst] = ColumnMatrixTy();
+    Inst2ColumnMatrix[Inst] = ColumnMatrixTy().addNumStores(
+        getNumOps(LM.getColumnTy()) * LM.getNumColumns());
 
     ToRemove.push_back(Inst);
   }
 
   /// Lowers llvm.matrix.columnwise.store.
   ///
   /// The intrinsic store a matrix back memory using a stride between columns.
   void LowerColumnwiseStore(CallInst *Inst) {
for (; i < VecNumElts; i++)
       Mask.push_back(Builder.getInt32(i));
 
     Value *MaskVal = ConstantVector::get(Mask);
 
     return Builder.CreateShuffleVector(Col, Block, MaskVal);
   }
 
   Value *createMulAdd(Value *Sum, Value *A, Value *B, bool UseFPOp,
-                      IRBuilder<> &Builder, bool AllowContraction) {
-
+                      IRBuilder<> &Builder, bool AllowContraction,
+                      unsigned &NumComputeOps) {
+    NumComputeOps += getNumOps(A->getType());
     if (!Sum)
       return UseFPOp ? Builder.CreateFMul(A, B) : Builder.CreateMul(A, B);
 
     if (UseFPOp) {
       if (AllowContraction) {
         // Use fmuladd for floating point operations and let the backend decide
         // if that's profitable.
         Value *FMulAdd = Intrinsic::getDeclaration(
             Func.getParent(), Intrinsic::fmuladd, A->getType());
         return Builder.CreateCall(FMulAdd, {A, B, Sum});
       }
+      NumComputeOps += getNumOps(A->getType());
       Value *Mul = Builder.CreateFMul(A, B);
       return Builder.CreateFAdd(Sum, Mul);
     }
 
+    NumComputeOps += getNumOps(A->getType());
     Value *Mul = Builder.CreateMul(A, B);
     return Builder.CreateAdd(Sum, Mul);
   }
 
   /// Cache \p Matrix as result of \p Inst and update the uses of \p Inst. For
   /// users with shape information, there's nothing to do: the will use the
   /// cached value when they are lowered. For other users, \p Matrix is
   /// flattened and the uses are updated to use it. Also marks \p Inst for
for (unsigned J = 0; J < C; ++J)
       Result.addColumn(UndefValue::get(VectorType::get(EltType, R)));
 
     const unsigned VF = std::max(TTI.getRegisterBitWidth(true) /
                                      EltType->getPrimitiveSizeInBits(),
                                  uint64_t(1));
 
     bool AllowContract = AllowContractEnabled || (isa<FPMathOperator>(MatMul) &&
                                                   MatMul->hasAllowContract());
+    unsigned NumComputeOps = 0;
     // Multiply columns from the first operand with scalars from the second
     // operand.  Then move along the K axes and accumulate the columns.  With
     // this the adds can be vectorized without reassociation.
     for (unsigned J = 0; J < C; ++J) {
       unsigned BlockSize = VF;
       for (unsigned I = 0; I < R; I += BlockSize) {
         // Gradually lower the vectorization factor to cover the remainder.
         while (I + BlockSize > R)
           BlockSize /= 2;
 
         Value *Sum = nullptr;
         for (unsigned K = 0; K < M; ++K) {
           Value *L = extractVector(Lhs, I, K, BlockSize, Builder);
           Value *RH = Builder.CreateExtractElement(Rhs.getColumn(J), K);
           Value *Splat = Builder.CreateVectorSplat(BlockSize, RH, "splat");
           Sum = createMulAdd(Sum, L, Splat, EltType->isFloatingPointTy(),
-                             Builder, AllowContract);
+                             Builder, AllowContract, NumComputeOps);
         }
         Result.setColumn(J, insertVector(Result.getColumn(J), I, Sum, Builder));
       }
     }
+    Result.addNumComputeOps(NumComputeOps);
     finalizeLowering(MatMul, Result, Builder);
   }
 
   /// Lowers llvm.matrix.transpose.
   void LowerTranspose(CallInst *Inst) {
     ColumnMatrixTy Result;
     IRBuilder<> Builder(Inst);
     Value *InputVal = Inst->getArgOperand(0);
for (unsigned Row = 0; Row < ArgShape.NumRows; ++Row) {
         // We insert at index Column since that is the row index after the
         // transpose.
         ResultColumn =
             Builder.CreateInsertElement(ResultColumn, Elt, C.index());
       }
       Result.addColumn(ResultColumn);
     }
 
-    finalizeLowering(Inst, Result, Builder);
+    // TODO: Improve estimate of operations needed for transposes. Currently we
+    // just count the insertelement/extractelement instructions, but do not
+    // account for later simplifications/combines.
+    finalizeLowering(
+        Inst,
+        Result.addNumComputeOps(2 * ArgShape.NumRows * ArgShape.NumColumns),
+        Builder);
   }
 
   /// Lower load instructions, if shape information is available.
   bool VisitLoad(Instruction *Inst, Value *Ptr, IRBuilder<> &Builder) {
     auto I = ShapeMap.find(Inst);
     if (I == ShapeMap.end())
       return false;
 
auto BuildColumnOp = [&Builder, Inst](Value *LHS, Value *RHS) {
       default:
         llvm_unreachable("Unsupported binary operator for matrix");
       }
     };
     for (unsigned C = 0; C < Shape.NumColumns; ++C)
       Result.addColumn(
           BuildColumnOp(LoweredLhs.getColumn(C), LoweredRhs.getColumn(C)));
 
-    finalizeLowering(Inst, Result, Builder);
+    finalizeLowering(Inst,
+                     Result.addNumComputeOps(getNumOps(Result.getColumnTy()) *
+                                             Result.getNumColumns()),
+                     Builder);
     return true;
   }
 
   /// Helper to linearize a matrix expression tree into a string. Currently
   /// matrix expressions are linarized by starting at an expression leaf and
   /// linearizing bottom up.
   struct ExprLinearizer {
     unsigned LengthToBreak = 100;
SmallVector<Value *, 4> getExpressionLeaves() {
       SmallVector<Value *, 4> Leaves;
       for (auto &KV : Inst2ColumnMatrix)
         if (KV.first->getType()->isVoidTy())
           Leaves.push_back(KV.first);
 
       return Leaves;
     }
 
+    /// Calculate the number of exclusive and shared op counts for expression
+    /// starting at \p V. Expressions used multiple times are counted once.
+    OpInfoTy sumOpInfos(Value *Root, SmallPtrSetImpl<Value *> &ReusedExprs) {
+      auto CM = Inst2ColumnMatrix.find(Root);
+      if (CM == Inst2ColumnMatrix.end())
+        return {};
+
+      // Already counted this expression. Stop.
+      if (!ReusedExprs.insert(Root).second)
+        return {};
+
+      OpInfoTy Count = CM->second.getOpInfo();
+      for (Value *Op : cast<Instruction>(Root)->operand_values())
+        Count += sumOpInfos(Op, ReusedExprs);
+      return Count;
+    }
+
     void emitRemarks() {
       if (!ORE.allowExtraAnalysis(DEBUG_TYPE))
         return;
 
       // Find leafs of matrix expressions.
       auto Leaves = getExpressionLeaves();
 
       // Generate remarks for each leaf.
       for (auto *L : Leaves) {
+        SmallPtrSet<Value *, 8> ReusedExprs;
+        auto Counts = sumOpInfos(L, ReusedExprs);
         OptimizationRemark Rem(DEBUG_TYPE, "matrix-lowered",
                                cast<Instruction>(L)->getDebugLoc(),
                                cast<Instruction>(L)->getParent());
-        Rem << "Lowered matrix expression ";
+        Rem << "Lowered with ";
+        Rem << ore::NV("NumStores", Counts.NumStores) << " stores, "
+            << ore::NV("NumLoads", Counts.NumLoads) << " loads, "
+            << ore::NV("NumComputeOps", Counts.NumComputeOps) << " compute ops";
+
         Rem << ("\n" + linearize(L, DL));
         ORE.emit(Rem);
       }
     }
 
     std::string linearize(Value *L, const DataLayout &DL) {
       ExprLinearizer Lin(DL, Inst2ColumnMatrix);
       Lin.linearizeExpr(L, 0, false);

llvm/test/Transforms/LowerMatrixIntrinsics/remarks.ll

 ; RUN: opt -lower-matrix-intrinsics -pass-remarks=lower-matrix-intrinsics < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "aarch64-apple-ios"
 
-; CHECK-LABEL: remark: test.h:40:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:40:20: Lowered with 6 stores, 6 loads, 24 compute ops
 ; CHECK-NEXT: store(
 ; CHECK-NEXT:  transpose.2x6.double(load(addr %A)),
 ; CHECK-NEXT:  addr %B)
 define void @transpose(<12 x double>* %A, <12 x double>* %B) !dbg !23 {
   %load = load <12 x double>, <12 x double>* %A, !dbg !24
   %t = call <12 x double> @llvm.matrix.transpose.v12f64.v12f64(<12 x double> %load, i32 2, i32 6), !dbg !24
   store <12 x double> %t, <12 x double>* %B, !dbg !24
   ret void
 }
 
 declare <12 x double> @llvm.matrix.transpose.v12f64.v12f64(<12 x double>, i32, i32)
 
 
-; CHECK-LABEL: remark: test.h:50:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:50:20: Lowered with 2 stores, 12 loads, 22 compute ops
 ; CHECK-NEXT:  store(
 ; CHECK-NEXT:   multiply.2x6.6x2.double(
 ; CHECK-NEXT:    load(addr %A),
 ; CHECK-NEXT:    load(addr %B)),
 ; CHECK-NEXT:   addr %C)
 define void @multiply(<12 x double>* %A, <12 x double>* %B, <4 x double>* %C) !dbg !25 {
   %A.matrix = load <12 x double>, <12 x double>* %A, !dbg !26
   %B.matrix = load <12 x double>, <12 x double>* %B, !dbg !26
   %t = call <4 x double> @llvm.matrix.multiply(<12 x double> %A.matrix, <12 x double> %B.matrix, i32 2, i32 6, i32 2), !dbg !26
   store <4 x double> %t, <4 x double>* %C, !dbg !26
   ret void
 }
 
 declare <4 x double> @llvm.matrix.multiply(<12 x double>, <12 x double>, i32, i32, i32)
 
-; CHECK-LABEL: remark: test.h:60:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:60:20: Lowered with 6 stores, 6 loads, 0 compute ops
 ; CHECK-NEXT:  store(
 ; CHECK-NEXT:   columnwise.load.3x3.double(addr %A, 5),
 ; CHECK-NEXT:   addr %B)
 define void @columnwise.load(<9 x double>* %A, <9 x double>* %B) !dbg !27 {
   %A.matrix = call <9 x double> @llvm.matrix.columnwise.load(<9 x double>* %A, i32 5, i32 3, i32 3), !dbg !28
   store <9 x double> %A.matrix, <9 x double>* %B, !dbg !28
   ret void
 }
 
 declare <9 x double> @llvm.matrix.columnwise.load(<9 x double>*, i32, i32, i32)
 
-; CHECK-LABEL: remark: test.h:70:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:70:20: Lowered with 6 stores, 6 loads, 0 compute ops
 ; CHECK-NEXT:  columnwise.store.3x3.double(
 ; CHECK-NEXT:   columnwise.load.3x3.double(addr %A, 5),
 ; CHECK-NEXT:   addr %B,
 ; CHECK-NEXT:   10)
 define void @columnwise.store(<9 x double>* %A, <9 x double>* %B) !dbg !29 {
   %A.matrix = call <9 x double> @llvm.matrix.columnwise.load(<9 x double>* %A, i32 5, i32 3, i32 3), !dbg !30
   call void @llvm.matrix.columnwise.store(<9 x double> %A.matrix, <9 x double>* %B, i32 10, i32 3, i32 3), !dbg !30
   ret void
 }
 
 declare void @llvm.matrix.columnwise.store(<9 x double>, <9 x double>*, i32, i32, i32)
 
-; CHECK-LABEL: remark: test.h:80:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:80:20: Lowered with 6 stores, 6 loads, 12 compute ops
 ; CHECK-NEXT:  columnwise.store.3x3.double(
 ; CHECK-NEXT:   fmul(
 ; CHECK-NEXT:    fadd(
 ; CHECK-NEXT:     columnwise.load.3x3.double(addr %A, 5)
 ; CHECK-NEXT:     (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:    (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:   addr %B,
 ; CHECK-NEXT:   10)
 
 define void @binaryops(<9 x double>* %A, <9 x double>* %B) !dbg !31 {
   %A.matrix = call <9 x double> @llvm.matrix.columnwise.load(<9 x double>* %A, i32 5, i32 3, i32 3), !dbg !32
   %R1.matrix = fadd <9 x double> %A.matrix, %A.matrix
   %R2.matrix = fmul <9 x double> %R1.matrix, %A.matrix
   call void @llvm.matrix.columnwise.store(<9 x double> %R2.matrix, <9 x double>* %B, i32 10, i32 3, i32 3), !dbg !32
   ret void
 }
 
-; CHECK-LABEL: remark: test.h:90:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:90:20: Lowered with 6 stores, 6 loads, 12 compute ops
 ; CHECK-NEXT:  columnwise.store.3x3.double(
 ; CHECK-NEXT:   fmul(
 ; CHECK-NEXT:    fadd(
 ; CHECK-NEXT:     columnwise.load.3x3.double(addr %A, 5)
 ; CHECK-NEXT:     (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:    (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:   addr %B,
 ; CHECK-NEXT:   10)
-; CHECK-NEXT:  remark: test.h:90:20: Lowered matrix expression
+; CHECK-NEXT:  remark: test.h:90:20: Lowered with 2 stores, 12 loads, 22 compute ops
 ; CHECK-NEXT:  store(
 ; CHECK-NEXT:   multiply.2x6.6x2.double(
 ; CHECK-NEXT:    load(addr %C),
 ; CHECK-NEXT:    load(addr %D)),
 ; CHECK-NEXT:   addr %E)
 
 define void @multiple_expressions(<9 x double>* %A, <9 x double>* %B, <12 x double>* %C, <12 x double>* %D, <4 x double>* %E) !dbg !33 {
   %A.matrix = call <9 x double> @llvm.matrix.columnwise.load(<9 x double>* %A, i32 5, i32 3, i32 3), !dbg !34
   %R1.matrix = fadd <9 x double> %A.matrix, %A.matrix
   %R2.matrix = fmul <9 x double> %R1.matrix, %A.matrix
   call void @llvm.matrix.columnwise.store(<9 x double> %R2.matrix, <9 x double>* %B, i32 10, i32 3, i32 3), !dbg !34
 
   %C.matrix = load <12 x double>, <12 x double>* %C, !dbg !34
   %D.matrix = load <12 x double>, <12 x double>* %D, !dbg !34
   %Mult.matrix = call <4 x double> @llvm.matrix.multiply(<12 x double> %C.matrix, <12 x double> %D.matrix, i32 2, i32 6, i32 2), !dbg !34
   store <4 x double> %Mult.matrix, <4 x double>* %E, !dbg !34
 
   ret void
 }
 
-; CHECK-LABEL: remark: test.h:100:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:100:20: Lowered with 6 stores, 6 loads, 12 compute ops
 ; CHECK-NEXT:  columnwise.store.3x3.double(
 ; CHECK-NEXT:   fmul(
 ; CHECK-NEXT:    fadd(
 ; CHECK-NEXT:     columnwise.load.3x3.double(addr %A, 5)
 ; CHECK-NEXT:     (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:    (reused) columnwise.load.3x3.double(addr %A, 5)),
 ; CHECK-NEXT:   stack addr %B,
 ; CHECK-NEXT:   10)
 define void @stackaddresses(<9 x double>* %A) !dbg !35 {
   %B = alloca <9 x double>
   %A.matrix = call <9 x double> @llvm.matrix.columnwise.load(<9 x double>* %A, i32 5, i32 3, i32 3), !dbg !36
   %R1.matrix = fadd <9 x double> %A.matrix, %A.matrix
   %R2.matrix = fmul <9 x double> %R1.matrix, %A.matrix
   call void @llvm.matrix.columnwise.store(<9 x double> %R2.matrix, <9 x double>* %B, i32 10, i32 3, i32 3), !dbg !36
   ret void
 }
 
-; CHECK-LABEL: remark: test.h:30:20: Lowered matrix expression
+; CHECK-LABEL: remark: test.h:30:20: Lowered with 10 stores, 9 loads, 30 compute ops
 ; CHECK-NEXT:  store(
 ; CHECK-NEXT:   transpose.5x3.double(load(addr %A)),
 ; CHECK-NEXT:   stack addr %s1)
 %S1 = type {<15 x double>*}
 define void @get_underlying_object(%S1* %A) !dbg !21 {
 entry:
   %s1 = alloca <15 x double>, !dbg !22
   %a1 = getelementptr %S1, %S1* %A, i32 0, i32 0, !dbg !22