【头歌】操作系统冯·诺依曼体系结构及工作原理理解_头歌第7关:软件模拟

本文链接：https://blog.csdn.net/xmlx_mmx/article/details/144962688

冯·诺依曼体系结构及工作原理理解：

第6关：软件模拟 - 模拟硬件初始化

第6关任务描述

对使用变量模拟的 TOY 计算机的部分硬件装置，进行初始化赋值。

第6关任务过程

def init():

    ########## Begin ##########
    mem = [0] * 1000     #主存，1000个单元
    reg = [0] * 10     #通用寄存器，10个
    pReg = 0    #程序计数器，1个
    iReg = 0    #指令寄存器，1个
    ########## End ##########

第7关：软件模拟 - 程序加载

第7关任务描述

将存放在文件中的程序指令加载到 TOY 计算机的主存中。

第7关任务过程

def loadProgram(file, mem, address):

    ########## Begin ##########
    txt = open(file, 'r')
    s = txt.readlines()
    for x in s :
        l = len(x)
        bg, L = 0, []
        while bg <= l - 1 :
            mdl = ''
            flag = False
            while x[bg] != ' ' :
                mdl += x[bg]
                bg += 1
                if bg == l - 1 :
                    flag = True
                    break
            while x[bg] == ' ' :
                if bg == l - 1 :
                    flag = True
                    break
                bg += 1
            L.append(mdl)
            if flag :
                break
        L.pop(0)
        
        mem[address] = ' '.join(L)
        address += 1
    ########## End ##########

第8关：软件模拟 - 取指令

第8关任务描述

模拟计算机取指令操作，将内存中的指令取到指令寄存器中来，同时程序计数器加一，指向下一条要执行的指令地址。

第8关任务过程

def fetch(mem, pReg):

    ########## Begin ##########
    iReg = mem[pReg]
    pReg += 1
    ########## End ##########

第9关：软件模拟 - 指令译码

第9关任务描述

对程序寄存器中的指令进行解析，得到操作码和操作数。

第9关任务过程

def decode(iReg):

    ########## Begin ##########
    l = len(iReg)
    cnt, i = 0, 0
    L = []
    while i < l :
        while i < l and iReg[i] == ' ' :
            i = i + 1
        if i == l :
            break;
        cnt = cnt + 1; 
        mdl = ''
        while i < l and iReg[i] != ' ' :
            mdl = mdl + iReg[i]
            i = i + 1
        if cnt > 1 :
            bg = 0
            while bg < len(mdl) and mdl[bg] == '0' :
                bg = bg + 1
            mdl = mdl[bg : ]
        L.append(mdl)
    while cnt < 3 :
        L.append('None')
        cnt = cnt + 1
    ret = '(' + "'" + L[0] + "'" + ',' + ' ' + L[1] + ',' + ' ' + L[2] + ')'
    return ret
    ########## End ##########

第10关：软件模拟 - 指令执行

第10关任务描述

根据 TOY 计算机指令译码结果，编程模拟指令执行及写结果的操作。

第10关任务过程

def execute(opcode, op1, op2, reg, mem, pReg):

    ########## Begin ##########
    global iReg
    if opcode == 'mov1' :
        reg[op1] = eval(mem[op2])
        result = reg[op1]
    elif opcode == 'mov2' :
        mem[op1] = str(reg[op2])
        result = mem[op1]
    elif opcode == 'mov3' :
        reg[op1] = op2
        result = reg[op1]
    elif opcode == 'add' :
        reg[op1] += reg[op2]
        result = reg[op1]
    elif opcode == 'sub' :
        reg[op1] -= reg[op2]
        result = reg[op1]
    elif opcode == 'mul' :
        reg[op1] *= reg[op2]
        result = reg[op1]
    elif opcode == 'div' :
        reg[op1] = reg[op1] // reg[op2]
        result = reg[op1]
    elif opcode == 'jmp' :
        iReg = mem[op1]
        # pReg = eval(mem[op1])
        return pReg
    elif opcode == 'jz' :
        if reg[op1] == 0 :
            # pReg = eval(mem[op2]
            iReg = mem[op2]
        result = pReg
    elif opcode == 'in' :
        reg[op1] = eval(input())
        result = reg[op1]
    elif opcode == 'out' :
        # print(reg[op1])
        result = reg[op1]
    else :
        result = False
    ########## End ##########

第11关：软件模拟 - TOY计算机执行程序的完整过程

第11关任务描述

完成完整的toy计算机程序的模拟执行。

第11关任务过程

11.1 def loadProgram(file, mem, address):

    ########## Begin ##########
    txt = open(file, 'r')
    s = txt.readlines()
    for x in s :
        l = len(x)
        bg, L = 0, []
        while bg < l :
            mdl = ''
            while bg < l and x[bg] != ' ' :
                mdl = mdl + x[bg]
                bg += 1
            while bg < l and x[bg] == ' ' :
                bg += 1
            L.append(mdl)
        L.pop(0)
        mem[address] = ' '.join(L)
        address = address + 1
    ########## End ##########

11.2 def fetch(mem, pReg):

    ########## Begin ##########
    iReg = mem[pReg]    
    ########## End ##########

11.3 def decode(iReg):

    ########## Begin ##########
    l = len(iReg)
    cnt, i = 0, 0
    L = []
    while i < l :
        while i < l and iReg[i] == ' ' :
            i = i + 1
        if i == l :
            break
        cnt = cnt + 1; mdl = ''
        while i < l and iReg[i] != ' ' :
            mdl = mdl + iReg[i]
            i = i + 1
        if cnt > 1 :
            bg = 0
            while bg < len(mdl) and mdl[bg] == '0' :
                bg = bg + 1
            mdl = mdl[bg : ]
        L.append(mdl)
    tmp = cnt
    while cnt < 3 :
        L.append('None')
        cnt = cnt + 1
    if tmp == 1 :
        return L[0], 0, 0
    elif tmp == 2 :
        if L[1] == '' or L[1] == '\n':
            return L[0], 0, 0
        return L[0], eval(L[1]), 0
    else :
        ret1, ret2 = 0, 0
        if L[1] != '' and L[1] != '\n':
            ret1 = eval(L[1])
        if L[2] != '' and L[2] != '\n':
            ret2 = eval(L[2])
    ########## End ##########

11.4 def execute(opcode, op1, op2, reg, mem, address):

    ########## Begin ##########
    global pReg
    flag = False
    if opcode == 'mov1' :
        reg[op1] = eval(mem[op2])
    elif opcode == 'mov2' :
        mem[op1] = str(reg[op2])
    elif opcode == 'mov3' :
        reg[op1] = op2
    elif opcode == 'add' :
        reg[op1] += reg[op2]
    elif opcode == 'sub' :
        reg[op1] -= reg[op2]
    elif opcode == 'mul' :
        reg[op1] *= reg[op2]
    elif opcode == 'div' :
        reg[op1] = reg[op1] // reg[op2]
    elif opcode == 'jmp' :
        iReg = mem[op1]
        pReg = op1 + address
        flag = True
    elif opcode == 'jz' :
        if reg[op1] == 0 :
            flag = True
            iReg = mem[op2]
            pReg = op2 + address
    elif opcode == 'in' :
        reg[op1] = eval(input())
    elif opcode == 'out' :
        print(reg[op1])
    if flag == False :
        pReg = pReg + 1
    if opcode != 'halt' and opcode != 'halt\n':
        result = True
    else :
        result = False
    return result
    ########## End ##########

11.5 def run(file, addr):

    ########BEGIN########
    global pReg, iReg    
    pReg = addr
    loadProgram(file, mem, addr)
    while True :
        pReg, iReg = fetch(mem, pReg)
        L, op1, op2 = decode(iReg)
        mdl = execute(L, op1, op2, reg, mem, addr)
        if mdl == False :
            break
    ########## End ##########

第12关：软件模拟 - 扩展 TOY 计算机指令集

第12关任务描述

本关任务：修改给定的程序代码，使其支持执行使用 TOY 计算机扩展指令集编写的程序代码。

第12关任务过程

12.1 def init():

    ########## Begin ##########
    mem = ['']*1000     #主存
    reg = [0]*10       #通用寄存器
    pReg = 0          #程序计数器
    iReg = ''         #指令寄存器
    CF = 0   
    ########## End ##########

12.2 def loadProgram(file, mem, address):

    ########## Begin ##########
    txt = open(file, 'r')
    s = txt.readlines()
    for x in s :
        l = len(x)
        bg, L = 0, []
        while bg < l :
            mdl = ''
            while bg < l and x[bg] != ' ' and x[bg] != '\t' :
                mdl = mdl + x[bg]
                bg += 1
            while bg < l and (x[bg] == ' ' or x[bg] == '\t'):
                bg += 1
            L.append(mdl)
        L.pop(0)
        mem[address] = ' '.join(L)
        address = address + 1
    ########## End ##########

12.3 def fetch():

    ########## Begin ##########
    iReg = mem[pReg]
    return pReg, iReg    
    ########## End ##########

12.4 def decode():

    ########## Begin ##########
    l = len(iReg)
    cnt, i = 0, 0
    L = []
    while i < l :
        while i < l and iReg[i] == ' ' :
            i = i + 1
        if i == l :
            break
        cnt = cnt + 1; mdl = ''
        while i < l and iReg[i] != ' ' :
            mdl = mdl + iReg[i]
            i = i + 1
        if cnt > 1 :
            bg = 0
            while bg < len(mdl) and mdl[bg] == '0' :
                bg = bg + 1
            mdl = mdl[bg : ]
        L.append(mdl)
    tmp = cnt
    while cnt < 3 :
        L.append('None')
        cnt = cnt + 1
    if tmp == 1 :
        return L[0], 0, 0
    elif tmp == 2 :
        if L[1] == '' or L[1] == '\n':
            return L[0], 0, 0
        return L[0], eval(L[1]), 0
    else :
        ret1, ret2 = 0, 0
        if L[1] != '' and L[1] != '\n':
            ret1 = eval(L[1])
        if L[2] != '' and L[2] != '\n':
            ret2 = eval(L[2])
        return L[0], ret1, ret2
    ########## End ##########

12.5 def execute(opcode,op1,op2, address):

    ########## Begin ##########
    flag = False
    if opcode == 'mov1' :
        reg[op1] = eval(mem[op2])
    elif opcode == 'mov2' :
        mem[op1] = str(reg[op2])
    elif opcode == 'mov3' :
        reg[op1] = op2
    elif opcode == 'add' :
        reg[op1] += reg[op2]
    elif opcode == 'sub' :
        reg[op1] -= reg[op2]
    elif opcode == 'mul' :
        reg[op1] *= reg[op2]
    elif opcode == 'div' :
        reg[op1] = reg[op1] // reg[op2]
    elif opcode == 'jmp' :
        iReg = mem[op1]
        pReg = op1 + address
        flag = True
    elif opcode == 'jz' :
        if reg[op1] == 0 :
            flag = True
            iReg = mem[op2]
            pReg = op2 + address
    elif opcode == 'in' :
        reg[op1] = eval(input())
    elif opcode == 'out' :
        print(reg[op1])
    elif opcode == 'add2' :
        reg[op1] += op2
    elif opcode == 'cmp' :
        if reg[op1] <= op2 :
            CF = 1
        else :
            CF = 0
    elif opcode == 'ble' :
        if CF :
            pReg = reg[op1] + address
            flag = True
    if flag == False :
        pReg = pReg + 1
    if opcode != 'halt' and opcode != 'halt\n':
        result = True
    else :
        result = False
    ########## End ##########
    
    return result	//需要修改返回值TRUE为result

12.6 def run(file, addr):

    ######## Begin ########
    pReg = addr
    loadProgram(file, mem, addr)
    while True :
        pReg, iReg = fetch()
        L, op1, op2 = decode()
        mdl = execute(L, op1, op2, addr)
        if mdl == False :
            break  
    ########## End ##########