Optimizations of UTF-16 length, is_bmp

Author: ScottPJones

Project.toml

@@ -27,6 +27,6 @@ test = ["Test", "Random"]
 julia = "1"
 ModuleInterfaceTools = "1"
 MurmurHash3 = "^1.0.3"
-StrAPI = "1"
+StrAPI = "1.1"
 ChrBase = "^1.0.1"
 CharSetEncodings = "1"

src/compare.jl

@@ -54,7 +54,7 @@ end
     while pnt < fin
         str_done(b, pos) && return 1
         c1, pnt = _nextcp(C, pnt)
-        ch, pos = str_next(b, pos)
+        ch, pos = iterate(b, pos)
         c2 = ch%UInt32
         c1 == c2 || return ifelse(c1 < c2, -1, 1)
     end
@@ -93,7 +93,7 @@ function _cpeq(a::MaybeSub{T}, b) where {C<:CSE, T<:Str{C}}
     while pnt < fin
         str_done(b, pos) && return false
         c1, pnt = _nextcp(C, pnt)
-        ch, pos = str_next(b, pos)
+        ch, pos = iterate(b, pos)
         c1 == codepoint(ch) || return false
     end
     true

src/core.jl

@@ -2,7 +2,7 @@
 Core functions
 
 
-Copyright 2017-2018 Gandalf Software, Inc., Scott P. Jones, and others (see Julia contributors)
+Copyright 2017-2020 Gandalf Software, Inc., Scott P. Jones, and others (see Julia contributors)
 Licensed under MIT License, see LICENSE.md
 
 Inspired by / derived from code in Julia
@@ -33,7 +33,7 @@ _nextcp(::Type{T}, pnt) where {T} = _nextcpfun(EncodingStyle(T), T, pnt)
 
 # Use more generic length check
 @inline _length_check(str::SubString{<:Str{C}}, cnt) where {C<:CSE} =
-    _length(MultiCU(), C, pointer(str), cnt)
+    @preserve str _length_ul(MultiCU(), C, pointer(str), cnt)
 
 # Go directly to aligned length check
 @inline _length_check(str::Str{C}, cnt) where {C<:CSE} =
@@ -42,7 +42,7 @@ _nextcp(::Type{T}, pnt) where {T} = _nextcpfun(EncodingStyle(T), T, pnt)
 @inline _length(::MultiCU, str::MaybeSub{T}) where {T<:Str} =
     (cnt = ncodeunits(str); cnt < 2 ? Int(cnt > 0) : @preserve str _length_check(str, cnt))
 
-@inline _length(::SingleCU, ::Type{<:CSE}, ::Ptr{<:CodeUnitTypes}, cnt::Int) = cnt
+@inline _length_ul(::SingleCU, ::Type{<:CSE}, ::Ptr{<:CodeUnitTypes}, cnt::Int) = cnt
 
 @inline _length(::MultiCU, str::Str{RawUTF8CSE}) = length(str.data)
 @inline _length(::MultiCU, str::Str{RawUTF8CSE}, i::Int, j::Int) = length(str.data, i, j)
@@ -55,7 +55,7 @@ _nextcp(::Type{T}, pnt) where {T} = _nextcpfun(EncodingStyle(T), T, pnt)
         0 <= j <  lim || boundserr(str, j)
     end
     (cnt = j - i + 1) <= 0 ? 0 :
-        @preserve str _length(cs, cse(str), bytoff(pointer(str), i - 1), cnt)
+        @preserve str _length_ul(cs, cse(str), bytoff(pointer(str), i - 1), cnt)
 end
 
 @inline _thisind(::SingleCU, str, len, pnt, pos) = Int(pos)

src/search.jl

@@ -193,7 +193,7 @@ function find(::Type{D}, needle::AbstractString, str::AbstractString,
     @inbounds is_valid(str, pos) || index_error(str, pos)
     (tlen = ncodeunits(needle)) == 0 && return pos:pos-1
     (cmp = CanContain(str, needle)) === NoCompare() && return _not_found
-    @inbounds ch, nxt = str_next(needle, 1)
+    @inbounds ch, nxt = iterate(needle, 1)
     is_valid(eltype(str), ch) || return _not_found
     # Check if single character
     if nxt > tlen
@@ -209,7 +209,7 @@ function find(::Type{T}, needle::AbstractString, str::AbstractString) where {T<:
     pos = T === First ? 1 : thisind(str, slen)
     (tlen = ncodeunits(needle)) == 0 && return pos:(pos-1)
     (cmp = CanContain(str, needle)) === NoCompare() && return _not_found
-    @inbounds ch, nxt = str_next(needle, 1)
+    @inbounds ch, nxt = iterate(needle, 1)
     is_valid(eltype(str), ch) || return _not_found
     # Check if single character
     if nxt > tlen
@@ -302,8 +302,8 @@ end
 """Compare two strings, starting at nxtstr and nxtsub"""
 @inline function _cmp_str(str, strpos, endpos, sub, subpos, endsub)
     while strpos <= endpos
-        c, strnxt = str_next(str, strpos)
-        d, subpos = str_next(sub, subpos)
+        c, strnxt = iterate(str, strpos)
+        d, subpos = iterate(sub, subpos)
         c == d || break
         subpos > endsub && return strpos
         strpos = strnxt

src/support.jl

@@ -264,7 +264,7 @@ function unsafe_check_string(str::T;
     totalchar = latin1byte = num2byte = num3byte = num4byte = invalids = 0
     pos = 1
     @inbounds while !str_done(str, pos)
-        chr, nxt = str_next(str, pos)
+        chr, nxt = iterate(str, pos)
         ch = chr%UInt32
         totalchar += 1
         if ch > 0x7f
@@ -288,7 +288,7 @@ function unsafe_check_string(str::T;
                     break
                 end
                 # next character *must* be a trailing surrogate character
-                chr, nxt = str_next(str, nxt)
+                chr, nxt = iterate(str, nxt)
                 if !is_surrogate_trail(chr)
                     accept_invalids || strerror(StrErrors.NOT_TRAIL, pos, chr)
                     invalids += 1

src/types.jl

@@ -145,7 +145,7 @@ ncodeunits(s::Str{<:Quad_CSEs}) = sizeof(s) >>> 2
 @inline _big_mask_bytes(n) = ((1%BigChunk) << ((n & BIGCHUNKMSK) << 3)) - 0x1
 
 @inline function _mask_bytes(v::T, cnt) where {T}
-    shft = (cnt & (sizeof(T) - 1))%UInt << 3
+    shft = ((cnt & (sizeof(T) - 1))%UInt) << 3
     ifelse(shft == 0, v, v & ~(typemax(T) << shft))
 end
 

src/utf16.jl

@@ -10,34 +10,59 @@ Based in (small) part on code for UTF16String that used to be in Julia
 const _trail_mask = CHUNKSZ == 4 ? 0xdc00_dc00 : 0xdc00_dc00_dc00_dc00
 const _hi_bit_16  = CHUNKSZ == 4 ? 0x8000_8000 : 0x8000_8000_8000_8000
 
-@inline _mask_surr(v)  = xor((v | v<<1 | v<<2 | v<<3 | v<<4 | v<<5) & _hi_bit_16, _hi_bit_16)
-@inline _get_masked(v::UInt) = _mask_surr(xor(v, _trail_mask))
-@inline _get_masked(qpnt::Ptr{UInt}) = _get_masked(unsafe_load(qpnt))
-@inline _get_lead(qpnt) = xor(_get_masked(qpnt), _hi_bit_16)
+const _big_trail_mask = _widen_mask(_trail_mask)
+const _big_hi_bit_16  = _widen_mask(_big_hi_bit_16)
 
-@inline function _align_len_utf16(pnt, cnt, v)
-    len = 0
+@inline _mask_surr(v, msk)  = xor((v | v<<1 | v<<2 | v<<3 | v<<4 | v<<5) & msk, msk)
+
+@inline _get_masked(v::UInt) = _mask_surr(xor(v, _trail_mask))
+@inline _get_masked(v::BigChunk) = _mask_surr(xor(v, _big_trail_mask))
+@inline _get_masked(qpnt::Ptr) = _get_masked(unsafe_load(qpnt))
+
+@inline _get_lead(qpnt::Ptr{UInt}) = xor(_get_masked(qpnt), _hi_bit_16)
+@inline _get_lead(qpnt::Ptr{BigChunk}) = xor(_get_masked(qpnt), _big_hi_bit_16)
+
+@inline function _length_al(::MultiCU, ::Type{UTF16CSE}, beg::Ptr{UInt16}, cnt::Int)
+    # First check very frequent cases of short strings
+    # (on 64-bit machines, 1-8 bytes, 9-16 bytes, and 17-24)
+    # taking advantage of the knowledge of how String types are stored in Julia,
+    # i.e. UInt length, immediate followed by the string data, aligned on sizeof(UInt)*2
+    cnt <<= 1
+    if cnt <= BIGCHUNKSZ
+        return (cnt <= CHUNKSZ
+                ? count_ones(_mask_bytes(_get_lead(_pntchunk(beg), cnt))
+                : count_ones(_mask_bytes(_get_lead(_pntbigchunk(beg), cnt))
+    end
+    len = count_ones(_get_lead(_pntchunk(beg)))
+    cnt -= CHUNKSZ
+    pnt = _pntbigchunk(beg + CHUNKSZ)
+    v = _get_lead(pnt)
+    cnt <= BIGCHUNKSZ && return len + count_ones(_mask_bytes(v, cnt))
     fin = pnt + cnt
-    while (pnt += CHUNKSZ) < fin
+    while (pnt += BIGCHUNKSZ) < fin
         len += count_ones(v)
         v = _get_lead(pnt)
     end
     len + count_ones(_mask_bytes(v, cnt))
 end
 
-_length_al(::MultiCU, ::Type{UTF16CSE}, beg::Ptr{UInt16}, cnt::Int) =
-    (pnt = reinterpret(Ptr{UInt}, beg); _align_len_utf16(pnt, cnt<<1, _get_lead(pnt)))
-
-function _length(::MultiCU, ::Type{UTF16CSE}, beg::Ptr{UInt16}, cnt::Int)
+function _length_ul(::MultiCU, ::Type{UTF16CSE}, beg::Ptr{UInt16}, cnt::Int)
     align = reinterpret(UInt, beg)
-    pnt = reinterpret(Ptr{UInt}, align & ~CHUNKMSK)
+    pnt = reinterpret(Ptr{BigChunk}, align & ~BIGCHUNKMSK)
+    cnt <<= 1
     v = _get_lead(pnt)
-    if (align &= CHUNKMSK) != 0
-        msk = _mask_bytes(align)
-        v = (v & ~msk) | (msk & _trail_mask)
-        cnt += (align>>>1)
+    if (align &= BIGCHUNKMSK) != 0
+        msk = _big_mask_bytes(align)
+        v = (v & ~msk) | (msk & _big_trail_mask)
+        cnt += align
     end
-    _align_len_utf16(pnt, cnt<<1, v)
+    len = 0
+    fin = pnt + cnt
+    while (pnt += BIGCHUNKSZ) < fin
+        len += count_ones(v)
+        v = _get_lead(pnt)
+    end
+    len + count_ones(_mask_bytes(v, cnt))
 end
 
 function _nextind(::MultiCU, str::MS_UTF16, pos::Int, nchar::Int)
@@ -93,31 +118,41 @@ function is_bmp(str::MS_UTF16)
     end
 end
 
-@inline function _check_bmp_utf16_al(pnt, cnt, v)
+@inline function _check_bmp_utf16_al(beg, cnt)
+    cnt <= CHUNKSZ && return _mask_bytes(_get_masked(_pntchunk(beg)), cnt) == 0
+    cnt <= BIGCHUNKSZ && return _mask_bytes(_get_masked(_pntbigchunk(beg)), cnt) == 0
+    _get_masked(_pntchunk(beg)) == 0 || return false
+    cnt -= CHUNKSZ
+    cnt <= BIGCHUNKSZ && return _mask_bytes(_get_masked(_pntbigchunk(beg)), cnt) == 0
+    pnt = _pntbigchunk(beg + CHUNKSZ)
+    v = _get_masked(pnt)
     fin = pnt + cnt
-    v = _get_masked(v)
-    while (pnt += CHUNKSZ) < fin
+    while (pnt += BIGCHUNKSZ) < fin
         v == 0 || return false
         v = _get_masked(pnt)
     end
     _mask_bytes(v, cnt) == 0
 end
-@inline _check_bmp_utf16_al(pnt, cnt) = _check_bmp_utf16_al(pnt, cnt, unsafe_load(pnt))
 
 @inline function _check_bmp_utf16_ul(beg, cnt)
     align = reinterpret(UInt, beg)
-    pnt = reinterpret(Ptr{UInt}, align & ~CHUNKMSK)
+    pnt = reinterpret(Ptr{BigChunk}, align & ~BIGCHUNKMSK)
     v = unsafe_load(pnt)
-    if (align &= CHUNKMSK) != 0
-        v &= ~_mask_bytes(align)
+    if (align &= BIGCHUNKMSK) != 0
+        v &= ~_big_mask_bytes(align)
         cnt += align
     end
-    _check_bmp_utf16_al(pnt, cnt, v)
+    v = _get_masked(v)
+    fin = pnt + cnt
+    while (pnt += BIGCHUNKSZ) < fin
+        v == 0 || return false
+        v = _get_masked(pnt)
+    end
+    _mask_bytes(v, cnt) == 0
 end
 
 is_bmp(str::Str{UTF16CSE}) =
-    (cnt = sizeof(str)) == 0 ||
-    @preserve str _check_bmp_utf16_al(reinterpret(Ptr{UInt}, pointer(str)), cnt)
+    (cnt = sizeof(str)) == 0 || @preserve str _check_bmp_utf16_al(pointer(str), cnt)
 
 is_bmp(str::SubString{<:Str{UTF16CSE}}) =
     (cnt = sizeof(str)) == 0 || @preserve str _check_bmp_utf16_ul(pointer(str), cnt)

src/utf8.jl

@@ -209,11 +209,11 @@ const ASCII_Union = Union{UTF8CSE,LatinCSE,Binary_CSEs,UTF16CSE,UCS2CSE,Text2CSE
 
 is_ascii(str::SubString{<:Str{C}}) where {C<:ASCII_Union} =
     (cnt = sizeof(str)) == 0 ||
-        (@preserve str _check_block_ul(pointer(str), cnt, _ascii_mask(codeunit(C))))
+        (@preserve str _check_mask_ul(pointer(str), cnt, _ascii_mask(codeunit(C))))
 
 is_ascii(vec::Vector{T}) where {T<:CodeUnitTypes} =
     (cnt = sizeof(vec)) == 0 ||
-         (@preserve str _check_block_ul(pointer(vec), cnt, _ascii_mask(T)))
+         (@preserve str _check_mask_ul(pointer(vec), cnt, _ascii_mask(T)))
 
 is_ascii(str::Str{C}) where {C<:ASCII_Union} =
     (cnt = sizeof(str)) == 0 ||
@@ -225,10 +225,16 @@ _all_latin(val) =
     ((val & (val<<1) & (val<<2 | (val<<3) | (val<<4) | (val<<5))) & get_high_mask(val)) == 0
 
 @inline function _check_latin_utf8_al(beg, cnt)
-    pnt = reinterpret(Ptr{UInt}, beg)
-    fin = pnt + cnt
+    cnt <= CHUNKSZ && return _all_latin(_mask_bytes(unsafe_load(_pntchunk(ptr)), cnt))
+    bigmsk = _widen_mask(msk)
+    cnt <= BIGCHUNKSZ && return _all_latin(_mask_bytes(unsafe_load(_pntbigchunk(ptr)), cnt))
+    _all_latin(unsafe_load(_pntchunk(ptr))) || return false
+    cnt -= CHUNKSZ
+    cnt <= BIGCHUNKSZ && return  _all_latin(_mask_bytes(unsafe_load(_pntbigchunk(ptr)), cnt))
+    pnt = _pntbigchunk(ptr + CHUNKSZ)
     v = unsafe_load(pnt)
-    while (pnt += CHUNKSZ) < fin
+    fin = pnt + cnt
+    while (pnt += BIGCHUNKSZ) < fin
         _all_latin(v) || return false
         v = unsafe_load(pnt)
     end
@@ -273,10 +279,16 @@ is_latin(str::Str{C}) where {C<:Union{Word_CSEs,Quad_CSEs}} =
 _all_bmp(val) = ((val | (val<<1) | (val<<2) | (val<<3)) & get_high_mask(val)) == 0
 
 @inline function _check_bmp_utf8_al(beg, cnt)
-    pnt = reinterpret(Ptr{UInt}, beg)
-    fin = pnt + cnt
+    cnt <= CHUNKSZ && return _all_bmp(_mask_bytes(unsafe_load(_pntchunk(ptr)), cnt))
+    bigmsk = _widen_mask(msk)
+    cnt <= BIGCHUNKSZ && return _all_bmp(_mask_bytes(unsafe_load(_pntbigchunk(ptr)), cnt))
+    _all_bmp(unsafe_load(_pntchunk(ptr))) || return false
+    cnt -= CHUNKSZ
+    cnt <= BIGCHUNKSZ && return  _all_bmp(_mask_bytes(unsafe_load(_pntbigchunk(ptr)), cnt))
+    pnt = _pntbigchunk(ptr + CHUNKSZ)
+    fin = _pntbigchunk(ptr + CHUNKSZ + cnt)
     v = unsafe_load(pnt)
-    while (pnt += CHUNKSZ) < fin
+    while (pnt += BIGCHUNKSZ) < fin
         _all_bmp(v) || return false
         v = unsafe_load(pnt)
     end
@@ -452,9 +464,9 @@ _iterate(::MultiCU, ::Type{T}, str::SubString{<:Str{RawUTF8CSE}}, pos::Int) wher
 end
 
 _next(::MultiCU, ::Type{T}, str::Str{RawUTF8CSE}, pos::Int) where {T} =
-    str_next(str.data, pos)
+    iterate(str.data, pos)
 _next(::MultiCU, ::Type{T}, str::SubString{<:Str{RawUTF8CSE}}, pos::Int) where {T} =
-    str_next(SubString(str.string.data, str.offset + pos, str.offset + ncodeunits(str)), 1)
+    iterate(SubString(str.string.data, str.offset + pos, str.offset + ncodeunits(str)), 1)
 
 ## overload methods for efficiency ##
 

test/basic.jl

@@ -292,8 +292,8 @@ let
 
     @test lastindex(srep) == 7
 
-    @test str_next(srep, 3) == ('β',5)
-    @test str_next(srep, 7) == ('β',9)
+    @test iterate(srep, 3) == ('β',5)
+    @test iterate(srep, 7) == ('β',9)
 
     @test srep[7] == 'β'
     @test_throws StringIndexError srep[8]
@@ -327,8 +327,8 @@ end
     @test_throws MethodError codeunit(tstr, true)
     @test_throws MethodError isvalid(tstr, 1)
     @test_throws MethodError isvalid(tstr, true)
-    @test_throws MethodError str_next(tstr, 1)
-    @test_throws MethodError str_next(tstr, true)
+    @test_throws MethodError iterate(tstr, 1)
+    @test_throws MethodError iterate(tstr, true)
     @test_throws MethodError lastindex(tstr)
 
     gstr = GenericString("12")
@@ -598,7 +598,7 @@ end
     for st in ("Hello", "Σ", "こんにちは", "😊😁")
         local s
         s = ST(st)
-        @test str_next(s, lastindex(s))[2] > sizeof(s)
+        @test iterate(s, lastindex(s))[2] > sizeof(s)
         @test nextind(s, lastindex(s)) > sizeof(s)
     end
 end
@@ -902,7 +902,7 @@ function testbin(::Type{ST}) where {ST}
                  b"\xf8\x9f\x98\x84", b"\xf8\x9f\x98\x84z")),
         s in lst
         st = ST(s)
-        @test str_next(st, 1)[2] == 2
+        @test iterate(st, 1)[2] == 2
         @test nextind(st, 1) == 2
     end
 
@@ -917,7 +917,7 @@ function testbin(::Type{ST}) where {ST}
         (s, r) in lst
         st = ST(s)
         (ST === BinaryStr || ST === Text1Str) && (r = 2)
-        @test str_next(st, 1)[2] == r
+        @test iterate(st, 1)[2] == r
         @test nextind(st, 1) == r
     end
 end
@@ -937,12 +937,7 @@ end
     @test String(sym) == string(Char(0xdcdb))
     @test Meta.lower(Main, sym) === sym
     res = string(Meta.parse(string(Char(0xdcdb)," = 1"),1,raise=false)[1])
-    @static if VERSION ≥ v"1.5.0-DEV.460"
-        @test res == "\$(Expr(:error, \"invalid UTF-8 sequence\"))"
-    else
-        @test startswith(res, "\$(Expr(:error, \"invalid character \\\"\\udcdb\\\"")
-        @test endswith(res,   "\"))")
-    end
+    @test res == "\$(Expr(:error, \"invalid UTF-8 sequence\"))"
 end
 
 @testset "invalid code point" begin