def __init__(self,
tank_init=[1, 1],
injector_init=[1, 1],
cc_init=[1, 1],
nozzle_init=[1, 1]):
self.Tank = Tank(tank_init)
self.Injector = Injector(injector_init)
self.cc = CombustionChamber(cc_init)
def __init__(self):
# The order of initialisation here reflects the hierarchy we are using
# For now, all properties are hard-coded, rather than inputs
self.Tank = Tank()
self.Injector = Injector()
self.CombustionChamber = CombustionChamber()
self.Nozzle = Nozzle()
self.t = 0
#self.T_tank = 0
#self.rho_tank_liquid = 0
self.T_cc = 0
#self.T_post_comb = 0 #cp = combustion products
self.P_cc = 0 #cp = combustion products
self.m_dot_ox = 0
self.m_dot_fuel = 0
self.m_dot_choke = 0
def __init__(self):
'''
Constructor
'''
self.main_board = Board(GameRules.grid_size)
self.injector = Injector()
self.gen_number = 0 # to keep track of which generation we are currently in
self.born_cells = 0 # keep track of cells that are born
self.died_cells = 0 # keep track of cells that die
self.running = True # keep track of the simulation status
class CommandLineInjector:
def __init__(self):
if len(sys.argv) < 2:
print "No method call, can't run"
sys.exit(0)
self.op = sys.argv[1]
params = {}
for i in range(2, len(sys.argv)):
if sys.argv[i][0:len("--")] == "--":
params[sys.argv[i][len("--"):sys.argv[i].find("=")]] = sys.argv[i][sys.argv[i].find("=") + 1:]
elif sys.argv[i][0] == '-':
params[sys.argv[i][len("-"):sys.argv[i].find("=")]] = sys.argv[i][sys.argv[i].find("=") + 1:]
self.injector = Injector(params)
def initialize(self):
pass
def run(self, runner):
self.injector.run(self.op, runner)
def addInstantiation(self, key, value):
self.injector.addInstantiation(key, value)
return self
def addMethod(self, method):
self.injector.methods.append(method)
return self
def addClass(self, key, clazz, paramMapping = {}):
self.injector.addToClassMap(key, clazz, paramMapping)
return self
def __init__(self):
if len(sys.argv) < 2:
print "No method call, can't run"
sys.exit(0)
self.op = sys.argv[1]
params = {}
for i in range(2, len(sys.argv)):
if sys.argv[i][0:len("--")] == "--":
params[sys.argv[i][len("--"):sys.argv[i].find("=")]] = sys.argv[i][sys.argv[i].find("=") + 1:]
elif sys.argv[i][0] == '-':
params[sys.argv[i][len("-"):sys.argv[i].find("=")]] = sys.argv[i][sys.argv[i].find("=") + 1:]
self.injector = Injector(params)
def Injectors(self):
# Injectors[PEPos] = (Injector Object)
injectors = [None] * self.AmountOfPEs
if self.AllocationMap is None:
return injectors
for PEinPlatform in self.PEs:
injectors[PEinPlatform.PEPos] = Injector(
PEPos=PEinPlatform.PEPos,
Thread=self.AllocationMap[PEinPlatform.PEPos],
InjectorClockFrequency=self.ReferenceClock)
return injectors
if len(app['InjRate']) == 1:
InjRate = [int(app['InjRate'][0])] * (int(numtask))
else:
InjRate = app['InjRate']
for task in range(int(numtask)):
#Se o trafego for randomico, guardar apenas os vizinhos da tarefa
SourcePEs = PEpos[:] #Copia a lista de todos
SourcePEs.pop(task) #Se retira da lista, sobrando apenas os vizinhos
TargetPEs = PEpos[:] #Copia a lista de todos
TargetPEs.pop(task) #Se retira da lista, sobrando apenas os vizinhos
TargetPayloadSize_aux = TargetPayloadSize[:]
TargetPayloadSize_aux.pop(task)
inj = Injector(PEPos=PEpos[task],
APPID=appID,
ThreadID=task,
InjectionRate=InjRate[task],
SourcePEs=SourcePEs,
SourcePayloadSize=SourcePayloadSize,
TargetPEs=TargetPEs,
TargetPayloadSize=TargetPayloadSize)
f = open('output' + str(appID) + str(task) + '.json', 'w')
f.write(inj.toJSON())
f.close()
#print(PEpos[task])
#appID += 1
class Game(object):
'''
The main game logic
'''
def __init__(self):
'''
Constructor
'''
self.main_board = Board(GameRules.grid_size)
self.injector = Injector()
self.gen_number = 0 # to keep track of which generation we are currently in
self.born_cells = 0 # keep track of cells that are born
self.died_cells = 0 # keep track of cells that die
self.running = True # keep track of the simulation status
def pause(self):
self.running = False
def start(self):
while self.gen_number < 130: #until there is a way to stop it
self.run_life()
self.gen_number += 1
self.display()
if GameRules.injector and self.gen_number % GameRules.injector_gens == 0:
self.run_injector()
time.sleep(GameRules.time_between_gen)
def run_life(self):
'''
checks every cell in the board to see if it must be turned on or off
'''
model_board = copy.deepcopy(self.main_board) # we make a copy so as to not run into crazy problems :)
for node in self.main_board.get_node_list():
neighbors = node.count_live_neighbors(model_board)
if neighbors == GameRules.cells_for_reproduction and not node.is_alive():
node.born()
self.born_cells += 1
elif neighbors > GameRules.cells_for_overpopulation and node.is_alive():
node.die()
self.died_cells += 1
elif neighbors < GameRules.cells_for_underpopulation and node.is_alive():
node.die()
self.died_cells += 1
def display(self):
os.system('cls' if os.name == 'nt' else 'clear')
print("Gen: " + str(self.gen_number) + " Born Cells: " + str(self.born_cells) + " Died Cells: " + str(self.died_cells))
print(self.main_board)
def run_injector(self):
self.injector.inject(self.main_board)
def toggle_cel(self, x, y):
'''
This is for manually changing the state of a cell
keep in mind that this alters the state of the 0 generation
'''
self.main_board.get_board()[y][x].toggle_life()
class Rocket:
DEBUG_VERBOSITY = 2
def __init__(self):
# The order of initialisation here reflects the hierarchy we are using
# For now, all properties are hard-coded, rather than inputs
self.Tank = Tank()
self.Injector = Injector()
self.CombustionChamber = CombustionChamber()
self.Nozzle = Nozzle()
self.t = 0
#self.T_tank = 0
#self.rho_tank_liquid = 0
self.T_cc = 0
#self.T_post_comb = 0 #cp = combustion products
self.P_cc = 0 #cp = combustion products
self.m_dot_ox = 0
self.m_dot_fuel = 0
self.m_dot_choke = 0
def simulate(self, dt=0.001, max_timesteps=1e6):
# Simulate until reach zero oxidiser/fuel mass, not based on final time
loop_ctr = 0
thrust_curve = []
self.initiate()
while self.Tank.m_ox > 0 and self.CombustionChamber.inner_radius < self.CombustionChamber.outer_radius \
and loop_ctr < max_timesteps:
if self.DEBUG_VERBOSITY > 0:
print("t = ", dt * loop_ctr)
# converge is configured to return -1 in order to end simulation
tmp = self.converge()
if tmp == -1:
break
self.update(dt)
loop_ctr += 1
thrust_curve.append(self.Nozzle.thrust)
if self.Tank.m_ox < 1e-5:
print("[Rocket.Simulate] Tank has emptied of oxidiser")
elif self.CombustionChamber.outer_radius - self.CombustionChamber.inner_radius < 1e-5:
print("[Rocket.Simulate] Fuel grain has burned away")
elif loop_ctr > max_timesteps:
print(
"[Rocket.Simulate: ERROR, minor] Simulator has exceeded max timesteps without emptying"
)
return thrust_curve
def initiate(self):
# Calculate m_dot_ox when ignition occurs
# Eventually we could change this to simulate the startup transient
# This assumes combustion is already occurring at steady state and
# that m_dot_ox is determined by the choke
self.m_dot_ox = self.Nozzle.get_mass_flow_rate(
self.CombustionChamber.pressure,
self.CombustionChamber.temperature)
#self.T_tank = self.Tank.T_tank
#self.rho_tank_liquid = self.Tank.rho_liquid
self.T_cc = self.CombustionChamber.temperature
#self.T_post_comb = 0
self.P_cc = 0
def update(self, dt):
self.Tank.update(dt, self.m_dot_ox) # change m_ox
# Tank.update is configured to set rho = -1 in certain cases to end simulation
if self.Tank.rho_liquid == -1:
return
#self.Injector.update(dt) # should do NOTHING
self.CombustionChamber.update(
dt, self.m_dot_fuel) # change m_fuel & r_fuel
#self.Nozzle.update(dt) # should do NOTHING
def converge(self):
#The second MAJOR function. After everything that depends EXPLICITLY on time
# has changed, call this function to "equilibrate" the various components. This should
# be done after every timestep
epsilon = 1000 # Percent change between steps
epsilon_min = 1e-3
converge_ctr = 0
while epsilon > epsilon_min:
# Does nothing
self.Tank.converge()
# Determine oxidiser mass flow rate based on the injector model
self.m_dot_ox = self.Injector.converge(self.Tank.T_tank, self.Tank.rho_liquid, \
self.CombustionChamber.temperature, self.CombustionChamber.pressure)
# Determine fuel mass flow rate based on CC model
self.m_dot_fuel = self.CombustionChamber.converge(
self.m_dot_ox, self.m_dot_fuel)
# Determine, based on CC conditions, the choked flow rate
# We require that this choked rate be equal to the total flow rate
m_dot_choke = self.Nozzle.converge(
self.CombustionChamber.temperature,
self.CombustionChamber.pressure)
epsilon = abs(self.m_dot_ox + self.m_dot_fuel - m_dot_choke)
converge_ctr += 1
if self.DEBUG_VERBOSITY > 1:
print("***DEBUG*** [Rocket.converge] Steps to convergence = ",
converge_ctr)
print("***DEBUG*** [Rocket.converge] Convergence epsilon = ",
epsilon)
class BaseCPU(MemObject):
type = 'BaseCPU'
abstract = True
cxx_header = "cpu/base.hh"
cxx_exports = [
PyBindMethod("switchOut"),
PyBindMethod("takeOverFrom"),
PyBindMethod("switchedOut"),
PyBindMethod("flushTLBs"),
PyBindMethod("totalInsts"),
PyBindMethod("scheduleInstStop"),
PyBindMethod("scheduleLoadStop"),
PyBindMethod("getCurrentInstCount"),
]
@classmethod
def memory_mode(cls):
"""Which memory mode does this CPU require?"""
return 'invalid'
@classmethod
def require_caches(cls):
"""Does the CPU model require caches?
Some CPU models might make assumptions that require them to
have caches.
"""
return False
@classmethod
def support_take_over(cls):
"""Does the CPU model support CPU takeOverFrom?"""
return False
def takeOverFrom(self, old_cpu):
self._ccObject.takeOverFrom(old_cpu._ccObject)
system = Param.System(Parent.any, "system object")
cpu_id = Param.Int(-1, "CPU identifier")
socket_id = Param.Unsigned(0, "Physical Socket identifier")
numThreads = Param.Unsigned(1, "number of HW thread contexts")
function_trace = Param.Bool(False, "Enable function trace")
function_trace_start = Param.Tick(0, "Tick to start function trace")
checker = Param.BaseCPU(NULL, "checker CPU")
syscallRetryLatency = Param.Cycles(10000, "Cycles to wait until retry")
do_checkpoint_insts = Param.Bool(True,
"enable checkpoint pseudo instructions")
do_statistics_insts = Param.Bool(True,
"enable statistics pseudo instructions")
profile = Param.Latency('0ns', "trace the kernel stack")
do_quiesce = Param.Bool(True, "enable quiesce instructions")
wait_for_remote_gdb = Param.Bool(False,
"Wait for a remote GDB connection");
workload = VectorParam.Process([], "processes to run")
if buildEnv['TARGET_ISA'] == 'sparc':
dtb = Param.SparcTLB(SparcTLB(), "Data TLB")
itb = Param.SparcTLB(SparcTLB(), "Instruction TLB")
interrupts = VectorParam.SparcInterrupts(
[], "Interrupt Controller")
isa = VectorParam.SparcISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'alpha':
dtb = Param.AlphaTLB(AlphaDTB(), "Data TLB")
itb = Param.AlphaTLB(AlphaITB(), "Instruction TLB")
interrupts = VectorParam.AlphaInterrupts(
[], "Interrupt Controller")
isa = VectorParam.AlphaISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'x86':
dtb = Param.X86TLB(X86TLB(), "Data TLB")
itb = Param.X86TLB(X86TLB(), "Instruction TLB")
interrupts = VectorParam.X86LocalApic([], "Interrupt Controller")
isa = VectorParam.X86ISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'mips':
dtb = Param.MipsTLB(MipsTLB(), "Data TLB")
itb = Param.MipsTLB(MipsTLB(), "Instruction TLB")
interrupts = VectorParam.MipsInterrupts(
[], "Interrupt Controller")
isa = VectorParam.MipsISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'arm':
dtb = Param.ArmTLB(ArmTLB(), "Data TLB")
itb = Param.ArmTLB(ArmTLB(), "Instruction TLB")
istage2_mmu = Param.ArmStage2MMU(ArmStage2IMMU(), "Stage 2 trans")
dstage2_mmu = Param.ArmStage2MMU(ArmStage2DMMU(), "Stage 2 trans")
interrupts = VectorParam.ArmInterrupts(
[], "Interrupt Controller")
isa = VectorParam.ArmISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'power':
UnifiedTLB = Param.Bool(True, "Is this a Unified TLB?")
dtb = Param.PowerTLB(PowerTLB(), "Data TLB")
itb = Param.PowerTLB(PowerTLB(), "Instruction TLB")
interrupts = VectorParam.PowerInterrupts(
[], "Interrupt Controller")
isa = VectorParam.PowerISA([ isa_class() ], "ISA instance")
elif buildEnv['TARGET_ISA'] == 'riscv':
dtb = Param.RiscvTLB(RiscvTLB(), "Data TLB")
itb = Param.RiscvTLB(RiscvTLB(), "Instruction TLB")
interrupts = VectorParam.RiscvInterrupts(
[], "Interrupt Controller")
isa = VectorParam.RiscvISA([ isa_class() ], "ISA instance")
else:
print "Don't know what TLB to use for ISA %s" % \
buildEnv['TARGET_ISA']
sys.exit(1)
max_insts_all_threads = Param.Counter(0,
"terminate when all threads have reached this inst count")
max_insts_any_thread = Param.Counter(0,
"terminate when any thread reaches this inst count")
simpoint_start_insts = VectorParam.Counter([],
"starting instruction counts of simpoints")
max_loads_all_threads = Param.Counter(0,
"terminate when all threads have reached this load count")
max_loads_any_thread = Param.Counter(0,
"terminate when any thread reaches this load count")
progress_interval = Param.Frequency('0Hz',
"frequency to print out the progress message")
switched_out = Param.Bool(False,
"Leave the CPU switched out after startup (used when switching " \
"between CPU models)")
tracer = Param.InstTracer(default_tracer, "Instruction tracer")
injector = Param.Injector(Injector(), "fault injector")
icache_port = MasterPort("Instruction Port")
dcache_port = MasterPort("Data Port")
_cached_ports = ['icache_port', 'dcache_port']
if buildEnv['TARGET_ISA'] in ['x86', 'arm']:
_cached_ports += ["itb.walker.port", "dtb.walker.port"]
_uncached_slave_ports = []
_uncached_master_ports = []
if buildEnv['TARGET_ISA'] == 'x86':
_uncached_slave_ports += ["interrupts[0].pio",
"interrupts[0].int_slave"]
_uncached_master_ports += ["interrupts[0].int_master"]
def createInterruptController(self):
if buildEnv['TARGET_ISA'] == 'sparc':
self.interrupts = [SparcInterrupts() for i in xrange(self.numThreads)]
elif buildEnv['TARGET_ISA'] == 'alpha':
self.interrupts = [AlphaInterrupts() for i in xrange(self.numThreads)]
elif buildEnv['TARGET_ISA'] == 'x86':
self.apic_clk_domain = DerivedClockDomain(clk_domain =
Parent.clk_domain,
clk_divider = 16)
self.interrupts = [X86LocalApic(clk_domain = self.apic_clk_domain,
pio_addr=0x2000000000000000)
for i in xrange(self.numThreads)]
_localApic = self.interrupts
elif buildEnv['TARGET_ISA'] == 'mips':
self.interrupts = [MipsInterrupts() for i in xrange(self.numThreads)]
elif buildEnv['TARGET_ISA'] == 'arm':
self.interrupts = [ArmInterrupts() for i in xrange(self.numThreads)]
elif buildEnv['TARGET_ISA'] == 'power':
self.interrupts = [PowerInterrupts() for i in xrange(self.numThreads)]
elif buildEnv['TARGET_ISA'] == 'riscv':
self.interrupts = \
[RiscvInterrupts() for i in xrange(self.numThreads)]
else:
print "Don't know what Interrupt Controller to use for ISA %s" % \
buildEnv['TARGET_ISA']
sys.exit(1)
def connectCachedPorts(self, bus):
for p in self._cached_ports:
exec('self.%s = bus.slave' % p)
def connectUncachedPorts(self, bus):
for p in self._uncached_slave_ports:
exec('self.%s = bus.master' % p)
for p in self._uncached_master_ports:
exec('self.%s = bus.slave' % p)
def connectAllPorts(self, cached_bus, uncached_bus = None):
self.connectCachedPorts(cached_bus)
if not uncached_bus:
uncached_bus = cached_bus
self.connectUncachedPorts(uncached_bus)
def addPrivateSplitL1Caches(self, ic, dc, iwc = None, dwc = None):
self.icache = ic
self.dcache = dc
self.icache_port = ic.cpu_side
self.dcache_port = dc.cpu_side
self._cached_ports = ['icache.mem_side', 'dcache.mem_side']
if buildEnv['TARGET_ISA'] in ['x86', 'arm']:
if iwc and dwc:
self.itb_walker_cache = iwc
self.dtb_walker_cache = dwc
self.itb.walker.port = iwc.cpu_side
self.dtb.walker.port = dwc.cpu_side
self._cached_ports += ["itb_walker_cache.mem_side", \
"dtb_walker_cache.mem_side"]
else:
self._cached_ports += ["itb.walker.port", "dtb.walker.port"]
# Checker doesn't need its own tlb caches because it does
# functional accesses only
if self.checker != NULL:
self._cached_ports += ["checker.itb.walker.port", \
"checker.dtb.walker.port"]
def addTwoLevelCacheHierarchy(self, ic, dc, l2c, iwc = None, dwc = None):
self.addPrivateSplitL1Caches(ic, dc, iwc, dwc)
self.toL2Bus = L2XBar()
self.connectCachedPorts(self.toL2Bus)
self.l2cache = l2c
self.toL2Bus.master = self.l2cache.cpu_side
self._cached_ports = ['l2cache.mem_side']
def createThreads(self):
self.isa = [ isa_class() for i in xrange(self.numThreads) ]
if self.checker != NULL:
self.checker.createThreads()
def addCheckerCpu(self):
pass
