source: libcfa/src/concurrency/mutex.cfa@ bb7c77d

//                              -*- Mode: CFA -*-
//
// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// mutex.c --
//
// Author           : Thierry Delisle
// Created On       : Fri May 25 01:37:11 2018
// Last Modified By : Peter A. Buhr
// Last Modified On : Wed Dec  4 09:16:39 2019
// Update Count     : 1
//

#define __cforall_thread__
#define _GNU_SOURCE

#include "mutex.hfa"

#include "kernel/private.hfa"

//-----------------------------------------------------------------------------
// Locks

// Exclusive lock - non-recursive
// ---
void ?{}(mutex_lock & this) {
        this.lock{};
        this.blocked_threads{};
        this.is_locked = false;
}

void ^?{}(mutex_lock & this) {
        // default
}

void lock(mutex_lock & this) with(this) {
        lock( lock __cfaabi_dbg_ctx2 );
        if( is_locked ) {
                append( blocked_threads, active_thread() );
                unlock( lock );
                park();
        }
        else {
                is_locked = true;
                unlock( lock );
        }
}

bool try_lock(mutex_lock & this) with(this) {
        bool ret = false;
        lock( lock __cfaabi_dbg_ctx2 );
        if( !is_locked ) {
                ret = true;
                is_locked = true;
        }
        unlock( lock );
        return ret;
}

void unlock(mutex_lock & this) {
        lock( this.lock __cfaabi_dbg_ctx2 );
        this.is_locked = (this.blocked_threads != 0);
        unpark(
                pop_head( this.blocked_threads )
        );
        unlock( this.lock );
}

// Exclusive lock - non-recursive
// ---
void ?{}(recursive_mutex_lock & this) {
        this.lock{};
        this.blocked_threads{};
        this.owner = 0p;
        this.recursion_count = 0;
}

void ^?{}(recursive_mutex_lock & this) {
        // default
}

void lock(recursive_mutex_lock & this) with(this) {
        lock( lock __cfaabi_dbg_ctx2 );
        if( owner == 0p ) {
                owner = active_thread();
                recursion_count = 1;
                unlock( lock );
        }
        else if( owner == active_thread() ) {
                recursion_count++;
                unlock( lock );
        }
        else {
                append( blocked_threads, active_thread() );
                unlock( lock );
                park();
        }
}

bool try_lock(recursive_mutex_lock & this) with(this) {
        bool ret = false;
        lock( lock __cfaabi_dbg_ctx2 );
        if( owner == 0p ) {
                owner = active_thread();
                recursion_count = 1;
                ret = true;
        }
        else if( owner == active_thread() ) {
                recursion_count++;
                ret = true;
        }
        unlock( lock );
        return ret;
}

void unlock(recursive_mutex_lock & this) with(this) {
        lock( lock __cfaabi_dbg_ctx2 );
        recursion_count--;
        if( recursion_count == 0 ) {
                thread$ * thrd = pop_head( blocked_threads );
                owner = thrd;
                recursion_count = (thrd ? 1 : 0);
                unpark( thrd );
        }
        unlock( lock );
}

//-----------------------------------------------------------------------------
// Conditions
void ?{}(condition_variable & this) {
        this.blocked_threads{};
}

void ^?{}(condition_variable & this) {
        // default
}

void notify_one(condition_variable & this) with(this) {
        lock( lock __cfaabi_dbg_ctx2 );
        unpark(
                pop_head( this.blocked_threads )
        );
        unlock( lock );
}

void notify_all(condition_variable & this) with(this) {
        lock( lock __cfaabi_dbg_ctx2 );
        while(this.blocked_threads) {
                unpark(
                        pop_head( this.blocked_threads )
                );
        }
        unlock( lock );
}

void wait(condition_variable & this) {
        lock( this.lock __cfaabi_dbg_ctx2 );
        append( this.blocked_threads, active_thread() );
        unlock( this.lock );
        park();
}

forall(L & | is_lock(L))
void wait(condition_variable & this, L & l) {
        lock( this.lock __cfaabi_dbg_ctx2 );
        append( this.blocked_threads, active_thread() );
        unlock(l);
        unlock(this.lock);
        park();
        lock(l);
}

//-----------------------------------------------------------------------------
// Scopes
forall(L & | is_lock(L))
void lock_all  ( L * locks[], size_t count) {
        // Sort locks based on addresses
        __libcfa_small_sort(locks, count);

        // Lock all
        for(size_t i = 0; i < count; i++) {
                L * l = locks[i];
                lock( *l );
        }
}

forall(L & | is_lock(L))
void unlock_all( L * locks[], size_t count) {
        // Lock all
        for(size_t i = 0; i < count; i++) {
                L * l = locks[i];
                unlock( *l );
        }
}