Index: libcfa/src/concurrency/monitor
===================================================================
--- libcfa/src/concurrency/monitor	(revision bf71cfdb7285490eee552b461158846f626cc52f)
+++ libcfa/src/concurrency/monitor	(revision bf71cfdb7285490eee552b461158846f626cc52f)
@@ -0,0 +1,149 @@
+//
+// 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 Oct  7 18:06:45 2017
+// Update Count     : 10
+//
+
+#pragma once
+
+#include <stddef.h>
+
+#include <assert.h>
+#include "invoke.h"
+#include "stdlib"
+
+trait is_monitor(dtype T) {
+	monitor_desc * get_monitor( T & );
+	void ^?{}( T & mutex );
+};
+
+static inline void ?{}(monitor_desc & this) with( this ) {
+	lock{};
+	entry_queue{};
+	signal_stack{};
+	owner         = NULL;
+	recursion     = 0;
+	mask.accepted = NULL;
+	mask.data     = NULL;
+	mask.size     = 0;
+	dtor_node     = NULL;
+}
+
+struct monitor_guard_t {
+	monitor_desc ** 	m;
+	__lock_size_t   	count;
+	__monitor_group_t prev;
+};
+
+void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
+void ^?{}( monitor_guard_t & this );
+
+struct monitor_dtor_guard_t {
+	monitor_desc *    m;
+	__monitor_group_t prev;
+};
+
+void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
+void ^?{}( monitor_dtor_guard_t & this );
+
+static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } )
+void delete( T * th ) {
+	^(*th){};
+	free( th );
+}
+
+//-----------------------------------------------------------------------------
+// Internal scheduling
+
+struct __condition_criterion_t {
+	// Whether or not the criterion is met (True if met)
+	bool ready;
+
+	// The monitor this criterion concerns
+	monitor_desc * target;
+
+	// The parent node to which this criterion belongs
+	struct __condition_node_t * owner;
+
+	// Intrusive linked list Next field
+	__condition_criterion_t * next;
+};
+
+static inline __condition_criterion_t * & get_next( __condition_criterion_t & this ) {
+	return this.next;
+}
+
+struct __condition_node_t {
+	// Thread that needs to be woken when all criteria are met
+	thread_desc * waiting_thread;
+
+	// Array of criteria (Criterions are contiguous in memory)
+	__condition_criterion_t * criteria;
+
+	// Number of criterions in the criteria
+	__lock_size_t count;
+
+	// Intrusive linked list Next field
+	__condition_node_t * next;
+
+	// Custom user info accessible before signalling
+	uintptr_t user_info;
+};
+
+static inline __condition_node_t * & get_next( __condition_node_t & this ) {
+	return this.next;
+}
+
+void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
+void ?{}(__condition_criterion_t & this );
+void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
+
+struct condition {
+	// Link list which contains the blocked threads as-well as the information needed to unblock them
+	__queue_t(__condition_node_t) blocked;
+
+	// Array of monitor pointers (Monitors are NOT contiguous in memory)
+	monitor_desc ** monitors;
+
+	// Number of monitors in the array
+	__lock_size_t monitor_count;
+};
+
+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 {
+	inline struct __monitor_group_t;
+	bool is_dtor;
+};
+
+void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
+
+// Local Variables: //
+// mode: c //
+// tab-width: 4 //
+// End: //