18761516878

Committed 23 Oct 2025 08:43PM UTC coverage: 68.56% (-0.3%) from 68.825%

Build # 18761516878

Build Type

Pull #55

github

Committed by

ghettovoice

Commit Message

Memory usage optimizations

- use abnf.Nodes by pointer
- use multiError by pointer and allocc only when needed
- use small abnf.Nodes for children nodes
- use chunk of input for cache key

Pull Request Pull Request #55: Memory usage optimizations

Run Details

97 of 121 new or added lines in 4 files covered. (80.17%)

1 existing line in 1 file now uncovered.

1509 of 2201 relevant lines covered (68.56%)

55.04 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

37.5

/errors.go

package abnf

import (
        "errors"
        "fmt"
        "strings"
        "sync"
)

const (
        // ErrNotMatched returned by operators if input doesn't match
        ErrNotMatched sentinelError = "not matched"
)

type sentinelError string

func (e sentinelError) Error() string { return string(e) }

type operError struct {
        op  string
        pos uint
        err error
}

func (e operError) Unwrap() error { return e.err }

func (e operError) Error() string {
        var sb strings.Builder
        e.writeError(&sb, 0)
        return sb.String()
}

func (e *operError) writeError(sb *strings.Builder, depth int) {
        fmt.Fprintf(sb, "operator %q failed at position %d: ", e.op, e.pos)

        var merr multiError
        if errors.As(e.err, &merr) {
                merr.writeError(sb, depth)
        } else {
                sb.WriteString(e.err.Error())
        }
}

type multiError []error

func (e multiError) Unwrap() []error { return e }

func (e multiError) Error() string {
        var sb strings.Builder
        e.writeError(&sb, 0)
        return sb.String()
}

func (e multiError) writeError(sb *strings.Builder, depth int) {
        sb.WriteString("following errors are occurred:\n")

        for _, err := range e {
                var (
                        merr multiError
                        oerr *operError
                )
                if errors.As(err, &oerr) {
                        sb.WriteString(strings.Repeat("  ", depth+1) + "- ")
                        oerr.writeError(sb, depth+1)
                        sb.WriteString("\n")
                } else if errors.As(err, &merr) {
                        merr.writeError(sb, depth+1)
                } else {
                        sb.WriteString(strings.Repeat("  ", depth+1) + "- " + err.Error() + "\n")
                }
        }
}

const multiErrCap = 10

var multiErrPool = &sync.Pool{
        New: func() any {
                me := make(multiError, 0, multiErrCap)
                return &me
        },
}

func newMultiErr(c uint) *multiError {
        var err *multiError
        if c <= multiErrCap {
                err = multiErrPool.Get().(*multiError)
        } else {
                me := make(multiError, 0, c)
                err = &me
        }
        return err
}

func (e *multiError) clear() {
        if e == nil {
                return
        }

        clear(*e)
        *e = (*e)[:0]
}

func (e *multiError) free() {
        if e == nil || cap(*e) > 10*multiErrCap {
                return
        }

        e.clear()
        multiErrPool.Put(e)
}

1	package abnf
2
3	import (
4	"errors"
5	"fmt"
6	"strings"
7	"sync"
8	)
9
10	const (
11	// ErrNotMatched returned by operators if input doesn't match
12	ErrNotMatched sentinelError = "not matched"
13	)
14
15	type sentinelError string
16
17	func (e sentinelError) Error() string { return string(e) }	×
18
19	type operError struct {
20	op string
21	pos uint
22	err error
23	}
24
25	func (e operError) Unwrap() error { return e.err }	36✔
26
27	func (e operError) Error() string {	×
28	var sb strings.Builder	×
29	e.writeError(&sb, 0)	×
30	return sb.String()	×
31	}	×
32
33	func (e operError) writeError(sb strings.Builder, depth int) {	×
34	fmt.Fprintf(sb, "operator %q failed at position %d: ", e.op, e.pos)	×
35		×
36	var merr multiError	×
37	if errors.As(e.err, &merr) {	×
38	merr.writeError(sb, depth)	×
39	} else {	×
40	sb.WriteString(e.err.Error())	×
41	}	×
42	}
43
44	type multiError []error
45
46	func (e multiError) Unwrap() []error { return e }	10✔
47
48	func (e multiError) Error() string {	×
49	var sb strings.Builder	×
50	e.writeError(&sb, 0)	×
51	return sb.String()	×
52	}	×
53
54	func (e multiError) writeError(sb *strings.Builder, depth int) {	×
55	sb.WriteString("following errors are occurred:\n")	×
56		×
57	for _, err := range e {	×
58	var (	×
59	merr multiError	×
60	oerr *operError	×
61	)	×
62	if errors.As(err, &oerr) {	×
63	sb.WriteString(strings.Repeat(" ", depth+1) + "- ")	×
64	oerr.writeError(sb, depth+1)	×
65	sb.WriteString("\n")	×
66	} else if errors.As(err, &merr) {	×
67	merr.writeError(sb, depth+1)	×
68	} else {	×
69	sb.WriteString(strings.Repeat(" ", depth+1) + "- " + err.Error() + "\n")	×
70	}	×
71	}
72	}
73
74	const multiErrCap = 10
75
76	var multiErrPool = &sync.Pool{
77	New: func() any {	15✔
78	me := make(multiError, 0, multiErrCap)	15✔
79	return &me	15✔
80	},	15✔
81	}
82
83	func newMultiErr(c uint) *multiError {	25✔
84	var err *multiError	25✔
85	if c <= multiErrCap {	50✔
86	err = multiErrPool.Get().(*multiError)	25✔
87	} else {	25✔
NEW 88	me := make(multiError, 0, c)	×
NEW 89	err = &me	×
UNCOV 90	}	×
91	return err	25✔
92	}
93
94	func (e *multiError) clear() {	97✔
95	if e == nil {	152✔
96	return	55✔
97	}	55✔
98
99	clear(*e)	42✔
100	e = (e)[:0]	42✔
101	}
102
103	func (e *multiError) free() {	31✔
104	if e == nil \|\| cap(e) > 10multiErrCap {	45✔
105	return	14✔
106	}	14✔
107
108	e.clear()	17✔
109	multiErrPool.Put(e)	17✔
110	}

ghettovoice / abnf / 18761516878

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous