mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-19 12:56:06 +00:00
feat(session): manage memory automatically and remove the manual memory controls (#2853)
Memory in the Steam session is kept above a floor by a monitor instead of the zRAM, RAM cap and VRAM cap settings, which are removed.
This commit is contained in:
1 parent
123c431b8e
commit
adf13d0bdd
60 files changed
+1117
-2264
No files matched your search
@@ -1,154 +0,0 @@
|
||||
#include <assert.h>
|
||||
#include <inttypes.h>
|
||||
#include "../src/vk_layer_droiddeck_vramcap.c"
|
||||
|
||||
static int instance_dispatch, device_dispatch;
|
||||
static void *instance_object = &instance_dispatch, *physical_object = &instance_dispatch;
|
||||
static void *device_object = &device_dispatch;
|
||||
static VkInstance instance;
|
||||
static VkPhysicalDevice physical;
|
||||
static VkDevice device;
|
||||
static unsigned allocations, frees, destroyed_devices, destroyed_instances;
|
||||
|
||||
static void VKAPI_CALL memory_properties(VkPhysicalDevice pd, VkPhysicalDeviceMemoryProperties *out) {
|
||||
assert(pd == physical);
|
||||
*out = (VkPhysicalDeviceMemoryProperties){
|
||||
.memoryHeapCount = 3,
|
||||
.memoryHeaps = {{8ULL << 30, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT}, {4ULL << 30, 0},
|
||||
{512ULL << 20, VK_MEMORY_HEAP_DEVICE_LOCAL_BIT}},
|
||||
.memoryTypeCount = 1,
|
||||
.memoryTypes = {{VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, 0}},
|
||||
};
|
||||
}
|
||||
|
||||
static void VKAPI_CALL memory_properties2(VkPhysicalDevice pd, VkPhysicalDeviceMemoryProperties2 *out) {
|
||||
memory_properties(pd, &out->memoryProperties);
|
||||
for (VkBaseOutStructure *p = out->pNext; p; p = p->pNext)
|
||||
if (p->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT) {
|
||||
VkPhysicalDeviceMemoryBudgetPropertiesEXT *b = (void *)p;
|
||||
b->heapBudget[0] = 6ULL << 30;
|
||||
b->heapBudget[1] = 3ULL << 30;
|
||||
b->heapBudget[2] = 256ULL << 20;
|
||||
b->heapUsage[0] = 3ULL << 30;
|
||||
}
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL allocate(VkDevice d, const VkMemoryAllocateInfo *info,
|
||||
const VkAllocationCallbacks *a, VkDeviceMemory *out) {
|
||||
assert(d == device && info->allocationSize == (3ULL << 30));
|
||||
*out = (VkDeviceMemory)(uintptr_t)++allocations;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL release(VkDevice d, VkDeviceMemory m, const VkAllocationCallbacks *a) {
|
||||
assert(d == device && m);
|
||||
frees++;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL destroy_device(VkDevice d, const VkAllocationCallbacks *a) {
|
||||
assert(d == device);
|
||||
destroyed_devices++;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL destroy_instance(VkInstance in, const VkAllocationCallbacks *a) {
|
||||
assert(in == instance);
|
||||
destroyed_instances++;
|
||||
}
|
||||
|
||||
static PFN_vkVoidFunction VKAPI_CALL gdpa(VkDevice d, const char *name) {
|
||||
assert(d == device);
|
||||
if (!strcmp(name, "vkAllocateMemory")) return (PFN_vkVoidFunction)allocate;
|
||||
if (!strcmp(name, "vkFreeMemory")) return (PFN_vkVoidFunction)release;
|
||||
if (!strcmp(name, "vkDestroyDevice")) return (PFN_vkVoidFunction)destroy_device;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL create_device(VkPhysicalDevice pd, const VkDeviceCreateInfo *ci,
|
||||
const VkAllocationCallbacks *a, VkDevice *out) {
|
||||
assert(pd == physical);
|
||||
*out = device;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL create_instance(const VkInstanceCreateInfo *ci, const VkAllocationCallbacks *a, VkInstance *out) {
|
||||
*out = instance;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
static PFN_vkVoidFunction VKAPI_CALL gipa(VkInstance in, const char *name) {
|
||||
assert(in == instance || in == VK_NULL_HANDLE);
|
||||
if (!strcmp(name, "vkCreateInstance")) return (PFN_vkVoidFunction)create_instance;
|
||||
if (!strcmp(name, "vkDestroyInstance")) return (PFN_vkVoidFunction)destroy_instance;
|
||||
if (!strcmp(name, "vkCreateDevice")) return (PFN_vkVoidFunction)create_device;
|
||||
if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties")) return (PFN_vkVoidFunction)memory_properties;
|
||||
if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2") || !strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR"))
|
||||
return (PFN_vkVoidFunction)memory_properties2;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
assert(vramcap_parse_mb("2048") == (2ULL << 30));
|
||||
assert(vramcap_parse_mb(NULL) == 0 && vramcap_parse_mb("") == 0 && vramcap_parse_mb("0") == 0);
|
||||
const char *bad[] = {"-1", "+1", " 1024", "1024 ", "1GB", "18446744073709551616", "17592186044416"};
|
||||
for (size_t i = 0; i < sizeof(bad) / sizeof(bad[0]); i++) assert(vramcap_parse_mb(bad[i]) == 0);
|
||||
assert(vramcap_parse_mb("17592186044415") == ((UINT64_MAX >> 20) << 20));
|
||||
|
||||
instance = (VkInstance)&instance_object;
|
||||
physical = (VkPhysicalDevice)&physical_object;
|
||||
device = (VkDevice)&device_object;
|
||||
g_cap = 2ULL << 30;
|
||||
VkLayerInstanceLink il = {.pfnNextGetInstanceProcAddr = gipa};
|
||||
VkLayerInstanceCreateInfo ic = {.sType = VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO,
|
||||
.function = VK_LAYER_LINK_INFO, .u.pLayerInfo = &il};
|
||||
VkInstanceCreateInfo ici = {.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, .pNext = &ic};
|
||||
VkInstance got_instance;
|
||||
assert(CreateInstance(&ici, NULL, &got_instance) == VK_SUCCESS && got_instance == instance);
|
||||
VkPhysicalDeviceMemoryProperties p;
|
||||
PFN_vkGetPhysicalDeviceMemoryProperties get = (void *)DroidDeckVramCap_GetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties");
|
||||
assert(get == memory_properties);
|
||||
get(physical, &p);
|
||||
assert(p.memoryHeaps[0].size == (8ULL << 30) && p.memoryHeaps[1].size == (4ULL << 30));
|
||||
assert(p.memoryHeaps[2].size == (512ULL << 20));
|
||||
assert(p.memoryTypes[0].propertyFlags == (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT));
|
||||
|
||||
const char *names[] = {"vkGetPhysicalDeviceMemoryProperties2", "vkGetPhysicalDeviceMemoryProperties2KHR"};
|
||||
for (size_t i = 0; i < 2; i++) {
|
||||
VkPhysicalDeviceMemoryBudgetPropertiesEXT b = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT};
|
||||
VkPhysicalDeviceIDProperties id = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, .pNext = &b};
|
||||
VkPhysicalDeviceMemoryProperties2 p2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, .pNext = &id};
|
||||
PFN_vkGetPhysicalDeviceMemoryProperties2 get2 = (void *)DroidDeckVramCap_GetInstanceProcAddr(instance, names[i]);
|
||||
get2(physical, &p2);
|
||||
assert(p2.memoryProperties.memoryHeaps[0].size == (8ULL << 30));
|
||||
assert(b.heapBudget[0] == g_cap && b.heapBudget[1] == (3ULL << 30));
|
||||
assert(b.heapBudget[2] == (256ULL << 20));
|
||||
assert(b.heapUsage[0] == (3ULL << 30));
|
||||
assert(p2.pNext == &id && id.pNext == &b);
|
||||
}
|
||||
|
||||
VkLayerDeviceLink dl = {.pfnNextGetInstanceProcAddr = gipa, .pfnNextGetDeviceProcAddr = gdpa};
|
||||
VkLayerDeviceCreateInfo dc = {.sType = VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO,
|
||||
.function = VK_LAYER_LINK_INFO, .u.pLayerInfo = &dl};
|
||||
VkDeviceCreateInfo dci = {.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO, .pNext = &dc};
|
||||
VkDevice got_device;
|
||||
assert(CreateDevice(physical, &dci, NULL, &got_device) == VK_SUCCESS && got_device == device);
|
||||
PFN_vkAllocateMemory next_allocate = (void *)DroidDeckVramCap_GetDeviceProcAddr(device, "vkAllocateMemory");
|
||||
PFN_vkFreeMemory next_free = (void *)DroidDeckVramCap_GetDeviceProcAddr(device, "vkFreeMemory");
|
||||
assert(next_allocate == allocate && next_free == release);
|
||||
VkMemoryAllocateInfo ai = {.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO, .allocationSize = 3ULL << 30};
|
||||
VkDeviceMemory blocks[2];
|
||||
for (unsigned i = 0; i < 2; i++) assert(next_allocate(device, &ai, NULL, &blocks[i]) == VK_SUCCESS);
|
||||
assert(allocations == 2);
|
||||
for (unsigned i = 0; i < 2; i++) next_free(device, blocks[i], NULL);
|
||||
assert(frees == 2);
|
||||
|
||||
g_cap = 0;
|
||||
assert(DroidDeckVramCap_GetInstanceProcAddr(instance, names[0]) == (PFN_vkVoidFunction)memory_properties2);
|
||||
assert(DroidDeckVramCap_GetInstanceProcAddr(instance, "vkGetPhysicalDeviceMemoryProperties") == (PFN_vkVoidFunction)memory_properties);
|
||||
PFN_vkDestroyDevice destroy = (void *)DroidDeckVramCap_GetInstanceProcAddr(instance, "vkDestroyDevice");
|
||||
assert(destroy == DestroyDevice);
|
||||
destroy(device, NULL);
|
||||
DestroyInstance(instance, NULL);
|
||||
assert(destroyed_devices == 1 && destroyed_instances == 1 && !g_devs && !g_insts);
|
||||
puts("test_vramcap_budget: ok");
|
||||
return 0;
|
||||
}
|
||||
Reference in new issue
Block a user