Some progress with dispatch coersion

Author: juntyr

Cargo.lock

@@ -10,10 +10,17 @@ edition = "2021"
 [features]
 default = []
 
+necsim-partitioning-mpi = ["dep:necsim-partitioning-mpi"]
+
+rustcoalescence-algorithms-gillespie = ["dep:rustcoalescence-algorithms-gillespie"]
+rustcoalescence-algorithms-independent = ["dep:rustcoalescence-algorithms-independent"]
+rustcoalescence-algorithms-cuda = ["dep:rustcoalescence-algorithms-cuda", "dep:necsim-impls-cuda", "dep:rust-cuda"]
+
 [dependencies]
 necsim-core = { path = "../necsim/core" }
 necsim-core-bond = { path = "../necsim/core/bond" }
 necsim-impls-no-std = { path = "../necsim/impls/no-std" }
+necsim-impls-cuda = { path = "../necsim/impls/cuda", optional = true }
 necsim-impls-std = { path = "../necsim/impls/std" }
 necsim-plugins-core = { path = "../necsim/plugins/core", features = ["import"] }
 necsim-partitioning-core = { path = "../necsim/partitioning/core" }
@@ -28,6 +35,8 @@ rustcoalescence-algorithms-gillespie = { path = "algorithms/gillespie", optional
 rustcoalescence-algorithms-independent = { path = "algorithms/independent", optional = true }
 rustcoalescence-algorithms-cuda = { path = "algorithms/cuda", optional = true }
 
+rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "dd9507d", features = [], optional = true }
+
 clap = { version = "4.0", features = ["derive"] }
 anyhow = "1.0"
 serde = { version = "1.0", features = ["derive"] }

rustcoalescence/Cargo.toml

@@ -1,6 +1,7 @@
 #![deny(clippy::pedantic)]
 #![feature(c_str_literals)]
 #![feature(min_specialization)]
+#![allow(long_running_const_eval)]
 #![recursion_limit = "1024"]
 
 use necsim_core::{

rustcoalescence/algorithms/cuda/cpu-kernel/src/lib.rs

@@ -48,14 +48,14 @@ unsafe impl<
         simulate<M, H, G, S, X, D, C, T, N, E, I, A, ReportSpeciation, ReportDispersal>,
     > for SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, ReportSpeciation, ReportDispersal>
 where
-    SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, False, False>:
-        CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, False, False>>,
-    SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, False, True>:
-        CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, False, True>>,
-    SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, True, False>:
-        CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, True, False>>,
-    SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, True, True>:
-        CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, True, True>>,
+    // SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, False, False>:
+    //     CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, False, False>>,
+    // SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, False, True>:
+    //     CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, False, True>>,
+    // SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, True, False>:
+    //     CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, True, False>>,
+    // SimulationKernelPtx<M, H, G, S, X, D, C, T, N, E, I, A, True, True>:
+    //     CompiledKernelPtx<simulate<M, H, G, S, X, D, C, T, N, E, I, A, True, True>>,
 {
     default fn get_ptx() -> &'static CStr {
         unsafe { unreachable_cuda_simulation_linking_reporter() }

rustcoalescence/algorithms/cuda/cpu-kernel/src/patch.rs

@@ -4,6 +4,7 @@
 #![feature(decl_macro)]
 #![feature(c_str_literals)]
 #![cfg_attr(target_os = "cuda", feature(abi_ptx))]
+#![cfg_attr(target_os = "cuda", feature(asm_experimental_arch))]
 #![cfg_attr(target_os = "cuda", feature(alloc_error_handler))]
 #![allow(long_running_const_eval)]
 #![recursion_limit = "1024"]

rustcoalescence/algorithms/cuda/gpu-kernel/src/lib.rs

@@ -398,7 +398,7 @@ where
             _,
             _,
             _,
-            <FixUpInitialiser<L> as CudaLineageStoreSampleInitialiser<_, _, O, _>>::ActiveLineageSampler<_, ExpEventTimeSampler>,
+            <FixUpInitialiser<L> as CudaLineageStoreSampleInitialiser<_, _, O, _>>::ActiveLineageSampler<_, ConstEventTimeSampler>,
             _,
             _,
         >>(

rustcoalescence/algorithms/cuda/src/lib.rs

@@ -103,6 +103,7 @@ macro_rules! match_scenario_algorithm {
 }
 
 #[allow(clippy::too_many_arguments)]
+#[allow(clippy::too_many_lines)] // FIXME
 pub(super) fn dispatch<'p, R: Reporter, P: LocalPartition<'p, R>>(
     local_partition: P,
 
@@ -150,9 +151,47 @@ pub(super) fn dispatch<'p, R: Reporter, P: LocalPartition<'p, R>>(
         },
         #[cfg(feature = "rustcoalescence-algorithms-cuda")]
         AlgorithmArgs::Cuda(algorithm_args) => {
-            rng::dispatch::<
-                <CudaAlgorithm as AlgorithmDefaults>::MathsCore,
-                CudaAlgorithm, _, R, P,
+            fn coerce_cuda_dispatch<
+                'p,
+                M: necsim_core::cogs::MathsCore + Sync,
+                O: Scenario<M, necsim_impls_cuda::cogs::rng::CudaRng<
+                    M, necsim_impls_no_std::cogs::rng::wyhash::WyHash<M>,
+                >>,
+                R: Reporter,
+                P: LocalPartition<'p, R>,
+            >(
+                local_partition: P,
+
+                sample: crate::args::config::sample::Sample,
+                algorithm_args: <CudaAlgorithm as rustcoalescence_algorithms::AlgorithmParamters>::Arguments,
+                scenario: O,
+                pause_before: Option<NonNegativeF64>,
+
+                ron_args: &str,
+                normalised_args: &mut BufferingSimulateArgsBuilder,
+            ) -> anyhow::Result<SimulationOutcome> where
+                O::Habitat: rust_cuda::lend::RustToCuda + Sync,
+                O::DispersalSampler<
+                    necsim_impls_no_std::cogs::dispersal_sampler::in_memory::packed_alias::InMemoryPackedAliasDispersalSampler<
+                        M, O::Habitat, necsim_impls_cuda::cogs::rng::CudaRng<
+                            M, necsim_impls_no_std::cogs::rng::wyhash::WyHash<M>,
+                        >
+                    >
+                >: rust_cuda::lend::RustToCuda + Sync,
+                O::TurnoverRate: rust_cuda::lend::RustToCuda + Sync,
+                O::SpeciationProbability: rust_cuda::lend::RustToCuda + Sync,
+            {
+                rng::dispatch::<
+                    M,
+                    CudaAlgorithm, _, R, P,
+                >(
+                    local_partition, sample, algorithm_args, scenario,
+                    pause_before, ron_args, normalised_args,
+                )
+            }
+
+            coerce_cuda_dispatch::<
+                <CudaAlgorithm as AlgorithmDefaults>::MathsCore, _, R, P,
             >(
                 local_partition, sample, algorithm_args, scenario,
                 pause_before, ron_args, normalised_args,