WIP: Finished kernels

Author: jakobnissen

src/counting.jl

@@ -259,12 +259,6 @@ _n_certain(seq::BioSequence) = count_naive(iscertain, seq)
 
 _n_gc(seq::BioSequence) = count_naive(isGC, seq)
 
-const FourBit = SeqOrView{<:NucleicAcidAlphabet{4}}
-const TwoBit = SeqOrView{<:NucleicAcidAlphabet{2}}
-
-const TwoBitSeq = BioSequence{<:NucleicAcidAlphabet{2}}
-const FourBitSeq = BioSequence{<:NucleicAcidAlphabet{4}}
-
 # Trivial overloads
 _n_certain(s::TwoBitSeq) = length(s)
 _n_ambiguous(s::TwoBitSeq) = 0

src/longsequences/find.jl

@@ -1,52 +1,91 @@
-# * iscertain + !iscertain
-#   Four bit: Certain bitcount OR enumerate_nibbles & 0x1111111 + tz
-#   AA: 0x00-0x15 or 0x1a
-#
-
-# * isambiguous + !isambiguous
-#   Four bit: Ambiguous bitcount OR enumerate_nibbles & 0xEEE.. + tz
-#   AA: 0x16-0x19
-
-# Make 0 for any other bitpattern than 0x1, 0x2, 0x4, 0x8.
-
 # Zeros out all nibbles except the ones with 4bit A,C,G or T
-function iscertain_kernel(x::UInt64)
+function iscertain_kernel(::NucleicAcidAlphabet{4}, x::UInt64)
     x = enumerate_nibbles(x)
-    y =  (x & 0x4444444444444444) >> 2
+    y = (x & 0x4444444444444444) >> 2
     y |= (x & 0x2222222222222222) >> 1
-    x & ~y & 0x1111111111111111
+    return x & ~y & 0x1111111111111111
 end
 
-# Zeros out all which is not a certain AA
-# TODO: This is not efficient.
-function iscertain_aa_kernel(x::UInt64)
-    y = reinterpret(NTuple{8, UInt8}, x)
-    y = map(i -> ((i < 0x16) | (i == 0x1a)), y)
-    reinterpret(UInt64, y)
+# Zeros out all which is not a certain (normal or AA_Term)
+function iscertain_kernel(::AminoAcidAlphabet, x::UInt64)
+    # 1. Set normal to FF, others to 00
+    y = simd_lt_byte(x, 0x16)
+
+    # 2. Set Term to FF, others to 00
+    z = set_zero_encoding(BitsPerSymbol{8}(), x ⊻ 0x1a1a1a1a1a1a1a1a) * 0xFF
+
+    # 3: OR them
+    return y | z
 end
 
+@inline function simd_lt_byte(x::UInt64, byte::UInt8)
+    T = NTuple{8, VecElement{UInt8}}
+    x = reinterpret(T, x)
+    y = ntuple(i -> VecElement(byte), Val{8}())
+    s = """
+    %res = icmp ult <8 x i8> %0, %1
+    %resb = sext <8 x i1> %res to <8 x i8>
+    ret <8 x i8> %resb
+    """
+    z = Core.Intrinsics.llvmcall(s, NTuple{8, VecElement{UInt8}}, Tuple{NTuple{8, VecElement{UInt8}}, NTuple{8, VecElement{UInt8}}}, x, y)
+    reinterpret(UInt64, z)
+end
+
+@inline function sub_byte(x::UInt64, byte::UInt8)
+    T = NTuple{8, VecElement{UInt8}}
+    x = reinterpret(T, x)
+    y = ntuple(i -> VecElement(byte), Val{8}())
+    s = """
+    %res = sub <8 x i8> %0, %1
+    ret <8 x i8> %res
+    """
+    z = Core.Intrinsics.llvmcall(s, NTuple{8, VecElement{UInt8}}, Tuple{NTuple{8, VecElement{UInt8}}, NTuple{8, VecElement{UInt8}}}, x, y)
+    reinterpret(UInt64, z)
+end
 
 # Zeros out all nibbles encoding 4bit A,C,G or T
-uncertain_kernel(x::UInt64) = enumerate_nibbles(x) ⊻ 0x1111111111111111
+uncertain_kernel(::NucleicAcidAlphabet{4}, x::UInt64) = enumerate_nibbles(x) ⊻ 0x1111111111111111
+
+# Zero out normal AAs and AA_Term
+function uncertain_kernel(::AminoAcidAlphabet, x::UInt64)
+    # Zero out normal AA, set rest to 0xFF
+    y = ~simd_lt_byte(x, 0x16)
+
+    # Zero out 0x1a, set rest to other bitpatterns
+    z = x ⊻ 0x1a1a1a1a1a1a1a1a
+
+    return y & z
+end
 
 # Zeros out A, C, G, T or Gap
-function ambiguous_kernel(x::UInt64)
+function ambiguous_kernel(A::NucleicAcidAlphabet{4}, x::UInt64)
     # The y part makes every nibble 0xF, unless it's 0 to begin with
     y = x | (x >>> 2)
     y |= y >>> 1
     y &= 0x1111111111111111
-    y *= 0xF
-    uncertain_kernel(x) & y
+    y *= 0x0F
+    return uncertain_kernel(A, x) & y
+end
+
+# Zero out all except ambiguous symbols (AA_B, AA_J, AA_Z, AA_X), 0x16:0x19
+function ambiguous_kernel(::AminoAcidAlphabet, x::UInt64)
+    return simd_lt_byte(sub_byte(x, 0x16), 0x04)
 end
 
 # Zeros out all except A, C, G, T and Gap
-function unambiguous_kernel(x::UInt64)
+function unambiguous_kernel(::NucleicAcidAlphabet{4}, x::UInt64)
     y = enumerate_nibbles(x)
     y = (y >>> 1) | (y >>> 2)
     y &= 0x1111111111111111
-    y ⊻= 0x1111111111111111
+    return y ⊻= 0x1111111111111111
+end
+
+# Zero out the four ambiguous amino acids B, J, Z, X
+function unambiguous_kernel(::AminoAcidAlphabet, x::UInt64)
+    return ~simd_lt_byte(sub_byte(x, 0x16), 0x04)
 end
 
+
 # For debug
 #=
 function make_all_nibbles()
@@ -56,4 +95,4 @@ function make_all_nibbles()
     end
     x
 end
-=#
+=#