Subversion Repositories openrisc

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

// +build freebsd linux

#include "runtime.h"

// This implementation depends on OS-specific implementations of

//

//      runtime_futexsleep(uint32 *addr, uint32 val, int64 ns)

//              Atomically,

//                      if(*addr == val) sleep

//              Might be woken up spuriously; that's allowed.

//              Don't sleep longer than ns; ns < 0 means forever.

//

//      runtime_futexwakeup(uint32 *addr, uint32 cnt)

//              If any procs are sleeping on addr, wake up at most cnt.

enum

{

        MUTEX_UNLOCKED = 0,

        MUTEX_LOCKED = 1,

        MUTEX_SLEEPING = 2,

        ACTIVE_SPIN = 4,

        ACTIVE_SPIN_CNT = 30,

        PASSIVE_SPIN = 1,

};

// Possible lock states are MUTEX_UNLOCKED, MUTEX_LOCKED and MUTEX_SLEEPING.

// MUTEX_SLEEPING means that there is presumably at least one sleeping thread.

// Note that there can be spinning threads during all states - they do not

// affect mutex's state.

void

runtime_lock(Lock *l)

{

        uint32 i, v, wait, spin;

        if(runtime_m()->locks++ < 0)

                runtime_throw("runtime_lock: lock count");

        // Speculative grab for lock.

        v = runtime_xchg(&l->key, MUTEX_LOCKED);

        if(v == MUTEX_UNLOCKED)

                return;

        // wait is either MUTEX_LOCKED or MUTEX_SLEEPING

        // depending on whether there is a thread sleeping

        // on this mutex.  If we ever change l->key from

        // MUTEX_SLEEPING to some other value, we must be

        // careful to change it back to MUTEX_SLEEPING before

        // returning, to ensure that the sleeping thread gets

        // its wakeup call.

        wait = v;

        // On uniprocessor's, no point spinning.

        // On multiprocessors, spin for ACTIVE_SPIN attempts.

        spin = 0;

        if(runtime_ncpu > 1)

                spin = ACTIVE_SPIN;

        for(;;) {

                // Try for lock, spinning.

                for(i = 0; i < spin; i++) {

                        while(l->key == MUTEX_UNLOCKED)

                                if(runtime_cas(&l->key, MUTEX_UNLOCKED, wait))

                                        return;

                        runtime_procyield(ACTIVE_SPIN_CNT);

                }

                // Try for lock, rescheduling.

                for(i=0; i < PASSIVE_SPIN; i++) {

                        while(l->key == MUTEX_UNLOCKED)

                                if(runtime_cas(&l->key, MUTEX_UNLOCKED, wait))

                                        return;

                        runtime_osyield();

                }

                // Sleep.

                v = runtime_xchg(&l->key, MUTEX_SLEEPING);

                if(v == MUTEX_UNLOCKED)

                        return;

                wait = MUTEX_SLEEPING;

                runtime_futexsleep(&l->key, MUTEX_SLEEPING, -1);

        }

}

void

runtime_unlock(Lock *l)

{

        uint32 v;

        if(--runtime_m()->locks < 0)

                runtime_throw("runtime_unlock: lock count");

        v = runtime_xchg(&l->key, MUTEX_UNLOCKED);

        if(v == MUTEX_UNLOCKED)

                runtime_throw("unlock of unlocked lock");

        if(v == MUTEX_SLEEPING)

                runtime_futexwakeup(&l->key, 1);

}

// One-time notifications.

void

runtime_noteclear(Note *n)

{

        n->key = 0;

}

void

runtime_notewakeup(Note *n)

{

        runtime_xchg(&n->key, 1);

        runtime_futexwakeup(&n->key, 1);

}

void

runtime_notesleep(Note *n)

{

        while(runtime_atomicload(&n->key) == 0)

                runtime_futexsleep(&n->key, 0, -1);

}

void

runtime_notetsleep(Note *n, int64 ns)

{

        int64 deadline, now;

        if(ns < 0) {

                runtime_notesleep(n);

                return;

        }

        if(runtime_atomicload(&n->key) != 0)

                return;

        deadline = runtime_nanotime() + ns;

        for(;;) {

                runtime_futexsleep(&n->key, 0, ns);

                if(runtime_atomicload(&n->key) != 0)

                        return;

                now = runtime_nanotime();

                if(now >= deadline)

                        return;

                ns = deadline - now;

        }

}