gcc/libgo/go/time/internal_test.go

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package time

import (
	"errors"
	"runtime"
)

func init() {
	// force US/Pacific for time zone tests
	ForceUSPacificForTesting()
}

var Interrupt = interrupt
var DaysIn = daysIn

func empty(now int64, arg interface{}) {}

// Test that a runtimeTimer with a duration so large it overflows
// does not cause other timers to hang.
//
// This test has to be in internal_test.go since it fiddles with
// unexported data structures.
func CheckRuntimeTimerOverflow() error {
	// We manually create a runtimeTimer to bypass the overflow
	// detection logic in NewTimer: we're testing the underlying
	// runtime.addtimer function.
	r := &runtimeTimer{
		when: runtimeNano() + (1<<63 - 1),
		f:    empty,
		arg:  nil,
	}
	startTimer(r)

	timeout := 100 * Millisecond
	switch runtime.GOOS {
	// Allow more time for gobuilder to succeed.
	case "windows":
		timeout = Second
	case "plan9":
		// TODO(0intro): We don't know why it is needed.
		timeout = 3 * Second
	}

	// Start a goroutine that should send on t.C before the timeout.
	t := NewTimer(1)

	defer func() {
		// Subsequent tests won't work correctly if we don't stop the
		// overflow timer and kick the timer proc back into service.
		//
		// The timer proc is now sleeping and can only be awoken by
		// adding a timer to the *beginning* of the heap. We can't
		// wake it up by calling NewTimer since other tests may have
		// left timers running that should have expired before ours.
		// Instead we zero the overflow timer duration and start it
		// once more.
		stopTimer(r)
		t.Stop()
		r.when = 0
		startTimer(r)
	}()

	// Try to receive from t.C before the timeout. It will succeed
	// iff the previous sleep was able to finish. We're forced to
	// spin and yield after trying to receive since we can't start
	// any more timers (they might hang due to the same bug we're
	// now testing).
	stop := Now().Add(timeout)
	for {
		select {
		case <-t.C:
			return nil // It worked!
		default:
			if Now().After(stop) {
				return errors.New("runtime timer stuck: overflow in addtimer")
			}
			// Issue 6874. This test previously called runtime.Gosched to try to yield
			// to the goroutine servicing t, however the scheduler has a bias towards the
			// previously running goroutine in an idle system. Combined with high load due
			// to all CPUs busy running tests t's goroutine could be delayed beyond the
			// timeout window.
			//
			// Calling runtime.GC() reduces the worst case lantency for scheduling t by 20x
			// under the current Go 1.3 scheduler.
			runtime.GC()
		}
	}
}