fix: use a private task-local RNG for kernel launch seeds

Kernel launches were drawing seeds via `Random.rand(UInt32)`, which
consumed from Julia's task-global default RNG.  This silently perturbed
the host random-number stream whenever user code interleaved `@cuda`
calls with `rand()` calls, making reproducibility impossible.

Fix: introduce `launch_rng()`, which lazily creates a `Random.Xoshiro`
in `task_local_storage()` (key `:CUDACore_launch_rng`) seeded from
`Random.RandomDevice()`.  The private RNG is completely independent of
the default RNG and is task-local, so concurrent tasks each get their
own seeded RNG.  `make_seed(::HostKernel)` now draws from this private
RNG instead.  Device-side seeding (DeviceKernel / random.jl) is
unchanged.

Fixes #2417

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: JohnCobbler

CUDACore/src/compiler/execution.jl

@@ -473,7 +473,18 @@ end
 # cache of kernel instances
 const _kernel_instances = Dict{Any, Any}()
 
-make_seed(::HostKernel) = Random.rand(UInt32)
+# Return a task-local Xoshiro RNG that is seeded from RandomDevice on first use
+# per task.  Using a private RNG ensures that launching a kernel does NOT
+# perturb the user-visible default RNG stream.  (JuliaGPU/CUDA.jl#2417)
+const _LAUNCH_RNG_KEY = :CUDACore_launch_rng
+
+function launch_rng()
+    get!(() -> Random.Xoshiro(rand(Random.RandomDevice(), UInt64)),
+         task_local_storage(),
+         _LAUNCH_RNG_KEY)::Random.Xoshiro
+end
+
+make_seed(::HostKernel) = rand(launch_rng(), UInt32)
 
 
 ## device-side kernels

test/core/execution.jl

@@ -1222,3 +1222,32 @@ end
 end
 
 ############################################################################################
+
+# JuliaGPU/CUDA.jl#2417: kernel launches must not perturb the host default RNG stream
+@testset "launch seed does not perturb host RNG" begin
+
+    dummy_kernel() = return
+
+    # Capture two host-rand values with a kernel launch interleaved; the sequence
+    # must be identical to the sequence produced without any launch.
+    Random.seed!(0xdeadbeef)
+    a_before = rand(UInt64)
+    @cuda threads=1 dummy_kernel()   # must not consume from default RNG
+    a_after  = rand(UInt64)
+
+    Random.seed!(0xdeadbeef)
+    b_before = rand(UInt64)
+    b_after  = rand(UInt64)
+
+    @test a_before == b_before
+    @test a_after  == b_after
+
+    # Two consecutive launches must still receive distinct seeds.
+    k = @cuda launch=false dummy_kernel()
+    seed1 = CUDACore.make_seed(k)
+    seed2 = CUDACore.make_seed(k)
+    @test seed1 != seed2
+
+end
+
+############################################################################################