Enable transforming image 3d to image 2d array

Change-Id: I8fdc6899780481bdebeaf858a330e9dea822bda3

Author: JablonskiMateusz

runtime/kernel/CMakeLists.txt

@@ -21,6 +21,8 @@
 set(RUNTIME_SRCS_KERNEL
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
   ${CMAKE_CURRENT_SOURCE_DIR}/dynamic_kernel_info.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/image_transformer.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/image_transformer.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel.inl

runtime/kernel/image_transformer.cpp

@@ -0,0 +1,60 @@
+/*
+ * 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 "runtime/helpers/ptr_math.h"
+#include "runtime/kernel/image_transformer.h"
+#include "runtime/mem_obj/image.h"
+#include "runtime/program/kernel_info.h"
+
+namespace OCLRT {
+void ImageTransformer::registerImage3d(uint32_t argIndex) {
+    if (std::find(argIndexes.begin(), argIndexes.end(), argIndex) == argIndexes.end()) {
+        argIndexes.push_back(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) {
+            auto clMemObj = *(static_cast<const cl_mem *>(kernelArguments.at(argIndex).value));
+            auto image = castToObjectOrAbort<Image>(clMemObj);
+            auto surfaceState = ptrOffset(ssh, kernelInfo.kernelArgInfo.at(argIndex).offsetHeap);
+            image->transformImage3dTo2dArray(surfaceState);
+        }
+    }
+    transformed = true;
+}
+void ImageTransformer::transformImagesTo3d(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh) {
+    for (auto const &argIndex : argIndexes) {
+        auto clMemObj = *(static_cast<const cl_mem *>(kernelArguments.at(argIndex).value));
+        auto image = castToObjectOrAbort<Image>(clMemObj);
+        auto surfaceState = ptrOffset(ssh, kernelInfo.kernelArgInfo.at(argIndex).offsetHeap);
+        image->transformImage2dArrayTo3d(surfaceState);
+    }
+    transformed = false;
+}
+bool ImageTransformer::didTransform() const {
+    return transformed;
+}
+bool ImageTransformer::hasRegisteredImages3d() const {
+    return !argIndexes.empty();
+}
+}

runtime/kernel/image_transformer.h

@@ -0,0 +1,40 @@
+/*
+ * 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 "runtime/kernel/kernel.h"
+
+namespace OCLRT {
+
+class ImageTransformer {
+  public:
+    void registerImage3d(uint32_t argIndex);
+    void transformImagesTo2dArray(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh);
+    void transformImagesTo3d(const KernelInfo &kernelInfo, const std::vector<Kernel::SimpleKernelArgInfo> &kernelArguments, void *ssh);
+    bool didTransform() const;
+    bool hasRegisteredImages3d() const;
+
+  protected:
+    bool transformed = false;
+    std::vector<uint32_t> argIndexes;
+};
+}

runtime/kernel/kernel.cpp

@@ -41,6 +41,7 @@
 #include "runtime/mem_obj/buffer.h"
 #include "runtime/mem_obj/image.h"
 #include "runtime/mem_obj/pipe.h"
+#include "runtime/kernel/image_transformer.h"
 #include "runtime/memory_manager/memory_manager.h"
 #include "runtime/memory_manager/surface.h"
 #include "runtime/os_interface/debug_settings_manager.h"
@@ -105,6 +106,7 @@ Kernel::Kernel(Program *programArg, const KernelInfo &kernelInfoArg, const Devic
       kernelReflectionSurface(nullptr),
       usingSharedObjArgs(false) {
     program->retain();
+    imageTransformer.reset(new ImageTransformer);
 }
 
 Kernel::~Kernel() {
@@ -773,6 +775,7 @@ cl_int Kernel::setArg(uint32_t argIndex, size_t argSize, const void *argVal) {
             patchedArgumentsNum++;
             kernelArguments[argIndex].isPatched = true;
         }
+        resolveArgs();
     }
     return retVal;
 }
@@ -1210,6 +1213,10 @@ cl_int Kernel::setArgImageWithMipLevel(uint32_t argIndex,
         auto &imageDesc = pImage->getImageDesc();
         auto &imageFormat = pImage->getImageFormat();
 
+        if (imageDesc.image_type == CL_MEM_OBJECT_IMAGE3D) {
+            imageTransformer->registerImage3d(argIndex);
+        }
+
         patch<uint32_t, size_t>(imageDesc.image_width, crossThreadData, kernelArgInfo.offsetImgWidth);
         patch<uint32_t, size_t>(imageDesc.image_height, crossThreadData, kernelArgInfo.offsetImgHeight);
         patch<uint32_t, size_t>(imageDesc.image_depth, crossThreadData, kernelArgInfo.offsetImgDepth);
@@ -2045,4 +2052,31 @@ cl_int Kernel::checkCorrectImageAccessQualifier(cl_uint argIndex,
     }
     return CL_SUCCESS;
 }
+
+void Kernel::resolveArgs() {
+    if (!Kernel::isPatched() || !imageTransformer->hasRegisteredImages3d() || !canTransformImages())
+        return;
+    bool canTransformImageTo2dArray = true;
+    for (uint32_t i = 0; i < patchedArgumentsNum; i++) {
+        if (kernelInfo.kernelArgInfo.at(i).isSampler) {
+            auto clSamplerObj = *(static_cast<const cl_sampler *>(kernelArguments.at(i).value));
+            auto sampler = castToObjectOrAbort<Sampler>(clSamplerObj);
+            if (sampler->isTransformable()) {
+                canTransformImageTo2dArray = true;
+            } else {
+                canTransformImageTo2dArray = false;
+                break;
+            }
+        }
+    }
+    if (canTransformImageTo2dArray) {
+        imageTransformer->transformImagesTo2dArray(kernelInfo, kernelArguments, getSurfaceStateHeap());
+    } else if (imageTransformer->didTransform()) {
+        imageTransformer->transformImagesTo3d(kernelInfo, kernelArguments, getSurfaceStateHeap());
+    }
+}
+
+bool Kernel::canTransformImages() const {
+    return device.getHardwareInfo().pPlatform->eRenderCoreFamily >= IGFX_GEN9_CORE;
+}
 } // namespace OCLRT

runtime/kernel/kernel.h

@@ -35,6 +35,7 @@
 namespace OCLRT {
 struct CompletionStamp;
 class GraphicsAllocation;
+class ImageTransformer;
 class Surface;
 class PrintfHandler;
 
@@ -126,6 +127,7 @@ class Kernel : public BaseObject<_cl_kernel> {
 
     cl_int cloneKernel(Kernel *pSourceKernel);
 
+    MOCKABLE_VIRTUAL bool canTransformImages() const;
     MOCKABLE_VIRTUAL bool isPatched() const;
 
     // API entry points
@@ -455,6 +457,8 @@ class Kernel : public BaseObject<_cl_kernel> {
 
     void patchBlocksCurbeWithConstantValues();
 
+    void resolveArgs();
+
     Program *program;
     Context *context;
     const Device &device;
@@ -481,5 +485,6 @@ class Kernel : public BaseObject<_cl_kernel> {
     uint32_t patchedArgumentsNum = 0;
 
     std::vector<PatchInfoData> patchInfoDataList;
+    std::unique_ptr<ImageTransformer> imageTransformer;
 };
 } // namespace OCLRT

runtime/mem_obj/image.h

@@ -182,6 +182,9 @@ class Image : public MemObj {
     const McsSurfaceInfo &getMcsSurfaceInfo() { return mcsSurfaceInfo; }
     size_t calculateOffsetForMapping(const MemObjOffsetArray &origin) const override;
 
+    virtual void transformImage2dArrayTo3d(void *memory) = 0;
+    virtual void transformImage3dTo2dArray(void *memory) = 0;
+
     const bool isTiledImage;
 
   protected:
@@ -272,7 +275,8 @@ class ImageHw : public Image {
     void setMediaSurfaceRotation(void *memory) override;
     void setSurfaceMemoryObjectControlStateIndexToMocsTable(void *memory, uint32_t value) override;
     void appendSurfaceStateParams(RENDER_SURFACE_STATE *surfaceState);
-
+    void transformImage2dArrayTo3d(void *memory) override;
+    void transformImage3dTo2dArray(void *memory) override;
     static Image *create(Context *context,
                          cl_mem_flags flags,
                          size_t size,

runtime/mem_obj/image.inl

@@ -250,4 +250,21 @@ void ImageHw<GfxFamily>::setMediaImageArg(void *memory) {
 
     surfaceState->setSurfaceBaseAddress(getGraphicsAllocation()->getGpuAddress() + this->surfaceOffsets.offset);
 }
+
+template <typename GfxFamily>
+void ImageHw<GfxFamily>::transformImage2dArrayTo3d(void *memory) {
+    DEBUG_BREAK_IF(imageDesc.image_type != CL_MEM_OBJECT_IMAGE3D);
+    using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
+    auto surfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(memory);
+    surfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_3D);
+    surfaceState->setSurfaceArray(false);
+}
+template <typename GfxFamily>
+void ImageHw<GfxFamily>::transformImage3dTo2dArray(void *memory) {
+    DEBUG_BREAK_IF(imageDesc.image_type != CL_MEM_OBJECT_IMAGE3D);
+    using SURFACE_TYPE = typename RENDER_SURFACE_STATE::SURFACE_TYPE;
+    auto surfaceState = reinterpret_cast<RENDER_SURFACE_STATE *>(memory);
+    surfaceState->setSurfaceType(SURFACE_TYPE::SURFACE_TYPE_SURFTYPE_2D);
+    surfaceState->setSurfaceArray(true);
+}
 } // namespace OCLRT

runtime/program/kernel_arg_info.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 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"),
@@ -69,6 +69,7 @@ struct KernelArgInfo {
     uint32_t offsetBufferOffset = undefinedOffset;
 
     bool needPatch = false;
+    bool isTransformable = false;
 
     cl_kernel_arg_access_qualifier accessQualifier = CL_KERNEL_ARG_ACCESS_NONE;
     cl_kernel_arg_address_qualifier addressQualifier = CL_KERNEL_ARG_ADDRESS_GLOBAL;

runtime/program/kernel_info.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 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"),
@@ -303,6 +303,8 @@ void KernelInfo::storeKernelArgument(
     kernelArgInfo[argNum].accessQualifier = pImageMemObjKernelArg->Writeable
                                                 ? CL_KERNEL_ARG_ACCESS_READ_WRITE
                                                 : CL_KERNEL_ARG_ACCESS_READ_ONLY;
+
+    kernelArgInfo[argNum].isTransformable = pImageMemObjKernelArg->Transformable != 0;
     patchInfo.imageMemObjKernelArgs.push_back(pImageMemObjKernelArg);
 }
 

runtime/sampler/sampler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 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"),
@@ -187,4 +187,11 @@ cl_int Sampler::getInfo(cl_sampler_info paramName, size_t paramValueSize,
 
     return retVal;
 }
+
+bool Sampler::isTransformable() const {
+    return addressingMode == CL_ADDRESS_CLAMP_TO_EDGE &&
+           filterMode == CL_FILTER_NEAREST &&
+           normalizedCoordinates == CL_FALSE;
+}
+
 } // namespace OCLRT