[AIE] Improved format availability check

Author: Martien de Jong

llvm/lib/Target/AIE/AIEBundle.h

@@ -98,8 +98,10 @@ template <class I> class Bundle {
     if (OccupiedSlots & ConflictBits) {
       return false;
     }
-    SlotBits NewSlots = OccupiedSlots | SlotInfo->getSlotSet();
-    return FormatInterface->getPacketFormats().getFormat(NewSlots);
+    const SlotBits NewSlots = OccupiedSlots | SlotInfo->getSlotSet();
+    // Note: Now that we have the conflict bits we may no longer need this
+    // final check, but it is cheap and represents proven technology.
+    return FormatInterface->isFormatAvailable(NewSlots);
   }
 
   /// Add an instruction to the bundle

llvm/lib/Target/AIE/AIEHazardRecognizer.cpp

@@ -139,7 +139,7 @@ bool FuncUnitWrapper::conflict(const FuncUnitWrapper &Other) const {
   // This allows representing a blocked cycle (Slots = ~0) without knowing
   // the slot and format details.
   return Slots && Other.Slots &&
-         !FormatInterface->getPacketFormats().getFormat(Slots | Other.Slots);
+         !FormatInterface->isFormatAvailable(Slots | Other.Slots);
 }
 
 namespace {

llvm/lib/Target/AIE/MCTargetDesc/AIE2MCFormats.cpp

@@ -35,6 +35,10 @@ const MCFormatDesc *AIE2MCFormats::getMCFormats() const {
 
 const PacketFormats &AIE2MCFormats::getPacketFormats() const { return Formats; }
 
+ArrayRef<bool> AIE2MCFormats::getIsFormatAvailable() const {
+  return FormatAvailable;
+}
+
 SmallVector<MCSlotKind, 2> AIE2MCFormats::getLoadSlotKinds() const {
   return {MCSlotKind::AIE2_SLOT_LDB, MCSlotKind::AIE2_SLOT_LDA};
 }

llvm/lib/Target/AIE/MCTargetDesc/AIEBaseMCFormats.cpp

@@ -58,6 +58,11 @@ bool AIEBaseMCFormats::isSupportedInstruction(unsigned int Opcode) const {
   return getFormatDescIndex(Opcode) ? true : false;
 }
 
+bool AIEBaseMCFormats::isFormatAvailable(uint64_t SlotSet) const {
+  ArrayRef<bool> IsFormatsAvailable = getIsFormatAvailable();
+  return SlotSet < IsFormatsAvailable.size() && IsFormatsAvailable[SlotSet];
+}
+
 const MCSlotKind AIEBaseMCFormats::getSlotKind(unsigned int Opcode) const {
   // First, we check that the instruction has a format defined.
   // Some KILLs instructions are still in the pipeline for example...

llvm/lib/Target/AIE/MCTargetDesc/AIEMCFormats.cpp

@@ -62,4 +62,8 @@ const MCFormatDesc *AIEMCFormats::getMCFormats() const { return AIE::Formats; }
 
 const PacketFormats &AIEMCFormats::getPacketFormats() const { return Formats; }
 
+ArrayRef<bool> AIEMCFormats::getIsFormatAvailable() const {
+  return FormatAvailable;
+}
+
 } // end namespace llvm

llvm/lib/Target/AIE/MCTargetDesc/AIEMCFormats.h

@@ -389,11 +389,15 @@ class AIEBaseMCFormats {
 
   virtual const PacketFormats &getPacketFormats() const = 0;
 
+  virtual ArrayRef<bool> getIsFormatAvailable() const = 0;
+
   // \return all Slots that correspond to the load instructions
   virtual SmallVector<MCSlotKind, 2> getLoadSlotKinds() const {
     llvm_unreachable("Target didn't implement getLoadSlotKinds()");
   }
 
+  bool isFormatAvailable(uint64_t SlotSet) const;
+
 protected:
   /// Check if the Instruction is indeed into the Tables.
   void checkInstructionIsSupported(unsigned int Opcode) const;
@@ -407,6 +411,7 @@ class AIEMCFormats : public AIEBaseMCFormats {
   getFormatDescIndex(unsigned int Opcode) const override;
   const MCSlotInfo *getSlotInfo(const MCSlotKind Kind) const override;
   const MCFormatDesc *getMCFormats() const override;
+  ArrayRef<bool> getIsFormatAvailable() const override;
   const PacketFormats &getPacketFormats() const override;
 };
 
@@ -419,6 +424,7 @@ class AIE2MCFormats : public AIEBaseMCFormats {
   const MCSlotInfo *getSlotInfo(const MCSlotKind Kind) const override;
   const MCFormatDesc *getMCFormats() const override;
   const PacketFormats &getPacketFormats() const override;
+  ArrayRef<bool> getIsFormatAvailable() const override;
   SmallVector<MCSlotKind, 2> getLoadSlotKinds() const override;
 };
 
@@ -431,6 +437,7 @@ class AIE2PMCFormats : public AIEBaseMCFormats {
   const MCSlotInfo *getSlotInfo(const MCSlotKind Kind) const override;
   const MCFormatDesc *getMCFormats() const override;
   const PacketFormats &getPacketFormats() const override;
+  ArrayRef<bool> getIsFormatAvailable() const override;
   SmallVector<MCSlotKind, 2> getLoadSlotKinds() const override;
 };
 

llvm/lib/Target/AIE/MCTargetDesc/aie2p/AIE2PMCFormats.cpp

@@ -37,6 +37,10 @@ const PacketFormats &AIE2PMCFormats::getPacketFormats() const {
   return Formats;
 }
 
+ArrayRef<bool> AIE2PMCFormats::getIsFormatAvailable() const {
+  return FormatAvailable;
+}
+
 SmallVector<MCSlotKind, 2> AIE2PMCFormats::getLoadSlotKinds() const {
   return {MCSlotKind::AIE2P_SLOT_LDB, MCSlotKind::AIE2P_SLOT_LDA};
 }

llvm/unittests/Target/AIE/BundleTest.cpp

@@ -99,6 +99,9 @@ class MockMCFormats : public AIEBaseMCFormats {
   const MCFormatDesc *getMCFormats() const override {
     llvm_unreachable("Un-implemented");
   }
+  ArrayRef<bool> getIsFormatAvailable() const override {
+    llvm_unreachable("Un-implemented");
+  }
 };
 
 class MockTII : public AIEInstrInfo {

llvm/utils/TableGen/CodeGenFormat.cpp

@@ -240,6 +240,43 @@ void CodeGenFormat::run(raw_ostream &o) {
       o << SlotData << FormatData
         << "static const PacketFormats Formats {FormatData};\n\n";
 
+      // Create an O(1) function of available formats by ticking them in
+      // a lookup table;
+      uint64_t MaxSlotSet = 0;
+      for (const TGInstrLayout *Packet : Packets) {
+        MaxSlotSet = std::max(MaxSlotSet, Packet->getSlotSet());
+      }
+      const size_t Size = MaxSlotSet + 1;
+      // Catering for 16 slots for now, just to check the logic.
+      assert(Size <= 65536);
+      std::vector<bool> LUT(Size, false);
+      // First the trivial ones, without nops.
+      for (const TGInstrLayout *Packet : Packets) {
+        LUT[Packet->getSlotSet()] = true;
+      }
+      // Then the remaining ones
+      for (uint64_t SlotSet = 0; SlotSet < Size; SlotSet++) {
+        if (LUT[SlotSet]) {
+          continue;
+        }
+        // We start with the largest packets, since they cover more.
+        for (const TGInstrLayout *Packet : reverse(Packets)) {
+          // If the packet clears all bits of SlotSet, it can hold all these
+          // slots. Slots that are not present in SlotSet can be filled
+          // with nops.
+          if ((SlotSet & ~Packet->getSlotSet()) == 0) {
+            LUT[SlotSet] = true;
+            break;
+          }
+        }
+      }
+      o << "const size_t SlotSetSize = " << Size << ";\n";
+      o << "static const bool FormatAvailable[SlotSetSize] = {\n";
+      for (size_t Index = 0; Index < Size; Index++) {
+        o << "\t/* " << Index << " */ " << LUT[Index] << ",\n";
+      }
+      o << "};\n";
+
       o << "#endif // GET_FORMATS_PACKETS_TABLE\n\n";
     }
   }