spiped 0.0.0

data/ext/spiped/spiped-source/libcperciva/datastruct/ptrheap.h

@@ -0,0 +1,89 @@
+#ifndef _PTRHEAP_H_
+#define _PTRHEAP_H_
+
+#include <stddef.h>
+
+/**
+ * Pointer-heap data structure.  Arbitrary pointers can be inserted and are
+ * compared using a provided callback; the usual heapy getmin / increasemin /
+ * deletemin algorithms are supported.  To use two additional functions,
+ * ptrheap_delete and ptrheap_increase, a setreccookie callback needs to be
+ * provided.  Both functions require a record cookie to identify the element
+ * to increase or delete; each time a record's record cookie changes, the
+ * setreccookie callback will be called.  Functions return NULL or (int)(-1)
+ * on error and set errno; other return types indicate that failure is not
+ * possible.  On error, the heap will be unmodified.
+ */
+
+/* Opaque pointer-heap type. */
+struct ptrheap;
+
+/**
+ * ptrheap_init(compar, setreccookie, cookie):
+ * Create and return an empty heap.  The function ${compar}(${cookie}, x, y)
+ * should return less than, equal to, or greater than 0 depending on whether
+ * x is less than, equal to, or greater than y; and if ${setreccookie} is
+ * non-zero it will be called as ${setreccookie}(${cookie}, ${ptr}, ${rc}) to
+ * indicate that the value ${rc} is the current record cookie for the pointer
+ * ${ptr}.  The function ${setreccookie} may not make any ptrheap_* calls.
+ */
+struct ptrheap * ptrheap_init(int (*)(void *, const void *, const void *),
+    void (*)(void *, void *, size_t), void *);
+
+/**
+ * ptrheap_create(compar, setreccookie, cookie, N, ptrs):
+ * Create and return a heap, as in ptrheap_init, but with the ${N} pointers
+ * in ${ptrs} as heap elements.  This is faster than creating an empty heap
+ * and adding the elements individually.
+ */
+struct ptrheap * ptrheap_create(int (*)(void *, const void *, const void *),
+    void (*)(void *, void *, size_t), void *, size_t, void **);
+
+/**
+ * ptrheap_add(H, ptr):
+ * Add the pointer ${ptr} to the heap ${H}.
+ */
+int ptrheap_add(struct ptrheap *, void *);
+
+/**
+ * ptrheap_getmin(H):
+ * Return the minimum pointer in the heap ${H}.  If the heap is empty, NULL
+ * is returned.
+ */
+void * ptrheap_getmin(struct ptrheap *);
+
+/**
+ * ptrheap_delete(H, rc):
+ * Delete from the heap ${H} the element ptr for which the function call
+ * setreccookie(cookie, ptr, ${rc}) was most recently made.
+ */
+void ptrheap_delete(struct ptrheap *, size_t);
+
+/**
+ * ptrheap_deletemin(H):
+ * Delete the minimum element in the heap ${H}.  The heap must not be empty.
+ */
+void ptrheap_deletemin(struct ptrheap *);
+
+/**
+ * ptrheap_increase(H, rc):
+ * Adjust the heap ${H} to account for the fact that the element ptr for
+ * which the function call setreccookie(cookie, ptr, ${rc}) was most recently
+ * made has increased.
+ */
+void ptrheap_increase(struct ptrheap *, size_t);
+
+/**
+ * ptrheap_increasemin(H):
+ * Adjust the heap ${H} to account for the fact that the (formerly) minimum
+ * element has increased.
+ */
+void ptrheap_increasemin(struct ptrheap *);
+
+/**
+ * ptrheap_free(H):
+ * Free the pointer heap ${H}.
+ */
+void ptrheap_free(struct ptrheap *);
+
+#endif /* !_PTRHEAP_H_ */

data/ext/spiped/spiped-source/libcperciva/datastruct/timerqueue.c

@@ -0,0 +1,241 @@
+#include <sys/time.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "ptrheap.h"
+
+#include "timerqueue.h"
+
+struct timerqueue {
+	struct ptrheap * H;
+};
+
+struct timerrec {
+	struct timeval tv;
+	size_t rc;
+	void * ptr;
+};
+
+/* Compare two timevals. */
+static int
+tvcmp(const struct timeval * x, const struct timeval * y)
+{
+
+	/* Does one have more seconds? */
+	if (x->tv_sec > y->tv_sec)
+		return (1);
+	if (x->tv_sec < y->tv_sec)
+		return (-1);
+
+	/* Does one have more microseconds? */
+	if (x->tv_usec > y->tv_usec)
+		return (1);
+	if (x->tv_usec < y->tv_usec)
+		return (-1);
+
+	/* They must be equal. */
+	return (0);
+}
+
+/* Record-comparison callback from ptrheap. */
+static int
+compar(void * cookie, const void * x, const void * y)
+{
+	const struct timerrec * _x = x;
+	const struct timerrec * _y = y;
+
+	(void)cookie; /* UNUSED */
+
+	return (tvcmp(&_x->tv, &_y->tv));
+}
+
+/* Cookie-recording callback from ptrheap. */
+static void
+setreccookie(void * cookie, void * ptr, size_t rc)
+{
+	struct timerrec * rec = ptr;
+
+	(void)cookie; /* UNUSED */
+
+	rec->rc = rc;
+}
+
+/**
+ * timerqueue_init(void):
+ * Create and return an empty timer priority queue.
+ */
+struct timerqueue *
+timerqueue_init(void)
+{
+	struct timerqueue * Q;
+
+	/* Allocate structure. */
+	if ((Q = malloc(sizeof(struct timerqueue))) == NULL)
+		goto err0;
+
+	/* Allocate heap. */
+	if ((Q->H = ptrheap_init(compar, setreccookie, Q)) == NULL)
+		goto err1;
+
+	/* Success! */
+	return (Q);
+
+err1:
+	free(Q);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * timerqueue_add(Q, tv, ptr):
+ * Add the pair (${tv}, ${ptr}) to the priority queue ${Q}.  Returns a cookie
+ * which can be passed to timerqueue_delete or timerqueue_increase.
+ */
+void *
+timerqueue_add(struct timerqueue * Q, const struct timeval * tv, void * ptr)
+{
+	struct timerrec * r;
+
+	/* Allocate (timeval, ptr) pair record. */
+	if ((r = malloc(sizeof(struct timerrec))) == NULL)
+		goto err0;
+
+	/* Fill in values. */
+	memcpy(&r->tv, tv, sizeof(struct timeval));
+	r->ptr = ptr;
+
+	/*
+	 * Add the record to the heap.  The value r->rc will be filled in
+	 * by setreccookie which will be called by ptrheap_add.
+	 */
+	if (ptrheap_add(Q->H, r))
+		goto err1;
+
+	/* Success! */
+	return (r);
+
+err1:
+	free(r);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * timerqueue_delete(Q, cookie):
+ * Delete the (timeval, ptr) pair associated with the cookie ${cookie} from
+ * the priority queue ${Q}.
+ */
+void
+timerqueue_delete(struct timerqueue * Q, void * cookie)
+{
+	struct timerrec * r = cookie;
+
+	/* Remove the record from the heap. */
+	ptrheap_delete(Q->H, r->rc);
+
+	/* Free the record. */
+	free(r);
+}
+
+/**
+ * timerqueue_increase(Q, cookie, tv):
+ * Increase the timer associated with the cookie ${cookie} in the priority
+ * queue ${Q} to ${tv}.
+ */
+void
+timerqueue_increase(struct timerqueue * Q, void * cookie,
+    const struct timeval * tv)
+{
+	struct timerrec * r = cookie;
+
+	/* Adjust timer value. */
+	memcpy(&r->tv, tv, sizeof(struct timeval));
+
+	/* Inform the heap that the record value has increased. */
+	ptrheap_increase(Q->H, r->rc);
+}
+
+/**
+ * timerqueue_getmin(Q):
+ * Return a pointer to the least timeval in ${Q}, or NULL if the priority
+ * queue is empty.  The pointer will remain valid until the next call to a
+ * timerqueue_* function.  This function cannot fail.
+ */
+const struct timeval *
+timerqueue_getmin(struct timerqueue * Q)
+{
+	struct timerrec * r;
+
+	/* Get the minimum element from the heap. */
+	r = ptrheap_getmin(Q->H);
+
+	/* If we have an element, return its timeval; otherwise, NULL. */
+	if (r != NULL)
+		return (&r->tv);
+	else
+		return (NULL);
+}
+
+/**
+ * timerqueue_getptr(Q, tv):
+ * If the least timeval in ${Q} is less than or equal to ${tv}, return the
+ * associated pointer and remove the pair from the priority queue.  If not,
+ * return NULL.
+ */
+void *
+timerqueue_getptr(struct timerqueue * Q, const struct timeval * tv)
+{
+	struct timerrec * r;
+	void * ptr;
+
+	/*
+	 * Get the minimum element from the heap.  Return NULL if the heap
+	 * has no minimum element (i.e., is empty).
+	 */
+	if ((r = ptrheap_getmin(Q->H)) == NULL)
+		return (NULL);
+
+	/* If the minimum timeval is greater than ${tv}, return NULL. */
+	if (tvcmp(&r->tv, tv) > 0)
+		return (NULL);
+
+	/* Remove this record from the heap. */
+	ptrheap_deletemin(Q->H);
+
+	/* Extract its pointer. */
+	ptr = r->ptr;
+
+	/* Free the record. */
+	free(r);
+
+	/*
+	 * And finally return the pointer which was associated with the
+	 * (formerly) minimum timeval in the heap.
+	 */
+	return (ptr);
+}
+
+/**
+ * timerqueue_free(Q):
+ * Free the timer priority queue ${Q}.
+ */
+void
+timerqueue_free(struct timerqueue * Q)
+{
+	struct timerrec * r;
+
+	/* Extract elements from the heap and free them one by one. */
+	while ((r = ptrheap_getmin(Q->H)) != NULL) {
+		free(r);
+		ptrheap_deletemin(Q->H);
+	}
+
+	/* Free the heap. */
+	ptrheap_free(Q->H);
+
+	/* Free the timer priority queue structure. */
+	free(Q);
+}

data/ext/spiped/spiped-source/libcperciva/datastruct/timerqueue.h

@@ -0,0 +1,60 @@
+#ifndef _TIMERQUEUE_H_
+#define _TIMERQUEUE_H_
+
+#include <sys/time.h>
+
+/* Timer priority queue.  Contains (timeval, ptr) pairs. */
+
+/* Opaque timer priority queue type. */
+struct timerqueue;
+
+/**
+ * timerqueue_init(void):
+ * Create and return an empty timer priority queue.
+ */
+struct timerqueue * timerqueue_init(void);
+
+/**
+ * timerqueue_add(Q, tv, ptr):
+ * Add the pair (${tv}, ${ptr}) to the priority queue ${Q}.  Returns a cookie
+ * which can be passed to timerqueue_delete or timerqueue_increase.
+ */
+void * timerqueue_add(struct timerqueue *, const struct timeval *, void *);
+
+/**
+ * timerqueue_delete(Q, cookie):
+ * Delete the (timeval, ptr) pair associated with the cookie ${cookie} from
+ * the priority queue ${Q}.
+ */
+void timerqueue_delete(struct timerqueue *, void *);
+
+/**
+ * timerqueue_increase(Q, cookie, tv):
+ * Increase the timer associated with the cookie ${cookie} in the priority
+ * queue ${Q} to ${tv}.
+ */
+void timerqueue_increase(struct timerqueue *, void *, const struct timeval *);
+
+/**
+ * timerqueue_getmin(Q):
+ * Return a pointer to the least timeval in ${Q}, or NULL if the priority
+ * queue is empty.  The pointer will remain valid until the next call to a
+ * timerqueue_* function.  This function cannot fail.
+ */
+const struct timeval * timerqueue_getmin(struct timerqueue *);
+
+/**
+ * timerqueue_getptr(Q, tv):
+ * If the least timeval in ${Q} is less than or equal to ${tv}, return the
+ * associated pointer and remove the pair from the priority queue.  If not,
+ * return NULL.  This function cannot fail.
+ */
+void * timerqueue_getptr(struct timerqueue *, const struct timeval *);
+
+/**
+ * timerqueue_free(Q):
+ * Free the timer priority queue ${Q}.
+ */
+void timerqueue_free(struct timerqueue *);
+
+#endif /* !_TIMERQUEUE_H_ */

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

@@ -0,0 +1,203 @@
+#include <sys/time.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "mpool.h"
+
+#include "events_internal.h"
+#include "events.h"
+
+/* Event structure. */
+struct eventrec {
+	int (*func)(void *);
+	void * cookie;
+};
+
+MPOOL(eventrec, struct eventrec, 4096);
+
+/* Zero timeval, for use with non-blocking event runs. */
+static const struct timeval tv_zero = {0, 0};
+
+/**
+ * events_mkrec(func, cookie):
+ * Package ${func}, ${cookie} into a struct eventrec.
+ */
+struct eventrec *
+events_mkrec(int (*func)(void *), void * cookie)
+{
+	struct eventrec * r;
+
+	/* Allocate structure. */
+	if ((r = mpool_eventrec_malloc()) == NULL)
+		goto err0;
+
+	/* Initialize. */
+	r->func = func;
+	r->cookie = cookie;
+
+	/* Success! */
+	return (r);
+
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * events_freerec(r):
+ * Free the eventrec ${r}.
+ */
+void
+events_freerec(struct eventrec * r)
+{
+
+	mpool_eventrec_free(r);
+}
+
+/* Do an event.  This makes events_run cleaner. */
+static inline int
+doevent(struct eventrec * r)
+{
+	int rc;
+
+	/* Invoke the callback. */
+	rc = (r->func)(r->cookie);
+
+	/* Free the event record. */
+	mpool_eventrec_free(r);
+
+	/* Return the status code from the callback. */
+	return (rc);
+}
+
+/**
+ * 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)
+{
+	struct eventrec * r;
+	struct timeval * tv;
+	struct timeval tv2;
+	int rc = 0;
+
+	/* If we have any immediate events, process them and return. */
+	if ((r = events_immediate_get()) != NULL) {
+		while (r != NULL) {
+			/* Process the event. */
+			if ((rc = doevent(r)) != 0)
+				goto done;
+
+			/* Get the next event. */
+			r = events_immediate_get();
+		}
+
+		/* We've processed at least one event; time to return. */
+		goto done;
+	}
+
+	/*
+	 * Figure out the maximum duration to block, and wait up to that
+	 * duration for network events to become available.
+	 */
+	if (events_timer_min(&tv))
+		goto err0;
+	if (events_network_select(tv))
+		goto err1;
+	free(tv);
+
+	/*
+	 * Check for available immediate events, network events, and timer
+	 * events, in that order of priority; exit only when no more events
+	 * are available.
+	 */
+	do {
+		/* Run an immediate event, if one is available. */
+		if ((r = events_immediate_get()) != NULL) {
+			if ((rc = doevent(r)) != 0)
+				goto done;
+			continue;
+		}
+
+		/* Run a network event, if one is available. */
+		if ((r = events_network_get()) != NULL) {
+			if ((rc = doevent(r)) != 0)
+				goto done;
+			continue;
+		}
+
+		/* Check if any new network events are available. */
+		memcpy(&tv2, &tv_zero, sizeof(struct timeval));
+		if (events_network_select(&tv2))
+			goto err0;
+		if ((r = events_network_get()) != NULL) {
+			if ((rc = doevent(r)) != 0)
+				goto done;
+			continue;
+		}
+
+		/* Run a timer event, if one is available. */
+		if (events_timer_get(&r))
+			goto err0;
+		if (r != NULL) {
+			if ((rc = doevent(r)) != 0)
+				goto done;
+			continue;
+		}
+
+		/* No events available. */
+		break;
+	} while (1);
+
+done:
+	/* Success! */
+	return (rc);
+
+err1:
+	free(tv);
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * 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 * done)
+{
+	int rc = 0;
+
+	/* Loop until we're done or have a non-zero status. */
+	while ((done[0] == 0) && (rc == 0)) {
+		/* Run events. */
+		rc = events_run();
+	}
+
+	/* Return status code. */
+	return (rc);
+}
+
+/**
+ * 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)
+{
+
+	events_network_shutdown();
+	events_timer_shutdown();
+}