src/python/m5/__init__.py

   1 # Copyright (c) 2005 The Regents of The University of Michigan
   2 # All rights reserved.
   3 #
   4 # Redistribution and use in source and binary forms, with or without
   5 # modification, are permitted provided that the following conditions are
   6 # met: redistributions of source code must retain the above copyright
   7 # notice, this list of conditions and the following disclaimer;
   8 # redistributions in binary form must reproduce the above copyright
   9 # notice, this list of conditions and the following disclaimer in the
  10 # documentation and/or other materials provided with the distribution;
  11 # neither the name of the copyright holders nor the names of its
  12 # contributors may be used to endorse or promote products derived from
  13 # this software without specific prior written permission.
  14 #
  15 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  16 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  17 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  18 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  19 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  21 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 #
  27 # Authors: Nathan Binkert
  28 #          Steve Reinhardt
  29
  30 import atexit, os, sys
  31
  32 # import the SWIG-wrapped main C++ functions
  33 import cc_main
  34 # import a few SWIG-wrapped items (those that are likely to be used
  35 # directly by user scripts) completely into this module for
  36 # convenience
  37 from cc_main import simulate, SimLoopExitEvent
  38
  39 # import the m5 compile options
  40 import defines
  41
  42 # define this here so we can use it right away if necessary
  43 def panic(string):
  44     print >>sys.stderr, 'panic:', string
  45     sys.exit(1)
  46
  47 # force scalars to one-element lists for uniformity
  48 def makeList(objOrList):
  49     if isinstance(objOrList, list):
  50         return objOrList
  51     return [objOrList]
  52
  53 # Prepend given directory to system module search path.  We may not
  54 # need this anymore if we can structure our config library more like a
  55 # Python package.
  56 def AddToPath(path):
  57     # if it's a relative path and we know what directory the current
  58     # python script is in, make the path relative to that directory.
  59     if not os.path.isabs(path) and sys.path[0]:
  60         path = os.path.join(sys.path[0], path)
  61     path = os.path.realpath(path)
  62     # sys.path[0] should always refer to the current script's directory,
  63     # so place the new dir right after that.
  64     sys.path.insert(1, path)
  65
  66 # make a SmartDict out of the build options for our local use
  67 import smartdict
  68 build_env = smartdict.SmartDict()
  69 build_env.update(defines.m5_build_env)
  70
  71 # make a SmartDict out of the OS environment too
  72 env = smartdict.SmartDict()
  73 env.update(os.environ)
  74
  75 # The final hook to generate .ini files.  Called from the user script
  76 # once the config is built.
  77 def instantiate(root):
  78     params.ticks_per_sec = float(root.clock.frequency)
  79     root.unproxy_all()
  80     # ugly temporary hack to get output to config.ini
  81     sys.stdout = file(os.path.join(options.outdir, 'config.ini'), 'w')
  82     root.print_ini()
  83     sys.stdout.close() # close config.ini
  84     sys.stdout = sys.__stdout__ # restore to original
  85     cc_main.loadIniFile(resolveSimObject)  # load config.ini into C++
  86     root.createCCObject()
  87     root.connectPorts()
  88     cc_main.finalInit()
  89     noDot = True # temporary until we fix dot
  90     if not noDot:
  91        dot = pydot.Dot()
  92        instance.outputDot(dot)
  93        dot.orientation = "portrait"
  94        dot.size = "8.5,11"
  95        dot.ranksep="equally"
  96        dot.rank="samerank"
  97        dot.write("config.dot")
  98        dot.write_ps("config.ps")
  99
 100 # Export curTick to user script.
 101 def curTick():
 102     return cc_main.cvar.curTick
 103
 104 # register our C++ exit callback function with Python
 105 atexit.register(cc_main.doExitCleanup)
 106
 107 # This loops until all objects have been fully drained.
 108 def doDrain(root):
 109     all_drained = drain(root)
 110     while (not all_drained):
 111         all_drained = drain(root)
 112
 113 # Tries to drain all objects.  Draining might not be completed unless
 114 # all objects return that they are drained on the first call.  This is
 115 # because as objects drain they may cause other objects to no longer
 116 # be drained.
 117 def drain(root):
 118     all_drained = False
 119     drain_event = cc_main.createCountedDrain()
 120     unready_objects = root.startDrain(drain_event, True)
 121     # If we've got some objects that can't drain immediately, then simulate
 122     if unready_objects > 0:
 123         drain_event.setCount(unready_objects)
 124         simulate()
 125     else:
 126         all_drained = True
 127     cc_main.cleanupCountedDrain(drain_event)
 128     return all_drained
 129
 130 def resume(root):
 131     root.resume()
 132
 133 def checkpoint(root, dir):
 134     if not isinstance(root, objects.Root):
 135         raise TypeError, "Object is not a root object. Checkpoint must be called on a root object."
 136     doDrain(root)
 137     print "Writing checkpoint"
 138     cc_main.serializeAll(dir)
 139     resume(root)
 140
 141 def restoreCheckpoint(root, dir):
 142     print "Restoring from checkpoint"
 143     cc_main.unserializeAll(dir)
 144     resume(root)
 145
 146 def changeToAtomic(system):
 147     if not isinstance(system, objects.Root) and not isinstance(system, objects.System):
 148         raise TypeError, "Object is not a root or system object.  Checkpoint must be "
 149         "called on a root object."
 150     doDrain(system)
 151     print "Changing memory mode to atomic"
 152     system.changeTiming(cc_main.SimObject.Atomic)
 153
 154 def changeToTiming(system):
 155     if not isinstance(system, objects.Root) and not isinstance(system, objects.System):
 156         raise TypeError, "Object is not a root or system object.  Checkpoint must be "
 157         "called on a root object."
 158     doDrain(system)
 159     print "Changing memory mode to timing"
 160     system.changeTiming(cc_main.SimObject.Timing)
 161
 162 def switchCpus(cpuList):
 163     print "switching cpus"
 164     if not isinstance(cpuList, list):
 165         raise RuntimeError, "Must pass a list to this function"
 166     for i in cpuList:
 167         if not isinstance(i, tuple):
 168             raise RuntimeError, "List must have tuples of (oldCPU,newCPU)"
 169
 170     [old_cpus, new_cpus] = zip(*cpuList)
 171
 172     for cpu in old_cpus:
 173         if not isinstance(cpu, objects.BaseCPU):
 174             raise TypeError, "%s is not of type BaseCPU" % cpu
 175     for cpu in new_cpus:
 176         if not isinstance(cpu, objects.BaseCPU):
 177             raise TypeError, "%s is not of type BaseCPU" % cpu
 178
 179     # Drain all of the individual CPUs
 180     drain_event = cc_main.createCountedDrain()
 181     unready_cpus = 0
 182     for old_cpu in old_cpus:
 183         unready_cpus += old_cpu.startDrain(drain_event, False)
 184     # If we've got some objects that can't drain immediately, then simulate
 185     if unready_cpus > 0:
 186         drain_event.setCount(unready_cpus)
 187         simulate()
 188     cc_main.cleanupCountedDrain(drain_event)
 189     # Now all of the CPUs are ready to be switched out
 190     for old_cpu in old_cpus:
 191         old_cpu._ccObject.switchOut()
 192     index = 0
 193     for new_cpu in new_cpus:
 194         new_cpu.takeOverFrom(old_cpus[index])
 195         new_cpu._ccObject.resume()
 196         index += 1
 197
 198 # Since we have so many mutual imports in this package, we should:
 199 # 1. Put all intra-package imports at the *bottom* of the file, unless
 200 #    they're absolutely needed before that (for top-level statements
 201 #    or class attributes).  Imports of "trivial" packages that don't
 202 #    import other packages (e.g., 'smartdict') can be at the top.
 203 # 2. Never use 'from foo import *' on an intra-package import since
 204 #    you can get the wrong result if foo is only partially imported
 205 #    at the point you do that (i.e., because foo is in the middle of
 206 #    importing *you*).
 207 from main import options
 208 import objects
 209 import params
 210 from SimObject import resolveSimObject