zero copy vec of types

[Roms1383]

Hi! Yesterday I was reading through the book again and came to wonder if it's possible to zero copy a big vec of typed instances. I initially thought about using a ZeroCopyBuffer and cast it to the Dart type on the other side of the wire, but quickly recalled that what Rust will send probably cannot be cast into a Dart type as I guess its underlying representation to be different. How would you approach this? Are there alternatives that I completely overlooked?
Thanks

[fzyzcjy]

ZeroCopyBuffer relys on the underlying Dart C api: https://github.com/sunshine-protocol/allo-isolate/blob/913b17dfb34b3a63bbbf4ddb282e97b8340e3e0e/src/ffi.rs#L56 i.e. https://github.com/dart-lang/sdk/blob/main/runtime/include/dart_native_api.h

Thus, given that Dart only exposes a C api that represents u8/i8/... arrays, we seem to have no other approaches at the first glance.

However there do seem to exist an approach

you may use "wrappers" around raw bytes. For example, say I have struct S {a: u8, b: u8} and suppose each field align to 4 bytes (only for simplicity!). Then we can do the following to zero-copy a Vec<S> to Dart:

1. We are given a Vec<S>
2. Use bytemuck or other crate, to convert to Vec<u8> without memory copy
3. send it to Dart using ZeroCopyBuffer, no mem copy
4. In Dart, we get Uint8List, but do the following:

class VecOfS {
  final Uint8List data;
  VecOfS(this.data);

  ProxyOfS operator[](int index) => ProxyOfS(this, index);
}

class ProxyOfS {
  final VecOfS vec;
  final int index;

  int get a => vec.data[index * 8];
  int get b => vec.data[index * 8 + 4];
}

Usage:

var vecOfS = await api.callTheRustApiThatReturnVecOfS();
vecOfS[0].a;
vecOfS[42].b;
...

Feel free to PR!

[Roms1383]

tbh I don't know what is deviation @huang12zheng
does that mean otherwise that, if Rust struct is aligned with 4 bytes padding, on the other side of the wire it can be cast in its Dart representation? I'm sorry guys, my understanding is still very limited in this area.

[Roms1383]

I was wondering about something but maybe I'm completely mislead.
What if, through a Rust struct we force the user to pass ownership (without any way to come mutate it afterwards), then lay it out in memory into what Dart expects to find and is able to decode, then std::mem::forget and send the pointer over the wire ?
Isn't that kind of approach possible ?

[fzyzcjy]

into what Dart expects to find and is able to decode

(1) If talking about arbitrary types: Dart's C api does not provide a way for arbitrary types.
(2) If talking about my "VecOfS" approach above - we have already implemented it, just use ZeroCopyBuffer

[Roms1383]

Well I think it's too early for me to venture there. If I have a chance to read through flutter_rust_bridge's codebase thoroughly and better grap its inner mechanisms, maybe I'll give a try in the future.

[fzyzcjy]

Sure, take your time! Btw don't forget these chapters, e.g. http://cjycode.com/flutter_rust_bridge/contributing/design.html

[huang12zheng]

I am not familiar with the DART API, or the nature of fridge, so I welcome any reply. Or point out the ones I forget. @fzyzcjy

As Fzyzcjy put it:

1. https://github.com/dart-lang/sdk/blob/main/runtime/include/dart_native_api.h
   Dart exposes a number of types (kind of 14) that you can use to convert
   But these types are relatively simple, which means that if you are a complex type, you might choose to cast to the nested 14 types.
   In particular, multiple types in Rust may correspond to one of the DART types.

Meanwhile, in the fridge, we used the Nest IntoDart to generate nest DartCObjectType.
it is to adjust the memory data in different languages.
so computed from memory to CPU.
To speed up CPU computation, we might need to know where the data is,
It's better if it's in a contiguous block of memory

tbh I don't know what is deviation @Roms1383
That might be the answer to your question

If it's a nested object, how is that different from serialization?
Dart to Rust is out of my mind, but it's probably just deserialization.

2.1. Then it becomes a question of needing another, faster method,
Or,
2.2. that memory in Rust was DartCObjectType from the beginning,

The first scenario, I didn't test it, I just follow Fzyzcjy's reply, And with the above supplementary information. But there maybe no mistakes.

I think flatbuffers only hold nested meat information and values. In other words, meat information and the type of nest DartCObjectType should be equivalent. But it doesn't have to make the CPU wonder where the hell my data is, so I think it might be faster.

For the second scenario, which has the same memory across languages (so you don't need a CPU to compute it).

idea from arrow2, I haven't seen the code for arrow2, but the second scenario should not be consistent from the beginning, so there should be serializations as well, but when used later, it's all in that format.

I was wondering about something but maybe I'm completely mislead. @Roms1383
What if, through a Rust struct we force the user to pass ownership (without any way to come mutate it afterwards), then lay it out in memory into what Dart expects to find and is able to decode, then std::mem::forget and send the pointer over the wire ?

if in second scenario, your idea maybe work. But, you need to implement a lib like arrow2.