def test_inserer_cpu(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10)
stackValue = [i for i in range(CPU.TAILLE_STACK)]
c1 = CPU.CPU(3,
u,
ax=4,
bx=6,
cx=7,
dx=8,
stack_ptr=1,
stack=stackValue)
CheckCPU.checkCPU(self, c1, 3, 4, 6, 7, 8, 1, stackValue)
u.inserer_cpu(c1)
CheckCPU.checkCPU(self, c1, 3, 4, 6, 7, 8, 1, stackValue)
self.assertTrue(c1 in u.liste_cpus)
self.assertTrue(c1 in u.localisation_cpus[3])
c2 = CPU.CPU(3, u)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c2)
u.inserer_cpu(c3)
self.assertTrue(c2 in u.liste_cpus)
self.assertTrue(c2 in u.localisation_cpus[3])
self.assertTrue(c3 in u.liste_cpus)
self.assertTrue(c3 in u.localisation_cpus[4])
self.assertTrue(c1 in u.liste_cpus)
self.assertTrue(c1 in u.localisation_cpus[3])
def test_die(self):
c1 = CPU.CPU(102, self.u)
c2 = CPU.CPU(0, self.u)
c3 = CPU.CPU(101, self.u)
c4 = CPU.CPU(102, self.u)
self.u.inserer_cpu(c1)
self.u.inserer_cpu(c2)
self.u.inserer_cpu(c3)
self.u.inserer_cpu(c4)
c1.die()
self.assertFalse(c1 in self.u.liste_cpus)
self.assertTrue((c1.ptr not in self.u.localisation_cpus)
or (c1 not in self.u.localisation_cpus[c1.ptr]))
c2.die()
self.assertFalse(c2 in self.u.liste_cpus)
self.assertTrue((c2.ptr not in self.u.localisation_cpus)
or (c2 not in self.u.localisation_cpus[c2.ptr]))
c4.die()
self.assertFalse(c4 in self.u.liste_cpus)
self.assertTrue((c4.ptr not in self.u.localisation_cpus)
or (c4 not in self.u.localisation_cpus[c4.ptr]))
c3.die()
self.assertFalse(c3 in self.u.liste_cpus)
self.assertTrue((c3.ptr not in self.u.localisation_cpus)
or (c3 not in self.u.localisation_cpus[c3.ptr]))
def test_cpu_actuel(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10)
c1 = CPU.CPU(3, u)
c2 = CPU.CPU(3, u)
c3 = CPU.CPU(4, u)
u.liste_cpus = [c1, c2, c3]
u.indice_cpu_actuel = 1
self.assertEqual(c2, u.cpu_actuel())
def test_killAround(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10,
LARGEUR_CALCUL_DENSITE=1,
maxCPUs=2)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
u.killAround(3, 3)
self.assertEqual(
u.nbCPUs_at_i(3) + u.nbCPUs_at_i(4) + u.nbCPUs_at_i(5), 1)
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10,
LARGEUR_CALCUL_DENSITE=1,
maxCPUs=5)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
c4 = CPU.CPU(4, u)
u.inserer_cpu(c4)
c5 = CPU.CPU(4, u)
u.inserer_cpu(c5)
c6 = CPU.CPU(4, u)
u.inserer_cpu(c6)
u.killAround(3, 6)
self.assertEqual(
u.nbCPUs_at_i(3) + u.nbCPUs_at_i(4) + u.nbCPUs_at_i(5), 2)
def test_supprimer_localisation(self):
u = Univers.Univers(NextSiteTest.NextSiteTest())
c1 = CPU.CPU(102, u)
c2 = CPU.CPU(102, u)
c3 = CPU.CPU(102, u)
u.ajouter_cpu_localisation(c1)
u.ajouter_cpu_localisation(c3)
u.ajouter_cpu_localisation(c2)
u.supprimer_cpu_localisation(c1)
self.assertTrue(c1 not in u.localisation_cpus[102]
and c2 in u.localisation_cpus[102]
and c3 in u.localisation_cpus[102])
def test_nbCPUs_at_i(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
self.assertEqual(2, u.nbCPUs_at_i(3))
self.assertEqual(1, u.nbCPUs_at_i(4))
self.assertEqual(0, u.nbCPUs_at_i(0))
def test_tuer_cpus_par_densite(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10,
LARGEUR_CALCUL_DENSITE=1,
maxCPUs=2)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
u.tuer_cpus_par_densite()
for i in range(10):
self.assertTrue(u.nbCPUs_around_i(i) <= 1)
def create_and_run(self):
self.program = json.loads(self.program_file.read())
self.CPU = CPU.CPU(self.program)
print "\n\nCPU object created\n\n"
go = str(raw_input("Press enter to begin\n\n"))
self.CPU.run()
def main():
parser = argparse.ArgumentParser(description="NES Emulator.")
parser.add_argument('rom_path',
metavar='ROM path',
type=str,
help='path to nes rom')
args = parser.parse_args()
print("Path to ROM: " + args.rom_path)
rom = ROM()
rom.read_data(args.rom_path)
for i in rom.read_bytes(0, 100):
print(i)
ram = RAM()
cpu = CPU()
cpu.start_up(ram)
cpu.A = 0
cpu.PC = 16
instr = ADC()
cpu.ram.write_bytes(0, bytearray([5, 7]))
print("Before execution: " + str(cpu.A))
cpu.executeProgram(rom.read_bytes(16, 4))
print("After execution: " + str(cpu.A))
def test_tuer_cpu(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
u.tuer_cpu(c1)
self.assertTrue(c2 in u.liste_cpus)
self.assertTrue(c2 in u.localisation_cpus[3])
self.assertTrue(c3 in u.liste_cpus)
self.assertTrue(c3 in u.localisation_cpus[4])
self.assertTrue(c1 not in u.liste_cpus)
self.assertTrue(c1 not in u.localisation_cpus[3])
def run():
flags = []
for token in sys.argv:
if token[0] == '-':
flags.append(token)
print "\nImporting Machine Code = ",
machine_code = load_code()
print "Done"
print "\n\nCreating CPU object = ",
CPU_instance = CPU.CPU(machine_code)
print "Done"
print "\n\n_____________________ Beginning execution _____________________"
start = time.time()
if "-d" in flags:
try:
start = int(sys.argv[-1])
except:
start = 0
CPU_instance.debug_run(start)
else:
CPU_instance.run()
end = time.time()
print "\n_____________________ Halted __________________________________"
print "executed ", CPU_instance.instruction_count, "instructions in ", end - start, "seconds, at ", CPU_instance.instruction_count / (
end - start) if end - start != 0 else "Too fast", "I/s"
print "Registers as follows:"
print_registers(CPU_instance)
def setUp(self):
self.U = Univers.Univers(NextSiteTest.NextSiteTest(memLen=120), TAILLE_MEMOIRE=120)
self.U.insDict.initialize(Instructions.instructions)
eve = Enregistrement.charger_genome('eve')
self.ancestor = self.U.insDict.toInts(eve)
self.U.addIndividual(0, self.ancestor)
self.c = CPU.CPU(0, self.U)
self.U.inserer_cpu(self.c)
def setUp(self):
self.i = 0
self.U = Univers.Univers(NextSite.NextSite())
self.U.insDict.initialize(Instructions.instructions)
self.U.addIndividual(0, self.U.insDict.toInts(charger_genome('eve')))
self.U.inserer_cpu(CPU.CPU(0, self.U))
self.N = random.randint(100, 200)
self.replay = Replay()
def test_next_cpu(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
u.liste_cpus = [c1, c2, c3]
u.indice_cpu_actuel = 1
u.next_cpu()
self.assertEqual(u.indice_cpu_actuel, 0)
u.next_cpu()
self.assertEqual(u.indice_cpu_actuel, 2)
u.next_cpu()
self.assertEqual(u.indice_cpu_actuel, 1)
def test_ajouter_cpu_localisation(self):
u = Univers.Univers(NextSiteTest.NextSiteTest())
c = CPU.CPU(102, u)
u.ajouter_cpu_localisation(c)
self.assertTrue(102 in u.localisation_cpus
and c in u.localisation_cpus[102])
c2 = CPU.CPU(102, u)
c3 = CPU.CPU(102, u)
u.ajouter_cpu_localisation(c3)
u.ajouter_cpu_localisation(c2)
#Pour verifier que l'ajout de CPUs n'en retire pas d'autres :
self.assertTrue(102 in u.localisation_cpus
and c in u.localisation_cpus[102])
self.assertTrue(102 in u.localisation_cpus
and c2 in u.localisation_cpus[102])
self.assertTrue(102 in u.localisation_cpus
and c3 in u.localisation_cpus[102])
def test_incr_stack(self):
c = CPU.CPU(102, self.u)
p = c.stack_ptr
c.incrementer_stack_ptr()
self.assertTrue(c.stack_ptr == p + 1
or (c.stack_ptr == 0 & p == CPU.TAILLE_STACK - 1))
c.stack_ptr = 1
c.incrementer_stack_ptr()
self.assertEqual(c.stack_ptr, 2)
def __init__(self, policity, aMMU, aDisk):
self.modeKernel = False # comienza en modo usuario
self.mmu = aMMU
self.pcbFinish = []
self.disk = aDisk
self.manageIRQ = ManageIRQ(self)
self.handlerIO = HandlerIO(self.manageIRQ)
self.shortScheduler = ShortScheduler(policity(), self)
self.longScheduler = LongScheduler(policity(), self) # revisar
self.cpu = CPU(self)
def __init__(self, no_display=False, quiet=True, frame_rate=20):
pygame.mixer.pre_init(11025, -16, 1)
pygame.init()
self.display = Display(self, no_display)
self.speaker = Speaker(quiet)
self.softswitches = SoftSwitches(self.display, self.speaker)
self.memory = Memory(self)
self.memory.load_image(0xD000, r'bin\A2ROM.BIN')
self.cpu = CPU(self.memory, program_counter=None)
def test_decr_stack(self):
c = CPU.CPU(102, self.u)
p = c.stack_ptr
c.decrementer_stack_ptr()
if p == 0:
self.assertEqual(c.stack_ptr, CPU.TAILLE_STACK - 1)
else:
self.assertEqual(c.stack_ptr, p - 1)
c.stack_ptr = 1
c.incrementer_stack_ptr()
self.assertEqual(c.stack_ptr, 2)
def test_incr_ptr(self):
c = CPU.CPU(102, self.u)
p = c.ptr
c.incrementer_ptr()
if p == len(self.u.memoire) - 1:
self.assertEqual(c.ptr, 0)
else:
self.assertEqual(c.ptr, p + 1)
c.ptr = len(self.u.memoire) - 1
p = c.ptr
c.incrementer_ptr()
self.assertEqual(c.ptr, 0)
def test_nbCPUs_around_i(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10,
LARGEUR_CALCUL_DENSITE=1)
c1 = CPU.CPU(3, u)
u.inserer_cpu(c1)
c2 = CPU.CPU(3, u)
u.inserer_cpu(c2)
c3 = CPU.CPU(4, u)
u.inserer_cpu(c3)
self.assertEqual(3, u.nbCPUs_around_i(3))
self.assertEqual(3, u.nbCPUs_around_i(4))
self.assertEqual(1, u.nbCPUs_around_i(5))
self.assertEqual(0, u.nbCPUs_around_i(6))
self.assertEqual(0, u.nbCPUs_around_i(0))
c4 = CPU.CPU(0, u)
u.inserer_cpu(c4)
self.assertEqual(1, u.nbCPUs_around_i(9))
c5 = CPU.CPU(9, u)
u.inserer_cpu(c5)
self.assertEqual(2, u.nbCPUs_around_i(0))
def test_executer_cpus(self):
u = Univers.Univers(NextSiteTest.NextSiteTest(memLen=10),
TAILLE_MEMOIRE=10,
LARGEUR_CALCUL_DENSITE=1,
maxCPUs=2)
u.memoire = [0, 37, 0, 0, 0, 0, 0, 0, 0, 0]
u.insDict.initialize(Instructions.instructions)
c1 = CPU.CPU(0, u)
c2 = CPU.CPU(0, u)
c3 = CPU.CPU(0, u)
u.inserer_cpu(c1)
u.inserer_cpu(c2)
u.inserer_cpu(c3)
self.assertEqual(u.liste_cpus[0], c1)
self.assertEqual(u.liste_cpus[1], c3)
self.assertEqual(u.liste_cpus[2], c2)
u.executer_cpus()
self.assertEqual(c1.ptr, 1)
self.assertEqual(c2.ptr, 1)
self.assertEqual(c3.ptr, 1)
self.assertRaises(Univers.NoCPUException, u.executer_cpus)
c1 = CPU.CPU(1, u)
c2 = CPU.CPU(2, u)
c3 = CPU.CPU(0, u)
u.inserer_cpu(c1)
u.inserer_cpu(c2)
u.inserer_cpu(c3)
self.assertEqual(u.liste_cpus[0], c1)
self.assertEqual(u.liste_cpus[1], c3)
self.assertEqual(u.liste_cpus[2], c2)
u.indice_cpu_actuel = 1
u.executer_cpus()
self.assertEqual(u.liste_cpus, [c3, c2])
self.assertEqual(c3.ptr, 1)
self.assertEqual(c2.ptr, 3)
def process(p_list, time_quantum, assertions, output_options):
orig_list = []
orig_list.extend(p_list)
logging = output_options.get_prop("show_text_output")
cpu = CPU()
RoundRobinAlgorithm().schedule(cpu, p_list, time_quantum, logging)
wt,tt,context_switches = CalculateTime().calculate(orig_list, "wait_time", logging)\
,CalculateTime().calculate(orig_list, "turn_around_time", logging),CalculateContextSwitch().count(cpu.running_slots, logging)
if assertions is not None:
assertions.check_assertions(cpu, wt, tt, context_switches, logging)
if output_options.show_chart:
GanttChart().create_gantt_chart(cpu, orig_list, wt, tt,
context_switches, time_quantum,
output_options)
def test_push_stack(self):
c = CPU.CPU(102, self.u)
c.push_stack(3)
self.assertEqual(c.stack_ptr, 0)
self.assertEqual(c.stack[c.stack_ptr], 3)
c.push_stack(2)
for i in range(1, CPU.TAILLE_STACK):
self.assertEqual(c.stack[i], 0)
self.assertEqual(c.stack_ptr, 0)
self.assertEqual(c.stack[c.stack_ptr], 2)
c.incrementer_stack_ptr()
c.push_stack(-5)
self.assertEqual(c.stack_ptr, 1)
self.assertEqual(c.stack[c.stack_ptr], -5)
def test_pop_stack(self):
c = CPU.CPU(102, self.u, stack=[0] * CPU.TAILLE_STACK)
self.assertEqual(0, c.pop_stack())
c.stack = [i for i in range(CPU.TAILLE_STACK)]
self.assertEqual(CPU.TAILLE_STACK - 1, c.pop_stack(
)) #On verifie que pop_stack renvoie la bonne valeur...
for i in range(
CPU.TAILLE_STACK): # ...et qu'il ne change pas les valeurs
self.assertEqual(i, c.stack[i])
c.push_stack(3)
self.assertEqual(CPU.TAILLE_STACK - 1, c.pop_stack())
c.incrementer_stack_ptr()
self.assertEqual(c.stack_ptr, 1)
self.assertEqual(3, c.pop_stack())
self.assertEqual(c.stack_ptr, 1)
def __init__(self):
self.i = 0
nextSite = NextSite.NextSite()
self.U = Univers.Univers(nextSite)
self.stats = Statistiques.Statistiques(self.U)
self.U.insDict.initialize(Instructions.instructions)
eve = charger_genome('eve')
ancestor = self.U.insDict.toInts(eve)
self.U.addIndividual(0, ancestor)
c = CPU.CPU(0, self.U)
self.U.inserer_cpu(c)
while self.i < 1000000:
self.U.cycle()
self.test()
self.i += 1
def run():
print "\nImporting Machine Code = ",
machine_code = load_code()
print "Done"
print "\n\nCreating CPU object = ",
CPU_instance = CPU.CPU(machine_code)
print "Done"
print "\n\n_____________________ Beginning execution _____________________\n\n"
start = time.time()
CPU_instance.run()
end = time.time()
print "\n\n_____________________ Halted __________________________________"
print "executed ", CPU_instance.instruction_count, "instructions in ", end - start, "seconds, at ", CPU_instance.instruction_count / (
end - start) if end - start != 0 else "Too fast", "Ips"
print "Registers as follows:"
print_registers(CPU_instance)
def intToCPU(entier, univers):
k = ceil(log(CPU.TAILLE_STACK, 2))
bits0 = 0
for i in range(univers.n3):
bits0 += 2 ** i
bits1 = 2**k-1
bits2 = 2**(univers.n2)-1
bits3 = 2**(univers.b1 *8)-1
stack_ptr = entier & bits1
stack = []
for i in range(CPU.TAILLE_STACK):
stack.insert(0, (entier >> (k + i * univers.n2)) & bits2)
ptr = (entier >> (k + (CPU.TAILLE_STACK) * univers.n2)) & bits0
dx = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + 1 * univers.n3)) & bits0
cx = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + 2 * univers.n3)) & bits0
bx = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + 3 * univers.n3)) & bits0
ax = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + 4 * univers.n3)) & bits0
parent = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + 5 * univers.n3)) & bits3
id = (entier >> (k + CPU.TAILLE_STACK * univers.n2 + univers.b1 * 8 + 5 * univers.n3)) & bits3
id_final =(str(id) if parent==2**(univers.b1 *8)-1 else str(parent)+"/"+str(id))
return CPU(ptr, univers, ax, bx, cx, dx, stack, stack_ptr, None, id_final )
import CPU
import sys
rom_file = sys.argv[1]
cpu = CPU.CPU()
cpu.mmu.load(rom_file)
while (True):
cpu.pc += 1
op = cpu.mmu.rb(cpu.pc)
CPU.opcodes[op](cpu)
cpu.pc &= 65535
cpu.cm += cpu.m
words = line.rstrip('\n').split()
if (words[0] != '--'):
sl = int(words[0].strip(':'))
m = words[1].upper()
if (m == 'NUM'):
store = ReverseBits(int(words[2]))
else:
i = next((i for i, x in enumerate(instructions)
if (x['mnemonic'] == m)), None)
if (i == None):
print('Cannot process line {}: {}'.format(
lineNumber, line))
exit()
else:
opcode = instructions[i]['opcode']
if (m in ['STOP', 'HLT', 'CMP', 'SKN']):
ln = 0
else:
ln = int(words[2])
store = ReverseBits(ln | (opcode << 13))
storeLines.SetLine(sl, Register.Register(store))
#
# The Manchester Baby
#
storeLines = StoreLines.StoreLines(32)
Assembler('Samples/hfr989.asm', storeLines)
cpu = CPU.CPU(storeLines)
cpu.RunProgram(debugging=False)
