compute-runtime/shared/test/common/mocks/mock_cpu_page_fault_manager.h

106 lines
3.4 KiB
C++

/*
* Copyright (C) 2019-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include "shared/source/page_fault_manager/cpu_page_fault_manager.h"
using namespace NEO;
class MockPageFaultManager : public PageFaultManager {
public:
using PageFaultManager::gpuDomainHandler;
using PageFaultManager::handleGpuDomainTransferForAubAndTbx;
using PageFaultManager::handleGpuDomainTransferForHw;
using PageFaultManager::memoryData;
using PageFaultManager::PageFaultData;
using PageFaultManager::PageFaultManager;
using PageFaultManager::selectGpuDomainHandler;
using PageFaultManager::verifyPageFault;
void allowCPUMemoryAccess(void *ptr, size_t size) override {
allowMemoryAccessCalled++;
allowedMemoryAccessAddress = ptr;
accessAllowedSize = size;
}
void protectCPUMemoryAccess(void *ptr, size_t size) override {
protectMemoryCalled++;
protectedMemoryAccessAddress = ptr;
protectedSize = size;
}
void transferToCpu(void *ptr, size_t size, void *cmdQ) override {
transferToCpuCalled++;
transferToCpuAddress = ptr;
transferToCpuSize = size;
}
void transferToGpu(void *ptr, void *cmdQ) override {
transferToGpuCalled++;
transferToGpuAddress = ptr;
}
void setAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) override {
isAubWritable = writable;
}
void baseAubWritable(bool writable, void *ptr, SVMAllocsManager *unifiedMemoryManager) {
PageFaultManager::setAubWritable(writable, ptr, unifiedMemoryManager);
}
void baseCpuTransfer(void *ptr, size_t size, void *cmdQ) {
PageFaultManager::transferToCpu(ptr, size, cmdQ);
}
void baseGpuTransfer(void *ptr, void *cmdQ) {
PageFaultManager::transferToGpu(ptr, cmdQ);
}
void evictMemoryAfterImplCopy(GraphicsAllocation *allocation, Device *device) override {}
void *getHwHandlerAddress() {
return reinterpret_cast<void *>(PageFaultManager::handleGpuDomainTransferForHw);
}
void *getAubAndTbxHandlerAddress() {
return reinterpret_cast<void *>(PageFaultManager::handleGpuDomainTransferForAubAndTbx);
}
void moveAllocationToGpuDomain(void *ptr) override {
moveAllocationToGpuDomainCalled++;
PageFaultManager::moveAllocationToGpuDomain(ptr);
}
int allowMemoryAccessCalled = 0;
int protectMemoryCalled = 0;
int transferToCpuCalled = 0;
int transferToGpuCalled = 0;
int moveAllocationToGpuDomainCalled = 0;
void *transferToCpuAddress = nullptr;
void *transferToGpuAddress = nullptr;
void *allowedMemoryAccessAddress = nullptr;
void *protectedMemoryAccessAddress = nullptr;
size_t transferToCpuSize = 0;
size_t accessAllowedSize = 0;
size_t protectedSize = 0;
bool isAubWritable = true;
};
template <class T>
class MockPageFaultManagerHandlerInvoke : public T {
public:
using T::allowCPUMemoryAccess;
using T::evictMemoryAfterImplCopy;
using T::protectCPUMemoryAccess;
using T::T;
bool verifyPageFault(void *ptr) override {
handlerInvoked = true;
if (allowCPUMemoryAccessOnPageFault) {
this->allowCPUMemoryAccess(ptr, size);
}
return returnStatus;
}
bool returnStatus = true;
bool allowCPUMemoryAccessOnPageFault = false;
bool handlerInvoked = false;
size_t size = 65536;
};