src/python/m5/util/convert.py - arm/gem5 - Git at Google

 # Copyright (c) 2005 The Regents of The University of Michigan
 # Copyright (c) 2010 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.
 #
 # Authors: Nathan Binkert
 #          Gabe Black

 # 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 toInteger(value):
     value = toFloat(value)
     result = long(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 anyToLatency(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 anyToFrequency(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)
         return val
     except ValueError:
         pass

     try:
         val = toLatency(value)
         if val != 0:
             val = 1 / val
         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 long(value[:-2]) * pebi
     elif value.endswith('TB'):
         return long(value[:-2]) * tebi
     elif value.endswith('GB'):
         return long(value[:-2]) * gibi
     elif value.endswith('MB'):
         return long(value[:-2]) * mebi
     elif value.endswith('kB'):
         return long(value[:-2]) * kibi
     elif value.endswith('B'):
         return long(value[:-1])

     raise ValueError, "cannot convert '%s' to memory size" % value

 def toIpAddress(value):
     if not isinstance(value, str):
         raise TypeError, "wrong type '%s' should be str" % type(value)

     bytes = value.split('.')
     if len(bytes) != 4:
         raise ValueError, 'invalid ip address %s' % value

     for byte in bytes:
         if not 0 <= int(byte) <= 0xff:
             raise ValueError, 'invalid ip address %s' % value

     return (int(bytes[0]) << 24) | (int(bytes[1]) << 16) | \
            (int(bytes[2]) << 8)  | (int(bytes[3]) << 0)

 def toIpNetmask(value):
     if not isinstance(value, str):
         raise TypeError, "wrong type '%s' should be str" % type(value)

     (ip, netmask) = value.split('/')
     ip = toIpAddress(ip)
     netmaskParts = netmask.split('.')
     if len(netmaskParts) == 1:
         if not 0 <= int(netmask) <= 32:
             raise ValueError, 'invalid netmask %s' % netmask
         return (ip, int(netmask))
     elif len(netmaskParts) == 4:
         netmaskNum = toIpAddress(netmask)
         if netmaskNum == 0:
             return (ip, 0)
         testVal = 0
         for i in range(32):
             testVal |= (1 << (31 - i))
             if testVal == netmaskNum:
                 return (ip, i + 1)
         raise ValueError, 'invalid netmask %s' % netmask
     else:
         raise ValueError, 'invalid netmask %s' % netmask

 def toIpWithPort(value):
     if not isinstance(value, str):
         raise TypeError, "wrong type '%s' should be str" % type(value)

     (ip, port) = value.split(':')
     ip = toIpAddress(ip)
     if not 0 <= int(port) <= 0xffff:
         raise ValueError, 'invalid port %s' % port
     return (ip, int(port))

 def toVoltage(value):
     if not isinstance(value, str):
         raise TypeError, "wrong type '%s' should be str" % type(value)

     if value.endswith('mV'):
         return float(value[:-2]) * milli
     elif value.endswith('V'):
         return float(value[:-1])

     raise ValueError, "cannot convert '%s' to voltage" % value

 def toCurrent(value):
     if not isinstance(value, str):
         raise TypeError, "wrong type '%s' should be str" % type(value)

     if value.endswith('A'):
         return toFloat(value[:-1])

     raise ValueError, "cannot convert '%s' to current" % value
	# Copyright (c) 2005 The Regents of The University of Michigan
	# Copyright (c) 2010 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.
	#
	# Authors: Nathan Binkert
	# Gabe Black

	# 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 toInteger(value):
	value = toFloat(value)
	result = long(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 anyToLatency(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 anyToFrequency(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)
	return val
	except ValueError:
	pass

	try:
	val = toLatency(value)
	if val != 0:
	val = 1 / val
	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 long(value[:-2]) * pebi
	elif value.endswith('TB'):
	return long(value[:-2]) * tebi
	elif value.endswith('GB'):
	return long(value[:-2]) * gibi
	elif value.endswith('MB'):
	return long(value[:-2]) * mebi
	elif value.endswith('kB'):
	return long(value[:-2]) * kibi
	elif value.endswith('B'):
	return long(value[:-1])

	raise ValueError, "cannot convert '%s' to memory size" % value

	def toIpAddress(value):
	if not isinstance(value, str):
	raise TypeError, "wrong type '%s' should be str" % type(value)

	bytes = value.split('.')
	if len(bytes) != 4:
	raise ValueError, 'invalid ip address %s' % value

	for byte in bytes:
	if not 0 <= int(byte) <= 0xff:
	raise ValueError, 'invalid ip address %s' % value

	return (int(bytes[0]) << 24) \| (int(bytes[1]) << 16) \| \
	(int(bytes[2]) << 8) \| (int(bytes[3]) << 0)

	def toIpNetmask(value):
	if not isinstance(value, str):
	raise TypeError, "wrong type '%s' should be str" % type(value)

	(ip, netmask) = value.split('/')
	ip = toIpAddress(ip)
	netmaskParts = netmask.split('.')
	if len(netmaskParts) == 1:
	if not 0 <= int(netmask) <= 32:
	raise ValueError, 'invalid netmask %s' % netmask
	return (ip, int(netmask))
	elif len(netmaskParts) == 4:
	netmaskNum = toIpAddress(netmask)
	if netmaskNum == 0:
	return (ip, 0)
	testVal = 0
	for i in range(32):
	testVal \|= (1 << (31 - i))
	if testVal == netmaskNum:
	return (ip, i + 1)
	raise ValueError, 'invalid netmask %s' % netmask
	else:
	raise ValueError, 'invalid netmask %s' % netmask

	def toIpWithPort(value):
	if not isinstance(value, str):
	raise TypeError, "wrong type '%s' should be str" % type(value)

	(ip, port) = value.split(':')
	ip = toIpAddress(ip)
	if not 0 <= int(port) <= 0xffff:
	raise ValueError, 'invalid port %s' % port
	return (ip, int(port))

	def toVoltage(value):
	if not isinstance(value, str):
	raise TypeError, "wrong type '%s' should be str" % type(value)

	if value.endswith('mV'):
	return float(value[:-2]) * milli
	elif value.endswith('V'):
	return float(value[:-1])

	raise ValueError, "cannot convert '%s' to voltage" % value

	def toCurrent(value):
	if not isinstance(value, str):
	raise TypeError, "wrong type '%s' should be str" % type(value)

	if value.endswith('A'):
	return toFloat(value[:-1])

	raise ValueError, "cannot convert '%s' to current" % value