Fix & refactor AUBCreateImageArray

- verify memory on GPU when non-system MemoryPool is used
- set correct region for IMAGE1D_ARRAY

Change-Id: I0f50d40520d2a99f124ec87b91be0c8b5f3d48be

Author: HoppeMateusz

unit_tests/aub_tests/mem_obj/create_image_aub_tests.cpp

@@ -14,6 +14,8 @@
 #include "test.h"
 #include "unit_tests/mocks/mock_gmm.h"
 
+#include <memory>
+
 extern GFXCORE_FAMILY renderCoreFamily;
 
 using namespace OCLRT;
@@ -95,7 +97,7 @@ HWTEST_P(AUBCreateImageArray, CheckArrayImages) {
     auto pixelSize = 4;
     auto storageSize = imageDesc.image_array_size * pixelSize * imageDesc.image_width * imageDesc.image_height;
 
-    int *hostPtr = new int[storageSize];
+    std::unique_ptr<int[]> hostPtr(new int[storageSize]);
 
     for (auto i = 0u; i < storageSize; i++) {
         hostPtr[i] = i;
@@ -106,7 +108,7 @@ HWTEST_P(AUBCreateImageArray, CheckArrayImages) {
         flags,
         surfaceFormat,
         &imageDesc,
-        hostPtr,
+        hostPtr.get(),
         retVal);
 
     ASSERT_EQ(CL_SUCCESS, retVal);
@@ -119,29 +121,41 @@ HWTEST_P(AUBCreateImageArray, CheckArrayImages) {
     EXPECT_EQ(image->getQPitch(), imgInfo.qPitch);
     EXPECT_EQ(image->getCubeFaceIndex(), static_cast<uint32_t>(__GMM_NO_CUBE_MAP));
 
-    auto address = (int *)image->getCpuAddress();
+    auto imageHeight = imageDesc.image_height;
+    std::unique_ptr<uint32_t[]> readMemory(new uint32_t[image->getSize() / sizeof(uint32_t)]);
+    auto allocation = createResidentAllocationAndStoreItInCsr(readMemory.get(), image->getSize());
 
-    ASSERT_NE(nullptr, address);
+    size_t imgOrigin[] = {0, 0, 0};
+    size_t imgRegion[] = {imageDesc.image_width, 1, 1};
 
-    auto imageHeight = imageDesc.image_height;
+    if (imageDesc.image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY) {
+        imgRegion[1] = imageDesc.image_array_size;
+    } else if (imageDesc.image_type == CL_MEM_OBJECT_IMAGE2D_ARRAY) {
+        imgRegion[1] = imageDesc.image_height;
+        imgRegion[2] = imageDesc.image_array_size;
+    } else {
+        ASSERT_TRUE(false);
+    }
+    retVal = pCmdQ->enqueueReadImage(image, CL_FALSE, imgOrigin, imgRegion, imgInfo.rowPitch, imgInfo.slicePitch,
+                                     readMemory.get(), 0, nullptr, nullptr);
+    EXPECT_EQ(CL_SUCCESS, retVal);
 
-    uint32_t *readMemory = nullptr;
-    if (image->allowTiling()) {
-        readMemory = new uint32_t[image->getSize()];
-        size_t imgOrigin[] = {0, 0, 0};
-        size_t imgRegion[] = {imageDesc.image_width, imageDesc.image_height, imageDesc.image_array_size};
-        retVal = pCmdQ->enqueueReadImage(image, CL_TRUE, imgOrigin, imgRegion, imgInfo.rowPitch, imgInfo.slicePitch,
-                                         readMemory, 0, nullptr, nullptr);
-        EXPECT_EQ(CL_SUCCESS, retVal);
+    allocation = pCommandStreamReceiver->getTemporaryAllocations().peekHead();
+    while (allocation && allocation->getUnderlyingBuffer() != readMemory.get()) {
+        allocation = allocation->next;
     }
 
+    auto destGpuAddress = reinterpret_cast<uint32_t *>(allocation->getGpuAddress());
+    pCmdQ->flush();
+
+    auto address = (int *)image->getCpuAddress();
     auto currentCounter = 0;
     for (auto array = 0u; array < imageDesc.image_array_size; array++) {
         for (auto height = 0u; height < imageHeight; height++) {
             for (auto element = 0u; element < imageDesc.image_width; element++) {
                 auto offset = (array * imgInfo.slicePitch + element * pixelSize + height * imgInfo.rowPitch) / 4;
-                if (image->allowTiling()) {
-                    AUBCommandStreamFixture::expectMemory<FamilyType>(&readMemory[offset], &currentCounter, pixelSize);
+                if (MemoryPool::isSystemMemoryPool(image->getGraphicsAllocation()->getMemoryPool()) == false) {
+                    AUBCommandStreamFixture::expectMemory<FamilyType>(&destGpuAddress[offset], &currentCounter, pixelSize);
                 } else {
                     EXPECT_EQ(currentCounter, address[offset]);
                 }
@@ -150,13 +164,8 @@ HWTEST_P(AUBCreateImageArray, CheckArrayImages) {
         }
     }
 
-    if (readMemory) {
-        delete readMemory;
-    }
     delete image;
-    delete[] hostPtr;
 }
-
 struct AUBCreateImageHostPtr : public AUBCreateImage,
                                public ::testing::WithParamInterface<uint64_t /*cl_mem_object_type*/> {
     void SetUp() override {