feat_: implement low memory mode with garbage collection logging

Author: qfrank

mobile/status.go

@@ -8,6 +8,8 @@ import (
 	"os"
 	"path"
 	"runtime"
+	"runtime/debug"
+	"sync"
 	"time"
 	"unsafe"
 
@@ -57,6 +59,15 @@ import (
 	"github.com/status-im/status-go/signal"
 )
 
+var (
+	lastGCTime     time.Time
+	lastGCTimeLock sync.Mutex
+)
+
+const (
+	gcInterval = 10 * time.Second
+)
+
 func call(fn any, params ...any) any {
 	return callog.Call(logutils.ZapLogger(), requestlog.GetRequestLogger(), fn, params...)
 }
@@ -2429,3 +2440,52 @@ func IntendedPanic(message string) string {
 		panic(err)
 	})
 }
+
+func SwitchToLowMemoryMode() string {
+	return callWithResponse(switchToLowMemoryMode)
+}
+
+func switchToLowMemoryMode() string {
+	lastGCTimeLock.Lock()
+	defer lastGCTimeLock.Unlock()
+
+	var err error
+	// Only run GC if 10 seconds have passed since the last call
+	if time.Since(lastGCTime) >= gcInterval {
+		releaseMemory()
+		lastGCTime = time.Now()
+	} else {
+		err = errors.New("skipping GC because it was called too recently")
+	}
+
+	return makeJSONResponse(err)
+}
+
+func releaseMemory() {
+	logger := logutils.ZapLogger()
+	var before, after runtime.MemStats
+
+	// Collect stats before GC
+	runtime.ReadMemStats(&before)
+	logger.Info("Before garbage collection",
+		zap.Uint64("heap_alloc_mb", before.HeapAlloc/1024/1024),
+		zap.Uint64("heap_objects", before.HeapObjects),
+		zap.Uint64("sys_mb", before.Sys/1024/1024),
+	)
+
+	runtime.GC()
+	debug.FreeOSMemory()
+
+	// Collect stats after GC
+	runtime.ReadMemStats(&after)
+
+	// Log results with differences
+	logger.Info("After garbage collection",
+		zap.Uint64("heap_alloc_mb", after.HeapAlloc/1024/1024),
+		zap.Uint64("heap_objects", after.HeapObjects),
+		zap.Uint64("sys_mb", after.Sys/1024/1024),
+		zap.Int64("freed_mb", int64(before.HeapAlloc-after.HeapAlloc)/1024/1024),
+		zap.Int64("objects_freed", int64(before.HeapObjects-after.HeapObjects)),
+		zap.Int64("released_mb", int64(after.HeapReleased-before.HeapReleased)/1024/1024),
+	)
+}

mobile/status_test.go

@@ -2,7 +2,9 @@ package statusgo
 
 import (
 	"encoding/json"
+	"sync"
 	"testing"
+	"time"
 
 	"github.com/stretchr/testify/require"
 
@@ -47,3 +49,72 @@ func TestIntendedPanic(t *testing.T) {
 		IntendedPanic(message)
 	})
 }
+
+func TestSwitchToLowMemoryMode(t *testing.T) {
+	// Reset the lastGCTime to ensure we can trigger GC
+	lastGCTimeLock.Lock()
+	lastGCTime = time.Time{}
+	lastGCTimeLock.Unlock()
+
+	// First call should succeed
+	result := SwitchToLowMemoryMode()
+
+	var response APIResponse
+	err := json.Unmarshal([]byte(result), &response)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal response: %v", err)
+	}
+
+	if response.Error != "" {
+		t.Errorf("Expected no error on first call, got: %s", response.Error)
+	}
+
+	// Second immediate call should be skipped due to rate limiting
+	result = SwitchToLowMemoryMode()
+
+	err = json.Unmarshal([]byte(result), &response)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal response: %v", err)
+	}
+
+	if response.Error == "" {
+		t.Error("Expected error on second immediate call, but got none")
+	}
+
+	// The error should indicate that GC was skipped
+	if response.Error != "skipping GC because it was called too recently" {
+		t.Errorf("Unexpected error message: %s", response.Error)
+	}
+
+	// Test concurrent access
+	var wg sync.WaitGroup
+	for i := 0; i < 5; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			SwitchToLowMemoryMode()
+		}()
+	}
+	wg.Wait()
+
+	// After waiting, we should be able to call it again
+	lastGCTimeLock.Lock()
+	lastGCTime = time.Now().Add(-(gcInterval + time.Second))
+	lastGCTimeLock.Unlock()
+
+	result = SwitchToLowMemoryMode()
+
+	err = json.Unmarshal([]byte(result), &response)
+	if err != nil {
+		t.Fatalf("Failed to unmarshal response: %v", err)
+	}
+
+	if response.Error != "" {
+		t.Errorf("Expected no error after waiting, got: %s", response.Error)
+	}
+}
+
+// TestReleaseMemory is a simple test to ensure the function doesn't panic
+func TestReleaseMemory(t *testing.T) {
+	releaseMemory()
+}