source: libcfa/src/concurrency/thread.cfa

Last change on this file was e5d9274, checked in by caparsons <caparson@…>, 4 months ago

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

  • Property mode set to 100644
File size: 5.6 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// thread.c --
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 : Sat Feb 12 15:24:18 2022
13// Update Count     : 66
14//
15
16#define __cforall_thread__
17#define _GNU_SOURCE
18
19#include "thread.hfa"
20
21#include "exception.hfa"
22#include "kernel/private.hfa"
23#include "limits.hfa"
24
25#define __CFA_INVOKE_PRIVATE__
26#include "invoke.h"
27
28extern uint32_t __global_random_seed, __global_random_prime, __global_random_mask;
29
30#pragma GCC visibility push(default)
31
32//-----------------------------------------------------------------------------
33// Thread ctors and dtors
34void ?{}( thread$ & this, const char * const name, cluster & cl, void * storage, size_t storageSize ) with( this ) {
35        context{ 0p, 0p };
36        self_cor{ name, storage, storageSize };
37        ticket = TICKET_RUNNING;
38        state = Start;
39        preempted = __NO_PREEMPTION;
40        corctx_flag = false;
41        curr_cor = &self_cor;
42        self_mon.owner = &this;
43        self_mon.recursion = 1;
44        self_mon_p = &self_mon;
45        curr_cluster = &cl;
46        link.next = 0p;
47        link.ts   = MAX;
48        preferred = ready_queue_new_preferred();
49        last_proc = 0p;
50        random_state = __global_random_mask ? __global_random_prime : __global_random_prime ^ rdtscl();
51        #if defined( __CFA_WITH_VERIFY__ )
52                canary = 0x0D15EA5E0D15EA5Ep;
53        #endif
54
55        node.next = 0p;
56        node.prev = 0p;
57
58        clh_node = malloc( );
59        *clh_node = false;
60
61        doregister(curr_cluster, this);
62        monitors{ &self_mon_p, 1, (fptr_t)0 };
63}
64
65void ^?{}(thread$& this) with( this ) {
66        #if defined( __CFA_WITH_VERIFY__ )
67                canary = 0xDEADDEADDEADDEADp;
68        #endif
69        free(clh_node);
70        unregister(curr_cluster, this);
71        ^self_cor{};
72}
73
74forall(T &)
75void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) {
76        dst->virtual_table = src->virtual_table;
77        dst->the_thread = src->the_thread;
78        dst->the_exception = src->the_exception;
79}
80
81forall(T &)
82const char * msg(ThreadCancelled(T) *) {
83        return "ThreadCancelled(...)";
84}
85
86forall(T &)
87static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
88        // Improve this error message, can I do formatting?
89        abort( "Unhandled thread cancellation.\n" );
90}
91
92forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled(T))
93    | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
94void ?{}( thread_dtor_guard_t & this,
95                T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
96        monitor$ * m = get_monitor(thrd);
97        thread$ * desc = get_thread(thrd);
98
99        // Setup the monitor guard
100        void (*dtor)(T& mutex this) = ^?{};
101        bool join = cancelHandler != (void(*)(ThreadCancelled(T)&))0;
102        (this.mg){&m, (void(*)())dtor, join};
103
104
105        /* paranoid */ verifyf( Halted == desc->state || Cancelled == desc->state, "Expected thread to be Halted or Cancelled, was %d\n", (int)desc->state );
106
107        // After the guard set-up and any wait, check for cancellation.
108        struct _Unwind_Exception * cancellation = desc->self_cor.cancellation;
109        if ( likely( 0p == cancellation ) ) {
110                return;
111        } else if ( Cancelled == desc->state ) {
112                return;
113        }
114        desc->state = Cancelled;
115        void(*defaultResumptionHandler)(ThreadCancelled(T) &) =
116                join ? cancelHandler : default_thread_cancel_handler;
117
118        // TODO: Remove explitate vtable set once trac#186 is fixed.
119        ThreadCancelled(T) except;
120        except.virtual_table = &_default_vtable;
121        except.the_thread = &thrd;
122        except.the_exception = __cfaehm_cancellation_exception( cancellation );
123        // Why is this cast required?
124        throwResume (ThreadCancelled(T) &)except;
125
126        except.the_exception->virtual_table->free( except.the_exception );
127        free( cancellation );
128        desc->self_cor.cancellation = 0p;
129}
130
131void ^?{}( thread_dtor_guard_t & this ) {
132        ^(this.mg){};
133}
134
135//-----------------------------------------------------------------------------
136// Starting and stopping threads
137forall( T & | is_thread(T) )
138void __thrd_start( T & this, void (*main_p)(T &) ) {
139        thread$ * this_thrd = get_thread(this);
140
141        disable_interrupts();
142        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
143
144        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
145        /* paranoid */ verify( this_thrd->context.SP );
146
147        schedule_thread$( this_thrd, UNPARK_LOCAL );
148        enable_interrupts();
149}
150
151//-----------------------------------------------------------------------------
152// Support for threads that don't ues the thread keyword
153forall( T & | sized(T) | is_thread(T) | { void ?{}(T&); } )
154void ?{}( scoped(T)& this ) with( this ) {
155        handle{};
156        __thrd_start(handle, main);
157}
158
159forall( T &, P... | sized(T) | is_thread(T) | { void ?{}(T&, P); } )
160void ?{}( scoped(T)& this, P params ) with( this ) {
161        handle{ params };
162        __thrd_start(handle, main);
163}
164
165forall( T & | sized(T) | is_thread(T) )
166void ^?{}( scoped(T)& this ) with( this ) {
167        ^handle{};
168}
169
170//-----------------------------------------------------------------------------
171forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled(T))
172        | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
173T & join( T & this ) {
174        thread_dtor_guard_t guard = { this, defaultResumptionHandler };
175        return this;
176}
177
178//-----------------------------------------------------------------------------
179#define GENERATOR LCG
180
181void set_seed( uint32_t seed ) {
182        uint32_t & state = active_thread()->random_state;
183        state = __global_random_seed = seed;
184        GENERATOR( state );
185        __global_random_prime = state;
186        __global_random_mask = true;
187} // set_seed
188
189uint32_t prng( void ) {                                                                 // [0,UINT_MAX]
190        uint32_t & state = active_thread()->random_state;
191        return GENERATOR( state );
192} // prng
193
194// Local Variables: //
195// mode: c //
196// tab-width: 4 //
197// End: //
Note: See TracBrowser for help on using the repository browser.