Python machine.Machine类代码示例

    def test_issue(self):
        machine = Machine()
        instr = Instruction(0x20010003)
        self.assertTrue(machine.issue(instr))
        self.assertTrue(machine.hasInstruction())

        rstations = machine.unitContainers['IntUnit'].dumpRStations()

class StarTest(object):
    def __init__(self, tmpdir):
        self.tmpdir = str(tmpdir)
        self.root = Compound(None, 'root')
        self.events = {}
        for meth_name in dir(self):
            meth = getattr(self, meth_name)
            ticks = getattr(meth, 'ticks', None)
            if ticks is not None:
                for tick in ticks:
                    events = self.events.get(tick, [])
                    events.append(meth)
                    self.events[tick] = events

    def each_tick(self, tick):
        pass

    def each_clock(self, clock):
        pass

    def get_total_ticks(self):
        return max(self.events.keys() or [0]) + 1

    def run_machine(self, ticks=None):
        self.machine = Machine(self.root, on_tick=self.each_tick,
                               on_clock=self.each_clock)
        self.machine.run(ticks or self.get_total_ticks(), self.events)

    def view(self, prefix, tick=None):
        tick = tick if tick is not None else self.machine.tick
        builder = GraphBuilder()
        graph = builder.visit(self.root)
        graph.render(os.path.join(self.tmpdir, '%s_%i' % (prefix, tick)))

def main(argv):
	
	if len(argv) < 5:
		print "Usage: mipssim.py -i [input_file_name] -o [output_file_name]"
		quit(-1)
	try:
		inputFilenameIndex = argv.index('-i') + 1
		outputFilenameIndex = argv.index('-o') + 1
	except ValueError:
		print "Usage: mipssim.py -i [input_file_name] -o [output_file_name]"
		quit(-1)
	
	infileName = argv[inputFilenameIndex]
	if '.bin' not in infileName:
		infileName+='.bin'
	outFileName = argv[outputFilenameIndex]
	
	(word, address) = filemanager.loadInstructionsAndAddresses(infileName)
	instruction = []
	for i in range(len(word)):
		instruction.append(Instruction(word[i], address[i]))
	
	disassembler.target_file = open(outFileName+'_dis.txt', 'w')
	disassembler.disassembleSet(instruction)
	mips = Machine(outFileName+'_sim.txt')
	mips.loadInstructions(instruction)
	mips.executeInstructions()

def main():
    if len(sys.argv) != 3:
        print "usage: %s [input_directory] [output_directory]" % (sys.argv[0])
        sys.exit()

    input_dir = os.path.abspath(sys.argv[1])
    output_dir = os.path.abspath(sys.argv[2])
    os.path.exists(output_dir) or os.mkdir(output_dir)

    framework_dir = os.path.dirname(os.path.abspath(os.path.join(os.getcwd(), __file__)))
    os.chdir(framework_dir)

    m = Machine(input_dir=input_dir, output_dir=output_dir, framework_dir=framework_dir, program=[])
    m.setup(
        "defaults",
        "exception",
        "parse",
        "modules",
        "php_backend",
        "php_view",
        "macro",
        "global_command",
        "guard",
        "handler",
        "view",
        "generate",
    )
    m.boot()

 def __init__(self, vm_limit, azure_config, skip_setup, local):
     self.vm_limit = vm_limit # user input
     self.budget = 0
     self.timestamp = datetime.now()
     self.cost_pred = 0
     self.wf_end = None
     
     self.jobs_terminated = False
     self.last_resched = None
     
     self.workflow = Workflow()
     self.logwatcher = LogWatcher()
     
     self.schedule = Schedule()
     
     manager = Machine()
     manager.status = MachineStatus.manager
     manager.condor_slot = 'manager'
     self.machines = [manager]
     
     boot_entry = ScheduleEntry(Job('boot', None), manager, self.timestamp, self.timestamp)
     boot_entry.real_start = self.timestamp
     boot_entry.real_end = self.timestamp
     boot_entry.status = EntryStatus.completed
     self.schedule.add_entry_host(boot_entry, manager)
     
     self.local = local
     if azure_config and not local:
         hostname = socket.gethostname()
         self.exp = AzureExperiment(azure_config, skip_setup=skip_setup, name=hostname)
         self.master_addr = socket.gethostbyname(hostname)
         self.user = azure_config.admin_username
     else:
         self.exp = self.master_addr = self.user = None

    def test_math_is_right_on_restock(self):
        bev1 = Beverage('Coke', 150, 1.00)
        bev = ['Coke', 150, 1.00]

        my_machine = Machine()
        my_machine.beverages.append((bev1))

        self.assertEqual('9 Cokes have been added to the machine', my_machine.restock(bev, 9))

 def test_brUnit1(self):
     sys.stdout = output = io.StringIO()
     machine = Machine()
     machine.loadProgram('Tomasulo/brUnit1.hex')
     machine.run()
     with open('Tomasulo/brUnit1.out', 'r') as answerFile:
         answer = answerFile.read()
     self.assertEquals(output.getvalue(), answer)

def run():
    print 'machine echo side a'
    ma = Machine('proxy_runner')
    ma.add_peer(peer)
    n = ProxyNode('node.example.TestNode')
    ma.add(n)

    return ma

def run():
	m = Machine('Chain')
	a = A()
	nodes = [a, B(), C(), D(), E(), F(), G(), H(), I(), J(), K(), L(), M()]
	m.nodes.add(*nodes)
	a=m.get_nodes('A')[0]
	import pdb; pdb.set_trace()
	a.set('on', True)
	return m

 def test_allInts(self):
     for i in range(1, 9):
         sys.stdout = output = io.StringIO()
         machine = Machine()
         machine.loadProgram('Tomasulo/intUnit{0}.hex'.format(i))
         machine.run()
         with open('Tomasulo/intUnit{0}.out'.format(i), 'r') as answerFile:
             answer = answerFile.read()
         self.assertEquals(output.getvalue(), answer)

def run():
    print 'running simple machine'
    m = Machine()
    m.add_peer('PYRO:[email protected]:55090')
    a = A()
    m.add(a)

    print 'perform a.one += 4'
    a.one += 4
    return m

 def test_all(self):
     sys.stdout = output = io.StringIO()
     for inputFile in os.listdir('Tomasulo'):
         if inputFile.endswith('.dlx'): continue
         if inputFile.endswith('.out'): continue
         machine = Machine()
         machine.loadProgram('Tomasulo/' + inputFile)
         machine.run()
         with open('Tomasulo/' + inputFile.strip('.hex') + '.out', 'r') as answerFile:
             answer = answerFile.read()
         self.assertEquals(output.getvalue(), answer)

def process_start_trans_tape(start_status, transition, tape):
    print("Transition:")
    print(transition)
    print("Tape:")
    print(tape)
    if not start_status:
        machine = Machine(transition,tape)
    else:
        machine = Machine(transition,tape,start_status)
    print("Execution:")
    machine.execute()

    def test_count_bevs_of_one_name(self):
        my_machine = Machine()
        bevs = []
        new_bev = Beverage('Coke', 150, 1.00)
        new_bev2 = Beverage('Coke', 150, 1.00)
        new_bev3 = Beverage('Pepsi', 150, 1.50)
        bevs.append(new_bev)
        bevs.append(new_bev2)
        bevs.append(new_bev3)
        my_machine.beverages = bevs

        self.assertEqual(2, my_machine.get_number_of_bev('Coke'))

 def sync_machines(self):
     slots = condor_slots()
     for s in slots:
         if s not in [m.condor_slot for m in self.machines]:
             machine = Machine()
             machine.status = MachineStatus.running
             machine.condor_slot = s
             boot_job = Job('boot', None)
             boot_entry = ScheduleEntry(boot_job, machine, None, None)
             boot_entry.log[LogKey.real_start] = self.creation_timestamp
             boot_entry.log[LogKey.real_end] = self.timestamp
             boot_entry.status = EntryStatus.completed
             self.entries.append(boot_entry)
             self.machines.append(machine)
             print "++Machine", s