Merge pull request #2 from deso-protocol/ln/merge-latest-sasha-s-updates

Ln/merge latest sasha s updates

Author: lazynina

.github/workflows/go.yml

@@ -2,24 +2,31 @@ name: Go
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 jobs:
-
   build:
     runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        go:
+          - "1.17"
+          - "1.20"
+          - "1.22"
+          - "1.23"
     steps:
-    - uses: actions/checkout@v2
+      - uses: actions/checkout@v4
 
-    - name: Set up Go
-      uses: actions/setup-go@v2
-      with:
-        go-version: 1.17
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: ${{ matrix.go }}
 
-    - name: Build
-      run: go build -v ./...
+      - name: Build
+        run: go build -v ./...
 
-    - name: Test
-      run: go test -v ./...
+      - name: Test
+        run: go test -v -bench=. -coverprofile=coverage.txt ./...

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

@@ -21,7 +21,7 @@ var Opts = struct {
 	// Would disable lock order based deadlock detection if DisableLockOrderDetection == true.
 	DisableLockOrderDetection bool
 	// Waiting for a lock for longer than DeadlockTimeout is considered a deadlock.
-	// Ignored is DeadlockTimeout <= 0.
+	// Ignored if DeadlockTimeout <= 0.
 	DeadlockTimeout time.Duration
 	// OnPotentialDeadlock is called each time a potential deadlock is detected -- either based on
 	// lock order or on lock wait time.
@@ -71,6 +71,9 @@ type WaitGroup struct {
 	sync.WaitGroup
 }
 
+// NewCond is a sync.NewCond wrapper
+var NewCond = sync.NewCond
+
 // A Mutex is a drop-in replacement for sync.Mutex.
 // Performs deadlock detection unless disabled in Opts.
 type Mutex struct {
@@ -157,12 +160,12 @@ func (m *RWMutex) RLocker() sync.Locker {
 	return (*rlocker)(m)
 }
 
-func preLock(skip int, p interface{}) {
-	lo.preLock(skip, p)
+func preLock(stack []uintptr, p interface{}) {
+	lo.preLock(stack, p)
 }
 
-func postLock(skip int, p interface{}) {
-	lo.postLock(skip, p)
+func postLock(stack []uintptr, p interface{}) {
+	lo.postLock(stack, p)
 }
 
 func postUnlock(p interface{}) {
@@ -174,65 +177,88 @@ func lock(lockFn func(), ptr interface{}) {
 		lockFn()
 		return
 	}
-	preLock(4, ptr)
+	stack := callers(1)
+	preLock(stack, ptr)
 	if Opts.DeadlockTimeout <= 0 {
 		lockFn()
 	} else {
 		ch := make(chan struct{})
-		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", goid.Get(), ptr)
-					printStack(Opts.LogBuf, callers(2))
-					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
-				}
-			}
-		}()
+		currentID := goid.Get()
+		go checkDeadlock(stack, ptr, currentID, ch)
 		lockFn()
-		postLock(4, ptr)
+		postLock(stack, ptr)
 		close(ch)
 		return
 	}
-	postLock(4, ptr)
+	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 {
@@ -265,19 +291,17 @@ func newLockOrder() *lockOrder {
 	}
 }
 
-func (l *lockOrder) postLock(skip int, p interface{}) {
-	stack := callers(skip)
+func (l *lockOrder) postLock(stack []uintptr, p interface{}) {
 	gid := goid.Get()
 	l.mu.Lock()
 	l.cur[p] = stackGID{stack, gid}
 	l.mu.Unlock()
 }
 
-func (l *lockOrder) preLock(skip int, p interface{}) {
+func (l *lockOrder) preLock(stack []uintptr, p interface{}) {
 	if Opts.DisableLockOrderDetection {
 		return
 	}
-	stack := callers(skip)
 	gid := goid.Get()
 	l.mu.Lock()
 	for b, bs := range l.cur {

go.mod

@@ -1,5 +1,3 @@
 module github.com/deso-protocol/go-deadlock
 
-require github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 // indirect
-
-go 1.13
+require github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7

go.sum

@@ -1,2 +1,2 @@
-github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp0hoxKjt1H5pDo6utceo3dQVK3I5XQ=
-github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7 h1:Dx7Ovyv/SFnMFw3fD4oEoeorXc6saIiQ23LrGLth0Gw=
+github.com/petermattis/goid v0.0.0-20240813172612-4fcff4a6cae7/go.mod h1:pxMtw7cyUw6B2bRH0ZBANSPg+AoSud1I1iyJHI69jH4=

test.sh

@@ -4,7 +4,7 @@ set -e
 echo "" > coverage.txt
 
 for d in $(go list ./...); do
-    go test -coverprofile=profile.out -covermode=atomic "$d"
+    go test -bench=. -coverprofile=profile.out -covermode=atomic "$d"
     if [ -f profile.out ]; then
         cat profile.out >> coverage.txt
         rm profile.out

trylock.go

@@ -0,0 +1,39 @@
+// +build go1.18
+
+package deadlock
+
+// TryLock tries to lock the mutex.
+// Returns false if the lock is already in use, true otherwise.
+func (m *Mutex) TryLock() bool {
+	return trylock(m.mu.TryLock, m)
+}
+
+// TryLock tries to lock rw for writing.
+// Returns false if the lock is already locked for reading or writing, true otherwise.
+func (m *RWMutex) TryLock() bool {
+	return trylock(m.mu.TryLock, m)
+}
+
+// TryRLock tries to lock rw for reading.
+// Returns false if the lock is already locked for writing, true otherwise.
+func (m *RWMutex) TryRLock() bool {
+	return trylock(m.mu.TryRLock, m)
+}
+
+// trylock can not deadlock, so there is no deadlock detection.
+// lock ordering is still supported by calling into preLock/postLock,
+// and in failed attempt into postUnlock to unroll the state added by preLock.
+func trylock(lockFn func() bool, ptr interface{}) bool {
+	if Opts.Disable {
+		return lockFn()
+	}
+	stack := callers(1)
+	preLock(stack, ptr)
+	ret := lockFn()
+	if ret {
+		postLock(stack, ptr)
+	} else {
+		postUnlock(ptr)
+	}		
+	return ret
+}