Update private package.

Author: klauspost

private-gen.go

@@ -32,6 +32,7 @@ var reWrites = []rewrite{
 var excludeNames = map[string]bool{"string": true, "join": true, "trim": true,
 	// cpuid_test.go
 	"t": true, "println": true, "logf": true, "log": true, "fatalf": true, "fatal": true,
+	"maxuint32": true, "lastindex": true,
 }
 
 var excludePrefixes = []string{"test", "benchmark"}

private/cpuid.go

@@ -175,6 +175,7 @@ type cpuInfo struct {
 	family         int    // CPU family number
 	model          int    // CPU model number
 	cacheline      int    // Cache line size in bytes. Will be 0 if undetectable.
+	hz             int64  // Clock speed, if known
 	cache          struct {
 		l1i int // L1 Instruction Cache (per core or shared). Will be -1 if undetected
 		l1d int // L1 Data Cache (per core or shared). Will be -1 if undetected
@@ -222,6 +223,7 @@ func detect() {
 	cpu.logicalcores = logicalCores()
 	cpu.physicalcores = physicalCores()
 	cpu.vendorid = vendorID()
+	cpu.hz = hertz(cpu.brandname)
 	cpu.cacheSize()
 }
 
@@ -598,6 +600,65 @@ func (c cpuInfo) logicalcpu() int {
 	return int(ebx >> 24)
 }
 
+// hertz tries to compute the clock speed of the CPU. If leaf 15 is
+// supported, use it, otherwise parse the brand string. Yes, really.
+func hertz(model string) int64 {
+	mfi := maxFunctionID()
+	if mfi >= 0x15 {
+		eax, ebx, ecx, _ := cpuid(0x15)
+		if eax != 0 && ebx != 0 && ecx != 0 {
+			return int64((int64(ecx) * int64(ebx)) / int64(eax))
+		}
+	}
+	// computeHz determines the official rated speed of a CPU from its brand
+	// string. This insanity is *actually the official documented way to do
+	// this according to Intel*, prior to leaf 0x15 existing. The official
+	// documentation only shows this working for exactly `x.xx` or `xxxx`
+	// cases, e.g., `2.50GHz` or `1300MHz`; this parser will accept other
+	// sizes.
+	hz := strings.LastIndex(model, "Hz")
+	if hz < 3 {
+		return -1
+	}
+	var multiplier int64
+	switch model[hz-1] {
+	case 'M':
+		multiplier = 1000 * 1000
+	case 'G':
+		multiplier = 1000 * 1000 * 1000
+	case 'T':
+		multiplier = 1000 * 1000 * 1000 * 1000
+	}
+	if multiplier == 0 {
+		return -1
+	}
+	freq := int64(0)
+	divisor := int64(0)
+	decimalShift := int64(1)
+	var i int
+	for i = hz - 2; i >= 0 && model[i] != ' '; i-- {
+		if model[i] >= '0' && model[i] <= '9' {
+			freq += int64(model[i]-'0') * decimalShift
+			decimalShift *= 10
+		} else if model[i] == '.' {
+			if divisor != 0 {
+				return -1
+			}
+			divisor = decimalShift
+		} else {
+			return -1
+		}
+	}
+	// we didn't find a space
+	if i < 0 {
+		return -1
+	}
+	if divisor != 0 {
+		return (freq * multiplier) / divisor
+	}
+	return freq * multiplier
+}
+
 // VM Will return true if the cpu id indicates we are in
 // a virtual machine. This is only a hint, and will very likely
 // have many false negatives.
@@ -849,7 +910,7 @@ func (c *cpuInfo) cacheSize() {
 		if maxExtendedFunction() < 0x8000001D {
 			return
 		}
-		for i := uint32(0); i < math.maxuint32; i++ {
+		for i := uint32(0); i < math.MaxUint32; i++ {
 			eax, ebx, ecx, _ := cpuidex(0x8000001D, i)
 
 			level := (eax >> 5) & 7

private/cpuid_test.go

@@ -27,6 +27,7 @@ func TestCPUID(t *testing.T) {
 	t.Log("L1 Data Cache:", cpu.cache.l1d, "bytes")
 	t.Log("L2 Cache:", cpu.cache.l2, "bytes")
 	t.Log("L3 Cache:", cpu.cache.l3, "bytes")
+	t.Log("Hz:", cpu.hz, "Hz")
 
 	if cpu.sse2() {
 		t.Log("We have SSE2")