Remove KernelArgInfo and use KernelDescriptor's args instead

Related-To: NEO-4729
Signed-off-by: Krystian Chmielewski <[email protected]>

Author: KrystianChmielewski

level_zero/core/source/module/module_imp.cpp

@@ -347,7 +347,6 @@ ModuleImp::~ModuleImp() {
 
 bool ModuleImp::initialize(const ze_module_desc_t *desc, NEO::Device *neoDevice) {
     bool success = true;
-    NEO::useKernelDescriptor = true;
 
     std::string buildOptions;
     std::string internalBuildOptions;

level_zero/core/test/unit_tests/main.cpp

@@ -255,7 +255,6 @@ int main(int argc, char **argv) {
     NEO::defaultHwInfo = std::make_unique<NEO::HardwareInfo>();
     *NEO::defaultHwInfo = hwInfoForTests;
 
-    NEO::useKernelDescriptor = true;
     NEO::MockSipData::mockSipKernel.reset(new NEO::MockSipKernel());
 
     environment = reinterpret_cast<TestEnvironment *>(::testing::AddGlobalTestEnvironment(new TestEnvironment));

opencl/source/api/api.cpp

@@ -4832,7 +4832,10 @@ cl_int CL_API_CALL clSetKernelArgSVMPointer(cl_kernel kernel,
 
     for (const auto &pDevice : pMultiDeviceKernel->getDevices()) {
         auto pKernel = pMultiDeviceKernel->getKernel(pDevice->getRootDeviceIndex());
-        cl_int kernelArgAddressQualifier = asClKernelArgAddressQualifier(pKernel->getKernelInfo().kernelArgInfo[argIndex].metadata.getAddressQualifier());
+        cl_int kernelArgAddressQualifier = asClKernelArgAddressQualifier(pKernel->getKernelInfo()
+                                                                             .kernelDescriptor.payloadMappings.explicitArgs[argIndex]
+                                                                             .getTraits()
+                                                                             .getAddressQualifier());
         if ((kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_GLOBAL) &&
             (kernelArgAddressQualifier != CL_KERNEL_ARG_ADDRESS_CONSTANT)) {
             retVal = CL_INVALID_ARG_VALUE;

opencl/source/built_ins/vme_dispatch_builder.h

@@ -166,11 +166,12 @@ class VmeBuiltinDispatchInfoBuilder : public BuiltinDispatchInfoBuilder {
 
     template <typename RetType>
     RetType getKernelArgByValValue(uint32_t argNum) const {
-        auto &kernelArgInfo = vmeKernel->getKernelInfo().kernelArgInfo[argNum];
-        DEBUG_BREAK_IF(kernelArgInfo.kernelArgPatchInfoVector.size() != 1);
-        const KernelArgPatchInfo &patchInfo = kernelArgInfo.kernelArgPatchInfoVector[0];
-        DEBUG_BREAK_IF(sizeof(RetType) > patchInfo.size);
-        return *(RetType *)(vmeKernel->getCrossThreadData() + patchInfo.crossthreadOffset);
+        const auto &argAsVal = vmeKernel->getKernelInfo().kernelDescriptor.payloadMappings.explicitArgs[argNum].as<ArgDescValue>();
+        DEBUG_BREAK_IF(argAsVal.elements.size() != 1);
+
+        const auto &element = argAsVal.elements[0];
+        DEBUG_BREAK_IF(sizeof(RetType) > element.size);
+        return *(RetType *)(vmeKernel->getCrossThreadData() + element.offset);
     }
 
     cl_int validateImages(Vec3<size_t> inputRegion, Vec3<size_t> offset) const {

opencl/source/command_queue/command_queue.cpp

@@ -536,7 +536,7 @@ void CommandQueue::enqueueBlockedMapUnmapOperation(const cl_event *eventWaitList
 bool CommandQueue::setupDebugSurface(Kernel *kernel) {
     auto debugSurface = getGpgpuCommandStreamReceiver().getDebugSurfaceAllocation();
 
-    DEBUG_BREAK_IF(!kernel->requiresSshForBuffers());
+    DEBUG_BREAK_IF(!kernel->usesBindfulAddressingForBuffers());
     auto surfaceState = ptrOffset(reinterpret_cast<uintptr_t *>(kernel->getSurfaceStateHeap()),
                                   kernel->getKernelInfo().kernelDescriptor.payloadMappings.implicitArgs.systemThreadSurfaceAddress.bindful);
     void *addressToPatch = reinterpret_cast<void *>(debugSurface->getGpuAddress());

opencl/source/helpers/cl_hw_helper_base.inl

@@ -20,13 +20,12 @@ inline bool ClHwHelperHw<GfxFamily>::requiresAuxResolves(const KernelInfo &kerne
 
 template <typename GfxFamily>
 inline bool ClHwHelperHw<GfxFamily>::hasStatelessAccessToBuffer(const KernelInfo &kernelInfo) const {
-    bool hasStatelessAccessToBuffer = false;
-    for (uint32_t i = 0; i < kernelInfo.kernelArgInfo.size(); ++i) {
-        if (kernelInfo.kernelArgInfo[i].isBuffer) {
-            hasStatelessAccessToBuffer |= !kernelInfo.kernelArgInfo[i].pureStatefulBufferAccess;
+    for (const auto &arg : kernelInfo.kernelDescriptor.payloadMappings.explicitArgs) {
+        if (arg.is<ArgDescriptor::ArgTPointer>() && !arg.as<ArgDescPointer>().isPureStateful()) {
+            return true;
         }
     }
-    return hasStatelessAccessToBuffer;
+    return false;
 }
 
 template <typename GfxFamily>

opencl/source/kernel/image_transformer.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018-2020 Intel Corporation
+ * Copyright (C) 2018-2021 Intel Corporation
  *
  * SPDX-License-Identifier: MIT
  *
@@ -20,20 +20,22 @@ void ImageTransformer::registerImage3d(uint32_t argIndex) {
 }
 void ImageTransformer::transformImagesTo2dArray(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh) {
     for (auto const &argIndex : argIndexes) {
-        if (kernelInfo.kernelArgInfo.at(argIndex).isTransformable) {
+        const auto &arg = kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[argIndex];
+        if (arg.getExtendedTypeInfo().isTransformable) {
             auto clMemObj = static_cast<cl_mem>(kernelArguments.at(argIndex).object);
             auto image = castToObjectOrAbort<Image>(clMemObj);
-            auto surfaceState = ptrOffset(ssh, kernelInfo.kernelArgInfo.at(argIndex).offsetHeap);
+            auto surfaceState = ptrOffset(ssh, arg.as<ArgDescImage>().bindful);
             image->transformImage3dTo2dArray(surfaceState);
         }
     }
     transformed = true;
 }
 void ImageTransformer::transformImagesTo3d(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh) {
     for (auto const &argIndex : argIndexes) {
+        const auto &arg = kernelInfo.kernelDescriptor.payloadMappings.explicitArgs[argIndex];
         auto clMemObj = static_cast<cl_mem>(kernelArguments.at(argIndex).object);
         auto image = castToObjectOrAbort<Image>(clMemObj);
-        auto surfaceState = ptrOffset(ssh, kernelInfo.kernelArgInfo.at(argIndex).offsetHeap);
+        auto surfaceState = ptrOffset(ssh, arg.as<ArgDescImage>().bindful);
         image->transformImage2dArrayTo3d(surfaceState);
     }
     transformed = false;