Why can't we create virtualization that runs on multiple machines?

Question

You are probably familiar with virtualization, which takes one host and can "emulate" many instances, sharing resources among all. You have probably heard of XEN .

Is it completely impossible to imagine the “opposite” of XEN: a layer that abstracts multiple hosts in one running instance ? I believe that this will allow you to create applications that do not need significant care about the “clustering” layer.

I wonder what the technical limitations are for this, because I'm sure some people are already working on this somewhere :)

The goal is not to achieve any recovery of failure. I believe that this can (and should?) Be handled at a higher level. For example, if someone can run the MySQL server on a gigantic instance (for example, 50 hosts), then you can easily use the MySQL replication functions to replicate the database over a similar virtual instance.

Answer 1

Good question. Microsoft Azure tries to solve this problem by allowing you to host applications in the cloud and should not be interested in up / down scaling, redundancy, data storage, etc. But this is not done at the hypervisor level.

http://www.microsoft.com/windowsazure/

Hardware, there are some drawbacks, so that everything was one big virtual machine, and not many smaller ones. First, software does not always understand how to process all resources. For example, some applications still cannot process multiple processor cores. I have seen unofficial tests showing that IIS is better at distributing the same resources across multiple instances, rather than one gigantic instance.

From a management point of view, it is probably best to have multiple virtual machines in certain cases. Imagine a poor deployment corrupts a node. If this was your only (albeit giant) node, now your entire application is down.

Answer 2

You are probably talking about the concept of a single system image .

There used to be an implementation of Linux, openMosix , which was closed. I do not know any replacements. openMosix simplified the creation and use of SSI on a standard Linux kernel; Too bad he overtook events.

Answer 3

I don’t know enough about Xen to find out if this is possible, but with VMware you can create resource pools that come from many physical hosts. Then you can assign resources to your virtual machines. It can be many virtual machines or just one virtual machine. Aggregation: Converting Isolated Resources to Shared Pools

Answer 4

I agree with ethimu, you are talking about the concept of Single System Image. In addition to the OpenMosix project, several commercial implementations of the same idea were implemented (one modern example is ScaleMP). This is not a new idea.

I just wanted to dwell on some of the technical aspects of SSI.

Basically, the reason this is not done is because performance is generally completely unpredictable or terrible. There is a concept in computer systems known as [NUMA] [3], which basically means that the cost of accessing different parts of the memory is uneven. This can be applied to huge systems in which processors can access memory for different microcircuits or in cases where memory is accessed remotely over the network (for example, in SSI). Typically, the operating system will try to compensate for this by laying out programs and data in memory so that the program can run as quickly as possible. Ie, code and data will be placed in the same NUMA region and should be scheduled on the nearest possible CPU.

However, in cases where you run large applications (trying to use all the memory in your SSI), the operating system can do little to reduce the impact of remote memory retrievals. MySQL does not know that access to page 0x1f3c will cost 8 nanoseconds, and access to page 0x7f46 will stop it for hundreds of microseconds, possibly milliseconds, while memory is loaded over the network. This means that applications that do not support NUMA will work like shit (seriously, really bad) in such conditions. As far as I know, most modern SSI products rely on the fastest interconnects (like Infiniband) between machines to achieve even missed performance.

That is why frameworks that reveal the true cost of accessing data to a programmer (e.g. MPI: messaging interface) have achieved more traction than SSI or DSM (Distributed Shared Memory) approaches. In fact, it is not possible for a programmer to optimize an application to work in an SSI environment that simply sucks.

Answer 5

Simulating a single core on multiple physical cores is very inefficient. You can do this, but it will be slower than a cluster. Two physical cores can talk to each other almost in real time, if they are on separate computers, then you do something like you want to reduce the speed of your motherboard by 10 or more times, if these two physical cores (and RAM) interact even over a fiber optic network.

Dual cores can communicate faster than two different processors on the same motherboard, if they are on different machines, this is slower if there are several machines, even slower.

Basically, you can, but there is a net performance loss compared to the network performance gain that you would hope to achieve.

Real life example, I had a bunch of virtual machines on a dual-core quad-core server (~ 2.5 GHz / core), capable of lower than they should have been. Upon closer examination, it turned out that the hypervisor emulated a single core of 3.5-4 GHz, when the load on a separate virtual machine was more than 2.5 GHz - after the limitation of each VM to 2.5 GHz was returned to the expected one.