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)