Float.(randn(dims)) or randn(Float32, dims)

General Usage
1

Found a behaviour of randn that I didn’t really understand. Since there exists a version where you can select the type I assume that that would be more efficient than generating and then converting, but it seems that this depends on the size of the generated data.

Here we see f1 using the conversion and f2 using the direct call. f1 is clearly slower when generating only 10 numbers, but a little faster when generating 2000 numbers. Anyone have a clue as to why this is?

julia> using BenchmarkTools

julia> f1(dims) = Float32.(randn(dims))
f1 (generic function with 2 methods)

julia> f2(dims) = randn(Float32, dims)
f2 (generic function with 2 methods)

julia> @benchmark f1(10)
BenchmarkTools.Trial: 10000 samples with 919 evaluations.
 Range (min … max):  107.929 ns …  1.170 ΞΌs  β”Š GC (min … max): 0.00% … 84.78%
 Time  (median):     118.046 ns              β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   124.795 ns Β± 55.602 ns  β”Š GC (mean Β± Οƒ):  3.12% Β±  6.36%

  β–ƒβ–†β–‡β–ˆβ–‡β–…β–ƒβ–‚ ▁                                                   β–‚
  β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–‡β–„β–†β–„β–…β–…β–„β–„β–„β–ƒβ–β–β–ƒβ–„β–β–β–ƒβ–β–β–β–β–β–β–β–ƒβ–β–ƒβ–β–„β–†β–†β–†β–‡β–†β–†β–…β–…β–†β–…β–…β–†β–…β–ƒβ–†β–„β–„β–ƒβ–† β–ˆ
  108 ns        Histogram: log(frequency) by time       281 ns <

 Memory estimate: 288 bytes, allocs estimate: 2.

julia> @benchmark f2(10)
BenchmarkTools.Trial: 10000 samples with 968 evaluations.
 Range (min … max):  71.681 ns … 770.913 ns  β”Š GC (min … max): 0.00% … 88.68%
 Time  (median):     78.347 ns               β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   83.177 ns Β±  34.070 ns  β”Š GC (mean Β± Οƒ):  1.95% Β±  4.54%

   β–β–ƒβ–‡β–ˆβ–†β–…β–„β–ƒβ–β–                                                  β–‚
  β–‡β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–‡β–†β–†β–†β–…β–†β–…β–†β–‡β–†β–†β–†β–…β–„β–„β–„β–ƒβ–β–β–ƒβ–„β–β–‡β–‡β–‡β–‡β–‡β–‡β–‡β–‡β–†β–†β–†β–†β–†β–†β–†β–„β–†β–†β–ƒβ–ƒβ–†β–†β–…β–†β–‡β–‡ β–ˆ
  71.7 ns       Histogram: log(frequency) by time       161 ns <

 Memory estimate: 128 bytes, allocs estimate: 1.

julia> @benchmark f1(2000)
BenchmarkTools.Trial: 10000 samples with 4 evaluations.
 Range (min … max):  6.650 ΞΌs … 233.773 ΞΌs  β”Š GC (min … max): 0.00% … 80.82%
 Time  (median):     7.554 ΞΌs               β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   8.138 ΞΌs Β±   8.375 ΞΌs  β”Š GC (mean Β± Οƒ):  4.01% Β±  3.77%

         β–β–„β–†β–‡β–ˆβ–ˆβ–†β–„β–ƒβ–                                            
  β–β–β–β–‚β–‚β–ƒβ–‡β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–†β–†β–…β–…β–„β–„β–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–ƒβ–‚β–‚β–‚β–‚β–‚β–‚β–‚β–β–β–β–β–β–β–β–β–β–β–β–β–β–β–β–β– β–ƒ
  6.65 ΞΌs         Histogram: frequency by time        10.6 ΞΌs <

 Memory estimate: 23.69 KiB, allocs estimate: 2.

julia> @benchmark f2(2000)
BenchmarkTools.Trial: 10000 samples with 4 evaluations.
 Range (min … max):  7.191 ΞΌs … 276.534 ΞΌs  β”Š GC (min … max): 0.00% … 86.09%
 Time  (median):     7.627 ΞΌs               β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   8.019 ΞΌs Β±   6.315 ΞΌs  β”Š GC (mean Β± Οƒ):  1.70% Β±  2.12%

   β–‚β–…β–†β–ˆβ–ˆβ–ˆβ–‡β–‡β–†β–…β–„β–„β–„β–ƒβ–„β–ƒβ–ƒβ–ƒβ–ƒβ–‚β–‚β–‚β–β– ▁                                 β–ƒ
  β–†β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–†β–‡β–‡β–†β–…β–‡β–†β–‡β–‡β–ˆβ–‡β–‡β–‡β–‡β–†β–‡β–‡β–‡β–‡β–†β–‡β–‡β–†β–ˆβ–‡ β–ˆ
  7.19 ΞΌs      Histogram: log(frequency) by time      10.8 ΞΌs <

 Memory estimate: 7.94 KiB, allocs estimate: 1.
2

Just a guess, but maybe the randn is a bit less efficient for Float32 than for Float64

julia> @benchmark randn(Float32, 20000)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  57.300 ΞΌs …  4.728 ms  β”Š GC (min … max): 0.00% … 98.41%
 Time  (median):     60.500 ΞΌs              β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   70.436 ΞΌs Β± 83.550 ΞΌs  β”Š GC (mean Β± Οƒ):  3.27% Β±  3.72%

    β–ˆβ–…           
  β–‚β–ˆβ–ˆβ–ˆβ–‡β–ƒβ–‚β–‚β–‚β–β–‚β–‚β–β–β–β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–β–‚β–‚β–„β–…β–…β–…β–ƒβ–ƒβ–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚β–‚ β–ƒ
  57.3 ΞΌs         Histogram: frequency by time         112 ΞΌs <

 Memory estimate: 78.20 KiB, allocs estimate: 2.

julia> @benchmark randn(Float64, 20000)
BenchmarkTools.Trial: 10000 samples with 1 evaluation.
 Range (min … max):  49.600 ΞΌs …  3.921 ms  β”Š GC (min … max): 0.00% … 97.23%
 Time  (median):     52.800 ΞΌs              β”Š GC (median):    0.00%
 Time  (mean Β± Οƒ):   65.426 ΞΌs Β± 90.596 ΞΌs  β”Š GC (mean Β± Οƒ):  5.09% Β±  4.92%

  β–ƒβ–ˆβ–ˆβ–…β–                         ▃▄▄▄▃▂▁                       β–‚
  β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–…β–ƒβ–„β–β–…β–†β–…β–†β–„β–…β–„β–„β–ƒβ–…β–ƒβ–„β–β–ƒβ–ƒβ–…β–β–…β–β–…β–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–ˆβ–‡β–†β–†β–†β–…β–†β–…β–„β–…β–…β–…β–…β–†β–†β–†β–†β–†β–…β–…β–†β–… β–ˆ
  49.6 ΞΌs      Histogram: log(frequency) by time       136 ΞΌs <

 Memory estimate: 156.33 KiB, allocs estimate: 2.

The difference is also comparable to the one in your experiment.

3

I agree that this must be the case, I was just curious as to why there was such a difference, especially to the degree that it would be faster to generate Float64 random numbers and convert them to Float32 instead of directly generating them as Float32.

Not sure why I didn’t check the source directly to begin with, but it was quite clear there. There is an optimization for MersenneTwister (default rng in 1.6) together with Float64 specifically:

        # filling arrays
        function $randfun!(rng::AbstractRNG, A::AbstractArray{T}) where T
            for i in eachindex(A)
                @inbounds A[i] = $randfun(rng, T)
            end
            A
        end

        # optimization for MersenneTwister, which randomizes natively Array{Float64}
        function $randfun!(rng::MersenneTwister, A::Array{Float64})
            if length(A) < 13
                for i in eachindex(A)
                    @inbounds A[i] = $randfun(rng, Float64)
                end
            else
                rand!(rng, A, CloseOpen12())
                for i in eachindex(A)
                    @inbounds A[i] = $_randfun(rng, reinterpret(UInt64, A[i]))
                end
            end
            A
        end

Running the same thing with for example StableRNGs rng type will be faster for the randn(rng, Float32, dims) case.

4

Curious to see how this changes in 1.7 with the new Xoroshiro RNG. Does that change also impact floating points?

5

I think that the comparison of times in the posted example may be misleading, because the random number generators are called with different seeds every time. I have observed time differences f1 and f2 of the same order of magnitude as between succesive calls to f1, for instance.

It would be better if each @benchmark is preceded by Random.seed! with the same number.

6

Seems current master has something similar for Xoshiro and Float64.

7

randn will very rarely branch out to some extra computations from what I saw in the code, so this is certainly a possibility, but one that should be removed over many samples. Since @benchmark will run 10000 samples I think looking at the minimum (or maybe median) will still give a good estimate of how fast it can be. I did run some of them a few times and those numbers seemed consistent for me then, but of course it can never hurt to seed the test as you mention.