Struct wasmer_middlewares::metering::Metering

pub struct Metering<F: Fn(&Operator<'_>) -> u64 + Send + Sync> {
    initial_limit: u64,
    cost_function: Arc<F>,
    global_indexes: Mutex<Option<MeteringGlobalIndexes>>,
}

The module-level metering middleware.

Panic

An instance of Metering should not be shared among different modules, since it tracks module-specific information like the global index to store metering state. Attempts to use a Metering instance from multiple modules will result in a panic.

Example

use std::sync::Arc;
use wasmer::{wasmparser::Operator, sys::CompilerConfig};
use wasmer_middlewares::Metering;

fn create_metering_middleware(compiler_config: &mut dyn CompilerConfig) {
    // Let's define a dummy cost function,
    // which counts 1 for all operators.
    let cost_function = |_operator: &Operator| -> u64 { 1 };

    // Let's define the initial limit.
    let initial_limit = 10;

    // Let's creating the metering middleware.
    let metering = Arc::new(Metering::new(
        initial_limit,
        cost_function
    ));

    // Finally, let's push the middleware.
    compiler_config.push_middleware(metering);
}

Fields

initial_limit: u64

Initial limit of points.

cost_function: Arc<F>

Function that maps each operator to a cost in “points”.

global_indexes: Mutex<Option<MeteringGlobalIndexes>>

The global indexes for metering points.

Implementations

impl<F: Fn(&Operator<'_>) -> u64 + Send + Sync> Metering<F>

pub fn new(initial_limit: u64, cost_function: F) -> Self

Creates a Metering middleware.

When providing a cost function, you should consider that branching operations do additional work to track the metering points and probably need to have a higher cost. To find out which operations are affected by this, you can call is_accounting.

Trait Implementations

impl<F: Fn(&Operator<'_>) -> u64 + Send + Sync> Debug for Metering<F>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Fn(&Operator<'_>) -> u64 + Send + Sync + 'static> ModuleMiddleware for Metering<F>

fn generate_function_middleware( &self, _: LocalFunctionIndex, ) -> Box<dyn FunctionMiddleware>

Generates a FunctionMiddleware for a given function.

fn transform_module_info( &self, module_info: &mut ModuleInfo, ) -> Result<(), MiddlewareError>

Transforms a ModuleInfo struct in-place. This is called before application on functions begins.