From 005049f548dfd260f2057febe000c720779f9c08 Mon Sep 17 00:00:00 2001 From: "Bobby R. Bruce" Date: Wed, 30 Nov 2022 15:02:05 -0800 Subject: [PATCH] stdlib,python: Allow setting of to tick exits via m5 This commit adds the following functions to the `m5` python module: - setMaxTick(tick) -> None - getMaxTick() -> int - getTicksUntilMax() -> int - scheduleTickExitFromCurrent(tick, exit_string) -> None - scheduleTickExitAbsolute(tick, exit_string) -> None Until this patch the only way to set an exit at a particular tick was via `simulate.run` which would reschedule the maximum tick. This functionality has been explicity exposed via the new `setMaxTick` function. However, as this is only rescheduling the maximum tick, it stops scheduling exits at multiple different ticks. To get around this problem the `scheduleTickExit` functions have been added. These allow a user to schedule multiple exit events. The functions contain a `exit_string` parameter that provides the string the simulator is to return when the specified tick is met. By default this string is "Tick exit reached" which is used by the stdlib Simulator module to declare a new `SCHEDULED_TICK` exit event (Note: this has been deliberatly kept seperate from the `MAX_TICK` exit event. This commit serves as an attempt to decouple these are two concepts). Tests are provided in this patch to ensure these new functions work as intended. Additional notes: - The `simulate` function has been fixed to match the documentation. If the `num_cycles` is -1 then the maximum ticks is set to MaxTicks. Otherwise the max ticks is set to `curTicks() + num_cycles`. The functionality of this function will remain unchanged to the end-user. - Full integration into the Simulator module is not complete as of this patch. Users must us the m5 python module to set these exit events. Change-Id: I6c92b31dd409dc866152224600ea8166cfcba38b Issue-on: https://gem5.atlassian.net/browse/GEM5-1131 Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/66231 Reviewed-by: Jason Lowe-Power Tested-by: kokoro Maintainer: Jason Lowe-Power Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/66331 Reviewed-by: Bobby Bruce Maintainer: Bobby Bruce --- src/python/gem5/simulate/exit_event.py | 3 + src/python/gem5/simulate/simulator.py | 2 + src/python/m5/simulate.py | 59 +++++- src/python/pybind11/event.cc | 4 + src/sim/simulate.cc | 53 +++++- src/sim/simulate.hh | 32 +++- tests/gem5/to_tick/configs/tick-exit.py | 100 ++++++++++ tests/gem5/to_tick/configs/tick-to-max.py | 123 +++++++++++++ .../to_tick/ref/tick-exit-10-20-30-40.txt | 6 + tests/gem5/to_tick/ref/tick-exit-100.txt | 3 + .../ref/tick-to-max-at-execution-100.txt | 4 + ...-to-max-at-execution-and-after-100-200.txt | 4 + .../ref/tick-to-max-before-execution-250.txt | 4 + tests/gem5/to_tick/test_to_tick.py | 174 ++++++++++++++++++ 14 files changed, 561 insertions(+), 10 deletions(-) create mode 100644 tests/gem5/to_tick/configs/tick-exit.py create mode 100644 tests/gem5/to_tick/configs/tick-to-max.py create mode 100644 tests/gem5/to_tick/ref/tick-exit-10-20-30-40.txt create mode 100644 tests/gem5/to_tick/ref/tick-exit-100.txt create mode 100644 tests/gem5/to_tick/ref/tick-to-max-at-execution-100.txt create mode 100644 tests/gem5/to_tick/ref/tick-to-max-at-execution-and-after-100-200.txt create mode 100644 tests/gem5/to_tick/ref/tick-to-max-before-execution-250.txt create mode 100644 tests/gem5/to_tick/test_to_tick.py diff --git a/src/python/gem5/simulate/exit_event.py b/src/python/gem5/simulate/exit_event.py index 089017806b..1e14fdd11a 100644 --- a/src/python/gem5/simulate/exit_event.py +++ b/src/python/gem5/simulate/exit_event.py @@ -42,6 +42,7 @@ class ExitEvent(Enum): SWITCHCPU = "switchcpu" # An exit needed to switch CPU cores. FAIL = "fail" # An exit because the simulation has failed. CHECKPOINT = "checkpoint" # An exit to load a checkpoint. + SCHEDULED_TICK = "scheduled tick exit" MAX_TICK = "max tick" # An exit due to a maximum tick value being met. USER_INTERRUPT = ( # An exit due to a user interrupt (e.g., cntr + c) "user interupt" @@ -75,6 +76,8 @@ class ExitEvent(Enum): return ExitEvent.EXIT elif exit_string == "simulate() limit reached": return ExitEvent.MAX_TICK + elif exit_string == "Tick exit reached": + return ExitEvent.SCHEDULED_TICK elif exit_string == "switchcpu": return ExitEvent.SWITCHCPU elif exit_string == "m5_fail instruction encountered": diff --git a/src/python/gem5/simulate/simulator.py b/src/python/gem5/simulate/simulator.py index 1d0d3ecc66..e27679a996 100644 --- a/src/python/gem5/simulate/simulator.py +++ b/src/python/gem5/simulate/simulator.py @@ -157,6 +157,7 @@ class Simulator: * ExitEvent.WORKEND: exit simulation * ExitEvent.USER_INTERRUPT: exit simulation * ExitEvent.MAX_TICK: exit simulation + * ExitEvent.SCHEDULED_TICK: exit simulation * ExitEvent.SIMPOINT_BEGIN: reset stats * ExitEvent.MAX_INSTS: exit simulation @@ -197,6 +198,7 @@ class Simulator: )(), ExitEvent.USER_INTERRUPT: exit_generator(), ExitEvent.MAX_TICK: exit_generator(), + ExitEvent.SCHEDULED_TICK: exit_generator(), ExitEvent.SIMPOINT_BEGIN: warn_default_decorator( reset_stats_generator, "simpoint begin", diff --git a/src/python/m5/simulate.py b/src/python/m5/simulate.py index a47d4cacd6..744d95f9f6 100644 --- a/src/python/m5/simulate.py +++ b/src/python/m5/simulate.py @@ -54,7 +54,7 @@ from . import params from m5.util.dot_writer import do_dot, do_dvfs_dot from m5.util.dot_writer_ruby import do_ruby_dot -from .util import fatal +from .util import fatal, warn from .util import attrdict # define a MaxTick parameter, unsigned 64 bit @@ -205,6 +205,63 @@ def simulate(*args, **kwargs): return sim_out +def setMaxTick(tick: int) -> None: + """Sets the maximum tick the simulation may run to. When when using the + stdlib simulator module, reaching this max tick triggers a + `ExitEvent.MAX_TICK` exit event. + + :param tick: the maximum tick (absolute, not relative to the current tick). + """ + if tick <= curTick(): + warn("Max tick scheduled for the past. This will not be triggered.") + _m5.event.setMaxTick(tick=tick) + + +def getMaxTick() -> int: + """Returns the current maximum tick.""" + return _m5.event.getMaxTick() + + +def getTicksUntilMax() -> int: + """Returns the current number of ticks until the maximum tick.""" + return getMaxTick() - curTick() + + +def scheduleTickExitFromCurrent( + ticks: int, exit_string: str = "Tick exit reached" +) -> None: + """Schedules a tick exit event from the current tick. I.e., if ticks == 100 + then an exit event will be scheduled at tick `curTick() + 100`. + + The default `exit_string` value is used by the stdlib Simulator module to + declare this exit event as `ExitEvent.SCHEDULED_TICK`. + + :param ticks: The simulation ticks, from `curTick()` to schedule the exit + event. + :param exit_string: The exit string to return when the exit event is + triggered. + """ + scheduleTickExitAbsolute(tick=ticks + curTick(), exit_string=exit_string) + + +def scheduleTickExitAbsolute( + tick: int, exit_string: str = "Tick exit reached" +) -> None: + """Schedules a tick exit event using absolute ticks. I.e., if tick == 100 + then an exit event will be scheduled at tick 100. + + The default `exit_string` value is used by the stdlib Simulator module to + declare this exit event as `ExitEvent.SCHEDULED_TICK`. + + :param tick: The absolute simulation tick to schedule the exit event. + :param exit_string: The exit string to return when the exit event is + triggered. + """ + if tick <= curTick(): + warn("Tick exit scheduled for the past. This will not be triggered.") + _m5.event.scheduleTickExit(tick=tick, exit_string=exit_string) + + def drain(): """Drain the simulator in preparation of a checkpoint or memory mode switch. diff --git a/src/python/pybind11/event.cc b/src/python/pybind11/event.cc index 7a02221611..827768f52f 100644 --- a/src/python/pybind11/event.cc +++ b/src/python/pybind11/event.cc @@ -107,6 +107,10 @@ pybind_init_event(py::module_ &m_native) m.def("simulate", &simulate, py::arg("ticks") = MaxTick); + m.def("setMaxTick", &set_max_tick, py::arg("tick")); + m.def("getMaxTick", &get_max_tick, py::return_value_policy::copy); + m.def("scheduleTickExit", &schedule_tick_exit, py::arg("tick"), + py::arg("exit_string")); m.def("terminateEventQueueThreads", &terminateEventQueueThreads); m.def("exitSimLoop", &exitSimLoop); m.def("getEventQueue", []() { return curEventQueue(); }, diff --git a/src/sim/simulate.cc b/src/sim/simulate.cc index c5d07942ef..4993859036 100644 --- a/src/sim/simulate.cc +++ b/src/sim/simulate.cc @@ -180,16 +180,14 @@ struct DescheduleDeleter }; /** Simulate for num_cycles additional cycles. If num_cycles is -1 - * (the default), do not limit simulation; some other event must - * terminate the loop. Exported to Python. + * (the default), we simulate to MAX_TICKS unless the max ticks has been set + * via the 'set_max_tick' function prior. This function is exported to Python. * @return The SimLoopExitEvent that caused the loop to exit. */ GlobalSimLoopExitEvent * simulate(Tick num_cycles) { std::unique_ptr quantum_event; - const Tick exit_tick = num_cycles < MaxTick - curTick() ? - curTick() + num_cycles : MaxTick; inform("Entering event queue @ %d. Starting simulation...\n", curTick()); @@ -197,11 +195,22 @@ simulate(Tick num_cycles) simulatorThreads.reset(new SimulatorThreads(numMainEventQueues)); if (!simulate_limit_event) { - simulate_limit_event = new GlobalSimLoopExitEvent( - mainEventQueue[0]->getCurTick(), - "simulate() limit reached", 0); + // If the simulate_limit_event is not set, we set it to MaxTick. + set_max_tick(MaxTick); + } + + if (num_cycles != -1) { + // If the user has specified an exit event after X cycles, do so here. + // Note: This will override any prior set max_tick behaviour (such as + // that above when it is set to MAxTick). + const Tick max_tick = num_cycles < MaxTick - curTick() ? + curTick() + num_cycles : MaxTick; + + // This is kept to `set_max_tick` instead of `schedule_tick_exit` to + // preserve backwards functionality. It may be better to deprecate this + // behaviour at some point in favor of `schedule_tick_exit`. + set_max_tick(max_tick); } - simulate_limit_event->reschedule(exit_tick); if (numMainEventQueues > 1) { fatal_if(simQuantum == 0, @@ -231,6 +240,34 @@ simulate(Tick num_cycles) return global_exit_event; } +void set_max_tick(Tick tick) +{ + if (!simulate_limit_event) { + simulate_limit_event = new GlobalSimLoopExitEvent( + mainEventQueue[0]->getCurTick(), + "simulate() limit reached", 0); + } + simulate_limit_event->reschedule(tick); +} + + +Tick get_max_tick() +{ + if (!simulate_limit_event) { + /* If the GlobalSimLoopExitEvent has not been setup, the maximum tick + * is `MaxTick` as declared in "src/base/types.hh". + */ + return MaxTick; + } + + return simulate_limit_event->when(); +} + +void schedule_tick_exit(Tick tick, std::string exit_string) +{ + new GlobalSimLoopExitEvent(tick, exit_string, 0); +} + void terminateEventQueueThreads() { diff --git a/src/sim/simulate.hh b/src/sim/simulate.hh index 5ef499541f..e7c4fa640c 100644 --- a/src/sim/simulate.hh +++ b/src/sim/simulate.hh @@ -45,7 +45,37 @@ namespace gem5 class GlobalSimLoopExitEvent; -GlobalSimLoopExitEvent *simulate(Tick num_cycles = MaxTick); +GlobalSimLoopExitEvent *simulate(Tick num_cycles = -1); + +/** + * @brief Set the maximum tick. + * + * This function will schedule, or reschedule, the maximum tick for the + * simulation. + * + * This will setup the GlobalSimLoopExitEvent if it does not already exist. + * + * @param tick The maximum tick. + */ +void set_max_tick(Tick tick); + +/** + * @brief Get the maximum simulation tick. + * + * + * @returns The maximum simulation tick. + */ +Tick get_max_tick(); + +/** + * @brief Schedule an exit event at a particular tick. + * + * Schedule a tick with a particular exit string. + * + * @param tick The tick at which the simulation loop should exit. + * @param exit_string The exit string explaining the exit. + */ +void schedule_tick_exit(Tick tick, std::string exit_string); /** * Terminate helper threads when running in parallel mode. diff --git a/tests/gem5/to_tick/configs/tick-exit.py b/tests/gem5/to_tick/configs/tick-exit.py new file mode 100644 index 0000000000..9b412cbfb6 --- /dev/null +++ b/tests/gem5/to_tick/configs/tick-exit.py @@ -0,0 +1,100 @@ +# Copyright (c) 2022 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. + +""" + +""" + +from gem5.resources.resource import Resource +from gem5.isas import ISA +from gem5.components.memory import SingleChannelDDR3_1600 +from gem5.components.boards.simple_board import SimpleBoard +from gem5.components.cachehierarchies.classic.no_cache import NoCache +from gem5.components.processors.simple_processor import SimpleProcessor +from gem5.components.processors.cpu_types import CPUTypes +from gem5.simulate.simulator import Simulator +from gem5.simulate.exit_event import ExitEvent + +import m5 + +import argparse + +parser = argparse.ArgumentParser() + +parser.add_argument( + "-t", + "--tick-exits", + type=int, + nargs="+", + required=True, + help="Set the tick exits to exit.", +) + +parser.add_argument( + "-r", + "--resource-directory", + type=str, + required=False, + help="The directory in which resources will be downloaded or exist.", +) + +args = parser.parse_args() + +# Setup the system. +motherboard = SimpleBoard( + clk_freq="3GHz", + processor=SimpleProcessor( + cpu_type=CPUTypes.TIMING, + isa=ISA.X86, + num_cores=1, + ), + memory=SingleChannelDDR3_1600(), + cache_hierarchy=NoCache(), +) + +# Set the workload +binary = Resource( + "x86-hello64-static", resource_directory=args.resource_directory +) +motherboard.set_se_binary_workload(binary) + + +def scheduled_tick_generator(): + while True: + print(f"Exiting at: {m5.curTick()}") + yield False + + +# Run the simulation +simulator = Simulator( + board=motherboard, + on_exit_event={ExitEvent.SCHEDULED_TICK: scheduled_tick_generator()}, +) + +for tick in args.tick_exits: + m5.scheduleTickExitFromCurrent(tick) + +simulator.run() diff --git a/tests/gem5/to_tick/configs/tick-to-max.py b/tests/gem5/to_tick/configs/tick-to-max.py new file mode 100644 index 0000000000..2b679df412 --- /dev/null +++ b/tests/gem5/to_tick/configs/tick-to-max.py @@ -0,0 +1,123 @@ +# Copyright (c) 2022 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. + +""" +This configuration script is used to test running a simulation to a specified +maximum tick. This script was setup to test setting the number of ticks to +run before, at, or after the running of `simulator.run`. + +**Note:** There can only ever be one MAX_TICK exit event scheduled at any one +time. +""" + +from gem5.resources.resource import Resource +from gem5.isas import ISA +from gem5.components.memory import SingleChannelDDR3_1600 +from gem5.components.boards.simple_board import SimpleBoard +from gem5.components.cachehierarchies.classic.no_cache import NoCache +from gem5.components.processors.simple_processor import SimpleProcessor +from gem5.components.processors.cpu_types import CPUTypes +from gem5.simulate.simulator import Simulator + +import m5 + +import argparse + +parser = argparse.ArgumentParser() + +parser.add_argument( + "-b", + "--set-ticks-before", + type=int, + required=False, + help="Set the number of ticks to run to prior to executing " + "`simulator.run`.", +) + +parser.add_argument( + "-e", + "--set-ticks-at-execution", + type=int, + required=False, + help="Set the number of ticks to run via `simulator.run`.", +) + +parser.add_argument( + "-a", + "--set-ticks-after", + type=int, + required=False, + help="Set the number of ticks to run after `simulator.run` has ceased " + "execution.", +) + +parser.add_argument( + "-r", + "--resource-directory", + type=str, + required=False, + help="The directory in which resources will be downloaded or exist.", +) + +args = parser.parse_args() + +# Setup the system. +motherboard = SimpleBoard( + clk_freq="3GHz", + processor=SimpleProcessor( + cpu_type=CPUTypes.TIMING, + isa=ISA.X86, + num_cores=1, + ), + memory=SingleChannelDDR3_1600(), + cache_hierarchy=NoCache(), +) + +# Set the workload +binary = Resource( + "x86-hello64-static", resource_directory=args.resource_directory +) +motherboard.set_se_binary_workload(binary) + +# Set the max ticks before setting up the simulation, if applicable. +if args.set_ticks_before: + m5.setMaxTick(args.set_ticks_before) + +# Run the simulation +simulator = Simulator(board=motherboard) + +if args.set_ticks_at_execution: + simulator.run(max_ticks=args.set_ticks_at_execution) +else: + simulator.run() + +# Set the max ticks after the simulator run. +if args.set_ticks_after: + m5.setMaxTick(args.set_ticks_after) + +print(f"Current Tick: {m5.curTick()}") +print(f"Current Max Tick: {m5.getMaxTick()}") +print(f"Ticks until max: {m5.getTicksUntilMax()}") diff --git a/tests/gem5/to_tick/ref/tick-exit-10-20-30-40.txt b/tests/gem5/to_tick/ref/tick-exit-10-20-30-40.txt new file mode 100644 index 0000000000..05f8159065 --- /dev/null +++ b/tests/gem5/to_tick/ref/tick-exit-10-20-30-40.txt @@ -0,0 +1,6 @@ +Global frequency set at 1000000000000 ticks per second +Exiting at: 10 +Exiting at: 20 +Exiting at: 30 +Exiting at: 40 +Hello world! diff --git a/tests/gem5/to_tick/ref/tick-exit-100.txt b/tests/gem5/to_tick/ref/tick-exit-100.txt new file mode 100644 index 0000000000..62f9330e13 --- /dev/null +++ b/tests/gem5/to_tick/ref/tick-exit-100.txt @@ -0,0 +1,3 @@ +Global frequency set at 1000000000000 ticks per second +Exiting at: 100 +Hello world! diff --git a/tests/gem5/to_tick/ref/tick-to-max-at-execution-100.txt b/tests/gem5/to_tick/ref/tick-to-max-at-execution-100.txt new file mode 100644 index 0000000000..1507716e42 --- /dev/null +++ b/tests/gem5/to_tick/ref/tick-to-max-at-execution-100.txt @@ -0,0 +1,4 @@ +Global frequency set at 1000000000000 ticks per second +Current Tick: 100 +Current Max Tick: 100 +Ticks until max: 0 diff --git a/tests/gem5/to_tick/ref/tick-to-max-at-execution-and-after-100-200.txt b/tests/gem5/to_tick/ref/tick-to-max-at-execution-and-after-100-200.txt new file mode 100644 index 0000000000..b1cde8ae4c --- /dev/null +++ b/tests/gem5/to_tick/ref/tick-to-max-at-execution-and-after-100-200.txt @@ -0,0 +1,4 @@ +Global frequency set at 1000000000000 ticks per second +Current Tick: 100 +Current Max Tick: 200 +Ticks until max: 100 diff --git a/tests/gem5/to_tick/ref/tick-to-max-before-execution-250.txt b/tests/gem5/to_tick/ref/tick-to-max-before-execution-250.txt new file mode 100644 index 0000000000..b26e9ebee2 --- /dev/null +++ b/tests/gem5/to_tick/ref/tick-to-max-before-execution-250.txt @@ -0,0 +1,4 @@ +Global frequency set at 1000000000000 ticks per second +Current Tick: 250 +Current Max Tick: 250 +Ticks until max: 0 diff --git a/tests/gem5/to_tick/test_to_tick.py b/tests/gem5/to_tick/test_to_tick.py new file mode 100644 index 0000000000..ba5bcbf9b9 --- /dev/null +++ b/tests/gem5/to_tick/test_to_tick.py @@ -0,0 +1,174 @@ +# Copyright (c) 2022 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. + +from testlib import * + +if config.bin_path: + resource_path = config.bin_path +else: + resource_path = joinpath(absdirpath(__file__), "..", "resources") + +# This test sets the tick to max tick via the `simulator.run` function. This is +# set to 100. Therefore, at the end of the execution the expected current tick +# should be 100, with the max tick still 100. The number of expected ticks to +# max is therefore 0. +gem5_verify_config( + name="test-to-max-tick-at-execution-100", + verifiers=[ + verifier.MatchStdoutNoPerf( + joinpath(getcwd(), "ref", "tick-to-max-at-execution-100.txt") + ) + ], + fixtures=(), + config=joinpath( + config.base_dir, + "tests", + "gem5", + "to_tick", + "configs", + "tick-to-max.py", + ), + config_args=[ + "--resource-directory", + resource_path, + "--set-ticks-at-execution", + "100", + ], + valid_isas=(constants.all_compiled_tag,), + valid_hosts=constants.supported_hosts, + length=constants.quick_tag, +) + +# This test sets the max tick via the `simulator.run` function at tick 100. +# The `m5.setMaxTick` function is then called after, passing the value 200 . +# This means at the end of execution the current tick is 100, and the max tick +# is 200. The number of expected ticks to max is therefore 100. +gem5_verify_config( + name="test-to-max-tick-at-execution-and-after-100-200", + verifiers=[ + verifier.MatchStdoutNoPerf( + joinpath( + getcwd(), + "ref", + "tick-to-max-at-execution-and-after-100-200.txt", + ) + ) + ], + fixtures=(), + config=joinpath( + config.base_dir, + "tests", + "gem5", + "to_tick", + "configs", + "tick-to-max.py", + ), + config_args=[ + "--resource-directory", + resource_path, + "--set-ticks-at-execution", + "100", + "--set-ticks-after", + "200", + ], + valid_isas=(constants.all_compiled_tag,), + valid_hosts=constants.supported_hosts, + length=constants.quick_tag, +) + +# This test sets the max tick to 250 via the `m5.setMaxTick` prior to running +# `simulator.run`. This means at the end of execution the current tick is 250 +# and the max tick is 250. The expected number of ticks to max is therefore 0. +gem5_verify_config( + name="test-to-max-tick-before-execution-250", + verifiers=[ + verifier.MatchStdoutNoPerf( + joinpath(getcwd(), "ref", "tick-to-max-before-execution-250.txt") + ) + ], + fixtures=(), + config=joinpath( + config.base_dir, + "tests", + "gem5", + "to_tick", + "configs", + "tick-to-max.py", + ), + config_args=[ + "--resource-directory", + resource_path, + "--set-ticks-before", + "250", + ], + valid_isas=(constants.all_compiled_tag,), + valid_hosts=constants.supported_hosts, + length=constants.quick_tag, +) + +# Tests the scheduling of a tick exit event at tick 100. +gem5_verify_config( + name="test-to-tick-exit-100", + verifiers=[ + verifier.MatchStdoutNoPerf( + joinpath(getcwd(), "ref", "tick-exit-100.txt") + ) + ], + fixtures=(), + config=joinpath( + config.base_dir, "tests", "gem5", "to_tick", "configs", "tick-exit.py" + ), + config_args=["--resource-directory", resource_path, "--tick-exits", "100"], + valid_isas=(constants.all_compiled_tag,), + valid_hosts=constants.supported_hosts, + length=constants.quick_tag, +) + +# Tests the scheduling of a tick exit event at tick 10, 20, 30, and 40. +gem5_verify_config( + name="test-to-tick-exit-10-20-30-40", + verifiers=[ + verifier.MatchStdoutNoPerf( + joinpath(getcwd(), "ref", "tick-exit-10-20-30-40.txt") + ) + ], + fixtures=(), + config=joinpath( + config.base_dir, "tests", "gem5", "to_tick", "configs", "tick-exit.py" + ), + config_args=[ + "--resource-directory", + resource_path, + "--tick-exits", + "10", + "20", + "30", + "40", + ], + valid_isas=(constants.all_compiled_tag,), + valid_hosts=constants.supported_hosts, + length=constants.quick_tag, +)