internal/core/adt: prevent logging overhead when disabled

LogEval is zero by default, and its implementation via Indentf has
a non-zero cost which I spotted via pprof, so avoid calling the funcs
entirely in all the call sites. Some already skipped via an early
LogEval check, but others did not.

Benchmarking the code from https://cuelang.org/issue/3881
via benchcmd -n 8 CueVetIssue3881 cue vet -c f.cue:

                    │     old     │                new                │
                    │   sec/op    │   sec/op     vs base              │
    CueVetIssue3881   507.4m ± 0%   496.0m ± 1%  -2.24% (p=0.000 n=8)

                    │     old     │                new                │
                    │ user-sec/op │ user-sec/op  vs base              │
    CueVetIssue3881   571.9m ± 1%   560.0m ± 1%  -2.08% (p=0.003 n=8)

                    │      old      │              new              │
                    │  sys-sec/op   │  sys-sec/op   vs base         │
    CueVetIssue3881   12.159m ± 51%   9.510m ± 58%  ~ (p=0.234 n=8)

                    │      old       │               new               │
                    │ peak-RSS-bytes │ peak-RSS-bytes  vs base         │
    CueVetIssue3881     47.95Mi ± 3%     49.42Mi ± 4%  ~ (p=0.857 n=8)

Updates #3881.

Signed-off-by: Daniel Martí <[email protected]>
Change-Id: I8ec0215239e97f6e8aeaeb50196b42910d91a815
Reviewed-on: https://review.gerrithub.io/c/cue-lang/cue/+/1213054
TryBot-Result: CUEcueckoo <[email protected]>
Reviewed-by: Marcel van Lohuizen <[email protected]>
Unity-Result: CUE porcuepine <[email protected]>

Author: mvdan

Diff for: internal/core/adt/log.go

@@ -68,6 +68,9 @@ func (c *OpContext) Un(s nestString, id int) {
 // Indentf logs a function call and increases the nesting level.
 // The first argument must be the function name.
 func (c *OpContext) Indentf(v *Vertex, format string, args ...any) (s nestString, id int) {
+	if c.LogEval == 0 {
+		panic("avoid calling OpContext.Indentf when logging is disabled to prevent overhead")
+	}
 	name := strings.Split(format, "(")[0]
 	if name == "" {
 		name, _ = getCallerFunctionName(1)

Diff for: internal/core/adt/sched.go

@@ -655,7 +655,9 @@ func runTask(t *task, mode runMode) {
 		return
 	}
 	ctx := t.node.ctx
-	defer ctx.Un(ctx.Indentf(t.node.node, "RUNTASK(%v, %v)", t.run.name, t.x))
+	if ctx.LogEval > 0 {
+		defer ctx.Un(ctx.Indentf(t.node.node, "RUNTASK(%v, %v)", t.run.name, t.x))
+	}
 
 	switch t.state {
 	case taskSUCCESS, taskFAILED:

Diff for: internal/core/adt/unify.go

@@ -486,7 +486,9 @@ func (v *Vertex) unify(c *OpContext, needs condition, mode runMode, checkTypos b
 // NOT:
 // - complete value. That is reserved for Unify.
 func (n *nodeContext) completeNodeTasks(mode runMode) {
-	defer n.ctx.Un(n.ctx.Indentf(n.node, "(%v)", mode))
+	if n.ctx.LogEval > 0 {
+		defer n.ctx.Un(n.ctx.Indentf(n.node, "(%v)", mode))
+	}
 
 	n.assertInitialized()