src,lib: add constrainedMemory API for process

doc/api/process.md

@@ -1103,6 +1103,25 @@ and [Cluster][] documentation), the `process.connected` property will return
 Once `process.connected` is `false`, it is no longer possible to send messages
 over the IPC channel using `process.send()`.
 
+## `process.constrainedMemory()`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {number}
+
+Gets the amount of memory available to the process (in bytes) based on
+limits imposed by the OS. If there is no such constraint, or the constraint
+is unknown, `0` is returned.
+
+It is not unusual for this value to be less than or greater than `os.totalmem()`.
+This function currently only returns a non-zero value on Linux, based on cgroups
+if it is present, and on z/OS based on `RLIMIT_MEMLIMIT`.
+
+See [`uv_get_constrained_memory`][uv_get_constrained_memory] for more
+information.
+
 ## `process.cpuUsage([previousValue])`
 
 <!-- YAML
@@ -3901,6 +3920,7 @@ cases:
 [process_warning]: #event-warning
 [report documentation]: report.md
 [terminal raw mode]: tty.md#readstreamsetrawmodemode
+[uv_get_constrained_memory]: https://docs.libuv.org/en/v1.x/misc.html#c.uv_get_constrained_memory
 [uv_rusage_t]: https://docs.libuv.org/en/v1.x/misc.html#c.uv_rusage_t
 [wikipedia_major_fault]: https://en.wikipedia.org/wiki/Page_fault#Major
 [wikipedia_minor_fault]: https://en.wikipedia.org/wiki/Page_fault#Minor

lib/internal/bootstrap/node.js

@@ -184,6 +184,7 @@ const rawMethods = internalBinding('process_methods');
 
   process.hrtime = perThreadSetup.hrtime;
   process.hrtime.bigint = perThreadSetup.hrtimeBigInt;
+  process.constrainedMemory = perThreadSetup.constrainedMemory;
 
   process.openStdin = function() {
     process.stdin.resume();

lib/internal/process/per_thread.js

@@ -60,6 +60,7 @@ const binding = internalBinding('process_methods');
 
 let hrValues;
 let hrBigintValues;
+let constrainedMemoryValues;
 
 function refreshHrtimeBuffer() {
   // The 3 entries filled in by the original process.hrtime contains
@@ -71,8 +72,12 @@ function refreshHrtimeBuffer() {
   hrBigintValues = new BigUint64Array(binding.hrtimeBuffer, 0, 1);
 }
 
+function refreshConstrainedMemoryValuesBuffer() {
+  constrainedMemoryValues = new BigUint64Array(binding.hrtimeBuffer, 0, 1);
+}
 // Create the buffers.
 refreshHrtimeBuffer();
+refreshConstrainedMemoryValuesBuffer();
 
 function hrtime(time) {
   binding.hrtime();
@@ -100,6 +105,11 @@ function hrtimeBigInt() {
   return hrBigintValues[0];
 }
 
+function constrainedMemory() {
+  binding.constrainedMemory();
+  return constrainedMemoryValues[0];
+}
+
 function nop() {}
 
 // The execution of this function itself should not cause any side effects.
@@ -427,4 +437,6 @@ module.exports = {
   hrtime,
   hrtimeBigInt,
   refreshHrtimeBuffer,
+  refreshConstrainedMemoryValuesBuffer,
+  constrainedMemory,
 };

lib/internal/process/pre_execution.js

@@ -131,9 +131,9 @@ function refreshRuntimeOptions() {
 function patchProcessObject(expandArgv1) {
   const binding = internalBinding('process_methods');
   binding.patchProcessObject(process);
-
-  require('internal/process/per_thread').refreshHrtimeBuffer();
-
+  const perThread = require('internal/process/per_thread');
+  perThread.refreshHrtimeBuffer();
+  perThread.refreshConstrainedMemoryValuesBuffer();
   ObjectDefineProperty(process, 'argv0', {
     __proto__: null,
     enumerable: true,

src/node_process.h

@@ -81,6 +81,11 @@ class BindingData : public SnapshotableObject {
 
   static void SlowBigInt(const v8::FunctionCallbackInfo<v8::Value>& args);
 
+  static void ConstrainedMemoryImpl(BindingData* receiver);
+  static void SlowGetConstrainedMemory(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void FastGetConstrainedMemory(v8::Local<v8::Value> receiver);
+
  private:
   static constexpr size_t kBufferSize =
       std::max(sizeof(uint64_t), sizeof(uint32_t) * 3);
@@ -92,6 +97,7 @@ class BindingData : public SnapshotableObject {
   // time.
   static v8::CFunction fast_number_;
   static v8::CFunction fast_bigint_;
+  static v8::CFunction fast_get_constrained_memory_;
 };
 
 }  // namespace process

src/node_process_methods.cc

@@ -471,11 +471,18 @@ BindingData::BindingData(Environment* env, v8::Local<v8::Object> object)
 
 v8::CFunction BindingData::fast_number_(v8::CFunction::Make(FastNumber));
 v8::CFunction BindingData::fast_bigint_(v8::CFunction::Make(FastBigInt));
+v8::CFunction BindingData::fast_get_constrained_memory_ =
+    v8::CFunction::Make(FastGetConstrainedMemory);
 
 void BindingData::AddMethods() {
   Local<Context> ctx = env()->context();
   SetFastMethod(ctx, object(), "hrtime", SlowNumber, &fast_number_);
   SetFastMethod(ctx, object(), "hrtimeBigInt", SlowBigInt, &fast_bigint_);
+  SetFastMethod(ctx,
+                object(),
+                "constrainedMemory",
+                SlowGetConstrainedMemory,
+                &fast_get_constrained_memory_);
 }
 
 void BindingData::RegisterExternalReferences(
@@ -486,6 +493,9 @@ void BindingData::RegisterExternalReferences(
   registry->Register(FastBigInt);
   registry->Register(fast_number_.GetTypeInfo());
   registry->Register(fast_bigint_.GetTypeInfo());
+  registry->Register(SlowGetConstrainedMemory);
+  registry->Register(FastGetConstrainedMemory);
+  registry->Register(fast_get_constrained_memory_.GetTypeInfo());
 }
 
 BindingData* BindingData::FromV8Value(Local<Value> value) {
@@ -533,6 +543,23 @@ void BindingData::SlowNumber(const v8::FunctionCallbackInfo<v8::Value>& args) {
   NumberImpl(FromJSObject<BindingData>(args.Holder()));
 }
 
+void BindingData::ConstrainedMemoryImpl(BindingData* receiver) {
+  // Make sure we don't accidentally access buffers wiped for snapshot.
+  CHECK(!receiver->array_buffer_.IsEmpty());
+  uint64_t t = uv_get_constrained_memory();
+  uint64_t* fields = static_cast<uint64_t*>(receiver->backing_store_->Data());
+  fields[0] = t;
+}
+
+void BindingData::SlowGetConstrainedMemory(
+    const FunctionCallbackInfo<Value>& args) {
+  ConstrainedMemoryImpl(FromJSObject<BindingData>(args.Holder()));
+}
+
+void BindingData::FastGetConstrainedMemory(v8::Local<v8::Value> receiver) {
+  ConstrainedMemoryImpl(FromV8Value(receiver));
+}
+
 bool BindingData::PrepareForSerialization(Local<Context> context,
                                           v8::SnapshotCreator* creator) {
   // It's not worth keeping.

test/sequential/test-process-constrained-memory.js

@@ -0,0 +1,12 @@
+'use strict';
+require('../common');
+const assert = require('assert');
+const { Worker } = require('worker_threads');
+
+if (!process.env.isWorker) {
+  process.env.isWorker = true;
+  new Worker(__filename);
+  assert(process.constrainedMemory() >= 0);
+} else {
+  assert(process.constrainedMemory() >= 0);
+}