OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [time/] [sleep.go] - Blame information for rev 747

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// Copyright 2009 The Go Authors. All rights reserved.
2 
// Use of this source code is governed by a BSD-style
3 
// license that can be found in the LICENSE file.
4 
 
5 
package time
6 
 
7 
// Sleep pauses the current goroutine for the duration d.
8 
func Sleep(d Duration)
9 
 
10 
func nano() int64 {
11 
        sec, nsec := now()
12 
        return sec*1e9 + int64(nsec)
13 
}
14 
 
15 
// Interface to timers implemented in package runtime.
16 
// Must be in sync with ../runtime/runtime.h:/^struct.Timer$
17 
type runtimeTimer struct {
18 
        i      int32
19 
        when   int64
20 
        period int64
21 
        f      func(int64, interface{})
22 
        arg    interface{}
23 
}
24 
 
25 
func startTimer(*runtimeTimer)
26 
func stopTimer(*runtimeTimer) bool
27 
 
28 
// The Timer type represents a single event.
29 
// When the Timer expires, the current time will be sent on C,
30 
// unless the Timer was created by AfterFunc.
31 
type Timer struct {
32 
        C <-chan Time
33 
        r runtimeTimer
34 
}
35 
 
36 
// Stop prevents the Timer from firing.
37 
// It returns true if the call stops the timer, false if the timer has already
38 
// expired or stopped.
39 
func (t *Timer) Stop() (ok bool) {
40 
        return stopTimer(&t.r)
41 
}
42 
 
43 
// NewTimer creates a new Timer that will send
44 
// the current time on its channel after at least duration d.
45 
func NewTimer(d Duration) *Timer {
46 
        c := make(chan Time, 1)
47 
        t := &Timer{
48 
                C: c,
49 
                r: runtimeTimer{
50 
                        when: nano() + int64(d),
51 
                        f:    sendTime,
52 
                        arg:  c,
53 
                },
54 
        }
55 
        startTimer(&t.r)
56 
        return t
57 
}
58 
 
59 
func sendTime(now int64, c interface{}) {
60 
        // Non-blocking send of time on c.
61 
        // Used in NewTimer, it cannot block anyway (buffer).
62 
        // Used in NewTicker, dropping sends on the floor is
63 
        // the desired behavior when the reader gets behind,
64 
        // because the sends are periodic.
65 
        select {
66 
        case c.(chan Time) <- Unix(0, now):
67 
        default:
68 
        }
69 
}
70 
 
71 
// After waits for the duration to elapse and then sends the current time
72 
// on the returned channel.
73 
// It is equivalent to NewTimer(d).C.
74 
func After(d Duration) <-chan Time {
75 
        return NewTimer(d).C
76 
}
77 
 
78 
// AfterFunc waits for the duration to elapse and then calls f
79 
// in its own goroutine. It returns a Timer that can
80 
// be used to cancel the call using its Stop method.
81 
func AfterFunc(d Duration, f func()) *Timer {
82 
        t := &Timer{
83 
                r: runtimeTimer{
84 
                        when: nano() + int64(d),
85 
                        f:    goFunc,
86 
                        arg:  f,
87 
                },
88 
        }
89 
        startTimer(&t.r)
90 
        return t
91 
}
92 
 
93 
func goFunc(now int64, arg interface{}) {
94 
        go arg.(func())()
95 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.