test: add data-path benchmarks and S3 request-count assertions

Author: Mmx233

README.md

@@ -122,6 +122,21 @@ lifecycle rule. It cleans up multipart uploads left incomplete if the server
 exits during composition; verify lifecycle support when using an S3-compatible
 endpoint.
 
+An AWS S3 lifecycle configuration can scope the rule to the cache prefix:
+
+```json
+{
+  "Rules": [
+    {
+      "ID": "abort-incomplete-cache-uploads",
+      "Status": "Enabled",
+      "Filter": { "Prefix": "gh-actions-cache/" },
+      "AbortIncompleteMultipartUpload": { "DaysAfterInitiation": 1 }
+    }
+  ]
+}
+```
+
 ### Cache Behavior
 
 | Variable                      | Default              | Description                                                                                                    |
@@ -201,6 +216,21 @@ E2E_S3_BUCKET=cache-test \
 go test ./e2e -run 'TestExternal(Postgres|MySQL|S3MinIO)SaveAndRestore' -count=1
 ```
 
+Targeted data-path benchmarks cover filesystem whole-cache upload/download,
+Azure block commit, ordered-parts versus merged downloads, concurrent runners,
+and S3 server-side composition:
+
+```sh
+go test ./internal/cache ./internal/storage -run '^$' -bench 'Benchmark(Filesystem|Azure|S3)' -benchmem -count=5
+```
+
+Streaming benchmarks run with 32 KiB, 128 KiB, 256 KiB, and 1 MiB buffers.
+The concurrent-runner benchmark also reports p95 latency and peak process RSS;
+the deterministic S3 protocol benchmark reports and asserts SDK HTTP requests
+per composition. When `E2E_S3_ENDPOINT_URL` and `E2E_S3_BUCKET` are configured,
+the same command also runs composition against that external S3-compatible
+backend to measure its wall-clock latency.
+
 The repository also contains a Go smoke test for the cache v2 HTTP protocol
 shape. Full runner-level compatibility should be tested with the patched
 falcondev runner container and a real GitHub Actions job.

internal/cache/rss_linux_test.go

@@ -0,0 +1,25 @@
+//go:build linux
+
+package cache
+
+import (
+	"os"
+	"strconv"
+	"strings"
+)
+
+func processRSSBytes() uint64 {
+	contents, err := os.ReadFile("/proc/self/statm")
+	if err != nil {
+		return 0
+	}
+	fields := strings.Fields(string(contents))
+	if len(fields) < 2 {
+		return 0
+	}
+	residentPages, err := strconv.ParseUint(fields[1], 10, 64)
+	if err != nil {
+		return 0
+	}
+	return residentPages * uint64(os.Getpagesize())
+}

internal/cache/rss_other_test.go

@@ -0,0 +1,7 @@
+//go:build !windows && !linux
+
+package cache
+
+func processRSSBytes() uint64 {
+	return 0
+}

internal/cache/rss_windows_test.go

@@ -0,0 +1,40 @@
+//go:build windows
+
+package cache
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+var getProcessMemoryInfo = syscall.NewLazyDLL("psapi.dll").NewProc("GetProcessMemoryInfo")
+
+type processMemoryCounters struct {
+	Size                       uint32
+	PageFaultCount             uint32
+	PeakWorkingSetSize         uintptr
+	WorkingSetSize             uintptr
+	QuotaPeakPagedPoolUsage    uintptr
+	QuotaPagedPoolUsage        uintptr
+	QuotaPeakNonPagedPoolUsage uintptr
+	QuotaNonPagedPoolUsage     uintptr
+	PagefileUsage              uintptr
+	PeakPagefileUsage          uintptr
+}
+
+func processRSSBytes() uint64 {
+	handle, err := syscall.GetCurrentProcess()
+	if err != nil {
+		return 0
+	}
+	counters := processMemoryCounters{Size: uint32(unsafe.Sizeof(processMemoryCounters{}))}
+	result, _, _ := getProcessMemoryInfo.Call(
+		uintptr(handle),
+		uintptr(unsafe.Pointer(&counters)),
+		uintptr(counters.Size),
+	)
+	if result == 0 {
+		return 0
+	}
+	return uint64(counters.WorkingSetSize)
+}