简单虚拟机

简单虚拟机

         本文参考自《一个简单的虚拟机》

         虚拟机有：

         1.内存：大小100字

         2.寄存器：

指令计数器

指令寄存器

操作码寄存器

内存地址寄存器

累加寄存器

         3.指令：

指令	解释
01	输入
02	输出
03	加载数据到累加寄存器
04	存放累加寄存器数据到内存
05	加
06	减
07	乘
08	除
09	转移
10	小于零转移
11	等于零转移
12	终止
0000	输入结束

         比如有以下程序：打印两个数中的较大数

行号	指令	解释
00	0120	输入一个数到内存20
01	0121	输入一个树到内存21
02	0320	加载内存20中的数据到累加寄存器中
03	0621	累加寄存器减去内存21的数据
04	1007	如果小于0，则转移到内存07
05	0220	输出内存20的数据
06	1200	终止
07	0221	输出内存21的数据
08	1200	终止
09	0000	输入结束

         虚拟机类的定义如下：

// CVirtualMachine的定义：VirtualMachine.h
#pragma once

class CVirtualMachine
{
private:
    int m_memory[100];                        // 内存
    int m_instruction_counter;                // 指令计数器
    int m_instruction_register;               // 指令寄存器
    int m_opcode;                             // 操作码寄存器
    int m_address;                            // 内存地址寄存器
    int m_accumulator;                        // 累加寄存器

public:
    // 虚拟机操作码
    static const int const_input        = 1;  // 操作码：01，存放用户输入的数据到内存
    static const int const_print        = 2;  // 操作码：02，输出内存中的数据到屏幕
    static const int const_load         = 3;  // 操作码：03，加载内存数据到累加寄存器
    static const int const_store        = 4;  // 操作码：04，存放累加寄存器到内存
    static const int const_plus         = 5;  // 操作码：05，累加寄存器数据加上内存数据
    static const int const_minus        = 6;  // 操作码：06，累加寄存器数据减去内存数据
    static const int const_multiply     = 7;  // 操作码：07，累加寄存器数据乘以内存数据
    static const int const_divde        = 8;  // 操作码：08，累加寄存器数据除以内存数据
    static const int const_branch       = 9;  // 操作码：09，转移
    static const int const_branch_below = 10; // 操作码：10，累加寄存器数据小于0，则转移
    static const int const_branch_zero  = 11; // 操作码：11，累加寄存器数据等于0，则转移
    static const int const_halt         = 12; // 操作码：12，终止

public:
    CVirtualMachine();
    ~CVirtualMachine();

    void boot();                              // 启动虚拟机
    void shut();                              // 关闭虚拟机
    void load_program(int* program);          // 加载程序到虚拟机内存
    void print_program();                     // 打印程序
    void run_program();                       // 运行程序
};

         虚拟机类的实现

// CVirtualMachine的实现：VirtualMachine.cpp
#include "VirtualMachine.h"
#include <iostream>

// 初始化虚拟机
CVirtualMachine::CVirtualMachine()
{
    m_instruction_counter = 0;
    m_instruction_register = 0;
    m_opcode = 0;
    m_address = 0;
}

CVirtualMachine::~CVirtualMachine()
{
}

// 启动虚拟机
void CVirtualMachine::boot()
{
    std::cout << "Virtual machine is booting..." << std::endl;
    std::cout << "Complete booting.
" << std::endl;
}

// 关闭虚拟机
void CVirtualMachine::shut()
{
    std::cout << "Virtual machine is shutting..." << std::endl;
    std::cout << "Complete shutting.
" << std::endl;
}

// 加载程序到虚拟机内存
void CVirtualMachine::load_program(int* program)
{
    int index;
    std::cout << "Virtual machine is loading the program..." << std::endl;
    for (index = 0; index < 100 && program[index] != 0; ++index)
    {
        m_memory[index] = program[index];
    }
    m_memory[index] = program[index];
    std::cout << "Complete loading.
" << std::endl;
}

// 打印程序
void CVirtualMachine::print_program()
{
    int index;
    std::cout << "Virtual machine is printing the program..." << std::endl;
    for (index = 0; index < 100 && m_memory[index] != 0; ++index)
    {
        std::cout << index / 10 << index % 10 << '	';
        std::cout << m_memory[index] / 1000 << m_memory[index] % 1000 / 100
                  << m_memory[index] % 100 / 10 << m_memory[index] % 10
                  << std::endl;
    }
    std::cout << "Complete printing.
" << std::endl;
}

// 运行程序：SimpleVirtualMachine.cpp
void CVirtualMachine::run_program()
{
    int index;
    std::cout << "Virtual machine is running the program..." << std::endl;

    // 取出指令
    m_instruction_counter = 0;
    m_instruction_register = m_memory[m_instruction_counter];
    ++m_instruction_counter;

    // 指令解码
    m_opcode = m_instruction_register / 100;
    m_address = m_instruction_register % 100;
    for (index = 0; index < 100 && m_opcode != const_halt; ++index)
    {
        std::cout << '	' << "指令" << '	' << "地址" << std::endl;
        std::cout << (m_instruction_counter - 1) / 10 << (m_instruction_counter - 1) % 10 << '	' << m_opcode / 10 << m_opcode % 10 << '	' << m_address / 10 << m_address % 10 << std::endl;

        // 执行指令
        switch (m_opcode)
        {
        case const_input:
            int buffer;
            std::cin >> buffer;
            m_memory[m_address] = buffer;
            break;

        case const_print:
            std::cout << m_memory[m_address] << std::endl;
            break;

        case const_load:
            m_accumulator = m_memory[m_address];
            break;

        case const_store:
            m_memory[m_address] = m_accumulator;
            break;

        case const_plus:
            m_accumulator += m_memory[m_address];
            break;

        case const_minus:
            m_accumulator -= m_memory[m_address];
            break;

        case const_multiply:
            m_accumulator *= m_memory[m_address];
            break;

        case const_divde:
            m_accumulator /= m_memory[m_address];
            break;

        case const_branch:
            m_instruction_counter = m_address;
            break;

        case const_branch_below:
            if (m_accumulator < 0)
            {
                m_instruction_counter = m_address;
            }
            break;

        case const_branch_zero:
            if (m_accumulator == 0)
            {
                m_instruction_counter = m_address;
            }
            break;

        default:
            break;
        }
        std::cout << std::endl;

        // 取出指令
        m_instruction_register = m_memory[m_instruction_counter];
        ++m_instruction_counter;

        // 指令解码
        m_opcode = m_instruction_register / 100;
        m_address = m_instruction_register % 100;
    }
    std::cout << "Complete running.
" << std::endl;
}

         测试：启动虚拟机、输入程序、加载程序到虚拟机内存、打印程序、运行程序、关闭虚拟机。

// 测试虚拟机：SimpleVirtualMachine.cpp
#include "VirtualMachine.h"
#include <iostream>
using namespace std;

int main()
{
    CVirtualMachine virutal_machine; // 创建虚拟机对象
    int program[100];                // 存放程序
    int buffer;

    // 启动虚拟机
    virutal_machine.boot();
    // 输入程序
    cout << "Please enter your program:" << endl;
    cout << "00	";
    cin >> buffer;
    for (int index = 0; (program[index] = buffer) != 0; ++index)
    {
        cout << (index + 1) / 10 << (index + 1) % 10 << '	';
        cin >> buffer;
    }
    cout << "Good job." << endl;

    // 加载程序到虚拟机内存
    virutal_machine.load_program(program);
    // 打印程序
    virutal_machine.print_program();
    // 运行程序
    virutal_machine.run_program();

    // 关闭虚拟机
    virutal_machine.shut();

    char ch;
    cout << "Window closing" << endl;
    cin >> ch;

    return 0;
}

         总结

         上文内容均来自于《一个简单的虚拟机》。通过对这一简单虚拟机的学习，初步了解了虚拟机相关的知识。本文涉及的虚拟机是寄存器虚拟机，此外还有栈虚拟机。下一步将进一步学习寄存器虚拟机以及栈虚拟机，了解更多关于虚拟机方面的原理和实现机制。