This is an archive of the discontinued LLVM Phabricator instance.

Differential D132757

[mlir][sparse] move sparse2sparse conversion to own test file
ClosedPublic

Authored by aartbik on Aug 26 2022, 12:32 PM.

Details

Reviewers
bixia
Peiming
wrengr
Commits
rGa8166d880125: [mlir][sparse] move sparse2sparse conversion to own test file
Summary

Rationale:
We were running *all* conversion tests two times, just to check the
difference of one indidivual test in that file. By splitting that test
out, we have a much more focused testing setup.

Diff Detail

Event Timeline

aartbik created this revision.Aug 26 2022, 12:32 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 26 2022, 12:32 PM
Herald added subscribers: anlunx, bzcheeseman, sdasgup3 and 18 others. · View Herald Transcript
aartbik requested review of this revision.Aug 26 2022, 12:32 PM
Herald added a project: Restricted Project. · View Herald TranscriptAug 26 2022, 12:32 PM
Herald added subscribers: stephenneuendorffer, nicolasvasilache. · View Herald Transcript
aartbik added reviewers: Peiming, wrengr.Aug 26 2022, 12:32 PM
bixia accepted this revision.Aug 26 2022, 12:50 PM
This revision is now accepted and ready to land.Aug 26 2022, 12:50 PM
Harbormaster completed remote builds in B183662: Diff 455998.Aug 26 2022, 1:16 PM
Closed by commit rGa8166d880125: [mlir][sparse] move sparse2sparse conversion to own test file (authored by aartbik). · Explain WhyAug 26 2022, 1:17 PM
This revision was automatically updated to reflect the committed changes.
aartbik added a commit: rGa8166d880125: [mlir][sparse] move sparse2sparse conversion to own test file.

Revision Contents

PathSize
mlir/
test/
Dialect/
SparseTensor/
26 lines
49 lines

Diff 456006

mlir/test/Dialect/SparseTensor/conversion.mlir

// First use with `kViaCOO` for sparse2sparse conversion (the old way). // RUN: mlir-opt %s --sparse-tensor-conversion --canonicalize --cse | FileCheck %s
// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=1" \
// RUN: --canonicalize --cse | FileCheck %s
//
// Now again with `kAuto` (the new default).
// RUN: mlir-opt %s --sparse-tensor-conversion="s2s-strategy=0" \
// RUN: --canonicalize --cse | FileCheck %s -check-prefix=CHECKAUTO
#SparseVector = #sparse_tensor.encoding<{ #SparseVector = #sparse_tensor.encoding<{
dimLevelType = ["compressed"] dimLevelType = ["compressed"]
}> }>
#SparseVector64 = #sparse_tensor.encoding<{ #SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"], dimLevelType = ["compressed"],
pointerBitWidth = 64, pointerBitWidth = 64,
▲ Show 20 Lines • Show All 212 Lines • ▼ Show 20 Lines
// CHECK: return %[[T]] : !llvm.ptr<i8> // CHECK: return %[[T]] : !llvm.ptr<i8>
func.func @sparse_convert_complex(%arg0: tensor<100xcomplex<f64>>) -> tensor<100xcomplex<f64>, #SparseVector> { func.func @sparse_convert_complex(%arg0: tensor<100xcomplex<f64>>) -> tensor<100xcomplex<f64>, #SparseVector> {
%0 = sparse_tensor.convert %arg0 : tensor<100xcomplex<f64>> to tensor<100xcomplex<f64>, #SparseVector> %0 = sparse_tensor.convert %arg0 : tensor<100xcomplex<f64>> to tensor<100xcomplex<f64>, #SparseVector>
return %0 : tensor<100xcomplex<f64>, #SparseVector> return %0 : tensor<100xcomplex<f64>, #SparseVector>
} }
// CHECK-LABEL: func @sparse_convert_1d_ss( // CHECK-LABEL: func @sparse_convert_1d_ss(
// CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>) // CHECK-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32 // CHECK-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32
// CHECK-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32
// CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8> // CHECK-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>
// CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex> // CHECK-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex> // CHECK-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>
// CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8> // CHECK-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>
// CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex> // CHECK-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>
// CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex> // CHECK-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>
// CHECK: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ToCOO]], %[[A]]) // CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]])
// CHECK: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]])
// CHECK: call @delSparseTensorCOOF32(%[[C]])
// CHECK: return %[[T]] : !llvm.ptr<i8> // CHECK: return %[[T]] : !llvm.ptr<i8>
// CHECKAUTO-LABEL: func @sparse_convert_1d_ss(
// CHECKAUTO-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECKAUTO-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32
// CHECKAUTO-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>
// CHECKAUTO-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>
// CHECKAUTO-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>
// CHECKAUTO-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>
// CHECKAUTO-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>
// CHECKAUTO-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>
// CHECKAUTO: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]])
// CHECKAUTO: return %[[T]] : !llvm.ptr<i8>
func.func @sparse_convert_1d_ss(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf32, #SparseVector32> { func.func @sparse_convert_1d_ss(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf32, #SparseVector32> {
%0 = sparse_tensor.convert %arg0 : tensor<?xf32, #SparseVector64> to tensor<?xf32, #SparseVector32> %0 = sparse_tensor.convert %arg0 : tensor<?xf32, #SparseVector64> to tensor<?xf32, #SparseVector32>
return %0 : tensor<?xf32, #SparseVector32> return %0 : tensor<?xf32, #SparseVector32>
} }
// CHECK-LABEL: func @sparse_convert_2d( // CHECK-LABEL: func @sparse_convert_2d(
// CHECK-SAME: %[[A:.*]]: tensor<2x4xf64>) -> !llvm.ptr<i8> // CHECK-SAME: %[[A:.*]]: tensor<2x4xf64>) -> !llvm.ptr<i8>
// CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32 // CHECK-DAG: %[[EmptyCOO:.*]] = arith.constant 4 : i32
▲ Show 20 Lines • Show All 321 Lines • Show Last 20 Lines

mlir/test/Dialect/SparseTensor/conversion_sparse2sparse.mlir

  • This file was added.
// 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-prefix=CHECK-AUTO
#SparseVector64 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"],
pointerBitWidth = 64,
indexBitWidth = 64
}>
#SparseVector32 = #sparse_tensor.encoding<{
dimLevelType = ["compressed"],
pointerBitWidth = 32,
indexBitWidth = 32
}>
// CHECK-COO-LABEL: func @sparse_convert(
// CHECK-COO-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK-COO-DAG: %[[ToCOO:.*]] = arith.constant 5 : i32
// CHECK-COO-DAG: %[[FromCOO:.*]] = arith.constant 2 : i32
// CHECK-COO-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>
// CHECK-COO-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>
// CHECK-COO-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>
// CHECK-COO-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>
// CHECK-COO-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>
// CHECK-COO-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>
// CHECK-COO: %[[C:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[ToCOO]], %[[A]])
// CHECK-COO: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[FromCOO]], %[[C]])
// CHECK-COO: call @delSparseTensorCOOF32(%[[C]])
// CHECK-COO: return %[[T]] : !llvm.ptr<i8>
// CHECK-AUTO-LABEL: func @sparse_convert(
// CHECK-AUTO-SAME: %[[A:.*]]: !llvm.ptr<i8>)
// CHECK-AUTO-DAG: %[[SparseToSparse:.*]] = arith.constant 3 : i32
// CHECK-AUTO-DAG: %[[P:.*]] = memref.alloca() : memref<1xi8>
// CHECK-AUTO-DAG: %[[Q:.*]] = memref.alloca() : memref<1xindex>
// CHECK-AUTO-DAG: %[[R:.*]] = memref.alloca() : memref<1xindex>
// CHECK-AUTO-DAG: %[[X:.*]] = memref.cast %[[P]] : memref<1xi8> to memref<?xi8>
// CHECK-AUTO-DAG: %[[Y:.*]] = memref.cast %[[Q]] : memref<1xindex> to memref<?xindex>
// CHECK-AUTO-DAG: %[[Z:.*]] = memref.cast %[[R]] : memref<1xindex> to memref<?xindex>
// CHECK-AUTO: %[[T:.*]] = call @newSparseTensor(%[[X]], %[[Y]], %[[Z]], %{{.*}}, %{{.*}}, %{{.*}}, %[[SparseToSparse]], %[[A]])
// CHECK-AUTO: return %[[T]] : !llvm.ptr<i8>
func.func @sparse_convert(%arg0: tensor<?xf32, #SparseVector64>) -> tensor<?xf32, #SparseVector32> {
%0 = sparse_tensor.convert %arg0 : tensor<?xf32, #SparseVector64> to tensor<?xf32, #SparseVector32>
return %0 : tensor<?xf32, #SparseVector32>
}