source: libcfa/src/concurrency/monitor.hfa @ af67ee1

enumforall-pointer-decayjacob/cs343-translation
Last change on this file since af67ee1 was af67ee1, checked in by caparsons <caparson@…>, 9 months ago

Added support for locks as parameters to mutex stmt

  • Property mode set to 100644
File size: 4.1 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 : Wed Dec  4 07:55:32 2019
13// Update Count     : 11
14//
15
16#pragma once
17
18#include <stddef.h>
19
20#include <assert.h>
21#include "invoke.h"
22#include "stdlib.hfa"
23
24trait is_monitor(T &) {
25        monitor$ * get_monitor( T & );
26        void ^?{}( T & mutex );
27};
28
29static inline void ?{}(monitor$ & this) with( this ) {
30        lock{};
31        entry_queue{};
32        signal_stack{};
33        owner         = 0p;
34        recursion     = 0;
35        mask.accepted = 0p;
36        mask.data     = 0p;
37        mask.size     = 0;
38        dtor_node     = 0p;
39}
40
41static inline void ^?{}(monitor$ & ) {}
42
43struct monitor_guard_t {
44        monitor$ **     m;
45        __lock_size_t           count;
46        __monitor_group_t prev;
47};
48
49void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
50void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
51void ^?{}( monitor_guard_t & this );
52
53struct monitor_dtor_guard_t {
54        monitor$ *    m;
55        __monitor_group_t prev;
56        bool join;
57};
58
59void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join );
60void ^?{}( monitor_dtor_guard_t & this );
61
62static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
63void delete( T * th ) {
64        if(th) ^(*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$ * 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
85static inline __condition_criterion_t * & get_next( __condition_criterion_t & this ) {
86        return this.next;
87}
88
89struct __condition_node_t {
90        // Thread that needs to be woken when all criteria are met
91        thread$ * waiting_thread;
92
93        // Array of criteria (Criterions are contiguous in memory)
94        __condition_criterion_t * criteria;
95
96        // Number of criterions in the criteria
97        __lock_size_t count;
98
99        // Intrusive linked list Next field
100        __condition_node_t * next;
101
102        // Custom user info accessible before signalling
103        uintptr_t user_info;
104};
105
106static inline __condition_node_t * & get_next( __condition_node_t & this ) {
107        return this.next;
108}
109
110void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
111void ?{}(__condition_criterion_t & this );
112void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
113
114struct condition {
115        // Link list which contains the blocked threads as-well as the information needed to unblock them
116        __queue_t(__condition_node_t) blocked;
117
118        // Array of monitor pointers (Monitors are NOT contiguous in memory)
119        monitor$ ** monitors;
120
121        // Number of monitors in the array
122        __lock_size_t monitor_count;
123};
124
125static inline void ?{}( condition & this ) {
126        this.monitors = 0p;
127        this.monitor_count = 0;
128}
129
130static inline void ^?{}( condition & this ) {
131        free( this.monitors );
132}
133
134              void wait        ( condition & this, uintptr_t user_info = 0 );
135static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
136              bool signal      ( condition & this );
137              bool signal_block( condition & this );
138static inline bool signal_all  ( condition & this ) { bool ret = false; while(!is_empty(this)) { ret = signal(this) || ret; } return ret; }
139         uintptr_t front       ( condition & this );
140
141//-----------------------------------------------------------------------------
142// External scheduling
143
144struct __acceptable_t {
145        inline struct __monitor_group_t;
146        bool is_dtor;
147};
148
149void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
150
151// lock and unlock routines for mutex statements to use
152void lock( monitor$ * this );
153void unlock( monitor$ * this );
154
155// Local Variables: //
156// mode: c //
157// tab-width: 4 //
158// End: //
Note: See TracBrowser for help on using the repository browser.