Remove executionEnvironment from KernelInfo

Related-To: NEO-3739

shared/source/command_container/command_encoder_bdw_plus.inl

@@ -69,7 +69,7 @@ void EncodeDispatchKernel<Family>::encode(CommandContainer &container,
     idd.setNumberOfThreadsInGpgpuThreadGroup(numThreadsPerThreadGroup);
 
     EncodeDispatchKernel<Family>::programBarrierEnable(idd,
-                                                       kernelDescriptor.kernelAttributes.hasBarriers,
+                                                       kernelDescriptor.kernelAttributes.barrierCount,
                                                        hwInfo);
     auto slmSize = static_cast<typename INTERFACE_DESCRIPTOR_DATA::SHARED_LOCAL_MEMORY_SIZE>(
         HwHelperHw<Family>::get().computeSlmValues(hwInfo, dispatchInterface->getSlmTotalSize()));

shared/source/command_stream/preemption.cpp

@@ -60,14 +60,10 @@ PreemptionMode PreemptionHelper::taskPreemptionMode(PreemptionMode devicePreempt
 
 void PreemptionHelper::setPreemptionLevelFlags(PreemptionFlags &flags, Device &device, Kernel *kernel) {
     if (kernel) {
-        const auto &kernelInfo = kernel->getKernelInfo(device.getRootDeviceIndex());
-        flags.flags.disabledMidThreadPreemptionKernel =
-            kernelInfo.patchInfo.executionEnvironment &&
-            kernelInfo.patchInfo.executionEnvironment->DisableMidThreadPreemption;
+        const auto &kernelDescriptor = kernel->getKernelInfo(device.getRootDeviceIndex()).kernelDescriptor;
+        flags.flags.disabledMidThreadPreemptionKernel = kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption;
         flags.flags.vmeKernel = kernel->isVmeKernel();
-        flags.flags.usesFencesForReadWriteImages =
-            kernelInfo.patchInfo.executionEnvironment &&
-            kernelInfo.patchInfo.executionEnvironment->UsesFencesForReadWriteImages;
+        flags.flags.usesFencesForReadWriteImages = kernelDescriptor.kernelAttributes.flags.usesFencesForReadWriteImages;
         flags.flags.schedulerKernel = kernel->isSchedulerKernel;
     }
     flags.flags.deviceSupportsVmePreemption = device.getDeviceInfo().vmeAvcSupportsPreemption;

shared/source/device_binary_format/zebin_decoder.cpp

@@ -798,8 +798,7 @@ NEO::DecodeError populateKernelDescriptor(NEO::ProgramInfo &dst, NEO::Elf::Elf<N
         }
     }
 
-    kernelDescriptor.kernelAttributes.hasBarriers = execEnv.barrierCount;
-    kernelDescriptor.kernelAttributes.flags.usesBarriers = (kernelDescriptor.kernelAttributes.hasBarriers > 0U);
+    kernelDescriptor.kernelAttributes.barrierCount = execEnv.barrierCount;
     kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption = execEnv.disableMidThreadPreemption;
     kernelDescriptor.kernelAttributes.numGrfRequired = execEnv.grfCount;
     if (execEnv.has4GBBuffers) {

shared/source/kernel/CMakeLists.txt

@@ -17,6 +17,8 @@ set(NEO_CORE_KERNEL
     ${CMAKE_CURRENT_SOURCE_DIR}/kernel_descriptor.h
     ${CMAKE_CURRENT_SOURCE_DIR}/kernel_descriptor_from_patchtokens.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/kernel_descriptor_from_patchtokens.h
+    ${CMAKE_CURRENT_SOURCE_DIR}/read_extended_info.h
+    ${CMAKE_CURRENT_SOURCE_DIR}${BRANCH_DIR_SUFFIX}/read_extended_info.cpp
 )
 
 set_property(GLOBAL PROPERTY NEO_CORE_KERNEL ${NEO_CORE_KERNEL})

shared/source/kernel/kernel_descriptor.h

@@ -26,6 +26,10 @@ namespace NEO {
 using StringMap = std::unordered_map<uint32_t, std::string>;
 using InstructionsSegmentOffset = uint16_t;
 
+struct ExtendedInfoBase {
+    virtual ~ExtendedInfoBase() = default;
+};
+
 struct KernelDescriptor final {
     enum AddressingMode : uint8_t {
         AddrNone,
@@ -46,12 +50,13 @@ struct KernelDescriptor final {
         uint32_t perThreadScratchSize[2] = {0U, 0U};
         uint32_t perHwThreadPrivateMemorySize = 0U;
         uint32_t perThreadSystemThreadSurfaceSize = 0U;
-        uint32_t hasBarriers = 0u;
         uint16_t requiredWorkgroupSize[3] = {0U, 0U, 0U};
         uint16_t crossThreadDataSize = 0U;
         uint16_t perThreadDataSize = 0U;
         uint16_t numArgsToPatch = 0U;
         uint16_t numGrfRequired = 0U;
+        uint8_t barrierCount = 0u;
+
         AddressingMode bufferAddressingMode = BindfulAndStateless;
         AddressingMode imageAddressingMode = Bindful;
         AddressingMode samplerAddressingMode = Bindful;
@@ -67,10 +72,13 @@ struct KernelDescriptor final {
             return Stateless == bufferAddressingMode;
         }
 
+        bool usesBarriers() const {
+            return 0 != barrierCount;
+        }
+
         union {
             struct {
                 bool usesPrintf : 1;
-                bool usesBarriers : 1;
                 bool usesFencesForReadWriteImages : 1;
                 bool usesFlattenedLocalIds;
                 bool usesPrivateMemory : 1;
@@ -170,6 +178,7 @@ struct KernelDescriptor final {
     } external;
 
     std::vector<uint8_t> generatedHeaps;
+    std::unique_ptr<ExtendedInfoBase> extendedInfo;
 };
 
 } // namespace NEO

shared/source/kernel/kernel_descriptor_from_patchtokens.cpp

@@ -11,6 +11,7 @@
 #include "shared/source/kernel/kernel_arg_descriptor_extended_device_side_enqueue.h"
 #include "shared/source/kernel/kernel_arg_descriptor_extended_vme.h"
 #include "shared/source/kernel/kernel_descriptor.h"
+#include "shared/source/kernel/read_extended_info.h"
 
 #include <sstream>
 #include <string>
@@ -49,17 +50,20 @@ void populateKernelDescriptor(KernelDescriptor &dst, const SPatchExecutionEnviro
     } else {
         dst.kernelAttributes.bufferAddressingMode = KernelDescriptor::BindfulAndStateless;
     }
+
+    dst.kernelAttributes.numGrfRequired = execEnv.NumGRFRequired;
     dst.kernelAttributes.simdSize = execEnv.LargestCompiledSIMDSize;
+    dst.kernelAttributes.barrierCount = execEnv.HasBarriers;
+
     dst.kernelAttributes.flags.usesDeviceSideEnqueue = (0 != execEnv.HasDeviceEnqueue);
-    dst.kernelAttributes.flags.usesBarriers = (0 != execEnv.HasBarriers);
-    dst.kernelAttributes.hasBarriers = execEnv.HasBarriers;
     dst.kernelAttributes.flags.requiresDisabledMidThreadPreemption = (0 != execEnv.DisableMidThreadPreemption);
-    dst.kernelMetadata.compiledSubGroupsNumber = execEnv.CompiledSubGroupsNumber;
     dst.kernelAttributes.flags.usesFencesForReadWriteImages = (0 != execEnv.UsesFencesForReadWriteImages);
     dst.kernelAttributes.flags.requiresSubgroupIndependentForwardProgress = (0 != execEnv.SubgroupIndependentForwardProgressRequired);
-    dst.kernelAttributes.numGrfRequired = execEnv.NumGRFRequired;
-    dst.kernelAttributes.flags.useGlobalAtomics = execEnv.HasGlobalAtomics;
-    dst.kernelAttributes.flags.usesStatelessWrites = (execEnv.StatelessWritesCount > 0U);
+    dst.kernelAttributes.flags.useGlobalAtomics = (0 != execEnv.HasGlobalAtomics);
+    dst.kernelAttributes.flags.usesStatelessWrites = (0 != execEnv.StatelessWritesCount);
+
+    dst.kernelMetadata.compiledSubGroupsNumber = execEnv.CompiledSubGroupsNumber;
+    readExtendedInfo(dst.extendedInfo, execEnv);
 }
 
 void populateKernelDescriptor(KernelDescriptor &dst, const SPatchSamplerStateArray &token) {

shared/source/kernel/read_extended_info.cpp

@@ -0,0 +1,12 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/kernel/read_extended_info.h"
+
+namespace NEO {
+void readExtendedInfo(std::unique_ptr<ExtendedInfoBase> &extendedInfo, const iOpenCL::SPatchExecutionEnvironment &execEnv) {}
+} // namespace NEO

shared/source/kernel/read_extended_info.h

@@ -0,0 +1,15 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "kernel_descriptor.h"
+#include "patch_shared.h"
+
+#include <memory>
+
+namespace NEO {
+void readExtendedInfo(std::unique_ptr<ExtendedInfoBase> &extendedInfo, const iOpenCL::SPatchExecutionEnvironment &execEnv);
+} // namespace NEO

shared/test/unit_test/device_binary_format/zebin_decoder_tests.cpp

@@ -2777,8 +2777,8 @@ kernels:
     ASSERT_EQ(1U, programInfo.kernelInfos.size());
 
     auto &kernelDescriptor = programInfo.kernelInfos[0]->kernelDescriptor;
-    EXPECT_EQ(7U, kernelDescriptor.kernelAttributes.hasBarriers);
-    EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.usesBarriers);
+    EXPECT_EQ(7U, kernelDescriptor.kernelAttributes.barrierCount);
+    EXPECT_TRUE(kernelDescriptor.kernelAttributes.usesBarriers());
     EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption);
     EXPECT_EQ(13U, kernelDescriptor.kernelAttributes.numGrfRequired);
     EXPECT_EQ(KernelDescriptor::Stateless, kernelDescriptor.kernelAttributes.bufferAddressingMode);

shared/test/unit_test/kernel/kernel_descriptor_from_patchtokens_tests.cpp

@@ -93,10 +93,10 @@ TEST(KernelDescriptorFromPatchtokens, GivenExecutionEnvironmentThenSetsProperPar
     NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
     EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.usesDeviceSideEnqueue);
 
-    EXPECT_FALSE(kernelDescriptor.kernelAttributes.flags.usesBarriers);
+    EXPECT_FALSE(kernelDescriptor.kernelAttributes.usesBarriers());
     execEnv.HasBarriers = 1U;
     NEO::populateKernelDescriptor(kernelDescriptor, kernelTokens, 4);
-    EXPECT_TRUE(kernelDescriptor.kernelAttributes.flags.usesBarriers);
+    EXPECT_TRUE(kernelDescriptor.kernelAttributes.usesBarriers());
 
     EXPECT_FALSE(kernelDescriptor.kernelAttributes.flags.requiresDisabledMidThreadPreemption);
     execEnv.DisableMidThreadPreemption = 1U;