IOSurfacePool debug stats logging

Author: j-mie

rlawt.h

@@ -58,6 +58,19 @@ typedef struct {
 	int count; // entries currently allocated (0..RLAWT_MAX_POOL)
 	int back;  // current render target index
 	int front; // most recently presented surface index
+
+	// debug stats (reset every 60s)
+	struct {
+		int swaps;
+		int allocs;
+		int reuses;
+		int recycles;
+		int grows;
+		int evictions;
+		int failures;
+		int highWater;
+	} stats;
+	CFAbsoluteTime lastLogTime;
 } IOSurfacePool;
 #endif
 

rlawt_mac.m

@@ -122,6 +122,8 @@ static void poolInit(IOSurfacePool *pool) {
 	pool->count = 0;
 	pool->back = 0;
 	pool->front = 0;
+	memset(&pool->stats, 0, sizeof(pool->stats));
+	pool->lastLogTime = CFAbsoluteTimeGetCurrent();
 }
 
 static void poolDestroy(IOSurfacePool *pool) {
@@ -212,6 +214,7 @@ static int poolNextBack(IOSurfacePool *pool, CALayer *layer) {
 	for (int i = 0; i < pool->count; i++) {
 		if (i == pool->front) continue;
 		if (poolSurfaceMatchesSize(pool, i, layer) && !IOSurfaceIsInUse(pool->entries[i].surface)) {
+			pool->stats.reuses++;
 			return i;
 		}
 	}
@@ -220,23 +223,53 @@ static int poolNextBack(IOSurfacePool *pool, CALayer *layer) {
 	for (int i = 0; i < pool->count; i++) {
 		if (i == pool->front) continue;
 		if (pool->entries[i].surface && !IOSurfaceIsInUse(pool->entries[i].surface)) {
+			pool->stats.recycles++;
 			return i;
 		}
 	}
 
 	// Grow pool if nothing was available
 	if (pool->count < RLAWT_MAX_POOL) {
-		return pool->count++;
+		int idx = pool->count++;
+		pool->stats.grows++;
+		if (pool->count > pool->stats.highWater) {
+			pool->stats.highWater = pool->count;
+		}
+		return idx;
 	}
 
 	// Pool full, all in use -- evict first non-front entry.
 	// count >= 2 is guaranteed here (pool grows on first swap), so this always finds one.
 	for (int i = 0; i < pool->count; i++) {
-		if (i != pool->front) return i;
+		if (i != pool->front) {
+			pool->stats.evictions++;
+			return i;
+		}
 	}
 	return 0; // unreachable
 }
 
+static void poolLogStats(IOSurfacePool *pool) {
+	CFAbsoluteTime now = CFAbsoluteTimeGetCurrent();
+	if (now - pool->lastLogTime < 60.0) return;
+
+	NSLog(@"IOSurfacePool: %d swaps, %d allocs, pool %d/%d (hw %d), %d reuse, %d recycle, %d grow, %d evict, %d fail",
+		pool->stats.swaps,
+		pool->stats.allocs,
+		pool->count,
+		RLAWT_MAX_POOL,
+		pool->stats.highWater,
+		pool->stats.reuses,
+		pool->stats.recycles,
+		pool->stats.grows,
+		pool->stats.evictions,
+		pool->stats.failures);
+
+	memset(&pool->stats, 0, sizeof(pool->stats));
+	pool->stats.highWater = pool->count;
+	pool->lastLogTime = now;
+}
+
 JNIEXPORT void JNICALL Java_net_runelite_rlawt_AWTContext_createGLContext(JNIEnv *env, jobject self) {
 	AWTContext *ctx = rlawtGetContext(env, self);
 	if (!ctx || !rlawtContextState(env, ctx, false)) {
@@ -378,16 +411,22 @@ JNIEXPORT void JNICALL Java_net_runelite_rlawt_AWTContext_swapBuffers(JNIEnv *en
 		withObject: (id)(pool->entries[pool->front].surface)
 		waitUntilDone: true];
 
+	pool->stats.swaps++;
+
 	// Find a free surface for the next frame
 	pool->back = poolNextBack(pool, ctx->layer);
 
 	// Create/recreate surface if needed (new slot, wrong size, or still held by compositor)
 	if (!poolSurfaceMatchesSize(pool, pool->back, ctx->layer)
 		|| IOSurfaceIsInUse(pool->entries[pool->back].surface)) {
 		if (!poolCreateSurface(env, pool, pool->back, ctx->layer, ctx->context)) {
+			pool->stats.failures++;
 			return;
 		}
+		pool->stats.allocs++;
 	}
+
+	poolLogStats(pool);
 }
 
 JNIEXPORT jint JNICALL Java_net_runelite_rlawt_AWTContext_getFramebuffer(JNIEnv *env, jobject self, jboolean front) {