source: src/libcfa/concurrency/monitor @ 59a0bde

aaron-thesisarm-ehcleanup-dtorsdeferred_resndemanglerjacob/cs343-translationjenkins-sandboxnew-astnew-ast-unique-exprnew-envno_listpersistent-indexerresolv-newwith_gc
Last change on this file since 59a0bde was 59a0bde, checked in by Thierry Delisle <tdelisle@…>, 4 years ago

Converted more shorts to int_fast16_T

  • Property mode set to 100644
File size: 3.9 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// monitor --
8//
9// Author           : Thierry Delisle
10// Created On       : Thd Feb 23 12:27:26 2017
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Sat Oct  7 18:06:45 2017
13// Update Count     : 10
14//
15
16#pragma once
17
18#include <stddef.h>
19
20#include <assert.h>
21#include "invoke.h"
22#include "stdlib"
23
24trait is_monitor(dtype T) {
25        monitor_desc * get_monitor( T & );
26        void ^?{}( T & mutex );
27};
28
29static inline void ?{}(monitor_desc & this) {
30        (this.lock){};
31        (this.entry_queue){};
32        (this.signal_stack){};
33        this.owner         = NULL;
34        this.recursion     = 0;
35        this.mask.accepted = NULL;
36        this.mask.clauses  = NULL;
37        this.mask.size     = 0;
38        this.dtor_node     = NULL;
39}
40
41struct monitor_guard_t {
42        monitor_desc ** m;
43        __lock_size_t   count;
44        monitor_desc ** prev_mntrs;
45        __lock_size_t   prev_count;
46        fptr_t          prev_func;
47};
48
49void ?{}( monitor_guard_t & this, monitor_desc ** m, __lock_size_t count, void (*func)() );
50void ^?{}( monitor_guard_t & this );
51
52struct monitor_dtor_guard_t {
53        monitor_desc * m;
54        monitor_desc ** prev_mntrs;
55        __lock_size_t   prev_count;
56        fptr_t          prev_func;
57};
58
59void ?{}( monitor_dtor_guard_t & this, monitor_desc ** m, void (*func)() );
60void ^?{}( monitor_dtor_guard_t & this );
61
62static inline forall( dtype T | sized(T) | { void ^?{}( T & mutex ); } )
63void delete( T * th ) {
64        ^(*th){};
65        free( th );
66}
67
68//-----------------------------------------------------------------------------
69// Internal scheduling
70
71struct __condition_criterion_t {
72        // Whether or not the criterion is met (True if met)
73        bool ready;
74
75        // The monitor this criterion concerns
76        monitor_desc * target;
77
78        // The parent node to which this criterion belongs
79        struct __condition_node_t * owner;
80
81        // Intrusive linked list Next field
82        __condition_criterion_t * next;
83};
84
85struct __condition_node_t {
86        // Thread that needs to be woken when all criteria are met
87        thread_desc * waiting_thread;
88
89        // Array of criteria (Criterions are contiguous in memory)
90        __condition_criterion_t * criteria;
91
92        // Number of criterions in the criteria
93        __lock_size_t count;
94
95        // Intrusive linked list Next field
96        __condition_node_t * next;
97
98        // Custom user info accessible before signalling
99        uintptr_t user_info;
100};
101
102struct __condition_blocked_queue_t {
103        __condition_node_t * head;
104        __condition_node_t ** tail;
105};
106
107void ?{}(__condition_node_t & this, thread_desc * waiting_thread, __lock_size_t count, uintptr_t user_info );
108void ?{}(__condition_criterion_t & this );
109void ?{}(__condition_criterion_t & this, monitor_desc * target, __condition_node_t * owner );
110
111void ?{}( __condition_blocked_queue_t & );
112void append( __condition_blocked_queue_t &, __condition_node_t * );
113__condition_node_t * pop_head( __condition_blocked_queue_t & );
114
115struct condition {
116        // Link list which contains the blocked threads as-well as the information needed to unblock them
117        __condition_blocked_queue_t blocked;
118
119        // Array of monitor pointers (Monitors are NOT contiguous in memory)
120        monitor_desc ** monitors;
121
122        // Number of monitors in the array
123        __lock_size_t monitor_count;
124};
125
126static inline void ?{}( condition & this ) {
127        this.monitors = NULL;
128        this.monitor_count = 0;
129}
130
131static inline void ^?{}( condition & this ) {
132        free( this.monitors );
133}
134
135              void wait        ( condition & this, uintptr_t user_info = 0 );
136              bool signal      ( condition & this );
137              bool signal_block( condition & this );
138static inline bool is_empty    ( condition & this ) { return !this.blocked.head; }
139         uintptr_t front       ( condition & this );
140
141//-----------------------------------------------------------------------------
142// External scheduling
143
144struct __acceptable_t {
145        __monitor_group_t;
146        bool is_dtor;
147};
148
149void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
150
151// Local Variables: //
152// mode: c //
153// tab-width: 4 //
154// End: //
Note: See TracBrowser for help on using the repository browser.