Better handling of latency/frequency parameter types

python/m5/config.py:
    Addr is slightly different from memory size in that Addr
    will take non strings.
    Deal with the fact that the convert.toFoo functions only accept
    strings.
    Add RootFrequency as a special type for the Root.frequency
    parameter which is not scaled.
    Add ClockPeriod parameter type.
python/m5/convert.py:
    Be more strict about what's allowed.
    Only accept strings as inputs for these conversion functions.
    If the user wants to accept something else, they need to deal
    with the failure and convert other types on their own.
python/m5/objects/Bus.mpy:
    Use the new ClockPeriod parameter type
python/m5/objects/Root.mpy:
    Can't use integers for frequency anymore
python/m5/smartdict.py:
    rename SmartDict.Proxy to just Variable.  Create a new class
    UndefinedVariable that is returned when the user tries to get
    a variable that is not in the dict.  Undefined variable evaluates
    to false, and will cause an error elsewhere.

--HG--
extra : convert_revision : 1d55246fd1af65106f102396234827d6401ef9ce

1 files changed, 114 insertions, 91 deletions

diff --git a/python/m5/convert.py b/python/m5/convert.py
index 4a4492af7..6ccefd2fc 100644
--- a/python/m5/convert.py
+++ b/python/m5/convert.py
@@ -22,162 +22,185 @@ pebi = tebi * 1024
 exbi = pebi * 1024
 
 # memory size configuration stuff
-def toInteger(value):
+def toFloat(value):
     if not isinstance(value, str):
-        result = int(value)
-    elif value.endswith('Ei'):
-        result = int(value[:-2]) * exbi
+        raise TypeError, "wrong type '%s' should be str" % type(value)
+
+    if value.endswith('Ei'):
+        return float(value[:-2]) * exbi
     elif value.endswith('Pi'):
-        result = int(value[:-2]) * pebi
+        return float(value[:-2]) * pebi
     elif value.endswith('Ti'):
-        result = int(value[:-2]) * tebi
+        return float(value[:-2]) * tebi
     elif value.endswith('Gi'):
-        result = int(value[:-2]) * gibi
+        return float(value[:-2]) * gibi
     elif value.endswith('Mi'):
-        result = int(value[:-2]) * mebi
+        return float(value[:-2]) * mebi
     elif value.endswith('ki'):
-        result = int(value[:-2]) * kibi
+        return float(value[:-2]) * kibi
     elif value.endswith('E'):
-        result = int(value[:-1]) * exa
+        return float(value[:-1]) * exa
     elif value.endswith('P'):
-        result = int(value[:-1]) * peta
+        return float(value[:-1]) * peta
     elif value.endswith('T'):
-        result = int(value[:-1]) * tera
+        return float(value[:-1]) * tera
     elif value.endswith('G'):
-        result = int(value[:-1]) * giga
+        return float(value[:-1]) * giga
     elif value.endswith('M'):
-        result = int(value[:-1]) * mega
+        return float(value[:-1]) * mega
     elif value.endswith('k'):
-        result = int(value[:-1]) * kilo
+        return float(value[:-1]) * kilo
     elif value.endswith('m'):
-        result = int(value[:-1]) * milli
+        return float(value[:-1]) * milli
     elif value.endswith('u'):
-        result = int(value[:-1]) * micro
+        return float(value[:-1]) * micro
     elif value.endswith('n'):
-        result = int(value[:-1]) * nano
+        return float(value[:-1]) * nano
     elif value.endswith('p'):
-        result = int(value[:-1]) * pico
+        return float(value[:-1]) * pico
     elif value.endswith('f'):
-        result = int(value[:-1]) * femto
+        return float(value[:-1]) * femto
     else:
-        result = int(float(value))
+        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 toBool(val):
-    t = type(val)
-    if t == bool:
-        return val
+def toInteger(value):
+    value = toFloat(value)
+    result = int(value)
+    if value != result:
+        raise ValueError, "cannot convert '%s' to integer" % value
 
-    if t == None:
-        return False
+    return result
 
-    if t == int or t == long:
-        return bool(val)
+def toBool(value):
+    if not isinstance(value, str):
+        raise TypeError, "wrong type '%s' should be str" % type(value)
 
-    if t == str:
-        val = val.lower()
-        if val == "true" or val == "t" or val == "yes" or val == "y":
-            return True
-        elif val == "false" or val == "f" or val == "no" or val == "n":
-            return False
-        elif val == "":
-            return False
+    value = value.lower()
+    if value == "true" or value == "t" or value == "yes" or value == "y":
+        return True
+    elif value == "false" or value == "f" or value == "no" or value == "n":
+        return False
 
-    return toInteger(val) != 0
+    raise ValueError, "cannot convert '%s' to bool" % value
 
 def toFrequency(value):
     if not isinstance(value, str):
-        result = float(value)
-    elif value.endswith('THz'):
-        result = float(value[:-3]) * tera
+        raise TypeError, "wrong type '%s' should be str" % type(value)
+
+    if value.endswith('THz'):
+        return float(value[:-3]) * tera
     elif value.endswith('GHz'):
-        result = float(value[:-3]) * giga
+        return float(value[:-3]) * giga
     elif value.endswith('MHz'):
-        result = float(value[:-3]) * mega
+        return float(value[:-3]) * mega
     elif value.endswith('kHz'):
-        result = float(value[:-3]) * kilo
+        return float(value[:-3]) * kilo
     elif value.endswith('Hz'):
-        result = float(value[:-2])
-    else:
-        result = float(value)
+        return float(value[:-2])
 
-    return result
+    raise ValueError, "cannot convert '%s' to frequency" % value
 
 def toLatency(value):
     if not isinstance(value, str):
-        result = float(value)
-    elif value.endswith('c'):
-        result = float(value[:-1])
-    elif value.endswith('ps'):
-        result = float(value[:-2]) * pico
+        raise TypeError, "wrong type '%s' should be str" % type(value)
+
+    if value.endswith('ps'):
+        return float(value[:-2]) * pico
     elif value.endswith('ns'):
-        result = float(value[:-2]) * nano
+        return float(value[:-2]) * nano
     elif value.endswith('us'):
-        result = float(value[:-2]) * micro
+        return float(value[:-2]) * micro
     elif value.endswith('ms'):
-        result = float(value[:-2]) * milli
+        return float(value[:-2]) * milli
     elif value.endswith('s'):
-        result = float(value[:-1])
-    else:
-        result = float(value)
+        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
 
-    return result;
 
 def toNetworkBandwidth(value):
     if not isinstance(value, str):
-        result = float(value)
-    elif value.endswith('Tbps'):
-        result = float(value[:-3]) * tera
+        raise TypeError, "wrong type '%s' should be str" % type(value)
+
+    if value.endswith('Tbps'):
+        return float(value[:-3]) * tera
     elif value.endswith('Gbps'):
-        result = float(value[:-3]) * giga
+        return float(value[:-3]) * giga
     elif value.endswith('Mbps'):
-        result = float(value[:-3]) * mega
+        return float(value[:-3]) * mega
     elif value.endswith('kbps'):
-        result = float(value[:-3]) * kilo
+        return float(value[:-3]) * kilo
     elif value.endswith('bps'):
-        result = float(value[:-2])
+        return float(value[:-2])
     else:
-        result = float(value)
+        return float(value)
 
-    return result
+    raise ValueError, "cannot convert '%s' to network bandwidth" % value
 
 def toMemoryBandwidth(value):
     if not isinstance(value, str):
-        result = int(value)
-    elif value.endswith('PB/s'):
-        result = int(value[:-4]) * pebi
+        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'):
-        result = int(value[:-4]) * tebi
+        return float(value[:-4]) * tebi
     elif value.endswith('GB/s'):
-        result = int(value[:-4]) * gibi
+        return float(value[:-4]) * gibi
     elif value.endswith('MB/s'):
-        result = int(value[:-4]) * mebi
+        return float(value[:-4]) * mebi
     elif value.endswith('kB/s'):
-        result = int(value[:-4]) * kibi
+        return float(value[:-4]) * kibi
     elif value.endswith('B/s'):
-        result = int(value[:-3])
-    else:
-        result = int(value)
+        return float(value[:-3])
 
-    return result
+    raise ValueError, "cannot convert '%s' to memory bandwidth" % value
 
 def toMemorySize(value):
     if not isinstance(value, str):
-        result = int(value)
-    elif value.endswith('PB'):
-        result = int(value[:-2]) * pebi
+        raise TypeError, "wrong type '%s' should be str" % type(value)
+
+    if value.endswith('PB'):
+        return float(value[:-2]) * pebi
     elif value.endswith('TB'):
-        result = int(value[:-2]) * tebi
+        return float(value[:-2]) * tebi
     elif value.endswith('GB'):
-        result = int(value[:-2]) * gibi
+        return float(value[:-2]) * gibi
     elif value.endswith('MB'):
-        result = int(value[:-2]) * mebi
+        return float(value[:-2]) * mebi
     elif value.endswith('kB'):
-        result = int(value[:-2]) * kibi
+        return float(value[:-2]) * kibi
     elif value.endswith('B'):
-        result = int(value[:-1])
-    else:
-        result = int(value)
+        return float(value[:-1])
 
-    return result
+    raise ValueError, "cannot convert '%s' to memory size" % value