diff --git a/mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h b/mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h index f25df11d15fda..e723a35434584 100644 --- a/mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h +++ b/mlir/include/mlir/ExecutionEngine/SparseTensorRuntime.h @@ -57,8 +57,8 @@ MLIR_CRUNNERUTILS_EXPORT void *_mlir_ciface_newSparseTensor( // NOLINT StridedMemRefType *dimSizesRef, StridedMemRefType *lvlSizesRef, StridedMemRefType *lvlTypesRef, - StridedMemRefType *lvl2dimRef, - StridedMemRefType *dim2lvlRef, OverheadType posTp, + StridedMemRefType *dim2lvlRef, + StridedMemRefType *lvl2dimRef, OverheadType posTp, OverheadType crdTp, PrimaryType valTp, Action action, void *ptr); /// Tensor-storage method to obtain direct access to the values array. @@ -85,6 +85,7 @@ MLIR_SPARSETENSOR_FOREVERY_O(DECL_SPARSECOORDINATES) #undef DECL_SPARSECOORDINATES /// Coordinate-scheme method for adding a new element. +/// TODO: remove dim2lvl #define DECL_ADDELT(VNAME, V) \ MLIR_CRUNNERUTILS_EXPORT void *_mlir_ciface_addElt##VNAME( \ void *lvlCOO, StridedMemRefType *vref, \ diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp index eb0c5160e8d61..bb92029ff1e92 100644 --- a/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp +++ b/mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorConversion.cpp @@ -187,25 +187,38 @@ static Value genLvlPtrsBuffers(OpBuilder &builder, Location loc, /// This class abstracts over the API of `_mlir_ciface_newSparseTensor`: /// the "swiss army knife" method of the sparse runtime support library -/// for materializing sparse tensors into the computation. This abstraction -/// reduces the need to make modifications to client code whenever that -/// API changes. +/// for materializing sparse tensors into the computation. This abstraction +/// reduces the need for modifications when the API changes. class NewCallParams final { public: - /// Allocates the `ValueRange` for the `func::CallOp` parameters, - /// but does not initialize them. + /// Allocates the `ValueRange` for the `func::CallOp` parameters. NewCallParams(OpBuilder &builder, Location loc) : builder(builder), loc(loc), pTp(getOpaquePointerType(builder)) {} /// Initializes all static parameters (i.e., those which indicate /// type-level information such as the encoding and sizes), generating /// MLIR buffers as needed, and returning `this` for method chaining. - /// This method does not set the action and pointer arguments, since - /// those are handled by `genNewCall` instead. - NewCallParams &genBuffers(SparseTensorType stt, ValueRange dimSizes); + NewCallParams &genBuffers(SparseTensorType stt, + ArrayRef dimSizesValues) { + const Dimension dimRank = stt.getDimRank(); + assert(dimSizesValues.size() == static_cast(dimRank)); + // Sparsity annotations. + params[kParamLvlTypes] = genLvlTypesBuffer(builder, loc, stt); + // Construct dimSizes, lvlSizes, dim2lvl, and lvl2dim buffers. + params[kParamDimSizes] = allocaBuffer(builder, loc, dimSizesValues); + params[kParamLvlSizes] = genReaderBuffers( + builder, loc, stt, dimSizesValues, params[kParamDimSizes], + params[kParamDim2Lvl], params[kParamLvl2Dim]); + // Secondary and primary types encoding. + setTemplateTypes(stt); + // Finally, make note that initialization is complete. + assert(isInitialized() && "Initialization failed"); + // And return `this` for method chaining. + return *this; + } /// (Re)sets the C++ template type parameters, and returns `this` - /// for method chaining. This is already done as part of `genBuffers`, + /// for method chaining. This is already done as part of `genBuffers`, /// but is factored out so that it can also be called independently /// whenever subsequent `genNewCall` calls want to reuse the same /// buffers but different type parameters. @@ -236,7 +249,7 @@ class NewCallParams final { // this one-off getter, and to avoid potential mixups)? Value getDimToLvl() const { assert(isInitialized() && "Must initialize before getDimToLvl"); - return params[kParamDimToLvl]; + return params[kParamDim2Lvl]; } /// Generates a function call, with the current static parameters @@ -257,8 +270,8 @@ class NewCallParams final { static constexpr unsigned kParamDimSizes = 0; static constexpr unsigned kParamLvlSizes = 1; static constexpr unsigned kParamLvlTypes = 2; - static constexpr unsigned kParamLvlToDim = 3; - static constexpr unsigned kParamDimToLvl = 4; + static constexpr unsigned kParamDim2Lvl = 3; + static constexpr unsigned kParamLvl2Dim = 4; static constexpr unsigned kParamPosTp = 5; static constexpr unsigned kParamCrdTp = 6; static constexpr unsigned kParamValTp = 7; @@ -271,62 +284,6 @@ class NewCallParams final { Value params[kNumParams]; }; -// TODO: see the note at `_mlir_ciface_newSparseTensor` about how -// the meaning of the various arguments (e.g., "sizes" vs "shapes") -// is inconsistent between the different actions. -NewCallParams &NewCallParams::genBuffers(SparseTensorType stt, - ValueRange dimSizes) { - const Level lvlRank = stt.getLvlRank(); - const Dimension dimRank = stt.getDimRank(); - // Sparsity annotations. - params[kParamLvlTypes] = genLvlTypesBuffer(builder, loc, stt); - // Dimension-sizes array of the enveloping tensor. Useful for either - // verification of external data, or for construction of internal data. - assert(dimSizes.size() == static_cast(dimRank) && - "Dimension-rank mismatch"); - params[kParamDimSizes] = allocaBuffer(builder, loc, dimSizes); - // The level-sizes array must be passed as well, since for arbitrary - // dimToLvl mappings it cannot be trivially reconstructed at runtime. - // For now however, since we're still assuming permutations, we will - // initialize this parameter alongside the `dimToLvl` and `lvlToDim` - // parameters below. We preinitialize `lvlSizes` for code symmetry. - SmallVector lvlSizes(lvlRank); - // The dimension-to-level mapping and its inverse. We must preinitialize - // `dimToLvl` so that the true branch below can perform random-access - // `operator[]` assignment. We preinitialize `lvlToDim` for code symmetry. - SmallVector dimToLvl(dimRank); - SmallVector lvlToDim(lvlRank); - if (!stt.isIdentity()) { - const auto dimToLvlMap = stt.getDimToLvl(); - assert(dimToLvlMap.isPermutation()); - for (Level l = 0; l < lvlRank; l++) { - // The `d`th source variable occurs in the `l`th result position. - const Dimension d = dimToLvlMap.getDimPosition(l); - dimToLvl[d] = constantIndex(builder, loc, l); - lvlToDim[l] = constantIndex(builder, loc, d); - lvlSizes[l] = dimSizes[d]; - } - } else { - // The `SparseTensorType` ctor already ensures `dimRank == lvlRank` - // when `isIdentity`; so no need to re-assert it here. - for (Level l = 0; l < lvlRank; l++) { - dimToLvl[l] = lvlToDim[l] = constantIndex(builder, loc, l); - lvlSizes[l] = dimSizes[l]; - } - } - params[kParamLvlSizes] = allocaBuffer(builder, loc, lvlSizes); - params[kParamLvlToDim] = allocaBuffer(builder, loc, lvlToDim); - params[kParamDimToLvl] = stt.isIdentity() - ? params[kParamLvlToDim] - : allocaBuffer(builder, loc, dimToLvl); - // Secondary and primary types encoding. - setTemplateTypes(stt); - // Finally, make note that initialization is complete. - assert(isInitialized() && "Initialization failed"); - // And return `this` for method chaining. - return *this; -} - /// Generates a call to obtain the values array. static Value genValuesCall(OpBuilder &builder, Location loc, ShapedType tp, ValueRange ptr) { diff --git a/mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp b/mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp index 5b910716c0f9e..05da8cd79190e 100644 --- a/mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp +++ b/mlir/lib/ExecutionEngine/SparseTensorRuntime.cpp @@ -231,8 +231,8 @@ void *_mlir_ciface_newSparseTensor( // NOLINT StridedMemRefType *dimSizesRef, StridedMemRefType *lvlSizesRef, StridedMemRefType *lvlTypesRef, - StridedMemRefType *lvl2dimRef, - StridedMemRefType *dim2lvlRef, OverheadType posTp, + StridedMemRefType *dim2lvlRef, + StridedMemRefType *lvl2dimRef, OverheadType posTp, OverheadType crdTp, PrimaryType valTp, Action action, void *ptr) { ASSERT_NO_STRIDE(dimSizesRef); ASSERT_NO_STRIDE(lvlSizesRef); @@ -250,6 +250,9 @@ void *_mlir_ciface_newSparseTensor( // NOLINT const index_type *dim2lvl = MEMREF_GET_PAYLOAD(dim2lvlRef); const index_type *lvl2dim = MEMREF_GET_PAYLOAD(lvl2dimRef); + // Prepare map. + // TODO: start using MapRef map(dimRank, lvlRank, dim2lvl, lvl2dim) below + // Rewrite kIndex to kU64, to avoid introducing a bunch of new cases. // This is safe because of the static_assert above. if (posTp == OverheadType::kIndex) @@ -400,6 +403,7 @@ MLIR_SPARSETENSOR_FOREVERY_O(IMPL_SPARSECOORDINATES) #undef IMPL_GETOVERHEAD // TODO: use MapRef here for translation of coordinates +// TOOD: remove dim2lvl #define IMPL_ADDELT(VNAME, V) \ void *_mlir_ciface_addElt##VNAME( \ void *lvlCOO, StridedMemRefType *vref, \ @@ -540,13 +544,13 @@ void *_mlir_ciface_newSparseTensorFromReader( SparseTensorReader &reader = *static_cast(p); ASSERT_NO_STRIDE(lvlSizesRef); ASSERT_NO_STRIDE(lvlTypesRef); - ASSERT_NO_STRIDE(lvl2dimRef); ASSERT_NO_STRIDE(dim2lvlRef); + ASSERT_NO_STRIDE(lvl2dimRef); const uint64_t dimRank = reader.getRank(); const uint64_t lvlRank = MEMREF_GET_USIZE(lvlSizesRef); ASSERT_USIZE_EQ(lvlTypesRef, lvlRank); - ASSERT_USIZE_EQ(lvl2dimRef, lvlRank); ASSERT_USIZE_EQ(dim2lvlRef, dimRank); + ASSERT_USIZE_EQ(lvl2dimRef, lvlRank); (void)dimRank; const index_type *lvlSizes = MEMREF_GET_PAYLOAD(lvlSizesRef); const DimLevelType *lvlTypes = MEMREF_GET_PAYLOAD(lvlTypesRef); diff --git a/mlir/test/Dialect/SparseTensor/conversion.mlir b/mlir/test/Dialect/SparseTensor/conversion.mlir index 138736e26c1df..29093a055ab2e 100644 --- a/mlir/test/Dialect/SparseTensor/conversion.mlir +++ b/mlir/test/Dialect/SparseTensor/conversion.mlir @@ -136,18 +136,16 @@ func.func @sparse_new3d(%arg0: !llvm.ptr) -> tensor -// CHECK-DAG: %[[LvlSizes0:.*]] = memref.alloca() : memref<2xindex> // CHECK-DAG: %[[LvlTypes0:.*]] = memref.alloca() : memref<2xi8> +// CHECK-DAG: %[[Sizes0:.*]] = memref.alloca() : memref<2xindex> // CHECK-DAG: %[[Iota0:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizes:.*]] = memref.cast %[[DimSizes0]] : memref<2xindex> to memref -// CHECK-DAG: %[[LvlSizes:.*]] = memref.cast %[[LvlSizes0]] : memref<2xindex> to memref // CHECK-DAG: %[[LvlTypes:.*]] = memref.cast %[[LvlTypes0]] : memref<2xi8> to memref +// CHECK-DAG: %[[Sizes:.*]] = memref.cast %[[Sizes0]] : memref<2xindex> to memref // CHECK-DAG: %[[Iota:.*]] = memref.cast %[[Iota0]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I]], %[[DimSizes0]][%[[C0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[J]], %[[DimSizes0]][%[[C1]]] : memref<2xindex> +// CHECK-DAG: memref.store %[[I]], %[[Sizes0]][%[[C0]]] : memref<2xindex> +// CHECK-DAG: memref.store %[[J]], %[[Sizes0]][%[[C1]]] : memref<2xindex> // CHECK: %[[NP:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizes]], %[[LvlSizes]], %[[LvlTypes]], %[[Iota]], %[[Iota]], %{{.*}}, %{{.*}}, %{{.*}}, %[[Empty]], %[[NP]]) +// CHECK: %[[T:.*]] = call @newSparseTensor(%[[Sizes]], %[[Sizes]], %[[LvlTypes]], %[[Iota]], %[[Iota]], %{{.*}}, %{{.*}}, %{{.*}}, %[[Empty]], %[[NP]]) // CHECK: return %[[T]] : !llvm.ptr func.func @sparse_init(%arg0: index, %arg1: index) -> tensor { %0 = tensor.empty(%arg0, %arg1) : tensor diff --git a/mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir b/mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir index b11da60cd4830..1a69c80f7ecad 100644 --- a/mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir +++ b/mlir/test/Dialect/SparseTensor/convert_dense2sparse.mlir @@ -1,6 +1,4 @@ // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s -// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ -// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT #SparseVector = #sparse_tensor.encoding<{ map = (d0) -> (d0 : compressed) @@ -18,161 +16,187 @@ map = (d0, d1, d2) -> (d2 : dense, d0 : compressed, d1 : compressed) }> -// CHECK-LABEL: func @sparse_convert_1d( -// CHECK-SAME: %[[A:.*]]: tensor) -> !llvm.ptr { -// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 -// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : i32 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[U:.*]] = tensor.dim %[[A]], %[[C0]] : tensor -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK: %[[NP:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[EmptyCOO]], %[[NP]]) -// CHECK: %[[M:.*]] = memref.alloca() : memref<1xindex> -// CHECK: %[[T:.*]] = memref.cast %[[M]] : memref<1xindex> to memref -// CHECK: %[[BUF:.*]] = memref.alloca() : memref -// CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[U]] step %[[C1]] { -// CHECK: %[[E:.*]] = tensor.extract %[[A]][%[[I]]] : tensor -// CHECK: %[[N:.*]] = arith.cmpi ne, %[[E]], %[[I0]] : i32 -// CHECK: scf.if %[[N]] { -// CHECK: memref.store %[[I]], %[[M]][%[[C0]]] : memref<1xindex> -// CHECK: memref.store %[[E]], %[[BUF]][] : memref -// CHECK: call @addEltI32(%[[C]], %[[BUF]], %[[T]], %[[IotaP]]) -// CHECK: } -// CHECK: } -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK: call @delSparseTensorCOOI32(%[[C]]) -// CHECK: return %[[T]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_convert_1d( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_8:.*]] = tensor.dim %[[VAL_0]], %[[VAL_7]] : tensor +// CHECK: %[[VAL_9:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_10:.*]] = memref.cast %[[VAL_9]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_9]]{{\[}}%[[VAL_7]]] : memref<1xi8> +// CHECK: %[[VAL_11:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = memref.cast %[[VAL_11]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_11]]{{\[}}%[[VAL_7]]] : memref<1xindex> +// CHECK: %[[VAL_13:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_14:.*]] = memref.cast %[[VAL_13]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<1xindex> +// CHECK: %[[VAL_15:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_12]], %[[VAL_12]], %[[VAL_10]], %[[VAL_14]], %[[VAL_14]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_15]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_17:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<1xindex> to memref +// CHECK: %[[VAL_19:.*]] = memref.alloca() : memref +// CHECK: scf.for %[[VAL_20:.*]] = %[[VAL_7]] to %[[VAL_8]] step %[[VAL_5]] { +// CHECK: %[[VAL_21:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_20]]] : tensor +// CHECK: %[[VAL_22:.*]] = arith.cmpi ne, %[[VAL_21]], %[[VAL_4]] : i32 +// CHECK: scf.if %[[VAL_22]] { +// CHECK: memref.store %[[VAL_20]], %[[VAL_17]]{{\[}}%[[VAL_7]]] : memref<1xindex> +// CHECK: memref.store %[[VAL_21]], %[[VAL_19]][] : memref +// CHECK: %[[VAL_23:.*]] = func.call @addEltI32(%[[VAL_16]], %[[VAL_19]], %[[VAL_18]], %[[VAL_14]]) : (!llvm.ptr, memref, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: } +// CHECK: %[[VAL_24:.*]] = call @newSparseTensor(%[[VAL_12]], %[[VAL_12]], %[[VAL_10]], %[[VAL_14]], %[[VAL_14]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_1]], %[[VAL_16]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOI32(%[[VAL_16]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_24]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_1d(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-LABEL: func @sparse_convert_complex( -// CHECK-SAME: %[[A:.*]]: tensor<100xcomplex>) -> !llvm.ptr { -// CHECK-DAG: %[[CC:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[C100:.*]] = arith.constant 100 : index -// CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[C100]] step %[[C1]] { -// CHECK: %[[E:.*]] = tensor.extract %[[A]][%[[I]]] : tensor<100xcomplex> -// CHECK: %[[N:.*]] = complex.neq %[[E]], %[[CC]] : complex -// CHECK: scf.if %[[N]] { -// CHECK: memref.store %[[I]], %{{.*}}[%[[C0]]] : memref<1xindex> -// CHECK: call @addEltC64 -// CHECK: } -// CHECK: } -// CHECK: %[[T:.*]] = call @newSparseTensor -// CHECK: call @delSparseTensorCOOC64 -// CHECK: return %[[T]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_convert_complex( +// CHECK-SAME: %[[VAL_0:.*]]: tensor<100xcomplex>) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = complex.constant [0.000000e+00, 0.000000e+00] : complex +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 9 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 100 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_10]]{{\[}}%[[VAL_6]]] : memref<1xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<1xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<1xindex> +// CHECK: %[[VAL_16:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_17:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_3]], %[[VAL_16]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_18:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_19:.*]] = memref.cast %[[VAL_18]] : memref<1xindex> to memref +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref> +// CHECK: scf.for %[[VAL_21:.*]] = %[[VAL_6]] to %[[VAL_7]] step %[[VAL_9]] { +// CHECK: %[[VAL_22:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_21]]] : tensor<100xcomplex> +// CHECK: %[[VAL_23:.*]] = complex.neq %[[VAL_22]], %[[VAL_2]] : complex +// CHECK: scf.if %[[VAL_23]] { +// CHECK: memref.store %[[VAL_21]], %[[VAL_18]]{{\[}}%[[VAL_6]]] : memref<1xindex> +// CHECK: memref.store %[[VAL_22]], %[[VAL_20]][] : memref> +// CHECK: %[[VAL_24:.*]] = func.call @addEltC64(%[[VAL_17]], %[[VAL_20]], %[[VAL_19]], %[[VAL_15]]) : (!llvm.ptr, memref>, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: } +// CHECK: %[[VAL_25:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_1]], %[[VAL_17]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOC64(%[[VAL_17]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_25]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_complex(%arg0: tensor<100xcomplex>) -> tensor<100xcomplex, #SparseVector> { %0 = sparse_tensor.convert %arg0 : tensor<100xcomplex> to tensor<100xcomplex, #SparseVector> return %0 : tensor<100xcomplex, #SparseVector> } -// CHECK-LABEL: func @sparse_convert_2d( -// CHECK-SAME: %[[A:.*]]: tensor<2x4xf64>) -> !llvm.ptr -// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 -// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK: %[[NP:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[EmptyCOO]], %[[NP]]) -// CHECK: %[[M:.*]] = memref.alloca() : memref<2xindex> -// CHECK: %[[T:.*]] = memref.cast %[[M]] : memref<2xindex> to memref -// CHECK: %[[BUF:.*]] = memref.alloca() : memref -// CHECK: scf.for %[[I:.*]] = %[[C0]] to %{{.*}} step %[[C1]] { -// CHECK: scf.for %[[J:.*]] = %[[C0]] to %{{.*}} step %[[C1]] { -// CHECK: %[[E:.*]] = tensor.extract %[[A]][%[[I]], %[[J]]] : tensor<2x4xf64> -// CHECK: memref.store %[[I]], %[[M]][%[[C0]]] : memref<2xindex> -// CHECK: memref.store %[[J]], %[[M]][%[[C1]]] : memref<2xindex> -// CHECK: memref.store %[[E]], %[[BUF]][] : memref -// CHECK: call @addEltF64(%[[C]], %[[BUF]], %[[T]], %[[IotaP]]) -// CHECK: } -// CHECK: } -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK: call @delSparseTensorCOOF64(%[[C]]) -// CHECK: return %[[T]] : !llvm.ptr - -// CHECK-RWT-LABEL: func.func @sparse_convert_2d( -// CHECK-RWT-SAME: %[[T0:.*]]: tensor<2x4xf64>) -> tensor<2x4xf64, #sparse_tensor.encoding<{{{.*}}}>> { -// CHECK-RWT: %[[T1:.*]] = bufferization.alloc_tensor() -// CHECK-RWT: %[[T2:.*]] = sparse_tensor.foreach in %[[T0]] init(%[[T1]]) -// CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f64, %[[L0T:.*]]: tensor -// CHECK-RWT: %[[CMP:.*]] = arith.cmpf une, %[[L0V]] -// CHECK-RWT: %[[IFR:.*]] = scf.if %[[CMP]] -// CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]] -// CHECK-RWT: scf.yield %[[L0T2]] -// CHECK-RWT: } else { -// CHECK-RWT: scf.yield %[[L0T]] -// CHECK-RWT: } -// CHECK-RWT: sparse_tensor.yield %[[IFR]] -// CHECK-RWT: } -// CHECK-RWT: %[[R:.*]] = sparse_tensor.load %[[T2]] hasInserts -// CHECK-RWT: return %[[R]] -// CHECK-RWT: } +// CHECK-LABEL: func.func @sparse_convert_2d( +// CHECK-SAME: %[[VAL_0:.*]]: tensor<2x4xf64>) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : index +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 8 : i8 +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_10]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_11]], %[[VAL_12]]{{\[}}%[[VAL_8]]] : memref<2xi8> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_14]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_17:.*]] = memref.cast %[[VAL_16]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_16]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_16]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_19:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_15]], %[[VAL_13]], %[[VAL_17]], %[[VAL_17]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_3]], %[[VAL_18]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_21:.*]] = memref.cast %[[VAL_20]] : memref<2xindex> to memref +// CHECK: %[[VAL_22:.*]] = memref.alloca() : memref +// CHECK: scf.for %[[VAL_23:.*]] = %[[VAL_6]] to %[[VAL_7]] step %[[VAL_8]] { +// CHECK: scf.for %[[VAL_24:.*]] = %[[VAL_6]] to %[[VAL_9]] step %[[VAL_8]] { +// CHECK: %[[VAL_25:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_23]], %[[VAL_24]]] : tensor<2x4xf64> +// CHECK: %[[VAL_26:.*]] = arith.cmpf une, %[[VAL_25]], %[[VAL_2]] : f64 +// CHECK: scf.if %[[VAL_26]] { +// CHECK: memref.store %[[VAL_23]], %[[VAL_20]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_24]], %[[VAL_20]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_25]], %[[VAL_22]][] : memref +// CHECK: %[[VAL_27:.*]] = func.call @addEltF64(%[[VAL_19]], %[[VAL_22]], %[[VAL_21]], %[[VAL_17]]) : (!llvm.ptr, memref, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: } +// CHECK: } +// CHECK: %[[VAL_28:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_15]], %[[VAL_13]], %[[VAL_17]], %[[VAL_17]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_1]], %[[VAL_19]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOF64(%[[VAL_19]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_28]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_2d(%arg0: tensor<2x4xf64>) -> tensor<2x4xf64, #CSR> { %0 = sparse_tensor.convert %arg0 : tensor<2x4xf64> to tensor<2x4xf64, #CSR> return %0 : tensor<2x4xf64, #CSR> } -// CHECK-LABEL: func @sparse_constant() -> !llvm.ptr { -// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 -// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK: %[[NP:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[EmptyCOO]], %[[NP]]) -// CHECK: %[[M:.*]] = memref.alloca() : memref<2xindex> -// CHECK: %[[N:.*]] = memref.cast %[[M]] : memref<2xindex> to memref -// CHECK: %[[BUF:.*]] = memref.alloca() : memref -// CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[C2]] step %[[C1]] { -// CHECK-DAG: memref.store %{{.*}}, %[[M]][%[[C0]]] : memref<2xindex> -// CHECK-DAG: memref.store %{{.*}}, %[[M]][%[[C1]]] : memref<2xindex> -// CHECK-DAG: %[[V:.*]] = tensor.extract %{{.*}}[%[[I]]] : tensor<2xf32> -// CHECK: memref.store %[[V]], %[[BUF]][] : memref -// CHECK: call @addEltF32(%{{.*}}, %[[BUF]], %[[N]], %[[IotaP]]) -// CHECK: } -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK: call @delSparseTensorCOOF32(%[[C]]) -// CHECK: return %[[T]] : !llvm.ptr - -// CHECK-RWT-LABEL: func.func @sparse_constant() -> tensor<8x7xf32, #sparse_tensor.encoding<{{{.*}}}>> { -// CHECK-RWT: %[[F0:.*]] = arith.constant sparse<{{\[\[}}0, 0], [1, 6]], [1.000000e+00, 5.000000e+00]> : tensor<8x7xf32> -// CHECK-RWT: %[[T0:.*]] = bufferization.alloc_tensor() -// CHECK-RWT: %[[T1:.*]] = sparse_tensor.foreach in %[[F0]] init(%[[T0]]) -// CHECK-RWT: ^bb0(%[[L0I0:.*]]: index, %[[L0I1:.*]]: index, %[[L0V:.*]]: f32, %[[L0T:.*]]: tensor -// CHECK-RWT: %[[L0T2:.*]] = sparse_tensor.insert %[[L0V]] into %[[L0T]]{{\[}}%[[L0I0]], %[[L0I1]]] -// CHECK-RWT: sparse_tensor.yield %[[L0T2]] -// CHECK-RWT: } -// CHECK-RWT: %[[R:.*]] = sparse_tensor.load %[[T1]] hasInserts -// CHECK-RWT: return %[[R]] -// CHECK-RWT: } +// CHECK-LABEL: func.func @sparse_constant() -> !llvm.ptr { +// CHECK-DAG: %[[VAL_0:.*]] = arith.constant dense<[1.000000e+00, 5.000000e+00]> : tensor<2xf32> +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant dense<{{\[\[}}0, 0], [1, 6]]> : tensor<2x2xi64> +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 7 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 2 : index +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_10]], %[[VAL_12]]{{\[}}%[[VAL_7]]] : memref<2xi8> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_14]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_17:.*]] = memref.cast %[[VAL_16]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_16]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_16]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_19:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_15]], %[[VAL_13]], %[[VAL_17]], %[[VAL_17]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_18]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_21:.*]] = memref.cast %[[VAL_20]] : memref<2xindex> to memref +// CHECK: %[[VAL_22:.*]] = memref.alloca() : memref +// CHECK: scf.for %[[VAL_23:.*]] = %[[VAL_5]] to %[[VAL_11]] step %[[VAL_7]] { +// CHECK: %[[VAL_24:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_23]], %[[VAL_5]]] : tensor<2x2xi64> +// CHECK: %[[VAL_25:.*]] = arith.index_cast %[[VAL_24]] : i64 to index +// CHECK: %[[VAL_26:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_23]], %[[VAL_7]]] : tensor<2x2xi64> +// CHECK: %[[VAL_27:.*]] = arith.index_cast %[[VAL_26]] : i64 to index +// CHECK: %[[VAL_28:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_23]]] : tensor<2xf32> +// CHECK: memref.store %[[VAL_25]], %[[VAL_20]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_27]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_28]], %[[VAL_22]][] : memref +// CHECK: %[[VAL_29:.*]] = func.call @addEltF32(%[[VAL_19]], %[[VAL_22]], %[[VAL_21]], %[[VAL_17]]) : (!llvm.ptr, memref, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: %[[VAL_30:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_15]], %[[VAL_13]], %[[VAL_17]], %[[VAL_17]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_3]], %[[VAL_19]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOF32(%[[VAL_19]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_30]] : !llvm.ptr +// CHECK: } func.func @sparse_constant() -> tensor<8x7xf32, #CSR>{ // Initialize a tensor. %0 = arith.constant sparse<[[0, 0], [1, 6]], [1.0, 5.0]> : tensor<8x7xf32> @@ -181,17 +205,59 @@ func.func @sparse_constant() -> tensor<8x7xf32, #CSR>{ return %1 : tensor<8x7xf32, #CSR> } -// CHECK-RWT-LABEL: func.func @sparse_constant_csc() -> tensor<8x7xf32, -// CHECK-RWT: %[[VAL_0:.*]] = arith.constant sparse<{{\[\[}}0, 0], [1, 6]], [1.000000e+00, 5.000000e+00]> : tensor<8x7xf32> -// CHECK-RWT: %[[VAL_1:.*]] = bufferization.alloc_tensor() : -// CHECK-RWT: %[[VAL_2:.*]] = sparse_tensor.foreach in %[[VAL_0]] init(%[[VAL_1]]) {order = #map} : tensor<8x7xf32>, -// CHECK-RWT: ^bb0(%[[VAL_3:.*]]: index, %[[VAL_4:.*]]: index, %[[VAL_5:.*]]: f32, %[[VAL_6:.*]]: tensor -// CHECK-RWT: %[[VAL_7:.*]] = sparse_tensor.insert %[[VAL_5]] into %[[VAL_6]]{{\[}}%[[VAL_4]], %[[VAL_3]]] : -// CHECK-RWT: sparse_tensor.yield %[[VAL_7]] : -// CHECK-RWT: } -// CHECK-RWT: %[[VAL_8:.*]] = sparse_tensor.load %[[VAL_9:.*]] hasInserts : -// CHECK-RWT: return %[[VAL_8]] : -// CHECK-RWT: } +// CHECK-LABEL: func.func @sparse_constant_csc() -> !llvm.ptr { +// CHECK-DAG: %[[VAL_0:.*]] = arith.constant dense<[1.000000e+00, 5.000000e+00]> : tensor<2xf32> +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant dense<{{\[\[}}0, 0], [1, 6]]> : tensor<2x2xi64> +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 7 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 2 : index +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_10]], %[[VAL_12]]{{\[}}%[[VAL_7]]] : memref<2xi8> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_14]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_17:.*]] = memref.cast %[[VAL_16]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_16]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_16]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_19:.*]] = memref.cast %[[VAL_18]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_18]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_21:.*]] = memref.cast %[[VAL_20]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_20]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_6]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_22:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_23:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_21]], %[[VAL_13]], %[[VAL_17]], %[[VAL_19]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_22]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_24:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_25:.*]] = memref.cast %[[VAL_24]] : memref<2xindex> to memref +// CHECK: %[[VAL_26:.*]] = memref.alloca() : memref +// CHECK: scf.for %[[VAL_27:.*]] = %[[VAL_5]] to %[[VAL_11]] step %[[VAL_7]] { +// CHECK: %[[VAL_28:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_27]], %[[VAL_5]]] : tensor<2x2xi64> +// CHECK: %[[VAL_29:.*]] = arith.index_cast %[[VAL_28]] : i64 to index +// CHECK: %[[VAL_30:.*]] = tensor.extract %[[VAL_1]]{{\[}}%[[VAL_27]], %[[VAL_7]]] : tensor<2x2xi64> +// CHECK: %[[VAL_31:.*]] = arith.index_cast %[[VAL_30]] : i64 to index +// CHECK: %[[VAL_32:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_27]]] : tensor<2xf32> +// CHECK: memref.store %[[VAL_29]], %[[VAL_24]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_31]], %[[VAL_24]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_32]], %[[VAL_26]][] : memref +// CHECK: %[[VAL_33:.*]] = func.call @addEltF32(%[[VAL_23]], %[[VAL_26]], %[[VAL_25]], %[[VAL_17]]) : (!llvm.ptr, memref, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: %[[VAL_34:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_21]], %[[VAL_13]], %[[VAL_17]], %[[VAL_19]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_3]], %[[VAL_23]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOF32(%[[VAL_23]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_34]] : !llvm.ptr +// CHECK: } func.func @sparse_constant_csc() -> tensor<8x7xf32, #CSC>{ // Initialize a tensor. %0 = arith.constant sparse<[[0, 0], [1, 6]], [1.0, 5.0]> : tensor<8x7xf32> @@ -200,46 +266,73 @@ func.func @sparse_constant_csc() -> tensor<8x7xf32, #CSC>{ return %1 : tensor<8x7xf32, #CSC> } -// CHECK-LABEL: func @sparse_convert_3d( -// CHECK-SAME: %[[A:.*]]: tensor) -> !llvm.ptr -// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 -// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[C2:.*]] = arith.constant 2 : index -// CHECK-DAG: %[[U1:.*]] = tensor.dim %[[A]], %[[C0]] : tensor -// CHECK-DAG: %[[U2:.*]] = tensor.dim %[[A]], %[[C1]] : tensor -// CHECK-DAG: %[[U3:.*]] = tensor.dim %[[A]], %[[C2]] : tensor -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<3xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[Lvl2Dim:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[Dim2Lvl:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<3xi8> to memref -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<3xindex> to memref -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<3xindex> to memref -// CHECK-DAG: %[[Lvl2DimP:.*]] = memref.cast %[[Lvl2Dim]] : memref<3xindex> to memref -// CHECK-DAG: %[[Dim2LvlP:.*]] = memref.cast %[[Dim2Lvl]] : memref<3xindex> to memref -// CHECK: %[[NP:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[Lvl2DimP]], %[[Dim2LvlP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[EmptyCOO]], %[[NP]]) -// CHECK: %[[M:.*]] = memref.alloca() : memref<3xindex> -// CHECK: %[[N:.*]] = memref.cast %[[M]] : memref<3xindex> to memref -// CHECK: %[[BUF:.*]] = memref.alloca() : memref -// CHECK: scf.for %[[I:.*]] = %[[C0]] to %[[U1]] step %[[C1]] { -// CHECK: scf.for %[[J:.*]] = %[[C0]] to %[[U2]] step %[[C1]] { -// CHECK: scf.for %[[K:.*]] = %[[C0]] to %[[U3]] step %[[C1]] { -// CHECK: %[[E:.*]] = tensor.extract %[[A]][%[[I]], %[[J]], %[[K]]] : tensor -// CHECK: memref.store %[[I]], %[[M]][%[[C0]]] : memref<3xindex> -// CHECK: memref.store %[[J]], %[[M]][%[[C1]]] : memref<3xindex> -// CHECK: memref.store %[[K]], %[[M]][%[[C2]]] : memref<3xindex> -// CHECK: memref.store %[[E]], %[[BUF]][] : memref -// CHECK: call @addEltF64(%[[C]], %[[BUF]], %[[N]], %[[Dim2LvlP]]) -// CHECK: } -// CHECK: } -// CHECK: } -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[Lvl2DimP]], %[[Dim2LvlP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK: call @delSparseTensorCOOF64(%[[C]]) -// CHECK: return %[[T]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_convert_3d( +// CHECK-SAME: %[[VAL_0:.*]]: tensor) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 4 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_11:.*]] = tensor.dim %[[VAL_0]], %[[VAL_10]] : tensor +// CHECK: %[[VAL_12:.*]] = tensor.dim %[[VAL_0]], %[[VAL_9]] : tensor +// CHECK: %[[VAL_13:.*]] = tensor.dim %[[VAL_0]], %[[VAL_8]] : tensor +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<3xi8> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<3xi8> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_14]]{{\[}}%[[VAL_10]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_9]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_8]]] : memref<3xi8> +// CHECK: %[[VAL_16:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_17:.*]] = memref.cast %[[VAL_16]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_11]], %[[VAL_16]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_12]], %[[VAL_16]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_13]], %[[VAL_16]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: %[[VAL_20:.*]] = memref.load %[[VAL_16]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: %[[VAL_21:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_22:.*]] = memref.cast %[[VAL_21]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_21]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_21]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_10]], %[[VAL_21]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: %[[VAL_23:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_24:.*]] = memref.cast %[[VAL_23]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_23]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_10]], %[[VAL_23]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_23]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: %[[VAL_25:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_26:.*]] = memref.cast %[[VAL_25]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_18]], %[[VAL_25]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_19]], %[[VAL_25]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_20]], %[[VAL_25]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: %[[VAL_27:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_28:.*]] = call @newSparseTensor(%[[VAL_17]], %[[VAL_26]], %[[VAL_15]], %[[VAL_22]], %[[VAL_24]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_3]], %[[VAL_27]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_29:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_30:.*]] = memref.cast %[[VAL_29]] : memref<3xindex> to memref +// CHECK: %[[VAL_31:.*]] = memref.alloca() : memref +// CHECK: scf.for %[[VAL_32:.*]] = %[[VAL_10]] to %[[VAL_11]] step %[[VAL_9]] { +// CHECK: scf.for %[[VAL_33:.*]] = %[[VAL_10]] to %[[VAL_12]] step %[[VAL_9]] { +// CHECK: scf.for %[[VAL_34:.*]] = %[[VAL_10]] to %[[VAL_13]] step %[[VAL_9]] { +// CHECK: %[[VAL_35:.*]] = tensor.extract %[[VAL_0]]{{\[}}%[[VAL_32]], %[[VAL_33]], %[[VAL_34]]] : tensor +// CHECK: %[[VAL_36:.*]] = arith.cmpf une, %[[VAL_35]], %[[VAL_2]] : f64 +// CHECK: scf.if %[[VAL_36]] { +// CHECK: memref.store %[[VAL_32]], %[[VAL_29]]{{\[}}%[[VAL_10]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_33]], %[[VAL_29]]{{\[}}%[[VAL_9]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_34]], %[[VAL_29]]{{\[}}%[[VAL_8]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_35]], %[[VAL_31]][] : memref +// CHECK: %[[VAL_37:.*]] = func.call @addEltF64(%[[VAL_28]], %[[VAL_31]], %[[VAL_30]], %[[VAL_22]]) : (!llvm.ptr, memref, memref, memref) -> !llvm.ptr +// CHECK: } +// CHECK: } +// CHECK: } +// CHECK: } +// CHECK: %[[VAL_38:.*]] = call @newSparseTensor(%[[VAL_17]], %[[VAL_26]], %[[VAL_15]], %[[VAL_22]], %[[VAL_24]], %[[VAL_5]], %[[VAL_5]], %[[VAL_4]], %[[VAL_1]], %[[VAL_28]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOF64(%[[VAL_28]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_38]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_3d(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor diff --git a/mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir b/mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir index 17394aa46783a..ffc0f57a23110 100644 --- a/mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir +++ b/mlir/test/Dialect/SparseTensor/convert_sparse2dense.mlir @@ -1,8 +1,5 @@ // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s -// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ -// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT - #SparseVector = #sparse_tensor.encoding<{ map = (d0) -> (d0 : compressed) }> @@ -15,358 +12,326 @@ map = (d0, d1, d2) -> (d2 : dense, d0 : compressed, d1 : compressed) }> -// CHECK-LABEL: func @sparse_convert_1d( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor<13xi32> -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I13:.*]] = arith.constant 13 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-DAG: %[[C6:.*]] = arith.constant 6 : i32 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<1xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-DAG: memref.store %[[I13]], %[[DimSizes]][%[[I0]]] : memref<1xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<1xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %[[C0]], %[[C0]], %[[C6]], %[[C6]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<13xi32> -// CHECK-DAG: linalg.fill ins(%[[C0]] : i32) outs(%[[M]] : memref<13xi32>) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref<13xi32> -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<13xi32> -// CHECK: return %[[T]] : tensor<13xi32> +// CHECK-LABEL: func.func @sparse_convert_1d( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor<13xi32> { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 13 : index +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : i8 +// CHECK: %[[VAL_6:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_6]]{{\[}}%[[VAL_3]]] : memref<1xi8> +// CHECK: %[[VAL_8:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_8]]{{\[}}%[[VAL_3]]] : memref<1xindex> +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_3]], %[[VAL_10]]{{\[}}%[[VAL_3]]] : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = call @newSparseTensor(%[[VAL_9]], %[[VAL_9]], %[[VAL_7]], %[[VAL_11]], %[[VAL_11]], %[[VAL_2]], %[[VAL_2]], %[[VAL_1]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_13:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_14:.*]] = memref.cast %[[VAL_13]] : memref<1xindex> to memref +// CHECK: %[[VAL_15:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_16:.*]] = memref.alloc() : memref<13xi32> +// CHECK: linalg.fill ins(%[[VAL_2]] : i32) outs(%[[VAL_16]] : memref<13xi32>) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_17:.*]] = func.call @getNextI32(%[[VAL_12]], %[[VAL_14]], %[[VAL_15]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_17]]) +// CHECK: } do { +// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_3]]] : memref<1xindex> +// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_15]][] : memref +// CHECK: memref.store %[[VAL_19]], %[[VAL_16]]{{\[}}%[[VAL_18]]] : memref<13xi32> +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorI32(%[[VAL_12]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_20:.*]] = bufferization.to_tensor %[[VAL_16]] : memref<13xi32> +// CHECK: return %[[VAL_20]] : tensor<13xi32> +// CHECK: } func.func @sparse_convert_1d(%arg0: tensor<13xi32, #SparseVector>) -> tensor<13xi32> { %0 = sparse_tensor.convert %arg0 : tensor<13xi32, #SparseVector> to tensor<13xi32> return %0 : tensor<13xi32> } -// CHECK-LABEL: func @sparse_convert_1d_dyn( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-DAG: %[[C6:.*]] = arith.constant 6 : i32 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<1xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr, index) -> index -// CHECK-DAG: memref.store %[[SizeI0]], %[[DimSizes]][%[[I0]]] : memref<1xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<1xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %[[C0]], %[[C0]], %[[C6]], %[[C6]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<1xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref -// CHECK-DAG: linalg.fill ins(%[[C0]] : i32) outs(%[[M]] : memref) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextI32(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<1xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]]] : memref -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref -// CHECK: return %[[T]] : tensor +// CHECK-LABEL: func.func @sparse_convert_1d_dyn( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_5:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_4]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_6:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_3]], %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<1xi8> +// CHECK: %[[VAL_8:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = call @newSparseTensor(%[[VAL_9]], %[[VAL_9]], %[[VAL_7]], %[[VAL_11]], %[[VAL_11]], %[[VAL_2]], %[[VAL_2]], %[[VAL_1]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_13:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_14:.*]] = memref.cast %[[VAL_13]] : memref<1xindex> to memref +// CHECK: %[[VAL_15:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_16:.*]] = memref.alloc(%[[VAL_5]]) : memref +// CHECK: linalg.fill ins(%[[VAL_2]] : i32) outs(%[[VAL_16]] : memref) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_17:.*]] = func.call @getNextI32(%[[VAL_12]], %[[VAL_14]], %[[VAL_15]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_17]]) +// CHECK: } do { +// CHECK: %[[VAL_18:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_19:.*]] = memref.load %[[VAL_15]][] : memref +// CHECK: memref.store %[[VAL_19]], %[[VAL_16]]{{\[}}%[[VAL_18]]] : memref +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorI32(%[[VAL_12]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_20:.*]] = bufferization.to_tensor %[[VAL_16]] : memref +// CHECK: return %[[VAL_20]] : tensor +// CHECK: } func.func @sparse_convert_1d_dyn(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-LABEL: func @sparse_convert_2d( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor<2x4xf64> -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index -// CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32 -// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<2xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I1]]] : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I2]], %[[DimSizes]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I4]], %[[DimSizes]][%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]][%[[I1]]] : memref<2xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x4xf64> -// CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x4xf64>) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex> -// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x4xf64> -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x4xf64> -// CHECK: return %[[T]] : tensor<2x4xf64> - -// CHECK-RWT-LABEL: func.func @sparse_convert_2d( -// CHECK-RWT-SAME: %[[A:.*]]: tensor<2x4xf64, #sparse_tensor.encoding<{{{.*}}}>>) -> tensor<2x4xf64> { -// CHECK-RWT: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 -// CHECK-RWT: %[[B:.*]] = memref.alloc() : memref<2x4xf64> -// CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]] -// CHECK-RWT: sparse_tensor.foreach in %[[A]] -// CHECK-RWT: ^bb0(%[[FI0:.*]]: index, %[[FI1:.*]]: index, %[[FV:.*]]: f64): -// CHECK-RWT: memref.store %[[FV]], %[[B]]{{\[}}%[[FI0]], %[[FI1]]] -// CHECK-RWT: } -// CHECK-RWT: %[[T:.*]] = bufferization.to_tensor %[[B]] -// CHECK-RWT: return %[[T]] : tensor<2x4xf64> +// CHECK-LABEL: func.func @sparse_convert_2d( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor<2x4xf64> { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 4 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : i8 +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_10]]{{\[}}%[[VAL_6]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_9]], %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_17:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<2xindex> to memref +// CHECK: %[[VAL_19:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_20:.*]] = memref.alloc() : memref<2x4xf64> +// CHECK: linalg.fill ins(%[[VAL_1]] : f64) outs(%[[VAL_20]] : memref<2x4xf64>) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_21:.*]] = func.call @getNextF64(%[[VAL_16]], %[[VAL_18]], %[[VAL_19]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_21]]) +// CHECK: } do { +// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_19]][] : memref +// CHECK: memref.store %[[VAL_24]], %[[VAL_20]]{{\[}}%[[VAL_22]], %[[VAL_23]]] : memref<2x4xf64> +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorF64(%[[VAL_16]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_25:.*]] = bufferization.to_tensor %[[VAL_20]] : memref<2x4xf64> +// CHECK: return %[[VAL_25]] : tensor<2x4xf64> +// CHECK: } func.func @sparse_convert_2d(%arg0: tensor<2x4xf64, #SparseMatrix>) -> tensor<2x4xf64> { %0 = sparse_tensor.convert %arg0 : tensor<2x4xf64, #SparseMatrix> to tensor<2x4xf64> return %0 : tensor<2x4xf64> } -// CHECK-LABEL: func @sparse_convert_2d_dyn0( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32 -// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<2xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I1]]] : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr, index) -> index -// CHECK-DAG: memref.store %[[SizeI0]], %[[DimSizes]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I4]], %[[DimSizes]][%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]][%[[I1]]] : memref<2xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]]) : memref -// CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex> -// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref -// CHECK: return %[[T]] : tensor +// CHECK-LABEL: func.func @sparse_convert_2d_dyn0( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 4 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_9:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_8]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_6]], %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_12]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_14]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_17:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<2xindex> to memref +// CHECK: %[[VAL_19:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_20:.*]] = memref.alloc(%[[VAL_9]]) : memref +// CHECK: linalg.fill ins(%[[VAL_1]] : f64) outs(%[[VAL_20]] : memref) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_21:.*]] = func.call @getNextF64(%[[VAL_16]], %[[VAL_18]], %[[VAL_19]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_21]]) +// CHECK: } do { +// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_19]][] : memref +// CHECK: memref.store %[[VAL_24]], %[[VAL_20]]{{\[}}%[[VAL_22]], %[[VAL_23]]] : memref +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorF64(%[[VAL_16]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_25:.*]] = bufferization.to_tensor %[[VAL_20]] : memref +// CHECK: return %[[VAL_25]] : tensor +// CHECK: } func.func @sparse_convert_2d_dyn0(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-LABEL: func @sparse_convert_2d_dyn1( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor<2x?xf64> -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32 -// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<2xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I1]]] : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[SizeI1:.*]] = call @sparseDimSize(%[[Arg]], %[[I1]]) : (!llvm.ptr, index) -> index -// CHECK-DAG: memref.store %[[I2]], %[[DimSizes]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[SizeI1]], %[[DimSizes]][%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]][%[[I1]]] : memref<2xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI1]]) : memref<2x?xf64> -// CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x?xf64>) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex> -// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref<2x?xf64> -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x?xf64> -// CHECK: return %[[T]] : tensor<2x?xf64> +// CHECK-LABEL: func.func @sparse_convert_2d_dyn1( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor<2x?xf64> { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 1 : index +// CHECK: %[[VAL_9:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_8]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_6]], %[[VAL_10]]{{\[}}%[[VAL_8]]] : memref<2xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_12]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_14]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_17:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<2xindex> to memref +// CHECK: %[[VAL_19:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_20:.*]] = memref.alloc(%[[VAL_9]]) : memref<2x?xf64> +// CHECK: linalg.fill ins(%[[VAL_1]] : f64) outs(%[[VAL_20]] : memref<2x?xf64>) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_21:.*]] = func.call @getNextF64(%[[VAL_16]], %[[VAL_18]], %[[VAL_19]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_21]]) +// CHECK: } do { +// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_8]]] : memref<2xindex> +// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_19]][] : memref +// CHECK: memref.store %[[VAL_24]], %[[VAL_20]]{{\[}}%[[VAL_22]], %[[VAL_23]]] : memref<2x?xf64> +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorF64(%[[VAL_16]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_25:.*]] = bufferization.to_tensor %[[VAL_20]] : memref<2x?xf64> +// CHECK: return %[[VAL_25]] : tensor<2x?xf64> +// CHECK: } func.func @sparse_convert_2d_dyn1(%arg0: tensor<2x?xf64, #SparseMatrix>) -> tensor<2x?xf64> { %0 = sparse_tensor.convert %arg0 : tensor<2x?xf64, #SparseMatrix> to tensor<2x?xf64> return %0 : tensor<2x?xf64> } -// CHECK-LABEL: func @sparse_convert_2d_dyn2( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32 -// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<2xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I1]]] : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[SizeI0:.*]] = call @sparseDimSize(%[[Arg]], %[[I0]]) : (!llvm.ptr, index) -> index -// CHECK-DAG: %[[SizeI1:.*]] = call @sparseDimSize(%[[Arg]], %[[I1]]) : (!llvm.ptr, index) -> index -// CHECK-DAG: memref.store %[[SizeI0]], %[[DimSizes]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[SizeI1]], %[[DimSizes]][%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]][%[[I1]]] : memref<2xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<2xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc(%[[SizeI0]], %[[SizeI1]]) : memref -// CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<2xindex> -// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<2xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]]] : memref -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref -// CHECK: return %[[T]] : tensor - -// CHECK-RWT-LABEL: func.func @sparse_convert_2d_dyn2( -// CHECK-RWT-SAME: %[[A:.*]]: tensor>) -> tensor { -// CHECK-RWT-DAG: %[[C0:.*]] = arith.constant 0 : index -// CHECK-RWT-DAG: %[[C1:.*]] = arith.constant 1 : index -// CHECK-RWT-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 -// CHECK-RWT: %[[D0:.*]] = tensor.dim %[[A]], %[[C0]] -// CHECK-RWT: %[[D1:.*]] = tensor.dim %[[A]], %[[C1]] -// CHECK-RWT: %[[B:.*]] = memref.alloc(%[[D0]], %[[D1]]) -// CHECK-RWT: linalg.fill ins(%[[F0]] : f64) outs(%[[B]] -// CHECK-RWT: sparse_tensor.foreach in %[[A]] -// CHECK-RWT: ^bb0(%[[FI0:.*]]: index, %[[FI1:.*]]: index, %[[FV:.*]]: f64): -// CHECK-RWT: memref.store %[[FV]], %[[B]]{{\[}}%[[FI0]], %[[FI1]]] -// CHECK-RWT: } -// CHECK-RWT: %[[T:.*]] = bufferization.to_tensor %[[B]] -// CHECK-RWT: return %[[T]] : tensor +// CHECK-LABEL: func.func @sparse_convert_2d_dyn2( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 4 : i8 +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_8:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_7]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_9:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_6]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_10]]{{\[}}%[[VAL_7]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_5]], %[[VAL_10]]{{\[}}%[[VAL_6]]] : memref<2xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_12]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_14]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_6]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_17:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = memref.cast %[[VAL_17]] : memref<2xindex> to memref +// CHECK: %[[VAL_19:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_20:.*]] = memref.alloc(%[[VAL_8]], %[[VAL_9]]) : memref +// CHECK: linalg.fill ins(%[[VAL_1]] : f64) outs(%[[VAL_20]] : memref) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_21:.*]] = func.call @getNextF64(%[[VAL_16]], %[[VAL_18]], %[[VAL_19]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_21]]) +// CHECK: } do { +// CHECK: %[[VAL_22:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_7]]] : memref<2xindex> +// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_17]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_19]][] : memref +// CHECK: memref.store %[[VAL_24]], %[[VAL_20]]{{\[}}%[[VAL_22]], %[[VAL_23]]] : memref +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorF64(%[[VAL_16]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_25:.*]] = bufferization.to_tensor %[[VAL_20]] : memref +// CHECK: return %[[VAL_25]] : tensor +// CHECK: } func.func @sparse_convert_2d_dyn2(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-LABEL: func @sparse_convert_3d( -// CHECK-SAME: %[[Arg:.*]]: !llvm.ptr) -> tensor<2x3x4xf64> -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[I2:.*]] = arith.constant 2 : index -// CHECK-DAG: %[[I3:.*]] = arith.constant 3 : index -// CHECK-DAG: %[[I4:.*]] = arith.constant 4 : index -// CHECK-DAG: %[[DenseDLT:.*]] = arith.constant 4 : i8 -// CHECK-DAG: %[[ActionToIter:.*]] = arith.constant 6 : i32 -// CHECK-DAG: %[[E0:.*]] = arith.constant 0.000000e+00 : f64 -// -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<3xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<3xi8> to memref -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I0]]] : memref<3xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I1]]] : memref<3xi8> -// CHECK-DAG: memref.store %[[DenseDLT]], %[[LvlTypes]][%[[I2]]] : memref<3xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<3xindex> to memref -// CHECK-DAG: memref.store %[[I2]], %[[DimSizes]][%[[I0]]] : memref<3xindex> -// CHECK-DAG: memref.store %[[I3]], %[[DimSizes]][%[[I1]]] : memref<3xindex> -// CHECK-DAG: memref.store %[[I4]], %[[DimSizes]][%[[I2]]] : memref<3xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<3xindex> to memref -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<3xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]][%[[I0]]] : memref<3xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]][%[[I1]]] : memref<3xindex> -// CHECK-DAG: memref.store %[[I2]], %[[Iota]][%[[I2]]] : memref<3xindex> -// CHECK: %[[Iter:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ActionToIter]], %[[Arg]]) -// -// CHECK-DAG: %[[IndS:.*]] = memref.alloca() : memref<3xindex> -// CHECK-DAG: %[[IndD:.*]] = memref.cast %[[IndS]] : memref<3xindex> to memref -// CHECK-DAG: %[[ElemBuffer:.*]] = memref.alloca() : memref -// CHECK-DAG: %[[M:.*]] = memref.alloc() : memref<2x3x4xf64> -// CHECK-DAG: linalg.fill ins(%[[E0]] : f64) outs(%[[M]] : memref<2x3x4xf64>) -// CHECK: scf.while : () -> () { -// CHECK: %[[Cond:.*]] = func.call @getNextF64(%[[Iter]], %[[IndD]], %[[ElemBuffer]]) : (!llvm.ptr, memref, memref) -> i1 -// CHECK: scf.condition(%[[Cond]]) -// CHECK: } do { -// CHECK: %[[Iv0:.*]] = memref.load %[[IndS]][%[[I0]]] : memref<3xindex> -// CHECK: %[[Iv1:.*]] = memref.load %[[IndS]][%[[I1]]] : memref<3xindex> -// CHECK: %[[Iv2:.*]] = memref.load %[[IndS]][%[[I2]]] : memref<3xindex> -// CHECK: %[[ElemVal:.*]] = memref.load %[[ElemBuffer]][] : memref -// CHECK: memref.store %[[ElemVal]], %[[M]][%[[Iv0]], %[[Iv1]], %[[Iv2]]] : memref<2x3x4xf64> -// CHECK: scf.yield -// CHECK: } -// CHECK: %[[T:.*]] = bufferization.to_tensor %[[M]] : memref<2x3x4xf64> -// CHECK: return %[[T]] : tensor<2x3x4xf64> +// CHECK-LABEL: func.func @sparse_convert_3d( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> tensor<2x3x4xf64> { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 3 : index +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 4 : index +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 4 : i8 +// CHECK: %[[VAL_11:.*]] = memref.alloca() : memref<3xi8> +// CHECK: %[[VAL_12:.*]] = memref.cast %[[VAL_11]] : memref<3xi8> to memref +// CHECK: memref.store %[[VAL_10]], %[[VAL_11]]{{\[}}%[[VAL_6]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_10]], %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_10]], %[[VAL_11]]{{\[}}%[[VAL_7]]] : memref<3xi8> +// CHECK: %[[VAL_13:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_14:.*]] = memref.cast %[[VAL_13]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_7]], %[[VAL_13]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_8]], %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: %[[VAL_15:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_16:.*]] = memref.cast %[[VAL_15]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_15]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_15]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_15]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: %[[VAL_17:.*]] = call @newSparseTensor(%[[VAL_14]], %[[VAL_14]], %[[VAL_12]], %[[VAL_16]], %[[VAL_16]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_2]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_18:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_19:.*]] = memref.cast %[[VAL_18]] : memref<3xindex> to memref +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref +// CHECK: %[[VAL_21:.*]] = memref.alloc() : memref<2x3x4xf64> +// CHECK: linalg.fill ins(%[[VAL_1]] : f64) outs(%[[VAL_21]] : memref<2x3x4xf64>) +// CHECK: scf.while : () -> () { +// CHECK: %[[VAL_22:.*]] = func.call @getNextF64(%[[VAL_17]], %[[VAL_19]], %[[VAL_20]]) : (!llvm.ptr, memref, memref) -> i1 +// CHECK: scf.condition(%[[VAL_22]]) +// CHECK: } do { +// CHECK: %[[VAL_23:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: %[[VAL_24:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_25:.*]] = memref.load %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: %[[VAL_26:.*]] = memref.load %[[VAL_20]][] : memref +// CHECK: memref.store %[[VAL_26]], %[[VAL_21]]{{\[}}%[[VAL_23]], %[[VAL_24]], %[[VAL_25]]] : memref<2x3x4xf64> +// CHECK: scf.yield +// CHECK: } +// CHECK: call @delSparseTensorIteratorF64(%[[VAL_17]]) : (!llvm.ptr) -> () +// CHECK: %[[VAL_27:.*]] = bufferization.to_tensor %[[VAL_21]] : memref<2x3x4xf64> +// CHECK: return %[[VAL_27]] : tensor<2x3x4xf64> +// CHECK: } func.func @sparse_convert_3d(%arg0: tensor<2x3x4xf64, #SparseTensor>) -> tensor<2x3x4xf64> { %0 = sparse_tensor.convert %arg0 : tensor<2x3x4xf64, #SparseTensor> to tensor<2x3x4xf64> return %0 : tensor<2x3x4xf64> diff --git a/mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir b/mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir index c373fd23bbef4..e8e69dc861015 100644 --- a/mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir +++ b/mlir/test/Dialect/SparseTensor/convert_sparse2sparse.mlir @@ -1,13 +1,4 @@ -// First use with `kViaCOO` for sparse2sparse conversion (the old way). -// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=1" \ -// RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECK-COO -// -// Now again with `kAuto` (the new default). -// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=0" \ -// RUN: --canonicalize --cse | FileCheck %s -check-prefixes=CHECK-AUTO,CHECK - -// RUN: mlir-opt %s --post-sparsification-rewrite="enable-runtime-library=false enable-foreach=false" \ -// RUN: --canonicalize --cse | FileCheck %s --check-prefix=CHECK-RWT +// RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s #SparseVector64 = #sparse_tensor.encoding<{ map = (d0) -> (d0 : compressed), @@ -42,71 +33,67 @@ map = (d0 : #sparse_tensor, d1 : #sparse_tensor) -> (d0 : compressed(nonunique), d1 : singleton) }> -// CHECK-LABEL: func @sparse_nop_convert( -// CHECK-SAME: %[[A:.*]]: !llvm.ptr) -> !llvm.ptr -// CHECK: return %[[A]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_nop_convert( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK: return %[[VAL_0]] : !llvm.ptr +// CHECK: } func.func @sparse_nop_convert(%arg0: tensor<64xf32, #SparseVector>) -> tensor<64xf32, #SparseVector> { %0 = sparse_tensor.convert %arg0 : tensor<64xf32, #SparseVector> to tensor<64xf32, #SparseVector> return %0 : tensor<64xf32, #SparseVector> } -// CHECK-LABEL: func @sparse_hidden_nop_cast( -// CHECK-SAME: %[[A:.*]]: !llvm.ptr) -> !llvm.ptr -// CHECK: return %[[A]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_hidden_nop_cast( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK: return %[[VAL_0]] : !llvm.ptr +// CHECK: } func.func @sparse_hidden_nop_cast(%arg0: tensor<32xf32, #SparseVector>) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor<32xf32, #SparseVector> to tensor return %0 : tensor } -// CHECK-LABEL: func @sparse_convert_1d_ss( -// CHECK-SAME: %[[A:.*]]: !llvm.ptr) -// CHECK-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32 -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]]) -// CHECK: return %[[T]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_convert_1d_ss( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_5:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_4]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_6:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_3]], %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<1xi8> +// CHECK: %[[VAL_8:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = call @newSparseTensor(%[[VAL_9]], %[[VAL_9]], %[[VAL_7]], %[[VAL_11]], %[[VAL_11]], %[[VAL_2]], %[[VAL_2]], %[[VAL_2]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: return %[[VAL_12]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_1d_ss(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-COO-LABEL: func @sparse_convert( -// CHECK-COO-SAME: %[[A:.*]]: !llvm.ptr) -// CHECK-COO-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32 -// CHECK-COO-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-COO-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-COO-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-COO-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-COO-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-COO-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-COO: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ToCOO]], %[[A]]) -// CHECK-COO: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK-COO: call @delSparseTensorCOOF32(%[[C]]) -// CHECK-COO: return %[[T]] : !llvm.ptr -// -// CHECK-AUTO-LABEL: func @sparse_convert( -// CHECK-AUTO-SAME: %[[A:.*]]: !llvm.ptr) -// CHECK-AUTO-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32 -// CHECK-AUTO-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-AUTO-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-AUTO-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-AUTO-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-AUTO-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-AUTO: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]]) -// CHECK-AUTO: return %[[T]] : !llvm.ptr - +// CHECK-LABEL: func.func @sparse_convert( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_5:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_4]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_6:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_3]], %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<1xi8> +// CHECK: %[[VAL_8:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = call @newSparseTensor(%[[VAL_9]], %[[VAL_9]], %[[VAL_7]], %[[VAL_11]], %[[VAL_11]], %[[VAL_2]], %[[VAL_2]], %[[VAL_2]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: return %[[VAL_12]] : !llvm.ptr +// CHECK: } func.func @sparse_convert(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor @@ -124,87 +111,107 @@ func.func @sparse_convert(%arg0: tensor) -> tensor -// CHECK-COO-LABEL: func @sparse_convert_singleton( -// CHECK-COO-SAME: %[[A:.*]]: !llvm.ptr) -// CHECK-COO-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32 -// CHECK-COO-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32 -// CHECK-COO-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-COO-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-COO-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-COO-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-COO-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-COO-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-COO: %[[C:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ToCOO]], %[[A]]) -// CHECK-COO: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]]) -// CHECK-COO: call @delSparseTensorCOOF32(%[[C]]) -// CHECK-COO: return %[[T]] : !llvm.ptr // -// CHECK-AUTO-LABEL: func @sparse_convert_singleton( -// CHECK-AUTO-SAME: %[[A:.*]]: !llvm.ptr) -// CHECK-AUTO-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32 -// CHECK-AUTO-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<1xi8> -// CHECK-AUTO-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[Iota:.*]] = memref.alloca() : memref<1xindex> -// CHECK-AUTO-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<1xi8> to memref -// CHECK-AUTO-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<1xindex> to memref -// CHECK-AUTO-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<1xindex> to memref -// CHECK-AUTO-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<1xindex> to memref -// CHECK-AUTO: %[[T:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]]) -// CHECK-AUTO: return %[[T]] : !llvm.ptr +// CHECK-LABEL: func.func @sparse_convert_singleton( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 16 : i8 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_5:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_4]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_6:.*]] = memref.alloca() : memref<1xi8> +// CHECK: %[[VAL_7:.*]] = memref.cast %[[VAL_6]] : memref<1xi8> to memref +// CHECK: memref.store %[[VAL_3]], %[[VAL_6]]{{\[}}%[[VAL_4]]] : memref<1xi8> +// CHECK: %[[VAL_8:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_9:.*]] = memref.cast %[[VAL_8]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_8]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<1xindex> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<1xindex> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<1xindex> +// CHECK: %[[VAL_12:.*]] = call @newSparseTensor(%[[VAL_9]], %[[VAL_9]], %[[VAL_7]], %[[VAL_11]], %[[VAL_11]], %[[VAL_2]], %[[VAL_2]], %[[VAL_2]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: return %[[VAL_12]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_singleton(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-RWT-LABEL: func.func @sparse_convert_permuted( -// CHECK-RWT-SAME: %[[VAL_0:.*]]: tensor>) -> tensor> { -// CHECK-RWT-DAG: %[[VAL_1:.*]] = arith.constant 0 : index -// CHECK-RWT-DAG: %[[VAL_2:.*]] = arith.constant 1 : index -// CHECK-RWT-DAG: %[[VAL_3:.*]] = arith.constant 2 : index -// CHECK-RWT-DAG: %[[VAL_4:.*]] = tensor.dim %[[VAL_0]], %[[VAL_1]] -// CHECK-RWT-DAG: %[[VAL_5:.*]] = tensor.dim %[[VAL_0]], %[[VAL_2]] -// CHECK-RWT-DAG: %[[VAL_6:.*]] = tensor.dim %[[VAL_0]], %[[VAL_3]] -// CHECK-RWT-DAG: %[[VAL_7:.*]] = sparse_tensor.number_of_entries %[[VAL_0]] -// CHECK-RWT: %[[VAL_8:.*]] = bufferization.alloc_tensor(%[[VAL_4]], %[[VAL_5]], %[[VAL_6]]) size_hint=%[[VAL_7]] -// CHECK-RWT: %[[VAL_9:.*]] = sparse_tensor.foreach in %[[VAL_0]] init(%[[VAL_8]]) -// CHECK-RWT: ^bb0(%[[VAL_10:.*]]: index, %[[VAL_11:.*]]: index, %[[VAL_12:.*]]: index, %[[VAL_13:.*]]: f32, %[[VAL_14:.*]]: tensor>): -// CHECK-RWT: %[[VAL_15:.*]] = sparse_tensor.insert %[[VAL_13]] into %[[VAL_14]]{{\[}}%[[VAL_12]], %[[VAL_10]], %[[VAL_11]]] -// CHECK-RWT: sparse_tensor.yield %[[VAL_15]] : tensor> -// CHECK-RWT: } -// CHECK-RWT: %[[VAL_16:.*]] = sparse_tensor.load %[[VAL_17:.*]] hasInserts : tensor> -// CHECK-RWT: %[[VAL_18:.*]] = sparse_tensor.values %[[VAL_16]] : tensor> to memref -// CHECK-RWT: %[[VAL_19:.*]] = sparse_tensor.coordinates_buffer %[[VAL_16]] : tensor> to memref -// CHECK-RWT: sparse_tensor.sort hybrid_quick_sort %[[VAL_7]], %[[VAL_19]] jointly %[[VAL_18]] {ny = 0 : index, perm_map = #map} -// CHECK-RWT: %[[VAL_20:.*]] = bufferization.alloc_tensor(%[[VAL_4]], %[[VAL_5]], %[[VAL_6]]) size_hint=%[[VAL_7]] -// CHECK-RWT: %[[VAL_21:.*]] = sparse_tensor.foreach in %[[VAL_16]] init(%[[VAL_20]]) -// CHECK-RWT: ^bb0(%[[VAL_22:.*]]: index, %[[VAL_23:.*]]: index, %[[VAL_24:.*]]: index, %[[VAL_25:.*]]: f32, %[[VAL_26:.*]]: tensor>): -// CHECK-RWT: %[[VAL_27:.*]] = sparse_tensor.insert %[[VAL_25]] into %[[VAL_26]]{{\[}}%[[VAL_24]], %[[VAL_22]], %[[VAL_23]]] -// CHECK-RWT: sparse_tensor.yield %[[VAL_27]] -// CHECK-RWT: } -// CHECK-RWT: bufferization.dealloc_tensor %[[VAL_16]] -// CHECK-RWT: %[[VAL_28:.*]] = sparse_tensor.load %[[VAL_29:.*]] hasInserts -// CHECK-RWT: %[[VAL_30:.*]] = sparse_tensor.convert %[[VAL_28]] -// CHECK-RWT: return %[[VAL_30]] +// CHECK-LABEL: func.func @sparse_convert_permuted( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 5 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 2 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 8 : i8 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 0 : index +// CHECK: %[[VAL_8:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_7]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_9:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_6]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_10:.*]] = call @sparseDimSize(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr, index) -> index +// CHECK: %[[VAL_11:.*]] = memref.alloca() : memref<3xi8> +// CHECK: %[[VAL_12:.*]] = memref.cast %[[VAL_11]] : memref<3xi8> to memref +// CHECK: memref.store %[[VAL_4]], %[[VAL_11]]{{\[}}%[[VAL_7]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_4]], %[[VAL_11]]{{\[}}%[[VAL_6]]] : memref<3xi8> +// CHECK: memref.store %[[VAL_4]], %[[VAL_11]]{{\[}}%[[VAL_5]]] : memref<3xi8> +// CHECK: %[[VAL_13:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_14:.*]] = memref.cast %[[VAL_13]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_9]], %[[VAL_13]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_10]], %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_15:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_16:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: %[[VAL_17:.*]] = memref.load %[[VAL_13]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: %[[VAL_18:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_19:.*]] = memref.cast %[[VAL_18]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_18]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_5]], %[[VAL_18]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_18]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_20:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_21:.*]] = memref.cast %[[VAL_20]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_20]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_20]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_6]], %[[VAL_20]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_22:.*]] = memref.alloca() : memref<3xindex> +// CHECK: %[[VAL_23:.*]] = memref.cast %[[VAL_22]] : memref<3xindex> to memref +// CHECK: memref.store %[[VAL_15]], %[[VAL_22]]{{\[}}%[[VAL_7]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_16]], %[[VAL_22]]{{\[}}%[[VAL_6]]] : memref<3xindex> +// CHECK: memref.store %[[VAL_17]], %[[VAL_22]]{{\[}}%[[VAL_5]]] : memref<3xindex> +// CHECK: %[[VAL_24:.*]] = call @newSparseTensor(%[[VAL_14]], %[[VAL_23]], %[[VAL_12]], %[[VAL_19]], %[[VAL_21]], %[[VAL_3]], %[[VAL_3]], %[[VAL_2]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: %[[VAL_25:.*]] = call @newSparseTensor(%[[VAL_14]], %[[VAL_23]], %[[VAL_12]], %[[VAL_19]], %[[VAL_21]], %[[VAL_3]], %[[VAL_3]], %[[VAL_2]], %[[VAL_2]], %[[VAL_24]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: call @delSparseTensorCOOF32(%[[VAL_24]]) : (!llvm.ptr) -> () +// CHECK: return %[[VAL_25]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_permuted(%arg0: tensor) -> tensor { %0 = sparse_tensor.convert %arg0 : tensor to tensor return %0 : tensor } -// CHECK-RWT-LABEL: func.func @sparse_convert_slice( -// CHECK-RWT-SAME: %[[VAL_0:.*]]: tensor<2x13xi32, #{{.*}}>) -> tensor<2x13xi32, #{{.*}}> { -// CHECK-RWT: %[[VAL_1:.*]] = sparse_tensor.number_of_entries %[[VAL_0]] : tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: %[[VAL_2:.*]] = bufferization.alloc_tensor() size_hint=%[[VAL_1]] : tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: %[[VAL_3:.*]] = sparse_tensor.foreach in %[[VAL_0]] init(%[[VAL_2]]) : tensor<2x13xi32, #{{.*}}>, tensor<2x13xi32, #{{.*}}> -> tensor<2x13xi32, #{{.*}}> do { -// CHECK-RWT: ^bb0(%[[VAL_4:.*]]: index, %[[VAL_5:.*]]: index, %[[VAL_6:.*]]: i32, %[[VAL_7:.*]]: tensor<2x13xi32, #{{.*}}>): -// CHECK-RWT: %[[VAL_8:.*]] = sparse_tensor.insert %[[VAL_6]] into %[[VAL_7]]{{\[}}%[[VAL_4]], %[[VAL_5]]] : tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: sparse_tensor.yield %[[VAL_8]] : tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: } -// CHECK-RWT: %[[VAL_9:.*]] = sparse_tensor.load %[[VAL_10:.*]] hasInserts : tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: %[[VAL_11:.*]] = sparse_tensor.convert %[[VAL_9]] : tensor<2x13xi32, #{{.*}}> to tensor<2x13xi32, #{{.*}}> -// CHECK-RWT: return %[[VAL_11]] : tensor<2x13xi32, #{{.*}}> +// CHECK-LABEL: func.func @sparse_convert_slice( +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_1:.*]] = arith.constant 3 : i32 +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 6 : i32 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 2 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant 13 : index +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant 9 : i8 +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 16 : i8 +// CHECK: %[[VAL_10:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_11:.*]] = memref.cast %[[VAL_10]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_8]], %[[VAL_10]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_9]], %[[VAL_10]]{{\[}}%[[VAL_4]]] : memref<2xi8> +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_6]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_7]], %[[VAL_12]]{{\[}}%[[VAL_4]]] : memref<2xindex> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_4]], %[[VAL_14]]{{\[}}%[[VAL_4]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = call @newSparseTensor(%[[VAL_13]], %[[VAL_13]], %[[VAL_11]], %[[VAL_15]], %[[VAL_15]], %[[VAL_3]], %[[VAL_3]], %[[VAL_2]], %[[VAL_1]], %[[VAL_0]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK: return %[[VAL_16]] : !llvm.ptr +// CHECK: } func.func @sparse_convert_slice(%arg0: tensor<2x13xi32, #COOSlice>) -> (tensor<2x13xi32, #SortedCOO2D>) { %0 = sparse_tensor.convert %arg0 : tensor<2x13xi32, #COOSlice> to tensor<2x13xi32, #SortedCOO2D> return %0 : tensor<2x13xi32, #SortedCOO2D> diff --git a/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir b/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir index e1fe5d85e72ec..7d852ca9cc1aa 100644 --- a/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir +++ b/mlir/test/Dialect/SparseTensor/sparse_fill_zero.mlir @@ -3,64 +3,60 @@ #DCSR = #sparse_tensor.encoding<{ map = (d0, d1) -> (d0 : compressed, d1 : compressed) }> // CHECK-LABEL: func.func @fill_zero_after_alloc( -// CHECK-SAME: %[[Arg0:.*]]: !llvm.ptr, -// CHECK-SAME: %[[Arg1:.*]]: !llvm.ptr) -> !llvm.ptr { -// CHECK-DAG: %[[F0:.*]] = arith.constant 0.000000e+00 : f64 -// CHECK-DAG: %[[C1:.*]] = arith.constant 1 : i32 -// CHECK-DAG: %[[C0:.*]] = arith.constant 0 : i32 -// CHECK-DAG: %[[I0:.*]] = arith.constant 0 : index -// CHECK-DAG: %[[I1:.*]] = arith.constant 1 : index -// CHECK-DAG: %[[False:.*]] = arith.constant false -// CHECK-DAG: %[[True:.*]] = arith.constant true -// CHECK-DAG: %[[I100:.*]] = arith.constant 100 : index -// CHECK-DAG: %[[I300:.*]] = arith.constant 300 : index -// CHECK-DAG: %[[CompressedDLT:.*]] = arith.constant 8 : i8 -// CHECK-DAG: %[[LvlTypes:.*]] = memref.alloca() : memref<2xi8> -// CHECK-DAG: %[[LvlTypesP:.*]] = memref.cast %[[LvlTypes]] : memref<2xi8> to memref -// CHECK-DAG: memref.store %[[CompressedDLT]], %[[LvlTypes]]{{\[}}%[[I0]]] : memref<2xi8> -// CHECK-DAG: memref.store %[[CompressedDLT]], %[[LvlTypes]]{{\[}}%[[I1]]] : memref<2xi8> -// CHECK-DAG: %[[DimSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[DimSizesP:.*]] = memref.cast %[[DimSizes]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I100]], %[[DimSizes]]{{\[}}%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I300]], %[[DimSizes]]{{\[}}%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[LvlSizes:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[LvlSizesP:.*]] = memref.cast %[[LvlSizes]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I100]], %[[LvlSizes]]{{\[}}%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I300]], %[[LvlSizes]]{{\[}}%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[Iota:.*]] = memref.alloca() : memref<2xindex> -// CHECK-DAG: %[[IotaP:.*]] = memref.cast %[[Iota]] : memref<2xindex> to memref -// CHECK-DAG: memref.store %[[I0]], %[[Iota]]{{\[}}%[[I0]]] : memref<2xindex> -// CHECK-DAG: memref.store %[[I1]], %[[Iota]]{{\[}}%[[I1]]] : memref<2xindex> -// CHECK-DAG: %[[NullPtr:.*]] = llvm.mlir.zero : !llvm.ptr -// CHECK: %[[VAL_19:.*]] = call @newSparseTensor(%[[DimSizesP]], %[[LvlSizesP]], %[[LvlTypesP]], %[[IotaP]], %[[IotaP]], %[[C0]], %[[C0]], %[[C1]], %[[C0]], %[[NullPtr]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr +// CHECK-SAME: %[[VAL_0:.*]]: !llvm.ptr, +// CHECK-SAME: %[[VAL_1:.*]]: !llvm.ptr) -> !llvm.ptr { +// CHECK-DAG: %[[VAL_2:.*]] = arith.constant 0.000000e+00 : f64 +// CHECK-DAG: %[[VAL_3:.*]] = arith.constant 1 : i32 +// CHECK-DAG: %[[VAL_4:.*]] = arith.constant 0 : i32 +// CHECK-DAG: %[[VAL_5:.*]] = arith.constant 0 : index +// CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1 : index +// CHECK-DAG: %[[VAL_7:.*]] = arith.constant false +// CHECK-DAG: %[[VAL_8:.*]] = arith.constant true +// CHECK-DAG: %[[VAL_9:.*]] = arith.constant 100 : index +// CHECK-DAG: %[[VAL_10:.*]] = arith.constant 300 : index +// CHECK-DAG: %[[VAL_11:.*]] = arith.constant 8 : i8 +// CHECK: %[[VAL_12:.*]] = memref.alloca() : memref<2xi8> +// CHECK: %[[VAL_13:.*]] = memref.cast %[[VAL_12]] : memref<2xi8> to memref +// CHECK: memref.store %[[VAL_11]], %[[VAL_12]]{{\[}}%[[VAL_5]]] : memref<2xi8> +// CHECK: memref.store %[[VAL_11]], %[[VAL_12]]{{\[}}%[[VAL_6]]] : memref<2xi8> +// CHECK: %[[VAL_14:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_15:.*]] = memref.cast %[[VAL_14]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_9]], %[[VAL_14]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_10]], %[[VAL_14]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_16:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_17:.*]] = memref.cast %[[VAL_16]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_5]], %[[VAL_16]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: memref.store %[[VAL_6]], %[[VAL_16]]{{\[}}%[[VAL_6]]] : memref<2xindex> +// CHECK: %[[VAL_18:.*]] = llvm.mlir.zero : !llvm.ptr +// CHECK: %[[VAL_19:.*]] = call @newSparseTensor(%[[VAL_15]], %[[VAL_15]], %[[VAL_13]], %[[VAL_17]], %[[VAL_17]], %[[VAL_4]], %[[VAL_4]], %[[VAL_3]], %[[VAL_4]], %[[VAL_18]]) : (memref, memref, memref, memref, memref, i32, i32, i32, i32, !llvm.ptr) -> !llvm.ptr // CHECK: %[[VAL_20:.*]] = memref.alloc() : memref<300xf64> // CHECK: %[[VAL_21:.*]] = memref.cast %[[VAL_20]] : memref<300xf64> to memref // CHECK: %[[VAL_22:.*]] = memref.alloc() : memref<300xi1> // CHECK: %[[VAL_23:.*]] = memref.cast %[[VAL_22]] : memref<300xi1> to memref // CHECK: %[[VAL_24:.*]] = memref.alloc() : memref<300xindex> // CHECK: %[[VAL_25:.*]] = memref.cast %[[VAL_24]] : memref<300xindex> to memref -// CHECK: linalg.fill ins(%[[F0]] : f64) outs(%[[VAL_20]] : memref<300xf64>) -// CHECK: linalg.fill ins(%[[False]] : i1) outs(%[[VAL_22]] : memref<300xi1>) -// CHECK: %[[VAL_26:.*]] = call @sparsePositions0(%[[Arg0]], %[[I0]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_27:.*]] = call @sparseCoordinates0(%[[Arg0]], %[[I0]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_28:.*]] = call @sparsePositions0(%[[Arg0]], %[[I1]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_29:.*]] = call @sparseCoordinates0(%[[Arg0]], %[[I1]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_30:.*]] = call @sparseValuesF64(%[[Arg0]]) : (!llvm.ptr) -> memref -// CHECK: %[[VAL_31:.*]] = call @sparsePositions0(%[[Arg1]], %[[I0]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_32:.*]] = call @sparseCoordinates0(%[[Arg1]], %[[I0]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_33:.*]] = call @sparsePositions0(%[[Arg1]], %[[I1]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_34:.*]] = call @sparseCoordinates0(%[[Arg1]], %[[I1]]) : (!llvm.ptr, index) -> memref -// CHECK: %[[VAL_35:.*]] = call @sparseValuesF64(%[[Arg1]]) : (!llvm.ptr) -> memref -// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_26]]{{\[}}%[[I0]]] : memref -// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_26]]{{\[}}%[[I1]]] : memref -// CHECK: scf.for %[[VAL_38:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[I1]] { +// CHECK: linalg.fill ins(%[[VAL_2]] : f64) outs(%[[VAL_20]] : memref<300xf64>) +// CHECK: linalg.fill ins(%[[VAL_7]] : i1) outs(%[[VAL_22]] : memref<300xi1>) +// CHECK: %[[VAL_26:.*]] = call @sparsePositions0(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_27:.*]] = call @sparseCoordinates0(%[[VAL_0]], %[[VAL_5]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_28:.*]] = call @sparsePositions0(%[[VAL_0]], %[[VAL_6]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_29:.*]] = call @sparseCoordinates0(%[[VAL_0]], %[[VAL_6]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_30:.*]] = call @sparseValuesF64(%[[VAL_0]]) : (!llvm.ptr) -> memref +// CHECK: %[[VAL_31:.*]] = call @sparsePositions0(%[[VAL_1]], %[[VAL_5]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_32:.*]] = call @sparseCoordinates0(%[[VAL_1]], %[[VAL_5]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_33:.*]] = call @sparsePositions0(%[[VAL_1]], %[[VAL_6]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_34:.*]] = call @sparseCoordinates0(%[[VAL_1]], %[[VAL_6]]) : (!llvm.ptr, index) -> memref +// CHECK: %[[VAL_35:.*]] = call @sparseValuesF64(%[[VAL_1]]) : (!llvm.ptr) -> memref +// CHECK: %[[VAL_36:.*]] = memref.load %[[VAL_26]]{{\[}}%[[VAL_5]]] : memref +// CHECK: %[[VAL_37:.*]] = memref.load %[[VAL_26]]{{\[}}%[[VAL_6]]] : memref +// CHECK: scf.for %[[VAL_38:.*]] = %[[VAL_36]] to %[[VAL_37]] step %[[VAL_6]] { // CHECK: %[[VAL_39:.*]] = memref.load %[[VAL_27]]{{\[}}%[[VAL_38]]] : memref // CHECK: %[[VAL_40:.*]] = memref.load %[[VAL_28]]{{\[}}%[[VAL_38]]] : memref -// CHECK: %[[VAL_41:.*]] = arith.addi %[[VAL_38]], %[[I1]] : index +// CHECK: %[[VAL_41:.*]] = arith.addi %[[VAL_38]], %[[VAL_6]] : index // CHECK: %[[VAL_42:.*]] = memref.load %[[VAL_28]]{{\[}}%[[VAL_41]]] : memref -// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_31]]{{\[}}%[[I0]]] : memref -// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_31]]{{\[}}%[[I1]]] : memref -// CHECK: %[[VAL_45:.*]]:3 = scf.while (%[[VAL_46:.*]] = %[[VAL_40]], %[[VAL_47:.*]] = %[[VAL_43]], %[[VAL_48:.*]] = %[[I0]]) : (index, index, index) -> (index, index, index) { +// CHECK: %[[VAL_43:.*]] = memref.load %[[VAL_31]]{{\[}}%[[VAL_5]]] : memref +// CHECK: %[[VAL_44:.*]] = memref.load %[[VAL_31]]{{\[}}%[[VAL_6]]] : memref +// CHECK: %[[VAL_45:.*]]:3 = scf.while (%[[VAL_46:.*]] = %[[VAL_40]], %[[VAL_47:.*]] = %[[VAL_43]], %[[VAL_48:.*]] = %[[VAL_5]]) : (index, index, index) -> (index, index, index) { // CHECK: %[[VAL_49:.*]] = arith.cmpi ult, %[[VAL_46]], %[[VAL_42]] : index // CHECK: %[[VAL_50:.*]] = arith.cmpi ult, %[[VAL_47]], %[[VAL_44]] : index // CHECK: %[[VAL_51:.*]] = arith.andi %[[VAL_49]], %[[VAL_50]] : i1 @@ -77,50 +73,50 @@ // CHECK: %[[VAL_62:.*]] = scf.if %[[VAL_61]] -> (index) { // CHECK: %[[VAL_63:.*]] = memref.load %[[VAL_30]]{{\[}}%[[VAL_52]]] : memref // CHECK: %[[VAL_64:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_53]]] : memref -// CHECK: %[[VAL_65:.*]] = arith.addi %[[VAL_53]], %[[I1]] : index +// CHECK: %[[VAL_65:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index // CHECK: %[[VAL_66:.*]] = memref.load %[[VAL_33]]{{\[}}%[[VAL_65]]] : memref -// CHECK: %[[VAL_67:.*]] = scf.for %[[VAL_68:.*]] = %[[VAL_64]] to %[[VAL_66]] step %[[I1]] iter_args(%[[VAL_69:.*]] = %[[VAL_54]]) -> (index) { +// CHECK: %[[VAL_67:.*]] = scf.for %[[VAL_68:.*]] = %[[VAL_64]] to %[[VAL_66]] step %[[VAL_6]] iter_args(%[[VAL_69:.*]] = %[[VAL_54]]) -> (index) { // CHECK: %[[VAL_70:.*]] = memref.load %[[VAL_34]]{{\[}}%[[VAL_68]]] : memref // CHECK: %[[VAL_71:.*]] = memref.load %[[VAL_20]]{{\[}}%[[VAL_70]]] : memref<300xf64> // CHECK: %[[VAL_72:.*]] = memref.load %[[VAL_35]]{{\[}}%[[VAL_68]]] : memref // CHECK: %[[VAL_73:.*]] = arith.mulf %[[VAL_63]], %[[VAL_72]] : f64 // CHECK: %[[VAL_74:.*]] = arith.addf %[[VAL_71]], %[[VAL_73]] : f64 // CHECK: %[[VAL_75:.*]] = memref.load %[[VAL_22]]{{\[}}%[[VAL_70]]] : memref<300xi1> -// CHECK: %[[VAL_76:.*]] = arith.cmpi eq, %[[VAL_75]], %[[False]] : i1 +// CHECK: %[[VAL_76:.*]] = arith.cmpi eq, %[[VAL_75]], %[[VAL_7]] : i1 // CHECK: %[[VAL_77:.*]] = scf.if %[[VAL_76]] -> (index) { -// CHECK: memref.store %[[True]], %[[VAL_22]]{{\[}}%[[VAL_70]]] : memref<300xi1> -// CHECK: memref.store %[[VAL_70]], %[[VAL_24]]{{\[}}%[[VAL_69]]] : memref<300xindex> -// CHECK: %[[VAL_78:.*]] = arith.addi %[[VAL_69]], %[[I1]] : index -// CHECK: scf.yield %[[VAL_78]] : index +// CHECK: memref.store %[[VAL_8]], %[[VAL_22]]{{\[}}%[[VAL_70]]] : memref<300xi1> +// CHECK: memref.store %[[VAL_70]], %[[VAL_24]]{{\[}}%[[VAL_69]]] : memref<300xindex> +// CHECK: %[[VAL_78:.*]] = arith.addi %[[VAL_69]], %[[VAL_6]] : index +// CHECK: scf.yield %[[VAL_78]] : index // CHECK: } else { -// CHECK: scf.yield %[[VAL_69]] : index +// CHECK: scf.yield %[[VAL_69]] : index // CHECK: } // CHECK: memref.store %[[VAL_74]], %[[VAL_20]]{{\[}}%[[VAL_70]]] : memref<300xf64> -// CHECK: scf.yield %[[VAL_79:.*]] : index +// CHECK: scf.yield %[[VAL_77]] : index // CHECK: } -// CHECK: scf.yield %[[VAL_80:.*]] : index +// CHECK: scf.yield %[[VAL_67]] : index // CHECK: } else { // CHECK: scf.yield %[[VAL_54]] : index // CHECK: } -// CHECK: %[[VAL_81:.*]] = arith.addi %[[VAL_52]], %[[I1]] : index -// CHECK: %[[VAL_82:.*]] = arith.select %[[VAL_59]], %[[VAL_81]], %[[VAL_52]] : index -// CHECK: %[[VAL_83:.*]] = arith.addi %[[VAL_53]], %[[I1]] : index -// CHECK: %[[VAL_84:.*]] = arith.select %[[VAL_60]], %[[VAL_83]], %[[VAL_53]] : index -// CHECK: scf.yield %[[VAL_82]], %[[VAL_84]], %[[VAL_85:.*]] : index, index, index +// CHECK: %[[VAL_79:.*]] = arith.addi %[[VAL_52]], %[[VAL_6]] : index +// CHECK: %[[VAL_80:.*]] = arith.select %[[VAL_59]], %[[VAL_79]], %[[VAL_52]] : index +// CHECK: %[[VAL_81:.*]] = arith.addi %[[VAL_53]], %[[VAL_6]] : index +// CHECK: %[[VAL_82:.*]] = arith.select %[[VAL_60]], %[[VAL_81]], %[[VAL_53]] : index +// CHECK: scf.yield %[[VAL_80]], %[[VAL_82]], %[[VAL_62]] : index, index, index // CHECK: } -// CHECK: %[[VAL_86:.*]] = memref.alloca() : memref<2xindex> -// CHECK: %[[VAL_87:.*]] = memref.cast %[[VAL_86]] : memref<2xindex> to memref -// CHECK: memref.store %[[VAL_39]], %[[VAL_86]]{{\[}}%[[I0]]] : memref<2xindex> -// CHECK: func.call @expInsertF64(%[[VAL_19]], %[[VAL_87]], %[[VAL_21]], %[[VAL_23]], %[[VAL_25]], %[[VAL_88:.*]]#2) : (!llvm.ptr, memref, memref, memref, memref, index) -> () +// CHECK: %[[VAL_83:.*]] = memref.alloca() : memref<2xindex> +// CHECK: %[[VAL_84:.*]] = memref.cast %[[VAL_83]] : memref<2xindex> to memref +// CHECK: memref.store %[[VAL_39]], %[[VAL_83]]{{\[}}%[[VAL_5]]] : memref<2xindex> +// CHECK: func.call @expInsertF64(%[[VAL_19]], %[[VAL_84]], %[[VAL_21]], %[[VAL_23]], %[[VAL_25]], %[[VAL_85:.*]]#2) : (!llvm.ptr, memref, memref, memref, memref, index) -> () // CHECK: } // CHECK: memref.dealloc %[[VAL_20]] : memref<300xf64> // CHECK: memref.dealloc %[[VAL_22]] : memref<300xi1> // CHECK: memref.dealloc %[[VAL_24]] : memref<300xindex> // CHECK: call @endInsert(%[[VAL_19]]) : (!llvm.ptr) -> () // CHECK: return %[[VAL_19]] : !llvm.ptr -// CHECK: } +// CHECK: } func.func @fill_zero_after_alloc(%arg0: tensor<100x200xf64, #DCSR>, - %arg1: tensor<200x300xf64, #DCSR>) -> tensor<100x300xf64, #DCSR> { + %arg1: tensor<200x300xf64, #DCSR>) -> tensor<100x300xf64, #DCSR> { %0 = tensor.empty() : tensor<100x300xf64, #DCSR> %cst = arith.constant 0.000000e+00 : f64 %1 = linalg.fill ins(%cst : f64)