Change state tracking interfaces to split properties update

Related-To: NEO-5055 Signed-off-by: Zbigniew Zdanowicz <zbigniew.zdanowicz@intel.com>
2025-12-26 23:33:20 +08:00 · 2023-02-10 09:51:27 +00:00
parent 429be6b4cb
commit 98b60ba148
25 changed files with 603 additions and 156 deletions
--- a/shared/source/command_stream/command_stream_receiver_hw_base.inl
+++ b/shared/source/command_stream/command_stream_receiver_hw_base.inl
@@ -373,8 +373,8 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
    handlePipelineSelectStateTransition(dispatchFlags);

    auto requiresCoherency = gfxCoreHelper.forceNonGpuCoherencyWA(dispatchFlags.requiresCoherency);
-    this->streamProperties.stateComputeMode.setProperties(requiresCoherency, dispatchFlags.numGrfRequired,
-                                                          dispatchFlags.threadArbitrationPolicy, device.getPreemptionMode(), peekRootDeviceEnvironment());
+    this->streamProperties.stateComputeMode.setPropertiesAll(requiresCoherency, dispatchFlags.numGrfRequired,
+                                                             dispatchFlags.threadArbitrationPolicy, device.getPreemptionMode(), peekRootDeviceEnvironment());

    csrSizeRequestFlags.l3ConfigChanged = this->lastSentL3Config != newL3Config;
    csrSizeRequestFlags.preemptionRequestChanged = this->lastPreemptionMode != dispatchFlags.preemptionMode;
@@ -490,11 +490,11 @@ CompletionStamp CommandStreamReceiverHw<GfxFamily>::flushTask(
        lastSentUseGlobalAtomics = dispatchFlags.useGlobalAtomics;
    }

-    this->streamProperties.stateBaseAddress.setProperties(dispatchFlags.useGlobalAtomics, mocsIndex,
-                                                          bindingTablePoolBaseAddress, bindingTablePoolSize,
-                                                          surfaceStateBaseAddress, surfaceStateSize,
-                                                          dynamicStateBaseAddress, dynamicStateSize,
-                                                          indirectObjectBaseAddress, indirectObjectSize, this->peekRootDeviceEnvironment());
+    this->streamProperties.stateBaseAddress.setPropertiesAll(dispatchFlags.useGlobalAtomics, mocsIndex,
+                                                             bindingTablePoolBaseAddress, bindingTablePoolSize,
+                                                             surfaceStateBaseAddress, surfaceStateSize,
+                                                             dynamicStateBaseAddress, dynamicStateSize,
+                                                             indirectObjectBaseAddress, indirectObjectSize, this->peekRootDeviceEnvironment());

    bool debuggingEnabled = device.getDebugger() != nullptr;
    bool sourceLevelDebuggerActive = device.getSourceLevelDebugger() != nullptr ? true : false;
@@ -1115,7 +1115,7 @@ inline void CommandStreamReceiverHw<GfxFamily>::programVFEState(LinearStream &cs

        auto isCooperative = dispatchFlags.kernelExecutionType == KernelExecutionType::Concurrent;
        auto disableOverdispatch = (dispatchFlags.additionalKernelExecInfo != AdditionalKernelExecInfo::NotSet);
-        streamProperties.frontEndState.setProperties(isCooperative, dispatchFlags.disableEUFusion, disableOverdispatch, osContext->isEngineInstanced(), peekRootDeviceEnvironment());
+        streamProperties.frontEndState.setPropertiesAll(isCooperative, dispatchFlags.disableEUFusion, disableOverdispatch, osContext->isEngineInstanced(), peekRootDeviceEnvironment());

        auto &gfxCoreHelper = getGfxCoreHelper();
        auto engineGroupType = gfxCoreHelper.getEngineGroupType(getOsContext().getEngineType(), getOsContext().getEngineUsage(), hwInfo);
--- a/shared/source/command_stream/command_stream_receiver_hw_bdw_and_later.inl
+++ b/shared/source/command_stream/command_stream_receiver_hw_bdw_and_later.inl
@@ -65,7 +65,7 @@ void CommandStreamReceiverHw<GfxFamily>::programPipelineSelect(LinearStream &com
        }
        this->lastMediaSamplerConfig = pipelineSelectArgs.mediaSamplerRequired;
        this->lastSystolicPipelineSelectMode = pipelineSelectArgs.systolicPipelineSelectMode;
-        this->streamProperties.pipelineSelect.setProperties(true, this->lastMediaSamplerConfig, this->lastSystolicPipelineSelectMode, peekRootDeviceEnvironment());
+        this->streamProperties.pipelineSelect.setPropertiesAll(true, this->lastMediaSamplerConfig, this->lastSystolicPipelineSelectMode, peekRootDeviceEnvironment());
    }
 }

--- a/shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl
+++ b/shared/source/command_stream/command_stream_receiver_hw_xehp_and_later.inl
@@ -49,7 +49,7 @@ void CommandStreamReceiverHw<GfxFamily>::programPipelineSelect(LinearStream &com
        PreambleHelper<GfxFamily>::programPipelineSelect(&commandStream, pipelineSelectArgs, peekRootDeviceEnvironment());
        this->lastMediaSamplerConfig = pipelineSelectArgs.mediaSamplerRequired;
        this->lastSystolicPipelineSelectMode = pipelineSelectArgs.systolicPipelineSelectMode;
-        this->streamProperties.pipelineSelect.setProperties(true, this->lastMediaSamplerConfig, this->lastSystolicPipelineSelectMode, peekRootDeviceEnvironment());
+        this->streamProperties.pipelineSelect.setPropertiesAll(true, this->lastMediaSamplerConfig, this->lastSystolicPipelineSelectMode, peekRootDeviceEnvironment());
    }
 }

--- a/shared/source/command_stream/definitions/stream_properties.inl
+++ b/shared/source/command_stream/definitions/stream_properties.inl
@@ -29,19 +29,22 @@ struct StateComputeModeProperties {
    StreamProperty threadArbitrationPolicy{};
    StreamProperty devicePreemptionMode{};

-    void setProperties(bool requiresCoherency, uint32_t numGrfRequired, int32_t threadArbitrationPolicy, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesAll(bool requiresCoherency, uint32_t numGrfRequired, int32_t threadArbitrationPolicy, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment);
    void setProperties(const StateComputeModeProperties &properties);
    void setPropertiesGrfNumberThreadArbitration(uint32_t numGrfRequired, int32_t threadArbitrationPolicy, const RootDeviceEnvironment &rootDeviceEnvironment);
-    void setPropertiesCoherencyDevicePreemption(bool requiresCoherency, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesCoherencyDevicePreemption(bool requiresCoherency, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState);
    bool isDirty() const;

  protected:
    void clearIsDirty();
-
+    void clearIsDirtyExtraPerContext();
+    void clearIsDirtyExtraPerKernel();
    bool isDirtyExtra() const;
-    void setPropertiesExtra();
+
+    void setPropertiesExtraPerContext();
+    void setPropertiesExtraPerKernel();
    void setPropertiesExtra(const StateComputeModeProperties &properties);
-    void clearIsDirtyExtra();
+
    void initSupport(const RootDeviceEnvironment &rootDeviceEnvironment);

    void setCoherencyProperty(bool requiresCoherency);
@@ -67,10 +70,10 @@ struct FrontEndProperties {
    StreamProperty disableOverdispatch{};
    StreamProperty singleSliceDispatchCcsMode{};

-    void setProperties(bool isCooperativeKernel, bool disableEuFusion, bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesAll(bool isCooperativeKernel, bool disableEuFusion, bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment);
    void setProperties(const FrontEndProperties &properties);
    void setPropertySingleSliceDispatchCcsMode(int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment);
-    void setPropertyDisableOverdispatch(bool disableOverdispatch, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesDisableOverdispatchEngineInstanced(bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState);
    void setPropertiesComputeDispatchAllWalkerEnableDisableEuFusion(bool isCooperativeKernel, bool disableEuFusion, const RootDeviceEnvironment &rootDeviceEnvironment);
    bool isDirty() const;

@@ -93,8 +96,9 @@ struct PipelineSelectProperties {
    StreamProperty mediaSamplerDopClockGate{};
    StreamProperty systolicMode{};

-    void setProperties(bool modeSelected, bool mediaSamplerDopClockGate, bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesAll(bool modeSelected, bool mediaSamplerDopClockGate, bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment);
    void setProperties(const PipelineSelectProperties &properties);
+    void setPropertiesModeSelectedMediaSamplerClockGate(bool modeSelected, bool mediaSamplerDopClockGate, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState);
    void setPropertySystolicMode(bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment);
    bool isDirty() const;

@@ -124,16 +128,23 @@ struct StateBaseAddressProperties {
    StreamProperty globalAtomics{};
    StreamProperty statelessMocs{};

-    void setProperties(bool globalAtomics, int32_t statelessMocs,
-                       int64_t bindingTablePoolBaseAddress, size_t surfaceStateSize,
-                       int64_t surfaceStateBaseAddress, size_t bindingTablePoolSize,
-                       int64_t dynamicStateBaseAddress, size_t dynamicStateSize,
-                       int64_t indirectObjectBaseAddress, size_t indirectObjectSize, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesAll(bool globalAtomics, int32_t statelessMocs,
+                          int64_t bindingTablePoolBaseAddress, size_t bindingTablePoolSize,
+                          int64_t surfaceStateBaseAddress, size_t surfaceStateSize,
+                          int64_t dynamicStateBaseAddress, size_t dynamicStateSize,
+                          int64_t indirectObjectBaseAddress, size_t indirectObjectSize, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesSurfaceState(int64_t bindingTablePoolBaseAddress, size_t bindingTablePoolSize,
+                                   int64_t surfaceStateBaseAddress, size_t surfaceStateSize, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertiesDynamicState(int64_t dynamicStateBaseAddress, size_t dynamicStateSize);
+    void setPropertiesIndirectState(int64_t indirectObjectBaseAddress, size_t indirectObjectSize);
+    void setPropertyStatelessMocs(int32_t statelessMocs, const RootDeviceEnvironment &rootDeviceEnvironment);
+    void setPropertyGlobalAtomics(bool globalAtomics, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState);
    void setProperties(const StateBaseAddressProperties &properties);
    bool isDirty() const;

  protected:
    void clearIsDirty();
+    void initSupport(const RootDeviceEnvironment &rootDeviceEnvironment);

    StateBaseAddressPropertiesSupport stateBaseAddressPropertiesSupport = {};
    bool propertiesSupportLoaded = false;
--- a/shared/source/command_stream/stream_properties.cpp
+++ b/shared/source/command_stream/stream_properties.cpp
@@ -16,8 +16,8 @@

 using namespace NEO;

-void StateComputeModeProperties::setProperties(bool requiresCoherency, uint32_t numGrfRequired, int32_t threadArbitrationPolicy, PreemptionMode devicePreemptionMode,
-                                               const RootDeviceEnvironment &rootDeviceEnvironment) {
+void StateComputeModeProperties::setPropertiesAll(bool requiresCoherency, uint32_t numGrfRequired, int32_t threadArbitrationPolicy, PreemptionMode devicePreemptionMode,
+                                                  const RootDeviceEnvironment &rootDeviceEnvironment) {
    initSupport(rootDeviceEnvironment);
    clearIsDirty();

@@ -42,7 +42,8 @@ void StateComputeModeProperties::setProperties(bool requiresCoherency, uint32_t
    }
    setDevicePreemptionProperty(devicePreemptionMode);

-    setPropertiesExtra();
+    setPropertiesExtraPerContext();
+    setPropertiesExtraPerKernel();
 }

 void StateComputeModeProperties::setProperties(const StateComputeModeProperties &properties) {
@@ -71,7 +72,8 @@ void StateComputeModeProperties::clearIsDirty() {
    threadArbitrationPolicy.isDirty = false;
    devicePreemptionMode.isDirty = false;

-    clearIsDirtyExtra();
+    clearIsDirtyExtraPerContext();
+    clearIsDirtyExtraPerKernel();
 }

 void StateComputeModeProperties::setCoherencyProperty(bool requiresCoherency) {
@@ -119,13 +121,22 @@ void StateComputeModeProperties::initSupport(const RootDeviceEnvironment &rootDe
    }
 }

-void StateComputeModeProperties::setPropertiesCoherencyDevicePreemption(bool requiresCoherency, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment) {
+void StateComputeModeProperties::setPropertiesCoherencyDevicePreemption(bool requiresCoherency, PreemptionMode devicePreemptionMode, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState) {
    initSupport(rootDeviceEnvironment);

-    this->isCoherencyRequired.isDirty = false;
-    this->devicePreemptionMode.isDirty = false;
+    if (!clearDirtyState) {
+        this->isCoherencyRequired.isDirty = false;
+        this->devicePreemptionMode.isDirty = false;
+        clearIsDirtyExtraPerContext();
+    }
    setCoherencyProperty(requiresCoherency);
    setDevicePreemptionProperty(devicePreemptionMode);
+    setPropertiesExtraPerContext();
+    if (clearDirtyState) {
+        this->isCoherencyRequired.isDirty = false;
+        this->devicePreemptionMode.isDirty = false;
+        clearIsDirtyExtraPerContext();
+    }
 }

 void StateComputeModeProperties::setPropertiesGrfNumberThreadArbitration(uint32_t numGrfRequired, int32_t threadArbitrationPolicy, const RootDeviceEnvironment &rootDeviceEnvironment) {
@@ -133,9 +144,11 @@ void StateComputeModeProperties::setPropertiesGrfNumberThreadArbitration(uint32_

    this->threadArbitrationPolicy.isDirty = false;
    this->largeGrfMode.isDirty = false;
+    clearIsDirtyExtraPerKernel();

    setGrfNumberProperty(numGrfRequired);
    setThreadArbitrationProperty(threadArbitrationPolicy, rootDeviceEnvironment);
+    setPropertiesExtraPerKernel();
 }

 void FrontEndProperties::initSupport(const RootDeviceEnvironment &rootDeviceEnvironment) {
@@ -147,7 +160,7 @@ void FrontEndProperties::initSupport(const RootDeviceEnvironment &rootDeviceEnvi
    }
 }

-void FrontEndProperties::setProperties(bool isCooperativeKernel, bool disableEuFusion, bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment) {
+void FrontEndProperties::setPropertiesAll(bool isCooperativeKernel, bool disableEuFusion, bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment) {
    initSupport(rootDeviceEnvironment);

    clearIsDirty();
@@ -178,13 +191,25 @@ void FrontEndProperties::setPropertySingleSliceDispatchCcsMode(int32_t engineIns
    }
 }

-void FrontEndProperties::setPropertyDisableOverdispatch(bool disableOverdispatch, const RootDeviceEnvironment &rootDeviceEnvironment) {
+void FrontEndProperties::setPropertiesDisableOverdispatchEngineInstanced(bool disableOverdispatch, int32_t engineInstancedDevice, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState) {
    initSupport(rootDeviceEnvironment);

-    this->disableOverdispatch.isDirty = false;
+    if (!clearDirtyState) {
+        this->disableOverdispatch.isDirty = false;
+        this->singleSliceDispatchCcsMode.isDirty = false;
+    }
+
    if (this->frontEndPropertiesSupport.disableOverdispatch) {
        this->disableOverdispatch.set(disableOverdispatch);
    }
+    if (this->frontEndPropertiesSupport.singleSliceDispatchCcsMode) {
+        this->singleSliceDispatchCcsMode.set(engineInstancedDevice);
+    }
+
+    if (clearDirtyState) {
+        this->disableOverdispatch.isDirty = false;
+        this->singleSliceDispatchCcsMode.isDirty = false;
+    }
 }

 void FrontEndProperties::setPropertiesComputeDispatchAllWalkerEnableDisableEuFusion(bool isCooperativeKernel, bool disableEuFusion, const RootDeviceEnvironment &rootDeviceEnvironment) {
@@ -232,7 +257,7 @@ void PipelineSelectProperties::initSupport(const RootDeviceEnvironment &rootDevi
    }
 }

-void PipelineSelectProperties::setProperties(bool modeSelected, bool mediaSamplerDopClockGate, bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment) {
+void PipelineSelectProperties::setPropertiesAll(bool modeSelected, bool mediaSamplerDopClockGate, bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment) {
    initSupport(rootDeviceEnvironment);
    clearIsDirty();

@@ -249,6 +274,27 @@ void PipelineSelectProperties::setProperties(bool modeSelected, bool mediaSample
    }
 }

+void PipelineSelectProperties::setPropertiesModeSelectedMediaSamplerClockGate(bool modeSelected, bool mediaSamplerDopClockGate, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState) {
+    initSupport(rootDeviceEnvironment);
+
+    if (!clearDirtyState) {
+        this->modeSelected.isDirty = false;
+        this->mediaSamplerDopClockGate.isDirty = false;
+    }
+
+    if (this->pipelineSelectPropertiesSupport.modeSelected) {
+        this->modeSelected.set(modeSelected);
+    }
+    if (this->pipelineSelectPropertiesSupport.mediaSamplerDopClockGate) {
+        this->mediaSamplerDopClockGate.set(mediaSamplerDopClockGate);
+    }
+
+    if (clearDirtyState) {
+        this->modeSelected.isDirty = false;
+        this->mediaSamplerDopClockGate.isDirty = false;
+    }
+}
+
 void PipelineSelectProperties::setPropertySystolicMode(bool systolicMode, const RootDeviceEnvironment &rootDeviceEnvironment) {
    initSupport(rootDeviceEnvironment);

@@ -277,17 +323,74 @@ void PipelineSelectProperties::clearIsDirty() {
    systolicMode.isDirty = false;
 }

-void StateBaseAddressProperties::setProperties(bool globalAtomics, int32_t statelessMocs,
-                                               int64_t bindingTablePoolBaseAddress, size_t bindingTablePoolSize,
-                                               int64_t surfaceStateBaseAddress, size_t surfaceStateSize,
-                                               int64_t dynamicStateBaseAddress, size_t dynamicStateSize,
-                                               int64_t indirectObjectBaseAddress, size_t indirectObjectSize, const RootDeviceEnvironment &rootDeviceEnvironment) {
+void StateBaseAddressProperties::initSupport(const RootDeviceEnvironment &rootDeviceEnvironment) {
    if (this->propertiesSupportLoaded == false) {
        auto &productHelper = rootDeviceEnvironment.getHelper<ProductHelper>();
        productHelper.fillStateBaseAddressPropertiesSupportStructure(this->stateBaseAddressPropertiesSupport);
        this->propertiesSupportLoaded = true;
    }
+}

+void StateBaseAddressProperties::setPropertiesSurfaceState(int64_t bindingTablePoolBaseAddress, size_t bindingTablePoolSize,
+                                                           int64_t surfaceStateBaseAddress, size_t surfaceStateSize, const RootDeviceEnvironment &rootDeviceEnvironment) {
+    initSupport(rootDeviceEnvironment);
+
+    this->bindingTablePoolBaseAddress.isDirty = false;
+    this->bindingTablePoolSize.isDirty = false;
+    this->surfaceStateBaseAddress.isDirty = false;
+    this->surfaceStateSize.isDirty = false;
+
+    if (this->stateBaseAddressPropertiesSupport.bindingTablePoolBaseAddress) {
+        this->bindingTablePoolBaseAddress.set(bindingTablePoolBaseAddress);
+        this->bindingTablePoolSize.set(bindingTablePoolSize);
+    }
+    this->surfaceStateBaseAddress.set(surfaceStateBaseAddress);
+    this->surfaceStateSize.set(surfaceStateSize);
+}
+
+void StateBaseAddressProperties::setPropertiesDynamicState(int64_t dynamicStateBaseAddress, size_t dynamicStateSize) {
+    this->dynamicStateBaseAddress.isDirty = false;
+    this->dynamicStateSize.isDirty = false;
+    this->dynamicStateBaseAddress.set(dynamicStateBaseAddress);
+    this->dynamicStateSize.set(dynamicStateSize);
+}
+
+void StateBaseAddressProperties::setPropertiesIndirectState(int64_t indirectObjectBaseAddress, size_t indirectObjectSize) {
+    this->indirectObjectBaseAddress.isDirty = false;
+    this->indirectObjectSize.isDirty = false;
+    this->indirectObjectBaseAddress.set(indirectObjectBaseAddress);
+    this->indirectObjectSize.set(indirectObjectSize);
+}
+
+void StateBaseAddressProperties::setPropertyStatelessMocs(int32_t statelessMocs, const RootDeviceEnvironment &rootDeviceEnvironment) {
+    initSupport(rootDeviceEnvironment);
+
+    this->statelessMocs.isDirty = false;
+    if (this->stateBaseAddressPropertiesSupport.statelessMocs) {
+        this->statelessMocs.set(statelessMocs);
+    }
+}
+
+void StateBaseAddressProperties::setPropertyGlobalAtomics(bool globalAtomics, const RootDeviceEnvironment &rootDeviceEnvironment, bool clearDirtyState) {
+    initSupport(rootDeviceEnvironment);
+
+    if (!clearDirtyState) {
+        this->globalAtomics.isDirty = false;
+    }
+    if (this->stateBaseAddressPropertiesSupport.globalAtomics) {
+        this->globalAtomics.set(globalAtomics);
+    }
+    if (clearDirtyState) {
+        this->globalAtomics.isDirty = false;
+    }
+}
+
+void StateBaseAddressProperties::setPropertiesAll(bool globalAtomics, int32_t statelessMocs,
+                                                  int64_t bindingTablePoolBaseAddress, size_t bindingTablePoolSize,
+                                                  int64_t surfaceStateBaseAddress, size_t surfaceStateSize,
+                                                  int64_t dynamicStateBaseAddress, size_t dynamicStateSize,
+                                                  int64_t indirectObjectBaseAddress, size_t indirectObjectSize, const RootDeviceEnvironment &rootDeviceEnvironment) {
+    initSupport(rootDeviceEnvironment);
    clearIsDirty();

    if (this->stateBaseAddressPropertiesSupport.globalAtomics) {
--- a/shared/source/command_stream/stream_properties_extra.cpp
+++ b/shared/source/command_stream/stream_properties_extra.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2022 Intel Corporation
+ * Copyright (C) 2022-2023 Intel Corporation
 *
 * SPDX-License-Identifier: MIT
 *
@@ -9,12 +9,19 @@

 using namespace NEO;

-void StateComputeModeProperties::setPropertiesExtra() {
+void StateComputeModeProperties::setPropertiesExtraPerContext() {
 }
+void StateComputeModeProperties::setPropertiesExtraPerKernel() {
+}
+
 void StateComputeModeProperties::setPropertiesExtra(const StateComputeModeProperties &properties) {
 }
+
 bool StateComputeModeProperties::isDirtyExtra() const {
    return false;
 }
-void StateComputeModeProperties::clearIsDirtyExtra() {
+
+void StateComputeModeProperties::clearIsDirtyExtraPerContext() {
+}
+void StateComputeModeProperties::clearIsDirtyExtraPerKernel() {
 }