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:
MaxsTechReview authored and GitHub committed 2026-11-18 21:58:57 -05:00
1 parent 123c431b8e
commit adf13d0bdd
60 files changed
+1117 -2264

No files matched your search

+1 -2
View File
@@ -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
View File
@@ -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;
}
-32
View File
@@ -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
-154
View File
@@ -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
View File
@@ -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;
+1 -2
View File
@@ -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',
+49 -198
View File
@@ -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()
-17
View File
@@ -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
View File
@@ -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__':
+155 -2
View File
@@ -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"])