code review 126720043: test/mapnan.go: add regression test for non-empty inter...

test/maplinear.go

 // +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 maps don't go quadratic for NaNs and other values.
 
 package main
@@ skipping 21 matching lines @@
         t0 := time.Now()
 
         n := tries
         fails := 0
         for {
                 t1 := timeF(n)
                 t2 := timeF(2 * n)
 
                 // should be 2x (linear); allow up to 3x
                 if t2 < 3*t1 {
-                        fmt.Println(typ, "\t", time.Since(t0))
+                        if false {
+                                fmt.Println(typ, "\t", time.Since(t0))
+                        }
                         return
                 }
                 fails++
                 if fails == 6 {
                         panic(fmt.Sprintf("%s: too slow: %d inserts: %v; %d inserts: %v\n",
                                 typ, n, t1, 2*n, t2))
                 }
                 if fails < 4 {
                         n *= 2
                 }
         }
 }
 
 type I interface {
         f()
 }
 
 type C int
 
 func (C) f() {}
 
 func main() {
-        // NaNs. ~8ms user time on a Mid 2011 MacBook Air (1.8 GHz Core i7))
-        // ~31ms on a 1.6GHz Zeon.
+        // NaNs. ~31ms on a 1.6GHz Zeon.
         checkLinear("NaN", 30000, func(n int) {
                 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")
                 }
         })
@@ skipping 24 matching lines @@
         })
 
         // ~18ms on a 1.6GHz Zeon.
         checkLinear("string", 10000, func(n int) {
                 m := map[string]int{}
                 for i := 0; i < n; i++ {
                         m[fmt.Sprint(i)] = 1
                 }
         })
 
-        // The following checks seem to fail, for a variety of tries
-        // values, because of non-linear behaviour.
-        if false {
-                checkLinear("float32", 1000, func(n int) {
-                        m := map[float32]int{}
-                        for i := 0; i < n; i++ {
-                                m[float32(i)] = 1
-                        }
-                })
+        // ~6ms on a 1.6GHz Zeon.
+        checkLinear("float32", 10000, func(n int) {
+                m := map[float32]int{}
+                for i := 0; i < n; i++ {
+                        m[float32(i)] = 1
+                }
+        })
 
-                checkLinear("float64", 1000, func(n int) {
-                        m := map[float64]int{}
-                        for i := 0; i < n; i++ {
-                                m[float64(i)] = 1
-                        }
-                })
+        // ~6ms on a 1.6GHz Zeon.
+        checkLinear("float64", 10000, func(n int) {
+                m := map[float64]int{}
+                for i := 0; i < n; i++ {
+                        m[float64(i)] = 1
+                }
+        })
 
-                checkLinear("complex64", 2000, func(n int) {
-                        m := map[complex64]int{}
-                        for i := 0; i < n; i++ {
-                                m[complex(float32(i), float32(i))] = 1
-                        }
-                })
+        // ~22ms on a 1.6GHz Zeon.
+        checkLinear("complex64", 10000, func(n int) {
+                m := map[complex64]int{}
+                for i := 0; i < n; i++ {
+                        m[complex(float32(i), float32(i))] = 1
+                }
+        })
 
-                checkLinear("complex128", 2000, func(n int) {
-                        m := map[complex128]int{}
-                        for i := 0; i < n; i++ {
-                                m[complex(float64(i), float64(i))] = 1
-                        }
-                })
-        }
+        // ~32ms on a 1.6GHz Zeon.
+        checkLinear("complex128", 10000, func(n int) {
+                m := map[complex128]int{}
+                for i := 0; i < n; i++ {
+                        m[complex(float64(i), float64(i))] = 1
+                }
+        })
 }