fix: preserve GPU stats while pinning clocks (#1416)

Enabling GPU clock pinning froze Thor's kernel utilization counters,
leaving the HUD stuck at an arbitrary value (10–11% in the reproduced
sessions). KGSL_PROP_PWRCTRL disables both the governor and its
utilization sampling.

Use a dedicated KGSL context with a maximum-power constraint, renewed by
a small NOP submission every 25 ms. Keep devfreq running, bound the
queue to one submission, and release the context, mapped command buffer
and GPU allocation on stop or failure. Preserve recovery of legacy
global pins and report native setup failures instead of claiming
success.

Validation:
- AYN Thor: reproduced frozen counters with the old pin. The replacement
native implementation, run as a standalone ARM64 harness alongside the
installed Steam/Bulletstorm session, kept 680 MHz while utilization
changed from 17% in Steam to about 4% loading and 44% at the animated
title. A final-source smoke run also returned changing 60–66% samples at
680 MHz.
- Native lifecycle regression passed on Linux and as an ARM64 executable
on Thor: setup failure cleanup, renewal, bounded queue, runtime failure,
restart, and type-3/type-7 NOP selection for older/newer Adreno cores.
- Android native build and Kotlin compilation passed locally (NDK
27.0.12077973).
- CI build, Android tests, native regressions, and signing passed.
Installed the release-signed PR APK on Thor with app data preserved.
With GPU pin enabled, the normal Steam/Bulletstorm session held 680 MHz
while the HUD changed from 3% loading to 53% in the animated game scene
at 60 FPS; raw gpubusy samples also continued changing. This checks
utilization reporting, not long-term gameplay stability.

The earlier session exit was recorded by Android as LOW_MEMORY; this PR
addresses the utilization freeze.
This commit is contained in:
Kurt Himebauch authored and GitHub committed 2026-10-23 15:41:12 -04:00
commit 2d59f03e7b
7 files changed
+404 -2

No files matched your search

@@ -8,6 +8,7 @@ add_library(droiddeckwayland SHARED
src/sc_layer.c
src/ahb_swapchain.c
src/waylandcomp_jni.c
src/gpu_clock_pin.c
src/droiddeck_ext.c
src/wl_dmabuf.c
src/wl_clipboard.c
@@ -0,0 +1,170 @@
#include "gpu_clock_pin.h"
#include <android/log.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdatomic.h>
#include <stdint.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <unistd.h>
#include "../../adrenotools/src/hook/kgsl.h"
static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_t worker;
static bool joinable;
static atomic_bool running;
struct pin {
int fd;
unsigned int context;
unsigned int memory;
unsigned int timestamp;
unsigned long gpuaddr;
uint32_t nop;
void *commands;
size_t size;
};
static struct pin pin = { .fd = -1 };
static void release_pin(void) {
if (pin.context) {
struct kgsl_drawctxt_destroy destroy = { .drawctxt_id = pin.context };
ioctl(pin.fd, IOCTL_KGSL_DRAWCTXT_DESTROY, &destroy);
}
if (pin.commands) munmap(pin.commands, pin.size);
if (pin.memory) {
struct kgsl_gpumem_free_id free_memory = { .id = pin.memory };
ioctl(pin.fd, IOCTL_KGSL_GPUMEM_FREE_ID, &free_memory);
}
if (pin.fd >= 0) close(pin.fd);
pin = (struct pin) { .fd = -1 };
}
static bool submit_pin(void) {
struct kgsl_command_object object = {
.gpuaddr = pin.gpuaddr,
.size = 2 * sizeof(uint32_t),
.flags = KGSL_CMDLIST_IB,
.id = pin.memory,
};
struct kgsl_gpu_command command = {
.flags = KGSL_CMDBATCH_PWR_CONSTRAINT,
.cmdlist = (uintptr_t)&object,
.cmdsize = sizeof(object),
.numcmds = 1,
.context_id = pin.context,
};
if (ioctl(pin.fd, IOCTL_KGSL_GPU_COMMAND, &command) < 0) return false;
pin.timestamp = command.timestamp;
return true;
}
static bool prepare_pin(void) {
pin.fd = open("/dev/kgsl-3d0", O_RDWR | O_CLOEXEC);
if (pin.fd < 0) return false;
struct kgsl_devinfo info = {0};
struct kgsl_device_getproperty device_info = {
.type = KGSL_PROP_DEVICE_INFO, .value = &info, .sizebytes = sizeof(info),
};
if (ioctl(pin.fd, IOCTL_KGSL_DEVICE_GETPROPERTY, &device_info) < 0) return false;
unsigned int core = info.chip_id >> 24;
if (!core) core = info.gpu_id / 100;
if (core < 3) { errno = ENODEV; return false; }
pin.nop = core >= 5 ? 0x70100001 : 0xc0001000;
struct kgsl_drawctxt_create context = {
.flags = KGSL_CONTEXT_NO_GMEM_ALLOC | KGSL_CONTEXT_PREAMBLE | KGSL_CONTEXT_PWR_CONSTRAINT,
};
if (ioctl(pin.fd, IOCTL_KGSL_DRAWCTXT_CREATE, &context) < 0) return false;
pin.context = context.drawctxt_id;
struct kgsl_device_constraint_pwrlevel level = { .level = KGSL_CONSTRAINT_PWR_MAX };
struct kgsl_device_constraint constraint = {
.type = KGSL_CONSTRAINT_PWRLEVEL,
.context_id = pin.context,
.data = &level,
.size = sizeof(level),
};
struct kgsl_device_getproperty property = {
.type = KGSL_PROP_PWR_CONSTRAINT,
.value = &constraint,
.sizebytes = sizeof(constraint),
};
if (ioctl(pin.fd, IOCTL_KGSL_SETPROPERTY, &property) < 0) return false;
struct kgsl_gpumem_alloc_id memory = { .size = 4096 };
if (ioctl(pin.fd, IOCTL_KGSL_GPUMEM_ALLOC_ID, &memory) < 0) return false;
pin.memory = memory.id;
pin.gpuaddr = memory.gpuaddr;
pin.size = memory.mmapsize;
void *commands = mmap(NULL, pin.size, PROT_READ | PROT_WRITE, MAP_SHARED, pin.fd,
(off_t)pin.memory << 12);
if (commands == MAP_FAILED) return false;
pin.commands = commands;
// A3xx/A4xx use type-3 CP_NOP; newer cores use type-7 with zero odd-parity bits.
uint32_t *words = commands;
words[0] = pin.nop;
words[1] = 0;
struct kgsl_gpumem_sync_cache sync = { .id = pin.memory, .op = KGSL_GPUMEM_CACHE_CLEAN };
if (ioctl(pin.fd, IOCTL_KGSL_GPUMEM_SYNC_CACHE, &sync) < 0) return false;
return submit_pin();
}
static void *hold_pin(void *unused) {
(void)unused;
while (atomic_load(&running)) {
struct kgsl_device_waittimestamp_ctxtid wait = {
.context_id = pin.context,
.timestamp = pin.timestamp,
.timeout = 100,
};
if (ioctl(pin.fd, IOCTL_KGSL_DEVICE_WAITTIMESTAMP_CTXTID, &wait) < 0) {
if (errno == EINTR || errno == ETIMEDOUT) continue;
break;
}
// Constraints expire after idle_timer (normally 80 ms); renew with a NOP, keeping devfreq alive.
usleep(25000);
if (atomic_load(&running) && !submit_pin()) break;
}
if (atomic_exchange(&running, false))
__android_log_print(ANDROID_LOG_WARN, "GpuClockPin", "constraint stopped: %s", strerror(errno));
release_pin();
return NULL;
}
bool gpu_clock_pin_set(bool on) {
pthread_mutex_lock(&lock);
if (joinable) {
if (on && atomic_load(&running)) {
pthread_mutex_unlock(&lock);
return true;
}
atomic_store(&running, false);
pthread_join(worker, NULL);
joinable = false;
}
bool ok = true;
if (on) {
ok = prepare_pin();
if (ok) {
atomic_store(&running, true);
int error = pthread_create(&worker, NULL, hold_pin, NULL);
if (error) {
atomic_store(&running, false);
errno = error;
ok = false;
} else {
joinable = true;
}
}
if (!ok) {
int error = errno;
release_pin();
errno = error;
}
}
pthread_mutex_unlock(&lock);
return ok;
}
@@ -0,0 +1,5 @@
#pragma once
#include <stdbool.h>
bool gpu_clock_pin_set(bool on);
@@ -16,6 +16,7 @@
#include "effects_chain.h"
#include "cardboard.h"
#include "droiddeck_color.h"
#include "gpu_clock_pin.h"
extern int droiddeck_wayland_run(void);
extern void droiddeck_wayland_set_scale_mode(int mode, int alignment);
@@ -634,8 +635,14 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeTextInputDelete(JNIE
extern void adrenotools_set_turbo(bool turbo);
JNIEXPORT void JNICALL
Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetGpuTurbo(JNIEnv *env, jclass clazz, jboolean on) {
(void)env; (void)clazz;
adrenotools_set_turbo(on == JNI_TRUE);
(void)clazz;
if (!gpu_clock_pin_set(on == JNI_TRUE)) {
int saved_errno = errno;
jclass error = (*env)->FindClass(env, "java/lang/IllegalStateException");
if (error) (*env)->ThrowNew(env, error, strerror(saved_errno));
}
// Clear a legacy global pin when recovering its marker after an app upgrade or crash.
if (on != JNI_TRUE) adrenotools_set_turbo(false);
}
JNIEXPORT jint JNICALL