+++ /dev/null
-/*
- * C eventloop example.
- *
- * Timer management is similar to eventloop.js but implemented in C.
- * In particular, timer insertion is an O(n) operation; in a real world
- * eventloop based on a heap insertion would be O(log N).
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <sys/time.h>
-#include <poll.h>
-
-#include "duktape.h"
-
-#define MAX_TIMERS 4096 /* this is quite excessive for embedded use, but good for testing */
-#define MIN_DELAY 1.0
-#define MIN_WAIT 1.0
-#define MAX_WAIT 60000.0
-#define MAX_EXPIRYS 10
-
-#define MAX_FDS 256
-
-typedef struct {
- int64_t id; /* numeric ID (returned from e.g. setTimeout); zero if unused */
- double target; /* next target time */
- double delay; /* delay/interval */
- int oneshot; /* oneshot=1 (setTimeout), repeated=0 (setInterval) */
- int removed; /* timer has been requested for removal */
-
- /* The callback associated with the timer is held in the "global stash",
- * in <stash>.eventTimers[String(id)]. The references must be deleted
- * when a timer struct is deleted.
- */
-} ev_timer;
-
-/* Active timers. Dense list, terminates to end of list or first unused timer.
- * The list is sorted by 'target', with lowest 'target' (earliest expiry) last
- * in the list. When a timer's callback is being called, the timer is moved
- * to 'timer_expiring' as it needs special handling should the user callback
- * delete that particular timer.
- */
-static ev_timer timer_list[MAX_TIMERS];
-static ev_timer timer_expiring;
-static int timer_count; /* last timer at timer_count - 1 */
-static int64_t timer_next_id = 1;
-
-/* Socket poll state. */
-static struct pollfd poll_list[MAX_FDS];
-static int poll_count = 0;
-
-/* Misc */
-static int exit_requested = 0;
-
-/* Get Javascript compatible 'now' timestamp (millisecs since 1970). */
-static double get_now(void) {
- struct timeval tv;
- int rc;
-
- rc = gettimeofday(&tv, NULL);
- if (rc != 0) {
- /* Should never happen, so return whatever. */
- return 0.0;
- }
- return ((double) tv.tv_sec) * 1000.0 + ((double) tv.tv_usec) / 1000.0;
-}
-
-static ev_timer *find_nearest_timer(void) {
- /* Last timer expires first (list is always kept sorted). */
- if (timer_count <= 0) {
- return NULL;
- }
- return timer_list + timer_count - 1;
-}
-
-/* Bubble last timer on timer list backwards until it has been moved to
- * its proper sorted position (based on 'target' time).
- */
-static void bubble_last_timer(void) {
- int i;
- int n = timer_count;
- ev_timer *t;
- ev_timer tmp;
-
- for (i = n - 1; i > 0; i--) {
- /* Timer to bubble is at index i, timer to compare to is
- * at i-1 (both guaranteed to exist).
- */
- t = timer_list + i;
- if (t->target <= (t-1)->target) {
- /* 't' expires earlier than (or same time as) 't-1', so we're done. */
- break;
- } else {
- /* 't' expires later than 't-1', so swap them and repeat. */
- memcpy((void *) &tmp, (void *) (t - 1), sizeof(ev_timer));
- memcpy((void *) (t - 1), (void *) t, sizeof(ev_timer));
- memcpy((void *) t, (void *) &tmp, sizeof(ev_timer));
- }
- }
-}
-
-static void expire_timers(duk_context *ctx) {
- ev_timer *t;
- int sanity = MAX_EXPIRYS;
- double now;
- int rc;
-
- /* Because a user callback can mutate the timer list (by adding or deleting
- * a timer), we expire one timer and then rescan from the end again. There
- * is a sanity limit on how many times we do this per expiry round.
- */
-
- duk_push_global_stash(ctx);
- duk_get_prop_string(ctx, -1, "eventTimers");
-
- /* [ ... stash eventTimers ] */
-
- now = get_now();
- while (sanity-- > 0) {
- /*
- * If exit has been requested, exit without running further
- * callbacks.
- */
-
- if (exit_requested) {
-#if 0
- fprintf(stderr, "exit requested, exiting timer expiry loop\n");
- fflush(stderr);
-#endif
- break;
- }
-
- /*
- * Expired timer(s) still exist?
- */
-
- if (timer_count <= 0) {
- break;
- }
- t = timer_list + timer_count - 1;
- if (t->target > now) {
- break;
- }
-
- /*
- * Move the timer to 'expiring' for the duration of the callback.
- * Mark a one-shot timer deleted, compute a new target for an interval.
- */
-
- memcpy((void *) &timer_expiring, (void *) t, sizeof(ev_timer));
- memset((void *) t, 0, sizeof(ev_timer));
- timer_count--;
- t = &timer_expiring;
-
- if (t->oneshot) {
- t->removed = 1;
- } else {
- t->target = now + t->delay; /* XXX: or t->target + t->delay? */
- }
-
- /*
- * Call timer callback. The callback can operate on the timer list:
- * add new timers, remove timers. The callback can even remove the
- * expired timer whose callback we're calling. However, because the
- * timer being expired has been moved to 'timer_expiring', we don't
- * need to worry about the timer's offset changing on the timer list.
- */
-
-#if 0
- fprintf(stderr, "calling user callback for timer id %d\n", (int) t->id);
- fflush(stderr);
-#endif
-
- duk_push_number(ctx, (double) t->id);
- duk_get_prop(ctx, -2); /* -> [ ... stash eventTimers func ] */
- rc = duk_pcall(ctx, 0 /*nargs*/); /* -> [ ... stash eventTimers retval ] */
- if (rc != 0) {
-#if 0
- fprintf(stderr, "timer callback failed for timer %d: %s\n", (int) t->id, duk_to_string(ctx, -1));
- fflush(stderr);
-#endif
- }
- duk_pop(ctx); /* ignore errors for now -> [ ... stash eventTimers ] */
-
- if (t->removed) {
- /* One-shot timer (always removed) or removed by user callback. */
-#if 0
- fprintf(stderr, "deleting callback state for timer %d\n", (int) t->id);
- fflush(stderr);
-#endif
- duk_push_number(ctx, (double) t->id);
- duk_del_prop(ctx, -2);
- } else {
- /* Interval timer, not removed by user callback. Queue back to
- * timer list and bubble to its final sorted position.
- */
-#if 0
- fprintf(stderr, "queueing timer %d back into active list\n", (int) t->id);
- fflush(stderr);
-#endif
- if (timer_count >= MAX_TIMERS) {
- duk_error(ctx, DUK_ERR_RANGE_ERROR, "out of timer slots");
- }
- memcpy((void *) (timer_list + timer_count), (void *) t, sizeof(ev_timer));
- timer_count++;
- bubble_last_timer();
- }
- }
-
- memset((void *) &timer_expiring, 0, sizeof(ev_timer));
-
- duk_pop_2(ctx); /* -> [ ... ] */
-}
-
-static void compact_poll_list(void) {
- int i, j, n;
-
- /* i = input index
- * j = output index (initially same as i)
- */
-
- n = poll_count;
- for (i = 0, j = 0; i < n; i++) {
- struct pollfd *pfd = poll_list + i;
- if (pfd->fd == 0) {
- /* keep output index the same */
-#if 0
- fprintf(stderr, "remove pollfd (index %d): fd=%d, events=%d, revents=%d\n",
- i, pfd->fd, pfd->events, pfd->revents),
- fflush(stderr);
-#endif
-
- continue;
- }
-#if 0
- fprintf(stderr, "keep pollfd (index %d -> %d): fd=%d, events=%d, revents=%d\n",
- i, j, pfd->fd, pfd->events, pfd->revents),
- fflush(stderr);
-#endif
- if (i != j) {
- /* copy only if indices have diverged */
- memcpy((void *) (poll_list + j), (void *) (poll_list + i), sizeof(struct pollfd));
- }
- j++;
- }
-
- if (j < poll_count) {
- /* zeroize unused entries for sanity */
- memset((void *) (poll_list + j), 0, (poll_count - j) * sizeof(struct pollfd));
- }
-
- poll_count = j;
-}
-
-int eventloop_run(duk_context *ctx) {
- ev_timer *t;
- double now;
- double diff;
- int timeout;
- int rc;
- int i, n;
- int idx_eventloop;
- int idx_fd_handler;
-
- /* The Ecmascript poll handler is passed through EventLoop.fdPollHandler
- * which c_eventloop.js sets before we come here.
- */
- duk_push_global_object(ctx);
- duk_get_prop_string(ctx, -1, "EventLoop");
- duk_get_prop_string(ctx, -1, "fdPollHandler"); /* -> [ global EventLoop fdPollHandler ] */
- idx_fd_handler = duk_get_top_index(ctx);
- idx_eventloop = idx_fd_handler - 1;
-
- for (;;) {
- /*
- * Expire timers.
- */
-
- expire_timers(ctx);
-
- /*
- * If exit requested, bail out as fast as possible.
- */
-
- if (exit_requested) {
-#if 0
- fprintf(stderr, "exit requested, exiting event loop\n");
- fflush(stderr);
-#endif
- break;
- }
-
- /*
- * Compact poll list by removing pollfds with fd == 0.
- */
-
- compact_poll_list();
-
- /*
- * Determine poll() timeout (as close to poll() as possible as
- * the wait is relative).
- */
-
- now = get_now();
- t = find_nearest_timer();
- if (t) {
- diff = t->target - now;
- if (diff < MIN_WAIT) {
- diff = MIN_WAIT;
- } else if (diff > MAX_WAIT) {
- diff = MAX_WAIT;
- }
- timeout = (int) diff; /* clamping ensures that fits */
- } else {
- if (poll_count == 0) {
-#if 0
- fprintf(stderr, "no timers and no sockets to poll, exiting\n");
- fflush(stderr);
-#endif
- break;
- }
- timeout = (int) MAX_WAIT;
- }
-
- /*
- * Poll for activity or timeout.
- */
-
-#if 0
- fprintf(stderr, "going to poll, timeout %d ms, pollfd count %d\n", timeout, poll_count);
- fflush(stderr);
-#endif
-
- rc = poll(poll_list, poll_count, timeout);
-#if 0
- fprintf(stderr, "poll rc: %d\n", rc);
- fflush(stderr);
-#endif
- if (rc < 0) {
- /* error */
- } else if (rc == 0) {
- /* timeout */
- } else {
- /* 'rc' fds active */
- }
-
- /*
- * Check socket activity, handle all sockets. Handling is offloaded to
- * Ecmascript code (fd + revents).
- *
- * If FDs are removed from the poll list while we're processing callbacks,
- * the entries are simply marked unused (fd set to 0) without actually
- * removing them from the poll list. This ensures indices are not
- * disturbed. The poll list is compacted before next poll().
- */
-
- n = (rc == 0 ? 0 : poll_count); /* if timeout, no need to check pollfd */
- for (i = 0; i < n; i++) {
- struct pollfd *pfd = poll_list + i;
-
- if (pfd->fd == 0) {
- /* deleted, perhaps by previous callback */
- continue;
- }
-
- if (pfd->revents) {
-#if 0
- fprintf(stderr, "fd %d has revents: %d\n", (int) pfd->fd, (int) pfd->revents);
- fflush(stderr);
-#endif
- duk_dup(ctx, idx_fd_handler);
- duk_dup(ctx, idx_eventloop);
- duk_push_int(ctx, pfd->fd);
- duk_push_int(ctx, pfd->revents);
- rc = duk_pcall_method(ctx, 2 /*nargs*/);
- if (rc) {
-#if 0
- fprintf(stderr, "fd callback failed for fd %d: %s\n", (int) pfd->fd, duk_to_string(ctx, -1));
- fflush(stderr);
-#endif
- }
- duk_pop(ctx);
-
- pfd->revents = 0;
- }
-
- }
- }
-
- duk_pop_n(ctx, 3);
-
- return 0;
-}
-
-static int create_timer(duk_context *ctx) {
- double delay;
- int oneshot;
- int idx;
- int64_t timer_id;
- double now;
- ev_timer *t;
-
- now = get_now();
-
- /* indexes:
- * 0 = function (callback)
- * 1 = delay
- * 2 = boolean: oneshot
- */
-
- delay = duk_require_number(ctx, 1);
- if (delay < MIN_DELAY) {
- delay = MIN_DELAY;
- }
- oneshot = duk_require_boolean(ctx, 2);
-
- if (timer_count >= MAX_TIMERS) {
- duk_error(ctx, DUK_ERR_RANGE_ERROR, "out of timer slots");
- }
- idx = timer_count++;
- timer_id = timer_next_id++;
- t = timer_list + idx;
-
- memset((void *) t, 0, sizeof(ev_timer));
- t->id = timer_id;
- t->target = now + delay;
- t->delay = delay;
- t->oneshot = oneshot;
- t->removed = 0;
-
- /* Timer is now at the last position; use swaps to "bubble" it to its
- * correct sorted position.
- */
-
- bubble_last_timer();
-
- /* Finally, register the callback to the global stash 'eventTimers' object. */
-
- duk_push_global_stash(ctx);
- duk_get_prop_string(ctx, -1, "eventTimers"); /* -> [ func delay oneshot stash eventTimers ] */
- duk_push_number(ctx, (double) timer_id);
- duk_dup(ctx, 0);
- duk_put_prop(ctx, -3); /* eventTimers[timer_id] = callback */
-
- /* Return timer id. */
-
- duk_push_number(ctx, (double) timer_id);
-#if 0
- fprintf(stderr, "created timer id: %d\n", (int) timer_id);
- fflush(stderr);
-#endif
- return 1;
-}
-
-static int delete_timer(duk_context *ctx) {
- int i, n;
- int64_t timer_id;
- ev_timer *t;
- int found = 0;
-
- /* indexes:
- * 0 = timer id
- */
-
- timer_id = (int64_t) duk_require_number(ctx, 0);
-
- /*
- * Unlike insertion, deletion needs a full scan of the timer list
- * and an expensive remove. If no match is found, nothing is deleted.
- * Caller gets a boolean return code indicating match.
- *
- * When a timer is being expired and its user callback is running,
- * the timer has been moved to 'timer_expiring' and its deletion
- * needs special handling: just mark it to-be-deleted and let the
- * expiry code remove it.
- */
-
- t = &timer_expiring;
- if (t->id == timer_id) {
- t->removed = 1;
- duk_push_true(ctx);
-#if 0
- fprintf(stderr, "deleted expiring timer id: %d\n", (int) timer_id);
- fflush(stderr);
-#endif
- return 1;
- }
-
- n = timer_count;
- for (i = 0; i < n; i++) {
- t = timer_list + i;
- if (t->id == timer_id) {
- found = 1;
-
- /* Shift elements downwards to keep the timer list dense
- * (no need if last element).
- */
- if (i < timer_count - 1) {
- memmove((void *) t, (void *) (t + 1), (timer_count - i - 1) * sizeof(ev_timer));
- }
-
- /* Zero last element for clarity. */
- memset((void *) (timer_list + n - 1), 0, sizeof(ev_timer));
-
- /* Update timer_count. */
- timer_count--;
-
- /* The C state is now up-to-date, but we still need to delete
- * the timer callback state from the global 'stash'.
- */
-
- duk_push_global_stash(ctx);
- duk_get_prop_string(ctx, -1, "eventTimers"); /* -> [ timer_id stash eventTimers ] */
- duk_push_number(ctx, (double) timer_id);
- duk_del_prop(ctx, -2); /* delete eventTimers[timer_id] */
-
-#if 0
- fprintf(stderr, "deleted timer id: %d\n", (int) timer_id);
- fflush(stderr);
-#endif
- break;
- }
- }
-
-#if 0
- if (!found) {
- fprintf(stderr, "trying to delete timer id %d, but not found; ignoring\n", (int) timer_id);
- fflush(stderr);
- }
-#endif
-
- duk_push_boolean(ctx, found);
- return 1;
-}
-
-static int listen_fd(duk_context *ctx) {
- int fd = duk_require_int(ctx, 0);
- int events = duk_require_int(ctx, 1);
- int i, n;
- struct pollfd *pfd;
-
-#if 0
- fprintf(stderr, "listen_fd: fd=%d, events=%d\n", fd, events);
- fflush(stderr);
-#endif
- /* events == 0 means stop listening to the FD */
-
- n = poll_count;
- for (i = 0; i < n; i++) {
- pfd = poll_list + i;
- if (pfd->fd == fd) {
-#if 0
- fprintf(stderr, "listen_fd: fd found at index %d\n", i);
- fflush(stderr);
-#endif
- if (events == 0) {
- /* mark to-be-deleted, cleaned up by next poll */
- pfd->fd = 0;
- } else {
- pfd->events = events;
- }
- return 0;
- }
- }
-
- /* not found, append to list */
-#if 0
- fprintf(stderr, "listen_fd: fd not found on list, add new entry\n");
- fflush(stderr);
-#endif
-
- if (poll_count >= MAX_FDS) {
- duk_error(ctx, DUK_ERR_ERROR, "out of fd slots");
- }
-
- pfd = poll_list + poll_count;
- pfd->fd = fd;
- pfd->events = events;
- pfd->revents = 0;
- poll_count++;
-
- return 0;
-}
-
-static int request_exit(duk_context *ctx) {
- (void) ctx;
- exit_requested = 1;
- return 0;
-}
-
-static duk_function_list_entry eventloop_funcs[] = {
- { "createTimer", create_timer, 3 },
- { "deleteTimer", delete_timer, 1 },
- { "listenFd", listen_fd, 2 },
- { "requestExit", request_exit, 0 },
- { NULL, NULL, 0 }
-};
-
-void eventloop_register(duk_context *ctx) {
- memset((void *) timer_list, 0, MAX_TIMERS * sizeof(ev_timer));
- memset((void *) &timer_expiring, 0, sizeof(ev_timer));
- memset((void *) poll_list, 0, MAX_FDS * sizeof(struct pollfd));
-
- /* Set global 'EventLoop'. */
- duk_push_global_object(ctx);
- duk_push_object(ctx);
- duk_put_function_list(ctx, -1, eventloop_funcs);
- duk_put_prop_string(ctx, -2, "EventLoop");
- duk_pop(ctx);
-
- /* Initialize global stash 'eventTimers'. */
- duk_push_global_stash(ctx);
- duk_push_object(ctx);
- duk_put_prop_string(ctx, -2, "eventTimers");
- duk_pop(ctx);
-}
projects / ceph.git / blobdiff