cmd/compile: inlining callback functions

[tulzke]

Proposal Details

I'm sorry if this is a duplicate. I honestly tried to find a similar issue

1. What version of Go are you using (go version)?

go 1.23

2. What operating system and processor architecture are you using?

MacOS

3. What did you do?

I wrote simple generic functions to simplify the work.
Example:

func SeparateIntoTwo[T any](slice []T, isFirstGroupFunc func(T) bool) [2][]T {
	result := [2][]T{
		make([]T, 0, len(slice)/2),
		make([]T, 0, len(slice)/2),
	}
	for _, elem := range slice {
		if isFirstGroupFunc(elem) {
			result[0] = append(result[0], elem)
		} else {
			result[1] = append(result[1], elem)
		}
	}

	return result
}

func foo() {
    slice := []SomeStruct{...}
    // We divide slice here into two groups: deleted and not.
    // func(s SomeStruct) IsDeleted() bool
    SeparateIntoTwo(slice, SomeStruct.IsDeleted)
}

Most of them accept callback functions for various groupings and aggregations.
I compared the performance with the same function, but instead of a callback, it used a method.
I found that the performance of functions with callback is slightly lower than without them.

Benchmark_SeparateIntoTwo/callback_100000
Benchmark_SeparateIntoTwo/callback_100000-8     	    3776	    322542 ns/op	 2408448 B/op	       2 allocs/op
Benchmark_SeparateIntoTwo/method_100000
Benchmark_SeparateIntoTwo/method_100000-8       	    4939	    245211 ns/op	 2408448 B/op	       2 allocs/op

The reason is that the methods were inline by the compiler, while the callback remained unchanged.
Moreover, the callback is not inline even when the SeparateIntoTwo function itself is inline. At this point, the compiler had information about the complexity of the function being passed as an argument.

4. What did you expect to see?

An attempt to inline a callback function by the compiler in cases where the function taking the callback as an argument is also inline

5. What did you see instead?

Lack of inlining

[timothy-king]

Not a proposal https://github.com/golang/proposal#readme. Taking out of the proposal process.

[gabyhelp]

Related Issues

• cmd/compile: inline is slower #51028 (closed)
• cmd/compile: combining two inlined functions with interfaces produces non-inlineable code #61036 (closed)

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[randall77]

@dr2chase

[dr2chase]

I think this is the same root cause as #69411 ; there's a glitch in the "constant propagation" for some-but-not-all closures.

[dr2chase]

If you could include that benchmark here, or put it up on the playground (won't run as a benchmark but that is okay with me) then I could add it to the collection of "is this really all the same problem?" bugs.