moduselect.c 13.2 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2014 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

27
28
29
#include "py/mpconfig.h"
#if MICROPY_PY_USELECT

30
31
#include <stdio.h>

32
#include "py/runtime.h"
33
34
#include "py/obj.h"
#include "py/objlist.h"
35
#include "py/stream.h"
36
#include "py/mperrno.h"
37
#include "py/mphal.h"
38

39
40
41
// Flags for poll()
#define FLAG_ONESHOT (1)

42
43
44
/// \module select - Provides select function to wait for events on a stream
///
/// This module provides the select function.
45
46

typedef struct _poll_obj_t {
47
    mp_obj_t obj;
48
    mp_uint_t (*ioctl)(mp_obj_t obj, mp_uint_t request, mp_uint_t arg, int *errcode);
49
50
51
52
53
54
    mp_uint_t flags;
    mp_uint_t flags_ret;
} poll_obj_t;

STATIC void poll_map_add(mp_map_t *poll_map, const mp_obj_t *obj, mp_uint_t obj_len, mp_uint_t flags, bool or_flags) {
    for (mp_uint_t i = 0; i < obj_len; i++) {
55
        mp_map_elem_t *elem = mp_map_lookup(poll_map, mp_obj_id(obj[i]), MP_MAP_LOOKUP_ADD_IF_NOT_FOUND);
56
57
        if (elem->value == NULL) {
            // object not found; get its ioctl and add it to the poll list
58
            const mp_stream_p_t *stream_p = mp_get_stream_raise(obj[i], MP_STREAM_OP_IOCTL);
59
            poll_obj_t *poll_obj = m_new_obj(poll_obj_t);
60
            poll_obj->obj = obj[i];
61
            poll_obj->ioctl = stream_p->ioctl;
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
            poll_obj->flags = flags;
            poll_obj->flags_ret = 0;
            elem->value = poll_obj;
        } else {
            // object exists; update its flags
            if (or_flags) {
                ((poll_obj_t*)elem->value)->flags |= flags;
            } else {
                ((poll_obj_t*)elem->value)->flags = flags;
            }
        }
    }
}

// poll each object in the map
STATIC mp_uint_t poll_map_poll(mp_map_t *poll_map, mp_uint_t *rwx_num) {
    mp_uint_t n_ready = 0;
    for (mp_uint_t i = 0; i < poll_map->alloc; ++i) {
        if (!MP_MAP_SLOT_IS_FILLED(poll_map, i)) {
            continue;
        }

        poll_obj_t *poll_obj = (poll_obj_t*)poll_map->table[i].value;
85
        int errcode;
86
        mp_int_t ret = poll_obj->ioctl(poll_obj->obj, MP_STREAM_POLL, poll_obj->flags, &errcode);
87
88
89
90
        poll_obj->flags_ret = ret;

        if (ret == -1) {
            // error doing ioctl
91
            mp_raise_OSError(errcode);
92
93
94
95
96
97
        }

        if (ret != 0) {
            // object is ready
            n_ready += 1;
            if (rwx_num != NULL) {
98
                if (ret & MP_STREAM_POLL_RD) {
99
100
                    rwx_num[0] += 1;
                }
101
                if (ret & MP_STREAM_POLL_WR) {
102
103
                    rwx_num[1] += 1;
                }
104
                if ((ret & ~(MP_STREAM_POLL_RD | MP_STREAM_POLL_WR)) != 0) {
105
106
107
108
109
110
111
112
113
114
115
                    rwx_num[2] += 1;
                }
            }
        }
    }
    return n_ready;
}

/// \function select(rlist, wlist, xlist[, timeout])
STATIC mp_obj_t select_select(uint n_args, const mp_obj_t *args) {
    // get array data from tuple/list arguments
116
    size_t rwx_len[3];
117
118
119
120
121
122
123
124
125
    mp_obj_t *r_array, *w_array, *x_array;
    mp_obj_get_array(args[0], &rwx_len[0], &r_array);
    mp_obj_get_array(args[1], &rwx_len[1], &w_array);
    mp_obj_get_array(args[2], &rwx_len[2], &x_array);

    // get timeout
    mp_uint_t timeout = -1;
    if (n_args == 4) {
        if (args[3] != mp_const_none) {
Dave Hylands's avatar
Dave Hylands committed
126
            #if MICROPY_PY_BUILTINS_FLOAT
127
128
129
130
            float timeout_f = mp_obj_get_float(args[3]);
            if (timeout_f >= 0) {
                timeout = (mp_uint_t)(timeout_f * 1000);
            }
Dave Hylands's avatar
Dave Hylands committed
131
132
133
            #else
            timeout = mp_obj_get_int(args[3]) * 1000;
            #endif
134
135
136
137
138
139
        }
    }

    // merge separate lists and get the ioctl function for each object
    mp_map_t poll_map;
    mp_map_init(&poll_map, rwx_len[0] + rwx_len[1] + rwx_len[2]);
140
141
142
    poll_map_add(&poll_map, r_array, rwx_len[0], MP_STREAM_POLL_RD, true);
    poll_map_add(&poll_map, w_array, rwx_len[1], MP_STREAM_POLL_WR, true);
    poll_map_add(&poll_map, x_array, rwx_len[2], MP_STREAM_POLL_ERR | MP_STREAM_POLL_HUP, true);
143

144
    mp_uint_t start_tick = mp_hal_ticks_ms();
145
146
147
148
149
    rwx_len[0] = rwx_len[1] = rwx_len[2] = 0;
    for (;;) {
        // poll the objects
        mp_uint_t n_ready = poll_map_poll(&poll_map, rwx_len);

150
        if (n_ready > 0 || (timeout != -1 && mp_hal_ticks_ms() - start_tick >= timeout)) {
151
152
153
154
155
156
157
158
159
160
161
            // one or more objects are ready, or we had a timeout
            mp_obj_t list_array[3];
            list_array[0] = mp_obj_new_list(rwx_len[0], NULL);
            list_array[1] = mp_obj_new_list(rwx_len[1], NULL);
            list_array[2] = mp_obj_new_list(rwx_len[2], NULL);
            rwx_len[0] = rwx_len[1] = rwx_len[2] = 0;
            for (mp_uint_t i = 0; i < poll_map.alloc; ++i) {
                if (!MP_MAP_SLOT_IS_FILLED(&poll_map, i)) {
                    continue;
                }
                poll_obj_t *poll_obj = (poll_obj_t*)poll_map.table[i].value;
162
                if (poll_obj->flags_ret & MP_STREAM_POLL_RD) {
163
                    ((mp_obj_list_t*)list_array[0])->items[rwx_len[0]++] = poll_obj->obj;
164
                }
165
                if (poll_obj->flags_ret & MP_STREAM_POLL_WR) {
166
                    ((mp_obj_list_t*)list_array[1])->items[rwx_len[1]++] = poll_obj->obj;
167
                }
168
                if ((poll_obj->flags_ret & ~(MP_STREAM_POLL_RD | MP_STREAM_POLL_WR)) != 0) {
169
                    ((mp_obj_list_t*)list_array[2])->items[rwx_len[2]++] = poll_obj->obj;
170
171
172
173
174
                }
            }
            mp_map_deinit(&poll_map);
            return mp_obj_new_tuple(3, list_array);
        }
175
        MICROPY_EVENT_POLL_HOOK
176
177
178
179
    }
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(mp_select_select_obj, 3, 4, select_select);

180
/// \class Poll - poll class
181
182
183
184

typedef struct _mp_obj_poll_t {
    mp_obj_base_t base;
    mp_map_t poll_map;
185
186
    short iter_cnt;
    short iter_idx;
187
    int flags;
188
189
    // callee-owned tuple
    mp_obj_t ret_tuple;
190
191
192
193
194
195
196
197
198
} mp_obj_poll_t;

/// \method register(obj[, eventmask])
STATIC mp_obj_t poll_register(uint n_args, const mp_obj_t *args) {
    mp_obj_poll_t *self = args[0];
    mp_uint_t flags;
    if (n_args == 3) {
        flags = mp_obj_get_int(args[2]);
    } else {
199
        flags = MP_STREAM_POLL_RD | MP_STREAM_POLL_WR;
200
201
202
203
204
205
206
207
208
    }
    poll_map_add(&self->poll_map, &args[1], 1, flags, false);
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(poll_register_obj, 2, 3, poll_register);

/// \method unregister(obj)
STATIC mp_obj_t poll_unregister(mp_obj_t self_in, mp_obj_t obj_in) {
    mp_obj_poll_t *self = self_in;
209
    mp_map_lookup(&self->poll_map, mp_obj_id(obj_in), MP_MAP_LOOKUP_REMOVE_IF_FOUND);
210
211
212
213
214
215
216
217
    // TODO raise KeyError if obj didn't exist in map
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_2(poll_unregister_obj, poll_unregister);

/// \method modify(obj, eventmask)
STATIC mp_obj_t poll_modify(mp_obj_t self_in, mp_obj_t obj_in, mp_obj_t eventmask_in) {
    mp_obj_poll_t *self = self_in;
218
    mp_map_elem_t *elem = mp_map_lookup(&self->poll_map, mp_obj_id(obj_in), MP_MAP_LOOKUP);
219
    if (elem == NULL) {
220
        mp_raise_OSError(MP_ENOENT);
221
222
223
224
225
226
    }
    ((poll_obj_t*)elem->value)->flags = mp_obj_get_int(eventmask_in);
    return mp_const_none;
}
MP_DEFINE_CONST_FUN_OBJ_3(poll_modify_obj, poll_modify);

227
STATIC mp_uint_t poll_poll_internal(uint n_args, const mp_obj_t *args) {
228
229
230
231
    mp_obj_poll_t *self = args[0];

    // work out timeout (its given already in ms)
    mp_uint_t timeout = -1;
232
233
    int flags = 0;
    if (n_args >= 2) {
234
235
236
237
238
239
        if (args[1] != mp_const_none) {
            mp_int_t timeout_i = mp_obj_get_int(args[1]);
            if (timeout_i >= 0) {
                timeout = timeout_i;
            }
        }
240
241
242
        if (n_args >= 3) {
            flags = mp_obj_get_int(args[2]);
        }
243
244
    }

245
246
    self->flags = flags;

247
    mp_uint_t start_tick = mp_hal_ticks_ms();
248
    mp_uint_t n_ready;
249
250
    for (;;) {
        // poll the objects
251
        n_ready = poll_map_poll(&self->poll_map, NULL);
252
        if (n_ready > 0 || (timeout != -1 && mp_hal_ticks_ms() - start_tick >= timeout)) {
253
            break;
254
        }
255
        MICROPY_EVENT_POLL_HOOK
256
    }
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282

    return n_ready;
}

STATIC mp_obj_t poll_poll(uint n_args, const mp_obj_t *args) {
    mp_obj_poll_t *self = args[0];
    mp_uint_t n_ready = poll_poll_internal(n_args, args);

    // one or more objects are ready, or we had a timeout
    mp_obj_list_t *ret_list = mp_obj_new_list(n_ready, NULL);
    n_ready = 0;
    for (mp_uint_t i = 0; i < self->poll_map.alloc; ++i) {
        if (!MP_MAP_SLOT_IS_FILLED(&self->poll_map, i)) {
            continue;
        }
        poll_obj_t *poll_obj = (poll_obj_t*)self->poll_map.table[i].value;
        if (poll_obj->flags_ret != 0) {
            mp_obj_t tuple[2] = {poll_obj->obj, MP_OBJ_NEW_SMALL_INT(poll_obj->flags_ret)};
            ret_list->items[n_ready++] = mp_obj_new_tuple(2, tuple);
            if (self->flags & FLAG_ONESHOT) {
                // Don't poll next time, until new event flags will be set explicitly
                poll_obj->flags = 0;
            }
        }
    }
    return ret_list;
283
}
284
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(poll_poll_obj, 1, 3, poll_poll);
285

286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
STATIC mp_obj_t poll_ipoll(size_t n_args, const mp_obj_t *args) {
    mp_obj_poll_t *self = MP_OBJ_TO_PTR(args[0]);

    if (self->ret_tuple == MP_OBJ_NULL) {
        self->ret_tuple = mp_obj_new_tuple(2, NULL);
    }

    int n_ready = poll_poll_internal(n_args, args);
    self->iter_cnt = n_ready;
    self->iter_idx = 0;

    return args[0];
}
MP_DEFINE_CONST_FUN_OBJ_VAR_BETWEEN(poll_ipoll_obj, 1, 3, poll_ipoll);

STATIC mp_obj_t poll_iternext(mp_obj_t self_in) {
    mp_obj_poll_t *self = MP_OBJ_TO_PTR(self_in);

    if (self->iter_cnt == 0) {
        return MP_OBJ_STOP_ITERATION;
    }

    self->iter_cnt--;

    for (mp_uint_t i = self->iter_idx; i < self->poll_map.alloc; ++i) {
        self->iter_idx++;
        if (!MP_MAP_SLOT_IS_FILLED(&self->poll_map, i)) {
            continue;
        }
        poll_obj_t *poll_obj = (poll_obj_t*)self->poll_map.table[i].value;
        if (poll_obj->flags_ret != 0) {
            mp_obj_tuple_t *t = MP_OBJ_TO_PTR(self->ret_tuple);
            t->items[0] = poll_obj->obj;
            t->items[1] = MP_OBJ_NEW_SMALL_INT(poll_obj->flags_ret);
            if (self->flags & FLAG_ONESHOT) {
                // Don't poll next time, until new event flags will be set explicitly
                poll_obj->flags = 0;
            }
            return MP_OBJ_FROM_PTR(t);
        }
    }

    assert(!"inconsistent number of poll active entries");
    self->iter_cnt = 0;
    return MP_OBJ_STOP_ITERATION;
}

333
334
335
336
337
STATIC const mp_rom_map_elem_t poll_locals_dict_table[] = {
    { MP_ROM_QSTR(MP_QSTR_register), MP_ROM_PTR(&poll_register_obj) },
    { MP_ROM_QSTR(MP_QSTR_unregister), MP_ROM_PTR(&poll_unregister_obj) },
    { MP_ROM_QSTR(MP_QSTR_modify), MP_ROM_PTR(&poll_modify_obj) },
    { MP_ROM_QSTR(MP_QSTR_poll), MP_ROM_PTR(&poll_poll_obj) },
338
    { MP_ROM_QSTR(MP_QSTR_ipoll), MP_ROM_PTR(&poll_ipoll_obj) },
339
340
341
342
343
344
};
STATIC MP_DEFINE_CONST_DICT(poll_locals_dict, poll_locals_dict_table);

STATIC const mp_obj_type_t mp_type_poll = {
    { &mp_type_type },
    .name = MP_QSTR_poll,
345
346
    .getiter = mp_identity_getiter,
    .iternext = poll_iternext,
347
    .locals_dict = (void*)&poll_locals_dict,
348
349
350
351
352
353
354
};

/// \function poll()
STATIC mp_obj_t select_poll(void) {
    mp_obj_poll_t *poll = m_new_obj(mp_obj_poll_t);
    poll->base.type = &mp_type_poll;
    mp_map_init(&poll->poll_map, 0);
355
356
    poll->iter_cnt = 0;
    poll->ret_tuple = MP_OBJ_NULL;
357
358
359
    return poll;
}
MP_DEFINE_CONST_FUN_OBJ_0(mp_select_poll_obj, select_poll);
360

361
362
363
364
365
366
367
368
STATIC const mp_rom_map_elem_t mp_module_select_globals_table[] = {
    { MP_ROM_QSTR(MP_QSTR___name__), MP_ROM_QSTR(MP_QSTR_uselect) },
    { MP_ROM_QSTR(MP_QSTR_select), MP_ROM_PTR(&mp_select_select_obj) },
    { MP_ROM_QSTR(MP_QSTR_poll), MP_ROM_PTR(&mp_select_poll_obj) },
    { MP_ROM_QSTR(MP_QSTR_POLLIN), MP_OBJ_NEW_SMALL_INT(MP_STREAM_POLL_RD) },
    { MP_ROM_QSTR(MP_QSTR_POLLOUT), MP_OBJ_NEW_SMALL_INT(MP_STREAM_POLL_WR) },
    { MP_ROM_QSTR(MP_QSTR_POLLERR), MP_OBJ_NEW_SMALL_INT(MP_STREAM_POLL_ERR) },
    { MP_ROM_QSTR(MP_QSTR_POLLHUP), MP_OBJ_NEW_SMALL_INT(MP_STREAM_POLL_HUP) },
369
370
};

371
STATIC MP_DEFINE_CONST_DICT(mp_module_select_globals, mp_module_select_globals_table);
372

373
const mp_obj_module_t mp_module_uselect = {
374
375
376
    .base = { &mp_type_module },
    .globals = (mp_obj_dict_t*)&mp_module_select_globals,
};
377

378
#endif // MICROPY_PY_USELECT