Optimization for some string operations, such as isascii

Author: ScottPJones

.drone.yml

@@ -11,30 +11,3 @@ steps:
   image: julia:1.5
   commands:
   - "julia --project=. --check-bounds=yes --color=yes -e 'using InteractiveUtils; versioninfo(verbose=true); using Pkg; Pkg.build(); Pkg.test(coverage=true)'"
----
-kind: pipeline
-name: linux - arm64 - Julia 1.0
-
-platform:
-  os: linux
-  arch: arm64
-
-steps:
-- name: build
-  image: julia:1.0
-  commands:
-  - "julia --project=. --check-bounds=yes --color=yes -e 'using InteractiveUtils; versioninfo(verbose=true); using Pkg; Pkg.build(); Pkg.test(coverage=true)'"
-
----
-kind: pipeline
-name: linux - arm - Julia 1.0
-
-platform:
-  os: linux
-  arch: arm
-
-steps:
-- name: build
-  image: julia:1.0
-  commands:
-  - "julia --project=. --check-bounds=yes --color=yes -e 'using InteractiveUtils; versioninfo(verbose=true); using Pkg; Pkg.build(); Pkg.test(coverage=true)'"

Project.toml

@@ -4,7 +4,7 @@ authors  = ["ScottPJones <[email protected]>"]
 keywords = ["Strings"]
 license  = "MIT"
 uuid     = "e79e7a6a-7bb1-5a4d-9d64-da657b06f53a"
-version = "1.0.4"
+version = "1.0.5"
 
 [deps]
 Unicode = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5"
@@ -24,9 +24,9 @@ Random  = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 test = ["Test", "Random"]
 
 [compat]
-julia = "^1.0.0"
-ModuleInterfaceTools = "^1.0.0"
+julia = "1"
+ModuleInterfaceTools = "1"
 MurmurHash3 = "^1.0.3"
-StrAPI = "^1.0.0"
+StrAPI = "1"
 ChrBase = "^1.0.1"
-CharSetEncodings = "^1.0.0"
+CharSetEncodings = "1"

src/latin.jl

@@ -167,7 +167,7 @@ end
 
 function convert(::Type{<:Str{C}}, vec::Vector{CU}) where {C<:Latin_CSEs,CU<:CodeUnitTypes}
     # handle zero length string quickly
-    (len = length(vec)) == 0 && return _empty_str(C)
+    (len = length(vec)) == 0 && return empty_str(C)
     @preserve vec begin
         pnt = pointer(vec)
         # get number of bytes to allocate

src/search.jl

@@ -121,6 +121,10 @@ found(::Type{<:AbstractString}, v) = v != 0
 find_result(::Type{<:AbstractString}, v) = v
 
 nothing_sentinel(i) = first(i) == 0 ? nothing : i
+Base.findfirst(a::AbstractChar, b::Str)   = nothing_sentinel(find(First, a, b))
+Base.findlast(a::AbstractChar, b::Str)    = nothing_sentinel(find(Last, a, b))
+Base.findnext(a::AbstractChar, b::Str, i) = nothing_sentinel(find(Fwd, a, b, i))
+Base.findprev(a::AbstractChar, b::Str, i) = nothing_sentinel(find(Rev, a, b, i))
 Base.findfirst(a, b::Str)   = nothing_sentinel(find(First, a, b))
 Base.findlast(a, b::Str)    = nothing_sentinel(find(Last, a, b))
 Base.findnext(a, b::Str, i) = nothing_sentinel(find(Fwd, a, b, i))

src/types.jl

@@ -30,18 +30,6 @@ _mskdn32(v, m, s) = _msk32(v, m) >>> s
 (::Type{Str})(::Type{C}, v::String) where {C<:CSE} = Str(C, v, nothing, nothing, nothing)
 (::Type{Str})(::Type{C}, v::Str) where {C<:CSE} = Str(C, v.data, nothing, nothing, nothing)
 
-# Handle change from endof -> lastindex
-@static if !isdefined(Base, :lastindex)
-    lastindex(str::AbstractString) = Base.endof(str)
-    lastindex(arr::AbstractArray) = Base.endof(arr)
-    Base.endof(str::Str) = lastindex(str)
-end
-@static if !isdefined(Base, :firstindex)
-    firstindex(str::AbstractString) = 1
-    # AbstractVector might be an OffsetArray
-    firstindex(str::Vector) = 1
-end
-
 # Definition of built-in Str types
 
 const empty_string = ""
@@ -131,8 +119,18 @@ pointer(s::Str{<:Quad_CSEs}) = reinterpret(Ptr{UInt32}, pointer(s.data))
 const CHUNKSZ = sizeof(UInt) # used for fast processing of strings
 const CHUNKMSK = (CHUNKSZ-1)%UInt
 
-_pntchunk(s::Union{String,Vector{UInt8}}) = reinterpret(Ptr{UInt}, pointer(s))
-_pntchunk(s::Str) = reinterpret(Ptr{UInt}, pointer(s.data))
+_pntchunk(p::Union{UInt,Ptr}) = reinterpret(Ptr{UInt}, p)
+_pntchunk(s::Union{String,Vector{UInt8}}) = _pntchunk(pointer(s))
+_pntchunk(s::Str) = _pntchunk(pointer(s.data))
+
+# Type and mask for even faster string handling
+const BigChunk = UInt === UInt32 ? UInt64 : UInt128
+const BIGCHUNKSZ = sizeof(BigChunk)
+const BIGCHUNKMSK = (BIGCHUNKSZ-1)%UInt
+
+_pntbigchunk(p::Union{UInt,Ptr}) = reinterpret(Ptr{BigChunk}, p)
+_pntbigchunk(s::Union{String,Vector{UInt8}}) = _pntbigchunk(pointer(s))
+_pntbigchunk(s::Str) = _pntbigchunk(pointer(s.data))
 
 """Length of string in codeunits"""
 ncodeunits(s::Str)              = sizeof(s)
@@ -144,6 +142,8 @@ ncodeunits(s::Str{<:Quad_CSEs}) = sizeof(s) >>> 2
 
 @inline _mask_bytes(n) = ((1%UInt) << ((n & CHUNKMSK) << 3)) - 0x1
 
+@inline _big_mask_bytes(n) = ((1%BigChunk) << ((n & BIGCHUNKMSK) << 3)) - 0x1
+
 # Support for SubString of Str
 
 Base.SubString(str::Str{C}) where {C<:SubSet_CSEs} =

src/utf8.jl

@@ -1,7 +1,7 @@
 #=
 UTF8Str type
 
-Copyright 2017-2018 Gandalf Software, Inc., Scott P. Jones,
+Copyright 2017-2020 Gandalf Software, Inc., Scott P. Jones,
 and other contributors to the Julia language
 
 Licensed under MIT License, see LICENSE.md
@@ -89,10 +89,19 @@ xor 80 then << 1 then |
 11 -> 01 -> 1
 =#
 
+@inline _widen_mask(msk::UInt) = ((msk%BigChunk) << (8*sizeof(UInt))) | msk
+
 const hi_mask = CHUNKSZ == 4 ? 0x8080_8080 : 0x8080_8080_8080_8080
+const big_hi_mask = _widen_mask(hi_mask)
+
+@inline _count_cont(v, msk) = (v = xor(v, msk); count_ones(xor(((v << 1) | v), msk) & msk))
+@inline msk_lead(v, msk) = (v = xor(v, msk); xor(xor(((v << 1) | v), msk) & msk, msk))
+
+@inline _count_cont(v::UInt) = _count_cont(v, hi_mask)
+@inline msk_lead(v::UInt) = msk_lead(v, hi_mask)
 
-@inline _count_cont(v) = (v = xor(v, hi_mask); count_ones(xor(((v << 1) | v), hi_mask) & hi_mask))
-@inline msk_lead(v) = (v = xor(v, hi_mask); xor(xor(((v << 1) | v), hi_mask) & hi_mask, hi_mask))
+@inline _count_cont(v::BigChunk) = _count_cont(v, big_hi_mask)
+@inline _msk_lead(v::BigChunk) = _msk_lead(v, big_hi_mask)
 
 @inline function _align_len_utf8(pnt, cnt, v)
     len = 0
@@ -141,29 +150,83 @@ end
     _check_mask_al(pnt, cnt, msk, v)
 end
 
+@inline _mask_bytes(v::T, cnt) where {T} =
+    ifelse((cnt & (sizeof(T)-1)%UInt) == 0,
+           v, T(v & (one(T) << ((cnt & (sizeof(T)-1)%UInt) << 3)) - 1))
+
+@inline chk_chunk(ptr, msk::T, cnt) where {T} =
+    iszero(_mask_bytes(unsafe_load(reinterpret(Ptr{T}, ptr)) & msk, cnt))
+
+@inline function _check_block_al(ptr, cnt, msk)
+    # 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 <= CHUNKSZ && return chk_chunk(ptr, msk, cnt)
+    bigmsk = _widen_mask(msk)
+    cnt <= BIGCHUNKSZ && return chk_chunk(ptr, bigmsk, cnt)
+    (unsafe_load(_pntchunk(ptr)) & msk) == 0 || return false
+    cnt -= CHUNKSZ
+    cnt <= BIGCHUNKSZ && return chk_chunk(ptr, bigmsk, cnt)
+    pnt = _pntbigchunk(ptr + CHUNKSZ)
+    fin = _pntbigchunk(ptr + CHUNKSZ + cnt)
+    v = unsafe_load(pnt) & bigmsk
+    while (pnt += BIGCHUNKSZ) < fin
+        v == 0 || return false
+        v = unsafe_load(pnt) & bigmsk
+    end
+    iszero(_mask_bytes(v, cnt))
+end
+
+@inline function _check_block_ul(beg, cnt, msk)
+    align = reinterpret(UInt, beg)
+    pnt = _pntbigchunk(align & ~BIGCHUNKMSK)
+    v = unsafe_load(pnt)
+    if (align &= BIGCHUNKMSK) != 0
+        v &= ~_big_mask_bytes(align)
+        cnt += align
+    end
+    fin = _pntbigchunk(pnt + cnt)
+    bigmsk = _widen_mask(msk)
+    while (pnt += BIGCHUNKSZ) < fin
+        (v & bigmsk) == 0 || return false
+        v = unsafe_load(pnt)
+    end
+    ((cnt & BIGCHUNKMSK) == 0 ? v : (v & _big_mask_bytes(cnt))) & bigmsk == 0
+end
+
 _ascii_mask(::Type{UInt8})  = hi_mask
-_ascii_mask(::Type{UInt16}) = 0xff80_ff80_ff80_ff80
-_ascii_mask(::Type{UInt32}) = 0xffffff80_ffffff80
+@static if UInt == 4
+    _ascii_mask(::Type{UInt16}) = 0xff80_ff80
+    _ascii_mask(::Type{UInt32}) = 0xffffff80
 
-_latin_mask(::Type{UInt16}) = 0xff00_ff00_ff00_ff00
-_latin_mask(::Type{UInt32}) = 0xffffff00_ffffff00
+    _latin_mask(::Type{UInt16}) = 0xff00_ff00
+    _latin_mask(::Type{UInt32}) = 0xffffff00
 
-const _bmp_mask_32   = 0xffff0000_ffff0000
+    const _bmp_mask_32   = 0xffff0000
+else
+    _ascii_mask(::Type{UInt16}) = 0xff80_ff80_ff80_ff80
+    _ascii_mask(::Type{UInt32}) = 0xffffff80_ffffff80
 
-is_ascii(str::SubString{<:Str{C}}) where {C<:Union{UTF8CSE,LatinCSE,Binary_CSEs,UTF16CSE,UCS2CSE,
-                                                   Text2CSE,Text4CSE,UTF32CSE}} =
-    (cnt = sizeof(str)) == 0 ? true :
-    @preserve str _check_mask_ul(pointer(str), cnt, _ascii_mask(codeunit(C)))
+    _latin_mask(::Type{UInt16}) = 0xff00_ff00_ff00_ff00
+    _latin_mask(::Type{UInt32}) = 0xffffff00_ffffff00
+
+    const _bmp_mask_32   = 0xffff0000_ffff0000
+end
+
+const ASCII_Union = Union{UTF8CSE,LatinCSE,Binary_CSEs,UTF16CSE,UCS2CSE,Text2CSE,Text4CSE,UTF32CSE}
+
+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))))
 
 is_ascii(vec::Vector{T}) where {T<:CodeUnitTypes} =
-    (cnt = sizeof(vec)) == 0 ? true :
-    @preserve str _check_mask_ul(pointer(vec), cnt, _ascii_mask(T))
+    (cnt = sizeof(vec)) == 0 ||
+         (@preserve str _check_block_ul(pointer(vec), cnt, _ascii_mask(T)))
 
-is_ascii(str::Str{C}) where {C<:Union{UTF8_CSEs,LatinCSE,Binary_CSEs,UTF16CSE,UCS2CSE,
-                                      Text2CSE,Text4CSE,UTF32CSE}} =
-    (cnt = sizeof(str)) == 0 ? true :
-    @preserve str _check_mask_al(reinterpret(Ptr{UInt}, pointer(str)), cnt,
-                                 _ascii_mask(codeunit(C)))
+is_ascii(str::Str{C}) where {C<:ASCII_Union} =
+    (cnt = sizeof(str)) == 0 ||
+         (@preserve str _check_block_al(pointer(str), cnt, _ascii_mask(codeunit(C))))
 
 # Todo! Here you need to see that 0b11yyyyxx at least 1 y must be set,
 # which indicates a non-Latin1 character