[go-nuts] Why does this struct escape to the heap?

[Paul D]

I'm trying to reduce allocations (and improve performance) in some Go code. 
There's a recurring pattern in the code where a struct is passed to a 
function, and the function passes one of the struct's methods to 
strings.IndexFunc. For some reason, this causes the entire struct to escape 
to the heap. If I wrap the method call in an anonymous function, the struct 
does not escape and the benchmarks run about 30% faster.

Here is a minimal example. In the actual code, the struct has more 
fields/methods and the function in question actually does something. But 
this sample code illustrates the problem. Why does the opts argument escape 
to the heap in index1 but not in the functionally equivalent index2? And is 
there a robust way to ensure that it stays on the stack?


type options struct {
    zero rune
}

func (opts *options) isDigit(r rune) bool {
    r -= opts.zero
    return r >= 0 && r <= 9
}

// opts escapes to heap
func index1(s string, opts options) int {
    return strings.IndexFunc(s, opts.isDigit)
}

// opts does not escape to heap
func index2(s string, opts options) int {
    return strings.IndexFunc(s, func(r rune) bool {
        return opts.isDigit(r)
    })
}


FYI I'm running Go 1.10.3 on Linux. Thanks...


-- 
You received this message because you are subscribed to the Google Groups 
"golang-nuts" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to golang-nuts+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.