feat: support vCpuTime function

Author: Guy Bedford

.vscode/c_cpp_properties.json

@@ -3,12 +3,11 @@
         {
             "name": "sm-wasi",
             "includePath": [
-                "${workspaceFolder}/runtime/spidermonkey/debug/include",
-                "${workspaceFolder}/runtime/spidermonkey/release/include",
+                "${workspaceFolder}/runtime/StarlingMonkey/include",
+                "${workspaceFolder}/runtime/StarlingMonkey/builtins/web",
+                "${workspaceFolder}/runtime/fastly/build-debug/",
                 "/opt/wasi-sdk/share/wasi-sysroot/include/",
-                "${workspaceFolder}/runtime/js-compute-runtime",
-                "${workspaceFolder}/runtime/js-compute-runtime/build/openssl-3.0.7/include",
-                "${workspaceFolder}/runtime/js-compute-runtime/third_party/fmt/include"
+                "${workspaceFolder}/runtime/fastly/host-api"
             ],
             "defines": [
                 "__wasi__"
@@ -22,8 +21,7 @@
             },
             "forcedInclude": [
                 "${workspaceFolder}/.vscode/vscode-preinclude.h"
-            ],
-            "compileCommands": "${workspaceFolder}/runtime/js-compute-runtime/compile_commands.json"
+            ]
         }
     ],
     "version": 4

integration-tests/js-compute/fixtures/app/src/assertions-throwing.js

@@ -54,6 +54,16 @@ export function assert(actual, expected, code) {
   }
 }
 
+export { assert as strictEqual }
+
+export function ok(truthy, code) {
+  if (!truthy) {
+    fail(
+      `Expected ${code ? ' ' + code : ''}to be truthy - Found \`${JSON.stringify(prettyPrintSymbol(truthy))}\``,
+    );
+  }
+}
+
 export async function assertResolves(func) {
   try {
     await func();
@@ -124,6 +134,8 @@ export function assertDoesNotThrow(func) {
   }
 }
 
+export { deepEqual as deepStrictEqual }
+
 export function deepEqual(a, b) {
   var aKeys;
   var bKeys;

integration-tests/js-compute/fixtures/app/src/index.js

@@ -44,6 +44,7 @@ import "./request-method.js";
 import "./response-json.js";
 import "./response-redirect.js";
 import "./response.js";
+import "./runtime.js";
 import "./secret-store.js";
 import "./server.js";
 import "./tee.js";

integration-tests/js-compute/fixtures/app/src/runtime.js

@@ -0,0 +1,26 @@
+import {
+  pass,
+  ok,
+  strictEqual
+} from "./assertions-throwing.js";
+import { routes } from "./routes.js";
+import { vCpuTime } from "fastly:runtime";
+
+routes.set("/runtime/get-vcpu-ms", () => {
+  const cpuTime = vCpuTime();
+  console.log(cpuTime);
+  strictEqual(typeof cpuTime, 'number');
+  console.log('3');
+  ok(cpuTime > 0);
+  ok(cpuTime < 1000);
+  console.log('4');
+  const arr = [];
+  for (let i = 0; i < 1000; i++) {
+    arr.push(i);
+  }
+  const cpuTime2 = vCpuTime();
+  ok(cpuTime2 > cpuTime);
+  ok(cpuTime2 - cpuTime > 1);
+  ok(cpuTime2 - cpuTime < 1000);
+  return pass();
+});

integration-tests/js-compute/fixtures/app/tests.json

@@ -9066,5 +9066,16 @@
       "status": 200,
       "body": "ok"
     }
+  },
+  "GET /runtime/get-vcpu-ms": {
+    "environments": ["compute", "viceroy"],
+    "downstream_request": {
+      "method": "GET",
+      "pathname": "/runtime/get-vcpu-ms"
+    },
+    "downstream_response": {
+      "body": "ok",
+      "status": 200
+    }
   }
 }

runtime/fastly/builtins/fastly.cpp

@@ -220,6 +220,18 @@ bool Fastly::env_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
+bool runtime_get_vcpu_time(JSContext *cx, unsigned argc, JS::Value *vp) {
+  JS::CallArgs args = CallArgsFromVp(argc, vp);
+  auto res = host_api::Runtime::get_vcpu_ms();
+  if (auto *err = res.to_err()) {
+    HANDLE_ERROR(cx, *err);
+    return false;
+  }
+  fprintf(stderr, "GOT: %llu", res.unwrap());
+  args.rval().setNumber(res.unwrap());
+  return true;
+}
+
 bool Env::env_get(JSContext *cx, unsigned argc, JS::Value *vp) {
   JS::CallArgs args = CallArgsFromVp(argc, vp);
   if (!args.requireAtLeast(cx, "fastly.env.get", 1))
@@ -412,6 +424,23 @@ bool install(api::Engine *engine) {
     return false;
   }
 
+  // fastly:runtime
+  auto runtime_vcpu_time_get =
+      JS_NewFunction(engine->cx(), &runtime_get_vcpu_time, 0, 0, "vCpuTime");
+  RootedObject runtime_vcpu_time_get_obj(engine->cx(), JS_GetFunctionObject(runtime_vcpu_time_get));
+  RootedValue runtime_vcpu_time_get_val(engine->cx(), ObjectValue(*runtime_vcpu_time_get_obj));
+  RootedObject runtime_builtin(engine->cx(), JS_NewObject(engine->cx(), nullptr));
+  if (!JS_SetProperty(engine->cx(), runtime_builtin, "vCpuTime", runtime_vcpu_time_get_val)) {
+    return false;
+  }
+  if (!JS_SetProperty(engine->cx(), fastly, "vCpuTime", runtime_vcpu_time_get_val)) {
+    return false;
+  }
+  RootedValue runtime_builtin_val(engine->cx(), JS::ObjectValue(*runtime_builtin));
+  if (!engine->define_builtin_module("fastly:runtime", runtime_builtin_val)) {
+    return false;
+  }
+
   // fastly:experimental
   RootedObject experimental(engine->cx(), JS_NewObject(engine->cx(), nullptr));
   RootedValue experimental_val(engine->cx(), JS::ObjectValue(*experimental));

runtime/fastly/host-api/fastly.h

@@ -749,6 +749,9 @@ WASM_IMPORT("fastly_device_detection", "lookup")
 int device_detection_lookup(const char *user_agent, size_t user_agent_len, const char *buf,
                             size_t buf_len, size_t *nwritten);
 
+WASM_IMPORT("fastly_compute_runtime", "get_vcpu_ms")
+int runtime_get_vcpu_ms(uint64_t *vcpu_ms);
+
 } // namespace fastly
 #ifdef __cplusplus
 }

runtime/fastly/host-api/host_api.cpp

@@ -2773,4 +2773,16 @@ Result<HostString> DeviceDetection::lookup(std::string_view user_agent) {
   return res;
 }
 
+Result<uint64_t> Runtime::get_vcpu_ms() {
+  Result<uint64_t> res;
+  uint64_t ret;
+  fastly::fastly_host_error err;
+  if (!convert_result(fastly::runtime_get_vcpu_ms(&ret), &err)) {
+    res.emplace_err(err);
+  } else {
+    res.emplace(ret);
+  }
+  return res;
+}
+
 } // namespace host_api

runtime/fastly/host-api/host_api_fastly.h

@@ -806,6 +806,11 @@ class DeviceDetection final {
   static Result<HostString> lookup(std::string_view user_agent);
 };
 
+class Runtime final {
+public:
+  static Result<uint64_t> get_vcpu_ms();
+};
+
 } // namespace host_api
 
 #endif

src/bundle.js

@@ -94,6 +94,11 @@ export const TransactionCacheEntry = globalThis.TransactionCacheEntry;
 `,
           };
         }
+        case 'runtime': {
+          return {
+            contents: `export const vCpuTime = globalThis.fastly.vCpuTime;`,
+          };
+        }
       }
     });
   },