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

ADTast-experimentalpthread-emulation
Last change on this file since ef1da0e2 was ef1da0e2, checked in by Fangren Yu <f37yu@…>, 19 months ago

try to make parameter qualifier conversion work for assertions

  • Property mode set to 100644
File size: 4.5 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
62/*
63static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
64void delete( T * th ) {
65        if(th) ^(*th){};
66        free( th );
67}
68*/
69
70static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
71void adelete( T arr[] ) {
72        if ( arr ) {                                                                            // ignore null
73                size_t dim = malloc_size( arr ) / sizeof( T );
74                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
75                        ^(arr[i]){};                                                            // run destructor
76                } // for
77                free( arr );
78        } // if
79} // adelete
80
81//-----------------------------------------------------------------------------
82// Internal scheduling
83
84struct __condition_criterion_t {
85        // Whether or not the criterion is met (True if met)
86        bool ready;
87
88        // The monitor this criterion concerns
89        monitor$ * target;
90
91        // The parent node to which this criterion belongs
92        struct __condition_node_t * owner;
93
94        // Intrusive linked list Next field
95        __condition_criterion_t * next;
96};
97
98static inline __condition_criterion_t * & get_next( __condition_criterion_t & this ) {
99        return this.next;
100}
101
102struct __condition_node_t {
103        // Thread that needs to be woken when all criteria are met
104        thread$ * waiting_thread;
105
106        // Array of criteria (Criterions are contiguous in memory)
107        __condition_criterion_t * criteria;
108
109        // Number of criterions in the criteria
110        __lock_size_t count;
111
112        // Intrusive linked list Next field
113        __condition_node_t * next;
114
115        // Custom user info accessible before signalling
116        uintptr_t user_info;
117};
118
119static inline __condition_node_t * & get_next( __condition_node_t & this ) {
120        return this.next;
121}
122
123// void ?{}(__condition_node_t & this, thread$ * waiting_thread, __lock_size_t count, uintptr_t user_info );
124// void ?{}(__condition_criterion_t & this );
125// void ?{}(__condition_criterion_t & this, monitor$ * target, __condition_node_t * owner );
126
127struct condition {
128        // Link list which contains the blocked threads as-well as the information needed to unblock them
129        __queue_t(__condition_node_t) blocked;
130
131        // Array of monitor pointers (Monitors are NOT contiguous in memory)
132        monitor$ ** monitors;
133
134        // Number of monitors in the array
135        __lock_size_t monitor_count;
136};
137
138static inline void ?{}( condition & this ) {
139        this.monitors = 0p;
140        this.monitor_count = 0;
141}
142
143static inline void ^?{}( condition & this ) {
144        free( this.monitors );
145}
146
147              void wait        ( condition & this, uintptr_t user_info = 0 );
148static inline bool is_empty    ( condition & this ) { return this.blocked.head == 1p; }
149              bool signal      ( condition & this );
150              bool signal_block( condition & this );
151static inline bool signal_all  ( condition & this ) { bool ret = false; while(!is_empty(this)) { ret = signal(this) || ret; } return ret; }
152         uintptr_t front       ( condition & this );
153
154//-----------------------------------------------------------------------------
155// External scheduling
156
157struct __acceptable_t {
158        inline struct __monitor_group_t;
159        bool is_dtor;
160};
161
162void __waitfor_internal( const __waitfor_mask_t & mask, int duration );
163
164// lock and unlock routines for mutex statements to use
165void lock( monitor$ * this );
166void unlock( monitor$ * this );
167
168// Local Variables: //
169// mode: c //
170// tab-width: 4 //
171// End: //
Note: See TracBrowser for help on using the repository browser.