Remove WorkloadInfo from KernelInfo

Related-to: NEO-4729

Signed-off-by: Krystian Chmielewski <[email protected]>

Author: KrystianChmielewski

opencl/source/helpers/hardware_commands_helper_base.inl

@@ -46,7 +46,7 @@ size_t HardwareCommandsHelper<GfxFamily>::getSizeRequiredDSH(const Kernel &kerne
 
     totalSize += borderColorSize + additionalSizeRequiredDsh();
 
-    DEBUG_BREAK_IF(!(totalSize >= kernel.getDynamicStateHeapSize() || kernel.getKernelInfo().isVmeWorkload));
+    DEBUG_BREAK_IF(!(totalSize >= kernel.getDynamicStateHeapSize() || kernel.isVmeKernel()));
 
     return alignUp(totalSize, EncodeStates<GfxFamily>::alignInterfaceDescriptorData);
 }

opencl/source/kernel/kernel.cpp

@@ -359,29 +359,19 @@ void KernelInfo::apply(const DeviceInfoKernelPayloadConstants &constants) {
         return;
     }
 
-    uint32_t privateMemoryStatelessSizeOffset = this->workloadInfo.privateMemoryStatelessSizeOffset;
-    uint32_t localMemoryStatelessWindowSizeOffset = this->workloadInfo.localMemoryStatelessWindowSizeOffset;
-    uint32_t localMemoryStatelessWindowStartAddressOffset = this->workloadInfo.localMemoryStatelessWindowStartAddressOffset;
+    const auto &implicitArgs = kernelDescriptor.payloadMappings.implicitArgs;
+    const auto privateMemorySize = static_cast<uint32_t>(KernelHelper::getPrivateSurfaceSize(kernelDescriptor.kernelAttributes.perHwThreadPrivateMemorySize,
+                                                                                             constants.computeUnitsUsedForScratch));
 
-    if (localMemoryStatelessWindowStartAddressOffset != WorkloadInfo::undefinedOffset) {
-        *(uintptr_t *)&(this->crossThreadData[localMemoryStatelessWindowStartAddressOffset]) = reinterpret_cast<uintptr_t>(constants.slmWindow);
-    }
-
-    if (localMemoryStatelessWindowSizeOffset != WorkloadInfo::undefinedOffset) {
-        *(uint32_t *)&(this->crossThreadData[localMemoryStatelessWindowSizeOffset]) = constants.slmWindowSize;
-    }
-
-    auto perHwThreadSize = kernelDescriptor.kernelAttributes.perHwThreadPrivateMemorySize;
-    uint32_t privateMemorySize = static_cast<uint32_t>(KernelHelper::getPrivateSurfaceSize(perHwThreadSize,
-                                                                                           constants.computeUnitsUsedForScratch));
-
-    if (privateMemoryStatelessSizeOffset != WorkloadInfo::undefinedOffset) {
-        *(uint32_t *)&(this->crossThreadData[privateMemoryStatelessSizeOffset]) = privateMemorySize;
-    }
-
-    if (this->workloadInfo.maxWorkGroupSizeOffset != WorkloadInfo::undefinedOffset) {
-        *(uint32_t *)&(this->crossThreadData[this->workloadInfo.maxWorkGroupSizeOffset]) = constants.maxWorkGroupSize;
-    }
+    auto setIfValidOffset = [&](auto value, NEO::CrossThreadDataOffset offset) {
+        if (isValidOffset(offset)) {
+            *ptrOffset(reinterpret_cast<decltype(value) *>(crossThreadData), offset) = value;
+        }
+    };
+    setIfValidOffset(reinterpret_cast<uintptr_t>(constants.slmWindow), implicitArgs.localMemoryStatelessWindowStartAddres);
+    setIfValidOffset(constants.slmWindowSize, implicitArgs.localMemoryStatelessWindowSize);
+    setIfValidOffset(privateMemorySize, implicitArgs.privateMemorySize);
+    setIfValidOffset(constants.maxWorkGroupSize, implicitArgs.maxWorkGroupSize);
 }
 
 std::string concatenateKernelNames(ArrayRef<KernelInfo *> kernelInfos) {

opencl/source/program/kernel_info.cpp

@@ -43,31 +43,9 @@ extern bool useKernelDescriptor;
 
 extern std::map<std::string, size_t> typeSizeMap;
 
-struct WorkloadInfo {
-    enum : uint32_t { undefinedOffset = std::numeric_limits<uint32_t>::max() };
-    enum : uint32_t { invalidParentEvent = std::numeric_limits<uint32_t>::max() };
-
-    uint32_t globalWorkOffsetOffsets[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t globalWorkSizeOffsets[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t localWorkSizeOffsets[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t localWorkSizeOffsets2[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t enqueuedLocalWorkSizeOffsets[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t numWorkGroupsOffset[3] = {undefinedOffset, undefinedOffset, undefinedOffset};
-    uint32_t maxWorkGroupSizeOffset = undefinedOffset;
-    uint32_t workDimOffset = undefinedOffset;
-    uint32_t slmStaticSize = 0;
-    uint32_t simdSizeOffset = undefinedOffset;
-    uint32_t parentEventOffset = undefinedOffset;
-    uint32_t preferredWkgMultipleOffset = undefinedOffset;
-    uint32_t privateMemoryStatelessSizeOffset = undefinedOffset;
-    uint32_t localMemoryStatelessWindowSizeOffset = undefinedOffset;
-    uint32_t localMemoryStatelessWindowStartAddressOffset = undefinedOffset;
-};
-
 static const float YTilingRatioValue = 1.3862943611198906188344642429164f;
 
 struct WorkSizeInfo {
-
     uint32_t maxWorkGroupSize;
     uint32_t minWorkGroupSize;
     bool hasBarriers;
@@ -168,7 +146,6 @@ struct KernelInfo {
     PatchInfo patchInfo = {};
     std::vector<KernelArgInfo> kernelArgInfo;
     std::vector<KernelArgInfo> kernelNonArgInfo;
-    WorkloadInfo workloadInfo = {};
     std::vector<std::pair<uint32_t, uint32_t>> childrenKernelsIdOffset;
     bool usesSsh = false;
     bool requiresSshForBuffers = false;

opencl/source/program/kernel_info.h

@@ -24,15 +24,13 @@ inline void storeTokenIfNotNull(KernelInfo &kernelInfo, T *token) {
         kernelInfo.storePatchToken(token);
     }
 }
-
 template <typename T>
 inline uint32_t getOffset(T *token) {
     if (token != nullptr) {
         return token->Offset;
     }
-    return WorkloadInfo::undefinedOffset;
+    return undefined<uint32_t>;
 }
-
 void populateKernelInfoArgMetadata(KernelInfo &dstKernelInfoArg, const SPatchKernelArgumentInfo *src) {
     if (nullptr == src) {
         return;
@@ -158,7 +156,7 @@ void populateKernelInfo(KernelInfo &dst, const PatchTokenBinary::KernelFromPatch
 
     storeTokenIfNotNull(dst, src.tokens.executionEnvironment);
     dst.usesSsh = src.tokens.bindingTableState && (src.tokens.bindingTableState->Count > 0);
-    dst.workloadInfo.slmStaticSize = src.tokens.allocateLocalSurface ? src.tokens.allocateLocalSurface->TotalInlineLocalMemorySize : 0U;
+    dst.kernelDescriptor.kernelAttributes.slmInlineSize = src.tokens.allocateLocalSurface ? src.tokens.allocateLocalSurface->TotalInlineLocalMemorySize : 0U;
 
     dst.kernelArgInfo.resize(src.tokens.kernelArgs.size());
 
@@ -178,23 +176,6 @@ void populateKernelInfo(KernelInfo &dst, const PatchTokenBinary::KernelFromPatch
     dst.isVmeWorkload = dst.isVmeWorkload || (src.tokens.inlineVmeSamplerInfo != nullptr);
     dst.systemKernelOffset = src.tokens.stateSip ? src.tokens.stateSip->SystemKernelOffset : 0U;
 
-    for (uint32_t i = 0; i < 3U; ++i) {
-        dst.workloadInfo.localWorkSizeOffsets[i] = getOffset(src.tokens.crossThreadPayloadArgs.localWorkSize[i]);
-        dst.workloadInfo.localWorkSizeOffsets2[i] = getOffset(src.tokens.crossThreadPayloadArgs.localWorkSize2[i]);
-        dst.workloadInfo.globalWorkOffsetOffsets[i] = getOffset(src.tokens.crossThreadPayloadArgs.globalWorkOffset[i]);
-        dst.workloadInfo.enqueuedLocalWorkSizeOffsets[i] = getOffset(src.tokens.crossThreadPayloadArgs.enqueuedLocalWorkSize[i]);
-        dst.workloadInfo.globalWorkSizeOffsets[i] = getOffset(src.tokens.crossThreadPayloadArgs.globalWorkSize[i]);
-        dst.workloadInfo.numWorkGroupsOffset[i] = getOffset(src.tokens.crossThreadPayloadArgs.numWorkGroups[i]);
-    }
-
-    dst.workloadInfo.maxWorkGroupSizeOffset = getOffset(src.tokens.crossThreadPayloadArgs.maxWorkGroupSize);
-    dst.workloadInfo.workDimOffset = getOffset(src.tokens.crossThreadPayloadArgs.workDimensions);
-    dst.workloadInfo.simdSizeOffset = getOffset(src.tokens.crossThreadPayloadArgs.simdSize);
-    dst.workloadInfo.parentEventOffset = getOffset(src.tokens.crossThreadPayloadArgs.parentEvent);
-    dst.workloadInfo.preferredWkgMultipleOffset = getOffset(src.tokens.crossThreadPayloadArgs.preferredWorkgroupMultiple);
-    dst.workloadInfo.privateMemoryStatelessSizeOffset = getOffset(src.tokens.crossThreadPayloadArgs.privateMemoryStatelessSize);
-    dst.workloadInfo.localMemoryStatelessWindowSizeOffset = getOffset(src.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowSize);
-    dst.workloadInfo.localMemoryStatelessWindowStartAddressOffset = getOffset(src.tokens.crossThreadPayloadArgs.localMemoryStatelessWindowStartAddress);
     for (auto &childSimdSize : src.tokens.crossThreadPayloadArgs.childBlockSimdSize) {
         dst.childrenKernelsIdOffset.push_back({childSimdSize->ArgumentNumber, childSimdSize->Offset});
     }