source: libcfa/src/concurrency/kernel.hfa @ f80f840

arm-ehjacob/cs343-translationnew-astnew-ast-unique-expr
Last change on this file since f80f840 was f80f840, checked in by Thierry Delisle <tdelisle@…>, 2 years ago

Merge branch 'master' into relaxed_ready

  • Property mode set to 100644
File size: 7.7 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// kernel --
8//
9// Author           : Thierry Delisle
10// Created On       : Tue Jan 17 12:27:26 2017
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Wed Dec  4 07:54:51 2019
13// Update Count     : 18
14//
15
16#pragma once
17
18#include <stdbool.h>
19
20#include "invoke.h"
21#include "time_t.hfa"
22#include "coroutine.hfa"
23
24extern "C" {
25#include <pthread.h>
26#include <semaphore.h>
27}
28
29//-----------------------------------------------------------------------------
30// Locks
31struct semaphore {
32        __spinlock_t lock;
33        int count;
34        __queue_t(thread_desc) waiting;
35};
36
37void  ?{}(semaphore & this, int count = 1);
38void ^?{}(semaphore & this);
39void   P (semaphore & this);
40void   V (semaphore & this);
41
42
43//-----------------------------------------------------------------------------
44// Processor
45extern struct cluster * mainCluster;
46
47enum FinishOpCode { No_Action, Release, Schedule, Release_Schedule, Release_Multi, Release_Multi_Schedule, Callback };
48
49typedef void (*__finish_callback_fptr_t)(void);
50
51//TODO use union, many of these fields are mutually exclusive (i.e. MULTI vs NOMULTI)
52struct FinishAction {
53        FinishOpCode action_code;
54        /*
55        // Union of possible actions
56        union {
57                // Option 1 : locks and threads
58                struct {
59                        // 1 thread or N thread
60                        union {
61                                thread_desc * thrd;
62                                struct {
63                                        thread_desc ** thrds;
64                                        unsigned short thrd_count;
65                                };
66                        };
67                        // 1 lock or N lock
68                        union {
69                                __spinlock_t * lock;
70                                struct {
71                                        __spinlock_t ** locks;
72                                        unsigned short lock_count;
73                                };
74                        };
75                };
76                // Option 2 : action pointer
77                __finish_callback_fptr_t callback;
78        };
79        /*/
80        thread_desc * thrd;
81        thread_desc ** thrds;
82        unsigned short thrd_count;
83        __spinlock_t * lock;
84        __spinlock_t ** locks;
85        unsigned short lock_count;
86        __finish_callback_fptr_t callback;
87        //*/
88};
89static inline void ?{}(FinishAction & this) {
90        this.action_code = No_Action;
91        this.thrd = 0p;
92        this.lock = 0p;
93}
94static inline void ^?{}(FinishAction &) {}
95
96// Processor
97coroutine processorCtx_t {
98        struct processor * proc;
99};
100
101// Wrapper around kernel threads
102struct processor {
103        // Main state
104        // Coroutine ctx who does keeps the state of the processor
105        struct processorCtx_t runner;
106
107        // Cluster from which to get threads
108        struct cluster * cltr;
109        unsigned int id;
110
111        // Name of the processor
112        const char * name;
113
114        // Handle to pthreads
115        pthread_t kernel_thread;
116
117        // RunThread data
118        // Action to do after a thread is ran
119        struct FinishAction finish;
120
121        // Preemption data
122        // Node which is added in the discrete event simulaiton
123        struct alarm_node_t * preemption_alarm;
124
125        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
126        bool pending_preemption;
127
128        // Idle lock
129        __bin_sem_t idleLock;
130
131        // Termination
132        // Set to true to notify the processor should terminate
133        volatile bool do_terminate;
134
135        // Termination synchronisation
136        semaphore terminated;
137
138        // pthread Stack
139        void * stack;
140
141        // Link lists fields
142        struct __dbg_node_proc {
143                struct processor * next;
144                struct processor * prev;
145        } node;
146
147#ifdef __CFA_DEBUG__
148        // Last function to enable preemption on this processor
149        const char * last_enable;
150#endif
151};
152
153void  ?{}(processor & this, const char * name, struct cluster & cltr);
154void ^?{}(processor & this);
155
156static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
157static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
158static inline void  ?{}(processor & this, const char * name) { this{name, *mainCluster }; }
159
160static inline [processor *&, processor *& ] __get( processor & this ) {
161        return this.node.[next, prev];
162}
163
164
165//-----------------------------------------------------------------------------
166// Cluster Tools
167struct __processor_id;
168
169// Reader-Writer lock protecting the ready-queue
170struct __clusterRWLock_t {
171        // total cachelines allocated
172        unsigned int max;
173
174        // cachelines currently in use
175        volatile unsigned int alloc;
176
177        // cachelines ready to itereate over
178        // (!= to alloc when thread is in second half of doregister)
179        volatile unsigned int ready;
180
181        // writer lock
182        volatile bool lock;
183
184        // data pointer
185        __processor_id * data;
186};
187
188void  ?{}(__clusterRWLock_t & this);
189void ^?{}(__clusterRWLock_t & this);
190
191// Underlying sub quues of the ready queue
192struct __attribute__((aligned(128))) __intrusive_ready_queue_t {
193        // spin lock protecting the queue
194        volatile bool lock;
195        unsigned int last_id;
196
197        // anchor for the head and the tail of the queue
198        struct __sentinel_t {
199                // Link lists fields
200                // instrusive link field for threads
201                // must be exactly as in thread_desc
202                __thread_desc_link link;
203        } before, after;
204
205        // Optional statistic counters
206        #if !defined(__CFA_NO_SCHED_STATS__)
207                struct __attribute__((aligned(64))) {
208                        // difference between number of push and pops
209                        ssize_t diff;
210
211                        // total number of pushes and pops
212                        size_t  push;
213                        size_t  pop ;
214                } stat;
215        #endif
216};
217
218void  ?{}(__intrusive_ready_queue_t & this);
219void ^?{}(__intrusive_ready_queue_t & this);
220
221typedef unsigned long long __cfa_readyQ_mask_t;
222
223// enum {
224//      __cfa_ready_queue_mask_size = (64 - sizeof(size_t)) / sizeof(size_t),
225//      __cfa_max_ready_queues = __cfa_ready_queue_mask_size * 8 * sizeof(size_t)
226// };
227
228#define __cfa_readyQ_mask_size ((64 - sizeof(size_t)) / sizeof(__cfa_readyQ_mask_t))
229#define __cfa_max_readyQs (__cfa_readyQ_mask_size * 8 * sizeof(__cfa_readyQ_mask_t))
230
231//TODO adjust cache size to ARCHITECTURE
232struct __attribute__((aligned(128))) __ready_queue_t {
233        struct {
234                volatile size_t count;
235                volatile __cfa_readyQ_mask_t mask[ __cfa_readyQ_mask_size ];
236        } empty;
237
238        struct __attribute__((aligned(64))) {
239                __intrusive_ready_queue_t * volatile data;
240                volatile size_t count;
241        } list;
242
243        #if !defined(__CFA_NO_STATISTICS__)
244                __attribute__((aligned(64))) struct {
245                        struct {
246                                struct {
247                                        volatile size_t attempt;
248                                        volatile size_t success;
249                                } push;
250                                struct {
251                                        volatile size_t maskrds;
252                                        volatile size_t attempt;
253                                        volatile size_t success;
254                                } pop;
255                        } pick;
256                        struct {
257                                volatile size_t value;
258                                volatile size_t count;
259                        } full;
260                } global_stats;
261
262        #endif
263};
264
265void  ?{}(__ready_queue_t & this);
266void ^?{}(__ready_queue_t & this);
267
268//-----------------------------------------------------------------------------
269// Cluster
270struct cluster {
271        // Ready queue locks
272        __clusterRWLock_t ready_lock;
273
274        // Ready queue for threads
275        __ready_queue_t ready_queue;
276
277        // Name of the cluster
278        const char * name;
279
280        // Preemption rate on this cluster
281        Duration preemption_rate;
282
283        // List of processors
284        __spinlock_t proc_list_lock;
285        __dllist_t(struct processor) idles;
286
287        // List of threads
288        __spinlock_t thread_list_lock;
289        __dllist_t(struct thread_desc) threads;
290        unsigned int nthreads;
291
292        // Link lists fields
293        struct __dbg_node_cltr {
294                cluster * next;
295                cluster * prev;
296        } node;
297};
298extern Duration default_preemption();
299
300void ?{} (cluster & this, const char * name, Duration preemption_rate);
301void ^?{}(cluster & this);
302
303static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
304static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
305static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
306
307static inline [cluster *&, cluster *& ] __get( cluster & this ) {
308        return this.node.[next, prev];
309}
310
311static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE
312static inline struct cluster   * active_cluster  () { return TL_GET( this_processor )->cltr; }
313
314// Local Variables: //
315// mode: c //
316// tab-width: 4 //
317// End: //
Note: See TracBrowser for help on using the repository browser.