ruby-minigraph 0.0.20.0

data/ext/minigraph/misc.c

@@ -0,0 +1,12 @@
+#include <stdlib.h>
+#include "mgpriv.h"
+#include "ksort.h"
+
+int mg_verbose = 1;
+int mg_dbg_flag = 0;
+double mg_realtime0;
+
+#define sort_key_128x(a) ((a).x)
+KRADIX_SORT_INIT(128x, mg128_t, sort_key_128x, 8) 
+
+KSORT_INIT_GENERIC(uint32_t)

data/ext/minigraph/options.c

@@ -0,0 +1,134 @@
+#include <string.h>
+#include "mgpriv.h"
+#include "sys.h"
+
+void mg_idxopt_init(mg_idxopt_t *io)
+{
+	memset(io, 0, sizeof(mg_idxopt_t));
+	io->k = 17;
+	io->w = 11;
+	io->bucket_bits = 14;
+}
+
+void mg_mapopt_init(mg_mapopt_t *mo)
+{
+	memset(mo, 0, sizeof(mg_mapopt_t));
+	mo->seed = 11;
+	mo->occ_max1 = 50, mo->occ_max1_cap = 250;
+	mo->occ_max1_frac = 2e-4f;
+	mo->max_gap = 5000;
+	mo->max_gap_ref = -1;
+	mo->max_gap_pre = 1000;
+	mo->max_lc_skip = 25, mo->max_gc_skip = 25;
+	mo->max_lc_iter = 5000;
+	mo->bw = 500, mo->bw_long = 20000;
+	mo->rmq_size_cap = 100000;
+	mo->rmq_rescue_size = 1000;
+	mo->rmq_rescue_ratio = 0.1f;
+	mo->mini_batch_size = 500000000;
+	mo->div = 0.1f;
+	mo->chn_pen_gap = 1.0f, mo->chn_pen_skip = 0.05f;
+	mo->min_lc_cnt = 5, mo->min_lc_score = 40;
+	mo->min_gc_cnt = 5, mo->min_gc_score = 50;
+	mo->gdp_max_ed = 10000;
+	mo->lc_max_trim = 50;
+	mo->lc_max_occ = 2;
+	mo->mask_level = 0.5f;
+	mo->sub_diff = 6;
+	mo->best_n = 5;
+	mo->pri_ratio = 0.8f;
+	mo->ref_bonus = 0;
+	mo->pe_ori = 0; // FF
+	mo->min_cov_mapq = 20;
+	mo->min_cov_blen = 1000;
+	mo->cap_kalloc = 1000000000;
+}
+
+void mg_ggopt_init(mg_ggopt_t *go)
+{
+	memset(go, 0, sizeof(mg_ggopt_t));
+	go->algo = MG_G_NONE;
+	go->flag |= MG_G_NO_QOVLP;
+	go->min_map_len = 100000;
+	go->min_depth_len = 20000;
+	go->min_mapq = 5;
+	go->min_var_len = 50;
+	go->match_pen = 10;
+	// for ggs
+	go->ggs_shrink_pen = 9;
+	go->ggs_min_end_cnt = 10;
+	go->ggs_min_end_frac = 0.1f;
+	go->ggs_max_iden = 0.80f;
+	go->ggs_min_inv_iden = 0.95f;
+}
+
+int mg_opt_set(const char *preset, mg_idxopt_t *io, mg_mapopt_t *mo, mg_ggopt_t *go)
+{
+	if (preset == 0) {
+		mg_idxopt_init(io);
+		mg_mapopt_init(mo);
+		mg_ggopt_init(go);
+	} else if (strcmp(preset, "lr") == 0) { // this is the default
+	} else if (strcmp(preset, "asm") == 0 || strcmp(preset, "ggs") == 0) {
+		io->k = 19, io->w = 10;
+		mo->flag |= MG_M_RMQ;
+		mo->occ_max1 = 10, mo->occ_max1_cap = 100;
+		mo->bw = 1000, mo->bw_long = 150000;
+		mo->max_gap = 10000, mo->max_gap_pre = 1000;
+		mo->min_lc_cnt = 5, mo->min_lc_score = 40;
+		mo->min_gc_cnt = 5, mo->min_gc_score = 1000;
+		mo->min_cov_mapq = 5;
+		mo->min_cov_blen = 100000;
+		mo->max_lc_skip = mo->max_gc_skip = 50;
+		mo->div = 0.01f;
+		mo->mini_batch_size = 4000000000LL;
+		if (strcmp(preset, "ggs") == 0)
+			go->algo = MG_G_GGSIMPLE, mo->best_n = 0;
+	} else if (strcmp(preset, "se") == 0 || strcmp(preset, "sr") == 0) {
+		io->k = 21, io->w = 10;
+		mo->flag |= MG_M_SR | MG_M_HEAP_SORT | MG_M_2_IO_THREADS;
+		mo->occ_max1 = 1000;
+		mo->occ_max1_cap = 2500;
+		mo->max_gap = 100;
+		mo->bw = mo->bw_long = 100;
+		mo->max_frag_len = 800;
+		mo->pri_ratio = 0.5f;
+		mo->min_lc_cnt = 2, mo->min_lc_score = 25;
+		mo->min_gc_cnt = 3, mo->min_gc_score = 40;
+		mo->mini_batch_size = 50000000;
+		mo->min_cov_blen = 50;
+		mo->chn_pen_gap = 0.2f;
+		mo->ref_bonus = 1;
+		if (strcmp(preset, "sr") == 0) {
+			mo->flag |= MG_M_FRAG_MODE | MG_M_FRAG_MERGE;
+			mo->pe_ori = 0<<1|1; // FR
+		}
+	} else return -1;
+	return 0;
+}
+
+int mg_opt_check(const mg_idxopt_t *io, const mg_mapopt_t *mo, const mg_ggopt_t *go)
+{
+	if ((mo->flag & MG_M_FRAG_MODE) && !(mo->flag & MG_M_FRAG_MERGE)) {
+		if (mg_verbose >= 1)
+			fprintf(stderr, "[ERROR]\033[1;31m the fragment-without-merge mode is not implemented\033[0m\n");
+		return -1;
+	}
+	return 0;
+}
+
+void mg_opt_update(const mg_idx_t *gi, mg_mapopt_t *mo, mg_ggopt_t *go)
+{
+	float f[2];
+	int32_t q[2];
+	f[0] = 0.1f, f[1] = mo->occ_max1_frac;
+	mg_idx_cal_quantile(gi, 2, f, q);
+	if (q[0] > mo->lc_max_occ) mo->lc_max_occ = q[0];
+	if (mo->lc_max_occ > mo->occ_max1_cap) mo->lc_max_occ = mo->occ_max1_cap;
+	if (q[1] > mo->occ_max1) mo->occ_max1 = q[1];
+	if (mo->occ_max1 > mo->occ_max1_cap) mo->occ_max1 = mo->occ_max1_cap;
+	if (mo->bw_long < mo->bw) mo->bw_long = mo->bw;
+	if (mg_verbose >= 3)
+		fprintf(stderr, "[M::%s::%.3f*%.2f] occ_max1=%d; lc_max_occ=%d\n", __func__,
+				realtime() - mg_realtime0, cputime() / (realtime() - mg_realtime0), mo->occ_max1, mo->lc_max_occ);
+}

data/ext/minigraph/shortk.c

@@ -0,0 +1,251 @@
+#include "mgpriv.h"
+#include "ksort.h"
+#include "kavl.h"
+#include "algo.h"
+#include "khashl.h"
+
+typedef struct sp_node_s {
+	uint64_t di; // dist<<32 | unique_id
+	uint32_t v;
+	int32_t pre;
+	uint32_t hash;
+	int32_t is_0;
+	KAVL_HEAD(struct sp_node_s) head;
+} sp_node_t, *sp_node_p;
+
+#define sp_node_cmp(a, b) (((a)->di > (b)->di) - ((a)->di < (b)->di))
+KAVL_INIT(sp, sp_node_t, head, sp_node_cmp)
+
+#define sp_node_lt(a, b) ((a)->di < (b)->di)
+KSORT_INIT(sp, sp_node_p, sp_node_lt)
+
+typedef struct {
+	int32_t k;
+	int32_t qs, qe;
+	sp_node_t *p[MG_MAX_SHORT_K]; // this forms a max-heap
+} sp_topk_t;
+
+KHASHL_MAP_INIT(KH_LOCAL, kh_sp_t,  sp,  uint32_t, sp_topk_t, kh_hash_uint32, kh_eq_generic)
+KHASHL_MAP_INIT(KH_LOCAL, kh_sp2_t, sp2, uint32_t, uint64_t,  kh_hash_uint32, kh_eq_generic)
+
+#define MG_SHORT_K_EXT 1000
+
+static inline sp_node_t *gen_sp_node(void *km, const gfa_t *g, uint32_t v, int32_t d, int32_t id)
+{
+	sp_node_t *p;
+	KMALLOC(km, p, 1);
+	p->v = v, p->di = (uint64_t)d<<32 | id, p->pre = -1, p->is_0 = 1;
+	return p;
+}
+
+mg_pathv_t *mg_shortest_k(void *km0, const gfa_t *g, uint32_t src, int32_t n_dst, mg_path_dst_t *dst, int32_t max_dist, int32_t max_k, int32_t *n_pathv)
+{
+	sp_node_t *p, *root = 0, **out;
+	sp_topk_t *q;
+	kh_sp_t *h;
+	kh_sp2_t *h2;
+	void *km;
+	khint_t k;
+	int absent;
+	int32_t i, j, n_done, n_found;
+	uint32_t id, n_out, m_out;
+	int8_t *dst_done;
+	mg_pathv_t *ret = 0;
+	uint64_t *dst_group, *seeds = 0;
+	void *h_seeds = 0;
+	mg128_v mini = {0,0,0};
+
+	if (n_pathv) *n_pathv = 0;
+	if (n_dst <= 0) return 0;
+	for (i = 0; i < n_dst; ++i) { // initialize
+		mg_path_dst_t *t = &dst[i];
+		if (t->inner)
+			t->dist = 0, t->n_path = 1, t->path_end = -1;
+		else
+			t->dist = -1, t->n_path = 0, t->path_end = -1;
+	}
+	if (max_k > MG_MAX_SHORT_K) max_k = MG_MAX_SHORT_K;
+	km = (mg_dbg_flag&MG_DBG_NO_KALLOC) && (mg_dbg_flag&MG_DBG_SHORTK)? 0 : km_init2(km0, 0x4000);
+
+	KCALLOC(km, dst_done, n_dst);
+	KMALLOC(km, dst_group, n_dst);
+	for (i = 0; i < n_dst; ++i) // multiple dst[] may have the same dst[].v. We need to group them first.
+		dst_group[i] = (uint64_t)dst[i].v<<32 | i;
+	radix_sort_gfa64(dst_group, dst_group + n_dst);
+
+	h2 = sp2_init2(km); // this hash table keeps all destinations
+	sp2_resize(h2, n_dst * 2);
+	for (i = 1, j = 0; i <= n_dst; ++i) {
+		if (i == n_dst || dst_group[i]>>32 != dst_group[j]>>32) {
+			k = sp2_put(h2, dst_group[j]>>32, &absent);
+			kh_val(h2, k) = (uint64_t)j << 32 | (i - j);
+			assert(absent);
+			j = i;
+		}
+	}
+
+	h = sp_init2(km); // this hash table keeps visited vertices
+	sp_resize(h, 16);
+	m_out = 16, n_out = 0;
+	KMALLOC(km, out, m_out);
+
+	id = 0;
+	p = gen_sp_node(km, g, src, 0, id++);
+	p->hash = kh_hash_uint32(src);
+	kavl_insert(sp, &root, p, 0);
+	k = sp_put(h, src, &absent);
+	q = &kh_val(h, k);
+	q->k = 1, q->p[0] = p, q->qs = q->qe = -1;
+
+	n_done = 0;
+	while (kavl_size(head, root) > 0) {
+		int32_t i, nv;
+		gfa_arc_t *av;
+		sp_node_t *r;
+
+		r = kavl_erase_first(sp, &root); // take out the closest vertex in the heap (as a binary tree)
+		//fprintf(stderr, "XX\t%d\t%d\t%d\t%c%s[%d]\t%d\n", n_out, kavl_size(head, root), n_finished, "><"[(r->v&1)^1], g->seg[r->v>>1].name, r->v, (int32_t)(r->di>>32));
+		if (n_out == m_out) KEXPAND(km, out, m_out);
+		r->di = r->di>>32<<32 | n_out; // lower 32 bits now for position in the out[] array
+		out[n_out++] = r;
+
+		k = sp2_get(h2, r->v);
+		if (k != kh_end(h2)) { // we have reached one dst vertex
+			int32_t j, dist = r->di>>32, off = kh_val(h2, k) >> 32, cnt = (int32_t)kh_val(h2, k);
+			for (j = 0; j < cnt; ++j) {
+				mg_path_dst_t *t = &dst[(int32_t)dst_group[off + j]];
+				int32_t done = 0;
+				if (t->inner) {
+					done = 1;
+				} else {
+					int32_t copy = 0;
+					//if (mg_dbg_flag & MG_DBG_GC1) fprintf(stderr, "  src=%c%s[%d],qlen=%d\tdst=%c%s[%d]\ttarget_distx=%d,target_hash=%x\tdistx=%d,hash=%x\n", "><"[src&1], g->seg[src>>1].name, src, ql, "><"[t->v&1], g->seg[t->v>>1].name, t->v, t->target_dist - g->seg[src>>1].len, t->target_hash, dist - g->seg[src>>1].len, r->hash);
+					if (t->n_path == 0) { // keep the shortest path
+						copy = 1;
+					} else if (t->target_dist >= 0) { // we have a target distance; choose the closest
+						if (dist == t->target_dist && t->check_hash && r->hash == t->target_hash) { // we found the target path
+							copy = 1, done = 1;
+						} else {
+							int32_t d0 = t->dist, d1 = dist;
+							d0 = d0 > t->target_dist? d0 - t->target_dist : t->target_dist - d0;
+							d1 = d1 > t->target_dist? d1 - t->target_dist : t->target_dist - d1;
+							if (d1 < d0) copy = 1;
+						}
+					}
+					if (copy) {
+						t->path_end = n_out - 1, t->dist = dist, t->hash = r->hash, t->is_0 = r->is_0;
+						if (t->target_dist >= 0) {
+							if (dist == t->target_dist && t->check_hash && r->hash == t->target_hash) done = 1;
+							else if (dist > t->target_dist + MG_SHORT_K_EXT) done = 1;
+						}
+					}
+					++t->n_path;
+					if (t->n_path >= max_k) done = 1;
+				}
+				if (dst_done[off + j] == 0 && done)
+					dst_done[off + j] = 1, ++n_done;
+			}
+			if (n_done == n_dst) break;
+		}
+
+		nv = gfa_arc_n(g, r->v);
+		av = gfa_arc_a(g, r->v);
+		for (i = 0; i < nv; ++i) { // visit all neighbors
+			gfa_arc_t *ai = &av[i];
+			int32_t d = (r->di>>32) + (uint32_t)ai->v_lv;
+			if (d > max_dist) continue; // don't probe vertices too far away
+			k = sp_put(h, ai->w, &absent);
+			q = &kh_val(h, k);
+			if (absent) { // a new vertex visited
+				q->k = 0, q->qs = q->qe = -1;
+				//if (ql && qs) fprintf(stderr, "ql=%d,src=%d\tv=%c%s[%d]\n", ql, src, "><"[ai->w&1], g->seg[ai->w>>1].name, ai->w);
+			}
+			if (q->k < max_k) { // enough room: add to the heap
+				p = gen_sp_node(km, g, ai->w, d, id++);
+				p->pre = n_out - 1;
+				p->hash = r->hash + kh_hash_uint32(ai->w);
+				p->is_0 = r->is_0;
+				if (ai->rank > 0) p->is_0 = 0;
+				kavl_insert(sp, &root, p, 0);
+				q->p[q->k++] = p;
+				ks_heapup_sp(q->k, q->p);
+			} else if (q->p[0]->di>>32 > d) { // shorter than the longest path so far: replace the longest
+				p = kavl_erase(sp, &root, q->p[0], 0);
+				if (p) {
+					p->di = (uint64_t)d<<32 | (id++);
+					p->pre = n_out - 1;
+					p->hash = r->hash + kh_hash_uint32(ai->w);
+					p->is_0 = r->is_0;
+					if (ai->rank > 0) p->is_0 = 0;
+					kavl_insert(sp, &root, p, 0);
+					ks_heapdown_sp(0, q->k, q->p);
+				} else {
+					fprintf(stderr, "Warning: logical bug in gfa_shortest_k(): q->k=%d,q->p[0]->{d,i}={%d,%d},d=%d,src=%u,max_dist=%d,n_dst=%d\n", q->k, (int32_t)(q->p[0]->di>>32), (int32_t)q->p[0]->di, d, src, max_dist, n_dst);
+					km_destroy(km);
+					return 0;
+				}
+			} // else: the path is longer than all the existing paths ended at ai->w
+		}
+	}
+
+	kfree(km, dst_group);
+	kfree(km, dst_done);
+	sp_destroy(h);
+	mg_idx_hfree(h_seeds);
+	kfree(km, seeds);
+	kfree(km, mini.a);
+	// NB: AVL nodes are not deallocated. When km==0, they are memory leaks.
+
+	for (i = 0, n_found = 0; i < n_dst; ++i)
+		if (dst[i].n_path > 0) ++n_found;
+
+	if (n_found > 0 && n_pathv) { // then generate the backtrack array
+		int32_t n, *trans;
+		KCALLOC(km, trans, n_out); // used to squeeze unused elements in out[]
+		for (i = 0; i < n_dst; ++i) { // mark dst vertices with a target distance
+			mg_path_dst_t *t = &dst[i];
+			if (t->n_path > 0 && t->target_dist >= 0 && t->path_end >= 0)
+				trans[(int32_t)out[t->path_end]->di] = 1;
+		}
+		for (i = 0; i < n_out; ++i) { // mark dst vertices without a target distance
+			k = sp2_get(h2, out[i]->v);
+			if (k != kh_end(h2)) { // TODO: check if this is correct!
+				int32_t off = kh_val(h2, k)>>32, cnt = (int32_t)kh_val(h2, k);
+				for (j = off; j < off + cnt; ++j)
+					if (dst[j].target_dist < 0)
+						trans[i] = 1;
+			}
+		}
+		for (i = n_out - 1; i >= 0; --i) // mark all predecessors
+			if (trans[i] && out[i]->pre >= 0)
+				trans[out[i]->pre] = 1;
+		for (i = n = 0; i < n_out; ++i) // generate coordinate translations
+			if (trans[i]) trans[i] = n++;
+			else trans[i] = -1;
+
+		*n_pathv = n;
+		KMALLOC(km0, ret, n);
+		for (i = 0; i < n_out; ++i) { // generate the backtrack array
+			mg_pathv_t *p;
+			if (trans[i] < 0) continue;
+			p = &ret[trans[i]];
+			p->v = out[i]->v, p->d = out[i]->di >> 32;
+			p->pre = out[i]->pre < 0? out[i]->pre : trans[out[i]->pre];
+		}
+		for (i = 0; i < n_dst; ++i) // translate "path_end"
+			if (dst[i].path_end >= 0)
+				dst[i].path_end = trans[dst[i].path_end];
+	}
+
+	km_destroy(km);
+	return ret;
+}
+
+void mg_sub_print_path(FILE *fp, const gfa_t *g, int32_t n, mg_pathv_t *path)
+{
+	int32_t i;
+	for (i = 0; i < n; ++i) {
+		mg_pathv_t *p = &path[i];
+		fprintf(fp, "[%d]\t%d\t%s\t%d\t%d\n", i, p->v, g->seg[p->v>>1].name, p->d, p->pre);
+	}
+}

data/ext/minigraph/sketch.c

@@ -0,0 +1,109 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#define __STDC_LIMIT_MACROS
+#include "kvec-km.h"
+#include "mgpriv.h"
+
+unsigned char seq_nt4_table[256] = {
+	0, 1, 2, 3,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 0, 4, 1,  4, 4, 4, 2,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  3, 3, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 0, 4, 1,  4, 4, 4, 2,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  3, 3, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,
+	4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4,  4, 4, 4, 4
+};
+
+static inline uint64_t hash64(uint64_t key, uint64_t mask)
+{
+	key = (~key + (key << 21)) & mask; // key = (key << 21) - key - 1;
+	key = key ^ key >> 24;
+	key = ((key + (key << 3)) + (key << 8)) & mask; // key * 265
+	key = key ^ key >> 14;
+	key = ((key + (key << 2)) + (key << 4)) & mask; // key * 21
+	key = key ^ key >> 28;
+	key = (key + (key << 31)) & mask;
+	return key;
+}
+
+/**
+ * Find symmetric (w,k)-minimizers on a DNA sequence
+ *
+ * @param km     thread-local memory pool; using NULL falls back to malloc()
+ * @param str    DNA sequence
+ * @param len    length of $str
+ * @param w      find a minimizer for every $w consecutive k-mers
+ * @param k      k-mer size
+ * @param rid    reference ID; will be copied to the output $p array
+ * @param p      minimizers
+ *               p->a[i].x = kMer<<8 | kmerSpan
+ *               p->a[i].y = rid<<32 | lastPos<<1 | strand
+ *               where lastPos is the position of the last base of the i-th minimizer,
+ *               and strand indicates whether the minimizer comes from the top or the bottom strand.
+ *               Callers may want to set "p->n = 0"; otherwise results are appended to p
+ */
+void mg_sketch(void *km, const char *str, int len, int w, int k, uint32_t rid, mg128_v *p)
+{
+	uint64_t shift1 = 2 * (k - 1), mask = (1ULL<<2*k) - 1, kmer[2] = {0,0};
+	int i, j, l, buf_pos, min_pos, kmer_span = 0;
+	mg128_t buf[256], min = { UINT64_MAX, UINT64_MAX };
+
+	assert(len > 0 && (w > 0 && w < 256) && (k > 0 && k <= 28)); // 56 bits for k-mer; could use long k-mers, but 28 enough in practice
+	memset(buf, 0xff, w * 16);
+	kv_resize(mg128_t, km, *p, p->n + len/w);
+
+	for (i = l = buf_pos = min_pos = 0; i < len; ++i) {
+		int c = seq_nt4_table[(uint8_t)str[i]];
+		mg128_t info = { UINT64_MAX, UINT64_MAX };
+		if (c < 4) { // not an ambiguous base
+			int z;
+			kmer_span = l + 1 < k? l + 1 : k;
+			kmer[0] = (kmer[0] << 2 | c) & mask;           // forward k-mer
+			kmer[1] = (kmer[1] >> 2) | (3ULL^c) << shift1; // reverse k-mer
+			if (kmer[0] == kmer[1]) continue; // skip "symmetric k-mers" as we don't know it strand
+			z = kmer[0] < kmer[1]? 0 : 1; // strand
+			++l;
+			if (l >= k && kmer_span < 256) {
+				info.x = hash64(kmer[z], mask) << 8 | kmer_span;
+				info.y = (uint64_t)rid<<32 | (uint32_t)i<<1 | z;
+			}
+		} else l = 0, kmer_span = 0;
+		buf[buf_pos] = info; // need to do this here as appropriate buf_pos and buf[buf_pos] are needed below
+		if (l == w + k - 1 && min.x != UINT64_MAX) { // special case for the first window - because identical k-mers are not stored yet
+			for (j = buf_pos + 1; j < w; ++j)
+				if (min.x == buf[j].x && buf[j].y != min.y) kv_push(mg128_t, km, *p, buf[j]);
+			for (j = 0; j < buf_pos; ++j)
+				if (min.x == buf[j].x && buf[j].y != min.y) kv_push(mg128_t, km, *p, buf[j]);
+		}
+		if (info.x <= min.x) { // a new minimum; then write the old min
+			if (l >= w + k && min.x != UINT64_MAX) kv_push(mg128_t, km, *p, min);
+			min = info, min_pos = buf_pos;
+		} else if (buf_pos == min_pos) { // old min has moved outside the window
+			if (l >= w + k - 1 && min.x != UINT64_MAX) kv_push(mg128_t, km, *p, min);
+			for (j = buf_pos + 1, min.x = UINT64_MAX; j < w; ++j) // the two loops are necessary when there are identical k-mers
+				if (min.x >= buf[j].x) min = buf[j], min_pos = j; // >= is important s.t. min is always the closest k-mer
+			for (j = 0; j <= buf_pos; ++j)
+				if (min.x >= buf[j].x) min = buf[j], min_pos = j;
+			if (l >= w + k - 1 && min.x != UINT64_MAX) { // write identical k-mers
+				for (j = buf_pos + 1; j < w; ++j) // these two loops make sure the output is sorted
+					if (min.x == buf[j].x && min.y != buf[j].y) kv_push(mg128_t, km, *p, buf[j]);
+				for (j = 0; j <= buf_pos; ++j)
+					if (min.x == buf[j].x && min.y != buf[j].y) kv_push(mg128_t, km, *p, buf[j]);
+			}
+		}
+		if (++buf_pos == w) buf_pos = 0;
+	}
+	if (min.x != UINT64_MAX)
+		kv_push(mg128_t, km, *p, min);
+}

data/ext/minigraph/sys.c

@@ -0,0 +1,147 @@
+#include <stdlib.h>
+#include "sys.h"
+
+#if defined(WIN32) || defined(_WIN32)
+#include <windows.h>
+
+struct timezone
+{
+	__int32  tz_minuteswest; /* minutes W of Greenwich */
+	int  tz_dsttime;     /* type of dst correction */
+};
+
+/*
+ * gettimeofday.c
+ *    Win32 gettimeofday() replacement
+ *    taken from PostgreSQL, according to
+ *    https://stackoverflow.com/questions/1676036/what-should-i-use-to-replace-gettimeofday-on-windows
+ *
+ * src/port/gettimeofday.c
+ *
+ * Copyright (c) 2003 SRA, Inc.
+ * Copyright (c) 2003 SKC, Inc.
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose, without fee, and without a
+ * written agreement is hereby granted, provided that the above
+ * copyright notice and this paragraph and the following two
+ * paragraphs appear in all copies.
+ *
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT,
+ * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING
+ * LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
+ * DOCUMENTATION, EVEN IF THE UNIVERSITY OF CALIFORNIA HAS BEEN ADVISED
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS
+ * IS" BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE,
+ * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
+ */
+
+/* FILETIME of Jan 1 1970 00:00:00. */
+static const unsigned __int64 epoch = ((unsigned __int64) 116444736000000000ULL);
+
+/*
+ * timezone information is stored outside the kernel so tzp isn't used anymore.
+ *
+ * Note: this function is not for Win32 high precision timing purpose. See
+ * elapsed_time().
+ */
+int gettimeofday(struct timeval * tp, struct timezone *tzp)
+{
+	FILETIME    file_time;
+	SYSTEMTIME  system_time;
+	ULARGE_INTEGER ularge;
+
+	GetSystemTime(&system_time);
+	SystemTimeToFileTime(&system_time, &file_time);
+	ularge.LowPart = file_time.dwLowDateTime;
+	ularge.HighPart = file_time.dwHighDateTime;
+
+	tp->tv_sec = (long) ((ularge.QuadPart - epoch) / 10000000L);
+	tp->tv_usec = (long) (system_time.wMilliseconds * 1000);
+
+	return 0;
+}
+
+// taken from https://stackoverflow.com/questions/5272470/c-get-cpu-usage-on-linux-and-windows
+double cputime()
+{
+	HANDLE hProcess = GetCurrentProcess();
+	FILETIME ftCreation, ftExit, ftKernel, ftUser;
+	SYSTEMTIME stKernel;
+	SYSTEMTIME stUser;
+
+	GetProcessTimes(hProcess, &ftCreation, &ftExit, &ftKernel, &ftUser);
+	FileTimeToSystemTime(&ftKernel, &stKernel);
+	FileTimeToSystemTime(&ftUser, &stUser);
+
+	double kernelModeTime = ((stKernel.wHour * 60.) + stKernel.wMinute * 60.) + stKernel.wSecond * 1. + stKernel.wMilliseconds / 1000.;
+	double userModeTime = ((stUser.wHour * 60.) + stUser.wMinute * 60.) + stUser.wSecond * 1. + stUser.wMilliseconds / 1000.;
+
+	return kernelModeTime + userModeTime;
+}
+
+long peakrss(void) { return 0; }
+#else
+#include <sys/resource.h>
+#include <sys/time.h>
+
+double cputime(void)
+{
+	struct rusage r;
+	getrusage(RUSAGE_SELF, &r);
+	return r.ru_utime.tv_sec + r.ru_stime.tv_sec + 1e-6 * (r.ru_utime.tv_usec + r.ru_stime.tv_usec);
+}
+
+long peakrss(void)
+{
+	struct rusage r;
+	getrusage(RUSAGE_SELF, &r);
+#ifdef __linux__
+	return r.ru_maxrss * 1024;
+#else
+	return r.ru_maxrss;
+#endif
+}
+
+#endif /* WIN32 || _WIN32 */
+
+double realtime(void)
+{
+	struct timeval tp;
+	gettimeofday(&tp, NULL);
+	return tp.tv_sec + tp.tv_usec * 1e-6;
+}
+
+void mg_err_fputs(const char *str, FILE *fp)
+{
+	int ret;
+	ret = fputs(str, fp);
+	if (ret == EOF) {
+		fprintf(stderr, "[ERROR] failed to write the results\n");
+		exit(EXIT_FAILURE);
+	}
+}
+
+void mg_err_fwrite(const void *p, size_t size, size_t nitems, FILE *fp)
+{
+	int ret;
+	ret = fwrite(p, size, nitems, fp);
+	if (ret == EOF) {
+		fprintf(stderr, "[ERROR] failed to write data\n");
+		exit(EXIT_FAILURE);
+	}
+}
+
+void mg_err_fread(void *p, size_t size, size_t nitems, FILE *fp)
+{
+	int ret;
+	ret = fread(p, size, nitems, fp);
+	if (ret == EOF) {
+		fprintf(stderr, "[ERROR] failed to read data\n");
+		exit(EXIT_FAILURE);
+	}
+}

data/ext/minigraph/sys.h

@@ -0,0 +1,20 @@
+#ifndef MG_SYS_H
+#define MG_SYS_H
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void mg_err_fputs(const char *str, FILE *fp);
+
+double realtime(void);
+double cputime(void);
+long peakrss(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif