105 lines
2.9 KiB
Go
105 lines
2.9 KiB
Go
|
package regexp2
|
||
|
|
|
||
|
|
import (
|
||
|
|
"sync"
|
||
|
|
"sync/atomic"
|
||
|
|
"time"
|
||
|
|
)
|
||
|
|
|
||
|
|
// fasttime holds a time value (ticks since clock initialization)
|
||
|
|
type fasttime int64
|
||
|
|
|
||
|
|
// fastclock provides a fast clock implementation.
|
||
|
|
//
|
||
|
|
// A background goroutine periodically stores the current time
|
||
|
|
// into an atomic variable.
|
||
|
|
//
|
||
|
|
// A deadline can be quickly checked for expiration by comparing
|
||
|
|
// its value to the clock stored in the atomic variable.
|
||
|
|
//
|
||
|
|
// The goroutine automatically stops once clockEnd is reached.
|
||
|
|
// (clockEnd covers the largest deadline seen so far + some
|
||
|
|
// extra time). This ensures that if regexp2 with timeouts
|
||
|
|
// stops being used we will stop background work.
|
||
|
|
type fastclock struct {
|
||
|
|
// current and clockEnd can be read via atomic loads.
|
||
|
|
// Reads and writes of other fields require mu to be held.
|
||
|
|
mu sync.Mutex
|
||
|
|
|
||
|
|
start time.Time // Time corresponding to fasttime(0)
|
||
|
|
current atomicTime // Current time (approximate)
|
||
|
|
clockEnd atomicTime // When clock updater is supposed to stop (>= any existing deadline)
|
||
|
|
running bool // Is a clock updater running?
|
||
|
|
}
|
||
|
|
|
||
|
|
var fast fastclock
|
||
|
|
|
||
|
|
// reached returns true if current time is at or past t.
|
||
|
|
func (t fasttime) reached() bool {
|
||
|
|
return fast.current.read() >= t
|
||
|
|
}
|
||
|
|
|
||
|
|
// makeDeadline returns a time that is approximately time.Now().Add(d)
|
||
|
|
func makeDeadline(d time.Duration) fasttime {
|
||
|
|
// Increase the deadline since the clock we are reading may be
|
||
|
|
// just about to tick forwards.
|
||
|
|
end := fast.current.read() + durationToTicks(d+clockPeriod)
|
||
|
|
|
||
|
|
// Start or extend clock if necessary.
|
||
|
|
if end > fast.clockEnd.read() {
|
||
|
|
extendClock(end)
|
||
|
|
}
|
||
|
|
return end
|
||
|
|
}
|
||
|
|
|
||
|
|
// extendClock ensures that clock is live and will run until at least end.
|
||
|
|
func extendClock(end fasttime) {
|
||
|
|
fast.mu.Lock()
|
||
|
|
defer fast.mu.Unlock()
|
||
|
|
|
||
|
|
if fast.start.IsZero() {
|
||
|
|
fast.start = time.Now()
|
||
|
|
}
|
||
|
|
|
||
|
|
// Extend the running time to cover end as well as a bit of slop.
|
||
|
|
if shutdown := end + durationToTicks(time.Second); shutdown > fast.clockEnd.read() {
|
||
|
|
fast.clockEnd.write(shutdown)
|
||
|
|
}
|
||
|
|
|
||
|
|
// Start clock if necessary
|
||
|
|
if !fast.running {
|
||
|
|
fast.running = true
|
||
|
|
go runClock()
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
func durationToTicks(d time.Duration) fasttime {
|
||
|
|
// Downscale nanoseconds to approximately a millisecond so that we can avoid
|
||
|
|
// overflow even if the caller passes in math.MaxInt64.
|
||
|
|
return fasttime(d) >> 20
|
||
|
|
}
|
||
|
|
|
||
|
|
// clockPeriod is the approximate interval between updates of approximateClock.
|
||
|
|
const clockPeriod = 100 * time.Millisecond
|
||
|
|
|
||
|
|
func runClock() {
|
||
|
|
fast.mu.Lock()
|
||
|
|
defer fast.mu.Unlock()
|
||
|
|
|
||
|
|
for fast.current.read() <= fast.clockEnd.read() {
|
||
|
|
// Unlock while sleeping.
|
||
|
|
fast.mu.Unlock()
|
||
|
|
time.Sleep(clockPeriod)
|
||
|
|
fast.mu.Lock()
|
||
|
|
|
||
|
|
newTime := durationToTicks(time.Since(fast.start))
|
||
|
|
fast.current.write(newTime)
|
||
|
|
}
|
||
|
|
fast.running = false
|
||
|
|
}
|
||
|
|
|
||
|
|
type atomicTime struct{ v int64 } // Should change to atomic.Int64 when we can use go 1.19
|
||
|
|
|
||
|
|
func (t *atomicTime) read() fasttime { return fasttime(atomic.LoadInt64(&t.v)) }
|
||
|
|
func (t *atomicTime) write(v fasttime) { atomic.StoreInt64(&t.v, int64(v)) }
|