mirror of
https://github.com/denoland/deno.git
synced 2024-11-01 09:24:20 -04:00
d43b43ca78
Instead of using core/snapshot_creator.rs, instead two crates are introduced which allow building the snapshot during build.rs. Rollup is removed and replaced with our own bundler. This removes the Node build dependency. Modules in //js now use Deno-style imports with file extensions, rather than Node style extensionless imports. This improves incremental build time when changes are made to //js files by about 40 seconds.
80 lines
2.2 KiB
TypeScript
80 lines
2.2 KiB
TypeScript
// Copyright 2018-2019 the Deno authors. All rights reserved. MIT license.
|
|
import * as util from "./util.ts";
|
|
import { core } from "./core.ts";
|
|
|
|
const promiseTableMin = new Map<number, util.Resolvable<number>>();
|
|
// Note it's important that promiseId starts at 1 instead of 0, because sync
|
|
// messages are indicated with promiseId 0. If we ever add wrap around logic for
|
|
// overflows, this should be taken into account.
|
|
let _nextPromiseId = 1;
|
|
|
|
function nextPromiseId(): number {
|
|
return _nextPromiseId++;
|
|
}
|
|
|
|
export interface RecordMinimal {
|
|
promiseId: number;
|
|
opId: number; // Maybe better called dispatchId
|
|
arg: number;
|
|
result: number;
|
|
}
|
|
|
|
export function recordFromBufMinimal(
|
|
opId: number,
|
|
buf32: Int32Array
|
|
): RecordMinimal {
|
|
if (buf32.length != 3) {
|
|
throw Error("Bad message");
|
|
}
|
|
return {
|
|
promiseId: buf32[0],
|
|
opId,
|
|
arg: buf32[1],
|
|
result: buf32[2]
|
|
};
|
|
}
|
|
|
|
const scratch32 = new Int32Array(3);
|
|
const scratchBytes = new Uint8Array(
|
|
scratch32.buffer,
|
|
scratch32.byteOffset,
|
|
scratch32.byteLength
|
|
);
|
|
util.assert(scratchBytes.byteLength === scratch32.length * 4);
|
|
|
|
export function asyncMsgFromRust(opId: number, ui8: Uint8Array): void {
|
|
const buf32 = new Int32Array(ui8.buffer, ui8.byteOffset, ui8.byteLength / 4);
|
|
const record = recordFromBufMinimal(opId, buf32);
|
|
const { promiseId, result } = record;
|
|
const promise = promiseTableMin.get(promiseId);
|
|
promiseTableMin.delete(promiseId);
|
|
promise!.resolve(result);
|
|
}
|
|
|
|
export function sendAsyncMinimal(
|
|
opId: number,
|
|
arg: number,
|
|
zeroCopy: Uint8Array
|
|
): Promise<number> {
|
|
const promiseId = nextPromiseId(); // AKA cmdId
|
|
scratch32[0] = promiseId;
|
|
scratch32[1] = arg;
|
|
scratch32[2] = 0; // result
|
|
const promise = util.createResolvable<number>();
|
|
promiseTableMin.set(promiseId, promise);
|
|
core.dispatch(opId, scratchBytes, zeroCopy);
|
|
return promise;
|
|
}
|
|
|
|
export function sendSyncMinimal(
|
|
opId: number,
|
|
arg: number,
|
|
zeroCopy: Uint8Array
|
|
): number {
|
|
scratch32[0] = 0; // promiseId 0 indicates sync
|
|
scratch32[1] = arg;
|
|
const res = core.dispatch(opId, scratchBytes, zeroCopy)!;
|
|
const res32 = new Int32Array(res.buffer, res.byteOffset, 3);
|
|
const resRecord = recordFromBufMinimal(opId, res32);
|
|
return resRecord.result;
|
|
}
|