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
@@ -23,8 +23,7 @@
|
||||
"outputs": [
|
||||
"app/src/main/assets/linuxfs/usr/local/bin/gamescope",
|
||||
"app/src/main/assets/linuxfs/usr/local/lib/droiddeck-vr/droiddeck/bin/linuxarm64/driver_droiddeck.so",
|
||||
"app/src/main/assets/linuxfs/usr/local/lib/droiddeck-gpuload/libVkLayer_droiddeck_gpuload.so",
|
||||
"app/src/main/assets/linuxfs/usr/local/lib/droiddeck-gpuload/libVkLayer_droiddeck_vramcap.so"
|
||||
"app/src/main/assets/linuxfs/usr/local/lib/droiddeck-gpuload/libVkLayer_droiddeck_gpuload.so"
|
||||
],
|
||||
"ndk": true,
|
||||
"packages": [
|
||||
|
||||
+3
-10
@@ -1,6 +1,5 @@
|
||||
#!/usr/bin/env bash
|
||||
# Builds VK_LAYER_DROIDDECK_gpu_load for the arm64 guest: tools/gpuload/build.sh [--native] OUT
|
||||
# OUT gets libVkLayer_droiddeck_gpuload.so, libVkLayer_droiddeck_vramcap.so and their implicit-layer manifests.
|
||||
set -euo pipefail
|
||||
here=$(cd "$(dirname "$0")" && pwd)
|
||||
repo=$(cd "$here/../.." && pwd)
|
||||
@@ -36,15 +35,10 @@ cmd=(sh -c '
|
||||
build/gpuload/test_gpuload_busy
|
||||
cc -std=c11 -O2 -Wall -Wextra -Werror -Ibuild/gpuload/include -Itools/gpuload/src -o build/gpuload/test_gpuload_ring tools/gpuload/tests/test_gpuload_ring.c
|
||||
build/gpuload/test_gpuload_ring
|
||||
cc -std=c11 -O2 -Wall -Wextra -Werror -Ibuild/gpuload/include -Itools/gpuload/src -pthread -Wno-unused-parameter -Wno-missing-field-initializers -o build/gpuload/test_vramcap_budget tools/gpuload/tests/test_vramcap_budget.c
|
||||
build/gpuload/test_vramcap_budget
|
||||
aarch64-linux-gnu-gcc -std=c11 -shared -fPIC -O2 -Wall -Wextra -Werror -Wno-unused-parameter -Wno-missing-field-initializers \
|
||||
-fvisibility=hidden -pthread -Wl,-z,defs -Ibuild/gpuload/include -Itools/gpuload/src \
|
||||
-o build/gpuload/out/libVkLayer_droiddeck_gpuload.so tools/gpuload/src/vk_layer_droiddeck_gpuload.c
|
||||
aarch64-linux-gnu-gcc -std=c11 -shared -fPIC -O2 -Wall -Wextra -Werror -Wno-unused-parameter -Wno-missing-field-initializers \
|
||||
-fvisibility=hidden -pthread -Wl,-z,defs -Ibuild/gpuload/include -Itools/gpuload/src \
|
||||
-o build/gpuload/out/libVkLayer_droiddeck_vramcap.so tools/gpuload/src/vk_layer_droiddeck_vramcap.c
|
||||
aarch64-linux-gnu-strip --strip-unneeded build/gpuload/out/libVkLayer_droiddeck_gpuload.so build/gpuload/out/libVkLayer_droiddeck_vramcap.so')
|
||||
aarch64-linux-gnu-strip --strip-unneeded build/gpuload/out/libVkLayer_droiddeck_gpuload.so')
|
||||
if [ "$native" = 1 ]; then
|
||||
(cd "$repo" && "${cmd[@]}")
|
||||
else
|
||||
@@ -52,8 +46,7 @@ else
|
||||
"${DROIDDECK_BUILD_IMAGE:-droiddeck-local-cross:24.04-v3}" "${cmd[@]}"
|
||||
fi
|
||||
|
||||
cp "$here/layer/VK_LAYER_DROIDDECK_gpu_load.json" "$here/layer/VK_LAYER_DROIDDECK_vram_cap.json" "$work/out/"
|
||||
cp "$here/layer/VK_LAYER_DROIDDECK_gpu_load.json" "$work/out/"
|
||||
mkdir -p "$out"
|
||||
cp "$work/out/libVkLayer_droiddeck_gpuload.so" "$work/out/libVkLayer_droiddeck_vramcap.so" \
|
||||
"$work/out/VK_LAYER_DROIDDECK_gpu_load.json" "$work/out/VK_LAYER_DROIDDECK_vram_cap.json" "$out/"
|
||||
cp "$work/out/libVkLayer_droiddeck_gpuload.so" "$work/out/VK_LAYER_DROIDDECK_gpu_load.json" "$out/"
|
||||
echo "built $out"
|
||||
@@ -1,20 +0,0 @@
|
||||
{
|
||||
"file_format_version": "1.2.0",
|
||||
"layer": {
|
||||
"name": "VK_LAYER_DROIDDECK_vram_cap",
|
||||
"type": "GLOBAL",
|
||||
"library_path": "/usr/local/lib/droiddeck-gpuload/libVkLayer_droiddeck_vramcap.so",
|
||||
"api_version": "1.3.0",
|
||||
"implementation_version": "1",
|
||||
"description": "Reports a smaller video memory budget to DXVK and vkd3d-proton",
|
||||
"functions": {
|
||||
"vkNegotiateLoaderLayerInterfaceVersion": "DroidDeckVramCap_NegotiateLoaderLayerInterfaceVersion"
|
||||
},
|
||||
"enable_environment": {
|
||||
"DROIDDECK_VRAM_CAP": "1"
|
||||
},
|
||||
"disable_environment": {
|
||||
"DROIDDECK_VRAM_CAP_DISABLE": "1"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,206 +0,0 @@
|
||||
#define _GNU_SOURCE
|
||||
#include <vulkan/vulkan.h>
|
||||
#include <vulkan/vk_layer.h>
|
||||
|
||||
#include <pthread.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "vramcap_budget.h"
|
||||
|
||||
#define EXPORT __attribute__((visibility("default")))
|
||||
|
||||
static uint64_t g_cap;
|
||||
|
||||
__attribute__((constructor)) static void init(void) {
|
||||
g_cap = vramcap_parse_mb(getenv("DROIDDECK_VRAM_CAP_MB"));
|
||||
}
|
||||
|
||||
struct inst {
|
||||
struct inst *next_in_list;
|
||||
VkInstance handle;
|
||||
PFN_vkGetInstanceProcAddr gipa;
|
||||
PFN_vkDestroyInstance destroy;
|
||||
PFN_vkGetPhysicalDeviceMemoryProperties2 mem2;
|
||||
PFN_vkGetPhysicalDeviceMemoryProperties2 mem2_khr;
|
||||
};
|
||||
|
||||
struct dev {
|
||||
struct dev *next_in_list;
|
||||
VkDevice handle;
|
||||
PFN_vkGetDeviceProcAddr gdpa;
|
||||
PFN_vkDestroyDevice destroy;
|
||||
};
|
||||
|
||||
static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;
|
||||
static struct inst *g_insts;
|
||||
static struct dev *g_devs;
|
||||
static int g_announced;
|
||||
|
||||
static void *key(const void *obj) { return *(void *const *)obj; }
|
||||
|
||||
static struct inst *inst_for(const void *obj) {
|
||||
struct inst *r;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
for (r = g_insts; r && key(r->handle) != key(obj); r = r->next_in_list) {}
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static struct dev *dev_for(const void *obj) {
|
||||
struct dev *r;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
for (r = g_devs; r && key(r->handle) != key(obj); r = r->next_in_list) {}
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
return r;
|
||||
}
|
||||
|
||||
static void say(const char *what) {
|
||||
fprintf(stderr, "[droiddeck-vram-cap] pid %d: %s\n", (int)getpid(), what);
|
||||
}
|
||||
|
||||
static void announce(void) {
|
||||
if (__atomic_exchange_n(&g_announced, 1, __ATOMIC_RELAXED)) return;
|
||||
char line[96];
|
||||
snprintf(line, sizeof(line), "reported device memory budget %llu MB", (unsigned long long)(g_cap >> 20));
|
||||
say(line);
|
||||
}
|
||||
|
||||
static void clamp_properties2(PFN_vkGetPhysicalDeviceMemoryProperties2 next, VkPhysicalDevice pd,
|
||||
VkPhysicalDeviceMemoryProperties2 *out) {
|
||||
next(pd, out);
|
||||
for (VkBaseOutStructure *s = out->pNext; s; s = s->pNext)
|
||||
if (s->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT) {
|
||||
vramcap_budget(&out->memoryProperties, (VkPhysicalDeviceMemoryBudgetPropertiesEXT *)s, g_cap);
|
||||
if (g_cap) announce();
|
||||
}
|
||||
}
|
||||
|
||||
static void VKAPI_CALL GetMemoryProperties2(VkPhysicalDevice pd, VkPhysicalDeviceMemoryProperties2 *out) {
|
||||
struct inst *in = inst_for(pd);
|
||||
if (in) clamp_properties2(in->mem2, pd, out);
|
||||
}
|
||||
|
||||
static void VKAPI_CALL GetMemoryProperties2KHR(VkPhysicalDevice pd, VkPhysicalDeviceMemoryProperties2 *out) {
|
||||
struct inst *in = inst_for(pd);
|
||||
if (in) clamp_properties2(in->mem2_khr, pd, out);
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL CreateInstance(const VkInstanceCreateInfo *ci, const VkAllocationCallbacks *alloc, VkInstance *out) {
|
||||
VkLayerInstanceCreateInfo *link = (VkLayerInstanceCreateInfo *)ci->pNext;
|
||||
while (link && !(link->sType == VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO && link->function == VK_LAYER_LINK_INFO))
|
||||
link = (VkLayerInstanceCreateInfo *)link->pNext;
|
||||
if (!link) return VK_ERROR_INITIALIZATION_FAILED;
|
||||
PFN_vkGetInstanceProcAddr next_gipa = link->u.pLayerInfo->pfnNextGetInstanceProcAddr;
|
||||
link->u.pLayerInfo = link->u.pLayerInfo->pNext;
|
||||
PFN_vkCreateInstance create = (PFN_vkCreateInstance)next_gipa(VK_NULL_HANDLE, "vkCreateInstance");
|
||||
if (!create) return VK_ERROR_INITIALIZATION_FAILED;
|
||||
struct inst *in = calloc(1, sizeof(*in));
|
||||
if (!in) return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
VkResult r = create(ci, alloc, out);
|
||||
if (r != VK_SUCCESS) { free(in); return r; }
|
||||
in->handle = *out;
|
||||
in->gipa = next_gipa;
|
||||
in->destroy = (PFN_vkDestroyInstance)next_gipa(*out, "vkDestroyInstance");
|
||||
in->mem2 = (PFN_vkGetPhysicalDeviceMemoryProperties2)next_gipa(*out, "vkGetPhysicalDeviceMemoryProperties2");
|
||||
in->mem2_khr = (PFN_vkGetPhysicalDeviceMemoryProperties2)next_gipa(*out, "vkGetPhysicalDeviceMemoryProperties2KHR");
|
||||
pthread_mutex_lock(&g_lock);
|
||||
in->next_in_list = g_insts;
|
||||
g_insts = in;
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL DestroyInstance(VkInstance instance, const VkAllocationCallbacks *alloc) {
|
||||
struct inst *in = inst_for(instance);
|
||||
if (!in) return;
|
||||
PFN_vkDestroyInstance destroy = in->destroy;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
for (struct inst **p = &g_insts; *p; p = &(*p)->next_in_list)
|
||||
if (*p == in) { *p = in->next_in_list; break; }
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
free(in);
|
||||
if (destroy) destroy(instance, alloc);
|
||||
}
|
||||
|
||||
static VkLayerDeviceCreateInfo *device_chain(const VkDeviceCreateInfo *ci, VkLayerFunction function) {
|
||||
VkLayerDeviceCreateInfo *c = (VkLayerDeviceCreateInfo *)ci->pNext;
|
||||
while (c && !(c->sType == VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO && c->function == function))
|
||||
c = (VkLayerDeviceCreateInfo *)c->pNext;
|
||||
return c;
|
||||
}
|
||||
|
||||
static VkResult VKAPI_CALL CreateDevice(VkPhysicalDevice pd, const VkDeviceCreateInfo *ci, const VkAllocationCallbacks *alloc,
|
||||
VkDevice *out) {
|
||||
VkLayerDeviceCreateInfo *link = device_chain(ci, VK_LAYER_LINK_INFO);
|
||||
if (!link) return VK_ERROR_INITIALIZATION_FAILED;
|
||||
PFN_vkGetInstanceProcAddr next_gipa = link->u.pLayerInfo->pfnNextGetInstanceProcAddr;
|
||||
PFN_vkGetDeviceProcAddr next_gdpa = link->u.pLayerInfo->pfnNextGetDeviceProcAddr;
|
||||
link->u.pLayerInfo = link->u.pLayerInfo->pNext;
|
||||
struct inst *in = inst_for(pd);
|
||||
PFN_vkCreateDevice create = (PFN_vkCreateDevice)next_gipa(in ? in->handle : VK_NULL_HANDLE, "vkCreateDevice");
|
||||
if (!create) return VK_ERROR_INITIALIZATION_FAILED;
|
||||
struct dev *d = calloc(1, sizeof(*d));
|
||||
if (!d) return VK_ERROR_OUT_OF_HOST_MEMORY;
|
||||
VkResult r = create(pd, ci, alloc, out);
|
||||
if (r != VK_SUCCESS) { free(d); return r; }
|
||||
d->handle = *out;
|
||||
d->gdpa = next_gdpa;
|
||||
d->destroy = (PFN_vkDestroyDevice)next_gdpa(*out, "vkDestroyDevice");
|
||||
pthread_mutex_lock(&g_lock);
|
||||
d->next_in_list = g_devs;
|
||||
g_devs = d;
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
|
||||
static void VKAPI_CALL DestroyDevice(VkDevice device, const VkAllocationCallbacks *alloc) {
|
||||
struct dev *d = dev_for(device);
|
||||
if (!d) return;
|
||||
pthread_mutex_lock(&g_lock);
|
||||
for (struct dev **p = &g_devs; *p; p = &(*p)->next_in_list)
|
||||
if (*p == d) { *p = d->next_in_list; break; }
|
||||
pthread_mutex_unlock(&g_lock);
|
||||
PFN_vkDestroyDevice destroy = d->destroy;
|
||||
free(d);
|
||||
if (destroy) destroy(device, alloc);
|
||||
}
|
||||
|
||||
EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL DroidDeckVramCap_GetDeviceProcAddr(VkDevice device, const char *name);
|
||||
|
||||
EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL DroidDeckVramCap_GetInstanceProcAddr(VkInstance instance, const char *name) {
|
||||
if (!strcmp(name, "vkCreateInstance")) return (PFN_vkVoidFunction)CreateInstance;
|
||||
if (!strcmp(name, "vkDestroyInstance")) return (PFN_vkVoidFunction)DestroyInstance;
|
||||
if (!strcmp(name, "vkCreateDevice")) return (PFN_vkVoidFunction)CreateDevice;
|
||||
if (!strcmp(name, "vkDestroyDevice")) return (PFN_vkVoidFunction)DestroyDevice;
|
||||
if (!strcmp(name, "vkGetInstanceProcAddr")) return (PFN_vkVoidFunction)DroidDeckVramCap_GetInstanceProcAddr;
|
||||
if (!strcmp(name, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction)DroidDeckVramCap_GetDeviceProcAddr;
|
||||
if (!instance) return NULL;
|
||||
struct inst *in = inst_for(instance);
|
||||
if (!in) return NULL;
|
||||
if (g_cap) {
|
||||
if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2") && in->mem2) return (PFN_vkVoidFunction)GetMemoryProperties2;
|
||||
if (!strcmp(name, "vkGetPhysicalDeviceMemoryProperties2KHR") && in->mem2_khr)
|
||||
return (PFN_vkVoidFunction)GetMemoryProperties2KHR;
|
||||
}
|
||||
return in->gipa(instance, name);
|
||||
}
|
||||
|
||||
EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL DroidDeckVramCap_GetDeviceProcAddr(VkDevice device, const char *name) {
|
||||
if (!strcmp(name, "vkGetDeviceProcAddr")) return (PFN_vkVoidFunction)DroidDeckVramCap_GetDeviceProcAddr;
|
||||
if (!strcmp(name, "vkDestroyDevice")) return (PFN_vkVoidFunction)DestroyDevice;
|
||||
struct dev *d = dev_for(device);
|
||||
if (!d) return NULL;
|
||||
return d->gdpa(device, name);
|
||||
}
|
||||
|
||||
EXPORT VKAPI_ATTR VkResult VKAPI_CALL DroidDeckVramCap_NegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface *v) {
|
||||
if (v->loaderLayerInterfaceVersion > 2) v->loaderLayerInterfaceVersion = 2;
|
||||
v->pfnGetInstanceProcAddr = DroidDeckVramCap_GetInstanceProcAddr;
|
||||
v->pfnGetDeviceProcAddr = DroidDeckVramCap_GetDeviceProcAddr;
|
||||
v->pfnGetPhysicalDeviceProcAddr = NULL;
|
||||
return VK_SUCCESS;
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
#ifndef VRAMCAP_BUDGET_H
|
||||
#define VRAMCAP_BUDGET_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <vulkan/vulkan.h>
|
||||
|
||||
static inline uint64_t vramcap_parse_mb(const char *text) {
|
||||
if (!text || !*text) return 0;
|
||||
uint64_t value = 0, limit = UINT64_MAX >> 20;
|
||||
for (; *text; text++) {
|
||||
if (*text < '0' || *text > '9') return 0;
|
||||
unsigned digit = (unsigned)(*text - '0');
|
||||
if (value > (limit - digit) / 10) return 0;
|
||||
value = value * 10 + digit;
|
||||
}
|
||||
return value << 20;
|
||||
}
|
||||
|
||||
static inline VkDeviceSize vramcap_clamp(VkDeviceSize value, uint64_t cap) {
|
||||
return cap && value > cap ? cap : value;
|
||||
}
|
||||
|
||||
static inline void vramcap_budget(const VkPhysicalDeviceMemoryProperties *p,
|
||||
VkPhysicalDeviceMemoryBudgetPropertiesEXT *budget, uint64_t cap) {
|
||||
for (uint32_t i = 0; i < p->memoryHeapCount && i < VK_MAX_MEMORY_HEAPS; i++)
|
||||
if (p->memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) {
|
||||
budget->heapBudget[i] = vramcap_clamp(budget->heapBudget[i], cap);
|
||||
budget->heapBudget[i] = vramcap_clamp(budget->heapBudget[i], p->memoryHeaps[i].size);
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -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;
|
||||
}
|
||||
@@ -14,7 +14,6 @@ from pathlib import Path
|
||||
GAME_PREFIX = "DROIDDECK_GAME_"
|
||||
GAME_SPLIT_KEYS = ("TU_DEBUG", "MESA_NO_ERROR")
|
||||
CHROMIUM_FILES = {"chrome-sandbox", "chrome_100_percent.pak", "v8_context_snapshot.bin"}
|
||||
D3D9_DEFAULT_MEMORY_MB = 4096
|
||||
SYNC_KEYS = ("DD_SYNC", "DD_SYNC_FALLBACK", "DD_FSYNC_FIRST", "DD_SYNC_MIN_NOFILE", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC", "PROTON_NO_NTSYNC", "WINEESYNC")
|
||||
SEED_REDISTS = "/usr/local/bin/droiddeck-seed-redists"
|
||||
PACK_KEYS = ("WINESERVER", "DD_SYNC_PACK", "WINEESYNC", "PROTON_NO_ESYNC", "PROTON_NO_FSYNC")
|
||||
@@ -470,21 +469,6 @@ def split_game_gpu(entries):
|
||||
return result
|
||||
|
||||
|
||||
def vram_cap(env):
|
||||
value = env.get("DD_VRAM_MB", "")
|
||||
if not re.fullmatch(r"[1-9][0-9]{0,6}", value):
|
||||
return env
|
||||
result = env.copy()
|
||||
cap = "dxgi.maxDeviceMemory = {0}; dxgi.maxSharedMemory = {0}".format(int(value))
|
||||
if int(value) < D3D9_DEFAULT_MEMORY_MB:
|
||||
cap += "; d3d9.maxAvailableMemory = {0}".format(int(value))
|
||||
own = result.get("DXVK_CONFIG", "").strip().strip(";").strip()
|
||||
result["DXVK_CONFIG"] = cap + "; " + own if own else cap
|
||||
result["DROIDDECK_VRAM_CAP"] = "1"
|
||||
result["DROIDDECK_VRAM_CAP_MB"] = value
|
||||
return result
|
||||
|
||||
|
||||
def parse_cores(text):
|
||||
cores = set()
|
||||
for part in text.replace(" ", "").split(","):
|
||||
@@ -1456,7 +1440,6 @@ def main():
|
||||
if mic_enabled == "0":
|
||||
env["AUDIO_DIRECT_MIC"] = "0"
|
||||
env = directaudio_settings(env)
|
||||
env = vram_cap(env)
|
||||
note = render_path_defaults(command, env) if app_id else None
|
||||
if note:
|
||||
print("droiddeck-game-env: " + note, file=sys.stderr)
|
||||
|
||||
@@ -132,6 +132,7 @@ clear_stale_tmp() {
|
||||
[ -z "${DD_INSIDE:-}" ] && clear_stale_tmp
|
||||
if [ -z "${DD_INSIDE:-}" ]; then
|
||||
if [ "${DD_ZRAM:-0}" = 1 ]; then printf 0 > /tmp/.dd-zram; else rm -f /tmp/.dd-zram; fi
|
||||
rm -f /tmp/.dd-zram.hold
|
||||
dd if=/dev/zero of=/tmp/.dd-clock bs=8 count=1 conv=notrunc status=none
|
||||
fi
|
||||
|
||||
@@ -756,13 +757,6 @@ case $mode in
|
||||
fi
|
||||
if [ "${DD_ZRAM:-0}" = 1 ]; then
|
||||
step "zRAM compression: on"
|
||||
[ "${DD_ZRAM_CLIENT:-1}" = 1 ] || step "zRAM: Steam, the hidden Epic Games Launcher and Battle.net are not compressed while games run (turned off in Performance)"
|
||||
_dd_ram_cap=0
|
||||
case ${DD_RAM_CAP_MB:-} in
|
||||
''|0) ;;
|
||||
*[!0-9]*|0*|???????*) step "RAM cap: ignored invalid value '$DD_RAM_CAP_MB'" ;;
|
||||
*) _dd_ram_cap=$((DD_RAM_CAP_MB * 1024)); step "RAM cap: ${DD_RAM_CAP_MB} MB" ;;
|
||||
esac
|
||||
(
|
||||
dd_zram_scan() {
|
||||
_dd_game=0 _dd_pids=() _dd_others=() _dd_apps=
|
||||
@@ -839,284 +833,235 @@ case $mode in
|
||||
echo "$# processes, resident $((_rss / 1024)) MB, in zram $((_swap / 1024)) MB"
|
||||
}
|
||||
dd_memory_read() {
|
||||
local _k _v _u _kind _fields _avg _whole _frac _gpu_bytes _growth _saved_growth _saved_fall
|
||||
_saved_growth=${_dd_preserved_growth:-0} _saved_fall=${_dd_preserved_fall:-0}
|
||||
_dd_preserved_growth=0 _dd_preserved_fall=0
|
||||
_dd_mem_total=0 _dd_available=-1 _dd_swap_total=0 _dd_swap_free=-1
|
||||
_dd_psi_some=0 _dd_psi_full=0 _dd_gpu=0 _dd_unevictable=0 _dd_shmem=0
|
||||
local _k _v _u _kind _fields _name _type _size _used _orig _comp _mem _dt _fall
|
||||
local _stall=-1 _swap_total=0 _swap_free=0 _total=0 _room=0 _listed=0 _in=-1
|
||||
_dd_mem_total=0 _dd_available=-1
|
||||
while read -r _k _v _u; do
|
||||
case $_v in ''|*[!0-9]*) continue ;; esac
|
||||
case $_k in
|
||||
MemTotal:) _dd_mem_total=$_v ;;
|
||||
MemAvailable:) _dd_available=$_v ;;
|
||||
SwapTotal:) _dd_swap_total=$_v ;;
|
||||
SwapFree:) _dd_swap_free=$_v ;;
|
||||
Unevictable:) _dd_unevictable=$_v ;;
|
||||
Shmem:) _dd_shmem=$_v ;;
|
||||
SwapTotal:) _swap_total=$_v ;;
|
||||
SwapFree:) _swap_free=$_v ;;
|
||||
esac
|
||||
done 2>/dev/null < /proc/meminfo
|
||||
while read -r _name _type _size _used _u; do
|
||||
_listed=1
|
||||
case $_name in */zram[0-9]*) ;; *) continue ;; esac
|
||||
case $_size$_used in ''|*[!0-9]*) continue ;; esac
|
||||
_total=$((_total + _size)) _room=$((_room + _size - _used))
|
||||
done 2>/dev/null < /proc/swaps
|
||||
[ "$_listed" = 1 ] || _total=$_swap_total _room=$_swap_free
|
||||
_dd_swap_room=$((_total / 8))
|
||||
[ "$_dd_swap_room" -ge $((128 * 1024)) ] || _dd_swap_room=$((128 * 1024))
|
||||
_dd_swap_room=$((_room - _dd_swap_room))
|
||||
_dd_saving=600
|
||||
if [ -r /sys/block/zram0/mm_stat ] && read -r _orig _comp _mem _u 2>/dev/null < /sys/block/zram0/mm_stat; then
|
||||
case $_orig$_mem in
|
||||
''|*[!0-9]*) ;;
|
||||
*) [ "$_orig" -lt $((64 << 20)) ] || _dd_saving=$(((_orig - _mem) / (_orig / 1000))) ;;
|
||||
esac
|
||||
[ "$_dd_saving" -ge 167 ] || _dd_saving=167
|
||||
[ "$_dd_saving" -le 833 ] || _dd_saving=833
|
||||
fi
|
||||
if [ -r /proc/pressure/memory ]; then
|
||||
while read -r _kind _fields; do
|
||||
[ "$_kind" = some ] || [ "$_kind" = full ] || continue
|
||||
_avg=${_fields#avg10=} _avg=${_avg%% *}
|
||||
_whole=${_avg%%.*} _frac=${_avg#*.}
|
||||
[ "$_frac" = "$_avg" ] && _frac=00
|
||||
_frac=${_frac}00
|
||||
_frac=${_frac:0:2}
|
||||
case $_whole$_frac in ''|*[!0-9]*) continue ;; esac
|
||||
if [ "$_kind" = some ]; then
|
||||
_dd_psi_some=$((10#$_whole * 100 + 10#$_frac))
|
||||
else
|
||||
_dd_psi_full=$((10#$_whole * 100 + 10#$_frac))
|
||||
fi
|
||||
[ "$_kind" = some ] || continue
|
||||
_fields=${_fields##*total=}
|
||||
case $_fields in ''|*[!0-9]*) ;; *) _stall=$_fields ;; esac
|
||||
done 2>/dev/null < /proc/pressure/memory
|
||||
fi
|
||||
if [ -r /sys/class/kgsl/kgsl/page_alloc ]; then
|
||||
read -r _gpu_bytes _u < /sys/class/kgsl/kgsl/page_alloc
|
||||
case $_gpu_bytes in ''|*[!0-9]*) _gpu_bytes=0 ;; esac
|
||||
_dd_gpu=$((_gpu_bytes / 1024))
|
||||
while read -r _k _v; do
|
||||
[ "$_k" = pswpin ] || continue
|
||||
case $_v in ''|*[!0-9]*) ;; *) _in=$((_v * _dd_page_kb)) ;; esac
|
||||
break
|
||||
done 2>/dev/null < /proc/vmstat
|
||||
_dt=$((SECONDS - ${_dd_sample_at:-$SECONDS}))
|
||||
if [ -z "${_dd_sample_at:-}" ]; then
|
||||
_dd_rate=0 _dd_psi=0 _dd_returned=0
|
||||
elif [ "$_dt" -gt 0 ] && [ "$_dd_available" -ge 0 ]; then
|
||||
_fall=$(((_dd_sample_available - _dd_available + _dd_freed) / _dt))
|
||||
_dd_rate=$((_dd_rate * 3 / 4))
|
||||
[ "$_fall" -le "$_dd_rate" ] || _dd_rate=$_fall
|
||||
_dd_psi=0
|
||||
[ "$_stall" -lt 0 ] || [ "$_dd_sample_stall" -lt 0 ] || _dd_psi=$(((_stall - _dd_sample_stall) / (_dt * 100)))
|
||||
_dd_returned=$((_dt < 30 ? _dd_returned * (30 - _dt) / 30 : 0))
|
||||
[ "$_in" -lt "$_dd_sample_in" ] || [ "$_dd_sample_in" -lt 0 ] || _dd_returned=$((_dd_returned + _in - _dd_sample_in))
|
||||
fi
|
||||
_dd_psi=$_dd_psi_some
|
||||
[ "$_dd_psi_full" -gt "$_dd_psi" ] && _dd_psi=$_dd_psi_full
|
||||
if [ "${_dd_sample_at:-}" = "" ]; then
|
||||
_dd_growth=0 _dd_fall=0
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_gpu=$_dd_gpu
|
||||
_dd_sample_unevictable=$_dd_unevictable _dd_sample_shmem=$_dd_shmem
|
||||
elif [ "$SECONDS" -gt "$_dd_sample_at" ]; then
|
||||
_dd_growth=0 _dd_fall=0
|
||||
_growth=$((_dd_gpu - _dd_sample_gpu)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_growth=$((_dd_unevictable - _dd_sample_unevictable)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_growth=$((_dd_shmem - _dd_sample_shmem)); [ "$_growth" -gt 0 ] && _dd_growth=$((_dd_growth + _growth))
|
||||
_dd_fall=$((_dd_sample_available - _dd_available))
|
||||
[ "$_saved_growth" -gt "$_dd_growth" ] && _dd_growth=$_saved_growth
|
||||
[ "$_saved_fall" -gt "$_dd_fall" ] && _dd_fall=$_saved_fall
|
||||
if [ $((SECONDS - _dd_sample_at)) -ge 5 ]; then
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_gpu=$_dd_gpu
|
||||
_dd_sample_unevictable=$_dd_unevictable _dd_sample_shmem=$_dd_shmem
|
||||
fi
|
||||
if [ "$_dd_available" -ge 0 ] && { [ -z "${_dd_sample_at:-}" ] || [ "$_dt" -gt 0 ]; }; then
|
||||
_dd_sample_at=$SECONDS _dd_sample_available=$_dd_available _dd_sample_stall=$_stall _dd_sample_in=$_in _dd_freed=0
|
||||
fi
|
||||
_dd_real_available=$_dd_available
|
||||
[ "$_dd_real_available" -ge 0 ] && _dd_real_available=$((_dd_real_available - _dd_growth))
|
||||
_dd_headroom=$((_dd_mem_total / 5))
|
||||
[ "$_dd_headroom" -ge $((512 * 1024)) ] || _dd_headroom=$((512 * 1024))
|
||||
[ "$_dd_headroom" -le $((1536 * 1024)) ] || _dd_headroom=$((1536 * 1024))
|
||||
_dd_tier_headroom=$((_dd_mem_total / 4))
|
||||
[ "$_dd_tier_headroom" -ge $((768 * 1024)) ] || _dd_tier_headroom=$((768 * 1024))
|
||||
[ "$_dd_tier_headroom" -le $((2560 * 1024)) ] || _dd_tier_headroom=$((2560 * 1024))
|
||||
_dd_fall_headroom=$((_dd_tier_headroom * 2))
|
||||
[ "$_dd_fall_headroom" -ge $((_dd_mem_total * 2 / 5)) ] || _dd_fall_headroom=$((_dd_mem_total * 2 / 5))
|
||||
_dd_swap_reserve=$((_dd_swap_total / 5))
|
||||
[ "$_dd_swap_reserve" -ge $((256 * 1024)) ] || _dd_swap_reserve=$((256 * 1024))
|
||||
_dd_floor=$((_dd_mem_total / 8))
|
||||
[ "$_dd_floor" -ge $((640 * 1024)) ] || _dd_floor=$((640 * 1024))
|
||||
[ "$_dd_floor" -le $((1280 * 1024)) ] || _dd_floor=$((1280 * 1024))
|
||||
_dd_target=$((_dd_floor + _dd_rate * 10))
|
||||
}
|
||||
dd_memory_tight() {
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_real_available" -lt "$_dd_headroom" ] ||
|
||||
{ [ "$_dd_psi" -ge 100 ] && [ "$_dd_real_available" -lt $((_dd_mem_total / 3)) ]; } ||
|
||||
{ [ "$_dd_fall" -ge $((256 * 1024)) ] && [ "$_dd_real_available" -lt $((_dd_headroom * 2)) ]; }; }
|
||||
}
|
||||
dd_client_can_pageout() {
|
||||
dd_memory_read
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
[ "$_dd_mem_total" -gt 0 ] && dd_zram_has_room
|
||||
}
|
||||
dd_zram_has_room() {
|
||||
[ "$_dd_swap_total" -gt 0 ] &&
|
||||
[ $((_dd_swap_free - _dd_anon - ${_dd_client_reserve:-0})) -ge "$_dd_swap_reserve" ]
|
||||
}
|
||||
dd_client_can_readback() {
|
||||
dd_memory_read
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
[ "$_dd_mem_total" -gt 0 ] && ! dd_memory_tight && ! dd_memory_critical &&
|
||||
[ "$_dd_real_available" -ge $((_dd_swap * 2)) ] &&
|
||||
[ $((_dd_real_available - _dd_swap)) -ge "$_dd_headroom" ]
|
||||
}
|
||||
dd_client_pressure() {
|
||||
[ "${DD_ZRAM_CLIENT:-1}" = 1 ] && [ "$_dd_game" = 1 ] &&
|
||||
[ "${#_dd_pids[@]}" -gt 0 ] && { dd_memory_tight || dd_memory_critical; } || return 0
|
||||
[ "$_dd_pressure_at" -lt 0 ] ||
|
||||
[ $((SECONDS - _dd_pressure_at)) -ge "$_dd_pressure_backoff" ] || return 0
|
||||
[ "$_dd_packed" -lt 0 ] || [ $((SECONDS - _dd_packed)) -ge 30 ] || return 0
|
||||
_dd_pressure_at=$SECONDS
|
||||
if ! dd_client_can_pageout; then
|
||||
step "zRAM: pressure reclaim skipped, swap headroom too small ($((_dd_swap_free / 1024)) MB free)"
|
||||
return 0
|
||||
dd_memory_need() {
|
||||
local _burst=$((_dd_rate * 2))
|
||||
_dd_need=0 _dd_hard=0 _dd_force=0
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] || return 0
|
||||
_dd_need=$((_dd_target - _dd_available)) _dd_hard=$((_dd_floor - _dd_available))
|
||||
if [ "$_burst" -ge $((64 * 1024)) ] && [ "$_dd_available" -lt $((_dd_mem_total * 2 / 5)) ] && [ "$_burst" -gt "$_dd_need" ]; then
|
||||
_dd_need=$_burst
|
||||
fi
|
||||
[ "$_dd_rss" -ge $((128 * 1024)) ] || return 0
|
||||
_dd_pressure_before=$_dd_rss
|
||||
if [ "${1:-}" = defer ]; then
|
||||
_dd_client_reserve=$_dd_anon
|
||||
_dd_client_pending=1
|
||||
fi
|
||||
dd_zram_send 1 "memory pressure, compressing the client (available $((_dd_available / 1024)) MB, swap free $((_dd_swap_free / 1024)) MB)" client "${1:-}"
|
||||
_dd_packed=$SECONDS
|
||||
if [ "${1:-}" = defer ]; then
|
||||
_dd_client_targets=("${_dd_zram_targets[@]}")
|
||||
else
|
||||
dd_client_pressure_result
|
||||
if [ "$_dd_psi" -ge 100 ] && [ "$_burst" -gt "$_dd_hard" ]; then
|
||||
_dd_hard=$_burst
|
||||
fi
|
||||
[ "$_dd_hard" -gt 0 ] || _dd_hard=0
|
||||
[ "$_dd_need" -ge "$_dd_hard" ] || _dd_need=$_dd_hard
|
||||
[ "$_dd_available" -ge $((_dd_floor / 2)) ] || _dd_force=1
|
||||
}
|
||||
dd_client_pressure_finish() {
|
||||
[ "${_dd_client_pending:-0}" = 1 ] || return 0
|
||||
dd_zram_finish 1 "${_dd_client_targets[@]}"
|
||||
dd_client_pressure_result "${_dd_client_targets[@]}"
|
||||
_dd_client_pending=0 _dd_client_reserve=0 _dd_client_targets=()
|
||||
}
|
||||
dd_client_pressure_result() {
|
||||
[ "${_dd_pageout_complete:-0}" = 1 ] || return 0
|
||||
if [ "$#" -gt 0 ]; then dd_zram_usage "$@" > /dev/null; else dd_zram_usage "${_dd_pids[@]}" > /dev/null; fi
|
||||
if [ $((_dd_pressure_before - _dd_rss)) -lt $((16 * 1024)) ]; then
|
||||
_dd_pressure_backoff=$((_dd_pressure_backoff * 2 > 300 ? 300 : _dd_pressure_backoff * 2))
|
||||
else
|
||||
_dd_pressure_backoff=30
|
||||
fi
|
||||
}
|
||||
dd_memory_critical() {
|
||||
[ "$_dd_mem_total" -gt 0 ] && [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_real_available" -lt "$_dd_tier_headroom" ] ||
|
||||
{ [ "$_dd_psi" -ge 100 ] && [ "$_dd_real_available" -lt $((_dd_tier_headroom * 3 / 2)) ]; } ||
|
||||
{ [ "$_dd_fall" -ge $((256 * 1024)) ] && [ "$_dd_real_available" -lt "$_dd_fall_headroom" ]; }; }
|
||||
}
|
||||
dd_session_pressure() {
|
||||
dd_memory_read
|
||||
dd_memory_critical || _dd_tier_backoff=30 _dd_tier_nogain=0
|
||||
[ "$_dd_game" = 1 ] && dd_memory_critical || return 0
|
||||
[ "${DD_ZRAM_IDLE:-1}" = 1 ] && dd_game_focused 0 || return 0
|
||||
local _wait=$_dd_tier_backoff _before _available_before _pids _targets _gain _min_gain
|
||||
[ "$_dd_available" -ge $((_dd_headroom / 2)) ] || [ "$_dd_tier_pushed" -lt 0 ] || _wait=30
|
||||
[ "$_dd_tier_at" -lt 0 ] || [ $((SECONDS - _dd_tier_at)) -ge "$_wait" ] || return 0
|
||||
if [ "$_dd_tier_at" -ge 0 ] && [ "$_dd_tier_pushed" -gt 0 ]; then
|
||||
dd_tier_readback
|
||||
if [ "$_dd_tier_back" -le $((_dd_tier_pushed / 2)) ]; then
|
||||
[ "${_dd_tier_nogain:-0}" = 1 ] || _dd_tier_backoff=30
|
||||
else
|
||||
_dd_tier_backoff=$((_dd_tier_backoff * 2 > 300 ? 300 : _dd_tier_backoff * 2))
|
||||
_dd_tier_at=$SECONDS _dd_tier_pushed=-1
|
||||
step "zRAM: the game read back most of its last page-out, next try in ${_dd_tier_backoff} s"
|
||||
return 0
|
||||
fi
|
||||
fi
|
||||
_dd_tier_at=$SECONDS _dd_tier_pushed=0
|
||||
dd_zram_pick session
|
||||
dd_zram_usage "${_pids[@]}" > /dev/null
|
||||
[ "$_dd_rss" -ge $((256 * 1024)) ] || return 0
|
||||
if ! dd_zram_has_room; then
|
||||
step "zRAM: low-memory page-out skipped, swap headroom too small ($((_dd_swap_free / 1024)) MB free)"
|
||||
return 0
|
||||
fi
|
||||
_targets=("${_pids[@]}") _before=$_dd_swap _available_before=$_dd_available
|
||||
dd_zram_send 1 "low memory (available $((_dd_real_available / 1024)) MB), compressing idle game memory" session
|
||||
dd_zram_usage "${_targets[@]}" > /dev/null
|
||||
_dd_tier_pushed=$((_dd_swap - _before))
|
||||
dd_tier_note "${_targets[@]}"
|
||||
if [ "${_dd_pageout_complete:-0}" = 1 ]; then
|
||||
dd_memory_read
|
||||
_gain=$((_dd_available - _available_before))
|
||||
_min_gain=$((_dd_tier_headroom / 16))
|
||||
[ "$_min_gain" -ge $((16 * 1024)) ] || _min_gain=$((16 * 1024))
|
||||
if [ "$_gain" -lt "$_min_gain" ]; then
|
||||
_dd_tier_backoff=$((_dd_tier_backoff * 2 > 300 ? 300 : _dd_tier_backoff * 2))
|
||||
_dd_tier_at=$SECONDS _dd_tier_nogain=1
|
||||
step "zRAM: low-memory page-out gained only $((_gain / 1024)) MB available, next try in ${_dd_tier_backoff} s"
|
||||
else
|
||||
_dd_tier_nogain=0
|
||||
fi
|
||||
fi
|
||||
}
|
||||
dd_proc_start() {
|
||||
local _s=
|
||||
_dd_start=
|
||||
read -r _s 2>/dev/null < "/proc/$1/stat" || return 1
|
||||
_s=${_s##*) }
|
||||
set -- $_s
|
||||
[ "$1" != Z ] && [ "$#" -ge 20 ] || return 1
|
||||
_dd_start=${20}
|
||||
}
|
||||
dd_tier_note() {
|
||||
local _p
|
||||
_dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
for _p in "$@"; do
|
||||
dd_proc_start "$_p" || continue
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
_dd_tier_targets+=("$_p") _dd_tier_swaps+=("$_dd_swap") _dd_tier_starts+=("$_dd_start")
|
||||
done
|
||||
}
|
||||
dd_tier_readback() {
|
||||
local _i _back=0
|
||||
for _i in "${!_dd_tier_targets[@]}"; do
|
||||
dd_proc_start "${_dd_tier_targets[$_i]}" && [ "$_dd_start" = "${_dd_tier_starts[$_i]}" ] || continue
|
||||
dd_zram_usage "${_dd_tier_targets[$_i]}" > /dev/null
|
||||
[ "${_dd_tier_swaps[$_i]}" -le "$_dd_swap" ] || _back=$((_back + _dd_tier_swaps[_i] - _dd_swap))
|
||||
done
|
||||
_dd_tier_back=$_back
|
||||
}
|
||||
dd_watch_nap() {
|
||||
local _i
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_available" -ge 0 ] && [ "$_dd_real_available" -lt "$_dd_fall_headroom" ]; then
|
||||
for _i in 1 2 3 4 5; do
|
||||
nap 1
|
||||
dd_memory_read
|
||||
dd_memory_critical && return 0
|
||||
done
|
||||
else
|
||||
nap 5
|
||||
fi
|
||||
return 0
|
||||
dd_pid_key() {
|
||||
local _s
|
||||
_dd_key=$1
|
||||
read -r _s 2>/dev/null < "/proc/$1/stat" || return 0
|
||||
set -- ${_s##*) }
|
||||
_dd_key=$_dd_key.${20:-}
|
||||
}
|
||||
dd_session_others() {
|
||||
local _p
|
||||
local -A _known=()
|
||||
_dd_session=()
|
||||
for _p in "${_dd_others[@]}"; do
|
||||
grep -q -m1 '/libddsession\.so$' "/proc/$_p/maps" 2>/dev/null && _dd_session+=("$_p")
|
||||
dd_pid_key "$_p"
|
||||
[ -n "${_dd_preloaded[$_dd_key]:-}" ] ||
|
||||
grep -q -m1 '/libddsession\.so$' "/proc/$_p/maps" 2>/dev/null || continue
|
||||
_known[$_dd_key]=1
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
_dd_session+=("$_dd_anon $_p")
|
||||
done
|
||||
_dd_preloaded=()
|
||||
for _p in "${!_known[@]}"; do
|
||||
_dd_preloaded[$_p]=1
|
||||
done
|
||||
[ "${#_dd_session[@]}" -gt 0 ] || return 0
|
||||
mapfile -t _dd_session < <(printf '%s\n' "${_dd_session[@]}" | sort -rn)
|
||||
_dd_session=("${_dd_session[@]#* }")
|
||||
}
|
||||
dd_zram_pick() {
|
||||
if [ "$1" = game ]; then
|
||||
dd_session_others
|
||||
_pids=("${_dd_session[@]}")
|
||||
[ "${DD_ZRAM_CLIENT:-1}" != 1 ] || _pids+=("${_dd_pids[@]}")
|
||||
elif [ "$1" = session ]; then
|
||||
dd_session_others
|
||||
_pids=("${_dd_session[@]}")
|
||||
dd_memory_relieved() {
|
||||
local _k _v _u
|
||||
while read -r _k _v _u; do
|
||||
[ "$_k" = MemAvailable: ] || continue
|
||||
case $_v in ''|*[!0-9]*) return 1 ;; esac
|
||||
[ "$_v" -ge "$_dd_goal" ]
|
||||
return
|
||||
done 2>/dev/null < /proc/meminfo
|
||||
return 1
|
||||
}
|
||||
dd_zram_trim() {
|
||||
local _mode=$1 _left=$2 _p _k _n _i _acks=()
|
||||
shift 2
|
||||
_dd_trimmed=0
|
||||
for _k in "${!_dd_deaf[@]}"; do
|
||||
[ "${_dd_deaf[$_k]}" -gt "$SECONDS" ] || unset "_dd_deaf[$_k]"
|
||||
done
|
||||
for _p in "$@"; do
|
||||
[ "$_left" -ge 4096 ] && [ "$_dd_polls" -lt 250 ] && [ $((SECONDS - _dd_pass_at)) -lt 6 ] &&
|
||||
[ ! -e /tmp/.dd-zram.hold ] || break
|
||||
! dd_memory_relieved || break
|
||||
dd_pid_key "$_p"
|
||||
_k=$_dd_key
|
||||
[ "${_dd_deaf[$_k]:-0}" -le "$SECONDS" ] || continue
|
||||
dd_zram_usage "$_p" > /dev/null
|
||||
[ "$_dd_anon" -ge 8192 ] || continue
|
||||
printf %s - > "/tmp/.dd-zram.trim.$_p"
|
||||
_acks+=("/tmp/.dd-zram.trim.$_p")
|
||||
printf '%s %s\n' "$_mode" "$_left" > /tmp/.dd-zram
|
||||
kill -URG "$_p" 2>/dev/null || continue
|
||||
_dd_deaf[$_k]=$((SECONDS + 60))
|
||||
for ((_i = 0; _dd_polls < 250 && SECONDS - _dd_pass_at < 6; _i++, _dd_polls++)); do
|
||||
[ ! -e /tmp/.dd-zram.hold ] || { _dd_deaf[$_k]=0; break; }
|
||||
_n=
|
||||
read -r _n 2>/dev/null < "/tmp/.dd-zram.trim.$_p" || :
|
||||
case $_n in
|
||||
-) [ "$_i" -lt 25 ] || break ;;
|
||||
''|*[!0-9]*) ;;
|
||||
*) _dd_trimmed=$((_dd_trimmed + _n)) _left=$((_left - _n)) _dd_deaf[$_k]=0; break ;;
|
||||
esac
|
||||
nap 0.02
|
||||
done
|
||||
done
|
||||
[ ! -e /tmp/.dd-zram.hold ] || return 0
|
||||
printf '2 0\n' > /tmp/.dd-zram
|
||||
[ "${#_acks[@]}" = 0 ] || rm -f "${_acks[@]}"
|
||||
}
|
||||
dd_memory_relieve() {
|
||||
local _mode=2 _budget _gain=0 _rest _cap=$((256 * 1024)) _all=$((1024 * 1024))
|
||||
dd_memory_need
|
||||
_dd_polls=0 _dd_pass_at=$SECONDS
|
||||
if [ "$_dd_need" -le 0 ]; then
|
||||
_dd_rest=0
|
||||
return 0
|
||||
fi
|
||||
[ "$_dd_rest" = 0 ] || [ "$_dd_force" = 1 ] || [ "$SECONDS" -ge "$_dd_rest_until" ] ||
|
||||
[ "$_dd_available" -lt $((_dd_rest_available - _dd_floor / 8)) ] || return 0
|
||||
if [ "$_dd_swap_room" -lt $((64 * 1024)) ]; then
|
||||
if [ $((SECONDS - _dd_full_at)) -ge 60 ]; then
|
||||
_dd_full_at=$SECONDS
|
||||
step "memory: available $((_dd_available / 1024)) MB and zRAM has no room left"
|
||||
fi
|
||||
return 0
|
||||
fi
|
||||
if [ "$_dd_force" = 1 ] && [ $((SECONDS - _dd_forced_at)) -ge 10 ]; then
|
||||
_mode=3 _dd_forced_at=$SECONDS _cap=$_all
|
||||
else
|
||||
_pids=("${_dd_pids[@]}")
|
||||
_cap=$((_cap - _dd_returned)) _all=$((_all - _dd_returned))
|
||||
fi
|
||||
if [ "${#_dd_pids[@]}" -gt 0 ] && [ "$_all" -ge 4096 ] &&
|
||||
{ [ "$_dd_hard" -gt 0 ] ||
|
||||
{ [ "$_dd_game" = 1 ] && [ "$_dd_focus" != 1 ] && [ $((SECONDS - _dd_back_at)) -ge 30 ]; }; }; then
|
||||
_budget=$((_dd_need * 1000 / _dd_saving))
|
||||
[ "$_budget" -le "$_all" ] || _budget=$_all
|
||||
[ "$_budget" -le "$_dd_swap_room" ] || _budget=$_dd_swap_room
|
||||
_dd_goal=$((_dd_available + _dd_need))
|
||||
dd_zram_trim "$_mode" "$_budget" "${_dd_pids[@]}"
|
||||
_gain=$((_dd_trimmed * _dd_saving / 1000))
|
||||
_dd_swap_room=$((_dd_swap_room - _dd_trimmed)) _all=$((_all - _dd_trimmed))
|
||||
[ "$_cap" -le "$_all" ] || _cap=$_all
|
||||
_dd_client_out=$((_dd_client_out + _dd_trimmed)) _dd_note_client=$((_dd_note_client + _dd_trimmed))
|
||||
[ "$_dd_trimmed" = 0 ] || _dd_trim_at=$SECONDS
|
||||
fi
|
||||
_rest=$((_dd_hard - _gain))
|
||||
if [ "$_rest" -gt 0 ] && [ "$_cap" -ge 4096 ] && [ "$_dd_swap_room" -ge $((64 * 1024)) ]; then
|
||||
[ "$_dd_session_at" = "$_dd_scan_at" ] || dd_session_others
|
||||
_dd_session_at=$_dd_scan_at
|
||||
_budget=$((_rest * 1000 / _dd_saving))
|
||||
[ "$_budget" -le "$_cap" ] || _budget=$_cap
|
||||
[ "$_budget" -le "$_dd_swap_room" ] || _budget=$_dd_swap_room
|
||||
_dd_goal=$((_dd_available + _dd_hard))
|
||||
dd_zram_trim "$_mode" "$_budget" "${_dd_session[@]}"
|
||||
_gain=$((_gain + _dd_trimmed * _dd_saving / 1000))
|
||||
_dd_note_session=$((_dd_note_session + _dd_trimmed))
|
||||
fi
|
||||
_dd_freed=$((_dd_freed + _gain))
|
||||
if [ "$_dd_hard" -gt 0 ] && [ "$_gain" -lt $((_dd_hard / 4)) ]; then
|
||||
_dd_rest=$((_dd_rest > 0 ? _dd_rest * 2 : 5))
|
||||
[ "$_dd_rest" -le 60 ] || _dd_rest=60
|
||||
_dd_rest_until=$((SECONDS + _dd_rest)) _dd_rest_available=$_dd_available
|
||||
else
|
||||
_dd_rest=0
|
||||
fi
|
||||
}
|
||||
dd_zram_wait() {
|
||||
local _p _left _start=$SECONDS
|
||||
while [ $((SECONDS - _start)) -lt 12 ]; do
|
||||
_left=0
|
||||
for _p in "$@"; do
|
||||
[ -s "/tmp/.dd-zram.ack.$_p" ] && continue
|
||||
[ -d "/proc/$_p" ] || continue
|
||||
[ $((SECONDS - _start)) -ge 2 ] && [ ! -e "/tmp/.dd-zram.ack.$_p" ] && continue
|
||||
_left=1
|
||||
done
|
||||
[ "$_left" = 1 ] || break
|
||||
nap 0.2
|
||||
done
|
||||
_dd_pageout_complete=1
|
||||
for _p in "$@"; do
|
||||
if [ -d "/proc/$_p" ] && [ ! -s "/tmp/.dd-zram.ack.$_p" ]; then _dd_pageout_complete=0; fi
|
||||
rm -f "/tmp/.dd-zram.ack.$_p"
|
||||
done
|
||||
dd_memory_note() {
|
||||
[ $((_dd_note_client + _dd_note_session)) -ge $((16 * 1024)) ] && [ $((SECONDS - _dd_noted_at)) -ge 5 ] || return 0
|
||||
step "memory: available $((_dd_available / 1024)) MB, falling $((_dd_rate / 1024)) MB/s, compressed $((_dd_note_client / 1024)) MB of the client and $((_dd_note_session / 1024)) MB of the session"
|
||||
_dd_note_client=0 _dd_note_session=0 _dd_noted_at=$SECONDS
|
||||
}
|
||||
dd_zram_send() {
|
||||
local _mode=$1 _what=$2 _which=$3 _pids _p
|
||||
dd_zram_pick "$_which"
|
||||
step "zRAM: $_what ($(dd_zram_usage "${_pids[@]}"))"
|
||||
for _p in "${_pids[@]}"; do rm -f "/tmp/.dd-zram.ack.$_p"; done
|
||||
printf '%s' "$_mode" > /tmp/.dd-zram
|
||||
[ "${#_pids[@]}" = 0 ] || kill -URG "${_pids[@]}" 2>/dev/null
|
||||
_dd_zram_targets=("${_pids[@]}")
|
||||
[ "${4:-}" != defer ] || return 0
|
||||
dd_zram_finish "$_mode" "${_pids[@]}"
|
||||
}
|
||||
dd_zram_finish() {
|
||||
local _mode=$1
|
||||
shift
|
||||
if [ "$_mode" = 1 ]; then dd_zram_wait "$@"; else nap 5; fi
|
||||
dd_zram_scan
|
||||
step "zRAM: done ($(dd_zram_usage "$@"))"
|
||||
dd_client_readback() {
|
||||
[ "$_dd_client_out" -gt 0 ] && [ "${#_dd_pids[@]}" -gt 0 ] || return 0
|
||||
[ "$_dd_game" = 0 ] || { [ -n "$_dd_away" ] && [ $((SECONDS - _dd_away)) -ge 5 ]; } || return 0
|
||||
[ $((SECONDS - _dd_trim_at)) -ge 30 ] || return 0
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
if [ "$_dd_swap" -lt $((16 * 1024)) ]; then
|
||||
_dd_client_out=0
|
||||
return 0
|
||||
fi
|
||||
[ $((_dd_available - _dd_swap)) -ge $((_dd_target + _dd_floor)) ] || return 0
|
||||
step "memory: available $((_dd_available / 1024)) MB, reading $((_dd_swap / 1024)) MB of the client back"
|
||||
printf 0 > /tmp/.dd-zram || return 0
|
||||
kill -URG "${_dd_pids[@]}" 2>/dev/null || return 0
|
||||
_dd_freed=$((_dd_freed - _dd_swap * _dd_saving / 1000))
|
||||
_dd_client_out=0 _dd_back_at=$SECONDS
|
||||
}
|
||||
dd_game_focused() {
|
||||
if [ "${DD_DESKTOP:-}" = 1 ] || [ -z "${DD_LAUNCH_DIR:-}" ]; then
|
||||
@@ -1131,92 +1076,40 @@ case $mode in
|
||||
esac
|
||||
return 1
|
||||
}
|
||||
dd_over_cap() {
|
||||
[ "$_dd_ram_cap" -gt 0 ] || return 1
|
||||
_dd_measured=$SECONDS
|
||||
dd_session_others
|
||||
dd_zram_usage "${_dd_pids[@]}" "${_dd_session[@]}" > /dev/null
|
||||
[ "$_dd_rss" -gt "$_dd_ram_cap" ]
|
||||
}
|
||||
dd_cap_due() {
|
||||
[ "$_dd_ram_cap" -gt 0 ] && { [ "$_dd_measured" -lt 0 ] || [ $((SECONDS - _dd_measured)) -ge 30 ]; }
|
||||
}
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_measured=-1 _dd_unpack=0 _dd_capped=-1 _dd_backoff=30
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_nogain=0 _dd_tier_pushed=0 _dd_tier_back=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
_dd_client_pending=0 _dd_client_reserve=0 _dd_client_targets=() _dd_away=
|
||||
_dd_sample_at= _dd_sample_available=0 _dd_sample_gpu=0 _dd_sample_unevictable=0 _dd_sample_shmem=0
|
||||
while kill -0 $$ 2>/dev/null; do
|
||||
dd_zram_scan
|
||||
dd_memory_read
|
||||
if dd_cap_due; then
|
||||
if dd_over_cap; then
|
||||
if [ "$_dd_capped" -lt 0 ] || [ $((SECONDS - _dd_capped)) -ge "$_dd_backoff" ]; then
|
||||
dd_zram_usage "${_dd_pids[@]}" > /dev/null
|
||||
if [ "$_dd_rss" -ge $((512 * 1024)) ]; then
|
||||
dd_zram_send 1 "over the ${DD_RAM_CAP_MB} MB RAM cap, compressing the client" client
|
||||
[ "$_dd_game" = 1 ] && _dd_packed=$SECONDS
|
||||
else
|
||||
step "RAM cap: over, client already small ($((_dd_rss / 1024)) MB resident), skipping it"
|
||||
fi
|
||||
dd_over_cap && dd_zram_send 1 "still over the RAM cap, compressing the rest of the session" session
|
||||
if dd_over_cap; then
|
||||
_dd_backoff=$((_dd_backoff * 2 > 600 ? 600 : _dd_backoff * 2))
|
||||
step "RAM cap: still over after paging out, next try in ${_dd_backoff} s"
|
||||
else
|
||||
_dd_backoff=30
|
||||
fi
|
||||
_dd_capped=$SECONDS
|
||||
fi
|
||||
else
|
||||
_dd_backoff=30
|
||||
dd_memory_tick() {
|
||||
if [ $((SECONDS - _dd_scan_at)) -ge 5 ]; then
|
||||
_dd_scan_at=$SECONDS
|
||||
dd_zram_scan
|
||||
_dd_focus=1
|
||||
if [ "$_dd_game" = 1 ]; then
|
||||
dd_game_focused && _dd_focus=0 || _dd_focus=$?
|
||||
fi
|
||||
fi
|
||||
_dd_preserved_growth=$_dd_growth _dd_preserved_fall=$_dd_fall
|
||||
dd_client_pressure defer
|
||||
_dd_preserved_growth=$_dd_growth _dd_preserved_fall=$_dd_fall
|
||||
dd_session_pressure
|
||||
dd_client_pressure_finish
|
||||
_dd_focus=1
|
||||
[ "$_dd_game" = 1 ] && { dd_game_focused && _dd_focus=0 || _dd_focus=$?; }
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_focus" = 0 ]; then
|
||||
_dd_away=
|
||||
if [ "$_dd_since" -lt 0 ] || [ "$_dd_since_apps" != "$_dd_apps" ]; then
|
||||
_dd_since=$SECONDS _dd_since_apps=$_dd_apps
|
||||
fi
|
||||
if [ "${DD_ZRAM_CLIENT:-1}" = 1 ] && [ $((SECONDS - _dd_since)) -ge 20 ] && [ "${#_dd_pids[@]}" -gt 0 ] &&
|
||||
{ [ "$_dd_packed" -lt 0 ] || [ $((SECONDS - _dd_packed)) -ge 300 ]; } && dd_client_can_pageout; then
|
||||
dd_zram_send 1 "compressing the client" client
|
||||
_dd_packed=$SECONDS
|
||||
fi
|
||||
elif [ "$_dd_game" != 1 ]; then
|
||||
_dd_away=
|
||||
if [ "$_dd_packed" -ge 0 ]; then
|
||||
_dd_unpack=1
|
||||
fi
|
||||
_dd_since=-1 _dd_packed=-1 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_nogain=0 _dd_tier_pushed=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=()
|
||||
else
|
||||
_dd_since=-1
|
||||
if [ "$_dd_focus" = 1 ]; then
|
||||
[ -n "${_dd_away-}" ] || _dd_away=$SECONDS
|
||||
if [ "$_dd_game" = 1 ] && [ "$_dd_focus" = 1 ]; then
|
||||
[ -n "$_dd_away" ] || _dd_away=$SECONDS
|
||||
else
|
||||
_dd_away=
|
||||
fi
|
||||
if [ "$_dd_packed" -ge 0 ]; then
|
||||
_dd_unpack=1
|
||||
fi
|
||||
fi
|
||||
if [ "$_dd_unpack" = 1 ] &&
|
||||
{ [ "$_dd_game" = 0 ] || { [ "${_dd_ram_cap:-0}" = 0 ] && [ -n "${_dd_away-}" ] && [ $((SECONDS - _dd_away)) -ge 5 ]; }; } &&
|
||||
! dd_over_cap && dd_client_can_readback; then
|
||||
if [ "$_dd_game" = 0 ]; then
|
||||
dd_zram_send 0 "memory recovered, reading the client back" client
|
||||
else
|
||||
dd_zram_send 0 "the client is in front of the game, reading it back" client
|
||||
_dd_packed=-1
|
||||
fi
|
||||
_dd_unpack=0
|
||||
dd_memory_read
|
||||
[ ! -e /tmp/.dd-zram.hold ] || return 0
|
||||
dd_memory_relieve
|
||||
dd_memory_note
|
||||
[ "$_dd_need" -gt 0 ] || dd_client_readback
|
||||
}
|
||||
declare -A _dd_deaf=() _dd_preloaded=()
|
||||
_dd_scan_at=-5 _dd_session_at=-1 _dd_session=() _dd_focus=1 _dd_away=
|
||||
_dd_page_kb=$(($(getconf PAGESIZE 2>/dev/null || echo 4096) / 1024)) _dd_returned=0 _dd_polls=0 _dd_pass_at=0 _dd_goal=0
|
||||
_dd_sample_at= _dd_freed=0 _dd_client_out=0 _dd_note_client=0 _dd_note_session=0
|
||||
_dd_trim_at=-30 _dd_back_at=-30 _dd_forced_at=-10 _dd_full_at=-60 _dd_noted_at=-5
|
||||
_dd_rest=0 _dd_rest_until=0 _dd_rest_available=0
|
||||
while kill -0 $$ 2>/dev/null; do
|
||||
dd_memory_tick
|
||||
if [ "$_dd_available" -ge 0 ] &&
|
||||
{ [ "$_dd_available" -lt $((_dd_mem_total * 2 / 5)) ] || [ "$_dd_rate" -ge $((16 * 1024)) ]; }; then
|
||||
nap 1
|
||||
else
|
||||
nap 5
|
||||
fi
|
||||
dd_watch_nap
|
||||
done
|
||||
) &
|
||||
fi
|
||||
|
||||
+167
-30
@@ -20,7 +20,16 @@
|
||||
#define ZR_CTL "/tmp/.dd-zram"
|
||||
#endif
|
||||
#define ZR_SWAPPED (1ULL << 62)
|
||||
#define ZR_PRESENT (1ULL << 63)
|
||||
#define ZR_BATCH 512
|
||||
#define ZR_CHUNK (1UL << 20)
|
||||
#define ZR_SLOTS 32768UL
|
||||
#define ZR_PROBES 16
|
||||
#define ZR_HEAT_MAX 3
|
||||
#define ZR_SKIP 32U
|
||||
#define ZR_INLINE_KB (32UL << 10)
|
||||
#define ZR_INLINE_CHUNKS 512UL
|
||||
#define ZR_FAILED (~0UL)
|
||||
#define ZR_FUTEX_WAIT 0
|
||||
#define ZR_FUTEX_WAKE 1
|
||||
|
||||
@@ -33,18 +42,43 @@ static char zr_maps[8192];
|
||||
static uint64_t zr_entries[ZR_BATCH];
|
||||
static struct iovec zr_iov[ZR_BATCH];
|
||||
static char zr_sink[ZR_BATCH];
|
||||
static struct zr_slot {
|
||||
unsigned long key;
|
||||
uint16_t gen;
|
||||
uint16_t pushed;
|
||||
uint16_t kept;
|
||||
uint8_t heat;
|
||||
uint8_t skip;
|
||||
} zr_slots[ZR_SLOTS];
|
||||
static uint16_t zr_gen = 1;
|
||||
static unsigned long zr_cursor;
|
||||
static unsigned long zr_visits;
|
||||
|
||||
static int zr_open(const char *path) {
|
||||
return (int)zr_sys(SYS_openat, AT_FDCWD, path, O_RDONLY | O_CLOEXEC, 0);
|
||||
}
|
||||
|
||||
static int zr_mode(void) {
|
||||
char c = 0;
|
||||
int fd = zr_open(ZR_CTL);
|
||||
if (fd < 0) return -1;
|
||||
long n = zr_sys(SYS_read, fd, &c, 1);
|
||||
zr_sys(SYS_close, fd);
|
||||
return n == 1 && (c == '0' || c == '1') ? c - '0' : -1;
|
||||
static int zr_mode(unsigned long *want) {
|
||||
char text[24];
|
||||
long n = 0;
|
||||
int fd = zr_open(ZR_CTL ".hold");
|
||||
if (fd >= 0) {
|
||||
n = zr_sys(SYS_read, fd, text, sizeof(text));
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
if (n < 1) {
|
||||
fd = zr_open(ZR_CTL);
|
||||
if (fd < 0) return -1;
|
||||
n = zr_sys(SYS_read, fd, text, sizeof(text));
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
if (n < 1 || text[0] < '0' || text[0] > '3') return -1;
|
||||
unsigned long kb = 0;
|
||||
for (long i = 2; i < n && text[i] >= '0' && text[i] <= '9'; i++)
|
||||
kb = kb * 10 + (unsigned long)(text[i] - '0');
|
||||
*want = kb / (zr_page / 1024);
|
||||
if (text[0] >= '2' && *want == 0) return -1;
|
||||
return text[0] - '0';
|
||||
}
|
||||
|
||||
static unsigned long zr_hex(const char **p) {
|
||||
@@ -96,16 +130,103 @@ static void zr_read_back(int pagemap, unsigned long start, unsigned long end) {
|
||||
}
|
||||
}
|
||||
|
||||
static void zr_walk(int compress) {
|
||||
int maps = zr_open("/proc/self/maps");
|
||||
if (maps < 0) return;
|
||||
int pagemap = compress ? -1 : zr_open("/proc/self/pagemap");
|
||||
if (!compress && pagemap < 0) {
|
||||
zr_sys(SYS_close, maps);
|
||||
return;
|
||||
static unsigned long zr_count(int pagemap, unsigned long start, unsigned long end, uint64_t bit) {
|
||||
unsigned long count = 0;
|
||||
long size = (long)((end - start) / zr_page * sizeof(uint64_t));
|
||||
long got;
|
||||
do {
|
||||
if (zr_sys(SYS_lseek, pagemap, (long)(start / zr_page * sizeof(uint64_t)), SEEK_SET) < 0) return ZR_FAILED;
|
||||
got = zr_sys(SYS_read, pagemap, zr_entries, size);
|
||||
} while (got < 0 && errno == EINTR);
|
||||
if (got != size) return ZR_FAILED;
|
||||
for (long i = 0; i < got / (long)sizeof(uint64_t); i++)
|
||||
if (zr_entries[i] & bit) count++;
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct zr_slot *zr_slot(unsigned long addr, int create) {
|
||||
unsigned long key = addr / zr_page + 1;
|
||||
unsigned long home = key * 2654435761UL % ZR_SLOTS;
|
||||
for (unsigned long i = 0; i < ZR_PROBES; i++) {
|
||||
struct zr_slot *slot = &zr_slots[(home + i) % ZR_SLOTS];
|
||||
if (slot->key == key) return slot;
|
||||
if (slot->key == 0 && !create) return NULL;
|
||||
if (slot->key == 0) {
|
||||
slot->key = key;
|
||||
return slot;
|
||||
}
|
||||
}
|
||||
if (!create) return NULL;
|
||||
memset(&zr_slots[home], 0, sizeof(zr_slots[home]));
|
||||
zr_slots[home].key = key;
|
||||
return &zr_slots[home];
|
||||
}
|
||||
|
||||
static unsigned long zr_trim(int pagemap, unsigned long start, unsigned long end,
|
||||
unsigned long want, int force, unsigned long lo, unsigned long hi) {
|
||||
unsigned long done = 0;
|
||||
for (unsigned long addr = start, next; addr < end && done < want; addr = next) {
|
||||
next = (addr | (ZR_CHUNK - 1)) + 1;
|
||||
if (next > end || next < addr) next = end;
|
||||
if (next <= lo || addr >= hi) continue;
|
||||
if (zr_visits == 0) break;
|
||||
zr_visits--;
|
||||
zr_cursor = next;
|
||||
if (addr < (unsigned long)(zr_slots + ZR_SLOTS) && next > (unsigned long)zr_slots) continue;
|
||||
unsigned long present = zr_count(pagemap, addr, next, ZR_PRESENT);
|
||||
if (present == ZR_FAILED) continue;
|
||||
struct zr_slot *slot = zr_slot(addr, 0);
|
||||
if (slot != NULL && slot->gen == zr_gen && slot->pushed > 0) {
|
||||
if (present > slot->kept && (present - slot->kept) * 4 > slot->pushed) {
|
||||
if (slot->heat < ZR_HEAT_MAX) slot->heat++;
|
||||
slot->skip = (uint8_t)(ZR_SKIP << slot->heat > 255 ? 255 : ZR_SKIP << slot->heat);
|
||||
slot->pushed = 0;
|
||||
} else if (slot->heat > 0) {
|
||||
slot->heat--;
|
||||
}
|
||||
}
|
||||
if (slot != NULL && slot->skip > 0 && !force) {
|
||||
slot->skip--;
|
||||
continue;
|
||||
}
|
||||
if (present == 0) continue;
|
||||
unsigned long from = addr < lo ? lo : addr;
|
||||
unsigned long left = present;
|
||||
while (from < next && done + present - left < want) {
|
||||
unsigned long budget = want - done - (present - left);
|
||||
unsigned long i = (from - addr) / zr_page;
|
||||
for (; i < (next - addr) / zr_page && budget > 0; i++)
|
||||
if (zr_entries[i] & ZR_PRESENT) budget--;
|
||||
unsigned long to = addr + i * zr_page;
|
||||
zr_sys(SYS_madvise, from, to - from, MADV_PAGEOUT);
|
||||
from = to;
|
||||
unsigned long now = zr_count(pagemap, addr, next, ZR_PRESENT);
|
||||
if (now == ZR_FAILED) break;
|
||||
left = now < present ? now : present;
|
||||
}
|
||||
if (from < next) zr_cursor = from;
|
||||
if (left >= present) continue;
|
||||
if (slot == NULL) slot = zr_slot(addr, 1);
|
||||
if (slot->gen != zr_gen) slot->pushed = 0;
|
||||
slot->gen = zr_gen;
|
||||
slot->pushed = (uint16_t)(slot->pushed + present - left);
|
||||
slot->kept = (uint16_t)left;
|
||||
done += present - left;
|
||||
}
|
||||
return done;
|
||||
}
|
||||
|
||||
static unsigned long zr_walk(int mode, unsigned long want, unsigned long lo, unsigned long hi) {
|
||||
int maps = zr_open("/proc/self/maps");
|
||||
if (maps < 0) return 0;
|
||||
int pagemap = mode == 1 ? -1 : zr_open("/proc/self/pagemap");
|
||||
if (mode != 1 && pagemap < 0) {
|
||||
zr_sys(SYS_close, maps);
|
||||
return 0;
|
||||
}
|
||||
unsigned long done = 0;
|
||||
size_t have = 0;
|
||||
for (;;) {
|
||||
while (done < want && zr_visits > 0) {
|
||||
long n = zr_sys(SYS_read, maps, zr_maps + have, sizeof(zr_maps) - 1 - have);
|
||||
if (n < 0 && errno == EINTR) continue;
|
||||
if (n <= 0) break;
|
||||
@@ -113,12 +234,13 @@ static void zr_walk(int compress) {
|
||||
zr_maps[have] = 0;
|
||||
char *line = zr_maps;
|
||||
char *nl;
|
||||
while ((nl = memchr(line, '\n', have - (size_t)(line - zr_maps))) != NULL) {
|
||||
while (done < want && zr_visits > 0 && (nl = memchr(line, '\n', have - (size_t)(line - zr_maps))) != NULL) {
|
||||
*nl = 0;
|
||||
unsigned long s, e;
|
||||
if (zr_eligible(line, compress, &s, &e) && e > s) {
|
||||
if (compress) zr_sys(SYS_madvise, s, e - s, MADV_PAGEOUT);
|
||||
else zr_read_back(pagemap, s, e);
|
||||
if (zr_eligible(line, mode != 0, &s, &e) && e > s) {
|
||||
if (mode == 0) zr_read_back(pagemap, s, e);
|
||||
else if (mode == 1) zr_sys(SYS_madvise, s, e - s, MADV_PAGEOUT);
|
||||
else done += zr_trim(pagemap, s, e, want - done, mode == 3, lo, hi);
|
||||
}
|
||||
line = nl + 1;
|
||||
}
|
||||
@@ -128,11 +250,12 @@ static void zr_walk(int compress) {
|
||||
}
|
||||
if (pagemap >= 0) zr_sys(SYS_close, pagemap);
|
||||
zr_sys(SYS_close, maps);
|
||||
return done;
|
||||
}
|
||||
|
||||
static void zr_ack(int done) {
|
||||
static const char suffix[] = ".ack.";
|
||||
char path[sizeof(ZR_CTL) + sizeof(suffix) + 20];
|
||||
static void zr_ack(long value, int trim) {
|
||||
const char *suffix = trim ? ".trim." : ".ack.";
|
||||
char path[sizeof(ZR_CTL) + sizeof(".trim.") + 20];
|
||||
char digits[20];
|
||||
size_t n = 0, d = 0;
|
||||
for (const char *p = ZR_CTL; *p; p++) path[n++] = *p;
|
||||
@@ -143,15 +266,29 @@ static void zr_ack(int done) {
|
||||
path[n] = 0;
|
||||
int fd = (int)zr_sys(SYS_openat, AT_FDCWD, path, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0600);
|
||||
if (fd < 0) return;
|
||||
if (done) zr_sys(SYS_write, fd, "1", 1UL);
|
||||
for (d = 0; value >= 0 && (d == 0 || value > 0); value /= 10) digits[d++] = (char)('0' + value % 10);
|
||||
for (n = 0; d > 0;) path[n++] = digits[--d];
|
||||
if (n > 0) zr_sys(SYS_write, fd, path, n);
|
||||
zr_sys(SYS_close, fd);
|
||||
}
|
||||
|
||||
static void zr_request(void) {
|
||||
int mode = zr_mode();
|
||||
if (mode == 1) zr_ack(0);
|
||||
if (mode >= 0) zr_walk(mode);
|
||||
if (mode == 1) zr_ack(1);
|
||||
static void zr_request(int worker) {
|
||||
unsigned long want = 0;
|
||||
int mode = zr_mode(&want);
|
||||
if (mode < 0) return;
|
||||
if (!worker && want > ZR_INLINE_KB / (zr_page / 1024)) want = ZR_INLINE_KB / (zr_page / 1024);
|
||||
zr_visits = worker ? ZR_FAILED : ZR_INLINE_CHUNKS;
|
||||
if (mode > 0) zr_ack(-1, mode > 1);
|
||||
if (mode < 2) {
|
||||
zr_walk(mode, 1, 0, 0);
|
||||
zr_gen++;
|
||||
if (mode == 1) zr_ack(1, 0);
|
||||
return;
|
||||
}
|
||||
unsigned long from = zr_cursor;
|
||||
unsigned long done = zr_walk(mode, want, from, ~0UL);
|
||||
if (done < want && from > 0) done += zr_walk(mode, want - done, 0, from);
|
||||
zr_ack((long)(done * (zr_page / 1024)), 1);
|
||||
}
|
||||
|
||||
static void *zr_worker_main(void *unused) {
|
||||
@@ -160,7 +297,7 @@ static void *zr_worker_main(void *unused) {
|
||||
for (;;) {
|
||||
while (!__atomic_exchange_n(&zr_pending, 0, __ATOMIC_SEQ_CST))
|
||||
zr_sys(SYS_futex, &zr_pending, ZR_FUTEX_WAIT, 0, NULL, NULL, 0);
|
||||
zr_request();
|
||||
zr_request(1);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@@ -176,7 +313,7 @@ static void zr_handler(int sig, siginfo_t *info, void *context) {
|
||||
} else while (__atomic_load_n(&zr_pending, __ATOMIC_SEQ_CST)
|
||||
&& !__atomic_exchange_n(&zr_busy, 1, __ATOMIC_SEQ_CST)) {
|
||||
__atomic_store_n(&zr_pending, 0, __ATOMIC_SEQ_CST);
|
||||
zr_request();
|
||||
zr_request(0);
|
||||
__atomic_store_n(&zr_busy, 0, __ATOMIC_SEQ_CST);
|
||||
}
|
||||
errno = saved;
|
||||
|
||||
@@ -100,8 +100,7 @@ def required():
|
||||
'layer/VK_LAYER_DROIDDECK_vr.json', 'layer/VK_LAYER_DROIDDECK_vr_implicit.json',
|
||||
'layer/libdroiddeck_vr_scheduling.so']]
|
||||
paths += ['assets/linuxfs/usr/local/lib/droiddeck-gpuload/' + name for name in
|
||||
['libVkLayer_droiddeck_gpuload.so', 'VK_LAYER_DROIDDECK_gpu_load.json',
|
||||
'libVkLayer_droiddeck_vramcap.so', 'VK_LAYER_DROIDDECK_vram_cap.json']]
|
||||
['libVkLayer_droiddeck_gpuload.so', 'VK_LAYER_DROIDDECK_gpu_load.json']]
|
||||
for side in ['left', 'right']:
|
||||
paths += [f'assets/linuxfs/usr/local/lib/droiddeck-vr/droiddeck/resources/rendermodels/droiddeck_hand_{side}/{name}'
|
||||
for name in [f'droiddeck_hand_{side}.json', 'hand.mtl', 'hand.png', 'hand_open.obj', 'hand_fist.obj',
|
||||
|
||||
@@ -18,6 +18,15 @@ def run_bash(script, env=None):
|
||||
return subprocess.run(['bash', '-c', script], capture_output=True, text=True, timeout=10, env=env)
|
||||
|
||||
|
||||
def state_source():
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' declare -A _dd_deaf=()')
|
||||
return source[start:source.index(' while kill -0', start)]
|
||||
|
||||
|
||||
STATE = state_source()
|
||||
|
||||
|
||||
class ClientZramFocusTest(unittest.TestCase):
|
||||
def test_the_hidden_epic_launcher_is_compressed_with_the_client(self):
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
@@ -78,217 +87,59 @@ class ClientZramFocusTest(unittest.TestCase):
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('|6000021 6000022 6000020|0', result.stdout.strip())
|
||||
|
||||
def test_refocus_restarts_the_delay_and_game_exit_restores_a_packed_client(self):
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' _dd_focus=1\n')
|
||||
stop = source.index(' dd_watch_nap\n', start)
|
||||
body = source[start:stop]
|
||||
harness = '''
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_unpack=0 _dd_apps=" 413150"
|
||||
_dd_pids=(123)
|
||||
dd_game_focused() { [ "$focused" = 1 ]; }
|
||||
dd_over_cap() { return 1; }
|
||||
dd_client_can_pageout() { return 0; }
|
||||
dd_client_can_readback() { return 0; }
|
||||
dd_zram_send() { echo "send:$1"; }
|
||||
tick() {
|
||||
SECONDS=$1 _dd_game=$2 focused=$3
|
||||
''' + body + '''
|
||||
}
|
||||
tick 0 1 1
|
||||
tick 5 1 0
|
||||
tick 30 1 1
|
||||
echo "refocus:$_dd_packed"
|
||||
tick 49 1 1
|
||||
tick 50 1 1
|
||||
tick 55 1 0
|
||||
tick 60 0 0
|
||||
'''
|
||||
result = run_bash(harness)
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['refocus:-1', 'send:1', 'send:0'], result.stdout.splitlines())
|
||||
|
||||
def monitor_harness(self):
|
||||
source = SCRIPT.read_text()
|
||||
start = source.index(' dd_zram_scan\n dd_memory_read\n')
|
||||
stop = source.index(' dd_watch_nap\n', start)
|
||||
return '''
|
||||
_dd_since=-1 _dd_since_apps= _dd_packed=-1 _dd_measured=-1 _dd_unpack=0 _dd_capped=-1 _dd_backoff=30
|
||||
_dd_apps=" 413150"
|
||||
_dd_pids=(123)
|
||||
TICK = '''
|
||||
dd_zram_scan() { _dd_game=$game _dd_pids=(10) _dd_others=() _dd_apps=" 413150"; }
|
||||
dd_game_focused() { return $focus; }
|
||||
dd_memory_read() { _dd_available=$((available * 1024)) _dd_mem_total=$((7168 * 1024)) _dd_floor=$((896 * 1024)); _dd_target=$((target * 1024)) _dd_swap_room=$((4096 * 1024)) _dd_saving=500 _dd_rate=0 _dd_psi=0; }
|
||||
dd_zram_trim() { echo "trim:$NOW"; _dd_trimmed=$((64 * 1024)); }
|
||||
dd_zram_usage() { _dd_swap=$((64 * 1024)); }
|
||||
dd_session_others() { :; }
|
||||
step() { :; }
|
||||
dd_zram_scan() { :; }
|
||||
dd_memory_read() { :; }
|
||||
dd_client_pressure() { :; }
|
||||
dd_client_pressure_finish() { :; }
|
||||
dd_session_pressure() { :; }
|
||||
dd_client_can_pageout() { return 0; }
|
||||
dd_client_can_readback() { [ "${readback:-1}" = 1 ]; }
|
||||
dd_game_focused() { [ "$focused" = 1 ] && return 0; [ "$focused" = 2 ] && return 2; return 1; }
|
||||
dd_cap_due() { [ "$cap_due" = 1 ]; }
|
||||
dd_over_cap() { [ "$over_cap" = 1 ]; }
|
||||
dd_zram_send() { echo "send:$1:$3"; }
|
||||
tick() {
|
||||
SECONDS=$1 _dd_game=$2 focused=$3 over_cap=$4 cap_due=$5
|
||||
''' + source[start:stop] + '\n}\n'
|
||||
kill() { echo "back:$NOW"; }
|
||||
game=1 focus=0 available=1500 target=1600
|
||||
run() { for NOW in $(seq "$1" "$2"); do dd_memory_tick; done; }
|
||||
'''
|
||||
|
||||
def test_client_toggle_still_disables_automatic_compression(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0
|
||||
tick 0 1 1 0 0
|
||||
tick 25 1 1 0 0
|
||||
tick 30 0 0 0 0
|
||||
''')
|
||||
def tick(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_need', 'dd_memory_relieve', 'dd_memory_note', 'dd_client_readback', 'dd_memory_tick'))
|
||||
with tempfile.TemporaryDirectory() as tmp:
|
||||
script = (functions + self.TICK + body).replace('/tmp/.dd-zram', tmp + '/ctl')
|
||||
result = run_bash(('NOW=0\nset -u\n' + STATE + script).replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual('', result.stdout)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_a_new_game_restarts_the_compression_delay(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
_dd_apps=" 413150 1245620"
|
||||
tick 15 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
echo "starting:$_dd_packed"
|
||||
tick 34 1 1 0 0
|
||||
tick 35 1 1 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['starting:-1', 'send:1:client'], result.stdout.splitlines())
|
||||
def test_the_client_behind_a_game_is_trimmed_while_memory_is_short_of_the_target(self):
|
||||
self.assertEqual(['trim:0', 'trim:1', 'trim:2'], self.tick('run 0 2\navailable=1700; run 3 9\n'))
|
||||
|
||||
def test_ram_cap_can_still_compress_an_unfocused_client(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0 DD_RAM_CAP_MB=1024
|
||||
dd_zram_usage() { _dd_rss=$((768 * 1024)); }
|
||||
tick 0 1 0 1 1
|
||||
echo "cap:$_dd_packed:$_dd_since:$_dd_backoff"
|
||||
tick 5 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'send:1:session', 'cap:0:-1:60', 'send:0:client'], result.stdout.splitlines())
|
||||
def test_nothing_is_requested_while_the_app_holds_the_control_file(self):
|
||||
self.assertEqual(['trim:3'], self.tick(
|
||||
': > /tmp/.dd-zram.hold; run 0 2\nrm /tmp/.dd-zram.hold; run 3 3\n'))
|
||||
|
||||
def test_game_exit_defers_restore_until_the_session_is_under_the_ram_cap(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 30 0 0 1 0
|
||||
echo "deferred:$_dd_unpack:$_dd_packed"
|
||||
tick 35 0 0 0 0
|
||||
echo "restored:$_dd_unpack"
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'deferred:1:-1', 'send:0:client', 'restored:0'], result.stdout.splitlines())
|
||||
def test_nothing_is_read_back_while_memory_is_still_needed(self):
|
||||
self.assertEqual(['trim:0'], self.tick(
|
||||
'run 0 0\ngame=0 available=4000; dd_memory_need() { _dd_need=1 _dd_hard=0 _dd_force=0; }\n'
|
||||
'dd_memory_relieve() { dd_memory_need; }; run 1 40\n'))
|
||||
|
||||
def test_game_exit_defers_readback_under_pressure_even_without_a_ram_cap(self):
|
||||
result = run_bash(self.monitor_harness() + """
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
readback=0
|
||||
tick 25 0 0 0 0
|
||||
echo "deferred:$_dd_unpack"
|
||||
readback=1
|
||||
tick 30 0 0 0 0
|
||||
echo "restored:$_dd_unpack"
|
||||
""")
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'deferred:1', 'send:0:client', 'restored:0'], result.stdout.splitlines())
|
||||
def test_game_exit_reads_the_client_back_after_a_quiet_half_minute(self):
|
||||
self.assertEqual(['trim:0', 'back:30'], self.tick('run 0 0\ngame=0 available=4000; run 1 40\n'))
|
||||
|
||||
def test_client_in_front_of_a_running_game_is_read_back_and_compressed_again_later(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
echo "away:$_dd_packed"
|
||||
tick 30 1 0 0 0
|
||||
echo "read:$_dd_packed:$_dd_unpack"
|
||||
tick 35 1 0 0 0
|
||||
tick 40 1 1 0 0
|
||||
tick 55 1 1 0 0
|
||||
tick 60 1 1 0 0
|
||||
echo "again:$_dd_packed"
|
||||
tick 65 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'away:20', 'send:0:client', 'read:-1:0', 'send:1:client', 'again:60', 'send:0:client'],
|
||||
result.stdout.splitlines())
|
||||
|
||||
def test_unknown_focus_keeps_the_client_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 2 0 0
|
||||
tick 40 1 2 0 0
|
||||
echo "unknown:$_dd_packed:$_dd_unpack"
|
||||
tick 45 1 0 0 0
|
||||
tick 48 1 2 0 0
|
||||
tick 52 1 0 0 0
|
||||
tick 56 1 0 0 0
|
||||
echo "flicker:$_dd_packed"
|
||||
tick 57 1 0 0 0
|
||||
echo "read:$_dd_packed"
|
||||
tick 60 0 2 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'unknown:20:1', 'flicker:20', 'send:0:client', 'read:-1'],
|
||||
result.stdout.splitlines())
|
||||
def test_client_in_front_of_a_running_game_is_read_back_and_trimmed_again_later(self):
|
||||
self.assertEqual(['trim:0', 'back:30', 'trim:60'],
|
||||
self.tick('run 0 0\nfocus=1 available=4000; run 1 44\nfocus=0 available=1500; run 45 60\n'))
|
||||
|
||||
def test_a_short_look_at_the_client_keeps_it_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 28 1 1 0 0
|
||||
tick 30 1 0 0 0
|
||||
tick 34 1 0 0 0
|
||||
echo "packed:$_dd_packed"
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'packed:20'], result.stdout.splitlines())
|
||||
self.assertEqual(['trim:0'], self.tick('run 0 0\navailable=4000; run 1 34\nfocus=1; run 35 38\nfocus=0; run 39 60\n'))
|
||||
|
||||
def test_client_in_front_waits_for_memory_and_a_ram_cap_keeps_it_compressed(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
tick 0 1 1 0 0
|
||||
tick 20 1 1 0 0
|
||||
readback=0
|
||||
tick 25 1 0 0 0
|
||||
tick 35 1 0 0 0
|
||||
echo "tight:$_dd_packed"
|
||||
readback=1
|
||||
tick 40 1 0 0 0
|
||||
echo "eased:$_dd_packed"
|
||||
_dd_ram_cap=1048576
|
||||
tick 60 1 1 0 0
|
||||
tick 80 1 1 0 0
|
||||
tick 85 1 0 0 0
|
||||
tick 100 1 0 0 0
|
||||
echo "capped:$_dd_packed"
|
||||
tick 105 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual(['send:1:client', 'tight:20', 'send:0:client', 'eased:-1', 'send:1:client', 'capped:80', 'send:0:client'],
|
||||
result.stdout.splitlines())
|
||||
def test_unknown_focus_keeps_the_client_compressed(self):
|
||||
self.assertEqual(['trim:0'], self.tick('run 0 0\nfocus=2 available=4000; run 1 60\n'))
|
||||
|
||||
def test_client_in_front_without_compression_reads_nothing_back(self):
|
||||
result = run_bash(self.monitor_harness() + '''
|
||||
DD_ZRAM_CLIENT=0
|
||||
tick 0 1 1 0 0
|
||||
tick 25 1 0 0 0
|
||||
tick 40 1 0 0 0
|
||||
tick 45 0 0 0 0
|
||||
''')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
self.assertEqual('', result.stdout)
|
||||
def test_client_in_front_waits_for_memory(self):
|
||||
self.assertEqual(['trim:0', 'back:50'], self.tick('run 0 0\nfocus=1 available=1800 target=896; run 1 49\navailable=2500; run 50 60\n'))
|
||||
|
||||
def test_a_client_that_was_never_trimmed_reads_nothing_back(self):
|
||||
self.assertEqual([], self.tick('focus=1 available=4000; run 0 60\n'))
|
||||
|
||||
def test_scan_keeps_the_running_game_and_ignores_steams_own_reaper(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
|
||||
@@ -824,7 +824,6 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
"offline_without_anticheat": lambda command, env: command,
|
||||
"game_logs": lambda command, env, app_id: env,
|
||||
"directaudio_settings": lambda env: env,
|
||||
"vram_cap": lambda env: env,
|
||||
"render_path_defaults": lambda *args: None,
|
||||
"bridge_feature_level": lambda env: None,
|
||||
"force_ssbs": lambda command, env: env,
|
||||
@@ -1304,22 +1303,6 @@ class GameEnvironmentTest(unittest.TestCase):
|
||||
link.symlink_to(other, target_is_directory=True)
|
||||
self.assertTrue(chromium(str(link)))
|
||||
|
||||
def test_the_vram_cap_comes_before_the_games_own_dxvk_settings(self):
|
||||
cap = MODULE["vram_cap"]
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "4096"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4096; dxgi.maxSharedMemory = 4096")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "8192"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 8192; dxgi.maxSharedMemory = 8192")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "4095"})["DXVK_CONFIG"], "dxgi.maxDeviceMemory = 4095; dxgi.maxSharedMemory = 4095; d3d9.maxAvailableMemory = 4095")
|
||||
self.assertEqual(cap({"DD_VRAM_MB": "2048", "DXVK_CONFIG": "dxvk.maxFrameRate = 60;"})["DXVK_CONFIG"],
|
||||
"dxgi.maxDeviceMemory = 2048; dxgi.maxSharedMemory = 2048; d3d9.maxAvailableMemory = 2048; dxvk.maxFrameRate = 60")
|
||||
for off in ({}, {"DD_VRAM_MB": "0"}, {"DD_VRAM_MB": "lots"}, {"DD_VRAM_MB": "²"}, {"DD_VRAM_MB": "-1"}):
|
||||
self.assertNotIn("DXVK_CONFIG", cap(off))
|
||||
self.assertNotIn("DROIDDECK_VRAM_CAP", cap(off))
|
||||
self.assertNotIn("DROIDDECK_VRAM_CAP_MB", cap(off))
|
||||
|
||||
def test_the_vram_cap_also_turns_on_the_vulkan_layer_that_holds_the_game_to_it(self):
|
||||
env = MODULE["vram_cap"]({"DD_VRAM_MB": "3072", "DXVK_CONFIG": "dxgi.maxDeviceMemory = 16384"})
|
||||
self.assertEqual((env["DROIDDECK_VRAM_CAP"], env["DROIDDECK_VRAM_CAP_MB"]), ("1", "3072"))
|
||||
|
||||
def test_a_games_wine_sync_choice_also_reaches_its_setup_runs(self):
|
||||
env = {"DD_SYNC": "1", "DD_SYNC_FALLBACK": "1", "DD_FSYNC_FIRST": "0", "OTHER": "kept"}
|
||||
config = {"version": 1, "games": {"42": {"DD_SYNC": "0", "DD_FSYNC_FIRST": "1", "PROTON_NO_ESYNC": "1", "FEX_TSOENABLED": "1"}}}
|
||||
|
||||
+316
-607
@@ -2,7 +2,9 @@ from pathlib import Path
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
from tools.tests.test_client_zram_focus import SCRIPT, function_source, run_bash
|
||||
from tools.tests.test_client_zram_focus import STATE, function_source, run_bash
|
||||
|
||||
MB = 1024
|
||||
|
||||
|
||||
class MemoryPressureTest(unittest.TestCase):
|
||||
@@ -10,629 +12,336 @@ class MemoryPressureTest(unittest.TestCase):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.root = Path(self.directory.name)
|
||||
self.memory()
|
||||
|
||||
def memory(self, available=1024, swap_free=4096, total=7168, swap_total=6144, psi='0.00'):
|
||||
(self.root / 'meminfo').write_text(
|
||||
f'MemTotal: {total * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {swap_total * 1024} kB\nSwapFree: {swap_free * 1024} kB\n')
|
||||
(self.root / 'pressure').write_text(f'some avg10={psi} avg60=0.00 avg300=0.00 total=1234\n')
|
||||
def sample(self, available=3000, total=7168, stall=0, zram=(6144, 0), other=(4096, 0), stored=None, swapped_in=None):
|
||||
lines = [f'MemTotal: {total * MB} kB', f'MemAvailable: {available * MB} kB',
|
||||
f'SwapTotal: {(zram[0] + other[0]) * MB} kB',
|
||||
f'SwapFree: {(zram[0] - zram[1] + other[0] - other[1]) * MB} kB']
|
||||
swaps = ['Filename Type Size Used Priority']
|
||||
if zram[0]:
|
||||
swaps.append(f'/dev/block/zram0 partition {zram[0] * MB} {zram[1] * MB} 100')
|
||||
if other[0]:
|
||||
swaps.append(f'/data/swap/swapfile file {other[0] * MB} {other[1] * MB} 50')
|
||||
text = "printf '%s\\n' " + ' '.join(f"'{line}'" for line in lines) + f" > {self.root}/meminfo\n"
|
||||
text += "printf '%s\\n' " + ' '.join(f"'{line}'" for line in swaps) + f" > {self.root}/swaps\n"
|
||||
text += f"echo 'some avg10=0.00 avg60=0.00 avg300=0.00 total={stall}' > {self.root}/pressure\n"
|
||||
if swapped_in is None:
|
||||
text += f'rm -f {self.root}/vmstat\n'
|
||||
else:
|
||||
text += f"printf '%s\\n' 'pgfault 9' 'pswpin {swapped_in * MB // 4}' 'pswpout 7' > {self.root}/vmstat\n"
|
||||
if stored is None:
|
||||
text += f'rm -f {self.root}/mm_stat\n'
|
||||
else:
|
||||
text += f'echo "{stored[0] << 20} {stored[1] << 20} {stored[1] << 20} 0 0 0 0 0 0" > {self.root}/mm_stat\n'
|
||||
return text
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_read', 'dd_memory_tight', 'dd_memory_critical', 'dd_client_can_pageout',
|
||||
'dd_client_can_readback', 'dd_client_pressure', 'dd_client_pressure_result', 'dd_zram_has_room'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
set -u
|
||||
_dd_pids=(123) _dd_game=1 _dd_packed=-1 _dd_pressure_at=-1 _dd_pressure_backoff=30
|
||||
rss=$((384 * 1024)) client_swap=$((512 * 1024)) reclaimed=$((128 * 1024))
|
||||
step() { :; }
|
||||
dd_zram_usage() { _dd_rss=$rss _dd_anon=${anon:-$rss} _dd_swap=$client_swap; }
|
||||
dd_zram_send() { echo "send:$1:$3"; rss=$((rss - reclaimed)); _dd_pageout_complete=${pageout_complete:-1}; }
|
||||
''' + functions + '\ndd_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
def run_policy(self, body, *names):
|
||||
functions = '\n'.join(function_source(name) for name in ('dd_memory_read', 'dd_memory_need') + names)
|
||||
for name in ('meminfo', 'swaps', 'pressure/memory', 'vmstat'):
|
||||
functions = functions.replace('/proc/' + name, str(self.root / name.split('/')[0]))
|
||||
functions = functions.replace('/sys/block/zram0/mm_stat', str(self.root / 'mm_stat'))
|
||||
functions = functions.replace('/tmp/.dd-zram', str(self.root / 'ctl'))
|
||||
result = run_bash(('NOW=0\nset -u\n' + STATE + functions + '\n' + body).replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_pressure_reclaims_before_the_focus_delay_and_respects_cooldown(self):
|
||||
self.assertEqual(['send:1:client', 'send:1:client'], self.run_policy('''
|
||||
SECONDS=0; dd_client_pressure
|
||||
SECONDS=5; dd_client_pressure
|
||||
SECONDS=29; dd_client_pressure
|
||||
SECONDS=30; dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_no_game_or_disabled_client_compression_does_not_reclaim(self):
|
||||
self.assertEqual([], self.run_policy('''
|
||||
_dd_game=0; dd_client_pressure
|
||||
_dd_game=1 DD_ZRAM_CLIENT=0; dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_high_available_memory_does_not_reclaim_even_with_stalls(self):
|
||||
self.memory(available=4096, psi='12.34')
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_psi_reclaims_with_moderate_headroom(self):
|
||||
self.memory(available=2048, psi='01.23')
|
||||
self.assertEqual(['send:1:client'], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_missing_psi_still_uses_memory_headroom(self):
|
||||
(self.root / 'pressure').unlink()
|
||||
self.assertEqual(['send:1:client'], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_missing_meminfo_never_reclaims_or_prefetches(self):
|
||||
(self.root / 'meminfo').write_text('SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
|
||||
self.assertEqual(['no'], self.run_policy('''
|
||||
dd_client_pressure
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_missing_available_memory_does_not_trigger_pressure(self):
|
||||
p = self.root / 'meminfo'
|
||||
p.write_text('\n'.join(line for line in p.read_text().splitlines() if not line.startswith('MemAvailable:')))
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_swap_reserve_includes_the_clients_resident_memory(self):
|
||||
self.memory(swap_free=1536)
|
||||
self.assertEqual(['no'], self.run_policy('''
|
||||
dd_client_pressure
|
||||
if dd_client_can_pageout; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_client_swap_budget_excludes_file_backed_memory(self):
|
||||
self.memory(swap_free=1536)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('''
|
||||
rss=$((2048 * 1024)) anon=$((256 * 1024))
|
||||
dd_client_pressure
|
||||
'''))
|
||||
|
||||
def test_without_swap_automatic_pageout_is_disabled(self):
|
||||
self.memory(swap_total=0, swap_free=0)
|
||||
self.assertEqual([], self.run_policy('dd_client_pressure'))
|
||||
|
||||
def test_recent_periodic_pageout_prevents_an_immediate_pressure_repeat(self):
|
||||
self.assertEqual([], self.run_policy('_dd_packed=$SECONDS; dd_client_pressure'))
|
||||
|
||||
def test_ineffective_reclaim_backs_off_and_success_resets_it(self):
|
||||
self.assertEqual(['send:1:client', 'backoff:60', 'send:1:client', 'backoff:30'], self.run_policy('''
|
||||
reclaimed=0
|
||||
SECONDS=0; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
SECONDS=30; dd_client_pressure
|
||||
reclaimed=$((128 * 1024))
|
||||
SECONDS=60; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
'''))
|
||||
|
||||
def test_readback_requires_room_for_the_swapped_client_plus_headroom(self):
|
||||
self.memory(available=2048)
|
||||
self.assertEqual(['yes', 'no'], self.run_policy('''
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
client_swap=$((1024 * 1024))
|
||||
if dd_client_can_readback; then echo yes; else echo no; fi
|
||||
'''))
|
||||
|
||||
def test_unfinished_pageout_does_not_increase_the_ineffective_reclaim_backoff(self):
|
||||
self.assertEqual(['send:1:client', 'backoff:30'], self.run_policy('''
|
||||
reclaimed=0 pageout_complete=0
|
||||
SECONDS=0; dd_client_pressure
|
||||
echo "backoff:$_dd_pressure_backoff"
|
||||
'''))
|
||||
|
||||
def test_pageout_completion_requires_a_finished_ack_from_every_live_target(self):
|
||||
proc = self.root / 'proc'
|
||||
proc.mkdir()
|
||||
for pid in (123, 456):
|
||||
(proc / str(pid)).mkdir()
|
||||
source = function_source('dd_zram_wait').replace('/proc/', str(proc) + '/')
|
||||
source = source.replace('/tmp/.dd-zram.ack.', str(self.root / 'ack.'))
|
||||
for pending in ('done', 'running', 'not_started'):
|
||||
with self.subTest(pending=pending):
|
||||
(self.root / 'ack.123').write_text('1')
|
||||
if pending != 'not_started':
|
||||
(self.root / 'ack.456').write_text('1' if pending == 'done' else '')
|
||||
result = run_bash('nap() { SECONDS=$((SECONDS + 1)); }\n' + source +
|
||||
'\nSECONDS=0; dd_zram_wait 123 456; echo "$_dd_pageout_complete"')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('1' if pending == 'done' else '0', result.stdout.strip())
|
||||
|
||||
def test_pressure_prevents_prefetch_even_if_the_client_would_fit(self):
|
||||
self.memory(available=2048, psi='2.00')
|
||||
self.assertEqual(['no'], self.run_policy('if dd_client_can_readback; then echo yes; else echo no; fi'))
|
||||
|
||||
|
||||
class SessionPressureTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.directory = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.directory.cleanup)
|
||||
self.root = Path(self.directory.name)
|
||||
self.memory()
|
||||
|
||||
def memory(self, available=1024, swap_free=6144, total=7168, swap_total=8192, psi='0.00'):
|
||||
(self.root / 'meminfo').write_text(
|
||||
f'MemTotal: {total * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {swap_total * 1024} kB\nSwapFree: {swap_free * 1024} kB\n')
|
||||
(self.root / 'pressure').write_text(f'some avg10={psi} avg60=0.00 avg300=0.00 total=1234\n')
|
||||
|
||||
def run_policy(self, body):
|
||||
functions = '\n'.join(function_source(name) for name in (
|
||||
'dd_memory_read', 'dd_memory_tight', 'dd_memory_critical',
|
||||
'dd_client_can_pageout', 'dd_client_pressure', 'dd_client_pressure_result',
|
||||
'dd_session_pressure', 'dd_zram_has_room', 'dd_watch_nap', 'dd_zram_pick', 'dd_tier_note', 'dd_tier_readback'))
|
||||
functions = functions.replace('/proc/meminfo', str(self.root / 'meminfo'))
|
||||
functions = functions.replace('/proc/pressure/memory', str(self.root / 'pressure'))
|
||||
harness = '''
|
||||
set -u
|
||||
_dd_game=1 _dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_pushed=0 _dd_tier_back=0 _dd_tier_targets=() _dd_tier_swaps=() _dd_tier_starts=() _dd_pids=(999)
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_packed=-1
|
||||
rss=$((1536 * 1024)) swap=0 pushed=$((1024 * 1024)) alive="999 321 654" started=100 complete=1
|
||||
step() { :; }
|
||||
meminfo=''' + repr(str(self.root / 'meminfo')) + '''
|
||||
dd_game_focused() { [ "${focused:-1}" = 1 ]; }
|
||||
dd_proc_start() { _dd_start=; case " $alive " in *" $1 "*) _dd_start=$started; return 0 ;; esac; return 1; }
|
||||
nap() { echo "nap:$1"; }
|
||||
dd_session_others() { _dd_session=(321 654); }
|
||||
dd_zram_usage() { _dd_rss=$rss _dd_anon=${anon:-$rss} _dd_swap=$swap; }
|
||||
dd_zram_send() { echo "send:$1:$3"; rss=$((rss - pushed)); swap=$((swap + pushed)); next_available=${available_after:-$(( $(awk '/^MemAvailable:/ { print $2 }' "$meminfo") / 1024 + 128 ))}; sed -i "s/^MemAvailable:.*/MemAvailable: $((next_available * 1024)) kB/" "$meminfo"; _dd_pageout_complete=$complete; }
|
||||
''' + functions + '\ndd_memory_read\n' + body
|
||||
result = run_bash('NOW=0\n' + harness.replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_low_headroom_compresses_the_game_session_at_most_every_30_seconds(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=10; dd_session_pressure
|
||||
SECONDS=29; dd_session_pressure
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_pressure_policy_is_independent_of_ram_size(self):
|
||||
for total, expected in ((11264, ['send:1:session']), (12288, ['send:1:session']), (16384, ['send:1:session'])):
|
||||
with self.subTest(total=total):
|
||||
self.memory(total=total)
|
||||
self.assertEqual(expected, self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_large_device_with_real_headroom_does_not_reclaim(self):
|
||||
self.memory(total=16384, available=5120, psi='12.34')
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_large_device_with_psi_and_moderate_headroom_reclaims(self):
|
||||
self.memory(total=16384, available=3072, psi='1.23')
|
||||
self.assertEqual(['send:1:session'], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_a_fast_fall_on_a_large_device_reclaims_above_the_fixed_headroom(self):
|
||||
self.memory(total=15255, available=6176)
|
||||
falling = self.root / 'falling'
|
||||
falling.write_text(
|
||||
f'MemTotal: {15255 * 1024} kB\nMemAvailable: {5367 * 1024} kB\n'
|
||||
f'SwapTotal: {8192 * 1024} kB\nSwapFree: {6144 * 1024} kB\n')
|
||||
meminfo = self.root / 'meminfo'
|
||||
self.assertEqual(['send:1:session'], self.run_policy(
|
||||
f'cp {falling} {meminfo}\nSECONDS=5; dd_session_pressure'))
|
||||
|
||||
def test_a_fall_split_across_one_second_polls_still_reclaims(self):
|
||||
self.memory(total=15255, available=6300)
|
||||
steps = []
|
||||
for second, available in ((5, 6100), (6, 6020), (7, 5940), (8, 5860), (9, 5780)):
|
||||
sample = self.root / f'meminfo-{second}'
|
||||
sample.write_text(
|
||||
f'MemTotal: {15255 * 1024} kB\nMemAvailable: {available * 1024} kB\n'
|
||||
f'SwapTotal: {8192 * 1024} kB\nSwapFree: {6144 * 1024} kB\n')
|
||||
steps.append(f'cp {sample} {self.root / "meminfo"}; SECONDS={second}; dd_session_pressure')
|
||||
self.assertEqual(['send:1:session'], self.run_policy('\n'.join(steps)))
|
||||
|
||||
def test_no_game_does_not_compress_the_session(self):
|
||||
self.assertEqual([], self.run_policy('_dd_game=0; dd_session_pressure'))
|
||||
|
||||
def test_disabled_idle_compression_does_not_compress_the_session(self):
|
||||
self.assertEqual(['send:1:client'], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_disabled_idle_compression_signals_only_launcher_processes(self):
|
||||
sender = (function_source('dd_zram_send') + '\n' + function_source('dd_zram_finish')).replace('/tmp/.dd-zram', str(self.root / 'control'))
|
||||
self.assertEqual(['kill:-URG 999 998', 'mode:1'], self.run_policy('''
|
||||
_dd_pids=(999 998)
|
||||
kill() { echo "kill:$*"; }
|
||||
dd_zram_wait() { _dd_pageout_complete=1; }
|
||||
dd_zram_scan() { :; }
|
||||
''' + sender + '''
|
||||
DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure
|
||||
echo "mode:$(cat ''' + str(self.root / 'control') + ''')"
|
||||
'''))
|
||||
|
||||
def test_disabled_idle_compression_reclaims_only_the_launcher_before_focus(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('''
|
||||
DD_ZRAM_IDLE=0 focused=0
|
||||
dd_client_pressure
|
||||
dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_disabled_idle_compression_respects_launcher_setting_and_threshold(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual([], self.run_policy('DD_ZRAM_IDLE=0 DD_ZRAM_CLIENT=0; dd_client_pressure; dd_session_pressure'))
|
||||
self.memory(available=1900)
|
||||
self.assertEqual([], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_game_reclaim_requires_focus(self):
|
||||
self.assertEqual([], self.run_policy('focused=0; dd_session_pressure'))
|
||||
|
||||
def test_game_reclaim_runs_when_focus_is_unknown(self):
|
||||
launch = self.root / 'launch'
|
||||
(launch / 'agent').mkdir(parents=True)
|
||||
body = function_source('dd_game_focused') + f'\nDD_LAUNCH_DIR={launch} _dd_apps=7\n'
|
||||
self.assertEqual(['send:1:session'], self.run_policy(body + 'dd_session_pressure'))
|
||||
(launch / 'agent' / 'focus.json').write_text('{"focusedApp": 9}')
|
||||
self.assertEqual([], self.run_policy(body + 'dd_session_pressure'))
|
||||
self.assertEqual(['unfocused'], self.run_policy(body + 'dd_game_focused || echo unfocused'))
|
||||
(launch / 'agent' / 'focus.json').unlink()
|
||||
self.assertEqual(['unfocused'], self.run_policy(body + 'dd_game_focused || echo unfocused'))
|
||||
|
||||
def test_launcher_pressure_remains_available_on_larger_devices(self):
|
||||
self.memory(total=15360, available=1400)
|
||||
self.assertEqual(['send:1:client'], self.run_policy('DD_ZRAM_IDLE=0; dd_client_pressure; dd_session_pressure'))
|
||||
|
||||
def test_enough_available_memory_does_not_compress_even_with_stalls(self):
|
||||
self.memory(available=3072, psi='5.00')
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_stalls_with_moderate_headroom_compress_before_the_hard_limit(self):
|
||||
self.memory(available=2048, psi='1.50')
|
||||
self.assertEqual(['send:1:session'], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_moderate_headroom_without_stalls_waits(self):
|
||||
self.memory(available=2048)
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_same_second_memory_read_preserves_the_pressure_baseline(self):
|
||||
self.memory(available=2048)
|
||||
meminfo = self.root / 'meminfo'
|
||||
self.assertEqual(['1048576:524288:2097152'], self.run_policy(f'''
|
||||
SECONDS=100
|
||||
_dd_sample_at=100 _dd_sample_available=2097152 _dd_growth=0 _dd_fall=524288
|
||||
sed -i 's/MemAvailable: 2097152 kB/MemAvailable: 1048576 kB/' {meminfo}
|
||||
dd_memory_read
|
||||
echo "$_dd_available:$_dd_fall:$_dd_sample_available"
|
||||
'''))
|
||||
|
||||
def test_game_reading_back_most_of_a_pageout_skips_and_doubles_the_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:60',
|
||||
'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
pushed=$((512 * 1024))
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=$((swap / 4))
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=60; dd_session_pressure
|
||||
SECONDS=90; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=150; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_repeated_read_back_keeps_doubling_up_to_five_minutes(self):
|
||||
self.assertEqual(['backoff:300'], self.run_policy('''
|
||||
_dd_tier_backoff=240 _dd_tier_at=0 _dd_tier_targets=(999) _dd_tier_swaps=($((1024 * 1024))) _dd_tier_starts=(100) _dd_tier_pushed=$((1024 * 1024)) swap=0
|
||||
SECONDS=240; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_no_gain_pageout_doubles_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session', 'backoff:120'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=30; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_meaningful_available_gain_keeps_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:30', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
available_after=1300
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=1600
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_recovered_available_memory_resets_the_tier_wait(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'backoff:30', 'send:1:session'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=2000
|
||||
sed -i "s/^MemAvailable:.*/MemAvailable: 2048000 kB/" "$meminfo"
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
available_after=1024
|
||||
sed -i "s/^MemAvailable:.*/MemAvailable: 1048576 kB/" "$meminfo"
|
||||
SECONDS=60; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_critical_memory_still_compresses_after_a_no_gain_pass(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
available_after=512
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_a_no_gain_pass_still_skips_memory_the_game_read_back(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('''
|
||||
available_after=512
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_nearly_out_of_memory_ignores_the_backoff_but_keeps_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
_dd_tier_backoff=300
|
||||
SECONDS=0; dd_session_pressure
|
||||
SECONDS=20; dd_session_pressure
|
||||
SECONDS=30; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_nearly_out_of_memory_still_backs_off_when_the_game_reads_its_pageout_back(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
SECONDS=59; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure
|
||||
SECONDS=90; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_nearly_out_of_memory_retries_a_skipped_pageout_after_30_seconds(self):
|
||||
self.memory(available=512)
|
||||
self.assertEqual(['send:1:session', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
_dd_tier_backoff=300
|
||||
saved=$rss; rss=$((128 * 1024))
|
||||
SECONDS=330; dd_session_pressure
|
||||
rss=$saved
|
||||
SECONDS=359; dd_session_pressure
|
||||
SECONDS=360; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_small_swap_headroom_skips_the_pageout(self):
|
||||
self.memory(swap_free=1536, swap_total=2048)
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
def test_file_backed_resident_memory_does_not_consume_the_swap_budget(self):
|
||||
self.memory(swap_free=3088, swap_total=6144)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((1024 * 1024))
|
||||
dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_anonymous_memory_and_pending_client_still_need_the_full_swap_reserve(self):
|
||||
self.memory(swap_free=3088, swap_total=6144)
|
||||
self.assertEqual([], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((2048 * 1024))
|
||||
dd_session_pressure
|
||||
'''))
|
||||
self.assertEqual([], self.run_policy('''
|
||||
rss=$((4096 * 1024)) anon=$((1536 * 1024)) _dd_client_reserve=$((512 * 1024))
|
||||
dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_small_session_is_left_alone(self):
|
||||
self.assertEqual([], self.run_policy('rss=$((128 * 1024)); dd_session_pressure'))
|
||||
|
||||
def test_watch_polls_every_second_near_the_limit_and_stops_when_critical(self):
|
||||
self.memory(available=2560)
|
||||
self.assertEqual(['nap:1', 'nap:1', 'nap:1', 'nap:1', 'nap:1'], self.run_policy('dd_watch_nap'))
|
||||
self.memory(available=1024)
|
||||
self.assertEqual(['nap:1'], self.run_policy('_dd_available=$((2560 * 1024)); dd_watch_nap'))
|
||||
self.memory(available=4096)
|
||||
self.assertEqual(['nap:5'], self.run_policy('dd_watch_nap'))
|
||||
self.assertEqual(['nap:5'], self.run_policy('_dd_game=0; dd_watch_nap'))
|
||||
|
||||
def test_session_push_preserves_client_timestamps(self):
|
||||
self.assertEqual(['send:1:session', 'pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
dd_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
def test_launcher_compression_turned_off_keeps_the_launcher_out(self):
|
||||
self.assertEqual(['pids:321 654', 'client:-1:-1'], self.run_policy('''
|
||||
DD_ZRAM_CLIENT=0
|
||||
SECONDS=0; dd_session_pressure
|
||||
dd_zram_pick session; echo "pids:${_pids[*]}"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
''')[1:])
|
||||
|
||||
def test_low_ram_devices_compress_with_a_quarter_of_memory_left(self):
|
||||
self.memory(available=1700)
|
||||
self.assertEqual(['send:1:session'], self.run_policy('dd_session_pressure'))
|
||||
self.memory(available=1900)
|
||||
self.assertEqual([], self.run_policy('dd_session_pressure'))
|
||||
|
||||
|
||||
def test_a_compressed_process_that_exits_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
alive=""; swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_a_process_that_starts_after_a_pageout_is_not_in_its_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'targets:321 654', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "targets:${_dd_tier_targets[*]}"
|
||||
alive="999 1234"
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_read_back_wait_holds_above_the_critical_level(self):
|
||||
self.assertEqual(['send:1:session', 't:60', 'send:1:session'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
SECONDS=60; dd_session_pressure; echo t:60
|
||||
SECONDS=90; dd_session_pressure
|
||||
'''))
|
||||
|
||||
def test_a_no_gain_pageout_preserves_client_timestamps(self):
|
||||
self.assertEqual(['send:1:session', 'backoff:60', 'client:-1:-1'], self.run_policy('''
|
||||
available_after=1024
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
def test_an_incomplete_pageout_does_not_restart_the_launcher_wait(self):
|
||||
self.assertEqual(['send:1:session', 'client:-1:-1'], self.run_policy('''
|
||||
complete=0
|
||||
SECONDS=0; dd_session_pressure
|
||||
echo "client:$_dd_pressure_at:$_dd_packed"
|
||||
'''))
|
||||
|
||||
|
||||
def test_a_reused_process_id_is_not_counted_as_read_back(self):
|
||||
self.assertEqual(['send:1:session', 'send:1:session', 'backoff:30'], self.run_policy('''
|
||||
SECONDS=0; dd_session_pressure
|
||||
started=200; swap=0
|
||||
SECONDS=30; dd_session_pressure
|
||||
echo "backoff:$_dd_tier_backoff"
|
||||
'''))
|
||||
|
||||
def test_process_start_comes_from_stat_and_zombies_have_none(self):
|
||||
stat = self.root / 'stat'
|
||||
source = function_source('dd_proc_start').replace('/proc/$1/stat', str(stat))
|
||||
fields = ' '.join(['0'] * 17)
|
||||
for state, expected in (('S', ['ok:4242']), ('Z', ['gone:'])):
|
||||
with self.subTest(state=state):
|
||||
stat.write_text(f'77 (Wow (arm64).exe) {state} 1 {fields} 4242 99 0\n')
|
||||
result = run_bash(source + '\nif dd_proc_start 77; then echo "ok:$_dd_start"; else echo "gone:$_dd_start"; fi')
|
||||
self.assertEqual(expected, result.stdout.split())
|
||||
stat.unlink()
|
||||
result = run_bash(source + '\ndd_proc_start 77 || echo gone')
|
||||
self.assertEqual(['gone'], result.stdout.split())
|
||||
|
||||
|
||||
class ReclaimDispatchTest(unittest.TestCase):
|
||||
def run_cycle(self, client=1, game=1, anonymous=384, complete=1, reclaimed=128, body=None, available=1024, fall=0, tick=0):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
(root / 'meminfo').write_text(
|
||||
f'MemTotal: 7340032 kB\nMemAvailable: {available * 1024} kB\n'
|
||||
'SwapTotal: 6291456 kB\nSwapFree: 4194304 kB\n')
|
||||
(root / 'pressure').write_text('some avg10=0.00 avg60=0.00 avg300=0.00 total=0\n')
|
||||
names = ('dd_memory_read', 'dd_memory_tight', 'dd_memory_critical',
|
||||
'dd_zram_has_room', 'dd_client_can_pageout', 'dd_client_pressure',
|
||||
'dd_client_pressure_result', 'dd_client_pressure_finish',
|
||||
'dd_session_pressure', 'dd_zram_send', 'dd_zram_finish', 'dd_zram_pick')
|
||||
source = '\n'.join(function_source(name) for name in names)
|
||||
source = source.replace('/proc/meminfo', str(root / 'meminfo'))
|
||||
source = source.replace('/proc/pressure/memory', str(root / 'pressure'))
|
||||
source = source.replace('/tmp/.dd-zram', str(root / 'ctl'))
|
||||
monitor = SCRIPT.read_text()
|
||||
start = monitor.index(' _dd_preserved_growth=$_dd_growth', monitor.index('while kill -0 $$'))
|
||||
stop = monitor.index(' _dd_focus=1\n', start)
|
||||
cycle = monitor[start:stop] if body is None else body
|
||||
script = f'''
|
||||
set -u
|
||||
DD_ZRAM_CLIENT={client} _dd_game={game} _dd_pids=(123) _dd_others=(321)
|
||||
_dd_pressure_at=-1 _dd_pressure_backoff=30 _dd_packed=-1
|
||||
_dd_tier_at=-1 _dd_tier_backoff=30 _dd_tier_pushed=0
|
||||
_dd_client_reserve=0 client_rss=393216 client_anon={anonymous * 1024}
|
||||
step() {{ :; }}
|
||||
dd_session_others() {{ _dd_session=(321); }}
|
||||
dd_zram_scan() {{ _dd_pids=(456); }}
|
||||
nap() {{ echo "nap:$*:at:$NOW"; }}
|
||||
dd_zram_usage() {{
|
||||
if [ "$1" = 123 ]; then
|
||||
_dd_rss=$client_rss _dd_anon=$client_anon _dd_swap=0
|
||||
else
|
||||
_dd_rss=3145728 _dd_anon=1572864 _dd_swap=0
|
||||
fi
|
||||
}}
|
||||
kill() {{ echo "signal:$*:at:$NOW"; NOW=$((NOW + {tick})); }}
|
||||
dd_zram_wait() {{
|
||||
echo "wait:$*:at:$NOW"
|
||||
NOW=$((NOW + 12))
|
||||
_dd_pageout_complete={complete}
|
||||
[ "$1" != 123 ] || client_rss=$((client_rss - {reclaimed * 1024}))
|
||||
}}
|
||||
dd_tier_note() {{ :; }}
|
||||
dd_game_focused() {{ :; }}
|
||||
''' + source + f'''
|
||||
dd_memory_read
|
||||
_dd_fall={fall * 1024}
|
||||
''' + cycle + '''
|
||||
echo "client:$_dd_pressure_backoff:${_dd_client_reserve:-0}:${_dd_client_pending:-0}"
|
||||
def test_the_floor_follows_device_memory_within_limits(self):
|
||||
body = ''.join(self.sample(total=total) + 'dd_memory_read; echo $((_dd_floor / 1024))\n'
|
||||
for total in (3584, 7168, 15360))
|
||||
self.assertEqual(['640', '896', '1280'], self.run_policy(body))
|
||||
|
||||
def test_the_target_grows_with_how_fast_memory_is_falling(self):
|
||||
body = (self.sample(available=3000) + 'dd_memory_read; echo $_dd_rate $((_dd_target / 1024))\n' +
|
||||
self.sample(available=2800) + 'NOW=1; dd_memory_read; echo $((_dd_rate / 1024)) $((_dd_target / 1024))\n' +
|
||||
'NOW=2; dd_memory_read; echo $((_dd_rate / 1024)) $((_dd_target / 1024))\n' +
|
||||
self.sample(available=3400) + 'NOW=3; dd_memory_read; echo $((_dd_rate / 1024))\n')
|
||||
self.assertEqual(['0 896', '200 2896', '150 2396', '112'], self.run_policy(body))
|
||||
|
||||
def test_memory_the_monitor_freed_itself_does_not_hide_a_fall(self):
|
||||
body = (self.sample(available=2000) + 'dd_memory_read\n_dd_freed=$((300 * 1024))\n' +
|
||||
'NOW=2; dd_memory_read; echo $((_dd_rate / 1024)) $_dd_freed\n')
|
||||
self.assertEqual(['150 0'], self.run_policy(body))
|
||||
|
||||
def test_two_reads_in_the_same_second_keep_the_sample(self):
|
||||
body = (self.sample(available=2000) + 'dd_memory_read\n_dd_freed=4096\n' +
|
||||
self.sample(available=1000) + 'dd_memory_read; echo $_dd_rate $_dd_freed $_dd_sample_available\n')
|
||||
self.assertEqual([f'0 4096 {2000 * MB}'], self.run_policy(body))
|
||||
|
||||
def test_stall_time_becomes_a_share_of_the_interval(self):
|
||||
body = (self.sample(stall=1000) + 'dd_memory_read; echo $_dd_psi\n' +
|
||||
self.sample(stall=41000) + 'NOW=2; dd_memory_read; echo $_dd_psi\n' +
|
||||
'NOW=3; dd_memory_read; echo $_dd_psi\n')
|
||||
self.assertEqual(['0', '200', '0'], self.run_policy(body))
|
||||
|
||||
def test_room_counts_zram_only_and_keeps_a_reserve(self):
|
||||
body = (self.sample(zram=(6144, 1024)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(6144, 5632)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(0, 0), other=(4096, 1024)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(512, 0), other=(0, 0)) + 'dd_memory_read; echo $((_dd_swap_room / 1024))\n' +
|
||||
self.sample(zram=(0, 0), other=(4096, 1024)) + f'rm {self.root}/swaps\n' +
|
||||
'dd_memory_read; echo $((_dd_swap_room / 1024))\n')
|
||||
self.assertEqual(['4352', '-256', '-128', '384', '2560'], self.run_policy(body))
|
||||
|
||||
def test_memory_read_back_from_swap_is_remembered_for_half_a_minute(self):
|
||||
body = '_dd_page_kb=4\n' + ''.join(
|
||||
f'NOW={now}\n' + self.sample(swapped_in=total) + 'dd_memory_read; echo $((_dd_returned / 1024))\n'
|
||||
for now, total in ((0, 500), (1, 800), (2, 800), (16, 800), (17, None), (18, 900), (19, 1000), (60, 1000)))
|
||||
self.assertEqual(['0', '300', '290', '154', '149', '144', '239', '0'], self.run_policy(body))
|
||||
|
||||
def test_saving_comes_from_what_zram_really_stores(self):
|
||||
body = ''.join(self.sample(stored=stored) + 'dd_memory_read; echo $_dd_saving\n'
|
||||
for stored in (None, (32, 30), (1000, 250), (1000, 950), (1000, 20)))
|
||||
self.assertEqual(['600', '600', '750', '167', '833'], self.run_policy(body))
|
||||
|
||||
def need(self, available, rate=0, psi=0):
|
||||
return (self.sample(available=available) +
|
||||
f'dd_memory_read; _dd_rate=$(({rate} * 1024)) _dd_psi={psi}\n'
|
||||
'_dd_target=$((_dd_floor + _dd_rate * 10))\n'
|
||||
'dd_memory_need; echo $((_dd_need / 1024)) $((_dd_hard / 1024)) $_dd_force\n')
|
||||
|
||||
def test_steady_memory_above_the_floor_needs_nothing(self):
|
||||
self.assertEqual(['0 0 0'], self.run_policy(self.need(2000)))
|
||||
|
||||
def test_memory_under_the_floor_must_be_freed(self):
|
||||
self.assertEqual(['96 96 0'], self.run_policy(self.need(800)))
|
||||
|
||||
def test_a_slow_fall_is_met_ten_seconds_ahead(self):
|
||||
self.assertEqual(['196 0 0'], self.run_policy(self.need(1000, rate=30)))
|
||||
|
||||
def test_a_fast_fall_is_matched_once_memory_is_under_two_fifths(self):
|
||||
self.assertEqual(['0 0 0', '200 0 0', '0 0 0'],
|
||||
self.run_policy(self.need(2500, rate=20) + self.need(2500, rate=100) + self.need(4000, rate=100)))
|
||||
|
||||
def test_stalls_make_a_fall_urgent(self):
|
||||
self.assertEqual(['200 0 0', '200 200 0', '0 0 0'],
|
||||
self.run_policy(self.need(2500, rate=100) + self.need(2500, rate=100, psi=100) +
|
||||
self.need(2000, psi=900)))
|
||||
|
||||
def test_half_the_floor_forces(self):
|
||||
self.assertEqual(['446 446 0', '456 456 1'], self.run_policy(self.need(450) + self.need(440)))
|
||||
|
||||
RELIEVE = '''
|
||||
step() { echo "step:$*"; }
|
||||
dd_session_others() { echo others; _dd_session=(70 80); }
|
||||
dd_zram_trim() { echo "trim:$1:$(($2 / 1024)):${*:3}"; _dd_trimmed=${paged:-$2}; }
|
||||
relieve() { dd_memory_read; _dd_returned=${returned:-0}; _dd_rate=$((${2:-0} * 1024)) _dd_target=$((_dd_floor + ${2:-0} * 10240)); dd_memory_relieve; }
|
||||
_dd_pids=(10 20) _dd_game=1 _dd_focus=0 _dd_saving=500
|
||||
'''
|
||||
result = run_bash('NOW=0\n' + script.replace('SECONDS', 'NOW'))
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('', result.stderr)
|
||||
return result.stdout.splitlines()
|
||||
|
||||
def test_both_requests_are_sent_before_either_wait(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
|
||||
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'], self.run_cycle())
|
||||
def relieve(self, body):
|
||||
return self.run_policy(self.RELIEVE + body, 'dd_memory_relieve', 'dd_memory_note')
|
||||
|
||||
def test_disabled_client_is_never_signalled_or_waited_for(self):
|
||||
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(client=0))
|
||||
def test_a_fall_trims_the_client_behind_a_game_by_what_zram_gives_back(self):
|
||||
self.assertEqual(['trim:2:326:10 20', f'{196 * MB} {334506 * 600 // 1000} 334506'], self.relieve(
|
||||
self.sample(available=1000) + 'relieve 1000 30; echo $_dd_need $_dd_freed $_dd_client_out\n'))
|
||||
|
||||
def test_no_game_requests_nothing(self):
|
||||
self.assertEqual(['client:30:0:0'], self.run_cycle(game=0))
|
||||
def test_the_client_in_front_is_left_alone_until_memory_is_under_the_floor(self):
|
||||
self.assertEqual(['trim:2:160:10 20'], self.relieve(
|
||||
self.sample(available=1000) + '_dd_focus=1; relieve 1000 30\n' +
|
||||
self.sample(available=800) + 'relieve 800\n'))
|
||||
|
||||
def test_a_client_with_no_anonymous_pages_still_finishes_its_request(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:0',
|
||||
'wait:321:at:0', 'wait:123:at:12', 'client:30:0:0'],
|
||||
self.run_cycle(anonymous=0))
|
||||
def test_unknown_focus_still_trims_the_client(self):
|
||||
self.assertEqual(['trim:2:326:10 20'], self.relieve(self.sample(available=1000) + '_dd_focus=2; relieve 1000 30\n'))
|
||||
|
||||
def test_falling_headroom_survives_a_tick_between_requests(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'signal:-URG 321:at:1',
|
||||
'wait:321:at:2', 'wait:123:at:14', 'client:30:0:0'],
|
||||
self.run_cycle(available=2304, fall=512, tick=1))
|
||||
def test_the_client_is_not_trimmed_right_after_it_was_read_back(self):
|
||||
self.assertEqual(['trim:2:326:10 20'], self.relieve(
|
||||
self.sample(available=1000) + 'NOW=100 _dd_back_at=80; relieve 1000 30\nNOW=110; relieve 1000 30\n'))
|
||||
|
||||
def test_deferred_ineffective_reclaim_still_doubles_the_backoff(self):
|
||||
self.assertEqual('client:60:0:0', self.run_cycle(reclaimed=0)[-1])
|
||||
def test_without_a_game_only_the_floor_trims(self):
|
||||
self.assertEqual(['trim:2:160:10 20'], self.relieve(
|
||||
self.sample(available=1000) + '_dd_game=0 _dd_focus=1; relieve 1000 30\n' +
|
||||
self.sample(available=800) + 'relieve 800\n'))
|
||||
|
||||
def test_deferred_incomplete_reclaim_does_not_double_the_backoff(self):
|
||||
self.assertEqual('client:30:0:0', self.run_cycle(reclaimed=0, complete=0)[-1])
|
||||
def test_the_session_gives_what_the_client_could_not(self):
|
||||
self.assertEqual(['trim:2:660:10 20', 'others', 'trim:2:256:70 80', 'trim:2:660:10 20', 'trim:2:256:70 80'],
|
||||
self.relieve(self.sample(available=500) + f'paged={128 * MB}; relieve 500\nNOW=1; relieve 500\n'))
|
||||
|
||||
def test_explicit_combined_send_keeps_its_synchronous_wait(self):
|
||||
self.assertEqual(['signal:-URG 321 123:at:0', 'wait:321 123:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(body='dd_zram_send 1 cap game\n'))
|
||||
self.assertEqual(['signal:-URG 321:at:0', 'wait:321:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(client=0, body='dd_zram_send 1 cap game\n'))
|
||||
def test_the_session_gets_what_the_client_left_of_the_pass(self):
|
||||
self.assertEqual(['trim:3:1024:10 20', 'others', 'trim:3:24:70 80'], self.relieve(
|
||||
self.sample(available=100) + f'paged={1000 * MB}; relieve 100\n'))
|
||||
|
||||
def test_readback_keeps_its_synchronous_delay(self):
|
||||
self.assertEqual(['signal:-URG 123:at:0', 'nap:5:at:0', 'client:30:0:0'],
|
||||
self.run_cycle(body='dd_zram_send 0 readback client\n'))
|
||||
def test_memory_that_keeps_coming_back_is_taken_off_what_a_pass_may_move(self):
|
||||
self.assertEqual(['trim:2:660:10 20', 'others', 'trim:2:156:70 80', 'trim:2:660:10 20', 'trim:2:24:10 20'], self.relieve(
|
||||
self.sample(available=500) + f'paged={256 * MB}\nreturned={100 * MB}; relieve 500\n' +
|
||||
f'NOW=1 returned={300 * MB}; relieve 500\nNOW=2 returned={1000 * MB}; relieve 500\n'))
|
||||
|
||||
def test_usage_sums_anonymous_rss_and_falls_back_per_process(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
root = Path(directory)
|
||||
for pid, contents in ((123, 'VmRSS: 2000 kB\nRssAnon: 300 kB\nVmSwap: 100 kB\n'),
|
||||
(321, 'VmRSS: 4000 kB\nVmSwap: 200 kB\n'),
|
||||
(654, 'VmRSS: 1000 kB\nRssAnon: 0 kB\n')):
|
||||
(root / str(pid)).mkdir()
|
||||
(root / str(pid) / 'status').write_text(contents)
|
||||
source = function_source('dd_zram_usage').replace('/proc/', str(root) + '/')
|
||||
result = run_bash(source + '\ndd_zram_usage 123 321 654 > /dev/null; echo "$_dd_rss:$_dd_anon:$_dd_swap"')
|
||||
self.assertEqual(0, result.returncode, result.stderr)
|
||||
self.assertEqual('7000:4300:300', result.stdout.strip())
|
||||
def test_forcing_moves_memory_whatever_came_back(self):
|
||||
self.assertEqual(['trim:3:993:10 20', 'others', 'trim:3:993:70 80'], self.relieve(
|
||||
self.sample(available=300) + f'paged=0 returned={2048 * MB}; relieve 300\n'))
|
||||
|
||||
def test_the_session_is_scanned_again_after_a_new_process_scan(self):
|
||||
self.assertEqual(['others', 'others'], [line for line in self.relieve(
|
||||
self.sample(available=500) + f'paged={256 * MB}; relieve 500\n_dd_scan_at=5; relieve 500\n') if line == 'others'])
|
||||
|
||||
def test_forcing_ignores_heat_once_in_ten_seconds(self):
|
||||
lines = self.relieve(self.sample(available=300) + 'paged=0\nrelieve 300\nNOW=5; relieve 300\nNOW=10; relieve 300\n')
|
||||
self.assertEqual(['3', '3', '2', '2', '3', '3'], [line.split(':')[1] for line in lines if line.startswith('trim')])
|
||||
self.assertIn('trim:3:993:70 80', lines)
|
||||
|
||||
def trims(self, body):
|
||||
return [line.split(':')[2] for line in self.relieve(body) if line.startswith('trim') and line.endswith('10 20')]
|
||||
|
||||
def test_passes_that_free_little_come_further_and_further_apart(self):
|
||||
passes = ''.join(f'NOW={now}; relieve 500; echo at:{now}\n' for now in (0, 4, 5, 14, 15, 34, 35))
|
||||
lines = self.relieve(self.sample(available=500) + f'paged={8 * MB}\n' + passes)
|
||||
self.assertEqual(['0', '5', '15', '35'],
|
||||
[after.split(':')[1] for line, after in zip(lines, lines[1:] + ['']) if line == 'trim:2:256:70 80'])
|
||||
|
||||
def test_the_wait_between_passes_stops_at_a_minute(self):
|
||||
self.assertEqual(['60 195'], self.relieve(
|
||||
self.sample(available=500) + f'paged={8 * MB}\nfor NOW in 0 5 15 35 75 135; do relieve 500; done > /dev/null\n'
|
||||
'echo $_dd_rest $_dd_rest_until\n'))
|
||||
|
||||
def test_a_pass_that_frees_enough_is_followed_at_once(self):
|
||||
self.assertEqual(['660', '660'], self.trims(
|
||||
self.sample(available=500) + f'paged={128 * MB}; relieve 500\nNOW=1; relieve 500\n'))
|
||||
|
||||
def test_memory_that_keeps_falling_ends_the_wait(self):
|
||||
self.assertEqual(['326', '526'], self.trims(
|
||||
self.sample(available=700) + f'paged={8 * MB}; relieve 700\nNOW=1; relieve 700\n' +
|
||||
self.sample(available=600) + 'NOW=2; relieve 600\n' + self.sample(available=580) + 'NOW=3; relieve 580\n'))
|
||||
|
||||
def test_forcing_does_not_wait(self):
|
||||
self.assertEqual(['993', '993'], self.trims(
|
||||
self.sample(available=300) + 'paged=0\nrelieve 300\nNOW=1; relieve 300\n'))
|
||||
|
||||
def test_the_wait_is_forgotten_once_memory_is_back(self):
|
||||
self.assertEqual(['660', '660'], self.trims(
|
||||
self.sample(available=500) + f'paged={8 * MB}; relieve 500\n' +
|
||||
self.sample(available=3000) + 'NOW=1; relieve 3000\n' + self.sample(available=500) + 'NOW=2; relieve 500\n'))
|
||||
|
||||
def test_trims_stop_at_the_room_zram_has(self):
|
||||
self.assertEqual(['trim:2:100:10 20', 'step:memory: available 800 MB and zRAM has no room left'], self.relieve(
|
||||
self.sample(available=800, zram=(6144, 5276)) + 'relieve 800\n' +
|
||||
self.sample(available=800, zram=(6144, 5400)) + 'relieve 800\nNOW=30; relieve 800\n'))
|
||||
|
||||
def test_small_trims_are_not_logged(self):
|
||||
self.assertEqual(['step:memory: available 1000 MB, falling 30 MB/s, compressed 20 MB of the client and 0 MB of the session'],
|
||||
[line for line in self.relieve(
|
||||
self.sample(available=1000) + f'paged={10 * MB}\nrelieve 1000 30; dd_memory_note\n'
|
||||
'NOW=1; relieve 1000 30; dd_memory_note\nNOW=2; dd_memory_note\n')
|
||||
if line.startswith('step')])
|
||||
|
||||
TRIM = '''
|
||||
declare -A anon=() reply=() born=()
|
||||
nap() { :; }
|
||||
dd_pid_key() { _dd_key=$1.${born[$1]:-0}; }
|
||||
dd_zram_usage() { _dd_anon=${anon[$1]}; }
|
||||
kill() {
|
||||
echo "signal:$2:$(< "$ROOT/ctl")"
|
||||
case ${reply[$2]} in
|
||||
deaf) ;;
|
||||
gone) return 1 ;;
|
||||
*) printf %s "${reply[$2]}" > "$ROOT/ctl.trim.$2" ;;
|
||||
esac
|
||||
}
|
||||
'''
|
||||
|
||||
def trim(self, body):
|
||||
return self.run_policy(f'ROOT={self.root}\n' + self.TRIM + body + '\nls "$ROOT"; cat "$ROOT/ctl"', 'dd_memory_relieved', 'dd_zram_trim')
|
||||
|
||||
def test_a_trim_spends_its_budget_across_processes_in_order(self):
|
||||
self.assertEqual(['signal:10:2 100000', 'signal:20:2 60000', '100000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000 [30]=500000) reply=([10]=40000 [20]=60000 [30]=1)
|
||||
dd_zram_trim 2 100000 10 20 30
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_trim_skips_small_and_gone_processes_and_stops_when_little_is_left(self):
|
||||
self.assertEqual(['signal:20:3 50000', 'signal:30:3 50000', 'signal:40:3 50000', '47000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=4096 [20]=500000 [30]=500000 [40]=500000 [50]=500000) reply=([20]=gone [30]=0 [40]=47000 [50]=1)
|
||||
dd_zram_trim 3 50000 10 20 30 40 50
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_process_that_never_answers_is_left_alone_for_a_minute(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:20:2 9000', '500', 'signal:20:2 9000', 'signal:10:2 9000',
|
||||
'signal:20:2 9000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=deaf [20]=500)
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed
|
||||
NOW=59 _dd_pass_at=59; dd_zram_trim 2 9000 10 20
|
||||
NOW=60 _dd_pass_at=60; dd_zram_trim 2 9000 10 20'''))
|
||||
|
||||
def test_a_new_process_with_a_silent_ones_number_is_asked(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:10:2 9000', '1', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000) reply=([10]=deaf)
|
||||
dd_zram_trim 2 9000 10
|
||||
NOW=5 _dd_pass_at=5; dd_zram_trim 2 9000 10
|
||||
born[10]=7
|
||||
dd_zram_trim 2 9000 10
|
||||
NOW=62 _dd_pass_at=62 anon=(); dd_zram_trim 2 9000
|
||||
echo ${#_dd_deaf[@]}'''))
|
||||
|
||||
def test_one_pass_waits_five_seconds_in_all(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'signal:20:2 9000', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000 [30]=500000) reply=([10]=- [20]=deaf [30]=deaf)
|
||||
_dd_polls=215
|
||||
dd_zram_trim 2 9000 10
|
||||
dd_zram_trim 2 9000 20 30'''))
|
||||
|
||||
def test_one_pass_ends_six_seconds_after_it_began_however_slow_the_polls(self):
|
||||
self.assertEqual(['signal:10:2 9000', '6', 'ctl', '2 0'], self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=deaf [20]=500)
|
||||
nap() { NOW=$((NOW + 1)); }
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_polls'''))
|
||||
|
||||
def test_a_trim_stops_once_memory_is_back_where_it_should_be(self):
|
||||
self.assertEqual(['signal:10:2 9000', '500', 'signal:10:2 9000', 'signal:20:2 8500', '1000', 'ctl', 'meminfo', '2 0'],
|
||||
self.trim('''
|
||||
anon=([10]=500000 [20]=500000) reply=([10]=500 [20]=500)
|
||||
available() { echo "MemAvailable: $1 kB" > "$ROOT/meminfo"; }
|
||||
signal=$(declare -f kill)
|
||||
eval "raw_${signal}"
|
||||
kill() { raw_kill "$@"; available $((after)); }
|
||||
available 800000
|
||||
_dd_goal=900000 after=900000
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed
|
||||
available 800000
|
||||
after=899999
|
||||
dd_zram_trim 2 9000 10 20
|
||||
echo $_dd_trimmed'''))
|
||||
|
||||
def test_a_held_control_file_keeps_its_acknowledgements(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'ctl', 'ctl.hold', 'ctl.trim.10', '2 9000'], self.trim('''
|
||||
anon=([10]=500000)
|
||||
kill() { echo "signal:$2:$(< "$ROOT/ctl")"; : > "$ROOT/ctl.hold"; printf 1 > "$ROOT/ctl.trim.$2"; }
|
||||
dd_zram_trim 2 9000 10'''))
|
||||
|
||||
def test_a_trim_leaves_the_acknowledgement_of_a_suspend_page_out_alone(self):
|
||||
self.assertEqual(['signal:10:2 9000', 'ctl', 'ctl.ack.10', '2 0'], self.trim('''
|
||||
anon=([10]=500000) reply=([10]=9000)
|
||||
: > "$ROOT/ctl.ack.10"
|
||||
dd_zram_trim 2 9000 10'''))
|
||||
|
||||
READBACK = '''
|
||||
step() { echo "step:$*"; }
|
||||
kill() { echo "signal:$*:$(< "$ROOT/ctl")"; }
|
||||
dd_zram_usage() { _dd_swap=$((swap * 1024)); }
|
||||
back() { dd_memory_read; _dd_rate=0 _dd_target=$_dd_floor; dd_client_readback; }
|
||||
_dd_pids=(10 20) _dd_game=0 _dd_client_out=4096 _dd_trim_at=0 swap=400 NOW=30
|
||||
'''
|
||||
|
||||
def readback(self, body):
|
||||
return self.run_policy(f'ROOT={self.root}\n' + self.READBACK + body, 'dd_client_readback')
|
||||
|
||||
def test_the_client_is_read_back_once_memory_can_hold_it_with_a_floor_to_spare(self):
|
||||
self.assertEqual(['step:memory: available 2192 MB, reading 400 MB of the client back', 'signal:-URG 10 20:0',
|
||||
f'0 {-400 * MB * 600 // 1000} 30'], self.readback(
|
||||
self.sample(available=2191) + 'back\n' + self.sample(available=2192) + 'back\n' +
|
||||
'echo $_dd_client_out $_dd_freed $_dd_back_at\nback\n'))
|
||||
|
||||
def test_nothing_is_read_back_right_after_a_trim(self):
|
||||
self.assertEqual([], self.readback(self.sample(available=4000) + 'NOW=29; back\n'))
|
||||
|
||||
def test_a_running_game_keeps_the_client_compressed_until_the_client_is_in_front(self):
|
||||
self.assertEqual(['signal:-URG 10 20:0'], [line for line in self.readback(
|
||||
self.sample(available=4000) + '_dd_game=1\nback\n_dd_away=27; back\n_dd_away=25; back\n')
|
||||
if line.startswith('signal')])
|
||||
|
||||
def test_a_client_the_kernel_already_brought_back_needs_no_request(self):
|
||||
self.assertEqual(['0'], self.readback(self.sample(available=4000) + 'swap=8; back; echo $_dd_client_out\n'))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
@@ -60,6 +60,19 @@ static long status(const char *key) {
|
||||
return v;
|
||||
}
|
||||
|
||||
static long resident(char *start, size_t size) {
|
||||
long page = sysconf(_SC_PAGESIZE), kb = 0;
|
||||
int fd = open("/proc/self/pagemap", O_RDONLY);
|
||||
if (fd < 0) exit(8);
|
||||
for (size_t i = 0; i < size; i += page) {
|
||||
uint64_t entry;
|
||||
if (pread(fd, &entry, sizeof(entry), ((uintptr_t)start + i) / page * sizeof(entry)) != sizeof(entry)) exit(8);
|
||||
if (entry >> 63) kb += page / 1024;
|
||||
}
|
||||
close(fd);
|
||||
return kb;
|
||||
}
|
||||
|
||||
static void send_request(char mode) {
|
||||
int fd = open(ctl, O_WRONLY | O_TRUNC);
|
||||
if (fd < 0 || write(fd, &mode, 1) != 1) exit(3);
|
||||
@@ -91,6 +104,25 @@ static void request(char mode) {
|
||||
usleep(1000000);
|
||||
}
|
||||
|
||||
static long trim(char mode, long kb) {
|
||||
char ack[256], text[32];
|
||||
snprintf(ack, sizeof(ack), "%s.trim.%d", ctl, getpid());
|
||||
unlink(ack);
|
||||
FILE *f = fopen(ctl, "w");
|
||||
if (!f) exit(3);
|
||||
fprintf(f, "%c %ld\n", mode, kb);
|
||||
fclose(f);
|
||||
kill(getpid(), SIGURG);
|
||||
for (int i = 0; i < 1200; i++) {
|
||||
f = fopen(ack, "r");
|
||||
char *line = f ? fgets(text, sizeof(text), f) : NULL;
|
||||
if (f) fclose(f);
|
||||
if (line) return atol(text);
|
||||
usleep(10000);
|
||||
}
|
||||
exit(5);
|
||||
}
|
||||
|
||||
static uint64_t sum(const unsigned char *p, size_t n) {
|
||||
uint64_t s = 0;
|
||||
for (size_t i = 0; i < n; i += 64) s = s * 31 + p[i];
|
||||
@@ -167,6 +199,80 @@ int main(int argc, char **argv) {
|
||||
int status_code;
|
||||
waitpid(child, &status_code, 0);
|
||||
printf("childack %d\n", WIFEXITED(status_code) && WEXITSTATUS(status_code) == 0);
|
||||
} else if (!strcmp(argv[4], "trim")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
printf("first %ld\n", trim('2', 8192));
|
||||
printf("second %ld\n", trim('2', 8192));
|
||||
printf("swapped %ld\n", status("VmSwap:"));
|
||||
printf("rest %ld\n", trim('2', 1L << 30));
|
||||
printf("touched %d\n", sum(shared, size) != 0);
|
||||
printf("hot %ld\n", trim('2', 1L << 30));
|
||||
printf("forced %ld\n", trim('3', 1L << 30));
|
||||
request('0');
|
||||
printf("again %ld\n", trim('2', 1L << 30));
|
||||
printf("intact %d\n", sum(data, size) == before);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-small")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
long total = 0, largest = 0;
|
||||
for (int i = 0; i < 112; i++) {
|
||||
long step = trim('2', 512);
|
||||
total += step;
|
||||
if (step > largest) largest = step;
|
||||
}
|
||||
printf("small %ld\n", total);
|
||||
printf("largest %ld\n", largest);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-sparse")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
size_t wide = 32UL << 20;
|
||||
char *thin = mmap(NULL, wide, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
|
||||
if (thin == MAP_FAILED) exit(7);
|
||||
for (size_t i = 0; i < wide; i += 2 * page) thin[i] = 1;
|
||||
printf("sparse %ld\n", resident(thin, wide));
|
||||
for (int i = 0; i < 240; i++) trim('2', 512);
|
||||
printf("kept %ld\n", resident(thin, wide));
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "hold")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
char hold[256];
|
||||
snprintf(hold, sizeof(hold), "%s.hold", ctl);
|
||||
FILE *f = fopen(hold, "w");
|
||||
if (!f) exit(3);
|
||||
fclose(f);
|
||||
printf("empty %ld\n", trim('2', 512));
|
||||
f = fopen(hold, "w");
|
||||
if (!f) exit(3);
|
||||
fputs("1", f);
|
||||
fclose(f);
|
||||
f = fopen(ctl, "w");
|
||||
if (!f) exit(3);
|
||||
fputs("2 512\n", f);
|
||||
fclose(f);
|
||||
kill(getpid(), SIGURG);
|
||||
wait_ack();
|
||||
printf("held %ld\n", status("VmSwap:"));
|
||||
unlink(hold);
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "trim-fork")) {
|
||||
stop = 1;
|
||||
for (int i = 0; i < 2; i++) pthread_join(t[i], NULL);
|
||||
fflush(stdout);
|
||||
pid_t child = fork();
|
||||
if (child < 0) exit(6);
|
||||
if (child == 0) {
|
||||
for (size_t i = 0; i < size; i += page) data[i]++;
|
||||
printf("inline_trim %ld\n", trim('2', 1L << 30));
|
||||
fflush(stdout);
|
||||
_exit(0);
|
||||
}
|
||||
waitpid(child, NULL, 0);
|
||||
printf("worker_trim %ld\n", trim('2', 1L << 30));
|
||||
return 0;
|
||||
} else if (!strcmp(argv[4], "burst")) {
|
||||
send_request('0');
|
||||
usleep(10000);
|
||||
@@ -280,8 +386,9 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
|
||||
def setUp(self):
|
||||
self.ctl.write_text("0")
|
||||
for ack in self.dir.glob("ctl.ack.*"):
|
||||
for ack in [*self.dir.glob("ctl.ack.*"), *self.dir.glob("ctl.trim.*")]:
|
||||
ack.unlink()
|
||||
(self.dir / "ctl.hold").unlink(missing_ok=True)
|
||||
|
||||
def run_program(self, program=None, mb=48, cycles=1, *extra):
|
||||
environment = dict(os.environ, LD_PRELOAD=str(self.lib))
|
||||
@@ -347,7 +454,9 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
os.kill(process.pid, signal.SIGURG)
|
||||
os.kill(process.pid, signal.SIGUSR1)
|
||||
self.assertEqual(f"received {_ + 1}", process.stdout.readline().strip())
|
||||
output, _ = process.communicate(timeout=10)
|
||||
process.stdin.close()
|
||||
process.wait(timeout=10)
|
||||
output = process.stdout.read()
|
||||
values = dict(line.split() for line in output.splitlines())
|
||||
self.assertNotEqual(0, int(values["urg"]))
|
||||
self.assertNotEqual(0, int(values["usr"]))
|
||||
@@ -388,6 +497,50 @@ class ZramPreloadTest(unittest.TestCase):
|
||||
out = self.run_program(None, 48, 0, "fork")
|
||||
self.assertEqual([1], out["childack"])
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_trim_stops_at_its_budget_and_continues_where_it_stopped(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertTrue(7168 < out["first"][0] <= 8192, out)
|
||||
self.assertTrue(7168 < out["second"][0] <= 8192, out)
|
||||
self.assertGreater(out["swapped"][0], 15 * 1024)
|
||||
self.assertGreater(out["rest"][0], 40 * 1024)
|
||||
self.assertEqual([1], out["intact"])
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_trim_leaves_memory_that_came_straight_back(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertLess(out["hot"][0], 4 * 1024, out)
|
||||
self.assertGreater(out["forced"][0], 28 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_requested_read_back_does_not_count_as_heat(self):
|
||||
out = self.run_program(None, 32, 0, "trim")
|
||||
self.assertTrue(28 * 1024 < out["again"][0] < 40 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_budgets_smaller_than_a_chunk_still_reach_all_of_it(self):
|
||||
out = self.run_program(None, 32, 0, "trim-small")
|
||||
self.assertLessEqual(out["largest"][0], 512)
|
||||
self.assertGreater(out["small"][0], 52 * 1024)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_small_budgets_reach_the_end_of_a_thinly_used_chunk(self):
|
||||
out = self.run_program(None, 8, 0, "trim-sparse")
|
||||
self.assertEqual([16 * 1024], out["sparse"])
|
||||
self.assertLess(out["kept"][0], 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_a_request_in_the_hold_file_wins_over_the_control_file(self):
|
||||
out = self.run_program(None, 32, 0, "hold")
|
||||
self.assertTrue(0 < out["empty"][0] <= 512, out)
|
||||
self.assertGreater(out["held"][0], 40 * 1024, out)
|
||||
|
||||
@unittest.skipUnless(swap_total_kb() > 256 * 1024, "needs swap")
|
||||
def test_process_without_a_worker_trims_in_small_steps(self):
|
||||
out = self.run_program(None, 48, 0, "trim-fork")
|
||||
self.assertTrue(16 * 1024 < out["inline_trim"][0] <= 32 * 1024, out)
|
||||
self.assertGreater(out["worker_trim"][0], 64 * 1024, out)
|
||||
|
||||
def test_worker_acknowledges_back_to_back_requests(self):
|
||||
out = self.run_program(None, 48, 0, "burst")
|
||||
self.assertEqual([1], out["burstack"])
|
||||
|
||||
Reference in new issue
Block a user