Merge branch '32bit_safety'

I refactored @jmhodges' work slightly to conform to the patterms set in histogram.go and others.

README.md

@@ -3,8 +3,6 @@ go-metrics
 
 Go port of Coda Hale's Metrics library: <https://github.com/codahale/metrics>.
 
-**This code is not safe on 32-bit architectures.  It will be as soon as `atomic.LoadInt64` lands in a release tag.**
-
 Usage
 -----
 

counter.go

@@ -14,9 +14,7 @@ type Counter interface {
 }
 
 // The standard implementation of a Counter uses the sync/atomic package
-// to manage a single int64 value.  When the latest weeklies land in a
-// release, atomic.LoadInt64 will be available and this code will become
-// safe on 32-bit architectures.
+// to manage a single int64 value.
 type StandardCounter struct {
 	count int64
 }
@@ -28,13 +26,12 @@ func NewCounter() *StandardCounter {
 
 // Clear the counter: set it to zero.
 func (c *StandardCounter) Clear() {
-	c.count = 0
+	atomic.StoreInt64(&c.count, 0)
 }
 
-// Return the current count.  This is the method that's currently unsafe
-// on 32-bit architectures.
+// Return the current count.
 func (c *StandardCounter) Count() int64 {
-	return c.count
+	return atomic.LoadInt64(&c.count)
 }
 
 // Decrement the counter by the given amount.

ewma.go

@@ -18,22 +18,19 @@ type EWMA interface {
 
 // The standard implementation of an EWMA tracks the number of uncounted
 // events and processes them on each tick.  It uses the sync/atomic package
-// to manage uncounted events.  When the latest weeklies land in a release,
-// atomic.LoadInt64 will be available and this code will become safe on
-// 32-bit architectures.
+// to manage uncounted events.
 type StandardEWMA struct {
 	alpha float64
 	uncounted int64
-	rate float64
-	initialized bool
-	tick chan bool
+	in chan bool
+	out chan float64
 }
 
 // Create a new EWMA with the given alpha.  Create the clock channel and
 // start the ticker goroutine.
 func NewEWMA(alpha float64) *StandardEWMA {
-	a := &StandardEWMA{alpha, 0, 0.0, false, make(chan bool)}
-	go a.ticker()
+	a := &StandardEWMA{alpha, 0, make(chan bool), make(chan float64)}
+	go a.arbiter()
 	return a
 }
 
@@ -54,12 +51,12 @@ func NewEWMA15() *StandardEWMA {
 
 // Return the moving average rate of events per second.
 func (a *StandardEWMA) Rate() float64 {
-	return a.rate * float64(1e9)
+	return <-a.out * float64(1e9)
 }
 
 // Tick the clock to update the moving average.
 func (a *StandardEWMA) Tick() {
-	a.tick <- true
+	a.in <- true
 }
 
 // Add n uncounted events.
@@ -69,16 +66,22 @@ func (a *StandardEWMA) Update(n int64) {
 
 // On each clock tick, update the moving average to reflect the number of
 // events seen since the last tick.
-func (a *StandardEWMA) ticker() {
-	for <-a.tick {
-		count := a.uncounted
-		atomic.AddInt64(&a.uncounted, -count)
-		instantRate := float64(count) / float64(5e9)
-		if a.initialized {
-			a.rate += a.alpha * (instantRate - a.rate)
-		} else {
-			a.initialized = true
-			a.rate = instantRate
+func (a *StandardEWMA) arbiter() {
+	var initialized bool
+	var rate float64
+	for {
+		select {
+		case <-a.in:
+			count := atomic.LoadInt64(&a.uncounted)
+			atomic.AddInt64(&a.uncounted, -count)
+			instantRate := float64(count) / float64(5e9)
+			if initialized {
+				rate += a.alpha * (instantRate - rate)
+			} else {
+				initialized = true
+				rate = instantRate
+			}
+		case a.out <- rate:
 		}
 	}
 }

gauge.go

@@ -1,6 +1,6 @@
 package metrics
 
-import _ "sync/atomic"
+import "sync/atomic"
 
 // Gauges hold an int64 value that can be set arbitrarily.
 //
@@ -12,9 +12,7 @@ type Gauge interface {
 }
 
 // The standard implementation of a Gauge uses the sync/atomic package
-// to manage a single int64 value.  When the latest weeklies land in a
-// release, atomic.LoadInt64 will be available and this code will become
-// safe on 32-bit architectures.
+// to manage a single int64 value.
 type StandardGauge struct {
 	value int64
 }
@@ -26,10 +24,10 @@ func NewGauge() *StandardGauge {
 
 // Update the gauge's value.
 func (g *StandardGauge) Update(v int64) {
-	g.value = v
+	atomic.StoreInt64(&g.value, v)
 }
 
 // Return the gauge's current value.
 func (g *StandardGauge) Value() int64 {
-	return g.value
+	return atomic.LoadInt64(&g.value)
 }