spiped 0.0.0

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

@@ -0,0 +1,167 @@
+#ifndef _ELASTICARRAY_H_
+#define _ELASTICARRAY_H_
+
+#include <stddef.h>
+
+/**
+ * Elastic Arrays are dynamically resizing arrays which remain within a
+ * factor of 4 of the optimal size for the data they contain and have (within
+ * a constant factor) amortized optimal running time providing that all of
+ * the allocated space is accessed at some point.  Functions return NULL or
+ * (int)(-1) on error and set errno; other return types indicate that failure
+ * is not possible.  On error, the array will be unmodified.
+ *
+ * The ELASTICARRAY_DECL(type, prefix, rectype) macro can be used to create a
+ * more friendly interface, at the expense of restricting the array to only
+ * holding a single data type.
+ */
+
+/* Opaque elastic array type. */
+struct elasticarray;
+
+/**
+ * elasticarray_init(nrec, reclen):
+ * Create and return an elastic array holding ${nrec} (uninitialized) records
+ * of length ${reclen}.  Takes O(nrec * reclen) time.
+ */
+struct elasticarray * elasticarray_init(size_t, size_t);
+
+/**
+ * elasticarray_resize(EA, nrec, reclen):
+ * Resize the elastic array pointed to by ${EA} to hold ${nrec} records of
+ * length ${reclen}.  If ${nrec} exceeds the number of records previously
+ * held by the array, the additional records will be uninitialized.  Takes
+ * O(nrec * reclen) time.
+ */
+int elasticarray_resize(struct elasticarray *, size_t, size_t);
+
+/**
+ * elasticarray_getsize(EA, reclen):
+ * Return the number of length-${reclen} records in the array, rounding down
+ * if there is a partial record (which can only occur if elasticarray_*
+ * functions have been called with different values of reclen).  The value
+ * ${reclen} must be positive.
+ */
+size_t elasticarray_getsize(struct elasticarray *, size_t);
+
+/**
+ * elasticarray_append(EA, buf, nrec, reclen):
+ * Append to the elastic array ${EA} the ${nrec} records of length ${reclen}
+ * stored in ${buf}.  Takes O(nrec * reclen) amortized time.
+ */
+int elasticarray_append(struct elasticarray *, const void *, size_t, size_t);
+
+/**
+ * elasticarray_shrink(EA, nrec, reclen):
+ * Delete the final ${nrec} records of length ${reclen} from the elastic
+ * array ${EA}.  If there are fewer than ${nrec} records, all records
+ * present will be deleted.
+ *
+ * As an exception to the normal rule, an elastic array may occupy more than
+ * 4 times the optimal storage immediately following an elasticarray_shrink
+ * call; but only if realloc(3) failed to shrink a memory allocation.
+ */
+void elasticarray_shrink(struct elasticarray *, size_t, size_t);
+
+/**
+ * elasticarray_truncate(EA):
+ * Release any spare space in the elastic array ${EA}.
+ */
+int elasticarray_truncate(struct elasticarray *);
+
+/**
+ * elasticarray_get(EA, pos, reclen):
+ * Return a pointer to record number ${pos} of length ${reclen} in the
+ * elastic array ${EA}.  Takes O(1) time.
+ */
+void * elasticarray_get(struct elasticarray *, size_t, size_t);
+
+/**
+ * elasticarray_free(EA):
+ * Free the elastic array ${EA}.  Takes O(1) time.
+ */
+void elasticarray_free(struct elasticarray *);
+
+/**
+ * elasticarray_export(EA, buf, nrec, reclen):
+ * Return the data in the elastic array ${EA} as a buffer ${buf} containing
+ * ${nrec} records of length ${reclen}.  Free the elastic array ${EA}.
+ */
+int elasticarray_export(struct elasticarray *, void **, size_t *, size_t);
+
+/**
+ * ELASTICARRAY_DECL(type, prefix, rectype):
+ * Declare the type ${type} and the following functions:
+ * ${type} ${prefix}_init(size_t nrec);
+ * int ${prefix}_resize(${type} EA, size_t nrec);
+ * size_t ${prefix}_getsize(${type} EA);
+ * int ${prefix}_append(${type} EA, const void * buf, size_t nrec);
+ * void ${prefix}_shrink(${type} EA, size_t nrec);
+ * int ${prefix}_truncate(${type} EA);
+ * ${rectype} * ${prefix}_get(${type} EA, size_t pos);
+ * void ${prefix}_free(${type} EA);
+ */
+#define ELASTICARRAY_DECL(type, prefix, rectype)			\
+	static inline struct prefix##_struct *				\
+	prefix##_init(size_t nrec)					\
+	{								\
+		struct elasticarray * EA;				\
+									\
+		EA = elasticarray_init(nrec, sizeof(rectype));		\
+		return ((struct prefix##_struct *)EA);			\
+	}								\
+	static inline int						\
+	prefix##_resize(struct prefix##_struct * EA, size_t nrec)	\
+	{								\
+		return (elasticarray_resize((struct elasticarray *)EA,	\
+		    nrec, sizeof(rectype)));				\
+	}								\
+	static inline size_t						\
+	prefix##_getsize(struct prefix##_struct * EA)			\
+	{								\
+		return (elasticarray_getsize((struct elasticarray *)EA,	\
+		    sizeof(rectype)));					\
+	}								\
+	static inline int						\
+	prefix##_append(struct prefix##_struct * EA,			\
+	    rectype const * buf, size_t nrec)				\
+	{								\
+		return (elasticarray_append((struct elasticarray *)EA,	\
+		    buf, nrec, sizeof(rectype)));			\
+	}								\
+	static inline void						\
+	prefix##_shrink(struct prefix##_struct * EA, size_t nrec)	\
+	{								\
+		elasticarray_shrink((struct elasticarray *)EA,		\
+		    nrec, sizeof(rectype));				\
+	}								\
+	static inline int						\
+	prefix##_truncate(struct prefix##_struct * EA)			\
+	{								\
+		return (elasticarray_truncate(				\
+		    (struct elasticarray *)EA));			\
+	}								\
+	static inline rectype *						\
+	prefix##_get(struct prefix##_struct * EA, size_t pos)		\
+	{								\
+		rectype * rec;						\
+									\
+		rec = elasticarray_get((struct elasticarray *)EA,	\
+		    pos, sizeof(rectype));				\
+		return (rec);						\
+	}								\
+	static inline void						\
+	prefix##_free(struct prefix##_struct * EA)			\
+	{								\
+		elasticarray_free((struct elasticarray *)EA);		\
+	}								\
+	static inline int						\
+	prefix##_export(struct prefix##_struct * EA, rectype ** buf,	\
+	    size_t * nrec)						\
+	{								\
+		return (elasticarray_export((struct elasticarray *)EA,	\
+		    (void **)buf, nrec, sizeof(rectype)));		\
+	}								\
+	typedef struct prefix##_struct * type
+
+#endif /* !_ELASTICARRAY_H_ */

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

@@ -0,0 +1,85 @@
+#ifndef _MPOOL_H_
+#define _MPOOL_H_
+
+#include <stdlib.h>
+
+/**
+ * Memory allocator cache.  Memory allocations can be returned to the pool
+ * and reused by a subsequent allocation without returning all the way to
+ * free/malloc.  In effect, this is an optimization for the case where we
+ * know we will want another allocation of the same size soon, at the expense
+ * of allowing the memory to be reused by some other code.
+ */
+
+/**
+ * MPOOL(name, type, size):
+ * Define the functions
+ *
+ * ${type} * mpool_${name}_malloc(void);
+ * void mpool_${name}_free(${type} *);
+ *
+ * which allocate and free structures of type ${type}.  Up to ${size}
+ * such structures are kept cached after _free is called in order to
+ * allow future _malloc calls to be rapidly serviced.
+ *
+ * Cached structures will be freed at program exit time in order to aid
+ * in the detection of memory leaks.
+ */
+#define MPOOL(name, type, size) 				\
+static struct mpool_##name##_struct {				\
+	size_t stacklen;					\
+	void * top;						\
+	int atexit_set;						\
+} mpool_##name##_rec = {0, NULL, 0};				\
+								\
+static void							\
+mpool_##name##_atexit(void)					\
+{								\
+	void * top;						\
+								\
+	while ((top = mpool_##name##_rec.top) != NULL) {	\
+		mpool_##name##_rec.top = *(void **)top;		\
+		free(top);					\
+	}							\
+}								\
+								\
+static inline type *						\
+mpool_##name##_malloc(void)					\
+{								\
+	type * p;						\
+								\
+	if (mpool_##name##_rec.stacklen) {			\
+		p = mpool_##name##_rec.top;			\
+		mpool_##name##_rec.top = *(void **)p;		\
+		mpool_##name##_rec.stacklen -= 1;		\
+	} else {						\
+		if (mpool_##name##_rec.atexit_set == 0) {	\
+			atexit(mpool_##name##_atexit);		\
+			mpool_##name##_rec.atexit_set = 1;	\
+		}						\
+		p = malloc((sizeof(type) > sizeof(void *)) ?	\
+		    sizeof(type) : sizeof(void *));		\
+	}							\
+								\
+	return (p);						\
+}								\
+								\
+static inline void						\
+mpool_##name##_free(type * p)					\
+{								\
+								\
+	if (p == NULL)						\
+		return;						\
+								\
+	if (mpool_##name##_rec.stacklen < size) {		\
+		*(void **)p = mpool_##name##_rec.top;		\
+		mpool_##name##_rec.top = p;			\
+		mpool_##name##_rec.stacklen += 1;		\
+	} else {						\
+		free(p);					\
+	}							\
+}								\
+								\
+struct mpool_##name##_dummy
+
+#endif /* !_MPOOL_H_ */

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

@@ -0,0 +1,334 @@
+#include <stdlib.h>
+
+#include "elasticarray.h"
+
+#include "ptrheap.h"
+
+ELASTICARRAY_DECL(PTRLIST, ptrlist, void *);
+
+struct ptrheap {
+	int (* compar)(void *, const void *, const void *);
+	void (* setreccookie)(void *, void *, size_t);
+	void * cookie;
+	PTRLIST elems;
+	size_t nelems;
+};
+
+/**
+ * swap(elems, i, j, setreccookie, cookie):
+ * Swap elements ${i} and ${j} in ${elems}.  If ${setreccookie} is non-NULL,
+ * invoke ${setreccookie}(${cookie}, elem, pos) for each of the elements and
+ * their new positions in the tree.
+ */
+static void
+swap(PTRLIST elems, size_t i, size_t j,
+    void (* setreccookie)(void *, void *, size_t), void * cookie)
+{
+	void * tmp;
+
+	/* Swap the elements. */
+	tmp = *ptrlist_get(elems, i);
+	*ptrlist_get(elems, i) = *ptrlist_get(elems, j);
+	*ptrlist_get(elems, j) = tmp;
+
+	/* Notify about the moved elements. */
+	if (setreccookie != NULL) {
+		setreccookie(cookie, *ptrlist_get(elems, i), i);
+		setreccookie(cookie, *ptrlist_get(elems, j), j);
+	}
+}
+
+/**
+ * heapifyup(elems, i, compar, setreccookie, cookie):
+ * Sift up element ${i} of the elements ${elems}, using the comparison
+ * function ${compar} and the cookie ${cookie}.  If elements move and
+ * ${setreccookie} is non-NULL, use it to notify about the updated position
+ * of elements in the heap.
+ */
+static void
+heapifyup(PTRLIST elems, size_t i,
+    int (* compar)(void *, const void *, const void *),
+    void (* setreccookie)(void *, void *, size_t), void * cookie)
+{
+
+	/* Iterate up the tree. */
+	do {
+		/* If we're at the root, we have nothing to do. */
+		if (i == 0)
+			break;
+
+		/* If this is >= its parent, we're done. */
+		if (compar(cookie, *ptrlist_get(elems, i),
+		    *ptrlist_get(elems, (i - 1) / 2)) >= 0)
+			break;
+
+		/* Swap with the parent. */
+		swap(elems, i, (i - 1) / 2, setreccookie, cookie);
+
+		/* Move up the tree. */
+		i = (i - 1) / 2;
+	} while (1);
+}
+
+/**
+ * heapify(elems, i, N, compar, setreccookie, cookie):
+ * Sift down element number ${i} out of ${N} of the elements ${elems}, using
+ * the comparison function ${compar} and the cookie ${cookie}.  If elements
+ * move and ${setreccookie} is non-NULL, use it to notify about the updated
+ * position of elements in the heap.
+ */
+static void
+heapify(PTRLIST elems, size_t i, size_t N,
+    int (* compar)(void *, const void *, const void *),
+    void (* setreccookie)(void *, void *, size_t), void * cookie)
+{
+	size_t min;
+
+	/* Iterate down the tree. */
+	do {
+		/* Look for the minimum element out of {i, 2i+1, 2i+2}. */
+		min = i;
+
+		/* Is this bigger than element 2i+1? */
+		if ((2 * i + 1 < N) &&
+		    (compar(cookie, *ptrlist_get(elems, min),
+			*ptrlist_get(elems, 2 * i + 1)) > 0))
+			min = 2 * i + 1;
+
+		/* Is this bigger than element 2i+2? */
+		if ((2 * i + 2 < N) &&
+		    (compar(cookie, *ptrlist_get(elems, min),
+			*ptrlist_get(elems, 2 * i + 2)) > 0))
+			min = 2 * i + 2;
+
+		/* If the minimum is i, we have heap-property. */
+		if (min == i)
+			break;
+
+		/* Move the minimum into position i. */
+		swap(elems, min, i, setreccookie, cookie);
+
+		/* Move down the tree. */
+		i = min;
+	} while (1);
+}
+
+/**
+ * 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 (* compar)(void *, const void *, const void *),
+    void (* setreccookie)(void *, void *, size_t), void * cookie)
+{
+
+	/* Let ptrheap_create handle this. */
+	return (ptrheap_create(compar, setreccookie, cookie, 0, NULL));
+}
+
+/**
+ * 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 (* compar)(void *, const void *, const void *),
+    void (* setreccookie)(void *, void *, size_t), void * cookie,
+    size_t N, void ** ptrs)
+{
+	struct ptrheap * H;
+	size_t i;
+
+	/* Allocate structure. */
+	if ((H = malloc(sizeof(struct ptrheap))) == NULL)
+		goto err0;
+
+	/* Store parameters. */
+	H->compar = compar;
+	H->setreccookie = setreccookie;
+	H->cookie = cookie;
+
+	/* We will have N elements. */
+	H->nelems = N;
+
+	/* Allocate space for N heap elements. */
+	if ((H->elems = ptrlist_init(N)) == NULL)
+		goto err1;
+
+	/* Copy the heap elements in. */
+	for (i = 0; i < N; i++)
+		*ptrlist_get(H->elems, i) = ptrs[i];
+
+	/* Turn this into a heap. */
+	for (i = N - 1; i < N; i--)
+		heapify(H->elems, i, N, H->compar, NULL, H->cookie);
+
+	/* Advise the caller about the record cookies. */
+	if (H->setreccookie != NULL)
+		for (i = 0; i < N; i++)
+			(H->setreccookie)(H->cookie,
+			    *ptrlist_get(H->elems, i), i);
+
+	/* Success! */
+	return (H);
+
+err1:
+	free(H);
+err0:
+	/* Failure! */
+	return (NULL);
+}
+
+/**
+ * ptrheap_add(H, ptr):
+ * Add the pointer ${ptr} to the heap ${H}.
+ */
+int
+ptrheap_add(struct ptrheap * H, void * ptr)
+{
+
+	/* Add the element to the end of the heap. */
+	if (ptrlist_append(H->elems, &ptr, 1))
+		goto err0;
+	H->nelems += 1;
+
+	/* Advise the caller about the current location of this record. */
+	if (H->setreccookie != NULL)
+		(H->setreccookie)(H->cookie, ptr, H->nelems - 1);
+
+	/* Move the new element up in the tree if necessary. */
+	heapifyup(H->elems, H->nelems - 1,
+	    H->compar, H->setreccookie, H->cookie);
+
+	/* Success! */
+	return (0);
+
+err0:
+	/* Failure! */
+	return (-1);
+}
+
+/**
+ * ptrheap_getmin(H):
+ * Return the minimum pointer in the heap ${H}.  If the heap is empty, NULL
+ * is returned.
+ */
+void *
+ptrheap_getmin(struct ptrheap * H)
+{
+
+	/* If we have any elements, the minimum is in position 0. */
+	if (H->nelems)
+		return (*ptrlist_get(H->elems, 0));
+	else
+		return (NULL);
+}
+
+/**
+ * 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 * H, size_t rc)
+{
+
+	/*
+	 * If the element we're deleting is not at the end of the heap,
+	 * replace it with the element which is currently at the end.
+	 */
+	if (rc != H->nelems - 1) {
+		/* Move ptr from position H->nelems - 1 into position rc. */
+		*ptrlist_get(H->elems, rc) =
+		    *ptrlist_get(H->elems, H->nelems - 1);
+		if (H->setreccookie != NULL)
+			(H->setreccookie)(H->cookie,
+			    *ptrlist_get(H->elems, rc), rc);
+
+		/* Is this too small to be in position ${rc}? */
+		if ((rc > 0) &&
+		    (H->compar(H->cookie, *ptrlist_get(H->elems, rc),
+			*ptrlist_get(H->elems, (rc - 1) / 2)) < 0)) {
+			/* Swap with the parent, and keep moving up. */
+			swap(H->elems, rc, (rc - 1) / 2,
+			    H->setreccookie, H->cookie);
+			heapifyup(H->elems, (rc - 1) / 2,
+			    H->compar, H->setreccookie, H->cookie);
+		} else {
+			/* Maybe we need to move it down instead? */
+			heapify(H->elems, rc, H->nelems,
+			    H->compar, H->setreccookie, H->cookie);
+		}
+	}
+
+	/*
+	 * We've got everything we want to keep in positions 0 .. nelems - 2,
+	 * and we have heap-nature, so all we need to do is strip off the
+	 * final pointer.
+	 */
+	ptrlist_shrink(H->elems, 1);
+	H->nelems--;
+}
+
+/**
+ * ptrheap_deletemin(H):
+ * Delete the minimum element in the heap ${H}.
+ */
+void
+ptrheap_deletemin(struct ptrheap * H)
+{
+
+	/* Let ptrheap_delete handle this. */
+	ptrheap_delete(H, 0);
+}
+
+/**
+ * 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 incrased.
+ */
+void
+ptrheap_increase(struct ptrheap * H, size_t rc)
+{
+
+	/* Move the element down if necessary. */
+	heapify(H->elems, rc, H->nelems,
+	    H->compar, H->setreccookie, H->cookie);
+}
+
+/**
+ * ptrheap_increasemin(H):
+ * Adjust the heap ${H} to account for the fact that the (formerly) minimum
+ * element has increased.
+ */
+void
+ptrheap_increasemin(struct ptrheap * H)
+{
+
+	/* Move the element down if necessary. */
+	heapify(H->elems, 0, H->nelems,
+	    H->compar, H->setreccookie, H->cookie);
+}
+
+/**
+ * ptrheap_free(H):
+ * Free the pointer heap ${H}.
+ */
+void
+ptrheap_free(struct ptrheap * H)
+{
+
+	/* Be compatible with free(NULL). */
+	if (H == NULL)
+		return;
+
+	ptrlist_free(H->elems);
+	free(H);
+}