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 DisplayMenu(): print(""" 1: CPU 2: RAM 3: Read Log file 4: Exit """) menuItem = input("Choose menu item: ") #providing information efter user input if (menuItem == "1"): print("") CPU.printCpuUsage() elif (menuItem == "2"): MemoryControll.printMemoryUsage() elif (menuItem == "3"): FileControll.ReadLogFile() elif (menuItem == "4"): global isRunning isRunning = False print("Closing system!") else: print("\nError: invaild input")
def run(self): print("Waiting....") while self.isUpdates.wait(): print("Something to process !") programToRun=None with self.lock: if len (self.programs) != 0: print("number of programs",len (self.programs)) programToRun = self.programs.pop() if programToRun != None: #programToRun["client"].running=True #Has the program already been started once ? if "program" not in programToRun.keys(): programToRun.update(CPU.startProgram(programToRun["programString"])) else: programToRun.update(CPU.execute(programToRun["program"],programToRun["memory"],programToRun["state"])) #programToRun["client"].running=False with self.lock: if len(programToRun["program"])==programToRun["state"]: print("program finished", "memory is ",hex(id(programToRun["memory"])), "of" ,programToRun["programString"]) else: self.programs.appendleft(programToRun) else : self.isUpdates.clear() print ("Waiting for new programs to process...")
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]))
class Apple2: 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 pickle(self, pickler): self.memory.pickle(pickler) self.cpu.pickle(pickler) self.display.pickle(pickler) self.speaker.pickle(pickler) self.softswitches.pickle(pickler) def unpickle(self, unpickler): self.memory.unpickle(unpickler) self.cpu.unpickle(unpickler) self.display.unpickle(unpickler) self.speaker.unpickle(unpickler) self.softswitches.unpickle(unpickler)
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 __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 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))
class Kernel: 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 initializeThread(self): self.cpu.initializeThread() self.handlerIO.initializeThread() self.longScheduler.start() def modeOn(self): # lo pone en modo kernel self.modeKernel = True def modeOff(self): # lo pone en modo usuario self.modeKernel = False def setNextPcb(self): self.cpu.setPCB(self.shortScheduler.next()) self.cpu.timer.reset() def contextSwitch(self): self.modeOn() # coloco en modo kernel if self.cpu.pcbCurrent == None: # #chequeo si el CPU finalizo el ultimo PCB o lo self.setNextPcb() # # seteo en el pcb del CPU el proximo pcb else: self.returnToPcbTable( ) # # vuelvo a poner el pcb en la cola qReady self.setNextPcb() # # seteo en el pcb del CPU el proximo pcb self.modeOff() # vuelvo al modo usuario def returnToPcbTable(self): self.shortScheduler.retryAdd(self.cpu.pcbCurrent) def isModeKernel(self): return self.modeKernel def runProcess(self, aProgramName): self.manageIRQ.newInterrupt(aProgramName) def insertProcess(self, aProgramName): newPCB = PCB(aProgramName) self.longScheduler.handle(newPCB) def addDevice(self, aDevice): self.handlerIO.addDevice(aDevice)
class Kernel: 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 initializeThread(self): self.cpu.initializeThread() self.handlerIO.initializeThread() self.longScheduler.start() def modeOn(self): # lo pone en modo kernel self.modeKernel = True def modeOff(self): # lo pone en modo usuario self.modeKernel = False def setNextPcb(self): self.cpu.setPCB(self.shortScheduler.next()) self.cpu.timer.reset() def contextSwitch(self): self.modeOn() # coloco en modo kernel if self.cpu.pcbCurrent == None: # #chequeo si el CPU finalizo el ultimo PCB o lo self.setNextPcb() # # seteo en el pcb del CPU el proximo pcb else: self.returnToPcbTable() # # vuelvo a poner el pcb en la cola qReady self.setNextPcb() # # seteo en el pcb del CPU el proximo pcb self.modeOff() # vuelvo al modo usuario def returnToPcbTable(self): self.shortScheduler.retryAdd(self.cpu.pcbCurrent) def isModeKernel(self): return self.modeKernel def runProcess(self, aProgramName): self.manageIRQ.newInterrupt(aProgramName) def insertProcess(self, aProgramName): newPCB = PCB(aProgramName) self.longScheduler.handle(newPCB) def addDevice(self, aDevice): self.handlerIO.addDevice(aDevice)
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 execute(self, opcode: bytes, cpu: CPU): code = (opcode & 0b11100) >> 2 nextbytes = cpu.instructions[cpu.PC + 1:cpu.PC + 1 + 2] val = getMemArray[code](cpu, nextbytes) cpu.PC += val[1] #TODO: consider the use of if-statements here: if (cpu.A >= val[0]): if (cpu.A == val[0]): cpu.P = (cpu.P & 0b11111100) | 0b11 else: cpu.P = (cpu.P & 0b11111100) | 0b01
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))
class TestCPU(unittest.TestCase): myCPU = CPU.nandCPU() def test_ALU(self): self.assertEqual(self.myCPU.ALU([False, False, False, False, False, False], 1, 1), 1) self.assertEqual(self.myCPU.ALU([False, False, False, False, True, False], 1, 1), 2) self.assertEqual(self.myCPU.ALU([True, False, False, False, True, False], 1, 1), 1) self.assertEqual(self.myCPU.ALU([True, False, True, False, True, False], 1, 1), 0) self.assertEqual(self.myCPU.ALU([False, False, True, True, True, False], 1, 1), 0) self.assertEqual(self.myCPU.ALU([False, False, True, True, True, False], 0, 1), -1) self.assertEqual(self.myCPU.ALU([False, True, False, False, True, True], 0, 1), -1) self.assertEqual(self.myCPU.ALU([False, True, False, False, True, True], 5, 1), 4) self.assertEqual(self.myCPU.ALU([True, True, False, True, True, True], 5, 1), 2) self.assertEqual(self.myCPU.ALU([True, True, False, True, True, True], 5, 100), 101) def test_A_Instruction(self): self.myCPU.A_Instruction(int(bin(50), 2)) self.assertEqual(self.myCPU.regA, 50) self.myCPU.A_Instruction(int(bin(9999), 2)) self.assertEqual(self.myCPU.regA, 9999) def test_makeFlags(self): self.assertEqual(CPU.makeFlags(2688), [True, False, True, False, True, False]) self.assertEqual(CPU.makeFlags(1856), [False, True, True, True, False, True]) self.assertEqual(CPU.makeFlags(3520), [True, True, False, True, True, True]) def test_several(self): self.myCPU.A_Instruction(100) self.myCPU.C_Instruction(60881) self.assertEqual(self.myCPU.ip, 100) self.assertEqual(self.myCPU.regD, 101)
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 __init__(self, ROM): self.cpu = CPU.nandCPU() self.rom = ROM self.actualLength = len(ROM) amountToAdd = 32768 - self.actualLength self.rom += [0] * amountToAdd self.cpu.ip = 0
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.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 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 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 print_registers(CPU_instance): register_names = [ "Zero", "One", "Accumulator", "Jump", "PC", "Flags_set", "Flags_reset", "Stack_pointer", "gp0", "gp1", "gp2", "gp3", "gp4", "gp5", "gp6", "gp7" ] for i in xrange(16): print register_names[i], CPU.append_bytes( CPU_instance.Registers.registers[i].data)
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 guessClicked(self): ########### click 하면----> img = QPixmap(self.view.grab(self.view.sceneRect().toRect())) img.save('./images/test.png') self.cpAnswer.setText(CPU.start()) #사진 삭제 os 모듈 사용 if (self.cpAnswer.text() == self.word.text()): print('0')
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_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 walkpath(sr_path,savepath ): for path, dirs, files in os.walk(sr_path): for filename in files: if filename.startswith("cpu_") and filename.endswith("_log"): print "zhaodap" avgCPU=cpu.get_avgCPU(path,filename) str_avg=str(round(avgCPU,3))+'%' avgCPUinfo=filename+"\'s average CPU rate is "+str_avg cpuFile=open(savepath+"/[0]avgCPU.TXT",'a') cpuFile.write(avgCPUinfo+'\n') cpuFile.close() print "avgCPU",str_avg avgCPUList=cpu.get_avgCPUList(path,filename) cpu.draw_avgCPU(avgCPUList,path,filename,savepath) elif filename.startswith("jstat_") and filename.endswith(".log"): heapList=jstat.get_heapList(path,filename) puList=jstat.get_puList(path,filename) jstat.draw_Heap(heapList,path,filename,savepath) jstat.draw_PU(puList,path,filename,savepath) else: pass
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_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 busy(self, csv_row, disk): prev_times = self._last_times_busy prev_cpu_times = self._last_cpu_times_busy self._last_times_busy = system(csv_row=csv_row, disk=disk) self._last_cpu_times_busy = CPU.system_no_guest(csv_row=csv_row) if not prev_times and not prev_cpu_times: return 0.0 num_cpu = float(csv_row['cpu_count']) result = 100 * (self._last_times_busy.busy_time - prev_times.busy_time) / ( (sum(self._last_cpu_times_busy) - sum(prev_cpu_times)) / num_cpu * 1000.0) if result > 100: result = 100 return result
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)
import sys,os from CPU import * from Hardware import Console cpu=CPU(verbose=0) cpu.hw_attach(Console()) cpu.load(sys.argv[1]) inp="c" #sys.stdout=open(os.devnull,'w') while True: if cpu.verbose: cpu.dumpregs() print("Flags:",cpu.flags) print("Memory:") cpu.memory.dump(length=8,width=32) print('-'*10) if inp!="c": inp=input(">") if not cpu(): break
# Python Chip8 Interpreter Main Program # Joshua Tyler 09/15 from CPU import * from keyboard import * import logging import sys logging.basicConfig(stream=sys.stdout, level=logging.WARNING) logging.getLogger().disabled = True # Constants FILENAME = "Breakout (Brix hack) [David Winter, 1997].ch8" disp = screen() keyb = keyboard() file = open(FILENAME, 'rb') myCPU = CPU(file, disp, keyb) myCPU.start()
i = CPUInstruction("intr") program3.addInstruction(i) # Definimos un Disco hdd = HardDisk() hdd.save(program1) hdd.save(program2) hdd.save(program3) # Definimos el Sistema de I/O iosys = IOSystem() iosys.addDevice(hdd) # Definimos la CPU con un quantum de 3 cpu = CPU() # Definimos el Kernel kernel1point0 = Kernel() # Definimos la Memoria pageTable = PageTable() memory = Memoria(300,pageTable) # Definimos el Manejador de Interrupciones IH = InterruptionHandler(iosys,memory,pageTable,kernel1point0,cpu) # Seteamos el IH en todos los modulos que haga falta cpu.setInterruptionHandler(IH) kernel1point0.setInterruptionHandler(IH)
from Scheduler import Scheduler from CPU import * from shell import Shell import multiprocessing import time if __name__ == "__main__": # Crear Pipe para conectar la consola con el SO parent_conn, child_conn = multiprocessing.Pipe() shell = Shell(parent_conn) cpu = CPU(child_conn) cpu.start() shell.run() cpu.join()