Skip to content

Commit

Permalink
runtime: use CreateWaitableTimerEx to implement usleep
Browse files Browse the repository at this point in the history
@jstarks suggested that recent versions of Windows provide access to high resolution timers. See

#8687 (comment)

for details.

I tried to run this C program on my Windows 10 computer

```
 #include <stdio.h>
 #include <Windows.h>

 #pragma comment(lib, "Winmm.lib")

// Apparently this is already defined when I use msvc cl.
//#define CREATE_WAITABLE_TIMER_HIGH_RESOLUTION = 0x00000002;

int usleep(HANDLE timer, LONGLONG d) {
	LARGE_INTEGER liDueTime;
	DWORD ret;
	LARGE_INTEGER StartingTime, EndingTime, ElapsedMicroseconds;
	LARGE_INTEGER Frequency;

	QueryPerformanceFrequency(&Frequency);
	QueryPerformanceCounter(&StartingTime);

	liDueTime.QuadPart = d;
	liDueTime.QuadPart = liDueTime.QuadPart * 10;	// us into 100 of ns units
	liDueTime.QuadPart = -liDueTime.QuadPart;	// negative for relative dure time

	if (!SetWaitableTimer(timer, &liDueTime, 0, NULL, NULL, 0)) {
		printf("SetWaitableTimer failed: errno=%d\n", GetLastError());
		return 1;
	}

	ret = WaitForSingleObject(timer, INFINITE);
	if (ret != WAIT_OBJECT_0) {
		printf("WaitForSingleObject failed: ret=%d errno=%d\n", ret, GetLastError());
		return 1;
	}

	QueryPerformanceCounter(&EndingTime);
	ElapsedMicroseconds.QuadPart = EndingTime.QuadPart - StartingTime.QuadPart;
	ElapsedMicroseconds.QuadPart *= 1000000;
	ElapsedMicroseconds.QuadPart /= Frequency.QuadPart;

	printf("delay is %lld us - slept for %lld us\n", d, ElapsedMicroseconds.QuadPart);

	return 0;
}

int testTimer(DWORD createFlag)
{
	HANDLE timer;

	timer = CreateWaitableTimerEx(NULL, NULL, createFlag, TIMER_ALL_ACCESS);
	if (timer == NULL) {
		printf("CreateWaitableTimerEx failed: errno=%d\n", GetLastError());
		return 1;
	}

	usleep(timer, 1000LL);
	usleep(timer, 100LL);
	usleep(timer, 10LL);
	usleep(timer, 1LL);

	CloseHandle(timer);

	return 0;
}

int main()
{
	printf("\n1. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is off - timeBeginPeriod is off\n");
	testTimer(0);

	printf("\n2. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is on - timeBeginPeriod is off\n");
	testTimer(CREATE_WAITABLE_TIMER_HIGH_RESOLUTION);

	timeBeginPeriod(1);

	printf("\n3. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is off - timeBeginPeriod is on\n");
	testTimer(0);

	printf("\n4. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is on - timeBeginPeriod is on\n");
	testTimer(CREATE_WAITABLE_TIMER_HIGH_RESOLUTION);
}
```

and I see this output

```
1. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is off - timeBeginPeriod is off
delay is 1000 us - slept for 4045 us
delay is 100 us - slept for 3915 us
delay is 10 us - slept for 3291 us
delay is 1 us - slept for 2234 us

2. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is on - timeBeginPeriod is off
delay is 1000 us - slept for 1076 us
delay is 100 us - slept for 569 us
delay is 10 us - slept for 585 us
delay is 1 us - slept for 17 us

3. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is off - timeBeginPeriod is on
delay is 1000 us - slept for 742 us
delay is 100 us - slept for 893 us
delay is 10 us - slept for 414 us
delay is 1 us - slept for 920 us

4. CREATE_WAITABLE_TIMER_HIGH_RESOLUTION is on - timeBeginPeriod is on
delay is 1000 us - slept for 1466 us
delay is 100 us - slept for 559 us
delay is 10 us - slept for 535 us
delay is 1 us - slept for 5 us
```

That shows, that indeed using CREATE_WAITABLE_TIMER_HIGH_RESOLUTION
will provide sleeps as low as about 500 microseconds, while our
current approach provides about 1 millisecond sleep.

New approach also does not require for timeBeginPeriod to be on,
so this change solves long standing problem with go programs draining
laptop battery, because it calls timeBeginPeriod.

This change will only run on systems where
CREATE_WAITABLE_TIMER_HIGH_RESOLUTION flag is available. If not
available, the runtime will fallback to original code that uses
timeBeginPeriod.

This is how this change affects benchmark reported in issue #14790

name               old time/op  new time/op  delta
ChanToSyscallPing  1.05ms ± 2%  0.68ms ±11%  -35.43%  (p=0.000 n=10+10)

The benchmark was run with GOMAXPROCS set to 1.

Fixes #8687
Updates #14790

Change-Id: I5b97ba58289c088c17c05292e12e45285c467eae
Reviewed-on: https://go-review.googlesource.com/c/go/+/248699
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Alex Brainman <alex.brainman@gmail.com>
Reviewed-by: Austin Clements <austin@google.com>
  • Loading branch information
alexbrainman committed Oct 18, 2020
1 parent fc98165 commit 515e6a9
Show file tree
Hide file tree
Showing 4 changed files with 144 additions and 2 deletions.
73 changes: 71 additions & 2 deletions src/runtime/os_windows.go
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,7 @@ const (
//go:cgo_import_dynamic runtime._CreateIoCompletionPort CreateIoCompletionPort%4 "kernel32.dll"
//go:cgo_import_dynamic runtime._CreateThread CreateThread%6 "kernel32.dll"
//go:cgo_import_dynamic runtime._CreateWaitableTimerA CreateWaitableTimerA%3 "kernel32.dll"
//go:cgo_import_dynamic runtime._CreateWaitableTimerExW CreateWaitableTimerExW%4 "kernel32.dll"
//go:cgo_import_dynamic runtime._DuplicateHandle DuplicateHandle%7 "kernel32.dll"
//go:cgo_import_dynamic runtime._ExitProcess ExitProcess%1 "kernel32.dll"
//go:cgo_import_dynamic runtime._FreeEnvironmentStringsW FreeEnvironmentStringsW%1 "kernel32.dll"
Expand Down Expand Up @@ -68,6 +69,7 @@ var (
_CreateIoCompletionPort,
_CreateThread,
_CreateWaitableTimerA,
_CreateWaitableTimerExW,
_DuplicateHandle,
_ExitProcess,
_FreeEnvironmentStringsW,
Expand Down Expand Up @@ -151,6 +153,8 @@ type mOS struct {
waitsema uintptr // semaphore for parking on locks
resumesema uintptr // semaphore to indicate suspend/resume

highResTimer uintptr // high resolution timer handle used in usleep

// preemptExtLock synchronizes preemptM with entry/exit from
// external C code.
//
Expand Down Expand Up @@ -402,18 +406,64 @@ const osRelaxMinNS = 60 * 1e6
// osRelax is called by the scheduler when transitioning to and from
// all Ps being idle.
//
// On Windows, it adjusts the system-wide timer resolution. Go needs a
// Some versions of Windows have high resolution timer. For those
// versions osRelax is noop.
// For Windows versions without high resolution timer, osRelax
// adjusts the system-wide timer resolution. Go needs a
// high resolution timer while running and there's little extra cost
// if we're already using the CPU, but if all Ps are idle there's no
// need to consume extra power to drive the high-res timer.
func osRelax(relax bool) uint32 {
if haveHighResTimer {
// If the high resolution timer is available, the runtime uses the timer
// to sleep for short durations. This means there's no need to adjust
// the global clock frequency.
return 0
}

if relax {
return uint32(stdcall1(_timeEndPeriod, 1))
} else {
return uint32(stdcall1(_timeBeginPeriod, 1))
}
}

// haveHighResTimer indicates that the CreateWaitableTimerEx
// CREATE_WAITABLE_TIMER_HIGH_RESOLUTION flag is available.
var haveHighResTimer = false

// createHighResTimer calls CreateWaitableTimerEx with
// CREATE_WAITABLE_TIMER_HIGH_RESOLUTION flag to create high
// resolution timer. createHighResTimer returns new timer
// handle or 0, if CreateWaitableTimerEx failed.
func createHighResTimer() uintptr {
const (
// As per @jstarks, see
// https://github.com/golang/go/issues/8687#issuecomment-656259353
_CREATE_WAITABLE_TIMER_HIGH_RESOLUTION = 0x00000002

_SYNCHRONIZE = 0x00100000
_TIMER_QUERY_STATE = 0x0001
_TIMER_MODIFY_STATE = 0x0002
)
return stdcall4(_CreateWaitableTimerExW, 0, 0,
_CREATE_WAITABLE_TIMER_HIGH_RESOLUTION,
_SYNCHRONIZE|_TIMER_QUERY_STATE|_TIMER_MODIFY_STATE)
}

func initHighResTimer() {
if GOARCH == "arm" {
// TODO: Not yet implemented.
return
}
h := createHighResTimer()
if h != 0 {
haveHighResTimer = true
usleep2Addr = unsafe.Pointer(funcPC(usleep2HighRes))
stdcall1(_CloseHandle, h)
}
}

func osinit() {
asmstdcallAddr = unsafe.Pointer(funcPC(asmstdcall))
usleep2Addr = unsafe.Pointer(funcPC(usleep2))
Expand All @@ -429,6 +479,7 @@ func osinit() {

stdcall2(_SetConsoleCtrlHandler, funcPC(ctrlhandler), 1)

initHighResTimer()
timeBeginPeriodRetValue = osRelax(false)

ncpu = getproccount()
Expand Down Expand Up @@ -844,9 +895,20 @@ func minit() {
var thandle uintptr
stdcall7(_DuplicateHandle, currentProcess, currentThread, currentProcess, uintptr(unsafe.Pointer(&thandle)), 0, 0, _DUPLICATE_SAME_ACCESS)

// Configure usleep timer, if possible.
var timer uintptr
if haveHighResTimer {
timer = createHighResTimer()
if timer == 0 {
print("runtime: CreateWaitableTimerEx failed; errno=", getlasterror(), "\n")
throw("CreateWaitableTimerEx when creating timer failed")
}
}

mp := getg().m
lock(&mp.threadLock)
mp.thread = thandle
mp.highResTimer = timer
unlock(&mp.threadLock)

// Query the true stack base from the OS. Currently we're
Expand Down Expand Up @@ -884,6 +946,10 @@ func unminit() {
lock(&mp.threadLock)
stdcall1(_CloseHandle, mp.thread)
mp.thread = 0
if mp.highResTimer != 0 {
stdcall1(_CloseHandle, mp.highResTimer)
mp.highResTimer = 0
}
unlock(&mp.threadLock)
}

Expand Down Expand Up @@ -976,9 +1042,12 @@ func stdcall7(fn stdFunction, a0, a1, a2, a3, a4, a5, a6 uintptr) uintptr {
return stdcall(fn)
}

// in sys_windows_386.s and sys_windows_amd64.s
// In sys_windows_386.s and sys_windows_amd64.s.
func onosstack(fn unsafe.Pointer, arg uint32)

// These are not callable functions. They should only be called via onosstack.
func usleep2(usec uint32)
func usleep2HighRes(usec uint32)
func switchtothread()

var usleep2Addr unsafe.Pointer
Expand Down
36 changes: 36 additions & 0 deletions src/runtime/sys_windows_386.s
Original file line number Diff line number Diff line change
Expand Up @@ -428,6 +428,42 @@ TEXT runtime·usleep2(SB),NOSPLIT,$20
MOVL BP, SP
RET

// Runs on OS stack. duration (in 100ns units) is in BX.
TEXT runtime·usleep2HighRes(SB),NOSPLIT,$36
// Want negative 100ns units.
NEGL BX
MOVL $-1, hi-4(SP)
MOVL BX, lo-8(SP)

get_tls(CX)
MOVL g(CX), CX
MOVL g_m(CX), CX
MOVL (m_mOS+mOS_highResTimer)(CX), CX
MOVL CX, saved_timer-12(SP)

MOVL $0, fResume-16(SP)
MOVL $0, lpArgToCompletionRoutine-20(SP)
MOVL $0, pfnCompletionRoutine-24(SP)
MOVL $0, lPeriod-28(SP)
LEAL lo-8(SP), BX
MOVL BX, lpDueTime-32(SP)
MOVL CX, hTimer-36(SP)
MOVL SP, BP
MOVL runtime·_SetWaitableTimer(SB), AX
CALL AX
MOVL BP, SP

MOVL $0, ptime-28(SP)
MOVL $0, alertable-32(SP)
MOVL saved_timer-12(SP), CX
MOVL CX, handle-36(SP)
MOVL SP, BP
MOVL runtime·_NtWaitForSingleObject(SB), AX
CALL AX
MOVL BP, SP

RET

// Runs on OS stack.
TEXT runtime·switchtothread(SB),NOSPLIT,$0
MOVL SP, BP
Expand Down
32 changes: 32 additions & 0 deletions src/runtime/sys_windows_amd64.s
Original file line number Diff line number Diff line change
Expand Up @@ -457,6 +457,38 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$48
MOVQ 40(SP), SP
RET

// Runs on OS stack. duration (in 100ns units) is in BX.
TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$72
MOVQ SP, AX
ANDQ $~15, SP // alignment as per Windows requirement
MOVQ AX, 64(SP)

get_tls(CX)
MOVQ g(CX), CX
MOVQ g_m(CX), CX
MOVQ (m_mOS+mOS_highResTimer)(CX), CX // hTimer
MOVQ CX, 48(SP) // save hTimer for later
// Want negative 100ns units.
NEGQ BX
LEAQ 56(SP), DX // lpDueTime
MOVQ BX, (DX)
MOVQ $0, R8 // lPeriod
MOVQ $0, R9 // pfnCompletionRoutine
MOVQ $0, AX
MOVQ AX, 32(SP) // lpArgToCompletionRoutine
MOVQ AX, 40(SP) // fResume
MOVQ runtime·_SetWaitableTimer(SB), AX
CALL AX

MOVQ 48(SP), CX // handle
MOVQ $0, DX // alertable
MOVQ $0, R8 // ptime
MOVQ runtime·_NtWaitForSingleObject(SB), AX
CALL AX

MOVQ 64(SP), SP
RET

// Runs on OS stack.
TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
MOVQ SP, AX
Expand Down
5 changes: 5 additions & 0 deletions src/runtime/sys_windows_arm.s
Original file line number Diff line number Diff line change
Expand Up @@ -468,6 +468,11 @@ TEXT runtime·usleep2(SB),NOSPLIT|NOFRAME,$0
MOVW R4, R13 // Restore SP
MOVM.IA.W (R13), [R4, R15] // pop {R4, pc}

// Runs on OS stack. Duration (in 100ns units) is in R0.
// TODO: neeeds to be implemented properly.
TEXT runtime·usleep2HighRes(SB),NOSPLIT|NOFRAME,$0
B runtime·abort(SB)

// Runs on OS stack.
TEXT runtime·switchtothread(SB),NOSPLIT|NOFRAME,$0
MOVM.DB.W [R4, R14], (R13) // push {R4, lr}
Expand Down

0 comments on commit 515e6a9

Please sign in to comment.