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

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

new ready queue seems to work but halting does not, had to be disabled

  • 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        unsigned int count;
197
198        // anchor for the head and the tail of the queue
199        struct __sentinel_t {
200                // Link lists fields
201                // instrusive link field for threads
202                // must be exactly as in thread_desc
203                __thread_desc_link link;
204        } before, after;
205
206        // Optional statistic counters
207        #if !defined(__CFA_NO_SCHED_STATS__)
208                struct __attribute__((aligned(64))) {
209                        // difference between number of push and pops
210                        ssize_t diff;
211
212                        // total number of pushes and pops
213                        size_t  push;
214                        size_t  pop ;
215                } stat;
216        #endif
217};
218
219void  ?{}(__intrusive_ready_queue_t & this);
220void ^?{}(__intrusive_ready_queue_t & this);
221
222typedef unsigned long long __cfa_readyQ_mask_t;
223
224// enum {
225//      __cfa_ready_queue_mask_size = (64 - sizeof(size_t)) / sizeof(size_t),
226//      __cfa_max_ready_queues = __cfa_ready_queue_mask_size * 8 * sizeof(size_t)
227// };
228
229#define __cfa_readyQ_mask_size ((64 - sizeof(size_t)) / sizeof(__cfa_readyQ_mask_t))
230#define __cfa_max_readyQs (__cfa_readyQ_mask_size * 8 * sizeof(__cfa_readyQ_mask_t))
231
232//TODO adjust cache size to ARCHITECTURE
233struct __attribute__((aligned(128))) __ready_queue_t {
234        struct {
235                volatile size_t count;
236                volatile __cfa_readyQ_mask_t mask[ __cfa_readyQ_mask_size ];
237        } empty;
238
239        struct __attribute__((aligned(64))) {
240                __intrusive_ready_queue_t * volatile data;
241                volatile size_t count;
242        } list;
243
244        #if !defined(__CFA_NO_STATISTICS__)
245                __attribute__((aligned(64))) struct {
246                        struct {
247                                struct {
248                                        volatile size_t attempt;
249                                        volatile size_t success;
250                                } push;
251                                struct {
252                                        volatile size_t maskrds;
253                                        volatile size_t attempt;
254                                        volatile size_t success;
255                                } pop;
256                        } pick;
257                        struct {
258                                volatile size_t value;
259                                volatile size_t count;
260                        } full;
261                } global_stats;
262
263        #endif
264};
265
266void  ?{}(__ready_queue_t & this);
267void ^?{}(__ready_queue_t & this);
268
269//-----------------------------------------------------------------------------
270// Cluster
271struct cluster {
272        // Ready queue locks
273        __clusterRWLock_t ready_lock;
274
275        // Ready queue for threads
276        __ready_queue_t ready_queue;
277
278        // Name of the cluster
279        const char * name;
280
281        // Preemption rate on this cluster
282        Duration preemption_rate;
283
284        // List of processors
285        __spinlock_t proc_list_lock;
286        __dllist_t(struct processor) idles;
287
288        // List of threads
289        __spinlock_t thread_list_lock;
290        __dllist_t(struct thread_desc) threads;
291        unsigned int nthreads;
292
293        // Link lists fields
294        struct __dbg_node_cltr {
295                cluster * next;
296                cluster * prev;
297        } node;
298};
299extern Duration default_preemption();
300
301void ?{} (cluster & this, const char * name, Duration preemption_rate);
302void ^?{}(cluster & this);
303
304static inline void ?{} (cluster & this)                           { this{"Anonymous Cluster", default_preemption()}; }
305static inline void ?{} (cluster & this, Duration preemption_rate) { this{"Anonymous Cluster", preemption_rate}; }
306static inline void ?{} (cluster & this, const char * name)        { this{name, default_preemption()}; }
307
308static inline [cluster *&, cluster *& ] __get( cluster & this ) {
309        return this.node.[next, prev];
310}
311
312static inline struct processor * active_processor() { return TL_GET( this_processor ); } // UNSAFE
313static inline struct cluster   * active_cluster  () { return TL_GET( this_processor )->cltr; }
314
315// Local Variables: //
316// mode: c //
317// tab-width: 4 //
318// End: //
Note: See TracBrowser for help on using the repository browser.