spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/events/events.h

@@ -0,0 +1,106 @@
+#ifndef _EVENTS_H_
+#define _EVENTS_H_
+
+#include <sys/select.h>
+
+/**
+ * events_immediate_register(func, cookie, prio):
+ * Register ${func}(${cookie}) to be run the next time events_run is invoked,
+ * after immediate events with smaller ${prio} values and before events with
+ * larger ${prio} values.  The value ${prio} must be in the range [0, 31].
+ * Return a cookie which can be passed to events_immediate_cancel.
+ */
+void * events_immediate_register(int (*)(void *), void *, int);
+
+/**
+ * events_immediate_cancel(cookie):
+ * Cancel the immediate event for which the cookie ${cookie} was returned by
+ * events_immediate_register.
+ */
+void events_immediate_cancel(void *);
+
+/* "op" parameter to events_network_register. */
+#define EVENTS_NETWORK_OP_READ 	0
+#define EVENTS_NETWORK_OP_WRITE	1
+
+/**
+ * events_network_register(func, cookie, s, op):
+ * Register ${func}(${cookie}) to be run when socket ${s} is ready for
+ * reading or writing depending on whether ${op} is EVENTS_NETWORK_OP_READ or
+ * EVENTS_NETWORK_OP_WRITE.  If there is already an event registration for
+ * this ${s}/${op} pair, errno will be set to EEXIST and the function will
+ * fail.
+ */
+int events_network_register(int (*)(void *), void *, int, int);
+
+/**
+ * events_network_cancel(s, op):
+ * Cancel the event registered for the socket/operation pair ${s}/${op}.  If
+ * there is no such registration, errno will be set to ENOENT and the
+ * function will fail.
+ */
+int events_network_cancel(int, int);
+
+/**
+ * events_network_selectstats(N, mu, va, max):
+ * Return statistics on the inter-select durations since the last time this
+ * function was called.
+ */
+void events_network_selectstats(double *, double *, double *, double *);
+
+/**
+ * events_timer_register(func, cookie, timeo):
+ * Register ${func}(${cookie}) to be run ${timeo} in the future.  Return a
+ * cookie which can be passed to events_timer_cancel or events_timer_reset.
+ */
+void * events_timer_register(int (*)(void *), void *, const struct timeval *);
+
+/**
+ * events_timer_register_double(func, cookie, timeo):
+ * As events_timer_register, but ${timeo} is a double-precision floating point
+ * value specifying a number of seconds.
+ */
+void * events_timer_register_double(int (*)(void *), void *, double);
+
+/**
+ * events_timer_cancel(cookie):
+ * Cancel the timer for which the cookie ${cookie} was returned by
+ * events_timer_register.
+ */
+void events_timer_cancel(void *);
+
+/**
+ * events_timer_reset(cookie):
+ * Reset the timer for which the cookie ${cookie} was returned by
+ * events_timer_register to its initial value.
+ */
+int events_timer_reset(void *);
+
+/**
+ * events_run(void):
+ * Run events.  Events registered via events_immediate_register will be run
+ * first, in order of increasing ${prio} values; then events associated with
+ * ready sockets registered via events_network_register; finally, events
+ * associated with expired timers registered via events_timer_register will
+ * be run.  If any event function returns a non-zero result, no further
+ * events will be run and said non-zero result will be returned; on error,
+ * -1 will be returned.
+ */
+int events_run(void);
+
+/**
+ * events_spin(done):
+ * Run events until ${done} is non-zero (and return 0), an error occurs (and
+ * return -1), or a callback returns a non-zero status (and return the status
+ * code from the callback).
+ */
+int events_spin(int *);
+
+/**
+ * events_shutdown(void):
+ * Clean up and free memory.  This call is not necessary on program exit and
+ * is only expected to be useful when checking for memory leaks.
+ */
+void events_shutdown(void);
+
+#endif /* !_EVENTS_H_ */

data/ext/spiped/spiped-source/libcperciva/events/events_immediate.c

@@ -0,0 +1,149 @@
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "mpool.h"
+
+#include "events_internal.h"
+#include "events.h"
+
+struct eventq {
+	struct eventrec * r;
+	struct eventq * next;
+	struct eventq * prev;
+	int prio;
+};
+
+MPOOL(eventq, struct eventq, 4096);
+
+/* First nodes in the linked lists. */
+static struct eventq * heads[32] = {
+	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+	NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL
+};
+
+/* For non-NULL heads[i], tails[i] is the last node in the list. */
+static struct eventq * tails[32];
+
+/* For i < minq, heads[i] == NULL. */
+static int minq = 32;
+
+/**
+ * events_immediate_register(func, cookie, prio):
+ * Register ${func}(${cookie}) to be run the next time events_run is invoked,
+ * after immediate events with smaller ${prio} values and before events with
+ * larger ${prio} values.  The value ${prio} must be in the range [0, 31].
+ * Return a cookie which can be passed to events_immediate_cancel.
+ */
+void *
+events_immediate_register(int (*func)(void *), void * cookie, int prio)
+{
+	struct eventrec * r;
+	struct eventq * q;
+
+	/* Sanity check. */
+	assert((prio >= 0) && (prio < 32));
+
+	/* Bundle into an eventrec record. */
+	if ((r = events_mkrec(func, cookie)) == NULL)
+		goto err0;
+
+	/* Create a linked list node. */
+	if ((q = mpool_eventq_malloc()) == NULL)
+		goto err1;
+	q->r = r;
+	q->next = NULL;
+	q->prev = NULL;
+	q->prio = prio;
+
+	/* Add to the queue. */
+	if (heads[prio] == NULL) {
+		heads[prio] = q;
+		if (prio < minq)
+			minq = prio;
+	} else {
+		tails[prio]->next = q;
+		q->prev = tails[prio];
+	}
+	tails[prio] = q;
+
+	/* Success! */
+	return (q);
+
+err1:
+	events_freerec(r);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * events_immediate_cancel(cookie):
+ * Cancel the immediate event for which the cookie ${cookie} was returned by
+ * events_immediate_register.
+ */
+void
+events_immediate_cancel(void * cookie)
+{
+	struct eventq * q = cookie;
+	int prio = q->prio;
+
+	/* If we have a predecessor, point it at our successor. */
+	if (q->prev != NULL)
+		q->prev->next = q->next;
+	else
+		heads[prio] = q->next;
+
+	/* If we have a successor, point it at our predecessor. */
+	if (q->next != NULL)
+		q->next->prev = q->prev;
+	else
+		tails[prio] = q->prev;
+
+	/* Free the eventrec. */
+	events_freerec(q->r);
+
+	/* Return the node to the malloc pool. */
+	mpool_eventq_free(q);
+}
+
+/**
+ * events_immediate_get(void):
+ * Remove and return an eventrec structure from the immediate event queue,
+ * or return NULL if there are no such events.  The caller is responsible for
+ * freeing the returned memory.
+ */
+struct eventrec *
+events_immediate_get(void)
+{
+	struct eventq * q;
+	struct eventrec * r;
+
+	/* Advance past priorities which have no events. */
+	while ((minq < 32) && (heads[minq] == NULL))
+		minq++;
+
+	/* Are there any events? */
+	if (minq == 32)
+		return (NULL);
+
+	/*
+	 * Remove the first node from the highest priority non-empty linked
+	 * list.
+	 */
+	q = heads[minq];
+	heads[minq] = q->next;
+	if (heads[minq] != NULL)
+		heads[minq]->prev = NULL;
+
+	/* Extract the eventrec. */
+	r = q->r;
+
+	/* Return the node to the malloc pool. */
+	mpool_eventq_free(q);
+
+	/* Return the eventrec. */
+	return (r);
+}

data/ext/spiped/spiped-source/libcperciva/events/events_internal.h

@@ -0,0 +1,95 @@
+#ifndef _EVENTS_INTERNAL_H_
+#define _EVENTS_INTERNAL_H_
+
+#include <sys/time.h>
+
+/* Opaque event structure. */
+struct eventrec;
+
+/**
+ * events_mkrec(func, cookie):
+ * Package ${func}, ${cookie} into a struct eventrec.
+ */
+struct eventrec * events_mkrec(int (*)(void *), void *);
+
+/**
+ * events_freerec(r):
+ * Free the eventrec ${r}.
+ */
+void events_freerec(struct eventrec *);
+
+/**
+ * events_immediate_get(void):
+ * Remove and return an eventrec structure from the immediate event queue,
+ * or return NULL if there are no such events.  The caller is responsible for
+ * freeing the returned memory.
+ */
+struct eventrec * events_immediate_get(void);
+
+/**
+ * events_network_select(tv):
+ * Check for socket readiness events, waiting up to ${tv} time if there are
+ * no sockets immediately ready, or indefinitely if ${tv} is NULL.  The value
+ * stored in ${tv} may be modified.
+ */
+int events_network_select(struct timeval *);
+
+/**
+ * events_network_selectstats_startclock(void):
+ * Start the inter-select duration clock: There is a selectable event.
+ */
+void events_network_selectstats_startclock(void);
+
+/**
+ * events_network_selectstats_stopclock(void):
+ * Stop the inter-select duration clock: There are no selectable events.
+ */
+void events_network_selectstats_stopclock(void);
+
+/**
+ * events_network_selectstats_select(void):
+ * Update inter-select duration statistics in relation to an upcoming
+ * select(2) call.
+ */
+void events_network_selectstats_select(void);
+
+/**
+ * events_network_get(void):
+ * Find a socket readiness event which was identified by a previous call to
+ * events_network_select, and return it as an eventrec structure; or return
+ * NULL if there are no such events available.  The caller is responsible for
+ * freeing the returned memory.
+ */
+struct eventrec * events_network_get(void);
+
+/**
+ * events_network_shutdown(void)
+ * Clean up and free memory.  This call is not necessary on program exit and
+ * is only expected to be useful when checking for memory leaks.
+ */
+void events_network_shutdown(void);
+
+/**
+ * events_timer_min(timeo):
+ * Return via ${timeo} a pointer to the minimum time which must be waited
+ * before a timer will expire; or to NULL if there are no timers.  The caller
+ * is responsible for freeing the returned pointer.
+ */
+int events_timer_min(struct timeval **);
+
+/**
+ * events_timer_get(r):
+ * Return via ${r} a pointer to an eventrec structure corresponding to an
+ * expired timer, and delete said timer; or to NULL if there are no expired
+ * timers.  The caller is responsible for freeing the returned pointer.
+ */
+int events_timer_get(struct eventrec **);
+
+/**
+ * events_timer_shutdown(void):
+ * Clean up and free memory.  This call is not necessary on program exit and
+ * is only expected to be useful when checking for memory leaks.
+ */
+void events_timer_shutdown(void);
+
+#endif /* !_EVENTS_INTERNAL_H_ */

data/ext/spiped/spiped-source/libcperciva/events/events_network.c

@@ -0,0 +1,347 @@
+#include <sys/select.h>
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include "elasticarray.h"
+#include "warnp.h"
+
+#include "events_internal.h"
+#include "events.h"
+
+/* Structure for holding readability and writability events for a socket. */
+struct socketrec {
+	struct eventrec * reader;
+	struct eventrec * writer;
+};
+
+/* List of sockets. */
+ELASTICARRAY_DECL(SOCKETLIST, socketlist, struct socketrec);
+static SOCKETLIST S = NULL;
+
+/* File descriptor sets containing unevented ready sockets. */
+static fd_set readfds;
+static fd_set writefds;
+
+/* Position to which events_network_get has scanned in *fds. */
+static size_t fdscanpos;
+
+/* Number of registered events. */
+static size_t nev;
+
+/* Initialize the socket list if we haven't already done so. */
+static int
+initsocketlist(void)
+{
+
+	/* If we're already initialized, do nothing. */
+	if (S != NULL)
+		goto done;
+
+	/* Initialize the socket list. */
+	if ((S = socketlist_init(0)) == NULL)
+		goto err0;
+
+	/* There are no events registered. */
+	nev = 0;
+
+	/* There are no unevented ready sockets. */
+	fdscanpos = FD_SETSIZE;
+
+done:
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/* Grow the socket list and initialize new records. */
+static int
+growsocketlist(size_t nrec)
+{
+	size_t i;
+
+	/* Get the old size. */
+	i = socketlist_getsize(S);
+
+	/* Grow the list. */
+	if (socketlist_resize(S, nrec))
+		goto err0;
+
+	/* Initialize new members. */
+	for (; i < nrec; i++) {
+		socketlist_get(S, i)->reader = NULL;
+		socketlist_get(S, i)->writer = NULL;
+	}
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_network_register(func, cookie, s, op):
+ * Register ${func}(${cookie}) to be run when socket ${s} is ready for
+ * reading or writing depending on whether ${op} is EVENTS_NETWORK_OP_READ or
+ * EVENTS_NETWORK_OP_WRITE.  If there is already an event registration for
+ * this ${s}/${op} pair, errno will be set to EEXIST and the function will
+ * fail.
+ */
+int
+events_network_register(int (*func)(void *), void * cookie, int s, int op)
+{
+	struct eventrec ** r;
+
+	/* Initialize if necessary. */
+	if (initsocketlist())
+		goto err0;
+
+	/* Sanity-check socket number. */
+	if ((s < 0) || (s >= (int)FD_SETSIZE)) {
+		warn0("Invalid file descriptor for network event: %d", s);
+		goto err0;
+	}
+
+	/* Sanity-check operation. */
+	if ((op != EVENTS_NETWORK_OP_READ) &&
+	    (op != EVENTS_NETWORK_OP_WRITE)) {
+		warn0("Invalid operation for network event: %d", op);
+		goto err0;
+	}
+
+	/* Grow the array if necessary. */
+	if (((size_t)(s) >= socketlist_getsize(S)) &&
+	    (growsocketlist(s + 1) != 0))
+		goto err0;
+
+	/* Look up the relevant event pointer. */
+	if (op == EVENTS_NETWORK_OP_READ)
+		r = &socketlist_get(S, s)->reader;
+	else
+		r = &socketlist_get(S, s)->writer;
+
+	/* Error out if we already have an event registered. */
+	if (*r != NULL) {
+		errno = EEXIST;
+		goto err0;
+	}
+
+	/* Register the new event. */
+	if ((*r = events_mkrec(func, cookie)) == NULL)
+		goto err0;
+
+	/*
+	 * Increment events-registered counter; and if it was zero, start the
+	 * inter-select duration clock.
+	 */
+	if (nev++ == 0)
+		events_network_selectstats_startclock();
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_network_cancel(s, op):
+ * Cancel the event registered for the socket/operation pair ${s}/${op}.  If
+ * there is no such registration, errno will be set to ENOENT and the
+ * function will fail.
+ */
+int
+events_network_cancel(int s, int op)
+{
+	struct eventrec ** r;
+
+	/* Initialize if necessary. */
+	if (initsocketlist())
+		goto err0;
+
+	/* Sanity-check socket number. */
+	if ((s < 0) || (s >= (int)FD_SETSIZE)) {
+		warn0("Invalid file descriptor for network event: %d", s);
+		goto err0;
+	}
+
+	/* Sanity-check operation. */
+	if ((op != EVENTS_NETWORK_OP_READ) &&
+	    (op != EVENTS_NETWORK_OP_WRITE)) {
+		warn0("Invalid operation for network event: %d", op);
+		goto err0;
+	}
+
+	/* We have no events registered beyond the end of the array. */
+	if ((size_t)(s) >= socketlist_getsize(S)) {
+		errno = ENOENT;
+		goto err0;
+	}
+
+	/* Look up the relevant event pointer. */
+	if (op == EVENTS_NETWORK_OP_READ)
+		r = &socketlist_get(S, s)->reader;
+	else
+		r = &socketlist_get(S, s)->writer;
+
+	/* Check if we have an event. */
+	if (*r == NULL) {
+		errno = ENOENT;
+		goto err0;
+	}
+
+	/* Free the event. */
+	events_freerec(*r);
+	*r = NULL;
+
+	/*
+	 * Since there is no longer an event registered for this socket /
+	 * operation pair, it doesn't make any sense for it to be ready.
+	 */
+	if (op == EVENTS_NETWORK_OP_READ)
+		FD_CLR(s, &readfds);
+	else
+		FD_CLR(s, &writefds);
+
+	/*
+	 * Decrement events-registered counter; and if it is becoming zero,
+	 * stop the inter-select duration clock.
+	 */
+	if (--nev == 0)
+		events_network_selectstats_stopclock();
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_network_select(tv):
+ * Check for socket readiness events, waiting up to ${tv} time if there are
+ * no sockets immediately ready, or indefinitely if ${tv} is NULL.  The value
+ * stored in ${tv} may be modified.
+ */
+int
+events_network_select(struct timeval * tv)
+{
+	size_t i;
+
+	/* Initialize if necessary. */
+	if (initsocketlist())
+		goto err0;
+
+	/* Zero the fd sets... */
+	FD_ZERO(&readfds);
+	FD_ZERO(&writefds);
+
+	/* ... and add the ones we care about. */
+	for (i = 0; i < socketlist_getsize(S); i++) {
+		if (socketlist_get(S, i)->reader)
+			FD_SET(i, &readfds);
+		if (socketlist_get(S, i)->writer)
+			FD_SET(i, &writefds);
+	}
+
+	/* We're about to call select! */
+	events_network_selectstats_select();
+
+	/* Select. */
+	while (select(socketlist_getsize(S), &readfds, &writefds,
+	    NULL, tv) == -1) {
+		/* EINTR is harmless. */
+		if (errno == EINTR)
+			continue;
+
+		/* Anything else is an error. */
+		warnp("select()");
+		goto err0;
+	}
+
+	/* If we have any events registered, start the clock again. */
+	if (nev > 0)
+		events_network_selectstats_startclock();
+
+	/* We should start scanning for events at the beginning. */
+	fdscanpos = 0;
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * events_network_get(void):
+ * Find a socket readiness event which was identified by a previous call to
+ * events_network_select, and return it as an eventrec structure; or return
+ * NULL if there are no such events available.  The caller is responsible for
+ * freeing the returned memory.
+ */
+struct eventrec *
+events_network_get(void)
+{
+	struct eventrec * r;
+	size_t nfds = socketlist_getsize(S);
+
+	/* We haven't found any events yet. */
+	r = NULL;
+
+	/* Scan through the fd sets looking for ready sockets. */
+	for (; fdscanpos < nfds; fdscanpos++) {
+		/* Are we ready for reading? */
+		if (FD_ISSET(fdscanpos, &readfds)) {
+			r = socketlist_get(S, fdscanpos)->reader;
+			socketlist_get(S, fdscanpos)->reader = NULL;
+			if (--nev == 0)
+				events_network_selectstats_stopclock();
+			FD_CLR(fdscanpos, &readfds);
+			break;
+		}
+
+		/* Are we ready for writing? */
+		if (FD_ISSET(fdscanpos, &writefds)) {
+			r = socketlist_get(S, fdscanpos)->writer;
+			socketlist_get(S, fdscanpos)->writer = NULL;
+			if (--nev == 0)
+				events_network_selectstats_stopclock();
+			FD_CLR(fdscanpos, &writefds);
+			break;
+		}
+	}
+
+	/* Return the event we found, or NULL if we didn't find any. */
+	return (r);
+}
+
+/**
+ * events_network_shutdown(void)
+ * Clean up and free memory.  This call is not necessary on program exit and
+ * is only expected to be useful when checking for memory leaks.
+ */
+void
+events_network_shutdown(void)
+{
+
+	/* If we're not initialized, do nothing. */
+	if (S == NULL)
+		return;
+
+	/* If we have any registered events, do nothing. */
+	if (nev > 0)
+		return;
+
+	/* Free the socket list. */
+	socketlist_free(S);
+	S = NULL;
+}