def test_runs(self):
for file in ["test.psm", "test_int.psm"]:
print("TESTING PSM FILE %s" % file)
self.a = Assembler(file)
self.a.parse()
# print the debug representation of each line in the test file
for line in self.a.instructions:
print(repr(line))
self.proc = Processor()
self.proc.set_instructions(self.a.convert())
executed = 0
start_time = time.time()
while not self.proc.outside_program():
self.proc.execute()
executed += 1
if (time.time() - start_time) > AssemblerTest.TIMEOUT:
raise TimeoutError("Simulation never finished within timeout %.1f" % (time.time() - start_time))
dur = time.time() - start_time
ops_per_sec = executed / dur
eff_khz = 2.0 / 1000.0 * ops_per_sec # on PicoBlaze, one operation takes two clocks
print("--- %8.3f seconds, %d ops ---" % (dur, executed))
print("--- %8.0f ops per sec ---" % ops_per_sec)
print("--- %8.1f KHz clock ---" % eff_khz)
self.assertTrue(True)
class ProcTest(unittest.TestCase):
def setUp(self):
self.processor = Processor()
def test_readCores_invalidData(self):
self.assertRaises(InvalidDataError, self.processor._readCores, None)
self.assertRaises(InvalidDataError, self.processor._readCores, '')
def test_readCores(self):
data = """cpu 2255 34 2290 22625563 6290 127 456
cpu0 1132 34 1441 11311718 3675 127 438
cpu1 1123 0 849 11313845 2614 0 18
intr 114930548 113199788 3 0 5 263 0 4 [... lots more numbers ...]
ctxt 1990473
btime 1062191376
processes 2915
procs_running 1
procs_blocked 0
"""
self.processor._readCores(data)
self.assertEquals(len(self.processor.cores), 2)
def test_readFreqs_invalidData(self):
self.assertRaises(InvalidDataError, self.processor._readFreqs, None)
self.assertRaises(InvalidDataError, self.processor._readFreqs, '')
def test_readFreqs(self):
data = """3600000 2089
3400000 136
3200000 34
3000000 67
2800000 172488
"""
self.processor._readFreqs(data)
freqs = [2800000, 3000000, 3200000, 3400000, 3600000]
self.assertEquals(self.processor._availableFreqs, freqs)
def exec(self, processor: Processor):
# retrieve the memory rows' binary directly without converting to decimal
reg_row = processor.memory.REGISTERS[self.register].values
if not self.literal:
# look up the register binary
bits = processor.memory.REGISTERS[self.argument].values
else:
# retrieve the converted literal as binary
bits = self.argument.values
zipped = zip(reg_row, bits)
bits = list(map(lambda t: self.operator(t[0], t[1]), zipped))
# set the memory row bits directly
processor.memory.REGISTERS[self.register].values = bits
# carry always set to 0 for these ops
processor.set_carry(False)
# increment pc
processor.manager.next()
def main():
proc = Processor()
proc.detect()
T_states = get_T_States(
proc.cores[0]) #assume all cores have the same T-states
print 'Starting...'
for i in T_states:
output = open('T%d.txt' % i, 'w')
print '-' * 30
print 'Setting T%d...' % i
for j in range(proc.getCoreCount()):
set_T_State(i, j)
print 'Executing Stress...'
stress = Stress()
stress.cmd([
'stress', '--cpu', '50', '--timeout',
'%ss' % experiment_interval
])
stress.start()
total_time = 0.0
while stress.isAlive():
t0 = time()
sleep(1)
proc.updateTemp()
elapsed = time() - t0
total_time += elapsed
string = ''
output.write('%d' % int(total_time))
for core in proc.cores:
string += 'Core%d: %2.1f ' % (core.number, core.temperature)
output.write(' %f' % core.temperature)
output.write('\n')
print string
output.close()
for j in range(proc.getCoreCount()):
set_T_State(0, j)
print 'Cooling down...'
sleep(cooldown_interval)
def main():
proc = Processor()
proc.detect()
freqs = proc.availableFreqs()
uc = UserspaceController(proc)
uc.setup()
print 'Starting...'
for i in freqs:
output = open('freq%d.txt' % i, 'w')
print '-' * 30
print 'Setting Frequency %d...' % i
uc.setSpeed(i)
print 'Executing Stress...'
stress = Stress()
stress.cmd([
'stress', '--cpu', '50', '--timeout',
'%ss' % experiment_interval
])
stress.start()
total_time = 0.0
while stress.isAlive():
t0 = time()
sleep(1)
proc.updateTemp()
elapsed = time() - t0
total_time += elapsed
string = ''
output.write('%d' % int(total_time))
for core in proc.cores:
string += 'Core%d: %2.1f ' % (core.number, core.temperature)
output.write(' %f' % core.temperature)
output.write('\n')
print string
output.close()
uc.setSpeed(0)
print 'Cooling down...'
sleep(cooldown_interval)
class ServerTest(unittest.TestCase):
core = Core()
proc = Processor()
proc.cores = [core]
server = Server()
server.processor = proc
server.processor.availableFreqs = [1.0]
cont = DVFSController(server)
server.dvfsCont = cont
server._status = Server.OFF
server.WAKE_UP_TIME = 0
def testTurnOn(self):
self.server.turnOn()
#if the server is already on, nothing should happen:
self.server.turnOn()
def testTurnOff(self):
self.server._status = Server.ON
self.server.turnOff()
#if the server is already off, nothing should happen:
self.server.turnOff()
def testSwitching(self):
'''
Switching a server ON, then OFF then ON again
'''
self.server.turnOn()
self.server.turnOff()
self.server.turnOn()
def testReadSensors(self):
s = Server()
core = Core()
s.processor.cores.append(core)
core = Core()
s.processor.cores.append(core)
s.updateSensors()
'''
def main():
proc = Processor()
proc.detect()
T_states = get_T_States(proc.cores[0]) #assume all cores have the same T-states
print 'Starting...'
for i in T_states:
output = open('T%d.txt' % i,'w')
print '-' * 30
print 'Setting T%d...' % i
for j in range(proc.getCoreCount()):
set_T_State(i,j)
print 'Executing Stress...'
stress = Stress()
stress.cmd(['stress', '--cpu', '50', '--timeout', '%ss' % experiment_interval])
stress.start()
total_time = 0.0
while stress.isAlive():
t0 = time()
sleep(1)
proc.updateTemp()
elapsed = time() - t0
total_time += elapsed
string = ''
output.write('%d' % int(total_time))
for core in proc.cores:
string += 'Core%d: %2.1f ' % (core.number,core.temperature)
output.write(' %f' % core.temperature)
output.write('\n')
print string
output.close()
for j in range(proc.getCoreCount()):
set_T_State(0,j)
print 'Cooling down...'
sleep(cooldown_interval)
def setUp(self):
self.proc = Processor()
self.r = Memory.MEMORY_IMPL(Memory.REGISTER_WIDTH)
class OperationTests(unittest.TestCase):
def setUp(self):
self.proc = Processor()
self.r = Memory.MEMORY_IMPL(Memory.REGISTER_WIDTH)
def test_arithmetic_ops_stress(self):
for key, o in op.ArithmeticOperation.OPS.items():
eq = op.ArithmeticOperation.TESTING_EQUIVALENTS[key]
for i in range(0, ITERATIONS):
v1 = random.randint(0, MAX)
v2 = random.randint(0, MAX)
self.proc.memory.set_register('s1', v1)
self.proc.memory.set_register('s2', v2)
op.ArithmeticOperation(o, ['s1', 's2']).exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), make_positive(eq(v1, v2)))
def test_arithmetic_ops_stress_const(self):
for key, o in op.ArithmeticOperation.OPS.items():
eq = op.ArithmeticOperation.TESTING_EQUIVALENTS[key]
for i in range(0, ITERATIONS):
v1 = random.randint(0, MAX)
c1 = random.randint(0, MAX)
self.proc.memory.set_register('s1', v1)
op.ArithmeticOperation(o, ['s1', c1]).exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), make_positive(eq(v1, c1)))
def test_arithmetic_ops_stress_sum(self):
for key, o in op.ArithmeticOperation.OPS.items():
eq = op.ArithmeticOperation.TESTING_EQUIVALENTS[key]
s = random.randint(1, 100)
self.proc.memory.set_register('s1', s)
for i in range(0, ITERATIONS):
v = random.randint(1, 10)
op.ArithmeticOperation(o, ['s1', v]).exec(self.proc)
s = make_positive(eq(s, v))
self.assertEqual(self.proc.memory.fetch_register('s1'), s)
def test_bitwise_ops_stress(self):
for o in op.BitwiseOperation.OPS.values():
for i in range(0, ITERATIONS):
v1 = random.randint(0, MAX)
self.proc.memory.set_register('s1', v1)
self.proc.set_carry(False)
operation = op.BitwiseOperation(o, ['s1'])
operation.exec(self.proc)
r = Memory.MEMORY_IMPL(Memory.REGISTER_WIDTH)
r.set_value(v1)
r.values = o(operation, r)
self.assertEqual(self.proc.memory.fetch_register('s1'), r.value)
def test_bitwise_ops(self):
dummy = op.BitwiseOperation(op.BitwiseOperation.OPS["RL"], ["DUMMY"])
dummy.proc = Processor()
self.r.set_value(32)
self.r.values = op.BitwiseOperation.shift_right_zero(dummy, self.r)
self.assertEqual(self.r.value, 16)
self.r.set_value(32)
self.r.values = op.BitwiseOperation.shift_left_zero(dummy, self.r)
self.assertEqual(self.r.value, 64)
for i in range(0, ITERATIONS):
v1 = random.randint(0, MAX)
c = ((v1 << 1) | ((v1 & 0x80) >> 7)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.rotate_left(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) | ((v1 & 1) << 7))
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.rotate_right(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_zero(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_zero(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE | 1) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_one(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F | (1 << 7)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_one(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE | (v1 & 1)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_x(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F | (v1 & 0x80)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_x(dummy, self.r)
self.assertEqual(self.r.value, c)
for b in [True, False]:
self.proc.set_carry(b)
c = (((v1 << 1) & 0xFE) | self.proc.external.carry) % (MAX + 1)
self.proc.memory.set_register('s1', v1)
o = op.BitwiseOperation(op.BitwiseOperation.OPS["SLA"], ['s1'])
o.exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), c)
self.proc.set_carry(b)
c = (((v1 >> 1) & 0x7F) | (self.proc.external.carry << 7)) % (MAX + 1)
self.proc.memory.set_register('s1', v1)
o = op.BitwiseOperation(op.BitwiseOperation.OPS["SRA"], ['s1'])
o.exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), c)
def test_call(self):
o = op.FlowOperation(op.FlowOperation.OPS["CALL"], [0x297])
o.exec(self.proc)
self.assertEqual(self.proc.manager.pc, 0x297)
o = op.FlowOperation(op.FlowOperation.OPS["CALL"], [0x0])
o.exec(self.proc)
self.assertEqual(self.proc.manager.pc, 0x0)
o = op.FlowOperation(op.FlowOperation.OPS["CALL"], [0x3FF])
o.exec(self.proc)
self.assertEqual(self.proc.manager.pc, 0x3FF)
o = op.FlowOperation(op.FlowOperation.OPS["CALL"], [0x400])
o.exec(self.proc)
self.assertEqual(self.proc.manager.pc, 0x0)
def setUp(self):
self.proc = Processor()
class ProcessorTests(unittest.TestCase):
def setUp(self):
self.proc = Processor()
def test_performance(self):
v1 = random.randint(0, MAX)
v2 = random.randint(0, MAX)
self.proc.memory.set_register('s1', v1)
self.proc.memory.set_register('s2', v2)
self.proc.memory.set_register('s4', v2)
for o in op.ArithmeticOperation.OPS.values():
for i in range(0, 330 // len(op.ArithmeticOperation.OPS)):
instr = op.ArithmeticOperation(o, ['s1', 's2'])
self.proc.add_instruction(instr)
for o in op.BitwiseOperation.OPS.values():
for i in range(0, 330 // len(op.BitwiseOperation.OPS)):
instr = op.BitwiseOperation(o, ['s1'])
self.proc.add_instruction(instr)
for o in op.LogicOperation.OPS.values():
for i in range(0, 330 // len(op.LogicOperation.OPS)):
instr = op.LogicOperation(o, ['s4', 's2'])
self.proc.add_instruction(instr)
# repeat these ops while s3 is not FF
self.proc.add_instruction(op.ArithmeticOperation(op.ArithmeticOperation.OPS["ADD"], ['s3', 1]))
self.proc.add_instruction(op.CompareOperation(op.CompareOperation.OPS["COMPARE"], ['s3', 0xFF]))
self.proc.add_instruction(op.FlowOperation(op.FlowOperation.OPS["JUMP NZ"], [0x000]))
executed = 0
start_time = time.time()
while not self.proc.outside_program():
self.proc.execute()
executed += 1
dur = time.time() - start_time
ops_per_sec = executed / dur
eff_khz = 2.0 / 1000.0 * ops_per_sec # on PicoBlaze, one operation takes two clocks
print("--- %8.3f seconds, %d ops ---" % (dur, executed))
print("--- %8.0f ops per sec ---" % ops_per_sec)
print("--- %8.1f KHz clock ---" % eff_khz)
self.assertGreater(ops_per_sec, 10000)
def test_compare_jump(self):
self.proc.add_instruction(op.ArithmeticOperation(op.ArithmeticOperation.OPS["ADD"], ['s1', 1]))
self.proc.add_instruction(op.CompareOperation(op.CompareOperation.OPS["COMPARE"], ['s1', 0xFF]))
self.proc.add_instruction(op.FlowOperation(op.FlowOperation.OPS["JUMP NZ"], [0x000]))
executed = 0
while not self.proc.outside_program():
self.proc.execute()
executed += 1
self.assertEqual(executed, 3*0xFF)
def test_data_ops(self):
self.proc.add_instruction(op.DataOperation(op.DataOperation.OPS["LOAD"], ['s1', 0xFF]))
self.proc.add_instruction(op.DataOperation(op.DataOperation.OPS["STORE"], ['s1', 0x10]))
self.proc.add_instruction(op.DataOperation(op.DataOperation.OPS["FETCH"], ['s2', 0x10]))
self.proc.add_instruction(op.DataOperation(op.DataOperation.OPS["OUTPUT"], ['s2', 0x10]))
executed = 0
while not self.proc.outside_program():
self.proc.execute()
executed += 1
self.assertEqual(self.proc.memory.fetch_register('s1'), 0xFF)
self.assertEqual(self.proc.memory.fetch_register('s2'), 0xFF)
self.assertEqual(self.proc.external.port_id, 0x10)
self.assertEqual(self.proc.external.out_port, 0xFF)
self.proc.add_instruction(op.DataOperation(op.DataOperation.OPS["INPUT"], ['s3', 0x40]))
self.proc.external.set_int_port(0x88)
self.proc.execute()
self.assertEqual(self.proc.external.port_id, 0x40)
self.assertEqual(self.proc.memory.fetch_register('s3'), 0x88)
def test_bitwise_ops(self):
dummy = op.BitwiseOperation(op.BitwiseOperation.OPS["RL"], ["DUMMY"])
dummy.proc = Processor()
self.r.set_value(32)
self.r.values = op.BitwiseOperation.shift_right_zero(dummy, self.r)
self.assertEqual(self.r.value, 16)
self.r.set_value(32)
self.r.values = op.BitwiseOperation.shift_left_zero(dummy, self.r)
self.assertEqual(self.r.value, 64)
for i in range(0, ITERATIONS):
v1 = random.randint(0, MAX)
c = ((v1 << 1) | ((v1 & 0x80) >> 7)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.rotate_left(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) | ((v1 & 1) << 7))
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.rotate_right(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_zero(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_zero(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE | 1) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_one(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F | (1 << 7)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_one(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 << 1) & 0xFE | (v1 & 1)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_left_x(dummy, self.r)
self.assertEqual(self.r.value, c)
c = ((v1 >> 1) & 0x7F | (v1 & 0x80)) % (MAX + 1)
self.r.set_value(v1)
self.r.values = op.BitwiseOperation.shift_right_x(dummy, self.r)
self.assertEqual(self.r.value, c)
for b in [True, False]:
self.proc.set_carry(b)
c = (((v1 << 1) & 0xFE) | self.proc.external.carry) % (MAX + 1)
self.proc.memory.set_register('s1', v1)
o = op.BitwiseOperation(op.BitwiseOperation.OPS["SLA"], ['s1'])
o.exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), c)
self.proc.set_carry(b)
c = (((v1 >> 1) & 0x7F) | (self.proc.external.carry << 7)) % (MAX + 1)
self.proc.memory.set_register('s1', v1)
o = op.BitwiseOperation(op.BitwiseOperation.OPS["SRA"], ['s1'])
o.exec(self.proc)
self.assertEqual(self.proc.memory.fetch_register('s1'), c)
def setUp(self):
s = Server()
self.proc = Processor()
s.processor = self.proc
s.processor.availableFreqs = [1.0]
self.controller = DVFSController(s)
@author: giulio
'''
import sys, os
sys.path.append(os.path.abspath('..'))
from SimpleXMLRPCServer import SimpleXMLRPCServer
from system.processor import Processor
# Create server
server = SimpleXMLRPCServer(("", 8568))
# Registers the XML-RPC introspection functions system.listMethods, system.methodHelp and system.methodSignature
server.register_introspection_functions()
myProc = Processor()
def getInfo():
myProc.detect()
print myProc
return myProc
server.register_function(getInfo, 'getInfo')
try:
print 'Use Control-C to exit'
server.serve_forever()
except KeyboardInterrupt:
print 'Exiting'
def setUp(self):
self.processor = Processor()