//                              -*- 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.
//
// monitor --
//
// Author           : Thierry Delisle
// Created On       : Thd Feb 23 12:27:26 2017
// Last Modified By : Thierry Delisle
// Last Modified On : --
// Update Count     : 0
//

#ifndef MONITOR_H
#define MONITOR_H

#include <stddef.h>

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

static inline void ?{}(monitor_desc * this) {
	this->owner = NULL;
      this->stack_owner = NULL;
	this->recursion = 0;
}

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

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 ^?{}( 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
};

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 );
void signal( condition * this );
#endif //MONITOR_H