889f4bf264
This commit comprises a number of related changes:
(1) Reintroduces the semantic distinction between `parseVarUsage` vs `parseVarBinding`, adds documentation explaining the distinction, and adds commentary to the one place that violates the desired/intended semantics.
(2) Improves documentation/commentary about the forward-declaration of level-vars, and about the meaning of the `bool` parameter to `parseLvlSpec`.
(2) Removes the `VarEnv::addVars` method, and instead has `DimLvlMapParser` handle the conversion issues directly. In particular, the parser now stores and maintains the `{dims,lvls}AndSymbols` arrays, thereby avoiding the O(n^2) behavior of scanning through the entire `VarEnv` for each `parse{Dim,Lvl}Spec` call. Unfortunately there still remains another source of O(n^2) behavior, namely: the `AsmParser::parseAffineExpr` method will copy the `DimLvlMapParser::{dims,lvls}AndSymbols` arrays into `AffineParser::dimsAndSymbols` on each `parse{Dim,Lvl}Spec` call; but fixing that would require extensive changes to `AffineParser` itself.
Depends On D155532
Reviewed By: Peiming
Differential Revision: https://reviews.llvm.org/D155533
117 lines
4.4 KiB
MLIR
117 lines
4.4 KiB
MLIR
// RUN: mlir-opt %s -split-input-file -verify-diagnostics
|
|
|
|
// expected-error@+1 {{expected a non-empty array for lvlTypes}}
|
|
#a = #sparse_tensor.encoding<{lvlTypes = []}>
|
|
func.func private @scalar(%arg0: tensor<f64, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
// expected-error@+2 {{dimension-rank mismatch between encoding and tensor shape: 2 != 1}}
|
|
#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"]}>
|
|
func.func private @tensor_dimlevel_size_mismatch(%arg0: tensor<8xi32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
// expected-error@+1 {{level-rank mismatch between dimToLvl and lvlTypes: 1 != 2}}
|
|
#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimToLvl = affine_map<(i) -> (i)>}>
|
|
func.func private @tensor_sizes_mismatch(%arg0: tensor<8xi32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{lvlTypes = [1]}> // expected-error {{expected a string value in lvlTypes}}
|
|
func.func private @tensor_type_mismatch(%arg0: tensor<8xi32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{lvlTypes = ["strange"]}> // expected-error {{unexpected level-type: strange}}
|
|
func.func private @tensor_value_mismatch(%arg0: tensor<8xi32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{dimToLvl = "wrong"}> // expected-error {{expected an affine map for dimToLvl}}
|
|
func.func private @tensor_dimtolvl_mismatch(%arg0: tensor<8xi32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
// expected-error@+1 {{expected a permutation affine map for dimToLvl}}
|
|
#a = #sparse_tensor.encoding<{lvlTypes = ["dense", "compressed"], dimToLvl = affine_map<(i,j) -> (i,i)>}>
|
|
func.func private @tensor_no_permutation(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{posWidth = "x"}> // expected-error {{expected an integral position bitwidth}}
|
|
func.func private @tensor_no_int_ptr(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{posWidth = 42}> // expected-error {{unexpected position bitwidth: 42}}
|
|
func.func private @tensor_invalid_int_ptr(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{crdWidth = "not really"}> // expected-error {{expected an integral index bitwidth}}
|
|
func.func private @tensor_no_int_index(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{crdWidth = 128}> // expected-error {{unexpected coordinate bitwidth: 128}}
|
|
func.func private @tensor_invalid_int_index(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#a = #sparse_tensor.encoding<{key = 1}> // expected-error {{unexpected key: key}}
|
|
func.func private @tensor_invalid_key(%arg0: tensor<16x32xf32, #a>) -> ()
|
|
|
|
// -----
|
|
|
|
#CSR_SLICE = #sparse_tensor.encoding<{
|
|
lvlTypes = [ "dense", "compressed" ],
|
|
dimSlices = [ (-1, ?, 1), (?, 4, 2) ] // expected-error{{expect positive value or ? for slice offset/size/stride}}
|
|
}>
|
|
func.func private @sparse_slice(tensor<?x?xf64, #CSR_SLICE>)
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// Migration plan for new STEA surface syntax,
|
|
// use the NEW_SYNTAX on selected examples
|
|
// and then TODO: remove when fully migrated
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
// -----
|
|
|
|
// expected-error@+3 {{Level-rank mismatch between forward-declarations and specifiers. Declared 3 level-variables; but got 2 level-specifiers.}}
|
|
#TooManyLvlDecl = #sparse_tensor.encoding<{
|
|
NEW_SYNTAX =
|
|
{l0, l1, l2} (d0, d1) -> (l0 = d0 : dense, l1 = d1 : compressed)
|
|
}>
|
|
func.func private @too_many_lvl_decl(%arg0: tensor<?x?xf64, #TooManyLvlDecl>) {
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// NOTE: We don't get the "level-rank mismatch" error here, because this
|
|
// "undeclared identifier" error occurs first. The error message is a bit
|
|
// misleading because `parseLvlVarBinding` calls `parseVarUsage` rather
|
|
// than `parseVarBinding` (and the error message generated by `parseVar`
|
|
// is assuming that `parseVarUsage` is only called for *uses* of variables).
|
|
// expected-error@+3 {{use of undeclared identifier 'l1'}}
|
|
#TooFewLvlDecl = #sparse_tensor.encoding<{
|
|
NEW_SYNTAX =
|
|
{l0} (d0, d1) -> (l0 = d0 : dense, l1 = d1 : compressed)
|
|
}>
|
|
func.func private @too_few_lvl_decl(%arg0: tensor<?x?xf64, #TooFewLvlDecl>) {
|
|
return
|
|
}
|
|
|
|
// -----
|
|
|
|
// expected-error@+3 {{Level-variable ordering mismatch. The variable 'l0' was forward-declared as the 1st level; but is bound by the 0th specification.}}
|
|
#WrongOrderLvlDecl = #sparse_tensor.encoding<{
|
|
NEW_SYNTAX =
|
|
{l1, l0} (d0, d1) -> (l0 = d0 : dense, l1 = d1 : compressed)
|
|
}>
|
|
func.func private @wrong_order_lvl_decl(%arg0: tensor<?x?xf64, #WrongOrderLvlDecl>) {
|
|
return
|
|
}
|
|
|