From f7fdb90fd51e340ea598c055bb3573d3cdfbdaa8 Mon Sep 17 00:00:00 2001 From: Ryan Dahl Date: Mon, 8 Apr 2019 10:12:43 -0400 Subject: [PATCH] core: snapshot improvements (#2052) * Moves how snapshots are supplied to the Isolate. Previously they were given by Behavior::startup_data() but it was only called once at startup. It makes more sense (and simplifies Behavior) to pass it to the constructor of Isolate. * Adds new libdeno type deno_snapshot instead of overloading deno_buf. * Adds new libdeno method to delete snapshot deno_snapshot_delete(). * Renames deno_get_snapshot() to deno_snapshot_new(). * Makes StartupData hold references to snapshots. This was implicit when it previously held a deno_buf but is made explicit now. Note that include_bytes!() returns a &'static [u8] and we want to avoid copying that. --- cli/cli_behavior.rs | 16 +------- cli/compiler.rs | 6 +-- cli/isolate.rs | 13 +++--- cli/main.rs | 5 +-- cli/ops.rs | 2 + cli/startup_data.rs | 21 ++++------ cli/workers.rs | 15 ++++--- core/http_bench.rs | 19 ++++----- core/isolate.rs | 70 +++++++++++++++++++------------- core/libdeno.rs | 60 ++++++++++++++++++++++++++- core/libdeno/api.cc | 10 +++-- core/libdeno/deno.h | 30 +++++++++----- core/libdeno/internal.h | 1 + core/libdeno/libdeno_test.cc | 14 +++---- core/libdeno/modules_test.cc | 8 ++-- core/libdeno/snapshot_creator.cc | 8 ++-- core/libdeno/test.cc | 2 +- core/libdeno/test.h | 3 +- 18 files changed, 182 insertions(+), 121 deletions(-) diff --git a/cli/cli_behavior.rs b/cli/cli_behavior.rs index 05f2cf006e..860ec76ece 100644 --- a/cli/cli_behavior.rs +++ b/cli/cli_behavior.rs @@ -4,24 +4,16 @@ use crate::ops; use deno::deno_buf; use deno::Behavior; use deno::Op; -use deno::StartupData; use std::sync::Arc; /// Implements deno::Behavior for the main Deno command-line. pub struct CliBehavior { - startup_data: Option, pub state: Arc, } impl CliBehavior { - pub fn new( - startup_data: Option, - state: Arc, - ) -> Self { - Self { - startup_data, - state, - } + pub fn new(state: Arc) -> Self { + Self { state } } } @@ -38,10 +30,6 @@ impl IsolateStateContainer for CliBehavior { } impl Behavior for CliBehavior { - fn startup_data(&mut self) -> Option { - self.startup_data.take() - } - fn dispatch( &mut self, control: &[u8], diff --git a/cli/compiler.rs b/cli/compiler.rs index 3bf230bc33..e4d76c44ca 100644 --- a/cli/compiler.rs +++ b/cli/compiler.rs @@ -17,7 +17,6 @@ use deno::Behavior; use deno::Buf; use deno::JSError; use deno::Op; -use deno::StartupData; use futures::future::*; use futures::sync::oneshot; use futures::Future; @@ -70,10 +69,6 @@ impl IsolateStateContainer for &CompilerBehavior { } impl Behavior for CompilerBehavior { - fn startup_data(&mut self) -> Option { - Some(startup_data::compiler_isolate_init()) - } - fn dispatch( &mut self, control: &[u8], @@ -148,6 +143,7 @@ fn lazy_start(parent_state: Arc) -> ResourceId { cell .get_or_insert_with(|| { let worker_result = workers::spawn( + startup_data::compiler_isolate_init(), CompilerBehavior::new( parent_state.flags.clone(), parent_state.argv.clone(), diff --git a/cli/isolate.rs b/cli/isolate.rs index 1d7201074e..2e6d69d87a 100644 --- a/cli/isolate.rs +++ b/cli/isolate.rs @@ -13,6 +13,7 @@ use deno; use deno::deno_mod; use deno::Behavior; use deno::JSError; +use deno::StartupData; use futures::future::Either; use futures::Async; use futures::Future; @@ -32,10 +33,10 @@ pub struct Isolate { } impl Isolate { - pub fn new(behavior: B) -> Isolate { + pub fn new(startup_data: StartupData, behavior: B) -> Isolate { let state = behavior.state().clone(); Self { - inner: CoreIsolate::new(behavior), + inner: CoreIsolate::new(startup_data, behavior), state, } } @@ -270,8 +271,8 @@ mod tests { let state = Arc::new(IsolateState::new(flags, rest_argv, None, false)); let state_ = state.clone(); tokio_util::run(lazy(move || { - let cli = CliBehavior::new(None, state.clone()); - let mut isolate = Isolate::new(cli); + let cli = CliBehavior::new(state.clone()); + let mut isolate = Isolate::new(StartupData::None, cli); if let Err(err) = isolate.execute_mod(&filename, false) { eprintln!("execute_mod err {:?}", err); } @@ -293,8 +294,8 @@ mod tests { let state = Arc::new(IsolateState::new(flags, rest_argv, None, false)); let state_ = state.clone(); tokio_util::run(lazy(move || { - let cli = CliBehavior::new(None, state.clone()); - let mut isolate = Isolate::new(cli); + let cli = CliBehavior::new(state.clone()); + let mut isolate = Isolate::new(StartupData::None, cli); if let Err(err) = isolate.execute_mod(&filename, false) { eprintln!("execute_mod err {:?}", err); } diff --git a/cli/main.rs b/cli/main.rs index 4d0ceab5ad..bda4f7b8f6 100644 --- a/cli/main.rs +++ b/cli/main.rs @@ -107,9 +107,8 @@ fn main() { let state = Arc::new(IsolateState::new(flags, rest_argv, None, false)); let state_ = state.clone(); - let startup_data = startup_data::deno_isolate_init(); - let cli = CliBehavior::new(Some(startup_data), state_); - let mut isolate = Isolate::new(cli); + let cli = CliBehavior::new(state_); + let mut isolate = Isolate::new(startup_data::deno_isolate_init(), cli); let main_future = lazy(move || { // Setup runtime. diff --git a/cli/ops.rs b/cli/ops.rs index 8890616519..a0169d6abc 100644 --- a/cli/ops.rs +++ b/cli/ops.rs @@ -15,6 +15,7 @@ use crate::resolve_addr::resolve_addr; use crate::resources; use crate::resources::table_entries; use crate::resources::Resource; +use crate::startup_data; use crate::tokio_util; use crate::tokio_write; use crate::version; @@ -1865,6 +1866,7 @@ fn op_create_worker( parent_state.argv.clone(), ); match workers::spawn( + startup_data::deno_isolate_init(), behavior, &format!("USER-WORKER-{}", specifier), workers::WorkerInit::Module(specifier.to_string()), diff --git a/cli/startup_data.rs b/cli/startup_data.rs index 61891ced48..1a77915e90 100644 --- a/cli/startup_data.rs +++ b/cli/startup_data.rs @@ -1,8 +1,7 @@ // Copyright 2018-2019 the Deno authors. All rights reserved. MIT license. -use deno::deno_buf; use deno::{Script, StartupData}; -pub fn deno_isolate_init() -> StartupData { +pub fn deno_isolate_init() -> StartupData<'static> { if cfg!(feature = "no-snapshot-init") { debug!("Deno isolate init without snapshots."); #[cfg(not(feature = "check-only"))] @@ -12,8 +11,8 @@ pub fn deno_isolate_init() -> StartupData { let source_bytes = vec![]; StartupData::Script(Script { - filename: "gen/cli/bundle/main.js".to_string(), - source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(), + filename: "gen/cli/bundle/main.js", + source: std::str::from_utf8(&source_bytes[..]).unwrap(), }) } else { debug!("Deno isolate init with snapshots."); @@ -23,13 +22,11 @@ pub fn deno_isolate_init() -> StartupData { #[cfg(any(feature = "check-only", feature = "no-snapshot-init"))] let data = vec![]; - unsafe { - StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len())) - } + StartupData::Snapshot(data) } } -pub fn compiler_isolate_init() -> StartupData { +pub fn compiler_isolate_init() -> StartupData<'static> { if cfg!(feature = "no-snapshot-init") { debug!("Compiler isolate init without snapshots."); #[cfg(not(feature = "check-only"))] @@ -41,8 +38,8 @@ pub fn compiler_isolate_init() -> StartupData { let source_bytes = vec![]; StartupData::Script(Script { - filename: "gen/cli/bundle/compiler.js".to_string(), - source: std::str::from_utf8(&source_bytes[..]).unwrap().to_string(), + filename: "gen/cli/bundle/compiler.js", + source: std::str::from_utf8(&source_bytes[..]).unwrap(), }) } else { debug!("Deno isolate init with snapshots."); @@ -54,8 +51,6 @@ pub fn compiler_isolate_init() -> StartupData { #[cfg(any(feature = "check-only", feature = "no-snapshot-init"))] let data = vec![]; - unsafe { - StartupData::Snapshot(deno_buf::from_raw_parts(data.as_ptr(), data.len())) - } + StartupData::Snapshot(data) } } diff --git a/cli/workers.rs b/cli/workers.rs index 02126f1e2b..7c39a5d2e8 100644 --- a/cli/workers.rs +++ b/cli/workers.rs @@ -7,7 +7,6 @@ use crate::isolate_state::IsolateStateContainer; use crate::isolate_state::WorkerChannels; use crate::ops; use crate::resources; -use crate::startup_data; use deno::deno_buf; use deno::Behavior; use deno::Buf; @@ -44,10 +43,6 @@ impl IsolateStateContainer for &UserWorkerBehavior { } impl Behavior for UserWorkerBehavior { - fn startup_data(&mut self) -> Option { - Some(startup_data::deno_isolate_init()) - } - fn dispatch( &mut self, control: &[u8], @@ -83,7 +78,7 @@ pub struct Worker { } impl Worker { - pub fn new(mut behavior: B) -> Self { + pub fn new(startup_data: StartupData, mut behavior: B) -> Self { let (worker_in_tx, worker_in_rx) = mpsc::channel::(1); let (worker_out_tx, worker_out_rx) = mpsc::channel::(1); @@ -92,7 +87,7 @@ impl Worker { behavior.set_internal_channels(internal_channels); - let isolate = Isolate::new(behavior); + let isolate = Isolate::new(startup_data, behavior); Worker { isolate, @@ -129,12 +124,13 @@ pub enum WorkerInit { } pub fn spawn( + startup_data: StartupData, behavior: B, worker_debug_name: &str, init: WorkerInit, ) -> Result, RustOrJsError> { let state = behavior.state().clone(); - let mut worker = Worker::new(behavior); + let mut worker = Worker::new(startup_data, behavior); worker .execute(&format!("denoMain('{}')", worker_debug_name)) @@ -172,6 +168,7 @@ mod tests { use crate::compiler::CompilerBehavior; use crate::isolate_state::IsolateState; use crate::js_errors::JSErrorColor; + use crate::startup_data; use crate::tokio_util; use futures::future::lazy; use std::thread; @@ -180,6 +177,7 @@ mod tests { fn test_spawn() { tokio_util::init(|| { let worker_result = spawn( + startup_data::compiler_isolate_init(), CompilerBehavior::new( IsolateState::mock().flags.clone(), IsolateState::mock().argv.clone(), @@ -242,6 +240,7 @@ mod tests { fn removed_from_resource_table_on_close() { tokio_util::init(|| { let worker_result = spawn( + startup_data::compiler_isolate_init(), CompilerBehavior::new( IsolateState::mock().flags.clone(), IsolateState::mock().argv.clone(), diff --git a/core/http_bench.rs b/core/http_bench.rs index 37965510fe..fced92bf83 100644 --- a/core/http_bench.rs +++ b/core/http_bench.rs @@ -99,15 +99,6 @@ pub type HttpBenchOp = dyn Future + Send; struct HttpBench(); impl Behavior for HttpBench { - fn startup_data(&mut self) -> Option { - let js_source = include_str!("http_bench.js"); - - Some(StartupData::Script(Script { - source: js_source.to_string(), - filename: "http_bench.js".to_string(), - })) - } - fn dispatch( &mut self, control: &[u8], @@ -168,7 +159,15 @@ fn main() { // TODO currently isolate.execute() must be run inside tokio, hence the // lazy(). It would be nice to not have that contraint. Probably requires // using v8::MicrotasksPolicy::kExplicit - let isolate = deno::Isolate::new(HttpBench()); + + let js_source = include_str!("http_bench.js"); + + let startup_data = StartupData::Script(Script { + source: js_source, + filename: "http_bench.js", + }); + + let isolate = deno::Isolate::new(startup_data, HttpBench()); isolate.then(|r| { js_check(r); diff --git a/core/isolate.rs b/core/isolate.rs index a722f5a3ce..88f42be0e9 100644 --- a/core/isolate.rs +++ b/core/isolate.rs @@ -8,6 +8,8 @@ use crate::js_errors::JSError; use crate::libdeno; use crate::libdeno::deno_buf; use crate::libdeno::deno_mod; +use crate::libdeno::Snapshot1; +use crate::libdeno::Snapshot2; use crate::shared_queue::SharedQueue; use crate::shared_queue::RECOMMENDED_SIZE; use futures::Async; @@ -16,6 +18,7 @@ use futures::Poll; use libc::c_void; use std::ffi::CStr; use std::ffi::CString; +use std::ptr::null; use std::sync::{Arc, Mutex, Once, ONCE_INIT}; pub type Buf = Box<[u8]>; @@ -48,26 +51,24 @@ impl Future for PendingOp { } /// Stores a script used to initalize a Isolate -pub struct Script { - pub source: String, - pub filename: String, +pub struct Script<'a> { + pub source: &'a str, + pub filename: &'a str, } /// Represents data used to initialize isolate at startup /// either a binary snapshot or a javascript source file /// in the form of the StartupScript struct. -pub enum StartupData { - Script(Script), - Snapshot(deno_buf), +pub enum StartupData<'a> { + Script(Script<'a>), + Snapshot(&'a [u8]), + None, } /// Defines the behavior of an Isolate. +// TODO(ry) Now that Behavior only has the dispatch method, it should be renamed +// to Dispatcher. pub trait Behavior { - /// Allow for a behavior to define the snapshot or script used at - /// startup to initalize the isolate. Called exactly once when an - /// Isolate is created. - fn startup_data(&mut self) -> Option; - /// Called whenever Deno.core.dispatch() is called in JavaScript. zero_copy_buf /// corresponds to the second argument of Deno.core.dispatch(). fn dispatch( @@ -109,7 +110,9 @@ impl Drop for Isolate { static DENO_INIT: Once = ONCE_INIT; impl Isolate { - pub fn new(mut behavior: B) -> Self { + /// startup_data defines the snapshot or script used at startup to initalize + /// the isolate. + pub fn new(startup_data: StartupData, behavior: B) -> Self { DENO_INIT.call_once(|| { unsafe { libdeno::deno_init() }; }); @@ -118,16 +121,16 @@ impl Isolate { let needs_init = true; // Seperate into Option values for eatch startup type - let (startup_snapshot, startup_script) = match behavior.startup_data() { - Some(StartupData::Snapshot(d)) => (Some(d), None), - Some(StartupData::Script(d)) => (None, Some(d)), - None => (None, None), + let (startup_snapshot, startup_script) = match startup_data { + StartupData::Snapshot(d) => (Some(d), None), + StartupData::Script(d) => (None, Some(d)), + StartupData::None => (None, None), }; let config = libdeno::deno_config { will_snapshot: 0, load_snapshot: match startup_snapshot { - Some(s) => s, - None => libdeno::deno_buf::empty(), + Some(s) => Snapshot2::from(s), + None => Snapshot2::empty(), }, shared: shared.as_deno_buf(), recv_cb: Self::pre_dispatch, @@ -146,9 +149,7 @@ impl Isolate { // If we want to use execute this has to happen here sadly. if let Some(s) = startup_script { - core_isolate - .execute(s.filename.as_str(), s.source.as_str()) - .unwrap() + core_isolate.execute(s.filename, s.source).unwrap() }; core_isolate @@ -329,6 +330,18 @@ impl Isolate { } out } + + pub fn snapshot_new(&self) -> Result { + let snapshot = unsafe { libdeno::deno_snapshot_new(self.libdeno_isolate) }; + if let Some(js_error) = self.last_exception() { + assert_eq!(snapshot.data_ptr, null()); + assert_eq!(snapshot.data_len, 0); + return Err(js_error); + } + assert_ne!(snapshot.data_ptr, null()); + assert_ne!(snapshot.data_len, 0); + Ok(snapshot) + } } /// Called during mod_instantiate() to resolve imports. @@ -546,10 +559,13 @@ pub mod tests { impl TestBehavior { pub fn setup(mode: TestBehaviorMode) -> Isolate { - let mut isolate = Isolate::new(TestBehavior { - dispatch_count: 0, - mode, - }); + let mut isolate = Isolate::new( + StartupData::None, + TestBehavior { + dispatch_count: 0, + mode, + }, + ); js_check(isolate.execute( "setup.js", r#" @@ -566,10 +582,6 @@ pub mod tests { } impl Behavior for TestBehavior { - fn startup_data(&mut self) -> Option { - None - } - fn dispatch( &mut self, control: &[u8], diff --git a/core/libdeno.rs b/core/libdeno.rs index 1a80330ded..e6445f2991 100644 --- a/core/libdeno.rs +++ b/core/libdeno.rs @@ -4,6 +4,7 @@ use libc::c_char; use libc::c_int; use libc::c_void; use libc::size_t; +use std::marker::PhantomData; use std::ops::{Deref, DerefMut}; use std::ptr::null; @@ -108,6 +109,56 @@ impl AsMut<[u8]> for deno_buf { } } +#[repr(C)] +pub struct deno_snapshot<'a> { + pub data_ptr: *const u8, + pub data_len: usize, + _marker: PhantomData<&'a [u8]>, +} + +/// `deno_snapshot` can not clone, and there is no interior mutability. +/// This type satisfies Send bound. +unsafe impl Send for deno_snapshot<'_> {} + +// TODO(ry) Snapshot1 and Snapshot2 are not very good names and need to be +// reconsidered. The entire snapshotting interface is still under construction. + +/// The type returned from deno_snapshot_new. Needs to be dropped. +pub type Snapshot1<'a> = deno_snapshot<'a>; + +// TODO Does this make sense? +impl Drop for Snapshot1<'_> { + fn drop(&mut self) { + unsafe { deno_snapshot_delete(self) } + } +} + +/// The type created from slice. Used for loading. +pub type Snapshot2<'a> = deno_snapshot<'a>; + +/// Converts Rust &Buf to libdeno `deno_buf`. +impl<'a> From<&'a [u8]> for Snapshot2<'a> { + #[inline] + fn from(x: &'a [u8]) -> Self { + Self { + data_ptr: x.as_ref().as_ptr(), + data_len: x.len(), + _marker: PhantomData, + } + } +} + +impl Snapshot2<'_> { + #[inline] + pub fn empty() -> Self { + Self { + data_ptr: null(), + data_len: 0, + _marker: PhantomData, + } + } +} + #[allow(non_camel_case_types)] type deno_recv_cb = unsafe extern "C" fn( user_data: *mut c_void, @@ -126,9 +177,9 @@ type deno_resolve_cb = unsafe extern "C" fn( ) -> deno_mod; #[repr(C)] -pub struct deno_config { +pub struct deno_config<'a> { pub will_snapshot: c_int, - pub load_snapshot: deno_buf, + pub load_snapshot: Snapshot2<'a>, pub shared: deno_buf, pub recv_cb: deno_recv_cb, } @@ -214,4 +265,9 @@ extern "C" { user_data: *const c_void, id: deno_mod, ); + + pub fn deno_snapshot_new(i: *const isolate) -> Snapshot1<'static>; + + #[allow(dead_code)] + pub fn deno_snapshot_delete(s: &mut deno_snapshot); } diff --git a/core/libdeno/api.cc b/core/libdeno/api.cc index fa1fe92f9e..ad9c2a5741 100644 --- a/core/libdeno/api.cc +++ b/core/libdeno/api.cc @@ -93,7 +93,7 @@ void deno_unlock(Deno* d_) { d->locker_ = nullptr; } -deno_buf deno_get_snapshot(Deno* d_) { +deno_snapshot deno_snapshot_new(Deno* d_) { auto* d = unwrap(d_); CHECK_NOT_NULL(d->snapshot_creator_); d->ClearModules(); @@ -101,8 +101,12 @@ deno_buf deno_get_snapshot(Deno* d_) { auto blob = d->snapshot_creator_->CreateBlob( v8::SnapshotCreator::FunctionCodeHandling::kKeep); - return {nullptr, 0, reinterpret_cast(const_cast(blob.data)), - blob.raw_size, 0}; + return {reinterpret_cast(const_cast(blob.data)), + blob.raw_size}; +} + +void deno_snapshot_delete(deno_snapshot snapshot) { + delete[] snapshot.data_ptr; } static std::unique_ptr platform; diff --git a/core/libdeno/deno.h b/core/libdeno/deno.h index f3902985e0..8054090eda 100644 --- a/core/libdeno/deno.h +++ b/core/libdeno/deno.h @@ -18,6 +18,11 @@ typedef struct { size_t zero_copy_id; // 0 = normal, 1 = must call deno_zero_copy_release. } deno_buf; +typedef struct { + uint8_t* data_ptr; + size_t data_len; +} deno_snapshot; + typedef struct deno_s Deno; // A callback to receive a message from a libdeno.send() javascript call. @@ -31,23 +36,28 @@ const char* deno_v8_version(); void deno_set_v8_flags(int* argc, char** argv); typedef struct { - int will_snapshot; // Default 0. If calling deno_get_snapshot 1. - deno_buf load_snapshot; // Optionally: A deno_buf from deno_get_snapshot. - deno_buf shared; // Shared buffer to be mapped to libdeno.shared - deno_recv_cb recv_cb; // Maps to libdeno.send() calls. + int will_snapshot; // Default 0. If calling deno_snapshot_new 1. + deno_snapshot load_snapshot; // A startup snapshot to use. + deno_buf shared; // Shared buffer to be mapped to libdeno.shared + deno_recv_cb recv_cb; // Maps to libdeno.send() calls. } deno_config; // Create a new deno isolate. -// Warning: If config.will_snapshot is set, deno_get_snapshot() must be called +// Warning: If config.will_snapshot is set, deno_snapshot_new() must be called // or an error will result. Deno* deno_new(deno_config config); - -// Generate a snapshot. The resulting buf can be used with deno_new. -// The caller must free the returned data by calling delete[] buf.data_ptr. -deno_buf deno_get_snapshot(Deno* d); - void deno_delete(Deno* d); +// Generate a snapshot. The resulting buf can be used in as the load_snapshot +// member in deno_confg. +// When calling this function, the caller must have created the isolate "d" with +// "will_snapshot" set to 1. +// The caller must free the returned data with deno_snapshot_delete(). +deno_snapshot deno_snapshot_new(Deno* d); + +// Only for use with data returned from deno_snapshot_new. +void deno_snapshot_delete(deno_snapshot); + void deno_lock(Deno* d); void deno_unlock(Deno* d); diff --git a/core/libdeno/internal.h b/core/libdeno/internal.h index 71cf731b69..ce8c63c56b 100644 --- a/core/libdeno/internal.h +++ b/core/libdeno/internal.h @@ -169,6 +169,7 @@ static intptr_t external_references[] = { 0}; static const deno_buf empty_buf = {nullptr, 0, nullptr, 0, 0}; +static const deno_snapshot empty_snapshot = {nullptr, 0}; Deno* NewFromSnapshot(void* user_data, deno_recv_cb cb); diff --git a/core/libdeno/libdeno_test.cc b/core/libdeno/libdeno_test.cc index 8949e7f4a8..7b936cc32b 100644 --- a/core/libdeno/libdeno_test.cc +++ b/core/libdeno/libdeno_test.cc @@ -10,10 +10,10 @@ TEST(LibDenoTest, InitializesCorrectly) { } TEST(LibDenoTest, Snapshotter) { - Deno* d1 = deno_new(deno_config{1, empty, empty, nullptr}); + Deno* d1 = deno_new(deno_config{1, empty_snapshot, empty, nullptr}); deno_execute(d1, nullptr, "a.js", "a = 1 + 2"); EXPECT_EQ(nullptr, deno_last_exception(d1)); - deno_buf test_snapshot = deno_get_snapshot(d1); + deno_snapshot test_snapshot = deno_snapshot_new(d1); deno_delete(d1); Deno* d2 = deno_new(deno_config{0, test_snapshot, empty, nullptr}); @@ -21,7 +21,7 @@ TEST(LibDenoTest, Snapshotter) { EXPECT_EQ(nullptr, deno_last_exception(d2)); deno_delete(d2); - delete[] test_snapshot.data_ptr; + deno_snapshot_delete(test_snapshot); } TEST(LibDenoTest, CanCallFunction) { @@ -249,7 +249,7 @@ TEST(LibDenoTest, CheckPromiseErrors) { } TEST(LibDenoTest, LastException) { - Deno* d = deno_new(deno_config{0, empty, empty, nullptr}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr}); EXPECT_EQ(deno_last_exception(d), nullptr); deno_execute(d, nullptr, "a.js", "\n\nthrow Error('boo');\n\n"); EXPECT_STREQ(deno_last_exception(d), @@ -264,7 +264,7 @@ TEST(LibDenoTest, LastException) { } TEST(LibDenoTest, EncodeErrorBug) { - Deno* d = deno_new(deno_config{0, empty, empty, nullptr}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr}); EXPECT_EQ(deno_last_exception(d), nullptr); deno_execute(d, nullptr, "a.js", "eval('a')"); EXPECT_STREQ( @@ -293,7 +293,7 @@ TEST(LibDenoTest, Shared) { } TEST(LibDenoTest, Utf8Bug) { - Deno* d = deno_new(deno_config{0, empty, empty, nullptr}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, nullptr}); // The following is a valid UTF-8 javascript which just defines a string // literal. We had a bug where libdeno would choke on this. deno_execute(d, nullptr, "a.js", "x = \"\xEF\xBF\xBD\""); @@ -318,7 +318,7 @@ TEST(LibDenoTest, LibDenoEvalContextError) { TEST(LibDenoTest, SharedAtomics) { int32_t s[] = {0, 1, 2}; deno_buf shared = {nullptr, 0, reinterpret_cast(s), sizeof s, 0}; - Deno* d = deno_new(deno_config{0, empty, shared, nullptr}); + Deno* d = deno_new(deno_config{0, empty_snapshot, shared, nullptr}); deno_execute(d, nullptr, "a.js", "Atomics.add(new Int32Array(Deno.core.shared), 0, 1)"); EXPECT_EQ(nullptr, deno_last_exception(d)); diff --git a/core/libdeno/modules_test.cc b/core/libdeno/modules_test.cc index 9f92284306..0eaa9e8eb7 100644 --- a/core/libdeno/modules_test.cc +++ b/core/libdeno/modules_test.cc @@ -13,7 +13,7 @@ void recv_cb(void* user_data, deno_buf buf, deno_buf zero_copy_buf) { TEST(ModulesTest, Resolution) { exec_count = 0; // Reset - Deno* d = deno_new(deno_config{0, empty, empty, recv_cb}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb}); EXPECT_EQ(0, exec_count); static deno_mod a = deno_mod_new(d, true, "a.js", @@ -66,7 +66,7 @@ TEST(ModulesTest, Resolution) { TEST(ModulesTest, ResolutionError) { exec_count = 0; // Reset - Deno* d = deno_new(deno_config{0, empty, empty, recv_cb}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb}); EXPECT_EQ(0, exec_count); static deno_mod a = deno_mod_new(d, true, "a.js", @@ -99,7 +99,7 @@ TEST(ModulesTest, ResolutionError) { TEST(ModulesTest, ImportMetaUrl) { exec_count = 0; // Reset - Deno* d = deno_new(deno_config{0, empty, empty, recv_cb}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb}); EXPECT_EQ(0, exec_count); static deno_mod a = @@ -119,7 +119,7 @@ TEST(ModulesTest, ImportMetaUrl) { } TEST(ModulesTest, ImportMetaMain) { - Deno* d = deno_new(deno_config{0, empty, empty, recv_cb}); + Deno* d = deno_new(deno_config{0, empty_snapshot, empty, recv_cb}); const char* throw_not_main_src = "if (!import.meta.main) throw 'err'"; static deno_mod throw_not_main = diff --git a/core/libdeno/snapshot_creator.cc b/core/libdeno/snapshot_creator.cc index 19098392df..081bd11569 100644 --- a/core/libdeno/snapshot_creator.cc +++ b/core/libdeno/snapshot_creator.cc @@ -8,8 +8,6 @@ #include "third_party/v8/include/v8.h" #include "third_party/v8/src/base/logging.h" -namespace deno {} // namespace deno - int main(int argc, char** argv) { const char* snapshot_out_bin = argv[1]; const char* js_fn = argv[2]; @@ -23,7 +21,7 @@ int main(int argc, char** argv) { CHECK(deno::ReadFileToString(js_fn, &js_source)); deno_init(); - deno_config config = {1, deno::empty_buf, deno::empty_buf, nullptr}; + deno_config config = {1, deno::empty_snapshot, deno::empty_buf, nullptr}; Deno* d = deno_new(config); deno_execute(d, nullptr, js_fn, js_source.c_str()); @@ -34,13 +32,13 @@ int main(int argc, char** argv) { return 1; } - auto snapshot = deno_get_snapshot(d); + auto snapshot = deno_snapshot_new(d); std::ofstream file_(snapshot_out_bin, std::ios::binary); file_.write(reinterpret_cast(snapshot.data_ptr), snapshot.data_len); file_.close(); - delete[] snapshot.data_ptr; + deno_snapshot_delete(snapshot); deno_delete(d); return file_.bad(); diff --git a/core/libdeno/test.cc b/core/libdeno/test.cc index 1340fe8c37..3d022c9044 100644 --- a/core/libdeno/test.cc +++ b/core/libdeno/test.cc @@ -3,7 +3,7 @@ #include #include "file_util.h" -deno_buf snapshot = {nullptr, 0, nullptr, 0, 0}; +deno_snapshot snapshot = {nullptr, 0}; int main(int argc, char** argv) { // Locate the snapshot. diff --git a/core/libdeno/test.h b/core/libdeno/test.h index 2f7c323844..dd5dc99b21 100644 --- a/core/libdeno/test.h +++ b/core/libdeno/test.h @@ -5,7 +5,8 @@ #include "deno.h" #include "testing/gtest/include/gtest/gtest.h" -extern deno_buf snapshot; // Loaded in libdeno/test.cc +extern deno_snapshot snapshot; // Loaded in libdeno/test.cc const deno_buf empty = {nullptr, 0, nullptr, 0, 0}; +const deno_snapshot empty_snapshot = {nullptr, 0}; #endif // TEST_H_