| Server IP : 153.92.12.163 / Your IP : 216.73.216.170 Web Server : LiteSpeed System : Linux id-dci-web1986.main-hosting.eu 5.14.0-611.26.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Thu Jan 29 05:24:47 EST 2026 x86_64 User : u686484674 ( 686484674) PHP Version : 8.0.30 Disable Function : system, exec, shell_exec, passthru, mysql_list_dbs, ini_alter, dl, symlink, link, chgrp, leak, popen, apache_child_terminate, virtual, mb_send_mail MySQL : OFF | cURL : ON | WGET : ON | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /./opt/golang/1.22.0/src/cmd/compile/internal/test/testdata/pgo/devirtualize/ |
Upload File : |
// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
// WARNING: Please avoid updating this file. If this file needs to be updated,
// then a new devirt.pprof file should be generated:
//
// $ cd $GOROOT/src/cmd/compile/internal/test/testdata/pgo/devirtualize/
// $ go mod init example.com/pgo/devirtualize
// $ go test -bench=. -cpuprofile ./devirt.pprof
package devirt
// Devirtualization of callees from transitive dependencies should work even if
// they aren't directly referenced in the package. See #61577.
//
// Dots in the last package path component are escaped in symbol names. Use one
// to ensure the escaping doesn't break lookup.
import (
"fmt"
"example.com/pgo/devirtualize/mult.pkg"
)
var sink int
type Adder interface {
Add(a, b int) int
}
type Add struct{}
func (Add) Add(a, b int) int {
for i := 0; i < 1000; i++ {
sink++
}
return a + b
}
type Sub struct{}
func (Sub) Add(a, b int) int {
for i := 0; i < 1000; i++ {
sink++
}
return a - b
}
// ExerciseIface calls mostly a1 and m1.
//
//go:noinline
func ExerciseIface(iter int, a1, a2 Adder, m1, m2 mult.Multiplier) int {
// The call below must evaluate selectA() to determine the receiver to
// use. This should happen exactly once per iteration. Assert that is
// the case to ensure the IR manipulation does not result in over- or
// under-evaluation.
selectI := 0
selectA := func(gotI int) Adder {
if gotI != selectI {
panic(fmt.Sprintf("selectA not called once per iteration; got i %d want %d", gotI, selectI))
}
selectI++
if gotI%10 == 0 {
return a2
}
return a1
}
oneI := 0
one := func(gotI int) int {
if gotI != oneI {
panic(fmt.Sprintf("one not called once per iteration; got i %d want %d", gotI, oneI))
}
oneI++
// The function value must be evaluated before arguments, so
// selectI must have been incremented already.
if selectI != oneI {
panic(fmt.Sprintf("selectA not called before not called before one; got i %d want %d", selectI, oneI))
}
return 1
}
val := 0
for i := 0; i < iter; i++ {
m := m1
if i%10 == 0 {
m = m2
}
// N.B. Profiles only distinguish calls on a per-line level,
// making the two calls ambiguous. However because the
// interfaces and implementations are mutually exclusive,
// devirtualization can still select the correct callee for
// each.
//
// If they were not mutually exclusive (for example, two Add
// calls), then we could not definitively select the correct
// callee.
val += m.Multiply(42, selectA(i).Add(one(i), 2))
}
return val
}
type AddFunc func(int, int) int
func AddFn(a, b int) int {
for i := 0; i < 1000; i++ {
sink++
}
return a + b
}
func SubFn(a, b int) int {
for i := 0; i < 1000; i++ {
sink++
}
return a - b
}
// ExerciseFuncConcrete calls mostly a1 and m1.
//
//go:noinline
func ExerciseFuncConcrete(iter int, a1, a2 AddFunc, m1, m2 mult.MultFunc) int {
// The call below must evaluate selectA() to determine the function to
// call. This should happen exactly once per iteration. Assert that is
// the case to ensure the IR manipulation does not result in over- or
// under-evaluation.
selectI := 0
selectA := func(gotI int) AddFunc {
if gotI != selectI {
panic(fmt.Sprintf("selectA not called once per iteration; got i %d want %d", gotI, selectI))
}
selectI++
if gotI%10 == 0 {
return a2
}
return a1
}
oneI := 0
one := func(gotI int) int {
if gotI != oneI {
panic(fmt.Sprintf("one not called once per iteration; got i %d want %d", gotI, oneI))
}
oneI++
// The function value must be evaluated before arguments, so
// selectI must have been incremented already.
if selectI != oneI {
panic(fmt.Sprintf("selectA not called before not called before one; got i %d want %d", selectI, oneI))
}
return 1
}
val := 0
for i := 0; i < iter; i++ {
m := m1
if i%10 == 0 {
m = m2
}
// N.B. Profiles only distinguish calls on a per-line level,
// making the two calls ambiguous. However because the
// function types are mutually exclusive, devirtualization can
// still select the correct callee for each.
//
// If they were not mutually exclusive (for example, two
// AddFunc calls), then we could not definitively select the
// correct callee.
val += int(m(42, int64(selectA(i)(one(i), 2))))
}
return val
}
// ExerciseFuncField calls mostly a1 and m1.
//
// This is a simplified version of ExerciseFuncConcrete, but accessing the
// function values via a struct field.
//
//go:noinline
func ExerciseFuncField(iter int, a1, a2 AddFunc, m1, m2 mult.MultFunc) int {
ops := struct {
a AddFunc
m mult.MultFunc
}{}
val := 0
for i := 0; i < iter; i++ {
ops.a = a1
ops.m = m1
if i%10 == 0 {
ops.a = a2
ops.m = m2
}
// N.B. Profiles only distinguish calls on a per-line level,
// making the two calls ambiguous. However because the
// function types are mutually exclusive, devirtualization can
// still select the correct callee for each.
//
// If they were not mutually exclusive (for example, two
// AddFunc calls), then we could not definitively select the
// correct callee.
val += int(ops.m(42, int64(ops.a(1, 2))))
}
return val
}
//go:noinline
func AddClosure() AddFunc {
// Implicit closure by capturing the receiver.
var a Add
return a.Add
}
//go:noinline
func SubClosure() AddFunc {
var s Sub
return s.Add
}
// ExerciseFuncClosure calls mostly a1 and m1.
//
// This is a simplified version of ExerciseFuncConcrete, but we need two
// distinct call sites to test two different types of function values.
//
//go:noinline
func ExerciseFuncClosure(iter int, a1, a2 AddFunc, m1, m2 mult.MultFunc) int {
val := 0
for i := 0; i < iter; i++ {
a := a1
m := m1
if i%10 == 0 {
a = a2
m = m2
}
// N.B. Profiles only distinguish calls on a per-line level,
// making the two calls ambiguous. However because the
// function types are mutually exclusive, devirtualization can
// still select the correct callee for each.
//
// If they were not mutually exclusive (for example, two
// AddFunc calls), then we could not definitively select the
// correct callee.
val += int(m(42, int64(a(1, 2))))
}
return val
}