Media/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2025-09-15 13:01:45 +08:00
Code Issues Packages Projects Releases Wiki Activity

Move some shared tests to shared

Browse Source 
Tests that are not specific to openCL or level zero

Related-To: NEO-5161

Signed-off-by: Dominik Dabek <dominik.dabek@intel.com>
This commit is contained in:
Dominik Dabek
2021-05-13 13:27:50 +00:00
committed by Compute-Runtime-Automation
parent 074fc1d60f
commit a5d38170ad
70 changed files with 135 additions and 95 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
opencl/test/unit_test/mocks/CMakeLists.txt
View File

@ -35,16 +35,10 @@ set(IGDRCL_SRCS_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/mock_context.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_context.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_csr.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_deferrable_deletion.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_deferrable_deletion.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_deferred_deleter.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_deferred_deleter.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_device_queue.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_event.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_execution_environment.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_experimental_command_buffer.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gfx_partition.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gfx_partition.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_client_context_base.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_gmm_client_context_base.h
@ -68,7 +62,6 @@ set(IGDRCL_SRCS_tests_mocks
${CMAKE_CURRENT_SOURCE_DIR}/mock_memory_operations_handler.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_os_context.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_ostime.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_physical_address_allocator.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_platform.cpp
${CMAKE_CURRENT_SOURCE_DIR}/mock_platform.h
${CMAKE_CURRENT_SOURCE_DIR}/mock_program.h

18
opencl/test/unit_test/mocks/mock_deferrable_deletion.cpp
View File

@ -1,18 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/mocks/mock_deferrable_deletion.h"
namespace NEO {
bool MockDeferrableDeletion::apply() {
applyCalled++;
return true;
}
MockDeferrableDeletion::~MockDeferrableDeletion() {
EXPECT_EQ(1, applyCalled);
}
} // namespace NEO

21
opencl/test/unit_test/mocks/mock_deferrable_deletion.h
View File

@ -1,21 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/deferrable_deletion.h"
#include "gtest/gtest.h"
namespace NEO {
class MockDeferrableDeletion : public DeferrableDeletion {
public:
bool apply() override;
~MockDeferrableDeletion() override;
int applyCalled = 0;
};
} // namespace NEO

132
opencl/test/unit_test/mocks/mock_deferred_deleter.cpp
View File

@ -1,132 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/mocks/mock_deferred_deleter.h"
#include "shared/source/memory_manager/deferrable_deletion.h"
#include "shared/source/os_interface/os_thread.h"
#include "gtest/gtest.h"
namespace NEO {
MockDeferredDeleter::MockDeferredDeleter() {
shouldStopCalled = 0;
clearCalled = 0;
}
void MockDeferredDeleter::deferDeletion(DeferrableDeletion *deletion) {
deferDeletionCalled++;
deletion->apply();
delete deletion;
}
void MockDeferredDeleter::addClient() {
++numClients;
}
void MockDeferredDeleter::removeClient() {
--numClients;
}
void MockDeferredDeleter::drain(bool blocking) {
if (expectDrainCalled) {
EXPECT_EQ(expectedDrainValue, blocking);
}
DeferredDeleter::drain(blocking);
drainCalled++;
}
void MockDeferredDeleter::drain() {
return drain(true);
}
bool MockDeferredDeleter::areElementsReleased() {
areElementsReleasedCalled++;
return areElementsReleasedCalled != 1;
}
bool MockDeferredDeleter::shouldStop() {
shouldStopCalled++;
return shouldStopCalled > 1;
}
void MockDeferredDeleter::clearQueue() {
DeferredDeleter::clearQueue();
clearCalled++;
}
int MockDeferredDeleter::getClientsNum() {
return numClients;
}
int MockDeferredDeleter::getElementsToRelease() {
return elementsToRelease;
}
bool MockDeferredDeleter::isWorking() {
return doWorkInBackground;
}
bool MockDeferredDeleter::isThreadRunning() {
return worker != nullptr;
}
bool MockDeferredDeleter::isQueueEmpty() {
std::lock_guard<std::mutex> lock(queueMutex);
return queue.peekIsEmpty();
}
void MockDeferredDeleter::setElementsToRelease(int elementsNum) {
elementsToRelease = elementsNum;
}
void MockDeferredDeleter::setDoWorkInBackgroundValue(bool value) {
doWorkInBackground = value;
}
bool MockDeferredDeleter::baseAreElementsReleased() {
return DeferredDeleter::areElementsReleased();
}
bool MockDeferredDeleter::baseShouldStop() {
return DeferredDeleter::shouldStop();
}
Thread *MockDeferredDeleter::getThreadHandle() {
return worker.get();
}
std::unique_ptr<DeferredDeleter> createDeferredDeleter() {
return std::unique_ptr<DeferredDeleter>(new MockDeferredDeleter());
}
void MockDeferredDeleter::runThread() {
worker = Thread::create(run, reinterpret_cast<void *>(this));
}
void MockDeferredDeleter::forceStop() {
allowEarlyStopThread();
stop();
}
void MockDeferredDeleter::allowEarlyStopThread() {
shouldStopCalled = 2;
}
MockDeferredDeleter::~MockDeferredDeleter() {
allowEarlyStopThread();
if (expectDrainCalled) {
EXPECT_NE(0, drainCalled);
}
}
void MockDeferredDeleter::expectDrainBlockingValue(bool value) {
expectedDrainValue = value;
expectDrainCalled = true;
}
} // namespace NEO

76
opencl/test/unit_test/mocks/mock_deferred_deleter.h
View File

@ -1,76 +0,0 @@
/*
* Copyright (C) 2018-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/deferred_deleter.h"
namespace NEO {
class MockDeferredDeleter : public DeferredDeleter {
public:
MockDeferredDeleter();
~MockDeferredDeleter() override;
void deferDeletion(DeferrableDeletion *deletion) override;
void addClient() override;
void removeClient() override;
void drain(bool blocking) override;
bool areElementsReleased() override;
bool shouldStop() override;
void drain();
int getClientsNum();
int getElementsToRelease();
bool isWorking();
bool isThreadRunning();
bool isQueueEmpty();
void setElementsToRelease(int elementsNum);
void setDoWorkInBackgroundValue(bool value);
bool baseAreElementsReleased();
bool baseShouldStop();
Thread *getThreadHandle();
void runThread();
int drainCalled = 0;
int areElementsReleasedCalled = 0;
std::atomic<int> shouldStopCalled;
std::atomic<int> clearCalled;
int deferDeletionCalled = 0;
void forceStop();
void allowEarlyStopThread();
void expectDrainBlockingValue(bool value);
bool expectedDrainValue = false;
bool expectDrainCalled = false;
void clearQueue() override;
};
} // namespace NEO

20
opencl/test/unit_test/mocks/mock_gfx_partition.cpp
View File

@ -1,20 +0,0 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "opencl/test/unit_test/mocks/mock_gfx_partition.h"
using namespace NEO;
std::array<HeapIndex, static_cast<uint32_t>(HeapIndex::TOTAL_HEAPS)>
MockGfxPartition::allHeapNames{{HeapIndex::HEAP_INTERNAL_DEVICE_MEMORY,
HeapIndex::HEAP_INTERNAL,
HeapIndex::HEAP_EXTERNAL_DEVICE_MEMORY,
HeapIndex::HEAP_EXTERNAL,
HeapIndex::HEAP_STANDARD,
HeapIndex::HEAP_STANDARD64KB,
HeapIndex::HEAP_STANDARD2MB,
HeapIndex::HEAP_SVM}};

76
opencl/test/unit_test/mocks/mock_gfx_partition.h
View File

@ -1,76 +0,0 @@
/*
* Copyright (C) 2019-2021 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/source/memory_manager/gfx_partition.h"
#include "gmock/gmock.h"
using namespace NEO;
class MockGfxPartition : public GfxPartition {
public:
using GfxPartition::osMemory;
MockGfxPartition() : GfxPartition(reservedCpuAddressRange) {}
MockGfxPartition(OSMemory::ReservedCpuAddressRange &sharedReservedCpuAddressRange) : GfxPartition(sharedReservedCpuAddressRange) {}
uint64_t getHeapSize(HeapIndex heapIndex) {
return getHeap(heapIndex).getSize();
}
bool heapInitialized(HeapIndex heapIndex) {
return getHeapSize(heapIndex) > 0;
}
void *getReservedCpuAddressRange() {
return reservedCpuAddressRange.alignedPtr;
}
size_t getReservedCpuAddressRangeSize() {
return reservedCpuAddressRange.actualReservedSize - GfxPartition::heapGranularity;
}
uint64_t heapAllocate(HeapIndex heapIndex, size_t &size) override {
if (callHeapAllocate) {
return getHeap(heapIndex).allocate(size);
}
heapAllocateIndex = heapIndex;
return mockGpuVa;
}
void heapFree(HeapIndex heapIndex, uint64_t ptr, size_t size) override {
if (callHeapAllocate) {
getHeap(heapIndex).free(ptr, size);
}
}
static std::array<HeapIndex, static_cast<uint32_t>(HeapIndex::TOTAL_HEAPS)> allHeapNames;
OSMemory::ReservedCpuAddressRange reservedCpuAddressRange;
bool callHeapAllocate = true;
HeapIndex heapAllocateIndex = HeapIndex::TOTAL_HEAPS;
const uint64_t mockGpuVa = std::numeric_limits<uint64_t>::max();
};
struct GmockGfxPartition : MockGfxPartition {
using MockGfxPartition::MockGfxPartition;
MOCK_METHOD(void, freeGpuAddressRange, (uint64_t gpuAddress, size_t size), (override));
};
class MockGfxPartitionBasic : public GfxPartition {
public:
MockGfxPartitionBasic() : GfxPartition(reservedCpuAddressRange) {}
OSMemory::ReservedCpuAddressRange reservedCpuAddressRange;
};
class FailedInitGfxPartition : public MockGfxPartition {
public:
virtual bool init(uint64_t gpuAddressSpace, size_t cpuAddressRangeSizeToReserve, uint32_t rootDeviceIndex, size_t numRootDevices, bool useFrontWindowPool) override {
return false;
}
};

18
opencl/test/unit_test/mocks/mock_physical_address_allocator.h
View File

@ -1,18 +0,0 @@
/*
* Copyright (C) 2018-2020 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/memory_manager/physical_address_allocator.h"
using namespace NEO;
class MockPhysicalAddressAllocator : public PhysicalAddressAllocator {
public:
using PhysicalAddressAllocator::initialPageAddress;
using PhysicalAddressAllocator::mainAllocator;
using PhysicalAddressAllocator::PhysicalAddressAllocator;
};