《MMO 服务器开发》2.2 双栈对照：Go GC vs JVM GC

// file: internal/profile/gcstats.go
// tier: L2
// verify: go test ./internal/profile/ -run TestGoGCSample -v
package profile

import (
	"runtime"
	"runtime/debug"
	"time"
)

// AllocSample is one measurement of Go's allocator and GC after a workload.
// It is the Go half of the section 2.2 double-stack comparison: the JVM half
// reads the same four facts (bytes allocated, object count, GC cycles, pause
// time) out of ManagementFactory.
type AllocSample struct {
	TotalAlloc uint64        // cumulative bytes allocated (monotonic)
	Mallocs    uint64        // cumulative object count allocated (monotonic)
	HeapAlloc  uint64        // live heap bytes after the run
	HeapSys    uint64        // heap bytes obtained from the OS
	NumGC      uint32        // completed GC cycles
	PauseTotal time.Duration // cumulative stop-the-world pause
	PauseMax   time.Duration // largest observed pause
	LastPause  time.Duration // most recent pause
}

// ReadMemStats snapshots runtime.MemStats plus debug.GCStats in one call.
func ReadMemStats() AllocSample {
	var m runtime.MemStats
	runtime.ReadMemStats(&m)
	var g debug.GCStats
	g.PauseQuantiles = make([]time.Duration, 5)
	debug.ReadGCStats(&g)
	max := time.Duration(0)
	for _, q := range g.PauseQuantiles {
		if q > max {
			max = q
		}
	}
	last := time.Duration(0)
	if len(g.Pause) > 0 {
		last = g.Pause[0]
	}
	return AllocSample{
		TotalAlloc: m.TotalAlloc,
		Mallocs:    m.Mallocs,
		HeapAlloc:  m.HeapAlloc,
		HeapSys:    m.HeapSys,
		NumGC:      m.NumGC,
		PauseTotal: g.PauseTotal,
		PauseMax:   max,
		LastPause:  last,
	}
}

// allocChunk is one small object of the kind a tick allocates: a broadcast
// envelope, a damage event, a timer entry. 32 bytes of payload keeps it in a
// small-object size class, which is what a real tick mostly allocates.
type allocChunk struct {
	id  uint64
	seq uint32
	pad [20]byte
}

// AllocObjects allocates n small objects and returns them so the compiler
// cannot elide the allocation and so the caller controls the live set. This is
// deliberately the same shape as the Java half's `new Chunk()` loop.
func AllocObjects(n int) []*allocChunk {
	keep := make([]*allocChunk, n)
	for i := range keep {
		keep[i] = &allocChunk{id: uint64(i), seq: uint32(i)}
	}
	return keep
}

// file: cmd/gcbench/main.go
// tier: L2
// verify: go run ./cmd/gcbench
// Command gcbench is the Go half of section 2.2's double-stack GC comparison.
// It allocates n fresh objects per round for a fixed number of rounds, holding
// each round's objects live for the duration of the round, then reports the
// allocator and GC counters that the Java half reads from ManagementFactory.
package main

import (
	"flag"
	"fmt"
	"runtime"
	"runtime/debug"
	"time"
)

// chunk mirrors the Java half's Chunk: a small object with a 32-byte footprint
// (8 id + 4 seq + 20 pad), the size class a tick's broadcast envelope lands in.
type chunk struct {
	id  uint64
	seq uint32
	pad [20]byte
}

func alloc(n int) []*chunk {
	keep := make([]*chunk, n)
	for i := range keep {
		keep[i] = &chunk{id: uint64(i), seq: uint32(i)}
	}
	return keep
}

func main() {
	n := flag.Int("n", 5_000_000, "objects to allocate per round")
	rounds := flag.Int("rounds", 5, "rounds; each allocates n fresh objects")
	flag.Parse()

	// Warm up the allocator and the GC so the measured window is steady state.
	warm := alloc(*n)
	runtime.KeepAlive(warm)
	warm = nil
	runtime.GC()

	var m0, m1 runtime.MemStats
	runtime.ReadMemStats(&m0)

	t0 := time.Now()
	for r := 0; r < *rounds; r++ {
		s := alloc(*n)
		runtime.KeepAlive(s)
	}
	elapsed := time.Since(t0)

	runtime.ReadMemStats(&m1)
	var g debug.GCStats
	g.PauseQuantiles = make([]time.Duration, 5)
	debug.ReadGCStats(&g)

	allocs := m1.Mallocs - m0.Mallocs
	bytes := m1.TotalAlloc - m0.TotalAlloc
	gc := m1.NumGC - m0.NumGC
	pauseMax := g.PauseQuantiles[len(g.PauseQuantiles)-1]

	fmt.Printf("go   rounds=%d objs/round=%d elapsed=%v\n", *rounds, *n, elapsed.Round(time.Millisecond))
	fmt.Printf("go   alloc=%d objects, %.1f MiB total, %.1f ns/obj\n",
		allocs, float64(bytes)/(1<<20), float64(elapsed.Nanoseconds())/float64(allocs))
	fmt.Printf("go   gc=%d cycles, pauseTotal=%v, pauseMax=%v\n",
		gc, g.PauseTotal.Round(time.Microsecond), pauseMax.Round(time.Microsecond))
	fmt.Printf("go   heapAlloc=%.1f MiB heapSys=%.1f MiB\n",
		float64(m1.HeapAlloc)/(1<<20), float64(m1.HeapSys)/(1<<20))
}

// file: src/main/java/dev/aegis/eng/GcBench.java
// tier: L2J
// verify: docker run --rm -v "$HOME/.m2-mmo:/root/.m2" -v "$HOME/.aegis-java/eng-ch02:/w" -w /w -e MAVEN_OPTS="-Xmx1g" maven:3.9-eclipse-temurin-21 sh -c "mvn -B -q compile exec:java"
package dev.aegis.eng;

import java.lang.management.GarbageCollectorMXBean;
import java.lang.management.ManagementFactory;
import java.lang.management.MemoryMXBean;
import java.lang.management.MemoryUsage;
import java.util.ArrayList;
import java.util.List;

/**
 * GcBench is the Java half of section 2.2's double-stack GC comparison. It runs
 * the same workload as the Go half (cmd/gcbench): allocate n fresh objects per
 * round for a fixed number of rounds, holding each round's objects live for the
 * duration of the round, then report the heap and GC counters that the Go half
 * reads from runtime.MemStats / debug.GCStats.
 *
 * Run it under a bounded heap (-Xmx) so young collections are frequent enough
 * to observe, the same way a real server runs with a fixed heap ceiling.
 */
public final class GcBench {

    /** Mirrors the Go half's chunk: a small object with a ~32-byte footprint. */
    static final class Chunk {
        long id;
        int seq;
        // padding to roughly match the Go struct's 32-byte size class
        long padA;
        long padB;
    }

    static List<Chunk> alloc(int n) {
        List<Chunk> keep = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            Chunk c = new Chunk();
            c.id = i;
            c.seq = i;
            keep.add(c);
        }
        return keep;
    }

    static String collectorNames(List<GarbageCollectorMXBean> gcs) {
        StringBuilder sb = new StringBuilder();
        for (GarbageCollectorMXBean g : gcs) {
            if (sb.length() > 0) {
                sb.append('+');
            }
            sb.append(g.getName());
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        int n = args.length > 0 ? Integer.parseInt(args[0]) : 5_000_000;
        int rounds = args.length > 1 ? Integer.parseInt(args[1]) : 5;

        // Warm up the allocator and the JIT so the measured window is steady.
        List<Chunk> warm = alloc(n);
        System.out.println("java warmup kept=" + warm.size());
        warm = null;
        System.gc();

        MemoryMXBean mem = ManagementFactory.getMemoryMXBean();
        List<GarbageCollectorMXBean> gcs = ManagementFactory.getGarbageCollectorMXBeans();

        long gcCount0 = 0, gcTime0 = 0;
        for (GarbageCollectorMXBean g : gcs) {
            gcCount0 += g.getCollectionCount();
            gcTime0 += g.getCollectionTime();
        }

        long t0 = System.nanoTime();
        long total = 0;
        for (int r = 0; r < rounds; r++) {
            List<Chunk> keep = alloc(n);
            total += keep.size();
        }
        long elapsed = System.nanoTime() - t0;

        long gcCount1 = 0, gcTime1 = 0;
        for (GarbageCollectorMXBean g : gcs) {
            gcCount1 += g.getCollectionCount();
            gcTime1 += g.getCollectionTime();
        }

        MemoryUsage heap = mem.getHeapMemoryUsage();
        System.out.printf("java rounds=%d objs/round=%d elapsed=%d ms%n", rounds, n, elapsed / 1_000_000);
        System.out.printf("java alloc=%d objects, %.1f ns/obj%n", total, (double) elapsed / total);
        System.out.printf("java gc=%d cycles, pauseTotal=%d ms%n", gcCount1 - gcCount0, gcTime1 - gcTime0);
        System.out.printf("java heapUsed=%.1f MiB heapMax=%.1f MiB committed=%.1f MiB%n",
                heap.getUsed() / 1048576.0, heap.getMax() / 1048576.0, heap.getCommitted() / 1048576.0);
        System.out.printf("java collectors=%s%n", collectorNames(gcs));
        System.out.flush();

        // exec:java runs in the Maven JVM; exit explicitly so no non-daemon
        // thread (a metrics reporter, a pool) can hold the process open.
        System.exit(0);
    }
}

go   rounds=5 objs/round=5000000 elapsed=448ms
go   alloc=25000013 objects, 953.7 MiB total, 17.9 ns/obj
go   gc=11 cycles, pauseTotal=995µs, pauseMax=107µs
go   heapAlloc=191.0 MiB heapSys=319.5 MiB

java rounds=5 objs/round=5000000 elapsed=618 ms
java alloc=25000000 objects, 24.7 ns/obj
java gc=28 cycles, pauseTotal=346 ms
java heapUsed=461.7 MiB heapMax=1024.0 MiB committed=940.0 MiB
java collectors=G1 Young Generation+G1 Concurrent GC+G1 Old Generation