extend VC type size wrapper with strict size calculation

In some situations we'd like to ensure that the type size can be represented
in the specified units of measurements exactly.

Author: aparshin-intel

IGC/VectorCompiler/include/vc/Utils/GenX/TypeSize.h

@@ -57,17 +57,30 @@ class TypeSizeWrapper {
   TypeSizeWrapper(uint64_t TSIn) : TS{FixedDLSize(TSIn)} {};
 #endif
 
-  SzType inBits() const { return asIntegral<1>(); }
-  SzType inBytes() const { return asIntegral<ByteBits>(); }
-  SzType inWords() const { return asIntegral<WordBits>(); }
-  SzType inDWords() const { return asIntegral<DWordBits>(); }
-  SzType inQWords() const { return asIntegral<QWordBits>(); }
-  SzType inOWords() const { return asIntegral<OWordBits>(); }
+  SzType inBytesCeil() const { return asIntegralCeil<ByteBits>(); }
+  SzType inWordsCeil() const { return asIntegralCeil<WordBits>(); }
+  SzType inDWordsCeil() const { return asIntegralCeil<DWordBits>(); }
+  SzType inQWordsCeil() const { return asIntegralCeil<QWordBits>(); }
+  SzType inOWordsCeil() const { return asIntegralCeil<OWordBits>(); }
+
+  SzType inBits() const { return asIntegralStrict<1>(); }
+  SzType inBytes() const { return asIntegralStrict<ByteBits>(); }
+  SzType inWords() const { return asIntegralStrict<WordBits>(); }
+  SzType inDWords() const { return asIntegralStrict<DWordBits>(); }
+  SzType inQWords() const { return asIntegralStrict<QWordBits>(); }
+  SzType inOWords() const { return asIntegralStrict<OWordBits>(); }
 
   bool operator==(const TypeSizeWrapper &Other) const { return TS == Other.TS; }
 
 private:
-  template <unsigned UnitBitSize> SzType asIntegral() const {
+  template <unsigned UnitBitSize> SzType asIntegralStrict() const {
+    return asIntegral<UnitBitSize, true>();
+  }
+  template <unsigned UnitBitSize> SzType asIntegralCeil() const {
+    return asIntegral<UnitBitSize, false>();
+  }
+
+  template <unsigned UnitBitSize, bool Strict> SzType asIntegral() const {
 #if LLVM_VERSION_MAJOR >= 10
     IGC_ASSERT(!TS.isScalable());
     uint64_t BitsAsUI = TS.getFixedSize();
@@ -77,7 +90,13 @@ class TypeSizeWrapper {
     IGC_ASSERT_MESSAGE(BitsAsUI <= std::numeric_limits<SzType>::max(),
                        "Type is too large to operate on");
     IGC_ASSERT_MESSAGE(BitsAsUI > 0, "Could not determine size of Type");
-    return static_cast<SzType>(llvm::divideCeil(BitsAsUI, UnitBitSize));
+    if constexpr (Strict) {
+      IGC_ASSERT_MESSAGE(BitsAsUI % UnitBitSize == 0,
+          "Type size in bits cannot be represented in requested units exactly");
+      return BitsAsUI / UnitBitSize;
+    } else {
+      return static_cast<SzType>(llvm::divideCeil(BitsAsUI, UnitBitSize));
+    }
   }
   DLTypeSize TS;
 };

IGC/VectorCompiler/lib/GenXCodeGen/GenXCoalescing.cpp

@@ -829,7 +829,7 @@ unsigned GenXCoalescing::getPriority(Type *Ty, BasicBlock *BB) const
   constexpr unsigned LoopScale = 4;
 
   // Estimate number of moves required for this type.
-  unsigned VecWidth = vc::getTypeSize(Ty, DL).inBytes();
+  unsigned VecWidth = vc::getTypeSize(Ty, DL).inBytesCeil();
   unsigned Priority = VecWidth / ST->getGRFByteSize() +
     countPopulation(VecWidth % ST->getGRFByteSize());
   // Scale by loop depth.

IGC/VectorCompiler/lib/GenXCodeGen/GenXPressureTracker.cpp

@@ -38,7 +38,7 @@ unsigned PressureTracker::getSizeInBytes(LiveRange *LR, bool AllowWidening) {
   SimpleValue SV = *LR->value_begin();
   Value *V = SV.getValue();
   Type *Ty = IndexFlattener::getElementType(V->getType(), SV.getIndex());
-  unsigned Bytes = vc::getTypeSize(Ty, &DL).inWords() * WordBytes;
+  unsigned Bytes = vc::getTypeSize(Ty, &DL).inWordsCeil() * WordBytes;
   if (!AllowWidening)
     return Bytes;
 

IGC/VectorCompiler/lib/GenXCodeGen/GenXVisaRegAlloc.cpp

@@ -859,7 +859,7 @@ void GenXVisaRegAlloc::print(raw_ostream &OS, const FunctionGroup *FG) const {
     }
     Type *ElTy = IndexFlattener::getElementType(SV.getValue()->getType(),
           SV.getIndex());
-    unsigned Bytes = vc::getTypeSize(ElTy).inWords() * WordBytes;
+    unsigned Bytes = vc::getTypeSize(ElTy).inBytes();
     bool IsFlag = ElTy->getScalarType()->isIntegerTy(1);
     OS << "] (" << Bytes << " bytes, length " << i->Length <<") ";
     // Dump some indication of what the live range is. For a kernel argument,