gem5/configs/example/components-library/parsec_disk_run.py

# Copyright (c) 2021 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.

"""
A run script for running the parsec benchmark suite in gem5.

On the first run of this script it will download the disk image for parsec
and Linux kernel version 5.4.

The disk image is about 8 GB so this can take 10-15 minutes on a fast
connection.
"""

import m5
import m5.ticks
from m5.objects import Root

import sys
import os

# This is a lame hack to get the imports working correctly.
# TODO: This needs fixed.
sys.path.append(
    os.path.join(
        os.path.dirname(os.path.abspath(__file__)),
        os.pardir,
        os.pardir,
        os.pardir,
    )
)

from components_library.boards.x86_board import X86Board
from components_library.cachehierarchies.classic.\
    private_l1_private_l2_cache_hierarchy import (
    PrivateL1PrivateL2CacheHierarchy,
)
from components_library.memory.single_channel import SingleChannelDDR3_1600
from components_library.processors.simple_switchable_processor import (
    SimpleSwitchableProcessor,
)
from components_library.processors.cpu_types import CPUTypes
from components_library.runtime import (
    get_runtime_isa,
    get_runtime_coherence_protocol,
)

import subprocess
import gzip
import time
import shutil
import time


# Setup the cachie hierarchy.
cache_hierarchy = PrivateL1PrivateL2CacheHierarchy(
    l1d_size="32kB",
    l1i_size="32kB",
    l2_size="256kB",
)

# Setup the memory system.
# Warning!!! This must be kept at 3GB for now. X86Motherboard does not support
# anything else right now!
memory = SingleChannelDDR3_1600(size="3GB")


# The processor. In this case we use the special "SwitchableProcessor" which
# allows us to switch between different SimpleProcessors.
#
# WARNING: This is known buggy. While it works starting with Atomic and
# switching to Timing. The reverse is not true. KVM is not yet functional.

processor = SimpleSwitchableProcessor(
    starting_core_type=CPUTypes.ATOMIC,
    switch_core_type=CPUTypes.TIMING,
    num_cores=4,
)

# Setup the board.
motherboard = X86Board(
    clk_freq="3GHz",
    processor=processor,
    memory=memory,
    cache_hierarchy=cache_hierarchy,
    exit_on_work_items=True,
)

motherboard.connect_things()


# Download the linux kernel and parsec disk image needed to run the
# simuluation.
thispath = os.path.dirname(os.path.realpath(__file__))

kernel_url = (
    "http://dist.gem5.org/dist/v21-0/kernels/x86/static/vmlinux-5.4.49"
)
kernel_path = os.path.join(thispath, "vmlinux-5.4.49")
if not os.path.exists(kernel_path):
    subprocess.run(["wget", "-P", thispath, kernel_url])

parsec_img_url = (
    "http://dist.gem5.org/dist/v21-0/images/x86/ubuntu-18-04/parsec.img.gz"
)
parsec_img_path_gz = os.path.join(thispath, "parsec.img.gz")
parsec_img_path = os.path.join(thispath, "parsec.img")

if not os.path.exists(parsec_img_path):
    subprocess.run(["wget", "-P", thispath, parsec_img_url])
    with gzip.open(parsec_img_path_gz, "rb") as f:
        with open(parsec_img_path, "wb") as o:
            shutil.copyfileobj(f, o)


# The command to run. In this case the blackscholes app with the simsmall
# workload.
command = "cd /home/gem5/parsec-benchmark\n"
command += "source env.sh\n"
command += "parsecmgmt -a run -p blackscholes "
command += "-c gcc-hooks -i simsmall -n {}\n".format(processor.get_num_cores())
command += "sleep 5 \n"
command += "m5 exit \n"

motherboard.set_workload(
    kernel=kernel_path, disk_image=parsec_img_path, command=command
)

print("Running with ISA: " + get_runtime_isa().name)
print("Running with protocol: " + get_runtime_coherence_protocol().name)
print()

root = Root(full_system=True, system=motherboard)

m5.instantiate()

globalStart = time.time()
print("Beginning the simulation")

start_tick = m5.curTick()
end_tick = m5.curTick()

m5.stats.reset()

exit_event = m5.simulate()

if exit_event.getCause() == "workbegin":
    print("Done booting Linux")
    # Reached the start of ROI.
    # The start of the ROI is marked by an m5_work_begin() call.
    print("Resetting stats at the start of ROI!")
    m5.stats.reset()
    start_tick = m5.curTick()

    # Switch to the Timing Processor.
    motherboard.get_processor().switch()
else:
    print("Unexpected termination of simulation!")
    print()

    m5.stats.dump()
    end_tick = m5.curTick()

    m5.stats.reset()
    print("Performance statistics:")
    print("Simulated time: {}s".format((end_tick - start_tick) / 1e12))
    print("Ran a total of", m5.curTick() / 1e12, "simulated seconds")
    print(
        "Total wallclock time: {}s, {} min".format(
            (time.time() - globalStart, (time.time() - globalStart) / 60)
        )
    )
    exit()

# Simulate the ROI.
exit_event = m5.simulate()

if exit_event.getCause() == "workend":
    # Reached the end of ROI
    # The end of the ROI is marked by an m5_work_end() call.
    print("Dumping stats at the end of the ROI!")
    m5.stats.dump()
    end_tick = m5.curTick()

    m5.stats.reset()

    # Switch back to the Atomic Processor
    motherboard.get_processor().switch()
else:
    print("Unexpected termination of simulation!")
    print()
    m5.stats.dump()
    end_tick = m5.curTick()

    m5.stats.reset()
    print("Performance statistics:")
    print("Simulated time: {}s".format((end_tick - start_tick) / 1e12))
    print("Ran a total of", m5.curTick() / 1e12, "simulated seconds")
    print(
        "Total wallclock time: {}s, {} min".format(
            time.time() - globalStart, (time.time() - globalStart) / 60
        )
    )
    exit()

# Simulate the remaning part of the benchmark
# Run the rest of the workload until m5 exit

exit_event = m5.simulate()

print("Done running the simulation")
print()
print("Performance statistics:")

print("Simulated time in ROI: {}s".format((end_tick - start_tick) / 1e12))
print("Ran a total of {} simulated seconds".format(m5.curTick() / 1e12))
print(
    "Total wallclock time: {}s, {} min".format(
        time.time() - globalStart, (time.time() - globalStart) / 60
    )
)