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 __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_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()
