runtime: convert timer0When/timerModifiedEarliest to atomic.Int64

So they match with when/nextwhen fields of timer struct.

Updates #53821

Change-Id: Iad0cceb129796745774facfbbfe5756df3a320b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/423117
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index 1b33d59736f28eeb71845cd52b4f0a734a361539..d572fa2215e9fd68d78939bde42c60eb4e6e52f0 100644 (file)
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -3329,8 +3329,8 @@ func dropg() {
 func checkTimers(pp *p, now int64) (rnow, pollUntil int64, ran bool) {
        // If it's not yet time for the first timer, or the first adjusted
        // timer, then there is nothing to do.
-       next := int64(pp.timer0When.Load())
-       nextAdj := int64(pp.timerModifiedEarliest.Load())
+       next := pp.timer0When.Load()
+       nextAdj := pp.timerModifiedEarliest.Load()
        if next == 0 || (nextAdj != 0 && nextAdj < next) {
                next = nextAdj
        }

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 21dba96a59857596830d5c595ea0a96a485916e7..56318e2bce7cf9072fe8e0db448fa212cf411e0e 100644 (file)
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -671,13 +671,13 @@ type p struct {
 
        // The when field of the first entry on the timer heap.
        // This is 0 if the timer heap is empty.
-       timer0When atomic.Uint64
+       timer0When atomic.Int64
 
        // The earliest known nextwhen field of a timer with
        // timerModifiedEarlier status. Because the timer may have been
        // modified again, there need not be any timer with this value.
        // This is 0 if there are no timerModifiedEarlier timers.
-       timerModifiedEarliest atomic.Uint64
+       timerModifiedEarliest atomic.Int64
 
        // Per-P GC state
        gcAssistTime         int64 // Nanoseconds in assistAlloc

diff --git a/src/runtime/time.go b/src/runtime/time.go
index 7ce3caf1135fa6ac72a3f2fb1268ff0035d8c678..5f12a1a297c7cdb9e82cb7142497b0c5fcba358d 100644 (file)
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -301,7 +301,7 @@ func doaddtimer(pp *p, t *timer) {
        pp.timers = append(pp.timers, t)
        siftupTimer(pp.timers, i)
        if t == pp.timers[0] {
-               pp.timer0When.Store(uint64(t.when))
+               pp.timer0When.Store(t.when)
        }
        atomic.Xadd(&pp.numTimers, 1)
 }
@@ -672,7 +672,7 @@ func adjusttimers(pp *p, now int64) {
        // We'll postpone looking through all the adjusted timers until
        // one would actually expire.
        first := pp.timerModifiedEarliest.Load()
-       if first == 0 || int64(first) > now {
+       if first == 0 || first > now {
                if verifyTimers {
                        verifyTimerHeap(pp)
                }
@@ -754,8 +754,8 @@ func addAdjustedTimers(pp *p, moved []*timer) {
 //
 //go:nowritebarrierrec
 func nobarrierWakeTime(pp *p) int64 {
-       next := int64(pp.timer0When.Load())
-       nextAdj := int64(pp.timerModifiedEarliest.Load())
+       next := pp.timer0When.Load()
+       nextAdj := pp.timerModifiedEarliest.Load()
        if next == 0 || (nextAdj != 0 && nextAdj < next) {
                next = nextAdj
        }
@@ -1005,7 +1005,7 @@ func updateTimer0When(pp *p) {
        if len(pp.timers) == 0 {
                pp.timer0When.Store(0)
        } else {
-               pp.timer0When.Store(uint64(pp.timers[0].when))
+               pp.timer0When.Store(pp.timers[0].when)
        }
 }
 
@@ -1019,7 +1019,7 @@ func updateTimerModifiedEarliest(pp *p, nextwhen int64) {
                        return
                }
 
-               if pp.timerModifiedEarliest.CompareAndSwap(old, uint64(nextwhen)) {
+               if pp.timerModifiedEarliest.CompareAndSwap(old, nextwhen) {
                        return
                }
        }
@@ -1040,12 +1040,12 @@ func timeSleepUntil() int64 {
                        continue
                }
 
-               w := int64(pp.timer0When.Load())
+               w := pp.timer0When.Load()
                if w != 0 && w < next {
                        next = w
                }
 
-               w = int64(pp.timerModifiedEarliest.Load())
+               w = pp.timerModifiedEarliest.Load()
                if w != 0 && w < next {
                        next = w
                }