Սկիզբ » Ուսումնական նյութեր » Ծրագրավորում » Ծրագրավորման լեզուներ » Java » Ֆոն-Նեյմանի մեքենայի էմուլյատորի օրինակ

Ֆոն-Նեյմանի մեքենայի էմուլյատորի օրինակ

| Հոկտեմբեր 9, 2012 | Մեկնաբանված չէ |

Ժամանակին ես այս օրինակը պատրաստէլ էի ԵՊՀ Տեղեկատվական տեխնոլոգիաների կրթական և հետազոտական կենտրոնում կարդացվող “Ներդրված համակարգերի նախագծում” դասընթացի համար, որպես ցուցադրական օրինակ։ Նպատակս էր համակուրսեցիներիս ցույց տալ, թե ինչպես եմ ատրաստվում իրականացնել կուրսային աշխատանքի ինձ բաժին հասած հատվածը։

Վերացական մեքենա

Որպես ֆոն-Նեյմանի մեքենայի պարզագույն օրինակ դիտարկենք ամբողջ թվերի հետ աշխատող մի վերացական մեքենա։ Այն ունի ունի 4 ներքին ռեգիստր, 65535 ամբողջ թվերի հիշողություն, և հետևյալ հրամանները.

Անուն Կոդ Տիպ Վարք
MOV 0x00 r, c reg[r] := c (c is integer)
MOV 0x01 r, m reg[r] := mem[m]
MOV 0x02 m, r mem[m] := reg[r]
ADD 0x03 r, c reg[r] := reg[r] + c (c is integer)
ADD 0x04 r, m reg[r] := reg[r] + mem[m]
ADD 0x05 r, v reg[r] := reg[r] + reg[v]
SUB 0x06 r, c reg[r] := reg[r] – c (c is integer)
SUB 0x07 r, m reg[r] := reg[r] – mem[m]
SUB 0x08 r, v reg[r] := reg[r] – reg[v]
MUL 0x09 r, c reg[r] := reg[r] * c (c is integer)
MUL 0x0A r, m reg[r] := reg[r] * mem[m]
MUL 0x0B r, v reg[r] := reg[r] * reg[v]
DIV 0x0C r, c reg[r] := reg[r] / c (c is integer)
DIV 0x0D r, m reg[r] := reg[r] / mem[m]
DIV 0x0E r, v reg[r] := reg[r] / reg[v]

reg և mem փոփոխականներով նշված են համապատասխանաբար ռեգիստրներն ու հիշողությունը: Մեքենան ունի նաև ip ռեգիստրը, որը ցույց է տալիս, թե հաջորդ կատարվող հրամանի հասցեն հիշողության մեջ: Ըստ ֆոն-Նեյմանի դասական մեքենայի սկզբունքի, ծրագիրն ու տվյալները պահվում են նույն հիշողության մեջ: Մեր դիտարկած դեպքում կհամարենք, որ ծրագիրը սկսվում է հիշողության 0x00 հասցեից և ավարտվում է 0xFF արժեքն ունեցող հիշողության տարրով:

Օրինակ, այս մեքենայի համար գրենք ծրագիր, որը հաշվում է 1+2-(3 x 4)/5 արտահայտության արժեքը և վերագրում հիշողության 25-րդ տարրին:

MOV r0, 1
ADD r0, 2
MOV r1, 3
MUL r1, 4
DIV r1, 5
SUB r0, r1
MOV m[25], r0

Բերված ծրագիրը տող առ տող տասնվեցական կոդերի թարգմանելուց հետո կունենա հետևյալ տեսքը.

0x00 0x00 0x01
0x03 0x00 0x02
0x00 0x01 0x03
0x09 0x01 0x04
0x0C 0x01 0x05
0x08 0x00 0x01
0x02 0x19 0x00

Այս կոդը հիշողություն բեռնելուց հետո պետք է պարզապես այն լրացնել 0xFF կոդով` որպես ծրագրի ավարտ:

Էմուլյատորի ալգորիթմը

Նկարագրված մեքենայի աշխատանքի էմուլյացիայի ալգորիթմը հետևյալն է.

  1. ip := 0
  2. հրաման := mem[ip]
  3. Եթե հրաման = 0xFF, ապա ավարտել էմուլյացիան:
  4. արգ1 := mem[ip+1], արգ2 := mem[ip+2]
  5. Եթե հրաման = 0x00, ապա reg[արգ1] := արգ2
  6. Եթե հրաման = 0x04, ապա reg[արգ1] := reg[արգ1] + mem[արգ2]
  7. ip := ip + 3
  8. Կրկնել 2-րդ կետից:

Ծրագիրը Java լեզվով

/***/
public class EmulatorX {
    // registers
    private int[] reg = new int[4];
    // memory
    private int[] mem = new int[65535];
    // instruction pointer
    private int ip = 0;

    /**
     * Constructor.
     */
    public EmulatorX( int[] program )
    {
        for(int i = 0; i < program.length; ++i)
            mem[i] = program[i];
    }

    /**
     * Emulate.
     */
    public void emulate()
    {
        ip = 0; // setting instruction pointer to first address of memory
        int inst = mem[ip]; // taking instruction code
        int op0 = 0, op1 = 0;   // variables for operands
        while( inst != 0xFF ) {
            op0 = mem[ip+1];    // taking first operand
            op1 = mem[ip+2];    // taking decond operand
            switch( inst ) {
                case 0x00:
                    reg[op0] = op1;
                    break;
                case 0x01:
                    reg[op0] = mem[op1];
                    break;
                case 0x02:
                    mem[op0] = reg[op1];
                    break;
                case 0x03:	
                    reg[op0] += op1;
                    break;
                case 0x04:
                    reg[op0] += mem[op1];
                    break;
                case 0x05:
                    reg[op0] += reg[op1];
                    break;
                case 0x06:
                    reg[op0] -= op1;
                    break;
                case 0x07:
                    reg[op0] -= mem[op1];
                    break;
                case 0x08:
                    reg[op0] -= reg[op1];
                    break;
                case 0x09:
                    reg[op0] *= op1;
                    break;
                case 0x0A:
                    reg[op0] *= mem[op1];
                    break;
                case 0x0B:
                    reg[op0] *= reg[op1];
                    break;
                case 0x0C:
                    // exception - if op1 == 0
                    reg[op0] /= op1;
                    break;
                case 0x0D:
                    // exception - if mem[op1] == 0
                    reg[op0] /= mem[op1];
                    break;
                case 0x0E:
                    // exception - if reg[op1] == 0
                    reg[op0] /= reg[op1];
                    break;
            }
            ip += 3;        // moving to next instruction
            inst = mem[ip]; //taking instruction code
        }
    }
}
Ֆոն-Նեյմանի մեքենայի էմուլյատորի օրինակ, 9.8 out of 10 based on 4 ratings

Նշագրեր: , ,

Բաժին: Java, Ալգորիթմներ

Կիսվել , տարածել , պահպանել

VN:F [1.9.20_1166]
Rating: 9.8/10 (4 votes cast)

Մեկնաբանեք

Կհաստատվեն միայն մեսրոպատառ հայերենով գրած մեկնաբանությունները

203