e1db67c4bd
This commit contains the rest of the base 2 vs base 10 cache/memory size clarifications. It also changes the warning message to use warn(). With these changes, the warning message should now no longer show up during a fresh compilation of gem5. Change-Id: Ia63f841bdf045b76473437f41548fab27dc19631
296 lines
9.9 KiB
Python
296 lines
9.9 KiB
Python
# Copyright (c) 2019 ARM Limited
|
|
# All rights reserved.
|
|
#
|
|
# The license below extends only to copyright in the software and shall
|
|
# not be construed as granting a license to any other intellectual
|
|
# property including but not limited to intellectual property relating
|
|
# to a hardware implementation of the functionality of the software
|
|
# licensed hereunder. You may use the software subject to the license
|
|
# terms below provided that you ensure that this notice is replicated
|
|
# unmodified and in its entirety in all distributions of the software,
|
|
# modified or unmodified, in source code or in binary form.
|
|
#
|
|
# Copyright (c) 2015 Advanced Micro Devices, Inc.
|
|
# 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 getpass
|
|
import operator
|
|
import os
|
|
import platform
|
|
from functools import reduce
|
|
from os import (
|
|
access,
|
|
getpid,
|
|
listdir,
|
|
makedirs,
|
|
mkdir,
|
|
stat,
|
|
)
|
|
from os.path import isdir
|
|
from os.path import join as joinpath
|
|
from pwd import getpwuid
|
|
from shutil import (
|
|
copyfile,
|
|
rmtree,
|
|
)
|
|
|
|
import m5
|
|
from m5.objects import *
|
|
from m5.util.convert import *
|
|
|
|
|
|
def hex_mask(terms):
|
|
dec_mask = reduce(operator.or_, [2**i for i in terms], 0)
|
|
return f"{dec_mask:08x}"
|
|
|
|
|
|
def file_append(path, contents):
|
|
with open(joinpath(*path), "a") as f:
|
|
f.write(str(contents))
|
|
|
|
|
|
def replace_tree(path):
|
|
if isdir(path):
|
|
rmtree(path)
|
|
mkdir(path)
|
|
|
|
|
|
def config_filesystem(system, options=None):
|
|
"""This function parses the system object to create the pseudo file system
|
|
@param system: The system to create the config for
|
|
@param options: An optional argument which contains an Options.py options
|
|
object. This is useful if when use se.py and will set the L2 cache
|
|
size and the clock in /proc/cpuinfo if provided.
|
|
|
|
First, this function walks the system object to find all CPUs.
|
|
Then, this function creates the following files with the CPU information
|
|
- /proc/cpuinfo which contains the clock and the L2 size
|
|
(assumes all L2s private and the same size)
|
|
- /proc/stat simply lists all CPUs
|
|
- /sys/devices/system/cpu/online and /sys/devices/system/cpu/possible
|
|
These files list all of the CPUs in this system.
|
|
- /tmp
|
|
|
|
These files are created in the `fs` directory in the outdir path.
|
|
"""
|
|
fsdir = joinpath(m5.options.outdir, "fs")
|
|
replace_tree(fsdir)
|
|
|
|
# Set up /proc
|
|
procdir = joinpath(fsdir, "proc")
|
|
mkdir(procdir)
|
|
|
|
try:
|
|
cpus = [
|
|
obj for obj in system.descendants() if isinstance(obj, BaseCPU)
|
|
]
|
|
except NameError:
|
|
# BaseCPU is not defined for the NULL ISA
|
|
cpus = []
|
|
|
|
cpu_clock = 0
|
|
if hasattr(options, "cpu_clock"):
|
|
cpu_clock = toFrequency(options.cpu_clock) / mega
|
|
|
|
l2_size = 0
|
|
if hasattr(options, "l2_size"):
|
|
l2_size = toMemorySize(options.l2_size) / kibi
|
|
|
|
for i, cpu in enumerate(cpus):
|
|
one_cpu = (
|
|
"processor : {proc}\n"
|
|
+ "vendor_id : Generic\n"
|
|
+ "cpu family : 0\n"
|
|
+ "model : 0\n"
|
|
+ "model name : Generic\n"
|
|
+ "stepping : 0\n"
|
|
+ "cpu MHz : {clock:0.3f}\n"
|
|
+ "cache size: : {l2_size}K\n"
|
|
+ "physical id : 0\n"
|
|
+ "siblings : {num_cpus}\n"
|
|
+ "core id : {proc}\n"
|
|
+ "cpu cores : {num_cpus}\n"
|
|
+ "fpu : yes\n"
|
|
+ "fpu exception : yes\n"
|
|
+ "cpuid level : 1\n"
|
|
+ "wp : yes\n"
|
|
+ "flags : fpu\n"
|
|
+ "cache alignment : {cacheline_size}\n"
|
|
+ "\n"
|
|
)
|
|
one_cpu = one_cpu.format(
|
|
proc=i,
|
|
num_cpus=len(cpus),
|
|
# Note: it would be nice to use cpu.clock, but it hasn't
|
|
# been finalized yet since m5.instantiate() isn't done.
|
|
clock=cpu_clock,
|
|
# Note: this assumes the L2 is private to each core
|
|
l2_size=l2_size,
|
|
cacheline_size=system.cache_line_size.getValue(),
|
|
)
|
|
file_append((procdir, "cpuinfo"), one_cpu)
|
|
|
|
file_append((procdir, "stat"), "cpu 0 0 0 0 0 0 0\n")
|
|
for i in range(len(cpus)):
|
|
file_append((procdir, "stat"), "cpu%d 0 0 0 0 0 0 0\n" % i)
|
|
|
|
# Set up /sys
|
|
sysdir = joinpath(fsdir, "sys")
|
|
mkdir(sysdir)
|
|
|
|
# Set up /sys/devices/system/cpu
|
|
cpudir = joinpath(sysdir, "devices", "system", "cpu")
|
|
makedirs(cpudir, exist_ok=True)
|
|
|
|
file_append((cpudir, "online"), "0-%d" % (len(cpus) - 1))
|
|
file_append((cpudir, "possible"), "0-%d" % (len(cpus) - 1))
|
|
|
|
# Set up /tmp
|
|
tmpdir = joinpath(fsdir, "tmp")
|
|
replace_tree(tmpdir)
|
|
|
|
system.redirect_paths = _redirect_paths(options)
|
|
|
|
# Setting the interpreter path. This is used to load the
|
|
# guest dynamic linker itself from the elf file.
|
|
interp = getattr(options, "interp_dir", None)
|
|
if interp:
|
|
from m5.core import setInterpDir
|
|
|
|
setInterpDir(interp)
|
|
|
|
print(
|
|
"Setting the interpreter path to:",
|
|
interp,
|
|
"\nFor dynamically linked applications you might still "
|
|
"need to setup the --redirects so that libraries are "
|
|
"found\n",
|
|
)
|
|
|
|
|
|
def register_node(cpu_list, mem, node_number):
|
|
nodebasedir = joinpath(
|
|
m5.options.outdir, "fs", "sys", "devices", "system", "node"
|
|
)
|
|
|
|
nodedir = joinpath(nodebasedir, "node%d" % node_number)
|
|
makedirs(nodedir, exist_ok=True)
|
|
|
|
file_append((nodedir, "cpumap"), hex_mask(cpu_list))
|
|
file_append(
|
|
(nodedir, "meminfo"),
|
|
"Node %d MemTotal: %dKiB"
|
|
% (node_number, toMemorySize(str(mem)) / kibi),
|
|
)
|
|
|
|
|
|
def register_cpu(physical_package_id, core_siblings, core_id, thread_siblings):
|
|
cpudir = joinpath(
|
|
m5.options.outdir,
|
|
"fs",
|
|
"sys",
|
|
"devices",
|
|
"system",
|
|
"cpu",
|
|
"cpu%d" % core_id,
|
|
)
|
|
|
|
makedirs(joinpath(cpudir, "topology"), exist_ok=True)
|
|
makedirs(joinpath(cpudir, "cache"))
|
|
|
|
file_append((cpudir, "online"), "1")
|
|
file_append(
|
|
(cpudir, "topology", "physical_package_id"), physical_package_id
|
|
)
|
|
file_append((cpudir, "topology", "core_siblings"), hex_mask(core_siblings))
|
|
file_append((cpudir, "topology", "core_id"), core_id)
|
|
file_append(
|
|
(cpudir, "topology", "thread_siblings"), hex_mask(thread_siblings)
|
|
)
|
|
|
|
|
|
def register_cache(level, idu_type, size, line_size, assoc, cpus):
|
|
fsdir = joinpath(m5.options.outdir, "fs")
|
|
for i in cpus:
|
|
cachedir = joinpath(
|
|
fsdir, "sys", "devices", "system", "cpu", "cpu%d" % i, "cache"
|
|
)
|
|
|
|
j = 0
|
|
while isdir(joinpath(cachedir, "index%d" % j)):
|
|
j += 1
|
|
indexdir = joinpath(cachedir, "index%d" % j)
|
|
makedirs(indexdir, exist_ok=True)
|
|
|
|
file_append((indexdir, "level"), level)
|
|
file_append((indexdir, "type"), idu_type)
|
|
file_append((indexdir, "size"), "%dK" % (toMemorySize(size) / kibi))
|
|
file_append((indexdir, "coherency_line_size"), line_size)
|
|
|
|
# Since cache size = number of indices * associativity * block size
|
|
num_sets = toMemorySize(size) / int(assoc) * int(line_size)
|
|
|
|
file_append((indexdir, "number_of_sets"), num_sets)
|
|
file_append((indexdir, "physical_line_partition"), "1")
|
|
file_append((indexdir, "shared_cpu_map"), hex_mask(cpus))
|
|
file_append(
|
|
(indexdir, "shared_cpu_list"), ",".join(str(cpu) for cpu in cpus)
|
|
)
|
|
|
|
|
|
def _redirect_paths(options):
|
|
# Redirect filesystem syscalls from src to the first matching dests
|
|
redirect_paths = [
|
|
RedirectPath(
|
|
app_path="/proc", host_paths=[f"{m5.options.outdir}/fs/proc"]
|
|
),
|
|
RedirectPath(
|
|
app_path="/sys", host_paths=[f"{m5.options.outdir}/fs/sys"]
|
|
),
|
|
RedirectPath(
|
|
app_path="/tmp", host_paths=[f"{m5.options.outdir}/fs/tmp"]
|
|
),
|
|
]
|
|
|
|
# Setting the redirect paths so that the guest dynamic linker
|
|
# can point to the proper /lib collection (e.g. to load libc)
|
|
redirects = getattr(options, "redirects", [])
|
|
for redirect in redirects:
|
|
app_path, host_path = redirect.split("=")
|
|
redirect_paths.append(
|
|
RedirectPath(app_path=app_path, host_paths=[host_path])
|
|
)
|
|
|
|
chroot = getattr(options, "chroot", None)
|
|
if chroot:
|
|
redirect_paths.append(
|
|
RedirectPath(
|
|
app_path="/", host_paths=[f"{os.path.expanduser(chroot)}"]
|
|
)
|
|
)
|
|
|
|
return redirect_paths
|