test: fix flaky NaN-key map complexity test

Don't measure wall time in map.go. Keep it portable
and only test NaN, but not time.

Move time tests to mapnan.go and only measure user CPU time,
not wall time. It builds on Darwin and Linux, the primary
platforms where people hack on the runtime & in particular
maps. The runtime is shared, though, so we don't need it to
run on all of the platforms.

Fixes flaky build failures like:
http://build.golang.org/log/ba67eceefdeaa1142cb6c990a62fa3ffd8fd73f8

R=golang-dev, r
CC=golang-dev
https://codereview.appspot.com/8479043

2 files changed, 85 insertions, 34 deletions

diff --git a/test/map.go b/test/map.go
index 041c8fbbe..485e743fe 100644
--- a/test/map.go
+++ b/test/map.go
@@ -5,6 +5,7 @@
 // license that can be found in the LICENSE file.
 
 // Test maps, almost exhaustively.
+// NaN complexity test is in mapnan.go.
 
 package main
 
@@ -12,7 +13,6 @@ import (
 	"fmt"
 	"math"
 	"strconv"
-	"time"
 )
 
 const count = 100
@@ -659,39 +659,26 @@ func testfloat() {
 }
 
 func testnan() {
-	// Test that NaNs in maps don't go quadratic.
-	t := func(n int) time.Duration {
-		t0 := time.Now()
-		m := map[float64]int{}
-		nan := math.NaN()
-		for i := 0; i < n; i++ {
-			m[nan] = 1
-		}
-		if len(m) != n {
-			panic("wrong size map after nan insertion")
-		}
-		return time.Since(t0)
+	n := 500
+	m := map[float64]int{}
+	nan := math.NaN()
+	for i := 0; i < n; i++ {
+		m[nan] = 1
 	}
-
-	// Depending on the machine and OS, this test might be too fast
-	// to measure with accurate enough granularity. On failure,
-	// make it run longer, hoping that the timing granularity
-	// is eventually sufficient.
-
-	n := 30000 // 0.02 seconds on a MacBook Air
-	fails := 0
-	for {
-		t1 := t(n)
-		t2 := t(2 * n)
-		// should be 2x (linear); allow up to 3x
-		if t2 < 3*t1 {
-			return
-		}
-		fails++
-		if fails == 4 {
-			panic(fmt.Sprintf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2))
-			return
-		}
-		n *= 2
+	if len(m) != n {
+		panic("wrong size map after nan insertion")
+	}
+	iters := 0
+	for k, v := range m {
+		iters++
+		if !math.IsNaN(k) {
+			panic("not NaN")
+		}
+		if v != 1 {
+			panic("wrong value")
+		}
+	}
+	if iters != n {
+		panic("wrong number of nan range iters")
 	}
 }
diff --git a/test/mapnan.go b/test/mapnan.go
new file mode 100644
index 000000000..897454002
--- /dev/null
+++ b/test/mapnan.go
@@ -0,0 +1,64 @@
+// +build darwin,linux
+// run
+
+// Copyright 2013 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.
+
+// Test that NaNs in maps don't go quadratic.
+
+package main
+
+import (
+	"fmt"
+	"math"
+	"time"
+	"syscall"
+)
+
+func main() {
+
+	// Test that NaNs in maps don't go quadratic.
+	t := func(n int) time.Duration {
+		var u0 syscall.Rusage
+		if err := syscall.Getrusage(0,  &u0); err != nil {
+			panic(err)
+		}
+		m := map[float64]int{}
+		nan := math.NaN()
+		for i := 0; i < n; i++ {
+			m[nan] = 1
+		}
+		if len(m) != n {
+			panic("wrong size map after nan insertion")
+		}
+		var u1 syscall.Rusage
+		if err := syscall.Getrusage(0,  &u1); err != nil {
+			panic(err)
+		}
+		return time.Duration(u1.Utime.Nano() - u0.Utime.Nano())
+	}
+
+	// Depending on the machine and OS, this test might be too fast
+	// to measure with accurate enough granularity. On failure,
+	// make it run longer, hoping that the timing granularity
+	// is eventually sufficient.
+
+	n := 30000 // ~8ms user time on a Mid 2011 MacBook Air (1.8 GHz Core i7)
+	fails := 0
+	for {
+		t1 := t(n)
+		t2 := t(2 * n)
+		// should be 2x (linear); allow up to 3x
+		if t2 < 3*t1 {
+			return
+		}
+		fails++
+		if fails == 6 {
+			panic(fmt.Sprintf("too slow: %d inserts: %v; %d inserts: %v\n", n, t1, 2*n, t2))
+		}
+		if fails < 4 {
+			n *= 2
+		}
+	}
+}