Returning a Buffer without memory copy

[overlookmotel]

I am trying to create a Buffer from another type which contains a NonNull<u8> pointer, without copying memory.

The type I start with is an AlignedVec from RKYV and trying to return the bytes to JS via a Buffer.

Here's my initial code:

#[napi]
pub fn parse(src: String) -> napi::Result<Buffer> {
  let program = parseImpl(src);
  let aligned_vec: rkyv::AlignedVec = rkyv::to_bytes::<_, 512>(&program).unwrap();
  let vec: Vec<u8> = aligned_vec.into_vec();
  let buffer = Buffer::from(vec);
  Ok(buffer)
}

If I comment out the lines from let vec onwards, there's a significant speed-up, so creating the Buffer seems to have a sizeable cost. I assume this is due to copying memory.

I also tried using a pointer:

let ptr: *mut u8 = aligned_vec.as_mut_ptr();
let len: usize = aligned_vec.len();
let capacity: usize = aligned_vec.capacity();
mem::forget(aligned_vec);
let vec = unsafe { Vec::from_raw_parts(ptr, len, capacity) };
let buffer = Buffer::from(vec);
Ok(buffer)

This performs the same. However, if I comment out mem::forget(aligned_vec);, it speeds up considerably, but the first 8 bytes of the buffer's data is corrupted.

Is there any way to avoid memory copy when creating a Buffer?

At present, I'm only converting to Vec as an intermediate as From<Vec<u8>> for Buffer implementation appears to be the most efficient and involves no memory copy. If there were a Buffer::from_raw_parts method, would that allow to avoid the copy in this case?

As you can probably tell from the way I'm talking, I'm new to Rust, so apologies if what I'm asking is stupid. Would really appreciate any help you can give.

Background on what I'm trying to achieve: swc-project/swc#2175

[Brooooooklyn]

You can use Env::create_buffer_with_borrowed_data for this scenario:

use napi::{bindgen_prelude::*, JsBuffer};
use napi_derive::napi;

#[napi]
pub fn parse(env: Env, src: String) -> napi::Result<JsBuffer> {
  let program = parseImpl(src);
  let aligned_vec: rkyv::AlignedVec = rkyv::to_bytes::<_, 512>(&program).unwrap();
  let aligned_data_len = aligned_vec.len();
  unsafe {
    env.create_buffer_with_borrowed_data(aligned_vec.as_ptr(), aligned_vec_len, aligned_vec, |aligned_vec, _| {
      drop(aligned_vec);
    })
  }
}

[overlookmotel]

Amazing! Thanks loads for your fast response. I'll try that and will report back.

[overlookmotel]

Sorry for very long silence. Work went nuts, and then I got Covid!

I'm afraid I'm still having trouble with this. Env::create_buffer_with_borrowed_data returns a JsBufferValue, so closest I could get to your code above is:

use napi::{ Env, JsBuffer };

#[napi]
pub fn parse_sync_to_buffer_fast(env: Env, src: String) -> napi::Result<JsBuffer> {
    let program = parseImpl(src);
    let aligned_vec: rkyv::AlignedVec = rkyv::to_bytes::<_, 512>(&program).convert_err()?;
    let aligned_vec_len = aligned_vec.len();
    let buffer_value = unsafe {
        env.create_buffer_with_borrowed_data(
            aligned_vec.as_ptr(),
            aligned_vec_len,
            aligned_vec,
            |aligned_vec, _| { drop(aligned_vec); },
        )?
    };
    Ok(buffer_value.into_raw())
}

This works, but does not improve the performance. In fact performance got slightly worse.

Buffer::from(slice) and return:
  2 702 ops/s, ±0.21%   | 7.18% slower

Buffer::from(slice) but buffer not returned to JS:
  2 745 ops/s, ±0.10%   | 5.7% slower

Env::create_buffer_with_borrowed_data:
  2 682 ops/s, ±0.28%   | slowest, 7.87% slower

Not converted to buffer at all:
  2 911 ops/s, ±0.08%   | fastest

I also tried returning JSBufferValue instead of JsBuffer but got a compile error the trait 'NapiRaw' is not implemented for 'JsBufferValue'.

I'm thoroughly confused why the operation of converting the AlignedVec to Buffer/JsBuffer is quite slow. Can you offer any advice?

Here's the full code: https://github.com/overlookmotel/swc/blob/fast-buffer/crates/binding_core_node/src/parse.rs#L279

[overlookmotel]

For anyone else who encounters this and is interested:

It turned out most of the slowdown I was experiencing was actually due to the JS benchmarking framework I used, which it turns out runs the entire benchmark synchronously with no breaks (ticks) between runs. This meant V8 had no opportunity to garbage collect, so buffers returned to JS ate up more and more memory as the benchmark progressed, whereas buffers that stayed on Rust side got freed promptly. It was the memory pressure which slowed down JS, more than the cost of conversion to a buffer, and once I inserted some ticks to allow buffers to be freed on JS side, the performance gap I was asking about above narrowed dramatically.

That said, I did also find a way to avoid a memory copy on Rust side which also yielded a speed gain:

let aligned_vec: rkyv::AlignedVec = rkyv::to_bytes::<_, 512>(&program).convert_err()?;

let buffer = unsafe {
  Uint8Array::with_external_data(
    aligned_vec.as_mut_ptr(),
    aligned_vec.len(),
    move |_ptr, _len| drop(aligned_vec),
  )
};

NB My understanding is that it's important to drop types with same layout they're created with. In this case rkyv::AlignedVec has alignment of 16, whereas Vec<u8> has alignment of 1, so transmuting to Vec<u8> and just handing that to napi-rs to deal with would be UB.