minibwa 0.0.0

data/ext/minibwa/minibwa/index.c

@@ -0,0 +1,342 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include "libsais.h"
+#include "libsais64.h"
+#include "kommon.h"
+#include "ketopt.h"
+#include "mbpriv.h"
+
+void mb_bwtgen(const char *fn_pac, const char *fn_bwt, int block_size);
+
+static ko_longopt_t long_opts[] = { // common long options shared across all index-related functions
+	{ "help", ko_no_argument, 901 },
+	{ "meth", ko_no_argument, 902 },
+	{ 0, 0, 0 }
+};
+
+static inline uint8_t l2b_c2t(uint8_t b) { return b == 1? 3 : b; } // C(1) -> T(3)
+static inline uint8_t l2b_g2a(uint8_t b) { return b == 2? 0 : b; } // G(2) -> A(0)
+
+// invert the suffix array a[] (32- or 64-bit) to the BWT in seq[], sample the SSA and drop the primary ($); return the primary
+static int64_t sa_to_bwt(void *a, int use_int32, uint8_t *seq, int64_t len, int sa_bit, uint64_t *ssa)
+{
+	int32_t *a32 = a;
+	int64_t *a64 = a, i, primary = -1;
+	uint64_t mask = (1ULL<<sa_bit) - 1;
+	for (i = 0; i <= len; ++i) {
+		int64_t v = use_int32? a32[i] : a64[i];
+		if ((i & mask) == 0) ssa[i>>sa_bit] = v;
+		if (v == 0) primary = i;
+		else if (use_int32) a32[i] = seq[v - 1];
+		else a64[i] = seq[v - 1];
+	}
+	ssa[0] = (uint64_t)-1;
+	for (i = 0; i < primary; ++i) seq[i] = use_int32? a32[i] : a64[i];
+	for (; i < len; ++i) seq[i] = use_int32? a32[i+1] : a64[i+1];
+	return primary;
+}
+
+static mb_bwt_t *mb_bwt_libsais(const l2b_t *l2b, int sa_bit, int both_strand, int is_meth, int n_thread)
+{
+	const int fs = 10000;
+	uint8_t *seq;
+	int64_t i, j, primary, len;
+	mb_bwt_t *bwt;
+	uint64_t *ssa, n_ssa;
+	void *a;
+	int use_int32;
+
+	len = l2b->tot_len * (is_meth? 2 : 1) * (both_strand? 2 : 1);
+	// use a 32-bit suffix array (half the memory) when the concatenated length fits in int32_t
+	use_int32 = (len + fs + 1 <= INT32_MAX);
+	seq = kom_malloc(uint8_t, len);
+	if (use_int32) a = kom_malloc(int32_t, len + fs + 1);
+	else a = kom_malloc(int64_t, len + fs + 1);
+	if (is_meth) {
+		// c2t forward
+		for (i = 0, j = 0; i < l2b->tot_len; ++i, ++j)
+			seq[j] = l2b_c2t(l2b_get0(l2b, i));
+		// g2a forward
+		for (i = 0; i < l2b->tot_len; ++i, ++j)
+			seq[j] = l2b_g2a(l2b_get0(l2b, i));
+		if (both_strand) {
+			// g2a reverse (reverse complement of g2a converted)
+			for (i = l2b->tot_len - 1; i >= 0; --i, ++j)
+				seq[j] = 3 - l2b_g2a(l2b_get0(l2b, i));
+			// c2t reverse (reverse complement of c2t converted)
+			for (i = l2b->tot_len - 1; i >= 0; --i, ++j)
+				seq[j] = 3 - l2b_c2t(l2b_get0(l2b, i));
+		}
+	} else {
+		for (i = 0, j = 0; i < l2b->tot_len; ++i, ++j)
+			seq[j] = l2b_get0(l2b, i);
+		if (both_strand)
+			for (i = l2b->tot_len - 1; i >= 0; --i, ++j)
+				seq[j] = 3 - l2b_get0(l2b, i);
+	}
+	if (use_int32) {
+		int32_t *a32 = a;
+#ifdef LIBSAIS_OPENMP
+		libsais_omp(seq, a32 + 1, (int32_t)len, fs, 0, n_thread);
+#else
+		libsais(seq, a32 + 1, (int32_t)len, fs, 0);
+#endif
+		a32[0] = (int32_t)len; // libsais doesn't write a[0], which always equals to len
+	} else {
+		int64_t *a64 = a;
+#ifdef LIBSAIS_OPENMP
+		libsais64_omp(seq, a64 + 1, len, fs, 0, n_thread);
+#else
+		libsais64(seq, a64 + 1, len, fs, 0);
+#endif
+		a64[0] = len;
+	}
+
+	n_ssa = (len + (1<<sa_bit)) >> sa_bit;
+	ssa = kom_calloc(uint64_t, n_ssa);
+	primary = sa_to_bwt(a, use_int32, seq, len, sa_bit, ssa);
+	assert(primary != -1);
+	free(a);
+	bwt = mb_bwt_init_from_raw(1, seq, len, primary);
+	bwt->sa_bit = sa_bit, bwt->n_sa = n_ssa, bwt->sa = ssa;
+	free(seq);
+	return bwt;
+}
+
+static int usage_fa2bit(FILE *fp, uint64_t seed)
+{
+	fprintf(fp, "Usage: minibwa fa2bit [options] <in.fa> <out.l2b>\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  -s INT    random seed [%lu]\n", (unsigned long)seed);
+	fprintf(fp, "  -p        output the BWA pac format\n");
+	fprintf(fp, "  -2        output both strands (effective with -p)\n");
+	fprintf(fp, "  --help    print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+
+int main_fa2bit(int argc, char *argv[])
+{
+	l2b_t *l2b;
+	int out_pac = 0, both_strand = 0;
+	uint64_t seed = 11;
+	ketopt_t o = KETOPT_INIT;
+	int c;
+	while ((c = ketopt(&o, argc, argv, 1, "s:p2", long_opts)) >= 0) {
+		if (c == 's') seed = atol(o.arg);
+		else if (c == 'p') out_pac = 1;
+		else if (c == '2') both_strand = 1;
+		else if (c == 901) return usage_fa2bit(stdout, seed);
+	}
+	if (argc - o.ind < 2) return usage_fa2bit(stderr, seed);
+	l2b = l2b_import(argv[o.ind], seed);
+	if (out_pac)
+		l2b_save_pac(argv[o.ind+1], l2b, both_strand);
+	else
+		l2b_save(argv[o.ind+1], l2b);
+	l2b_destroy(l2b);
+	return 0;
+}
+
+#ifdef USE_GPL
+static int usage_genraw(FILE *fp)
+{
+	fprintf(fp, "Usage: minibwa genraw [options] <in.pac> <out.raw-bwt>\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  -b NUM      block size [10m]\n");
+	fprintf(fp, "  --help      print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+#endif
+
+int main_genraw(int argc, char *argv[])
+{
+#ifdef USE_GPL
+	ketopt_t o = KETOPT_INIT;
+	int c, block_size = 10000000;
+	while ((c = ketopt(&o, argc, argv, 1, "b:", long_opts)) >= 0) {
+		if (c == 'b') block_size = kom_parse_num(o.arg, 0);
+		else if (c == 901) return usage_genraw(stdout);
+	}
+	if (argc - o.ind < 2) return usage_genraw(stderr);
+	mb_bwtgen(argv[o.ind], argv[o.ind+1], block_size);
+	return 0;
+#else
+	(void)argc; (void)argv;
+	if (kom_verbose >= 1) fprintf(stderr, "ERROR: genraw not compiled as it depends on GPL'd code\n");
+	return 1;
+#endif
+}
+
+static int usage_raw2bwt(FILE *fp)
+{
+	fprintf(fp, "Usage: minibwa raw2bwt <raw.bwt> <recode.bwt>\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  --help    print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+
+int main_raw2bwt(int argc, char *argv[])
+{
+	mb_bwt_t *bwt;
+	int i;
+	for (i = 1; i < argc; ++i)
+		if (strcmp(argv[i], "--help") == 0) return usage_raw2bwt(stdout);
+	if (argc < 3) return usage_raw2bwt(stderr);
+	bwt = mb_bwt_load_raw(argv[1]);
+	mb_bwt_save(argv[2], bwt);
+	mb_bwt_destroy(bwt);
+	return 0;
+}
+
+static int usage_genbwt(FILE *fp, int sa_bit, int n_thread)
+{
+	(void)n_thread;
+	fprintf(fp, "Usage: minibwa genbwt [options] <in.l2b> <out.bwt>\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  -u INT      SA sample rate at 1/(1<<INT) [%d]\n", sa_bit);
+	fprintf(fp, "  -1          forward strand only\n");
+#ifdef LIBSAIS_OPENMP
+	fprintf(fp, "  -t INT      number of threads [%d]\n", n_thread);
+#endif
+	fprintf(fp, "  --help      print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+
+int main_genbwt(int argc, char *argv[])
+{
+	ketopt_t o = KETOPT_INIT;
+	int c, n_thread = 4, both_strand = 1, sa_bit = 4;
+	mb_bwt_t *bwt;
+	l2b_t *l2b;
+	while ((c = ketopt(&o, argc, argv, 1, "1u:t:", long_opts)) >= 0) {
+		if (c == 't') n_thread = atoi(o.arg);
+		else if (c == '1') both_strand = 0;
+		else if (c == 'u') sa_bit = atoi(o.arg);
+		else if (c == 901) return usage_genbwt(stdout, sa_bit, n_thread);
+	}
+	if (argc - o.ind < 2) return usage_genbwt(stderr, sa_bit, n_thread);
+	l2b = l2b_load(argv[o.ind]);
+	kom_assert(l2b, "failed to open the input file.");
+	bwt = mb_bwt_libsais(l2b, sa_bit, both_strand, 0, n_thread);
+	l2b_destroy(l2b);
+	mb_bwt_save(argv[o.ind+1], bwt);
+	mb_bwt_destroy(bwt);
+	return 0;
+}
+
+static int usage_gensa(FILE *fp, int sa_bit)
+{
+	fprintf(fp, "Usage: minibwa gensa [options] <in.bwt> <out.bwt>\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  -u INT    sample rate at 1/(1<<INT) [%d]\n", sa_bit);
+	fprintf(fp, "  -r        input BWT in the raw BWA format\n");
+	fprintf(fp, "  --help    print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+
+int main_gensa(int argc, char *argv[])
+{
+	mb_bwt_t *bwt;
+	int c, sa_bit = 4, is_raw = 0;
+	ketopt_t o = KETOPT_INIT;
+	while ((c = ketopt(&o, argc, argv, 1, "ru:", long_opts)) >= 0) {
+		if (c == 'u') sa_bit = atoi(o.arg);
+		else if (c == 'r') is_raw = 1;
+		else if (c == 901) return usage_gensa(stdout, sa_bit);
+	}
+	if (argc - o.ind < 2) return usage_gensa(stderr, sa_bit);
+	bwt = is_raw? mb_bwt_load_raw(argv[o.ind]) : mb_bwt_load(argv[o.ind]);
+	mb_bwt_gen_sa(bwt, sa_bit);
+	mb_bwt_save(argv[o.ind+1], bwt);
+	mb_bwt_destroy(bwt);
+	return 0;
+}
+
+static int usage_index(FILE *fp, uint64_t seed, int sa_bit, int n_thread)
+{
+	(void)n_thread;
+	fprintf(fp, "Usage: minibwa index [options] <in.fasta> [out.prefix]\n");
+	fprintf(fp, "Options:\n");
+	fprintf(fp, "  -s INT    random seed for amibiguous bases [%ld]\n", (unsigned long)seed);
+	fprintf(fp, "  -u INT    SA sample rate at 1/(1<<INT) [%d]\n", sa_bit);
+	fprintf(fp, "  -l        low-memory GPL'd algorithm for BWT construction\n");
+	fprintf(fp, "  -b NUM    block size (effective with -l) [10m]\n");
+#ifdef LIBSAIS_OPENMP
+	fprintf(fp, "  -t INT    number of threads (effective w/o -l) [%d]\n", n_thread);
+#endif
+	fprintf(fp, "  --meth    build FM-index for BS-seq mapping\n");
+	fprintf(fp, "  --help    print this help message\n");
+	return fp == stdout? 0 : 1;
+}
+
+int main_index(int argc, char *argv[])
+{
+	ketopt_t o = KETOPT_INIT;
+	int c, low_mem = 0, n_thread = 4, sa_bit = 4, is_meth = 0;
+	int64_t block_size = 10000000;
+	uint64_t seed = 11;
+	char *prefix, *fn_l2b, *fn_bwt, *fn_meth_bwt = 0;
+	l2b_t *l2b;
+	mb_bwt_t *bwt;
+
+	while ((c = ketopt(&o, argc, argv, 1, "ls:u:b:t:", long_opts)) >= 0) {
+		if (c == 't') n_thread = atoi(o.arg);
+		else if (c == 'l') low_mem = 1;
+		else if (c == 'b') block_size = kom_parse_num(o.arg, 0);
+		else if (c == 'u') sa_bit = atoi(o.arg);
+		else if (c == 's') seed = atol(o.arg);
+		else if (c == 901) return usage_index(stdout, seed, sa_bit, n_thread);
+		else if (c == 902) is_meth = 1;
+	}
+	if (argc - o.ind == 0) return usage_index(stderr, seed, sa_bit, n_thread);
+
+	prefix = o.ind + 1 < argc? argv[o.ind+1] : argv[o.ind];
+	fn_l2b = kom_calloc(char, strlen(prefix) + 10);
+	strcat(strcpy(fn_l2b, prefix), ".l2b");
+	fn_bwt = kom_calloc(char, strlen(prefix) + 10);
+	strcat(strcpy(fn_bwt, prefix), ".mbw");
+	if (is_meth) {
+		fn_meth_bwt = kom_calloc(char, strlen(prefix) + 10);
+		strcat(strcpy(fn_meth_bwt, prefix), ".meth.mbw");
+	}
+
+	l2b = l2b_import(argv[o.ind], seed);
+	kom_assert(l2b, "failed to read the genome FASTA.");
+	if (low_mem) {
+#ifdef USE_GPL
+		l2b_save_pac(fn_l2b, l2b, 1);
+		mb_bwtgen(fn_l2b, fn_bwt, block_size);
+		l2b_save(fn_l2b, l2b);
+		bwt = mb_bwt_load_raw(fn_bwt);
+		mb_bwt_gen_sa(bwt, sa_bit);
+		mb_bwt_save(fn_bwt, bwt);
+		mb_bwt_destroy(bwt);
+		if (is_meth) {
+			l2b_save_pac_meth(fn_l2b, l2b, 1);
+			mb_bwtgen(fn_l2b, fn_meth_bwt, block_size);
+			l2b_save(fn_l2b, l2b); // restore the real .l2b; the meth pac above overwrote it (cf. the regular pass)
+			bwt = mb_bwt_load_raw(fn_meth_bwt);
+			mb_bwt_gen_sa(bwt, sa_bit);
+			mb_bwt_save(fn_meth_bwt, bwt);
+			mb_bwt_destroy(bwt);
+		}
+#else
+		if (kom_verbose >= 1) fprintf(stderr, "ERROR: option -l not compiled as it depends on GPL'd code\n");
+		abort();
+#endif
+	} else {
+		l2b_save(fn_l2b, l2b);
+		bwt = mb_bwt_libsais(l2b, sa_bit, 1, 0, n_thread);
+		mb_bwt_save(fn_bwt, bwt);
+		mb_bwt_destroy(bwt);
+		if (is_meth) {
+			bwt = mb_bwt_libsais(l2b, sa_bit, 1, 1, n_thread);
+			mb_bwt_save(fn_meth_bwt, bwt);
+			mb_bwt_destroy(bwt);
+		}
+	}
+	l2b_destroy(l2b);
+	free(fn_meth_bwt); free(fn_bwt); free(fn_l2b);
+	return 0;
+}

data/ext/minibwa/minibwa/kalloc.c

@@ -0,0 +1,224 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "kalloc.h"
+
+/* In kalloc, a *core* is a large chunk of contiguous memory. Each core is
+ * associated with a master header, which keeps the size of the current core
+ * and the pointer to next core. Kalloc allocates small *blocks* of memory from
+ * the cores and organizes free memory blocks in a circular single-linked list.
+ *
+ * In the following diagram, "@" stands for the header of a free block (of type
+ * header_t), "#" for the header of an allocated block (of type size_t), "-"
+ * for free memory, and "+" for allocated memory.
+ *
+ * master        This region is core 1.          master           This region is core 2.
+ *      |                                             |
+ *      *@-------#++++++#++++++++++++@--------        *@----------#++++++++++++#+++++++@------------
+ *       |                           |                 |                               |
+ *       p=p->ptr->ptr->ptr->ptr     p->ptr            p->ptr->ptr                     p->ptr->ptr->ptr
+ */
+typedef struct header_t {
+	size_t size;
+	struct header_t *ptr;
+} header_t;
+
+typedef struct {
+	void *par;
+	size_t min_core_size;
+	header_t base, *loop_head, *core_head; /* base is a zero-sized block always kept in the loop */
+} kmem_t;
+
+static void panic(const char *s)
+{
+	fprintf(stderr, "%s\n", s);
+	abort();
+}
+
+void *km_init2(void *km_par, size_t min_core_size)
+{
+	kmem_t *km;
+	km = (kmem_t*)kcalloc(km_par, 1, sizeof(kmem_t));
+	km->par = km_par;
+	if (km_par) km->min_core_size = min_core_size > 0? min_core_size : ((kmem_t*)km_par)->min_core_size - 2;
+	else km->min_core_size = min_core_size > 0? min_core_size : 0x80000;
+	return (void*)km;
+}
+
+void *km_init(void) { return km_init2(0, 0); }
+
+void km_destroy(void *_km)
+{
+	kmem_t *km = (kmem_t*)_km;
+	void *km_par;
+	header_t *p, *q;
+	if (km == NULL) return;
+	km_par = km->par;
+	for (p = km->core_head; p != NULL;) {
+		q = p->ptr;
+		kfree(km_par, p);
+		p = q;
+	}
+	kfree(km_par, km);
+}
+
+static header_t *morecore(kmem_t *km, size_t nu)
+{
+	header_t *q;
+	size_t bytes, *p;
+	nu = (nu + 1 + (km->min_core_size - 1)) / km->min_core_size * km->min_core_size; /* the first +1 for core header */
+	bytes = nu * sizeof(header_t);
+	q = (header_t*)kmalloc(km->par, bytes);
+	if (!q) panic("[morecore] insufficient memory");
+	q->ptr = km->core_head, q->size = nu, km->core_head = q;
+	p = (size_t*)(q + 1);
+	*p = nu - 1; /* the size of the free block; -1 because the first unit is used for the core header */
+	kfree(km, p + 1); /* initialize the new "core"; NB: the core header is not looped. */
+	return km->loop_head;
+}
+
+void kfree(void *_km, void *ap) /* kfree() also adds a new core to the circular list */
+{
+	header_t *p, *q;
+	kmem_t *km = (kmem_t*)_km;
+	
+	if (!ap) return;
+	if (km == NULL) {
+		free(ap);
+		return;
+	}
+	p = (header_t*)((size_t*)ap - 1);
+	p->size = *((size_t*)ap - 1);
+	/* Find the pointer that points to the block to be freed. The following loop can stop on two conditions:
+	 *
+	 * a) "p>q && p<q->ptr": @------#++++++++#+++++++@-------    @---------------#+++++++@-------
+	 *    (can also be in    |      |                |        -> |                       |
+	 *     two cores)        q      p           q->ptr           q                  q->ptr
+	 *
+	 *                       @--------    #+++++++++@--------    @--------    @------------------
+	 *                       |            |         |         -> |            |
+	 *                       q            p    q->ptr            q       q->ptr
+	 *
+	 * b) "q>=q->ptr && (p>q || p<q->ptr)":  @-------#+++++   @--------#+++++++     @-------#+++++   @----------------
+	 *                                       |                |        |         -> |                |
+	 *                                  q->ptr                q        p       q->ptr                q
+	 *
+	 *                                       #+++++++@-----   #++++++++@-------     @-------------   #++++++++@-------
+	 *                                       |       |                 |         -> |                         |
+	 *                                       p  q->ptr                 q       q->ptr                         q
+	 */
+	for (q = km->loop_head; !(p > q && p < q->ptr); q = q->ptr)
+		if (q >= q->ptr && (p > q || p < q->ptr)) break;
+	if (p + p->size == q->ptr) { /* two adjacent blocks, merge p and q->ptr (the 2nd and 4th cases) */
+		p->size += q->ptr->size;
+		p->ptr = q->ptr->ptr;
+	} else if (p + p->size > q->ptr && q->ptr >= p) {
+		panic("[kfree] The end of the allocated block enters a free block.");
+	} else p->ptr = q->ptr; /* backup q->ptr */
+
+	if (q + q->size == p) { /* two adjacent blocks, merge q and p (the other two cases) */
+		q->size += p->size;
+		q->ptr = p->ptr;
+		km->loop_head = q;
+	} else if (q + q->size > p && p >= q) {
+		panic("[kfree] The end of a free block enters the allocated block.");
+	} else km->loop_head = p, q->ptr = p; /* in two cores, cannot be merged; create a new block in the list */
+}
+
+void *kmalloc(void *_km, size_t n_bytes)
+{
+	kmem_t *km = (kmem_t*)_km;
+	size_t n_units;
+	header_t *p, *q;
+
+	if (n_bytes == 0) return 0;
+	if (km == NULL) return malloc(n_bytes);
+	n_units = (n_bytes + sizeof(size_t) + sizeof(header_t) - 1) / sizeof(header_t); /* header+n_bytes requires at least this number of units */
+
+	if (!(q = km->loop_head)) /* the first time when kmalloc() is called, intialize it */
+		q = km->loop_head = km->base.ptr = &km->base;
+	for (p = q->ptr;; q = p, p = p->ptr) { /* search for a suitable block */
+		if (p->size >= n_units) { /* p->size if the size of current block. This line means the current block is large enough. */
+			if (p->size == n_units) q->ptr = p->ptr; /* no need to split the block */
+			else { /* split the block. NB: memory is allocated at the end of the block! */
+				p->size -= n_units; /* reduce the size of the free block */
+				p += p->size; /* p points to the allocated block */
+				*(size_t*)p = n_units; /* set the size */
+			}
+			km->loop_head = q; /* set the end of chain */
+			return (size_t*)p + 1;
+		}
+		if (p == km->loop_head) { /* then ask for more "cores" */
+			if ((p = morecore(km, n_units)) == 0) return 0;
+		}
+	}
+}
+
+void *kcalloc(void *_km, size_t count, size_t size)
+{
+	kmem_t *km = (kmem_t*)_km;
+	void *p;
+	if (size == 0 || count == 0) return 0;
+	if (km == NULL) return calloc(count, size);
+	p = kmalloc(km, count * size);
+	memset(p, 0, count * size);
+	return p;
+}
+
+void *krealloc(void *_km, void *ap, size_t n_bytes) // TODO: this can be made more efficient in principle
+{
+	kmem_t *km = (kmem_t*)_km;
+	size_t cap, *p, *q;
+
+	if (n_bytes == 0) {
+		kfree(km, ap); return 0;
+	}
+	if (km == NULL) return realloc(ap, n_bytes);
+	if (ap == NULL) return kmalloc(km, n_bytes);
+	p = (size_t*)ap - 1;
+	cap = (*p) * sizeof(header_t) - sizeof(size_t);
+	if (cap >= n_bytes) return ap; /* TODO: this prevents shrinking */
+	q = (size_t*)kmalloc(km, n_bytes);
+	memcpy(q, ap, cap);
+	kfree(km, ap);
+	return q;
+}
+
+void *krelocate(void *km, void *ap, size_t n_bytes)
+{
+	void *p;
+	if (km == 0 || ap == 0) return ap;
+	p = kmalloc(km, n_bytes);
+	memcpy(p, ap, n_bytes);
+	kfree(km, ap);
+	return p;
+}
+
+void km_stat(const void *_km, km_stat_t *s)
+{
+	kmem_t *km = (kmem_t*)_km;
+	header_t *p;
+	memset(s, 0, sizeof(km_stat_t));
+	if (km == NULL || km->loop_head == NULL) return;
+	for (p = km->loop_head;; p = p->ptr) {
+		s->available += p->size * sizeof(header_t);
+		if (p->size != 0) ++s->n_blocks; /* &kmem_t::base is always one of the cores. It is zero-sized. */
+		if (p->ptr > p && p + p->size > p->ptr)
+			panic("[km_stat] The end of a free block enters another free block.");
+		if (p->ptr == km->loop_head) break;
+	}
+	for (p = km->core_head; p != NULL; p = p->ptr) {
+		size_t size = p->size * sizeof(header_t);
+		++s->n_cores;
+		s->capacity += size;
+		s->largest = s->largest > size? s->largest : size;
+	}
+}
+
+void km_stat_print(const void *km)
+{
+	km_stat_t st;
+	km_stat(km, &st);
+	fprintf(stderr, "[km_stat] cap=%ld, avail=%ld, largest=%ld, n_core=%ld, n_block=%ld\n",
+			st.capacity, st.available, st.largest, st.n_blocks, st.n_cores);
+}

data/ext/minibwa/minibwa/kalloc.h

@@ -0,0 +1,54 @@
+#ifndef _KALLOC_H_
+#define _KALLOC_H_
+
+#include <stddef.h> /* for size_t */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct {
+	size_t capacity, available, n_blocks, n_cores, largest;
+} km_stat_t;
+
+void *kmalloc(void *km, size_t size);
+void *krealloc(void *km, void *ptr, size_t size);
+void *krelocate(void *km, void *ap, size_t n_bytes);
+void *kcalloc(void *km, size_t count, size_t size);
+void kfree(void *km, void *ptr);
+
+void *km_init(void);
+void *km_init2(void *km_par, size_t min_core_size);
+void km_destroy(void *km);
+void km_stat(const void *_km, km_stat_t *s);
+void km_stat_print(const void *km);
+
+#ifdef __cplusplus
+}
+#endif
+
+#define Kmalloc(km, type, cnt)       ((type*)kmalloc((km), (cnt) * sizeof(type)))
+#define Kcalloc(km, type, cnt)       ((type*)kcalloc((km), (cnt), sizeof(type)))
+#define Krealloc(km, type, ptr, cnt) ((type*)krealloc((km), (ptr), (cnt) * sizeof(type)))
+
+#define Kgrow(km, type, ptr, __i, __m) do { \
+		if ((__i) >= (__m)) { \
+			(__m) = (__i) + 1; \
+			(__m) += ((__m)>>1) + 16; \
+			(ptr) = Krealloc(km, type, ptr, (__m)); \
+		} \
+	} while (0)
+
+#define Kexpand(km, type, a, m) do { \
+		(m) = (m) >= 4? (m) + ((m)>>1) : 16; \
+		(a) = Krealloc(km, type, (a), (m)); \
+	} while (0)
+
+#ifndef klib_unused
+#if (defined __clang__ && __clang_major__ >= 3) || (defined __GNUC__ && __GNUC__ >= 3)
+#define klib_unused __attribute__ ((__unused__))
+#else
+#define klib_unused
+#endif
+#endif /* klib_unused */
+#endif