Sending vectors via an AsyncTask

[Libbum]

Hi Thomas, first of all - thank you so much for actively working on these julia <-> rust tools: they are invaluable!

I've read over lots of the documentation now and have had a decent amount of success getting what I need back and forth. Final piece of the puzzle I'm missing is sending (and later receiving) a few small vectors.

Setup:

• Base fully_async_tokio.rs
• A julia module I've baked into a sysimage and binded into a RuntimeBuilder.
• A pub static JULIA: OnceCell<Arc<AsyncJulia<Tokio>>> = OnceCell::new(); container for the runtime
• Two structs from Julia that I've generated decorations for via JlrsReflect.

Simplified versions of these:

struct Simple
      one::Float32
      two::Float32
end
  
struct Containers
      three::Vector{String}
      four::Vector{Float32}
end

here, three and four have a fixed length (~10 elements, but not known at compile time) and do not need to be modified.

Issue:
Modifying MyTask to attach the Containers struct.

On the rust side, we generate

#[repr(C)]    
#[derive(Clone, Debug, Unbox, ValidLayout, ValidField, Typecheck, IntoJulia)]    
#[jlrs(julia_type = "Main.Simple")]    
pub struct Simple {    
      pub one: f32,    
      pub two: f32,    
}    

#[repr(C)]    
#[derive(Clone, Debug, Unbox, ValidLayout, ValidField, Typecheck)]    
#[jlrs(julia_type = "Main.Containers")]    
pub struct Containers<'frame, 'data> {    
      pub three: ::std::option::Option<::jlrs::wrappers::ptr::array::ArrayRef<'frame, 'data>>, 
      pub four: ::std::option::Option<::jlrs::wrappers::ptr::array::ArrayRef<'frame, 'data>>,     
}  
// Looking for something like this as an outcome
struct MyTask {
      simple: Simple,
      containers: Containers,
}

If I add Copy to Simple, this is all I need to do, other than modifying the run method for MyTask and pass this as normal through the channel via julia.task(..., sender).await.

However, trying to do this with Containers—it really seems I'm going about this the wrong way? How do I deal with the lifetimes here? Is it sufficient to extend the decoration to #[async_trait(?Send + ?Sync)] to satisfy

This struct must be Send, Sync, and contain no borrowed data.

Since I'm looking to only send fixed length collections, can/should I leverage something like SimpleVector instead? How would I go about doing so in the fully_async_tokio.rs example layout?

[Taaitaaiger]

Hi Tim,

These generated wrappers provide a compatible layout for data of that type in Julia. Simple contains two floating point numbers which are stored inline, while in the case of Containers the two fields are stored as ArrayRef because Vector is a mutable type.

Because Simple doesn't contain any references to Julia data, it can exist outside a scope (i.e. a function or closure where you're able to use a GcFrame) and derives IntoJulia so it can be converted to a Value by calling Value::new. This isn't the case for Containers, you'll need to call the constructor from a scope, and it's not possible to have instances of this type outside of the scope that has rooted it.

I hope the following example clarifies how an instance of Containers can be created in an AsyncTask and the meaning of the lifetimes:

    struct MyTask {
        floats: Option<Vec<f32>>,
        strings: Option<Vec<String>>,
    }

    #[async_trait(?Send)]
    impl AsyncTask for MyTask {
        type Output = ();

        async fn run<'frame>(&mut self, mut frame: AsyncGcFrame<'frame>) -> JlrsResult<Self::Output> {
            let output = frame.output();

            // Construct an instance of `Containers` in a separate scope to prevent rooting temporary
            // data longer than necessary.
            let container = frame
                .scope(|mut frame| {
                    // An `Array{Float32}` can be directly constructed from `Vec<f32>`
                    let floats = self.floats.take().unwrap();
                    let n_floats = floats.len();
                    let float_vec = Array::from_vec(frame.as_extended_target(), floats, n_floats)?
                        .into_jlrs_result()?;

                    // Allocate a Array{String}
                    let strings = self.strings.take().unwrap();
                    let n_strings = strings.len();
                    let string_type = DataType::string_type(&frame).as_value();
                    let mut string_vec =
                        Array::new_for(frame.as_extended_target(), n_strings, string_type)
                            .into_jlrs_result()?;

                    // Convert each string to a `JuliaString` and put it in `string_vec`.
                    {
                        let mut tracked = string_vec.track_mut()?;
                        // Safety: this data was just allocated, it's not possible that some other Julia task
                        // is currently using this data.
                        let mut contents = unsafe { tracked.wrapper_data_mut::<StringRef>()? };

                        for (idx, s) in strings.into_iter().enumerate() {
                            // Convert each string in its own scope to avoid rooting a lot of temporary data.
                            frame.scope(|mut frame| {
                                let julia_string = JuliaString::new(&mut frame, s.as_str());
                                contents.set(idx, Some(julia_string.as_value()))?;
                                Ok(())
                            })?;
                        }
                    }

                    let containers_ctor = Module::main(&frame).global(&mut frame, "Containers")?;
                    // Safety: this constructor is safe to call
                    unsafe {
                        Ok(containers_ctor.call2(output, string_vec.as_value(), float_vec.as_value()))
                    }
                })?
                .into_jlrs_result()?;

            // Because `Containers` implements `Unbox` and `ValidLayout`, the data can be unboxed.
            // `unboxed_container` can't be returned from this scope though because the `ArrayRef`s it 
            // contains have the same lifetimes as `container` does. This ensure the data can't be used
            // after it has become unreachable after leaving the scope. The `'data` lifetime is `'static`
            // in this case because the the data in the arrays was moved from Rust to Julia, if the array
            // of floats had been created with `Array::from_slice` instead, that lifetime would have been
            // the lifetime of the borrow to ensure the data can only be used from Rust while the borrow 
            // is active.
            let unboxed_container = container.unbox::<Container>()?;
            Ok(())
        }
    }

[Libbum]

Thanks Thomas, this explains a lot and will certainly move me forward. I'll poke around and see if I can get a working system with these details 😃