Adding support for get_image_num_mip_levels

* patch token decoding
* crossthread data patching

* additionally, fixing nasty ODR violation in VA tests
  (note : ODR = One Definition Rule)

Change-Id: I9803ed599826c97359349d2b8fa0d86e46cb33ea

Author: jchodor

runtime/kernel/kernel.cpp

@@ -1235,6 +1235,7 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
         patch<uint32_t, cl_channel_type>(imageFormat.image_channel_data_type, crossThreadData, kernelArgInfo.offsetChannelDataType);
         patch<uint32_t, cl_channel_order>(imageFormat.image_channel_order, crossThreadData, kernelArgInfo.offsetChannelOrder);
         patch<uint32_t, uint32_t>(kernelArgInfo.offsetHeap, crossThreadData, kernelArgInfo.offsetObjectId);
+        patch<uint32_t, cl_uint>(imageDesc.num_mip_levels, crossThreadData, kernelArgInfo.offsetNumMipLevels);
 
         retVal = CL_SUCCESS;
     }

runtime/program/kernel_arg_info.h

@@ -67,6 +67,7 @@ struct KernelArgInfo {
     uint32_t offsetVmeSearchPathType = undefinedOffset;
     uint32_t offsetObjectId = undefinedOffset;
     uint32_t offsetBufferOffset = undefinedOffset;
+    uint32_t offsetNumMipLevels = undefinedOffset;
 
     bool needPatch = false;
     bool isTransformable = false;

runtime/program/process_gen_binary.cpp

@@ -430,6 +430,11 @@ cl_int Program::parsePatchList(KernelInfo &kernelInfo) {
                 break;
 
             case DATA_PARAMETER_IMAGE_NUM_MIP_LEVELS:
+                DBG_LOG(LogPatchTokens, "\n  .Type", "IMAGE_NUM_MIP_LEVELS");
+                kernelInfo.resizeKernelArgInfoAndRegisterParameter(argNum);
+                kernelInfo.kernelArgInfo[argNum].offsetNumMipLevels = pDataParameterBuffer->Offset;
+                DEBUG_BREAK_IF(pDataParameterBuffer->DataSize != sizeof(uint32_t));
+                break;
             case DATA_PARAMETER_IMAGE_SRGB_CHANNEL_ORDER:
             case DATA_PARAMETER_STAGE_IN_GRID_ORIGIN:
             case DATA_PARAMETER_STAGE_IN_GRID_SIZE:

unit_tests/fixtures/CMakeLists.txt

@@ -32,6 +32,8 @@ set(IGDRCL_SRCS_tests_fixtures
   ${CMAKE_CURRENT_SOURCE_DIR}/hello_world_kernel_fixture.h
   ${CMAKE_CURRENT_SOURCE_DIR}/image_fixture.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/image_fixture.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_fixture.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/kernel_arg_fixture.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_data_fixture.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_data_fixture.h
   ${CMAKE_CURRENT_SOURCE_DIR}/media_kernel_fixture.h

unit_tests/fixtures/kernel_arg_fixture.cpp

@@ -0,0 +1,93 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#include "unit_tests/fixtures/kernel_arg_fixture.h"
+
+#include "unit_tests/fixtures/image_fixture.h"
+#include "unit_tests/mocks/mock_context.h"
+#include "unit_tests/mocks/mock_kernel.h"
+#include "unit_tests/mocks/mock_program.h"
+#include "unit_tests/mocks/mock_image.h"
+
+KernelImageArgTest::~KernelImageArgTest() = default;
+
+void KernelImageArgTest::SetUp() {
+    pKernelInfo.reset(OCLRT::KernelInfo::create());
+    KernelArgPatchInfo kernelArgPatchInfo;
+    kernelHeader.reset(new iOpenCL::SKernelBinaryHeaderCommon{});
+
+    kernelHeader->SurfaceStateHeapSize = sizeof(surfaceStateHeap);
+    pKernelInfo->heapInfo.pSsh = surfaceStateHeap;
+    pKernelInfo->heapInfo.pKernelHeader = kernelHeader.get();
+    pKernelInfo->usesSsh = true;
+
+    pKernelInfo->kernelArgInfo.resize(5);
+    pKernelInfo->kernelArgInfo[4].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
+    pKernelInfo->kernelArgInfo[3].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
+    pKernelInfo->kernelArgInfo[2].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
+    pKernelInfo->kernelArgInfo[1].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
+    pKernelInfo->kernelArgInfo[0].kernelArgPatchInfoVector.push_back(kernelArgPatchInfo);
+
+    pKernelInfo->kernelArgInfo[0].offsetImgWidth = 0x4;
+    pKernelInfo->kernelArgInfo[0].offsetNumSamples = 0x3c;
+    offsetNumMipLevelsImage0 = 0x40;
+    pKernelInfo->kernelArgInfo[0].offsetNumMipLevels = offsetNumMipLevelsImage0;
+    pKernelInfo->kernelArgInfo[1].offsetImgHeight = 0xc;
+    pKernelInfo->kernelArgInfo[2].kernelArgPatchInfoVector[0].crossthreadOffset = 0x20;
+    pKernelInfo->kernelArgInfo[2].kernelArgPatchInfoVector[0].size = sizeof(void *);
+    pKernelInfo->kernelArgInfo[3].offsetImgDepth = 0x30;
+    pKernelInfo->kernelArgInfo[4].offsetHeap = 0x20;
+    pKernelInfo->kernelArgInfo[4].offsetObjectId = 0x0;
+
+    pKernelInfo->kernelArgInfo[4].isImage = true;
+    pKernelInfo->kernelArgInfo[3].isImage = true;
+    pKernelInfo->kernelArgInfo[2].isImage = true;
+    pKernelInfo->kernelArgInfo[1].isImage = true;
+    pKernelInfo->kernelArgInfo[0].isImage = true;
+
+    DeviceFixture::SetUp();
+    program.reset(new OCLRT::MockProgram);
+    pKernel.reset(new OCLRT::MockKernel(program.get(), *pKernelInfo, *pDevice));
+    ASSERT_EQ(CL_SUCCESS, pKernel->initialize());
+
+    pKernel->setKernelArgHandler(0, &OCLRT::Kernel::setArgImage);
+    pKernel->setKernelArgHandler(1, &OCLRT::Kernel::setArgImage);
+    pKernel->setKernelArgHandler(2, &OCLRT::Kernel::setArgImmediate);
+    pKernel->setKernelArgHandler(3, &OCLRT::Kernel::setArgImage);
+    pKernel->setKernelArgHandler(4, &OCLRT::Kernel::setArgImage);
+
+    uint32_t crossThreadData[0x44] = {};
+    crossThreadData[0x20 / sizeof(uint32_t)] = 0x12344321;
+    pKernel->setCrossThreadData(crossThreadData, sizeof(crossThreadData));
+
+    context.reset(new OCLRT::MockContext(pDevice));
+    image.reset(Image2dHelper<>::create(context.get()));
+    ASSERT_NE(nullptr, image);
+}
+
+void KernelImageArgTest::TearDown() {
+    image.reset();
+    pKernel.reset();
+    program.reset();
+    context.reset();
+    DeviceFixture::TearDown();
+}

unit_tests/fixtures/kernel_arg_fixture.h

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2018, Intel Corporation
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#pragma once
+
+#include "unit_tests/fixtures/device_fixture.h"
+#include "unit_tests/gen_common/test.h"
+
+#include <cstdint>
+
+namespace OCLRT {
+class MockContext;
+class MockKernel;
+class MockProgram;
+class Image;
+struct KernelInfo;
+}
+
+namespace iOpenCL {
+struct SKernelBinaryHeaderCommon;
+}
+
+class KernelImageArgTest : public Test<DeviceFixture> {
+  public:
+    KernelImageArgTest() {
+    }
+
+    ~KernelImageArgTest() override;
+
+  protected:
+    void SetUp() override;
+
+    void TearDown() override;
+
+    cl_int retVal = 0;
+    std::unique_ptr<iOpenCL::SKernelBinaryHeaderCommon> kernelHeader;
+    std::unique_ptr<OCLRT::MockContext> context;
+    std::unique_ptr<OCLRT::MockProgram> program;
+    std::unique_ptr<OCLRT::KernelInfo> pKernelInfo;
+    std::unique_ptr<OCLRT::MockKernel> pKernel;
+    std::unique_ptr<OCLRT::Image> image;
+
+    char surfaceStateHeap[0x80];
+    uint32_t offsetNumMipLevelsImage0 = -1;
+};

unit_tests/helpers/mipmap_tests.cpp

@@ -24,6 +24,7 @@
 #include "runtime/mem_obj/image.h"
 #include "unit_tests/mocks/mock_buffer.h"
 #include "unit_tests/mocks/mock_gmm.h"
+#include "unit_tests/mocks/mock_image.h"
 
 #include "gtest/gtest.h"
 
@@ -107,40 +108,17 @@ struct MockMipMapGmmResourceInfo : GmmResourceInfo {
     }
 };
 
-struct MockImage : public OCLRT::Image {
-    using Image::imageDesc;
-    using Image::graphicsAllocation;
-
+struct MockImage : MockImageBase {
     MockGmm mockGmm;
 
-    MockImage() : Image(nullptr, cl_mem_flags{}, 0, nullptr, cl_image_format{},
-                        cl_image_desc{}, false, new MockGraphicsAllocation(nullptr, 0), false, false,
-                        0, 0, SurfaceFormatInfo{}, nullptr) {
+    MockImage() : MockImageBase() {
         graphicsAllocation->gmm = &mockGmm;
         mockGmm.gmmResourceInfo.reset(new MockMipMapGmmResourceInfo());
     }
-    ~MockImage() override {
-        delete this->graphicsAllocation;
-    }
-
-    MockGraphicsAllocation *getAllocation() {
-        return static_cast<MockGraphicsAllocation *>(graphicsAllocation);
-    }
 
     MockMipMapGmmResourceInfo *getResourceInfo() {
         return static_cast<MockMipMapGmmResourceInfo *>(mockGmm.gmmResourceInfo.get());
     }
-
-    void setImageArg(void *memory, bool isMediaBlockImage, uint32_t mipLevel) override {
-    }
-    void setMediaImageArg(void *memory) override {
-    }
-    void setMediaSurfaceRotation(void *memory) override {
-    }
-    void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override {
-    }
-    void transformImage2dArrayTo3d(void *memory) override {}
-    void transformImage3dTo2dArray(void *memory) override {}
 };
 
 TEST(MipmapHelper, givenImageWithoutMipLevelsWhenIsMipMappedIsCalledThenFalseIsReturned) {