Subversion Repositories openrisc

// Copyright 2009 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.

// Time-related runtime and pieces of package time.

package time

#include "runtime.h"

#include "defs.h"

#include "arch.h"

#include "malloc.h"

static Timers timers;

static void addtimer(Timer*);

static bool deltimer(Timer*);

// Package time APIs.

// Godoc uses the comments in package time, not these.

// time.now is implemented in assembly.

// Sleep puts the current goroutine to sleep for at least ns nanoseconds.

func Sleep(ns int64) {

        G *g;

        g = runtime_g();

        g->status = Gwaiting;

        g->waitreason = "sleep";

        runtime_tsleep(ns);

}

// startTimer adds t to the timer heap.

func startTimer(t *Timer) {

        addtimer(t);

}

// stopTimer removes t from the timer heap if it is there.

// It returns true if t was removed, false if t wasn't even there.

func stopTimer(t *Timer) (stopped bool) {

        stopped = deltimer(t);

}

// C runtime.

static void timerproc(void*);

static void siftup(int32);

static void siftdown(int32);

// Ready the goroutine e.data.

static void

ready(int64 now, Eface e)

{

        USED(now);

        runtime_ready(e.__object);

}

// Put the current goroutine to sleep for ns nanoseconds.

// The caller must have set g->status and g->waitreason.

void

runtime_tsleep(int64 ns)

{

        Timer t;

        if(ns <= 0)

                return;

        t.when = runtime_nanotime() + ns;

        t.period = 0;

        t.f = ready;

        t.arg.__object = runtime_g();

        addtimer(&t);

        runtime_gosched();

}

// Add a timer to the heap and start or kick the timer proc

// if the new timer is earlier than any of the others.

static void

addtimer(Timer *t)

{

        int32 n;

        Timer **nt;

        runtime_lock(&timers);

        if(timers.len >= timers.cap) {

                // Grow slice.

                n = 16;

                if(n <= timers.cap)

                        n = timers.cap*3 / 2;

                nt = runtime_malloc(n*sizeof nt[0]);

                runtime_memmove(nt, timers.t, timers.len*sizeof nt[0]);

                runtime_free(timers.t);

                timers.t = nt;

                timers.cap = n;

        }

        t->i = timers.len++;

        timers.t[t->i] = t;

        siftup(t->i);

        if(t->i == 0) {

                // siftup moved to top: new earliest deadline.

                if(timers.sleeping) {

                        timers.sleeping = false;

                        runtime_notewakeup(&timers.waitnote);

                }

                if(timers.rescheduling) {

                        timers.rescheduling = false;

                        runtime_ready(timers.timerproc);

                }

        }

        if(timers.timerproc == nil)

                timers.timerproc = __go_go(timerproc, nil);

        runtime_unlock(&timers);

}

// Delete timer t from the heap.

// Do not need to update the timerproc:

// if it wakes up early, no big deal.

static bool

deltimer(Timer *t)

{

        int32 i;

        runtime_lock(&timers);

        // t may not be registered anymore and may have

        // a bogus i (typically 0, if generated by Go).

        // Verify it before proceeding.

        i = t->i;

        if(i < 0 || i >= timers.len || timers.t[i] != t) {

                runtime_unlock(&timers);

                return false;

        }

        timers.len--;

        if(i == timers.len) {

                timers.t[i] = nil;

        } else {

                timers.t[i] = timers.t[timers.len];

                timers.t[timers.len] = nil;

                timers.t[i]->i = i;

                siftup(i);

                siftdown(i);

        }

        runtime_unlock(&timers);

        return true;

}

// Timerproc runs the time-driven events.

// It sleeps until the next event in the timers heap.

// If addtimer inserts a new earlier event, addtimer

// wakes timerproc early.

static void

timerproc(void* dummy __attribute__ ((unused)))

{

        G *g;

        int64 delta, now;

        Timer *t;

        void (*f)(int64, Eface);

        Eface arg;

        g = runtime_g();

        for(;;) {

                runtime_lock(&timers);

                now = runtime_nanotime();

                for(;;) {

                        if(timers.len == 0) {

                                delta = -1;

                                break;

                        }

                        t = timers.t[0];

                        delta = t->when - now;

                        if(delta > 0)

                                break;

                        if(t->period > 0) {

                                // leave in heap but adjust next time to fire

                                t->when += t->period * (1 + -delta/t->period);

                                siftdown(0);

                        } else {

                                // remove from heap

                                timers.t[0] = timers.t[--timers.len];

                                timers.t[0]->i = 0;

                                siftdown(0);

                                t->i = -1;  // mark as removed

                        }

                        f = t->f;

                        arg = t->arg;

                        runtime_unlock(&timers);

                        f(now, arg);

                        runtime_lock(&timers);

                }

                if(delta < 0) {

                        // No timers left - put goroutine to sleep.

                        timers.rescheduling = true;

                        g->status = Gwaiting;

                        g->waitreason = "timer goroutine (idle)";

                        runtime_unlock(&timers);

                        runtime_gosched();

                        continue;

                }

                // At least one timer pending.  Sleep until then.

                timers.sleeping = true;

                runtime_noteclear(&timers.waitnote);

                runtime_unlock(&timers);

                runtime_entersyscall();

                runtime_notetsleep(&timers.waitnote, delta);

                runtime_exitsyscall();

        }

}

// heap maintenance algorithms.

static void

siftup(int32 i)

{

        int32 p;

        Timer **t, *tmp;

        t = timers.t;

        while(i > 0) {

                p = (i-1)/2;  // parent

                if(t[i]->when >= t[p]->when)

                        break;

                tmp = t[i];

                t[i] = t[p];

                t[p] = tmp;

                t[i]->i = i;

                t[p]->i = p;

                i = p;

        }

}

static void

siftdown(int32 i)

{

        int32 c, len;

        Timer **t, *tmp;

        t = timers.t;

        len = timers.len;

        for(;;) {

                c = i*2 + 1;  // left child

                if(c >= len) {

                        break;

                }

                if(c+1 < len && t[c+1]->when < t[c]->when)

                        c++;

                if(t[c]->when >= t[i]->when)

                        break;

                tmp = t[i];

                t[i] = t[c];

                t[c] = tmp;

                t[i]->i = i;

                t[c]->i = c;

                i = c;

        }

}

void

runtime_time_scan(void (*scan)(byte*, int64))

{

        scan((byte*)&timers, sizeof timers);

}