Как написать виртуальную машину

• Download B32 Virtual Machine source code — 30.7 KB
• Download B32 Virtual Machine complete tutorial (PDF) — 2.02 MB

Attention People

I am working on a new version of this, a B33 virtual machine. I will post it on here when its done. This one will not have a PDF and the full tutorial will be contained in the code project article. I will make sure I let everyone know when its done! 

Introduction 

Have you ever wondered how the Microsoft .NET Framework or how a Java virtual machine works? Have you ever wondered how to create your own emulator to target a specific computer you own? If you answered yes to any of these questions, then you will find my tutorial helpful. B32 is a complete virtual machine created in C#. This is part 1 of a 2 part series. The tutorial presented here on CodeProject is a condensed version of the complete PDF tutorial. In this part of the tutorial, I will explain the fundamentals, enough to get us started, and we will code the assembler portion of our virtual machine. Part 2 will build the actual virtual machine. The tutorial starts from scratch with a new project and solution. It will teach you how to write both, an assembler for our B32 intermediate language code, and it will teach you how to write the virtual machine itself.

Intended Audience

This tutorial assumes you are pretty familiar with C# and Visual Studio 2005 or 2008. This tutorial was written with Visual Studio 2008, targeting the .NET Framework 2.0. It should also work with Visual Studio 2005. Some of the concepts introduced in this tutorial may be a little hard for a beginner C# programmer to understand. I have tried to make it as simple to understand as possible. Keep in mind that, after reading this tutorial, no one will be able to walk away from it ready to build the next Java or something. Virtual machines are very complex tasks, and even simple ones can take many years to make. If you need help or have questions, you are welcome to post them here or email me direct at icemanind@yahoo.com. If I lose any of you, I suggest reading the PDF and using it as a reference to supplement this article. The PDF goes into more details.

Virtual Machine Fundamentals

To build a virtual machine, you first need to understand what a virtual machine is. A virtual machine is a software implementation of either a real physical machine or a fictional machine. To create a virtual machine, we first need to define an intermediate language (sometimes called an assembly language). This intermediate language will be the lowest level, human readable code, that will eventually get assembled into bytecode. Bytecode consists of one or more bytes of data that is readable only by our virtual machine (in real world machines, this would be called the «machine language»). The «assembler», which converts Intermediate Language into bytecode, will be the first tool we will develop. This will be developed in this part of the tutorial.

Planning Out our Virtual Machine

Before getting our hands dirty with any code, we need to plan out our virtual machine and how it will work. I believe in trying to stick with the KISS (Keep It Simple Stupid) principle whenever possible. B32, the virtual machine created in this tutorial, is going to be a 16-bit machine. It will have access to 64K of memory, and B32 bytecode programs will have access to any of this memory ranging from $0000 — $FFFF. 64K may not seem like a lot of memory compared to today’s modern computers; however, as you will see, 64K will be more than enough to produce some interesting B32 programs.

I said that programs would have access to 64K of memory; however, not all of this will be for storage. From $A000 — $AFA0, this 4K area of memory will be devoted to our B32 screen output. Screen output in our virtual machine will work very similar to older DOS programs. There will be 1 byte for the character and 1 byte for the attribute on an 80×25 screen. The attribute byte comes after the character byte, and it defines the foreground and background color of the character.

Our virtual machine will have two 8-bit registers called ‘A’ and ‘B’. Registers are kind of like variables in programming. We can store any number between 0 and 255 in either register ‘A’, ‘B’, or both. In addition, we are going to have two 16-bit registers called ‘X’ and ‘Y’. These registers can hold any value from 0 to 65,535. As if that’s not enough, we are going to have one more 16-bit register called ‘D’. This register is unique, as ‘D’ represents the high order bits and low order bits of registers ‘A’ and ‘B’. In other words, if we were to store a value of $12F9 in our D register, then it would automatically change register ‘A’ to have the value $12 and register ‘B’ to have the value $F9. The opposite is also true. If we store $C1 in register ‘A’ and $78 in register ‘B’, then register ‘D’ would have the value $C178.

Before diving into creating our assembler, we need to define at least three mnemonics for now to make any kind of useful program. Mnemonics, by the way, are the building blocks of our intermediate language. They are human readable characters, usually 3-5 characters long, that tell the assembler what we want to do; e.g., «The verb». Most (but not all) mnemonics have an operand. An operand is some kind of data or information for the mnemonic to act on. For now, our assembler will understand the following mnemonics:

If you are confused by what ‘STA‘ actually does, think of it like this. If ‘X’ register contained $1234 and ‘A’ register contained $9F, then executing ‘STA‘ would store the value $9F at memory location $1234. The rest of the mnemonics should make sense.

Here is our first B32 assembly test file, which will compile with our assembler, once it is done:

START:
 LDA #65
 LDX #$A000
 STA ,X
 END START

You may be wondering what the pound sign ‘#’ means? In our B32 intermediate language, the ‘#’ will always mean «use this data», or rather, use the value immediately following the pound sign. The first line in our program is called a label. A label is a human readable point of reference in our program. Labels must start with a letter and end with a colon ‘:’, followed by a new line. For simplicity, our assembler will not have any error checking, so we must play by some rules. All mnemonics must be preceded by one or more spaces. This is how our assembler knows whether the text is a label or a mnemonic. Labels, obviously, should not have a space preceding them. The second line assigns the value 65 to our ‘A’ register. The third line assigns the hexadecimal number $A000 to our ‘X’ register. The fourth line says to store the value of the ‘A’ register into the memory location pointed to by our ‘X’ register. In other words, store 65 at $A000. The final line in the program tells our program to end. The ‘START‘ preceding END tells the assembler where the execution of this program should begin. In this case, it starts at the ‘START‘ label, which is the beginning of our program.

You might be able to guess at what this will do. Remember, we said earlier that our screen will start at $A000? This program should put a capital letter ‘A’ (65 is ASCII for the letter ‘A’) in the upper left hand corner of our B32 screen. Pretty dull, I know. But it will demonstrate the workings of our assembler and virtual machine.

The last thing we need to do before we start building the assembler is to define a B32 binary file format. Our file format should start with a header with some magic numbers so that our virtual machine will know if our program is a valid B32 binary file. Our B32 binaries will start with the letters ‘B32’. That will be our magic number. After that will be the 16-bit starting address. This defines where in our 64K memory our program is to be loaded. Our assembler will default our origin to $1000, but we can change that to anything. Following that will be the 16-bit execution address. This is where the execution of our binary program will start. Finally, our bytecode will follow.

Building our Assembler

You can download the source code to both the assembler and the virtual machine from up above. Keep in mind that the source code was built using the PDF tutorial. Therefore, our assembler will have a lot more functionality and mnemonics built into it than what is explained in this section. Rather than explaining a step-by-step process for building the assembler, I will just explain the important parts. If you want a step-by-step, read the PDF file attached above.

The assembler works by first reading in the source file into a string buffer, and then by opening a BinaryWriter stream, pointing to our output B32 binary program:

private void btnAssemble_Click(object sender, EventArgs e)
{
    AsLength = Convert.ToUInt16(this.txtOrigin.Text, 16);
    System.IO.BinaryWriter output;
    System.IO.TextReader input;
    System.IO.FileStream fs = new System.IO.FileStream(
        this.txtOutputFileName.Text, System.IO.FileMode.Create);

    output = new System.IO.BinaryWriter(fs);

    input = System.IO.File.OpenText(this.txtSourceFileName.Text);
    SourceProgram = input.ReadToEnd();
    input.Close();

    output.Write('B');
    output.Write('3');
    output.Write('2');
    output.Write(Convert.ToUInt16(this.txtOrigin.Text, 16));
    output.Write((ushort)0);
    Parse(output);

    output.Seek(5, System.IO.SeekOrigin.Begin);
    output.Write(ExecutionAddress);
    output.Close();
    fs.Close();
    MessageBox.Show("Done!");
}

Notice our B32 magic bytes are written followed by the origin (or start address), followed by a 16-bit zero. This zero will be replaced later by the execution address. For now, we have no way of knowing what that will be. A call to Parse() is made, which is where most of our work is done. Once it’s done, we seek back to that zero we placed earlier and replace it with the execution address. Finally, we close the streams and show a «Done!» box.

Our assembler works in two passes. The first pass simply scans the assembly file for all the labels and stores those labels in a hash table. This first pass is crucial in case there is a reference to a future label. The second pass does the hard part of converting the mnemonics into bytecode. Here is our Parse() function:

private void Parse(System.IO.BinaryWriter OutputFile)
{
    CurrentNdx = 0;
    while (IsEnd == false)
        LabelScan(OutputFile, true);

    IsEnd = false;
    CurrentNdx = 0;
    AsLength = Convert.ToUInt16(this.txtOrigin.Text, 16);

    while (IsEnd == false)
        LabelScan(OutputFile, false);
}

This function simply goes into a loop, calling another function called LabelScan. The first loop is the first pass. After resetting the index, it goes into a second loop. This is our second pass. All LabelScan() does is detect if the first character is a space. If it is, it assumes it is not a label, and it reads in the mnemonic. This mnemonic is passed off to another function that uses a series of ‘if‘ statements on the mnemonic, calling the appropriate function to process the mnemonic:

private void ReadMneumonic(System.IO.BinaryWriter OutputFile, bool IsLabelScan)
{
    string Mneumonic = "";

    while (!(char.IsWhiteSpace(SourceProgram[CurrentNdx])))
    {
        Mneumonic = Mneumonic + SourceProgram[CurrentNdx];
        CurrentNdx++;
    }
    if (Mneumonic.ToUpper() == "LDX") InterpretLDX(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "LDA") InterpretLDA(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "STA") InterpretSTA(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "END")
    { IsEnd = true; DoEnd(OutputFile, IsLabelScan); EatWhiteSpaces(); 
      ExecutionAddress = (ushort)LabelTable[(GetLabelName())]; return; }

}

Each of the Interpret() functions pretty much do the same thing. They read the operand, if there is one, then writes the appropriate byte code to the output file.

If you download the assembler from the link above, go ahead and try to compile our test program. Remember to precede each mnemonic with at least one space (mnemonics only, not labels). Also, remember to end the last line with a new line. Keep those two rules in mind, and the test program should compile and produce a .B32 binary file.

If you want more details on how the compiler works, reference the PDF tutorial. It goes into a lot more depth.

History

This is my first PDF tutorial. I wanted to get my feet wet a little bit and see how people responded to my writing and tutorial skills. This is only part 1 of the virtual machine tutorial. Part 2 will go into how to build the actual virtual machine. Please leave feedback, good or bad, and let me know if this was a help to you.

• Download B32 Virtual Machine source code — 30.7 KB
• Download B32 Virtual Machine complete tutorial (PDF) — 2.02 MB

Attention People

I am working on a new version of this, a B33 virtual machine. I will post it on here when its done. This one will not have a PDF and the full tutorial will be contained in the code project article. I will make sure I let everyone know when its done! 

Introduction 

Have you ever wondered how the Microsoft .NET Framework or how a Java virtual machine works? Have you ever wondered how to create your own emulator to target a specific computer you own? If you answered yes to any of these questions, then you will find my tutorial helpful. B32 is a complete virtual machine created in C#. This is part 1 of a 2 part series. The tutorial presented here on CodeProject is a condensed version of the complete PDF tutorial. In this part of the tutorial, I will explain the fundamentals, enough to get us started, and we will code the assembler portion of our virtual machine. Part 2 will build the actual virtual machine. The tutorial starts from scratch with a new project and solution. It will teach you how to write both, an assembler for our B32 intermediate language code, and it will teach you how to write the virtual machine itself.

Intended Audience

This tutorial assumes you are pretty familiar with C# and Visual Studio 2005 or 2008. This tutorial was written with Visual Studio 2008, targeting the .NET Framework 2.0. It should also work with Visual Studio 2005. Some of the concepts introduced in this tutorial may be a little hard for a beginner C# programmer to understand. I have tried to make it as simple to understand as possible. Keep in mind that, after reading this tutorial, no one will be able to walk away from it ready to build the next Java or something. Virtual machines are very complex tasks, and even simple ones can take many years to make. If you need help or have questions, you are welcome to post them here or email me direct at icemanind@yahoo.com. If I lose any of you, I suggest reading the PDF and using it as a reference to supplement this article. The PDF goes into more details.

Virtual Machine Fundamentals

To build a virtual machine, you first need to understand what a virtual machine is. A virtual machine is a software implementation of either a real physical machine or a fictional machine. To create a virtual machine, we first need to define an intermediate language (sometimes called an assembly language). This intermediate language will be the lowest level, human readable code, that will eventually get assembled into bytecode. Bytecode consists of one or more bytes of data that is readable only by our virtual machine (in real world machines, this would be called the «machine language»). The «assembler», which converts Intermediate Language into bytecode, will be the first tool we will develop. This will be developed in this part of the tutorial.

Planning Out our Virtual Machine

Before getting our hands dirty with any code, we need to plan out our virtual machine and how it will work. I believe in trying to stick with the KISS (Keep It Simple Stupid) principle whenever possible. B32, the virtual machine created in this tutorial, is going to be a 16-bit machine. It will have access to 64K of memory, and B32 bytecode programs will have access to any of this memory ranging from $0000 — $FFFF. 64K may not seem like a lot of memory compared to today’s modern computers; however, as you will see, 64K will be more than enough to produce some interesting B32 programs.

I said that programs would have access to 64K of memory; however, not all of this will be for storage. From $A000 — $AFA0, this 4K area of memory will be devoted to our B32 screen output. Screen output in our virtual machine will work very similar to older DOS programs. There will be 1 byte for the character and 1 byte for the attribute on an 80×25 screen. The attribute byte comes after the character byte, and it defines the foreground and background color of the character.

Our virtual machine will have two 8-bit registers called ‘A’ and ‘B’. Registers are kind of like variables in programming. We can store any number between 0 and 255 in either register ‘A’, ‘B’, or both. In addition, we are going to have two 16-bit registers called ‘X’ and ‘Y’. These registers can hold any value from 0 to 65,535. As if that’s not enough, we are going to have one more 16-bit register called ‘D’. This register is unique, as ‘D’ represents the high order bits and low order bits of registers ‘A’ and ‘B’. In other words, if we were to store a value of $12F9 in our D register, then it would automatically change register ‘A’ to have the value $12 and register ‘B’ to have the value $F9. The opposite is also true. If we store $C1 in register ‘A’ and $78 in register ‘B’, then register ‘D’ would have the value $C178.

Before diving into creating our assembler, we need to define at least three mnemonics for now to make any kind of useful program. Mnemonics, by the way, are the building blocks of our intermediate language. They are human readable characters, usually 3-5 characters long, that tell the assembler what we want to do; e.g., «The verb». Most (but not all) mnemonics have an operand. An operand is some kind of data or information for the mnemonic to act on. For now, our assembler will understand the following mnemonics:

If you are confused by what ‘STA‘ actually does, think of it like this. If ‘X’ register contained $1234 and ‘A’ register contained $9F, then executing ‘STA‘ would store the value $9F at memory location $1234. The rest of the mnemonics should make sense.

Here is our first B32 assembly test file, which will compile with our assembler, once it is done:

START:
 LDA #65
 LDX #$A000
 STA ,X
 END START

You may be wondering what the pound sign ‘#’ means? In our B32 intermediate language, the ‘#’ will always mean «use this data», or rather, use the value immediately following the pound sign. The first line in our program is called a label. A label is a human readable point of reference in our program. Labels must start with a letter and end with a colon ‘:’, followed by a new line. For simplicity, our assembler will not have any error checking, so we must play by some rules. All mnemonics must be preceded by one or more spaces. This is how our assembler knows whether the text is a label or a mnemonic. Labels, obviously, should not have a space preceding them. The second line assigns the value 65 to our ‘A’ register. The third line assigns the hexadecimal number $A000 to our ‘X’ register. The fourth line says to store the value of the ‘A’ register into the memory location pointed to by our ‘X’ register. In other words, store 65 at $A000. The final line in the program tells our program to end. The ‘START‘ preceding END tells the assembler where the execution of this program should begin. In this case, it starts at the ‘START‘ label, which is the beginning of our program.

You might be able to guess at what this will do. Remember, we said earlier that our screen will start at $A000? This program should put a capital letter ‘A’ (65 is ASCII for the letter ‘A’) in the upper left hand corner of our B32 screen. Pretty dull, I know. But it will demonstrate the workings of our assembler and virtual machine.

The last thing we need to do before we start building the assembler is to define a B32 binary file format. Our file format should start with a header with some magic numbers so that our virtual machine will know if our program is a valid B32 binary file. Our B32 binaries will start with the letters ‘B32’. That will be our magic number. After that will be the 16-bit starting address. This defines where in our 64K memory our program is to be loaded. Our assembler will default our origin to $1000, but we can change that to anything. Following that will be the 16-bit execution address. This is where the execution of our binary program will start. Finally, our bytecode will follow.

Building our Assembler

You can download the source code to both the assembler and the virtual machine from up above. Keep in mind that the source code was built using the PDF tutorial. Therefore, our assembler will have a lot more functionality and mnemonics built into it than what is explained in this section. Rather than explaining a step-by-step process for building the assembler, I will just explain the important parts. If you want a step-by-step, read the PDF file attached above.

The assembler works by first reading in the source file into a string buffer, and then by opening a BinaryWriter stream, pointing to our output B32 binary program:

private void btnAssemble_Click(object sender, EventArgs e)
{
    AsLength = Convert.ToUInt16(this.txtOrigin.Text, 16);
    System.IO.BinaryWriter output;
    System.IO.TextReader input;
    System.IO.FileStream fs = new System.IO.FileStream(
        this.txtOutputFileName.Text, System.IO.FileMode.Create);

    output = new System.IO.BinaryWriter(fs);

    input = System.IO.File.OpenText(this.txtSourceFileName.Text);
    SourceProgram = input.ReadToEnd();
    input.Close();

    output.Write('B');
    output.Write('3');
    output.Write('2');
    output.Write(Convert.ToUInt16(this.txtOrigin.Text, 16));
    output.Write((ushort)0);
    Parse(output);

    output.Seek(5, System.IO.SeekOrigin.Begin);
    output.Write(ExecutionAddress);
    output.Close();
    fs.Close();
    MessageBox.Show("Done!");
}

Notice our B32 magic bytes are written followed by the origin (or start address), followed by a 16-bit zero. This zero will be replaced later by the execution address. For now, we have no way of knowing what that will be. A call to Parse() is made, which is where most of our work is done. Once it’s done, we seek back to that zero we placed earlier and replace it with the execution address. Finally, we close the streams and show a «Done!» box.

Our assembler works in two passes. The first pass simply scans the assembly file for all the labels and stores those labels in a hash table. This first pass is crucial in case there is a reference to a future label. The second pass does the hard part of converting the mnemonics into bytecode. Here is our Parse() function:

private void Parse(System.IO.BinaryWriter OutputFile)
{
    CurrentNdx = 0;
    while (IsEnd == false)
        LabelScan(OutputFile, true);

    IsEnd = false;
    CurrentNdx = 0;
    AsLength = Convert.ToUInt16(this.txtOrigin.Text, 16);

    while (IsEnd == false)
        LabelScan(OutputFile, false);
}

This function simply goes into a loop, calling another function called LabelScan. The first loop is the first pass. After resetting the index, it goes into a second loop. This is our second pass. All LabelScan() does is detect if the first character is a space. If it is, it assumes it is not a label, and it reads in the mnemonic. This mnemonic is passed off to another function that uses a series of ‘if‘ statements on the mnemonic, calling the appropriate function to process the mnemonic:

private void ReadMneumonic(System.IO.BinaryWriter OutputFile, bool IsLabelScan)
{
    string Mneumonic = "";

    while (!(char.IsWhiteSpace(SourceProgram[CurrentNdx])))
    {
        Mneumonic = Mneumonic + SourceProgram[CurrentNdx];
        CurrentNdx++;
    }
    if (Mneumonic.ToUpper() == "LDX") InterpretLDX(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "LDA") InterpretLDA(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "STA") InterpretSTA(OutputFile, IsLabelScan);
    if (Mneumonic.ToUpper() == "END")
    { IsEnd = true; DoEnd(OutputFile, IsLabelScan); EatWhiteSpaces(); 
      ExecutionAddress = (ushort)LabelTable[(GetLabelName())]; return; }

}

Each of the Interpret() functions pretty much do the same thing. They read the operand, if there is one, then writes the appropriate byte code to the output file.

If you download the assembler from the link above, go ahead and try to compile our test program. Remember to precede each mnemonic with at least one space (mnemonics only, not labels). Also, remember to end the last line with a new line. Keep those two rules in mind, and the test program should compile and produce a .B32 binary file.

If you want more details on how the compiler works, reference the PDF tutorial. It goes into a lot more depth.

History

This is my first PDF tutorial. I wanted to get my feet wet a little bit and see how people responded to my writing and tutorial skills. This is only part 1 of the virtual machine tutorial. Part 2 will go into how to build the actual virtual machine. Please leave feedback, good or bad, and let me know if this was a help to you.

Что такое виртуальная машина

В статье мы расскажем, что называется виртуальной машиной и для чего она предназначена, разберём преимущества и недостатки использования виртуальных машин, кратко рассмотрим 4 виртуальные машины и установим VirtualBox.

Что такое виртуальная машина и зачем она нужна

Виртуальная машина (ВМ или VM) — это виртуальный компьютер, который использует выделенные ресурсы реального компьютера (процессор, диск, адаптер). Эти ресурсы хранятся в облаке и позволяют ВМ работать автономно. Простыми словами, виртуальная машина позволяет создать на одном компьютере ещё один компьютер, который будет использовать его ресурсы, но работать изолированно.

ВМ может работать в отдельном окне как программа или запускаться через панель управления.

Виртуализация, и виртуальная машина в частности, расширяет возможности IT-инфраструктуры. Она будет полезна разработчикам программных продуктов, веб-дизайнерам, а также тем, кто планирует перейти на новую ОС, но не уверен в выборе.

Для чего нужна виртуальная машина:

• чтобы разворачивать две и более независимые операционные системы на одном физическом устройстве. Например, на вашем компьютере установлена операционная система Windows 7, а на виртуальную машину вы установили Windows XP/8/10 или Linux;
• для экспериментов с программным обеспечением (например, кодом, предназначенным для запуска в различных ОС), не подвергая риску стабильность компьютера;
• чтобы устанавливать и тестировать различные программы и утилиты, не занимая место на основном ПК;
• чтобы запускать программы, которые не поддерживает основная ОС, или подключать оборудование, несовместимое с ней. Например, применять Windows-программы на Mac или Linux;
• для безопасного запуска приложения (программы), которое вызывает недоверие или подозрение на вирусы;
• чтобы эмулировать компьютерные сети и сложные среды, не настраивая виртуальную машину каждый раз. Можно сохранить настройки и продолжить с того этапа, где остановились;
• для создания резервных копий ОС.

Если сравнивать функции виртуальной машины с работой на обычном ПК, то можно выделить как преимущества, так и недостатки.

Преимущества виртуальной машины

1. Можно выключить ПК или перейти к другой задаче с сохранением текущего состояния машины. Если вы решите продолжить работу, ВМ загрузится в том состоянии, в котором находилась в момент выключения.
2. На VM можно делать снапшоты, которые позволяют откатываться до предыдущих конфигураций. Это удобно, если при тестировании нестабильного софта произошла критическая ошибка. По сравнению с основной системой, для ВМ выделяется меньше места на дисковом пространстве и откат до раннего состояния происходит быстрее.
3. Машину можно сохранять или дублировать как изолированную среду. Её можно будет запустить позднее или скопировать на другой ПК. Заданные конфигурации сохранятся.
4. ВМ вместе со всеми данными легко переносится с одного ПК на другой. Портативный софт для виртуальной машины сохраняет информацию одним файлом (в виде образа системы) на физическом компьютере. Для переноса достаточно переместить этот файл.
5. ВМ не занимает место постоянной памяти, а оперирует выделенной временной памятью. Все действия фиксируются в виде лога, который очищается при завершении каждого сеанса.
6. Для переподключения на другую ОС не нужно перезагружать компьютер.
7. На одном устройстве можно хранить несколько виртуальных машин с несколькими ОС в разных состояниях.

Недостатки использования VM

1. Чтобы одновременно запускать на ВМ несколько операционных систем, нужно иметь соответствующие аппаратные ресурсы.
2. ОС в виртуальных машинах могут работать медленнее. Несмотря на то что показатели производительности виртуальных ОС стремятся к показателям физических ОС, на данный момент развития они всё-таки не равны.
3. Виртуальная платформа поддерживает не весь функционал аппаратного обеспечения. VMware уже поддерживает USB 3.0, контроллеры портов COM и LPT и приводы CD-ROM, но с виртуализацией видеоадаптеров и поддержкой функций аппаратного ускорения трехмерной графики могут быть сложности.

Ниже мы расскажем про самые популярные и простые в использовании виртуальные машины и разберём их недостатки и преимущества.

Какие бывают виртуальные машины

К самым популярным виртуальным машинам относятся:

• VirtualBox,
• Microsoft Hyper-V,
• VMware Workstation Player,
• Parallels Desktop.

Microsoft Hyper-V ― это VM от Майкрософт.

VMware Workstation ― платная мощная виртуальная машина для профессионального использования. Работает в основном с Windows и Linux. Имеет бесплатную версию VMware Player, но она значительно ограничена функционалом.

Parallels Desktop ― это ВМ, которая позволяет использовать программы разных операционных систем на Mac.

VirtualBox ― cамая популярная программа виртуализации с открытым исходным кодом. С её помощью можно запускать любые операционные системы, например Windows, Linux, Mac, Android. Программа имеет русифицированный интерфейс и проста в применении.

Все машины имеют свои сильные и слабые стороны. Нельзя рекомендовать только одну. Для примера мы рассмотрим, как создать виртуальную машину Oracle VirtualBox.

Как создать виртуальную машину Oracle VirtualBox

Готово, вы создали VM Oracle. Теперь переходите к установке операционной системы.

Как установить операционную систему в Oracle VirtualBox

Рассмотрим, как установить операционную систему на примере Ubuntu 20.04.

Теперь вы знаете, зачем нужна виртуальная машина и как запустить её с помощью программы VirtualBox.

Виртуальный дата-центр VMware

Кроме VM, есть более крупные решения ― виртуальные дата-центры. Например, виртуальный дата-центр VMware, который можно заказать в REG.RU.

Для чего используют виртуальный дата-центр?

Эта услуга подходит для применения как частными лицами, так и крупными организациями и корпорациями. Возможности виртуализации в совокупности с облачными вычислениями обладают такими преимуществами как масштабируемость, экономичность и доступность ресурсов в любое время. Можно создавать и развёртывать несколько ВМ одновременно. К примеру, вы можете создать один виртуальный контейнер vApp с машинами для тестовой среды, а другой — для продуктивной. При этом у вас будет возможность изолировать их с помощью разных сетей. Подробнее об услуге читайте в статье: Как начать работу с VMware.

Теперь вы знаете, что собой представляет ВМ, что делает виртуальная машина и какими ресурсами виртуальной машины можно управлять, и при необходимости можете заказать Виртуальный дата-центр VMware в REG.RU.