366 lines · c
1//===- quant.c - Test of Quant dialect C API ------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM4// Exceptions.5// See https://llvm.org/LICENSE.txt for license information.6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception7//8//===----------------------------------------------------------------------===//9 10// RUN: mlir-capi-quant-test 2>&1 | FileCheck %s11 12#include "mlir-c/Dialect/Quant.h"13#include "mlir-c/BuiltinAttributes.h"14#include "mlir-c/BuiltinTypes.h"15#include "mlir-c/IR.h"16 17#include <assert.h>18#include <inttypes.h>19#include <stdio.h>20#include <stdlib.h>21 22// CHECK-LABEL: testTypeHierarchy23static void testTypeHierarchy(MlirContext ctx) {24 fprintf(stderr, "testTypeHierarchy\n");25 26 MlirType i8 = mlirIntegerTypeGet(ctx, 8);27 MlirType any = mlirTypeParseGet(28 ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));29 MlirType uniform =30 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(31 "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));32 MlirType perAxis = mlirTypeParseGet(33 ctx, mlirStringRefCreateFromCString(34 "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));35 MlirType calibrated = mlirTypeParseGet(36 ctx,37 mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));38 39 // The parser itself is checked in C++ dialect tests.40 assert(!mlirTypeIsNull(any) && "couldn't parse AnyQuantizedType");41 assert(!mlirTypeIsNull(uniform) && "couldn't parse UniformQuantizedType");42 assert(!mlirTypeIsNull(perAxis) &&43 "couldn't parse UniformQuantizedPerAxisType");44 assert(!mlirTypeIsNull(calibrated) &&45 "couldn't parse CalibratedQuantizedType");46 47 // CHECK: i8 isa QuantizedType: 048 fprintf(stderr, "i8 isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(i8));49 // CHECK: any isa QuantizedType: 150 fprintf(stderr, "any isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(any));51 // CHECK: uniform isa QuantizedType: 152 fprintf(stderr, "uniform isa QuantizedType: %d\n",53 mlirTypeIsAQuantizedType(uniform));54 // CHECK: perAxis isa QuantizedType: 155 fprintf(stderr, "perAxis isa QuantizedType: %d\n",56 mlirTypeIsAQuantizedType(perAxis));57 // CHECK: calibrated isa QuantizedType: 158 fprintf(stderr, "calibrated isa QuantizedType: %d\n",59 mlirTypeIsAQuantizedType(calibrated));60 61 // CHECK: any isa AnyQuantizedType: 162 fprintf(stderr, "any isa AnyQuantizedType: %d\n",63 mlirTypeIsAAnyQuantizedType(any));64 // CHECK: uniform isa UniformQuantizedType: 165 fprintf(stderr, "uniform isa UniformQuantizedType: %d\n",66 mlirTypeIsAUniformQuantizedType(uniform));67 // CHECK: perAxis isa UniformQuantizedPerAxisType: 168 fprintf(stderr, "perAxis isa UniformQuantizedPerAxisType: %d\n",69 mlirTypeIsAUniformQuantizedPerAxisType(perAxis));70 // CHECK: calibrated isa CalibratedQuantizedType: 171 fprintf(stderr, "calibrated isa CalibratedQuantizedType: %d\n",72 mlirTypeIsACalibratedQuantizedType(calibrated));73 74 // CHECK: perAxis isa UniformQuantizedType: 075 fprintf(stderr, "perAxis isa UniformQuantizedType: %d\n",76 mlirTypeIsAUniformQuantizedType(perAxis));77 // CHECK: uniform isa CalibratedQuantizedType: 078 fprintf(stderr, "uniform isa CalibratedQuantizedType: %d\n",79 mlirTypeIsACalibratedQuantizedType(uniform));80 fprintf(stderr, "\n");81}82 83// CHECK-LABEL: testAnyQuantizedType84void testAnyQuantizedType(MlirContext ctx) {85 fprintf(stderr, "testAnyQuantizedType\n");86 87 MlirType anyParsed = mlirTypeParseGet(88 ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));89 90 MlirType i8 = mlirIntegerTypeGet(ctx, 8);91 MlirType f32 = mlirF32TypeGet(ctx);92 MlirType any =93 mlirAnyQuantizedTypeGet(mlirQuantizedTypeGetSignedFlag(), i8, f32, -8, 7);94 95 // CHECK: flags: 196 fprintf(stderr, "flags: %u\n", mlirQuantizedTypeGetFlags(any));97 // CHECK: signed: 198 fprintf(stderr, "signed: %u\n", mlirQuantizedTypeIsSigned(any));99 // CHECK: storage type: i8100 fprintf(stderr, "storage type: ");101 mlirTypeDump(mlirQuantizedTypeGetStorageType(any));102 fprintf(stderr, "\n");103 // CHECK: expressed type: f32104 fprintf(stderr, "expressed type: ");105 mlirTypeDump(mlirQuantizedTypeGetExpressedType(any));106 fprintf(stderr, "\n");107 // CHECK: storage min: -8108 fprintf(stderr, "storage min: %" PRId64 "\n",109 mlirQuantizedTypeGetStorageTypeMin(any));110 // CHECK: storage max: 7111 fprintf(stderr, "storage max: %" PRId64 "\n",112 mlirQuantizedTypeGetStorageTypeMax(any));113 // CHECK: storage width: 8114 fprintf(stderr, "storage width: %u\n",115 mlirQuantizedTypeGetStorageTypeIntegralWidth(any));116 // CHECK: quantized element type: !quant.any<i8<-8:7>:f32>117 fprintf(stderr, "quantized element type: ");118 mlirTypeDump(mlirQuantizedTypeGetQuantizedElementType(any));119 fprintf(stderr, "\n");120 121 // CHECK: equal: 1122 fprintf(stderr, "equal: %d\n", mlirTypeEqual(anyParsed, any));123 // CHECK: !quant.any<i8<-8:7>:f32>124 mlirTypeDump(any);125 fprintf(stderr, "\n\n");126}127 128// CHECK-LABEL: testUniformType129void testUniformType(MlirContext ctx) {130 fprintf(stderr, "testUniformType\n");131 132 MlirType uniformParsed =133 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(134 "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));135 136 MlirType i8 = mlirIntegerTypeGet(ctx, 8);137 MlirType f32 = mlirF32TypeGet(ctx);138 MlirType uniform = mlirUniformQuantizedTypeGet(139 mlirQuantizedTypeGetSignedFlag(), i8, f32, 0.99872, 127, -8, 7);140 141 // CHECK: scale: 0.998720142 fprintf(stderr, "scale: %lf\n", mlirUniformQuantizedTypeGetScale(uniform));143 // CHECK: zero point: 127144 fprintf(stderr, "zero point: %" PRId64 "\n",145 mlirUniformQuantizedTypeGetZeroPoint(uniform));146 // CHECK: fixed point: 0147 fprintf(stderr, "fixed point: %d\n",148 mlirUniformQuantizedTypeIsFixedPoint(uniform));149 150 // CHECK: equal: 1151 fprintf(stderr, "equal: %d\n", mlirTypeEqual(uniform, uniformParsed));152 // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>153 mlirTypeDump(uniform);154 fprintf(stderr, "\n\n");155}156 157// CHECK-LABEL: testUniformPerAxisType158void testUniformPerAxisType(MlirContext ctx) {159 fprintf(stderr, "testUniformPerAxisType\n");160 161 MlirType perAxisParsed = mlirTypeParseGet(162 ctx, mlirStringRefCreateFromCString(163 "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));164 165 MlirType i8 = mlirIntegerTypeGet(ctx, 8);166 MlirType f32 = mlirF32TypeGet(ctx);167 double scales[] = {200.0, 0.99872};168 int64_t zeroPoints[] = {0, 120};169 MlirType perAxis = mlirUniformQuantizedPerAxisTypeGet(170 mlirQuantizedTypeGetSignedFlag(), i8, f32,171 /*nDims=*/2, scales, zeroPoints,172 /*quantizedDimension=*/1,173 mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,174 /*integralWidth=*/8),175 mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,176 /*integralWidth=*/8));177 178 // CHECK: num dims: 2179 fprintf(stderr, "num dims: %" PRIdPTR "\n",180 mlirUniformQuantizedPerAxisTypeGetNumDims(perAxis));181 // CHECK: scale 0: 200.000000182 fprintf(stderr, "scale 0: %lf\n",183 mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 0));184 // CHECK: scale 1: 0.998720185 fprintf(stderr, "scale 1: %lf\n",186 mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 1));187 // CHECK: zero point 0: 0188 fprintf(stderr, "zero point 0: %" PRId64 "\n",189 mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 0));190 // CHECK: zero point 1: 120191 fprintf(stderr, "zero point 1: %" PRId64 "\n",192 mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 1));193 // CHECK: quantized dim: 1194 fprintf(stderr, "quantized dim: %" PRId32 "\n",195 mlirUniformQuantizedPerAxisTypeGetQuantizedDimension(perAxis));196 // CHECK: fixed point: 0197 fprintf(stderr, "fixed point: %d\n",198 mlirUniformQuantizedPerAxisTypeIsFixedPoint(perAxis));199 200 // CHECK: equal: 1201 fprintf(stderr, "equal: %d\n", mlirTypeEqual(perAxis, perAxisParsed));202 // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>203 mlirTypeDump(perAxis);204 fprintf(stderr, "\n\n");205}206 207// CHECK-LABEL: testUniformSubChannelType208void testUniformSubChannelType(MlirContext ctx) {209 fprintf(stderr, "testUniformSubChannelType\n");210 211 MlirType subChannelParsed =212 mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(213 "!quant.uniform<i8:f32:{0:1, 1:2}, "214 "{{2.0:10, 3.0:20}, {4.0:30, 5.0:40}}>"));215 216 MlirType i8 = mlirIntegerTypeGet(ctx, 8);217 MlirType f32 = mlirF32TypeGet(ctx);218 219 // block-size information220 int32_t quantizedDimensions[] = {0, 1};221 int64_t blockSizes[] = {1, 2};222 int64_t numBlockSizes = 2;223 224 // quantization parameters225 int64_t quantParamShape[] = {2, 2};226 int64_t quantParamRank = 2;227 int64_t numQuantizationParams = 4;228 MlirAttribute scales[] = {mlirFloatAttrDoubleGet(ctx, f32, 2.0),229 mlirFloatAttrDoubleGet(ctx, f32, 3.0),230 mlirFloatAttrDoubleGet(ctx, f32, 4.0),231 mlirFloatAttrDoubleGet(ctx, f32, 5.0)};232 MlirAttribute zeroPoints[] = {233 mlirIntegerAttrGet(i8, 10), mlirIntegerAttrGet(i8, 20),234 mlirIntegerAttrGet(i8, 30), mlirIntegerAttrGet(i8, 40)};235 236 MlirType scalesType =237 mlirRankedTensorTypeGet(quantParamRank, quantParamShape, f32,238 /*encoding=*/mlirAttributeGetNull());239 MlirType zeroPointsType = mlirRankedTensorTypeGet(240 quantParamRank, quantParamShape, i8, /*encoding=*/mlirAttributeGetNull());241 MlirAttribute denseScalesAttr =242 mlirDenseElementsAttrGet(scalesType, numQuantizationParams, scales);243 MlirAttribute denseZeroPointsAttr = mlirDenseElementsAttrGet(244 zeroPointsType, numQuantizationParams, zeroPoints);245 246 MlirType subChannel = mlirUniformQuantizedSubChannelTypeGet(247 mlirQuantizedTypeGetSignedFlag(), i8, f32, denseScalesAttr,248 denseZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,249 mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,250 /*integralWidth=*/8),251 mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,252 /*integralWidth=*/8));253 254 MlirAttribute arrayScalesAttr =255 mlirArrayAttrGet(ctx, numQuantizationParams, scales);256 MlirAttribute arrayZeroPointsAttr =257 mlirArrayAttrGet(ctx, numQuantizationParams, zeroPoints);258 MlirType illegalSubChannel = mlirUniformQuantizedSubChannelTypeGet(259 mlirQuantizedTypeGetSignedFlag(), i8, f32, arrayScalesAttr,260 arrayZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,261 mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,262 /*integralWidth=*/8),263 mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,264 /*integralWidth=*/8));265 266 // CHECK: is null sub-channel type: 1267 fprintf(stderr, "is null sub-channel type: %d\n",268 mlirTypeIsNull(illegalSubChannel));269 270 // CHECK: num dims: 2271 fprintf(stderr, "num dims: %" PRIdPTR "\n",272 mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(subChannel));273 274 // CHECK: axis-block-size-pair[0]: 0:1275 fprintf(276 stderr, "axis-block-size-pair[0]: %" PRId32 ":%" PRId64 "\n",277 mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 0),278 mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 0));279 280 // CHECK: axis-block-size-pair[1]: 1:2281 fprintf(282 stderr, "axis-block-size-pair[1]: %" PRId32 ":%" PRId64 "\n",283 mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 1),284 mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 1));285 286 denseScalesAttr = mlirUniformQuantizedSubChannelTypeGetScales(subChannel);287 denseZeroPointsAttr =288 mlirUniformQuantizedSubChannelTypeGetZeroPoints(subChannel);289 scalesType = mlirAttributeGetType(denseScalesAttr);290 zeroPointsType = mlirAttributeGetType(denseZeroPointsAttr);291 292 // CHECK: tensor<2x2xf32>293 mlirTypeDump(scalesType);294 // CHECK: tensor<2x2xi8>295 mlirTypeDump(zeroPointsType);296 297 // CHECK: number of quantization parameters: 4298 fprintf(stderr, "number of quantization parameters: %" PRId64 "\n",299 mlirElementsAttrGetNumElements(denseScalesAttr));300 301 // CHECK: quantization-parameter[0]: 2.000000:10302 fprintf(stderr, "quantization-parameter[0]: %lf:%" PRId8 "\n",303 mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 0),304 mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 0));305 306 // CHECK: quantization-parameter[1]: 3.000000:20307 fprintf(stderr, "quantization-parameter[1]: %lf:%" PRId8 "\n",308 mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 1),309 mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 1));310 311 // CHECK: quantization-parameter[2]: 4.000000:30312 fprintf(stderr, "quantization-parameter[2]: %lf:%" PRId8 "\n",313 mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 2),314 mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 2));315 316 // CHECK: quantization-parameter[3]: 5.000000:40317 fprintf(stderr, "quantization-parameter[3]: %lf:%" PRId8 "\n",318 mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 3),319 mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 3));320 321 // CHECK: equal: 1322 fprintf(stderr, "equal: %d\n", mlirTypeEqual(subChannel, subChannelParsed));323 324 // CHECK: !quant.uniform<i8:f32:{0:1, 1:2},325 // {{.*}}2.000000e+00:10, 3.000000e+00:20},326 // {4.000000e+00:30, 5.000000e+00:40{{.*}}}}>327 mlirTypeDump(subChannel);328 fprintf(stderr, "\n\n");329}330 331// CHECK-LABEL: testCalibratedType332void testCalibratedType(MlirContext ctx) {333 fprintf(stderr, "testCalibratedType\n");334 335 MlirType calibratedParsed = mlirTypeParseGet(336 ctx,337 mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));338 339 MlirType f32 = mlirF32TypeGet(ctx);340 MlirType calibrated = mlirCalibratedQuantizedTypeGet(f32, -0.998, 1.2321);341 342 // CHECK: min: -0.998000343 fprintf(stderr, "min: %lf\n", mlirCalibratedQuantizedTypeGetMin(calibrated));344 // CHECK: max: 1.232100345 fprintf(stderr, "max: %lf\n", mlirCalibratedQuantizedTypeGetMax(calibrated));346 347 // CHECK: equal: 1348 fprintf(stderr, "equal: %d\n", mlirTypeEqual(calibrated, calibratedParsed));349 // CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>>350 mlirTypeDump(calibrated);351 fprintf(stderr, "\n\n");352}353 354int main(void) {355 MlirContext ctx = mlirContextCreate();356 mlirDialectHandleRegisterDialect(mlirGetDialectHandle__quant__(), ctx);357 testTypeHierarchy(ctx);358 testAnyQuantizedType(ctx);359 testUniformType(ctx);360 testUniformPerAxisType(ctx);361 testUniformSubChannelType(ctx);362 testCalibratedType(ctx);363 mlirContextDestroy(ctx);364 return EXIT_SUCCESS;365}366