Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

test: v8: Add test-linux-perf-logger test suite #50352

Merged
merged 2 commits into from
Oct 25, 2023
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
17 changes: 17 additions & 0 deletions test/fixtures/linux-perf-logger.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,17 @@
'use strict';

process.stdout.write(`${process.pid}`);

const testRegex = /test-regex/gi;

function functionOne() {
for (let i = 0; i < 100; i++) {
const match = testRegex.exec(Math.random().toString());
}
}

function functionTwo() {
functionOne();
}

functionTwo();
148 changes: 148 additions & 0 deletions test/v8-updates/test-linux-perf-logger.js
Original file line number Diff line number Diff line change
@@ -0,0 +1,148 @@
'use strict';

// --- About this test suite
//
// JIT support for perf(1) was added in 2009 (see https://lkml.org/lkml/2009/6/8/499).
// It works by looking for a perf map file in /tmp/perf-<pid>.map, where <pid> is the
// PID of the target process.
//
// The structure of this file is stable. Perf expects each line to specify a symbol
// in the form:
//
// <start> <length> <name>
//
// where <start> is the hex representation of the instruction pointer for the beginning
// of the function, <length> is the byte length of the function, and <name> is the
// readable JIT name used for reporting.
//
// This file asserts that a node script run with the appropriate flags will produce
// a compliant perf map.
//
// NOTE: This test runs only on linux, as that is the only platform supported by perf, and
// accordingly the only platform where `perf-basic-prof*` v8 flags are available.


const common = require('../common');
if (!common.isLinux) {
common.skip('--perf-basic-prof* is statically defined as linux-only');
}

const assert = require('assert');
const { spawnSync } = require('child_process');
const { readFileSync } = require('fs');

const fixtures = require('../common/fixtures');
const tmpdir = require('../common/tmpdir');
tmpdir.refresh();

const testCases = [
{
title: '--perf-basic-prof interpreted',
nodeFlags: ['--perf-basic-prof', '--no-turbo-inlining', '--no-opt'],
matches: [
'~functionOne .+/linux-perf-logger.js',
'~functionTwo .+/linux-perf-logger.js',
'test-regex',
],
noMatches: ['\\*functionOne', '\\*functionTwo'],
},
{
title: '--perf-basic-prof compiled',
nodeFlags: ['--perf-basic-prof', '--no-turbo-inlining', '--always-opt'],
matches: [
'test-regex',
'~functionOne .+/linux-perf-logger.js',
'~functionTwo .+/linux-perf-logger.js',
'\\*functionOne .+/linux-perf-logger.js',
'\\*functionTwo .+/linux-perf-logger.js',
],
noMatches: [],
},
{
title: '--perf-basic-prof-only-functions interpreted',
nodeFlags: ['--perf-basic-prof-only-functions', '--no-turbo-inlining', '--no-opt'],
matches: ['~functionOne .+/linux-perf-logger.js', '~functionTwo .+/linux-perf-logger.js'],
noMatches: ['\\*functionOne', '\\*functionTwo', 'test-regex'],
},
{
title: '--perf-basic-prof-only-functions compiled',
nodeFlags: ['--perf-basic-prof-only-functions', '--no-turbo-inlining', '--always-opt'],
matches: [
'~functionOne .+/linux-perf-logger.js',
'~functionTwo .+/linux-perf-logger.js',
'\\*functionOne .+/linux-perf-logger.js',
'\\*functionTwo .+/linux-perf-logger.js',
],
noMatches: ['test-regex'],
},
];

function runTest(test) {
const report = {
title: test.title,
perfMap: '[uninitialized]',
errors: [],
};

const args = test.nodeFlags.concat(fixtures.path('linux-perf-logger.js'));
const run = spawnSync(process.execPath, args, { cwd: tmpdir.path, encoding: 'utf8' });
if (run.error) {
report.errors.push(run.error.stack);
return report;
}
if (run.status !== 0) {
report.errors.push(`running script:\n${run.stderr}`);
return report;
}

try {
report.perfMap = readFileSync(`/tmp/perf-${run.pid}.map`, 'utf8');
} catch (err) {
report.errors.push(`reading perf map: ${err.stack}`);
return report;
}

const hexRegex = '[a-fA-F0-9]+';
for (const testRegex of test.matches) {
const lineRegex = new RegExp(`${hexRegex} ${hexRegex}.*:${testRegex}`);
if (!lineRegex.test(report.perfMap)) {
report.errors.push(`Expected to match ${lineRegex}`);
}
}

for (const regex of test.noMatches) {
const noMatch = new RegExp(regex);
if (noMatch.test(report.perfMap)) {
report.errors.push(`Expected not to match ${noMatch}`);
}
}

return report;
}

function serializeError(report, index) {
return `[ERROR ${index + 1}] ${report.title}
Errors:
${report.errors.map((err, i) => `${i + 1}. ${err}`).join('\n')}
Perf map content:
${report.perfMap}
</end perf map content>
`;
}

function runSuite() {
const failures = [];

for (const tc of testCases) {
const report = runTest(tc);
if (report.errors.length > 0) {
failures.push(report);
}
}

const errorsToReport = failures.map(serializeError).join('\n--------\n');

assert.strictEqual(failures.length, 0, `${failures.length} tests failed\n\n${errorsToReport}`);
}

runSuite();