[Shared Resources] Embedded host implementation #261

jerivas · 2023-11-13T23:48:49Z

Blocked until proposal is accepted.

I refactored the functions in compile.ts into three files:

compiler.ts has common helpers used by both sync and async compilations
sync-compiler.ts got the sync functions to implement the Compiler interface
async-compiler.ts got the async functions to implement the AsyncCompiler interface

With those changes, compile.ts has become only a thin wrapper around the compiler classes. In local testing the top level compile* functions are still working as usual, but the new classes allow multiple compilations against the same underlying process.

jerivas · 2023-11-14T00:00:44Z

I want to share resources across multiple invocations of the Sass compiler's JS API.

jamesnw

Nice work! I didn't test to confirm it works, but it sounds like it is working as intended, and the refactoring makes sense to me.

lib/src/async-compiler.ts

lib/src/compile.ts

jerivas · 2023-11-14T20:21:44Z

Well, this is encouraging! I benchmarked the current implementation of the compile functions, and these are the results:

View benchmark code

import {compare, mark, run} from 'micro-bmark';
import {compileString, compileStringAsync} from './dist/lib/index.mjs';
const styles = '$foo: bar; a {b: $foo}';

await run(async () => {
  mark('compileString', 10, () => compileString(styles));
  mark(
    'compileStringAsync',
    10,
    async () => await compileStringAsync(styles)
  );
});

Benchmarking
compileString x 3 ops/sec @ 287ms/op
compileStringAsync x 4 ops/sec @ 246ms/op

Then I checked out this branch and ran a comparison of the top-level functions and the new compiler methods:

View benchmark code

import {compare, mark, run} from 'micro-bmark';
import {compileString, compileStringAsync} from './dist/lib/index.mjs';

import {initCompiler} from './dist/lib/src/sync-compiler.js';
import {initAsyncCompiler} from './dist/lib/src/async-compiler.js';

const styles = '$foo: bar; a {b: $foo}';
const compiler = initCompiler();
const asyncCompiler = await initAsyncCompiler();

await run(async () => {
  await compare('sync', 10, {
    compileString: () => compileString(styles),
    'compiler.compileString': () => compiler.compileString(styles),
  });

  await compare('async', 10, {
    compileStringAsync: async () => await compileStringAsync(styles),
    'asyncCompiler.compileStringAsync': async () =>
      await asyncCompiler.compileStringAsync(styles),
  });
});

compiler.dispose();
await asyncCompiler.dispose();

Benchmarking
sync
├─compileString x 3 ops/sec @ 290ms/op ± 1.14% (min: 282ms, max: 299ms)
└─compiler.compileString x 52 ops/sec @ 19ms/op ± 172.04% (min: 2ms, max: 158ms)
async
├─compileStringAsync x 3 ops/sec @ 257ms/op ± 1.67% (min: 248ms, max: 267ms)
└─asyncCompiler.compileStringAsync x 51 ops/sec @ 19ms/op ± 174.40% (min: 2ms, max: 161ms)

Two takeaways:

There is no performance degradation on the top-level functions, they perform the same as in main
The new methods on the compiler classes are around 17 times faster 🎉

jamesnw · 2023-11-14T21:03:58Z

@jerivas One minor quibble is that the benchmarks exclude the compiler creation. I would expect that using the Compiler class for a single compile would be the same as not using the Compiler class. But this does show that subsequent compilations without the cost of creation are much faster indeed!

jerivas · 2023-11-14T21:57:22Z

I would expect that using the Compiler class for a single compile would be the same as not using the Compiler class.

In the main implementation, the helper functions are spawning a new process on each call, which remains the same in this implementation. The benchmarks highlight the difference of not having to pay for that overhead over and over.

nex3 · 2023-11-16T02:13:33Z

@ntkme Can you take a quick look at this as well, since I believe you currently maintain the most widely-used embedded host with a long-lived compiler process?

lib/src/async-compiler.ts

lib/src/compiler.ts

ntkme · 2024-01-04T20:33:46Z

@jerivas One more change to fix the broken tests and I think we're good to go:

embedded-host-node/lib/src/compile.ts

Line 99 in ad6f671

request.input = {case: 'path', value: path};

Relative path should always be resolved to absolute path on the host side before send to compiler. CWD can now change on host between different compilations with the same persisted compiler, but we don't have a way to change CWD of compiler once started or change the base dir for resolving relative path on compiler side, so host should resolve the relative path and only pass absolute path to compiler.

jerivas · 2024-01-04T22:58:50Z

@ntkme @nex3 thanks for the review and the summary, I believe everything has been implemented now. I also added regression tests for the compilation ID and cwd issues

ntkme

LGTM

nex3 · 2024-01-05T23:24:27Z

lib/src/async-compiler.ts

  /** The underlying process that's being wrapped. */
  private readonly process = spawn(
    compilerCommand[0],
    [...compilerCommand.slice(1), '--embedded'],
-    {windowsHide: true}
+    {cwd: path.dirname(compilerCommand[0]), windowsHide: true}


Probably a good idea to add a comment here explaining why we set the CWD explicitly.

Fixed in 66a7f66

nex3 · 2024-01-05T23:28:25Z

lib/src/async-compiler.ts

+      (resolve, reject) =>
+        dispatcher.sendCompileRequest(request, (err, response) => {
+          this.compilations.delete(compilation);
+          if (this.compilations.size === 0) this.compilationId = 1;


Probably worth adding a comment here about avoiding unbounded growth as well.

Fixed in 66a7f66

nex3 · 2024-01-05T23:28:45Z

lib/src/async-compiler.ts

+  constructor(flag: Symbol | undefined) {
+    if (flag !== initFlag) {
+      throw utils.compilerError(
+        'AsyncCompiler can not be directly constructed. Please use `sass.initAsyncCompiler()` instead.'


Nit: long line

Fixed in 66a7f66

nex3 · 2024-01-06T00:13:03Z

lib/src/compiler.ts

It's confusing to me that there are files named compile.ts and compiler.ts, but the latter doesn't define a class named Compiler or anything like that. I think these are shared functions between the two compiler classes, but that might be clearer in the directory structure if you put these in a compiler/ directory with sync.ts, async.ts, and utils.ts.

Fixed in 2556525

lib/src/dispatcher.ts

Co-authored-by: なつき <i@ntk.me>

* main: Update Dart Sass version and release Look for x64 version on arm64 windows (sass#266) Update Dart Sass version and release Support musl-libc and android (sass#265)

ntkme · 2024-01-10T18:25:25Z

embedded-host-node/lib/src/function-registry.ts

Lines 15 to 25 in ad6f671

    
           /** 
        
            * The next ID to use for a function. The embedded protocol requires that 
        
            * function IDs be globally unique. 
        
            */ 
        
           let nextFunctionID = 0; 
        
           /** 
        
            * Tracks functions that are defined on the host so that the compiler can 
        
            * execute them. 
        
            */ 
        
           export class FunctionRegistry<sync extends 'sync' | 'async'> {

We should also change FunctionRegistry's nextFunctionID from a global variable to a field. As it always constructs new FunctionRegistry for each compilation, this ID only need to be unique for the current compilation.

Note, for ImporterRegistry the importer ID is already a field.

embedded-host-node/lib/src/importer-registry.ts

Lines 18 to 29 in ad6f671

    
           export class ImporterRegistry<sync extends 'sync' | 'async'> { 
        
             /** Protocol buffer representations of the registered importers. */ 
        
             readonly importers: proto.InboundMessage_CompileRequest_Importer[]; 
        
             /** A map from importer IDs to their corresponding importers. */ 
        
             private readonly importersById = new Map<number, Importer<sync>>(); 
        
             /** A map from file importer IDs to their corresponding importers. */ 
        
             private readonly fileImportersById = new Map<number, FileImporter<sync>>(); 
        
             /** The next ID to use for an importer. */ 
        
             private id = 0;

jerivas · 2024-01-11T22:59:44Z

We should also change FunctionRegistry's nextFunctionID from a global variable to a field

@ntkme Thanks! Done in 84ae6a4

jamesnw · 2024-01-17T14:53:05Z

@jerivas Can you resolve the merge conflict?

jerivas added 4 commits November 13, 2023 22:57

Flesh out the sync Compiler class

e8032ae

Factor out common compilation helpers

eb23204

Add AsyncCompiler

9e78051

Autofix

4aaa65f

jerivas requested review from jamesnw and jgerigmeyer November 13, 2023 23:59

Bring back legacy checks

1caf32e

jamesnw mentioned this pull request Nov 14, 2023

[Shared Resources] Add types and specs sass/sass#3744

Merged

jamesnw reviewed Nov 14, 2023

View reviewed changes

lib/src/async-compiler.ts Outdated Show resolved Hide resolved

lib/src/compile.ts Outdated Show resolved Hide resolved

Don't autoclose the sync compiler

b41959e

Update module exports

7906f99

jerivas mentioned this pull request Nov 14, 2023

[Shared Resources] Add JS API tests sass/sass-spec#1954

Merged

jerivas changed the title ~~Shared resources~~ [Shared Resources] Embedded host implementation Nov 14, 2023

Let active compilations settle before disposing

ebfddd9

jerivas marked this pull request as ready for review November 15, 2023 19:09

jerivas requested a review from nex3 November 15, 2023 19:11

jgerigmeyer and others added 2 commits November 15, 2023 14:57

update copyright

c47a958

Add try/catch to sync functions as well

a6ca5d9

nex3 requested changes Nov 16, 2023

View reviewed changes

lib/src/async-compiler.ts Outdated Show resolved Hide resolved

lib/src/async-compiler.ts Outdated Show resolved Hide resolved

lib/src/compiler.ts Outdated Show resolved Hide resolved

jerivas added 6 commits November 16, 2023 17:01

Export compiler classes

8ecb0e3

Remove complete compilations from compiler state

ba7c156

Update comments

cdd32ca

Add unique compilation IDs

fbbe407

Lint

c35c965

Add missing getter

298daab

jerivas added 2 commits January 4, 2024 16:33

Unsubscribe dispatchers when they execute their callback

7138091

Use consistent cwd for compiler processes

d79ada4

ntkme mentioned this pull request Jan 4, 2024

[Package Importer] Add types and specs sass/sass#3728

Merged

jerivas added 3 commits January 4, 2024 22:44

Resolve paths before sending them to the compiler process

26a0338

Lint

55e64f2

Add missing await

612db59

jerivas requested review from ntkme and nex3 January 4, 2024 22:59

ntkme approved these changes Jan 4, 2024

View reviewed changes

Clean up Dispatcher class

329fa94

nex3 approved these changes Jan 6, 2024

View reviewed changes

jerivas added 3 commits January 6, 2024 01:49

Update compiler imports and file structure

2556525

Update copyright year

f5c2e8a

Add comments

66a7f66

ntkme reviewed Jan 6, 2024

View reviewed changes

lib/src/dispatcher.ts Outdated Show resolved Hide resolved

jerivas and others added 4 commits January 8, 2024 11:28

Update comment

55a55ed

Co-authored-by: なつき <i@ntk.me>

Merge branch 'main' into feature.shared-resources

0f0b5aa

* main: Update Dart Sass version and release Look for x64 version on arm64 windows (sass#266) Update Dart Sass version and release Support musl-libc and android (sass#265)

update comments

2b24ec4

copyrights are inconsistent in this repo

a222ff2

jgerigmeyer approved these changes Jan 8, 2024

View reviewed changes

Add private id to FunctionRegistry

84ae6a4

ntkme mentioned this pull request Jan 17, 2024

Provide a way to share resources across multiple compilations sass/sass#3296

Closed

Merge branch 'main' into feature.shared-resources

82819b0

nex3 merged commit 91f382f into sass:main Jan 18, 2024
16 checks passed

jgerigmeyer deleted the feature.shared-resources branch January 18, 2024 02:54

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[Shared Resources] Embedded host implementation #261

[Shared Resources] Embedded host implementation #261

jerivas commented Nov 13, 2023 •

edited

Loading

jerivas commented Nov 14, 2023

jamesnw left a comment

jerivas commented Nov 14, 2023

jamesnw commented Nov 14, 2023

jerivas commented Nov 14, 2023

nex3 commented Nov 16, 2023

ntkme commented Jan 4, 2024 •

edited

Loading

jerivas commented Jan 4, 2024 •

edited

Loading

ntkme left a comment

nex3 Jan 5, 2024

jerivas Jan 6, 2024

nex3 Jan 5, 2024

jerivas Jan 6, 2024

nex3 Jan 5, 2024

jerivas Jan 6, 2024

nex3 Jan 6, 2024

jerivas Jan 6, 2024

ntkme commented Jan 10, 2024 •

edited

Loading

jerivas commented Jan 11, 2024

jamesnw commented Jan 17, 2024

[Shared Resources] Embedded host implementation #261

[Shared Resources] Embedded host implementation #261

Conversation

jerivas commented Nov 13, 2023 • edited Loading

jerivas commented Nov 14, 2023

jamesnw left a comment

Choose a reason for hiding this comment

jerivas commented Nov 14, 2023

jamesnw commented Nov 14, 2023

jerivas commented Nov 14, 2023

nex3 commented Nov 16, 2023

ntkme commented Jan 4, 2024 • edited Loading

jerivas commented Jan 4, 2024 • edited Loading

ntkme left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

ntkme commented Jan 10, 2024 • edited Loading

jerivas commented Jan 11, 2024

jamesnw commented Jan 17, 2024

jerivas commented Nov 13, 2023 •

edited

Loading

ntkme commented Jan 4, 2024 •

edited

Loading

jerivas commented Jan 4, 2024 •

edited

Loading

ntkme commented Jan 10, 2024 •

edited

Loading