expvar: Use sync/atomic to manipulate Int for better perf

Using a mutex to protect a single int operation is quite heavyweight.
Using sync/atomic provides much better performance. This change was
benchmarked as such:

BenchmarkSync   10000000       139 ns/op
BenchmarkAtomic 200000000      9.90 ns/op

package blah

import (
        "sync"
        "sync/atomic"
        "testing"
)

type Int struct {
        mu sync.RWMutex
        i  int64
}

func (v *Int) Add(delta int64) {
        v.mu.Lock()
        defer v.mu.Unlock()
        v.i += delta
}

type AtomicInt struct {
        i int64
}

func (v *AtomicInt) Add(delta int64) {
        atomic.AddInt64(&v.i, delta)
}

func BenchmarkSync(b *testing.B) {
        s := new(Int)

        for i := 0; i < b.N; i++ {
                s.Add(1)
        }
}

func BenchmarkAtomic(b *testing.B) {
        s := new(AtomicInt)

        for i := 0; i < b.N; i++ {
                s.Add(1)
        }
}

Change-Id: I6998239c785967647351bbfe8533c38e4894543b
Reviewed-on: https://go-review.googlesource.com/3430
Reviewed-by: Dmitry Vyukov <dvyukov@google.com>

diff --git a/src/expvar/expvar.go b/src/expvar/expvar.go
index 9b6dab487cb6209e9b3e407dce9f90ce23bca372..2cb515a6784567621a922443f7dcda5bd3cf3b69 100644 (file)
--- a/src/expvar/expvar.go
+++ b/src/expvar/expvar.go
@@ -32,6 +32,7 @@ import (
        "sort"
        "strconv"
        "sync"
+       "sync/atomic"
 )
 
 // Var is an abstract type for all exported variables.
@@ -41,26 +42,19 @@ type Var interface {
 
 // Int is a 64-bit integer variable that satisfies the Var interface.
 type Int struct {
-       mu sync.RWMutex
-       i  int64
+       i int64
 }
 
 func (v *Int) String() string {
-       v.mu.RLock()
-       defer v.mu.RUnlock()
-       return strconv.FormatInt(v.i, 10)
+       return strconv.FormatInt(atomic.LoadInt64(&v.i), 10)
 }
 
 func (v *Int) Add(delta int64) {
-       v.mu.Lock()
-       defer v.mu.Unlock()
-       v.i += delta
+       atomic.AddInt64(&v.i, delta)
 }
 
 func (v *Int) Set(value int64) {
-       v.mu.Lock()
-       defer v.mu.Unlock()
-       v.i = value
+       atomic.StoreInt64(&v.i, value)
 }
 
 // Float is a 64-bit float variable that satisfies the Var interface.