Bobby Bruce has submitted this change. (
https://gem5-review.googlesource.com/c/public/gem5/+/67757?usp=email )
(
25 is the latest approved patch-set.
No files were changed between the latest approved patch-set and the
submitted one.
)Change subject: tests: Add pyunit tests for Looppoint
......................................................................
tests: Add pyunit tests for Looppoint
Change-Id: Ie275e50bbcf5fb3d38ee98d7ada27c3afe4ec1b0
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/67757
Maintainer: Bobby Bruce <bbr...@ucdavis.edu>
Reviewed-by: Bobby Bruce <bbr...@ucdavis.edu>
Tested-by: kokoro <noreply+kok...@google.com>
---
A tests/pyunit/stdlib/pyunit_looppoint.py
A tests/pyunit/stdlib/refs/matrix.1_92.global.pinpoints_reduced.csv
A tests/pyunit/stdlib/refs/output.json
3 files changed, 681 insertions(+), 0 deletions(-)
Approvals:
Bobby Bruce: Looks good to me, approved; Looks good to me, approved
kokoro: Regressions pass
diff --git a/tests/pyunit/stdlib/pyunit_looppoint.py
b/tests/pyunit/stdlib/pyunit_looppoint.py
new file mode 100644
index 0000000..0cb708e
--- /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 0000000..56e3fc5
--- /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 0000000..4324bac
--- /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
+ }
+}
--
To view, visit
https://gem5-review.googlesource.com/c/public/gem5/+/67757?usp=email
To unsubscribe, or for help writing mail filters, visit
https://gem5-review.googlesource.com/settings
Gerrit-Project: public/gem5
Gerrit-Branch: develop
Gerrit-Change-Id: Ie275e50bbcf5fb3d38ee98d7ada27c3afe4ec1b0
Gerrit-Change-Number: 67757
Gerrit-PatchSet: 27
Gerrit-Owner: Bobby Bruce <bbr...@ucdavis.edu>
Gerrit-Reviewer: Bobby Bruce <bbr...@ucdavis.edu>
Gerrit-Reviewer: kokoro <noreply+kok...@google.com>
Gerrit-MessageType: merged
_______________________________________________
gem5-dev mailing list -- gem5-dev@gem5.org
To unsubscribe send an email to gem5-dev-le...@gem5.org
