refactor(minimal ops) refactor minimal ops & rename to buffer ops

cli/tests/unit/dispatch_buffer_test.ts

@@ -0,0 +1,76 @@
+import {
+  assert,
+  assertEquals,
+  assertMatch,
+  unitTest,
+  unreachable,
+} from "./test_util.ts";
+
+const readErrorStackPattern = new RegExp(
+  `^.*
+    at handleError \\(.*10_dispatch_buffer\\.js:.*\\)
+    at bufferOpParseResult \\(.*10_dispatch_buffer\\.js:.*\\)
+    at Array.<anonymous> \\(.*10_dispatch_buffer\\.js:.*\\).*$`,
+  "ms",
+);
+
+unitTest(async function sendAsyncStackTrace(): Promise<void> {
+  const buf = new Uint8Array(10);
+  const rid = 10;
+  try {
+    await Deno.read(rid, buf);
+    unreachable();
+  } catch (error) {
+    assertMatch(error.stack, readErrorStackPattern);
+  }
+});
+
+declare global {
+  // deno-lint-ignore no-namespace
+  namespace Deno {
+    // deno-lint-ignore no-explicit-any
+    var core: any; // eslint-disable-line no-var
+  }
+}
+
+unitTest(function bufferOpsHeaderTooShort(): void {
+  for (const op of ["op_read_sync", "op_read_async"]) {
+    const readOpId = Deno.core.ops()[op];
+    const res = Deno.core.send(
+      readOpId,
+      new Uint8Array([
+        1,
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+        10,
+        11,
+      ]),
+    );
+
+    const headerByteLength = 4 * 4;
+    assert(res.byteLength > headerByteLength);
+    const view = new DataView(
+      res.buffer,
+      res.byteOffset + res.byteLength - headerByteLength,
+      headerByteLength,
+    );
+
+    const requestId = Number(view.getBigUint64(0, true));
+    const status = view.getUint32(8, true);
+    const result = view.getUint32(12, true);
+
+    assert(requestId === 0);
+    assert(status !== 0);
+    assertEquals(new TextDecoder().decode(res.slice(0, result)), "TypeError");
+    assertEquals(
+      new TextDecoder().decode(res.slice(result, -headerByteLength)).trim(),
+      "Unparsable control buffer",
+    );
+  }
+});

cli/tests/unit/metrics_test.ts

@@ -13,7 +13,7 @@ unitTest(async function metrics(): Promise<void> {
   assert(m1.bytesSentControl > 0);
   assert(m1.bytesSentData >= 0);
   assert(m1.bytesReceived > 0);
-  const m1OpWrite = m1.ops["op_write"];
+  const m1OpWrite = m1.ops["op_write_async"];
   assert(m1OpWrite.opsDispatchedAsync > 0);
   assert(m1OpWrite.opsCompletedAsync > 0);
   assert(m1OpWrite.bytesSentControl > 0);
@@ -28,7 +28,7 @@ unitTest(async function metrics(): Promise<void> {
   assert(m2.bytesSentControl > m1.bytesSentControl);
   assert(m2.bytesSentData >= m1.bytesSentData + dataMsg.byteLength);
   assert(m2.bytesReceived > m1.bytesReceived);
-  const m2OpWrite = m2.ops["op_write"];
+  const m2OpWrite = m2.ops["op_write_async"];
   assert(m2OpWrite.opsDispatchedAsync > m1OpWrite.opsDispatchedAsync);
   assert(m2OpWrite.opsCompletedAsync > m1OpWrite.opsCompletedAsync);
   assert(m2OpWrite.bytesSentControl > m1OpWrite.bytesSentControl);

cli/tests/unit/unit_tests.ts

@@ -15,7 +15,7 @@ import "./console_test.ts";
 import "./copy_file_test.ts";
 import "./custom_event_test.ts";
 import "./dir_test.ts";
-import "./dispatch_minimal_test.ts";
+import "./dispatch_buffer_test.ts";
 import "./dispatch_json_test.ts";
 import "./error_stack_test.ts";
 import "./event_test.ts";

core/core.js

@@ -155,6 +155,10 @@ SharedQueue Binary Layout
     asyncHandlers[opId] = cb;
   }
 
+  function setAsyncHandlerByName(opName, cb) {
+    setAsyncHandler(opsCache[opName], cb);
+  }
+
   function handleAsyncMsgFromRust() {
     while (true) {
       const opIdBuf = shift();
@@ -256,6 +260,7 @@ SharedQueue Binary Layout
     jsonOpAsync,
     jsonOpSync,
     setAsyncHandler,
+    setAsyncHandlerByName,
     dispatch: send,
     dispatchByName: dispatch,
     ops,

runtime/js/10_dispatch_buffer.js

@@ -0,0 +1,150 @@
+// Copyright 2018-2021 the Deno authors. All rights reserved. MIT license.
+"use strict";
+
+((window) => {
+  const core = window.Deno.core;
+
+  function assert(cond) {
+    if (!cond) {
+      throw Error("assert");
+    }
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  ////////////////////////////// General async handling //////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////
+
+  // General Async response handling
+  let nextRequestId = 1;
+  const promiseTable = {};
+
+  function opAsync(opName, opRequestBuilder, opResultParser) {
+    // Make sure requests of this type are handled by the asyncHandler
+    // The asyncHandler's role is to call the "promiseTable[requestId]" function
+    core.setAsyncHandlerByName(opName, (bufUi8, _) => {
+      const [requestId, result, error] = opResultParser(bufUi8, true);
+      if (error !== null) {
+        promiseTable[requestId][1](error);
+      } else {
+        promiseTable[requestId][0](result);
+      }
+      delete promiseTable[requestId];
+    });
+
+    const requestId = nextRequestId++;
+
+    // Create and store promise
+    const promise = new Promise((resolve, reject) => {
+      promiseTable[requestId] = [resolve, reject];
+    });
+
+    // Synchronously dispatch async request
+    core.dispatchByName(opName, ...opRequestBuilder(requestId));
+
+    // Wait for async response
+    return promise;
+  }
+
+  function opSync(opName, opRequestBuilder, opResultParser) {
+    const rawResult = core.dispatchByName(opName, ...opRequestBuilder());
+
+    const [_, result, error] = opResultParser(rawResult, false);
+    if (error !== null) throw error;
+    return result;
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  /////////////////////////////////// Error handling /////////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////
+
+  function handleError(className, message) {
+    const [ErrorClass, args] = core.getErrorClassAndArgs(className);
+    if (!ErrorClass) {
+      return new Error(
+        `Unregistered error class: "${className}"\n` +
+          `  ${message}\n` +
+          `  Classes of errors returned from ops should be registered via Deno.core.registerErrorClass().`,
+      );
+    }
+    return new ErrorClass(message, ...args);
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+  ///////////////////////////////// Buffer ops handling //////////////////////////////////////
+  ////////////////////////////////////////////////////////////////////////////////////////////
+
+  const scratchBytes = new ArrayBuffer(3 * 4);
+  const scratchView = new DataView(
+    scratchBytes,
+    scratchBytes.byteOffset,
+    scratchBytes.byteLength,
+  );
+
+  function bufferOpBuildRequest(requestId, argument, zeroCopy) {
+    scratchView.setBigUint64(0, BigInt(requestId), true);
+    scratchView.setUint32(8, argument, true);
+    return [scratchView, ...zeroCopy];
+  }
+
+  function bufferOpParseResult(bufUi8, isCopyNeeded) {
+    // Decode header value from ui8 buffer
+    const headerByteLength = 4 * 4;
+    assert(bufUi8.byteLength >= headerByteLength);
+    assert(bufUi8.byteLength % 4 == 0);
+    const view = new DataView(
+      bufUi8.buffer,
+      bufUi8.byteOffset + bufUi8.byteLength - headerByteLength,
+      headerByteLength,
+    );
+
+    const requestId = Number(view.getBigUint64(0, true));
+    const status = view.getUint32(8, true);
+    const result = view.getUint32(12, true);
+
+    // Error handling
+    if (status !== 0) {
+      const className = core.decode(bufUi8.subarray(0, result));
+      const message = core.decode(bufUi8.subarray(result, -headerByteLength))
+        .trim();
+
+      return [requestId, null, handleError(className, message)];
+    }
+
+    if (bufUi8.byteLength === headerByteLength) {
+      return [requestId, result, null];
+    }
+
+    // Rest of response buffer is passed as reference or as a copy
+    let respBuffer = null;
+    if (isCopyNeeded) {
+      // Copy part of the response array (if sent through shared array buf)
+      respBuffer = bufUi8.slice(0, result);
+    } else {
+      // Create view on existing array (if sent through overflow)
+      respBuffer = bufUi8.subarray(0, result);
+    }
+
+    return [requestId, respBuffer, null];
+  }
+
+  function bufferOpAsync(opName, argument = 0, ...zeroCopy) {
+    return opAsync(
+      opName,
+      (requestId) => bufferOpBuildRequest(requestId, argument, zeroCopy),
+      bufferOpParseResult,
+    );
+  }
+
+  function bufferOpSync(opName, argument = 0, ...zeroCopy) {
+    return opSync(
+      opName,
+      () => bufferOpBuildRequest(0, argument, zeroCopy),
+      bufferOpParseResult,
+    );
+  }
+
+  window.__bootstrap.dispatchBuffer = {
+    bufferOpSync,
+    bufferOpAsync,
+  };
+})(this);