deno_core (#1827)

A new low-level crate with focus on speed. 
This doesn't yet hook into the existing code base.

1 files changed, 37 insertions, 26 deletions

diff --git a/libdeno/libdeno_test.cc b/libdeno/libdeno_test.cc
index 3193e7677..90fceef73 100644
--- a/libdeno/libdeno_test.cc
+++ b/libdeno/libdeno_test.cc
@@ -26,9 +26,11 @@ TEST(LibDenoTest, Snapshotter) {
 
 TEST(LibDenoTest, CanCallFunction) {
   Deno* d = deno_new(deno_config{0, snapshot, empty, nullptr});
+  deno_lock(d);
   deno_execute(d, nullptr, "a.js",
                "if (CanCallFunction() != 'foo') throw Error();");
   EXPECT_EQ(nullptr, deno_last_exception(d));
+  deno_unlock(d);
   deno_delete(d);
 }
 
@@ -47,6 +49,7 @@ deno_buf strbuf(const char* str) {
   buf.alloc_len = len + 1;
   buf.data_ptr = buf.alloc_ptr;
   buf.data_len = len;
+  buf.zero_copy_id = 0;
 
   return buf;
 }
@@ -71,8 +74,8 @@ void assert_null(deno_buf b) {
 
 TEST(LibDenoTest, RecvReturnEmpty) {
   static int count = 0;
-  auto recv_cb = [](auto _, int req_id, auto buf, auto data_buf) {
-    assert_null(data_buf);
+  auto recv_cb = [](auto _, auto buf, auto zero_copy_buf) {
+    assert_null(zero_copy_buf);
     count++;
     EXPECT_EQ(static_cast<size_t>(3), buf.data_len);
     EXPECT_EQ(buf.data_ptr[0], 'a');
@@ -88,15 +91,17 @@ TEST(LibDenoTest, RecvReturnEmpty) {
 
 TEST(LibDenoTest, RecvReturnBar) {
   static int count = 0;
-  auto recv_cb = [](auto user_data, int req_id, auto buf, auto data_buf) {
+  auto recv_cb = [](auto user_data, auto buf, auto zero_copy_buf) {
     auto d = reinterpret_cast<Deno*>(user_data);
-    assert_null(data_buf);
+    assert_null(zero_copy_buf);
     count++;
     EXPECT_EQ(static_cast<size_t>(3), buf.data_len);
     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, req_id, strbuf("bar"));
+    EXPECT_EQ(zero_copy_buf.zero_copy_id, 0u);
+    EXPECT_EQ(zero_copy_buf.data_ptr, nullptr);
+    deno_respond(d, user_data, strbuf("bar"));
   };
   Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
   deno_execute(d, d, "a.js", "RecvReturnBar()");
@@ -114,9 +119,9 @@ TEST(LibDenoTest, DoubleRecvFails) {
 
 TEST(LibDenoTest, SendRecvSlice) {
   static int count = 0;
-  auto recv_cb = [](auto user_data, int req_id, auto buf, auto data_buf) {
+  auto recv_cb = [](auto user_data, auto buf, auto zero_copy_buf) {
     auto d = reinterpret_cast<Deno*>(user_data);
-    assert_null(data_buf);
+    assert_null(zero_copy_buf);
     static const size_t alloc_len = 1024;
     size_t i = count++;
     // Check the size and offset of the slice.
@@ -134,12 +139,12 @@ TEST(LibDenoTest, SendRecvSlice) {
     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};
+                  buf.data_len - 19, 0};
     // 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, req_id, buf2);
+    deno_respond(d, user_data, buf2);
   };
   Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
   deno_execute(d, d, "a.js", "SendRecvSlice()");
@@ -150,8 +155,8 @@ TEST(LibDenoTest, SendRecvSlice) {
 
 TEST(LibDenoTest, JSSendArrayBufferViewTypes) {
   static int count = 0;
-  auto recv_cb = [](auto _, int req_id, auto buf, auto data_buf) {
-    assert_null(data_buf);
+  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);
@@ -197,33 +202,39 @@ TEST(LibDenoTest, GlobalErrorHandling) {
   deno_delete(d);
 }
 
-TEST(LibDenoTest, DataBuf) {
+TEST(LibDenoTest, ZeroCopyBuf) {
   static int count = 0;
-  static deno_buf data_buf_copy;
-  auto recv_cb = [](auto _, int req_id, deno_buf buf, deno_buf data_buf) {
+  static deno_buf zero_copy_buf2;
+  auto recv_cb = [](auto user_data, deno_buf buf, deno_buf zero_copy_buf) {
     count++;
-    data_buf.data_ptr[0] = 4;
-    data_buf.data_ptr[1] = 2;
-    data_buf_copy = data_buf;
+    EXPECT_GT(zero_copy_buf.zero_copy_id, 0u);
+    zero_copy_buf.data_ptr[0] = 4;
+    zero_copy_buf.data_ptr[1] = 2;
+    zero_copy_buf2 = zero_copy_buf;
     EXPECT_EQ(2u, buf.data_len);
-    EXPECT_EQ(2u, data_buf.data_len);
+    EXPECT_EQ(2u, zero_copy_buf.data_len);
     EXPECT_EQ(buf.data_ptr[0], 1);
     EXPECT_EQ(buf.data_ptr[1], 2);
+    // Note zero_copy_buf won't actually be freed here because in
+    // libdeno_test.js zeroCopyBuf is a rooted global. We just want to exercise
+    // the API here.
+    auto d = reinterpret_cast<Deno*>(user_data);
+    deno_zero_copy_release(d, zero_copy_buf.zero_copy_id);
   };
   Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
-  deno_execute(d, nullptr, "a.js", "DataBuf()");
+  deno_execute(d, d, "a.js", "ZeroCopyBuf()");
   EXPECT_EQ(nullptr, deno_last_exception(d));
   EXPECT_EQ(count, 1);
-  // data_buf was subsequently changed in JS, let's check that our copy reflects
-  // that.
-  EXPECT_EQ(data_buf_copy.data_ptr[0], 9);
-  EXPECT_EQ(data_buf_copy.data_ptr[1], 8);
+  // zero_copy_buf was subsequently changed in JS, let's check that our copy
+  // reflects that.
+  EXPECT_EQ(zero_copy_buf2.data_ptr[0], 9);
+  EXPECT_EQ(zero_copy_buf2.data_ptr[1], 8);
   deno_delete(d);
 }
 
 TEST(LibDenoTest, CheckPromiseErrors) {
   static int count = 0;
-  auto recv_cb = [](auto _, int req_id, auto buf, auto data_buf) { count++; };
+  auto recv_cb = [](auto _, auto buf, auto zero_copy_buf) { count++; };
   Deno* d = deno_new(deno_config{0, snapshot, empty, recv_cb});
   EXPECT_EQ(deno_last_exception(d), nullptr);
   deno_execute(d, nullptr, "a.js", "CheckPromiseErrors()");
@@ -271,7 +282,7 @@ TEST(LibDenoTest, EncodeErrorBug) {
 
 TEST(LibDenoTest, Shared) {
   uint8_t s[] = {0, 1, 2};
-  deno_buf shared = {nullptr, 0, s, 3};
+  deno_buf shared = {nullptr, 0, s, 3, 0};
   Deno* d = deno_new(deno_config{0, snapshot, shared, nullptr});
   deno_execute(d, nullptr, "a.js", "Shared()");
   EXPECT_EQ(nullptr, deno_last_exception(d));
@@ -306,7 +317,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 = {nullptr, 0, reinterpret_cast<uint8_t*>(s), sizeof s, 0};
   Deno* d = deno_new(deno_config{0, empty, shared, nullptr});
   deno_execute(d, nullptr, "a.js",
                "Atomics.add(new Int32Array(libdeno.shared), 0, 1)");