runtime: prepare for extensions to waiting M list

Move the nextwaitm field into a small struct, in preparation for
additional metadata to track how long Ms need to wait for locks.

For #66999

Change-Id: Ib40e43c15cde22f7e35922641107973d99439ecd
Reviewed-on: https://go-review.googlesource.com/c/go/+/585635
Reviewed-by: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Rhys Hiltner <rhys.hiltner@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

diff --git a/src/runtime/lock_sema.go b/src/runtime/lock_sema.go
index 32d2235ad3ab900371a8241e6ba399a348b59025..1c24cf6d30fef52016144875ea7b8ada0220e51f 100644 (file)
--- a/src/runtime/lock_sema.go
+++ b/src/runtime/lock_sema.go
@@ -77,11 +77,11 @@ Loop:
                        osyield()
                } else {
                        // Someone else has it.
-                       // l->waitm points to a linked list of M's waiting
-                       // for this lock, chained through m->nextwaitm.
+                       // l.key points to a linked list of M's waiting
+                       // for this lock, chained through m.mWaitList.next.
                        // Queue this M.
                        for {
-                               gp.m.nextwaitm = muintptr(v &^ locked)
+                               gp.m.mWaitList.next = muintptr(v &^ locked)
                                if atomic.Casuintptr(&l.key, v, uintptr(unsafe.Pointer(gp.m))|locked) {
                                        break
                                }
@@ -119,7 +119,7 @@ func unlock2(l *mutex) {
                        // Other M's are waiting for the lock.
                        // Dequeue an M.
                        mp = muintptr(v &^ locked).ptr()
-                       if atomic.Casuintptr(&l.key, v, uintptr(mp.nextwaitm)) {
+                       if atomic.Casuintptr(&l.key, v, uintptr(mp.mWaitList.next)) {
                                // Dequeued an M.  Wake it.
                                semawakeup(mp)
                                break
@@ -200,7 +200,7 @@ func notetsleep_internal(n *note, ns int64, gp *g, deadline int64) bool {
        // This reduces the nosplit footprint of notetsleep_internal.
        gp = getg()
 
-       // Register for wakeup on n->waitm.
+       // Register for wakeup on n.key.
        if !atomic.Casuintptr(&n.key, 0, uintptr(unsafe.Pointer(gp.m))) {
                // Must be locked (got wakeup).
                if n.key != locked {

diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index b51a1ad3ce3d16ffb24d115ed78e09d3dd8b24dc..b97fac787eb165c977082e21de63b77c338c410c 100644 (file)
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -667,6 +667,17 @@ func (lt *lockTimer) end() {
        }
 }
 
+// mWaitList is part of the M struct, and holds the list of Ms that are waiting
+// for a particular runtime.mutex.
+//
+// When an M is unable to immediately obtain a lock, it adds itself to the list
+// of Ms waiting for the lock. It does that via this struct's next field,
+// forming a singly-linked list with the mutex's key field pointing to the head
+// of the list.
+type mWaitList struct {
+       next muintptr // next m waiting for lock (set by us, cleared by another during unlock)
+}
+
 type mLockProfile struct {
        waitTime   atomic.Int64 // total nanoseconds spent waiting in runtime.lockWithRank
        stack      []uintptr    // stack that experienced contention in runtime.lockWithRank

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index ff11414e3ef635e3e6efbfb3a22f045cc603daf2..470b82991233acf83c98f55cb83285c8f5b142af 100644 (file)
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -596,8 +596,8 @@ type m struct {
        createstack   [32]uintptr // stack that created this thread, it's used for StackRecord.Stack0, so it must align with it.
        lockedExt     uint32      // tracking for external LockOSThread
        lockedInt     uint32      // tracking for internal lockOSThread
-       nextwaitm     muintptr    // next m waiting for lock
 
+       mWaitList    mWaitList    // list of runtime lock waiters
        mLockProfile mLockProfile // fields relating to runtime.lock contention
        profStack    []uintptr    // used for memory/block/mutex stack traces