qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 14:00:03 -07:00
Code Releases Activity

runtime: make nanotime use monotonic clock in Solaris

Browse Source 
nanotime() currently uses the REALTIME clock to get the elapsed
time in Solaris. This commit changes it to use the MONOTONIC clock
instead, similar to how it's done in Linux and other OSs. Also changed
nanotime() and walltime() to call clock_gettime() library function
directly from Go code rather than from assembly.

Fixes #33674

Change-Id: Ie4a687b17d2140998ecd97af6ce048c86cf5fc02
Reviewed-on: https://go-review.googlesource.com/c/go/+/199502
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Aram Hăvărneanu <aram@mgk.ro>
This commit is contained in:
Jerrin Shaji George 2019-10-07 12:27:33 -07:00 committed by Ian Lance Taylor
parent c1ccae4d14
commit 2df5cdbadf
3 changed files with 14 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
src/runtime/os3_solaris.go
View File

@ -393,11 +393,16 @@ func munmap(addr unsafe.Pointer, n uintptr) {
sysvicall2(&libc_munmap, uintptr(addr), uintptr(n))
}
func nanotime2()
const (
_CLOCK_REALTIME = 3
_CLOCK_MONOTONIC = 4
)
//go:nosplit
func nanotime1() int64 {
return int64(sysvicall0((*libcFunc)(unsafe.Pointer(funcPC(nanotime2)))))
var ts mts
sysvicall2(&libc_clock_gettime, _CLOCK_MONOTONIC, uintptr(unsafe.Pointer(&ts)))
return ts.tv_sec*1e9 + ts.tv_nsec
}
//go:nosplit
@ -498,6 +503,12 @@ func usleep(µs uint32) {
usleep1(µs)
}
func walltime1() (sec int64, nsec int32) {
var ts mts
sysvicall2(&libc_clock_gettime, _CLOCK_REALTIME, uintptr(unsafe.Pointer(&ts)))
return ts.tv_sec, int32(ts.tv_nsec)
}
//go:nosplit
func write1(fd uintptr, buf unsafe.Pointer, nbyte int32) int32 {
return int32(sysvicall3(&libc_write, uintptr(fd), uintptr(buf), uintptr(nbyte)))

40
src/runtime/sys_solaris_amd64.s
View File

@ -29,26 +29,6 @@ TEXT runtime·miniterrno(SB),NOSPLIT,$0
MOVQ AX, (m_mOS+mOS_perrno)(BX)
RET
// int64 runtime·nanotime2(void);
//
// clock_gettime(3c) wrapper because Timespec is too large for
// runtime·nanotime stack.
//
// Called using runtime·sysvicall6 from os_solaris.c:/nanotime.
// NOT USING GO CALLING CONVENTION.
TEXT runtime·nanotime2(SB),NOSPLIT,$0
// need space for the timespec argument.
SUBQ $64, SP // 16 bytes will do, but who knows in the future?
MOVQ $3, DI // CLOCK_REALTIME from <sys/time_impl.h>
MOVQ SP, SI
LEAQ libc_clock_gettime(SB), AX
CALL AX
MOVQ (SP), AX // tv_sec from struct timespec
IMULQ $1000000000, AX // multiply into nanoseconds
ADDQ 8(SP), AX // tv_nsec, offset should be stable.
ADDQ $64, SP
RET
// pipe(3c) wrapper that returns fds in AX, DX.
// NOT USING GO CALLING CONVENTION.
TEXT runtime·pipe1(SB),NOSPLIT,$0
@ -338,23 +318,3 @@ TEXT runtime·osyield1(SB),NOSPLIT,$0
LEAQ libc_sched_yield(SB), AX
CALL AX
RET
// func walltime1() (sec int64, nsec int32)
TEXT runtime·walltime1(SB),NOSPLIT,$8-12
CALL runtime·nanotime1(SB)
MOVQ 0(SP), AX
// generated code for
// func f(x uint64) (uint64, uint64) { return x/1000000000, x%100000000 }
// adapted to reduce duplication
MOVQ AX, CX
MOVQ $1360296554856532783, AX
MULQ CX
ADDQ CX, DX
RCRQ $1, DX
SHRQ $29, DX
MOVQ DX, sec+0(FP)
IMULQ $1000000000, DX
SUBQ DX, CX
MOVL CX, nsec+8(FP)
RET

1
src/runtime/timestub2.go
View File

@ -6,6 +6,7 @@
// +build !windows
// +build !freebsd
// +build !aix
// +build !solaris
package runtime