Avoid the GRF file out of bound for SVM scatter read write operands

The GRF register + dst/src size of SVM scatter read/write operands may
be out of bound of GRF file.

Author: bcheng0127

visa/G4_IR.cpp

@@ -3510,6 +3510,24 @@ void G4_InstSend::setMsgDesc(G4_SendDesc *in) {
   resetRightBound(srcs[0]);
 }
 
+bool G4_InstSend::isSVMScatterRW() const {
+  SFID funcID = msgDesc->getSFID();
+  const G4_SendDescRaw *desc = getMsgDescRaw();
+  switch (funcID) {
+  case SFID::DP_DC1:
+    switch (desc->getHdcMessageType()) {
+    case DC1_A64_SCATTERED_READ:
+    case DC1_A64_SCATTERED_WRITE:
+      return true;
+    default:
+      break;
+    }
+  default:
+    break;
+  }
+  return false;
+}
+
 bool G4_InstSend::isDirectSplittableSend() const {
   unsigned short elemSize = dst->getElemSize();
   SFID funcID = msgDesc->getSFID();

visa/G4_IR.hpp

@@ -1343,6 +1343,8 @@ class G4_InstSend : public G4_INST {
 
   bool isFence() const { return getMsgDesc()->isFence(); }
 
+  bool isSVMScatterRW() const;
+
   bool isDirectSplittableSend() const;
 
   void computeRightBound(G4_Operand *opnd) override;

visa/GraphColor.cpp

@@ -1862,6 +1862,43 @@ void Interference::markInterferenceForSend(G4_BB *bb, G4_INST *inst,
   }
 }
 
+void Interference::setOutOfBoundForbidden(G4_Operand *opnd) {
+  G4_Declare *dcl = opnd->getBaseRegVarRootDeclare();
+  vISA_ASSERT(dcl, "NULL declare");
+  int dclEndGRF = (dcl->getByteSize() - 1) / builder.numEltPerGRF<Type_UB>();
+  int opndEndGRF = opnd->getLinearizedEnd() / builder.numEltPerGRF<Type_UB>();
+  unsigned lrId = ((G4_RegVar *)opnd->getBase())->getId();
+  LiveRange *lr = lrs[lrId];
+
+  if (lr && (opndEndGRF > dclEndGRF)) {
+    vISA_ASSERT((opndEndGRF - dclEndGRF) == 1,
+                "More register reservation required for svm gather");
+    lr->setForbidden(forbiddenKind::FBD_LASTGRF);
+  }
+}
+
+void Interference::setForbiddenGRFNumForSVMScatter(G4_INST *inst) {
+  G4_DstRegRegion *dst = inst->getDst();
+
+  if (dst && dst->getBase()->isRegVar()) {
+    if (dst->getBase()->isRegAllocPartaker()) {
+      setOutOfBoundForbidden(dst);
+    }
+  }
+
+  for (unsigned j = 0, numSrc = inst->getNumSrc(); j < numSrc; j++) {
+    G4_Operand *src = inst->getSrc(j);
+    if (src && src->isSrcRegRegion() &&
+        src->asSrcRegRegion()->getBase()->isRegVar()) {
+      if (src->asSrcRegRegion()->getBase()->isRegAllocPartaker()) {
+        setOutOfBoundForbidden(src);
+      }
+    }
+  }
+
+  return;
+}
+
 void Interference::markInterferenceToAvoidDstSrcOverlap(G4_BB *bb,
                                                         G4_INST *inst) {
   bool isDstRegAllocPartaker = false;
@@ -2155,6 +2192,11 @@ void Interference::buildInterferenceWithinBB(G4_BB *bb, SparseBitVector &live) {
       }
     }
 
+    if (inst->isSend() && inst->asSendInst()->isSVMScatterRW() &&
+        inst->getExecSize() < g4::SIMD8) {
+      setForbiddenGRFNumForSVMScatter(inst);
+    }
+
     if ((inst->isSend() || inst->isFillIntrinsic()) && !dst->isNullReg() &&
         kernel.fg.builder->WaDisableSendSrcDstOverlap()) {
       markInterferenceForSend(bb, inst, dst);

visa/GraphColor.h

@@ -903,6 +903,10 @@ class Interference {
 
   void markInterferenceForSend(G4_BB *bb, G4_INST *inst, G4_DstRegRegion *dst);
 
+  void setOutOfBoundForbidden(G4_Operand *opnd);
+
+  void setForbiddenGRFNumForSVMScatter(G4_INST *inst);
+
   void buildInterferenceWithLocalRA(G4_BB *bb);
 
   void buildInterferenceAmongLiveOuts();

visa/LocalRA.cpp

@@ -1159,6 +1159,58 @@ void LocalRA::setLexicalID(bool includePseudo) {
   }
 }
 
+void LocalRA::addOutOfBoundForbidden(G4_Declare *dcl, G4_Operand *opnd) {
+  LocalLiveRange *lr = gra.getLocalLR(dcl);
+  if (!lr) {
+    return;
+  }
+
+  int opndEndGRF = opnd->getLinearizedEnd() / builder.numEltPerGRF<Type_UB>();
+  int dclEndGRF = (dcl->getByteSize() - 1) / builder.numEltPerGRF<Type_UB>();
+  if (opndEndGRF > dclEndGRF) {
+    for (int i = 0; i < (opndEndGRF - dclEndGRF); i++) {
+      lr->addForbidden(kernel.getNumRegTotal() - i + 1);
+    }
+  }
+
+  return;
+}
+
+void LocalRA::markSpecialForbidden(INST_LIST_ITER inst_it) {
+  G4_INST *inst = (*inst_it);
+
+  if (!inst->isSend()) {
+    return;
+  }
+
+  if (!inst->asSendInst()->isSVMScatterRW() ||
+      inst->getExecSize() >= g4::SIMD8) {
+    return;
+  }
+
+  G4_DstRegRegion *dst = inst->getDst();
+  if (dst && !dst->isNullReg()) {
+    G4_Declare *dcl = inst->getDst()->getTopDcl();
+    if (dcl) {
+      dcl = dcl->getRootDeclare();
+      addOutOfBoundForbidden(dcl, dst);
+    }
+  }
+
+  for (unsigned i = 0, numSrc = inst->getNumSrc(); i < numSrc; i++) {
+    G4_Operand *src = inst->getSrc(i);
+    if (src) {
+      G4_Declare *dcl = src->getTopDcl();
+      if (dcl) {
+        dcl = dcl->getRootDeclare();
+        addOutOfBoundForbidden(dcl, src);
+      }
+    }
+  }
+
+  return;
+}
+
 void LocalRA::markReferences(unsigned int &numRowsEOT, bool &lifetimeOpFound) {
   unsigned int id = 0;
   // Iterate over all BBs
@@ -1194,6 +1246,7 @@ void LocalRA::markReferences(unsigned int &numRowsEOT, bool &lifetimeOpFound) {
       }
 
       markReferencesInInst(inst_it);
+      markSpecialForbidden(inst_it);
     }
   }
 }

visa/LocalRA.h

@@ -76,6 +76,8 @@ class LocalRA {
   void localRAOptReport();
   void markReferencesInOpnd(G4_Operand *opnd, bool isEOT,
                             INST_LIST_ITER inst_it, unsigned int pos);
+  void addOutOfBoundForbidden(G4_Declare *dcl, G4_Operand *opnd);
+  void markSpecialForbidden(INST_LIST_ITER inst_it);
   void markReferencesInInst(INST_LIST_ITER inst_it);
   void setLexicalID(bool includePseudo);
   void markReferences(unsigned int &numRowsEOT, bool &lifetimeOpFound);