zzh
/
fast-bwa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
fast-bwa/ertseeding.c

3512 lines
116 KiB
C
Raw Normal View History

添加了共享内存支持，成功构建ert索引
2024-08-03 17:26:32 +08:00
#include "ertseeding.h"
#define smem_lt(a, b) ((a).start == (b).start ? (a).end > (b).end : (a).start < (b).start)
KSORT_INIT(mem_smem_ert, mem_t, smem_lt)
#define smem_lt_2(a, b) ((a).start == (b).start ? (a).end < (b).end : (a).start < (b).start)
KSORT_INIT(mem_smem_sort_lt_ert, mem_t, smem_lt_2)
/**
* 256 x 3 (2B,3B,4B ptrs) x 4 (ACGT) table encoding offset to next address given a code byte for a leaf node
*/
unsigned char leaf_table[256 * 3][4] = {
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,2,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,7,2,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,2,0},{0,0,2,0},
{7,0,2,0},{0,0,2,0},{0,0,4,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,2,0,0},
{7,2,0,0},{0,2,0,0},{0,4,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,2},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,7,0,2},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,2},{0,0,0,2},
{7,0,0,2},{0,0,0,2},{0,0,0,4},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,7,2},{0,10,5,0},
{15,10,5,0},{0,10,5,0},{0,12,7,2},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,7,2},{0,0,7,2},
{12,0,7,2},{0,0,7,2},{0,0,9,4},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,2},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,7,0,2},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,2},{0,0,0,2},
{7,0,0,2},{0,0,0,2},{0,0,0,4},{0,0,0,2},
{7,0,0,2},{0,0,0,2},{0,0,0,4},{0,7,0,2},
{12,7,0,2},{0,7,0,2},{0,9,0,4},{0,0,0,2},
{7,0,0,2},{0,0,0,2},{0,0,0,4},{0,0,0,4},
{9,0,0,4},{0,0,0,4},{0,0,0,6},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,2,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,7,2,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,2,0},{0,0,2,0},
{7,0,2,0},{0,0,2,0},{0,0,4,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,2,0,0},
{7,2,0,0},{0,2,0,0},{0,4,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,2,0,0},
{7,2,0,0},{0,2,0,0},{0,4,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,2,0},
{7,0,2,0},{0,0,2,0},{0,0,4,0},{0,7,2,0},
{12,7,2,0},{0,7,2,0},{0,9,4,0},{0,0,2,0},
{7,0,2,0},{0,0,2,0},{0,0,4,0},{0,0,4,0},
{9,0,4,0},{0,0,4,0},{0,0,6,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,2,0,0},
{7,2,0,0},{0,2,0,0},{0,4,0,0},{0,0,0,0},
{2,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,4,0,0},
{9,4,0,0},{0,4,0,0},{0,6,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,3,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,8,3,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,3,0},{0,0,3,0},
{8,0,3,0},{0,0,3,0},{0,0,6,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,3,0,0},
{8,3,0,0},{0,3,0,0},{0,6,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,3},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,8,0,3},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,3},{0,0,0,3},
{8,0,0,3},{0,0,0,3},{0,0,0,6},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,8,3},{0,10,5,0},
{15,10,5,0},{0,10,5,0},{0,13,8,3},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,8,3},{0,0,8,3},
{13,0,8,3},{0,0,8,3},{0,0,11,6},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,3},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,8,0,3},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,3},{0,0,0,3},
{8,0,0,3},{0,0,0,3},{0,0,0,6},{0,0,0,3},
{8,0,0,3},{0,0,0,3},{0,0,0,6},{0,8,0,3},
{13,8,0,3},{0,8,0,3},{0,11,0,6},{0,0,0,3},
{8,0,0,3},{0,0,0,3},{0,0,0,6},{0,0,0,6},
{11,0,0,6},{0,0,0,6},{0,0,0,9},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,3,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,8,3,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,3,0},{0,0,3,0},
{8,0,3,0},{0,0,3,0},{0,0,6,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,3,0,0},
{8,3,0,0},{0,3,0,0},{0,6,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,3,0,0},
{8,3,0,0},{0,3,0,0},{0,6,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,3,0},
{8,0,3,0},{0,0,3,0},{0,0,6,0},{0,8,3,0},
{13,8,3,0},{0,8,3,0},{0,11,6,0},{0,0,3,0},
{8,0,3,0},{0,0,3,0},{0,0,6,0},{0,0,6,0},
{11,0,6,0},{0,0,6,0},{0,0,9,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,3,0,0},
{8,3,0,0},{0,3,0,0},{0,6,0,0},{0,0,0,0},
{3,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,6,0,0},
{11,6,0,0},{0,6,0,0},{0,9,0,0},{0,0,0,0},
{6,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{9,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,4,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,9,4,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,4,0},{0,0,4,0},
{9,0,4,0},{0,0,4,0},{0,0,8,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,4,0,0},
{9,4,0,0},{0,4,0,0},{0,8,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,4},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,9,0,4},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,4},{0,0,0,4},
{9,0,0,4},{0,0,0,4},{0,0,0,8},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,9,4},{0,10,5,0},
{15,10,5,0},{0,10,5,0},{0,14,9,4},{0,0,5,0},
{10,0,5,0},{0,0,5,0},{0,0,9,4},{0,0,9,4},
{14,0,9,4},{0,0,9,4},{0,0,13,8},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,4},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,9,0,4},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,0,4},{0,0,0,4},
{9,0,0,4},{0,0,0,4},{0,0,0,8},{0,0,0,4},
{9,0,0,4},{0,0,0,4},{0,0,0,8},{0,9,0,4},
{14,9,0,4},{0,9,0,4},{0,13,0,8},{0,0,0,4},
{9,0,0,4},{0,0,0,4},{0,0,0,8},{0,0,0,8},
{13,0,0,8},{0,0,0,8},{0,0,0,12},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,4,0},{0,5,0,0},
{10,5,0,0},{0,5,0,0},{0,9,4,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,0,4,0},{0,0,4,0},
{9,0,4,0},{0,0,4,0},{0,0,8,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{5,0,0,0},{0,0,0,0},{0,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,4,0,0},
{9,4,0,0},{0,4,0,0},{0,8,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,4,0,0},
{9,4,0,0},{0,4,0,0},{0,8,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,4,0},
{9,0,4,0},{0,0,4,0},{0,0,8,0},{0,9,4,0},
{14,9,4,0},{0,9,4,0},{0,13,8,0},{0,0,4,0},
{9,0,4,0},{0,0,4,0},{0,0,8,0},{0,0,8,0},
{13,0,8,0},{0,0,8,0},{0,0,12,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,4,0,0},
{9,4,0,0},{0,4,0,0},{0,8,0,0},{0,0,0,0},
{4,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,8,0,0},
{13,8,0,0},{0,8,0,0},{0,12,0,0},{0,0,0,0},
{8,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{12,0,0,0},{0,0,0,0},{0,0,0,0}
};
/**
* 256 x 3 (2B,3B,4B ptrs) x 4 (ACGT) table encoding offset to next address given a code byte for an internal 'DIVERGE' node
*/
unsigned char code_table[256 * 3][4] = {
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{2,0,0,0},{0,2,0,0},
{0,2,0,0},{0,2,0,0},{4,2,0,0},{0,0,2,0},
{0,0,2,0},{0,0,2,0},{4,0,2,0},{0,0,2,0},
{0,0,2,0},{0,0,2,0},{4,0,2,0},{0,0,2,0},
{0,0,2,0},{0,0,2,0},{4,0,2,0},{0,4,2,0},
{0,4,2,0},{0,4,2,0},{6,4,2,0},
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{3,0,0,0},{0,3,0,0},
{0,3,0,0},{0,3,0,0},{6,3,0,0},{0,0,3,0},
{0,0,3,0},{0,0,3,0},{6,0,3,0},{0,0,3,0},
{0,0,3,0},{0,0,3,0},{6,0,3,0},{0,0,3,0},
{0,0,3,0},{0,0,3,0},{6,0,3,0},{0,6,3,0},
{0,6,3,0},{0,6,3,0},{9,6,3,0},
{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,0,0,0},
{0,0,0,0},{0,0,0,0},{4,0,0,0},{0,4,0,0},
{0,4,0,0},{0,4,0,0},{8,4,0,0},{0,0,4,0},
{0,0,4,0},{0,0,4,0},{8,0,4,0},{0,0,4,0},
{0,0,4,0},{0,0,4,0},{8,0,4,0},{0,0,4,0},
{0,0,4,0},{0,0,4,0},{8,0,4,0},{0,8,4,0},
{0,8,4,0},{0,8,4,0},{12,8,4,0}
};
/**
* Return integer key from k-mer string.
*
* @param str Query sequence
* @param keysize K-mer length
* @param index Index into query sequence
* @param seq_len Length of query sequence
* @param end_flag Flag to indicate end of query
* @param idx_first_N Index of first ambiguous bp in the k-mer
*
* @return Integer key (hash) for k-mer
*/
static inline uint32_t getHashKey (const uint8_t *str, const int keysize, int index, int seq_len, int* end_flag, int* idx_first_N) {
int i;
uint32_t key = 0;
int len = keysize;
if (index + keysize > seq_len) {
*end_flag = 1;
len = seq_len - index;
}
for (i = 0; i < len; ++i) {
if (str[i] != 4) {
key |= ((uint32_t)(str[i]) << (i << 1));
}
else {
*idx_first_N = i;
break;
}
}
return key;
}
uint8_t *get_seq(int64_t l_pac, const uint8_t *pac, int64_t beg, int64_t end,
int64_t *len, uint8_t *ref_string, uint8_t *seqb)
{
uint8_t *seq = 0;
if (end < beg) end ^= beg, beg ^= end, end ^= beg; // if end is smaller, swap
if (end > l_pac<<1) end = l_pac<<1;
if (beg < 0) beg = 0;
if (beg >= l_pac || end <= l_pac) {
*len = end - beg;
if (beg >= l_pac) { // reverse strand
seq = ref_string + beg;
} else { // forward strand
seq = ref_string + beg;
}
} else *len = 0; // if bridging the forward-reverse boundary, return nothing
return seq;
}
/**
* Compute offset to child and return address of child node
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param code type of child nodes (EMPTY:00, LEAF:01, UNIFORM:10, DIVERGE:11) - 2b encoded
* @param c next character in read (used to traverse tree)
* @param byteIdx byte index into the mlt_data radix tree
*
*/
void getOffsetToChildNode(read_aux_t* raux, uint8_t* mlt_data, uint8_t code, uint8_t c, uint64_t* byteIdx) {
uint64_t nextByteIdx = *byteIdx;
uint64_t startByteIdx = nextByteIdx - 1;
int offset = code_table[((raux->ptr_width - 2) << 8) + code][c];
uint32_t reseed_data = 0;
nextByteIdx += offset;
memcpy_bwamem(&reseed_data, raux->ptr_width * sizeof(uint8_t), &mlt_data[nextByteIdx], raux->ptr_width * sizeof(uint8_t), __FILE__, __LINE__);
uint32_t jumpByteIdx = reseed_data >> 6;
raux->num_hits = (reseed_data & 0x3F);
nextByteIdx = startByteIdx + jumpByteIdx;
*byteIdx = nextByteIdx;
}
/**
* Compute offset to start of leaf data
*
* @param raux read parameters
* @param code type of child nodes (EMPTY:00, LEAF:01, UNIFORM:10, DIVERGE:11) - 2b encoded
* @param c next character in read (used to traverse tree)
*
*/
static inline int getOffsetToLeafData(read_aux_t* raux, uint8_t code, uint8_t c) {
return leaf_table[((raux->ptr_width - 2) << 8) + code][c];
}
/**
* This routine does depth-first tree traversal starting from an internal node to obtain all hits at leaf nodes
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param mem maximal-exact-match storage
* @param bc next character in read (used to traverse tree)
* @param hits list of hits for read
*/
void getNextByteIdx_dfs(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, mem_t* mem, uint8_t bc, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c;
c = 3 - bc;
mem->skip_ref_fetch = 1; // MEM cannot be extended by leaf decompression
uint8_t code = mlt_data[nextByteIdx++];
uint8_t code_c = (code >> (c << 1)) & 3;
assert(code != 0);
if (code_c == LEAF) { // Hit a leaf node
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // Found a multi-hit leaf node
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
}
else { // Single-hit leaf node
raux->num_hits = 1;
mem->hitcount += raux->num_hits;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
}
else if (code_c == UNIFORM) { // Multi-character internal node
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
uint8_t k;
uint64_t startByteIdx = nextByteIdx;
for (k = 0; k < 4; ++k) {
getNextByteIdx_dfs(raux, mlt_data, &startByteIdx, mem, k, hits);
startByteIdx = nextByteIdx;
}
}
else if (code_c == DIVERGE) { // Single-character internal node
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
uint8_t k;
uint64_t startByteIdx = nextByteIdx;
for (k = 0; k < 4; ++k) {
getNextByteIdx_dfs(raux, mlt_data, &startByteIdx, mem, k, hits);
startByteIdx = nextByteIdx;
}
}
*byte_idx = nextByteIdx;
}
/**
* Gather all hits for the MEM
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param mem MEM including hits
* @param hits list of hits for read
*/
void leaf_gather(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, mem_t* mem, u64v* hits) {
uint8_t k;
uint64_t startByteIdx = *byte_idx;
uint64_t tmpByteIdx = startByteIdx;
for (k = 0; k < 4; ++k) {
getNextByteIdx_dfs(raux, mlt_data, &tmpByteIdx, mem, k, hits);
tmpByteIdx = startByteIdx;
}
}
/**
* Traverse tree during backward search(seeding). Similar to getNextByteIdx, except that we don't compute LEP
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param i index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void getNextByteIdx_backward(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int* i, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c, code, code_c;
if (raux->read_buf[*i] != 4) {
c = 3 - raux->read_buf[*i];
code = mlt_data[nextByteIdx++];
code_c = (code >> (c << 1)) & 3;
assert(code != 0);
}
else { // Terminate MEM search when we hit an 'N'
code_c = EMPTY;
}
if (code_c == EMPTY) { // Gather leaves later during forward traversal
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
else if (code_c == LEAF) { // Hit a leaf node
*i += 1;
mem->rc_end = *i;
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // Found a multi-hit leaf node
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 5;
kv_push(uint64_t, *hits, ref_pos >> 1);
ref_pos = 0;
}
//
// We found a multi-hit. But to report hits in the same order as BWA-MEM,
// we will fetch the hits again in a forward tree traversal
//
mem->fetch_leaves = 1;
}
else { // Single-hit leaf node
mem->hitcount += 1;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
}
else if (code_c == UNIFORM) { // Multi-character internal node
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((*i + j) >= raux->l_seq) {
break;
}
if (raux->read_buf[*i+j] == 4) {
break;
}
if (3 - raux->read_buf[*i+j] != unpackedBP[j]) {
break;
}
}
*i += j;
if (j == countBP) { // We match all bps
if (*i < raux->l_seq) {
getNextByteIdx_backward(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->rc_end = *i;
}
}
else { // Did not match all bps. Gather leaves for MEM in a later forward traversal
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else { // Single-character internal node
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
*i += 1;
if (*i < raux->l_seq) {
getNextByteIdx_backward(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->rc_end = *i;
}
}
*byte_idx = nextByteIdx;
}
/**
* Traverse tree during backward search (reseeding). Terminate when fewer than 'raux->limit' hits are found for
* an internal node
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param i index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for each read
*/
void getNextByteIdx_backward_wlimit(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int* i, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c, code, code_c;
if (raux->read_buf[*i] != 4) {
c = 3 - raux->read_buf[*i];
code = mlt_data[nextByteIdx++];
code_c = (code >> (c << 1)) & 3;
assert(code != 0);
}
else { // Terminate MEM search when we hit an 'N'
code_c = EMPTY;
}
if (code_c == EMPTY) { // Gather leaves later during forward traversal
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
else if (code_c == LEAF) { // Hit a leaf node
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // Found a multi-hit leaf node
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
// Hits exceed reseeding threshold
if (raux->num_hits >= raux->limit) {
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 5;
kv_push(uint64_t, *hits, ref_pos >> 1);
ref_pos = 0;
}
*i += 1;
}
}
//
// We found a multi-hit. But to report hits in the same order as BWA-MEM,
// we will fetch the hits again in a forward tree traversal
//
mem->fetch_leaves = 1;
mem->rc_end = *i;
}
else if (code_c == UNIFORM) { // Multi-character internal node
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((*i + j) >= raux->l_seq) {
break;
}
if (raux->read_buf[*i+j] == 4) {
break;
}
if (3 - raux->read_buf[*i+j] != unpackedBP[j]) {
break;
}
}
*i += j;
if (j == countBP) { // We match all bps
if (*i < raux->l_seq) {
getNextByteIdx_backward_wlimit(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else { // Did not match all bps. Gather leaves for MEM in a later forward traversal
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else { // Single-character internal node
raux->num_hits = 0;
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
// In the internal nodes, raux->num_hits = 0 is used to reprsent # hits > 20
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
*i += 1;
if (*i < raux->l_seq) {
getNextByteIdx_backward_wlimit(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else {
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
*byte_idx = nextByteIdx;
}
/**
* Traverse tree during forward search (seeding).
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param i index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void getNextByteIdx(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int* i, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t parent_byte_idx = nextByteIdx;
uint64_t ref_pos = 0;
uint8_t c, code, code_c;
if (raux->read_buf[*i] != 4) {
c = 3 - raux->read_buf[*i];
code = mlt_data[nextByteIdx++];
code_c = (code >> (c << 1)) & 3;
assert(code != 0);
}
else { // Terminate MEM search when we hit an 'N'
code_c = EMPTY;
}
uint64_t lep_idx = 0;
uint64_t lep_bit_idx = 0;
if (code_c == EMPTY) {
if (mem->start == 0) { // FIXME: Gather leaves later during forward traversal even for MEMs starting at read_pos = 0
int mem_len = *i;
if (mem_len >= raux->min_seed_len) { // Only gather leaves when MEM length exceeds threshold
uint64_t startByteIdx = parent_byte_idx;
leaf_gather(raux, mlt_data, &startByteIdx, mem, hits);
}
}
// Update LEP for backward search
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
}
else if (code_c == LEAF) { // Hit a leaf node
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // Found a multi-hit leaf node
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
}
else { // Single-hit leaf node
raux->num_hits = 1;
mem->hitcount += raux->num_hits;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
// Update LEP for backward search
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
*i += 1;
}
else if (code_c == UNIFORM) { // Multi-character internal node
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((*i + j) >= raux->l_seq) { // Don't run past the end of the read
break;
}
if (raux->read_buf[*i+j] == 4) {
break;
}
if ((3 - raux->read_buf[*i+j]) != unpackedBP[j]) {
break;
}
}
raux->nextLEPBit += j;
*i += j;
if (j == countBP) { // If we match all bases of uniform entry
if (*i == raux->l_seq) { // Check if we reached the end of the read
if (mem->start == 0) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
}
else {
if (*i < raux->l_seq) {
getNextByteIdx(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
}
}
else {
//
// We did not match all bases of uniform entry
// Fetch all hits from leaf nodes for backward extension (dfs :( )
//
assert(*i <= raux->l_seq);
if (mem->start == 0) {
int mem_len = *i;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
// Update LEP to start backward search from last matching bp
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
}
}
else { // Single-character internal node
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
*i += 1;
if (*i < raux->l_seq) {
getNextByteIdx(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
if (mem->start == 0) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
*byte_idx = nextByteIdx;
}
/**
* Traverse tree during forward search (reseeding). Terminate when fewer than 'raux->limit' hits are found for an
* internal node
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param i index into read buffer
* @param mem maximal-exact-match storage
* @param visited stack to store list of visited nodes
* @param hits list of hits for read
*/
void getNextByteIdx_wlimit(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int* i, mem_t* mem, path_v* visited, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t parent_byte_idx = nextByteIdx;
uint64_t ref_pos = 0;
uint8_t c, code, code_c;
if (raux->read_buf[*i] != 4) {
c = 3 - raux->read_buf[*i];
code = mlt_data[nextByteIdx++];
code_c = (code >> (c << 1)) & 3;
assert(code != 0);
}
else { // Terminate MEM search when we hit an 'N'
code_c = EMPTY;
}
uint64_t lep_idx = 0;
uint64_t lep_bit_idx = 0;
if (code_c == EMPTY) {
if (mem->start == 0) {
int mem_len = *i;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &parent_byte_idx, mem, hits);
}
}
// Update LEP for backward search
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
}
else if (code_c == LEAF) { // Hit a leaf node
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // Found a multi-hit leaf node
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
}
else { // Single-hit leaf node
raux->num_hits = 1;
}
// Hits exceed reseeding threshold
if (raux->num_hits >= raux->limit) {
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
*i += 1;
}
else {
// Do DFS traversal to gather leaves starting from parent node
if (mem->start == 0) {
int mem_len = *i;
if (mem_len >= raux->min_seed_len) {
node_info_t* tmp_node_info = &kv_pop(*visited);
leaf_gather(raux, mlt_data, &tmp_node_info->byte_idx, mem, hits);
}
}
}
// Update LEP for backward search
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
}
else if (code_c == UNIFORM) { // Multi-character internal node
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((*i + j) >= raux->l_seq) { // Don't run past the end of the read
break;
}
if (raux->read_buf[*i+j] == 4) {
break;
}
if ((3 - raux->read_buf[*i+j]) != unpackedBP[j]) {
break;
}
}
raux->nextLEPBit += j;
*i += j;
if (j == countBP) { // If we match all bases of uniform entry
if (*i == raux->l_seq) { // Check if we reached the end of the read
if (mem->start == 0) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
}
else {
if (*i < raux->l_seq) {
getNextByteIdx_wlimit(raux, mlt_data, &nextByteIdx, i, mem, visited, hits);
}
}
}
else {
//
// We did not match all bases of uniform entry
// Fetch all hits from leaf nodes for backward extension (dfs :( )
//
assert(*i <= raux->l_seq);
if (mem->start == 0) {
int mem_len = *i;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
}
}
else {
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
lep_idx = raux->nextLEPBit >> 6;
lep_bit_idx = raux->nextLEPBit & (0x3FULL);
raux->lep[lep_idx] |= (1ULL << lep_bit_idx);
raux->nextLEPBit += 1;
// In the internal nodes, raux->num_hits = 0 is used to reprsent # hits > 20
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
node_info_t nif;
nif.byte_idx = nextByteIdx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, *visited, nif);
*i += 1;
if (*i < raux->l_seq) {
getNextByteIdx_wlimit(raux, mlt_data, &nextByteIdx, i, mem, visited, hits);
}
else {
if (mem->start == 0) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
else {
// Do DFS traveral to gather leaves from parent node
if (mem->start == 0) {
int mem_len = *i;
if (mem_len >= raux->min_seed_len) {
node_info_t* tmp_node_info = &kv_pop(*visited);
leaf_gather(raux, mlt_data, &tmp_node_info->byte_idx, mem, hits);
}
}
}
}
*byte_idx = nextByteIdx;
}
/**
* Traverse tree during forward search (LAST). Terminate when fewer than 'raux->limit' hits are found for an internal node
* Minimum MEM length for LAST is opt->min_seed_len + 1
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param i index into read buffer
* @param mem maximal-exact match found
* @param visited stack to store list of visited nodes
* @param hits list of hits for read
*/
void getNextByteIdx_last(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int* i, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c, code, code_c;
if (raux->read_buf[*i] != 4) {
c = 3 - raux->read_buf[*i];
code = mlt_data[nextByteIdx++];
code_c = (code >> (c << 1)) & 3;
assert(code != 0);
}
else { // Terminate MEM search when we hit an 'N'
code_c = EMPTY;
}
if (code_c == EMPTY) {
*i += 1;
}
else if (code_c == LEAF) { // Hit a leaf node
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) { // multi-hit leaf
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
}
else { // single-hit leaf
raux->num_hits = 1;
mem->hitcount += raux->num_hits;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
*i += 1;
}
else if (code_c == UNIFORM) { // Multi-character internal node
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((*i + j) >= raux->l_seq) { //!< Don't run past the end of the read
break;
}
if (raux->read_buf[*i+j] == 4) {
break;
}
if ((3 - raux->read_buf[*i+j]) != unpackedBP[j]) {
break;
}
}
*i += j;
int len = *i - mem->start;
//
// LAST stop criterion: MEM is sufficiently long and not too frequent
//
int stop_extension = (raux->num_hits > 0 &&
raux->num_hits < raux->limit &&
len >= (raux->min_seed_len + 1)) ? 1 : 0;
if (stop_extension) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
*i = mem->start + (raux->min_seed_len + 1);
}
else {
if (j == countBP) {
if (*i < raux->l_seq) {
getNextByteIdx_last(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
}
else {
*i += 1;
}
}
}
else if (code_c == DIVERGE) {
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
*i += 1;
int len = *i - mem->start;
//
// LAST stop criterion: MEM is sufficiently long and not too frequent
//
int stop_extension = (raux->num_hits > 0 &&
raux->num_hits < raux->limit &&
len >= (raux->min_seed_len + 1)) ? 1 : 0;
if (stop_extension) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
else {
if (*i < raux->l_seq) {
getNextByteIdx_last(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
}
}
*byte_idx = nextByteIdx;
}
/**
* Main backward search function (seeding). Lookup up k-mer and/or x-mer table and identify root of ERT
*
* @param iaux index parameters
* @param raux read parameters
* @param i index into read buffer
* @param mem maximal-exact match found
* @param hits list of hits for read
*/
void leftExtend(index_aux_t* iaux, read_aux_t* raux, int* i, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, ref_pos = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[*i], kmerSize, *i, raux->l_seq, 0, &idx_first_N);
if (idx_first_N != -1) {
*i += (kmerSize + xmerSize);
mem->rc_end = *i;
return;
}
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
// width used for internal pointers in tree
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
byte_idx = 0;
if (code == INVALID) { // k-mer absent
*i += (kmerSize + xmerSize);
mem->rc_end = *i;
}
else if (code == SINGLE_HIT_LEAF) { // single-hit k-mer
mlt_data = &iaux->mlt_table[start_addr];
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 5;
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
*i += kmerSize;
mem->rc_end = *i;
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
*i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
if (*i < raux->l_seq) {
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
getNextByteIdx_backward(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
mem->rc_end = *i;
}
}
else { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
*i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
hashval = getHashKey(&raux->read_buf[*i], xmerSize, *i, raux->l_seq, 0, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
if (idx_first_N != -1) {
*i += xmerSize;
mem->rc_end = *i;
return;
}
if (code == INVALID) {
*i += xmerSize;
mem->rc_end = *i;
}
else if (code == SINGLE_HIT_LEAF) {
byte_idx = ptr;
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 5;
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
*i += xmerSize;
mem->rc_end = *i;
}
else {
byte_idx = ptr;
*i += xmerSize;
if (*i < raux->l_seq) {
getNextByteIdx_backward(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
mem->rc_end = *i;
}
}
}
}
/**
* Main backward search function (reseeding). Lookup up k-mer and/or x-mer table and identify root of ERT.
* Return early if root node has fewer than 'raux->limit' hits
*
* @param iaux index parameters
* @param raux read parameters
* @param i index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void leftExtend_wlimit(index_aux_t* iaux, read_aux_t* raux, int* i, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[*i], kmerSize, *i, raux->l_seq, 0, &idx_first_N);
if (idx_first_N != -1) {
*i += (kmerSize + xmerSize);
mem->rc_end = *i;
return;
}
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
// width used for internal pointers in tree
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
// # hits for k-mer (0 if > 20 hits)
raux->num_hits = (kmer_entry >> 17) & 0x1F;
byte_idx = 0;
if (code == INVALID) { // k-mer absent
*i += (kmerSize + xmerSize);
mem->rc_end = *i;
}
else if (code == SINGLE_HIT_LEAF) { // single-hit k-mer
*i += (kmerSize + xmerSize);
mem->rc_end = *i;
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
*i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
if (*i < raux->l_seq) {
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
getNextByteIdx_backward_wlimit(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
// Leaf gathering to be done later
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else {
mem->rc_end = *i;
}
}
else { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
*i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
hashval = getHashKey(&raux->read_buf[*i], xmerSize, *i, raux->l_seq, 0, &idx_first_N);
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
// This helps in decoding nodes and creates compact trees
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
raux->num_hits = (xmer_entry >> 17) & 0x1F;
if (idx_first_N != -1) {
*i += xmerSize;
mem->rc_end = *i;
return;
}
if (code == INVALID) {
*i += xmerSize;
mem->rc_end = *i;
}
else if (code == SINGLE_HIT_LEAF) {
*i += xmerSize;
mem->rc_end = *i;
}
else {
byte_idx = ptr;
*i += xmerSize;
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
if (*i < raux->l_seq) {
getNextByteIdx_backward_wlimit(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
// Leaf gathering
mem->rc_end = *i;
mem->fetch_leaves = 1;
}
}
else {
mem->rc_end = *i;
}
}
}
}
/**
* Fetch hits for all MEMs identified after backward search (termination conditions based on reseeding)
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param idx index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void getNextByteIdx_fetch_leaves_prefix_reseed(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int idx, mem_t* mem, path_v* visited, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t parent_byte_idx = nextByteIdx;
uint64_t ref_pos = 0;
uint8_t c;
int i = idx;
assert(raux->read_buf[i] != 4); // Should not see N in SMEMs
c = 3 - raux->read_buf[i];
uint8_t code = mlt_data[nextByteIdx++];
uint8_t code_c = (code >> (c << 1)) & 3;
assert(code != 0);
if (code_c == EMPTY) { // Do leaf gathering
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &parent_byte_idx, mem, hits);
}
}
else if (code_c == LEAF) {
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) {
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
}
else {
raux->num_hits = 1;
}
if (raux->num_hits >= raux->limit) {
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
i += 1;
mem->end = i;
mem->is_multi_hit = 1; // decompress leaf node for potentially longer match
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
node_info_t* tmp_node_info = &kv_pop(*visited);
leaf_gather(raux, mlt_data, &tmp_node_info->byte_idx, mem, hits);
}
}
}
else if (code_c == UNIFORM) {
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((i + j) >= raux->l_seq) {
break;
}
if (3 - raux->read_buf[i+j] != unpackedBP[j]) {
break;
}
}
i += j;
if (j == countBP) {
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix_reseed(raux, mlt_data, &nextByteIdx, i, mem, visited, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
else if (code_c == DIVERGE) {
raux->num_hits = 0;
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
node_info_t nif;
nif.byte_idx = nextByteIdx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, *visited, nif);
i += 1;
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix_reseed(raux, mlt_data, &nextByteIdx, i, mem, visited, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
node_info_t* tmp_node_info = &kv_pop(*visited);
leaf_gather(raux, mlt_data, &tmp_node_info->byte_idx, mem, hits);
}
}
}
*byte_idx = nextByteIdx;
}
/**
* Fetch hits for all MEMs identified after backward search (extend beyond mem->end)
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param idx index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void getNextByteIdx_fetch_leaves_prefix(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int idx, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c;
int i = idx;
assert(raux->read_buf[i] != 4); // Should not see N in SMEMs
c = 3 - raux->read_buf[i];
uint8_t code = mlt_data[nextByteIdx++];
uint8_t code_c = (code >> (c << 1)) & 3;
assert(code != 0);
if (code_c == EMPTY) { // Do leaf gathering
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
nextByteIdx = *byte_idx;
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
else if (code_c == LEAF) {
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) {
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
}
else {
raux->num_hits = 1;
mem->hitcount += raux->num_hits;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
i += 1;
mem->end = i;
}
else if (code_c == UNIFORM) {
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((i + j) >= raux->l_seq) {
break;
}
if (3 - raux->read_buf[i+j] != unpackedBP[j]) {
break;
}
}
i += j;
if (j == countBP) {
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
else if (code_c == DIVERGE) {
raux->num_hits = 0;
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
i += 1;
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
}
/**
* Forward traversal to fetch hits for all MEMs identified after backward search.
*
* @param raux read parameters
* @param mlt_data radix tree of k-mer
* @param byteIdx byte index into the mlt_data radix tree
* @param idx index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void getNextByteIdx_fetch_leaves(read_aux_t* raux, uint8_t* mlt_data, uint64_t* byte_idx, int idx, mem_t* mem, u64v* hits) {
uint64_t nextByteIdx = *byte_idx;
uint64_t ref_pos = 0;
uint8_t c;
int i = idx;
assert(raux->read_buf[i] != 4); // Should not see N in SMEMs
c = 3 - raux->read_buf[i];
uint8_t code = mlt_data[nextByteIdx++];
uint8_t code_c = (code >> (c << 1)) & 3;
assert(code != 0);
assert(code_c != EMPTY);
if (code_c == LEAF) {
int k;
uint64_t leaf_data = 0;
nextByteIdx += getOffsetToLeafData(raux, code, c);
memcpy_bwamem(&leaf_data, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
if (leaf_data & 1) {
nextByteIdx = raux->mh_start_addr + (leaf_data >> 1);
memcpy_bwamem(&raux->num_hits, 2 * sizeof(uint8_t), &mlt_data[nextByteIdx], 2 * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += 2;
mem->hitcount += raux->num_hits;
for (k = 0; k < raux->num_hits; ++k) {
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[nextByteIdx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
kv_push(uint64_t, *hits, ref_pos >> 1);
nextByteIdx += 5;
ref_pos = 0;
}
}
else {
raux->num_hits = 1;
mem->hitcount += raux->num_hits;
kv_push(uint64_t, *hits, leaf_data >> 1);
}
i += 1;
}
else if (code_c == UNIFORM) {
uint32_t j;
int countBP = *((uint16_t*) &mlt_data[nextByteIdx]);
nextByteIdx += 2;
int numBitsForBP = countBP << 1;
int numBytesForBP = (numBitsForBP % 8) ? (numBitsForBP / 8 + 1) : (numBitsForBP / 8);
uint8_t packedBP[numBytesForBP];
memcpy_bwamem(packedBP, numBytesForBP * sizeof(uint8_t), &mlt_data[nextByteIdx], numBytesForBP * sizeof(uint8_t), __FILE__, __LINE__);
nextByteIdx += numBytesForBP;
// Unpack base pairs
uint8_t unpackedBP[countBP];
for (j = 0; j < countBP; ++j) {
unpackedBP[j] = ((packedBP[j >> 2] >> ((~(j) & 3) << 1)) & 3);
}
// Count number of matching base pairs with read
for (j = 0; j < countBP; ++j) {
if ((i + j) >= raux->l_seq) {
break;
}
if (3 - raux->read_buf[i+j] != unpackedBP[j]) {
break;
}
}
i += j;
if (j == countBP) {
if (i < mem->end) { // only extend till end of MEM found during previous backward search
getNextByteIdx_fetch_leaves(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
else {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
else if (code_c == DIVERGE) {
raux->num_hits = 0;
getOffsetToChildNode(raux, mlt_data, code, c, &nextByteIdx);
i += 1;
if (i < mem->end) { // only extend till end of MEM found during previous backward search
getNextByteIdx_fetch_leaves(raux, mlt_data, &nextByteIdx, i, mem, hits);
}
else {
leaf_gather(raux, mlt_data, &nextByteIdx, mem, hits);
}
}
}
/**
* Extend as much as possible to the right based on reseeding criteria.
*
* Return early if root node has fewer than 'raux->limit' hits
*
* @param iaux index parameters
* @param raux read parameters
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend_fetch_leaves_prefix_reseed(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
int flag = 0;
int i = mem->start;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[i], kmerSize, i, raux->l_seq, &flag, &idx_first_N);
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
raux->mh_start_addr = 0;
// width used for internal pointers in tree
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
// # hits for k-mer (0 if > 20 hits)
raux->num_hits = (kmer_entry >> 17) & 0x1F;
byte_idx = 0;
assert(code != INVALID);
if (code == SINGLE_HIT_LEAF) {
mem->end = i;
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
if (i < raux->l_seq) {
path_v visited;
kv_init(visited);
node_info_t nif;
nif.byte_idx = byte_idx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, visited, nif);
getNextByteIdx_fetch_leaves_prefix_reseed(raux, mlt_data, &byte_idx, i, mem, &visited, hits);
kv_destroy(visited);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
else {
mem->end = i;
}
}
else if (code == FREQUENT) { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
mlt_data = &iaux->mlt_table[start_addr];
hashval = getHashKey(&raux->read_buf[i + kmerSize], xmerSize, i + kmerSize, raux->l_seq, 0, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
// 5 bits to encode number of hits at each node
raux->num_hits = (xmer_entry >> 17) & 0x1F;
if (code == INVALID) {
mem->end = i;
}
else if (code == SINGLE_HIT_LEAF) {
mem->end = i;
}
else {
// When a node has greater than 20 (opt->max_mem->intv) hits, we store a 0 in the hits field
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
byte_idx = ptr;
i += (kmerSize + xmerSize);
if (i < raux->l_seq) {
path_v visited;
kv_init(visited);
node_info_t nif;
nif.byte_idx = byte_idx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, visited, nif);
getNextByteIdx_fetch_leaves_prefix_reseed(raux, mlt_data, &byte_idx, i, mem, &visited, hits);
kv_destroy(visited);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
else {
mem->end = i;
}
}
}
}
/**
* Extend as much as possible to the right and gather leaves if MEM length >= opt->min_seed_len.
*
* @param iaux index parameters
* @param raux read parameters
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend_fetch_leaves_prefix(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, ref_pos = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
int flag = 0;
int i = mem->start;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[i], kmerSize, i, raux->l_seq, &flag, &idx_first_N);
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
raux->mh_start_addr = 0;
// width used for internal pointers in tree, 2 bits, ptr_width = 4 is encoded as 0
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
byte_idx = 0;
assert(code != INVALID);
if (code == SINGLE_HIT_LEAF) {
mlt_data = &iaux->mlt_table[start_addr];
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
i += kmerSize;
mem->end = i;
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
else if (code == FREQUENT) { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
mlt_data = &iaux->mlt_table[start_addr];
hashval = getHashKey(&raux->read_buf[i + kmerSize], xmerSize, i + kmerSize, raux->l_seq, 0, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
if (code == INVALID) {
mem->end = i;
}
else if (code == SINGLE_HIT_LEAF) {
byte_idx = ptr;
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
i += (kmerSize + xmerSize);
mem->end = i;
}
else {
byte_idx = ptr;
i += (kmerSize + xmerSize);
if (i < raux->l_seq) {
getNextByteIdx_fetch_leaves_prefix(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
mem->end = i;
int mem_len = mem->end - mem->start;
if (mem_len >= raux->min_seed_len) {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
}
}
/**
* Fetch hits for all MEMs identified after backward search.
*
* Note that backward search functions above only perform tree traversal without gathering hits as they will be fetched in
* a different order than required by BWA-MEM (i.e., all hits for MEM need to be sorted by right-context). We re-traverse and
* the tree and fetch the hits in the correct order below (this has a minor performance penalty)
*
* Return early if root node has fewer than 'raux->limit' hits
*
* @param iaux index parameters
* @param raux read parameters
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend_fetch_leaves(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
int flag = 0;
int i = mem->start;
int end = mem->end;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[i], kmerSize, i, raux->l_seq, &flag, &idx_first_N);
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
raux->mh_start_addr = 0;
// width used for internal pointers in tree
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
byte_idx = 0;
assert(code != INVALID);
assert(code != SINGLE_HIT_LEAF);
if (code == INFREQUENT) { // k-mer has fewer than 256 hits
i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
if (i < end) {
getNextByteIdx_fetch_leaves(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
else if (code == FREQUENT) { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
hashval = getHashKey(&raux->read_buf[i], xmerSize, i, raux->l_seq, 0, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
assert(code != INVALID);
assert(code != SINGLE_HIT_LEAF);
byte_idx = ptr;
i += xmerSize;
if (i < end) {
getNextByteIdx_fetch_leaves(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
/**
* Main forward search function (seeding). Lookup up k-mer and/or x-mer table and identify root of ERT
*
* @param iaux index parameters
* @param raux read parameters
* @param i Index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend(index_aux_t* iaux, read_aux_t* raux, int* i, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, ref_pos = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
uint64_t lep_data = 0;
int flag = 0;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[*i], kmerSize, *i, raux->l_seq, &flag, &idx_first_N);
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
lep_data = (kmer_entry >> METADATA_BITWIDTH) & LEP_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
uint64_t mlt_start_addr = raux->mlt_start_addr = start_addr;
raux->mh_start_addr = 0;
// width used for internal pointers in tree
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
// LEP takes up kmerSize-1 bits. Last LEP bit is at position = kmerSize-2.
if (*i <= 64-kmerSize) {
raux->lep[0] |= (lep_data << *i);
}
else if (*i < 64) {
raux->lep[0] |= (lep_data << *i);
raux->lep[1] |= (lep_data >> (64-*i));
}
else if (*i <= 128-kmerSize) {
raux->lep[1] |= (lep_data << (*i-64));
}
else if (*i < 128) {
raux->lep[1] |= (lep_data << (*i-64));
raux->lep[2] |= (lep_data >> (128-*i));
}
else if (*i <= 192-kmerSize) {
raux->lep[2] |= (lep_data << (*i-128));
}
else if (*i < 192) {
raux->lep[2] |= (lep_data << (*i-128));
raux->lep[3] |= (lep_data >> (192-*i));
}
else if (*i <= 256-kmerSize) {
raux->lep[3] |= (lep_data << (*i-192));
}
else if (*i < 256) {
raux->lep[3] |= (lep_data << (*i-192));
raux->lep[4] |= (lep_data >> (256-*i));
}
else {
raux->lep[4] |= (lep_data << (*i-256));
}
raux->nextLEPBit = *i + kmerSize - 1;
byte_idx = 0;
// We found an ambiguous base in the kmer. Stop extension at ambiguous base and record LEP
if (idx_first_N != -1) {
if (*i != 0) {
raux->nextLEPBit = *i + idx_first_N - 1;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
}
*i += idx_first_N;
return;
}
if (flag) {
raux->nextLEPBit = (raux->l_seq - 1);
*i = raux->l_seq;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
return;
}
if (code == INVALID) {
// Do backward extension using LEP
*i += (kmerSize + xmerSize);
}
else if (code == SINGLE_HIT_LEAF) {
mlt_data = &iaux->mlt_table[start_addr];
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
*i += kmerSize;
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
*i += kmerSize;
mlt_data = &iaux->mlt_table[start_addr];
if (*i < raux->l_seq) {
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
getNextByteIdx(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
else if (code == FREQUENT) { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
*i += kmerSize;
int k;
uint64_t lepBit = 0;
flag = 0;
mlt_data = &iaux->mlt_table[mlt_start_addr];
hashval = getHashKey(&raux->read_buf[*i], xmerSize, *i, raux->l_seq, &flag, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
lep_data = (xmer_entry >> METADATA_BITWIDTH) & 0xF;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
int xmerLen = 0;
if (raux->l_seq - *i > xmerSize) {
xmerLen = xmerSize;
}
else {
xmerLen = raux->l_seq - *i;
}
for (k = 0; k < xmerLen; ++k) {
lepBit = (lep_data >> k) & 1;
raux->lep[raux->nextLEPBit >> 6] |= (lepBit << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit++;
}
// We found an ambiguous base in the kmer. Stop extension at ambiguous base and record LEP
if (idx_first_N != -1) {
raux->nextLEPBit = *i + idx_first_N - 1;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
*i += idx_first_N;
return;
}
if (flag) {
raux->nextLEPBit = (raux->l_seq - 1);
*i = raux->l_seq;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
return;
}
if (code == INVALID) {
*i += xmerSize;
}
else if (code == SINGLE_HIT_LEAF) {
byte_idx = ptr;
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
*i += xmerSize;
}
else {
byte_idx = ptr;
*i += xmerSize;
if (*i < raux->l_seq) {
getNextByteIdx(raux, mlt_data, &byte_idx, i, mem, hits);
}
else {
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
}
}
/**
* Main forward search function (reseeding). Lookup up k-mer and/or x-mer table and identify root of ERT
* Return early if root node has fewer than 'raux->limit' hits
*
* @param iaux index parameters
* @param raux read parameters
* @param i Index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend_wlimit(index_aux_t* iaux, read_aux_t* raux, int* i, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, kmer_entry = 0, start_addr = 0;
uint32_t hashval = 0;
uint64_t lep_data = 0;
int flag = 0;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[*i], kmerSize, *i, raux->l_seq, &flag, &idx_first_N);
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
// index-table entry type
code = kmer_entry & METADATA_MASK;
lep_data = (kmer_entry >> METADATA_BITWIDTH) & LEP_MASK;
// pointer to root of tree
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
uint64_t mlt_start_addr = raux->mlt_start_addr = start_addr;
raux->mh_start_addr = 0;
// width used for internal pointers in tree, 2 bits, ptr_width = 4 is encoded as 0
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
raux->num_hits = (kmer_entry >> 17) & 0x1F;
// LEP takes up kmerSize-1 bits. Last LEP bit is at position = kmerSize-2.
if (*i <= 64-kmerSize) {
raux->lep[0] |= (lep_data << *i);
}
else if (*i < 64) {
raux->lep[0] |= (lep_data << *i);
raux->lep[1] |= (lep_data >> (64-*i));
}
else if (*i <= 128-kmerSize) {
raux->lep[1] |= (lep_data << (*i-64));
}
else if (*i < 128) {
raux->lep[1] |= (lep_data << (*i-64));
raux->lep[2] |= (lep_data >> (128-*i));
}
else if (*i <= 192-kmerSize) {
raux->lep[2] |= (lep_data << (*i-128));
}
else if (*i < 192) {
raux->lep[2] |= (lep_data << (*i-128));
raux->lep[3] |= (lep_data >> (192-*i));
}
else if (*i <= 256-kmerSize) {
raux->lep[3] |= (lep_data << (*i-192));
}
else if (*i < 256) {
raux->lep[3] |= (lep_data << (*i-192));
raux->lep[4] |= (lep_data >> (256-*i));
}
else {
raux->lep[4] |= (lep_data << (*i-256));
}
raux->nextLEPBit = *i + kmerSize - 1;
byte_idx = 0;
// We found an ambiguous base in the kmer. Stop extension at ambiguous base and record LEP
if (idx_first_N != -1) {
if (*i != 0) {
raux->nextLEPBit = *i + idx_first_N - 1;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
}
*i += idx_first_N;
return;
}
if (flag) {
raux->nextLEPBit = (raux->l_seq - 1);
*i = raux->l_seq;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
return;
}
if (code == INVALID) {
// Do backward extension using LEP
*i += (kmerSize + xmerSize);
}
else if (code == SINGLE_HIT_LEAF) {
*i += (kmerSize + xmerSize);
}
else if (code == INFREQUENT) { // k-mer has fewer than 256 hits
*i += kmerSize;
mlt_data = &iaux->mlt_table[mlt_start_addr];
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
if (*i < raux->l_seq) {
path_v visited;
kv_init(visited);
node_info_t nif;
nif.byte_idx = byte_idx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, visited, nif);
//
// First 4 bytes of tree store the start of all multi-hit leaves for the k-mer
//
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
getNextByteIdx_wlimit(raux, mlt_data, &byte_idx, i, mem, &visited, hits);
kv_destroy(visited);
}
else {
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
}
else if (code == FREQUENT) { // k-mer has large, dense tree, do an additional x-mer lookup
uint64_t xmer_entry;
uint64_t ptr = 0;
*i += kmerSize;
int k;
uint64_t lepBit = 0;
flag = 0;
mlt_data = &iaux->mlt_table[mlt_start_addr];
hashval = getHashKey(&raux->read_buf[*i], xmerSize, *i, raux->l_seq, &flag, &idx_first_N);
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
lep_data = (xmer_entry >> METADATA_BITWIDTH) & 0xF;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
// 5 bits to encode hits for each node
raux->num_hits = (xmer_entry >> 17) & 0x1F;
int xmerLen = 0;
if (raux->l_seq - *i > xmerSize) {
xmerLen = xmerSize;
}
else {
xmerLen = raux->l_seq - *i;
}
for (k = 0; k < xmerLen; ++k) {
lepBit = (lep_data >> k) & 1;
raux->lep[raux->nextLEPBit >> 6] |= (lepBit << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit++;
}
// We found an ambiguous base in the kmer. Stop extension at ambiguous base and record LEP
if (idx_first_N != -1) {
raux->nextLEPBit = *i + idx_first_N - 1;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
*i += idx_first_N;
return;
}
if (flag) {
raux->nextLEPBit = (raux->l_seq - 1);
*i = raux->l_seq;
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
return;
}
if (code == INVALID) {
*i += xmerSize;
}
else if (code == SINGLE_HIT_LEAF) {
*i += xmerSize;
}
else {
byte_idx = ptr;
*i += xmerSize;
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit)) {
if (*i < raux->l_seq) {
path_v visited;
kv_init(visited);
node_info_t nif;
nif.byte_idx = byte_idx;
nif.num_hits = raux->num_hits;
kv_push(node_info_t, visited, nif);
getNextByteIdx_wlimit(raux, mlt_data, &byte_idx, i, mem, &visited, hits);
kv_destroy(visited);
}
else {
raux->lep[raux->nextLEPBit >> 6] |= (1ULL << (raux->nextLEPBit & (0x3FULL)));
raux->nextLEPBit += 1;
}
}
}
}
}
/*
* Main forward search function for LAST heuristic
*
* @param iaux index parameters
* @param raux read parameters
* @param i Index into read buffer
* @param mem maximal-exact-match storage
* @param hits list of hits for read
*/
void rightExtend_last(index_aux_t* iaux, read_aux_t* raux, int* i, mem_t* mem, u64v* hits) {
uint8_t code;
uint8_t* mlt_data;
uint64_t byte_idx = 0, ref_pos = 0, kmer_entry = 0, start_addr = 0;
int flag = 0;
uint32_t hashval = 0;
int idx_first_N = -1;
hashval = getHashKey(&raux->read_buf[*i], kmerSize, *i, raux->l_seq, &flag, &idx_first_N);
// We found an ambiguous base in the kmer. Stop extension
if (idx_first_N != -1) {
*i += (idx_first_N + 1);
return;
}
if (flag) {
*i = raux->l_seq;
return;
}
// index-table lookup
kmer_entry = iaux->kmer_offsets[hashval];
code = kmer_entry & METADATA_MASK;
start_addr = kmer_entry >> KMER_DATA_BITWIDTH;
uint64_t mlt_start_addr = raux->mlt_start_addr = start_addr;
raux->mh_start_addr = 0;
raux->ptr_width = (((kmer_entry >> 22) & 3) == 0) ? 4 : ((kmer_entry >> 22) & 3);
raux->num_hits = (kmer_entry >> 17) & 0x1F;
byte_idx = 0;
if (code == INVALID) {
// Do backward extension using LEP
*i += kmerSize;
}
else if (code == SINGLE_HIT_LEAF) {
mlt_data = &iaux->mlt_table[mlt_start_addr];
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
*i += kmerSize;
}
else if (code == INFREQUENT) {
*i += kmerSize;
mlt_data = &iaux->mlt_table[mlt_start_addr];
if (*i < raux->l_seq) { // Length <= (kmer + xmer). Need not check num_hits here.
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
getNextByteIdx_last(raux, mlt_data, &byte_idx, i, mem, hits);
}
}
else if (code == FREQUENT) {
uint64_t xmer_entry;
uint64_t ptr = 0;
*i += kmerSize;
flag = 0;
mlt_data = &iaux->mlt_table[mlt_start_addr];
hashval = getHashKey(&raux->read_buf[*i], xmerSize, *i, raux->l_seq, &flag, &idx_first_N);
// We found an ambiguous base in the kmer. Stop extension
if (idx_first_N != -1) {
*i += (idx_first_N + 1);
return;
}
if (flag) {
*i = raux->l_seq;
return;
}
memcpy_bwamem(&raux->mh_start_addr, 4 * sizeof(uint8_t), &mlt_data[byte_idx], 4 * sizeof(uint8_t), __FILE__, __LINE__);
byte_idx += 4;
memcpy_bwamem(&xmer_entry, 8 * sizeof(uint8_t), &mlt_data[byte_idx + (hashval << 3)], 8 * sizeof(uint8_t), __FILE__, __LINE__);
code = xmer_entry & METADATA_MASK;
ptr = xmer_entry >> KMER_DATA_BITWIDTH;
raux->num_hits = (xmer_entry >> 17) & 0x1F;
if (code == INVALID) {
*i += xmerSize;
}
else if (code == SINGLE_HIT_LEAF) {
byte_idx = ptr;
byte_idx++;
memcpy_bwamem(&ref_pos, 5 * sizeof(uint8_t), &mlt_data[byte_idx], 5 * sizeof(uint8_t), __FILE__, __LINE__);
mem->hitcount += 1;
kv_push(uint64_t, *hits, ref_pos >> 1);
byte_idx += 5;
*i += xmerSize;
}
else {
byte_idx = ptr;
*i += xmerSize;
if ((raux->num_hits == 0) || (raux->num_hits >= raux->limit) || ((*i - mem->start) < (raux->min_seed_len + 1))) {
if (*i < raux->l_seq) {
getNextByteIdx_last(raux, mlt_data, &byte_idx, i, mem, hits);
}
}
else { // number of hits is less than the limit and seed length >= opt->min_seed_len
leaf_gather(raux, mlt_data, &byte_idx, mem, hits);
}
}
}
}
/*
* Initialize MEM parameters for backward extension
*
* @param lep LEP bit vector
* @param mem maximal-exact-match
* @param j Index into LEP
* @param seq_len Read length
* @param min_seed_len Minimum seed length
*
* @return mem_valid valid flag to indicate if backward search needs to be performed from given position j
*/
static inline int init_mem(uint64_t* lep, mem_t* mem, int j, int seq_len, int min_seed_len) {
int lep_bit_set = (lep[j >> 6] >> (j & 63)) & 1;
int in_valid_range = (j >= (min_seed_len-1)) ? 1 : 0;
int mem_valid = (lep_bit_set && in_valid_range);
mem->end = j + 1; // [start, end) indexing
mem->rc_start = seq_len - j - 1;
mem->rc_end = mem->rc_start;
mem->skip_ref_fetch = 0;
mem->forward = 0;
mem->fetch_leaves = 0;
mem->hitbeg = mem->hitcount = 0;
mem->end_correction = 0;
mem->is_multi_hit = 0;
return mem_valid;
}
/*
* Compute final SMEMs and their hits after considering their overlaps
*
* Leaf expansion is also performed to get the actual length of the MEM.
* Note that leaf nodes store compressed suffixes by including a pointer to the reference genome
*
* @param iaux index related parameters
* @param raux read related parameters
* @param mem maximal-exact-match storage
* @param sh helper data structure to keep track of start and end positions of previously identified MEMs
* @param smems List of SMEMs
*
* @return n number of backward extensions to skip
*/
int check_and_add_smem_prefix_reseed(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, smem_helper_t* sh, mem_v* smems, u64v* hits) {
mem->start = raux->l_seq - mem->rc_end; // Adjust start position of LMEM
int lmemLen = mem->end - mem->start, rmemLen = -1, next_be_point;
if (mem->hitcount > 0 && !mem->skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[mem->hitbeg] - mem->rc_start;
int64_t end_ref_pos = hits->a[mem->hitbeg];
// Fetch reference to check for extra matching bps on the right
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m, numMatchingBP = 0;
for (m = 1; m <= len; ++m) {
if (rseq[mem->rc_start - m] == raux->read_buf[mem->rc_start - m]) {
numMatchingBP++;
}
else {
break;
}
}
mem->end += numMatchingBP;
mem->end_correction += numMatchingBP;
start_ref_pos = hits->a[mem->hitbeg] + lmemLen;
end_ref_pos = start_ref_pos + mem->start;
// Fetch reference to check for extra matching bps on the left
rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
numMatchingBP = 0;
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->read_buf[mem->rc_end + m]) {
numMatchingBP++;
}
else {
break;
}
}
mem->start -= numMatchingBP;
}
// Adjust start position of MEM by extra matching bps
lmemLen = mem->end - mem->start;
next_be_point = mem->end;
if (mem->hitcount == 1) {
if (lmemLen >= raux->min_seed_len) {
kv_push(mem_t, *smems, *mem);
}
else {
next_be_point += (raux->min_seed_len - lmemLen);
}
}
// perform forward extension only for non-empty MEMs from backward extension
else if (mem->fetch_leaves && (mem->start <= (raux->l_seq - raux->min_seed_len))) {
hits->n -= mem->hitcount;
mem->hitbeg = hits->n;
mem->hitcount = 0;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend_fetch_leaves_prefix_reseed(iaux, raux, mem, hits);
raux->read_buf = raux->unpacked_rc_queue_buf;
rmemLen = mem->end - mem->start;
next_be_point = mem->end;
if (mem->hitcount > 0) {
if (mem->is_multi_hit) {
int64_t len;
int64_t start_ref_pos = hits->a[mem->hitbeg] + rmemLen;
int64_t end_ref_pos = hits->a[mem->hitbeg] + raux->l_seq - mem->start;
/// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
/// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[mem->end + m]) {
numMatchingBP++;
}
else {
break;
}
}
mem->end += numMatchingBP;
rmemLen = mem->end - mem->start;
next_be_point = mem->end;
}
if (rmemLen >= raux->min_seed_len && mem->end <= sh->mem_end_limit) {
kv_push(mem_t, *smems, *mem);
}
else {
next_be_point += (raux->min_seed_len - rmemLen);
}
}
else { // we don't have min_seed_len match for this start position
assert(rmemLen <= raux->min_seed_len);
next_be_point += (raux->min_seed_len - rmemLen);
}
}
else {
if (lmemLen <= raux->min_seed_len) {
next_be_point += (raux->min_seed_len - lmemLen);
}
}
return next_be_point;
}
/*
* Compute final SMEMs and their hits after considering their overlaps
*
* Leaf expansion is also performed to get the actual length of the MEM.
* Note that leaf nodes store compressed suffixes by including a pointer to the reference genome
*
* @param iaux index related parameters
* @param raux read related parameters
* @param mem maximal-exact-match storage
* @param sh helper data structure to keep track of start and end positions of previously identified MEMs
* @param smems list of SMEMs
* @param hits list of hits for read
*
* @return n number of backward extensions to skip
*/
int check_and_add_smem_prefix(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, smem_helper_t* sh, mem_v* smems, u64v* hits) {
mem->start = raux->l_seq - mem->rc_end; // Adjust start position of LMEM
int lmemLen = mem->end - mem->start, rmemLen = -1, next_be_point;
if (mem->hitcount > 0 && !mem->skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[mem->hitbeg] - mem->rc_start;
int64_t end_ref_pos = hits->a[mem->hitbeg];
// Fetch reference to check for extra matching bps
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m, numMatchingBP = 0;
for (m = 1; m <= len; ++m) {
if (rseq[mem->rc_start - m] == raux->read_buf[mem->rc_start - m]) {
numMatchingBP++;
}
else {
break;
}
}
mem->end += numMatchingBP;
mem->end_correction += numMatchingBP;
start_ref_pos = hits->a[mem->hitbeg] + lmemLen;
end_ref_pos = start_ref_pos + mem->start;
// Fetch reference to check for extra matching bps
rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
numMatchingBP = 0;
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->read_buf[mem->rc_end + m]) {
numMatchingBP++;
}
else {
break;
}
}
// free(rseq);
mem->start -= numMatchingBP;
}
lmemLen = mem->end - mem->start;
next_be_point = mem->end;
// skip forward re-traversal for single-git MEMs
if (mem->hitcount == 1) {
if (lmemLen >= raux->min_seed_len) {
kv_push(mem_t, *smems, *mem);
}
else {
next_be_point += (raux->min_seed_len - lmemLen);
}
}
else if (mem->fetch_leaves && (mem->start <= (raux->l_seq - raux->min_seed_len))) {
hits->n -= mem->hitcount;
mem->hitbeg = hits->n;
mem->hitcount = 0;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend_fetch_leaves_prefix(iaux, raux, mem, hits);
raux->read_buf = raux->unpacked_rc_queue_buf;
rmemLen = mem->end - mem->start;
next_be_point = mem->end;
if (mem->hitcount > 0) {
int64_t len;
int64_t start_ref_pos = hits->a[mem->hitbeg] + rmemLen;
int64_t end_ref_pos = hits->a[mem->hitbeg] + raux->l_seq - mem->start;
/// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
/// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[mem->end + m]) {
numMatchingBP++;
}
else {
break;
}
}
mem->end += numMatchingBP;
rmemLen = mem->end - mem->start;
next_be_point = mem->end;
if (rmemLen >= raux->min_seed_len) {
kv_push(mem_t, *smems, *mem);
}
else {
next_be_point += (raux->min_seed_len - rmemLen);
}
}
else { // we don't have min_seed_len match for this start position
assert(rmemLen <= raux->min_seed_len);
next_be_point += (raux->min_seed_len - rmemLen);
}
}
else {
assert(lmemLen <= raux->min_seed_len);
next_be_point += (raux->min_seed_len - lmemLen);
}
return next_be_point;
}
/*
* Compute final SMEMs and their hits after considering their overlaps
*
* Leaf expansion is also performed to get the actual length of the MEM.
* Note that leaf nodes store compressed suffixes by including a pointer to the reference genome
*
* @param iaux index related parameters
* @param raux read related parameters
* @param mem maximal-exact-match storage
* @param sh helper data structure to keep track of start and end positions of previously identified MEMs
* @param smems list of SMEMs
* @param hits list of hits for read
*/
void check_and_add_smem(index_aux_t* iaux, read_aux_t* raux, mem_t* mem, smem_helper_t* sh, mem_v* smems, u64v* hits) {
mem->start = raux->l_seq - mem->rc_end; // Adjust start position of LMEM
int lmemLen = mem->end - mem->start;
if (mem->hitcount > 0 && !mem->skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[mem->hitbeg] + lmemLen;
int64_t end_ref_pos = start_ref_pos + mem->start;
// Fetch reference to check for extra matching bps
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m, numMatchingBP = 0;
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->read_buf[mem->rc_end + m]) {
numMatchingBP++;
}
else {
break;
}
}
// Adjust start position of MEM by extra matching bps
mem->start -= numMatchingBP;
}
lmemLen = mem->end - mem->start;
if (lmemLen >= raux->min_seed_len) {
// Check if MEM lies completely within previously discovered MEM
if (mem->start < sh->prevMemStart || mem->end > sh->prevMemEnd) {
// Extra work for equivalency with BWA-MEM.
if (mem->fetch_leaves) {
hits->n -= mem->hitcount;
mem->hitbeg = hits->n;
mem->hitcount = 0;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend_fetch_leaves(iaux, raux, mem, hits);
raux->read_buf = raux->unpacked_rc_queue_buf;
}
if (mem->hitcount > 0) {
mem->pt.c_pivot = sh->curr_pivot;
mem->pt.p_pivot = sh->prev_pivot;
mem->pt.pp_pivot = sh->prev_prev_pivot;
kv_push(mem_t, *smems, *mem);
if (mem->start <= (sh->prev_pivot + 1)) {
sh->stop_be = 1;
}
}
sh->prevMemStart = mem->start;
sh->prevMemEnd = mem->end;
}
}
}
/*
* This function replaces bwt_smem1() and uses ERT to generate SMEMs
*
* @param iaux index related parameters
* @param raux read related parameters
* @param smems list of SMEMs
* @param hits list of hits for read
*/
void get_seeds_prefix(index_aux_t* iaux, read_aux_t* raux, mem_v* smems, u64v* hits) {
smem_helper_t sh;
memset(&sh, 0, sizeof(smem_helper_t));
sh.prevMemStart = raux->l_seq;
sh.prevMemEnd = 0;
int i = 0, j = 0;
sh.prev_pivot = -1;
sh.prev_prev_pivot = -1;
memset(raux->lep, 0, 5 * sizeof(uint64_t));
while (i < raux->l_seq) { // Begin identifying RMEMs
mem_t rm;
memset(&rm, 0, sizeof(mem_t));
rm.start = i;
rm.forward = 1;
rm.hitbeg = hits->n;
sh.curr_pivot = rm.start;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend(iaux, raux, &i, &rm, hits); //!< Compute LEP.
// Lazy expansion of leaf nodes.
if (rm.hitcount > 0 && !rm.skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[rm.hitbeg] + i - rm.start;
int64_t end_ref_pos = hits->a[rm.hitbeg] + raux->l_seq - rm.start;
// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[i+m]) {
numMatchingBP++;
}
else {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
break;
}
}
// Last base of RMEM must have LEP bit set
if (m == len) {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
}
i += numMatchingBP;
}
rm.end = i;
int rmemLen = rm.end - rm.start;
// No left-extension for position 0 in read
// rm.start is the current pivot
if (rm.start == 0) {
if (rmemLen >= raux->min_seed_len) {
if (rm.hitcount > 0) {
kv_push(mem_t, *smems, rm);
}
}
else {
hits->n -= rm.hitcount;
}
memset(raux->lep, 0, 5 * sizeof(uint64_t));
}
else { // perform all backward extensions
hits->n -= rm.hitcount;
uint64_t* lep = raux->lep;
int seq_len = raux->l_seq;
int min_seed_len = raux->min_seed_len;
sh.stop_be = 0;
int min_j = (rm.start > min_seed_len) ? (rm.start-1) : (min_seed_len-1);
int max_j = rm.end - 1;
j = min_j;
sh.prev_pivot = rm.start;
while (j <= max_j) {
mem_t m;
int be_point;
int mem_valid = init_mem(lep, &m, j, seq_len, min_seed_len);
m.hitbeg = hits->n;
int next_j = j + 1;
if (mem_valid) {
be_point = j + 1;
if (be_point >= min_seed_len) {
int rc_i = seq_len - be_point;
raux->read_buf = raux->unpacked_rc_queue_buf;
leftExtend(iaux, raux, &rc_i, &m, hits);
next_j = check_and_add_smem_prefix(iaux, raux, &m, &sh, smems, hits);
}
}
j = next_j;
if (m.end > i) {
i = m.end;
}
}
}
raux->read_buf = raux->unpacked_queue_buf;
// Skip all ambiguous bases
while (i < raux->l_seq) {
if (raux->read_buf[i] == 4) {
++i;
}
else {
break;
}
}
// Check if there other ambiguous bases within min_seed_len bases of the start of the MEM
while ((i < raux->l_seq) && (i - rm.start) < raux->min_seed_len) {
if (raux->read_buf[i] == 4) {
++i;
break;
}
++i;
}
sh.prev_prev_pivot = sh.prev_pivot;
sh.prev_pivot = rm.start;
memset(raux->lep, 0, 5 * sizeof(uint64_t));
break; // zzh
}
#ifdef PRINT_SMEM
ks_introsort(mem_smem_sort_lt_ert, smems->n, smems->a); // Sort SMEMs based on start pos in read. For DEBUG.
for (i = 0; i < smems->n; ++i) {
// printf("[SMEM]:%d,%d\n", smems->a[i].start, smems->a[i].end);
int idx;
for (idx = 0; idx < smems->a[i].hitcount; ++idx) {
if (smems->a[i].forward || smems->a[i].fetch_leaves) {
printf("[SMEM]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, hits->a[smems->a[i].hitbeg + idx]);
}
else {
printf("[SMEM]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, (iaux->bns->l_pac << 1) - hits->a[smems->a[i].hitbeg + idx] - (smems->a[i].end - smems->a[i].start - smems->a[i].end_correction));
}
}
}
#endif
}
/*
* This function replaces bwt_smem1() and uses ERT to generate SMEMs
*
* @param iaux index related parameters
* @param raux read related parameters
* @param smems list of SMEMs
* @param hits list of hits for read
*/
void get_seeds(index_aux_t* iaux, read_aux_t* raux, mem_v* smems, u64v* hits) {
smem_helper_t sh;
memset(&sh, 0, sizeof(smem_helper_t));
sh.prevMemStart = raux->l_seq;
sh.prevMemEnd = 0;
int i = 0, j = 0;
sh.prev_pivot = -1;
sh.prev_prev_pivot = -1;
memset(raux->lep, 0, 5 * sizeof(uint64_t));
while (i < raux->l_seq) { // Begin identifying RMEMs
mem_t rm;
memset(&rm, 0, sizeof(mem_t));
rm.start = i;
rm.forward = 1;
rm.hitbeg = hits->n;
sh.curr_pivot = rm.start;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend(iaux, raux, &i, &rm, hits); // Compute LEP.
// Lazy expansion of leaf nodes.
if (rm.hitcount > 0 && !rm.skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[rm.hitbeg] + i - rm.start;
int64_t end_ref_pos = hits->a[rm.hitbeg] + raux->l_seq - rm.start;
// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[i+m]) {
numMatchingBP++;
}
else {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
break;
}
}
// Last base of RMEM must have LEP bit set
if (m == len) {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
}
i += numMatchingBP;
}
rm.end = i;
int rmemLen = rm.end - rm.start;
// No left-extension for position 0 in read
// rm.start is the current pivot
if (rm.start == 0) {
if (rmemLen >= raux->min_seed_len) {
if (rm.hitcount > 0) {
rm.pt.c_pivot = sh.curr_pivot;
rm.pt.p_pivot = sh.prev_pivot;
rm.pt.pp_pivot = sh.prev_prev_pivot;
kv_push(mem_t, *smems, rm);
}
}
else {
hits->n -= rm.hitcount;
}
memset(raux->lep, 0, 5 * sizeof(uint64_t));
}
else {
hits->n -= rm.hitcount;
uint64_t* lep = raux->lep;
int seq_len = raux->l_seq;
int min_seed_len = raux->min_seed_len;
j = rm.end-1;
sh.stop_be = 0;
int min_j = (rm.start > min_seed_len) ? (rm.start-1) : (min_seed_len-1);
while (j >= min_j) {
mem_t m;
int be_point;
int mem_valid = init_mem(lep, &m, j, seq_len, min_seed_len);
m.hitbeg = hits->n;
if (mem_valid) {
be_point = j + 1;
if (be_point >= min_seed_len) {
int rc_i = seq_len - be_point;
raux->read_buf = raux->unpacked_rc_queue_buf;
leftExtend(iaux, raux, &rc_i, &m, hits);
check_and_add_smem(iaux, raux, &m, &sh, smems, hits);
if (sh.stop_be) break;
}
}
j -= 1;
}
}
raux->read_buf = raux->unpacked_queue_buf;
// Skip all ambiguous bases
while (i < raux->l_seq) {
if (raux->read_buf[i] == 4) {
++i;
}
else {
break;
}
}
// Check if there other ambiguous bases within min_seed_len bases of the start of the MEM
while ((i < raux->l_seq) && (i - rm.start) < raux->min_seed_len) {
if (raux->read_buf[i] == 4) {
++i;
break;
}
++i;
}
sh.prev_prev_pivot = sh.prev_pivot;
sh.prev_pivot = rm.start;
memset(raux->lep, 0, 5 * sizeof(uint64_t));
break; // zzh
}
#ifdef PRINT_SMEM
ks_introsort(mem_smem_sort_lt_ert, smems->n, smems->a); // Sort SMEMs based on start pos in read. For DEBUG.
for (i = 0; i < smems->n; ++i) {
// printf("[SMEM]:%d,%d\n", smems->a[i].start, smems->a[i].end);
int idx;
for (idx = 0; idx < smems->a[i].hitcount; ++idx) {
if (smems->a[i].forward || smems->a[i].fetch_leaves) {
printf("[SMEM]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, hits->a[smems->a[i].hitbeg + idx]);
}
else {
printf("[SMEM]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, (iaux->bns->l_pac << 1) - hits->a[smems->a[i].hitbeg + idx] - (smems->a[i].end - smems->a[i].start));
}
}
}
#endif
}
/*
* This function performs reseeding of SMEMs
*
* @param iaux index related parameters
* @param raux read related parameters
* @param smems list of SMEMs
* @param start pivot position in read
* @param limit hit threshold below which tree traversal must stop
* @param pt track pivot information to reduce work done during reseeding
* @param hits list of hits for every read
*/
void reseed_prefix(index_aux_t* iaux, read_aux_t* raux, mem_v* smems, int start, int limit, pivot_t* pt, u64v* hits) {
smem_helper_t sh;
memset(&sh, 0, sizeof(smem_helper_t));
sh.prevMemStart = raux->l_seq;
sh.prevMemEnd = 0;
int i = start, j = 0;
#ifdef PRINT_SMEM
int old_n = smems->n;
#endif
memset(raux->lep, 0, 5 * sizeof(uint64_t));
mem_t rm;
memset(&rm, 0, sizeof(mem_t));
rm.start = i;
rm.forward = 1;
rm.hitbeg = hits->n;
sh.prev_pivot = (rm.start >= pt->c_pivot) ? pt->p_pivot : pt->pp_pivot;
raux->read_buf = raux->unpacked_queue_buf;
raux->limit = limit;
rightExtend_wlimit(iaux, raux, &i, &rm, hits); // Compute LEP.
// Lazy expansion of leaf nodes.
if (rm.hitcount > 0 && !rm.skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[rm.hitbeg] + i - rm.start;
int64_t end_ref_pos = hits->a[rm.hitbeg] + raux->l_seq - rm.start;
// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[i+m]) {
numMatchingBP++;
}
else {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
break;
}
}
// Last base of RMEM must have LEP bit set
if (m == len) {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
}
i += numMatchingBP;
}
rm.end = i;
int rmemLen = rm.end - rm.start;
if (rm.start == 0) {
if (rmemLen >= raux->min_seed_len) {
if (rm.hitcount > 0) {
kv_push(mem_t, *smems, rm);
}
}
else {
hits->n -= rm.hitcount;
}
memset(raux->lep, 0, 5 * sizeof(uint64_t));
}
// Begin left-extension, i.e., right extension on reverse complemented read
else {
hits->n -= rm.hitcount;
uint64_t* lep = raux->lep;
int seq_len = raux->l_seq;
int min_seed_len = raux->min_seed_len;
sh.stop_be = 0;
int min_j = (rm.start > min_seed_len) ? (rm.start-1) : (min_seed_len-1);
int max_j = rm.end - 1;
j = min_j;
sh.prev_pivot = rm.start;
sh.mem_end_limit = rm.end;
while (j <= max_j) {
mem_t m;
int be_point;
int mem_valid = init_mem(lep, &m, j, seq_len, min_seed_len);
m.hitbeg = hits->n;
int next_j = j + 1;
if (mem_valid) {
be_point = j + 1;
if (be_point >= min_seed_len) {
int rc_i = seq_len - be_point;
raux->read_buf = raux->unpacked_rc_queue_buf;
leftExtend_wlimit(iaux, raux, &rc_i, &m, hits);
next_j = check_and_add_smem_prefix_reseed(iaux, raux, &m, &sh, smems, hits);
}
}
j = next_j;
}
}
#ifdef PRINT_SMEM
ks_introsort(mem_smem_sort_lt_ert, smems->n - old_n, &smems->a[old_n]); // Debug: Sort SMEMs based on start pos in read.
for (i = old_n; i < smems->n; ++i) {
int idx;
for (idx = 0; idx < smems->a[i].hitcount; ++idx) {
if (smems->a[i].forward || smems->a[i].fetch_leaves) {
printf("[Reseed]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, hits->a[smems->a[i].hitbeg + idx]);
}
else {
printf("[Reseed]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, (iaux->bns->l_pac << 1) - hits->a[smems->a[i].hitbeg + idx] - (smems->a[i].end - smems->a[i].start - smems->a[i].end_correction));
}
}
}
#endif
}
/*
* This function performs reseeding of SMEMs
*
* @param iaux index related parameters
* @param raux read related parameters
* @param smems list of SMEMs and their hits
* @param start pivot position in read
* @param limit hit threshold below which tree traversal must stop
* @param pt track pivot information to reduce work done during reseeding
* @param hits list of hits for read
*/
void reseed(index_aux_t* iaux, read_aux_t* raux, mem_v* smems, int start, int limit, pivot_t* pt, u64v* hits) {
smem_helper_t sh;
memset(&sh, 0, sizeof(smem_helper_t));
sh.prevMemStart = raux->l_seq;
sh.prevMemEnd = 0;
int i = start, j = 0;
#ifdef PRINT_SMEM
int old_n = smems->n;
#endif
memset(raux->lep, 0, 5 * sizeof(uint64_t));
mem_t rm;
memset(&rm, 0, sizeof(mem_t));
rm.start = i;
rm.forward = 1;
rm.hitbeg = hits->n;
sh.prev_pivot = (rm.start >= pt->c_pivot) ? pt->p_pivot : pt->pp_pivot;
raux->read_buf = raux->unpacked_queue_buf;
raux->limit = limit;
rightExtend_wlimit(iaux, raux, &i, &rm, hits); //!< Compute LEP.
// Lazy expansion of leaf nodes.
if (rm.hitcount > 0 && !rm.skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[rm.hitbeg] + i - rm.start;
int64_t end_ref_pos = hits->a[rm.hitbeg] + raux->l_seq - rm.start;
// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m;
int numMatchingBP = 0;
// Check for matching bases
for (m = 0; m < len; ++m) {
if (rseq[m] == raux->unpacked_queue_buf[i+m]) {
numMatchingBP++;
}
else {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
break;
}
}
// Last base of RMEM must have LEP bit set
if (m == len) {
raux->lep[(i+m-1) >> 6] |= (1ULL << ((i+m-1) & (0x3FULL)));
}
i += numMatchingBP;
}
rm.end = i;
int rmemLen = rm.end - rm.start;
if (rm.start == 0) {
if (rmemLen >= raux->min_seed_len) {
if (rm.hitcount > 0) {
kv_push(mem_t, *smems, rm);
}
}
else {
hits->n -= rm.hitcount;
}
memset(raux->lep, 0, 5 * sizeof(uint64_t));
}
// Begin left-extension, i.e., right extension on reverse complemented read
else {
hits->n -= rm.hitcount;
uint64_t* lep = raux->lep;
int seq_len = raux->l_seq;
int min_seed_len = raux->min_seed_len;
j = rm.end-1;
sh.stop_be = 0;
int min_j = (rm.start > min_seed_len) ? (rm.start-1) : (min_seed_len-1);
while (j >= min_j) {
mem_t m;
int be_point;
int mem_valid = init_mem(lep, &m, j, seq_len, min_seed_len);
m.hitbeg = hits->n;
if (mem_valid) {
be_point = j + 1;
if (be_point >= min_seed_len) {
int rc_i = seq_len - be_point;
raux->read_buf = raux->unpacked_rc_queue_buf;
leftExtend_wlimit(iaux, raux, &rc_i, &m, hits);
check_and_add_smem(iaux, raux, &m, &sh, smems, hits);
if (sh.stop_be) break;
}
}
j -= 1;
}
}
#ifdef PRINT_SMEM
ks_introsort(mem_smem_sort_lt_ert, smems->n - old_n, &smems->a[old_n]); // Debug: Sort SMEMs based on start pos in read.
for (i = old_n; i < smems->n; ++i) {
int idx;
for (idx = 0; idx < smems->a[i].hitcount; ++idx) {
if (smems->a[i].forward || smems->a[i].fetch_leaves) {
printf("[Reseed]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, hits->a[smems->a[i].hitbeg + idx]);
}
else {
printf("[Reseed]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, (iaux->bns->l_pac << 1) - hits->a[smems->a[i].hitbeg + idx] - (smems->a[i].end - smems->a[i].start));
}
}
}
#endif
}
/*
* This function performs the LAST heuristic
*
* @param iaux index related parameters
* @param raux read related parameters
* @param smems list of SMEMs
* @param limit hit threshold above which tree traversal must stop
* @param hits list of hits for read
*/
void last(index_aux_t* iaux, read_aux_t* raux, mem_v* smems, int limit, u64v* hits) {
int i = 0;
#ifdef PRINT_SMEM
int old_n = smems->n;
#endif
const uint8_t minSeedLen = raux->min_seed_len + 1; // LAST exits seeding only when seed length >= 20
raux->limit = limit;
while (i < raux->l_seq) { // Begin identifying RMEMs
mem_t rm;
rm.start = i; rm.end = 0;
rm.forward = 1;
rm.skip_ref_fetch = 0;
rm.hitbeg = hits->n;
rm.hitcount = 0;
raux->read_buf = raux->unpacked_queue_buf;
rightExtend_last(iaux, raux, &i, &rm, hits);
// Lazy expansion of leaf nodes.
if (rm.hitcount > 0 && !rm.skip_ref_fetch) {
int64_t len;
int64_t start_ref_pos = hits->a[rm.hitbeg] + i - rm.start;
int64_t end_ref_pos = hits->a[rm.hitbeg] + raux->l_seq - rm.start;
// Fetch reference
uint8_t* rseq = get_seq(iaux->bns->l_pac, iaux->pac, start_ref_pos, end_ref_pos, &len, iaux->ref_string, 0);
int m, numMatchingBP = 0;
// Check for matching bases
for (m = 0; m < len; ++m) {
int seedLen = (i + m) - rm.start;
int match_next_bp = ((seedLen < minSeedLen) || (rm.hitcount >= raux->limit)) ? 1 : 0;
if (match_next_bp) {
if ((rseq[m] == raux->unpacked_queue_buf[i+m])) {
numMatchingBP++;
}
else {
++i; // Increment i on every mismatch for LAST to match BWA-MEM
hits->n -= rm.hitcount;
rm.hitcount = 0;
break;
}
}
else {
break;
}
}
i += numMatchingBP;
}
rm.end = i;
int rmemLen = rm.end - rm.start;
if (rmemLen >= minSeedLen) {
if (rm.hitcount > 0 && rm.hitcount < raux->limit) {
kv_push(mem_t, *smems, rm);
}
else {
hits->n -= rm.hitcount;
}
}
else {
hits->n -= rm.hitcount;
}
int foundN = 0;
// Skip all ambiguous bases
assert(i > 0);
if (raux->read_buf[i-1] == 4) { // Found an 'N' during lookup
foundN = 1;
}
if (!foundN) {
// Check if there other ambiguous bases within min_seed_len bases of the start of the MEM
while ((i < raux->l_seq) && (i - rm.start) < minSeedLen) {
if (raux->read_buf[i] == 4) {
++i;
break;
}
++i;
}
}
}
#ifdef PRINT_SMEM
ks_introsort(mem_smem_sort_lt_ert, smems->n - old_n, &smems->a[old_n]); // Debug: Sort SMEMs based on start pos in read.
for (i = old_n; i < smems->n; ++i) {
int idx;
for (idx = 0; idx < smems->a[i].hitcount; ++idx) {
printf("[LAST]:%d,%d,%lu\n", smems->a[i].start, smems->a[i].end, hits->a[smems->a[i].hitbeg + idx]);
}
}
#endif
}