Half-Life-RTX
/
xash3d-fwgs
mirror of https://github.com/w23/xash3d-fwgs
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

vk: profiler: devmem: save `peak` instead of `total` metrics 

Also minor code structure changes.
This commit is contained in:
nilsoncore 2023-10-07 16:58:04 +03:00
parent e3d86af5ab
commit 79e0e52061
4 changed files with 149 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
ref/vk/r_speeds.c
View File

@ -115,15 +115,12 @@ static void speedsPrintf( const char *msg, ... ) {
static void metricTypeSnprintf(char *buf, int buf_size, int value, r_speeds_metric_type_t type) { static void metricTypeSnprintf(char *buf, int buf_size, int value, r_speeds_metric_type_t type) {
switch (type) { switch (type) {
case kSpeedsMetricCount: { case kSpeedsMetricCount:
Q_snprintf( buf, buf_size, "%d", value ); Q_snprintf( buf, buf_size, "%d", value );
break; break;
} case kSpeedsMetricBytes:
case kSpeedsMetricBytes: { Q_strncpy( buf, Q_memprint( (float) value ), buf_size );
char *memory_str = Q_memprint( (float) value );
Q_strncpy( buf, memory_str, buf_size );
break; break;
}
case kSpeedsMetricMicroseconds: { case kSpeedsMetricMicroseconds: {
float msecs = value * 1e-3f; // us -> ms float msecs = value * 1e-3f; // us -> ms
Q_snprintf( buf, buf_size, "%.03f ms", msecs ); Q_snprintf( buf, buf_size, "%.03f ms", msecs );

3
ref/vk/vk_buffer.c
View File

@ -18,11 +18,10 @@ qboolean VK_BufferCreate(const char *debug_name, vk_buffer_t *buf, uint32_t size
memreq.alignment = ALIGN_UP(memreq.alignment, vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupBaseAlignment); memreq.alignment = ALIGN_UP(memreq.alignment, vk_core.physical_device.properties_ray_tracing_pipeline.shaderGroupBaseAlignment);
} }
usage = (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) ? VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT : 0;
vk_devmem_allocate_args_t args = (vk_devmem_allocate_args_t) { vk_devmem_allocate_args_t args = (vk_devmem_allocate_args_t) {
.requirements = memreq, .requirements = memreq,
.property_flags = flags, .property_flags = flags,
.allocate_flags = usage, .allocate_flags = (usage & VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT) ? VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT : 0,
}; };
buf->devmem = VK_DevMemAllocateBuffer( debug_name, args ); buf->devmem = VK_DevMemAllocateBuffer( debug_name, args );

299
ref/vk/vk_devmem.c
View File

@ -21,20 +21,22 @@ typedef struct vk_device_memory_slot_s {
} vk_device_memory_slot_t; } vk_device_memory_slot_t;
typedef struct vk_devmem_allocation_stats_s { typedef struct vk_devmem_allocation_stats_s {
// Note: // Metrics updated on every allocation and deallocation.
// `..._current` - Current size or number of allocations which gets updated on every allocation and deallocation. struct {
// `..._total` - Total size or number of allocations through the whole program runtime. int allocations; // Current number of active (not freed) allocations.
int allocated; // Current size of allocated memory.
int align_holes; // Current number of alignment holes in active (not freed) allocations.
int align_holes_size; // Current size of alignment holes in active (not freed) allocations.
} current;
int allocations_current; // Current number of active (not freed) allocations. // Metrics updated whenever new highest value is registered.
int allocated_current; // Current size of allocated memory. struct {
int allocations_total; // Total number of memory allocations. int allocations; // Highest number of allocations made.
int allocated_total; // Total size of allocated memory. int allocated; // Largest size of allocated memory.
int frees_total; // Total number of memory deallocations (frees). int align_holes; // Highest number of alignment holes made.
int freed_total; // Total size of deallocated (freed) memory. int align_holes_size; // Largest size of alignment holes made.
int align_holes_current; // Current number of alignment holes in active (not freed) allocations. int align_hole_size; // Largest size of the largest alignment hole made.
int align_holes_size_current; // Current size of alignment holes in active (not freed) allocations. } peak;
int align_holes_total; // Total number of alignment holes in all of allocations made.
int align_holes_size_total; // Total size of alignment holes in all of allocations made.
} vk_devmem_allocation_stats_t; } vk_devmem_allocation_stats_t;
static struct { static struct {
@ -49,123 +51,116 @@ static struct {
vk_devmem_allocation_stats_t stats[VK_DEVMEM_USAGE_TYPES_COUNT]; vk_devmem_allocation_stats_t stats[VK_DEVMEM_USAGE_TYPES_COUNT];
qboolean verbose; qboolean verbose;
} g_vk_devmem; } g_devmem;
// Register allocation in overall stats and for the corresponding type too. // Register allocation in overall stats and for the corresponding type stats too.
// This is "scalable" approach, which can be simplified if needed. #define REGISTER_ALLOCATION( type, size, alignment ) \
#define REGISTER_ALLOCATION( type, size, alignment ) { \ register_allocation_for_type( VK_DEVMEM_USAGE_TYPE_ALL, size, alignment ); \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocations_current += 1; \ register_allocation_for_type( type, size, alignment );
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocated_current += size; \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocations_total += 1; \ // Register deallocation (freeing) in overall stats and for the corresponding type stats too.
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocated_total += size; \ #define REGISTER_FREE( type, size, alignment ) \
int alignment_hole = size % alignment; \ register_free_for_type( VK_DEVMEM_USAGE_TYPE_ALL, size, alignment ); \
if ( alignment_hole > 0 ) { \ register_free_for_type( type, size, alignment );
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_current += 1; \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_size_current += alignment_hole; \ // Register allocation in stats of the provided type.
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_total += 1; \ static void register_allocation_for_type( vk_devmem_usage_type_t type, int size, int alignment ) {
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_size_total += alignment_hole; \ ASSERT( type >= VK_DEVMEM_USAGE_TYPE_ALL );
} \ ASSERT( type < VK_DEVMEM_USAGE_TYPES_COUNT );
for ( int type_idx = VK_DEVMEM_USAGE_TYPE_ALL + 1; type_idx < VK_DEVMEM_USAGE_TYPES_COUNT; type_idx += 1 ) { \
if ( type_idx == type ) { \ vk_devmem_allocation_stats_t *const stats = &g_devmem.stats[type];
g_vk_devmem.stats[type_idx].allocations_current += 1; \
g_vk_devmem.stats[type_idx].allocated_current += size; \ /* Update allocations stats. */
g_vk_devmem.stats[type_idx].allocations_total += 1; \
g_vk_devmem.stats[type_idx].allocated_total += size; \ // Update current allocations.
if ( alignment_hole > 0 ) { \ stats->current.allocations += 1;
g_vk_devmem.stats[type_idx].align_holes_current += 1; \ stats->current.allocated += size;
g_vk_devmem.stats[type_idx].align_holes_size_current += alignment_hole; \
g_vk_devmem.stats[type_idx].align_holes_total += 1; \ // Update peak allocations.
g_vk_devmem.stats[type_idx].align_holes_size_total += alignment_hole; \ if ( stats->peak.allocations < stats->current.allocations )
} \ stats->peak.allocations = stats->current.allocations;
break; \
} \ if ( stats->peak.allocated < stats->current.allocated )
} \ stats->peak.allocated = stats->current.allocated;
/* Update alignment holes stats. */
int alignment_hole = size % alignment;
if ( alignment_hole > 0 ) {
// Update current alignment holes stats.
stats->current.align_holes += 1;
stats->current.align_holes_size += alignment_hole;
// Update peak alignment holes stats.
if ( stats->peak.align_holes < stats->current.align_holes )
stats->peak.align_holes = stats->current.align_holes;
if ( stats->peak.align_holes_size < stats->current.align_holes_size )
stats->peak.align_holes_size = stats->current.align_holes_size;
if ( stats->peak.align_hole_size < alignment_hole )
stats->peak.align_hole_size = alignment_hole;
}
} }
// Register deallocation (freeing) in overall stats and for the corresponding type too. // Register deallocation (freeing) in stats of the provided type.
// This is "scalable" approach, which can be simplified if needed. static void register_free_for_type( vk_devmem_usage_type_t type, int size, int alignment ) {
#define REGISTER_FREE( type, size, alignment ) \ ASSERT( type >= VK_DEVMEM_USAGE_TYPE_ALL );
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocations_current -= 1; \ ASSERT( type < VK_DEVMEM_USAGE_TYPES_COUNT );
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].allocated_current -= size; \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].frees_total += 1; \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].freed_total += size; \
int alignment_hole = size % alignment; \
if ( alignment_hole > 0 ) { \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_current -= 1; \
g_vk_devmem.stats[VK_DEVMEM_USAGE_TYPE_ALL].align_holes_size_current -= alignment_hole; \
} \
for ( int type_idx = VK_DEVMEM_USAGE_TYPE_ALL + 1; type_idx < VK_DEVMEM_USAGE_TYPES_COUNT; type_idx += 1 ) { \
if ( type_idx == type ) { \
g_vk_devmem.stats[type_idx].allocations_current -= 1; \
g_vk_devmem.stats[type_idx].allocated_current -= size; \
g_vk_devmem.stats[type_idx].frees_total += 1; \
g_vk_devmem.stats[type_idx].freed_total += size; \
break; \
if ( alignment_hole > 0 ) { \
g_vk_devmem.stats[type_idx].align_holes_current -= 1; \
g_vk_devmem.stats[type_idx].align_holes_size_current -= alignment_hole; \
} \
} \
}
vk_devmem_allocation_stats_t *const stats = &g_devmem.stats[type];
/* Update current allocations stats. */
stats->current.allocations -= 1;
stats->current.allocated -= size;
/* Update current alignment holes stats. */
int alignment_hole = size % alignment;
if ( alignment_hole > 0 ) {
stats->current.align_holes -= 1;
stats->current.align_holes_size -= size;
}
}
#define VKMEMPROPFLAGS_COUNT 5 #define VKMEMPROPFLAGS_COUNT 5
#define VKMEMPROPFLAGS_MINSTRLEN (VKMEMPROPFLAGS_COUNT + 1) #define VKMEMPROPFLAGS_STRLEN (VKMEMPROPFLAGS_COUNT + 1)
// Fills string `out_flags` with characters at each corresponding flag slot. // Fills string `out_flags` with characters at each corresponding flag slot.
// Returns number of flags set. static void VK_MemoryPropertyFlags_String( VkMemoryPropertyFlags flags, char out_flags[VKMEMPROPFLAGS_STRLEN] ) {
static int VK_MemoryPropertyFlags_String( VkMemoryPropertyFlags flags, char *out_flags, size_t out_flags_size ) {
ASSERT( out_flags_size >= VKMEMPROPFLAGS_MINSTRLEN );
int set_flags = 0;
if ( out_flags_size < VKMEMPROPFLAGS_MINSTRLEN ) {
out_flags[0] = '\0';
return set_flags;
}
int flag = 0; int flag = 0;
if ( flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ) {out_flags[flag] = 'D'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT ) {out_flags[flag] = 'D';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ) {out_flags[flag] = 'V'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ) {out_flags[flag] = 'V';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ) {out_flags[flag] = 'C'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_PROPERTY_HOST_COHERENT_BIT ) {out_flags[flag] = 'C';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT ) {out_flags[flag] = '$'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_PROPERTY_HOST_CACHED_BIT ) {out_flags[flag] = '$';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT ) {out_flags[flag] = 'L'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT ) {out_flags[flag] = 'L';} else {out_flags[flag] = '-';} flag += 1;
// VK_MEMORY_PROPERTY_PROTECTED_BIT // VK_MEMORY_PROPERTY_PROTECTED_BIT
// VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD // VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD
// VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD // VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD
// VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV // VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV
out_flags[flag] = '\0'; out_flags[flag] = '\0';
return set_flags;
} }
#define VKMEMALLOCFLAGS_COUNT 3 #define VKMEMALLOCFLAGS_COUNT 3
#define VKMEMALLOCFLAGS_MINSTRLEN (VKMEMALLOCFLAGS_COUNT + 1) #define VKMEMALLOCFLAGS_STRLEN (VKMEMALLOCFLAGS_COUNT + 1)
// Fills string `out_flags` with characters at each corresponding flag slot. // Fills string `out_flags` with characters at each corresponding flag slot.
// Returns number of flags set. static void VK_MemoryAllocateFlags_String( VkMemoryAllocateFlags flags, char out_flags[VKMEMALLOCFLAGS_STRLEN] ) {
static int VK_MemoryAllocateFlags_String( VkMemoryAllocateFlags flags, char *out_flags, size_t out_flags_size ) {
ASSERT( out_flags_size >= VKMEMALLOCFLAGS_MINSTRLEN );
int set_flags = 0;
if ( out_flags_size < VKMEMALLOCFLAGS_MINSTRLEN ) {
out_flags[0] = '\0';
return set_flags;
}
int flag = 0; int flag = 0;
if ( flags & VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT ) {out_flags[flag] = 'M'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT ) {out_flags[flag] = 'M';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT ) {out_flags[flag] = 'A'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT ) {out_flags[flag] = 'A';} else {out_flags[flag] = '-';} flag += 1;
if ( flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT ) {out_flags[flag] = 'R'; set_flags += 1;} else {out_flags[flag] = '-';} flag += 1; if ( flags & VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT ) {out_flags[flag] = 'R';} else {out_flags[flag] = '-';} flag += 1;
out_flags[flag] = '\0'; out_flags[flag] = '\0';
return set_flags;
} }
static int findMemoryWithType(uint32_t type_index_bits, VkMemoryPropertyFlags flags) { static int findMemoryWithType(uint32_t type_index_bits, VkMemoryPropertyFlags flags) {
VkPhysicalDeviceMemoryProperties properties = vk_core.physical_device.memory_properties2.memoryProperties; const VkPhysicalDeviceMemoryProperties *const properties = &vk_core.physical_device.memory_properties2.memoryProperties;
for ( int type = 0; type < (int)properties.memoryTypeCount; type += 1 ) { for ( int type = 0; type < (int)properties->memoryTypeCount; type += 1 ) {
if ( !( type_index_bits & ( 1 << type ) ) ) if ( !( type_index_bits & ( 1 << type ) ) )
continue; continue;
if ( ( properties.memoryTypes[type].propertyFlags & flags ) == flags ) if ( ( properties->memoryTypes[type].propertyFlags & flags ) == flags )
return type; return type;
} }
@ -184,7 +179,7 @@ static VkDeviceSize optimalSize(VkDeviceSize size) {
} }
static int allocateDeviceMemory(VkMemoryRequirements req, int type_index, VkMemoryAllocateFlags allocate_flags) { static int allocateDeviceMemory(VkMemoryRequirements req, int type_index, VkMemoryAllocateFlags allocate_flags) {
if ( g_vk_devmem.alloc_slots_count == MAX_DEVMEM_ALLOC_SLOTS ) { if ( g_devmem.alloc_slots_count == MAX_DEVMEM_ALLOC_SLOTS ) {
gEngine.Host_Error( "Ran out of device memory allocation slots\n" ); gEngine.Host_Error( "Ran out of device memory allocation slots\n" );
return -1; return -1;
} }
@ -202,26 +197,26 @@ static int allocateDeviceMemory(VkMemoryRequirements req, int type_index, VkMemo
.memoryTypeIndex = type_index, .memoryTypeIndex = type_index,
}; };
if ( g_vk_devmem.verbose ) { if ( g_devmem.verbose ) {
char allocate_flags_str[VKMEMALLOCFLAGS_MINSTRLEN]; char allocate_flags_str[VKMEMALLOCFLAGS_STRLEN];
VK_MemoryAllocateFlags_String( allocate_flags, &allocate_flags_str[0], sizeof( allocate_flags_str ) ); VK_MemoryAllocateFlags_String( allocate_flags, allocate_flags_str );
unsigned long long size = (unsigned long long) mai.allocationSize; unsigned long long size = (unsigned long long) mai.allocationSize;
gEngine.Con_Reportf( " ^3->^7 ^6AllocateDeviceMemory:^7 { size: %llu, memoryTypeBits: 0x%x, allocate_flags: %s => typeIndex: %d }\n", gEngine.Con_Reportf( " ^3->^7 ^6AllocateDeviceMemory:^7 { size: %llu, memoryTypeBits: 0x%x, allocate_flags: %s => typeIndex: %d }\n",
size, req.memoryTypeBits, allocate_flags_str, mai.memoryTypeIndex ); size, req.memoryTypeBits, allocate_flags_str, mai.memoryTypeIndex );
} }
ASSERT( mai.memoryTypeIndex != UINT32_MAX ); ASSERT( mai.memoryTypeIndex != UINT32_MAX );
vk_device_memory_slot_t *slot = &g_vk_devmem.alloc_slots[g_vk_devmem.alloc_slots_count]; vk_device_memory_slot_t *slot = &g_devmem.alloc_slots[g_devmem.alloc_slots_count];
XVK_CHECK( vkAllocateMemory( vk_core.device, &mai, NULL, &slot->device_memory ) ); XVK_CHECK( vkAllocateMemory( vk_core.device, &mai, NULL, &slot->device_memory ) );
VkPhysicalDeviceMemoryProperties properties = vk_core.physical_device.memory_properties2.memoryProperties; const VkPhysicalDeviceMemoryProperties *const properties = &vk_core.physical_device.memory_properties2.memoryProperties;
slot->property_flags = properties.memoryTypes[mai.memoryTypeIndex].propertyFlags; slot->property_flags = properties->memoryTypes[mai.memoryTypeIndex].propertyFlags;
slot->allocate_flags = allocate_flags; slot->allocate_flags = allocate_flags;
slot->type_index = mai.memoryTypeIndex; slot->type_index = mai.memoryTypeIndex;
slot->refcount = 0; slot->refcount = 0;
slot->size = mai.allocationSize; slot->size = mai.allocationSize;
g_vk_devmem.device_allocated += mai.allocationSize; g_devmem.device_allocated += mai.allocationSize;
const int expected_allocations = 0; const int expected_allocations = 0;
const int min_alignment = 16; const int min_alignment = 16;
@ -229,7 +224,7 @@ static int allocateDeviceMemory(VkMemoryRequirements req, int type_index, VkMemo
if ( slot->property_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ) { if ( slot->property_flags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT ) {
XVK_CHECK( vkMapMemory( vk_core.device, slot->device_memory, 0, slot->size, 0, &slot->mapped ) ); XVK_CHECK( vkMapMemory( vk_core.device, slot->device_memory, 0, slot->size, 0, &slot->mapped ) );
if ( g_vk_devmem.verbose ) { if ( g_devmem.verbose ) {
size_t size = (size_t) slot->size; size_t size = (size_t) slot->size;
size_t device = (size_t) vk_core.device; size_t device = (size_t) vk_core.device;
size_t device_memory = (size_t) slot->device_memory; size_t device_memory = (size_t) slot->device_memory;
@ -242,7 +237,7 @@ static int allocateDeviceMemory(VkMemoryRequirements req, int type_index, VkMemo
} }
} }
return g_vk_devmem.alloc_slots_count++; return g_devmem.alloc_slots_count++;
} }
vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_type, vk_devmem_allocate_args_t devmem_allocate_args) { vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_type, vk_devmem_allocate_args_t devmem_allocate_args) {
@ -253,11 +248,11 @@ vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_typ
vk_devmem_t devmem = { .usage_type = usage_type }; vk_devmem_t devmem = { .usage_type = usage_type };
const int type_index = findMemoryWithType(req.memoryTypeBits, property_flags); const int type_index = findMemoryWithType(req.memoryTypeBits, property_flags);
if ( g_vk_devmem.verbose ) { if ( g_devmem.verbose ) {
char property_flags_str[VKMEMPROPFLAGS_MINSTRLEN]; char property_flags_str[VKMEMPROPFLAGS_STRLEN];
char allocate_flags_str[VKMEMALLOCFLAGS_MINSTRLEN]; char allocate_flags_str[VKMEMALLOCFLAGS_STRLEN];
VK_MemoryPropertyFlags_String( property_flags, &property_flags_str[0], sizeof( property_flags_str ) ); VK_MemoryPropertyFlags_String( property_flags, property_flags_str );
VK_MemoryAllocateFlags_String( allocate_flags, &allocate_flags_str[0], sizeof( allocate_flags_str ) ); VK_MemoryAllocateFlags_String( allocate_flags, allocate_flags_str );
const char *usage_type_str = VK_DevMemUsageTypeString( usage_type ); const char *usage_type_str = VK_DevMemUsageTypeString( usage_type );
@ -275,8 +270,8 @@ vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_typ
alo_block_t block; alo_block_t block;
int slot_index = -1; int slot_index = -1;
for ( int _slot_index = 0; _slot_index < g_vk_devmem.alloc_slots_count; _slot_index += 1 ) { for ( int _slot_index = 0; _slot_index < g_devmem.alloc_slots_count; _slot_index += 1 ) {
vk_device_memory_slot_t *const slot = g_vk_devmem.alloc_slots + _slot_index; vk_device_memory_slot_t *const slot = g_devmem.alloc_slots + _slot_index;
if ( slot->type_index != type_index ) if ( slot->type_index != type_index )
continue; continue;
@ -300,18 +295,18 @@ vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_typ
if ( slot_index < 0 ) if ( slot_index < 0 )
return devmem; return devmem;
struct alo_pool_s *allocator = g_vk_devmem.alloc_slots[slot_index].allocator; struct alo_pool_s *allocator = g_devmem.alloc_slots[slot_index].allocator;
block = aloPoolAllocate( allocator, req.size, req.alignment ); block = aloPoolAllocate( allocator, req.size, req.alignment );
ASSERT( block.size != 0 ); ASSERT( block.size != 0 );
} }
{ {
vk_device_memory_slot_t *const slot = g_vk_devmem.alloc_slots + slot_index; vk_device_memory_slot_t *const slot = g_devmem.alloc_slots + slot_index;
devmem.device_memory = slot->device_memory; devmem.device_memory = slot->device_memory;
devmem.offset = block.offset; devmem.offset = block.offset;
devmem.mapped = slot->mapped ? (char *)slot->mapped + block.offset : NULL; devmem.mapped = slot->mapped ? (char *)slot->mapped + block.offset : NULL;
if ( g_vk_devmem.verbose ) { if ( g_devmem.verbose ) {
gEngine.Con_Reportf( " ^3->^7 Allocated: { slot: %d, block: %d, offset: %d, size: %d }\n", gEngine.Con_Reportf( " ^3->^7 Allocated: { slot: %d, block: %d, offset: %d, size: %d }\n",
slot_index, block.index, (int)block.offset, (int)block.size ); slot_index, block.index, (int)block.offset, (int)block.size );
} }
@ -330,13 +325,13 @@ vk_devmem_t VK_DevMemAllocate(const char *name, vk_devmem_usage_type_t usage_typ
void VK_DevMemFree(const vk_devmem_t *mem) { void VK_DevMemFree(const vk_devmem_t *mem) {
ASSERT( mem->_slot_index >= 0 ); ASSERT( mem->_slot_index >= 0 );
ASSERT( mem->_slot_index < g_vk_devmem.alloc_slots_count ); ASSERT( mem->_slot_index < g_devmem.alloc_slots_count );
int slot_index = mem->_slot_index; int slot_index = mem->_slot_index;
vk_device_memory_slot_t *const slot = g_vk_devmem.alloc_slots + slot_index; vk_device_memory_slot_t *const slot = g_devmem.alloc_slots + slot_index;
ASSERT( mem->device_memory == slot->device_memory ); ASSERT( mem->device_memory == slot->device_memory );
if ( g_vk_devmem.verbose ) { if ( g_devmem.verbose ) {
const char *usage_type = VK_DevMemUsageTypeString( mem->usage_type ); const char *usage_type = VK_DevMemUsageTypeString( mem->usage_type );
int align_hole = mem->_block_size % mem->_block_alignment; int align_hole = mem->_block_size % mem->_block_alignment;
gEngine.Con_Reportf( "^2VK_DevMemFree:^7 { slot: %d, block: %d, usage: %s, size: %d, alignment: %d, hole: %d }\n", gEngine.Con_Reportf( "^2VK_DevMemFree:^7 { slot: %d, block: %d, usage: %s, size: %d, alignment: %d, hole: %d }\n",
@ -350,54 +345,48 @@ void VK_DevMemFree(const vk_devmem_t *mem) {
slot->refcount--; slot->refcount--;
} }
// Little helper macro to turn anything into string.
#define STRING( str ) #str
// Register single stats variable. // Register single stats variable.
#define REGISTER_STATS_METRIC( var, metric_name, var_name, metric_type ) \ #define REGISTER_STATS_METRIC( var, metric_name, var_name, metric_type ) \
R_SpeedsRegisterMetric( &(var), MODULE_NAME, metric_name, metric_type, /*reset*/ false, var_name, __FILE__, __LINE__ ); R_SpeedsRegisterMetric( &(var), MODULE_NAME, #metric_name, metric_type, /*reset*/ false, #var_name, __FILE__, __LINE__ );
// NOTE(nilsoncore): I know, this is a mess... Sorry. // NOTE(nilsoncore): I know, this is a mess... Sorry.
// It could have been avoided by having short `VK_DevMemUsageTypes` enum names, // It could have been avoided by having short `VK_DevMemUsageTypes` enum names,
// but I have done it this way because I want those enum names to be as descriptive as possible. // but I have done it this way because I want those enum names to be as descriptive as possible.
// This basically replaces those enum names with ones provided by suffixes, which are just their endings. // This basically replaces those enum names with ones provided by suffixes, which are just their endings.
//
// | var | metric_name | var_name | metric_type |
// | -------------------------------- | -------------------------------------- | ----------------------------------------------------- | ------------------ |
#define REGISTER_STATS_METRICS( usage_type, usage_suffix ) { \ #define REGISTER_STATS_METRICS( usage_type, usage_suffix ) { \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].allocations_current, STRING( allocations_current##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].allocations_current ), kSpeedsMetricCount ); \ vk_devmem_allocation_stats_t *const stats = &g_devmem.stats[usage_type]; \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].allocated_current, STRING( allocated_current##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].allocated_current ), kSpeedsMetricBytes ); \ REGISTER_STATS_METRIC( stats->current.allocations, current_allocations##usage_suffix, g_devmem.stats[usage_suffix].current.allocations, kSpeedsMetricCount ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].allocations_total, STRING( allocations_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].allocations_total ), kSpeedsMetricCount ); \ REGISTER_STATS_METRIC( stats->current.allocated, current_allocated##usage_suffix, g_devmem.stats[usage_suffix].current.allocated, kSpeedsMetricBytes ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].allocated_total, STRING( allocated_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].allocated_total ), kSpeedsMetricBytes ); \ REGISTER_STATS_METRIC( stats->current.align_holes, current_align_holes##usage_suffix, g_devmem.stats[usage_suffix].current.align_holes, kSpeedsMetricCount ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].frees_total, STRING( frees_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].frees_total ), kSpeedsMetricCount ); \ REGISTER_STATS_METRIC( stats->current.align_holes_size, current_align_holes_size##usage_suffix, g_devmem.stats[usage_suffix].current.align_holes_size, kSpeedsMetricBytes ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].freed_total, STRING( freed_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].freed_total ), kSpeedsMetricBytes ); \ REGISTER_STATS_METRIC( stats->peak.allocations, peak_allocations##usage_suffix, g_devmem.stats[usage_suffix].peak.allocations, kSpeedsMetricCount ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].align_holes_current, STRING( align_holes_current##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].align_holes_current ), kSpeedsMetricCount ); \ REGISTER_STATS_METRIC( stats->peak.allocated, peak_allocated##usage_suffix, g_devmem.stats[usage_suffix].peak.allocated, kSpeedsMetricBytes ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].align_holes_size_current, STRING( align_holes_size_current##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].align_holes_size_current ), kSpeedsMetricBytes ); \ REGISTER_STATS_METRIC( stats->peak.align_holes, peak_align_holes##usage_suffix, g_devmem.stats[usage_suffix].peak.align_holes, kSpeedsMetricCount ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].align_holes_total, STRING( align_holes_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].align_holes_total ), kSpeedsMetricCount ); \ REGISTER_STATS_METRIC( stats->peak.align_holes_size, peak_align_holes_size##usage_suffix, g_devmem.stats[usage_suffix].peak.align_holes_size, kSpeedsMetricBytes ); \
REGISTER_STATS_METRIC( g_vk_devmem.stats[usage_type].align_holes_size_total, STRING( align_holes_size_total##usage_suffix ), STRING( g_vk_devmem.stats[usage_suffix].align_holes_size_total ), kSpeedsMetricBytes ); \ REGISTER_STATS_METRIC( stats->peak.align_hole_size, peak_align_hole_size##usage_suffix, g_devmem.stats[usage_suffix].peak.align_hole_size, kSpeedsMetricBytes ); \
} }
qboolean VK_DevMemInit( void ) { qboolean VK_DevMemInit( void ) {
g_vk_devmem.verbose = gEngine.Sys_CheckParm( "-vkdebugmem" ); g_devmem.verbose = gEngine.Sys_CheckParm( "-vkdebugmem" );
// Register standalone metrics. // Register standalone metrics.
R_SPEEDS_METRIC( g_vk_devmem.alloc_slots_count, "allocated_slots", kSpeedsMetricCount ); R_SPEEDS_METRIC( g_devmem.alloc_slots_count, "allocated_slots", kSpeedsMetricCount );
R_SPEEDS_METRIC( g_vk_devmem.device_allocated, "device_allocated", kSpeedsMetricBytes ); R_SPEEDS_METRIC( g_devmem.device_allocated, "device_allocated", kSpeedsMetricBytes );
// Register stats metrics for each usage type. // Register stats metrics for each usage type.
// Maybe these metrics should be enabled only with `-vkdebugmem`? REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_ALL, _ALL );
REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_ALL, _ALL );
REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_BUFFER, _BUFFER ); REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_BUFFER, _BUFFER );
REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_IMAGE, _IMAGE ); REGISTER_STATS_METRICS( VK_DEVMEM_USAGE_TYPE_IMAGE, _IMAGE );
return true; return true;
} }
// NOTE(nilsoncore):
// It has to be undefined only after `VK_DevMemInit` because
// otherwise the function would not know what this is.
#undef STRING
void VK_DevMemDestroy( void ) { void VK_DevMemDestroy( void ) {
for ( int slot_index = 0; slot_index < g_vk_devmem.alloc_slots_count; slot_index += 1 ) { for ( int slot_index = 0; slot_index < g_devmem.alloc_slots_count; slot_index += 1 ) {
const vk_device_memory_slot_t *const slot = g_vk_devmem.alloc_slots + slot_index; const vk_device_memory_slot_t *const slot = g_devmem.alloc_slots + slot_index;
ASSERT( slot->refcount == 0 ); ASSERT( slot->refcount == 0 );
// TODO check that everything has been freed // TODO check that everything has been freed
@ -409,7 +398,7 @@ void VK_DevMemDestroy( void ) {
vkFreeMemory( vk_core.device, slot->device_memory, NULL ); vkFreeMemory( vk_core.device, slot->device_memory, NULL );
} }
g_vk_devmem.alloc_slots_count = 0; g_devmem.alloc_slots_count = 0;
} }
const char *VK_DevMemUsageTypeString( vk_devmem_usage_type_t type ) { const char *VK_DevMemUsageTypeString( vk_devmem_usage_type_t type ) {

3
ref/vk/vk_image.c
View File

@ -45,10 +45,9 @@ xvk_image_t XVK_ImageCreate(const xvk_image_create_t *create) {
vkGetImageMemoryRequirements(vk_core.device, image.image, &memreq); vkGetImageMemoryRequirements(vk_core.device, image.image, &memreq);
VkMemoryPropertyFlags memory_props = (create->memory_props) ? create->memory_props : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT;
vk_devmem_allocate_args_t args = (vk_devmem_allocate_args_t) { vk_devmem_allocate_args_t args = (vk_devmem_allocate_args_t) {
.requirements = memreq, .requirements = memreq,
.property_flags = memory_props, .property_flags = (create->memory_props) ? create->memory_props : VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
.allocate_flags = 0, .allocate_flags = 0,
}; };
image.devmem = VK_DevMemAllocateImage( create->debug_name, args ); image.devmem = VK_DevMemAllocateImage( create->debug_name, args );