Branch data Line data Source code
1 : : /*
2 : : * This file is part of the MicroPython project, http://micropython.org/
3 : : *
4 : : * The MIT License (MIT)
5 : : *
6 : : * Copyright (c) 2016 Damien P. George on behalf of Pycom Ltd
7 : : *
8 : : * Permission is hereby granted, free of charge, to any person obtaining a copy
9 : : * of this software and associated documentation files (the "Software"), to deal
10 : : * in the Software without restriction, including without limitation the rights
11 : : * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
12 : : * copies of the Software, and to permit persons to whom the Software is
13 : : * furnished to do so, subject to the following conditions:
14 : : *
15 : : * The above copyright notice and this permission notice shall be included in
16 : : * all copies or substantial portions of the Software.
17 : : *
18 : : * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 : : * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 : : * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
21 : : * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
22 : : * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
23 : : * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
24 : : * THE SOFTWARE.
25 : : */
26 : :
27 : : #include <stdio.h>
28 : : #include <string.h>
29 : :
30 : : #include "py/runtime.h"
31 : :
32 : : #if MICROPY_PY_THREAD
33 : :
34 : : #include "py/mpthread.h"
35 : :
36 : : #if MICROPY_DEBUG_VERBOSE // print debugging info
37 : : #define DEBUG_PRINT (1)
38 : : #define DEBUG_printf DEBUG_printf
39 : : #else // don't print debugging info
40 : : #define DEBUG_PRINT (0)
41 : : #define DEBUG_printf(...) (void)0
42 : : #endif
43 : :
44 : : /****************************************************************/
45 : : // Lock object
46 : :
47 : : static const mp_obj_type_t mp_type_thread_lock;
48 : :
49 : : typedef struct _mp_obj_thread_lock_t {
50 : : mp_obj_base_t base;
51 : : mp_thread_mutex_t mutex;
52 : : volatile bool locked;
53 : : } mp_obj_thread_lock_t;
54 : :
55 : 20 : static mp_obj_thread_lock_t *mp_obj_new_thread_lock(void) {
56 : 20 : mp_obj_thread_lock_t *self = mp_obj_malloc(mp_obj_thread_lock_t, &mp_type_thread_lock);
57 : 20 : mp_thread_mutex_init(&self->mutex);
58 : 20 : self->locked = false;
59 : 20 : return self;
60 : : }
61 : :
62 : 82402 : static mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *args) {
63 : 82402 : mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(args[0]);
64 : 82402 : bool wait = true;
65 [ + + ]: 82402 : if (n_args > 1) {
66 : 1 : wait = mp_obj_get_int(args[1]);
67 : : // TODO support timeout arg
68 : : }
69 : 82402 : MP_THREAD_GIL_EXIT();
70 : 82402 : int ret = mp_thread_mutex_lock(&self->mutex, wait);
71 : 82403 : MP_THREAD_GIL_ENTER();
72 [ + + ]: 82403 : if (ret == 0) {
73 : : return mp_const_false;
74 [ + - ]: 82402 : } else if (ret == 1) {
75 : 82402 : self->locked = true;
76 : 82402 : return mp_const_true;
77 : : } else {
78 : 0 : mp_raise_OSError(-ret);
79 : : }
80 : : }
81 : : static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock_acquire_obj, 1, 3, thread_lock_acquire);
82 : :
83 : 82402 : static mp_obj_t thread_lock_release(mp_obj_t self_in) {
84 : 82402 : mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
85 [ + + ]: 82402 : if (!self->locked) {
86 : 1 : mp_raise_msg(&mp_type_RuntimeError, NULL);
87 : : }
88 : 82401 : self->locked = false;
89 : 82401 : MP_THREAD_GIL_EXIT();
90 : 82401 : mp_thread_mutex_unlock(&self->mutex);
91 : 82400 : MP_THREAD_GIL_ENTER();
92 : 82400 : return mp_const_none;
93 : : }
94 : : static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_release_obj, thread_lock_release);
95 : :
96 : 9 : static mp_obj_t thread_lock_locked(mp_obj_t self_in) {
97 : 9 : mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in);
98 [ + + ]: 9 : return mp_obj_new_bool(self->locked);
99 : : }
100 : : static MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_locked_obj, thread_lock_locked);
101 : :
102 : 82364 : static mp_obj_t thread_lock___exit__(size_t n_args, const mp_obj_t *args) {
103 : 82364 : (void)n_args; // unused
104 : 82364 : return thread_lock_release(args[0]);
105 : : }
106 : : static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock___exit___obj, 4, 4, thread_lock___exit__);
107 : :
108 : : static const mp_rom_map_elem_t thread_lock_locals_dict_table[] = {
109 : : { MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) },
110 : : { MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) },
111 : : { MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) },
112 : : { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock_acquire_obj) },
113 : : { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&thread_lock___exit___obj) },
114 : : };
115 : :
116 : : static MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_table);
117 : :
118 : : static MP_DEFINE_CONST_OBJ_TYPE(
119 : : mp_type_thread_lock,
120 : : MP_QSTR_lock,
121 : : MP_TYPE_FLAG_NONE,
122 : : locals_dict, &thread_lock_locals_dict
123 : : );
124 : :
125 : : /****************************************************************/
126 : : // _thread module
127 : :
128 : : static size_t thread_stack_size = 0;
129 : :
130 : 2 : static mp_obj_t mod_thread_get_ident(void) {
131 : 2 : return mp_obj_new_int_from_uint(mp_thread_get_id());
132 : : }
133 : : static MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_get_ident_obj, mod_thread_get_ident);
134 : :
135 : 7 : static mp_obj_t mod_thread_stack_size(size_t n_args, const mp_obj_t *args) {
136 : 7 : mp_obj_t ret = mp_obj_new_int_from_uint(thread_stack_size);
137 [ + + ]: 7 : if (n_args == 0) {
138 : 5 : thread_stack_size = 0;
139 : : } else {
140 : 2 : thread_stack_size = mp_obj_get_int(args[0]);
141 : : }
142 : 7 : return ret;
143 : : }
144 : : static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_stack_size_obj, 0, 1, mod_thread_stack_size);
145 : :
146 : : typedef struct _thread_entry_args_t {
147 : : mp_obj_dict_t *dict_locals;
148 : : mp_obj_dict_t *dict_globals;
149 : : size_t stack_size;
150 : : mp_obj_t fun;
151 : : size_t n_args;
152 : : size_t n_kw;
153 : : mp_obj_t args[];
154 : : } thread_entry_args_t;
155 : :
156 : 596 : static void *thread_entry(void *args_in) {
157 : : // Execution begins here for a new thread. We do not have the GIL.
158 : :
159 : 596 : thread_entry_args_t *args = (thread_entry_args_t *)args_in;
160 : :
161 : 596 : mp_state_thread_t ts;
162 : 596 : mp_thread_init_state(&ts, args->stack_size, args->dict_locals, args->dict_globals);
163 : :
164 : : #if MICROPY_ENABLE_PYSTACK
165 : : // TODO threading and pystack is not fully supported, for now just make a small stack
166 : : mp_obj_t mini_pystack[128];
167 : : mp_pystack_init(mini_pystack, &mini_pystack[128]);
168 : : #endif
169 : :
170 : 595 : MP_THREAD_GIL_ENTER();
171 : :
172 : : // signal that we are set up and running
173 : 595 : mp_thread_start();
174 : :
175 : : // TODO set more thread-specific state here:
176 : : // cur_exception (root pointer)
177 : :
178 : 596 : DEBUG_printf("[thread] start ts=%p args=%p stack=%p\n", &ts, &args, MP_STATE_THREAD(stack_top));
179 : :
180 : 596 : nlr_buf_t nlr;
181 [ + + ]: 596 : if (nlr_push(&nlr) == 0) {
182 : 596 : mp_call_function_n_kw(args->fun, args->n_args, args->n_kw, args->args);
183 : 591 : nlr_pop();
184 : : } else {
185 : : // uncaught exception
186 : : // check for SystemExit
187 : 5 : mp_obj_base_t *exc = (mp_obj_base_t *)nlr.ret_val;
188 [ + + ]: 5 : if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) {
189 : : // swallow exception silently
190 : : } else {
191 : : // print exception out
192 : 1 : mp_printf(MICROPY_ERROR_PRINTER, "Unhandled exception in thread started by ");
193 : 1 : mp_obj_print_helper(MICROPY_ERROR_PRINTER, args->fun, PRINT_REPR);
194 : 1 : mp_printf(MICROPY_ERROR_PRINTER, "\n");
195 : 1 : mp_obj_print_exception(MICROPY_ERROR_PRINTER, MP_OBJ_FROM_PTR(exc));
196 : : }
197 : : }
198 : :
199 : 596 : DEBUG_printf("[thread] finish ts=%p\n", &ts);
200 : :
201 : : // signal that we are finished
202 : 596 : mp_thread_finish();
203 : :
204 : 595 : MP_THREAD_GIL_EXIT();
205 : :
206 : 595 : return NULL;
207 : : }
208 : :
209 : 597 : static mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args) {
210 : : // This structure holds the Python function and arguments for thread entry.
211 : : // We copy all arguments into this structure to keep ownership of them.
212 : : // We must be very careful about root pointers because this pointer may
213 : : // disappear from our address space before the thread is created.
214 : 597 : thread_entry_args_t *th_args;
215 : :
216 : : // get positional arguments
217 : 597 : size_t pos_args_len;
218 : 597 : mp_obj_t *pos_args_items;
219 : 597 : mp_obj_get_array(args[1], &pos_args_len, &pos_args_items);
220 : :
221 : : // check for keyword arguments
222 [ + + ]: 597 : if (n_args == 2) {
223 : : // just position arguments
224 : 595 : th_args = m_new_obj_var(thread_entry_args_t, args, mp_obj_t, pos_args_len);
225 : 595 : th_args->n_kw = 0;
226 : : } else {
227 : : // positional and keyword arguments
228 [ + + ]: 2 : if (mp_obj_get_type(args[2]) != &mp_type_dict) {
229 : 1 : mp_raise_TypeError(MP_ERROR_TEXT("expecting a dict for keyword args"));
230 : : }
231 : 1 : mp_map_t *map = &((mp_obj_dict_t *)MP_OBJ_TO_PTR(args[2]))->map;
232 : 1 : th_args = m_new_obj_var(thread_entry_args_t, args, mp_obj_t, pos_args_len + 2 * map->used);
233 : 1 : th_args->n_kw = map->used;
234 : : // copy across the keyword arguments
235 [ + + ]: 3 : for (size_t i = 0, n = pos_args_len; i < map->alloc; ++i) {
236 [ + - ]: 2 : if (mp_map_slot_is_filled(map, i)) {
237 : 2 : th_args->args[n++] = map->table[i].key;
238 : 2 : th_args->args[n++] = map->table[i].value;
239 : : }
240 : : }
241 : : }
242 : :
243 : : // copy across the positional arguments
244 : 596 : th_args->n_args = pos_args_len;
245 : 596 : memcpy(th_args->args, pos_args_items, pos_args_len * sizeof(mp_obj_t));
246 : :
247 : : // pass our locals and globals into the new thread
248 : 596 : th_args->dict_locals = mp_locals_get();
249 : 596 : th_args->dict_globals = mp_globals_get();
250 : :
251 : : // set the stack size to use
252 : 596 : th_args->stack_size = thread_stack_size;
253 : :
254 : : // set the function for thread entry
255 : 596 : th_args->fun = args[0];
256 : :
257 : : // spawn the thread!
258 : 596 : return mp_obj_new_int_from_uint(mp_thread_create(thread_entry, th_args, &th_args->stack_size));
259 : : }
260 : : static MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_start_new_thread_obj, 2, 3, mod_thread_start_new_thread);
261 : :
262 : 2 : static mp_obj_t mod_thread_exit(void) {
263 : 2 : mp_raise_type(&mp_type_SystemExit);
264 : : }
265 : : static MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_exit_obj, mod_thread_exit);
266 : :
267 : 20 : static mp_obj_t mod_thread_allocate_lock(void) {
268 : 20 : return MP_OBJ_FROM_PTR(mp_obj_new_thread_lock());
269 : : }
270 : : static MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_allocate_lock_obj, mod_thread_allocate_lock);
271 : :
272 : : static const mp_rom_map_elem_t mp_module_thread_globals_table[] = {
273 : : { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__thread) },
274 : : { MP_ROM_QSTR(MP_QSTR_LockType), MP_ROM_PTR(&mp_type_thread_lock) },
275 : : { MP_ROM_QSTR(MP_QSTR_get_ident), MP_ROM_PTR(&mod_thread_get_ident_obj) },
276 : : { MP_ROM_QSTR(MP_QSTR_stack_size), MP_ROM_PTR(&mod_thread_stack_size_obj) },
277 : : { MP_ROM_QSTR(MP_QSTR_start_new_thread), MP_ROM_PTR(&mod_thread_start_new_thread_obj) },
278 : : { MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mod_thread_exit_obj) },
279 : : { MP_ROM_QSTR(MP_QSTR_allocate_lock), MP_ROM_PTR(&mod_thread_allocate_lock_obj) },
280 : : };
281 : :
282 : : static MP_DEFINE_CONST_DICT(mp_module_thread_globals, mp_module_thread_globals_table);
283 : :
284 : : const mp_obj_module_t mp_module_thread = {
285 : : .base = { &mp_type_module },
286 : : .globals = (mp_obj_dict_t *)&mp_module_thread_globals,
287 : : };
288 : :
289 : : MP_REGISTER_MODULE(MP_QSTR__thread, mp_module_thread);
290 : :
291 : : #endif // MICROPY_PY_THREAD
|
