mlir/test/CAPI/quant.c

   1 //===- quant.c - Test of Quant dialect C API ------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM
   4 // Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // RUN: mlir-capi-quant-test 2>&1 | FileCheck %s
  11
  12 #include "mlir-c/Dialect/Quant.h"
  13 #include "mlir-c/BuiltinTypes.h"
  14 #include "mlir-c/IR.h"
  15
  16 #include <assert.h>
  17 #include <inttypes.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20
  21 // CHECK-LABEL: testTypeHierarchy
  22 static void testTypeHierarchy(MlirContext ctx) {
  23   fprintf(stderr, "testTypeHierarchy\n");
  24
  25   MlirType i8 = mlirIntegerTypeGet(ctx, 8);
  26   MlirType any = mlirTypeParseGet(
  27       ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));
  28   MlirType uniform =
  29       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(
  30                                 "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));
  31   MlirType perAxis = mlirTypeParseGet(
  32       ctx, mlirStringRefCreateFromCString(
  33                "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));
  34   MlirType calibrated = mlirTypeParseGet(
  35       ctx,
  36       mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));
  37
  38   // The parser itself is checked in C++ dialect tests.
  39   assert(!mlirTypeIsNull(any) && "couldn't parse AnyQuantizedType");
  40   assert(!mlirTypeIsNull(uniform) && "couldn't parse UniformQuantizedType");
  41   assert(!mlirTypeIsNull(perAxis) &&
  42          "couldn't parse UniformQuantizedPerAxisType");
  43   assert(!mlirTypeIsNull(calibrated) &&
  44          "couldn't parse CalibratedQuantizedType");
  45
  46   // CHECK: i8 isa QuantizedType: 0
  47   fprintf(stderr, "i8 isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(i8));
  48   // CHECK: any isa QuantizedType: 1
  49   fprintf(stderr, "any isa QuantizedType: %d\n", mlirTypeIsAQuantizedType(any));
  50   // CHECK: uniform isa QuantizedType: 1
  51   fprintf(stderr, "uniform isa QuantizedType: %d\n",
  52           mlirTypeIsAQuantizedType(uniform));
  53   // CHECK: perAxis isa QuantizedType: 1
  54   fprintf(stderr, "perAxis isa QuantizedType: %d\n",
  55           mlirTypeIsAQuantizedType(perAxis));
  56   // CHECK: calibrated isa QuantizedType: 1
  57   fprintf(stderr, "calibrated isa QuantizedType: %d\n",
  58           mlirTypeIsAQuantizedType(calibrated));
  59
  60   // CHECK: any isa AnyQuantizedType: 1
  61   fprintf(stderr, "any isa AnyQuantizedType: %d\n",
  62           mlirTypeIsAAnyQuantizedType(any));
  63   // CHECK: uniform isa UniformQuantizedType: 1
  64   fprintf(stderr, "uniform isa UniformQuantizedType: %d\n",
  65           mlirTypeIsAUniformQuantizedType(uniform));
  66   // CHECK: perAxis isa UniformQuantizedPerAxisType: 1
  67   fprintf(stderr, "perAxis isa UniformQuantizedPerAxisType: %d\n",
  68           mlirTypeIsAUniformQuantizedPerAxisType(perAxis));
  69   // CHECK: calibrated isa CalibratedQuantizedType: 1
  70   fprintf(stderr, "calibrated isa CalibratedQuantizedType: %d\n",
  71           mlirTypeIsACalibratedQuantizedType(calibrated));
  72
  73   // CHECK: perAxis isa UniformQuantizedType: 0
  74   fprintf(stderr, "perAxis isa UniformQuantizedType: %d\n",
  75           mlirTypeIsAUniformQuantizedType(perAxis));
  76   // CHECK: uniform isa CalibratedQuantizedType: 0
  77   fprintf(stderr, "uniform isa CalibratedQuantizedType: %d\n",
  78           mlirTypeIsACalibratedQuantizedType(uniform));
  79   fprintf(stderr, "\n");
  80 }
  81
  82 // CHECK-LABEL: testAnyQuantizedType
  83 void testAnyQuantizedType(MlirContext ctx) {
  84   fprintf(stderr, "testAnyQuantizedType\n");
  85
  86   MlirType anyParsed = mlirTypeParseGet(
  87       ctx, mlirStringRefCreateFromCString("!quant.any<i8<-8:7>:f32>"));
  88
  89   MlirType i8 = mlirIntegerTypeGet(ctx, 8);
  90   MlirType f32 = mlirF32TypeGet(ctx);
  91   MlirType any =
  92       mlirAnyQuantizedTypeGet(mlirQuantizedTypeGetSignedFlag(), i8, f32, -8, 7);
  93
  94   // CHECK: flags: 1
  95   fprintf(stderr, "flags: %u\n", mlirQuantizedTypeGetFlags(any));
  96   // CHECK: signed: 1
  97   fprintf(stderr, "signed: %u\n", mlirQuantizedTypeIsSigned(any));
  98   // CHECK: storage type: i8
  99   fprintf(stderr, "storage type: ");
 100   mlirTypeDump(mlirQuantizedTypeGetStorageType(any));
 101   fprintf(stderr, "\n");
 102   // CHECK: expressed type: f32
 103   fprintf(stderr, "expressed type: ");
 104   mlirTypeDump(mlirQuantizedTypeGetExpressedType(any));
 105   fprintf(stderr, "\n");
 106   // CHECK: storage min: -8
 107   fprintf(stderr, "storage min: %" PRId64 "\n",
 108           mlirQuantizedTypeGetStorageTypeMin(any));
 109   // CHECK: storage max: 7
 110   fprintf(stderr, "storage max: %" PRId64 "\n",
 111           mlirQuantizedTypeGetStorageTypeMax(any));
 112   // CHECK: storage width: 8
 113   fprintf(stderr, "storage width: %u\n",
 114           mlirQuantizedTypeGetStorageTypeIntegralWidth(any));
 115   // CHECK: quantized element type: !quant.any<i8<-8:7>:f32>
 116   fprintf(stderr, "quantized element type: ");
 117   mlirTypeDump(mlirQuantizedTypeGetQuantizedElementType(any));
 118   fprintf(stderr, "\n");
 119
 120   // CHECK: equal: 1
 121   fprintf(stderr, "equal: %d\n", mlirTypeEqual(anyParsed, any));
 122   // CHECK: !quant.any<i8<-8:7>:f32>
 123   mlirTypeDump(any);
 124   fprintf(stderr, "\n\n");
 125 }
 126
 127 // CHECK-LABEL: testUniformType
 128 void testUniformType(MlirContext ctx) {
 129   fprintf(stderr, "testUniformType\n");
 130
 131   MlirType uniformParsed =
 132       mlirTypeParseGet(ctx, mlirStringRefCreateFromCString(
 133                                 "!quant.uniform<i8<-8:7>:f32, 0.99872:127>"));
 134
 135   MlirType i8 = mlirIntegerTypeGet(ctx, 8);
 136   MlirType f32 = mlirF32TypeGet(ctx);
 137   MlirType uniform = mlirUniformQuantizedTypeGet(
 138       mlirQuantizedTypeGetSignedFlag(), i8, f32, 0.99872, 127, -8, 7);
 139
 140   // CHECK: scale: 0.998720
 141   fprintf(stderr, "scale: %lf\n", mlirUniformQuantizedTypeGetScale(uniform));
 142   // CHECK: zero point: 127
 143   fprintf(stderr, "zero point: %" PRId64 "\n",
 144           mlirUniformQuantizedTypeGetZeroPoint(uniform));
 145   // CHECK: fixed point: 0
 146   fprintf(stderr, "fixed point: %d\n",
 147           mlirUniformQuantizedTypeIsFixedPoint(uniform));
 148
 149   // CHECK: equal: 1
 150   fprintf(stderr, "equal: %d\n", mlirTypeEqual(uniform, uniformParsed));
 151   // CHECK: !quant.uniform<i8<-8:7>:f32, 9.987200e-01:127>
 152   mlirTypeDump(uniform);
 153   fprintf(stderr, "\n\n");
 154 }
 155
 156 // CHECK-LABEL: testUniformPerAxisType
 157 void testUniformPerAxisType(MlirContext ctx) {
 158   fprintf(stderr, "testUniformPerAxisType\n");
 159
 160   MlirType perAxisParsed = mlirTypeParseGet(
 161       ctx, mlirStringRefCreateFromCString(
 162                "!quant.uniform<i8:f32:1, {2.0e+2,0.99872:120}>"));
 163
 164   MlirType i8 = mlirIntegerTypeGet(ctx, 8);
 165   MlirType f32 = mlirF32TypeGet(ctx);
 166   double scales[] = {200.0, 0.99872};
 167   int64_t zeroPoints[] = {0, 120};
 168   MlirType perAxis = mlirUniformQuantizedPerAxisTypeGet(
 169       mlirQuantizedTypeGetSignedFlag(), i8, f32,
 170       /*nDims=*/2, scales, zeroPoints,
 171       /*quantizedDimension=*/1,
 172       mlirQuantizedTypeGetDefaultMinimumForInteger(/*isSigned=*/true,
 173                                                    /*integralWidth=*/8),
 174       mlirQuantizedTypeGetDefaultMaximumForInteger(/*isSigned=*/true,
 175                                                    /*integralWidth=*/8));
 176
 177   // CHECK: num dims: 2
 178   fprintf(stderr, "num dims: %" PRIdPTR "\n",
 179           mlirUniformQuantizedPerAxisTypeGetNumDims(perAxis));
 180   // CHECK: scale 0: 200.000000
 181   fprintf(stderr, "scale 0: %lf\n",
 182           mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 0));
 183   // CHECK: scale 1: 0.998720
 184   fprintf(stderr, "scale 1: %lf\n",
 185           mlirUniformQuantizedPerAxisTypeGetScale(perAxis, 1));
 186   // CHECK: zero point 0: 0
 187   fprintf(stderr, "zero point 0: %" PRId64 "\n",
 188           mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 0));
 189   // CHECK: zero point 1: 120
 190   fprintf(stderr, "zero point 1: %" PRId64 "\n",
 191           mlirUniformQuantizedPerAxisTypeGetZeroPoint(perAxis, 1));
 192   // CHECK: quantized dim: 1
 193   fprintf(stderr, "quantized dim: %" PRId32 "\n",
 194           mlirUniformQuantizedPerAxisTypeGetQuantizedDimension(perAxis));
 195   // CHECK: fixed point: 0
 196   fprintf(stderr, "fixed point: %d\n",
 197           mlirUniformQuantizedPerAxisTypeIsFixedPoint(perAxis));
 198
 199   // CHECK: equal: 1
 200   fprintf(stderr, "equal: %d\n", mlirTypeEqual(perAxis, perAxisParsed));
 201   // CHECK: !quant.uniform<i8:f32:1, {2.000000e+02,9.987200e-01:120}>
 202   mlirTypeDump(perAxis);
 203   fprintf(stderr, "\n\n");
 204 }
 205
 206 // CHECK-LABEL: testCalibratedType
 207 void testCalibratedType(MlirContext ctx) {
 208   fprintf(stderr, "testCalibratedType\n");
 209
 210   MlirType calibratedParsed = mlirTypeParseGet(
 211       ctx,
 212       mlirStringRefCreateFromCString("!quant.calibrated<f32<-0.998:1.2321>>"));
 213
 214   MlirType f32 = mlirF32TypeGet(ctx);
 215   MlirType calibrated = mlirCalibratedQuantizedTypeGet(f32, -0.998, 1.2321);
 216
 217   // CHECK: min: -0.998000
 218   fprintf(stderr, "min: %lf\n", mlirCalibratedQuantizedTypeGetMin(calibrated));
 219   // CHECK: max: 1.232100
 220   fprintf(stderr, "max: %lf\n", mlirCalibratedQuantizedTypeGetMax(calibrated));
 221
 222   // CHECK: equal: 1
 223   fprintf(stderr, "equal: %d\n", mlirTypeEqual(calibrated, calibratedParsed));
 224   // CHECK: !quant.calibrated<f32<-0.998:1.232100e+00>>
 225   mlirTypeDump(calibrated);
 226   fprintf(stderr, "\n\n");
 227 }
 228
 229 int main(void) {
 230   MlirContext ctx = mlirContextCreate();
 231   mlirDialectHandleRegisterDialect(mlirGetDialectHandle__quant__(), ctx);
 232   testTypeHierarchy(ctx);
 233   testAnyQuantizedType(ctx);
 234   testUniformType(ctx);
 235   testUniformPerAxisType(ctx);
 236   testCalibratedType(ctx);
 237   mlirContextDestroy(ctx);
 238   return EXIT_SUCCESS;
 239 }