1//===- QuantOps.cpp - Quantization Type and Ops Implementation --*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "mlir/Dialect/Quant/IR/QuantTypes.h"
10#include "TypeDetail.h"
11#include "mlir/Dialect/Quant/IR/Quant.h"
12#include "mlir/IR/DialectImplementation.h"
13#include "mlir/IR/OpImplementation.h"
14#include "mlir/IR/QuantStorageTypeInterface.h"
15
16#include "mlir/IR/BuiltinTypes.h"
17#include "mlir/IR/MLIRContext.h"
18
19using namespace mlir;
20using namespace mlir::quant;
21using namespace mlir::quant::detail;
22
23namespace {
24
25// Return the minimum scale representable in a given float type
26double getMinScale(Type expressedType) {
27 auto floatType = cast<FloatType>(Val&: expressedType);
28 return APFloat::getSmallest(Sem: floatType.getFloatSemantics()).convertToDouble();
29}
30
31// Return the maximum scale representable in a given float type
32double getMaxScale(Type expressedType) {
33 auto floatType = cast<FloatType>(Val&: expressedType);
34 return APFloat::getLargest(Sem: floatType.getFloatSemantics()).convertToDouble();
35}
36
37} // namespace
38
39unsigned QuantizedType::getFlags() const {
40 return static_cast<ImplType *>(impl)->flags;
41}
42
43bool QuantizedType::classof(Type type) {
44 return llvm::isa<AnyQuantizedType, UniformQuantizedType,
45 UniformQuantizedPerAxisType, UniformQuantizedSubChannelType,
46 CalibratedQuantizedType>(Val: type);
47}
48
49LogicalResult
50QuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
51 unsigned flags, Type storageType,
52 Type expressedType, int64_t storageTypeMin,
53 int64_t storageTypeMax) {
54 if (auto quantStorageTypeInterface =
55 llvm::dyn_cast<QuantStorageTypeInterface>(Val&: storageType)) {
56 unsigned integralWidth = quantStorageTypeInterface.getStorageWidth();
57
58 // Verify storage width.
59 if (integralWidth == 0 || integralWidth > MaxStorageBits)
60 return emitError() << "illegal storage type size: " << integralWidth;
61
62 bool isSigned = flags & QuantizationFlags::Signed;
63 int64_t defaultMin = quantStorageTypeInterface.getDefaultMinimum(isSigned);
64 int64_t defaultMax = quantStorageTypeInterface.getDefaultMaximum(isSigned);
65
66 if (storageTypeMax - storageTypeMin <= 0 || storageTypeMin < defaultMin ||
67 storageTypeMax > defaultMax) {
68 return emitError() << "illegal storage min and storage max: ("
69 << storageTypeMin << ":" << storageTypeMax << ")";
70 }
71
72 return success();
73 }
74
75 return emitError() << "storage type must implement QuantStorageTypeInterface";
76}
77
78Type QuantizedType::getStorageType() const {
79 return static_cast<ImplType *>(impl)->storageType;
80}
81
82int64_t QuantizedType::getStorageTypeMin() const {
83 return static_cast<ImplType *>(impl)->storageTypeMin;
84}
85
86int64_t QuantizedType::getStorageTypeMax() const {
87 return static_cast<ImplType *>(impl)->storageTypeMax;
88}
89
90bool QuantizedType::hasStorageTypeBounds() const {
91 Type storageType = static_cast<ImplType *>(impl)->storageType;
92 auto quantStorageTypeInterface =
93 llvm::dyn_cast<QuantStorageTypeInterface>(Val&: storageType);
94
95 int64_t defaultMin = quantStorageTypeInterface.getDefaultMinimum(isSigned: isSigned());
96 int64_t defaultMax = quantStorageTypeInterface.getDefaultMaximum(isSigned: isSigned());
97
98 return defaultMin != getStorageTypeMin() || defaultMax != getStorageTypeMax();
99}
100
101unsigned QuantizedType::getStorageTypeIntegralWidth() const {
102 Type storageType = static_cast<ImplType *>(impl)->storageType;
103 auto quantStorageTypeInterface =
104 llvm::dyn_cast<QuantStorageTypeInterface>(Val&: storageType);
105
106 return quantStorageTypeInterface.getStorageWidth();
107}
108
109Type QuantizedType::getExpressedType() const {
110 return static_cast<ImplType *>(impl)->expressedType;
111}
112
113bool QuantizedType::isCompatibleExpressedType(Type candidateExpressedType) {
114 if (llvm::isa<ShapedType>(Val: candidateExpressedType)) {
115 return llvm::cast<ShapedType>(Val&: candidateExpressedType).getElementType() ==
116 getExpressedType();
117 }
118 return candidateExpressedType == getExpressedType();
119}
120
121QuantizedType
122QuantizedType::getQuantizedElementType(Type primitiveOrContainerType) {
123 if (llvm::isa<ShapedType>(Val: primitiveOrContainerType)) {
124 Type elementType =
125 llvm::cast<ShapedType>(Val&: primitiveOrContainerType).getElementType();
126 return llvm::dyn_cast<QuantizedType>(Val&: elementType);
127 }
128 return llvm::dyn_cast<QuantizedType>(Val&: primitiveOrContainerType);
129}
130
131Type QuantizedType::castFromStorageType(Type candidateType) {
132 if (candidateType == getStorageType()) {
133 // i.e. i8 -> quant<"uniform[i8:f32]{1.0}">
134 return *this;
135 }
136 if (llvm::isa<RankedTensorType>(Val: candidateType)) {
137 // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
138 return RankedTensorType::get(
139 shape: llvm::cast<RankedTensorType>(Val&: candidateType).getShape(),
140 elementType: getStorageType());
141 }
142 if (llvm::isa<UnrankedTensorType>(Val: candidateType)) {
143 // i.e. tensor<xi8> -> tensor<x!quant<"uniform[i8:f32]{1.0}">>
144 return UnrankedTensorType::get(elementType: getStorageType());
145 }
146 if (llvm::isa<VectorType>(Val: candidateType)) {
147 // i.e. vector<4xi8> -> vector<4x!quant<"uniform[i8:f32]{1.0}">>
148 return VectorType::get(shape: llvm::cast<VectorType>(Val&: candidateType).getShape(),
149 elementType: getStorageType());
150 }
151
152 return nullptr;
153}
154
155Type QuantizedType::castToStorageType(Type quantizedType) {
156 if (llvm::isa<QuantizedType>(Val: quantizedType)) {
157 // i.e. quant<"uniform[i8:f32]{1.0}"> -> i8
158 return llvm::cast<QuantizedType>(Val&: quantizedType).getStorageType();
159 }
160 if (llvm::isa<ShapedType>(Val: quantizedType)) {
161 // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
162 ShapedType sType = llvm::cast<ShapedType>(Val&: quantizedType);
163 if (!llvm::isa<QuantizedType>(Val: sType.getElementType())) {
164 return nullptr;
165 }
166 Type storageType =
167 llvm::cast<QuantizedType>(Val: sType.getElementType()).getStorageType();
168 if (llvm::isa<RankedTensorType>(Val: quantizedType)) {
169 return RankedTensorType::get(shape: sType.getShape(), elementType: storageType);
170 }
171 if (llvm::isa<UnrankedTensorType>(Val: quantizedType)) {
172 return UnrankedTensorType::get(elementType: storageType);
173 }
174 if (llvm::isa<VectorType>(Val: quantizedType)) {
175 return VectorType::get(shape: sType.getShape(), elementType: storageType);
176 }
177 }
178
179 return nullptr;
180}
181
182Type QuantizedType::castFromExpressedType(Type candidateType) {
183 if (candidateType == getExpressedType()) {
184 // i.e. f32 -> quant<"uniform[i8:f32]{1.0}">
185 return *this;
186 }
187 if (llvm::isa<ShapedType>(Val: candidateType)) {
188 ShapedType candidateShapedType = llvm::cast<ShapedType>(Val&: candidateType);
189 if (candidateShapedType.getElementType() != getExpressedType()) {
190 return nullptr;
191 }
192
193 if (llvm::isa<RankedTensorType>(Val: candidateType)) {
194 // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
195 return RankedTensorType::get(shape: candidateShapedType.getShape(), elementType: *this);
196 }
197 if (llvm::isa<UnrankedTensorType>(Val: candidateType)) {
198 // i.e. tensor<xf32> -> tensor<x!quant<"uniform[i8:f32]{1.0}">>
199 return UnrankedTensorType::get(elementType: *this);
200 }
201 if (llvm::isa<VectorType>(Val: candidateType)) {
202 // i.e. tensor<4xf32> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
203 return VectorType::get(shape: candidateShapedType.getShape(), elementType: *this);
204 }
205 }
206
207 return nullptr;
208}
209
210Type QuantizedType::castToExpressedType(Type quantizedType) {
211 if (llvm::isa<QuantizedType>(Val: quantizedType)) {
212 // i.e. quant<"uniform[i8:f32]{1.0}"> -> f32
213 return llvm::cast<QuantizedType>(Val&: quantizedType).getExpressedType();
214 }
215 if (llvm::isa<ShapedType>(Val: quantizedType)) {
216 // i.e. tensor<4xi8> -> tensor<4x!quant<"uniform[i8:f32]{1.0}">>
217 ShapedType sType = llvm::cast<ShapedType>(Val&: quantizedType);
218 if (!llvm::isa<QuantizedType>(Val: sType.getElementType())) {
219 return nullptr;
220 }
221 Type expressedType =
222 llvm::cast<QuantizedType>(Val: sType.getElementType()).getExpressedType();
223 if (llvm::isa<RankedTensorType>(Val: quantizedType)) {
224 return RankedTensorType::get(shape: sType.getShape(), elementType: expressedType);
225 }
226 if (llvm::isa<UnrankedTensorType>(Val: quantizedType)) {
227 return UnrankedTensorType::get(elementType: expressedType);
228 }
229 if (llvm::isa<VectorType>(Val: quantizedType)) {
230 return VectorType::get(shape: sType.getShape(), elementType: expressedType);
231 }
232 }
233
234 return nullptr;
235}
236
237Type QuantizedType::castExpressedToStorageType(Type candidateType) {
238 Type expressedQuantizedType = castFromExpressedType(candidateType);
239 if (!expressedQuantizedType) {
240 return nullptr;
241 }
242 return QuantizedType::castToStorageType(quantizedType: expressedQuantizedType);
243}
244
245AnyQuantizedType AnyQuantizedType::get(unsigned flags, Type storageType,
246 Type expressedType,
247 int64_t storageTypeMin,
248 int64_t storageTypeMax) {
249 return Base::get(ctx: storageType.getContext(), args&: flags, args&: storageType, args&: expressedType,
250 args&: storageTypeMin, args&: storageTypeMax);
251}
252
253AnyQuantizedType
254AnyQuantizedType::getChecked(function_ref<InFlightDiagnostic()> emitError,
255 unsigned flags, Type storageType,
256 Type expressedType, int64_t storageTypeMin,
257 int64_t storageTypeMax) {
258 return Base::getChecked(emitErrorFn: emitError, ctx: storageType.getContext(), args: flags,
259 args: storageType, args: expressedType, args: storageTypeMin,
260 args: storageTypeMax);
261}
262
263LogicalResult
264AnyQuantizedType::verifyInvariants(function_ref<InFlightDiagnostic()> emitError,
265 unsigned flags, Type storageType,
266 Type expressedType, int64_t storageTypeMin,
267 int64_t storageTypeMax) {
268 if (failed(Result: QuantizedType::verifyInvariants(emitError, flags, storageType,
269 expressedType, storageTypeMin,
270 storageTypeMax))) {
271 return failure();
272 }
273
274 // Verify that the expressed type is floating point.
275 // If this restriction is ever eliminated, the parser/printer must be
276 // extended.
277 if (expressedType && !llvm::isa<FloatType>(Val: expressedType))
278 return emitError() << "expressed type must be floating point";
279
280 return success();
281}
282
283UniformQuantizedType UniformQuantizedType::get(unsigned flags, Type storageType,
284 Type expressedType, double scale,
285 int64_t zeroPoint,
286 int64_t storageTypeMin,
287 int64_t storageTypeMax) {
288 return Base::get(ctx: storageType.getContext(), args&: flags, args&: storageType, args&: expressedType,
289 args&: scale, args&: zeroPoint, args&: storageTypeMin, args&: storageTypeMax);
290}
291
292UniformQuantizedType UniformQuantizedType::getChecked(
293 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
294 Type storageType, Type expressedType, double scale, int64_t zeroPoint,
295 int64_t storageTypeMin, int64_t storageTypeMax) {
296 return Base::getChecked(emitErrorFn: emitError, ctx: storageType.getContext(), args: flags,
297 args: storageType, args: expressedType, args: scale, args: zeroPoint,
298 args: storageTypeMin, args: storageTypeMax);
299}
300
301LogicalResult UniformQuantizedType::verifyInvariants(
302 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
303 Type storageType, Type expressedType, double scale, int64_t zeroPoint,
304 int64_t storageTypeMin, int64_t storageTypeMax) {
305 if (failed(Result: QuantizedType::verifyInvariants(emitError, flags, storageType,
306 expressedType, storageTypeMin,
307 storageTypeMax))) {
308 return failure();
309 }
310
311 // Uniform quantization requires fully expressed parameters, including
312 // expressed type.
313 if (!expressedType)
314 return emitError() << "uniform quantization requires expressed type";
315
316 // Verify that the expressed type is floating point.
317 // If this restriction is ever eliminated, the parser/printer must be
318 // extended.
319 if (!llvm::isa<FloatType>(Val: expressedType))
320 return emitError() << "expressed type must be floating point";
321
322 // Verify scale.
323 double minScale = getMinScale(expressedType);
324 double maxScale = getMaxScale(expressedType);
325 if (scale < minScale || scale > maxScale)
326 return emitError() << "scale out of expressed type range [" << minScale
327 << ", " << maxScale << "]";
328
329 return success();
330}
331
332double UniformQuantizedType::getScale() const { return getImpl()->scale; }
333
334int64_t UniformQuantizedType::getZeroPoint() const {
335 return getImpl()->zeroPoint;
336}
337
338UniformQuantizedPerAxisType UniformQuantizedPerAxisType::get(
339 unsigned flags, Type storageType, Type expressedType,
340 ArrayRef<double> scales, ArrayRef<int64_t> zeroPoints,
341 int32_t quantizedDimension, int64_t storageTypeMin,
342 int64_t storageTypeMax) {
343 return Base::get(ctx: storageType.getContext(), args&: flags, args&: storageType, args&: expressedType,
344 args&: scales, args&: zeroPoints, args&: quantizedDimension, args&: storageTypeMin,
345 args&: storageTypeMax);
346}
347
348UniformQuantizedPerAxisType UniformQuantizedPerAxisType::getChecked(
349 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
350 Type storageType, Type expressedType, ArrayRef<double> scales,
351 ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
352 int64_t storageTypeMin, int64_t storageTypeMax) {
353 return Base::getChecked(emitErrorFn: emitError, ctx: storageType.getContext(), args: flags,
354 args: storageType, args: expressedType, args: scales, args: zeroPoints,
355 args: quantizedDimension, args: storageTypeMin, args: storageTypeMax);
356}
357
358LogicalResult UniformQuantizedPerAxisType::verifyInvariants(
359 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
360 Type storageType, Type expressedType, ArrayRef<double> scales,
361 ArrayRef<int64_t> zeroPoints, int32_t quantizedDimension,
362 int64_t storageTypeMin, int64_t storageTypeMax) {
363 if (failed(Result: QuantizedType::verifyInvariants(emitError, flags, storageType,
364 expressedType, storageTypeMin,
365 storageTypeMax))) {
366 return failure();
367 }
368
369 // Uniform quantization requires fully expressed parameters, including
370 // expressed type.
371 if (!expressedType)
372 return emitError() << "uniform quantization requires expressed type";
373
374 // Verify that the expressed type is floating point.
375 // If this restriction is ever eliminated, the parser/printer must be
376 // extended.
377 if (!llvm::isa<FloatType>(Val: expressedType))
378 return emitError() << "expressed type must be floating point";
379
380 // Ensure that the number of scales and zeroPoints match.
381 if (scales.size() != zeroPoints.size())
382 return emitError() << "illegal number of scales and zeroPoints: "
383 << scales.size() << ", " << zeroPoints.size();
384
385 // Verify scale.
386 double minScale = getMinScale(expressedType);
387 double maxScale = getMaxScale(expressedType);
388 for (double scale : scales) {
389 if (scale < minScale || scale > maxScale)
390 return emitError() << "scale out of expressed type range [" << minScale
391 << ", " << maxScale << "]";
392 }
393
394 // Verify quantized dimension.
395 if (quantizedDimension < 0)
396 return emitError() << "illegal quantized dimension: " << quantizedDimension;
397
398 return success();
399}
400
401ArrayRef<double> UniformQuantizedPerAxisType::getScales() const {
402 return getImpl()->getScales();
403}
404
405ArrayRef<int64_t> UniformQuantizedPerAxisType::getZeroPoints() const {
406 return getImpl()->getZeroPoints();
407}
408
409int32_t UniformQuantizedPerAxisType::getQuantizedDimension() const {
410 return getImpl()->quantizedDimension;
411}
412
413UniformQuantizedSubChannelType UniformQuantizedSubChannelType::get(
414 unsigned flags, Type storageType, Type expressedType,
415 DenseElementsAttr scales, DenseElementsAttr zeroPoints,
416 ArrayRef<int32_t> quantizedDimensions, ArrayRef<int64_t> blockSizes,
417 int64_t storageTypeMin, int64_t storageTypeMax) {
418 return Base::get(ctx: storageType.getContext(), args&: flags, args&: storageType, args&: expressedType,
419 args&: scales, args&: zeroPoints, args&: quantizedDimensions, args&: blockSizes,
420 args&: storageTypeMin, args&: storageTypeMax);
421}
422
423UniformQuantizedSubChannelType UniformQuantizedSubChannelType::getChecked(
424 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
425 Type storageType, Type expressedType, DenseElementsAttr scales,
426 DenseElementsAttr zeroPoints, ArrayRef<int32_t> quantizedDimensions,
427 ArrayRef<int64_t> blockSizes, int64_t storageTypeMin,
428 int64_t storageTypeMax) {
429 return Base::getChecked(emitErrorFn: emitError, ctx: storageType.getContext(), args: flags,
430 args: storageType, args: expressedType, args: scales, args: zeroPoints,
431 args: quantizedDimensions, args: blockSizes, args: storageTypeMin,
432 args: storageTypeMax);
433}
434
435LogicalResult UniformQuantizedSubChannelType::verifyInvariants(
436 function_ref<InFlightDiagnostic()> emitError, unsigned flags,
437 Type storageType, Type expressedType, DenseElementsAttr scales,
438 DenseElementsAttr zeroPoints, ArrayRef<int32_t> quantizedDimensions,
439 ArrayRef<int64_t> blockSizes, int64_t storageTypeMin,
440 int64_t storageTypeMax) {
441 if (failed(Result: QuantizedType::verifyInvariants(emitError, flags, storageType,
442 expressedType, storageTypeMin,
443 storageTypeMax))) {
444 return failure();
445 }
446
447 // Uniform quantization requires fully expressed parameters, including
448 // expressed type.
449 if (!expressedType)
450 return emitError() << "uniform quantization requires expressed type";
451
452 // Verify that the expressed type is floating point.
453 // If this restriction is ever eliminated, the parser/printer must be
454 // extended.
455 if (!llvm::isa<FloatType>(Val: expressedType))
456 return emitError() << "expressed type must be floating point";
457
458 // Verify scale type to match expressedType.
459 if (scales.getType().getElementType() != expressedType) {
460 return emitError() << "type of scale values "
461 << scales.getType().getElementType()
462 << " must match the expressed type " << expressedType;
463 }
464
465 // Verify zero-point type to match storageType.
466 if (zeroPoints.getType().getElementType() != storageType) {
467 return emitError() << "type of zero point values "
468 << zeroPoints.getType().getElementType()
469 << " must match the storage type " << storageType;
470 }
471
472 // Ensure that the shape of scales and zeroPoints match.
473 if (scales.getType().getShape() != zeroPoints.getType().getShape())
474 return emitError() << "shape of scales and zeroPoints ("
475 << scales.getType().getShape() << " vs "
476 << zeroPoints.getType().getShape() << ") does not match";
477
478 // Ensure that the number of quantized-dimensions and block-sizes match.
479 if (quantizedDimensions.size() != blockSizes.size())
480 return emitError() << "number of quantized dimensions and block sizes ("
481 << scales.size() << " vs " << zeroPoints.size()
482 << ") does not match";
483
484 // Verify quantized dimension.
485 for (auto quantizedDimension : quantizedDimensions) {
486 if (quantizedDimension < 0)
487 return emitError() << "illegal quantized dimension: "
488 << quantizedDimension;
489 }
490
491 // Verify block sizes.
492 for (auto blockSize : blockSizes) {
493 if (blockSize <= 0)
494 return emitError() << "illegal block size: " << blockSize;
495 }
496
497 return success();
498}
499
500DenseElementsAttr UniformQuantizedSubChannelType::getScales() const {
501 return getImpl()->getScales();
502}
503
504DenseElementsAttr UniformQuantizedSubChannelType::getZeroPoints() const {
505 return getImpl()->getZeroPoints();
506}
507
508ArrayRef<int32_t>
509UniformQuantizedSubChannelType::getQuantizedDimensions() const {
510 return getImpl()->getQuantizedDimensions();
511}
512
513ArrayRef<int64_t> UniformQuantizedSubChannelType::getBlockSizes() const {
514 return getImpl()->getBlockSizes();
515}
516
517const SmallVector<std::pair<int32_t, int64_t>>
518UniformQuantizedSubChannelType::getBlockSizeInfo() const {
519 SmallVector<std::pair<int32_t, int64_t>> result;
520 result.reserve(N: getQuantizedDimensions().size());
521
522 for (auto [dim, size] :
523 llvm::zip(t: getQuantizedDimensions(), u: getBlockSizes())) {
524 result.push_back(Elt: {dim, size});
525 }
526
527 return result;
528}
529
530CalibratedQuantizedType CalibratedQuantizedType::get(Type expressedType,
531 double min, double max) {
532 return Base::get(ctx: expressedType.getContext(), args&: expressedType, args&: min, args&: max);
533}
534
535CalibratedQuantizedType CalibratedQuantizedType::getChecked(
536 function_ref<InFlightDiagnostic()> emitError, Type expressedType,
537 double min, double max) {
538 return Base::getChecked(emitErrorFn: emitError, ctx: expressedType.getContext(), args: expressedType,
539 args: min, args: max);
540}
541
542LogicalResult CalibratedQuantizedType::verifyInvariants(
543 function_ref<InFlightDiagnostic()> emitError, Type expressedType,
544 double min, double max) {
545 // Verify that the expressed type is floating point.
546 // If this restriction is ever eliminated, the parser/printer must be
547 // extended.
548 if (!llvm::isa<FloatType>(Val: expressedType))
549 return emitError() << "expressed type must be floating point";
550 if (max <= min)
551 return emitError() << "illegal min and max: (" << min << ":" << max << ")";
552
553 return success();
554}
555
556double CalibratedQuantizedType::getMin() const { return getImpl()->min; }
557
558double CalibratedQuantizedType::getMax() const { return getImpl()->max; }
559
560QuantileType QuantileType::get(mlir::MLIRContext *ctx, mlir::Type storageType,
561 mlir::Type quantileType,
562 ArrayRef<double> quantiles,
563 std::optional<int64_t> storageMin,
564 std::optional<int64_t> storageMax) {
565 return Base::get(ctx, args&: storageType, args&: quantileType, args&: quantiles, args&: storageMin,
566 args&: storageMax);
567}
568
569QuantileType QuantileType::getChecked(
570 function_ref<InFlightDiagnostic()> emitError, mlir::MLIRContext *ctx,
571 mlir::Type storageType, mlir::Type quantileType, ArrayRef<double> quantiles,
572 std::optional<int64_t> storageMin, std::optional<int64_t> storageMax) {
573 return Base::getChecked(emitErrorFn: emitError, ctx, args: storageType, args: quantileType, args: quantiles,
574 args: storageMin, args: storageMax);
575}
576
577LogicalResult QuantileType::verifyInvariants(
578 function_ref<InFlightDiagnostic()> emitError, Type storageType,
579 Type quantileType, ArrayRef<double> quantiles,
580 std::optional<int64_t> storageMin, std::optional<int64_t> storageMax) {
581 if (!storageType.isIntOrFloat())
582 return emitError() << "storage type must be an integer or float type";
583 if (!llvm::isa<mlir::FloatType>(Val: quantileType) &&
584 !llvm::isa<mlir::IntegerType>(Val: quantileType))
585 return emitError() << "quantile type must be a float or integer type";
586 if (quantiles.empty())
587 return emitError() << "quantile values must not be empty";
588 if (storageMin.has_value() != storageMax.has_value())
589 return emitError()
590 << "storage min and max must both be specified or both omitted";
591 if (storageMin && storageMax && *storageMin >= *storageMax)
592 return emitError() << "storage min must be less than storage max";
593
594 unsigned width = storageType.getIntOrFloatBitWidth();
595 bool isSigned = !llvm::isa<mlir::IntegerType>(Val: storageType) ||
596 llvm::cast<mlir::IntegerType>(Val&: storageType).isSigned();
597 auto effectiveMin =
598 storageMin.value_or(u: isSigned ? -(1LL << (width - 1)) : 0LL);
599 auto effectiveMax = storageMax.value_or(u: isSigned ? (1LL << (width - 1)) - 1
600 : (1LL << width) - 1);
601 auto expectedSize = effectiveMax - effectiveMin + 1;
602 if (static_cast<decltype(expectedSize)>(quantiles.size()) != expectedSize)
603 return emitError() << "quantile LUT size (" << quantiles.size()
604 << ") must equal the number of representable storage "
605 "values ("
606 << expectedSize << ")";
607
608 for (double v : quantiles)
609 if (std::isnan(x: v) || std::isinf(x: v))
610 return emitError()
611 << "quantile values must be finite (no NaN or infinity)";
612
613 return success();
614}
615
616bool QuantileType::classof(mlir::Type type) {
617 return type.getTypeID() == mlir::TypeID::get<QuantileType>();
618}
619
620mlir::Type QuantileType::getStorageType() const {
621 return static_cast<ImplType *>(impl)->getStorageType();
622}
623
624mlir::Type QuantileType::getQuantileType() const {
625 return static_cast<ImplType *>(impl)->getQuantileType();
626}
627
628ArrayRef<double> QuantileType::getQuantiles() const {
629 return static_cast<ImplType *>(impl)->getQuantiles();
630}
631
632std::optional<int64_t> QuantileType::getStorageMin() const {
633 return static_cast<ImplType *>(impl)->getStorageMin();
634}
635
636std::optional<int64_t> QuantileType::getStorageMax() const {
637 return static_cast<ImplType *>(impl)->getStorageMax();
638}
639
640bool QuantileType::shouldDefaultToSigned() const {
641 if (auto intType = mlir::dyn_cast<mlir::IntegerType>(Val: getStorageType()))
642 return intType.isSigned();
643 // Float types default to signed.
644 return true;
645}
646
647unsigned QuantileType::getStorageWidth() const {
648 return getStorageType().getIntOrFloatBitWidth();
649}
650
651int64_t QuantileType::getDefaultMaximum(bool isSigned) const {
652 if (auto explicitMax = getStorageMax())
653 return *explicitMax;
654 if (isSigned)
655 return (1LL << (getStorageWidth() - 1)) - 1;
656 return (1LL << getStorageWidth()) - 1;
657}
658
659int64_t QuantileType::getDefaultMinimum(bool isSigned) const {
660 if (auto explicitMin = getStorageMin())
661 return *explicitMin;
662 if (isSigned)
663 return -(1LL << (getStorageWidth() - 1));
664 return 0;
665}
666
667std::string QuantileType::getStorageTypeName(bool isSigned) const {
668 std::string result = "!quant.quantile<";
669 llvm::raw_string_ostream os(result);
670 os << getStorageType() << ":" << getQuantileType() << ", {";
671 ArrayRef<double> quantiles = this->getQuantiles();
672 llvm::interleave(
673 c: llvm::seq<size_t>(Begin: 0, End: quantiles.size()), os,
674 each_fn: [&](size_t index) { os << quantiles[index]; }, separator: ",");
675 os << "}";
676 if (auto minVal = getStorageMin())
677 if (auto maxVal = getStorageMax())
678 os << ", <" << *minVal << ":" << *maxVal << ">";
679 os << ">";
680 os.flush();
681 return result;
682}
683
684bool QuantileType::isPacked() const { return getStorageWidth() <= 4; }
685
686unsigned QuantileType::getLogicalBitWidth() const { return getStorageWidth(); }
687
688unsigned QuantileType::getElementsPerByte() const {
689 unsigned width = getStorageWidth();
690 return width > 0 ? 8 / width : 0;
691}
692
693std::optional<unsigned> QuantileType::getPreferredAlignmentBytes() const {
694 return std::nullopt;
695}
696