hashmap_bench_test.go

package hashmap

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

const benchmarkItemCount = 1 << 10 // 1024

func setupHashMap(b *testing.B) *HashMap {
    m := New()
    for i := uintptr(0); i < benchmarkItemCount; i++ {
        m.Set(i, i)
    }
    b.ResetTimer()
    return m
}

func setupGoMap(b *testing.B) map[uintptr]uintptr {
    m := make(map[uintptr]uintptr)
    for i := uintptr(0); i < benchmarkItemCount; i++ {
        m[i] = i
    }

    b.ResetTimer()
    return m
}

func setupGoSyncMap(b *testing.B) *sync.Map {
    m := &sync.Map{}
    for i := uintptr(0); i < benchmarkItemCount; i++ {
        m.Store(i, i)
    }

    b.ResetTimer()
    return m
}

func BenchmarkStrconv(b *testing.B) {
    for i := 0; i < b.N; i++ {
        strconv.Itoa(i)
    }
}

func BenchmarkSingleInsertAbsent(b *testing.B) {
    m := New()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        m.Set(strconv.Itoa(i), "value")
    }
}

func BenchmarkSingleInsertAbsentSyncMap(b *testing.B) {
    var m sync.Map
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        m.Store(strconv.Itoa(i), "value")
    }
}

func BenchmarkSingleInsertPresent(b *testing.B) {
    m := New()
    m.Set("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        m.Set("key", "value")
    }
}

func BenchmarkSingleInsertPresentSyncMap(b *testing.B) {
    var m sync.Map
    m.Store("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        m.Store("key", "value")
    }
}

func BenchmarkMultiInsertDifferent(b *testing.B) {
    m := New()
    finished := make(chan struct{}, b.N)
    _, set := GetSet(m, finished)
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i), "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiInsertDifferentSyncMap(b *testing.B) {
    var m sync.Map
    finished := make(chan struct{}, b.N)
    _, set := GetSetSyncMap(&m, finished)

    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i), "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiInsertSame(b *testing.B) {
    m := New()
    finished := make(chan struct{}, b.N)
    _, set := GetSet(m, finished)
    m.Set("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set("key", "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiInsertSameSyncMap(b *testing.B) {
    var m sync.Map
    finished := make(chan struct{}, b.N)
    _, set := GetSetSyncMap(&m, finished)
    m.Store("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set("key", "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSame(b *testing.B) {
    m := New()
    finished := make(chan struct{}, b.N)
    get, _ := GetSet(m, finished)
    m.Set("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go get("key", "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSameSyncMap(b *testing.B) {
    var m sync.Map
    finished := make(chan struct{}, b.N)
    get, _ := GetSetSyncMap(&m, finished)
    m.Store("key", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go get("key", "value")
    }
    for i := 0; i < b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSetDifferent(b *testing.B) {
    m := New()
    finished := make(chan struct{}, 2*b.N)
    get, set := GetSet(m, finished)
    m.Set("-1", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i-1), "value")
        go get(strconv.Itoa(i), "value")
    }
    for i := 0; i < 2*b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSetDifferentSyncMap(b *testing.B) {
    var m sync.Map
    finished := make(chan struct{}, 2*b.N)
    get, set := GetSetSyncMap(&m, finished)
    m.Store("-1", "value")
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i-1), "value")
        go get(strconv.Itoa(i), "value")
    }
    for i := 0; i < 2*b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSetBlock(b *testing.B) {
    m := New()
    finished := make(chan struct{}, 2*b.N)
    get, set := GetSet(m, finished)
    for i := 0; i < b.N; i++ {
        m.Set(strconv.Itoa(i%100), "value")
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i%100), "value")
        go get(strconv.Itoa(i%100), "value")
    }
    for i := 0; i < 2*b.N; i++ {
        <-finished
    }
}

func BenchmarkMultiGetSetBlockSyncMap(b *testing.B) {
    var m sync.Map
    finished := make(chan struct{}, 2*b.N)
    get, set := GetSetSyncMap(&m, finished)
    for i := 0; i < b.N; i++ {
        m.Store(strconv.Itoa(i%100), "value")
    }
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        go set(strconv.Itoa(i%100), "value")
        go get(strconv.Itoa(i%100), "value")
    }
    for i := 0; i < 2*b.N; i++ {
        <-finished
    }
}

func GetSet(m *HashMap, finished chan struct{}) (set func(key, value string), get func(key, value string)) {
    return func(key, value string) {
            for i := 0; i < 10; i++ {
                m.Get(key)
            }
            finished <- struct{}{}
        }, func(key, value string) {
            for i := 0; i < 10; i++ {
                m.Set(key, value)
            }
            finished <- struct{}{}
        }
}

func GetSetSyncMap(m *sync.Map, finished chan struct{}) (get func(key, value string), set func(key, value string)) {
    get = func(key, value string) {
        for i := 0; i < 10; i++ {
            m.Load(key)
        }
        finished <- struct{}{}
    }
    set = func(key, value string) {
        for i := 0; i < 10; i++ {
            m.Store(key, value)
        }
        finished <- struct{}{}
    }
    return
}

func BenchmarkReadHashMapUint(b *testing.B) {
    m := setupHashMap(b)

    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            for i := uintptr(0); i < benchmarkItemCount; i++ {
                j, _ := m.Get(i)
                if j != i {
                    b.Fail()
                }
            }
        }
    })
}

func BenchmarkReadGoMapUintUnsafe(b *testing.B) {
    m := setupGoMap(b)
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            for i := uintptr(0); i < benchmarkItemCount; i++ {
                j := m[i]
                if j != i {
                    b.Fail()
                }
            }
        }
    })
}

func BenchmarkReadGoMapUintMutex(b *testing.B) {
    m := setupGoMap(b)
    l := &sync.RWMutex{}
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            for i := uintptr(0); i < benchmarkItemCount; i++ {
                l.RLock()
                j := m[i]
                l.RUnlock()
                if j != i {
                    b.Fail()
                }
            }
        }
    })
}

func BenchmarkReadGoSyncMapUint(b *testing.B) {
    m := setupGoSyncMap(b)
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            for i := uintptr(0); i < benchmarkItemCount; i++ {
                j, _ := m.Load(i)
                if j != i {
                    b.Fail()
                }
            }
        }
    })
}

func BenchmarkReadHashMapWithWritesUint(b *testing.B) {
    m := setupHashMap(b)
    var writer int32

    b.RunParallel(func(pb *testing.PB) {
        // use 1 thread as writer
        if atomic.CompareAndSwapInt32(&writer, 0, 1) {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    m.Set(i, i)
                }
            }
        } else {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    j, _ := m.Get(i)
                    if j != i {
                        b.Fail()
                    }
                }
            }
        }
    })
}

func BenchmarkReadGoMapWithWritesUintMutex(b *testing.B) {
    m := setupGoMap(b)
    l := &sync.RWMutex{}
    var writer int32

    b.RunParallel(func(pb *testing.PB) {
        // use 1 thread as writer
        if atomic.CompareAndSwapInt32(&writer, 0, 1) {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    l.Lock()
                    m[i] = i
                    l.Unlock()
                }
            }
        } else {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    l.RLock()
                    j := m[i]
                    l.RUnlock()
                    if j != i {
                        b.Fail()
                    }
                }
            }
        }
    })
}

func BenchmarkReadGoSyncMapWithWritesUint(b *testing.B) {
    m := setupGoSyncMap(b)
    var writer int32

    b.RunParallel(func(pb *testing.PB) {
        // use 1 thread as writer
        if atomic.CompareAndSwapInt32(&writer, 0, 1) {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    m.Store(i, i)
                }
            }
        } else {
            for pb.Next() {
                for i := uintptr(0); i < benchmarkItemCount; i++ {
                    j, _ := m.Load(i)
                    if j != i {
                        b.Fail()
                    }
                }
            }
        }
    })
}

func BenchmarkWriteHashMapUint(b *testing.B) {
    m := New()

    for n := 0; n < b.N; n++ {
        for i := uintptr(0); i < benchmarkItemCount; i++ {
            m.Set(i, i)
        }
    }
}

func BenchmarkWriteGoMapUnsafeUint(b *testing.B) {
    m := make(map[uintptr]uintptr)

    for n := 0; n < b.N; n++ {
        for i := uintptr(0); i < benchmarkItemCount; i++ {
            m[i] = i
        }
    }
}

func BenchmarkWriteGoMapMutexUint(b *testing.B) {
    m := make(map[uintptr]uintptr)
    l := &sync.RWMutex{}

    for n := 0; n < b.N; n++ {
        for i := uintptr(0); i < benchmarkItemCount; i++ {
            l.Lock()
            m[i] = i
            l.Unlock()
        }
    }
}

func BenchmarkWriteGoSyncMapUint(b *testing.B) {
    m := &sync.Map{}

    for n := 0; n < b.N; n++ {
        for i := uintptr(0); i < benchmarkItemCount; i++ {
            m.Store(i, i)
        }
    }
}