fix comment

Author: zhczhong

include/gc/Analysis/TargetDescriptionAnalysis.h

@@ -71,16 +71,13 @@ class CPUTargetDescriptionAnalysis : public TargetDescriptionAnalysisBase {
   static constexpr StringLiteral kNumThreads = "num_threads";
 
   // get runtime OMP_NUM_THREADS
-  size_t getNumThreads();
+  unsigned getNumThreads();
 
   // get cache size by cacheLevel
-  size_t getCacheSize(uint8_t cacheLevel);
+  unsigned getCacheSize(uint8_t cacheLevel);
 
   // get the maximum vector length in bits
-  size_t getMaxVectorWidth();
-
-  // get the default value map(attr key, default value)
-  static llvm::DenseMap<StringRef, int64_t> CPUTargetDeafultValueMap;
+  unsigned getMaxVectorWidth();
 
   CPUTargetDescriptionAnalysis(Operation *op)
       : TargetDescriptionAnalysisBase(op, DeviceType::CPU) {}

lib/gc/Analysis/TargetDescriptionAnalysis.cpp

@@ -21,16 +21,6 @@ llvm::DenseMap<DeviceType, std::string>
         {CPU, "CPU"},
 };
 
-// default values for properties
-llvm::DenseMap<StringRef, int64_t>
-    CPUTargetDescriptionAnalysis::CPUTargetDeafultValueMap = {
-        {CPUTargetDescriptionAnalysis::kNumThreads, 1},
-        {CPUTargetDescriptionAnalysis::kL1CacheSize, 32 * 1024},
-        {CPUTargetDescriptionAnalysis::kL2CacheSize, 1024 * 1024},
-        {CPUTargetDescriptionAnalysis::kL3CacheSize, 32 * 1024 * 1024},
-        {CPUTargetDescriptionAnalysis::kMaxVectorWidth, 512},
-};
-
 template <typename T>
 void TargetDescriptionAnalysisBase::emitNotFoundWarning(Location loc,
                                                         StringRef key,
@@ -66,18 +56,23 @@ TargetDescriptionAnalysisBase::getPropertyValue(StringRef key) {
       Builder(getContext()).getStringAttr(key));
 }
 
-size_t CPUTargetDescriptionAnalysis::getNumThreads() {
+unsigned CPUTargetDescriptionAnalysis::getNumThreads() {
+  static const unsigned defaultNumThreads = 1;
   std::optional<Attribute> numThreads = getPropertyValue(kNumThreads);
 
   if (numThreads)
     return getIntFromAttribute(*numThreads);
-  emitNotFoundWarning(getLocation(), kNumThreads,
-                      CPUTargetDeafultValueMap[kNumThreads]);
-  return CPUTargetDeafultValueMap[kNumThreads];
+  emitNotFoundWarning(getLocation(), kNumThreads, defaultNumThreads);
+  return defaultNumThreads;
 }
 
-size_t CPUTargetDescriptionAnalysis::getCacheSize(uint8_t cacheLevel) {
+unsigned CPUTargetDescriptionAnalysis::getCacheSize(uint8_t cacheLevel) {
   assert(cacheLevel > 0 && cacheLevel < 4 && "Invalid cache level");
+  llvm::DenseMap<StringRef, unsigned> CPUTargetCacheSizeValueMap = {
+      {CPUTargetDescriptionAnalysis::kL1CacheSize, 32 * 1024},
+      {CPUTargetDescriptionAnalysis::kL2CacheSize, 1024 * 1024},
+      {CPUTargetDescriptionAnalysis::kL3CacheSize, 32 * 1024 * 1024},
+  };
   StringLiteral key = "";
   if (cacheLevel == 1)
     key = kL1CacheSize;
@@ -90,17 +85,17 @@ size_t CPUTargetDescriptionAnalysis::getCacheSize(uint8_t cacheLevel) {
   if (cacheSize)
     return getIntFromAttribute(*cacheSize);
 
-  emitNotFoundWarning(getLocation(), key, CPUTargetDeafultValueMap[key]);
-  return CPUTargetDeafultValueMap[key];
+  emitNotFoundWarning(getLocation(), key, CPUTargetCacheSizeValueMap[key]);
+  return CPUTargetCacheSizeValueMap[key];
 }
 
-size_t CPUTargetDescriptionAnalysis::getMaxVectorWidth() {
+unsigned CPUTargetDescriptionAnalysis::getMaxVectorWidth() {
+  static const unsigned defaultMaxVectorWidth = 512;
   std::optional<Attribute> maxVectorWidth = getPropertyValue(kMaxVectorWidth);
   if (maxVectorWidth)
     return getIntFromAttribute(*maxVectorWidth);
-  emitNotFoundWarning(getLocation(), kMaxVectorWidth,
-                      CPUTargetDeafultValueMap[kMaxVectorWidth]);
-  return CPUTargetDeafultValueMap[kMaxVectorWidth];
+  emitNotFoundWarning(getLocation(), kMaxVectorWidth, defaultMaxVectorWidth);
+  return defaultMaxVectorWidth;
 }
 
 } // namespace gc

lib/gc/Transforms/Pipeline.cpp

@@ -133,6 +133,8 @@ void populateLLVMPasses(mlir::OpPassManager &pm) {
 }
 
 void populateCPUPipeline(mlir::OpPassManager &pm) {
+  // verify the target description attribute
+  pm.addNestedPass<func::FuncOp>(createVerifyTargetDescription());
   // front-end, oneDNN graph dialect
   populateFrontendPasses(pm);
   // middle-end, LinalgX/Linalg/tensor dialects

lib/gc/Transforms/VerifyTargetDescription.cpp

@@ -27,68 +27,43 @@ static LogicalResult verifyCPUTargetDescription(RewriterBase &rewriter,
   Location loc = op->getLoc();
 
   // Check if the num_threads is existed and greater than 0
-  std::optional<Attribute> numThreadsAttr =
-      cpuTargetDesc.getPropertyValue(CPUTargetDescriptionAnalysis::kNumThreads);
-  if (numThreadsAttr) {
-    if (!isa<IntegerAttr>(*numThreadsAttr) ||
-        cpuTargetDesc.getNumThreads() < 1) {
-      mlir::emitError(loc)
-          << "num_threads must be a greater than 0 integer, but get "
-          << *numThreadsAttr;
-      return failure();
-    }
+  if (cpuTargetDesc.getNumThreads() < 1) {
+    mlir::emitError(loc)
+        << "num_threads must be a greater than 0 integer, but get "
+        << cpuTargetDesc.getNumThreads();
+    return failure();
   }
 
   // Check if the L1 cache size is existed and greater than 0
-  std::optional<Attribute> l1CacheSizeAttr = cpuTargetDesc.getPropertyValue(
-      CPUTargetDescriptionAnalysis::kL1CacheSize);
-  if (l1CacheSizeAttr) {
-    if (!isa<IntegerAttr>(*l1CacheSizeAttr) ||
-        cpuTargetDesc.getCacheSize(1) < 1) {
-      mlir::emitError(loc)
-          << "L1_cache_size_in_bytes must be a greater than 0 integer, but get "
-          << *l1CacheSizeAttr;
-      return failure();
-    }
+  if (cpuTargetDesc.getCacheSize(1) < 1) {
+    mlir::emitError(loc)
+        << "L1_cache_size_in_bytes must be a greater than 0 integer, but get "
+        << cpuTargetDesc.getCacheSize(1);
+    return failure();
   }
 
   // Check if the L2 cache size is existed and greater than 0
-  std::optional<Attribute> l2CacheSizeAttr = cpuTargetDesc.getPropertyValue(
-      CPUTargetDescriptionAnalysis::kL2CacheSize);
-  if (l2CacheSizeAttr) {
-    if (!isa<IntegerAttr>(*l2CacheSizeAttr) ||
-        cpuTargetDesc.getCacheSize(2) < 1) {
-      mlir::emitError(loc)
-          << "L2_cache_size_in_bytes must be a greater than 0 integer, but get "
-          << *l2CacheSizeAttr;
-      return failure();
-    }
+  if (cpuTargetDesc.getCacheSize(2) < 1) {
+    mlir::emitError(loc)
+        << "L2_cache_size_in_bytes must be a greater than 0 integer, but get "
+        << cpuTargetDesc.getCacheSize(2);
+    return failure();
   }
 
   // Check if the L3 cache size is existed and greater than 0
-  std::optional<Attribute> l3CacheSizeAttr = cpuTargetDesc.getPropertyValue(
-      CPUTargetDescriptionAnalysis::kL3CacheSize);
-  if (l3CacheSizeAttr) {
-    if (!isa<IntegerAttr>(*l3CacheSizeAttr) ||
-        cpuTargetDesc.getCacheSize(3) < 1) {
-      mlir::emitError(loc)
-          << "L3_cache_size_in_bytes must be a greater than 0 integer, but get "
-          << *l3CacheSizeAttr;
-      return failure();
-    }
+  if (cpuTargetDesc.getCacheSize(3) < 1) {
+    mlir::emitError(loc)
+        << "L3_cache_size_in_bytes must be a greater than 0 integer, but get "
+        << cpuTargetDesc.getCacheSize(3);
+    return failure();
   }
 
   // Check if the max_vector_width is existed and greater than 0
-  std::optional<Attribute> maxVectorWidthAttr = cpuTargetDesc.getPropertyValue(
-      CPUTargetDescriptionAnalysis::kMaxVectorWidth);
-  if (maxVectorWidthAttr) {
-    if (!isa<IntegerAttr>(*maxVectorWidthAttr) ||
-        cpuTargetDesc.getMaxVectorWidth() < 1) {
-      mlir::emitError(loc)
-          << "max_vector_width must be a greater than 0 integer, but get "
-          << *maxVectorWidthAttr;
-      return failure();
-    }
+  if (cpuTargetDesc.getMaxVectorWidth() < 1) {
+    mlir::emitError(loc)
+        << "max_vector_width must be a greater than 0 integer, but get "
+        << cpuTargetDesc.getMaxVectorWidth();
+    return failure();
   }
   return success();
 }