//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = int64(timediv(ns, 1e9, &ts.tv_nsec))
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = int64(timediv(ns, 1e9, &ts.tv_nsec))
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = timediv(ns, 1e9, &ts.tv_nsec)
+ ts.tv_sec = int32(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = int64(timediv(ns, 1e9, &ts.tv_nsec))
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec32) setNsec(ns int64) {
- ts.tv_sec = timediv(ns, 1e9, &ts.tv_nsec)
+ ts.tv_sec = int32(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timespec struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- var newNS int32
- ts.tv_sec = int64(timediv(ns, 1e9, &newNS))
- ts.tv_nsec = int64(newNS)
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int64(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec32) setNsec(ns int64) {
- ts.tv_sec = timediv(ns, 1e9, &ts.tv_nsec)
+ ts.tv_sec = int32(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timespec struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- var newNS int32
- ts.tv_sec = int64(timediv(ns, 1e9, &newNS))
- ts.tv_nsec = int64(newNS)
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int64(ns % 1e9)
}
type stackt struct {
//go:nosplit
func (ts *timespec32) setNsec(ns int64) {
- ts.tv_sec = timediv(ns, 1e9, &ts.tv_nsec)
+ ts.tv_sec = int32(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timespec struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- var newNS int32
- ts.tv_sec = int64(timediv(ns, 1e9, &newNS))
- ts.tv_nsec = int64(newNS)
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int64(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = int64(timediv(ns, 1e9, &ts.tv_nsec))
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
//go:nosplit
func (ts *timespec) setNsec(ns int64) {
- ts.tv_sec = int64(timediv(ns, 1e9, &ts.tv_nsec))
+ ts.tv_sec = int64(ns / 1e9)
+ ts.tv_nsec = int32(ns % 1e9)
}
type timeval struct {
releasem(getg().m)
}
-var Timediv = timediv
-
type PIController struct {
piController
}
// The timeout is specified in microseconds - ensure that we
// do not end up dividing to zero, which would put us to sleep
// indefinitely...
- timeout = timediv(ns, 1000, nil)
+ timeout = int32(ns / 1000)
if timeout == 0 {
timeout = 1
}
func semasleep(ns int64) int {
gp := getg()
if ns >= 0 {
- ms := timediv(ns, 1000000, nil)
+ ms := int32(ns / 1000000)
if ms == 0 {
ms = 1
}
start := nanotime()
elapsed := int64(0)
for {
- ms := int64(timediv(ns-elapsed, 1000000, nil))
+ ms := (ns - elapsed) / 1000000
if ms == 0 {
ms = 1
}
throw("bad unsafe.Sizeof y1")
}
- if timediv(12345*1000000000+54321, 1000000000, &e) != 12345 || e != 54321 {
- throw("bad timediv")
- }
-
var z uint32
z = 1
if !atomic.Cas(&z, 1, 2) {
atomic.Store(&traceback_cache, t)
}
-// Poor mans 64-bit division.
-// This is a very special function, do not use it if you are not sure what you are doing.
-// int64 division is lowered into _divv() call on 386, which does not fit into nosplit functions.
-// Handles overflow in a time-specific manner.
-// This keeps us within no-split stack limits on 32-bit processors.
-//
-//go:nosplit
-func timediv(v int64, div int32, rem *int32) int32 {
- res := int32(0)
- for bit := 30; bit >= 0; bit-- {
- if v >= int64(div)<<uint(bit) {
- v = v - (int64(div) << uint(bit))
- // Before this for loop, res was 0, thus all these
- // power of 2 increments are now just bitsets.
- res |= 1 << uint(bit)
- }
- }
- if v >= int64(div) {
- if rem != nil {
- *rem = 0
- }
- return 0x7fffffff
- }
- if rem != nil {
- *rem = int32(v)
- }
- return res
-}
-
// Helpers for Go. Must be NOSPLIT, must only call NOSPLIT functions, and must not block.
//go:nosplit
import (
"flag"
- "fmt"
"internal/asan"
"internal/cpu"
"internal/msan"
}
}
-func TestTimediv(t *testing.T) {
- for _, tc := range []struct {
- num int64
- div int32
- ret int32
- rem int32
- }{
- {
- num: 8,
- div: 2,
- ret: 4,
- rem: 0,
- },
- {
- num: 9,
- div: 2,
- ret: 4,
- rem: 1,
- },
- {
- // Used by runtime.check.
- num: 12345*1000000000 + 54321,
- div: 1000000000,
- ret: 12345,
- rem: 54321,
- },
- {
- num: 1<<32 - 1,
- div: 2,
- ret: 1<<31 - 1, // no overflow.
- rem: 1,
- },
- {
- num: 1 << 32,
- div: 2,
- ret: 1<<31 - 1, // overflow.
- rem: 0,
- },
- {
- num: 1 << 40,
- div: 2,
- ret: 1<<31 - 1, // overflow.
- rem: 0,
- },
- {
- num: 1<<40 + 1,
- div: 1 << 10,
- ret: 1 << 30,
- rem: 1,
- },
- } {
- name := fmt.Sprintf("%d div %d", tc.num, tc.div)
- t.Run(name, func(t *testing.T) {
- // Double check that the inputs make sense using
- // standard 64-bit division.
- ret64 := tc.num / int64(tc.div)
- rem64 := tc.num % int64(tc.div)
- if ret64 != int64(int32(ret64)) {
- // Simulate timediv overflow value.
- ret64 = 1<<31 - 1
- rem64 = 0
- }
- if ret64 != int64(tc.ret) {
- t.Errorf("%d / %d got ret %d rem %d want ret %d rem %d", tc.num, tc.div, ret64, rem64, tc.ret, tc.rem)
- }
-
- var rem int32
- ret := Timediv(tc.num, tc.div, &rem)
- if ret != tc.ret || rem != tc.rem {
- t.Errorf("timediv %d / %d got ret %d rem %d want ret %d rem %d", tc.num, tc.div, ret, rem, tc.ret, tc.rem)
- }
- })
- }
-}
-
func BenchmarkProcYield(b *testing.B) {
benchN := func(n uint32) func(*testing.B) {
return func(b *testing.B) {