[1/n] Mipmap support

* adding support for map/unmap
* adding support for origin/region validation with mipmaps
* fixing slices returned in map/unmap
* removing ambiguity around mipLevel naming
* enabling cl_khr_mipmap_image in current shape
* enabling cl_khr_mipmap_image_writes in current shape

* fixing CompileProgramWithReraFlag test

Change-Id: I0c9d83028c5c376f638e45151755fd2c7d0fb0ab

Author: jchodor

Jenkinsfile

@@ -2,4 +2,4 @@
 neoDependenciesRev='748020-807'
 strategy='EQUAL'
 allowedF=40
-allowedCD=336
+allowedCD=335

runtime/api/api.cpp

@@ -2057,7 +2057,7 @@ cl_int CL_API_CALL clEnqueueReadImage(cl_command_queue commandQueue,
             if (retVal != CL_SUCCESS)
                 return retVal;
         }
-        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2113,7 +2113,7 @@ cl_int CL_API_CALL clEnqueueWriteImage(cl_command_queue commandQueue,
             if (retVal != CL_SUCCESS)
                 return retVal;
         }
-        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2159,7 +2159,7 @@ cl_int CL_API_CALL clEnqueueFillImage(cl_command_queue commandQueue,
                    "numEventsInWaitList", numEventsInWaitList, "event", event);
 
     if (CL_SUCCESS == retVal) {
-        if (!Image::validateRegionAndOrigin(origin, region, dstImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(origin, region, dstImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2217,10 +2217,10 @@ cl_int CL_API_CALL clEnqueueCopyImage(cl_command_queue commandQueue,
             if (pDstImage->getImageDesc().image_type == CL_MEM_OBJECT_IMAGE2D && dstOrigin[2] != 0)
                 return CL_INVALID_VALUE;
         }
-        if (!Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
-        if (!Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2271,7 +2271,7 @@ cl_int CL_API_CALL clEnqueueCopyImageToBuffer(cl_command_queue commandQueue,
             if (retVal != CL_SUCCESS)
                 return retVal;
         }
-        if (!Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(srcOrigin, region, pSrcImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2323,7 +2323,7 @@ cl_int CL_API_CALL clEnqueueCopyBufferToImage(cl_command_queue commandQueue,
             if (retVal != CL_SUCCESS)
                 return retVal;
         }
-        if (!Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(dstOrigin, region, pDstImage->getImageDesc())) {
             return CL_INVALID_VALUE;
         }
 
@@ -2452,7 +2452,7 @@ void *CL_API_CALL clEnqueueMapImage(cl_command_queue commandQueue,
             }
         }
 
-        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc().image_type)) {
+        if (!Image::validateRegionAndOrigin(origin, region, pImage->getImageDesc())) {
             retVal = CL_INVALID_VALUE;
             break;
         }

runtime/command_queue/command_queue.cpp

@@ -33,6 +33,7 @@
 #include "runtime/helpers/aligned_memory.h"
 #include "runtime/helpers/array_count.h"
 #include "runtime/helpers/get_info.h"
+#include "runtime/helpers/mipmap.h"
 #include "runtime/helpers/options.h"
 #include "runtime/helpers/ptr_math.h"
 #include "runtime/mem_obj/buffer.h"
@@ -463,8 +464,12 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
             retVal = enqueueWriteBuffer(buffer, CL_TRUE, unmapInfo.offset[0], unmapInfo.size[0], mappedPtr,
                                         eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
         } else {
-            auto image = castToObject<Image>(memObj);
-            retVal = enqueueWriteImage(image, CL_FALSE, &unmapInfo.offset[0], &unmapInfo.size[0],
+            auto image = castToObjectOrAbort<Image>(memObj);
+            size_t writeOrigin[4] = {unmapInfo.offset[0], unmapInfo.offset[1], unmapInfo.offset[2], 0};
+            auto mipIdx = getMipLevelOriginIdx(image->peekClMemObjType());
+            UNRECOVERABLE_IF(mipIdx >= 4);
+            writeOrigin[mipIdx] = unmapInfo.mipLevel;
+            retVal = enqueueWriteImage(image, CL_FALSE, writeOrigin, &unmapInfo.size[0],
                                        image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(), mappedPtr,
                                        eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
             bool mustCallFinish = true;
@@ -493,10 +498,10 @@ cl_int CommandQueue::enqueueWriteMemObjForUnmap(MemObj *memObj, void *mappedPtr,
 
 void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperties, EventsRequest &eventsRequest, cl_int &errcodeRet) {
     void *returnPtr = ptrOffset(transferProperties.memObj->getBasePtrForMap(),
-                                transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset));
+                                transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset) + transferProperties.mipPtrOffset);
 
     if (!transferProperties.memObj->addMappedPtr(returnPtr, transferProperties.memObj->calculateMappedPtrLength(transferProperties.size),
-                                                 transferProperties.mapFlags, transferProperties.size, transferProperties.offset)) {
+                                                 transferProperties.mapFlags, transferProperties.size, transferProperties.offset, transferProperties.mipLevel)) {
         errcodeRet = CL_INVALID_OPERATION;
         return nullptr;
     }
@@ -506,8 +511,12 @@ void *CommandQueue::enqueueReadMemObjForMap(TransferProperties &transferProperti
         errcodeRet = enqueueReadBuffer(buffer, transferProperties.blocking, transferProperties.offset[0], transferProperties.size[0], returnPtr,
                                        eventsRequest.numEventsInWaitList, eventsRequest.eventWaitList, eventsRequest.outEvent);
     } else {
-        auto image = castToObject<Image>(transferProperties.memObj);
-        errcodeRet = enqueueReadImage(image, transferProperties.blocking, &transferProperties.offset[0], &transferProperties.size[0],
+        auto image = castToObjectOrAbort<Image>(transferProperties.memObj);
+        size_t readOrigin[4] = {transferProperties.offset[0], transferProperties.offset[1], transferProperties.offset[2], 0};
+        auto mipIdx = getMipLevelOriginIdx(image->peekClMemObjType());
+        UNRECOVERABLE_IF(mipIdx >= 4);
+        readOrigin[mipIdx] = transferProperties.mipLevel;
+        errcodeRet = enqueueReadImage(image, transferProperties.blocking, readOrigin, &transferProperties.size[0],
                                       image->getHostPtrRowPitch(), image->getHostPtrSlicePitch(), returnPtr, eventsRequest.numEventsInWaitList,
                                       eventsRequest.eventWaitList, eventsRequest.outEvent);
     }
@@ -560,7 +569,6 @@ void *CommandQueue::enqueueMapImage(Image *image, cl_bool blockingMap,
                                     cl_uint numEventsInWaitList,
                                     const cl_event *eventWaitList, cl_event *event,
                                     cl_int &errcodeRet) {
-
     TransferProperties transferProperties(image, CL_COMMAND_MAP_IMAGE, mapFlags, blockingMap != CL_FALSE,
                                           const_cast<size_t *>(origin), const_cast<size_t *>(region), nullptr);
     EventsRequest eventsRequest(numEventsInWaitList, eventWaitList, event);
@@ -572,7 +580,9 @@ void *CommandQueue::enqueueMapImage(Image *image, cl_bool blockingMap,
         GetInfoHelper::set(imageSlicePitch, image->getHostPtrSlicePitch());
         GetInfoHelper::set(imageRowPitch, image->getHostPtrRowPitch());
     }
-
+    if (Image::hasSlices(image->peekClMemObjType()) == false) {
+        GetInfoHelper::set(imageSlicePitch, static_cast<size_t>(0));
+    }
     return enqueueMapMemObject(transferProperties, eventsRequest, errcodeRet);
 }
 

runtime/command_queue/cpu_data_transfer_handler.cpp

@@ -25,6 +25,7 @@
 #include "runtime/context/context.h"
 #include "runtime/event/event_builder.h"
 #include "runtime/helpers/get_info.h"
+#include "runtime/helpers/mipmap.h"
 #include "runtime/mem_obj/buffer.h"
 #include "runtime/mem_obj/image.h"
 
@@ -41,10 +42,10 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
 
     if (mapOperation) {
         returnPtr = ptrOffset(transferProperties.memObj->getCpuAddressForMapping(),
-                              transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset));
+                              transferProperties.memObj->calculateOffsetForMapping(transferProperties.offset) + transferProperties.mipPtrOffset);
 
         if (!transferProperties.memObj->addMappedPtr(returnPtr, transferProperties.memObj->calculateMappedPtrLength(transferProperties.size),
-                                                     transferProperties.mapFlags, transferProperties.size, transferProperties.offset)) {
+                                                     transferProperties.mapFlags, transferProperties.size, transferProperties.offset, transferProperties.mipLevel)) {
             err.set(CL_INVALID_OPERATION);
             return nullptr;
         }
@@ -115,6 +116,7 @@ void *CommandQueue::cpuDataTransferHandler(TransferProperties &transferPropertie
             outEventObj->setStartTimeStamp();
         }
 
+        UNRECOVERABLE_IF((transferProperties.memObj->isMemObjZeroCopy() == false) && isMipMapped(transferProperties.memObj));
         switch (transferProperties.cmdType) {
         case CL_COMMAND_MAP_BUFFER:
             if (!transferProperties.memObj->isMemObjZeroCopy()) {

runtime/gmm_helper/gmm_helper.cpp

@@ -1,24 +1,24 @@
 /*
- * Copyright (c) 2017, 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.
- */
+* 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"),
+* 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/gmm_helper/gmm_helper.h"
 #include "runtime/gmm_helper/resource_info.h"
@@ -178,7 +178,7 @@ void Gmm::queryImageParams(ImageInfo &imgInfo, const HardwareInfo &hwInfo) {
     this->resourceParams.Depth = imageDepth;
     this->resourceParams.ArraySize = imageCount;
     this->resourceParams.Flags.Wa.__ForceOtherHVALIGN4 = 1;
-    this->resourceParams.MaxLod = imgInfo.mipLevel;
+    this->resourceParams.MaxLod = imgInfo.baseMipLevel + imgInfo.mipCount;
     if (imgInfo.imgDesc->image_row_pitch && imgInfo.imgDesc->mem_object) {
         this->resourceParams.OverridePitch = (uint32_t)imgInfo.imgDesc->image_row_pitch;
         this->resourceParams.Flags.Info.AllowVirtualPadding = true;

runtime/helpers/CMakeLists.txt

@@ -56,6 +56,7 @@ set(RUNTIME_SRCS_HELPERS_BASE
   ${CMAKE_CURRENT_SOURCE_DIR}/kernel_commands.inl
   ${CMAKE_CURRENT_SOURCE_DIR}/kmd_notify_properties.h
   ${CMAKE_CURRENT_SOURCE_DIR}/kmd_notify_properties.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/mipmap.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/mipmap.h
   ${CMAKE_CURRENT_SOURCE_DIR}/options.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/options.h

runtime/helpers/base_object.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"),
@@ -73,6 +73,11 @@ inline DerivedType *castToObjectOrAbort(typename DerivedType::BaseType *object)
     }
 }
 
+template <typename DerivedType>
+inline const DerivedType *castToObject(const typename DerivedType::BaseType *object) {
+    return const_cast<const DerivedType *>(castToObject<DerivedType>(const_cast<typename DerivedType::BaseType *>(object)));
+}
+
 extern std::thread::id invalidThreadID;
 
 class ConditionVariableWithCounter {

runtime/helpers/debug_helpers.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"),
@@ -43,5 +43,5 @@
 
 namespace OCLRT {
 void debugBreak(int line, const char *file);
-void abortUnrecoverable(int line, const char *file);
+[[noreturn]] void abortUnrecoverable(int line, const char *file);
 } // namespace OCLRT

runtime/helpers/mipmap.cpp

@@ -0,0 +1,109 @@
+/*
+* 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/mipmap.h"
+
+#include "runtime/gmm_helper/gmm_helper.h"
+#include "runtime/gmm_helper/resource_info.h"
+#include "runtime/mem_obj/image.h"
+
+#include <cstdint>
+
+namespace OCLRT {
+
+uint32_t getMipLevelOriginIdx(cl_mem_object_type imageType) {
+    switch (imageType) {
+    case CL_MEM_OBJECT_IMAGE1D:
+        return 1;
+    case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+    case CL_MEM_OBJECT_IMAGE2D:
+        return 2;
+    case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+    case CL_MEM_OBJECT_IMAGE3D:
+        return 3;
+    default:
+        DEBUG_BREAK_IF(true);
+        return -1;
+    }
+}
+
+uint32_t findMipLevel(cl_mem_object_type imageType, const size_t *origin) {
+    size_t mipLevel = 0;
+    switch (imageType) {
+    case CL_MEM_OBJECT_IMAGE1D:
+    case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+    case CL_MEM_OBJECT_IMAGE2D:
+    case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+    case CL_MEM_OBJECT_IMAGE3D:
+        mipLevel = origin[getMipLevelOriginIdx(imageType)];
+        break;
+    default:
+        mipLevel = 0;
+        break;
+    }
+
+    return static_cast<uint32_t>(mipLevel);
+}
+
+bool isMipMapped(const MemObj *memObj) {
+    auto image = castToObject<Image>(memObj);
+    if (image == nullptr) {
+        return false;
+    }
+    return isMipMapped(image->getImageDesc());
+}
+
+uint32_t getMipOffset(Image *image, const size_t *origin) {
+    if (isMipMapped(image) == false) {
+        return 0;
+    }
+    UNRECOVERABLE_IF(origin == nullptr);
+
+    auto imageType = image->getImageDesc().image_type;
+    GMM_REQ_OFFSET_INFO GMMReqInfo = {};
+    GMMReqInfo.ReqLock = 1;
+    GMMReqInfo.MipLevel = findMipLevel(imageType, origin);
+    switch (imageType) {
+    case CL_MEM_OBJECT_IMAGE1D_ARRAY:
+        GMMReqInfo.ArrayIndex = static_cast<uint32_t>(origin[1]);
+        break;
+    case CL_MEM_OBJECT_IMAGE2D_ARRAY:
+        GMMReqInfo.ArrayIndex = static_cast<uint32_t>(origin[2]);
+        break;
+    case CL_MEM_OBJECT_IMAGE3D:
+        GMMReqInfo.Slice = static_cast<uint32_t>(origin[2]);
+        break;
+    default:
+        break;
+    }
+
+    auto graphicsAlloc = image->getGraphicsAllocation();
+    UNRECOVERABLE_IF(graphicsAlloc == nullptr);
+    UNRECOVERABLE_IF(graphicsAlloc->gmm == nullptr);
+    auto gmmResourceInfo = graphicsAlloc->gmm->gmmResourceInfo.get();
+    UNRECOVERABLE_IF(gmmResourceInfo == nullptr);
+
+    gmmResourceInfo->getOffset(GMMReqInfo);
+
+    return GMMReqInfo.Lock.Offset;
+}
+} // namespace OCLRT