Reuse timers with sync.Pool

alloc_test.go

@@ -0,0 +1,13 @@
+package deadlock
+
+import (
+ "testing"
+)
+
+func BenchmarkCheckDeadlock(b *testing.B) {
+ ch := make(chan struct{})
+ close(ch)
+ for i := 0; i < b.N; i++ {
+ checkDeadlock(nil, nil, 0, ch)
+ }
+}

deadlock.go

@@ -182,54 +182,7 @@ func lock(lockFn func(), ptr interface{}) {
  } else {
  ch := make(chan struct{})
  currentID := goid.Get()
- go func() {
- for {
- t := time.NewTimer(Opts.DeadlockTimeout)
- defer t.Stop() // This runs after the losure finishes, but it's OK.
- select {
- case <-t.C:
- lo.mu.Lock()
- prev, ok := lo.cur[ptr]
- if !ok {
- lo.mu.Unlock()
- break // Nobody seems to be holding the lock, try again.
- }
- Opts.mu.Lock()
- fmt.Fprintln(Opts.LogBuf, header)
- fmt.Fprintln(Opts.LogBuf, "Previous place where the lock was grabbed")
- fmt.Fprintf(Opts.LogBuf, "goroutine %v lock %p\n", prev.gid, ptr)
- printStack(Opts.LogBuf, prev.stack)
- fmt.Fprintln(Opts.LogBuf, "Have been trying to lock it again for more than", Opts.DeadlockTimeout)
- fmt.Fprintf(Opts.LogBuf, "goroutine %v lock %p\n", currentID, ptr)
- printStack(Opts.LogBuf, stack)
- stacks := stacks()
- grs := bytes.Split(stacks, []byte("\n\n"))
- for _, g := range grs {
- if goid.ExtractGID(g) == prev.gid {
- fmt.Fprintln(Opts.LogBuf, "Here is what goroutine", prev.gid, "doing now")
- Opts.LogBuf.Write(g)
- fmt.Fprintln(Opts.LogBuf)
- }
- }
- lo.other(ptr)
- if Opts.PrintAllCurrentGoroutines {
- fmt.Fprintln(Opts.LogBuf, "All current goroutines:")
- Opts.LogBuf.Write(stacks)
- }
- fmt.Fprintln(Opts.LogBuf)
- if buf, ok := Opts.LogBuf.(*bufio.Writer); ok {
- buf.Flush()
- }
- Opts.mu.Unlock()
- lo.mu.Unlock()
- Opts.OnPotentialDeadlock()
- <-ch
- return
- case <-ch:
- return
- }
- }
- }()
+ go checkDeadlock(stack, ptr, currentID, ch)
  lockFn()
  postLock(stack, ptr)
  close(ch)
@@ -238,6 +191,74 @@ func lock(lockFn func(), ptr interface{}) {
  postLock(stack, ptr)
 }
 
+var timersPool sync.Pool
+
+func acquireTimer(d time.Duration) *time.Timer {
+ t, ok := timersPool.Get().(*time.Timer)
+ if ok {
+ _ = t.Reset(d)
+ return t
+ }
+ return time.NewTimer(Opts.DeadlockTimeout)
+}
+
+func releaseTimer(t *time.Timer) {
+ if !t.Stop() {
+ <-t.C
+ }
+ timersPool.Put(t)
+}
+
+func checkDeadlock(stack []uintptr, ptr interface{}, currentID int64, ch <-chan struct{}) {
+ t := acquireTimer(Opts.DeadlockTimeout)
+ defer releaseTimer(t)
+ for {
+ select {
+ case <-t.C:
+ lo.mu.Lock()
+ prev, ok := lo.cur[ptr]
+ if !ok {
+ lo.mu.Unlock()
+ break // Nobody seems to be holding the lock, try again.
+ }
+ Opts.mu.Lock()
+ fmt.Fprintln(Opts.LogBuf, header)
+ fmt.Fprintln(Opts.LogBuf, "Previous place where the lock was grabbed")
+ fmt.Fprintf(Opts.LogBuf, "goroutine %v lock %p\n", prev.gid, ptr)
+ printStack(Opts.LogBuf, prev.stack)
+ fmt.Fprintln(Opts.LogBuf, "Have been trying to lock it again for more than", Opts.DeadlockTimeout)
+ fmt.Fprintf(Opts.LogBuf, "goroutine %v lock %p\n", currentID, ptr)
+ printStack(Opts.LogBuf, stack)
+ stacks := stacks()
+ grs := bytes.Split(stacks, []byte("\n\n"))
+ for _, g := range grs {
+ if goid.ExtractGID(g) == prev.gid {
+ fmt.Fprintln(Opts.LogBuf, "Here is what goroutine", prev.gid, "doing now")
+ Opts.LogBuf.Write(g)
+ fmt.Fprintln(Opts.LogBuf)
+ }
+ }
+ lo.other(ptr)
+ if Opts.PrintAllCurrentGoroutines {
+ fmt.Fprintln(Opts.LogBuf, "All current goroutines:")
+ Opts.LogBuf.Write(stacks)
+ }
+ fmt.Fprintln(Opts.LogBuf)
+ if buf, ok := Opts.LogBuf.(*bufio.Writer); ok {
+ buf.Flush()
+ }
+ Opts.mu.Unlock()
+ lo.mu.Unlock()
+ Opts.OnPotentialDeadlock()
+ <-ch
+ return
+ case <-ch:
+ return
+ }
+ t.Reset(Opts.DeadlockTimeout)
+ }
+}
+
 type lockOrder struct {
  mu sync.Mutex
  cur map[interface{}]stackGID // stacktraces + gids for the locks currently taken.