Class: Wasmtime::Store

Inherits:
Object
  • Object
show all
Defined in:
ext/src/ruby_api/store.rs

Overview

Represents a WebAssembly store.

See Also:

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.new(engine, data = nil, wasi_config: nil, wasi_p1_config: nil, limits: nil) ⇒ Wasmtime::Store

Examples:

store = Wasmtime::Store.new(Wasmtime::Engine.new)
store = Wasmtime::Store.new(Wasmtime::Engine.new, {})

Parameters:

  • engine (Wasmtime::Engine) —

    The engine for this store.

  • data (Object) (defaults to: nil) —

    The data attached to the store. Can be retrieved through #data and Caller#data.

  • wasi_config (Wasmtime::WasiConfig) (defaults to: nil) —

    The WASI config to use in this store.

  • wasi_p1_config (Wasmtime::WasiConfig) (defaults to: nil) —

    The WASI config to use in this store for WASI preview 1.

  • limits (Hash) (defaults to: nil) —

    See the +StoreLimitsBuilder+'s Rust doc for detailed description of the different options and the defaults.

Options Hash (limits:):

  • memory_size (Integer) —

    The maximum number of bytes a linear memory can grow to.

  • table_elements (Integer) —

    The maximum number of elements in a table.

  • instances (Integer) —

    The maximum number of instances that can be created for a Store.

  • tables (Integer) —

    The maximum number of tables that can be created for a Store.

  • memories (Integer) —

    The maximum number of linear memories that can be created for a Store.

Returns:



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
 
# File 'ext/src/ruby_api/store.rs', line 179

pub fn new(args: &[Value]) -> Result<Self, Error> {
    let ruby = Ruby::get().unwrap();
    let args = scan_args::scan_args::<(&Engine,), (Option<Value>,), (), (), _, ()>(args)?;
    let kw = scan_args::get_kwargs::<
        _,
        (),
        (Option<&WasiConfig>, Option<&WasiConfig>, Option<RHash>),
        (),
    >(
        args.keywords,
        &[],
        &[*WASI_CONFIG, *WASI_P1_CONFIG, *LIMITS],
    )?;

    let (engine,) = args.required;
    let (user_data,) = args.optional;
    let user_data = user_data.unwrap_or_else(|| ().into_value_with(&ruby));
    let wasi_config = kw.optional.0;
    let wasi_p1_config = kw.optional.1;

    let (wasi, wasi_retained) = wasi_config
        .map(|wasi_config| wasi_config.build(&ruby))
        .transpose()?
        .unzip();
    let (wasi_p1, wasi_p1_retained) = wasi_p1_config
        .map(|wasi_config| wasi_config.build_p1(&ruby))
        .transpose()?
        .unzip();

    // Store all WasiRetainedData to support both wasi and wasi_p1 configs
    let wasi_retained_data: Vec<WasiRetainedData> = [wasi_retained, wasi_p1_retained]
        .into_iter()
        .flatten()
        .flatten()
        .collect();

    let limiter = match kw.optional.2 {
        None => StoreLimitsBuilder::new(),
        Some(limits) => hash_to_store_limits_builder(&ruby, limits)?,
    }
    .build();
    let limiter = TrackingResourceLimiter::new(limiter);

    let eng = engine.get();
    let store_data = StoreData {
        user_data,
        wasi_p1,
        wasi,
        refs: Default::default(),
        wasi_retained_data,
        last_error: Default::default(),
        store_limits: limiter,
        resource_table: Default::default(),
    };
    let store = Self {
        inner: UnsafeCell::new(StoreImpl::new(eng, store_data)),
    };

    unsafe { &mut *store.inner.get() }.limiter(|data| &mut data.store_limits);

    Ok(store)
}

Instance Method Details

#data ⇒ Object

Returns The passed in value in new.

Returns:

  • (Object) —

    The passed in value in new



244
245
246
 
# File 'ext/src/ruby_api/store.rs', line 244

pub fn data(&self) -> Value {
    self.context().data().user_data()
}

#get_fuel ⇒ Integer

Returns the amount of fuel in the Wasmtime::Store.

Returns:

  • (Integer)

Raises:

  • (Error) —

    if fuel consumption is not enabled via Engine#new



253
254
255
 
# File 'ext/src/ruby_api/store.rs', line 253

pub fn get_fuel(&self) -> Result<u64, Error> {
    self.inner_ref().get_fuel().map_err(|e| error!("{}", e))
}

#linear_memory_limit_hit? ⇒ Boolean

Returns whether the linear memory limit has been hit.

Returns:

  • (Boolean) 


289
290
291
 
# File 'ext/src/ruby_api/store.rs', line 289

pub fn linear_memory_limit_hit(&self) -> bool {
    self.context().data().store_limits.linear_memory_limit_hit()
}

#max_linear_memory_consumed ⇒ Integer

Returns the maximum linear memory consumed.

Returns:

  • (Integer) 


297
298
299
300
301
302
 
# File 'ext/src/ruby_api/store.rs', line 297

pub fn max_linear_memory_consumed(&self) -> usize {
    self.context()
        .data()
        .store_limits
        .max_linear_memory_consumed()
}

#set_epoch_deadline(ticks_beyond_current) ⇒ nil

Sets the epoch deadline to a certain number of ticks in the future.

Raises if there isn't enough fuel left in the Wasmtime::Store, or when the Engine's config does not have fuel enabled.

Parameters:

  • ticks_beyond_current (Integer) —

    The number of ticks before this store reaches the deadline.

Returns:

  • (nil)

See Also:



280
281
282
 
# File 'ext/src/ruby_api/store.rs', line 280

pub fn set_epoch_deadline(&self, ticks_beyond_current: u64) {
    unsafe { &mut *self.inner.get() }.set_epoch_deadline(ticks_beyond_current);
}

#set_fuel(fuel) ⇒ Object

Sets fuel to the Wasmtime::Store.

Parameters:

  • fuel (Integer) —

    The new fuel amount.

Raises:

  • (Error) —

    if fuel consumption is not enabled via Engine#new



262
263
264
265
266
267
268
 
# File 'ext/src/ruby_api/store.rs', line 262

pub fn set_fuel(&self, fuel: u64) -> Result<(), Error> {
    unsafe { &mut *self.inner.get() }
        .set_fuel(fuel)
        .map_err(|e| error!("{}", e))?;

    Ok(())
}