From c393a51f4a00e88e7a72ad2c7bd56d19194f0b6a Mon Sep 17 00:00:00 2001
From: Nathan Binkert <binkertn@umich.edu>
Date: Fri, 11 Mar 2005 18:47:11 -0500
Subject: [PATCH] move the conversion stuff that was in
 configs/kernel/Config.py into the m5 package as convert.py add a smartdict
 class which stores strings and can intelligently interpret those string
 variables as several other types. make the env dict use the smartdict class

python/m5/config.py:
    move a bunch of conversion functions into convert.py
    turn the env dict into a smartdict
    adapt the _CheckedInt stuff to deal with derived types
python/m5/objects/BaseCPU.mpy:
    env is now a smartdict and can properly convert to bool

--HG--
extra : convert_revision : 8abcd35a5ab14b82f280aea59020953869e33365
---
 python/m5/config.py           |  17 ++--
 python/m5/convert.py          | 181 ++++++++++++++++++++++++++++++++++
 python/m5/objects/BaseCPU.mpy |   2 +-
 python/m5/smartdict.py        |  85 ++++++++++++++++
 4 files changed, 276 insertions(+), 9 deletions(-)
 create mode 100644 python/m5/convert.py
 create mode 100644 python/m5/smartdict.py

diff --git a/python/m5/config.py b/python/m5/config.py
index 33e329f3f..2c5a70b25 100644
--- a/python/m5/config.py
+++ b/python/m5/config.py
@@ -28,6 +28,8 @@ from __future__ import generators
 import os, re, sys, types, inspect
 
 from mpy_importer import AddToPath, LoadMpyFile
+from smartdict import SmartDict
+from convert import *
 
 noDot = False
 try:
@@ -35,7 +37,7 @@ try:
 except:
     noDot = True
 
-env = {}
+env = SmartDict()
 env.update(os.environ)
 
 def panic(string):
@@ -976,18 +978,17 @@ VectorParam = _VectorParamProxy(None)
 # Integer parameter type.
 class _CheckedInt(object):
     def _convert(cls, value):
-        t = type(value)
-        if t == bool:
+        if isinstance(value, bool):
             return int(value)
 
-        if t != int and t != long and t != float and t != str:
-            raise TypeError, 'Integer parameter of invalid type %s' % t
+        if not isinstance(value, (int, long, float, str)):
+            raise TypeError, 'Integer param of invalid type %s' % type(value)
 
-        if t == str or t == float:
-            value = long(value)
+        if isinstance(value, (str, float)):
+            value = long(float(value))
 
         if not cls._min <= value <= cls._max:
-            raise TypeError, 'Integer parameter out of bounds %d < %d < %d' % \
+            raise TypeError, 'Integer param out of bounds %d < %d < %d' % \
                   (cls._min, value, cls._max)
 
         return value
diff --git a/python/m5/convert.py b/python/m5/convert.py
new file mode 100644
index 000000000..b3f34e4ab
--- /dev/null
+++ b/python/m5/convert.py
@@ -0,0 +1,181 @@
+# 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 to_integer(value):
+    if not isinstance(value, str):
+        result = int(value)
+    elif value.endswith('Ei'):
+        result = int(value[:-2]) * exbi
+    elif value.endswith('Pi'):
+        result = int(value[:-2]) * pebi
+    elif value.endswith('Ti'):
+        result = int(value[:-2]) * tebi
+    elif value.endswith('Gi'):
+        result = int(value[:-2]) * gibi
+    elif value.endswith('Mi'):
+        result = int(value[:-2]) * mebi
+    elif value.endswith('ki'):
+        result = int(value[:-2]) * kibi
+    elif value.endswith('E'):
+        result = int(value[:-1]) * exa
+    elif value.endswith('P'):
+        result = int(value[:-1]) * peta
+    elif value.endswith('T'):
+        result = int(value[:-1]) * tera
+    elif value.endswith('G'):
+        result = int(value[:-1]) * giga
+    elif value.endswith('M'):
+        result = int(value[:-1]) * mega
+    elif value.endswith('k'):
+        result = int(value[:-1]) * kilo
+    elif value.endswith('m'):
+        result = int(value[:-1]) * milli
+    elif value.endswith('u'):
+        result = int(value[:-1]) * micro
+    elif value.endswith('n'):
+        result = int(value[:-1]) * nano
+    elif value.endswith('p'):
+        result = int(value[:-1]) * pico
+    elif value.endswith('f'):
+        result = int(value[:-1]) * femto
+    else:
+        result = int(value)
+
+    return result
+
+def to_bool(val):
+    t = type(val)
+    if t == bool:
+        return val
+
+    if t == None:
+        return False
+
+    if t == int or t == long:
+        return bool(val)
+
+    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
+
+    return to_integer(val) != 0
+
+def to_frequency(value):
+    if not isinstance(value, str):
+        result = float(value)
+    elif value.endswith('THz'):
+        result = float(value[:-3]) * tera
+    elif value.endswith('GHz'):
+        result = float(value[:-3]) * giga
+    elif value.endswith('MHz'):
+        result = float(value[:-3]) * mega
+    elif value.endswith('kHz'):
+        result = float(value[:-3]) * kilo
+    elif value.endswith('Hz'):
+        result = float(value[:-2])
+    else:
+        result = float(value)
+
+    return result
+
+def to_latency(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
+    elif value.endswith('ns'):
+        result = float(value[:-2]) * nano
+    elif value.endswith('us'):
+        result = float(value[:-2]) * micro
+    elif value.endswith('ms'):
+        result = float(value[:-2]) * milli
+    elif value.endswith('s'):
+        result = float(value[:-1])
+    else:
+        result = float(value)
+
+    return result;
+
+def to_network_bandwidth(value):
+    if not isinstance(value, str):
+        result = float(value)
+    elif value.endswith('Tbps'):
+        result = float(value[:-3]) * tera
+    elif value.endswith('Gbps'):
+        result = float(value[:-3]) * giga
+    elif value.endswith('Mbps'):
+        result = float(value[:-3]) * mega
+    elif value.endswith('kbps'):
+        result = float(value[:-3]) * kilo
+    elif value.endswith('bps'):
+        result = float(value[:-2])
+    else:
+        result = float(value)
+
+    return result
+
+def to_memory_bandwidth(value):
+    if not isinstance(value, str):
+        result = int(value)
+    elif value.endswith('PB/s'):
+        result = int(value[:-4]) * pebi
+    elif value.endswith('TB/s'):
+        result = int(value[:-4]) * tebi
+    elif value.endswith('GB/s'):
+        result = int(value[:-4]) * gibi
+    elif value.endswith('MB/s'):
+        result = int(value[:-4]) * mebi
+    elif value.endswith('kB/s'):
+        result = int(value[:-4]) * kibi
+    elif value.endswith('B/s'):
+        result = int(value[:-3])
+    else:
+        result = int(value)
+
+    return result
+
+def to_memory_size(value):
+    if not isinstance(value, str):
+        result = int(value)
+    elif value.endswith('PB'):
+        result = int(value[:-2]) * pebi
+    elif value.endswith('TB'):
+        result = int(value[:-2]) * tebi
+    elif value.endswith('GB'):
+        result = int(value[:-2]) * gibi
+    elif value.endswith('MB'):
+        result = int(value[:-2]) * mebi
+    elif value.endswith('kB'):
+        result = int(value[:-2]) * kibi
+    elif value.endswith('B'):
+        result = int(value[:-1])
+    else:
+        result = int(value)
+
+    return result
diff --git a/python/m5/objects/BaseCPU.mpy b/python/m5/objects/BaseCPU.mpy
index 484fcccd6..be93e8ad1 100644
--- a/python/m5/objects/BaseCPU.mpy
+++ b/python/m5/objects/BaseCPU.mpy
@@ -4,7 +4,7 @@ simobj BaseCPU(SimObject):
     icache = Param.BaseMem(NULL, "L1 instruction cache object")
     dcache = Param.BaseMem(NULL, "L1 data cache object")
 
-    if Bool._convert(env.get('FULL_SYSTEM', 'False')):
+    if env.get('FULL_SYSTEM', 'False'):
         dtb = Param.AlphaDTB("Data TLB")
         itb = Param.AlphaITB("Instruction TLB")
         mem = Param.FunctionalMemory("memory")
diff --git a/python/m5/smartdict.py b/python/m5/smartdict.py
new file mode 100644
index 000000000..e282bc07b
--- /dev/null
+++ b/python/m5/smartdict.py
@@ -0,0 +1,85 @@
+from convert import *
+
+class SmartDict(dict):
+    class Proxy(str):
+        def __int__(self):
+            return int(to_integer(str(self)))
+        def __long__(self):
+            return long(to_integer(str(self)))
+        def __float__(self):
+            return float(to_integer(str(self)))
+        def __nonzero__(self):
+            return to_bool(str(self))
+        def convert(self, other):
+            t = type(other)
+            if t == bool:
+                return bool(self)
+            if t == int:
+                return int(self)
+            if t == long:
+                return long(self)
+            if t == float:
+                return float(self)
+            return str(self)
+        def __lt__(self, other):
+            return self.convert(other) < other
+        def __le__(self, other):
+            return self.convert(other) <= other
+        def __eq__(self, other):
+            return self.convert(other) == other
+        def __ne__(self, other):
+            return self.convert(other) != other
+        def __gt__(self, other):
+            return self.convert(other) > other
+        def __ge__(self, other):
+            return self.convert(other) >= other
+
+        def __add__(self, other):
+            return self.convert(other) + other
+        def __sub__(self, other):
+            return self.convert(other) - other
+        def __mul__(self, other):
+            return self.convert(other) * other
+        def __div__(self, other):
+            return self.convert(other) / other
+        def __truediv__(self, other):
+            return self.convert(other) / other
+
+        def __radd__(self, other):
+            return other + self.convert(other)
+        def __rsub__(self, other):
+            return other - self.convert(other)
+        def __rmul__(self, other):
+            return other * self.convert(other)
+        def __rdiv__(self, other):
+            return other / self.convert(other)
+        def __rtruediv__(self, other):
+            return other / self.convert(other)
+
+
+    def __getitem__(self, key):
+        return self.Proxy(dict.__getitem__(self, key))
+
+    def __setitem__(self, key, item):
+        dict.__setitem__(self, key, str(item))
+
+    def values(self):
+        return [ self.Proxy(v) for v in dict.values(self) ]
+
+    def itervalues(self):
+        for value in dict.itervalues(self):
+            yield self.Proxy(value)
+
+    def items(self):
+        return [ (k, self.Proxy(v)) for k,v in dict.items(self) ]
+
+    def iteritems(self):
+        for key,value in dict.iteritems(self):
+            yield key, self.Proxy(value)
+
+    def get(self, key, default=''):
+        return self.Proxy(dict.get(self, key, str(default)))
+
+    def setdefault(self, key, default=''):
+        return self.Proxy(dict.setdefault(self, key, str(default)))
+