Program correct addresses in EnqueueReadWriteBufferRect scenarios

- SurfaceBaseAddress should be programmed with aligned address
this was not the case for certain origin and region values
- offset from aligned address added to operationParams

Change-Id: I0742b826dd0b70f0a6dedf436b850734fa015688
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>

unit_tests/fixtures/CMakeLists.txt

@@ -6,6 +6,7 @@
 
 set(IGDRCL_SRCS_tests_fixtures
   ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/buffer_enqueue_fixture.h
   ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/context_fixture.h
   ${CMAKE_CURRENT_SOURCE_DIR}/device_host_queue_fixture.cpp

unit_tests/fixtures/buffer_enqueue_fixture.h

@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2019 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+#include "runtime/memory_manager/internal_allocation_storage.h"
+#include "test.h"
+#include "unit_tests/fixtures/buffer_fixture.h"
+#include "unit_tests/helpers/execution_environment_helper.h"
+#include "unit_tests/helpers/hw_info_helper.h"
+#include "unit_tests/helpers/hw_parse.h"
+#include "unit_tests/mocks/mock_command_queue.h"
+#include "unit_tests/mocks/mock_csr.h"
+#include "unit_tests/mocks/mock_device.h"
+#include "unit_tests/mocks/mock_memory_manager.h"
+
+using namespace OCLRT;
+
+struct BufferEnqueueFixture : public HardwareParse,
+                              public ::testing::Test {
+    BufferEnqueueFixture(void)
+        : buffer(nullptr) {
+    }
+
+    void SetUp() override {
+        executionEnvironment = getExecutionEnvironmentImpl(hwInfo);
+    }
+
+    void TearDown() override {
+        buffer.reset(nullptr);
+    }
+
+    template <typename FamilyType>
+    void initializeFixture() {
+        auto mockCsr = new MockCsrHw2<FamilyType>(*executionEnvironment);
+
+        executionEnvironment->commandStreamReceivers.resize(1);
+        executionEnvironment->commandStreamReceivers[0].push_back(std::unique_ptr<CommandStreamReceiver>(mockCsr));
+
+        memoryManager = new MockMemoryManager(*executionEnvironment);
+        executionEnvironment->memoryManager.reset(memoryManager);
+
+        device = std::unique_ptr<MockDevice>(Device::create<MockDevice>(hwInfo, executionEnvironment, 0));
+
+        context = std::make_unique<MockContext>(device.get());
+
+        bufferMemory = std::make_unique<uint32_t[]>(alignUp(bufferSizeInDwords, sizeof(uint32_t)));
+        cl_int retVal = 0;
+
+        buffer.reset(Buffer::create(context.get(),
+                                    CL_MEM_READ_WRITE | CL_MEM_USE_HOST_PTR,
+                                    bufferSizeInDwords,
+                                    reinterpret_cast<char *>(bufferMemory.get()),
+                                    retVal));
+
+        EXPECT_EQ(CL_SUCCESS, retVal);
+    }
+
+  protected:
+    const size_t bufferSizeInDwords = 64;
+    HwInfoHelper hwInfoHelper;
+    HardwareInfo *hwInfo = nullptr;
+    ExecutionEnvironment *executionEnvironment;
+    cl_queue_properties properties = {};
+    std::unique_ptr<uint32_t[]> bufferMemory;
+    std::unique_ptr<MockDevice> device;
+    std::unique_ptr<MockContext> context;
+    std::unique_ptr<Buffer> buffer;
+
+    MockMemoryManager *memoryManager = nullptr;
+};
+
+struct EnqueueReadWriteBufferRectDispatch : public BufferEnqueueFixture {
+
+    void SetUp() override {
+        BufferEnqueueFixture::SetUp();
+    }
+
+    void TearDown() override {
+        BufferEnqueueFixture::TearDown();
+    }
+
+    uint32_t memory[64] = {0};
+
+    size_t bufferOrigin[3] = {0, 0, 0};
+    size_t hostOrigin[3] = {1, 1, 1};
+    size_t region[3] = {1, 2, 1};
+
+    size_t bufferRowPitch = 4;
+    size_t bufferSlicePitch = bufferSizeInDwords;
+
+    size_t hostRowPitch = 5;
+    size_t hostSlicePitch = 15;
+};