Передача строки JavaScript в функцию Rust, скомпилированную в WebAssembly

Question

Передача строки JavaScript в функцию Rust, скомпилированную в WebAssembly

У меня есть эта простая функция Rust:

#[no_mangle]
pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
    match operator {
        "SUM" => n1 + n2,
        "DIFF" => n1 - n2,
        "MULT" => n1 * n2,
        "DIV" => n1 / n2,
        _ => 0
    }
}

Я успешно компилирую это в WebAssembly, но не могу передать operator параметр от JS до Rust.

Строка JS, которая вызывает функцию Rust, выглядит следующим образом:

instance.exports.compute(operator, n1, n2);

operator это JS String а также n1, n2 являются JS Numbers.

n1 а также n2 передаются правильно и могут быть прочитаны внутри скомпилированной функции, так что я думаю, проблема в том, как я передаю строку. Я предполагаю, что он передается как указатель от JS на WebAssembly, но не может найти доказательства или материал о том, как это работает.

Я не использую Emscripten и хотел бы оставить его автономным (цель компиляции wasm32-unknown-unknown), но я вижу, что они оборачивают свои скомпилированные функции в Module.cwrapМожет быть, это могло бы помочь?

11

javascript string rust webassembly

Источник

user2432221 27 фев '18 в 17:29

3 ответа

Решение

Программа WebAssembly имеет свое собственное пространство памяти. И этим пространством часто управляет сама программа WebAssembly с помощью библиотеки распределителей, такой как wee_alloc.

JavaScript может видеть и изменять это пространство памяти, но у него нет возможности узнать, как организованы структуры библиотеки распределителя. Так что, если мы просто запишем в память WASM из JavaScript, мы, вероятно, перепишем что-то важное и испортим. Поэтому сама программа WebAssembly должна сначала выделить область памяти, передать ее в JavaScript, а затем JavaScript может заполнить эту область данными.

В следующем примере мы делаем именно это: выделяем буфер в пространстве памяти WASM, копируем туда байты UTF-8, передаем местоположение буфера в функцию Rust, затем освобождаем буфер.

Ржавчина:

#![feature(allocator_api)]

use std::heap::{Alloc, Heap, Layout};

#[no_mangle]
pub fn alloc(len: i32) -> *mut u8 {
    let mut heap = Heap;
    let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
    unsafe { heap.alloc(layout).expect("!alloc") }
}

#[no_mangle]
pub fn dealloc(ptr: *mut u8, len: i32) {
    let mut heap = Heap;
    let layout = Layout::from_size_align(len as usize, 1).expect("!from_size_align");
    unsafe { heap.dealloc(ptr, layout) }
}

#[no_mangle]
pub fn is_foobar(buf: *const u8, len: i32) -> i32 {
    let js = unsafe { std::slice::from_raw_parts(buf, len as usize) };
    let js = unsafe { std::str::from_utf8_unchecked(js) };
    if js == "foobar" {
        1
    } else {
        0
    }
}

Машинопись:

// cf. https://github.com/Microsoft/TypeScript/issues/18099
declare class TextEncoder {constructor (label?: string); encode (input?: string): Uint8Array}
declare class TextDecoder {constructor (utfLabel?: string); decode (input?: ArrayBufferView): string}
// https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/webassembly-js-api/index.d.ts
declare namespace WebAssembly {
  class Instance {readonly exports: any}
  interface ResultObject {instance: Instance}
  function instantiateStreaming (file: Promise<Response>, options?: any): Promise<ResultObject>}

var main: {
  memory: {readonly buffer: ArrayBuffer}
  alloc (size: number): number
  dealloc (ptr: number, len: number): void
  is_foobar (buf: number, len: number): number}

function withRustString (str: string, cb: (ptr: number, len: number) => any): any {
  // Convert the JavaScript string to an array of UTF-8 bytes.
  const utf8 = (new TextEncoder()).encode (str)
  // Reserve a WASM memory buffer for the UTF-8 array.
  const rsBuf = main.alloc (utf8.length)
  // Copy the UTF-8 array into the WASM memory.
  new Uint8Array (main.memory.buffer, rsBuf, utf8.length) .set (utf8)
  // Pass the WASM memory location and size into the callback.
  const ret = cb (rsBuf, utf8.length)
  // Free the WASM memory buffer.
  main.dealloc (rsBuf, utf8.length)
  return ret}

WebAssembly.instantiateStreaming (fetch ('main.wasm')) .then (results => {
  main = results.instance.exports
  // Prints "foobar is_foobar? 1".
  console.log ('foobar is_foobar? ' +
    withRustString ("foobar", function (buf, len) {return main.is_foobar (buf, len)}))
  // Prints "woot is_foobar? 0".
  console.log ('woot is_foobar? ' +
    withRustString ("woot", function (buf, len) {return main.is_foobar (buf, len)}))})

PS The Module._malloc в Emscripten может быть семантически эквивалентно alloc Функция, которую мы реализовали выше. Под целью "wasm32-unknown-emscripten" вы можете использовать Module._malloc с ржавчиной

3

Источник

user257568 11 мар '18 в 22:12

Как указывает Shepmaster, в WebAssembly могут быть переданы только числа, поэтому нам нужно преобразовать строку в Uint16Array,

Для этого мы можем использовать это str2ab Функция найдена здесь:

function str2ab(str) {
  var buf = new ArrayBuffer(str.length*2); // 2 bytes for each char
  var bufView = new Uint16Array(buf);
  for (var i=0, strLen=str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }
  return buf;
}

Теперь это работает:

instance.exports.compute(
    str2ab(operator), 
    n1, n2
);

Потому что мы передаем ссылку на массив целых чисел без знака.

-2

Источник

user2432221 27 фев '18 в 19:19

Другие вопросы по тегам javascript string rust webassembly

user155423 28 фев '18 в 01:06 2018-02-28 01:06 · Accepted Answer · 2018-02-28 01:06

Для передачи строковых данных между JavaScript и Rust вам необходимо решить

Кодировка текста: UTF-8 (Rust native) или UTF-16 (JS native).
Кому будет принадлежать буфер памяти: JS (вызывающий) или Rust (вызываемый).
Как представить данные и длину строк: NUL-концевые (в стиле C) или разные длины (в стиле Rust).
Как сообщать данные и длину, если они раздельные.

Решение 1

Я решила:

Чтобы преобразовать строки JS в UTF-8, это означает, что TextEncoder JS API подходит лучше всего.
Вызывающая сторона должна владеть буфером памяти.
Чтобы длина была отдельным значением.
Другая структура и распределение должны быть сделаны для хранения указателя и длины.

Lib/src.rs

// Inform Rust that memory will be provided 
#![feature(wasm_import_memory)]
#![wasm_import_memory]

// A struct with a known memory layout that we can pass string information in
#[repr(C)]
pub struct JsInteropString {
    data: *const u8,
    len: usize,
}

// Our FFI shim function    
#[no_mangle]
pub unsafe extern "C" fn compute(s: *const JsInteropString, n1: i32, n2: i32) -> i32 {
    // Check for NULL (see corresponding comment in JS)
    let s = match s.as_ref() {
        Some(s) => s,
        None => return -1,
    };

    // Convert the pointer and length to a `&[u8]`.
    let data = std::slice::from_raw_parts(s.data, s.len);

    // Convert the `&[u8]` to a `&str`    
    match std::str::from_utf8(data) {
        Ok(s) => real_code::compute(s, n1, n2),
        Err(_) => -2,
    }
}

// I advocate that you keep your interesting code in a different
// crate for easy development and testing. Have a separate crate
// with the FFI shims.
mod real_code {
    pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
        match operator {
            "SUM"  => n1 + n2,
            "DIFF" => n1 - n2,
            "MULT" => n1 * n2,
            "DIV"  => n1 / n2,
            _ => 0,
        }
    }
}

Важно создать C-dylibs для WASM, чтобы они были меньше по размеру.

Cargo.toml

[package]
name = "quick-maths"
version = "0.1.0"
authors = ["An Devloper <an.devloper@example.com>"]

[lib]
crate-type = ["cdylib"]

Для чего это стоит, я запускаю этот код в Node, а не в браузере.

index.js

const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');

// Allocate some memory.
const memory = new WebAssembly.Memory({ initial: 20, maximum: 100 });

// Connect these memory regions to the imported module
const importObject = {
  env: { memory }
};

// Create an object that handles converting our strings for us
const memoryManager = (memory) => {
  var base = 0;

  // NULL is conventionally at address 0, so we "use up" the first 4
  // bytes of address space to make our lives a bit simpler.
  base += 4;

  return {
    encodeString: (jsString) => {
      // Convert the JS String to UTF-8 data
      const encoder = new TextEncoder();
      const encodedString = encoder.encode(jsString);

      // Organize memory with space for the JsInteropString at the
      // beginning, followed by the UTF-8 string bytes.
      const asU32 = new Uint32Array(memory.buffer, base, 2);
      const asBytes = new Uint8Array(memory.buffer, asU32.byteOffset + asU32.byteLength, encodedString.length);

      // Copy the UTF-8 into the WASM memory.
      asBytes.set(encodedString);

      // Assign the data pointer and length values.
      asU32[0] = asBytes.byteOffset;
      asU32[1] = asBytes.length;

      // Update our memory allocator base address for the next call
      const originalBase = base;
      base += asBytes.byteOffset + asBytes.byteLength;

      return originalBase;
    }
  };
};

const myMemory = memoryManager(memory);

fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm')
  .then(bytes => WebAssembly.instantiate(bytes, importObject))
  .then(({ instance }) => {
    const argString = "MULT";
    const argN1 = 42;
    const argN2 = 100;

    const s = myMemory.encodeString(argString);
    const result = instance.exports.compute(s, argN1, argN2);

    console.log(result);
  });

Решение 2

Я решила:

Чтобы преобразовать строки JS в UTF-8, это означает, что TextEncoder JS API подходит лучше всего.
Модуль должен владеть буфером памяти.
Чтобы длина была отдельным значением.
Использовать Box<String> в качестве базовой структуры данных. Это позволяет распределению использоваться далее кодом Rust.

SRC / lib.rs

#![feature(repr_transparent)]

// Very important to use `transparent` to prevent ABI issues 
#[repr(transparent)]
pub struct JsInteropString(*mut String);

impl JsInteropString {
    // Unsafe because we create a string and say it's full of valid
    // UTF-8 data, but it isn't!
    unsafe fn with_capacity(cap: usize) -> Self {
        let mut d = Vec::with_capacity(cap);
        d.set_len(cap);
        let s = Box::new(String::from_utf8_unchecked(d));
        JsInteropString(Box::into_raw(s))
    }

    unsafe fn as_string(&self) -> &String {
        &*self.0
    }

    unsafe fn as_mut_string(&mut self) -> &mut String {
        &mut *self.0
    }

    unsafe fn into_boxed_string(self) -> Box<String> {
        Box::from_raw(self.0)
    }

    unsafe fn as_mut_ptr(&mut self) -> *mut u8 {
        self.as_mut_string().as_mut_vec().as_mut_ptr()
    }
}

#[no_mangle]
pub unsafe extern "C" fn stringPrepare(cap: usize) -> JsInteropString {
    JsInteropString::with_capacity(cap)
}

#[no_mangle]
pub unsafe extern "C" fn stringData(mut s: JsInteropString) -> *mut u8 {
    s.as_mut_ptr()
}

#[no_mangle]
pub unsafe extern "C" fn stringLen(s: JsInteropString) -> usize {
    s.as_string().len()
}

#[no_mangle]
pub unsafe extern "C" fn compute(s: JsInteropString, n1: i32, n2: i32) -> i32 {
    let s = s.into_boxed_string();
    real_code::compute(&s, n1, n2)
}

mod real_code {
    pub fn compute(operator: &str, n1: i32, n2: i32) -> i32 {
        match operator {
            "SUM"  => n1 + n2,
            "DIFF" => n1 - n2,
            "MULT" => n1 * n2,
            "DIV"  => n1 / n2,
            _ => 0,
        }
    }
}

index.js

const fs = require('fs-extra');
const { TextEncoder } = require('text-encoding');

class QuickMaths {
  constructor(instance) {
    this.instance = instance;
  }

  difference(n1, n2) {
    const { compute } = this.instance.exports;
    const op = this.copyJsStringToRust("DIFF");
    return compute(op, n1, n2);
  }

  copyJsStringToRust(jsString) {
    const { memory, stringPrepare, stringData, stringLen } = this.instance.exports;

    const encoder = new TextEncoder();
    const encodedString = encoder.encode(jsString);

    // Ask Rust code to allocate a string inside of the module's memory
    const rustString = stringPrepare(encodedString.length);

    // Get a JS view of the string data
    const rustStringData = stringData(rustString);
    const asBytes = new Uint8Array(memory.buffer, rustStringData, encodedString.length);

    // Copy the UTF-8 into the WASM memory.
    asBytes.set(encodedString);

    return rustString;
  }
}

async function main() {
  const bytes = await fs.readFile('./target/wasm32-unknown-unknown/release/quick_maths.wasm');
  const { instance } = await WebAssembly.instantiate(bytes);
  const maffs = new QuickMaths(instance);

  console.log(maffs.difference(100, 201));
}

main();

Обратите внимание, что этот процесс может быть использован для других типов. Вы "просто" должны решить, как представить данные в виде набора байтов, с которыми согласны обе стороны, и затем передать их.

Смотрите также:

Использование JavaScript API WebAssembly
TextEncoder API
Uint8Array / Uint32Array / TypedArray
WebAssembly.Memory
Привет, Руст! - Импорт буфера памяти
Как вернуть строку (или аналогичную) из Rust в WebAssembly?