rooty/rpi-vk-driver
1
0
Fork 0
mirror of https://github.com/Yours3lf/rpi-vk-driver.git synced 2025-02-17 14:54:20 +01:00
Code Issues Releases Wiki Activity

backup

Browse Source
This commit is contained in:
Unknown 2020-02-23 13:29:01 +00:00
parent 0c2d844251
commit 73e72e86e0
6 changed files with 52 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
driver/common.h
View File

@ -490,7 +490,7 @@ typedef struct VkDescriptorPool_T
typedef struct VkQuery_T typedef struct VkQuery_T
{ {
uint32_t enabledCounters[VC4_PERFCNT_NUM_EVENTS]; uint32_t enabledCounters[VC4_PERFCNT_NUM_EVENTS];
uint64_t counterValues[DRM_VC4_MAX_PERF_COUNTERS]; uint64_t counterValues[2][DRM_VC4_MAX_PERF_COUNTERS];
uint32_t numEnabledCounters; uint32_t numEnabledCounters;
uint32_t perfmonIDs[2]; uint32_t perfmonIDs[2];
} _query; } _query;

5
driver/instance.c
View File

@ -441,6 +441,11 @@ VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL rpi_vkGetInstanceProcAddr(
RETFUNC(vkAcquireNextImageKHR); RETFUNC(vkAcquireNextImageKHR);
RETFUNC(vkQueuePresentKHR); RETFUNC(vkQueuePresentKHR);
RETFUNC(vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR);
RETFUNC(vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR);
RETFUNC(vkAcquireProfilingLockKHR);
RETFUNC(vkReleaseProfilingLockKHR);
return 0; return 0;
} }

2
driver/kernelInterface.c
View File

@ -596,7 +596,7 @@ uint32_t vc4_create_perfmon(int fd, uint32_t* counters, uint32_t num_counters)
struct drm_vc4_perfmon_create arg = struct drm_vc4_perfmon_create arg =
{ {
.ncounters = 30, .ncounters = num_counters,
}; };
for(uint32_t c = 0; c < num_counters; ++c) for(uint32_t c = 0; c < num_counters; ++c)

9
driver/query.c
View File

@ -51,6 +51,7 @@ VKAPI_ATTR VkResult VKAPI_CALL rpi_vkCreateQueryPool(
for(uint32_t d = 0; d < ci.counterIndexCount; d += DRM_VC4_MAX_PERF_COUNTERS) for(uint32_t d = 0; d < ci.counterIndexCount; d += DRM_VC4_MAX_PERF_COUNTERS)
{ {
qp->queryPool[c].perfmonIDs[d] = vc4_create_perfmon(controlFd, &qp->queryPool[c].enabledCounters[d], qp->queryPool[c].numEnabledCounters > DRM_VC4_MAX_PERF_COUNTERS ? DRM_VC4_MAX_PERF_COUNTERS : qp->queryPool[c].numEnabledCounters); qp->queryPool[c].perfmonIDs[d] = vc4_create_perfmon(controlFd, &qp->queryPool[c].enabledCounters[d], qp->queryPool[c].numEnabledCounters > DRM_VC4_MAX_PERF_COUNTERS ? DRM_VC4_MAX_PERF_COUNTERS : qp->queryPool[c].numEnabledCounters);
memset(&qp->queryPool[c].counterValues[d][0], 0, sizeof(uint64_t) * DRM_VC4_MAX_PERF_COUNTERS);
} }
} }
@ -81,7 +82,7 @@ VKAPI_ATTR void VKAPI_CALL rpi_vkDestroyQueryPool(
for(uint32_t c = 0; c < qp->queryCount; ++c) for(uint32_t c = 0; c < qp->queryCount; ++c)
{ {
for(uint32_t d = 0; d < qp->queryPool[c].enabledCounters; d += DRM_VC4_MAX_PERF_COUNTERS) for(uint32_t d = 0; d < qp->queryPool[c].numEnabledCounters; d += DRM_VC4_MAX_PERF_COUNTERS)
{ {
vc4_destroy_perfmon(controlFd, qp->queryPool[c].perfmonIDs[d]); vc4_destroy_perfmon(controlFd, qp->queryPool[c].perfmonIDs[d]);
} }
@ -140,11 +141,17 @@ VKAPI_ATTR VkResult VKAPI_CALL rpi_vkGetQueryPoolResults(
assert(queryPool); assert(queryPool);
//TODO flags //TODO flags
//TODO return values etc.
_queryPool* qp = queryPool; _queryPool* qp = queryPool;
for(uint32_t c = firstQuery; c < queryCount; ++c) for(uint32_t c = firstQuery; c < queryCount; ++c)
{ {
for(uint32_t d = 0; d < qp->queryPool[c].numEnabledCounters; d += DRM_VC4_MAX_PERF_COUNTERS)
{
vc4_perfmon_get_values(controlFd, qp->queryPool[c].perfmonIDs[d], &qp->queryPool[c].counterValues[d][0]);
}
uint32_t counter = 0; uint32_t counter = 0;
for(uint32_t d = 0; d < dataSize; d += stride, ++counter) for(uint32_t d = 0; d < dataSize; d += stride, ++counter)
{ {

2
driver/vkCaps.h
View File

@ -557,6 +557,6 @@ static VkPerformanceCounterDescriptionKHR performanceCounterDescriptions[] =
} }
}; };
#define numPerformanceCounterTypes (sizeof(performanceCounterTypes)/sizeof(uint32_t)) #define numPerformanceCounterTypes (sizeof(performanceCounterTypes)/sizeof(VkPerformanceCounterKHR))
#define VK_DRIVER_VERSION VK_MAKE_VERSION(1, 1, 0) #define VK_DRIVER_VERSION VK_MAKE_VERSION(1, 1, 0)

42
test/query/query.cpp
View File

@ -84,6 +84,30 @@ uint32_t* enabledCounters = 0;
uint32_t numQueryPasses = 0; uint32_t numQueryPasses = 0;
VkQueryPool queryPool; VkQueryPool queryPool;
typedef VkResult (VKAPI_PTR *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(
VkPhysicalDevice physicalDevice,
uint32_t queueFamilyIndex,
uint32_t* pCounterCount,
VkPerformanceCounterKHR* pCounters,
VkPerformanceCounterDescriptionKHR* pCounterDescriptions);
typedef void (VKAPI_ATTR *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(
VkPhysicalDevice physicalDevice,
const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo,
uint32_t* pNumPasses);
typedef VkResult (VKAPI_ATTR *PFN_vkAcquireProfilingLockKHR)(
VkDevice device,
const VkAcquireProfilingLockInfoKHR* pInfo);
typedef void (VKAPI_ATTR *PFN_vkReleaseProfilingLockKHR)(
VkDevice device);
PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR my_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR;
PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR my_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR;
PFN_vkAcquireProfilingLockKHR my_vkAcquireProfilingLockKHR;
PFN_vkReleaseProfilingLockKHR my_vkReleaseProfilingLockKHR;
void cleanup() { void cleanup() {
vkDeviceWaitIdle(device); vkDeviceWaitIdle(device);
@ -151,6 +175,7 @@ void setupVulkan() {
//CreateUniformBuffer(); //CreateUniformBuffer();
CreateShaders(); CreateShaders();
CreatePipeline(); CreatePipeline();
CreateQueryPool();
recordCommandBuffers(); recordCommandBuffers();
} }
@ -659,7 +684,7 @@ void recordCommandBuffers()
lockInfo.sType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR; lockInfo.sType = VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR;
lockInfo.timeout = UINT64_MAX; lockInfo.timeout = UINT64_MAX;
vkAcquireProfilingLockKHR(device, &lockInfo); my_vkAcquireProfilingLockKHR(device, &lockInfo);
// Record command buffer // Record command buffer
vkBeginCommandBuffer(presentCommandBuffers[i], &beginInfo); vkBeginCommandBuffer(presentCommandBuffers[i], &beginInfo);
@ -749,7 +774,7 @@ void draw() {
std::cout << "submitted draw command buffer" << std::endl; std::cout << "submitted draw command buffer" << std::endl;
vkReleaseProfilingLockKHR(device); my_vkReleaseProfilingLockKHR(device);
{ //Get query results { //Get query results
VkPerformanceCounterResultKHR* recordedCounters = (VkPerformanceCounterResultKHR*)malloc(sizeof(VkPerformanceCounterResultKHR) * counterCount); VkPerformanceCounterResultKHR* recordedCounters = (VkPerformanceCounterResultKHR*)malloc(sizeof(VkPerformanceCounterResultKHR) * counterCount);
@ -761,7 +786,7 @@ void draw() {
{ {
case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR: case VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR:
case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR: case VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR:
printf("%s %ull\n", counterDescriptions[enabledCounters[c]].name, recordedCounters[c].uint64); printf("%s %llu\n", counterDescriptions[enabledCounters[c]].name, recordedCounters[c].uint64);
break; break;
} }
} }
@ -1232,11 +1257,16 @@ void CreateVertexBuffer()
void CreateQueryPool() void CreateQueryPool()
{ {
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, graphicsQueueFamily, &counterCount, 0, 0); my_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = (PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)vkGetInstanceProcAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
my_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = (PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
my_vkAcquireProfilingLockKHR = (PFN_vkAcquireProfilingLockKHR)vkGetInstanceProcAddr(instance, "vkAcquireProfilingLockKHR");
my_vkReleaseProfilingLockKHR = (PFN_vkReleaseProfilingLockKHR)vkGetInstanceProcAddr(instance, "vkReleaseProfilingLockKHR");
my_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, graphicsQueueFamily, &counterCount, 0, 0);
counters = (VkPerformanceCounterKHR*)malloc(sizeof(VkPerformanceCounterKHR) * counterCount); counters = (VkPerformanceCounterKHR*)malloc(sizeof(VkPerformanceCounterKHR) * counterCount);
counterDescriptions = (VkPerformanceCounterDescriptionKHR*)malloc(sizeof(VkPerformanceCounterDescriptionKHR) * counterCount); counterDescriptions = (VkPerformanceCounterDescriptionKHR*)malloc(sizeof(VkPerformanceCounterDescriptionKHR) * counterCount);
vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, graphicsQueueFamily, &counterCount, counters, counterDescriptions); my_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, graphicsQueueFamily, &counterCount, counters, counterDescriptions);
enabledCounters = (uint32_t*)malloc(sizeof(uint32_t) * counterCount); enabledCounters = (uint32_t*)malloc(sizeof(uint32_t) * counterCount);
for(uint32_t c = 0; c < counterCount; ++c) for(uint32_t c = 0; c < counterCount; ++c)
@ -1250,7 +1280,7 @@ void CreateQueryPool()
performanceQueryCreateInfo.counterIndexCount = counterCount; performanceQueryCreateInfo.counterIndexCount = counterCount;
performanceQueryCreateInfo.pCounterIndices = enabledCounters; performanceQueryCreateInfo.pCounterIndices = enabledCounters;
vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, &performanceQueryCreateInfo, &numQueryPasses); my_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, &performanceQueryCreateInfo, &numQueryPasses);
VkQueryPoolCreateInfo queryPoolCreateInfo = {}; VkQueryPoolCreateInfo queryPoolCreateInfo = {};
queryPoolCreateInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO; queryPoolCreateInfo.sType = VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO;