Use global rand.Rand instance in mathrand.

common/data/rand/mathrand/mathrand.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 // Package mathrand implements a mockable interface for math/rand.Rand.
 //
 // It is controllable through context.Context. You should use this instead of
 // math/rand directly, to allow you to make deterministic tests.
 package mathrand
 
 import (
         "math/rand"
 
         "golang.org/x/net/context"
 )
 
 var key = "holds a rand.Rand for mathrand"
 
+// globalRand is a global mathrand.Rand instance that is backed by a math/rand
+// instance. It is locking, and is safe for return as a default.
+var (
+        // globalRandBase is the NON-LOCKING global *rand.Rand instance.
+        globalRandBase = wrapped{newRand()}
+
+        // globalRand is a Locking wrapper around globalRandBase. globalRandBase MUST
+        // not be used without holding this lock.
+        globalRand = &Locking{R: globalRandBase}
+)
+
 func newRand() *rand.Rand {
         return rand.New(rand.NewSource(rand.Int63()))
 }
 
 func getRand(c context.Context) Rand {
         if r, ok := c.Value(&key).(Rand); ok {
                 return r
         }
         return nil
 }
 
 // Get gets a Rand from the Context. The resulting Rand is safe for concurrent
 // use.
 //
 // If one hasn't been set, this creates a new Rand object with a Source
 // initialized from the global randomness source provided by stdlib.
 //
 // If you want to get just a single random number, prefer to use a corresponding
 // global function instead: they know how to use math/rand global RNG directly
 // and thus are much faster in case the context doesn't have a rand.Rand
 // installed.
 //
 // Use 'Get' only if you plan to obtain a large series of random numbers.
 func Get(c context.Context) Rand {
         if r := getRand(c); r != nil {
                 return r
         }
 
         // Generate a new Rand instance and return it. Our callers expect this to be

[Vadim Sh., 2016/12/20 01:40:38]

this comment is stale now

[dnj, 2016/12/20 02:16:12]

Done.

         // concurrency-safe.
-        return wrapLocking(wrapRand(newRand()))
+        return globalRand
 }
 
 // Set sets the current *"math/rand".Rand object in the context.
 //
 // Useful for testing with a quick mock. The supplied *rand.Rand will be wrapped
 // in a *Locking if necessary such that when it is returned from Get, it is
 // safe for concurrent use.
 func Set(c context.Context, mr *rand.Rand) context.Context {
         var r Rand
         if mr != nil {
@@ skipping 167 matching lines @@
         if r := getRand(c); r != nil {
                 return r.ExpFloat64()
         }
         return rand.ExpFloat64()
 }
 
 // WithGoRand invokes the supplied "fn" while holding an exclusive lock
 // for it. This can be used by callers to pull and use a *rand.Rand instance
 // out of the Context safely.
 //
 // The callback's r must not be retained or used outside of hte scope of the

[Vadim Sh., 2016/12/20 01:40:38]

typo: hte scope

[dnj, 2016/12/20 02:16:12]

Done.

 // callback.
 func WithGoRand(c context.Context, fn func(r *rand.Rand) error) error {
         if r := getRand(c); r != nil {
                 return r.WithGoRand(fn)
         }
 
-        // No Rand is installed in our Context. Generate a single-use Rand instance.
-        // We don't need to wrap this at all, since the premise of this method is
-        // that the result is not safe for concurrent use.
-        return fn(newRand())
+        // Return our globalRandBase. We MUST hold globalRand's lock in order for this
+        // to be safe.
+        globalRand.Lock()
+        defer globalRand.Unlock()
+        return fn(globalRandBase.Rand)
 }