test: make test-tick-processor.js non-flaky

Wait for a sought-for symbol to appear instead of just hard-killing
subprocesses at 2s timeout.

Fix: #4427
PR-URL: #8542
Reviewed-By: Rich Trott <rtrott@gmail.com>

test/fixtures/tick-processor-base.js

@@ -0,0 +1,56 @@
+'use strict';
+const common = require('../common');
+const fs = require('fs');
+const cp = require('child_process');
+const path = require('path');
+
+common.refreshTmpDir();
+
+const LOG_FILE = path.join(common.tmpDir, 'tick-processor.log');
+const RETRY_TIMEOUT = 750;
+
+function runTest(test) {
+  const proc = cp.spawn(process.execPath, [
+    '--no_logfile_per_isolate',
+    '--logfile=-',
+    '--prof',
+    '-pe', test.code
+  ], {
+    stdio: [ null, 'pipe', 'inherit' ]
+  });
+
+  let ticks = '';
+  proc.stdout.on('data', chunk => ticks += chunk);
+
+  // Try to match after timeout
+  setTimeout(() => {
+    match(test.pattern, proc, () => ticks);
+  }, RETRY_TIMEOUT);
+}
+
+function match(pattern, parent, ticks) {
+  // Store current ticks log
+  fs.writeFileSync(LOG_FILE, ticks());
+
+  const proc = cp.spawn(process.execPath, [
+    '--prof-process',
+    '--call-graph-size=10',
+    LOG_FILE
+  ], {
+    stdio: [ null, 'pipe', 'inherit' ]
+  });
+
+  let out = '';
+  proc.stdout.on('data', chunk => out += chunk);
+  proc.stdout.on('end', () => {
+    // Retry after timeout
+    if (!pattern.test(out))
+      return setTimeout(() => match(pattern, parent, ticks), RETRY_TIMEOUT);
+
+    parent.kill('SIGTERM');
+
+    fs.unlinkSync(LOG_FILE);
+  });
+}
+
+exports.runTest = runTest;

test/parallel/parallel.status

@@ -7,13 +7,17 @@ prefix parallel
 [true] # This section applies to all platforms
 
 [$system==win32]
-test-tick-processor     : PASS,FLAKY
 
 [$system==linux]
 test-tick-processor           : PASS,FLAKY
 
 [$system==macos]
 
+[$arch==arm || $arch==arm64]
+test-tick-processor-builtin     : PASS,FLAKY
+test-tick-processor-cpp-core    : PASS,FLAKY
+test-tick-processor-unknown     : PASS,FLAKY
+
 [$system==solaris] # Also applies to SmartOS
 test-debug-signal-cluster         : PASS,FLAKY
 

test/parallel/test-tick-processor-builtin.js

@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+
+// TODO(mhdawson) Currently the test-tick-processor functionality in V8
+// depends on addresses being smaller than a full 64 bits.  Aix supports
+// the full 64 bits and the result is that it does not process the
+// addresses correctly and runs out of memory
+// Disabling until we get a fix upstreamed into V8
+if (common.isAix) {
+  common.skip('Aix address range too big for scripts.');
+  return;
+}
+
+const base = require(path.join(common.fixturesDir, 'tick-processor-base.js'));
+
+if (common.isWindows ||
+    common.isSunOS ||
+    common.isAix ||
+    common.isLinuxPPCBE ||
+    common.isFreeBSD) {
+  common.skip('C++ symbols are not mapped for this os.');
+  return;
+}
+
+base.runTest({
+  pattern: /Builtin_DateNow/,
+  code: `function f() {
+           this.ts = Date.now();
+           setImmediate(function() { new f(); });
+         };
+         f();`
+});

test/parallel/test-tick-processor-cpp-core.js

@@ -0,0 +1,33 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+
+// TODO(mhdawson) Currently the test-tick-processor functionality in V8
+// depends on addresses being smaller than a full 64 bits.  Aix supports
+// the full 64 bits and the result is that it does not process the
+// addresses correctly and runs out of memory
+// Disabling until we get a fix upstreamed into V8
+if (common.isAix) {
+  common.skip('Aix address range too big for scripts.');
+  return;
+}
+
+const base = require(path.join(common.fixturesDir, 'tick-processor-base.js'));
+
+if (common.isWindows ||
+    common.isSunOS ||
+    common.isAix ||
+    common.isLinuxPPCBE ||
+    common.isFreeBSD) {
+  common.skip('C++ symbols are not mapped for this os.');
+  return;
+}
+
+base.runTest({
+  pattern: /RunInDebugContext/,
+  code: `function f() {
+           require(\'vm\').runInDebugContext(\'Debug\');
+           setImmediate(function() { f(); });
+         };
+         f();`
+});

test/parallel/test-tick-processor-unknown.js

@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+const path = require('path');
+
+// TODO(mhdawson) Currently the test-tick-processor functionality in V8
+// depends on addresses being smaller than a full 64 bits.  Aix supports
+// the full 64 bits and the result is that it does not process the
+// addresses correctly and runs out of memory
+// Disabling until we get a fix upstreamed into V8
+if (common.isAix) {
+  common.skip('Aix address range too big for scripts.');
+  return;
+}
+
+const base = require(path.join(common.fixturesDir, 'tick-processor-base.js'));
+
+// Unknown checked for to prevent flakiness, if pattern is not found,
+// then a large number of unknown ticks should be present
+base.runTest({
+  pattern: /LazyCompile.*\[eval\]:1|.*%  UNKNOWN/,
+  code: `function f() {
+           for (var i = 0; i < 1000000; i++) {
+             i++;
+           }
+           setImmediate(function() { f(); });
+         };
+         f();`
+});