source: src/libcfa/concurrency/invoke.h @ 8fc45b7

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

Internal helper functions now use arrays and references instead of pointers

  • Property mode set to 100644
File size: 6.8 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// invoke.h --
8//
9// Author           : Thierry Delisle
10// Created On       : Tue Jan 17 12:27:26 2016
11// Last Modified By : Peter A. Buhr
12// Last Modified On : Fri Jul 21 22:28:56 2017
13// Update Count     : 1
14//
15
16#include <stdbool.h>
17#include <stdint.h>
18
19#ifdef __CFORALL__
20extern "C" {
21#endif
22
23#if ! defined(__CFA_INVOKE_PRIVATE__)
24#ifndef _INVOKE_H_
25#define _INVOKE_H_
26
27      #define unlikely(x)    __builtin_expect(!!(x), 0)
28      #define thread_local _Thread_local
29
30      typedef void (*fptr_t)();
31
32      struct spinlock {
33            volatile int lock;
34            #ifdef __CFA_DEBUG__
35                  const char * prev_name;
36                  void* prev_thrd;
37            #endif
38      };
39
40      struct __thread_queue_t {
41            struct thread_desc * head;
42            struct thread_desc ** tail;
43      };
44
45      struct __condition_stack_t {
46            struct __condition_criterion_t * top;
47      };
48
49      #ifdef __CFORALL__
50      extern "Cforall" {
51            void ?{}( struct __thread_queue_t & );
52            void append( struct __thread_queue_t &, struct thread_desc * );
53            struct thread_desc * pop_head( struct __thread_queue_t & );
54            struct thread_desc * remove( struct __thread_queue_t &, struct thread_desc ** );
55
56            void ?{}( struct __condition_stack_t & );
57            void push( struct __condition_stack_t &, struct __condition_criterion_t * );
58            struct __condition_criterion_t * pop( struct __condition_stack_t & );
59
60            void  ?{}(spinlock & this);
61            void ^?{}(spinlock & this);
62      }
63      #endif
64
65      struct coStack_t {
66            unsigned int size;                        // size of stack
67            void *storage;                            // pointer to stack
68            void *limit;                              // stack grows towards stack limit
69            void *base;                               // base of stack
70            void *context;                            // address of cfa_context_t
71            void *top;                                // address of top of storage
72            bool userStack;                           // whether or not the user allocated the stack
73      };
74
75      enum coroutine_state { Halted, Start, Inactive, Active, Primed };
76
77      struct coroutine_desc {
78            struct coStack_t stack;                   // stack information of the coroutine
79            const char *name;                         // textual name for coroutine/task, initialized by uC++ generated code
80            int errno_;                               // copy of global UNIX variable errno
81            enum coroutine_state state;               // current execution status for coroutine
82            struct coroutine_desc * starter;          // first coroutine to resume this one
83            struct coroutine_desc * last;             // last coroutine to resume this one
84      };
85
86      struct __waitfor_mask_t {
87            short * accepted;                         // the index of the accepted function, -1 if none
88            struct __acceptable_t * clauses;          // list of acceptable functions, null if any
89            short size;                               // number of acceptable functions
90      };
91
92      struct monitor_desc {
93            struct spinlock lock;                     // spinlock to protect internal data
94            struct thread_desc * owner;               // current owner of the monitor
95            struct __thread_queue_t entry_queue;      // queue of threads that are blocked waiting for the monitor
96            struct __condition_stack_t signal_stack;  // stack of conditions to run next once we exit the monitor
97            unsigned int recursion;                   // monitor routines can be called recursively, we need to keep track of that
98            struct __waitfor_mask_t mask;             // mask used to know if some thread is waiting for something while holding the monitor
99            struct __condition_node_t * dtor_node;    // node used to signal the dtor in a waitfor dtor
100      };
101
102      struct __monitor_group_t {
103            struct monitor_desc ** list;              // currently held monitors
104            short                  size;              // number of currently held monitors
105            fptr_t                 func;              // last function that acquired monitors
106      };
107
108      struct thread_desc {
109            // Core threading fields
110            struct coroutine_desc  self_cor;          // coroutine body used to store context
111            struct monitor_desc    self_mon;          // monitor body used for mutual exclusion
112            struct monitor_desc *  self_mon_p;        // pointer to monitor with sufficient lifetime for current monitors
113            struct __monitor_group_t monitors;        // monitors currently held by this thread
114
115            // Link lists fields
116            struct thread_desc * next;                // instrusive link field for threads
117
118
119     };
120
121     #ifdef __CFORALL__
122     extern "Cforall" {
123            static inline monitor_desc * ?[?]( const __monitor_group_t & this, ptrdiff_t index ) {
124                  return this.list[index];
125            }
126
127            static inline bool ?==?( const __monitor_group_t & lhs, const __monitor_group_t & rhs ) {
128                  if( (lhs.list != 0) != (rhs.list != 0) ) return false;
129                  if( lhs.size != rhs.size ) return false;
130                  if( lhs.func != rhs.func ) return false;
131
132                  // Check that all the monitors match
133                  for( int i = 0; i < lhs.size; i++ ) {
134                        // If not a match, check next function
135                        if( lhs[i] != rhs[i] ) return false;
136                  }
137
138                  return true;
139            }
140      }
141      #endif
142
143#endif //_INVOKE_H_
144#else //! defined(__CFA_INVOKE_PRIVATE__)
145#ifndef _INVOKE_PRIVATE_H_
146#define _INVOKE_PRIVATE_H_
147
148      struct machine_context_t {
149            void *SP;
150            void *FP;
151            void *PC;
152      };
153
154      // assembler routines that performs the context switch
155      extern void CtxInvokeStub( void );
156      void CtxSwitch( void * from, void * to ) asm ("CtxSwitch");
157
158      #if   defined( __x86_64__ )
159      #define CtxGet( ctx ) __asm__ ( \
160                  "movq %%rsp,%0\n"   \
161                  "movq %%rbp,%1\n"   \
162            : "=rm" (ctx.SP), "=rm" (ctx.FP) )
163      #elif defined( __i386__ )
164      #define CtxGet( ctx ) __asm__ ( \
165                  "movl %%esp,%0\n"   \
166                  "movl %%ebp,%1\n"   \
167            : "=rm" (ctx.SP), "=rm" (ctx.FP) )
168      #endif
169
170#endif //_INVOKE_PRIVATE_H_
171#endif //! defined(__CFA_INVOKE_PRIVATE__)
172#ifdef __CFORALL__
173}
174#endif
175
176// Local Variables: //
177// mode: c //
178// tab-width: 4 //
179// End: //
Note: See TracBrowser for help on using the repository browser.