#37599

Committed 16 Aug 2023 01:53AM UTC coverage: 86.427% (-1.1%) from 87.526%

Build # #37599

Build Type

push

local

Committed by

web-flow

Commit Message

Change heap-size-hint in test processes to total memory (#50922)

It seems this is causing macos to hang because the shown free memory is
generally very small.

xref: JuliaLang/julia#50673

Run Details

73086 of 84564 relevant lines covered (86.43%)

32342958.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/stdlib/Base64/src/encode.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

# Generate encode table.
const BASE64_ENCODE = [UInt8(x) for x in append!(['A':'Z'; 'a':'z'; '0':'9'], ['+', '/'])]
encode(x::UInt8) = @inbounds return BASE64_ENCODE[(x & 0x3f) + 1]
encodepadding()  = UInt8('=')

"""
    Base64EncodePipe(ostream)

Return a new write-only I/O stream, which converts any bytes written to it into
base64-encoded ASCII bytes written to `ostream`.  Calling [`close`](@ref) on the
`Base64EncodePipe` stream is necessary to complete the encoding (but does not
close `ostream`).

# Examples
```jldoctest
julia> io = IOBuffer();

julia> iob64_encode = Base64EncodePipe(io);

julia> write(iob64_encode, "Hello!")
6

julia> close(iob64_encode);

julia> str = String(take!(io))
"SGVsbG8h"

julia> String(base64decode(str))
"Hello!"
```
"""
struct Base64EncodePipe <: IO
    io::IO
    buffer::Buffer

    function Base64EncodePipe(io::IO)
        # The buffer size must be at least 3.
        buffer = Buffer(512)
        pipe = new(io, buffer)
        finalizer(_ -> close(pipe), buffer)
        return pipe
    end
end

Base.isreadable(::Base64EncodePipe) = false
Base.iswritable(pipe::Base64EncodePipe) = iswritable(pipe.io)

function Base.unsafe_write(pipe::Base64EncodePipe, ptr::Ptr{UInt8}, n::UInt)::Int
    buffer = pipe.buffer
    m = buffer.size
    b1, b2, b3, k = loadtriplet!(buffer, ptr, n)
    @assert k ≥ m
    p = ptr + k - m
    if k < 3
        if k == 1
            buffer[1] = b1
            buffer.size = 1
        elseif k == 2
            buffer[1] = b1
            buffer[2] = b2
            buffer.size = 2
        end
        return p - ptr
    end
    @assert buffer.size == 0

    i = 0
    p_end = ptr + n
    while true
        buffer[i+1] = encode(b1 >> 2          )
        buffer[i+2] = encode(b1 << 4 | b2 >> 4)
        buffer[i+3] = encode(b2 << 2 | b3 >> 6)
        buffer[i+4] = encode(          b3     )
        i += 4
        if p + 2 < p_end
            b1 = unsafe_load(p, 1)
            b2 = unsafe_load(p, 2)
            b3 = unsafe_load(p, 3)
            p += 3
        else
            break
        end
        if i + 4 > capacity(buffer)
            unsafe_write(pipe.io, pointer(buffer), i)
            i = 0
        end
    end
    if i > 0
        unsafe_write(pipe.io, pointer(buffer), i)
    end

    while p < p_end
        buffer[buffer.size+=1] = unsafe_load(p)
        p += 1
    end
    return p - ptr
end

function Base.write(pipe::Base64EncodePipe, x::UInt8)
    buffer = pipe.buffer
    buffer[buffer.size+=1] = x
    if buffer.size == 3
        unsafe_write(pipe, C_NULL, 0)
    end
    return 1
end

function Base.close(pipe::Base64EncodePipe)
    b1, b2, b3, k = loadtriplet!(pipe.buffer, Ptr{UInt8}(C_NULL), UInt(0))
    if k == 0
        # no leftover and padding
    elseif k == 1
        write(pipe.io,
              encode(b1 >> 2),
              encode(b1 << 4),
              encodepadding(),
              encodepadding())
    elseif k == 2
        write(pipe.io,
              encode(          b1 >> 2),
              encode(b1 << 4 | b2 >> 4),
              encode(b2 << 2          ),
              encodepadding())
    else
        @assert k == 3
        write(pipe.io,
              encode(b1 >> 2          ),
              encode(b1 << 4 | b2 >> 4),
              encode(b2 << 2 | b3 >> 6),
              encode(          b3     ))
    end
    return nothing
end

# Load three bytes from buffer and ptr.
function loadtriplet!(buffer::Buffer, ptr::Ptr{UInt8}, n::UInt)
    b1 = b2 = b3 = 0x00
    if buffer.size == 0
        if n == 0
            k = 0
        elseif n == 1
            b1 = unsafe_load(ptr, 1)
            k = 1
        elseif n == 2
            b1 = unsafe_load(ptr, 1)
            b2 = unsafe_load(ptr, 2)
            k = 2
        else
            b1 = unsafe_load(ptr, 1)
            b2 = unsafe_load(ptr, 2)
            b3 = unsafe_load(ptr, 3)
            k = 3
        end
    elseif buffer.size == 1
        b1 = buffer[1]
        if n == 0
            k = 1
        elseif n == 1
            b2 = unsafe_load(ptr, 1)
            k = 2
        else
            b2 = unsafe_load(ptr, 1)
            b3 = unsafe_load(ptr, 2)
            k = 3
        end
    elseif buffer.size == 2
        b1 = buffer[1]
        b2 = buffer[2]
        if n == 0
            k = 2
        else
            b3 = unsafe_load(ptr, 1)
            k = 3
        end
    else
        @assert buffer.size == 3
        b1 = buffer[1]
        b2 = buffer[2]
        b3 = buffer[3]
        k = 3
    end
    empty!(buffer)
    return b1, b2, b3, k
end

"""
    base64encode(writefunc, args...; context=nothing)
    base64encode(args...; context=nothing)

Given a [`write`](@ref)-like function `writefunc`, which takes an I/O stream as
its first argument, `base64encode(writefunc, args...)` calls `writefunc` to
write `args...` to a base64-encoded string, and returns the string.
`base64encode(args...)` is equivalent to `base64encode(write, args...)`: it
converts its arguments into bytes using the standard [`write`](@ref) functions
and returns the base64-encoded string.

The optional keyword argument `context` can be set to `:key=>value` pair
or an `IO` or [`IOContext`](@ref) object whose attributes are used for the I/O
stream passed to `writefunc` or `write`.

See also [`base64decode`](@ref).
"""
function base64encode(f::Function, args...; context=nothing)
    s = IOBuffer()
    b = Base64EncodePipe(s)
    if context === nothing
        f(b, args...)
    else
        f(IOContext(b, context), args...)
    end
    close(b)
    return String(take!(s))
end
base64encode(args...; context=nothing) = base64encode(write, args...; context=context)

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	# Generate encode table.
4	const BASE64_ENCODE = [UInt8(x) for x in append!(['A':'Z'; 'a':'z'; '0':'9'], ['+', '/'])]
5	encode(x::UInt8) = @inbounds return BASE64_ENCODE[(x & 0x3f) + 1]	×
6	encodepadding() = UInt8('=')	×
7
8	"""
9	Base64EncodePipe(ostream)
10
11	Return a new write-only I/O stream, which converts any bytes written to it into
12	base64-encoded ASCII bytes written to `ostream`. Calling [`close`](@ref) on the
13	`Base64EncodePipe` stream is necessary to complete the encoding (but does not
14	close `ostream`).
15
16	# Examples
17	```jldoctest
18	julia> io = IOBuffer();
19
20	julia> iob64_encode = Base64EncodePipe(io);
21
22	julia> write(iob64_encode, "Hello!")
23	6
24
25	julia> close(iob64_encode);
26
27	julia> str = String(take!(io))
28	"SGVsbG8h"
29
30	julia> String(base64decode(str))
31	"Hello!"
32	```
33	"""
34	struct Base64EncodePipe <: IO
35	io::IO
36	buffer::Buffer
37
38	function Base64EncodePipe(io::IO)	×
39	# The buffer size must be at least 3.
40	buffer = Buffer(512)	×
41	pipe = new(io, buffer)	×
42	finalizer(_ -> close(pipe), buffer)	×
43	return pipe	×
44	end
45	end
46
47	Base.isreadable(::Base64EncodePipe) = false	×
48	Base.iswritable(pipe::Base64EncodePipe) = iswritable(pipe.io)	×
49
50	function Base.unsafe_write(pipe::Base64EncodePipe, ptr::Ptr{UInt8}, n::UInt)::Int	×
51	buffer = pipe.buffer	×
52	m = buffer.size	×
53	b1, b2, b3, k = loadtriplet!(buffer, ptr, n)	×
54	@assert k ≥ m	×
55	p = ptr + k - m	×
56	if k < 3	×
57	if k == 1	×
58	buffer[1] = b1	×
59	buffer.size = 1	×
60	elseif k == 2	×
61	buffer[1] = b1	×
62	buffer[2] = b2	×
63	buffer.size = 2	×
64	end
65	return p - ptr	×
66	end
67	@assert buffer.size == 0	×
68
69	i = 0	×
70	p_end = ptr + n	×
71	while true	×
72	buffer[i+1] = encode(b1 >> 2 )	×
73	buffer[i+2] = encode(b1 << 4 \| b2 >> 4)	×
74	buffer[i+3] = encode(b2 << 2 \| b3 >> 6)	×
75	buffer[i+4] = encode( b3 )	×
76	i += 4	×
77	if p + 2 < p_end	×
78	b1 = unsafe_load(p, 1)	×
79	b2 = unsafe_load(p, 2)	×
80	b3 = unsafe_load(p, 3)	×
81	p += 3	×
82	else
83	break	×
84	end
85	if i + 4 > capacity(buffer)	×
86	unsafe_write(pipe.io, pointer(buffer), i)	×
87	i = 0	×
88	end
89	end	×
90	if i > 0	×
91	unsafe_write(pipe.io, pointer(buffer), i)	×
92	end
93
94	while p < p_end	×
95	buffer[buffer.size+=1] = unsafe_load(p)	×
96	p += 1	×
97	end	×
98	return p - ptr	×
99	end
100
101	function Base.write(pipe::Base64EncodePipe, x::UInt8)	×
102	buffer = pipe.buffer	×
103	buffer[buffer.size+=1] = x	×
104	if buffer.size == 3	×
105	unsafe_write(pipe, C_NULL, 0)	×
106	end
107	return 1	×
108	end
109
110	function Base.close(pipe::Base64EncodePipe)	×
111	b1, b2, b3, k = loadtriplet!(pipe.buffer, Ptr{UInt8}(C_NULL), UInt(0))	×
112	if k == 0	×
113	# no leftover and padding
114	elseif k == 1	×
115	write(pipe.io,	×
116	encode(b1 >> 2),
117	encode(b1 << 4),
118	encodepadding(),
119	encodepadding())
120	elseif k == 2	×
121	write(pipe.io,	×
122	encode( b1 >> 2),
123	encode(b1 << 4 \| b2 >> 4),
124	encode(b2 << 2 ),
125	encodepadding())
126	else
127	@assert k == 3	×
128	write(pipe.io,	×
129	encode(b1 >> 2 ),
130	encode(b1 << 4 \| b2 >> 4),
131	encode(b2 << 2 \| b3 >> 6),
132	encode( b3 ))
133	end
134	return nothing	×
135	end
136
137	# Load three bytes from buffer and ptr.
138	function loadtriplet!(buffer::Buffer, ptr::Ptr{UInt8}, n::UInt)	×
139	b1 = b2 = b3 = 0x00	×
140	if buffer.size == 0	×
141	if n == 0	×
142	k = 0	×
143	elseif n == 1	×
144	b1 = unsafe_load(ptr, 1)	×
145	k = 1	×
146	elseif n == 2	×
147	b1 = unsafe_load(ptr, 1)	×
148	b2 = unsafe_load(ptr, 2)	×
149	k = 2	×
150	else
151	b1 = unsafe_load(ptr, 1)	×
152	b2 = unsafe_load(ptr, 2)	×
153	b3 = unsafe_load(ptr, 3)	×
154	k = 3	×
155	end
156	elseif buffer.size == 1	×
157	b1 = buffer[1]	×
158	if n == 0	×
159	k = 1	×
160	elseif n == 1	×
161	b2 = unsafe_load(ptr, 1)	×
162	k = 2	×
163	else
164	b2 = unsafe_load(ptr, 1)	×
165	b3 = unsafe_load(ptr, 2)	×
166	k = 3	×
167	end
168	elseif buffer.size == 2	×
169	b1 = buffer[1]	×
170	b2 = buffer[2]	×
171	if n == 0	×
172	k = 2	×
173	else
174	b3 = unsafe_load(ptr, 1)	×
175	k = 3	×
176	end
177	else
178	@assert buffer.size == 3	×
179	b1 = buffer[1]	×
180	b2 = buffer[2]	×
181	b3 = buffer[3]	×
182	k = 3	×
183	end
184	empty!(buffer)	×
185	return b1, b2, b3, k	×
186	end
187
188	"""
189	base64encode(writefunc, args...; context=nothing)
190	base64encode(args...; context=nothing)
191
192	Given a [`write`](@ref)-like function `writefunc`, which takes an I/O stream as
193	its first argument, `base64encode(writefunc, args...)` calls `writefunc` to
194	write `args...` to a base64-encoded string, and returns the string.
195	`base64encode(args...)` is equivalent to `base64encode(write, args...)`: it
196	converts its arguments into bytes using the standard [`write`](@ref) functions
197	and returns the base64-encoded string.
198
199	The optional keyword argument `context` can be set to `:key=>value` pair
200	or an `IO` or [`IOContext`](@ref) object whose attributes are used for the I/O
201	stream passed to `writefunc` or `write`.
202
203	See also [`base64decode`](@ref).
204	"""
205	function base64encode(f::Function, args...; context=nothing)	×
206	s = IOBuffer()	×
207	b = Base64EncodePipe(s)	×
208	if context === nothing	×
209	f(b, args...)	×
210	else
211	f(IOContext(b, context), args...)	×
212	end
213	close(b)	×
214	return String(take!(s))	×
215	end
216	base64encode(args...; context=nothing) = base64encode(write, args...; context=context)	×

JuliaLang / julia / #37599

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous