fluencelabs/parity-wasm
1
0
Fork 0
mirror of https://github.com/fluencelabs/parity-wasm synced 2025-06-27 05:32:07 +00:00
Code Issues Projects Releases Wiki Activity

UserFunctionExecutor

Browse Source
This commit is contained in:
Svyatoslav Nikolsky
2017-05-19 09:36:50 +03:00
parent 977df55323
commit a0bfa322c6
6 changed files with 150 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

179
src/interpreter/tests/basics.rs
View File

@ -5,7 +5,9 @@ use builder::module;
use elements::{ExportEntry, Internal, ImportEntry, External, GlobalEntry, GlobalType,
InitExpr, ValueType, Opcodes, Opcode};
use interpreter::Error;
use interpreter::module::{ModuleInstanceInterface, CallerContext};
use interpreter::env_native::{env_native_module, UserFunction, UserFunctions, UserFunctionExecutor};
use interpreter::memory::MemoryInstance;
use interpreter::module::{ModuleInstanceInterface, CallerContext, ItemIndex, ExecutionParams};
use interpreter::program::ProgramInstance;
use interpreter::value::RuntimeValue;
@ -122,111 +124,96 @@ fn global_get_set() {
}
#[test]
fn with_user_functions() {
use interpreter::{UserFunction, UserFunctions, ExecutionParams, env_native_module};
fn single_program_different_modules() {
// user function executor
struct FunctionExecutor {
pub memory: Arc<MemoryInstance>,
pub values: Vec<i32>,
}
impl UserFunctionExecutor for FunctionExecutor {
fn execute(&mut self, name: &str, context: CallerContext) -> Result<Option<RuntimeValue>, Error> {
match name {
"add" => {
let memory_value = self.memory.get(0, 1).unwrap()[0];
let fn_argument = context.value_stack.pop_as::<u32>().unwrap() as u8;
let sum = memory_value + fn_argument;
self.memory.set(0, &vec![sum]).unwrap();
self.values.push(sum as i32);
Ok(Some(RuntimeValue::I32(sum as i32)))
},
"sub" => {
let memory_value = self.memory.get(0, 1).unwrap()[0];
let fn_argument = context.value_stack.pop_as::<u32>().unwrap() as u8;
let diff = memory_value - fn_argument;
self.memory.set(0, &vec![diff]).unwrap();
self.values.push(diff as i32);
Ok(Some(RuntimeValue::I32(diff as i32)))
},
_ => Err(Error::Trap("not implemented".into())),
}
}
}
// create new program
let program = ProgramInstance::new().unwrap();
// => env module is created
let env_instance = program.module("env").unwrap();
// => linear memory is created
let env_memory = env_instance.memory(ItemIndex::Internal(0)).unwrap();
let module = module()
.with_import(ImportEntry::new("env".into(), "custom_alloc".into(), External::Function(0)))
.with_import(ImportEntry::new("env".into(), "custom_increment".into(), External::Function(0)))
.with_import(ImportEntry::new("env".into(), "add".into(), External::Function(0)))
.with_import(ImportEntry::new("env".into(), "sub".into(), External::Function(0)))
.function()
.signature().return_type().i32().build()
.signature().param().i32().return_type().i32().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::I32Const(32),
Opcode::GetLocal(0),
Opcode::Call(0),
Opcode::End,
])).build()
.build()
.function()
.signature().param().i32().return_type().i32().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::GetLocal(0),
Opcode::Call(1),
Opcode::End,
])).build()
.build()
.build();
let mut top = 0i32;
let mut user_functions = UserFunctions::new();
user_functions.insert(
"custom_alloc".to_owned(),
UserFunction {
params: vec![ValueType::I32],
result: Some(ValueType::I32),
closure: Box::new(move |context: CallerContext| {
let prev = top;
top = top + context.value_stack.pop_as::<i32>()?;
Ok(Some(prev.into()))
}),
}
);
let mut rolling = 9999i32;
user_functions.insert(
"custom_increment".to_owned(),
UserFunction {
params: vec![ValueType::I32],
result: Some(ValueType::I32),
closure: Box::new(move |_context: CallerContext| {
rolling = rolling + 1;
Ok(Some(rolling.into()))
}),
}
);
let program = ProgramInstance::new().unwrap();
// load module
let module_instance = program.add_module("main", module).unwrap();
let native_env = Arc::new(env_native_module(program.module("env").unwrap(), user_functions).unwrap());
let params = ExecutionParams::with_external("env".into(), native_env);
// internal function using first import
assert_eq!(module_instance.execute_index(2, params.clone()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(module_instance.execute_index(2, params.clone()).unwrap().unwrap(), RuntimeValue::I32(32));
assert_eq!(module_instance.execute_index(2, params.clone()).unwrap().unwrap(), RuntimeValue::I32(64));
// second import
assert_eq!(module_instance.execute_index(1, params.clone()).unwrap().unwrap(), RuntimeValue::I32(10000));
assert_eq!(module_instance.execute_index(1, params).unwrap().unwrap(), RuntimeValue::I32(10001));
let mut executor = FunctionExecutor {
memory: env_memory.clone(),
values: Vec::new(),
};
{
// create native env module with native add && sub implementations
let functions: UserFunctions = UserFunctions {
executor: &mut executor,
functions: vec![UserFunction {
name: "add".into(),
params: vec![ValueType::I32],
result: Some(ValueType::I32),
}, UserFunction {
name: "sub".into(),
params: vec![ValueType::I32],
result: Some(ValueType::I32),
}],
};
let native_env_instance = Arc::new(env_native_module(env_instance, functions).unwrap());
// execute functions
let params = ExecutionParams::with_external("env".into(), native_env_instance);
assert_eq!(module_instance.execute_index(2, params.clone().add_argument(RuntimeValue::I32(7))).unwrap().unwrap(), RuntimeValue::I32(7));
assert_eq!(module_instance.execute_index(2, params.clone().add_argument(RuntimeValue::I32(50))).unwrap().unwrap(), RuntimeValue::I32(57));
assert_eq!(module_instance.execute_index(3, params.clone().add_argument(RuntimeValue::I32(15))).unwrap().unwrap(), RuntimeValue::I32(42));
}
assert_eq!(executor.memory.get(0, 1).unwrap()[0], 42);
assert_eq!(executor.values, vec![7, 57, 42]);
}
#[test]
fn with_user_functions_extended() {
use interpreter::{UserFunction, UserFunctions, UserFunctionInterface,
ExecutionParams, env_native_module};
struct UserMAlloc {
top: i32,
}
impl UserFunctionInterface for UserMAlloc {
fn call(&mut self, context: CallerContext) -> Result<Option<RuntimeValue>, Error> {
let prev = self.top;
self.top += context.value_stack.pop_as::<i32>()?;
Ok(Some(prev.into()))
}
}
let module = module()
.with_import(ImportEntry::new("env".into(), "_malloc".into(), External::Function(0)))
.function()
.signature().return_type().i32().build()
.body().with_opcodes(Opcodes::new(vec![
Opcode::I32Const(32),
Opcode::Call(0),
Opcode::End,
])).build()
.build()
.build();
let mut user_functions = UserFunctions::new();
user_functions.insert(
"_malloc".to_owned(),
UserFunction {
params: vec![ValueType::I32],
result: Some(ValueType::I32),
closure: Box::new(UserMAlloc { top: 0 }),
}
);
let program = ProgramInstance::new().unwrap();
let module_instance = program.add_module("main", module).unwrap();
let native_env = Arc::new(env_native_module(program.module("env").unwrap(), user_functions).unwrap());
let params = ExecutionParams::with_external("env".into(), native_env);
// internal function using first import
assert_eq!(module_instance.execute_index(1, params.clone()).unwrap().unwrap(), RuntimeValue::I32(0));
assert_eq!(module_instance.execute_index(1, params.clone()).unwrap().unwrap(), RuntimeValue::I32(32));
assert_eq!(module_instance.execute_index(1, params).unwrap().unwrap(), RuntimeValue::I32(64));
}