From 7c2e7c660804afca823d60e6496aa853f75db16c Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Thu, 10 Sep 2020 09:57:45 -0400 Subject: Use gotham-like state for ops (#7385) Provides a concrete state type that can be dynamically added. This is necessary for op crates. * renames BasicState to OpState * async ops take `Rc>` * sync ops take `&mut OpState` * removes `OpRegistry`, `OpRouter` traits * `get_error_class_fn` moved to OpState * ResourceTable moved to OpState --- core/examples/http_bench_bin_ops.rs | 84 +++++++++++++++++++----------------- core/examples/http_bench_json_ops.rs | 46 +++++++++----------- 2 files changed, 66 insertions(+), 64 deletions(-) (limited to 'core/examples') diff --git a/core/examples/http_bench_bin_ops.rs b/core/examples/http_bench_bin_ops.rs index 00eb95f44..b29af8b9d 100644 --- a/core/examples/http_bench_bin_ops.rs +++ b/core/examples/http_bench_bin_ops.rs @@ -2,11 +2,10 @@ extern crate log; use deno_core::js_check; -use deno_core::BasicState; use deno_core::BufVec; use deno_core::JsRuntime; use deno_core::Op; -use deno_core::OpRegistry; +use deno_core::OpState; use deno_core::Script; use deno_core::StartupData; use deno_core::ZeroCopyBuf; @@ -14,6 +13,7 @@ use futures::future::poll_fn; use futures::future::FutureExt; use futures::future::TryFuture; use futures::future::TryFutureExt; +use std::cell::RefCell; use std::convert::TryInto; use std::env; use std::fmt::Debug; @@ -78,23 +78,22 @@ impl From for RecordBuf { } fn create_isolate() -> JsRuntime { - let state = BasicState::new(); - register_op_bin_sync(&state, "listen", op_listen); - register_op_bin_sync(&state, "close", op_close); - register_op_bin_async(&state, "accept", op_accept); - register_op_bin_async(&state, "read", op_read); - register_op_bin_async(&state, "write", op_write); - let startup_data = StartupData::Script(Script { source: include_str!("http_bench_bin_ops.js"), filename: "http_bench_bin_ops.js", }); - JsRuntime::new(state, startup_data, false) + let mut isolate = JsRuntime::new(startup_data, false); + register_op_bin_sync(&mut isolate, "listen", op_listen); + register_op_bin_sync(&mut isolate, "close", op_close); + register_op_bin_async(&mut isolate, "accept", op_accept); + register_op_bin_async(&mut isolate, "read", op_read); + register_op_bin_async(&mut isolate, "write", op_write); + isolate } fn op_listen( - state: &BasicState, + state: &mut OpState, _rid: u32, _bufs: &mut [ZeroCopyBuf], ) -> Result { @@ -102,36 +101,33 @@ fn op_listen( let addr = "127.0.0.1:4544".parse::().unwrap(); let std_listener = std::net::TcpListener::bind(&addr)?; let listener = TcpListener::from_std(std_listener)?; - let rid = state - .resource_table - .borrow_mut() - .add("tcpListener", Box::new(listener)); + let rid = state.resource_table.add("tcpListener", Box::new(listener)); Ok(rid) } fn op_close( - state: &BasicState, + state: &mut OpState, rid: u32, _bufs: &mut [ZeroCopyBuf], ) -> Result { debug!("close rid={}", rid); state .resource_table - .borrow_mut() .close(rid) .map(|_| 0) .ok_or_else(bad_resource_id) } -fn op_accept( - state: Rc, +async fn op_accept( + state: Rc>, rid: u32, _bufs: BufVec, -) -> impl TryFuture { +) -> Result { debug!("accept rid={}", rid); poll_fn(move |cx| { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let listener = resource_table .get_mut::(rid) .ok_or_else(bad_resource_id)?; @@ -139,10 +135,11 @@ fn op_accept( resource_table.add("tcpStream", Box::new(stream)) }) }) + .await } fn op_read( - state: Rc, + state: Rc>, rid: u32, bufs: BufVec, ) -> impl TryFuture { @@ -152,7 +149,8 @@ fn op_read( debug!("read rid={}", rid); poll_fn(move |cx| { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let stream = resource_table .get_mut::(rid) .ok_or_else(bad_resource_id)?; @@ -161,7 +159,7 @@ fn op_read( } fn op_write( - state: Rc, + state: Rc>, rid: u32, bufs: BufVec, ) -> impl TryFuture { @@ -170,7 +168,8 @@ fn op_write( debug!("write rid={}", rid); poll_fn(move |cx| { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let stream = resource_table .get_mut::(rid) .ok_or_else(bad_resource_id)?; @@ -178,35 +177,42 @@ fn op_write( }) } -fn register_op_bin_sync(state: &BasicState, name: &'static str, op_fn: F) -where - F: Fn(&BasicState, u32, &mut [ZeroCopyBuf]) -> Result + 'static, +fn register_op_bin_sync( + isolate: &mut JsRuntime, + name: &'static str, + op_fn: F, +) where + F: Fn(&mut OpState, u32, &mut [ZeroCopyBuf]) -> Result + 'static, { - let base_op_fn = move |state: Rc, mut bufs: BufVec| -> Op { + let base_op_fn = move |state: Rc>, mut bufs: BufVec| -> Op { let record = Record::from(bufs[0].as_ref()); let is_sync = record.promise_id == 0; assert!(is_sync); let zero_copy_bufs = &mut bufs[1..]; - let result: i32 = match op_fn(&state, record.rid, zero_copy_bufs) { - Ok(r) => r as i32, - Err(_) => -1, - }; + let result: i32 = + match op_fn(&mut state.borrow_mut(), record.rid, zero_copy_bufs) { + Ok(r) => r as i32, + Err(_) => -1, + }; let buf = RecordBuf::from(Record { result, ..record })[..].into(); Op::Sync(buf) }; - state.register_op(name, base_op_fn); + isolate.register_op(name, base_op_fn); } -fn register_op_bin_async(state: &BasicState, name: &'static str, op_fn: F) -where - F: Fn(Rc, u32, BufVec) -> R + Copy + 'static, +fn register_op_bin_async( + isolate: &mut JsRuntime, + name: &'static str, + op_fn: F, +) where + F: Fn(Rc>, u32, BufVec) -> R + Copy + 'static, R: TryFuture, R::Ok: TryInto, >::Error: Debug, { - let base_op_fn = move |state: Rc, bufs: BufVec| -> Op { + let base_op_fn = move |state: Rc>, bufs: BufVec| -> Op { let mut bufs_iter = bufs.into_iter(); let record_buf = bufs_iter.next().unwrap(); let zero_copy_bufs = bufs_iter.collect::(); @@ -227,7 +233,7 @@ where Op::Async(fut.boxed_local()) }; - state.register_op(name, base_op_fn); + isolate.register_op(name, base_op_fn); } fn bad_resource_id() -> Error { diff --git a/core/examples/http_bench_json_ops.rs b/core/examples/http_bench_json_ops.rs index de467b8ad..dc0c837e2 100644 --- a/core/examples/http_bench_json_ops.rs +++ b/core/examples/http_bench_json_ops.rs @@ -2,17 +2,17 @@ extern crate log; use deno_core::js_check; -use deno_core::BasicState; use deno_core::BufVec; use deno_core::ErrBox; use deno_core::JsRuntime; -use deno_core::OpRegistry; +use deno_core::OpState; use deno_core::Script; use deno_core::StartupData; use deno_core::ZeroCopyBuf; use futures::future::poll_fn; use futures::future::Future; use serde_json::Value; +use std::cell::RefCell; use std::convert::TryInto; use std::env; use std::net::SocketAddr; @@ -42,23 +42,21 @@ impl log::Log for Logger { } fn create_isolate() -> JsRuntime { - let state = BasicState::new(); - state.register_op_json_sync("listen", op_listen); - state.register_op_json_sync("close", op_close); - state.register_op_json_async("accept", op_accept); - state.register_op_json_async("read", op_read); - state.register_op_json_async("write", op_write); - let startup_data = StartupData::Script(Script { source: include_str!("http_bench_json_ops.js"), filename: "http_bench_json_ops.js", }); - - JsRuntime::new(state, startup_data, false) + let mut runtime = JsRuntime::new(startup_data, false); + runtime.register_op("listen", deno_core::json_op_sync(op_listen)); + runtime.register_op("close", deno_core::json_op_sync(op_close)); + runtime.register_op("accept", deno_core::json_op_async(op_accept)); + runtime.register_op("read", deno_core::json_op_async(op_read)); + runtime.register_op("write", deno_core::json_op_async(op_write)); + runtime } fn op_listen( - state: &BasicState, + state: &mut OpState, _args: Value, _bufs: &mut [ZeroCopyBuf], ) -> Result { @@ -66,15 +64,12 @@ fn op_listen( let addr = "127.0.0.1:4544".parse::().unwrap(); let std_listener = std::net::TcpListener::bind(&addr)?; let listener = TcpListener::from_std(std_listener)?; - let rid = state - .resource_table - .borrow_mut() - .add("tcpListener", Box::new(listener)); + let rid = state.resource_table.add("tcpListener", Box::new(listener)); Ok(serde_json::json!({ "rid": rid })) } fn op_close( - state: &BasicState, + state: &mut OpState, args: Value, _buf: &mut [ZeroCopyBuf], ) -> Result { @@ -86,17 +81,15 @@ fn op_close( .try_into() .unwrap(); debug!("close rid={}", rid); - state .resource_table - .borrow_mut() .close(rid) .map(|_| serde_json::json!(())) .ok_or_else(ErrBox::bad_resource_id) } fn op_accept( - state: Rc, + state: Rc>, args: Value, _bufs: BufVec, ) -> impl Future> { @@ -110,7 +103,8 @@ fn op_accept( debug!("accept rid={}", rid); poll_fn(move |cx| { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let listener = resource_table .get_mut::(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -122,7 +116,7 @@ fn op_accept( } fn op_read( - state: Rc, + state: Rc>, args: Value, mut bufs: BufVec, ) -> impl Future> { @@ -138,7 +132,8 @@ fn op_read( debug!("read rid={}", rid); poll_fn(move |cx| -> Poll> { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let stream = resource_table .get_mut::(rid) .ok_or_else(ErrBox::bad_resource_id)?; @@ -149,7 +144,7 @@ fn op_read( } fn op_write( - state: Rc, + state: Rc>, args: Value, bufs: BufVec, ) -> impl Future> { @@ -165,7 +160,8 @@ fn op_write( debug!("write rid={}", rid); poll_fn(move |cx| { - let resource_table = &mut state.resource_table.borrow_mut(); + let resource_table = &mut state.borrow_mut().resource_table; + let stream = resource_table .get_mut::(rid) .ok_or_else(ErrBox::bad_resource_id)?; -- cgit v1.2.3