mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
core: remove support for moving deno_buf ownership from C++ to JavaScript
The functionality hasn't been in use for a long time. Without this feature, the `alloc_ptr` and `alloc_len` fields are no longer necessary.
This commit is contained in:
parent
c05cbc8eac
commit
ae0544b7ce
6 changed files with 40 additions and 144 deletions
|
@ -19,16 +19,9 @@ pub struct isolate {
|
|||
_unused: [u8; 0],
|
||||
}
|
||||
|
||||
/// If "alloc_ptr" is not null, this type represents a buffer which is created
|
||||
/// in C side, and then passed to Rust side by `deno_recv_cb`. Finally it should
|
||||
/// be moved back to C side by `deno_respond`. If it is not passed to
|
||||
/// `deno_respond` in the end, it will be leaked.
|
||||
///
|
||||
/// If "alloc_ptr" is null, this type represents a borrowed slice.
|
||||
/// This type represents a borrowed slice.
|
||||
#[repr(C)]
|
||||
pub struct deno_buf {
|
||||
alloc_ptr: *const u8,
|
||||
alloc_len: usize,
|
||||
data_ptr: *const u8,
|
||||
data_len: usize,
|
||||
}
|
||||
|
@ -41,8 +34,6 @@ impl deno_buf {
|
|||
#[inline]
|
||||
pub fn empty() -> Self {
|
||||
Self {
|
||||
alloc_ptr: null(),
|
||||
alloc_len: 0,
|
||||
data_ptr: null(),
|
||||
data_len: 0,
|
||||
}
|
||||
|
@ -51,8 +42,6 @@ impl deno_buf {
|
|||
#[inline]
|
||||
pub unsafe fn from_raw_parts(ptr: *const u8, len: usize) -> Self {
|
||||
Self {
|
||||
alloc_ptr: null(),
|
||||
alloc_len: 0,
|
||||
data_ptr: ptr,
|
||||
data_len: len,
|
||||
}
|
||||
|
@ -64,8 +53,6 @@ impl<'a> From<&'a [u8]> for deno_buf {
|
|||
#[inline]
|
||||
fn from(x: &'a [u8]) -> Self {
|
||||
Self {
|
||||
alloc_ptr: null(),
|
||||
alloc_len: 0,
|
||||
data_ptr: x.as_ref().as_ptr(),
|
||||
data_len: x.len(),
|
||||
}
|
||||
|
|
|
@ -167,57 +167,33 @@ v8::Local<v8::Uint8Array> ImportBuf(DenoIsolate* d, deno_buf buf) {
|
|||
return v8::Local<v8::Uint8Array>();
|
||||
}
|
||||
|
||||
if (buf.alloc_ptr == nullptr) {
|
||||
// If alloc_ptr isn't set, we memcpy.
|
||||
// This is currently used for flatbuffers created in Rust.
|
||||
|
||||
// To avoid excessively allocating new ArrayBuffers, we try to reuse a
|
||||
// single global ArrayBuffer. The caveat is that users must extract data
|
||||
// from it before the next tick. We only do this for ArrayBuffers less than
|
||||
// 1024 bytes.
|
||||
v8::Local<v8::ArrayBuffer> ab;
|
||||
void* data;
|
||||
if (buf.data_len > GLOBAL_IMPORT_BUF_SIZE) {
|
||||
// Simple case. We allocate a new ArrayBuffer for this.
|
||||
ab = v8::ArrayBuffer::New(d->isolate_, buf.data_len);
|
||||
data = ab->GetContents().Data();
|
||||
} else {
|
||||
// Fast case. We reuse the global ArrayBuffer.
|
||||
if (d->global_import_buf_.IsEmpty()) {
|
||||
// Lazily initialize it.
|
||||
DCHECK_NULL(d->global_import_buf_ptr_);
|
||||
ab = v8::ArrayBuffer::New(d->isolate_, GLOBAL_IMPORT_BUF_SIZE);
|
||||
d->global_import_buf_.Reset(d->isolate_, ab);
|
||||
d->global_import_buf_ptr_ = ab->GetContents().Data();
|
||||
} else {
|
||||
DCHECK(d->global_import_buf_ptr_);
|
||||
ab = d->global_import_buf_.Get(d->isolate_);
|
||||
}
|
||||
data = d->global_import_buf_ptr_;
|
||||
}
|
||||
memcpy(data, buf.data_ptr, buf.data_len);
|
||||
auto view = v8::Uint8Array::New(ab, 0, buf.data_len);
|
||||
return view;
|
||||
// To avoid excessively allocating new ArrayBuffers, we try to reuse a single
|
||||
// global ArrayBuffer. The caveat is that users must extract data from it
|
||||
// before the next tick. We only do this for ArrayBuffers less than 1024
|
||||
// bytes.
|
||||
v8::Local<v8::ArrayBuffer> ab;
|
||||
void* data;
|
||||
if (buf.data_len > GLOBAL_IMPORT_BUF_SIZE) {
|
||||
// Simple case. We allocate a new ArrayBuffer for this.
|
||||
ab = v8::ArrayBuffer::New(d->isolate_, buf.data_len);
|
||||
data = ab->GetContents().Data();
|
||||
} else {
|
||||
auto ab = v8::ArrayBuffer::New(
|
||||
d->isolate_, reinterpret_cast<void*>(buf.alloc_ptr), buf.alloc_len,
|
||||
v8::ArrayBufferCreationMode::kInternalized);
|
||||
auto view =
|
||||
v8::Uint8Array::New(ab, buf.data_ptr - buf.alloc_ptr, buf.data_len);
|
||||
return view;
|
||||
// Fast case. We reuse the global ArrayBuffer.
|
||||
if (d->global_import_buf_.IsEmpty()) {
|
||||
// Lazily initialize it.
|
||||
DCHECK_NULL(d->global_import_buf_ptr_);
|
||||
ab = v8::ArrayBuffer::New(d->isolate_, GLOBAL_IMPORT_BUF_SIZE);
|
||||
d->global_import_buf_.Reset(d->isolate_, ab);
|
||||
d->global_import_buf_ptr_ = ab->GetContents().Data();
|
||||
} else {
|
||||
DCHECK(d->global_import_buf_ptr_);
|
||||
ab = d->global_import_buf_.Get(d->isolate_);
|
||||
}
|
||||
data = d->global_import_buf_ptr_;
|
||||
}
|
||||
}
|
||||
|
||||
static deno_buf GetContents(v8::Isolate* isolate,
|
||||
v8::Local<v8::ArrayBufferView> view) {
|
||||
auto ab = view->Buffer();
|
||||
auto contents = ab->GetContents();
|
||||
deno_buf buf;
|
||||
buf.alloc_ptr = reinterpret_cast<uint8_t*>(contents.Data());
|
||||
buf.alloc_len = contents.ByteLength();
|
||||
buf.data_ptr = buf.alloc_ptr + view->ByteOffset();
|
||||
buf.data_len = view->ByteLength();
|
||||
return buf;
|
||||
memcpy(data, buf.data_ptr, buf.data_len);
|
||||
auto view = v8::Uint8Array::New(ab, 0, buf.data_len);
|
||||
return view;
|
||||
}
|
||||
|
||||
// Sets the recv_ callback.
|
||||
|
@ -247,13 +223,12 @@ void Send(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
|||
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
|
||||
deno_buf control = {nullptr, 0u, nullptr, 0u};
|
||||
if (args.Length() > 0) {
|
||||
v8::Local<v8::Value> control_v = args[0];
|
||||
if (control_v->IsArrayBufferView()) {
|
||||
control =
|
||||
GetContents(isolate, v8::Local<v8::ArrayBufferView>::Cast(control_v));
|
||||
}
|
||||
deno_buf control = {nullptr, 0};
|
||||
if (args[0]->IsArrayBufferView()) {
|
||||
auto view = v8::Local<v8::ArrayBufferView>::Cast(args[0]);
|
||||
auto data =
|
||||
reinterpret_cast<uint8_t*>(view->Buffer()->GetContents().Data());
|
||||
control = {data + view->ByteOffset(), view->ByteLength()};
|
||||
}
|
||||
|
||||
PinnedBuf zero_copy =
|
||||
|
|
|
@ -17,10 +17,8 @@ typedef deno::PinnedBuf::Raw deno_pinned_buf;
|
|||
|
||||
// Data that gets transmitted.
|
||||
typedef struct {
|
||||
uint8_t* alloc_ptr; // Start of memory allocation (from `new uint8_t[len]`).
|
||||
size_t alloc_len; // Length of the memory allocation.
|
||||
uint8_t* data_ptr; // Start of logical contents (within the allocation).
|
||||
size_t data_len; // Length of logical contents.
|
||||
uint8_t* data_ptr;
|
||||
size_t data_len;
|
||||
} deno_buf;
|
||||
|
||||
typedef struct {
|
||||
|
|
|
@ -157,7 +157,7 @@ static intptr_t external_references[] = {
|
|||
reinterpret_cast<intptr_t>(MessageCallback),
|
||||
0};
|
||||
|
||||
static const deno_buf empty_buf = {nullptr, 0, nullptr, 0};
|
||||
static const deno_buf empty_buf = {nullptr, 0};
|
||||
static const deno_snapshot empty_snapshot = {nullptr, 0};
|
||||
|
||||
Deno* NewFromSnapshot(void* user_data, deno_recv_cb cb);
|
||||
|
|
|
@ -41,17 +41,6 @@ TEST(LibDenoTest, ErrorsCorrectly) {
|
|||
deno_delete(d);
|
||||
}
|
||||
|
||||
deno_buf strbuf(const char* str) {
|
||||
auto len = strlen(str);
|
||||
deno_buf buf;
|
||||
buf.alloc_ptr = new uint8_t[len];
|
||||
buf.alloc_len = len;
|
||||
buf.data_ptr = buf.alloc_ptr;
|
||||
buf.data_len = len;
|
||||
memcpy(buf.data_ptr, str, len);
|
||||
return buf;
|
||||
}
|
||||
|
||||
void assert_null(deno_pinned_buf b) {
|
||||
EXPECT_EQ(b.data_ptr, nullptr);
|
||||
EXPECT_EQ(b.data_len, 0u);
|
||||
|
@ -85,7 +74,8 @@ TEST(LibDenoTest, RecvReturnBar) {
|
|||
EXPECT_EQ(buf.data_ptr[0], 'a');
|
||||
EXPECT_EQ(buf.data_ptr[1], 'b');
|
||||
EXPECT_EQ(buf.data_ptr[2], 'c');
|
||||
deno_respond(d, user_data, strbuf("bar"));
|
||||
uint8_t response[] = {'b', 'a', 'r'};
|
||||
deno_respond(d, user_data, {response, sizeof response});
|
||||
};
|
||||
Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
|
||||
deno_execute(d, d, "a.js", "RecvReturnBar()");
|
||||
|
@ -101,60 +91,6 @@ TEST(LibDenoTest, DoubleRecvFails) {
|
|||
deno_delete(d);
|
||||
}
|
||||
|
||||
TEST(LibDenoTest, SendRecvSlice) {
|
||||
static int count = 0;
|
||||
auto recv_cb = [](auto user_data, auto buf, auto zero_copy_buf) {
|
||||
auto d = reinterpret_cast<Deno*>(user_data);
|
||||
assert_null(zero_copy_buf);
|
||||
static const size_t alloc_len = 1024;
|
||||
size_t i = count++;
|
||||
// Check the size and offset of the slice.
|
||||
size_t data_offset = buf.data_ptr - buf.alloc_ptr;
|
||||
EXPECT_EQ(data_offset, i * 11);
|
||||
EXPECT_EQ(buf.data_len, alloc_len - i * 30);
|
||||
EXPECT_EQ(buf.alloc_len, alloc_len);
|
||||
// Check values written by the JS side.
|
||||
EXPECT_EQ(buf.data_ptr[0], 100 + i);
|
||||
EXPECT_EQ(buf.data_ptr[buf.data_len - 1], 100 - i);
|
||||
// Make copy of the backing buffer -- this is currently necessary
|
||||
// because deno_respond() takes ownership over the buffer, but we are
|
||||
// not given ownership of `buf` by our caller.
|
||||
uint8_t* alloc_ptr = new uint8_t[alloc_len];
|
||||
memcpy(alloc_ptr, buf.alloc_ptr, alloc_len);
|
||||
// Make a slice that is a bit shorter than the original.
|
||||
deno_buf buf2{alloc_ptr, alloc_len, alloc_ptr + data_offset,
|
||||
buf.data_len - 19};
|
||||
// Place some values into the buffer for the JS side to verify.
|
||||
buf2.data_ptr[0] = 200 + i;
|
||||
buf2.data_ptr[buf2.data_len - 1] = 200 - i;
|
||||
// Send back.
|
||||
deno_respond(d, user_data, buf2);
|
||||
};
|
||||
Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
|
||||
deno_execute(d, d, "a.js", "SendRecvSlice()");
|
||||
EXPECT_EQ(nullptr, deno_last_exception(d));
|
||||
EXPECT_EQ(count, 5);
|
||||
deno_delete(d);
|
||||
}
|
||||
|
||||
TEST(LibDenoTest, JSSendArrayBufferViewTypes) {
|
||||
static int count = 0;
|
||||
auto recv_cb = [](auto _, auto buf, auto zero_copy_buf) {
|
||||
assert_null(zero_copy_buf);
|
||||
count++;
|
||||
size_t data_offset = buf.data_ptr - buf.alloc_ptr;
|
||||
EXPECT_EQ(data_offset, 2468u);
|
||||
EXPECT_EQ(buf.data_len, 1000u);
|
||||
EXPECT_EQ(buf.alloc_len, 4321u);
|
||||
EXPECT_EQ(buf.data_ptr[0], count);
|
||||
};
|
||||
Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
|
||||
deno_execute(d, nullptr, "a.js", "JSSendArrayBufferViewTypes()");
|
||||
EXPECT_EQ(nullptr, deno_last_exception(d));
|
||||
EXPECT_EQ(count, 3);
|
||||
deno_delete(d);
|
||||
}
|
||||
|
||||
TEST(LibDenoTest, TypedArraySnapshots) {
|
||||
Deno* d = deno_new(deno_config{0, snapshot, empty, nullptr});
|
||||
deno_execute(d, nullptr, "a.js", "TypedArraySnapshots()");
|
||||
|
@ -266,7 +202,7 @@ TEST(LibDenoTest, EncodeErrorBug) {
|
|||
|
||||
TEST(LibDenoTest, Shared) {
|
||||
uint8_t s[] = {0, 1, 2};
|
||||
deno_buf shared = {nullptr, 0, s, 3};
|
||||
deno_buf shared = {s, sizeof s};
|
||||
Deno* d = deno_new(deno_config{0, snapshot, shared, nullptr});
|
||||
deno_execute(d, nullptr, "a.js", "Shared()");
|
||||
EXPECT_EQ(nullptr, deno_last_exception(d));
|
||||
|
@ -301,7 +237,7 @@ TEST(LibDenoTest, LibDenoEvalContextError) {
|
|||
|
||||
TEST(LibDenoTest, SharedAtomics) {
|
||||
int32_t s[] = {0, 1, 2};
|
||||
deno_buf shared = {nullptr, 0, reinterpret_cast<uint8_t*>(s), sizeof s};
|
||||
deno_buf shared = {reinterpret_cast<uint8_t*>(s), sizeof s};
|
||||
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)");
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
#include "testing/gtest/include/gtest/gtest.h"
|
||||
|
||||
extern deno_snapshot snapshot; // Loaded in libdeno/test.cc
|
||||
const deno_buf empty = {nullptr, 0, nullptr, 0};
|
||||
const deno_buf empty = {nullptr, 0};
|
||||
const deno_snapshot empty_snapshot = {nullptr, 0};
|
||||
|
||||
#endif // TEST_H_
|
||||
|
|
Loading…
Reference in a new issue