vm: implement vm.measureMemory() for per-context memory measurement

[joyeecheung]

This patch implements vm.measureMemory() with the new
v8::Isolate::MeasureMemory() API to measure per-context memory
usage. This should be experimental, since detailed memory
measurement requires further integration with the V8 API
that should be available in a future V8 update.

Refs: https://github.com/ulan/performance-measure-memory

Checklist

• make -j4 test (UNIX), or vcbuild test (Windows) passes
• tests and/or benchmarks are included
• documentation is changed or added
• commit message follows commit guidelines

[devsnek]

Is there a reason we don't want to expose this on performance instead?

[joyeecheung]

Is there a reason we don't want to expose this on performance instead?

@devsnek This is currently different from the API proposed in https://github.com/ulan/performance-measure-memory in that an options argument gives the user more control over how the memory can be measured and it supports cross-context measurement for contexts created with vm.createContext(). For Web compat, a performance API could be eventually built on top of vm but I think it's useful to provide a more powerful API for user to experiment with.

[devsnek]

@joyeecheung did you have any interest in the Context.current() approach I mentioned in irc?

[joyeecheung]

@devsnek That sounds interesting but seems orthogonal to what this PR does?

[devsnek]

@joyeecheung well if we wanted to use that approach instead i assume we wouldn't also have the static method this pr adds, which is why i ask

[joyeecheung]

@devsnek A measureMemory method could be added to the prototype of the Context class but that when the API does land, yes, but I think it's better to decouple the functionality of measuring the per-context memory from an API that has not landed yet, and this provides the functionality for contextified objects which is something that does exist in the wild (it could also take the new class when the time comes, and avoids the overhead of creating an extra wrapper for the invoking context).

[joyeecheung]

@bnoordhuis @addaleax @jasnell @lundibundi Thanks for the reviews. I've updated the PR, PTAL.

• Use strings instead of vm.constants
• Pass the context via options.context instead of a second argument
• Return a rejection containing ERR_CONTEXT_NOT_INITIALIZED when the context is not initialized instead of failing silently

[joyeecheung]

Landed in fb73045, thanks!

[SimonSchick]

It seems the example code is wrong, the docs suggest the function should be called like this vm.measureMemory({ mode: 'detailed' }, context), shouldn't it be vm.measureMemory({ mode: 'detailed', context })?

[gengjiawen]

It seems the example code is wrong, the docs suggest the function should be called like this vm.measureMemory({ mode: 'detailed' }, context), shouldn't it be vm.measureMemory({ mode: 'detailed', context })?

Do you mind send a PR for this ?

[SimonSchick]

I'm currently busy updating the node type definitions to v11 (hence this comment).

[limerickgds]

@joyeecheung i did a test, The data is not as expected,:

'use strict';

const vm = require('vm');

async function getMeasureMemory(context) {
  global.gc();
  return vm.measureMemory({ mode: 'summary', context });
}

let globalStore = [];

const operateStore = {
  add: () => {
    let i = 1000;
    while (i--) { globalStore.push('test'.repeat(10000)); }
  },

  remove: () => {
    globalStore = [];
  },
};

const script = `
  var store = [];
  fn = {
    add: () => {
      let i = 1000;
      while(i--){ store.push('test'.repeat(10000)) }
    },

    remove: () => {
      store = [];
    }
  }
`;

const context = vm.createContext({
  fn: () => {},
  console,
});

vm.runInContext(script, context);


async function measureMemoryTest() {
  let result = {};
  result = await getMeasureMemory(context);
  console.log('start:  \n', result);

  context.fn.add();

  result = await getMeasureMemory(context);
  console.log('after add once:  \n', result);

  context.fn.remove();

  result = await getMeasureMemory(context);
  console.log('after remove all: \n', result);


  operateStore.add();

  result = await getMeasureMemory(context);
  console.log('after add global context: \n', result);

  result = await getMeasureMemory(vm.createContext({}));
  console.log('after add global: \n', result);

  result = await getMeasureMemory(context);
  console.log('after add global context: \n', result);
}
measureMemoryTest();

new context size ~ global

[joyeecheung]

@limerickgds This no longer works after the recent V8 update - the promises returned by vm.measureMemory() will not keep the process alive, so it's uncertain how many requests will be completed before the program executes (in the output, there may be some lines being logged, or nothing at all). I added support for the execution option so that eager mode can be used instead of global.gc() #32988 with that the new numbers should look like this

'use strict';

const vm = require('vm');
require('util').inspect.defaultOptions.depth = 100;

function getMeasureMemory() {
  return vm.measureMemory({ mode: 'detailed', execution: 'eager' });
}

let globalStore = [];

const operateStore = {
  add: () => {
    let i = 1000;
    while (i--) { globalStore.push('test'.repeat(10000)); }
  },

  remove: () => {
    globalStore = [];
  },
};

const script = `
  var store = [];
  fn = {
    add: () => {
      let i = 1000;
      while(i--){ store.push('test'.repeat(10000)) }
    },

    remove: () => {
      store = [];
    }
  }
`;

const context = vm.createContext({
  fn: () => {},
  console,
});

vm.runInContext(script, context);

async function measureMemoryTest() {
  let result = {};
  result = await getMeasureMemory();
  console.log('start:  \n', result);

  context.fn.add();

  result = await getMeasureMemory();
  console.log('after add once:  \n', result);

  context.fn.remove();

  result = await getMeasureMemory();
  console.log('after remove all: \n', result);

  operateStore.add();

  result = await getMeasureMemory();
  console.log('after add global context: \n', result);
}
measureMemoryTest();

start:
 {
  total: { jsMemoryEstimate: 2584500, jsMemoryRange: [ 2584500, 2919297 ] },
  current: { jsMemoryEstimate: 2447444, jsMemoryRange: [ 2447444, 2782241 ] },
  other: [ { jsMemoryEstimate: 137056, jsMemoryRange: [ 137056, 471853 ] } ]
}
after add once:
 {
  total: { jsMemoryEstimate: 3162108, jsMemoryRange: [ 3162108, 3753265 ] },
  current: { jsMemoryEstimate: 3024820, jsMemoryRange: [ 3024820, 3615977 ] },
  other: [ { jsMemoryEstimate: 137288, jsMemoryRange: [ 137288, 728445 ] } ]
}
after remove all:
 {
  total: { jsMemoryEstimate: 2619380, jsMemoryRange: [ 2619380, 3210505 ] },
  current: { jsMemoryEstimate: 2481652, jsMemoryRange: [ 2481652, 3072777 ] },
  other: [ { jsMemoryEstimate: 137728, jsMemoryRange: [ 137728, 728853 ] } ]
}
after add global context:
 {
  total: { jsMemoryEstimate: 3090828, jsMemoryRange: [ 3090828, 3680865 ] },
  current: { jsMemoryEstimate: 2953060, jsMemoryRange: [ 2953060, 3543097 ] },
  other: [ { jsMemoryEstimate: 137768, jsMemoryRange: [ 137768, 727805 ] } ]
}

This seems to be about right (according to the ranges, instead of the estimates which are pretty rough since it's measured after marking, and before sweeping)