c4793184bd
build directory instead of being inferred from the name
of the build directory.
Options are passed to C++ via config/*.hh files instead of
via the command line. Build option flags are now always
defined to 0 or 1, so checks must use '#if' rather than
'#ifdef'.
SConscript:
MySQL detection moved to SConstruct.
Add config/*.hh files (via ConfigFile builder).
arch/alpha/alpha_memory.cc:
arch/alpha/ev5.cc:
arch/alpha/ev5.hh:
arch/alpha/isa_traits.hh:
base/fast_alloc.hh:
base/statistics.cc:
base/statistics.hh:
base/stats/events.cc:
base/stats/events.hh:
cpu/base.cc:
cpu/base.hh:
cpu/base_dyn_inst.cc:
cpu/base_dyn_inst.hh:
cpu/exec_context.cc:
cpu/exec_context.hh:
cpu/o3/alpha_cpu.hh:
cpu/o3/alpha_cpu_builder.cc:
cpu/o3/alpha_cpu_impl.hh:
cpu/o3/alpha_dyn_inst.hh:
cpu/o3/alpha_dyn_inst_impl.hh:
cpu/o3/alpha_params.hh:
cpu/o3/commit_impl.hh:
cpu/o3/cpu.cc:
cpu/o3/cpu.hh:
cpu/o3/fetch_impl.hh:
cpu/o3/iew.hh:
cpu/o3/iew_impl.hh:
cpu/o3/regfile.hh:
cpu/o3/rename_impl.hh:
cpu/o3/rob_impl.hh:
cpu/ozone/cpu.hh:
cpu/pc_event.cc:
cpu/simple/cpu.cc:
cpu/simple/cpu.hh:
sim/process.cc:
sim/process.hh:
Convert compile flags from def/undef to 0/1.
Set via #include config/*.hh instead of command line.
arch/alpha/isa_desc:
Convert compile flags from def/undef to 0/1.
Set via #include config/*.hh instead of command line.
Revamp fenv.h support... most of the ugliness is hidden
in base/fenv.hh now.
base/mysql.hh:
Fix typo in #ifndef guard.
build/SConstruct:
Build options are set via a build_options file in the
build directory instead of being inferred from the name
of the build directory.
Options are passed to C++ via config/*.hh files instead of
via the command line.
python/SConscript:
Generate m5_build_env directly from scons options
instead of indirectly via CPPDEFINES.
python/m5/convert.py:
Allow '0' and '1' for booleans.
Rewrite toBool to use dict.
base/fenv.hh:
Revamp <fenv.h> support to make it a compile option
(so we can test w/o it even if it's present) and to
make isa_desc cleaner.
--HG--
extra : convert_revision : 8f97dc11185bef5e1865b3269c7341df8525c9ad
236 lines
7.4 KiB
Python
236 lines
7.4 KiB
Python
# Copyright (c) 2005 The Regents of The University of Michigan
|
|
# 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.
|
|
|
|
# metric prefixes
|
|
exa = 1.0e18
|
|
peta = 1.0e15
|
|
tera = 1.0e12
|
|
giga = 1.0e9
|
|
mega = 1.0e6
|
|
kilo = 1.0e3
|
|
|
|
milli = 1.0e-3
|
|
micro = 1.0e-6
|
|
nano = 1.0e-9
|
|
pico = 1.0e-12
|
|
femto = 1.0e-15
|
|
atto = 1.0e-18
|
|
|
|
# power of 2 prefixes
|
|
kibi = 1024
|
|
mebi = kibi * 1024
|
|
gibi = mebi * 1024
|
|
tebi = gibi * 1024
|
|
pebi = tebi * 1024
|
|
exbi = pebi * 1024
|
|
|
|
# memory size configuration stuff
|
|
def toFloat(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('Ei'):
|
|
return float(value[:-2]) * exbi
|
|
elif value.endswith('Pi'):
|
|
return float(value[:-2]) * pebi
|
|
elif value.endswith('Ti'):
|
|
return float(value[:-2]) * tebi
|
|
elif value.endswith('Gi'):
|
|
return float(value[:-2]) * gibi
|
|
elif value.endswith('Mi'):
|
|
return float(value[:-2]) * mebi
|
|
elif value.endswith('ki'):
|
|
return float(value[:-2]) * kibi
|
|
elif value.endswith('E'):
|
|
return float(value[:-1]) * exa
|
|
elif value.endswith('P'):
|
|
return float(value[:-1]) * peta
|
|
elif value.endswith('T'):
|
|
return float(value[:-1]) * tera
|
|
elif value.endswith('G'):
|
|
return float(value[:-1]) * giga
|
|
elif value.endswith('M'):
|
|
return float(value[:-1]) * mega
|
|
elif value.endswith('k'):
|
|
return float(value[:-1]) * kilo
|
|
elif value.endswith('m'):
|
|
return float(value[:-1]) * milli
|
|
elif value.endswith('u'):
|
|
return float(value[:-1]) * micro
|
|
elif value.endswith('n'):
|
|
return float(value[:-1]) * nano
|
|
elif value.endswith('p'):
|
|
return float(value[:-1]) * pico
|
|
elif value.endswith('f'):
|
|
return float(value[:-1]) * femto
|
|
else:
|
|
return float(value)
|
|
|
|
def toLong(value):
|
|
value = toFloat(value)
|
|
result = int(value)
|
|
if value != result:
|
|
raise ValueError, "cannot convert '%s' to long" % value
|
|
|
|
return result
|
|
|
|
def toInteger(value):
|
|
value = toFloat(value)
|
|
result = int(value)
|
|
if value != result:
|
|
raise ValueError, "cannot convert '%s' to integer" % value
|
|
|
|
return result
|
|
|
|
_bool_dict = {
|
|
'true' : True, 't' : True, 'yes' : True, 'y' : True, '1' : True,
|
|
'false' : False, 'f' : False, 'no' : False, 'n' : False, '0' : False
|
|
}
|
|
|
|
def toBool(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
value = value.lower()
|
|
result = _bool_dict.get(value, None)
|
|
if result == None:
|
|
raise ValueError, "cannot convert '%s' to bool" % value
|
|
return result
|
|
|
|
def toFrequency(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('THz'):
|
|
return float(value[:-3]) * tera
|
|
elif value.endswith('GHz'):
|
|
return float(value[:-3]) * giga
|
|
elif value.endswith('MHz'):
|
|
return float(value[:-3]) * mega
|
|
elif value.endswith('kHz'):
|
|
return float(value[:-3]) * kilo
|
|
elif value.endswith('Hz'):
|
|
return float(value[:-2])
|
|
|
|
raise ValueError, "cannot convert '%s' to frequency" % value
|
|
|
|
def toLatency(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('ps'):
|
|
return float(value[:-2]) * pico
|
|
elif value.endswith('ns'):
|
|
return float(value[:-2]) * nano
|
|
elif value.endswith('us'):
|
|
return float(value[:-2]) * micro
|
|
elif value.endswith('ms'):
|
|
return float(value[:-2]) * milli
|
|
elif value.endswith('s'):
|
|
return float(value[:-1])
|
|
|
|
raise ValueError, "cannot convert '%s' to latency" % value
|
|
|
|
def toClockPeriod(value):
|
|
"""result is a clock period"""
|
|
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
try:
|
|
val = toFrequency(value)
|
|
if val != 0:
|
|
val = 1 / val
|
|
return val
|
|
except ValueError:
|
|
pass
|
|
|
|
try:
|
|
val = toLatency(value)
|
|
return val
|
|
except ValueError:
|
|
pass
|
|
|
|
raise ValueError, "cannot convert '%s' to clock period" % value
|
|
|
|
|
|
def toNetworkBandwidth(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('Tbps'):
|
|
return float(value[:-4]) * tera
|
|
elif value.endswith('Gbps'):
|
|
return float(value[:-4]) * giga
|
|
elif value.endswith('Mbps'):
|
|
return float(value[:-4]) * mega
|
|
elif value.endswith('kbps'):
|
|
return float(value[:-4]) * kilo
|
|
elif value.endswith('bps'):
|
|
return float(value[:-3])
|
|
else:
|
|
return float(value)
|
|
|
|
raise ValueError, "cannot convert '%s' to network bandwidth" % value
|
|
|
|
def toMemoryBandwidth(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('PB/s'):
|
|
return float(value[:-4]) * pebi
|
|
elif value.endswith('TB/s'):
|
|
return float(value[:-4]) * tebi
|
|
elif value.endswith('GB/s'):
|
|
return float(value[:-4]) * gibi
|
|
elif value.endswith('MB/s'):
|
|
return float(value[:-4]) * mebi
|
|
elif value.endswith('kB/s'):
|
|
return float(value[:-4]) * kibi
|
|
elif value.endswith('B/s'):
|
|
return float(value[:-3])
|
|
|
|
raise ValueError, "cannot convert '%s' to memory bandwidth" % value
|
|
|
|
def toMemorySize(value):
|
|
if not isinstance(value, str):
|
|
raise TypeError, "wrong type '%s' should be str" % type(value)
|
|
|
|
if value.endswith('PB'):
|
|
return float(value[:-2]) * pebi
|
|
elif value.endswith('TB'):
|
|
return float(value[:-2]) * tebi
|
|
elif value.endswith('GB'):
|
|
return float(value[:-2]) * gibi
|
|
elif value.endswith('MB'):
|
|
return float(value[:-2]) * mebi
|
|
elif value.endswith('kB'):
|
|
return float(value[:-2]) * kibi
|
|
elif value.endswith('B'):
|
|
return float(value[:-1])
|
|
|
|
raise ValueError, "cannot convert '%s' to memory size" % value
|