julia: #timev differing values for bytes allocated - memory

Question

Is it better to use #allocated versus "bytes allocated" for measuring memory usage? I'm a bit surprised that bytes allocated changes from invocation to invocation.
julia> #timev map(x->2*x, [1:100])
0.047360 seconds (89.54 k allocations: 4.269 MiB)
elapsed time (ns): 47359831
bytes allocated: 4476884
pool allocs: 89536
non-pool GC allocs:1
1-element Array{StepRange{Int64,Int64},1}:
2:2:200
julia> #timev map(x->2*x, [1:100])
0.047821 seconds (89.56 k allocations: 4.271 MiB)
elapsed time (ns): 47820714
bytes allocated: 4478708
pool allocs: 89554
non-pool GC allocs:1
1-element Array{StepRange{Int64,Int64},1}:
2:2:200
julia> #timev map(x->2*x, [1:100])
0.045273 seconds (89.58 k allocations: 4.274 MiB)
elapsed time (ns): 45272518
bytes allocated: 4481108
pool allocs: 89580
non-pool GC allocs:1
1-element Array{StepRange{Int64,Int64},1}:
2:2:200

Answer 1

Firstly, you should read the performance tips section of the Julia manual: https://docs.julialang.org/en/v1/manual/performance-tips/index.html
You are violating tip number one: don't benchmark in global scope. A big red flag should be that this simple operation takes 4/100 of a second and allocates 4MB.
For benchmarking, always use the BenchmarkTools.jl package. Below is example usage.
(BTW, do you really mean to operate on [1:100]? This is a single-element vector, where the single element is a Range object. Did you perhaps intend to work on 1:100 or maybe collect(1:100)?)
julia> using BenchmarkTools
julia> foo(y) = map(x->2*x, y)
foo (generic function with 2 methods)
julia> v = 1:100
1:100
julia> #btime foo($v)
73.372 ns (1 allocation: 896 bytes)
julia> v = collect(1:100);
julia> #btime foo($v);
73.699 ns (2 allocations: 912 bytes)
julia> #btime foo($v);
73.100 ns (2 allocations: 912 bytes)
julia> #btime foo($v);
74.033 ns (2 allocations: 912 bytes)
julia> v = [1:100];
julia> #btime foo($v);
55.563 ns (2 allocations: 128 bytes)
As you can see, runtimes are almost 6 orders of magnitude faster than what you are seeing, and allocations are stable.
Notice also that the last example, which uses [1:100], is faster than the others, but that's because it's doing something else.