fix extra heap allocations when detector is disabled

deadlock.go

@@ -71,13 +71,20 @@ func (m *Mutex) id() lockID {
 // Unless deadlock detection is disabled, logs potential deadlocks to Opts.LogBuf,
 // calling Opts.OnPotentialDeadlock on each occasion.
 func (m *Mutex) Lock() {
+	// shortcut for disabled deadlock detection to prevent extra copying of `m.mu.Lock` to the heap
+	if Opts.Disable {
+		m.mu.Lock()
+		return
+	}
+
 	counterMu.Lock()
 	if m.muId == 0 {
 		m.muId = currID
 		currID++
 	}
 	counterMu.Unlock()
-	lock(m.mu.Lock, m, false)
+
+	lockEnabled(m.mu.Lock, m, false)
 }
 
 // Unlock unlocks the mutex.
@@ -114,14 +121,19 @@ func (m *RWMutex) id() lockID {
 // Unless deadlock detection is disabled, logs potential deadlocks to Opts.LogBuf,
 // calling Opts.OnPotentialDeadlock on each occasion.
 func (m *RWMutex) Lock() {
+	if Opts.Disable {
+		m.mu.Lock()
+		return
+	}
+
 	counterMu.Lock()
 	if m.muId == 0 {
 		m.muId = currID
 		currID++
 	}
 	counterMu.Unlock()
 
-	lock(m.mu.Lock, m, false)
+	lockEnabled(m.mu.Lock, m, false)
 }
 
 // Unlock unlocks the mutex for writing.  It is a run-time error if rw is
@@ -142,14 +154,19 @@ func (m *RWMutex) Unlock() {
 // Unless deadlock detection is disabled, logs potential deadlocks to Opts.LogBuf,
 // calling Opts.OnPotentialDeadlock on each occasion.
 func (m *RWMutex) RLock() {
+	if Opts.Disable {
+		m.mu.RLock()
+		return
+	}
+
 	counterMu.Lock()
 	if m.muId == 0 {
 		m.muId = currID
 		currID++
 	}
 	counterMu.Unlock()
 
-	lock(m.mu.RLock, m, true)
+	lockEnabled(m.mu.RLock, m, true)
 }
 
 // RUnlock undoes a single RLock call;
@@ -189,11 +206,7 @@ func checkLockOrdering(skip int, p identifiable, gid int64) {
 	lo.checkLockOrdering(skip, p, gid)
 }
 
-func lock(lockFn func(), ptr identifiable, preLockCheckRecursiveLocking bool) {
-	if Opts.Disable {
-		lockFn()
-		return
-	}
+func lockEnabled(lockFn func(), ptr identifiable, preLockCheckRecursiveLocking bool) {
 	// grab the current goroutine identifier
 	gid := goid.Get()
 	preLock(4, ptr, gid, preLockCheckRecursiveLocking)

deadlock_test.go

@@ -275,3 +275,24 @@ func TestRWMutexDoubleRLockFail(t *testing.T) {
 		t.Fatalf("expected 1 deadlocks, detected %d", deadlocks)
 	}
 }
+
+//go:noinline
+func benchRWAlloc(mu *RWMutex, res *int) {
+	mu.Lock()
+	defer mu.Unlock() // defer prefers inlining for the benchmark
+	*res++
+}
+
+// BenchmarkRWMutexAlloc demonstrates there is one alloc per lock invocation.
+func BenchmarkRWMutexAlloc(b *testing.B) {
+	disable := Opts.Disable
+	Opts.Disable = true
+	defer func() {
+		Opts.Disable = disable
+	}()
+	var mu *RWMutex = &RWMutex{}
+	var res int
+	for i := 0; i < b.N; i++ {
+		benchRWAlloc(mu, &res)
+	}
+}