[SER] 'reordercoherent' HLSL attribute and DXIL encoding

Specification: https://github.com/microsoft/hlsl-specs/blob/main/proposals/0027-shader-execution-reordering.md

'reordercoherent' encoding hlsl-specs PR: microsoft/hlsl-specs#453

DXC SER implementation tracker: #7214

Author: simoll

include/dxc/DXIL/DxilMetadataHelper.h

@@ -233,6 +233,7 @@ class DxilMDHelper {
   static const unsigned kDxilStructuredBufferElementStrideTag = 1;
   static const unsigned kDxilSamplerFeedbackKindTag = 2;
   static const unsigned kDxilAtomic64UseTag = 3;
+  static const unsigned kDxilReorderCoherentTag = 4;
 
   // Type system.
   static const char kDxilTypeSystemMDName[];

include/dxc/DXIL/DxilResource.h

@@ -63,6 +63,8 @@ class DxilResource : public DxilResourceBase {
 
   bool IsGloballyCoherent() const;
   void SetGloballyCoherent(bool b);
+  bool IsReorderCoherent() const;
+  void SetReorderCoherent(bool b);
   bool HasCounter() const;
   void SetHasCounter(bool b);
 
@@ -97,6 +99,7 @@ class DxilResource : public DxilResourceBase {
   CompType m_CompType;
   DXIL::SamplerFeedbackType m_SamplerFeedbackType;
   bool m_bGloballyCoherent;
+  bool m_bReorderCoherent;
   bool m_bHasCounter;
   bool m_bROV;
   bool m_bHasAtomic64Use;

include/dxc/DXIL/DxilResourceProperties.h

@@ -47,7 +47,8 @@ struct DxilResourceProperties {
     uint8_t SamplerCmpOrHasCounter : 1;
 
     // BYTE 2
-    uint8_t Reserved2;
+    uint8_t IsReorderCoherent : 1;
+    uint8_t Reserved2 : 7;
 
     // BYTE 3
     uint8_t Reserved3;

include/dxc/DxilContainer/RDAT_LibraryTypes.inl

@@ -22,6 +22,7 @@ RDAT_ENUM_START(DxilResourceFlag, uint32_t)
   RDAT_ENUM_VALUE(UAVRasterizerOrderedView, 1 << 2)
   RDAT_ENUM_VALUE(DynamicIndexing,          1 << 3)
   RDAT_ENUM_VALUE(Atomics64Use,             1 << 4)
+  RDAT_ENUM_VALUE(UAVReorderCoherent,       1 << 5)
 RDAT_ENUM_END()
 
 RDAT_ENUM_START(DxilShaderStageFlags, uint32_t)

lib/DXIL/DxilMetadataHelper.cpp

@@ -3099,6 +3099,13 @@ void DxilExtraPropertyHelper::EmitUAVProperties(
         DxilMDHelper::kDxilAtomic64UseTag, m_Ctx));
     MDVals.emplace_back(DxilMDHelper::Uint32ToConstMD((unsigned)true, m_Ctx));
   }
+  // Whether resource is reordercoherent.
+  if (DXIL::CompareVersions(m_ValMajor, m_ValMinor, 1, 9) >= 0 &&
+      UAV.IsReorderCoherent()) {
+    MDVals.emplace_back(DxilMDHelper::Uint32ToConstMD(
+        DxilMDHelper::kDxilReorderCoherentTag, m_Ctx));
+    MDVals.emplace_back(DxilMDHelper::BoolToConstMD(true, m_Ctx));
+  }
 }
 
 void DxilExtraPropertyHelper::LoadUAVProperties(const MDOperand &MDO,
@@ -3136,6 +3143,9 @@ void DxilExtraPropertyHelper::LoadUAVProperties(const MDOperand &MDO,
     case DxilMDHelper::kDxilAtomic64UseTag:
       UAV.SetHasAtomic64Use(DxilMDHelper::ConstMDToBool(MDO));
       break;
+    case DxilMDHelper::kDxilReorderCoherentTag:
+      UAV.SetReorderCoherent(DxilMDHelper::ConstMDToBool(MDO));
+      break;
     default:
       DXASSERT(false, "Unknown resource record tag");
       m_bExtraMetadata = true;

lib/DXIL/DxilResource.cpp

@@ -25,8 +25,8 @@ namespace hlsl {
 DxilResource::DxilResource()
     : DxilResourceBase(DxilResourceBase::Class::Invalid), m_SampleCount(0),
       m_ElementStride(0), m_SamplerFeedbackType((DXIL::SamplerFeedbackType)0),
-      m_bGloballyCoherent(false), m_bHasCounter(false), m_bROV(false),
-      m_bHasAtomic64Use(false) {}
+      m_bGloballyCoherent(false), m_bReorderCoherent(false),
+      m_bHasCounter(false), m_bROV(false), m_bHasAtomic64Use(false) {}
 
 CompType DxilResource::GetCompType() const { return m_CompType; }
 
@@ -74,6 +74,10 @@ bool DxilResource::IsGloballyCoherent() const { return m_bGloballyCoherent; }
 
 void DxilResource::SetGloballyCoherent(bool b) { m_bGloballyCoherent = b; }
 
+bool DxilResource::IsReorderCoherent() const { return m_bReorderCoherent; }
+
+void DxilResource::SetReorderCoherent(bool b) { m_bReorderCoherent = b; }
+
 bool DxilResource::HasCounter() const { return m_bHasCounter; }
 
 void DxilResource::SetHasCounter(bool b) { m_bHasCounter = b; }

lib/DXIL/DxilResourceProperties.cpp

@@ -190,6 +190,7 @@ DxilResourceProperties loadPropsFromResourceBase(const DxilResourceBase *Res) {
     RP.Basic.IsUAV = true;
     RP.Basic.ResourceKind = (uint8_t)Res->GetKind();
     RP.Basic.IsGloballyCoherent = UAV->IsGloballyCoherent();
+    RP.Basic.IsReorderCoherent = UAV->IsReorderCoherent();
     RP.Basic.SamplerCmpOrHasCounter = UAV->HasCounter();
     RP.Basic.IsROV = UAV->IsROV();
     SetResProperties(*UAV);
@@ -234,6 +235,9 @@ DxilResourceProperties tryMergeProps(DxilResourceProperties curProps,
         prevProps.Basic.IsGloballyCoherent) {
       curProps.Basic.IsGloballyCoherent = prevProps.Basic.IsGloballyCoherent;
     }
+    if (curProps.Basic.IsReorderCoherent != prevProps.Basic.IsReorderCoherent) {
+      curProps.Basic.IsReorderCoherent = prevProps.Basic.IsReorderCoherent;
+    }
   }
 
   if (curProps.Basic.ResourceKind == (uint8_t)DXIL::ResourceKind::CBuffer) {

lib/DxilContainer/DxilContainerAssembler.cpp

@@ -1057,6 +1057,9 @@ class DxilRDATWriter : public DxilPartWriter {
       if (pRes->IsGloballyCoherent())
         info.Flags |=
             static_cast<uint32_t>(RDAT::DxilResourceFlag::UAVGloballyCoherent);
+      if (pRes->IsReorderCoherent())
+        info.Flags |=
+            static_cast<uint32_t>(RDAT::DxilResourceFlag::UAVReorderCoherent);
       if (pRes->IsROV())
         info.Flags |= static_cast<uint32_t>(
             RDAT::DxilResourceFlag::UAVRasterizerOrderedView);

lib/DxilPIXPasses/PixPassHelpers.cpp

@@ -312,6 +312,7 @@ hlsl::DxilResource *CreateGlobalUAVResource(hlsl::DxilModule &DM,
       (unsigned int)-2);   // This is the reserved-for-tools register space
   pUAV->SetSampleCount(0); // This is what compiler generates for a raw UAV
   pUAV->SetGloballyCoherent(false);
+  pUAV->SetReorderCoherent(false);
   pUAV->SetHasCounter(false);
   pUAV->SetCompType(
       CompType::getInvalid()); // This is what compiler generates for a raw UAV

lib/HLSL/DxilCondenseResources.cpp

@@ -2061,7 +2061,8 @@ void DxilLowerCreateHandleForLib::ReplaceResourceUserWithHandle(
     };
 
     // Search all users for update counter
-    bool updateAnnotateHandle = res.IsGloballyCoherent();
+    bool updateAnnotateHandle =
+        res.IsGloballyCoherent() || res.IsReorderCoherent();
     if (!res.HasCounter()) {
       for (User *U : handle->users()) {
         if (IsDxilOp(U, hlsl::OP::OpCode::BufferUpdateCounter)) {
@@ -2321,6 +2322,7 @@ void InitTBuffer(const DxilCBuffer *pSource, DxilResource *pDest) {
   pDest->SetSampleCount(0);
   pDest->SetElementStride(0);
   pDest->SetGloballyCoherent(false);
+  pDest->SetReorderCoherent(false);
   pDest->SetHasCounter(false);
   pDest->SetRW(false);
   pDest->SetROV(false);