[mlir][sparse] Remove the expansion of symmetric MTX in the sparse tensor storage.

[bixia]

Summary

We will support symmetric MTX without expanding the data in the sparse tensor
storage.

[aartbik]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

42–46

please add doc that reading in a symmetric matrix will result in lower/upper triangular and that proper symmetry support is TBD

mlir/include/mlir/ExecutionEngine/SparseTensor/File.h

169

I think it is okay to record the symmetric property, we just don't use it to do anything special (but in the future we still want to know this information)

303

keep this

mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h

251 ↗

(On Diff #497480)

keep this

mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp

880 ↗

(On Diff #497480)

keep

mlir/test/Integration/data/test_complex.mtx

1 ↗

(On Diff #497480)

we can still keep the symmetric flag, just to make sure we can read it

[aartbik]

mlir/lib/ExecutionEngine/SparseTensor/File.cpp

160 ↗

(On Diff #497480)

Oh, I would just record the property but then read the data is as if it were a regular matrix

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_file_io.mlir

43 ↗

(On Diff #497480)

keep

113 ↗

(On Diff #497480)

keep

[bixia]

Address review comment: keep symmetric property, keep two tests with symmetric input with TODO, add to doc about symmetric handling is TBD.

[aartbik]

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

42–46

did you

43–45

How about:

Reading in a symmetric matrix will result in just the lower/upper triangular part of
the matrix (so that only relevant information is stored). Proper symmetry support
for operating on symmetric matrices is still TBD.

52–53

does this fit on one line now?

[bixia]

Fix doc for symmetry. Fix assembly format.

mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorOps.td

 class SparseTensor_Op<string mnemonic, list<Trait> traits = []>
   : Op<SparseTensor_Dialect, mnemonic, traits>;
 
 //===----------------------------------------------------------------------===//
 // Sparse Tensor Operations.
 //===----------------------------------------------------------------------===//
 
 def SparseTensor_NewOp : SparseTensor_Op<"new", [Pure]>,
-    Arguments<(ins AnyType:$source, UnitAttr:$expandSymmetry)>,
+    Arguments<(ins AnyType:$source)>,
     Results<(outs AnySparseTensor:$result)> {
   string summary = "Materializes a new sparse tensor from given source";
   string description = [{
     Materializes a sparse tensor with contents taken from an opaque pointer
     provided by `source`. For targets that have access to a file system,
     for example, this pointer may be a filename (or file) of a sparse
     tensor in a particular external storage format. The form of the operation
     is kept deliberately very general to allow for alternative implementations
     in the future, such as pointers to buffers or runnable initialization
     code. The operation is provided as an anchor that materializes a properly
     typed sparse tensor with inital contents into a computation.
 
-    An optional attribute `expandSymmetry` can be used to extend this operation
-    to make symmetry in external formats explicit in the storage. That is, when
-    the attribute presents and a non-zero value is discovered at (i, j) where
-    i!=j, we add the same value to (j, i). This claims more storage than a pure
-    symmetric storage, and thus may cause a bad performance hit. True symmetric
-    storage is planned for the future.
+    Reading in a symmetric matrix will result in just the lower/upper triangular
+    part of the matrix (so that only relevant information is stored). Proper
+    symmetry support for operating on symmetric matrices is still TBD.
 
     Example:
 
     ```mlir
     sparse_tensor.new %source : !Source to tensor<1024x1024xf64, #CSR>
     ```
   }];
-  let assemblyFormat = "(`expand_symmetry` $expandSymmetry^)? $source attr-dict"
-                       "`:` type($source) `to` type($result)";
-  let hasVerifier = 1;
+  let assemblyFormat = "$source attr-dict `:` type($source) `to` type($result)";
 }
 
 def SparseTensor_PackOp : SparseTensor_Op<"pack", [Pure]>,
     Arguments<(ins 1DTensorOf<[AnyType]>:$data,
                    2DTensorOf<[AnySignlessIntegerOrIndex]>:$indices)>,
     Results<(outs AnySparseTensor: $result)> {
   let summary = "Returns a sparse tensor from the given (data, indices) pair";
 

mlir/include/mlir/ExecutionEngine/SparseTensor/File.h

public:
   /// parsing the header.
   bool isPattern() const {
     assert(isValid() && "Attempt to isPattern() before readHeader()");
     return valueKind_ == ValueKind::kPattern;
   }
 
   /// Gets the MME "symmetric" property setting.  Is only valid after
   /// parsing the header.
   bool isSymmetric() const {
     assert(isValid() && "Attempt to isSymmetric() before readHeader()");
     return isSymmetric_;
   }
 
   /// Gets the rank of the tensor.  Is only valid after parsing the header.
   uint64_t getRank() const {
     assert(isValid() && "Attempt to getRank() before readHeader()");
     return idata[0];
for (uint64_t dimRank = getRank(), d = 0; d < dimRank; ++d) {
       uint64_t idx = strtoul(linePtr, &linePtr, 10);
       // Store the 0-based index.
       indices[d] = static_cast<I>(idx - 1);
     }
     return linePtr;
   }
 
   /// The internal implementation of `readCOO`.  We template over
-  /// `IsPattern` and `IsSymmetric` in order to perform LICM without
-  /// needing to duplicate the source code.
+  /// `IsPattern` in order to perform LICM without needing to duplicate the
+  /// source code.
   //
   // TODO: We currently take the `dim2lvl` argument as a `PermutationRef`
   // since that's what `readCOO` creates.  Once we update `readCOO` to
   // functionalize the mapping, then this helper will just take that
   // same function.
-  template <typename V, bool IsPattern, bool IsSymmetric>
+  template <typename V, bool IsPattern>
   void readCOOLoop(uint64_t lvlRank, detail::PermutationRef dim2lvl,
                    SparseTensorCOO<V> *lvlCOO);
 
   /// Reads the MME header of a general sparse matrix of type real.
   void readMMEHeader();
 
   /// Reads the "extended" FROSTT header. Although not part of the
   /// documented format, we assume that the file starts with optional
   /// comments followed by two lines that define the rank, the number of
   /// nonzeros, and the dimensions sizes (one per rank) of the sparse tensor.
   void readExtFROSTTHeader();
 
   static constexpr int kColWidth = 1025;
   const char *const filename;
   FILE *file = nullptr;
   ValueKind valueKind_ = ValueKind::kInvalid;
   bool isSymmetric_ = false;
   uint64_t idata[512];
   char line[kColWidth];
 };
 
 //===----------------------------------------------------------------------===//
 
 template <typename V>
 SparseTensorCOO<V> *SparseTensorReader::readCOO(uint64_t lvlRank,
                                                 const uint64_t *lvlSizes,
                                                 const uint64_t *dim2lvl) {
   assert(isValid() && "Attempt to readCOO() before readHeader()");
   // Construct a `PermutationRef` for the `pushforward` below.
   // TODO: This specific implementation does not generalize to arbitrary
   // mappings, but once we functionalize the `dim2lvl` argument we can
   // simply use that function instead.
   const uint64_t dimRank = getRank();
   assert(lvlRank == dimRank && "Rank mismatch");
   detail::PermutationRef d2l(dimRank, dim2lvl);
   // Prepare a COO object with the number of nonzeros as initial capacity.
   auto *lvlCOO = new SparseTensorCOO<V>(lvlRank, lvlSizes, getNNZ());
   // Do some manual LICM, to avoid assertions in the for-loop.
   const bool IsPattern = isPattern();
-  const bool IsSymmetric = (isSymmetric() && getRank() == 2);
-  if (IsPattern && IsSymmetric)
-    readCOOLoop<V, true, true>(lvlRank, d2l, lvlCOO);
-  else if (IsPattern)
-    readCOOLoop<V, true, false>(lvlRank, d2l, lvlCOO);
-  else if (IsSymmetric)
-    readCOOLoop<V, false, true>(lvlRank, d2l, lvlCOO);
+  if (IsPattern)
+    readCOOLoop<V, true>(lvlRank, d2l, lvlCOO);
   else
-    readCOOLoop<V, false, false>(lvlRank, d2l, lvlCOO);
+    readCOOLoop<V, false>(lvlRank, d2l, lvlCOO);
   // Close the file and return the COO.
   closeFile();
   return lvlCOO;
 }
 
-template <typename V, bool IsPattern, bool IsSymmetric>
+template <typename V, bool IsPattern>
 void SparseTensorReader::readCOOLoop(uint64_t lvlRank,
                                      detail::PermutationRef dim2lvl,
                                      SparseTensorCOO<V> *lvlCOO) {
   const uint64_t dimRank = getRank();
   std::vector<uint64_t> dimInd(dimRank);
   std::vector<uint64_t> lvlInd(lvlRank);
   for (uint64_t nnz = getNNZ(), k = 0; k < nnz; ++k) {
     // We inline `readCOOElement` here in order to avoid redundant
     // assertions, since they're guaranteed by the call to `isValid()`
     // and the construction of `dimInd` above.
     char *linePtr = readCOOIndices(dimInd.data());
     const V value = detail::readCOOValue<V, IsPattern>(&linePtr);
     dim2lvl.pushforward(dimRank, dimInd.data(), lvlInd.data());
     // TODO: <https://github.com/llvm/llvm-project/issues/54179>
     lvlCOO->add(lvlInd, value);
-    // We currently chose to deal with symmetric matrices by fully
-    // constructing them.  In the future, we may want to make symmetry
-    // implicit for storage reasons.
-    if constexpr (IsSymmetric)
-      if (dimInd[0] != dimInd[1]) {
-        // Must recompute `lvlInd`, since arbitrary maps don't preserve swap.
-        std::swap(dimInd[0], dimInd[1]);
-        dim2lvl.pushforward(dimRank, dimInd.data(), lvlInd.data());
-        lvlCOO->add(lvlInd, value);
-      }
   }
 }
 
 /// Writes the sparse tensor to `filename` in extended FROSTT format.
 template <typename V>
 inline void writeExtFROSTT(const SparseTensorCOO<V> &coo,
                            const char *filename) {
   assert(filename && "Got nullptr for filename");

mlir/lib/Dialect/SparseTensor/IR/SparseTensorDialect.cpp

if (mdKind != StorageSpecifierKind::ValMemSize) {
 
     if (mdKind == StorageSpecifierKind::PtrMemSize && enc.isSingletonLvl(l))
       return op->emitError(
           "requested pointer memory size on a singleton level");
   }
   return success();
 }
 
-LogicalResult NewOp::verify() {
-  if (getExpandSymmetry() && getDimRank(getResult()) != 2)
-    return emitOpError("expand_symmetry can only be used for 2D tensors");
-  return success();
-}
-
 static LogicalResult verifyPackUnPack(Operation *op, TensorType cooTp,
                                       TensorType dataTp, TensorType idxTp) {
   if (!isUniqueCOOType(cooTp))
     return op->emitError("must operate on a COO tensor");
 
   auto enc = getSparseTensorEncoding(cooTp);
   if (idxTp.getElementType() != enc.getIndexType() ||
       dataTp.getElementType() != cooTp.getElementType())

mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorRewriting.cpp

LogicalResult matchAndRewrite(NewOp op,
     RankedTensorType cooTp =
         getUnorderedCOOFromTypeWithOrdering(dstTp, dstTp.getDimToLvlMap());
     Value cooBuffer =
         rewriter
             .create<AllocTensorOp>(loc, cooTp, dynSizesArray, Value(),
                                    /*sizeHint=*/nnz, Attribute())
             .getResult();
 
-    // The verifier ensures only 2D tensors can have the expandSymmetry flag.
-    Value symmetric;
-    if (dimRank == 2 && op.getExpandSymmetry()) {
-      symmetric =
-          createFuncCall(rewriter, loc, "getSparseTensorReaderIsSymmetric",
-                         {rewriter.getI1Type()}, {reader}, EmitCInterface::Off)
-              .getResult(0);
-    } else {
-      symmetric = Value();
-    }
     Type eltTp = dstTp.getElementType();
     Value value = genAllocaScalar(rewriter, loc, eltTp);
     scf::ForOp forOp = rewriter.create<scf::ForOp>(loc, c0, nnz, c1,
                                                    ArrayRef<Value>(cooBuffer));
     rewriter.setInsertionPointToStart(forOp.getBody());
 
     SmallString<29> getNextFuncName{"getSparseTensorReaderNext",
                                     primaryTypeFunctionSuffix(eltTp)};
     Value indices = dimSizes; // Reuse the indices memref to store indices.
     createFuncCall(rewriter, loc, getNextFuncName, {}, {reader, indices, value},
                    EmitCInterface::On);
     SmallVector<Value> indicesArray(dimRank);
     for (Dimension d = 0; d < dimRank; d++) {
       // FIXME: `toStoredDim` is deprecated
       indicesArray[toStoredDim(encDst, d)] = rewriter.create<memref::LoadOp>(
           loc, indices, constantIndex(rewriter, loc, d));
     }
     Value v = rewriter.create<memref::LoadOp>(loc, value);
     Value t = rewriter.create<InsertOp>(loc, v, forOp.getRegionIterArg(0),
                                         indicesArray);
-    if (symmetric) {
-      Value eq = rewriter.create<arith::CmpIOp>(
-          loc, arith::CmpIPredicate::ne, indicesArray[0], indicesArray[1]);
-      Value cond = rewriter.create<arith::AndIOp>(loc, symmetric, eq);
-      scf::IfOp ifOp =
-          rewriter.create<scf::IfOp>(loc, t.getType(), cond, /*else*/ true);
-      rewriter.setInsertionPointToStart(&ifOp.getThenRegion().front());
-      rewriter.create<scf::YieldOp>(
-          loc, Value(rewriter.create<InsertOp>(
-                   loc, v, t, ValueRange{indicesArray[1], indicesArray[0]})));
-      rewriter.setInsertionPointToStart(&ifOp.getElseRegion().front());
-      rewriter.create<scf::YieldOp>(loc, t);
-      t = ifOp.getResult(0);
-      rewriter.setInsertionPointAfter(ifOp);
-    }
     rewriter.create<scf::YieldOp>(loc, ArrayRef<Value>(t));
     rewriter.setInsertionPointAfter(forOp);
     // Link SSA chain.
     cooBuffer = forOp.getResult(0);
 
     // Release the sparse tensor reader.
     createFuncCall(rewriter, loc, "delSparseTensorReader", {}, {reader},
                    EmitCInterface::Off);

mlir/test/Dialect/SparseTensor/invalid.mlir

func.func @sparse_wrong_arity_compression(%arg0: memref<?xf64>,
   // expected-error@+1 {{'sparse_tensor.compress' op incorrect number of indices}}
   sparse_tensor.compress %arg0, %arg1, %arg2, %arg3 into %arg4[%arg5,%arg5]
     : memref<?xf64>, memref<?xi1>, memref<?xindex>, tensor<8x8xf64, #CSR>
   return
 }
 
 // -----
 
-#SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
-
-func.func @sparse_new(%arg0: !llvm.ptr<i8>) {
-  // expected-error@+1 {{expand_symmetry can only be used for 2D tensors}}
-  %0 = sparse_tensor.new expand_symmetry %arg0 : !llvm.ptr<i8> to tensor<128xf64, #SparseVector>
-  return
-}
-
-// -----
-
 func.func @sparse_convert_unranked(%arg0: tensor<*xf32>) -> tensor<10xf32> {
   // expected-error@+1 {{unexpected type in convert}}
   %0 = sparse_tensor.convert %arg0 : tensor<*xf32> to tensor<10xf32>
   return %0 : tensor<10xf32>
 }
 
 // -----
 

mlir/test/Dialect/SparseTensor/rewriting_for_codegen.mlir

 // RUN: mlir-opt %s -post-sparsification-rewrite="enable-runtime-library=false enable-convert=false" | \
 // RUN: FileCheck %s
 
 #CSR = #sparse_tensor.encoding<{
   dimLevelType = ["dense", "compressed"]
 }>
 
 #CSC = #sparse_tensor.encoding<{
   dimLevelType = [ "dense", "compressed" ],
   dimOrdering = affine_map<(i, j) -> (j, i)>
 }>
 
-// CHECK-LABEL:   func.func @sparse_new_symmetry(
-// CHECK-SAME:    %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> {
-// CHECK-DAG:     %[[C2:.*]] = arith.constant 2 : index
-// CHECK-DAG:     %[[C0:.*]] = arith.constant 0 : index
-// CHECK-DAG:     %[[C1:.*]] = arith.constant 1 : index
-// CHECK:         %[[R:.*]] = call @createSparseTensorReader(%[[A]])
-// CHECK:         %[[DS:.*]] = memref.alloca(%[[C2]]) : memref<?xindex>
-// CHECK:         call @copySparseTensorReaderDimSizes(%[[R]], %[[DS]])
-// CHECK:         %[[D0:.*]] = memref.load %[[DS]]{{\[}}%[[C0]]]
-// CHECK:         %[[D1:.*]] = memref.load %[[DS]]{{\[}}%[[C1]]]
-// CHECK:         %[[N:.*]] = call @getSparseTensorReaderNNZ(%[[R]])
-// CHECK:         %[[T:.*]] = bufferization.alloc_tensor(%[[D0]], %[[D1]]) size_hint=%[[N]]
-// CHECK:         %[[S:.*]] = call @getSparseTensorReaderIsSymmetric(%[[R]])
-// CHECK:         %[[VB:.*]] = memref.alloca()
-// CHECK:         %[[T2:.*]] = scf.for %{{.*}} = %[[C0]] to %[[N]] step %[[C1]] iter_args(%[[A2:.*]] = %[[T]])
-// CHECK:           func.call @getSparseTensorReaderNextF32(%[[R]], %[[DS]], %[[VB]])
-// CHECK:           %[[E0:.*]] = memref.load %[[DS]]{{\[}}%[[C0]]]
-// CHECK:           %[[E1:.*]] = memref.load %[[DS]]{{\[}}%[[C1]]]
-// CHECK:           %[[V:.*]] = memref.load %[[VB]][]
-// CHECK:           %[[T1:.*]] = sparse_tensor.insert %[[V]] into %[[A2]]{{\[}}%[[E0]], %[[E1]]]
-// CHECK:           %[[NE:.*]] = arith.cmpi ne, %[[E0]], %[[E1]]
-// CHECK:           %[[COND:.*]] = arith.andi %[[S]], %[[NE]]
-// CHECK:           %[[T3:.*]] = scf.if %[[COND]]
-// CHECK:             %[[T4:.*]] = sparse_tensor.insert %[[V]] into %[[T1]]{{\[}}%[[E1]], %[[E0]]]
-// CHECK:             scf.yield %[[T4]]
-// CHECK:           else
-// CHECK:             scf.yield %[[T1]]
-// CHECK:           scf.yield %[[T3]]
-// CHECK:         }
-// CHECK:         call @delSparseTensorReader(%[[R]])
-// CHECK:         %[[T5:.*]] = sparse_tensor.load %[[T2]] hasInserts
-// CHECK:         %[[R:.*]] = sparse_tensor.convert %[[T5]]
-// CHECK:         bufferization.dealloc_tensor %[[T5]]
-// CHECK:         return %[[R]]
-func.func @sparse_new_symmetry(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf32, #CSR> {
-  %0 = sparse_tensor.new expand_symmetry %arg0 : !llvm.ptr<i8> to tensor<?x?xf32, #CSR>
-  return %0 : tensor<?x?xf32, #CSR>
-}
-
 // CHECK-LABEL:   func.func @sparse_new(
 // CHECK-SAME:    %[[A:.*]]: !llvm.ptr<i8>) -> tensor<?x?xf32, #sparse_tensor.encoding<{ dimLevelType = [ "dense", "compressed" ] }>> {
 // CHECK-DAG:     %[[C2:.*]] = arith.constant 2 : index
 // CHECK-DAG:     %[[C0:.*]] = arith.constant 0 : index
 // CHECK-DAG:     %[[C1:.*]] = arith.constant 1 : index
 // CHECK:         %[[R:.*]] = call @createSparseTensorReader(%[[A]])
 // CHECK:         %[[DS:.*]] = memref.alloca(%[[C2]]) : memref<?xindex>
 // CHECK:         call @copySparseTensorReaderDimSizes(%[[R]], %[[DS]])

mlir/test/Dialect/SparseTensor/roundtrip.mlir

func.func @sparse_unpack(%sp : tensor<100xf64, #SparseVector>)
                        -> (tensor<6xf64>, tensor<6x1xi32>, i32) {
   %data, %indices, %nnz = sparse_tensor.unpack %sp : tensor<100xf64, #SparseVector>
                                                   to tensor<6xf64>, tensor<6x1xi32>, i32
   return %data, %indices, %nnz : tensor<6xf64>, tensor<6x1xi32>, i32
 }
 
 // -----
 
-#SparseMatrix = #sparse_tensor.encoding<{dimLevelType = ["compressed", "compressed"]}>
-
-// CHECK-LABEL: func @sparse_new_symmetry(
-// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>)
-//       CHECK: %[[T:.*]] = sparse_tensor.new expand_symmetry %[[A]] : !llvm.ptr<i8> to tensor<?x?xf64, #{{.*}}>
-//       CHECK: return %[[T]] : tensor<?x?xf64, #{{.*}}>
-func.func @sparse_new_symmetry(%arg0: !llvm.ptr<i8>) -> tensor<?x?xf64, #SparseMatrix> {
-  %0 = sparse_tensor.new expand_symmetry %arg0 : !llvm.ptr<i8> to tensor<?x?xf64, #SparseMatrix>
-  return %0 : tensor<?x?xf64, #SparseMatrix>
-}
-
-// -----
-
 #SparseVector = #sparse_tensor.encoding<{dimLevelType = ["compressed"]}>
 
 // CHECK-LABEL: func @sparse_dealloc(
 // CHECK-SAME: %[[A:.*]]: tensor<128xf64, #{{.*}}>
 //       CHECK: bufferization.dealloc_tensor %[[A]] : tensor<128xf64, #{{.*}}>
 //       CHECK: return
 func.func @sparse_dealloc(%arg0: tensor<128xf64, #SparseVector>) {
   bufferization.dealloc_tensor %arg0 : tensor<128xf64, #SparseVector>

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sum.mlir

 // REDEFINE: %lli \
 // REDEFINE:   --entry-function=entry_lli \
 // REDEFINE:   --extra-module=%S/Inputs/main_for_lli.ll \
 // REDEFINE:   %VLA_ARCH_ATTR_OPTIONS \
 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
+// TODO: The test currently only operates on the triangular part of the
+// symmetric matrix.
+
 !Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ]
 }>
 
 #trait_sum_reduce = {
   indexing_maps = [
func.func @entry() {
     %c0 = arith.constant 0 : index
 
     // Setup memory for a single reduction scalar,
     // initialized to zero.
     %x = tensor.from_elements %d0 : tensor<f64>
 
     // Read the sparse matrix from file, construct sparse storage.
     %fileName = call @getTensorFilename(%c0) : (index) -> (!Filename)
-    %a = sparse_tensor.new expand_symmetry %fileName : !Filename to tensor<?x?xf64, #SparseMatrix>
+    %a = sparse_tensor.new %fileName : !Filename to tensor<?x?xf64, #SparseMatrix>
 
     // Call the kernel.
     %0 = call @kernel_sum_reduce(%a, %x)
       : (tensor<?x?xf64, #SparseMatrix>, tensor<f64>) -> tensor<f64>
 
     // Print the result for verification.
     //
-    // CHECK: 30.2
+    // CHECK: 24.1
     //
     %v = tensor.extract %0[] : tensor<f64>
     vector.print %v : f64
 
     // Release the resources.
     bufferization.dealloc_tensor %a : tensor<?x?xf64, #SparseMatrix>
 
     return
   }
 }

mlir/test/Integration/Dialect/SparseTensor/CPU/sparse_sum_c32.mlir

 // REDEFINE:   %lli \
 // REDEFINE:   --entry-function=entry_lli \
 // REDEFINE:   --extra-module=%S/Inputs/main_for_lli.ll \
 // REDEFINE:   %VLA_ARCH_ATTR_OPTIONS \
 // REDEFINE:   --dlopen=%mlir_native_utils_lib_dir/libmlir_c_runner_utils%shlibext | \
 // REDEFINE: FileCheck %s
 // RUN: %{compile} | mlir-translate -mlir-to-llvmir | %{run}
 
+// TODO: The test currently only operates on the triangular part of the
+// symmetric matrix.
+
 !Filename = !llvm.ptr<i8>
 
 #SparseMatrix = #sparse_tensor.encoding<{
   dimLevelType = [ "compressed", "compressed" ]
 }>
 
 #trait_sum_reduce = {
   indexing_maps = [
func.func @entry() {
     // Setup memory for a single reduction scalar,
     // initialized to zero.
     // TODO: tensor.from_elements does not support complex.
     %alloc = bufferization.alloc_tensor() : tensor<complex<f64>>
     %x = tensor.insert %d0 into %alloc[] : tensor<complex<f64>>
 
     // Read the sparse matrix from file, construct sparse storage.
     %fileName = call @getTensorFilename(%c0) : (index) -> (!Filename)
-    %a = sparse_tensor.new expand_symmetry %fileName : !Filename to tensor<?x?xcomplex<f64>, #SparseMatrix>
+    %a = sparse_tensor.new %fileName : !Filename to tensor<?x?xcomplex<f64>, #SparseMatrix>
 
     // Call the kernel.
     %0 = call @kernel_sum_reduce(%a, %x)
       : (tensor<?x?xcomplex<f64>, #SparseMatrix>, tensor<complex<f64>>) -> tensor<complex<f64>>
 
     // Print the result for verification.
     //
-    // CHECK: 30.2
-    // CHECK-NEXT: 22.2
+    // CHECK: 24.1
+    // CHECK-NEXT: 16.1
     //
     %v = tensor.extract %0[] : tensor<complex<f64>>
     %real = complex.re %v : complex<f64>
     %imag = complex.im %v : complex<f64>
     vector.print %real : f64
     vector.print %imag : f64
 
     // Release the resources.
     bufferization.dealloc_tensor %a : tensor<?x?xcomplex<f64>, #SparseMatrix>
 
     return
   }
 }

mlir/test/Integration/Dialect/SparseTensor/taco/data/pwtk.mtx

-%%MatrixMarket matrix coordinate real symmetric
+%%MatrixMarket matrix coordinate real general
 %-------------------------------------------------------------------------------
 % To download a matrix for a real world application
 % https://math.nist.gov/MatrixMarket/
 %-------------------------------------------------------------------------------
-3 3 5
+3 3 8
 1 1 37423.0879671
+1 2 -22.4050781162
+1 3 -300.654980157
 2 1 -22.4050781162
+2 3 -.00869762944058
 3 1 -300.654980157
 3 2 -.00869762944058
 3 3 805225.750212

mlir/test/Integration/Dialect/SparseTensor/taco/unit_test_tensor_io.py

 
 
 # Define the aliases to shorten the code.
 _COMPRESSED = mlir_pytaco.ModeFormat.COMPRESSED
 _DENSE = mlir_pytaco.ModeFormat.DENSE
 
 
 _FORMAT = mlir_pytaco.Format([_COMPRESSED, _COMPRESSED])
-_MTX_DATA_TEMPLATE = Template(
-    """%%MatrixMarket matrix coordinate real $general_or_symmetry
+_MTX_DATA = """%%MatrixMarket matrix coordinate real general
 3 3 3
 3 1 3
 1 2 2
 3 2 4
-""")
-
-
-def _get_mtx_data(value):
-  mtx_data = _MTX_DATA_TEMPLATE
-  return mtx_data.substitute(general_or_symmetry=value)
+"""
 
 
 # CHECK-LABEL: test_read_mtx_matrix_general
 @testing_utils.run_test
 def test_read_mtx_matrix_general():
   with tempfile.TemporaryDirectory() as test_dir:
     file_name = os.path.join(test_dir, "data.mtx")
     with open(file_name, "w") as file:
-      file.write(_get_mtx_data("general"))
+      file.write(_MTX_DATA)
     a = mlir_pytaco_io.read(file_name, _FORMAT)
   passed = 0
   # The value of a is stored as an MLIR sparse tensor.
   passed += (not a.is_unpacked())
   a.unpack()
   passed += (a.is_unpacked())
   coords, values = a.get_coordinates_and_values()
   passed += np.array_equal(coords, [[0, 1], [2, 0], [2, 1]])
   passed += np.allclose(values, [2.0, 3.0, 4.0])
   # CHECK: 4
   print(passed)
 
 
-# CHECK-LABEL: test_read_mtx_matrix_symmetry
-@testing_utils.run_test
-def test_read_mtx_matrix_symmetry():
-  with tempfile.TemporaryDirectory() as test_dir:
-    file_name = os.path.join(test_dir, "data.mtx")
-    with open(file_name, "w") as file:
-      file.write(_get_mtx_data("symmetric"))
-    a = mlir_pytaco_io.read(file_name, _FORMAT)
-  passed = 0
-  # The value of a is stored as an MLIR sparse tensor.
-  passed += (not a.is_unpacked())
-  a.unpack()
-  passed += (a.is_unpacked())
-  coords, values = a.get_coordinates_and_values()
-  print(coords)
-  print(values)
-  passed += np.array_equal(coords,
-                           [[0, 1], [0, 2], [1, 0], [1, 2], [2, 0], [2, 1]])
-  passed += np.allclose(values, [2.0, 3.0, 2.0, 4.0, 3.0, 4.0])
-  # CHECK: 4
-  print(passed)
-
-
 _TNS_DATA = """2 3
 3 2
 3 1 3
 1 2 2
 3 2 4
 """