52#define LOG_MODULE "Process"
53#define LOG_LEVEL LOG_LEVEL_SYS
60static_assert(PROCESS_CONF_NUMEVENTS > 0 && PROCESS_CONF_NUMEVENTS <= 128,
61 "PROCESS_CONF_NUMEVENTS must be a positive value of at most 128.");
65static_assert(!(PROCESS_CONF_NUMEVENTS & (PROCESS_CONF_NUMEVENTS - 1)),
66 "PROCESS_CONF_NUMEVENTS must be a power of 2.");
71#ifdef PROCESS_CONF_POLL_REQUESTED
72#define PROCESS_POLL_REQUESTED PROCESS_CONF_POLL_REQUESTED
73void PROCESS_POLL_REQUESTED(
void);
75#define PROCESS_POLL_REQUESTED()
81struct process *process_list;
82struct process *process_current;
84static process_event_t lastevent;
95static process_num_events_t nevents, fevent;
96static struct event_data events[PROCESS_CONF_NUMEVENTS];
99process_num_events_t process_maxevents;
102static volatile bool poll_requested;
104#define PROCESS_STATE_NONE 0
105#define PROCESS_STATE_RUNNING 1
106#define PROCESS_STATE_CALLED 2
108static void call_process(
struct process *p, process_event_t ev, process_data_t data);
113 if(lastevent == (process_event_t)~0U) {
114 LOG_WARN(
"Cannot allocate another event number\n");
115 return PROCESS_EVENT_NONE;
127 for(q = process_list; q != p && q != NULL; q = q->next);
134 p->next = process_list;
136 p->state = PROCESS_STATE_RUNNING;
139 LOG_DBG(
"starting '%s'\n", PROCESS_NAME_STRING(p));
146exit_process(
struct process *p,
const struct process *fromprocess)
148 register struct process *q;
149 struct process *old_current = process_current;
151 LOG_DBG(
"exit_process '%s'\n", PROCESS_NAME_STRING(p));
155 for(q = process_list; q != p && q != NULL; q = q->next);
163 if(p->thread != NULL && p != fromprocess) {
166 p->thread(&p->pt, PROCESS_EVENT_EXIT, NULL);
170 if(p == process_list) {
171 process_list = process_list->next;
173 for(q = process_list; q != NULL; q = q->next) {
183 p->state = PROCESS_STATE_NONE;
190 for(q = process_list; q != NULL; q = q->next) {
191 call_process(q, PROCESS_EVENT_EXITED, (process_data_t)p);
195 process_current = old_current;
199call_process(
struct process *p, process_event_t ev, process_data_t data)
201 if(p->state == PROCESS_STATE_CALLED) {
202 LOG_DBG(
"process '%s' called again with event %d\n",
203 PROCESS_NAME_STRING(p), ev);
206 if((p->state & PROCESS_STATE_RUNNING) &&
208 LOG_DBG(
"calling process '%s' with event %d\n",
209 PROCESS_NAME_STRING(p), ev);
211 p->state = PROCESS_STATE_CALLED;
212 int ret = p->thread(&p->pt, ev, data);
213 if(ret == PT_EXITED || ret == PT_ENDED || ev == PROCESS_EVENT_EXIT) {
216 p->state = PROCESS_STATE_RUNNING;
230 lastevent = PROCESS_EVENT_MAX;
240 poll_requested =
false;
242 for(
struct process *p = process_list; p != NULL; p = p->next) {
244 p->state = PROCESS_STATE_RUNNING;
245 p->needspoll =
false;
246 call_process(p, PROCESS_EVENT_POLL, NULL);
269 process_event_t ev = events[fevent].ev;
270 process_data_t data = events[fevent].data;
271 struct process *receiver = events[fevent].p;
275 fevent = (fevent + 1) % PROCESS_CONF_NUMEVENTS;
280 if(receiver == PROCESS_BROADCAST) {
281 for(
struct process *p = process_list; p != NULL; p = p->next) {
287 call_process(p, ev, data);
294 if(ev == PROCESS_EVENT_INIT) {
295 receiver->state = PROCESS_STATE_RUNNING;
299 call_process(receiver, ev, data);
315 return nevents + poll_requested;
321 return nevents + poll_requested;
325process_post(
struct process *p, process_event_t ev, process_data_t data)
327 if(nevents == PROCESS_CONF_NUMEVENTS) {
328 LOG_WARN(
"Cannot post event %d to %s from %s because the queue is full\n",
330 p == PROCESS_BROADCAST ?
"<broadcast>" : PROCESS_NAME_STRING(p),
331 PROCESS_NAME_STRING(process_current));
335 LOG_DBG(
"Process '%s' posts event %d to process '%s', nevents %d\n",
337 ev, p == PROCESS_BROADCAST ?
"<broadcast>" : PROCESS_NAME_STRING(p),
340 process_num_events_t snum =
341 (process_num_events_t)(fevent + nevents) % PROCESS_CONF_NUMEVENTS;
342 events[snum].ev = ev;
343 events[snum].data = data;
347#if PROCESS_CONF_STATS
348 if(nevents > process_maxevents) {
349 process_maxevents = nevents;
359 struct process *caller = process_current;
361 call_process(p, ev, data);
362 process_current = caller;
369 (p->state == PROCESS_STATE_RUNNING || p->state == PROCESS_STATE_CALLED)) {
371 poll_requested =
true;
372 PROCESS_POLL_REQUESTED();
379 return p->state != PROCESS_STATE_NONE;
process_num_events_t process_run(void)
Run the system once - call poll handlers and process one event.
int process_post(struct process *p, process_event_t ev, process_data_t data)
Post an asynchronous event.
void process_exit(struct process *p)
Cause a process to exit.
void process_post_synch(struct process *p, process_event_t ev, process_data_t data)
Post a synchronous event to a process.
#define PROCESS_CURRENT()
Get a pointer to the currently running process.
bool process_is_running(struct process *p)
Check if a process is running.
process_event_t process_alloc_event(void)
Allocate a global event number.
void process_start(struct process *p, process_data_t data)
Start a process.
void process_init(void)
Initialize the process module.
#define PROCESS_ERR_OK
Return value indicating that an operation was successful.
process_num_events_t process_nevents(void)
Number of events waiting to be processed.
#define PROCESS_ERR_FULL
Return value indicating that the event queue was full.
void process_poll(struct process *p)
Request a process to be polled.
#define PT_INIT(pt)
Initialize a protothread.
Header file for the logging system.
Header file for the Contiki process interface.