Minimum upgrade to async-capable rust-cuda

necsim/core/Cargo.toml

@@ -20,7 +20,7 @@ contracts = "0.6.3"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 
 [target.'cfg(target_os = "cuda")'.dependencies]
-rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "6b53e88", features = ["derive"], optional = true }
+rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "4148959", features = ["derive"], optional = true }
 
 [target.'cfg(not(target_os = "cuda"))'.dependencies]
-rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "6b53e88", features = ["derive", "host"], optional = true }
+rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "4148959", features = ["derive", "host"], optional = true }

necsim/core/src/landscape/extent.rs

@@ -4,9 +4,10 @@ use super::Location;
 
 #[allow(clippy::module_name_repetitions, clippy::unsafe_derive_deserialize)]
 #[derive(PartialEq, Eq, Clone, Debug, serde::Deserialize, serde::Serialize, TypeLayout)]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
+#[cfg_attr(feature = "cuda", cuda(ignore))]
 #[serde(rename = "Extent")]
 #[serde(deny_unknown_fields)]
-#[repr(C)]
 pub struct LandscapeExtent {
     x: u32,
     y: u32,

necsim/core/src/landscape/location.rs

@@ -1,25 +1,18 @@
 use serde::{Deserialize, Serialize};
 
-use crate::cogs::Backup;
-
-#[allow(clippy::unsafe_derive_deserialize)]
+#[allow(clippy::module_name_repetitions)]
 #[derive(
     Eq, PartialEq, PartialOrd, Ord, Clone, Hash, Debug, Serialize, Deserialize, TypeLayout,
 )]
-#[serde(deny_unknown_fields)]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
 #[repr(C)]
+#[cfg_attr(feature = "cuda", cuda(ignore))]
+#[serde(deny_unknown_fields)]
 pub struct Location {
     x: u32,
     y: u32,
 }
 
-#[contract_trait]
-impl Backup for Location {
-    unsafe fn backup_unchecked(&self) -> Self {
-        self.clone()
-    }
-}
-
 impl Location {
     #[must_use]
     pub const fn new(x: u32, y: u32) -> Self {
@@ -46,10 +39,13 @@ impl From<IndexedLocation> for Location {
 #[derive(
     Eq, PartialEq, PartialOrd, Ord, Clone, Hash, Debug, Serialize, Deserialize, TypeLayout,
 )]
-#[allow(clippy::module_name_repetitions, clippy::unsafe_derive_deserialize)]
-#[serde(from = "IndexedLocationRaw", into = "IndexedLocationRaw")]
+#[allow(clippy::module_name_repetitions)]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
 #[repr(C)]
+#[cfg_attr(feature = "cuda", cuda(ignore))]
+#[serde(from = "IndexedLocationRaw", into = "IndexedLocationRaw")]
 pub struct IndexedLocation {
+    #[cfg_attr(feature = "cuda", cuda(embed))]
     location: Location,
     index: u32,
 }
@@ -74,7 +70,6 @@ impl IndexedLocation {
 #[derive(Serialize, Deserialize)]
 #[serde(deny_unknown_fields)]
 #[serde(rename = "IndexedLocation")]
-#[repr(C)]
 struct IndexedLocationRaw {
     x: u32,
     y: u32,

necsim/core/src/lib.rs

@@ -2,7 +2,6 @@
 #![no_std]
 #![feature(const_type_name)]
 #![feature(offset_of)]
-#![feature(control_flow_enum)]
 #![feature(min_specialization)]
 
 #[doc(hidden)]

necsim/core/src/lineage.rs

@@ -16,6 +16,7 @@ use crate::{
 };
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, TypeLayout)]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
 #[repr(transparent)]
 pub struct GlobalLineageReference(u64);
 
@@ -94,21 +95,29 @@ impl From<Option<GlobalLineageReference>> for LineageInteraction {
     }
 }
 
-#[allow(clippy::unsafe_derive_deserialize)]
+#[allow(clippy::unsafe_derive_deserialize, clippy::module_name_repetitions)]
 #[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize, TypeLayout)]
-#[serde(deny_unknown_fields)]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
 #[repr(C)]
+#[cfg_attr(feature = "cuda", cuda(ignore))]
+#[serde(deny_unknown_fields)]
 pub struct Lineage {
+    #[cfg_attr(feature = "cuda", cuda(embed))]
+    #[cfg_attr(feature = "cuda", cuda(ignore))]
     #[serde(alias = "id", alias = "ref")]
     pub global_reference: GlobalLineageReference,
+    #[cfg_attr(feature = "cuda", cuda(ignore))]
     #[serde(alias = "time")]
     pub last_event_time: NonNegativeF64,
+    #[cfg_attr(feature = "cuda", cuda(embed))]
+    #[cfg_attr(feature = "cuda", cuda(ignore))]
     #[serde(alias = "loc")]
     pub indexed_location: IndexedLocation,
 }
 
 impl Lineage {
     #[must_use]
+    #[allow(clippy::no_effect_underscore_binding)]
     #[debug_ensures(
         ret.indexed_location == old(indexed_location.clone()),
         "stores the indexed_location"

necsim/core/src/reporter/boolean.rs

@@ -5,7 +5,7 @@ mod private {
     impl Sealed for super::False {}
 }
 
-pub trait Boolean: private::Sealed {
+pub trait Boolean: 'static + private::Sealed {
     const VALUE: bool;
 }
 

necsim/core/src/simulation/builder.rs

@@ -86,7 +86,7 @@ impl<
 }
 
 #[derive(Debug, TypeLayout)]
-#[cfg_attr(feature = "cuda", derive(rust_cuda::common::LendRustToCuda))]
+#[cfg_attr(feature = "cuda", derive(rust_cuda::lend::LendRustToCuda))]
 #[cfg_attr(feature = "cuda", cuda(free = "M"))]
 #[repr(C)]
 pub struct Simulation<

necsim/impls/cuda/Cargo.toml

@@ -15,7 +15,7 @@ contracts = "0.6.3"
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 
 [target.'cfg(target_os = "cuda")'.dependencies]
-rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "6b53e88", features = ["derive"] }
+rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "4148959", features = ["derive"] }
 
 [target.'cfg(not(target_os = "cuda"))'.dependencies]
-rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "6b53e88", features = ["derive", "host"] }
+rust-cuda = { git = "https://github.com/juntyr/rust-cuda", rev = "4148959", features = ["derive", "host"] }

necsim/impls/cuda/src/cogs/rng.rs

@@ -3,22 +3,34 @@ use core::marker::PhantomData;
 use necsim_core::cogs::{MathsCore, PrimeableRng, RngCore};
 
 use const_type_layout::TypeGraphLayout;
-use rust_cuda::safety::StackOnly;
+use rust_cuda::{
+    safety::{PortableBitSemantics, StackOnly},
+    utils::adapter::RustToCudaWithPortableBitCloneSemantics,
+};
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 #[allow(clippy::module_name_repetitions)]
-#[derive(Debug, rust_cuda::common::LendRustToCuda)]
+#[derive(Debug, rust_cuda::lend::LendRustToCuda)]
 #[cuda(free = "M", free = "R")]
 pub struct CudaRng<M: MathsCore, R>
 where
-    R: RngCore<M> + StackOnly + TypeGraphLayout,
+    R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout,
 {
-    inner: R,
+    #[cuda(embed)]
+    inner: RustToCudaWithPortableBitCloneSemantics<R>,
     marker: PhantomData<M>,
 }
 
-impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> Clone for CudaRng<M, R> {
+impl<M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout + Copy> Copy
+    for CudaRng<M, R>
+{
+}
+
+#[allow(clippy::expl_impl_clone_on_copy)]
+impl<M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout> Clone
+    for CudaRng<M, R>
+{
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
@@ -27,25 +39,29 @@ impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> Clone for CudaRn
     }
 }
 
-impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> From<R> for CudaRng<M, R> {
+impl<M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout> From<R>
+    for CudaRng<M, R>
+{
     #[must_use]
     #[inline]
     fn from(rng: R) -> Self {
         Self {
-            inner: rng,
+            inner: rng.into(),
             marker: PhantomData::<M>,
         }
     }
 }
 
-impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> RngCore<M> for CudaRng<M, R> {
+impl<M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout> RngCore<M>
+    for CudaRng<M, R>
+{
     type Seed = <R as RngCore<M>>::Seed;
 
     #[must_use]
     #[inline]
     fn from_seed(seed: Self::Seed) -> Self {
         Self {
-            inner: R::from_seed(seed),
+            inner: R::from_seed(seed).into(),
             marker: PhantomData::<M>,
         }
     }
@@ -57,26 +73,28 @@ impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> RngCore<M> for C
     }
 }
 
-impl<M: MathsCore, R: PrimeableRng<M> + StackOnly + TypeGraphLayout> PrimeableRng<M>
-    for CudaRng<M, R>
+impl<M: MathsCore, R: PrimeableRng<M> + StackOnly + PortableBitSemantics + TypeGraphLayout>
+    PrimeableRng<M> for CudaRng<M, R>
 {
     #[inline]
     fn prime_with(&mut self, location_index: u64, time_index: u64) {
         self.inner.prime_with(location_index, time_index);
     }
 }
 
-impl<M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> Serialize for CudaRng<M, R> {
+impl<M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout> Serialize
+    for CudaRng<M, R>
+{
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.inner.serialize(serializer)
     }
 }
 
-impl<'de, M: MathsCore, R: RngCore<M> + StackOnly + TypeGraphLayout> Deserialize<'de>
-    for CudaRng<M, R>
+impl<'de, M: MathsCore, R: RngCore<M> + StackOnly + PortableBitSemantics + TypeGraphLayout>
+    Deserialize<'de> for CudaRng<M, R>
 {
     fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
-        let inner = R::deserialize(deserializer)?;
+        let inner = R::deserialize(deserializer)?.into();
 
         Ok(Self {
             inner,