feat(debug): add more metrics in ThreadDebugState

Author: alexandre-daubois

debugstate.go

@@ -1,5 +1,7 @@
 package frankenphp
 
+// #include "frankenphp.h"
+import "C"
 import (
 	"github.com/dunglas/frankenphp/internal/state"
 )
@@ -56,25 +58,30 @@ func threadDebugState(thread *phpThread) ThreadDebugState {
 	}
 
 	s.RequestCount = thread.requestCount.Load()
-	s.MemoryUsage = thread.lastMemoryUsage.Load()
+	s.MemoryUsage = int64(C.frankenphp_get_thread_memory_usage(C.uintptr_t(thread.threadIndex)))
 
-	if isBusy {
-		thread.handlerMu.RLock()
-		fc := thread.handler.frankenPHPContext()
-		thread.handlerMu.RUnlock()
+	if !isBusy {
+		return s
+	}
 
-		if fc != nil && fc.request != nil && fc.responseWriter != nil {
-			if fc.originalRequest != nil {
-				s.CurrentURI = fc.originalRequest.URL.RequestURI()
-				s.CurrentMethod = fc.originalRequest.Method
-			} else {
-				s.CurrentURI = fc.requestURI
-				s.CurrentMethod = fc.request.Method
-			}
-			if !fc.startedAt.IsZero() {
-				s.RequestStartedAt = fc.startedAt.UnixMilli()
-			}
-		}
+	thread.handlerMu.RLock()
+	defer thread.handlerMu.RUnlock()
+
+	fc := thread.handler.frankenPHPContext()
+	if fc == nil || fc.request == nil || fc.responseWriter == nil {
+		return s
+	}
+
+	if fc.originalRequest == nil {
+		s.CurrentURI = fc.requestURI
+		s.CurrentMethod = fc.request.Method
+	} else {
+		s.CurrentURI = fc.originalRequest.URL.RequestURI()
+		s.CurrentMethod = fc.originalRequest.Method
+	}
+
+	if !fc.startedAt.IsZero() {
+		s.RequestStartedAt = fc.startedAt.UnixMilli()
 	}
 
 	return s

frankenphp.c

@@ -244,11 +244,12 @@ static void frankenphp_reset_session_state(void) {
 }
 #endif
 
-static __thread size_t thread_last_memory_usage = 0;
+static frankenphp_thread_metrics *thread_metrics = NULL;
 
 /* Adapted from php_request_shutdown */
 static void frankenphp_worker_request_shutdown() {
-  thread_last_memory_usage = zend_memory_usage(0);
+  __atomic_store_n(&thread_metrics[thread_index].last_memory_usage,
+                   zend_memory_usage(0), __ATOMIC_RELAXED);
 
   /* Flush all output buffers */
   zend_try { php_output_end_all(); }
@@ -1237,7 +1238,8 @@ int frankenphp_execute_script(char *file_name) {
     sandboxed_env = NULL;
   }
 
-  thread_last_memory_usage = zend_memory_usage(0);
+  __atomic_store_n(&thread_metrics[thread_index].last_memory_usage,
+                   zend_memory_usage(0), __ATOMIC_RELAXED);
   php_request_shutdown((void *)0);
   frankenphp_free_request_context();
 
@@ -1410,7 +1412,19 @@ int frankenphp_reset_opcache(void) {
 
 int frankenphp_get_current_memory_limit() { return PG(memory_limit); }
 
-size_t frankenphp_get_current_memory_usage() { return thread_last_memory_usage; }
+void frankenphp_init_thread_metrics(int max_threads) {
+  thread_metrics = calloc(max_threads, sizeof(frankenphp_thread_metrics));
+}
+
+void frankenphp_destroy_thread_metrics(void) {
+  free(thread_metrics);
+  thread_metrics = NULL;
+}
+
+size_t frankenphp_get_thread_memory_usage(uintptr_t idx) {
+  return __atomic_load_n(&thread_metrics[idx].last_memory_usage,
+                         __ATOMIC_RELAXED);
+}
 
 static zend_module_entry **modules = NULL;
 static int modules_len = 0;

frankenphp.h

@@ -185,7 +185,14 @@ void frankenphp_register_server_vars(zval *track_vars_array,
 zend_string *frankenphp_init_persistent_string(const char *string, size_t len);
 int frankenphp_reset_opcache(void);
 int frankenphp_get_current_memory_limit();
-size_t frankenphp_get_current_memory_usage();
+
+typedef struct {
+  size_t last_memory_usage;
+} frankenphp_thread_metrics;
+
+void frankenphp_init_thread_metrics(int max_threads);
+void frankenphp_destroy_thread_metrics(void);
+size_t frankenphp_get_thread_memory_usage(uintptr_t thread_index);
 
 void register_extensions(zend_module_entry **m, int len);
 

phpmainthread.go

@@ -54,6 +54,8 @@ func initPHPThreads(numThreads int, numMaxThreads int, phpIni map[string]string)
 		return nil, err
 	}
 
+	C.frankenphp_init_thread_metrics(C.int(mainThread.maxThreads))
+
 	// initialize all other threads
 	phpThreads = make([]*phpThread, mainThread.maxThreads)
 	phpThreads[0] = initialThread
@@ -97,6 +99,7 @@ func drainPHPThreads() {
 	doneWG.Wait()
 	mainThread.state.Set(state.Done)
 	mainThread.state.WaitFor(state.Reserved)
+	C.frankenphp_destroy_thread_metrics()
 	phpThreads = nil
 }
 

phpthread.go

@@ -17,14 +17,13 @@ import (
 // identified by the index in the phpThreads slice
 type phpThread struct {
 	runtime.Pinner
-	threadIndex     int
-	requestChan     chan contextHolder
-	drainChan       chan struct{}
-	handlerMu       sync.RWMutex
-	handler         threadHandler
-	state           *state.ThreadState
-	requestCount    atomic.Int64
-	lastMemoryUsage atomic.Int64
+	threadIndex  int
+	requestChan  chan contextHolder
+	drainChan    chan struct{}
+	handlerMu    sync.RWMutex
+	handler      threadHandler
+	state        *state.ThreadState
+	requestCount atomic.Int64
 }
 
 // threadHandler defines how the callbacks from the C thread should be handled
@@ -176,10 +175,6 @@ func go_frankenphp_after_script_execution(threadIndex C.uintptr_t, exitStatus C.
 	if exitStatus < 0 {
 		panic(ErrScriptExecution)
 	}
-
-	thread.requestCount.Add(1)
-	thread.lastMemoryUsage.Store(int64(C.frankenphp_get_current_memory_usage()))
-
 	thread.handler.afterScriptExecution(int(exitStatus))
 
 	// unpin all memory used during script execution

threadregular.go

@@ -60,6 +60,7 @@ func (handler *regularThread) beforeScriptExecution() string {
 }
 
 func (handler *regularThread) afterScriptExecution(_ int) {
+	handler.thread.requestCount.Add(1)
 	handler.afterRequest()
 }
 

threadworker.go

@@ -293,7 +293,6 @@ func go_frankenphp_finish_worker_request(threadIndex C.uintptr_t, retval *C.zval
 	}
 
 	thread.requestCount.Add(1)
-	thread.lastMemoryUsage.Store(int64(C.frankenphp_get_current_memory_usage()))
 
 	fc.closeContext()
 	thread.handler.(*workerThread).workerFrankenPHPContext = nil