source: src/libcfa/concurrency/monitor@ 90c4df0

//
// 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.
//
// monitor --
//
// Author           : Thierry Delisle
// Created On       : Thd Feb 23 12:27:26 2017
// Last Modified By : Peter A. Buhr
// Last Modified On : Sat Jul 22 09:59:01 2017
// Update Count     : 3
//

#pragma once

#include <stddef.h>

#include <assert.h>
#include "invoke.h"
#include "stdlib"

static inline void ?{}(monitor_desc * this) {
        (&this->lock){};
        this->owner = NULL;
        (&this->entry_queue){};
        (&this->signal_stack){};
        this->recursion = 0;
        this->acceptables = NULL;
        this->acceptable_count = 0;
        this->accepted_index = -1;
        this->pre_accept = 0;
}

struct monitor_guard_t {
        monitor_desc ** m;
        int count;
        monitor_desc ** prev_mntrs;
        unsigned short  prev_count;
        fptr_t          prev_func;
};

static inline int ?<?(monitor_desc* lhs, monitor_desc* rhs) {
        return ((intptr_t)lhs) < ((intptr_t)rhs);
}

void ?{}( monitor_guard_t * this, monitor_desc ** m, int count, void (*func)() );
void ^?{}( monitor_guard_t * this );

//-----------------------------------------------------------------------------
// Internal scheduling

struct __condition_criterion_t {
        bool ready;                                             //Whether or not the criterion is met (True if met)
        monitor_desc * target;                          //The monitor this criterion concerns
        struct __condition_node_t * owner;              //The parent node to which this criterion belongs
        __condition_criterion_t * next;         //Intrusive linked list Next field
};

struct __condition_node_t {
        thread_desc * waiting_thread;                   //Thread that needs to be woken when all criteria are met
        __condition_criterion_t * criteria;     //Array of criteria (Criterions are contiguous in memory)
        unsigned short count;                           //Number of criterions in the criteria
        __condition_node_t * next;                      //Intrusive linked list Next field
        uintptr_t user_info;                            //Custom user info accessible before signalling
};

struct __condition_blocked_queue_t {
        __condition_node_t * head;
        __condition_node_t ** tail;
};

void ?{}( __condition_blocked_queue_t * );
void append( __condition_blocked_queue_t *, __condition_node_t * );
__condition_node_t * pop_head( __condition_blocked_queue_t * );

struct condition {
        __condition_blocked_queue_t blocked;    //Link list which contains the blocked threads as-well as the information needed to unblock them
        monitor_desc ** monitors;                       //Array of monitor pointers (Monitors are NOT contiguous in memory)
        unsigned short monitor_count;                   //Number of monitors in the array
};

static inline void ?{}( condition * this ) {
        this->monitors = NULL;
        this->monitor_count = 0;
}

static inline void ^?{}( condition * this ) {
        free( this->monitors );
}

void wait( condition * this, uintptr_t user_info = 0 );
bool signal( condition * this );
bool signal_block( condition * this );
static inline bool is_empty( condition * this ) { return !this->blocked.head; }
uintptr_t front( condition * this );

//-----------------------------------------------------------------------------
// External scheduling

struct __acceptable_t {
        fptr_t func;
        unsigned short count;
        monitor_desc ** monitors;
        bool run_preaccept;
};

int __accept_internal( unsigned short count, __acceptable_t * acceptables );

// Local Variables: //
// mode: c //
// tab-width: 4 //
// End: //