Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

refactor: Add GDI profiling 

Resolves: NEO-9236
Related-To: NEO-10036

Signed-off-by: Lukasz Jobczyk <lukasz.jobczyk@intel.com>
This commit is contained in:
Lukasz Jobczyk 2024-02-07 16:19:02 +00:00 committed by Compute-Runtime-Automation
parent ce17580b28
commit 486cc71b76
15 changed files with 193 additions and 175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@ -579,11 +579,6 @@ else()
set(NEO_TESTS_LISTENER_OPTION "--enable_default_listener")
endif()
# Put profiling enable flag into define
if(KMD_PROFILING)
add_definitions(-DKMD_PROFILING=${KMD_PROFILING})
endif()
if(MSVC)
# Force to treat warnings as errors
if(NOT CMAKE_CXX_FLAGS MATCHES "/WX")

7
opencl/source/api/api_enter.h
View File

@ -12,10 +12,3 @@
#define API_ENTER(retValPointer) \
LoggerApiEnterWrapper<NEO::FileLogger<globalDebugFunctionalityLevel>::enabled()> ApiWrapperForSingleCall(__FUNCTION__, retValPointer)
#if KMD_PROFILING == 1
#undef API_ENTER
#define API_ENTER(x) \
PerfProfilerApiWrapper globalPerfProfilersWrapperInstanceForSingleApiFunction(__FUNCTION__)
#endif

2
opencl/test/unit_test/linux/main_linux_dll.cpp
View File

@ -234,7 +234,7 @@ TEST_F(DrmSimpleTests, givenPrintIoctlTimesWhenCallIoctlThenStatisticsAreGathere
auto drm = DrmWrap::createDrm(*(mockExecutionEnvironment.rootDeviceEnvironments[0].get()));
DebugManagerStateRestore restorer;
debugManager.flags.PrintIoctlTimes.set(true);
debugManager.flags.PrintKmdTimes.set(true);
VariableBackup<decltype(forceExtraIoctlDuration)> backupForceExtraIoctlDuration(&forceExtraIoctlDuration, true);
EXPECT_TRUE(drm->ioctlStatistics.empty());

2
shared/source/debug_settings/debug_variables_base.inl
View File

@ -311,7 +311,7 @@ DECLARE_DEBUG_VARIABLE(bool, PrintBOPrefetchingResult, false, "tracks the result
DECLARE_DEBUG_VARIABLE(bool, PrintTagAllocationAddress, false, "Print tag allocation address for each engine")
DECLARE_DEBUG_VARIABLE(bool, ProvideVerboseImplicitFlush, false, "provides verbose messages about implicit flush mechanism")
DECLARE_DEBUG_VARIABLE(bool, PrintBlitDispatchDetails, false, "Print blit dispatch details")
DECLARE_DEBUG_VARIABLE(bool, PrintIoctlTimes, false, "Print ioctl times")
DECLARE_DEBUG_VARIABLE(bool, PrintKmdTimes, false, "Print ioctl times")
DECLARE_DEBUG_VARIABLE(bool, PrintIoctlEntries, false, "Print ioctl being called")
DECLARE_DEBUG_VARIABLE(bool, PrintUmdSharedMigration, false, "Print log message when shared allocation is being migrated by UMD")
DECLARE_DEBUG_VARIABLE(bool, PrintImageBlitBlockCopyCmdDetails, false, "Prints XY_BLOCK_COPY_BLT command details")

4
shared/source/helpers/options.h
View File

@ -8,10 +8,6 @@
#pragma once
#include <cstdint>
#ifndef KMD_PROFILING
#define KMD_PROFILING 0
#endif
namespace NEO {
enum CommandStreamReceiverType {
// Use receiver for real HW

4
shared/source/os_interface/linux/drm_neo.cpp
View File

@ -88,7 +88,7 @@ int Drm::ioctl(DrmIoctl request, void *arg) {
int returnedErrno = 0;
SYSTEM_ENTER();
do {
auto measureTime = debugManager.flags.PrintIoctlTimes.get();
auto measureTime = debugManager.flags.PrintKmdTimes.get();
std::chrono::steady_clock::time_point start;
std::chrono::steady_clock::time_point end;
@ -644,7 +644,7 @@ std::vector<DataType> Drm::query(uint32_t queryId, uint32_t queryItemFlags) {
}
void Drm::printIoctlStatistics() {
if (!debugManager.flags.PrintIoctlTimes.get()) {
if (!debugManager.flags.PrintKmdTimes.get()) {
return;
}

1
shared/source/os_interface/windows/CMakeLists.txt
View File

@ -68,6 +68,7 @@ set(NEO_CORE_OS_INTERFACE_WDDM
${CMAKE_CURRENT_SOURCE_DIR}/gdi_interface.h
${CMAKE_CURRENT_SOURCE_DIR}/gdi_interface_logging.cpp
${CMAKE_CURRENT_SOURCE_DIR}/gdi_interface_logging.h
${CMAKE_CURRENT_SOURCE_DIR}/gdi_profiling.h
${CMAKE_CURRENT_SOURCE_DIR}/hw_device_id_win.cpp
${CMAKE_CURRENT_SOURCE_DIR}/hw_device_id.h
${CMAKE_CURRENT_SOURCE_DIR}/product_helper_wddm.cpp

1
shared/source/os_interface/windows/gdi_interface.cpp
View File

@ -25,6 +25,7 @@ Gdi::~Gdi() {
if constexpr (GdiLogging::gdiLoggingSupport) {
GdiLogging::close();
}
this->profiler.printGdiTimes();
}
bool Gdi::setupHwQueueProcAddresses() {

96
shared/source/os_interface/windows/gdi_interface.h
View File

@ -8,67 +8,73 @@
#pragma once
#include "shared/source/os_interface/os_library.h"
#include "shared/source/os_interface/windows/d3dkmthk_wrapper.h"
#include "shared/source/os_interface/windows/gdi_profiling.h"
#include "shared/source/os_interface/windows/thk_wrapper.h"
#include <memory>
namespace NEO {
#define DEFINE_THK_WRAPPER(TYPE, VAR) ThkWrapper<TYPE> VAR = ThkWrapper<TYPE>(this->profiler, #TYPE, this->gdiId++);
class Gdi {
uint32_t gdiId = 0;
GdiProfiler profiler;
public:
Gdi();
MOCKABLE_VIRTUAL ~Gdi();
ThkWrapper<IN OUT CONST D3DKMT_OPENADAPTERFROMLUID *> openAdapterFromLuid{};
ThkWrapper<IN OUT D3DKMT_CREATEALLOCATION *> createAllocation{};
ThkWrapper<IN OUT D3DKMT_CREATEALLOCATION *> createAllocation2{};
DEFINE_THK_WRAPPER(IN OUT CONST D3DKMT_OPENADAPTERFROMLUID *, openAdapterFromLuid);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATEALLOCATION *, createAllocation);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATEALLOCATION *, createAllocation2);
NTSTATUS(APIENTRY *shareObjects)
(UINT cObjects, const D3DKMT_HANDLE *hObjects, POBJECT_ATTRIBUTES pObjectAttributes, DWORD dwDesiredAccess, HANDLE *phSharedNtHandle) = {};
ThkWrapper<IN CONST D3DKMT_DESTROYALLOCATION *> destroyAllocation{};
ThkWrapper<IN CONST D3DKMT_DESTROYALLOCATION2 *> destroyAllocation2{};
ThkWrapper<IN CONST D3DKMT_QUERYADAPTERINFO *> queryAdapterInfo{};
ThkWrapper<IN CONST D3DKMT_CLOSEADAPTER *> closeAdapter{};
ThkWrapper<IN OUT D3DKMT_CREATEDEVICE *> createDevice{};
ThkWrapper<IN CONST D3DKMT_DESTROYDEVICE *> destroyDevice{};
ThkWrapper<IN CONST D3DKMT_ESCAPE *> escape{};
ThkWrapper<IN D3DKMT_CREATECONTEXTVIRTUAL *> createContext{};
ThkWrapper<IN CONST D3DKMT_DESTROYCONTEXT *> destroyContext{};
ThkWrapper<IN OUT D3DKMT_OPENRESOURCE *> openResource{};
ThkWrapper<IN OUT D3DKMT_OPENRESOURCEFROMNTHANDLE *> openResourceFromNtHandle{};
ThkWrapper<IN OUT D3DKMT_QUERYRESOURCEINFO *> queryResourceInfo{};
ThkWrapper<IN OUT D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *> queryResourceInfoFromNtHandle{};
ThkWrapper<IN OUT D3DKMT_CREATESYNCHRONIZATIONOBJECT *> createSynchronizationObject{};
ThkWrapper<IN OUT D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *> createSynchronizationObject2{};
ThkWrapper<IN CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *> destroySynchronizationObject{};
ThkWrapper<IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *> signalSynchronizationObject{};
ThkWrapper<IN CONST_FROM_WDK_10_0_18328_0 D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *> waitForSynchronizationObject{};
ThkWrapper<IN CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU *> waitForSynchronizationObjectFromCpu{};
ThkWrapper<IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU *> signalSynchronizationObjectFromCpu{};
ThkWrapper<IN CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU *> waitForSynchronizationObjectFromGpu{};
ThkWrapper<IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU *> signalSynchronizationObjectFromGpu{};
ThkWrapper<IN OUT D3DKMT_CREATEPAGINGQUEUE *> createPagingQueue{};
ThkWrapper<IN OUT D3DDDI_DESTROYPAGINGQUEUE *> destroyPagingQueue{};
ThkWrapper<IN OUT D3DKMT_LOCK2 *> lock2{};
ThkWrapper<IN CONST D3DKMT_UNLOCK2 *> unlock2{};
ThkWrapper<IN OUT D3DDDI_MAPGPUVIRTUALADDRESS *> mapGpuVirtualAddress{};
ThkWrapper<IN OUT D3DDDI_RESERVEGPUVIRTUALADDRESS *> reserveGpuVirtualAddress{};
ThkWrapper<IN CONST D3DKMT_FREEGPUVIRTUALADDRESS *> freeGpuVirtualAddress{};
ThkWrapper<IN CONST D3DKMT_UPDATEGPUVIRTUALADDRESS *> updateGpuVirtualAddress{};
ThkWrapper<IN CONST D3DKMT_SUBMITCOMMAND *> submitCommand{};
ThkWrapper<IN OUT D3DDDI_MAKERESIDENT *> makeResident{};
ThkWrapper<IN D3DKMT_EVICT *> evict{};
ThkWrapper<IN D3DKMT_REGISTERTRIMNOTIFICATION *> registerTrimNotification{};
ThkWrapper<IN D3DKMT_UNREGISTERTRIMNOTIFICATION *> unregisterTrimNotification{};
ThkWrapper<IN CONST D3DKMT_SETALLOCATIONPRIORITY *> setAllocationPriority{};
ThkWrapper<IN CONST D3DKMT_SETCONTEXTSCHEDULINGPRIORITY *> setSchedulingPriority{};
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYALLOCATION *, destroyAllocation);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYALLOCATION2 *, destroyAllocation2);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_QUERYADAPTERINFO *, queryAdapterInfo);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_CLOSEADAPTER *, closeAdapter);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATEDEVICE *, createDevice);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYDEVICE *, destroyDevice);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_ESCAPE *, escape);
DEFINE_THK_WRAPPER(IN D3DKMT_CREATECONTEXTVIRTUAL *, createContext);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYCONTEXT *, destroyContext);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_OPENRESOURCE *, openResource);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_OPENRESOURCEFROMNTHANDLE *, openResourceFromNtHandle);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_QUERYRESOURCEINFO *, queryResourceInfo);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *, queryResourceInfoFromNtHandle);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATESYNCHRONIZATIONOBJECT *, createSynchronizationObject);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *, createSynchronizationObject2);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *, destroySynchronizationObject);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *, signalSynchronizationObject);
DEFINE_THK_WRAPPER(IN CONST_FROM_WDK_10_0_18328_0 D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *, waitForSynchronizationObject);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU *, waitForSynchronizationObjectFromCpu);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU *, signalSynchronizationObjectFromCpu);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU *, waitForSynchronizationObjectFromGpu);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU *, signalSynchronizationObjectFromGpu);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATEPAGINGQUEUE *, createPagingQueue);
DEFINE_THK_WRAPPER(IN OUT D3DDDI_DESTROYPAGINGQUEUE *, destroyPagingQueue);
DEFINE_THK_WRAPPER(IN OUT D3DKMT_LOCK2 *, lock2);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_UNLOCK2 *, unlock2);
DEFINE_THK_WRAPPER(IN OUT D3DDDI_MAPGPUVIRTUALADDRESS *, mapGpuVirtualAddress);
DEFINE_THK_WRAPPER(IN OUT D3DDDI_RESERVEGPUVIRTUALADDRESS *, reserveGpuVirtualAddress);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_FREEGPUVIRTUALADDRESS *, freeGpuVirtualAddress);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_UPDATEGPUVIRTUALADDRESS *, updateGpuVirtualAddress);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SUBMITCOMMAND *, submitCommand);
DEFINE_THK_WRAPPER(IN OUT D3DDDI_MAKERESIDENT *, makeResident);
DEFINE_THK_WRAPPER(IN D3DKMT_EVICT *, evict);
DEFINE_THK_WRAPPER(IN D3DKMT_REGISTERTRIMNOTIFICATION *, registerTrimNotification);
DEFINE_THK_WRAPPER(IN D3DKMT_UNREGISTERTRIMNOTIFICATION *, unregisterTrimNotification);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SETALLOCATIONPRIORITY *, setAllocationPriority);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SETCONTEXTSCHEDULINGPRIORITY *, setSchedulingPriority);
// HW queue
ThkWrapper<IN OUT D3DKMT_CREATEHWQUEUE *> createHwQueue{};
ThkWrapper<IN CONST D3DKMT_DESTROYHWQUEUE *> destroyHwQueue{};
ThkWrapper<IN CONST D3DKMT_SUBMITCOMMANDTOHWQUEUE *> submitCommandToHwQueue{};
DEFINE_THK_WRAPPER(IN OUT D3DKMT_CREATEHWQUEUE *, createHwQueue);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_DESTROYHWQUEUE *, destroyHwQueue);
DEFINE_THK_WRAPPER(IN CONST D3DKMT_SUBMITCOMMANDTOHWQUEUE *, submitCommandToHwQueue);
// For debug purposes
ThkWrapper<IN OUT D3DKMT_GETDEVICESTATE *> getDeviceState{};
DEFINE_THK_WRAPPER(IN OUT D3DKMT_GETDEVICESTATE *, getDeviceState);
bool isInitialized() {
return initialized;
@ -79,7 +85,7 @@ class Gdi {
protected:
OsLibrary *createGdiDLL();
MOCKABLE_VIRTUAL bool getAllProcAddresses();
std::unique_ptr<NEO::OsLibrary> gdiDll;
std::unique_ptr<NEO::OsLibrary> gdiDll = nullptr;
bool initialized = false;
};
} // namespace NEO

75
shared/source/os_interface/windows/gdi_profiling.h Normal file
View File

@ -0,0 +1,75 @@
/*
* Copyright (C) 2018-2024 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#pragma once
#include <algorithm>
#include <limits>
#include <vector>
namespace NEO {
class GdiProfiler {
struct StatisticsEntry {
long long totalTime = 0;
uint64_t count = 0;
long long minTime = std::numeric_limits<long long>::max();
long long maxTime = 0;
const char *gdiCall = nullptr;
size_t getLength() const {
return this->gdiCall ? strlen(this->gdiCall) : 0u;
}
};
public:
void printGdiTimes() {
if (this->gdiStatistics.empty()) {
return;
}
auto maxCallLengthIt = std::max_element(this->gdiStatistics.begin(), this->gdiStatistics.end(), [](const auto &gdiData1, const auto &gdiData2) {
return gdiData1.getLength() < gdiData2.getLength();
});
auto maxCallLength = static_cast<int>(strlen(maxCallLengthIt->gdiCall));
printf("\n--- Gdi statistics ---\n");
printf("%*s %15s %10s %25s %15s %15s", maxCallLength, "Request", "Total time(ns)", "Count", "Avg time per gdi call", "Min", "Max\n");
for (const auto &gdiData : this->gdiStatistics) {
if (gdiData.count == 0) {
continue;
}
printf("%*s %15llu %10lu %25f %15lld %15lld\n",
maxCallLength,
gdiData.gdiCall,
gdiData.totalTime,
static_cast<unsigned long>(gdiData.count),
gdiData.totalTime / static_cast<double>(gdiData.count),
gdiData.minTime,
gdiData.maxTime);
}
printf("\n");
}
void recordElapsedTime(long long elapsedTime, const char *name, uint32_t id) {
if (this->gdiStatistics.size() <= id) {
this->gdiStatistics.resize(id + 1u);
}
auto &gdiData = this->gdiStatistics[id];
gdiData.gdiCall = name;
gdiData.totalTime += elapsedTime;
gdiData.count++;
gdiData.minTime = std::min(gdiData.minTime, elapsedTime);
gdiData.maxTime = std::max(gdiData.maxTime, elapsedTime);
}
protected:
std::vector<StatisticsEntry> gdiStatistics{};
};
} // namespace NEO

104
shared/source/os_interface/windows/thk_wrapper.h
View File

@ -6,94 +6,56 @@
*/
#pragma once
#include "shared/source/debug_settings/debug_settings_manager.h"
#include "shared/source/helpers/options.h"
#include "shared/source/os_interface/windows/d3dkmthk_wrapper.h"
#include "shared/source/os_interface/windows/gdi_interface_logging.h"
#include "shared/source/os_interface/windows/gdi_profiling.h"
#include "shared/source/os_interface/windows/windows_wrapper.h"
#include "shared/source/utilities/api_intercept.h"
#include <chrono>
#include <iostream>
#include <string>
namespace NEO {
// Default template for GetID( ) for Thk function, causing compilation error !!
// Returns ID for specific ThkWrapper type
template <class Param>
constexpr unsigned int getThkWrapperId() {
static_assert(sizeof(Param) > sizeof(Param) + 1, "Template specialization for GetID is required for each new THKWrapper");
return 0;
}
// Template specializations of GetID(), required for every new Thk function
#define GET_ID(TYPE, VALUE) \
template <> \
constexpr unsigned int getThkWrapperId<TYPE>() { \
return 0; \
}
GET_ID(CONST D3DKMT_OPENADAPTERFROMLUID *, SYSTIMER_ID_OPENADAPTERFROMLUID)
GET_ID(CONST D3DKMT_CLOSEADAPTER *, SYSTIMER_ID_CLOSEADAPTER)
GET_ID(CONST D3DKMT_QUERYADAPTERINFO *, SYSTIMER_ID_QUERYADAPTERINFO)
GET_ID(CONST D3DKMT_ESCAPE *, SYSTIMER_ID_ESCAPE)
GET_ID(D3DKMT_CREATEDEVICE *, SYSTIMER_ID_CREATEDEVICE)
GET_ID(CONST D3DKMT_DESTROYDEVICE *, SYSTIMER_ID_DESTROYDEVICE)
GET_ID(D3DKMT_CREATECONTEXT *, SYSTIMER_ID_CREATECONTEXT)
GET_ID(CONST D3DKMT_DESTROYCONTEXT *, SYSTIMER_ID_DESTROYCONTEXT)
GET_ID(D3DKMT_CREATEALLOCATION *, SYSTIMER_ID_CREATEALLOCATION)
GET_ID(D3DKMT_OPENRESOURCE *, SYSTIMER_ID_OPENRESOURCE)
GET_ID(D3DKMT_QUERYRESOURCEINFO *, SYSTIMER_ID_QUERYRESOURCEINFO)
GET_ID(D3DKMT_CREATESYNCHRONIZATIONOBJECT *, SYSTIMER_ID_CREATESYNCHRONIZATIONOBJECT)
GET_ID(CONST D3DKMT_DESTROYSYNCHRONIZATIONOBJECT *, SYSTIMER_ID_DESTROYSYNCHRONIZATIONOBJECT)
GET_ID(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECT *, SYSTIMER_ID_SIGNALSYNCHRONIZATIONOBJECT)
GET_ID(CONST_FROM_WDK_10_0_18328_0 D3DKMT_WAITFORSYNCHRONIZATIONOBJECT *, SYSTIMER_ID_WAITFORSYNCHRONIZATIONOBJECT)
GET_ID(D3DKMT_CREATESYNCHRONIZATIONOBJECT2 *, SYSTIMER_ID_CREATESYNCHRONIZATIONOBJECT2)
GET_ID(D3DKMT_GETDEVICESTATE *, SYSTIMER_ID_GETDEVICESTATE)
GET_ID(D3DDDI_MAKERESIDENT *, SYSTIMER_ID_MAKERESIDENT)
GET_ID(D3DKMT_EVICT *, SYSTIMER_ID_EVICT)
GET_ID(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMCPU *, SYSTIMER_ID_WAITFORSYNCHRONIZATIONOBJECTFROMCPU)
GET_ID(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMCPU *, SYSTIMER_ID_SIGNALSYNCHRONIZATIONOBJECTFROMCPU)
GET_ID(CONST D3DKMT_WAITFORSYNCHRONIZATIONOBJECTFROMGPU *, SYSTIMER_ID_WAITFORSYNCHRONIZATIONOBJECTFROMGPU)
GET_ID(CONST D3DKMT_SIGNALSYNCHRONIZATIONOBJECTFROMGPU *, SYSTIMER_ID_SIGNALSYNCHRONIZATIONOBJECTFROMGPU)
GET_ID(D3DKMT_CREATEPAGINGQUEUE *, SYSTIMER_ID_CREATEPAGINGQUEUE)
GET_ID(D3DDDI_DESTROYPAGINGQUEUE *, SYSTIMER_ID_D3DDDI_DESTROYPAGINGQUEUE)
GET_ID(D3DKMT_LOCK2 *, SYSTIMER_ID_LOCK2)
GET_ID(CONST D3DKMT_UNLOCK2 *, SYSTIMER_ID_UNLOCK2)
GET_ID(CONST D3DKMT_INVALIDATECACHE *, SYSTIMER_ID_INVALIDATECACHE)
GET_ID(D3DDDI_MAPGPUVIRTUALADDRESS *, SYSTIMER_ID_D3DDDI_MAPGPUVIRTUALADDRESS)
GET_ID(D3DDDI_RESERVEGPUVIRTUALADDRESS *, SYSTIMER_ID_D3DDDI_RESERVEGPUVIRTUALADDRESS)
GET_ID(CONST D3DKMT_FREEGPUVIRTUALADDRESS *, SYSTIMER_ID_FREEGPUVIRTUALADDRESS)
GET_ID(CONST D3DKMT_UPDATEGPUVIRTUALADDRESS *, SYSTIMER_ID_UPDATEGPUVIRTUALADDRESS)
GET_ID(D3DKMT_CREATECONTEXTVIRTUAL *, SYSTIMER_ID_CREATECONTEXTVIRTUAL)
GET_ID(CONST D3DKMT_SUBMITCOMMAND *, SYSTIMER_ID_SUBMITCOMMAND)
GET_ID(D3DKMT_OPENSYNCOBJECTFROMNTHANDLE2 *, SYSTIMER_ID_OPENSYNCOBJECTFROMNTHANDLE2)
GET_ID(CONST D3DKMT_DESTROYALLOCATION2 *, SYSTIMER_ID_DESTROYALLOCATION2)
GET_ID(D3DKMT_REGISTERTRIMNOTIFICATION *, SYSTIMER_ID_REGISTERTRIMNOTIFICATION)
GET_ID(D3DKMT_UNREGISTERTRIMNOTIFICATION *, SYSTIMER_ID_UNREGISTERTRIMNOTIFICATION)
GET_ID(D3DKMT_OPENRESOURCEFROMNTHANDLE *, SYSTIMER_ID_OPENRESOURCEFROMNTHANDLE)
GET_ID(D3DKMT_QUERYRESOURCEINFOFROMNTHANDLE *, SYSTIMER_ID_QUERYRESOURCEINFOFROMNTHANDLE)
GET_ID(D3DKMT_CREATEHWQUEUE *, SYSTIMER_ID_CREATEHWQUEUE)
GET_ID(CONST D3DKMT_DESTROYHWQUEUE *, SYSTIMER_ID_DESTROYHWQUEUE)
GET_ID(CONST D3DKMT_SUBMITCOMMANDTOHWQUEUE *, SYSTIMER_ID_SUBMITCOMMANDTOHWQUEUE)
GET_ID(CONST D3DKMT_SETALLOCATIONPRIORITY *, SYSTIMER_ID_SETALLOCATIONPRIORITY)
GET_ID(CONST D3DKMT_SETCONTEXTSCHEDULINGPRIORITY *, SYSTIMER_ID_SETCONTEXTSCHEDULINGPRIORITY)
template <typename Param>
class ThkWrapper {
typedef NTSTATUS(APIENTRY *Func)(Param);
GdiProfiler &profiler;
const std::string name{};
const uint32_t id{};
public:
ThkWrapper(GdiProfiler &profiler, const char *name, uint32_t id) : profiler(profiler), name(name), id(id){};
Func mFunc = nullptr;
inline NTSTATUS operator()(Param param) const {
if (KMD_PROFILING) {
SYSTEM_ENTER()
NTSTATUS status;
status = mFunc(param);
SYSTEM_LEAVE(getId<Param>());
return status;
} else if constexpr (GdiLogging::gdiLoggingSupport) {
NTSTATUS status;
if constexpr (GdiLogging::gdiLoggingSupport) {
GdiLogging::logEnter<Param>(param);
status = mFunc(param);
GdiLogging::logExit<Param>(status, param);
return status;
auto measureTime = debugManager.flags.PrintKmdTimes.get();
std::chrono::steady_clock::time_point start;
std::chrono::steady_clock::time_point end;
if (measureTime) {
start = std::chrono::steady_clock::now();
}
auto ret = mFunc(param);
if (measureTime) {
end = std::chrono::steady_clock::now();
long long elapsedTime = std::chrono::duration_cast<std::chrono::nanoseconds>(end - start).count();
profiler.recordElapsedTime(elapsedTime, this->name.c_str(), this->id);
}
GdiLogging::logExit<Param>(ret, param);
return ret;
} else {
return mFunc(param);
}

18
shared/source/utilities/api_intercept.h
View File

@ -10,21 +10,3 @@
#define SYSTEM_LEAVE(id)
#define WAIT_ENTER()
#define WAIT_LEAVE()
#if KMD_PROFILING == 1
#undef SYSTEM_ENTER
#undef SYSTEM_LEAVE
#undef WAIT_ENTER
#undef WAIT_LEAVE
#define SYSTEM_ENTER() \
PerfProfiler::create(); \
gPerfProfiler->systemEnter();
#define SYSTEM_LEAVE(id) \
gPerfProfiler->systemLeave(id);
#define WAIT_ENTER() \
SYSTEM_ENTER()
#define WAIT_LEAVE() \
SYSTEM_LEAVE(0)
#endif

19
shared/source/utilities/perf_profiler.h
View File

@ -95,23 +95,4 @@ class PerfProfiler {
std::unique_ptr<std::ostream> sysLogFile;
std::vector<SystemLog> systemLogs;
};
#if KMD_PROFILING == 1
extern thread_local PerfProfiler *gPerfProfiler;
struct PerfProfilerApiWrapper {
PerfProfilerApiWrapper(const char *funcName)
: funcName(funcName) {
PerfProfiler::create();
gPerfProfiler->apiEnter();
}
~PerfProfilerApiWrapper() {
gPerfProfiler->apiLeave(funcName);
}
const char *funcName;
};
#endif
}; // namespace NEO

2
shared/test/common/test_files/igdrcl.config
View File

@ -260,7 +260,7 @@ EnableHostPointerImport = -1
EnableHostUsmSupport = -1
ForceBtpPrefetchMode = -1
OverrideProfilingTimerResolution = -1
PrintIoctlTimes = 0
PrintKmdTimes = 0
PrintIoctlEntries = 0
PrintUmdSharedMigration = 0
UpdateTaskCountFromWait = -1

28
shared/test/unit_test/os_interface/windows/gdi_interface_tests.cpp
View File

@ -47,8 +47,34 @@ TEST(GdiInterface, givenGdiOverridePathWhenGdiInterfaceIsCalledThenOverridePathI
Os::gdiDllName = oldName;
}
TEST(GdiInterface, givenPrintKmdTimesWhenCallThkWrapperThenRecordTime) {
if (!GdiLogging::gdiLoggingSupport) {
GTEST_SKIP();
}
DebugManagerStateRestore dbgRestorer;
debugManager.flags.PrintKmdTimes.set(1);
auto gdi = std::make_unique<Gdi>();
EXPECT_TRUE(gdi->isInitialized());
testing::internal::CaptureStdout();
D3DKMT_OPENADAPTERFROMLUID param = {};
gdi->openAdapterFromLuid(&param);
gdi->openAdapterFromLuid(&param);
D3DKMT_CLOSEADAPTER closeAdapter = {};
closeAdapter.hAdapter = param.hAdapter;
gdi->closeAdapter(&closeAdapter);
gdi.reset();
auto output = testing::internal::GetCapturedStdout();
EXPECT_TRUE(output.find("\n--- Gdi statistics ---\n") != std::string::npos);
}
TEST(ThkWrapperTest, givenThkWrapperWhenConstructedThenmFuncIsInitialized) {
NEO::ThkWrapper<void *> wrapper;
GdiProfiler profiler{};
NEO::ThkWrapper<void *> wrapper(profiler, "nullptr", 0u);
EXPECT_EQ(nullptr, wrapper.mFunc);
}