QEMU VS oVirt

My most-wanted QEMU feature: https://github.com/qemu/qemu/commit/a2260983c6553

Using `gic-version=3` on macOS you can now use more than 8 cores on ARM chips.

A better solution is just to write a plain ass shell script that tests if various C snippets compile.

https://github.com/oilshell/oil/blob/master/configure

https://github.com/oilshell/oil/blob/master/build/detect-pwe...

Not an unholy mix of m4, shell, and C, all in the same file.

---

These are the same style as a the configure scripts that Fabrice Bellard wrote for tcc and QEMU.

They are plain ass shell scripts, because he actually understands the code he writes.

https://github.com/qemu/qemu/blob/master/configure

https://github.com/TinyCC/tinycc/blob/mob/configure

OCaml’s configure script is also “normal”.

You don’t have to copy and paste thousands of lines of GNU stuff that you don’t understand.

(copy of lobste.rs comment)

Related:

A fast Pascal (Delphi) WebAssembly interpreter:

https://github.com/marat1961/wasm

WASM-4:

https://github.com/aduros/wasm4

Curated list of awesome things regarding WebAssembly (wasm) ecosystem:

https://github.com/mbasso/awesome-wasm

Also, it would be nice if there was a WASM (soft) CPU for QEMU, which (if it existed!) would go here:

https://github.com/qemu/qemu/tree/master/target

> architectural registers are always updated

In tiny code, the guest registers (global TCG variables) are stored in the host's registers until you either call an helper which can access the CPU state or you return (`git grep la_global_sync`). This is the reason why QEMU is not so terribly slow.

But after a check, this also happens when you access the guest memory address space! https://github.com/qemu/qemu/blob/master/include/tcg/tcg-opc... (TCG_OPF_SIDE_EFFECTS is what matters)

But still, in the end, it's the same problem. What QEMU does, can be done in LLVM too. You could probably be more efficient in LLVM by using the exception handling mechanism (invoke and friends) to only serialize back to memory when there's an actual exception, at the cost of higher register pressure. More or less what we do here: https://rev.ng/downloads/bar-2019-paper.pdf

Um, in case you don't know, UTM (based on QEMU) is out for quite a while.

Some of these tools include Oracle VM VirtualBox (that I've used since before the acquisition of Sun Microsystems by Oracle), VMWare Workstation Player, and QEMU, but last year, I found out about Multipass.

For C/C++ projects that use meson as the build system, there is an excellent way to manage dependencies:

https://mesonbuild.com/Wrapdb-projects.html

https://mesonbuild.com/Wrap-dependency-system-manual.html

meson will download and build the libraries automatically and give you a variable which you pass as a regular dependency into the built target:

https://github.com/qemu/qemu/tree/005ad32358f12fe9313a4a0191...

https://github.com/harfbuzz/harfbuzz/tree/main/subprojects

https://github.com/harfbuzz/harfbuzz/blob/37457412b3212463c5...

Or, if you're using proper operating systems, they're managed by the usual package manager, just like everything else.

For all the users of the Linux platform, QEMU is the VM that you should go for. This software comes without any price tag and works as an emulator of various machines with utmost ease and completion; the software uses dynamic translations to emulate hardware peripherals and enhances its overall performance. If you are using QEMU as a virtualizer, then it will function exactly like the host system (provided you have the right set of hardware).

In this tutorial, we set up macOS and Windows virtual machines on UTM, a macOS application that provides a GUI wrapper for QEMU, a powerful open-source emulator and virtualizer. UTM allows you to easily manage and run virtual machines without memorizing complex commands. It also has special handling for macOS, making it simpler to install compared to other virtual machine software.

Not _really_, due to a number of things around automation that you needed vCenter to run. Or at least that's how it was for a very long time.

In the early to middle days of virtualization, when corps had huge datacenters that were split between bare metal and virtualized solutions, I needed test labs of my own to more quickly and easily test different scenarios, then pause and save them to reduce use in the future.

The software chop shop I was working at had some solutions for lab provisioning but they were inefficient. Plus, I wanted spare machines for personal use too. Not really ideal to use personal resources to enhance my capabilities at work, but they were truly test-only with no customer data entering them.

I used ESX for a long time. Even kludged together a little automation. Then I uh borrowed a vCenter license for a long while. I changed jobs and decided that since most of the environments were useless I should really kick VMware to the curb.

I tried OpenStack, but it was too painful of a setup for a single hard node or even two nodes. Ovirt, on the other hand, was PERFECT. This is the open source upstream to RHV. Great integration with Ansible and a number of other tools, and there's very little configuration effort required after the base install, unlike with VMware.

I enjoyed that for a while through the orchestration wars, spinning up 6 and 8 node clusters of Kubernetes, mesosphere, and Swarm just to have a clean environment to test things out. Then it was just kubernetes, and configuration changed and improved a bit. At one point I even got kubernetes autoscaling to work, where load levels on a cluster would trigger calls to Ovirt to spin up additional nodes and add them to the cluster.

The first of my servers ran about 13 years until I put it into storage last year. It still runs great. I calculated out costs once for equivalent 24/7 resources on AWS, and they would have run $300-400k to have equivalent computer power at my disposal. For an investment of around $6k on that server plus a small monthly bump to my electric costs.

Of course, that doesn't count labor. But really, there was relatively little labor involved after moving to Ovirt compared to the ESX ecosystem, where there are a lot of frequently recurring decisions to be made between spending your time or paying ridiculous licensing costs to ease the workflow, both for the platform itself and for anything that integrates with it.

https://www.ovirt.org/

NOTE: RedHat seem to make the open source page look ugly and dated on purpose. Don't let it fool you. I speculate this is because RHV has traditionally been a _very_ thin skin over the top of Ovirt.

Over the past several years, though, they seem to have significantly added value to their downstream RHV by merging with OpenShift to create Red Hat OpenShift Virtualization as the primary value-add on top of Ovirt. But I've only used Ovirt since anything requiring me to test OpenShift necessitated licensing and therefore not-my-own-resources for proper reproduction and testing scenarios. One might check out how well OKD integrates with Ovirt, though, if they want a similar experience to OpenShift at home without the price tag.

If you want to have Linux virtualization and clustering, take a look at oVirt - https://www.ovirt.org/ (no native containers support there) or OpenStack - https://www.openstack.org/ or OpenShift/OKD (https://www.redhat.com/en/technologies/cloud-computing/openshift / https://www.okd.io/)

OVirt (the free version of RHEV) https://www.ovirt.org/ fits the bill for enterprisey environments

And there other choices as well (apart from Proxmox). For example ovirt. I ran a cluster of 14 with SAN using oVirt for many years. Very full featured.

Anyone have any experience with oVirt ?: https://www.ovirt.org/

It is another option that works. For a more scalable option loot at ovirt.

Or you can go open-source at varying levels of simplicity, from Proxmox to oVirt (probably closest to vSphere) to OpenStack.

Add oVirt Node 4.5-pre section #2787