Using atomics instead of mutexes could improve performance

[enkeyz]

Using atomics instead of mutexes can improve performance(just a small micro optimization). Also made a benchmark, so you can see the difference. I'd make a PR if interested @schollz

package main

import (
	"sync"
	"sync/atomic"
)

type WithMutex struct {
	mu    sync.Mutex
	value int64
}

type WithAtomic struct {
	value int64
}

func (wm *WithMutex) Increase() {
	wm.mu.Lock()
	defer wm.mu.Unlock()
	wm.value++
}

func (wa *WithAtomic) Increase() {
	atomic.AddInt64(&wa.value, 1)
}

benchmark file:

package main

import "testing"

func BenchmarkMutex(b *testing.B) {
	tMutex := WithMutex{}

	for i := 0; i < b.N; i++ {
		tMutex.Increase()
	}
}

func BenchmarkAtomic(b *testing.B) {
	tAtomic := WithAtomic{}

	for i := 0; i < b.N; i++ {
		tAtomic.Increase()
	}
}

benchmark result:

goos: linux
goarch: amd64
pkg: test_atomic
cpu: Intel(R) Core(TM) i5-7600K CPU @ 3.80GHz
BenchmarkMutex
BenchmarkMutex-4        79002190                14.23 ns/op            0 B/op          0 allocs/op
BenchmarkAtomic
BenchmarkAtomic-4       183248221                6.359 ns/op           0 B/op          0 allocs/op
PASS
ok      test_atomic     2.977s

[schollz]

Would love a PR ! Looks awesome

[rustiever]

hi @schollz, can i take up this ?

[schollz]

@rustiever Sure

[rustiever]

Hey it looks like atomic package doesn't support atomic operation on float64, and are we trying to remove mutex completely? @schollz

[schollz]

I think the goal of this PR is for optimization, so if mutex isn't optimal yes

[rustiever]

do you have any idea how to support atomic operations on float64?

[martikan]

@rustiever

Maybe its an old thread. But you can use it with math.Float64frombits() and math.Float64bits()..
Transform an unsigned integer to float and you can do the opposite as well.
After that you can use the atomic operations with unsigned int.
This 'trick' works because int32/64 and float32/64 are stored in the same data structure.

[mxey]

I would recommend against this. It would make the code harder to understand, and I doubt the locking is actually a bottleneck. Sending out the rendered progress bar is probably the most expensive part, but a profile should tell you.