attempt to fix oneAPI test precompilation hang with Julia v1.10 by disabling package images

Author: fjbarter

.buildkite/pipeline.yml

@@ -88,14 +88,13 @@ steps:
       - JuliaCI/julia#v1:
           version: "1.10"
     command: |
-      julia -e 'using Pkg
+      julia -e --pkgimages=no 'using Pkg
 
-                println("--- :julia: Instantiating environment")
-                Pkg.add("oneAPI")
-                Pkg.develop(path=".")
-
-                println("+++ :julia: Running tests")
-                Pkg.test("AcceleratedKernels", test_args=["--oneAPI"])'
+                               println("--- :julia: Instantiating environment")
+                               Pkg.add("oneAPI")
+                               Pkg.develop(path=".") 
+                               println("+++ :julia: Running tests")
+                               Pkg.test("AcceleratedKernels", test_args=["--oneAPI"])'
     agents:
       queue: "juliagpu"
       intel: "*"

src/rand/rand.jl

@@ -1,3 +1,10 @@
+const ALLOWED_RAND_SCALARS = Union{
+    UInt8, UInt16, UInt32, UInt64,
+    Int8, Int16, Int32, Int64,
+    Float16, Float32, Float64,
+    Bool
+}
+
 abstract type CounterRNGAlgorithm end
 
 
@@ -92,7 +99,8 @@ include("randn.jl")
 Fill `v` in-place with pseudo-random values using a counter-based RNG stream. For `v[i]`, the
 counter is `rng.offset + UInt64(i - 1)` in linear indexing order.
 
-After filling `v`, `rng.offset` advances by `length(v)`.
+After filling `v`, `rng.offset` advances by `length(v)`. It can be called without `rng`, in which
+case the default `CounterRNG` is used.
 
 Supported scalar element types are:
 - `UInt8`, `UInt16`, `UInt32`, `UInt64`
@@ -155,9 +163,13 @@ end
         backend::Backend,
         ::Type{T},
         dims::Integer...;
+
+        # CPU settings
         max_tasks::Int=Threads.nthreads(),
         min_elems::Int=1,
         prefer_threads::Bool=true,
+
+        # GPU settings
         block_size::Int=256,
     ) where T
 
@@ -178,7 +190,8 @@ function rand(
     # GPU settings
     block_size::Int=256,
 ) where T
-    return _allocate_and_fill(
+    @argcheck T <: ALLOWED_RAND_SCALARS "Unsupported eltype $T. Supported: $(ALLOWED_RAND_SCALARS)"
+    return _allocate_and_fill_rand(
         rand!, rng, backend, T, dims...;
         max_tasks, min_elems, prefer_threads, block_size,
     )

src/rand/randn.jl

@@ -1,9 +1,11 @@
-const ALLOWED_RANDN_SCALARS = Union{Float16, Float32, Float64}
+const ALLOWED_RANDN_SCALARS = Union{
+    Float16, Float32, Float64
+}
 
-const U24_MAX_SAFE_MIDPOINT = UInt32(0x00fffffe)                 # 2^24 - 2
-const U53_MAX_SAFE_MIDPOINT = UInt64(0x001ffffffffffffe)         # 2^53 - 2
-const MIDPOINT_SCALE_F32 = ldexp(Float32(1), -24)                # 2^-24
-const MIDPOINT_SCALE_F64 = ldexp(Float64(1), -53)                # 2^-53
+const OPEN01_MAX_MIDPOINT_INDEX_F32 = UInt32(0x00fffffe)
+const OPEN01_MAX_MIDPOINT_INDEX_F64 = UInt64(0x001ffffffffffffe)
+const OPEN01_MIDPOINT_SCALE_F32 = ldexp(Float32(1), -24)
+const OPEN01_MIDPOINT_SCALE_F64 = ldexp(Float64(1), -53)
 
 
 
@@ -19,16 +21,16 @@ Avoiding 0 is essential for Box-Muller due to the logarithm functions.
 # Convert random UInt32 bits to Float32 in (0, 1) using midpoint mapping on a 24-bit grid.
 @inline function uint32_to_open_unit_float32_midpoint(u::UInt32)::Float32
     # `min` keeps the top midpoint below one after Float32 rounding.
-    k = min(u >> 8, U24_MAX_SAFE_MIDPOINT)
-    return (Float32(k) + 0.5f0) * MIDPOINT_SCALE_F32
+    k = min(u >> 8, OPEN01_MAX_MIDPOINT_INDEX_F32)
+    return (Float32(k) + 0.5f0) * OPEN01_MIDPOINT_SCALE_F32
 end
 
 
 # Convert random UInt64 bits to Float64 in (0, 1) using midpoint mapping on a 53-bit grid.
 @inline function uint64_to_open_unit_float64_midpoint(u::UInt64)::Float64
     # `min` keeps the top midpoint below one after Float64 rounding.
-    k = min(u >> 11, U53_MAX_SAFE_MIDPOINT)
-    return (Float64(k) + 0.5) * MIDPOINT_SCALE_F64
+    k = min(u >> 11, OPEN01_MAX_MIDPOINT_INDEX_F64)
+    return (Float64(k) + 0.5) * OPEN01_MIDPOINT_SCALE_F64
 end
 
 
@@ -201,8 +203,6 @@ end
         # CPU settings
         max_tasks::Int=Threads.nthreads(),
         min_elems::Int=1,
-
-        # Implementation choice
         prefer_threads::Bool=true,
 
         # GPU settings
@@ -215,6 +215,8 @@ For `v[i]`, the normal stream counter is `rng.offset + UInt64(i - 1)` in linear
 Values are generated using Box-Muller from midpoint-open uniforms in `(0, 1)`.
 
 After filling `v`, `rng.offset` advances by `length(v)`.
+
+It can be called without an `rng`, in which case the default `CounterRNG` will be used.
 """
 function randn!(
     rng::CounterRNG,
@@ -269,9 +271,13 @@ end
         backend::Backend,
         ::Type{T},
         dims::Integer...;
+
+        # CPU settings
         max_tasks::Int=Threads.nthreads(),
         min_elems::Int=1,
         prefer_threads::Bool=true,
+
+        # GPU settings
         block_size::Int=256,
     ) where T
 
@@ -283,12 +289,17 @@ function randn(
     backend::Backend,
     ::Type{T},
     dims::Integer...;
+
+    # CPU settings
     max_tasks::Int=Threads.nthreads(),
     min_elems::Int=1,
     prefer_threads::Bool=true,
+
+    # GPU settings
     block_size::Int=256,
 ) where T
-    return _allocate_and_fill(
+    @argcheck T <: ALLOWED_RANDN_SCALARS "Unsupported eltype $T. Supported: $(ALLOWED_RANDN_SCALARS)"
+    return _allocate_and_fill_rand(
         randn!, rng, backend, T, dims...;
         max_tasks, min_elems, prefer_threads, block_size,
     )
@@ -299,9 +310,13 @@ function randn(
     backend::Backend,
     ::Type{T},
     dims::Integer...;
+
+    # CPU settings
     max_tasks::Int=Threads.nthreads(),
     min_elems::Int=1,
     prefer_threads::Bool=true,
+
+    # GPU settings
     block_size::Int=256,
 ) where T
     return randn(

src/rand/utilities.jl

@@ -16,15 +16,19 @@
 
 
 # Shared allocation + fill helper for rand/randn convenience constructors.
-@inline function _allocate_and_fill(
+@inline function _allocate_and_fill_rand(
     fill!,
     rng::CounterRNG,
     backend::Backend,
     ::Type{T},
     dims::Integer...;
+
+    # CPU settings
     max_tasks::Int=Threads.nthreads(),
     min_elems::Int=1,
     prefer_threads::Bool=true,
+
+    # GPU settings
     block_size::Int=256,
 ) where {T}
     dims_int = Base.map(Int, dims)
@@ -34,13 +38,6 @@
 end
 
 
-# Internal scalar eltypes currently supported by rand!.
-const ALLOWED_RAND_SCALARS = Union{
-    UInt8, UInt16, UInt32, UInt64,
-    Int8, Int16, Int32, Int64,
-    Float16, Float32, Float64,
-    Bool
-}
 
 
 @inline _rand_scalar_uint_type(::Type{UInt8}) = UInt32