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 | #include "py/stackctrl.h" |
32 | |
33 | #if MICROPY_PY_THREAD |
34 | |
35 | #include "py/mpthread.h" |
36 | |
37 | #if MICROPY_DEBUG_VERBOSE // print debugging info |
38 | #define DEBUG_PRINT (1) |
39 | #define DEBUG_printf DEBUG_printf |
40 | #else // don't print debugging info |
41 | #define DEBUG_PRINT (0) |
42 | #define DEBUG_printf(...) (void)0 |
43 | #endif |
44 | |
45 | /****************************************************************/ |
46 | // Lock object |
47 | |
48 | STATIC const mp_obj_type_t mp_type_thread_lock; |
49 | |
50 | typedef struct _mp_obj_thread_lock_t { |
51 | mp_obj_base_t base; |
52 | mp_thread_mutex_t mutex; |
53 | volatile bool locked; |
54 | } mp_obj_thread_lock_t; |
55 | |
56 | STATIC mp_obj_thread_lock_t *mp_obj_new_thread_lock(void) { |
57 | mp_obj_thread_lock_t *self = m_new_obj(mp_obj_thread_lock_t); |
58 | self->base.type = &mp_type_thread_lock; |
59 | mp_thread_mutex_init(&self->mutex); |
60 | self->locked = false; |
61 | return self; |
62 | } |
63 | |
64 | STATIC mp_obj_t thread_lock_acquire(size_t n_args, const mp_obj_t *args) { |
65 | mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(args[0]); |
66 | bool wait = true; |
67 | if (n_args > 1) { |
68 | wait = mp_obj_get_int(args[1]); |
69 | // TODO support timeout arg |
70 | } |
71 | MP_THREAD_GIL_EXIT(); |
72 | int ret = mp_thread_mutex_lock(&self->mutex, wait); |
73 | MP_THREAD_GIL_ENTER(); |
74 | if (ret == 0) { |
75 | return mp_const_false; |
76 | } else if (ret == 1) { |
77 | self->locked = true; |
78 | return mp_const_true; |
79 | } else { |
80 | mp_raise_OSError(-ret); |
81 | } |
82 | } |
83 | STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock_acquire_obj, 1, 3, thread_lock_acquire); |
84 | |
85 | STATIC mp_obj_t thread_lock_release(mp_obj_t self_in) { |
86 | mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in); |
87 | if (!self->locked) { |
88 | mp_raise_msg(&mp_type_RuntimeError, NULL); |
89 | } |
90 | self->locked = false; |
91 | MP_THREAD_GIL_EXIT(); |
92 | mp_thread_mutex_unlock(&self->mutex); |
93 | MP_THREAD_GIL_ENTER(); |
94 | return mp_const_none; |
95 | } |
96 | STATIC MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_release_obj, thread_lock_release); |
97 | |
98 | STATIC mp_obj_t thread_lock_locked(mp_obj_t self_in) { |
99 | mp_obj_thread_lock_t *self = MP_OBJ_TO_PTR(self_in); |
100 | return mp_obj_new_bool(self->locked); |
101 | } |
102 | STATIC MP_DEFINE_CONST_FUN_OBJ_1(thread_lock_locked_obj, thread_lock_locked); |
103 | |
104 | STATIC mp_obj_t thread_lock___exit__(size_t n_args, const mp_obj_t *args) { |
105 | (void)n_args; // unused |
106 | return thread_lock_release(args[0]); |
107 | } |
108 | STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(thread_lock___exit___obj, 4, 4, thread_lock___exit__); |
109 | |
110 | STATIC const mp_rom_map_elem_t thread_lock_locals_dict_table[] = { |
111 | { MP_ROM_QSTR(MP_QSTR_acquire), MP_ROM_PTR(&thread_lock_acquire_obj) }, |
112 | { MP_ROM_QSTR(MP_QSTR_release), MP_ROM_PTR(&thread_lock_release_obj) }, |
113 | { MP_ROM_QSTR(MP_QSTR_locked), MP_ROM_PTR(&thread_lock_locked_obj) }, |
114 | { MP_ROM_QSTR(MP_QSTR___enter__), MP_ROM_PTR(&thread_lock_acquire_obj) }, |
115 | { MP_ROM_QSTR(MP_QSTR___exit__), MP_ROM_PTR(&thread_lock___exit___obj) }, |
116 | }; |
117 | |
118 | STATIC MP_DEFINE_CONST_DICT(thread_lock_locals_dict, thread_lock_locals_dict_table); |
119 | |
120 | STATIC const mp_obj_type_t mp_type_thread_lock = { |
121 | { &mp_type_type }, |
122 | .name = MP_QSTR_lock, |
123 | .locals_dict = (mp_obj_dict_t *)&thread_lock_locals_dict, |
124 | }; |
125 | |
126 | /****************************************************************/ |
127 | // _thread module |
128 | |
129 | STATIC size_t thread_stack_size = 0; |
130 | |
131 | STATIC mp_obj_t mod_thread_get_ident(void) { |
132 | return mp_obj_new_int_from_uint((uintptr_t)mp_thread_get_state()); |
133 | } |
134 | STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_get_ident_obj, mod_thread_get_ident); |
135 | |
136 | STATIC mp_obj_t mod_thread_stack_size(size_t n_args, const mp_obj_t *args) { |
137 | mp_obj_t ret = mp_obj_new_int_from_uint(thread_stack_size); |
138 | if (n_args == 0) { |
139 | thread_stack_size = 0; |
140 | } else { |
141 | thread_stack_size = mp_obj_get_int(args[0]); |
142 | } |
143 | return ret; |
144 | } |
145 | STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_stack_size_obj, 0, 1, mod_thread_stack_size); |
146 | |
147 | typedef struct _thread_entry_args_t { |
148 | mp_obj_dict_t *dict_locals; |
149 | mp_obj_dict_t *dict_globals; |
150 | size_t stack_size; |
151 | mp_obj_t fun; |
152 | size_t n_args; |
153 | size_t n_kw; |
154 | mp_obj_t args[]; |
155 | } thread_entry_args_t; |
156 | |
157 | STATIC void *thread_entry(void *args_in) { |
158 | // Execution begins here for a new thread. We do not have the GIL. |
159 | |
160 | thread_entry_args_t *args = (thread_entry_args_t *)args_in; |
161 | |
162 | mp_state_thread_t ts; |
163 | mp_thread_set_state(&ts); |
164 | |
165 | mp_stack_set_top(&ts + 1); // need to include ts in root-pointer scan |
166 | mp_stack_set_limit(args->stack_size); |
167 | |
168 | #if MICROPY_ENABLE_PYSTACK |
169 | // TODO threading and pystack is not fully supported, for now just make a small stack |
170 | mp_obj_t mini_pystack[128]; |
171 | mp_pystack_init(mini_pystack, &mini_pystack[128]); |
172 | #endif |
173 | |
174 | // set locals and globals from the calling context |
175 | mp_locals_set(args->dict_locals); |
176 | mp_globals_set(args->dict_globals); |
177 | |
178 | MP_THREAD_GIL_ENTER(); |
179 | |
180 | // signal that we are set up and running |
181 | mp_thread_start(); |
182 | |
183 | // TODO set more thread-specific state here: |
184 | // mp_pending_exception? (root pointer) |
185 | // cur_exception (root pointer) |
186 | |
187 | DEBUG_printf("[thread] start ts=%p args=%p stack=%p\n" , &ts, &args, MP_STATE_THREAD(stack_top)); |
188 | |
189 | nlr_buf_t nlr; |
190 | if (nlr_push(&nlr) == 0) { |
191 | mp_call_function_n_kw(args->fun, args->n_args, args->n_kw, args->args); |
192 | nlr_pop(); |
193 | } else { |
194 | // uncaught exception |
195 | // check for SystemExit |
196 | mp_obj_base_t *exc = (mp_obj_base_t *)nlr.ret_val; |
197 | if (mp_obj_is_subclass_fast(MP_OBJ_FROM_PTR(exc->type), MP_OBJ_FROM_PTR(&mp_type_SystemExit))) { |
198 | // swallow exception silently |
199 | } else { |
200 | // print exception out |
201 | mp_printf(MICROPY_ERROR_PRINTER, "Unhandled exception in thread started by " ); |
202 | mp_obj_print_helper(MICROPY_ERROR_PRINTER, args->fun, PRINT_REPR); |
203 | mp_printf(MICROPY_ERROR_PRINTER, "\n" ); |
204 | mp_obj_print_exception(MICROPY_ERROR_PRINTER, MP_OBJ_FROM_PTR(exc)); |
205 | } |
206 | } |
207 | |
208 | DEBUG_printf("[thread] finish ts=%p\n" , &ts); |
209 | |
210 | // signal that we are finished |
211 | mp_thread_finish(); |
212 | |
213 | MP_THREAD_GIL_EXIT(); |
214 | |
215 | return NULL; |
216 | } |
217 | |
218 | STATIC mp_obj_t mod_thread_start_new_thread(size_t n_args, const mp_obj_t *args) { |
219 | // This structure holds the Python function and arguments for thread entry. |
220 | // We copy all arguments into this structure to keep ownership of them. |
221 | // We must be very careful about root pointers because this pointer may |
222 | // disappear from our address space before the thread is created. |
223 | thread_entry_args_t *th_args; |
224 | |
225 | // get positional arguments |
226 | size_t pos_args_len; |
227 | mp_obj_t *pos_args_items; |
228 | mp_obj_get_array(args[1], &pos_args_len, &pos_args_items); |
229 | |
230 | // check for keyword arguments |
231 | if (n_args == 2) { |
232 | // just position arguments |
233 | th_args = m_new_obj_var(thread_entry_args_t, mp_obj_t, pos_args_len); |
234 | th_args->n_kw = 0; |
235 | } else { |
236 | // positional and keyword arguments |
237 | if (mp_obj_get_type(args[2]) != &mp_type_dict) { |
238 | mp_raise_TypeError(MP_ERROR_TEXT("expecting a dict for keyword args" )); |
239 | } |
240 | mp_map_t *map = &((mp_obj_dict_t *)MP_OBJ_TO_PTR(args[2]))->map; |
241 | th_args = m_new_obj_var(thread_entry_args_t, mp_obj_t, pos_args_len + 2 * map->used); |
242 | th_args->n_kw = map->used; |
243 | // copy across the keyword arguments |
244 | for (size_t i = 0, n = pos_args_len; i < map->alloc; ++i) { |
245 | if (mp_map_slot_is_filled(map, i)) { |
246 | th_args->args[n++] = map->table[i].key; |
247 | th_args->args[n++] = map->table[i].value; |
248 | } |
249 | } |
250 | } |
251 | |
252 | // copy across the positional arguments |
253 | th_args->n_args = pos_args_len; |
254 | memcpy(th_args->args, pos_args_items, pos_args_len * sizeof(mp_obj_t)); |
255 | |
256 | // pass our locals and globals into the new thread |
257 | th_args->dict_locals = mp_locals_get(); |
258 | th_args->dict_globals = mp_globals_get(); |
259 | |
260 | // set the stack size to use |
261 | th_args->stack_size = thread_stack_size; |
262 | |
263 | // set the function for thread entry |
264 | th_args->fun = args[0]; |
265 | |
266 | // spawn the thread! |
267 | mp_thread_create(thread_entry, th_args, &th_args->stack_size); |
268 | |
269 | return mp_const_none; |
270 | } |
271 | STATIC MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mod_thread_start_new_thread_obj, 2, 3, mod_thread_start_new_thread); |
272 | |
273 | STATIC mp_obj_t mod_thread_exit(void) { |
274 | mp_raise_type(&mp_type_SystemExit); |
275 | } |
276 | STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_exit_obj, mod_thread_exit); |
277 | |
278 | STATIC mp_obj_t mod_thread_allocate_lock(void) { |
279 | return MP_OBJ_FROM_PTR(mp_obj_new_thread_lock()); |
280 | } |
281 | STATIC MP_DEFINE_CONST_FUN_OBJ_0(mod_thread_allocate_lock_obj, mod_thread_allocate_lock); |
282 | |
283 | STATIC const mp_rom_map_elem_t mp_module_thread_globals_table[] = { |
284 | { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR__thread) }, |
285 | { MP_ROM_QSTR(MP_QSTR_LockType), MP_ROM_PTR(&mp_type_thread_lock) }, |
286 | { MP_ROM_QSTR(MP_QSTR_get_ident), MP_ROM_PTR(&mod_thread_get_ident_obj) }, |
287 | { MP_ROM_QSTR(MP_QSTR_stack_size), MP_ROM_PTR(&mod_thread_stack_size_obj) }, |
288 | { MP_ROM_QSTR(MP_QSTR_start_new_thread), MP_ROM_PTR(&mod_thread_start_new_thread_obj) }, |
289 | { MP_ROM_QSTR(MP_QSTR_exit), MP_ROM_PTR(&mod_thread_exit_obj) }, |
290 | { MP_ROM_QSTR(MP_QSTR_allocate_lock), MP_ROM_PTR(&mod_thread_allocate_lock_obj) }, |
291 | }; |
292 | |
293 | STATIC MP_DEFINE_CONST_DICT(mp_module_thread_globals, mp_module_thread_globals_table); |
294 | |
295 | const mp_obj_module_t mp_module_thread = { |
296 | .base = { &mp_type_module }, |
297 | .globals = (mp_obj_dict_t *)&mp_module_thread_globals, |
298 | }; |
299 | |
300 | #endif // MICROPY_PY_THREAD |
301 | |