runtime: provide a knob to control profile precision.

Provide envvar GO_PPROF_PRECISION=0,1,2,3,4 values to control the profiling precision.
Values 0-3 are pass through, and 4 indicates automatic search for the best precision that works on the system.
The value 4 is not guaraneed to work on all systems. The default is arbitrary skid with value 0.

Author: chabbimilind

src/runtime/cpuprof.go

@@ -40,10 +40,11 @@ const (
 type profilePCPrecision uint8
 
 const (
-	_CPUPROF_IP_ARBITRARY_SKID profilePCPrecision = iota
-	_CPUPROF_IP_CONSTANT_SKID
+	_CPUPROF_IP_ARBITRARY_SKID, _CPUPROF_IP_FIRST_PRECISION profilePCPrecision = iota, iota
+	_CPUPROF_IP_CONSTANT_SKID                                                  = iota
 	_CPUPROF_IP_SUGGEST_NO_SKID
-	_CPUPROF_IP_NO_SKID
+	_CPUPROF_IP_NO_SKID, _CPUPROF_IP_LAST_PRECISION = iota, iota
+	_CPUPROF_IP_BEST_AVAILABLE_SKID                 = iota
 )
 
 // cpuProfileConfig holds different settings under which CPU samples can be produced.
@@ -138,7 +139,21 @@ func sanitizeCPUProfileConfig(profConfig *cpuProfileConfig) {
 	if profConfig == nil {
 		return
 	}
-	profConfig.preciseIP = _CPUPROF_IP_ARBITRARY_SKID
+	precision := _CPUPROF_IP_ARBITRARY_SKID
+	switch gogetenv("GO_PPROF_PRECISION") {
+	case "0":
+		precision = _CPUPROF_IP_ARBITRARY_SKID
+	case "1":
+		precision = _CPUPROF_IP_CONSTANT_SKID
+	case "2":
+		precision = _CPUPROF_IP_SUGGEST_NO_SKID
+	case "3":
+		precision = _CPUPROF_IP_NO_SKID
+	case "4":
+		precision = _CPUPROF_IP_BEST_AVAILABLE_SKID
+	default:
+	}
+	atomic.Store8((*uint8)(&profConfig.preciseIP), uint8(precision))
 	profConfig.isSampleIPIncluded = false
 	profConfig.isSampleThreadIDIncluded = false
 	profConfig.isSampleAddrIncluded = false

src/runtime/os_linux.go

@@ -5,6 +5,7 @@
 package runtime
 
 import (
+	"runtime/internal/atomic"
 	"runtime/internal/sys"
 	"unsafe"
 )
@@ -543,9 +544,25 @@ func setThreadPMUProfiler(eventId cpuEvent, profConfig *cpuProfileConfig) {
 
 	// profConfig != nil
 	var perfAttr perfEventAttr
+	var fd int32
+	initialPrecision := profilePCPrecision(atomic.Load8((*uint8)(&profConfig.preciseIP)))
 	perfAttrInit(eventId, profConfig, &perfAttr)
-	fd := perfEventOpen(&perfAttr, 0, -1, -1, uintptr(0))
-	if fd  < 0  {
+	if initialPrecision != _CPUPROF_IP_BEST_AVAILABLE_SKID {
+		fd = perfEventOpen(&perfAttr, 0, -1, -1, uintptr(0))
+	} else {
+		// auto detect precision
+		for p := _CPUPROF_IP_LAST_PRECISION; p >= int(_CPUPROF_IP_FIRST_PRECISION); p-- {
+			perfAttr.setPrecision(profilePCPrecision(p))
+			fd = perfEventOpen(&perfAttr, 0, -1, -1, uintptr(0))
+			if fd >= 0 {
+				// Set the precision to a value that worked.
+				atomic.Store8((*uint8)(&profConfig.preciseIP), uint8(p))
+				break
+			}
+		}
+	}
+
+	if fd < 0 {
 		//dont print because a filed perfEventOpen can be enabled later.
 		//perfEventOpen can fail due to interrupted system call.
 		//println("Linux perf event open failed")

src/runtime/perf_linux.go

@@ -11,6 +11,11 @@ func perfEventOpen(attr *perfEventAttr, pid uintptr, cpu, groupFd int32, flags u
 
 const perfDataPages = 2 // use 2^n data pages
 
+func (perfAttr *perfEventAttr) setPrecision(precision profilePCPrecision) {
+	perfAttr.bits &^= (uint64(3) << 15)
+	perfAttr.bits |= uint64(precision) << 15
+}
+
 func perfAttrInit(eventId cpuEvent, profConfig *cpuProfileConfig, perfAttr *perfEventAttr) {
 	perfAttr._type = perfEventOpt[eventId]._type
 	perfAttr.size = uint32(unsafe.Sizeof(*perfAttr))