Skip to content

Commit d2e8517

Browse files
yinying-lisa-liyinying-lisa-li
authored
[mlir][sparse] Update Enum name for CompressedWithHigh (#67845)
Change CompressedWithHigh to LooseCompressed.
1 parent 705d21f commit d2e8517

File tree

13 files changed

+102
-102
lines changed

13 files changed

+102
-102
lines changed

‎mlir/include/mlir-c/Dialect/SparseTensor.h

Lines changed: 14 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -26,20 +26,20 @@ MLIR_DECLARE_CAPI_DIALECT_REGISTRATION(SparseTensor, sparse_tensor);
2626
/// If updating, keep them in sync and update the static_assert in the impl
2727
/// file.
2828
enum MlirSparseTensorDimLevelType {
29-
MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE = 4, // 0b00001_00
30-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED = 8, // 0b00010_00
31-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU = 9, // 0b00010_01
32-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NO = 10, // 0b00010_10
33-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU_NO = 11, // 0b00010_11
34-
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON = 16, // 0b00100_00
35-
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU = 17, // 0b00100_01
36-
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NO = 18, // 0b00100_10
37-
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO = 19, // 0b00100_11
38-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI = 32, // 0b01000_00
39-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU = 33, // 0b01000_01
40-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NO = 34, // 0b01000_10
41-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU_NO = 35, // 0b01000_11
42-
MLIR_SPARSE_TENSOR_DIM_LEVEL_TWO_OUT_OF_FOUR = 64, // 0b10000_00
29+
MLIR_SPARSE_TENSOR_DIM_LEVEL_DENSE = 4, // 0b00001_00
30+
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED = 8, // 0b00010_00
31+
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU = 9, // 0b00010_01
32+
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NO = 10, // 0b00010_10
33+
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_NU_NO = 11, // 0b00010_11
34+
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON = 16, // 0b00100_00
35+
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU = 17, // 0b00100_01
36+
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NO = 18, // 0b00100_10
37+
MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO = 19, // 0b00100_11
38+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED = 32, // 0b01000_00
39+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NU = 33, // 0b01000_01
40+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NO = 34, // 0b01000_10
41+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NU_NO = 35, // 0b01000_11
42+
MLIR_SPARSE_TENSOR_DIM_LEVEL_TWO_OUT_OF_FOUR = 64, // 0b10000_00
4343
};
4444

4545
//===----------------------------------------------------------------------===//

‎mlir/include/mlir/Dialect/SparseTensor/IR/Enums.h

Lines changed: 53 additions & 53 deletions
Original file line numberDiff line numberDiff line change
@@ -170,33 +170,33 @@ enum class Action : uint32_t {
170170
// TODO: We should generalize TwoOutOfFour to N out of M and use property to
171171
// encode the value of N and M.
172172
// TODO: Update DimLevelType to use lower 8 bits for storage formats and the
173-
// higher 4 bits to store level properties. Consider CompressedWithHi and
173+
// higher 4 bits to store level properties. Consider LooseCompressed and
174174
// TwoOutOfFour as properties instead of formats.
175175
enum class DimLevelType : uint8_t {
176-
Undef = 0, // 0b00000_00
177-
Dense = 4, // 0b00001_00
178-
Compressed = 8, // 0b00010_00
179-
CompressedNu = 9, // 0b00010_01
180-
CompressedNo = 10, // 0b00010_10
181-
CompressedNuNo = 11, // 0b00010_11
182-
Singleton = 16, // 0b00100_00
183-
SingletonNu = 17, // 0b00100_01
184-
SingletonNo = 18, // 0b00100_10
185-
SingletonNuNo = 19, // 0b00100_11
186-
CompressedWithHi = 32, // 0b01000_00
187-
CompressedWithHiNu = 33, // 0b01000_01
188-
CompressedWithHiNo = 34, // 0b01000_10
189-
CompressedWithHiNuNo = 35, // 0b01000_11
190-
TwoOutOfFour = 64, // 0b10000_00
176+
Undef = 0, // 0b00000_00
177+
Dense = 4, // 0b00001_00
178+
Compressed = 8, // 0b00010_00
179+
CompressedNu = 9, // 0b00010_01
180+
CompressedNo = 10, // 0b00010_10
181+
CompressedNuNo = 11, // 0b00010_11
182+
Singleton = 16, // 0b00100_00
183+
SingletonNu = 17, // 0b00100_01
184+
SingletonNo = 18, // 0b00100_10
185+
SingletonNuNo = 19, // 0b00100_11
186+
LooseCompressed = 32, // 0b01000_00
187+
LooseCompressedNu = 33, // 0b01000_01
188+
LooseCompressedNo = 34, // 0b01000_10
189+
LooseCompressedNuNo = 35, // 0b01000_11
190+
TwoOutOfFour = 64, // 0b10000_00
191191
};
192192

193193
/// This enum defines all supported storage format without the level properties.
194194
enum class LevelFormat : uint8_t {
195-
Dense = 4, // 0b00001_00
196-
Compressed = 8, // 0b00010_00
197-
Singleton = 16, // 0b00100_00
198-
CompressedWithHi = 32, // 0b01000_00
199-
TwoOutOfFour = 64, // 0b10000_00
195+
Dense = 4, // 0b00001_00
196+
Compressed = 8, // 0b00010_00
197+
Singleton = 16, // 0b00100_00
198+
LooseCompressed = 32, // 0b01000_00
199+
TwoOutOfFour = 64, // 0b10000_00
200200
};
201201

202202
/// This enum defines all the nondefault properties for storage formats.
@@ -228,14 +228,14 @@ constexpr const char *toMLIRString(DimLevelType dlt) {
228228
return "singleton_no";
229229
case DimLevelType::SingletonNuNo:
230230
return "singleton_nu_no";
231-
case DimLevelType::CompressedWithHi:
232-
return "compressed_hi";
233-
case DimLevelType::CompressedWithHiNu:
234-
return "compressed_hi_nu";
235-
case DimLevelType::CompressedWithHiNo:
236-
return "compressed_hi_no";
237-
case DimLevelType::CompressedWithHiNuNo:
238-
return "compressed_hi_nu_no";
231+
case DimLevelType::LooseCompressed:
232+
return "loose_compressed";
233+
case DimLevelType::LooseCompressedNu:
234+
return "loose_compressed_nu";
235+
case DimLevelType::LooseCompressedNo:
236+
return "loose_compressed_no";
237+
case DimLevelType::LooseCompressedNuNo:
238+
return "loose_compressed_nu_no";
239239
case DimLevelType::TwoOutOfFour:
240240
return "compressed24";
241241
}
@@ -279,9 +279,9 @@ constexpr bool isCompressedDLT(DimLevelType dlt) {
279279
}
280280

281281
/// Check if the `DimLevelType` is compressed (regardless of properties).
282-
constexpr bool isCompressedWithHiDLT(DimLevelType dlt) {
282+
constexpr bool isLooseCompressedDLT(DimLevelType dlt) {
283283
return (static_cast<uint8_t>(dlt) & ~3) ==
284-
static_cast<uint8_t>(DimLevelType::CompressedWithHi);
284+
static_cast<uint8_t>(DimLevelType::LooseCompressed);
285285
}
286286

287287
/// Check if the `DimLevelType` is singleton (regardless of properties).
@@ -373,10 +373,10 @@ static_assert((isValidDLT(DimLevelType::Undef) &&
373373
isValidDLT(DimLevelType::SingletonNu) &&
374374
isValidDLT(DimLevelType::SingletonNo) &&
375375
isValidDLT(DimLevelType::SingletonNuNo) &&
376-
isValidDLT(DimLevelType::CompressedWithHi) &&
377-
isValidDLT(DimLevelType::CompressedWithHiNu) &&
378-
isValidDLT(DimLevelType::CompressedWithHiNo) &&
379-
isValidDLT(DimLevelType::CompressedWithHiNuNo) &&
376+
isValidDLT(DimLevelType::LooseCompressed) &&
377+
isValidDLT(DimLevelType::LooseCompressedNu) &&
378+
isValidDLT(DimLevelType::LooseCompressedNo) &&
379+
isValidDLT(DimLevelType::LooseCompressedNuNo) &&
380380
isValidDLT(DimLevelType::TwoOutOfFour)),
381381
"isValidDLT definition is broken");
382382

@@ -391,16 +391,16 @@ static_assert((!isCompressedDLT(DimLevelType::Dense) &&
391391
!isCompressedDLT(DimLevelType::SingletonNuNo)),
392392
"isCompressedDLT definition is broken");
393393

394-
static_assert((!isCompressedWithHiDLT(DimLevelType::Dense) &&
395-
isCompressedWithHiDLT(DimLevelType::CompressedWithHi) &&
396-
isCompressedWithHiDLT(DimLevelType::CompressedWithHiNu) &&
397-
isCompressedWithHiDLT(DimLevelType::CompressedWithHiNo) &&
398-
isCompressedWithHiDLT(DimLevelType::CompressedWithHiNuNo) &&
399-
!isCompressedWithHiDLT(DimLevelType::Singleton) &&
400-
!isCompressedWithHiDLT(DimLevelType::SingletonNu) &&
401-
!isCompressedWithHiDLT(DimLevelType::SingletonNo) &&
402-
!isCompressedWithHiDLT(DimLevelType::SingletonNuNo)),
403-
"isCompressedWithHiDLT definition is broken");
394+
static_assert((!isLooseCompressedDLT(DimLevelType::Dense) &&
395+
isLooseCompressedDLT(DimLevelType::LooseCompressed) &&
396+
isLooseCompressedDLT(DimLevelType::LooseCompressedNu) &&
397+
isLooseCompressedDLT(DimLevelType::LooseCompressedNo) &&
398+
isLooseCompressedDLT(DimLevelType::LooseCompressedNuNo) &&
399+
!isLooseCompressedDLT(DimLevelType::Singleton) &&
400+
!isLooseCompressedDLT(DimLevelType::SingletonNu) &&
401+
!isLooseCompressedDLT(DimLevelType::SingletonNo) &&
402+
!isLooseCompressedDLT(DimLevelType::SingletonNuNo)),
403+
"isLooseCompressedDLT definition is broken");
404404

405405
static_assert((!isSingletonDLT(DimLevelType::Dense) &&
406406
!isSingletonDLT(DimLevelType::Compressed) &&
@@ -423,10 +423,10 @@ static_assert((isOrderedDLT(DimLevelType::Dense) &&
423423
isOrderedDLT(DimLevelType::SingletonNu) &&
424424
!isOrderedDLT(DimLevelType::SingletonNo) &&
425425
!isOrderedDLT(DimLevelType::SingletonNuNo) &&
426-
isOrderedDLT(DimLevelType::CompressedWithHi) &&
427-
isOrderedDLT(DimLevelType::CompressedWithHiNu) &&
428-
!isOrderedDLT(DimLevelType::CompressedWithHiNo) &&
429-
!isOrderedDLT(DimLevelType::CompressedWithHiNuNo)),
426+
isOrderedDLT(DimLevelType::LooseCompressed) &&
427+
isOrderedDLT(DimLevelType::LooseCompressedNu) &&
428+
!isOrderedDLT(DimLevelType::LooseCompressedNo) &&
429+
!isOrderedDLT(DimLevelType::LooseCompressedNuNo)),
430430
"isOrderedDLT definition is broken");
431431

432432
static_assert((isUniqueDLT(DimLevelType::Dense) &&
@@ -439,10 +439,10 @@ static_assert((isUniqueDLT(DimLevelType::Dense) &&
439439
!isUniqueDLT(DimLevelType::SingletonNu) &&
440440
isUniqueDLT(DimLevelType::SingletonNo) &&
441441
!isUniqueDLT(DimLevelType::SingletonNuNo) &&
442-
isUniqueDLT(DimLevelType::CompressedWithHi) &&
443-
!isUniqueDLT(DimLevelType::CompressedWithHiNu) &&
444-
isUniqueDLT(DimLevelType::CompressedWithHiNo) &&
445-
!isUniqueDLT(DimLevelType::CompressedWithHiNuNo)),
442+
isUniqueDLT(DimLevelType::LooseCompressed) &&
443+
!isUniqueDLT(DimLevelType::LooseCompressedNu) &&
444+
isUniqueDLT(DimLevelType::LooseCompressedNo) &&
445+
!isUniqueDLT(DimLevelType::LooseCompressedNuNo)),
446446
"isUniqueDLT definition is broken");
447447

448448
} // namespace sparse_tensor

‎mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensor.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -114,10 +114,10 @@ SparseTensorEncodingAttr getSparseTensorEncoding(Type type);
114114
/// Convenience method to query whether a given DLT needs both position and
115115
/// coordinates array or only coordinates array.
116116
constexpr inline bool isDLTWithPos(DimLevelType dlt) {
117-
return isCompressedWithHiDLT(dlt) || isCompressedDLT(dlt);
117+
return isLooseCompressedDLT(dlt) || isCompressedDLT(dlt);
118118
}
119119
constexpr inline bool isDLTWithCrd(DimLevelType dlt) {
120-
return isSingletonDLT(dlt) || isCompressedWithHiDLT(dlt) ||
120+
return isSingletonDLT(dlt) || isLooseCompressedDLT(dlt) ||
121121
isCompressedDLT(dlt);
122122
}
123123

‎mlir/include/mlir/Dialect/SparseTensor/IR/SparseTensorAttrDefs.td

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -367,7 +367,7 @@ def SparseTensorEncodingAttr : SparseTensor_Attr<"SparseTensorEncoding",
367367
bool isDenseLvl(::mlir::sparse_tensor::Level l) const { return isDenseDLT(getLvlType(l)); }
368368
bool isTwoOutOfFourLvl(::mlir::sparse_tensor::Level l) const { return isTwoOutOfFourDLT(getLvlType(l)); }
369369
bool isCompressedLvl(::mlir::sparse_tensor::Level l) const { return isCompressedDLT(getLvlType(l)); }
370-
bool isCompressedWithHiLvl(::mlir::sparse_tensor::Level l) const { return isCompressedWithHiDLT(getLvlType(l)); }
370+
bool isLooseCompressedLvl(::mlir::sparse_tensor::Level l) const { return isLooseCompressedDLT(getLvlType(l)); }
371371
bool isSingletonLvl(::mlir::sparse_tensor::Level l) const { return isSingletonDLT(getLvlType(l)); }
372372
bool isOrderedLvl(::mlir::sparse_tensor::Level l) const { return isOrderedDLT(getLvlType(l)); }
373373
bool isUniqueLvl(::mlir::sparse_tensor::Level l) const { return isUniqueDLT(getLvlType(l)); }

‎mlir/lib/Bindings/Python/DialectSparseTensor.cpp

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -28,13 +28,13 @@ static void populateDialectSparseTensorSubmodule(const py::module &m) {
2828
.value("singleton_nu", MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU)
2929
.value("singleton_no", MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NO)
3030
.value("singleton_nu_no", MLIR_SPARSE_TENSOR_DIM_LEVEL_SINGLETON_NU_NO)
31-
.value("compressed_hi", MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI)
32-
.value("compressed_hi_nu",
33-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU)
34-
.value("compressed_hi_no",
35-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NO)
36-
.value("compressed_hi_nu_no",
37-
MLIR_SPARSE_TENSOR_DIM_LEVEL_COMPRESSED_WITH_HI_NU_NO);
31+
.value("loose_compressed", MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED)
32+
.value("loose_compressed_nu",
33+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NU)
34+
.value("loose_compressed_no",
35+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NO)
36+
.value("loose_compressed_nu_no",
37+
MLIR_SPARSE_TENSOR_DIM_LEVEL_LOOSE_COMPRESSED_NU_NO);
3838

3939
mlir_attribute_subclass(m, "EncodingAttr",
4040
mlirAttributeIsASparseTensorEncodingAttr)

‎mlir/lib/Dialect/SparseTensor/IR/Detail/LvlTypeParser.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ FailureOr<uint8_t> LvlTypeParser::parseLvlType(AsmParser &parser) const {
6868
} else if (base.compare("block2_4") == 0) {
6969
properties |= static_cast<uint8_t>(LevelFormat::TwoOutOfFour);
7070
} else if (base.compare("loose_compressed") == 0) {
71-
properties |= static_cast<uint8_t>(LevelFormat::CompressedWithHi);
71+
properties |= static_cast<uint8_t>(LevelFormat::LooseCompressed);
7272
} else if (base.compare("singleton") == 0) {
7373
properties |= static_cast<uint8_t>(LevelFormat::Singleton);
7474
} else {

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

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -422,10 +422,10 @@ const static DimLevelType validDLTs[] = {DimLevelType::Dense,
422422
DimLevelType::SingletonNu,
423423
DimLevelType::SingletonNo,
424424
DimLevelType::SingletonNuNo,
425-
DimLevelType::CompressedWithHi,
426-
DimLevelType::CompressedWithHiNu,
427-
DimLevelType::CompressedWithHiNo,
428-
DimLevelType::CompressedWithHiNuNo};
425+
DimLevelType::LooseCompressed,
426+
DimLevelType::LooseCompressedNu,
427+
DimLevelType::LooseCompressedNo,
428+
DimLevelType::LooseCompressedNuNo};
429429

430430
static std::optional<DimLevelType> parseDLT(StringRef str) {
431431
for (DimLevelType dlt : validDLTs)
@@ -712,7 +712,7 @@ mlir::sparse_tensor::getSparseTensorEncoding(Type type) {
712712
bool mlir::sparse_tensor::isCOOType(SparseTensorEncodingAttr enc,
713713
Level startLvl, bool isUnique) {
714714
if (!enc ||
715-
!(enc.isCompressedLvl(startLvl) || enc.isCompressedWithHiLvl(startLvl)))
715+
!(enc.isCompressedLvl(startLvl) || enc.isLooseCompressedLvl(startLvl)))
716716
return false;
717717
const Level lvlRank = enc.getLvlRank();
718718
for (Level l = startLvl + 1; l < lvlRank; ++l)

‎mlir/lib/Dialect/SparseTensor/Transforms/LoopEmitter.cpp

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -433,7 +433,7 @@ void LoopEmitter::initializeLoopEmit(
433433
!highs[t][l]);
434434
const auto lvlTp = lvlTypes[t][l];
435435
// Handle sparse storage schemes.
436-
if (isCompressedDLT(lvlTp) || isCompressedWithHiDLT(lvlTp)) {
436+
if (isCompressedDLT(lvlTp) || isLooseCompressedDLT(lvlTp)) {
437437
// Generate sparse primitives to obtain positions and coordinates.
438438
positionsBuffers[t][l] = genToPositions(builder, loc, tensor, l);
439439
coordinatesBuffers[t][l] =
@@ -534,7 +534,7 @@ void LoopEmitter::categorizeLoopCondition(
534534
auto lvlType = lvlTypes[t][l];
535535
// Must be a recognizable DLT.
536536
assert(isDenseDLT(lvlType) || isCompressedDLT(lvlType) ||
537-
isCompressedWithHiDLT(lvlType) || isSingletonDLT(lvlType));
537+
isLooseCompressedDLT(lvlType) || isSingletonDLT(lvlType));
538538

539539
bool isSparse = !isDenseDLT(lvlType);
540540
bool isSlice = isSparseSlices[t];
@@ -630,7 +630,7 @@ std::pair<Operation *, Value> LoopEmitter::emitForLoopOverTensorAtLvl(
630630
OpBuilder &builder, Location loc, TensorId tid, Level lvl, Value lo,
631631
Value hi, MutableArrayRef<Value> reduc, bool isParallel) {
632632
bool isSparseCond = isCompressedDLT(lvlTypes[tid][lvl]) ||
633-
isCompressedWithHiDLT(lvlTypes[tid][lvl]) ||
633+
isLooseCompressedDLT(lvlTypes[tid][lvl]) ||
634634
isSingletonDLT(lvlTypes[tid][lvl]);
635635
// TODO: support dynamic slices.
636636
// Uses the first dimension here to build the loop bound (which is also the
@@ -893,7 +893,7 @@ std::pair<Operation *, Value> LoopEmitter::emitWhileLoopOverTensorsAtLvls(
893893
// Dense level are handled by the shared univeral index.
894894
assert(!isDenseCond(cKind));
895895
// Must be a recognizable sparse level.
896-
assert(isCompressedDLT(lvlTp) || isCompressedWithHiDLT(lvlTp) ||
896+
assert(isCompressedDLT(lvlTp) || isLooseCompressedDLT(lvlTp) ||
897897
isSingletonDLT(lvlTp));
898898
(void)lvlTp;
899899

@@ -1012,7 +1012,7 @@ std::pair<Operation *, Value> LoopEmitter::emitWhileLoopOverTensorsAtLvls(
10121012
for (auto [tid, lvl] : unpackTensorLevelFromCondRange(spConds)) {
10131013
const auto lvlTp = lvlTypes[tid][lvl];
10141014
if (isCompressedDLT(lvlTp) || isSingletonDLT(lvlTp) ||
1015-
isCompressedWithHiDLT(lvlTp)) {
1015+
isLooseCompressedDLT(lvlTp)) {
10161016
const auto crd = coords[tid][lvl];
10171017
if (min) {
10181018
Value cmp = CMPI(ult, coords[tid][lvl], min);
@@ -1237,11 +1237,11 @@ void LoopEmitter::prepareLoopOverTensorAtLvl(OpBuilder &builder, Location loc,
12371237
// Either the first level, or the previous level has been set.
12381238
/// FIXME: See the [CLARIFY_POSITS_LVL] note in the header.
12391239
assert(lvl == 0 || posits[tid][lvl - 1]);
1240-
if (isCompressedDLT(lvlTp) || isCompressedWithHiDLT(lvlTp)) {
1240+
if (isCompressedDLT(lvlTp) || isLooseCompressedDLT(lvlTp)) {
12411241
const Value mem = positionsBuffers[tid][lvl];
12421242

12431243
Value pLo = lvl == 0 ? c0 : posits[tid][lvl - 1];
1244-
if (isCompressedWithHiDLT(lvlTp))
1244+
if (isLooseCompressedDLT(lvlTp))
12451245
pLo = builder.create<arith::MulIOp>(loc, pLo, C_IDX(2));
12461246
posits[tid][lvl] = genIndexLoad(builder, loc, mem, pLo);
12471247

@@ -1538,7 +1538,7 @@ void LoopEmitter::exitWhileLoop(OpBuilder &builder, Location loc,
15381538
for (auto [tid, lvl] : unpackTensorLevelRange(loopInfo.trivialTidLvls)) {
15391539
const auto lvlTp = lvlTypes[tid][lvl];
15401540
if (isCompressedDLT(lvlTp) || isSingletonDLT(lvlTp) ||
1541-
isCompressedWithHiDLT(lvlTp)) {
1541+
isLooseCompressedDLT(lvlTp)) {
15421542
const Value crd = coords[tid][lvl];
15431543
const Value pos = posits[tid][lvl];
15441544
Value cmp = CMPI(eq, crd, iv);

‎mlir/lib/Dialect/SparseTensor/Transforms/SparseTensorCodegen.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -498,7 +498,7 @@ static void genEndInsert(OpBuilder &builder, Location loc,
498498
const Level lvlRank = stt.getLvlRank();
499499
for (Level l = 0; l < lvlRank; l++) {
500500
const auto dlt = stt.getLvlType(l);
501-
if (isCompressedWithHiDLT(dlt))
501+
if (isLooseCompressedDLT(dlt))
502502
llvm_unreachable("TODO: Not yet implemented");
503503
if (isCompressedDLT(dlt)) {
504504
// Compressed dimensions need a position cleanup for all entries
@@ -1237,7 +1237,7 @@ class SparseNumberOfEntriesConverter
12371237
ConversionPatternRewriter &rewriter) const override {
12381238
// Query memSizes for the actually stored values.
12391239
// FIXME: the nse value computed in this way might be wrong when there is
1240-
// any "compressed_hi" level.
1240+
// any "loose_compressed" level.
12411241
rewriter.replaceOp(
12421242
op, genValMemSize(rewriter, op.getLoc(), adaptor.getTensor()));
12431243
return success();
@@ -1316,8 +1316,8 @@ struct SparseAssembleOpConverter : public OpConversionPattern<AssembleOp> {
13161316
}
13171317

13181318
if (isDLTWithPos(dlt)) {
1319-
assert(isCompressedDLT(dlt) || isCompressedWithHiDLT(dlt));
1320-
if (isCompressedWithHiDLT(dlt)) {
1319+
assert(isCompressedDLT(dlt) || isLooseCompressedDLT(dlt));
1320+
if (isLooseCompressedDLT(dlt)) {
13211321
memSize = rewriter.create<arith::MulIOp>(loc, memSize, c2);
13221322
posBack = rewriter.create<arith::SubIOp>(loc, memSize, c1);
13231323
} else {

0 commit comments

Comments
 (0)