v21.1.0 release proposal

BUILDING.md

@@ -110,6 +110,7 @@ platforms. This is true regardless of entries in the table below.
 | GNU/Linux        | armv6            | kernel >= 4.14, glibc >= 2.24     | Experimental                                    | Downgraded as of Node.js 12          |
 | GNU/Linux        | ppc64le >=power8 | kernel >= 4.18[^1], glibc >= 2.28 | Tier 2                                          | e.g. Ubuntu 20.04, RHEL 8            |
 | GNU/Linux        | s390x            | kernel >= 4.18[^1], glibc >= 2.28 | Tier 2                                          | e.g. RHEL 8                          |
+| GNU/Linux        | loong64          | kernel >= 5.19, glibc >= 2.36     | Experimental                                    |                                      |
 | Windows          | x64, x86 (WoW64) | >= Windows 10/Server 2016         | Tier 1                                          | [^2],[^3]                            |
 | Windows          | x86 (native)     | >= Windows 10/Server 2016         | Tier 1 (running) / Experimental (compiling)[^4] |                                      |
 | Windows          | x64, x86         | Windows 8.1/Server 2012           | Experimental                                    |                                      |

CHANGELOG.md

@@ -36,7 +36,8 @@ release.
 </tr>
 <tr>
   <td valign="top">
-<b><a href="doc/changelogs/CHANGELOG_V21.md#21.0.0">21.0.0</a></b><br/>
+<b><a href="doc/changelogs/CHANGELOG_V21.md#21.1.0">21.1.0</a></b><br/>
+<a href="doc/changelogs/CHANGELOG_V21.md#21.0.0">21.0.0</a><br/>
   </td>
   <td valign="top">
 <b><a href="doc/changelogs/CHANGELOG_V20.md#20.8.1">20.8.1</a></b><br/>

LICENSE

@@ -78,19 +78,30 @@ The externally maintained libraries used by Node.js are:
 
 - c-ares, located at deps/cares, is licensed as follows:
   """
-    Copyright (c) 2007 - 2018, Daniel Stenberg with many contributors, see AUTHORS
+    MIT License
+
+    Copyright (c) 1998 Massachusetts Institute of Technology
+    Copyright (c) 2007 - 2023 Daniel Stenberg with many contributors, see AUTHORS
     file.
 
-    Copyright 1998 by the Massachusetts Institute of Technology.
+    Permission is hereby granted, free of charge, to any person obtaining a copy of
+    this software and associated documentation files (the "Software"), to deal in
+    the Software without restriction, including without limitation the rights to
+    use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+    the Software, and to permit persons to whom the Software is furnished to do so,
+    subject to the following conditions:
+
+    The above copyright notice and this permission notice (including the next
+    paragraph) shall be included in all copies or substantial portions of the
+    Software.
 
-    Permission to use, copy, modify, and distribute this software and its
-    documentation for any purpose and without fee is hereby granted, provided that
-    the above copyright notice appear in all copies and that both that copyright
-    notice and this permission notice appear in supporting documentation, and that
-    the name of M.I.T. not be used in advertising or publicity pertaining to
-    distribution of the software without specific, written prior permission.
-    M.I.T. makes no representations about the suitability of this software for any
-    purpose.  It is provided "as is" without express or implied warranty.
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+    SOFTWARE.
   """
 
 - cjs-module-lexer, located at deps/cjs-module-lexer, is licensed as follows:

README.md

@@ -204,8 +204,6 @@ For information about the governance of the Node.js project, see
   **Michaël Zasso** <<[email protected]>> (he/him)
 * [tniessen](https://github.com/tniessen) -
   **Tobias Nießen** <<[email protected]>> (he/him)
-* [Trott](https://github.com/Trott) -
-  **Rich Trott** <<[email protected]>> (he/him)
 
 #### TSC regular members
 
@@ -233,6 +231,8 @@ For information about the governance of the Node.js project, see
   **Rod Vagg** <<[email protected]>>
 * [TimothyGu](https://github.com/TimothyGu) -
   **Tiancheng "Timothy" Gu** <<[email protected]>> (he/him)
+* [Trott](https://github.com/Trott) -
+  **Rich Trott** <<[email protected]>> (he/him)
 
 <details>
 
@@ -357,6 +357,8 @@ For information about the governance of the Node.js project, see
   **Gireesh Punathil** <<[email protected]>> (he/him)
 * [guybedford](https://github.com/guybedford) -
   **Guy Bedford** <<[email protected]>> (he/him)
+* [H4ad](https://github.com/H4ad) -
+  **Vinícius Lourenço Claro Cardoso** <<[email protected]>> (he/him)
 * [HarshithaKP](https://github.com/HarshithaKP) -
   **Harshitha K P** <<[email protected]>> (she/her)
 * [himself65](https://github.com/himself65) -

benchmark/blob/clone.js

@@ -7,14 +7,17 @@ const assert = require('assert');
 
 const bench = common.createBenchmark(main, {
   n: [50e3],
+  bytes: [128, 1024, 1024 ** 2],
 });
 
 let _cloneResult;
 
-function main({ n }) {
+function main({ n, bytes }) {
+  const buff = Buffer.allocUnsafe(bytes);
+  const blob = new Blob(buff);
   bench.start();
   for (let i = 0; i < n; ++i)
-    _cloneResult = structuredClone(new Blob(['hello']));
+    _cloneResult = structuredClone(blob);
   bench.end(n);
 
   // Avoid V8 deadcode (elimination)

benchmark/esm/detect-esm-syntax.js

@@ -0,0 +1,37 @@
+'use strict';
+
+// This benchmarks the cost of running `containsModuleSyntax` on a CommonJS module being imported.
+// We use the TypeScript fixture because it's a very large CommonJS file with no ESM syntax: the worst case.
+const common = require('../common.js');
+const tmpdir = require('../../test/common/tmpdir.js');
+const fixtures = require('../../test/common/fixtures.js');
+const scriptPath = fixtures.path('snapshot', 'typescript.js');
+const fs = require('node:fs');
+
+const bench = common.createBenchmark(main, {
+  type: ['with-module-syntax-detection', 'without-module-syntax-detection'],
+  n: [1e4],
+}, {
+  flags: ['--experimental-detect-module'],
+});
+
+const benchmarkDirectory = tmpdir.fileURL('benchmark-detect-esm-syntax');
+const ambiguousURL = new URL('./typescript.js', benchmarkDirectory);
+const explicitURL = new URL('./typescript.cjs', benchmarkDirectory);
+
+async function main({ n, type }) {
+  tmpdir.refresh();
+
+  fs.mkdirSync(benchmarkDirectory, { recursive: true });
+  fs.cpSync(scriptPath, ambiguousURL);
+  fs.cpSync(scriptPath, explicitURL);
+
+  bench.start();
+
+  for (let i = 0; i < n; i++) {
+    const url = type === 'with-module-syntax-detection' ? ambiguousURL : explicitURL;
+    await import(url);
+  }
+
+  bench.end(n);
+}

benchmark/fs/bench-chownSync.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../../test/common/tmpdir');
+
+if (process.platform === 'win32') {
+  console.log('Skipping: Windows does not have `getuid` or `getgid`');
+  process.exit(0);
+}
+
+const bench = common.createBenchmark(main, {
+  type: ['existing', 'non-existing'],
+  method: ['chownSync', 'lchownSync'],
+  n: [1e4],
+});
+
+function main({ n, type, method }) {
+  const uid = process.getuid();
+  const gid = process.getgid();
+  const fsMethod = fs[method];
+
+  switch (type) {
+    case 'existing': {
+      tmpdir.refresh();
+      const tmpfile = tmpdir.resolve(`.existing-file-${process.pid}`);
+      fs.writeFileSync(tmpfile, 'this-is-for-a-benchmark', 'utf8');
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        fsMethod(tmpfile, uid, gid);
+      }
+      bench.end(n);
+      break;
+    }
+    case 'non-existing': {
+      const path = tmpdir.resolve(`.non-existing-file-${Date.now()}`);
+      let hasError = false;
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        try {
+          fs[method](path, uid, gid);
+        } catch {
+          hasError = true;
+        }
+      }
+      bench.end(n);
+      assert(hasError);
+      break;
+    }
+    default:
+      new Error('Invalid type');
+  }
+}

benchmark/fs/bench-fsyncSync.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+const tmpfile = tmpdir.resolve(`.existing-file-${process.pid}`);
+fs.writeFileSync(tmpfile, 'this-is-for-a-benchmark', 'utf8');
+
+const bench = common.createBenchmark(main, {
+  type: ['existing', 'non-existing'],
+  n: [1e4],
+});
+
+function main({ n, type }) {
+  let fd;
+
+  switch (type) {
+    case 'existing':
+      fd = fs.openSync(tmpfile, 'r', 0o666);
+      break;
+    case 'non-existing':
+      fd = 1 << 30;
+      break;
+    default:
+      new Error('Invalid type');
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    try {
+      fs.fsyncSync(fd);
+    } catch {
+      // do nothing
+    }
+  }
+
+  bench.end(n);
+
+  if (type === 'existing') fs.closeSync(fd);
+}

benchmark/fs/bench-linkSync.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const assert = require('assert');
+const tmpdir = require('../../test/common/tmpdir');
+
+tmpdir.refresh();
+const tmpfile = tmpdir.resolve(`.bench-file-data-${Date.now()}`);
+fs.writeFileSync(tmpfile, 'bench-file', 'utf-8');
+
+const bench = common.createBenchmark(main, {
+  type: ['valid', 'invalid'],
+  n: [1e3],
+});
+
+function main({ n, type }) {
+  switch (type) {
+    case 'valid': {
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        fs.linkSync(tmpfile, tmpdir.resolve(`.valid-${i}`), 'file');
+      }
+      bench.end(n);
+
+      break;
+    }
+
+    case 'invalid': {
+      let hasError = false;
+      bench.start();
+      for (let i = 0; i < n; i++) {
+        try {
+          fs.linkSync(
+            tmpdir.resolve(`.non-existing-file-for-linkSync-${i}`),
+            __filename,
+            'file',
+          );
+        } catch {
+          hasError = true;
+        }
+      }
+      bench.end(n);
+      assert(hasError);
+      break;
+    }
+    default:
+      new Error('Invalid type');
+  }
+}

benchmark/fs/bench-mkdirSync.js

@@ -0,0 +1,44 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+const bench = common.createBenchmark(main, {
+  type: ['existing', 'non-existing'],
+  recursive: ['true', 'false'],
+  n: [1e3],
+});
+
+function main({ n, type, recursive }) {
+  recursive = recursive === 'true';
+  let files;
+
+  switch (type) {
+    case 'non-existing':
+      files = [];
+
+      // Populate tmpdir with target dirs
+      for (let i = 0; i < n; i++) {
+        const path = tmpdir.resolve(recursive ? `rmdirsync-bench-dir-${process.pid}-${i}/a/b/c` : `rmdirsync-bench-dir-${process.pid}-${i}`);
+        files.push(path);
+      }
+      break;
+    case 'existing':
+      files = new Array(n).fill(__dirname);
+      break;
+    default:
+      new Error('Invalid type');
+  }
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    try {
+      fs.mkdirSync(files[i], { recursive });
+    } catch {
+      // do nothing
+    }
+  }
+  bench.end(n);
+}

benchmark/fs/bench-readSync.js

@@ -0,0 +1,57 @@
+'use strict';
+
+const common = require('../common');
+const fs = require('fs');
+const tmpdir = require('../../test/common/tmpdir');
+tmpdir.refresh();
+
+const bufferSize = 1024;
+const sectorSize = 512;
+
+const bench = common.createBenchmark(main, {
+  type: ['existing', 'non-existing'],
+  n: [1e4],
+});
+
+function main({ n, type }) {
+  let fd;
+
+  const tmpfile = { name: tmpdir.resolve(`.existing-file-${process.pid}`),
+                    len: bufferSize * n };
+
+
+  tmpfile.contents = Buffer.allocUnsafe(tmpfile.len);
+
+  for (let offset = 0; offset < tmpfile.len; offset += sectorSize) {
+    const fillByte = 256 * Math.random();
+    const nBytesToFill = Math.min(sectorSize, tmpfile.len - offset);
+    tmpfile.contents.fill(fillByte, offset, offset + nBytesToFill);
+  }
+
+  fs.writeFileSync(tmpfile.name, tmpfile.contents);
+
+  switch (type) {
+    case 'existing':
+      fd = fs.openSync(tmpfile.name, 'r', 0o666);
+      break;
+    case 'non-existing':
+      fd = 1 << 30;
+      break;
+    default:
+      new Error('Invalid type');
+  }
+
+  const buffer = Buffer.alloc(bufferSize);
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    try {
+      fs.readSync(fd, buffer);
+    } catch {
+      // Continue regardless of error.
+    }
+  }
+  bench.end(n);
+
+  if (type === 'existing') fs.closeSync(fd);
+}