log: avoid stack lookups when not needed/used

[holiman]

We can avoid the somewhat expensive stack.Caller invocation by checking the atomic global.

name            old time/op    new time/op    delta
TraceLogging-8    2.84µs ± 8%    0.97µs ± 4%  -65.87%  (p=0.008 n=5+5)

name            old alloc/op   new alloc/op   delta
TraceLogging-8      511B ± 0%      263B ± 0%  -48.53%  (p=0.008 n=5+5)

name            old allocs/op  new allocs/op  delta
TraceLogging-8      4.00 ± 0%      2.00 ± 0%  -50.00%  (p=0.008 n=5+5)

Closes #28064

[rjl493456442]

It's problematic. e.g. in the log/handler_glog.go, L188, we assume this is available.

But I agree it's a good optimization, but just need more checks.

[holiman]

Hm, interesting. I dug into this, it turns out that r.Call.String() == %!v(NOFUNC).
due to

// String implements fmt.Stinger. It is equivalent to fmt.Sprintf("%v", c).
func (c Call) String() string {
	return fmt.Sprint(c)
}

So there's no crash, just it won't print the backtrace.

[holiman]

Should be noted, though: the Call is stack.Call -- not a pointer. Nothing is nil here. And it goes on

type Call struct {
	frame runtime.Frame
}

(no pointers)

type Frame struct {
	// PC is the program counter for the location in this frame.
	// For a frame that calls another frame, this will be the
	// program counter of a call instruction. Because of inlining,
	// multiple frames may have the same PC value, but different
	// symbolic information.
	PC uintptr
...

This struct too is (nearly) pointer-free.

[MariusVanDerWijden]

Ha I spent two hours yesterday trying to create a test to hit this, but couldn't because no pointer. So it looks good to me

[MariusVanDerWijden]

LGTM

[karalabe]

Sweet. On my machine it's 1000ns vs 98 with and without the call.

[karalabe]

linter's gonna lint :P field and comment name don't match

[karalabe]

SGTM