From 52194c87b0ca80c480e5b5c8b26868204d601f19 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Wed, 8 Feb 2023 20:06:16 +0000 Subject: [PATCH] tests: Add pyunit tests for Looppoint Change-Id: Ie275e50bbcf5fb3d38ee98d7ada27c3afe4ec1b0 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/67757 Maintainer: Bobby Bruce Reviewed-by: Bobby Bruce Tested-by: kokoro --- tests/pyunit/stdlib/pyunit_looppoint.py | 600 ++++++++++++++++++ .../matrix.1_92.global.pinpoints_reduced.csv | 28 + tests/pyunit/stdlib/refs/output.json | 40 ++ 3 files changed, 668 insertions(+) create mode 100644 tests/pyunit/stdlib/pyunit_looppoint.py create mode 100644 tests/pyunit/stdlib/refs/matrix.1_92.global.pinpoints_reduced.csv create mode 100644 tests/pyunit/stdlib/refs/output.json diff --git a/tests/pyunit/stdlib/pyunit_looppoint.py b/tests/pyunit/stdlib/pyunit_looppoint.py new file mode 100644 index 0000000000..0cb708e8ac --- /dev/null +++ b/tests/pyunit/stdlib/pyunit_looppoint.py @@ -0,0 +1,600 @@ +# Copyright (c) 2023 The Regents of the University of California +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer; +# redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution; +# neither the name of the copyright holders nor the names of its +# contributors may be used to endorse or promote products derived from +# this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import unittest + +from m5.params import PcCountPair + +from gem5.resources.looppoint import ( + Looppoint, + LooppointRegionPC, + LooppointRegionWarmup, + LooppointSimulation, + LooppointRegion, + LooppointCsvLoader, + LooppointJsonLoader, +) + +import os + + +class LooppointRegionPCTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointRegionPC class.""" + + def test_construction_with_relative(self) -> None: + region_pc = LooppointRegionPC(pc=444, globl=65, relative=454) + + self.assertEquals(444, region_pc.get_pc()) + self.assertEquals(65, region_pc.get_global()) + self.assertEquals(454, region_pc.get_relative()) + + def test_construction_without_relative(self) -> None: + region_pc = LooppointRegionPC(pc=43454, globl=653434) + + self.assertEquals(43454, region_pc.get_pc()) + self.assertEquals(653434, region_pc.get_global()) + self.assertIsNone(region_pc.get_relative()) + + def test_get_pc_count_pair(self) -> None: + region_pc = LooppointRegionPC(pc=1, globl=2) + expected = PcCountPair(1, 2) + self.assertEquals(expected, region_pc.get_pc_count_pair()) + + def update_relative_count(self) -> None: + pass # Not really sure what to do here... + + def test_to_json_with_relative(self) -> None: + region_pc = LooppointRegionPC(pc=100, globl=200, relative=300) + json_contents = region_pc.to_json() + + self.assertEquals(3, len(json_contents)) + self.assertTrue("pc" in json_contents) + self.assertEquals(100, json_contents["pc"]) + self.assertTrue("global" in json_contents) + self.assertEquals(200, json_contents["global"]) + self.assertTrue("relative" in json_contents) + self.assertEquals(300, json_contents["relative"]) + + def test_to_json_without_relative(self) -> None: + region_pc = LooppointRegionPC(pc=1111, globl=2222) + json_contents = region_pc.to_json() + + self.assertEquals(2, len(json_contents)) + self.assertTrue("pc" in json_contents) + self.assertEquals(1111, json_contents["pc"]) + self.assertTrue("global" in json_contents) + self.assertEquals(2222, json_contents["global"]) + self.assertFalse("relative" in json_contents) + + +class LooppointRegionWarmupTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointWarmup class.""" + + def test_construction(self) -> None: + region_warmup = LooppointRegionWarmup( + start=PcCountPair(123, 456), end=PcCountPair(789, 1011) + ) + + self.assertEquals(PcCountPair(123, 456), region_warmup.get_start()) + self.assertEquals(PcCountPair(789, 1011), region_warmup.get_end()) + + def test_get_pc_count_pairs(self) -> None: + region_warmup = LooppointRegionWarmup( + start=PcCountPair(1, 1), end=PcCountPair(2, 2) + ) + + output = region_warmup.get_pc_count_pairs() + self.assertEquals(2, len(output)) + self.assertEquals(PcCountPair(1, 1), output[0]) + self.assertEquals(PcCountPair(2, 2), output[1]) + + def test_to_json(self) -> None: + region_warmup = LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ) + + expected = { + "start": {"pc": 100, "count": 200}, + "end": {"pc": 101, "count": 202}, + } + + self.assertDictEqual(expected, region_warmup.to_json()) + + +class LooppointSimulationTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointSimulation class.""" + + def test_construction_with(self) -> None: + sim = LooppointSimulation( + start=LooppointRegionPC(pc=444, globl=65, relative=454), + end=LooppointRegionPC(pc=555, globl=699), + ) + + sim_start = sim.get_start() + + self.assertEquals(444, sim_start.get_pc()) + self.assertEquals(65, sim_start.get_global()) + self.assertEquals(454, sim_start.get_relative()) + + sim_end = sim.get_end() + + self.assertEquals(555, sim_end.get_pc()) + self.assertEquals(699, sim_end.get_global()) + self.assertIsNone(sim_end.get_relative()) + + def test_get_pc_count_pairs(self) -> None: + sim = LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=45, relative=34), + end=LooppointRegionPC(pc=23, globl=12), + ) + + sim_pc_count_pairs = sim.get_pc_count_pairs() + self.assertEquals(2, len(sim_pc_count_pairs)) + self.assertEquals(PcCountPair(56, 45), sim_pc_count_pairs[0]) + self.assertEquals(PcCountPair(23, 12), sim_pc_count_pairs[1]) + + def test_get_json(self) -> None: + sim = LooppointSimulation( + start=LooppointRegionPC(pc=1, globl=2, relative=3), + end=LooppointRegionPC(pc=4, globl=5), + ) + expected = { + "start": { + "pc": 1, + "global": 2, + "relative": 3, + }, + "end": { + "pc": 4, + "global": 5, + }, + } + self.assertDictEqual(expected, sim.to_json()) + + +class LooppointRegionTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointRegion class.""" + + def test_construction_with_warmup(self): + region = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=1, globl=2, relative=3), + end=LooppointRegionPC(pc=6, globl=7), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + + self.assertTrue( + isinstance(region.get_simulation(), LooppointSimulation) + ) + self.assertEquals(5.6, region.get_multiplier()) + self.assertIsNotNone(region.get_warmup()) + self.assertTrue(isinstance(region.get_warmup(), LooppointRegionWarmup)) + + def test_construction_without_warmup(self): + region = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + + self.assertTrue( + isinstance(region.get_simulation(), LooppointSimulation) + ) + self.assertEquals(5444.4, region.get_multiplier()) + self.assertIsNone(region.get_warmup()) + + def test_get_pc_count_pairs_with_warmup(self): + region = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=1, globl=2, relative=3), + end=LooppointRegionPC(pc=6, globl=7), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + pc_count_pairs = region.get_pc_count_pairs() + + self.assertEquals(4, len(pc_count_pairs)) + self.assertEquals(PcCountPair(1, 2), pc_count_pairs[0]) + self.assertEquals(PcCountPair(6, 7), pc_count_pairs[1]) + self.assertEquals(PcCountPair(100, 200), pc_count_pairs[2]) + self.assertEquals(PcCountPair(101, 202), pc_count_pairs[3]) + + def test_get_pc_count_pairs_without_warmup(self): + region = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + + pc_count_pairs = region.get_pc_count_pairs() + + self.assertEquals(2, len(pc_count_pairs)) + self.assertEquals(PcCountPair(56, 2345), pc_count_pairs[0]) + self.assertEquals(PcCountPair(645, 457), pc_count_pairs[1]) + + +class LooppointTestSuite(unittest.TestCase): + """Tests the resources.looppoint.Looppoint class.""" + + def test_construction(self): + region1 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + region2 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=67, globl=254, relative=3345), + end=LooppointRegionPC(pc=64554, globl=7454), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + + looppoint = Looppoint( + regions={ + 1: region1, + 3: region2, + } + ) + + self.assertEquals(2, len(looppoint.get_regions())) + self.assertTrue(1 in looppoint.get_regions()) + self.assertEquals(region1, looppoint.get_regions()[1]) + self.assertTrue(3 in looppoint.get_regions()) + self.assertEquals(region2, looppoint.get_regions()[3]) + + def test_get_targets(self): + region1 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + region2 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=67, globl=254, relative=3345), + end=LooppointRegionPC(pc=64554, globl=7454), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + + looppoint = Looppoint( + regions={ + 1: region1, + 3: region2, + } + ) + + targets = looppoint.get_targets() + self.assertEquals(6, len(targets)) + self.assertEquals(PcCountPair(56, 2345), targets[0]) + self.assertEquals(PcCountPair(645, 457), targets[1]) + self.assertEquals(PcCountPair(67, 254), targets[2]) + self.assertEquals(PcCountPair(64554, 7454), targets[3]) + self.assertEquals(PcCountPair(100, 200), targets[4]) + self.assertEquals(PcCountPair(101, 202), targets[5]) + + def test_get_region_start_id_map(self): + + region1 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + region2 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=67, globl=254, relative=3345), + end=LooppointRegionPC(pc=64554, globl=7454), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + + looppoint = Looppoint( + regions={ + 1: region1, + 3: region2, + } + ) + + region_start_id_map = looppoint.get_region_start_id_map() + + self.assertEquals(2, len(region_start_id_map)) + + # The start of region1. + self.assertTrue(PcCountPair(56, 2345) in region_start_id_map) + self.assertEquals(1, region_start_id_map[PcCountPair(56, 2345)]) + + # The start of region2. Since this has a warmup, it's the warmup. + self.assertTrue(PcCountPair(100, 200) in region_start_id_map) + self.assertEquals(3, region_start_id_map[PcCountPair(100, 200)]) + + def test_to_json(self) -> None: + region1 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=56, globl=2345, relative=344), + end=LooppointRegionPC(pc=645, globl=457), + ), + multiplier=5444.4, + ) + region2 = LooppointRegion( + simulation=LooppointSimulation( + start=LooppointRegionPC(pc=67, globl=254, relative=3345), + end=LooppointRegionPC(pc=64554, globl=7454), + ), + multiplier=5.6, + warmup=LooppointRegionWarmup( + start=PcCountPair(100, 200), end=PcCountPair(101, 202) + ), + ) + + looppoint = Looppoint( + regions={ + 1: region1, + 3: region2, + } + ) + + expected = { + 1: { + "simulation": { + "start": { + "pc": 56, + "global": 2345, + "relative": 344, + }, + "end": { + "pc": 645, + "global": 457, + }, + }, + "multiplier": 5444.4, + }, + 3: { + "simulation": { + "start": { + "pc": 67, + "global": 254, + "relative": 3345, + }, + "end": { + "pc": 64554, + "global": 7454, + }, + }, + "multiplier": 5.6, + "warmup": { + "start": { + "pc": 100, + "count": 200, + }, + "end": { + "pc": 101, + "count": 202, + }, + }, + }, + } + + # Need to increase the max for if there is an error. + self.maxDiff = 2056 + self.assertDictEqual(expected, looppoint.to_json()) + + +class LooppointCSVLoaderTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointCsvLoader class.""" + + def test_load_pinpoints_matrix(self): + looppoint = LooppointCsvLoader( + pinpoints_file=os.path.join( + os.path.realpath(os.path.dirname(__file__)), + "refs", + "matrix.1_92.global.pinpoints_reduced.csv", + ) + ) + + regions = looppoint.get_regions() + self.assertEquals(3, len(regions)) + + region1 = regions[1] + self.assertEquals(4.0, region1.get_multiplier()) + + region1start = region1.get_simulation().get_start() + self.assertEquals(0x4069D0, region1start.get_pc()) + self.assertEquals(211076617, region1start.get_global()) + self.assertIsNone(region1start.get_relative()) + + region1end = region1.get_simulation().get_end() + self.assertEquals(0x4069D0, region1end.get_pc()) + self.assertEquals(219060252, region1end.get_global()) + self.assertIsNotNone(region1end.get_relative()) + self.assertEquals(1060676, region1end.get_relative()) + + self.assertIsNone(region1.get_warmup()) + + region2 = regions[2] + self.assertEquals(5.001, region2.get_multiplier()) + + region2start = region2.get_simulation().get_start() + self.assertEquals(0x4069D0, region2start.get_pc()) + self.assertEquals(407294228, region2start.get_global()) + self.assertIsNone(region2start.get_relative()) + + region2end = region2.get_simulation().get_end() + self.assertEquals(0x4069D0, region2end.get_pc()) + self.assertEquals(415282447, region2end.get_global()) + self.assertIsNotNone(region2end.get_relative()) + self.assertEquals(1035231, region2end.get_relative()) + + region2warmup = region2.get_warmup() + self.assertIsNotNone(region2warmup) + self.assertEquals( + PcCountPair(0x406880, 48111518), region2warmup.get_start() + ) + self.assertEquals( + PcCountPair(0x4069D0, 407294228), region2warmup.get_end() + ) + + region3 = regions[3] + self.assertEquals(4.0, region3.get_multiplier()) + + region3start = region3.get_simulation().get_start() + self.assertEquals(0x4069D0, region3start.get_pc()) + self.assertEquals(187978221, region3start.get_global()) + self.assertIsNone(region3start.get_relative()) + + region3end = region3.get_simulation().get_end() + self.assertEquals(0x406880, region3end.get_pc()) + self.assertEquals(23520614, region3end.get_global()) + self.assertIsNotNone(region3end.get_relative()) + self.assertEquals(144352, region3end.get_relative()) + + self.assertIsNone(region3.get_warmup()) + + def test_load_pinpoints_matrix_region_1(self): + looppoint = LooppointCsvLoader( + pinpoints_file=os.path.join( + os.path.realpath(os.path.dirname(__file__)), + "refs", + "matrix.1_92.global.pinpoints_reduced.csv", + ), + region_id=1, + ) + + regions = looppoint.get_regions() + self.assertEquals(1, len(regions)) + + self.assertTrue(1 in regions) + region1 = regions[1] + self.assertEquals(4.0, region1.get_multiplier()) + + region1start = region1.get_simulation().get_start() + self.assertEquals(0x4069D0, region1start.get_pc()) + self.assertEquals(211076617, region1start.get_global()) + self.assertIsNone(region1start.get_relative()) + + region1end = region1.get_simulation().get_end() + self.assertEquals(0x4069D0, region1end.get_pc()) + self.assertEquals(219060252, region1end.get_global()) + self.assertIsNotNone(region1end.get_relative()) + self.assertEquals(1060676, region1end.get_relative()) + + self.assertIsNone(region1.get_warmup()) + + +class LooppointJsonLoaderTestSuite(unittest.TestCase): + """Tests the resources.looppoint.LooppointJsonLoader class.""" + + def test_load_pinpoints_matrix_region_1(self): + looppoint = LooppointJsonLoader( + looppoint_file=os.path.join( + os.path.realpath(os.path.dirname(__file__)), + "refs", + "output.json", + ), + region_id="1", + ) + + self.assertEquals(1, len(looppoint.get_regions())) + self.assertTrue("1" in looppoint.get_regions()) + region = looppoint.get_regions()["1"] + + self.assertEquals(4.0, region.get_multiplier()) + + region_start = region.get_simulation().get_start() + self.assertEquals(4221392, region_start.get_pc()) + self.assertEquals(211076617, region_start.get_global()) + self.assertIsNotNone(region_start.get_relative()) + self.assertEquals(15326617, region_start.get_relative()) + + region_end = region.get_simulation().get_end() + self.assertEquals(4221392, region_end.get_pc()) + self.assertEquals(219060252, region_end.get_global()) + self.assertIsNotNone(region_end.get_relative()) + self.assertEquals(23310252, region_end.get_relative()) + + region_warmup = region.get_warmup() + self.assertIsNotNone(region_warmup) + + self.assertEquals( + PcCountPair(4221056, 23520614), region_warmup.get_start() + ) + self.assertEquals( + PcCountPair(4221392, 211076617), region_warmup.get_end() + ) + + def test_load_pinpoints_matrix_region_2(self): + looppoint = LooppointJsonLoader( + looppoint_file=os.path.join( + os.path.realpath(os.path.dirname(__file__)), + "refs", + "output.json", + ), + region_id="2", + ) + + self.assertEquals(1, len(looppoint.get_regions())) + self.assertTrue("2" in looppoint.get_regions()) + region = looppoint.get_regions()["2"] + + self.assertEquals(5.001, region.get_multiplier()) + + region_start = region.get_simulation().get_start() + self.assertEquals(4221392, region_start.get_pc()) + self.assertEquals(407294228, region_start.get_global()) + self.assertIsNone(region_start.get_relative()) + + region_end = region.get_simulation().get_end() + self.assertEquals(4221392, region_end.get_pc()) + self.assertEquals(415282447, region_end.get_global()) + self.assertIsNone(region_end.get_relative()) + + region_warmup = region.get_warmup() + self.assertIsNone(region_warmup) diff --git a/tests/pyunit/stdlib/refs/matrix.1_92.global.pinpoints_reduced.csv b/tests/pyunit/stdlib/refs/matrix.1_92.global.pinpoints_reduced.csv new file mode 100644 index 0000000000..56e3fc57bf --- /dev/null +++ b/tests/pyunit/stdlib/refs/matrix.1_92.global.pinpoints_reduced.csv @@ -0,0 +1,28 @@ +# Regions based on: /home/alen/isca2022/looppoint/tools/sde-external-9.0.0-2021-11-07-lin/pinplay-scripts/pcregions.py --label_file t.labels --warmup_factor 2 --tid global --bbv_file t.bb --region_file t.simpoints --weight_file t.weights + +# comment,thread-id,region-id,start-pc, start-image-name, start-image-offset, start-pc-count,end-pc, end-image-name, end-image-offset, end-pc-count,end-pc-relative-count, region-length, region-weight, region-multiplier, region-type + +# RegionId = 1 Slice = 27 Icount = 2160042521 Length = 79958388 Weight = 0.04651 Multiplier = 4.000 ClusterSlicecount = 4 ClusterIcount = 320005167 +#Start: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 211076617 source-info: matrix-omp.cpp:75 +#End: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 219060252 relative_count: 1060676.0 source-info: matrix-omp.cpp:75 +cluster 0 from slice 27,global,1,0x4069d0,matrix-omp,0x69d0,211076617,0x4069d0,matrix-omp,0x69d0,219060252,1060676,79958388,0.04651,4.000,simulation + +# RegionId = 2 Slice = 52 Icount = 4160001603 Length = 80000011 Weight = 0.05814 Multiplier = 5.001 ClusterSlicecount = 5 ClusterIcount = 400040399 +#Start: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 407294228 source-info: matrix-omp.cpp:75 +#End: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 415282447 relative_count: 1035231.0 source-info: matrix-omp.cpp:75 +cluster 1 from slice 52,global,2,0x4069d0,matrix-omp,0x69d0,407294228,0x4069d0,matrix-omp,0x69d0,415282447,1035231,80000011,0.05814,5.001,simulation + +# RegionId = 3 Slice = 24 Icount = 1920000792 Length = 80027459 Weight = 0.04651 Multiplier = 4.000 ClusterSlicecount = 4 ClusterIcount = 320021091 +#Start: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 187978221 source-info: matrix-omp.cpp:75 +#End: pc : 0x406880 image: matrix-omp offset: 0x6880 absolute_count: 23520614 relative_count: 144352.0 source-info: matrix-omp.cpp:95 +cluster 2 from slice 24,global,3,0x4069d0,matrix-omp,0x69d0,187978221,0x406880,matrix-omp,0x6880,23520614,144352,80027459,0.04651,4.000,simulation + +# RegionId = 16 Slice = 50 Icount = 4000001542 Length = 160000061 WarmupFactor = 2 +#Start: pc : 0x406880 image: matrix-omp offset: 0x6880 absolute_count: 48111518 source-info: matrix-omp.cpp:95 +#End: pc : 0x4069d0 image: matrix-omp offset: 0x69d0 absolute_count: 407294228 relative_count: 2004125.0 source-info: matrix-omp.cpp:75 +Warmup for regionid 2,global,16,0x406880,matrix-omp,0x6880,48111518,0x4069d0,matrix-omp,0x69d0,407294228,2004125,160000061,0.00000,0.000,warmup:2 + +# First PC, 0x403050 +# Total instructions in 13 regions = 1039968792 +# Total instructions in workload = 6880002703 +# Total slices in workload = 86 diff --git a/tests/pyunit/stdlib/refs/output.json b/tests/pyunit/stdlib/refs/output.json new file mode 100644 index 0000000000..4324bac3de --- /dev/null +++ b/tests/pyunit/stdlib/refs/output.json @@ -0,0 +1,40 @@ +{ + "1": { + "simulation": { + "start": { + "pc": 4221392, + "global": 211076617, + "relative": 15326617 + }, + "end": { + "pc": 4221392, + "global": 219060252, + "relative": 23310252 + } + }, + "multiplier": 4.0, + "warmup": { + "start": { + "pc": 4221056, + "count": 23520614 + }, + "end": { + "pc": 4221392, + "count": 211076617 + } + } + }, + "2": { + "simulation": { + "start": { + "pc": 4221392, + "global": 407294228 + }, + "end": { + "pc": 4221392, + "global": 415282447 + } + }, + "multiplier": 5.001 + } +}