mlir/test/CAPI/quant.c - llvm-project - Git at Google


            
            //===- quant.c - Test of Quant dialect C API ------------------------------===//

            
            //

            
            // Part of the LLVM Project, under the Apache License v2.0 with LLVM

            
            // Exceptions.

            
            // See https://llvm.org/LICENSE.txt for license information.

            
            // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

            
            //

            
            //===----------------------------------------------------------------------===//


            // RUN: mlir-capi-quant-test 2>&1 | FileCheck %s


            #include "mlir-c/Dialect/Quant.h"

            
            #include "mlir-c/BuiltinAttributes.h"

            
            #include "mlir-c/BuiltinTypes.h"

            
            #include "mlir-c/IR.h"


            #include <assert.h>

            
            #include <inttypes.h>

            
            #include <stdio.h>

            
            #include <stdlib.h>


            // CHECK-LABEL: testTypeHierarchy

            
            static void testTypeHierarchy(MlirContext ctx) {

            
              fprintf(stderr, "testTypeHierarchy\n");


              MlirType i8 = mlirIntegerTypeGet(ctx, 8);

            
              MlirType any = mlirTypeParseGet(

            
                  ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));

            
              MlirType uniform =

            
                  mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(

            
                                            "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));

            
              MlirType perAxis = mlirTypeParseGet(

            
                  ctx, mlirStringRefCreateFromCString(

            
                           "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));

            
              MlirType calibrated = mlirTypeParseGet(

            
                  ctx,

            
                  mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));


              // The parser itself is checked in C++ dialect tests.

            
              assert(!mlirTypeIsNull(any) && "couldn't parse AnyQuantizedType");

            
              assert(!mlirTypeIsNull(uniform) && "couldn't parse UniformQuantizedType");

            
              assert(!mlirTypeIsNull(perAxis) &&

            
                     "couldn't parse UniformQuantizedPerAxisType");

            
              assert(!mlirTypeIsNull(calibrated) &&

            
                     "couldn't parse CalibratedQuantizedType");


              // CHECK: i8 isa QuantizedType: 0

            
              fprintf(stderr, "i8 isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(i8));

            
              // CHECK: any isa QuantizedType: 1

            
              fprintf(stderr, "any isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(any));

            
              // CHECK: uniform isa QuantizedType: 1

            
              fprintf(stderr, "uniform isa QuantizedType: %d\n",

            
                      mlirTypeIsAQuantizedType(uniform));

            
              // CHECK: perAxis isa QuantizedType: 1

            
              fprintf(stderr, "perAxis isa QuantizedType: %d\n",

            
                      mlirTypeIsAQuantizedType(perAxis));

            
              // CHECK: calibrated isa QuantizedType: 1

            
              fprintf(stderr, "calibrated isa QuantizedType: %d\n",

            
                      mlirTypeIsAQuantizedType(calibrated));


              // CHECK: any isa AnyQuantizedType: 1

            
              fprintf(stderr, "any isa AnyQuantizedType: %d\n",

            
                      mlirTypeIsAAnyQuantizedType(any));

            
              // CHECK: uniform isa UniformQuantizedType: 1

            
              fprintf(stderr, "uniform isa UniformQuantizedType: %d\n",

            
                      mlirTypeIsAUniformQuantizedType(uniform));

            
              // CHECK: perAxis isa UniformQuantizedPerAxisType: 1

            
              fprintf(stderr, "perAxis isa UniformQuantizedPerAxisType: %d\n",

            
                      mlirTypeIsAUniformQuantizedPerAxisType(perAxis));

            
              // CHECK: calibrated isa CalibratedQuantizedType: 1

            
              fprintf(stderr, "calibrated isa CalibratedQuantizedType: %d\n",

            
                      mlirTypeIsACalibratedQuantizedType(calibrated));


              // CHECK: perAxis isa UniformQuantizedType: 0

            
              fprintf(stderr, "perAxis isa UniformQuantizedType: %d\n",

            
                      mlirTypeIsAUniformQuantizedType(perAxis));

            
              // CHECK: uniform isa CalibratedQuantizedType: 0

            
              fprintf(stderr, "uniform isa CalibratedQuantizedType: %d\n",

            
                      mlirTypeIsACalibratedQuantizedType(uniform));

            
              fprintf(stderr, "\n");

            
            }


            // CHECK-LABEL: testAnyQuantizedType

            
            void testAnyQuantizedType(MlirContext ctx) {

            
              fprintf(stderr, "testAnyQuantizedType\n");


              MlirType anyParsed = mlirTypeParseGet(

            
                  ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));


              MlirType i8 = mlirIntegerTypeGet(ctx, 8);

            
              MlirType f32 = mlirF32TypeGet(ctx);

            
              MlirType any =

            
                  mlirAnyQuantizedTypeGet(mlirQuantizedTypeGetSignedFlag(), i8, f32, -8, 7);


              // CHECK: flags: 1

            
              fprintf(stderr, "flags: %u\n", mlirQuantizedTypeGetFlags(any));

            
              // CHECK: signed: 1

            
              fprintf(stderr, "signed: %u\n", mlirQuantizedTypeIsSigned(any));

            
              // CHECK: storage type: i8

            
              fprintf(stderr, "storage type: ");

            
              mlirTypeDump(mlirQuantizedTypeGetStorageType(any));

            
              fprintf(stderr, "\n");

            
              // CHECK: expressed type: f32

            
              fprintf(stderr, "expressed type: ");

            
              mlirTypeDump(mlirQuantizedTypeGetExpressedType(any));

            
              fprintf(stderr, "\n");

            
              // CHECK: storage min: -8

            
              fprintf(stderr, "storage min: %" PRId64 "\n",

            
                      mlirQuantizedTypeGetStorageTypeMin(any));

            
              // CHECK: storage max: 7

            
              fprintf(stderr, "storage max: %" PRId64 "\n",

            
                      mlirQuantizedTypeGetStorageTypeMax(any));

            
              // CHECK: storage width: 8

            
              fprintf(stderr, "storage width: %u\n",

            
                      mlirQuantizedTypeGetStorageTypeIntegralWidth(any));

            
              // CHECK: quantized element type: !quant.any<i8<-8:7>:f32>

            
              fprintf(stderr, "quantized element type: ");

            
              mlirTypeDump(mlirQuantizedTypeGetQuantizedElementType(any));

            
              fprintf(stderr, "\n");


              // CHECK: equal: 1

            
              fprintf(stderr, "equal: %d\n", mlirTypeEqual(anyParsed, any));

            
              // CHECK: !quant.any<i8<-8:7>:f32>

            
              mlirTypeDump(any);

            
              fprintf(stderr, "\n\n");

            
            }


            // CHECK-LABEL: testUniformType

            
            void testUniformType(MlirContext ctx) {

            
              fprintf(stderr, "testUniformType\n");


              MlirType uniformParsed =

            
                  mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(

            
                                            "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));


              MlirType i8 = mlirIntegerTypeGet(ctx, 8);

            
              MlirType f32 = mlirF32TypeGet(ctx);

            
              MlirType uniform = mlirUniformQuantizedTypeGet(

            
                  mlirQuantizedTypeGetSignedFlag(), i8, f32, 0.99872, 127, -8, 7);


              // CHECK: scale: 0.998720

            
              fprintf(stderr, "scale: %lf\n", mlirUniformQuantizedTypeGetScale(uniform));

            
              // CHECK: zero point: 127

            
              fprintf(stderr, "zero point: %" PRId64 "\n",

            
                      mlirUniformQuantizedTypeGetZeroPoint(uniform));

            
              // CHECK: fixed point: 0

            
              fprintf(stderr, "fixed point: %d\n",

            
                      mlirUniformQuantizedTypeIsFixedPoint(uniform));


              // CHECK: equal: 1

            
              fprintf(stderr, "equal: %d\n", mlirTypeEqual(uniform, uniformParsed));

            
              // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>

            
              mlirTypeDump(uniform);

            
              fprintf(stderr, "\n\n");

            
            }


            // CHECK-LABEL: testUniformPerAxisType

            
            void testUniformPerAxisType(MlirContext ctx) {

            
              fprintf(stderr, "testUniformPerAxisType\n");


              MlirType perAxisParsed = mlirTypeParseGet(

            
                  ctx, mlirStringRefCreateFromCString(

            
                           "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));


              MlirType i8 = mlirIntegerTypeGet(ctx, 8);

            
              MlirType f32 = mlirF32TypeGet(ctx);

            
              double scales[] = {200.0, 0.99872};

            
              int64_t zeroPoints[] = {0, 120};

            
              MlirType perAxis = mlirUniformQuantizedPerAxisTypeGet(

            
                  mlirQuantizedTypeGetSignedFlag(), i8, f32,

            
                  /*nDims=*/2, scales, zeroPoints,

            
                  /*quantizedDimension=*/1,

            
                  mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8),

            
                  mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8));


              // CHECK: num dims: 2

            
              fprintf(stderr, "num dims: %" PRIdPTR "\n",

            
                      mlirUniformQuantizedPerAxisTypeGetNumDims(perAxis));

            
              // CHECK: scale 0: 200.000000

            
              fprintf(stderr, "scale 0: %lf\n",

            
                      mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 0));

            
              // CHECK: scale 1: 0.998720

            
              fprintf(stderr, "scale 1: %lf\n",

            
                      mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 1));

            
              // CHECK: zero point 0: 0

            
              fprintf(stderr, "zero point 0: %" PRId64 "\n",

            
                      mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 0));

            
              // CHECK: zero point 1: 120

            
              fprintf(stderr, "zero point 1: %" PRId64 "\n",

            
                      mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 1));

            
              // CHECK: quantized dim: 1

            
              fprintf(stderr, "quantized dim: %" PRId32 "\n",

            
                      mlirUniformQuantizedPerAxisTypeGetQuantizedDimension(perAxis));

            
              // CHECK: fixed point: 0

            
              fprintf(stderr, "fixed point: %d\n",

            
                      mlirUniformQuantizedPerAxisTypeIsFixedPoint(perAxis));


              // CHECK: equal: 1

            
              fprintf(stderr, "equal: %d\n", mlirTypeEqual(perAxis, perAxisParsed));

            
              // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>

            
              mlirTypeDump(perAxis);

            
              fprintf(stderr, "\n\n");

            
            }


            // CHECK-LABEL: testUniformSubChannelType

            
            void testUniformSubChannelType(MlirContext ctx) {

            
              fprintf(stderr, "testUniformSubChannelType\n");


              MlirType subChannelParsed =

            
                  mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(

            
                                            "!quant.uniform<i8:f32:{0:1, 1:2}, "

            
                                            "{{2.0:10, 3.0:20}, {4.0:30, 5.0:40}}>"));


              MlirType i8 = mlirIntegerTypeGet(ctx, 8);

            
              MlirType f32 = mlirF32TypeGet(ctx);


              // block-size information

            
              int32_t quantizedDimensions[] = {0, 1};

            
              int64_t blockSizes[] = {1, 2};

            
              int64_t numBlockSizes = 2;


              // quantization parameters

            
              int64_t quantParamShape[] = {2, 2};

            
              int64_t quantParamRank = 2;

            
              int64_t numQuantizationParams = 4;

            
              MlirAttribute scales[] = {mlirFloatAttrDoubleGet(ctx, f32, 2.0),

            
                                        mlirFloatAttrDoubleGet(ctx, f32, 3.0),

            
                                        mlirFloatAttrDoubleGet(ctx, f32, 4.0),

            
                                        mlirFloatAttrDoubleGet(ctx, f32, 5.0)};

            
              MlirAttribute zeroPoints[] = {

            
                  mlirIntegerAttrGet(i8, 10), mlirIntegerAttrGet(i8, 20),

            
                  mlirIntegerAttrGet(i8, 30), mlirIntegerAttrGet(i8, 40)};


              MlirType scalesType =

            
                  mlirRankedTensorTypeGet(quantParamRank, quantParamShape, f32,

            
                                          /*encoding=*/mlirAttributeGetNull());

            
              MlirType zeroPointsType = mlirRankedTensorTypeGet(

            
                  quantParamRank, quantParamShape, i8, /*encoding=*/mlirAttributeGetNull());

            
              MlirAttribute denseScalesAttr =

            
                  mlirDenseElementsAttrGet(scalesType, numQuantizationParams, scales);

            
              MlirAttribute denseZeroPointsAttr = mlirDenseElementsAttrGet(

            
                  zeroPointsType, numQuantizationParams, zeroPoints);


              MlirType subChannel = mlirUniformQuantizedSubChannelTypeGet(

            
                  mlirQuantizedTypeGetSignedFlag(), i8, f32, denseScalesAttr,

            
                  denseZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,

            
                  mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8),

            
                  mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8));


              MlirAttribute arrayScalesAttr =

            
                  mlirArrayAttrGet(ctx, numQuantizationParams, scales);

            
              MlirAttribute arrayZeroPointsAttr =

            
                  mlirArrayAttrGet(ctx, numQuantizationParams, zeroPoints);

            
              MlirType illegalSubChannel = mlirUniformQuantizedSubChannelTypeGet(

            
                  mlirQuantizedTypeGetSignedFlag(), i8, f32, arrayScalesAttr,

            
                  arrayZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,

            
                  mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8),

            
                  mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,

            
                                                               /*integralWidth=*/8));


              // CHECK: is null sub-channel type: 1

            
              fprintf(stderr, "is null sub-channel type: %d\n",

            
                      mlirTypeIsNull(illegalSubChannel));


              // CHECK: num dims: 2

            
              fprintf(stderr, "num dims: %" PRIdPTR "\n",

            
                      mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(subChannel));


              // CHECK: axis-block-size-pair[0]: 0:1

            
              fprintf(

            
                  stderr, "axis-block-size-pair[0]: %" PRId32 ":%" PRId64 "\n",

            
                  mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 0),

            
                  mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 0));


              // CHECK: axis-block-size-pair[1]: 1:2

            
              fprintf(

            
                  stderr, "axis-block-size-pair[1]: %" PRId32 ":%" PRId64 "\n",

            
                  mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 1),

            
                  mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 1));


              denseScalesAttr = mlirUniformQuantizedSubChannelTypeGetScales(subChannel);

            
              denseZeroPointsAttr =

            
                  mlirUniformQuantizedSubChannelTypeGetZeroPoints(subChannel);

            
              scalesType = mlirAttributeGetType(denseScalesAttr);

            
              zeroPointsType = mlirAttributeGetType(denseZeroPointsAttr);


              // CHECK: tensor<2x2xf32>

            
              mlirTypeDump(scalesType);

            
              // CHECK: tensor<2x2xi8>

            
              mlirTypeDump(zeroPointsType);


              // CHECK: number of quantization parameters: 4

            
              fprintf(stderr, "number of quantization parameters: %" PRId64 "\n",

            
                      mlirElementsAttrGetNumElements(denseScalesAttr));


              // CHECK: quantization-parameter[0]: 2.000000:10

            
              fprintf(stderr, "quantization-parameter[0]: %lf:%" PRId8 "\n",

            
                      mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 0),

            
                      mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 0));


              // CHECK: quantization-parameter[1]: 3.000000:20

            
              fprintf(stderr, "quantization-parameter[1]: %lf:%" PRId8 "\n",

            
                      mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 1),

            
                      mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 1));


              // CHECK: quantization-parameter[2]: 4.000000:30

            
              fprintf(stderr, "quantization-parameter[2]: %lf:%" PRId8 "\n",

            
                      mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 2),

            
                      mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 2));


              // CHECK: quantization-parameter[3]: 5.000000:40

            
              fprintf(stderr, "quantization-parameter[3]: %lf:%" PRId8 "\n",

            
                      mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 3),

            
                      mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 3));


              // CHECK: equal: 1

            
              fprintf(stderr, "equal: %d\n", mlirTypeEqual(subChannel, subChannelParsed));


              // CHECK: !quant.uniform<i8:f32:{0:1, 1:2},

            
              // {{.*}}2.000000e+00:10, 3.000000e+00:20},

            
              // {4.000000e+00:30, 5.000000e+00:40{{.*}}}}>

            
              mlirTypeDump(subChannel);

            
              fprintf(stderr, "\n\n");

            
            }


            // CHECK-LABEL: testCalibratedType

            
            void testCalibratedType(MlirContext ctx) {

            
              fprintf(stderr, "testCalibratedType\n");


              MlirType calibratedParsed = mlirTypeParseGet(

            
                  ctx,

            
                  mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));


              MlirType f32 = mlirF32TypeGet(ctx);

            
              MlirType calibrated = mlirCalibratedQuantizedTypeGet(f32, -0.998, 1.2321);


              // CHECK: min: -0.998000

            
              fprintf(stderr, "min: %lf\n", mlirCalibratedQuantizedTypeGetMin(calibrated));

            
              // CHECK: max: 1.232100

            
              fprintf(stderr, "max: %lf\n", mlirCalibratedQuantizedTypeGetMax(calibrated));


              // CHECK: equal: 1

            
              fprintf(stderr, "equal: %d\n", mlirTypeEqual(calibrated, calibratedParsed));

            
              // CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>>

            
              mlirTypeDump(calibrated);

            
              fprintf(stderr, "\n\n");

            
            }


            int main(void) {

            
              MlirContext ctx = mlirContextCreate();

            
              mlirDialectHandleRegisterDialect(mlirGetDialectHandle__quant__(), ctx);

            
              testTypeHierarchy(ctx);

            
              testAnyQuantizedType(ctx);

            
              testUniformType(ctx);

            
              testUniformPerAxisType(ctx);

            
              testUniformSubChannelType(ctx);

            
              testCalibratedType(ctx);

            
              mlirContextDestroy(ctx);

            
              return EXIT_SUCCESS;

            
            }
	//===- quant.c - Test of Quant dialect C API ------------------------------===//
	//
	// Part of the LLVM Project, under the Apache License v2.0 with LLVM
	// Exceptions.
	// See https://llvm.org/LICENSE.txt for license information.
	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
	//
	//===----------------------------------------------------------------------===//

	// RUN: mlir-capi-quant-test 2>&1 \| FileCheck %s

	#include "mlir-c/Dialect/Quant.h"
	#include "mlir-c/BuiltinAttributes.h"
	#include "mlir-c/BuiltinTypes.h"
	#include "mlir-c/IR.h"

	#include <assert.h>
	#include <inttypes.h>
	#include <stdio.h>
	#include <stdlib.h>

	// CHECK-LABEL: testTypeHierarchy
	static void testTypeHierarchy(MlirContext ctx) {
	fprintf(stderr, "testTypeHierarchy\n");

	MlirType i8 = mlirIntegerTypeGet(ctx, 8);
	MlirType any = mlirTypeParseGet(
	ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));
	MlirType uniform =
	mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(
	"!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));
	MlirType perAxis = mlirTypeParseGet(
	ctx, mlirStringRefCreateFromCString(
	"!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));
	MlirType calibrated = mlirTypeParseGet(
	ctx,
	mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));

	// The parser itself is checked in C++ dialect tests.
	assert(!mlirTypeIsNull(any) && "couldn't parse AnyQuantizedType");
	assert(!mlirTypeIsNull(uniform) && "couldn't parse UniformQuantizedType");
	assert(!mlirTypeIsNull(perAxis) &&
	"couldn't parse UniformQuantizedPerAxisType");
	assert(!mlirTypeIsNull(calibrated) &&
	"couldn't parse CalibratedQuantizedType");

	// CHECK: i8 isa QuantizedType: 0
	fprintf(stderr, "i8 isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(i8));
	// CHECK: any isa QuantizedType: 1
	fprintf(stderr, "any isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(any));
	// CHECK: uniform isa QuantizedType: 1
	fprintf(stderr, "uniform isa QuantizedType: %d\n",
	mlirTypeIsAQuantizedType(uniform));
	// CHECK: perAxis isa QuantizedType: 1
	fprintf(stderr, "perAxis isa QuantizedType: %d\n",
	mlirTypeIsAQuantizedType(perAxis));
	// CHECK: calibrated isa QuantizedType: 1
	fprintf(stderr, "calibrated isa QuantizedType: %d\n",
	mlirTypeIsAQuantizedType(calibrated));

	// CHECK: any isa AnyQuantizedType: 1
	fprintf(stderr, "any isa AnyQuantizedType: %d\n",
	mlirTypeIsAAnyQuantizedType(any));
	// CHECK: uniform isa UniformQuantizedType: 1
	fprintf(stderr, "uniform isa UniformQuantizedType: %d\n",
	mlirTypeIsAUniformQuantizedType(uniform));
	// CHECK: perAxis isa UniformQuantizedPerAxisType: 1
	fprintf(stderr, "perAxis isa UniformQuantizedPerAxisType: %d\n",
	mlirTypeIsAUniformQuantizedPerAxisType(perAxis));
	// CHECK: calibrated isa CalibratedQuantizedType: 1
	fprintf(stderr, "calibrated isa CalibratedQuantizedType: %d\n",
	mlirTypeIsACalibratedQuantizedType(calibrated));

	// CHECK: perAxis isa UniformQuantizedType: 0
	fprintf(stderr, "perAxis isa UniformQuantizedType: %d\n",
	mlirTypeIsAUniformQuantizedType(perAxis));
	// CHECK: uniform isa CalibratedQuantizedType: 0
	fprintf(stderr, "uniform isa CalibratedQuantizedType: %d\n",
	mlirTypeIsACalibratedQuantizedType(uniform));
	fprintf(stderr, "\n");
	}

	// CHECK-LABEL: testAnyQuantizedType
	void testAnyQuantizedType(MlirContext ctx) {
	fprintf(stderr, "testAnyQuantizedType\n");

	MlirType anyParsed = mlirTypeParseGet(
	ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));

	MlirType i8 = mlirIntegerTypeGet(ctx, 8);
	MlirType f32 = mlirF32TypeGet(ctx);
	MlirType any =
	mlirAnyQuantizedTypeGet(mlirQuantizedTypeGetSignedFlag(), i8, f32, -8, 7);

	// CHECK: flags: 1
	fprintf(stderr, "flags: %u\n", mlirQuantizedTypeGetFlags(any));
	// CHECK: signed: 1
	fprintf(stderr, "signed: %u\n", mlirQuantizedTypeIsSigned(any));
	// CHECK: storage type: i8
	fprintf(stderr, "storage type: ");
	mlirTypeDump(mlirQuantizedTypeGetStorageType(any));
	fprintf(stderr, "\n");
	// CHECK: expressed type: f32
	fprintf(stderr, "expressed type: ");
	mlirTypeDump(mlirQuantizedTypeGetExpressedType(any));
	fprintf(stderr, "\n");
	// CHECK: storage min: -8
	fprintf(stderr, "storage min: %" PRId64 "\n",
	mlirQuantizedTypeGetStorageTypeMin(any));
	// CHECK: storage max: 7
	fprintf(stderr, "storage max: %" PRId64 "\n",
	mlirQuantizedTypeGetStorageTypeMax(any));
	// CHECK: storage width: 8
	fprintf(stderr, "storage width: %u\n",
	mlirQuantizedTypeGetStorageTypeIntegralWidth(any));
	// CHECK: quantized element type: !quant.any<i8<-8:7>:f32>
	fprintf(stderr, "quantized element type: ");
	mlirTypeDump(mlirQuantizedTypeGetQuantizedElementType(any));
	fprintf(stderr, "\n");

	// CHECK: equal: 1
	fprintf(stderr, "equal: %d\n", mlirTypeEqual(anyParsed, any));
	// CHECK: !quant.any<i8<-8:7>:f32>
	mlirTypeDump(any);
	fprintf(stderr, "\n\n");
	}

	// CHECK-LABEL: testUniformType
	void testUniformType(MlirContext ctx) {
	fprintf(stderr, "testUniformType\n");

	MlirType uniformParsed =
	mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(
	"!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));

	MlirType i8 = mlirIntegerTypeGet(ctx, 8);
	MlirType f32 = mlirF32TypeGet(ctx);
	MlirType uniform = mlirUniformQuantizedTypeGet(
	mlirQuantizedTypeGetSignedFlag(), i8, f32, 0.99872, 127, -8, 7);

	// CHECK: scale: 0.998720
	fprintf(stderr, "scale: %lf\n", mlirUniformQuantizedTypeGetScale(uniform));
	// CHECK: zero point: 127
	fprintf(stderr, "zero point: %" PRId64 "\n",
	mlirUniformQuantizedTypeGetZeroPoint(uniform));
	// CHECK: fixed point: 0
	fprintf(stderr, "fixed point: %d\n",
	mlirUniformQuantizedTypeIsFixedPoint(uniform));

	// CHECK: equal: 1
	fprintf(stderr, "equal: %d\n", mlirTypeEqual(uniform, uniformParsed));
	// CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
	mlirTypeDump(uniform);
	fprintf(stderr, "\n\n");
	}

	// CHECK-LABEL: testUniformPerAxisType
	void testUniformPerAxisType(MlirContext ctx) {
	fprintf(stderr, "testUniformPerAxisType\n");

	MlirType perAxisParsed = mlirTypeParseGet(
	ctx, mlirStringRefCreateFromCString(
	"!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));

	MlirType i8 = mlirIntegerTypeGet(ctx, 8);
	MlirType f32 = mlirF32TypeGet(ctx);
	double scales[] = {200.0, 0.99872};
	int64_t zeroPoints[] = {0, 120};
	MlirType perAxis = mlirUniformQuantizedPerAxisTypeGet(
	mlirQuantizedTypeGetSignedFlag(), i8, f32,
	/nDims=/2, scales, zeroPoints,
	/quantizedDimension=/1,
	mlirQuantizedTypeGetDefaultMinimumForInteger(/isSigned=/true,
	/integralWidth=/8),
	mlirQuantizedTypeGetDefaultMaximumForInteger(/isSigned=/true,
	/integralWidth=/8));

	// CHECK: num dims: 2
	fprintf(stderr, "num dims: %" PRIdPTR "\n",
	mlirUniformQuantizedPerAxisTypeGetNumDims(perAxis));
	// CHECK: scale 0: 200.000000
	fprintf(stderr, "scale 0: %lf\n",
	mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 0));
	// CHECK: scale 1: 0.998720
	fprintf(stderr, "scale 1: %lf\n",
	mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 1));
	// CHECK: zero point 0: 0
	fprintf(stderr, "zero point 0: %" PRId64 "\n",
	mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 0));
	// CHECK: zero point 1: 120
	fprintf(stderr, "zero point 1: %" PRId64 "\n",
	mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 1));
	// CHECK: quantized dim: 1
	fprintf(stderr, "quantized dim: %" PRId32 "\n",
	mlirUniformQuantizedPerAxisTypeGetQuantizedDimension(perAxis));
	// CHECK: fixed point: 0
	fprintf(stderr, "fixed point: %d\n",
	mlirUniformQuantizedPerAxisTypeIsFixedPoint(perAxis));

	// CHECK: equal: 1
	fprintf(stderr, "equal: %d\n", mlirTypeEqual(perAxis, perAxisParsed));
	// CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>
	mlirTypeDump(perAxis);
	fprintf(stderr, "\n\n");
	}

	// CHECK-LABEL: testUniformSubChannelType
	void testUniformSubChannelType(MlirContext ctx) {
	fprintf(stderr, "testUniformSubChannelType\n");

	MlirType subChannelParsed =
	mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(
	"!quant.uniform<i8:f32:{0:1, 1:2}, "
	"{{2.0:10, 3.0:20}, {4.0:30, 5.0:40}}>"));

	MlirType i8 = mlirIntegerTypeGet(ctx, 8);
	MlirType f32 = mlirF32TypeGet(ctx);

	// block-size information
	int32_t quantizedDimensions[] = {0, 1};
	int64_t blockSizes[] = {1, 2};
	int64_t numBlockSizes = 2;

	// quantization parameters
	int64_t quantParamShape[] = {2, 2};
	int64_t quantParamRank = 2;
	int64_t numQuantizationParams = 4;
	MlirAttribute scales[] = {mlirFloatAttrDoubleGet(ctx, f32, 2.0),
	mlirFloatAttrDoubleGet(ctx, f32, 3.0),
	mlirFloatAttrDoubleGet(ctx, f32, 4.0),
	mlirFloatAttrDoubleGet(ctx, f32, 5.0)};
	MlirAttribute zeroPoints[] = {
	mlirIntegerAttrGet(i8, 10), mlirIntegerAttrGet(i8, 20),
	mlirIntegerAttrGet(i8, 30), mlirIntegerAttrGet(i8, 40)};

	MlirType scalesType =
	mlirRankedTensorTypeGet(quantParamRank, quantParamShape, f32,
	/encoding=/mlirAttributeGetNull());
	MlirType zeroPointsType = mlirRankedTensorTypeGet(
	quantParamRank, quantParamShape, i8, /encoding=/mlirAttributeGetNull());
	MlirAttribute denseScalesAttr =
	mlirDenseElementsAttrGet(scalesType, numQuantizationParams, scales);
	MlirAttribute denseZeroPointsAttr = mlirDenseElementsAttrGet(
	zeroPointsType, numQuantizationParams, zeroPoints);

	MlirType subChannel = mlirUniformQuantizedSubChannelTypeGet(
	mlirQuantizedTypeGetSignedFlag(), i8, f32, denseScalesAttr,
	denseZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,
	mlirQuantizedTypeGetDefaultMinimumForInteger(/isSigned=/true,
	/integralWidth=/8),
	mlirQuantizedTypeGetDefaultMaximumForInteger(/isSigned=/true,
	/integralWidth=/8));

	MlirAttribute arrayScalesAttr =
	mlirArrayAttrGet(ctx, numQuantizationParams, scales);
	MlirAttribute arrayZeroPointsAttr =
	mlirArrayAttrGet(ctx, numQuantizationParams, zeroPoints);
	MlirType illegalSubChannel = mlirUniformQuantizedSubChannelTypeGet(
	mlirQuantizedTypeGetSignedFlag(), i8, f32, arrayScalesAttr,
	arrayZeroPointsAttr, numBlockSizes, quantizedDimensions, blockSizes,
	mlirQuantizedTypeGetDefaultMinimumForInteger(/isSigned=/true,
	/integralWidth=/8),
	mlirQuantizedTypeGetDefaultMaximumForInteger(/isSigned=/true,
	/integralWidth=/8));

	// CHECK: is null sub-channel type: 1
	fprintf(stderr, "is null sub-channel type: %d\n",
	mlirTypeIsNull(illegalSubChannel));

	// CHECK: num dims: 2
	fprintf(stderr, "num dims: %" PRIdPTR "\n",
	mlirUniformQuantizedSubChannelTypeGetNumBlockSizes(subChannel));

	// CHECK: axis-block-size-pair[0]: 0:1
	fprintf(
	stderr, "axis-block-size-pair[0]: %" PRId32 ":%" PRId64 "\n",
	mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 0),
	mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 0));

	// CHECK: axis-block-size-pair[1]: 1:2
	fprintf(
	stderr, "axis-block-size-pair[1]: %" PRId32 ":%" PRId64 "\n",
	mlirUniformQuantizedSubChannelTypeGetQuantizedDimension(subChannel, 1),
	mlirUniformQuantizedSubChannelTypeGetBlockSize(subChannel, 1));

	denseScalesAttr = mlirUniformQuantizedSubChannelTypeGetScales(subChannel);
	denseZeroPointsAttr =
	mlirUniformQuantizedSubChannelTypeGetZeroPoints(subChannel);
	scalesType = mlirAttributeGetType(denseScalesAttr);
	zeroPointsType = mlirAttributeGetType(denseZeroPointsAttr);

	// CHECK: tensor<2x2xf32>
	mlirTypeDump(scalesType);
	// CHECK: tensor<2x2xi8>
	mlirTypeDump(zeroPointsType);

	// CHECK: number of quantization parameters: 4
	fprintf(stderr, "number of quantization parameters: %" PRId64 "\n",
	mlirElementsAttrGetNumElements(denseScalesAttr));

	// CHECK: quantization-parameter[0]: 2.000000:10
	fprintf(stderr, "quantization-parameter[0]: %lf:%" PRId8 "\n",
	mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 0),
	mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 0));

	// CHECK: quantization-parameter[1]: 3.000000:20
	fprintf(stderr, "quantization-parameter[1]: %lf:%" PRId8 "\n",
	mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 1),
	mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 1));

	// CHECK: quantization-parameter[2]: 4.000000:30
	fprintf(stderr, "quantization-parameter[2]: %lf:%" PRId8 "\n",
	mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 2),
	mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 2));

	// CHECK: quantization-parameter[3]: 5.000000:40
	fprintf(stderr, "quantization-parameter[3]: %lf:%" PRId8 "\n",
	mlirDenseElementsAttrGetFloatValue(denseScalesAttr, 3),
	mlirDenseElementsAttrGetInt8Value(denseZeroPointsAttr, 3));

	// CHECK: equal: 1
	fprintf(stderr, "equal: %d\n", mlirTypeEqual(subChannel, subChannelParsed));

	// CHECK: !quant.uniform<i8:f32:{0:1, 1:2},
	// {{.*}}2.000000e+00:10, 3.000000e+00:20},
	// {4.000000e+00:30, 5.000000e+00:40{{.*}}}}>
	mlirTypeDump(subChannel);
	fprintf(stderr, "\n\n");
	}

	// CHECK-LABEL: testCalibratedType
	void testCalibratedType(MlirContext ctx) {
	fprintf(stderr, "testCalibratedType\n");

	MlirType calibratedParsed = mlirTypeParseGet(
	ctx,
	mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));

	MlirType f32 = mlirF32TypeGet(ctx);
	MlirType calibrated = mlirCalibratedQuantizedTypeGet(f32, -0.998, 1.2321);

	// CHECK: min: -0.998000
	fprintf(stderr, "min: %lf\n", mlirCalibratedQuantizedTypeGetMin(calibrated));
	// CHECK: max: 1.232100
	fprintf(stderr, "max: %lf\n", mlirCalibratedQuantizedTypeGetMax(calibrated));

	// CHECK: equal: 1
	fprintf(stderr, "equal: %d\n", mlirTypeEqual(calibrated, calibratedParsed));
	// CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>>
	mlirTypeDump(calibrated);
	fprintf(stderr, "\n\n");
	}

	int main(void) {
	MlirContext ctx = mlirContextCreate();
	mlirDialectHandleRegisterDialect(mlirGetDialectHandle__quant__(), ctx);
	testTypeHierarchy(ctx);
	testAnyQuantizedType(ctx);
	testUniformType(ctx);
	testUniformPerAxisType(ctx);
	testUniformSubChannelType(ctx);
	testCalibratedType(ctx);
	mlirContextDestroy(ctx);
	return EXIT_SUCCESS;
	}