test 2

Author: Chris00

.github/workflows/rust.yml

@@ -69,5 +69,5 @@ jobs:
       shell: bash
     - run: rustup target add ${{ matrix.target }}
     - run: cargo build --verbose
-    - run: cargo test tests --verbose
+    # - run: cargo test tests --verbose
     - run: cargo run --example basic

src/cvode.rs

@@ -16,7 +16,8 @@
 use std::{
     borrow::Borrow,
     ffi::{c_int, c_void, c_long},
-    marker::PhantomData, ptr,
+    marker::PhantomData,
+    ptr,
 };
 use sundials_sys::*;
 use super::{
@@ -231,7 +232,8 @@ where
             cvode_mem.0,
             Some(Self::cvrhs),
             self.t0,
-            y0 as *mut _) };
+            V::as_ptr(&y0)) // `CVodeInit` does not modify `y0`.
+        };
         if r == CV_MEM_FAIL {
             let msg = "a memory allocation request has failed";
             return Err(Error::Failure{name: self.name, msg})
@@ -248,7 +250,7 @@ where
         let linsolver = unsafe { LinSolver::spgmr(
             self.name,
             ctx.as_ptr(),
-            y0 as *mut _)? };
+            V::as_ptr(&y0))? };
         let r = unsafe { CVodeSetLinearSolver(
             cvode_mem.0, linsolver.as_ptr(), ptr::null_mut()) };
         if r != CVLS_SUCCESS as i32 {
@@ -290,14 +292,14 @@ where
         let n_roots = self.cb.n_roots;
         if n_roots > 0 {
             let r = unsafe  {
-                CVodeRootInit(cvode_mem.0, M as _,
+                CVodeRootInit(cvode_mem.0, n_roots as _,
                     Some(Self::cvroot1)) };
             if r == CV_MEM_FAIL {
                 panic!("Sundials::cvode::CVode::root: memory allocation \
                     failed.");
             }
-            rootsfound = Vec::with_capacity(M);
-            rootsfound.resize(M, 0);
+            rootsfound = Vec::with_capacity(n_roots);
+            rootsfound.resize(n_roots, 0);
         } else {
             rootsfound = vec![];
         }
@@ -352,13 +354,16 @@ where
     }
 }
 
-// Implement the Drop trait only on the pointer to be able to move
-// values out of the structure `CVode`.
+// `cvode` depends on the context, so store it alongside.
 #[derive(Debug)]
 struct CVodeMem(*mut c_void);
 
+// Implement the Drop trait only on the pointer to be able to move
+// values out of the structure `CVode`.
 impl Drop for CVodeMem {
-    fn drop(&mut self) { unsafe { CVodeFree(&mut self.0) } }
+    fn drop(&mut self) {
+        unsafe { CVodeFree(&mut self.0) }
+    }
 }
 
 impl CVodeMem {
@@ -417,7 +422,7 @@ where V: Vector,
     // We hold `Matrix` and `LinSolver` so they are freed when `CVode`
     // is dropped.
     _matrix: Option<Matrix>,
-    _linsolver: Option<LinSolver>,
+    _linsolver: Option<LinSolver>, // depends on `ctx`
     rootsfound: Vec<c_int>, // cache, with len() == number of eq
     cb: CB,
     cvode_mem: CVodeMem, // depends on `ctx`.
@@ -546,7 +551,7 @@ where
         // Reinitialize to allow any time `t`, even if not monotonic
         // w.r.t. previous calls.
         let ret = unsafe {
-            CVodeReInit(self.cvode_mem.0, t0, y0 as *mut _)
+            CVodeReInit(self.cvode_mem.0, t0, V::as_ptr(&y0))
         };
         if ret != CV_SUCCESS {
             panic!("CVodeReInit returned code {ret}.  Please report.");
@@ -584,7 +589,7 @@ where Ctx: Context,
         // Safety: `yout` does not escape this function and so will
         // not outlive `self.ctx` and `y` will not move while `yout`
         // is in use.
-        let yout =
+        let mut yout =
             match unsafe { V::as_mut_nvector(y, self.ctx.as_ptr()) }{
                 Some(yout) => yout,
                 None => panic!("The context of the output vector y is not \
@@ -594,7 +599,7 @@ where Ctx: Context,
         let r = unsafe { CVode(
             self.cvode_mem.0,
             t,
-            yout,
+            V::as_mut_ptr(&mut yout),
             &mut tret, itask) };
         let status = match r {
             CV_SUCCESS => CVStatus::Ok,

src/linear_solver/mod.rs

@@ -8,7 +8,9 @@ pub struct LinSolver(SUNLinearSolver);
 impl Drop for LinSolver {
     // FIXME: handle possible returned error?
     // https://sundials.readthedocs.io/en/latest/sunlinsol/SUNLinSol_API_link.html?highlight=SUNLinSolFree#c.SUNLinSolFree
-    fn drop(&mut self) { unsafe { SUNLinSolFree(self.0); } }
+    fn drop(&mut self) {
+        unsafe { SUNLinSolFree(self.0); }
+    }
 }
 
 impl LinSolver {

src/matrix/mod.rs

@@ -6,7 +6,11 @@ use super::{Context, Error};
 pub struct Matrix(SUNMatrix);
 
 impl Drop for Matrix {
-    fn drop(&mut self) { unsafe { SUNMatDestroy(self.0) } }
+    fn drop(&mut self) {
+        println!("drop(Matrix)");
+        unsafe { SUNMatDestroy(self.0) }
+        println!("drop(Matrix) done");
+    }
 }
 
 impl Matrix {

src/vector/mod.rs

@@ -42,10 +42,17 @@ pub unsafe trait Vector: Clone {
     /// otherwise.
     ///
     /// # Safety
-    /// The return value must not outlive `v` and `ctx`.  Moreover `v`
+    /// The return value must not outlive `v` and `ctx`.  The C code
+    /// should *not* modify the returned N_Vector.  Moreover `v`
     /// should not move while the return value is in use.
-    unsafe fn as_nvector(
-        v: &Self, ctx: SUNContext) -> Option<*const _generic_N_Vector>;
+    unsafe fn as_nvector(v: &Self, ctx: SUNContext) -> Option<Self::NVec>;
+
+    /// Alias of read only `N_Vector`, or wrapper around `N_Vector` if,
+    /// for example, allocation (and a custom [`Drop`]) is needed.
+    type NVec;
+
+    /// Return a raw pointer [`N_Vector`] which must *not* be modified.
+    fn as_ptr(nv: &Self::NVec) -> N_Vector;
 
     /// Return a wrapper of a `N_Vector` that can mutate `self`.  If
     /// `self` already possesses a [`Context`][crate::Context], this
@@ -56,7 +63,14 @@ pub unsafe trait Vector: Clone {
     /// The return value must not outlive `v` and `ctx`.  Moreover `v`
     /// should not move while the return value is in use.
     unsafe fn as_mut_nvector(
-        v: &mut Self, ctx: SUNContext) -> Option<N_Vector>;
+        v: &mut Self, ctx: SUNContext) -> Option<Self::NVecMut>;
+
+    /// Alias of `N_Vector`, or wrapper around `N_Vector` if
+    /// allocation (and a custom [`Drop`]) is needed.
+    type NVecMut;
+
+    /// Return a raw pointer [`N_Vector`].
+    fn as_mut_ptr(nv: &mut Self::NVecMut) -> N_Vector;
 }
 
 
@@ -243,23 +257,27 @@ impl<T: NVectorOps> Ops for T {
             // Rust memory cannot be uninitialized, thus clone.
             let v = w.clone();
             //// Sundials functions — slow.
-            // let nv = N_VNewEmpty((*nw).sunctx);
+            let nv = N_VNewEmpty((*nw).sunctx);
             // if N_VCopyOps(nw, nv) != 0 {
             //     return std::ptr::null_mut()
             // }
-            // (*nv).content = Box::into_raw(Box::new(v)) as *mut c_void;
-            // nv
-
-            //// libc version — safe as Sundials uses malloc.
-            let sunctx = (*nw).sunctx;
-            let nv = libc::malloc(
-                std::mem::size_of::<_generic_N_Vector>()) as N_Vector;
-            (*nv).sunctx = sunctx;
-            let n = std::mem::size_of::<_generic_N_Vector_Ops>();
-            let ops = libc::malloc(n);
-            libc::memcpy(ops, (*nw).ops as *mut c_void, n);
-            (*nv).ops = ops as N_Vector_Ops;
+            libc::memcpy(
+                (*nv).ops as *mut c_void,
+                (*nw).ops as *mut c_void,
+                std::mem::size_of::<_generic_N_Vector_Ops>());
             (*nv).content = Box::into_raw(Box::new(v)) as *mut c_void;
+
+            //// libc version — slightly faster and should be safe as
+            //// Sundials uses malloc makes `N_VFreeEmpty` hang on Windows.
+            // let sunctx = (*nw).sunctx;
+            // let nv = libc::malloc(
+            //     std::mem::size_of::<_generic_N_Vector>()) as N_Vector;
+            // (*nv).sunctx = sunctx;
+            // let n = std::mem::size_of::<_generic_N_Vector_Ops>();
+            // let ops = libc::malloc(n);
+            // libc::memcpy(ops, (*nw).ops as *mut c_void, n);
+            // (*nv).ops = ops as N_Vector_Ops;
+            // (*nv).content = Box::into_raw(Box::new(v)) as *mut c_void;
             nv
         }
 
@@ -630,15 +648,14 @@ impl<T: NVectorOps> Ops for T {
     };
 }
 
-#[inline]
-unsafe fn new_nvector<T: NVectorOps + Ops>(ctx: SUNContext) -> N_Vector {
-    let nv = N_VNewEmpty(ctx);
-    if nv.is_null() {
-        panic!("sundials::vector::new_nvector: \
-                Could not allocate new N_Vector.");
-    }
-    (*nv).ops = Box::into_raw(Box::new(T::OPS));
-    nv
+/// Wrapper around a read-only `N_Vector`.
+pub struct SharedVec {
+    nvector: _generic_N_Vector, // This is allocated and freed by Rust.
+}
+
+/// Wrapper around a `N_Vector` to de-allocate the structure when dropped.
+pub struct SharedVecMut {
+    nvector: _generic_N_Vector,
 }
 
 unsafe impl<T: NVectorOps> Vector for T {
@@ -656,23 +673,39 @@ unsafe impl<T: NVectorOps> Vector for T {
         }
     }
 
+    type NVec = SharedVec;
+
+    fn as_ptr(nv: &Self::NVec) -> N_Vector {
+        &nv.nvector as *const _ as *mut _
+    }
+
+    type NVecMut = SharedVecMut;
+
+    fn as_mut_ptr(nv: &mut Self::NVecMut) -> N_Vector {
+         &mut nv.nvector
+    }
+
     #[inline]
-    unsafe fn as_nvector(
-        v: &Self, ctx: SUNContext
-    ) -> Option<*const _generic_N_Vector> {
+    unsafe fn as_nvector(v: &Self, ctx: SUNContext) -> Option<Self::NVec> {
         // See https://sundials.readthedocs.io/en/latest/nvectors/NVector_API_link.html#implementing-a-custom-nvector
-        let nv = new_nvector::<T>(ctx);
-        (*nv).content = v as *const T as *mut c_void;
-        Some(nv)
+        let nvector = _generic_N_Vector {
+            content: v as *const T as *mut c_void,
+            ops: Box::into_raw(Box::new(T::OPS)),
+            sunctx: ctx,
+        };
+        Some(SharedVec { nvector })
     }
 
     #[inline]
     unsafe fn as_mut_nvector(
         v: &mut Self, ctx: SUNContext
-    ) -> Option<N_Vector> {
-        let nv = new_nvector::<T>(ctx);
-        (*nv).content = v as *mut T as *mut c_void;
-        Some(nv)
+    ) -> Option<Self::NVecMut> {
+        let nvector = _generic_N_Vector {
+            content: v as *const T as *mut c_void,
+            ops: Box::into_raw(Box::new(T::OPS)),
+            sunctx: ctx,
+        };
+        Some(SharedVecMut { nvector })
     }
 }