lazily allocate the threaded buffers and allocate them on the thread that will access it

Author: KristofferC

src/CookieRequest.jl

@@ -5,12 +5,12 @@ import ..Layer, ..request
 using URIs
 using ..Cookies
 using ..Pairs: getkv, setkv
-import ..@debug, ..DEBUG_LEVEL
+import ..@debug, ..DEBUG_LEVEL, ..access_threaded
 
-const default_cookiejar = [Dict{String, Set{Cookie}}()]
+const default_cookiejar = Dict{String, Set{Cookie}}[]
 
 function __init__()
-    Threads.resize_nthreads!(default_cookiejar)
+    resize!(empty!(default_cookiejar), Threads.nthreads())
     return
 end
 
@@ -26,7 +26,7 @@ export CookieLayer
 function request(::Type{CookieLayer{Next}},
                  method::String, url::URI, headers, body;
                  cookies::Union{Bool, Dict{<:AbstractString, <:AbstractString}}=Dict{String, String}(),
-                 cookiejar::Dict{String, Set{Cookie}}=default_cookiejar[Threads.threadid()],
+                 cookiejar::Dict{String, Set{Cookie}}=access_threaded(Dict{String, Set{Cookie}}, default_cookiejar),
                  kw...) where {Next}
 
     hostcookies = get!(cookiejar, url.host, Set{Cookie}())

src/HTTP.jl

@@ -12,6 +12,19 @@ Base.@deprecate escape escapeuri
 using Base64, Sockets, Dates
 using URIs
 
+function access_threaded(f, v::Vector)
+    tid = Threads.threadid()
+    0 < tid <= length(v) || _length_assert()
+    if @inbounds isassigned(v, tid)
+        @inbounds x = v[tid]
+    else
+        x = f()
+        @inbounds v[tid] = x
+    end
+    return x
+end
+@noinline _length_assert() =  @assert false "0 < tid <= v"
+
 include("debug.jl")
 
 include("Pairs.jl")                    ;using .Pairs

src/Parsers.jl

@@ -17,6 +17,8 @@ have field names compatible with those expected by the `parse_status_line!` and
 """
 module Parsers
 
+import ..access_threaded
+
 export Header, Headers,
        find_end_of_header, find_end_of_chunk_size, find_end_of_trailer,
        parse_status_line!, parse_request_line!, parse_header_field,
@@ -49,17 +51,24 @@ ParseError(code::Symbol, bytes="") =
 
 # Regular expressions for parsing HTTP start-line and header-fields
 
+init!(r::RegexAndMatchData) = (Base.compile(r.re); initialize!(r); r)
+
 """
 https://tools.ietf.org/html/rfc7230#section-3.1.1
 request-line = method SP request-target SP HTTP-version CRLF
 """
-const request_line_regex = [RegexAndMatchData(r"""^
+const request_line_regex = RegexAndMatchData[]
+function request_line_regex_f()
+    r = RegexAndMatchData(r"""^
     (?: \r? \n) ?                       #    ignore leading blank line
     ([!#$%&'*+\-.^_`|~[:alnum:]]+) [ ]+ # 1. method = token (RFC7230 3.2.6)
     ([^.][^ \r\n]*) [ ]+                # 2. target
     HTTP/(\d\.\d)                       # 3. version
     \r? \n                              #    CRLF
-"""x)]
+    """x)
+    init!(r)
+end
+
 
 """
 https://tools.ietf.org/html/rfc7230#section-3.1.2
@@ -68,40 +77,58 @@ status-line = HTTP-version SP status-code SP reason-phrase CRLF
 See:
 [#190](https://github.com/JuliaWeb/HTTP.jl/issues/190#issuecomment-363314009)
 """
-const status_line_regex = [RegexAndMatchData(r"""^
+const status_line_regex = RegexAndMatchData[]
+function status_line_regex_f()
+    r = RegexAndMatchData(r"""^
     [ ]?                                # Issue #190
     HTTP/(\d\.\d) [ ]+                  # 1. version
     (\d\d\d) .*                         # 2. status
     \r? \n                              #    CRLF
-"""x)]
+    """x)
+    init!(r)
+end
 
 """
 https://tools.ietf.org/html/rfc7230#section-3.2
 header-field = field-name ":" OWS field-value OWS
 """
-const header_field_regex = [RegexAndMatchData(r"""^
+const header_field_regex = RegexAndMatchData[]
+function header_field_regex_f()
+    r = RegexAndMatchData(r"""^
     ([!#$%&'*+\-.^_`|~[:alnum:]]+) :    # 1. field-name = token (RFC7230 3.2.6)
     [ \t]*                              #    OWS
     ([^\r\n]*?)                         # 2. field-value
     [ \t]*                              #    OWS
     \r? \n                              #    CRLF
     (?= [^ \t])                         #    no WS on next line
-"""x)]
+    """x)
+    init!(r)
+end
+
 
 """
 https://tools.ietf.org/html/rfc7230#section-3.2.4
 obs-fold = CRLF 1*( SP / HTAB )
 """
-const obs_fold_header_field_regex = [RegexAndMatchData(r"""^
+const obs_fold_header_field_regex = RegexAndMatchData[]
+function obs_fold_header_field_regex_f()
+    r = RegexAndMatchData(r"""^
     ([!#$%&'*+\-.^_`|~[:alnum:]]+) :    # 1. field-name = token (RFC7230 3.2.6)
     [ \t]*                              #    OWS
     ([^\r\n]*                           # 2. field-value
         (?: \r? \n [ \t] [^\r\n]*)*)    #    obs-fold
     [ \t]*                              #    OWS
     \r? \n                              #    CRLF
-"""x)]
+    """x)
+    init!(r)
+end
+
+const empty_header_field_regex = RegexAndMatchData[]
+function empty_header_field_regex_f()
+    r = RegexAndMatchData(r"^ \r? \n"x)
+    init!(r)
+end
 
-const empty_header_field_regex = [RegexAndMatchData(r"^ \r? \n"x)]
 
 # HTTP start-line and header-field parsing
 
@@ -157,7 +184,7 @@ Parse HTTP request-line `bytes` and set the
 Return a `SubString` containing the header-field lines.
 """
 function parse_request_line!(bytes::AbstractString, request)::SubString{String}
-    re = request_line_regex[Threads.threadid()]
+    re = access_threaded(request_line_regex_f, request_line_regex)
     if !exec(re, bytes)
         throw(ParseError(:INVALID_REQUEST_LINE, bytes))
     end
@@ -173,7 +200,7 @@ Parse HTTP response-line `bytes` and set the
 Return a `SubString` containing the header-field lines.
 """
 function parse_status_line!(bytes::AbstractString, response)::SubString{String}
-    re = status_line_regex[Threads.threadid()]
+    re = access_threaded(status_line_regex_f, status_line_regex)
     if !exec(re, bytes)
         throw(ParseError(:INVALID_STATUS_LINE, bytes))
     end
@@ -189,20 +216,20 @@ a `SubString` containing the remaining header-field lines.
 """
 function parse_header_field(bytes::SubString{String})::Tuple{Header,SubString{String}}
     # First look for: field-name ":" field-value
-    re = header_field_regex[Threads.threadid()]
+    re = access_threaded(header_field_regex_f, header_field_regex)
     if exec(re, bytes)
         return (group(1, re, bytes) => group(2, re, bytes)),
                 nextbytes(re, bytes)
     end
 
     # Then check for empty termination line:
-    re = empty_header_field_regex[Threads.threadid()]
+    re = access_threaded(empty_header_field_regex_f, empty_header_field_regex)
     if exec(re, bytes)
         return emptyheader, nextbytes(re, bytes)
     end
 
     # Finally look for obsolete line folding format:
-    re = obs_fold_header_field_regex[Threads.threadid()]
+    re = access_threaded(obs_fold_header_field_regex_f, obs_fold_header_field_regex)
     if exec(re, bytes)
         unfold = SubString(replace(group(2, re, bytes), r"\r?\n"=>""))
         return (group(1, re, bytes) => unfold), nextbytes(re, bytes)
@@ -312,21 +339,11 @@ const unhex = Int8[
 function __init__()
     # FIXME Consider turing off `PCRE.UTF` in `Regex.compile_options`
     # https://github.com/JuliaLang/julia/pull/26731#issuecomment-380676770
-    Threads.resize_nthreads!(status_line_regex)
-    Threads.resize_nthreads!(request_line_regex)
-    Threads.resize_nthreads!(header_field_regex)
-    Threads.resize_nthreads!(obs_fold_header_field_regex)
-    Threads.resize_nthreads!(empty_header_field_regex)
-    foreach(x -> Base.compile(x.re), status_line_regex)
-    foreach(x -> Base.compile(x.re), request_line_regex)
-    foreach(x -> Base.compile(x.re), header_field_regex)
-    foreach(x -> Base.compile(x.re), empty_header_field_regex)
-    foreach(x -> Base.compile(x.re), obs_fold_header_field_regex)
-    foreach(initialize!, status_line_regex)
-    foreach(initialize!, request_line_regex)
-    foreach(initialize!, header_field_regex)
-    foreach(initialize!, empty_header_field_regex)
-    foreach(initialize!, obs_fold_header_field_regex)
+    resize!(empty!(status_line_regex),           Threads.nthreads())
+    resize!(empty!(request_line_regex),          Threads.nthreads())
+    resize!(empty!(header_field_regex),          Threads.nthreads())
+    resize!(empty!(obs_fold_header_field_regex), Threads.nthreads())
+    resize!(empty!(empty_header_field_regex),    Threads.nthreads())
     return
 end
 

src/Servers.jl

@@ -23,7 +23,7 @@ import MbedTLS
 
 using Dates
 
-import ..@debug, ..@debugshow, ..DEBUG_LEVEL, ..taskid
+import ..@debug, ..@debugshow, ..DEBUG_LEVEL, ..taskid, ..access_threaded
 
 # rate limiting
 mutable struct RateLimit
@@ -42,7 +42,7 @@ function update!(rl::RateLimit, rate_limit)
     return nothing
 end
 
-const RATE_LIMITS = [Dict{IPAddr, RateLimit}()]
+const RATE_LIMITS = Dict{IPAddr, RateLimit}[]
 check_rate_limit(tcp::Base.PipeEndpoint, rate_limit::Rational{Int}) = true
 check_rate_limit(tcp, ::Nothing) = true
 
@@ -55,7 +55,8 @@ ip address is updated in the global cache.
 """
 function check_rate_limit(tcp, rate_limit::Rational{Int})
     ip = Sockets.getpeername(tcp)[1]
-    rl = get!(RATE_LIMITS[Threads.threadid()], ip, RateLimit(rate_limit, Dates.DateTime(0)))
+    rl_d = access_threaded(Dict{IPAddr, RateLimit}, RATE_LIMITS)
+    rl = get!(rl_d, ip, RateLimit(rate_limit, Dates.DateTime(0)))
     update!(rl, rate_limit)
     if rl.allowance < 1.0
         @warn "discarding connection from $ip due to rate limiting"
@@ -427,7 +428,7 @@ function handle_transaction(f, t::Transaction, server; final_transaction::Bool=f
 end
 
 function __init__()
-    Threads.resize_nthreads!(RATE_LIMITS)
+    resize!(empty!(RATE_LIMITS), Threads.nthreads())
     return
 end
 

test/client.jl

@@ -37,7 +37,7 @@ end
     end
 
     @testset "Cookie Requests" begin
-        empty!(HTTP.CookieRequest.default_cookiejar[1])
+        empty!(HTTP.access_threaded(Dict{String, Set{HTTP.Cookie}}, HTTP.CookieRequest.default_cookiejar))
         r = HTTP.get("$sch://httpbin.org/cookies", cookies=true)
 
         body = String(r.body)