v8/tools/gcmole/gcmole_test.py
Michael Achenbach 2a20b228ef [gcmole] Run gcmole on bots with matching architecture
This does:
- Move gcmole runs to bots with matching arch.
- Update mb_configs to enable gcmole on the bots that run it.
- Add a GN target that extracts some compiler flags from a
ninja file of one of V8's other targets.
- Use the extracted flags in the gcmole script and remove other
hard-coded arch-specific flags.

This is done for DEFINES and includes for now. Other compiler flags
are still a TODO.

Bug: v8:9287
Change-Id: Icba9ce59e0bfffd138d9207b1c2ad64d42bf6a91
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/4055629
Commit-Queue: Michael Achenbach <machenbach@chromium.org>
Reviewed-by: Camillo Bruni <cbruni@chromium.org>
Reviewed-by: Alexander Schulze <alexschulze@chromium.org>
Cr-Commit-Position: refs/heads/main@{#85341}
2023-01-17 13:56:18 +00:00

434 lines
13 KiB
Python

#!/usr/bin/env python3
# Copyright 2022 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from pathlib import Path
import collections
import os
import re
import shutil
import subprocess
import sys
import tempfile
import textwrap
import unittest
import gcmole
GCMOLE_PATH = Path(__file__).parent.absolute()
TESTDATA_PATH = GCMOLE_PATH / 'testdata' / 'v8'
Options = collections.namedtuple(
'Options', ['v8_root_dir', 'v8_target_cpu', 'shard_count', 'shard_index',
'test_run'])
def abs_test_file(f):
return TESTDATA_PATH / f
class FilesTest(unittest.TestCase):
def testFileList_for_testing(self):
options = Options(TESTDATA_PATH, 'x64', 1, 0, True)
self.assertEqual(
gcmole.build_file_list(options),
list(map(abs_test_file, ['tools/gcmole/gcmole-test.cc'])))
def testFileList_x64(self):
options = Options(TESTDATA_PATH, 'x64', 1, 0, False)
expected = [
'file1.cc',
'file2.cc',
'x64/file1.cc',
'x64/file2.cc',
'file3.cc',
'file4.cc',
'test/cctest/test-x64-file1.cc',
'test/cctest/test-x64-file2.cc',
]
self.assertEqual(
gcmole.build_file_list(options),
list(map(abs_test_file, expected)))
def testFileList_x64_shard0(self):
options = Options(TESTDATA_PATH, 'x64', 2, 0, False)
expected = [
'file1.cc',
'x64/file1.cc',
'file3.cc',
'test/cctest/test-x64-file1.cc',
]
self.assertEqual(
gcmole.build_file_list(options),
list(map(abs_test_file, expected)))
def testFileList_x64_shard1(self):
options = Options(TESTDATA_PATH, 'x64', 2, 1, False)
expected = [
'file2.cc',
'x64/file2.cc',
'file4.cc',
'test/cctest/test-x64-file2.cc',
]
self.assertEqual(
gcmole.build_file_list(options),
list(map(abs_test_file, expected)))
def testFileList_arm(self):
options = Options(TESTDATA_PATH, 'arm', 1, 0, False)
expected = [
'file1.cc',
'file2.cc',
'file3.cc',
'file4.cc',
'arm/file1.cc',
'arm/file2.cc',
]
self.assertEqual(
gcmole.build_file_list(options),
list(map(abs_test_file, expected)))
GC = 'Foo,NowCollectAllTheGarbage'
SP = 'Bar,SafepointSlowPath'
WF = 'Baz,WriteField'
class OutputLines:
CALLERS_RE = re.compile(r'([\w,]+)\s*→\s*(.*)')
def __init__(self, *callee_list):
"""Construct a test data placeholder for output lines of one invocation of
the GCMole plugin.
Args:
callee_list: Strings, each containing a caller/calle relationship
formatted as "A → B C", meaning A calls B and C. For GC,
Safepoint and a allow-listed function use GC, SP and WF
constants above respectivly.
Methods not calling anything are formatted as "A →".
"""
self.callee_list = callee_list
def lines(self):
result = []
for str_rep in self.callee_list:
match = self.CALLERS_RE.match(str_rep)
assert match
result.append(match.group(1))
for callee in (match.group(2) or '').split():
result.append('\t' + callee)
return result
class SuspectCollectorTest(unittest.TestCase):
def create_callgraph(self, *outputs):
call_graph = gcmole.CallGraph()
for output in outputs:
call_graph.parse(output.lines())
return call_graph
def testCallGraph(self):
call_graph = self.create_callgraph(OutputLines())
self.assertDictEqual(call_graph.funcs, {})
call_graph = self.create_callgraph(OutputLines('A →'))
self.assertDictEqual(call_graph.funcs, {'A': set()})
call_graph = self.create_callgraph(OutputLines('A → B'))
self.assertDictEqual(call_graph.funcs, {'A': set(), 'B': set('A')})
call_graph = self.create_callgraph(
OutputLines('A → B C', 'B → C D', 'D →'))
self.assertDictEqual(
call_graph.funcs,
{'A': set(), 'B': set('A'), 'C': set(['A', 'B']), 'D': set('B')})
call_graph = self.create_callgraph(
OutputLines('B → C D', 'D →'), OutputLines('A → B C'))
self.assertDictEqual(
call_graph.funcs,
{'A': set(), 'B': set('A'), 'C': set(['A', 'B']), 'D': set('B')})
def testCallGraphMerge(self):
"""Test serializing, deserializing and merging call graphs."""
temp_dir = Path(tempfile.mkdtemp('gcmole_test'))
call_graph1 = self.create_callgraph(
OutputLines('B → C D E', 'D →'), OutputLines('A → B C'))
self.assertDictEqual(
call_graph1.funcs,
{'A': set(), 'B': set('A'), 'C': set(['A', 'B']), 'D': set('B'),
'E': set('B')})
call_graph2 = self.create_callgraph(
OutputLines('E → A'), OutputLines('C → D F'))
self.assertDictEqual(
call_graph2.funcs,
{'A': set('E'), 'C': set(), 'D': set('C'), 'E': set(), 'F': set('C')})
file1 = temp_dir / 'file1.bin'
file2 = temp_dir / 'file2.bin'
call_graph1.to_file(file1)
call_graph2.to_file(file2)
expected = {'A': set(['E']), 'B': set('A'), 'C': set(['A', 'B']),
'D': set(['B', 'C']), 'E': set(['B']), 'F': set(['C'])}
call_graph = gcmole.CallGraph.from_files(file1, file2)
self.assertDictEqual(call_graph.funcs, expected)
call_graph = gcmole.CallGraph.from_files(file2, file1)
self.assertDictEqual(call_graph.funcs, expected)
call_graph3 = self.create_callgraph(
OutputLines('F → G'), OutputLines('G →'))
self.assertDictEqual(
call_graph3.funcs,
{'G': set('F'), 'F': set()})
file3 = temp_dir / 'file3.bin'
call_graph3.to_file(file3)
call_graph = gcmole.CallGraph.from_files(file1, file2, file3)
self.assertDictEqual(call_graph.funcs, dict(G=set('F'), **expected))
def create_collector(self, outputs):
Options = collections.namedtuple('OptionsForCollector', ['allowlist'])
options = Options(True)
call_graph = self.create_callgraph(*outputs)
collector = gcmole.GCSuspectsCollector(options, call_graph.funcs)
collector.propagate()
return collector
def check(self, outputs, expected_gc, expected_gc_caused):
"""Verify the GCSuspectsCollector propagation and outputs against test
data.
Args:
outputs: List of OutputLines object simulating the lines returned by
the GCMole plugin in drop-callees mode. Each output lines object
represents one plugin invocation.
expected_gc: Mapping as expected by GCSuspectsCollector.gc.
expected_gc_caused: Mapping as expected by GCSuspectsCollector.gc_caused.
"""
collector = self.create_collector(outputs)
self.assertDictEqual(collector.gc, expected_gc)
self.assertDictEqual(collector.gc_caused, expected_gc_caused)
def testNoGC(self):
self.check(
outputs=[OutputLines()],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A →')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A →', 'B →')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A → B C')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A → B', 'B → C')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A → B C', 'B → D', 'D → A', 'C →')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A →'), OutputLines('B →')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A → B'), OutputLines('B → C')],
expected_gc={},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines('A → B C'),
OutputLines('B → D', 'D → A'),
OutputLines('C →')],
expected_gc={},
expected_gc_caused={},
)
def testGCOneFile(self):
self.check(
outputs=[OutputLines(f'{GC}')],
expected_gc={GC: True},
expected_gc_caused={GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}')],
expected_gc={GC: True, 'A': True},
expected_gc_caused={'A': {GC}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}', 'B → A')],
expected_gc={GC: True, 'A': True, 'B': True},
expected_gc_caused={'B': {'A'}, 'A': {GC}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines('B → A', f'A → {GC}')],
expected_gc={GC: True, 'A': True, 'B': True},
expected_gc_caused={'B': {'A'}, 'A': {GC}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → B {GC}', 'B →', 'C → B A')],
expected_gc={GC: True, 'A': True, 'C': True},
expected_gc_caused={'C': {'A'}, 'A': {GC}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}', 'B → A', 'C → A', 'D → B C')],
expected_gc={GC: True, 'A': True, 'B': True, 'C': True, 'D': True},
expected_gc_caused={'C': {'A'}, 'A': {GC}, 'B': {'A'}, 'D': {'B', 'C'},
GC: {'<GC>'}},
)
def testAllowListOneFile(self):
self.check(
outputs=[OutputLines(f'{WF}')],
expected_gc={WF: False},
expected_gc_caused={},
)
self.check(
outputs=[OutputLines(f'{WF}{GC}')],
expected_gc={GC: True, WF: False},
expected_gc_caused={WF: {GC}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}', f'{WF} → A B', 'D → A B',
f'E → {WF}')],
expected_gc={GC: True, WF: False, 'A': True, 'D': True},
expected_gc_caused={'A': {GC}, WF: {'A'}, 'D': {'A'}, GC: {'<GC>'}},
)
def testSafepointOneFile(self):
self.check(
outputs=[OutputLines(f'{SP}')],
expected_gc={SP: True},
expected_gc_caused={SP: {'<Safepoint>'}},
)
self.check(
outputs=[OutputLines('B → A', f'A → {SP}')],
expected_gc={SP: True, 'A': True, 'B': True},
expected_gc_caused={'B': {'A'}, 'A': {SP}, SP: {'<Safepoint>'}},
)
def testCombinedOneFile(self):
self.check(
outputs=[OutputLines(f'{GC}', f'{SP}')],
expected_gc={SP: True, GC: True},
expected_gc_caused={SP: {'<Safepoint>'}, GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}', f'B → {SP}')],
expected_gc={GC: True, SP: True, 'A': True, 'B': True},
expected_gc_caused={'B': {SP}, 'A': {GC}, SP: {'<Safepoint>'},
GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}', f'B → {SP}', 'C → D A B')],
expected_gc={GC: True, SP: True, 'A': True, 'B': True, 'C': True},
expected_gc_caused={'B': {SP}, 'A': {GC}, 'C': {'A', 'B'},
SP: {'<Safepoint>'}, GC: {'<GC>'}},
)
def testCombinedMoreFiles(self):
self.check(
outputs=[OutputLines(f'A → {GC}'), OutputLines(f'B → {SP}')],
expected_gc={GC: True, SP: True, 'A': True, 'B': True},
expected_gc_caused={'B': {SP}, 'A': {GC}, SP: {'<Safepoint>'},
GC: {'<GC>'}},
)
self.check(
outputs=[OutputLines(f'A → {GC}'), OutputLines(f'B → {SP}'),
OutputLines('C → D A B')],
expected_gc={GC: True, SP: True, 'A': True, 'B': True, 'C': True},
expected_gc_caused={'B': {SP}, 'A': {GC}, 'C': {'A', 'B'},
SP: {'<Safepoint>'}, GC: {'<GC>'}},
)
def testWriteGCMoleResults(self):
temp_dir = Path(tempfile.mkdtemp('gcmole_test'))
Options = collections.namedtuple('OptionsForWriting', ['v8_target_cpu'])
collector = self.create_collector(
[OutputLines(f'A → {GC}'), OutputLines(f'B → {SP}')])
gcmole.write_gcmole_results(collector, Options('x64'), temp_dir)
gcsuspects_expected = textwrap.dedent(f"""\
{GC}
{SP}
A
B
""")
with open(temp_dir / 'gcsuspects') as f:
self.assertEqual(f.read(), gcsuspects_expected)
gccauses_expected = textwrap.dedent(f"""
{GC}
start,nested
<GC>
end,nested
{SP}
start,nested
<Safepoint>
end,nested
A
start,nested
{GC}
end,nested
B
start,nested
{SP}
end,nested
""").strip()
with open(temp_dir / 'gccauses') as f:
self.assertEqual(f.read().strip(), gccauses_expected)
class ArgsTest(unittest.TestCase):
def testArgs(self):
"""Test argument retrieval using a fake v8 file system and build dir."""
with tempfile.TemporaryDirectory('gcmole_args_test') as temp_dir:
temp_dir = Path(temp_dir)
temp_out = temp_dir / 'out'
temp_gcmole = temp_dir / 'tools' / 'gcmole' / 'gcmole_args.py'
shutil.copytree(abs_test_file('out'), temp_out)
os.makedirs(temp_gcmole.parent)
shutil.copy(GCMOLE_PATH / 'gcmole_args.py', temp_gcmole)
# Simulate a ninja call relative to the build dir.
subprocess.check_call([sys.executable, temp_gcmole], cwd=temp_out)
with open(temp_dir / 'out' / 'v8_gcmole.args') as f:
self.assertEqual(f.read().split(), [
'-DUSE_GLIB=1', '-DV8_TARGET_ARCH_X64', '-I.', '-Iout/gen',
'-Iinclude', '-Iout/gen/include'
])
if __name__ == '__main__':
unittest.main()