Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Generics und Performance – logsum 10× schneller

Ziel: logsum aus Tag 2 mit Benchmarks und pprof vermessen und den Combined-Parser rund zehnmal schneller machen – mit Generics, Iteratoren und Fuzzing als Sicherheitsnetz · Dauer: ca. 150 min · Voraussetzung: Tag 2, Tag 4

Briefing

  • Erst messen, dann optimieren: Benchmark als Messlatte, pprof zeigt, wo die Zeit hingeht.
  • Der langsame Tag-2-Parser bleibt als Orakel: Der schnelle Pfad muss exakt dasselbe liefern.
  • Schneller Pfad für „brave” Zeilen, Fallback auf den Regex für alles andere.
  • Generics (TopN[K]) und ein Iterator (iter.Seq) halten den Code kurz.
  • Fuzzing vergleicht beide Parser mit Zufallseingaben.
access.log --> Lines (iter.Seq) --> fastParser.add --ok--> Summary
                                         | nein
                                         v
                                 Combined.Parse (Tag 2, Regex) --> Summary

Drill 1: Ausgangslage und Testdaten

Du arbeitest auf einer Kopie von Tag 2 und erzeugst ein großes, reproduzierbares Log.

cp -r ~/go-lab/tag02-logsum ~/go-lab/tag13-logsum
cd ~/go-lab/tag13-logsum
mkdir -p cmd/genlog
cat > .golangci.yml <<'EOF'
version: "2"
linters:
  exclusions:
    presets: [std-error-handling] # fmt.Fprint*, Close & Co. nicht anmahnen
EOF
cat > cmd/genlog/main.go <<'EOF'
// genlog erzeugt ein reproduzierbares Access-Log im Combined-Format.
package main

import (
    "bufio"
    "flag"
    "fmt"
    "math/rand/v2"
    "os"
    "time"
)

func main() {
    n := flag.Int("n", 1_000_000, "Anzahl Zeilen")
    flag.Parse()
    rng := rand.New(rand.NewPCG(42, 2026)) // fester Seed: überall dieselbe Datei
    paths := []string{"/", "/login", "/api/users", "/api/orders", "/api/cart",
        "/healthz", "/metrics", "/static/app.js", "/api/search", "/admin"}
    methods := []string{"GET", "GET", "GET", "POST", "PUT", "DELETE"}
    codes := []int{200, 200, 200, 200, 201, 204, 301, 404, 500, 503}
    t := time.Date(2026, 10, 10, 8, 0, 0, 0, time.FixedZone("", 2*3600))
    const layout = "02/Jan/2006:15:04:05 -0700"
    w := bufio.NewWriter(os.Stdout)
    defer w.Flush()
    for i := range *n {
        fmt.Fprintf(w, "10.0.%d.%d - - [%s] \"%s %s HTTP/1.1\" %d %d \"-\" \"k6\"\n",
            rng.IntN(4), rng.IntN(255),
            t.Add(time.Duration(i)*time.Millisecond).Format(layout),
            methods[rng.IntN(len(methods))], paths[rng.IntN(len(paths))],
            codes[rng.IntN(len(codes))], rng.IntN(50_000))
    }
}
EOF
go run ./cmd/genlog > access.log
ls -lh access.log | awk '{print $5}'
head -2 access.log

Erwartet:

83M
10.0.2.98 - - [10/Oct/2026:08:00:00 +0200] "GET /api/cart HTTP/1.1" 204 26757 "-" "k6"
10.0.2.185 - - [10/Oct/2026:08:00:00 +0200] "DELETE /api/cart HTTP/1.1" 201 43895 ...

Warum? Der feste Seed (rand.NewPCG(42, 2026)) erzeugt auf jedem Rechner dieselbe Datei – Benchmarks werden vergleichbar. Die .golangci.yml kennst du aus Tag 5.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Benchmark als Messlatte

cat > internal/logs/bench_test.go <<'EOF'
package logs

import (
    "bytes"
    "os"
    "testing"
)

// load liest das große Log aus Drill 1 einmal pro Benchmark.
func load(b *testing.B) []byte {
    data, err := os.ReadFile("../../access.log")
    if err != nil {
        b.Skip("erst access.log erzeugen (Drill 1)")
    }
    b.SetBytes(int64(len(data))) // zeigt zusätzlich MB/s
    return data
}

func BenchmarkRead(b *testing.B) {
    data := load(b)
    for b.Loop() {
        if _, err := Read(bytes.NewReader(data), Combined{}); err != nil {
            b.Fatal(err)
        }
    }
}
EOF
go test -run '^$' -bench Read -benchmem ./internal/logs | tr -s ' \t' ' '

Erwartet (Werte hängen von deinem Rechner ab, gekürzt):

BenchmarkRead-10 1 1049953750 ns/op 83.26 MB/s 318696904 B/op 3000053 allocs/op
PASS
ok example.com/logsum/internal/logs 1.226s

Warum? -run '^$' überspringt die normalen Tests. b.Loop() (Tag 4) misst nur die Schleife, nicht load. Drei Allokationen pro Zeile und über 300 MB Garbage pro Durchlauf – das ist der erste Verdacht.

Fortschritt speichern? Kostenlos registrieren

Drill 3: pprof zeigt den Hotspot

go test -run '^$' -bench 'Read$' -cpuprofile cpu.out -memprofile mem.out \
  ./internal/logs > /dev/null
go tool pprof -top -cum cpu.out | grep -E 'Parse|Submatch|Text|mallocgc' \
  | awk '{print $4, $5, $6}'
go tool pprof -sample_index=alloc_space -top mem.out | grep -E 'MB ' \
  | awk '{print $4, $5, $6}'

Erwartet (gekürzt, Werte variieren):

1.24s 72.09% example.com/logsum/internal/logs.Combined.Parse
1.11s 64.53% regexp.(*Regexp).FindStringSubmatch
0.13s 7.56% runtime.mallocgc
0.13s 7.56% time.Parse
0.06s 3.49% bufio.(*Scanner).Text
399.04MB 59.65% regexp.(*Regexp).FindStringSubmatch
193.02MB 28.85% regexp.(*Regexp).backtrack
180.52MB 26.98% bufio.(*Scanner).Text
83.37MB 12.46% os.readFileContents

Drei Kostentreiber: der Regex (FindStringSubmatch), time.Parse für jede Zeile und Allokationen (Text() kopiert jede Zeile in einen String, der Regex legt Teilstrings an).

Achtung: Auf macOS sind CPU-Profile ungenau: Die Abtastsignale landen bevorzugt nach Systemaufrufen. Profile mit -cum lesen und Speicherprofile dazunehmen; belastbare CPU-Profile misst du unter Linux, etwa im CI.

rm -f cpu.out mem.out logs.test

Fortschritt speichern? Kostenlos registrieren

Drill 4: Generics – eine Top-Liste für jeden Schlüsseltyp

TopPaths aus Tag 2 kann nur map[string]int. Mit einem Typparameter funktioniert dieselbe Logik auch für Statuscodes (map[int]int):

cat > internal/logs/top.go <<'EOF'
package logs

import (
    "cmp"
    "slices"
)

// Pair ist ein Eintrag einer Top-Liste – für jeden Schlüsseltyp.
type Pair[K cmp.Ordered] struct {
    Key K
    N   int
}

// TopN liefert die n häufigsten Schlüssel, bei Gleichstand aufsteigend.
func TopN[K cmp.Ordered](m map[K]int, n int) []Pair[K] {
    list := make([]Pair[K], 0, len(m))
    for k, v := range m {
        list = append(list, Pair[K]{k, v})
    }
    slices.SortFunc(list, func(a, b Pair[K]) int {
        return cmp.Or(cmp.Compare(b.N, a.N), cmp.Compare(a.Key, b.Key))
    })
    return list[:min(n, len(list))]
}
EOF
cat > internal/logs/top_test.go <<'EOF'
package logs

import (
    "slices"
    "testing"
)

func TestTopN(t *testing.T) {
    paths := TopN(map[string]int{"/b": 2, "/a": 2, "/c": 5, "/d": 1}, 3)
    want := []Pair[string]{{"/c", 5}, {"/a", 2}, {"/b", 2}}
    if !slices.Equal(paths, want) {
        t.Errorf("got %v, want %v", paths, want)
    }
    codes := TopN(map[int]int{200: 7, 500: 9, 404: 1}, 5) // K = int
    if !slices.Equal(codes, []Pair[int]{{500, 9}, {200, 7}, {404, 1}}) {
        t.Errorf("got %v", codes)
    }
}
EOF
go test -run TestTopN -v ./internal/logs

Erwartet (gekürzt):

--- PASS: TestTopN (0.00s)
ok      example.com/logsum/internal/logs    0.187s

Warum? cmp.Ordered erlaubt alle Typen mit < – genau das braucht cmp.Compare. Beim Aufruf leitet Go K aus dem Argument ab; TopN[int](...) musst du nicht schreiben.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Iterator und schneller Pfad

Lines ist ein Iterator (iter.Seq, „range over func”): Er liefert Zeilen als Teil-Slices von data, ohne Kopie. Zwei Caches bringen das Tempo: Der letzte Zeitstempel wird nur bei Änderung geparst, jeder Pfad nur einmal als String angelegt.

cat > internal/logs/fast.go <<'EOF'
package logs

import (
    "bytes"
    "iter"
    "time"
)

// Lines liefert die Zeilen von data ohne Kopie; ein \r am Zeilenende fällt
// weg – wie bei bufio.ScanLines.
func Lines(data []byte) iter.Seq[[]byte] {
    return func(yield func([]byte) bool) {
        for len(data) > 0 {
            line, rest, _ := bytes.Cut(data, []byte{'\n'})
            if !yield(bytes.TrimSuffix(line, []byte{'\r'})) {
                return
            }
            data = rest
        }
    }
}

// ReadFast liefert dasselbe Ergebnis wie Read(r, Combined{}) – schneller.
func ReadFast(data []byte) *Summary {
    s := NewSummary()
    f := fastParser{paths: map[string]string{}}
    for line := range Lines(data) {
        s.Lines++
        if f.add(s, line) {
            continue
        }
        e, err := Combined{}.Parse(string(line)) // Fallback: exakt wie Tag 2
        if err != nil {
            s.Bad++
            continue
        }
        s.Add(e)
    }
    return s
}

// fastParser hält die Caches, die das Tempo bringen.
type fastParser struct {
    tm    timeMemo
    paths map[string]string // jeder Pfad nur einmal als String
}

// intern liefert path als String und alloziert nur beim ersten Auftreten.
func (f *fastParser) intern(path []byte) string {
    if p, ok := f.paths[string(path)]; ok { // Lookup ohne Allokation
        return p
    }
    p := string(path)
    f.paths[p] = p
    return p
}

// timeMemo merkt sich den letzten Zeitstempel: Viele Zeilen teilen ihn.
type timeMemo struct {
    key []byte
    t   time.Time
    err error
}

func (m *timeMemo) parse(b []byte) (time.Time, error) {
    if m.key == nil || !bytes.Equal(b, m.key) {
        m.key = append(m.key[:0], b...)
        m.t, m.err = time.Parse(combinedTime, string(b))
    }
    return m.t, m.err
}
EOF

add prüft eine strengere Grammatik als der Regex. Alles, was nicht hineinpasst, geht an den Fallback – so bleibt das Ergebnis exakt gleich.

cat > internal/logs/fastline.go <<'EOF'
package logs

import "bytes"

// add versteht nur „brave" ASCII-Zeilen und zählt sie direkt in s.
// false heißt: nichts verändert, der Aufrufer nimmt den Regex-Fallback.
func (f *fastParser) add(s *Summary, line []byte) bool {
    rest, ok := line, false
    for range 3 { // IP, ident, user
        if _, rest, ok = word(rest, ' '); !ok {
            return false
        }
    }
    if !bytes.HasPrefix(rest, []byte("[")) {
        return false
    }
    end := bytes.IndexByte(rest, ']')
    if end < 2 || !bytes.HasPrefix(rest[end:], []byte(`] "`)) {
        return false
    }
    ts := rest[1:end]
    if _, rest, ok = word(rest[end+3:], ' '); !ok { // Methode
        return false
    }
    path, rest, ok := word(rest, ' ', '"')
    q := bytes.IndexByte(rest, '"')
    if !ok || q < 0 {
        return false
    }
    rest = rest[q+1:] // jetzt: ` 200 512 ...`
    if len(rest) < 6 || rest[0] != ' ' || rest[4] != ' ' {
        return false
    }
    status, size := digits(rest[1:4]), int64(0)
    if n := digitRun(rest[5:]); n > 0 && n <= 18 {
        size = int64(digits(rest[5 : 5+n]))
    } else if n != 0 || rest[5] != '-' {
        return false
    }
    t, err := f.tm.parse(ts)
    if status < 0 || err != nil {
        return false
    }
    s.Bytes += size
    s.ByStatus[status]++
    s.ByPath[f.intern(path)]++
    if s.First.IsZero() || t.Before(s.First) {
        s.First = t
    }
    if t.After(s.Last) {
        s.Last = t
    }
    return true
}
EOF
cat > internal/logs/word.go <<'EOF'
package logs

import "bytes"

// word liest druckbare ASCII-Zeichen ohne '"' bis zu einem der Trenner.
// Ist der Trenner '"', bleibt er in rest.
func word(b []byte, seps ...byte) (w, rest []byte, ok bool) {
    for i, c := range b {
        if bytes.IndexByte(seps, c) >= 0 {
            if i == 0 {
                return nil, nil, false
            }
            if c == '"' {
                return b[:i], b[i:], true
            }
            return b[:i], b[i+1:], true
        }
        if c <= ' ' || c > '~' || c == '"' {
            return nil, nil, false
        }
    }
    return nil, nil, false
}

// digitRun zählt führende Ziffern.
func digitRun(b []byte) int {
    n := 0
    for n < len(b) && b[n] >= '0' && b[n] <= '9' {
        n++
    }
    return n
}

// digits parst reine Ziffern; -1 sonst.
func digits(b []byte) int {
    if digitRun(b) != len(b) {
        return -1
    }
    n := 0
    for _, c := range b {
        n = n*10 + int(c-'0')
    }
    return n
}
EOF

Der Test nutzt Tag 2 als Orakel; der Fuzzer sucht Zeilen, bei denen beide sich unterscheiden.

cat > internal/logs/fast_test.go <<'EOF'
package logs

import (
    "os"
    "reflect"
    "strings"
    "testing"
)

// diff vergleicht ReadFast mit der Tag-2-Version als Orakel.
func diff(t *testing.T, in string) {
    t.Helper()
    want, err := Read(strings.NewReader(in), Combined{})
    if err != nil {
        return // z. B. Zeile länger als der Scanner-Puffer
    }
    if got := ReadFast([]byte(in)); !reflect.DeepEqual(got, want) {
        t.Errorf("%q:\ngot  %+v\nwant %+v", in, got, want)
    }
}

func TestFastAgrees(t *testing.T) {
    b, err := os.ReadFile("../../testdata/access.log")
    if err != nil {
        t.Fatal(err)
    }
    diff(t, string(b))
    diff(t, "kaputt\n\r\n1.2.3.4 - - [x] \"GET / HTTP/1.1\" 200 1\n")
}

func FuzzFastAgrees(f *testing.F) {
    f.Add(`10.0.0.1 - - [10/Oct/2026:08:00:01 +0200] "GET / HTTP/1.1" 200 512`)
    f.Add(`10.0.0.1 - - [10/Oct/2026:08:00:01 +0200] "GET /a"b" 200 -`)
    f.Fuzz(diff)
}

func BenchmarkReadFast(b *testing.B) {
    data := load(b)
    for b.Loop() {
        ReadFast(data)
    }
}
EOF
go test -count=1 ./internal/logs
go test -run '^$' -fuzz FuzzFastAgrees -fuzztime 10s ./internal/logs 2>&1 | tail -2
go test -run '^$' -bench . -benchmem ./internal/logs | grep Bench | tr -s ' \t' ' '

Erwartet (Werte variieren):

ok      example.com/logsum/internal/logs    0.147s
PASS
ok      example.com/logsum/internal/logs    11.148s
BenchmarkRead-10 2 950859208 ns/op 91.93 MB/s 318720920 B/op 3000038 allocs/op
BenchmarkReadFast-10 8 146715656 ns/op 595.81 MB/s 2080 B/op 23 allocs/op

Warum? Allokationen von drei Millionen auf 23 pro Durchlauf – aber nur Faktor 6,5. Der Fuzzer ist dein Beweis, dass der schnelle Pfad nichts anders zählt; findet er etwas, legt er die Eingabe unter testdata/fuzz/ ab und go test prüft sie ab dann bei jedem Lauf.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Zweite Runde mit pprof

go test -run '^$' -bench ReadFast -cpuprofile cpu.out ./internal/logs > /dev/null
go tool pprof -top cpu.out | sed -n '6,10p'
go tool pprof -list 'logs.word' cpu.out | grep -E 'IndexByte|range b'

Erwartet (gekürzt, Werte variieren):

      flat  flat%   sum%        cum   cum%
     0.47s 42.73% 42.73%      0.47s 42.73%  internal/bytealg.IndexByteString
     0.14s 12.73% 55.45%      0.52s 47.27%  example.com/logsum/internal/logs.word
     0.06s  5.45% 66.36%      0.06s  5.45%  runtime.pthread_cond_signal
      40ms       40ms      8:   for i, c := range b {
      20ms      400ms      9:       if bytes.IndexByte(seps, c) >= 0 {

Fast die Hälfte der Zeit hängt an Zeile 9 von word: bytes.IndexByte(seps, c) läuft für jedes einzelne Zeichen – ein Funktionsaufruf pro Byte. Die Lösung: den häufigen Fall (normales Zeichen) zuerst prüfen und für die Trenner das generische slices.Contains nehmen, das der Compiler inline einsetzt.

cat > internal/logs/word.go <<'EOF'
package logs

import "slices"

// word liest druckbare ASCII-Zeichen ohne '"' bis zu einem der Trenner.
// Ist der Trenner '"', bleibt er in rest.
func word(b []byte, seps ...byte) (w, rest []byte, ok bool) {
    for i, c := range b {
        if c > ' ' && c <= '~' && c != '"' {
            continue // der häufige Fall zuerst: ein normales Zeichen
        }
        if i == 0 || !slices.Contains(seps, c) { // generisch, inline
            return nil, nil, false
        }
        if c == '"' {
            return b[:i], b[i:], true
        }
        return b[:i], b[i+1:], true
    }
    return nil, nil, false
}

// digitRun zählt führende Ziffern.
func digitRun(b []byte) int {
    n := 0
    for n < len(b) && b[n] >= '0' && b[n] <= '9' {
        n++
    }
    return n
}

// digits parst reine Ziffern; -1 sonst.
func digits(b []byte) int {
    if digitRun(b) != len(b) {
        return -1
    }
    n := 0
    for _, c := range b {
        n = n*10 + int(c-'0')
    }
    return n
}
EOF
go test -count=1 ./internal/logs
go test -run '^$' -bench . -benchmem ./internal/logs | grep Bench | tr -s ' \t' ' '
rm -f cpu.out logs.test

Erwartet (Werte variieren):

ok      example.com/logsum/internal/logs    0.134s
BenchmarkRead-10 2 864392854 ns/op 101.13 MB/s 318760668 B/op 3000044 allocs/op
BenchmarkReadFast-10 14 81036637 ns/op 1078.71 MB/s 2080 B/op 23 allocs/op

Faktor 10,7 im Benchmark, rund 10 im echten Aufruf (Drill 7). Warum? Das ist der Arbeitsrhythmus: messen, Hotspot finden, eine Sache ändern, Tests und Fuzzer grün halten, wieder messen. Mehrere Läufe vergleichst du sauber mit go test -count 10 ... > alt.txt und benchstat alt.txt neu.txt (golang.org/x/perf/cmd/benchstat).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Das Tool ist fertig

main bekommt die Muster aus Tag 5: run(args, stdin, stdout, stderr) int, dazu -slow zum Vergleichen und -cpuprofile für Profile im Betrieb.

cat > cmd/logsum/main.go <<'EOF'
// logsum fasst ein Zugriffslog zusammen: Status, Fehlerquote, Top-Pfade.
// Tag 13: schneller Pfad für das Combined-Format, Profiling per Flag.
package main

import (
    "bytes"
    "flag"
    "fmt"
    "io"
    "os"
    "runtime/pprof"

    "example.com/logsum/internal/logs"
)

func main() {
    os.Exit(run(os.Args[1:], os.Stdin, os.Stdout, os.Stderr))
}

func run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
    fs := flag.NewFlagSet("logsum", flag.ContinueOnError)
    fs.SetOutput(stderr)
    format := fs.String("format", "combined", "Logformat: combined oder json")
    top := fs.Int("top", 3, "Anzahl der Top-Einträge")
    slow := fs.Bool("slow", false, "Parser aus Tag 2 statt schnellem Pfad")
    cpuprof := fs.String("cpuprofile", "", "CPU-Profil in diese Datei schreiben")
    if err := fs.Parse(args); err != nil {
        return 2
    }
    parsers := map[string]logs.Parser{"combined": logs.Combined{}, "json": logs.JSON{}}
    p, ok := parsers[*format]
    if !ok {
        fmt.Fprintf(stderr, "logsum: unbekanntes Format %q\n", *format)
        return 2
    }
    if *cpuprof != "" {
        f, err := os.Create(*cpuprof)
        if err != nil {
            fmt.Fprintln(stderr, "logsum:", err)
            return 1
        }
        defer f.Close() //nolint:errcheck // Profil ist best effort
        if err := pprof.StartCPUProfile(f); err != nil {
            fmt.Fprintln(stderr, "logsum:", err)
            return 1
        }
        defer pprof.StopCPUProfile() // läuft vor f.Close (LIFO)
    }
    data, err := load(fs.Arg(0), stdin)
    if err != nil {
        fmt.Fprintln(stderr, "logsum:", err)
        return 1
    }
    var s *logs.Summary
    if *slow || *format != "combined" {
        s, err = logs.Read(bytes.NewReader(data), p)
    } else {
        s = logs.ReadFast(data)
    }
    if err == nil {
        err = s.Report(stdout, *top)
    }
    if err != nil {
        fmt.Fprintln(stderr, "logsum:", err)
        return 1
    }
    fmt.Fprint(stdout, "Top Status:")
    for _, c := range logs.TopN(s.ByStatus, *top) { // TopN mit int-Schlüsseln
        fmt.Fprintf(stdout, " %d=%d", c.Key, c.N)
    }
    fmt.Fprintln(stdout)
    return 0
}

// load liest die Datei oder stdin komplett: schnell, kostet aber RAM.
func load(path string, stdin io.Reader) ([]byte, error) {
    if path == "" {
        return io.ReadAll(stdin)
    }
    return os.ReadFile(path)
}
EOF
cat > cmd/logsum/main_test.go <<'EOF'
package main

import (
    "bytes"
    "strings"
    "testing"
)

func TestRunFastEqualsSlow(t *testing.T) {
    var out [2]bytes.Buffer
    for i, mode := range []string{"-slow=true", "-slow=false"} {
        code := run([]string{mode, "../../testdata/access.log"}, nil, &out[i], &out[i])
        if code != 0 {
            t.Fatalf("%s: exit %d: %s", mode, code, out[i].String())
        }
    }
    if out[0].String() != out[1].String() {
        t.Errorf("Ausgaben weichen ab:\n%s\n---\n%s", &out[0], &out[1])
    }
    if !strings.Contains(out[1].String(), "Top Status:") {
        t.Errorf("Top Status fehlt:\n%s", &out[1])
    }
}

func TestRunBadFormat(t *testing.T) {
    var buf bytes.Buffer
    if code := run([]string{"-format", "xml"}, nil, &buf, &buf); code != 2 {
        t.Errorf("exit %d, want 2", code)
    }
}
EOF
go test -count=1 ./... && go build -o bin/logsum ./cmd/logsum
/usr/bin/time -p ./bin/logsum -slow access.log 2>&1 >/dev/null | grep real
/usr/bin/time -p ./bin/logsum access.log 2>&1 | grep -v -e '^user' -e '^sys'

Erwartet (Zeiten hängen von deinem Rechner ab):

?       example.com/logsum/cmd/genlog   [no test files]
ok      example.com/logsum/cmd/logsum   0.262s
ok      example.com/logsum/internal/logs    0.128s
real 1,18
Requests:   1000000 (0 Zeilen unlesbar)
Zeitraum:   2026-10-10 08:00:00 bis 2026-10-10 08:16:39
Bytes:      25033798498
Status:     2xx=599137 3xx=100671 4xx=100345 5xx=199847
5xx-Quote:  20.0 %
Top 3 Pfade:
  100708  /healthz
  100551  /api/users
  100143  /api/cart
Top Status: 200=399264 301=100671 201=100390
real 0,11

Warum? Die Ausgabe ist dieselbe wie in Tag 2, plus Top Status über das generische TopN. Ohne Datei liest logsum weiter von stdin (load). -cpuprofile schreibt ein Profil für go tool pprof, ohne dass du einen Benchmark brauchst.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

#!/usr/bin/env bash
check() { if eval "$2" >/dev/null 2>&1; then echo "✔ $1"; else echo "✘ $1"; fi; }
cd ~/go-lab/tag13-logsum
check "gofmt sauber" "test -z \"\$(gofmt -l .)\""
check "go vet" "go vet ./..."
check "golangci-lint" "~/go-lab/bin/lint run ./..."
check "Tests mit -race" "go test -race -count=1 ./..."
check "Fuzzing 5 s ohne Fund" \
  "go test -run '^$' -fuzz FuzzFastAgrees -fuzztime 5s ./internal/logs"
check "schnell == langsam" \
  "diff <(./bin/logsum access.log) <(./bin/logsum -slow access.log)"
cpu() { /usr/bin/time -p "$@" 2>&1 >/dev/null | awk '/user/ {sub(",","."); print $2}'; }
check "CPU-Zeit mind. 5x kleiner" \
  "awk -v s=\$(cpu ./bin/logsum -slow access.log) \
       -v f=\$(cpu ./bin/logsum access.log) 'BEGIN { exit !(s > 5 * f) }'"

Erwartet:

✔ gofmt sauber
✔ go vet
✔ golangci-lint
✔ Tests mit -race
✔ Fuzzing 5 s ohne Fund
✔ schnell == langsam
✔ CPU-Zeit mind. 5x kleiner

Challenge

Nutze alle Kerne: Schreibe ReadParallel(data []byte, workers int) *Summary, das data an Zeilengrenzen in workers Stücke teilt, jedes mit ReadFast auswertet und die Ergebnisse zusammenführt. Beweise mit einem Test, dass es dasselbe liefert wie ReadFast, und miss den Gewinn.

Hinweis: sync.WaitGroup.Go (seit Go 1.25) startet eine Goroutine und zählt sie mit; jede Goroutine bekommt ihr eigenes Summary, dann braucht es keinen Lock.

Lösung

cat > internal/logs/parallel.go <<'EOF'
package logs

import (
    "bytes"
    "sync"
)

// ReadParallel teilt data an Zeilengrenzen und wertet die Stücke parallel aus.
func ReadParallel(data []byte, workers int) *Summary {
    parts := make([]*Summary, workers)
    var wg sync.WaitGroup
    for i := range parts {
        end := len(data)
        if i < workers-1 {
            end = len(data) / (workers - i) // gleicher Anteil vom Rest
            if nl := bytes.IndexByte(data[end:], '\n'); nl >= 0 {
                end += nl + 1
            } else {
                end = len(data)
            }
        }
        chunk := data[:end]
        data = data[end:]
        wg.Go(func() { parts[i] = ReadFast(chunk) }) // jede Goroutine ihr Summary
    }
    wg.Wait()
    s := NewSummary()
    for _, p := range parts {
        s.merge(p)
    }
    return s
}

func (s *Summary) merge(o *Summary) {
    s.Lines, s.Bad, s.Bytes = s.Lines+o.Lines, s.Bad+o.Bad, s.Bytes+o.Bytes
    for k, v := range o.ByStatus {
        s.ByStatus[k] += v
    }
    for k, v := range o.ByPath {
        s.ByPath[k] += v
    }
    if !o.First.IsZero() && (s.First.IsZero() || o.First.Before(s.First)) {
        s.First = o.First
    }
    if o.Last.After(s.Last) {
        s.Last = o.Last
    }
}
EOF
cat > internal/logs/parallel_test.go <<'EOF'
package logs

import (
    "os"
    "reflect"
    "runtime"
    "testing"
)

func TestParallel(t *testing.T) {
    data, err := os.ReadFile("../../testdata/access.log")
    if err != nil {
        t.Fatal(err)
    }
    want := ReadFast(data)
    for w := 1; w <= 16; w++ {
        if got := ReadParallel(data, w); !reflect.DeepEqual(got, want) {
            t.Errorf("workers=%d:\ngot  %+v\nwant %+v", w, got, want)
        }
    }
}

func BenchmarkReadParallel(b *testing.B) {
    data := load(b)
    for b.Loop() {
        ReadParallel(data, runtime.NumCPU())
    }
}
EOF
go test -race -count=1 ./internal/logs
go test -run '^$' -bench 'Fast|Parallel' -benchmem ./internal/logs \
  | grep Bench | tr -s ' \t' ' '

Erwartet (Werte variieren):

ok      example.com/logsum/internal/logs    1.152s
BenchmarkReadFast-10 14 85721673 ns/op 1019.76 MB/s 2445 B/op 24 allocs/op
BenchmarkReadParallel-10 58 20474545 ns/op 4269.46 MB/s 24961 B/op 264 allocs/op

Warum ist es nicht zehnmal schneller bei zehn Kernen? Das Aufteilen und Zusammenführen kostet, Effizienz- und Performance-Kerne sind unterschiedlich schnell, und irgendwann begrenzt die Speicherbandbreite. Für main wäre logs.ReadParallel(data, runtime.NumCPU()) die eine geänderte Zeile.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Optimiere nur, was ein Profil aus der Produktion als teuer zeigt; ein schneller Pfad mit Fallback und Fuzz-Test ist der sichere Weg, alte Semantik zu erhalten.
  • Benchmarks gehören ins CI – aber auf festen, ruhigen Runnern und mit benchstat; Shared Runner schwanken um 20 % und mehr.
  • Ganze Dateien in den Speicher zu laden ist schnell, aber bei Gigabyte-Logs riskant: Speicherlimit (GOMEMLIMIT) setzen oder blockweise lesen.
  • Für Dienste: net/http/pprof nur intern freigeben; Continuous Profiling (Pyroscope, Parca) findet Hotspots, die im Benchmark fehlen.
  • Profile-Guided Optimization: eine default.pgo aus der Produktion im Paket main ablegen, go build nutzt sie automatisch (oft 2–14 % schneller).