Add adjustMaxWorkGroupCount helper

fhazubski-Intel · Compute-Runtime-Automation · commit de1e4e00748d · 2021-08-27T15:39:48.000+02:00
Signed-off-by: Filip Hazubski &lt;filip.hazubski@intel.com&gt;
diff --git a/level_zero/api/core/ze_module.cpp b/level_zero/api/core/ze_module.cpp
@@ -111,7 +111,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL
 zeKernelSuggestMaxCooperativeGroupCount(
     ze_kernel_handle_t hKernel,
     uint32_t *totalGroupCount) {
-    return L0::Kernel::fromHandle(hKernel)->suggestMaxCooperativeGroupCount(totalGroupCount);
+    return L0::Kernel::fromHandle(hKernel)->suggestMaxCooperativeGroupCount(totalGroupCount, NEO::EngineGroupType::Compute, false);
 }
 
 ZE_APIEXPORT ze_result_t ZE_APICALL
diff --git a/level_zero/core/source/cmdlist/cmdlist_hw.inl b/level_zero/core/source/cmdlist/cmdlist_hw.inl
@@ -1880,7 +1880,8 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::programSyncBuffer(Kernel &kern
     }
 
     uint32_t maximalNumberOfWorkgroupsAllowed;
-    auto ret = kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed);
+    auto ret = kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed, this->engineGroupType,
+                                                      device.getDefaultEngine().osContext->isEngineInstanced());
     UNRECOVERABLE_IF(ret != ZE_RESULT_SUCCESS);
     size_t requestedNumberOfWorkgroups = (pThreadGroupDimensions->groupCountX * pThreadGroupDimensions->groupCountY *
                                           pThreadGroupDimensions->groupCountZ);
diff --git a/level_zero/core/source/kernel/kernel.h b/level_zero/core/source/kernel/kernel.h
@@ -118,7 +118,8 @@ struct Kernel : _ze_kernel_handle_t, virtual NEO::DispatchKernelEncoderI {
 
     virtual void patchWorkDim(uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) = 0;
 
-    virtual ze_result_t suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount) = 0;
+    virtual ze_result_t suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount, NEO::EngineGroupType engineGroupType,
+                                                        bool isEngineInstanced) = 0;
     virtual ze_result_t setCacheConfig(ze_cache_config_flags_t flags) = 0;
 
     virtual ze_result_t getProfileInfo(zet_profile_properties_t *pProfileProperties) = 0;
diff --git a/level_zero/core/source/kernel/kernel_imp.cpp b/level_zero/core/source/kernel/kernel_imp.cpp
@@ -393,7 +393,8 @@ ze_result_t KernelImp::suggestGroupSize(uint32_t globalSizeX, uint32_t globalSiz
     return ZE_RESULT_SUCCESS;
 }
 
-ze_result_t KernelImp::suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount) {
+ze_result_t KernelImp::suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount, NEO::EngineGroupType engineGroupType,
+                                                       bool isEngineInstanced) {
     UNRECOVERABLE_IF(0 == groupSize[0]);
     UNRECOVERABLE_IF(0 == groupSize[1]);
     UNRECOVERABLE_IF(0 == groupSize[2]);
@@ -423,6 +424,7 @@ ze_result_t KernelImp::suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount
                                                                hwHelper.getBarriersCountFromHasBarriers(barrierCount),
                                                                workDim,
                                                                localWorkSize);
+    *totalGroupCount = hwHelper.adjustMaxWorkGroupCount(*totalGroupCount, engineGroupType, hardwareInfo, isEngineInstanced);
     return ZE_RESULT_SUCCESS;
 }
 
diff --git a/level_zero/core/source/kernel/kernel_imp.h b/level_zero/core/source/kernel/kernel_imp.h
@@ -45,7 +45,8 @@ struct KernelImp : Kernel {
 
     ze_result_t getKernelName(size_t *pSize, char *pName) override;
 
-    ze_result_t suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount) override;
+    ze_result_t suggestMaxCooperativeGroupCount(uint32_t *totalGroupCount, NEO::EngineGroupType engineGroupType,
+                                                bool isEngineInstanced) override;
 
     const uint8_t *getCrossThreadData() const override { return crossThreadData.get(); }
     uint32_t getCrossThreadDataSize() const override { return crossThreadDataSize; }
diff --git a/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp b/level_zero/core/test/unit_tests/sources/cmdlist/test_cmdlist_append_launch_kernel_1.cpp
@@ -1038,7 +1038,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenKernelUsingSyncBufferWhenAppendLau
     {
         VariableBackup<uint32_t> groupCountX{&groupCount.groupCountX};
         uint32_t maximalNumberOfWorkgroupsAllowed;
-        kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed);
+        kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed, NEO::EngineGroupType::Compute, false);
         groupCountX = maximalNumberOfWorkgroupsAllowed + 1;
         pCommandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();
         pCommandList->initialize(device, NEO::EngineGroupType::Compute, 0u);
diff --git a/opencl/source/kernel/kernel.cpp b/opencl/source/kernel/kernel.cpp
@@ -1056,15 +1056,18 @@ uint32_t Kernel::getMaxWorkGroupCount(const cl_uint workDim, const size_t *local
         hardwareInfo.gtSystemInfo.EUCount, hardwareInfo.gtSystemInfo.ThreadCount / hardwareInfo.gtSystemInfo.EUCount);
 
     auto barrierCount = kernelDescriptor.kernelAttributes.barrierCount;
-    return KernelHelper::getMaxWorkGroupCount(kernelInfo.getMaxSimdSize(),
-                                              availableThreadCount,
-                                              dssCount,
-                                              dssCount * KB * hardwareInfo.capabilityTable.slmSize,
-                                              hwHelper.alignSlmSize(slmTotalSize),
-                                              static_cast<uint32_t>(hwHelper.getMaxBarrierRegisterPerSlice()),
-                                              hwHelper.getBarriersCountFromHasBarriers(barrierCount),
-                                              workDim,
-                                              localWorkSize);
+    auto maxWorkGroupCount = KernelHelper::getMaxWorkGroupCount(kernelInfo.getMaxSimdSize(),
+                                                                availableThreadCount,
+                                                                dssCount,
+                                                                dssCount * KB * hardwareInfo.capabilityTable.slmSize,
+                                                                hwHelper.alignSlmSize(slmTotalSize),
+                                                                static_cast<uint32_t>(hwHelper.getMaxBarrierRegisterPerSlice()),
+                                                                hwHelper.getBarriersCountFromHasBarriers(barrierCount),
+                                                                workDim,
+                                                                localWorkSize);
+    auto isEngineInstanced = commandQueue->getCommandStreamReceiver(false).getOsContext().isEngineInstanced();
+    maxWorkGroupCount = hwHelper.adjustMaxWorkGroupCount(maxWorkGroupCount, engineGroupType, hardwareInfo, isEngineInstanced);
+    return maxWorkGroupCount;
 }
 
 inline void Kernel::makeArgsResident(CommandStreamReceiver &commandStreamReceiver) {
diff --git a/shared/source/helpers/hw_helper.h b/shared/source/helpers/hw_helper.h
@@ -126,6 +126,8 @@ class HwHelper {
     virtual bool useSystemMemoryPlacementForISA(const HardwareInfo &hwInfo) const = 0;
     virtual bool packedFormatsSupported() const = 0;
     virtual bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType) const = 0;
+    virtual uint32_t adjustMaxWorkGroupCount(uint32_t maxWorkGroupCount, const EngineGroupType engineGroupType,
+                                             const HardwareInfo &hwInfo, bool isEngineInstanced) const = 0;
     virtual size_t getMaxFillPaternSizeForCopyEngine() const = 0;
     virtual bool isCopyOnlyEngineType(EngineGroupType type) const = 0;
     virtual bool isSipWANeeded(const HardwareInfo &hwInfo) const = 0;
@@ -334,6 +336,9 @@ class HwHelperHw : public HwHelper {
 
     bool isCooperativeDispatchSupported(const EngineGroupType engineGroupType) const override;
 
+    uint32_t adjustMaxWorkGroupCount(uint32_t maxWorkGroupCount, const EngineGroupType engineGroupType,
+                                     const HardwareInfo &hwInfo, bool isEngineInstanced) const override;
+
     size_t getMaxFillPaternSizeForCopyEngine() const override;
 
     bool isKmdMigrationSupported(const HardwareInfo &hwInfo) const override;
diff --git a/shared/source/helpers/hw_helper_base.inl b/shared/source/helpers/hw_helper_base.inl
@@ -596,6 +596,12 @@ bool HwHelperHw<GfxFamily>::isCooperativeDispatchSupported(const EngineGroupType
     return true;
 }
 
+template <typename GfxFamily>
+uint32_t HwHelperHw<GfxFamily>::adjustMaxWorkGroupCount(uint32_t maxWorkGroupCount, const EngineGroupType engineGroupType,
+                                                        const HardwareInfo &hwInfo, bool isEngineInstanced) const {
+    return maxWorkGroupCount;
+}
+
 template <typename GfxFamily>
 bool HwHelperHw<GfxFamily>::isKmdMigrationSupported(const HardwareInfo &hwInfo) const {
     return false;

Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,7 @@ ZE_APIEXPORT ze_result_t ZE_APICALL`
`111`	`111`	`zeKernelSuggestMaxCooperativeGroupCount(`
`112`	`112`	`ze_kernel_handle_t hKernel,`
`113`	`113`	`uint32_t *totalGroupCount) {`
`114`		`- return L0::Kernel::fromHandle(hKernel)->suggestMaxCooperativeGroupCount(totalGroupCount);`
	`114`	`+ return L0::Kernel::fromHandle(hKernel)->suggestMaxCooperativeGroupCount(totalGroupCount, NEO::EngineGroupType::Compute, false);`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`ZE_APIEXPORT ze_result_t ZE_APICALL`
Original file line number	Diff line number	Diff line change
`@@ -1880,7 +1880,8 @@ ze_result_t CommandListCoreFamily<gfxCoreFamily>::programSyncBuffer(Kernel &kern`
`1880`	`1880`	`}`
`1881`	`1881`
`1882`	`1882`	`uint32_t maximalNumberOfWorkgroupsAllowed;`
`1883`		`- auto ret = kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed);`
	`1883`	`+ auto ret = kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed, this->engineGroupType,`
	`1884`	`+ device.getDefaultEngine().osContext->isEngineInstanced());`
`1884`	`1885`	`UNRECOVERABLE_IF(ret != ZE_RESULT_SUCCESS);`
`1885`	`1886`	`size_t requestedNumberOfWorkgroups = (pThreadGroupDimensions->groupCountX * pThreadGroupDimensions->groupCountY *`
`1886`	`1887`	`pThreadGroupDimensions->groupCountZ);`
Original file line number	Diff line number	Diff line change
`@@ -1038,7 +1038,7 @@ HWTEST2_F(CommandListAppendLaunchKernel, givenKernelUsingSyncBufferWhenAppendLau`
`1038`	`1038`	`{`
`1039`	`1039`	`VariableBackup<uint32_t> groupCountX{&groupCount.groupCountX};`
`1040`	`1040`	`uint32_t maximalNumberOfWorkgroupsAllowed;`
`1041`		`- kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed);`
	`1041`	`+ kernel.suggestMaxCooperativeGroupCount(&maximalNumberOfWorkgroupsAllowed, NEO::EngineGroupType::Compute, false);`
`1042`	`1042`	`groupCountX = maximalNumberOfWorkgroupsAllowed + 1;`
`1043`	`1043`	`pCommandList = std::make_unique<WhiteBox<::L0::CommandListCoreFamily<gfxCoreFamily>>>();`
`1044`	`1044`	`pCommandList->initialize(device, NEO::EngineGroupType::Compute, 0u);`