LibVF.IO VS gvt-linux

Maybe you can try LibVF.IO

I'm on Linux and I'm running a 3070 Ti (Nvidia). I have always wanted to do GPU virtualization but because NVIDIA won't release vGPU for consumer card no one can do it without crossing legal red tape or problems with bricking your GPU. I did find this [https://github.com/jamesstringerparsec/Easy-GPU-PV] however it is only for windows, I found this [https://github.com/Arc-Compute/LibVF.IO/] and does not work with my GPU, and this [https://github.com/DualCoder/vgpu_unlock] and can't get it to work. Done any one know an alternative on Linux that work just like this, overcoming these problems (on KVM)?

If you are willing to thinker with you gpu driver you could look up libvfio and create multiple VM with the same gpu.

It seems they have issues with recent drivers/kernel, too: https://github.com/Arc-Compute/LibVF.IO/issues/61

I ran it like a year ago it was fine but not for my workflow. Might revisit the setup soon since it matured a lot since then. I suggest you also look at: https://github.com/Arc-Compute/LibVF.IO

For Affinity, I don't know. I have heard of people using Photoshop via VM, the problem usually comes when you need to utilize a lot of GPU because outside of GPU passthrough (might worth researching single-GPU passthrough and libvfio if you don't want to use two GPUs), GPU performance isn't great for VMs. I did find a few threads on the subject of Affinity on Linux, though, so maybe those could help.

I feel you on this. Looking forward to running libvf. Wine has come a long ways, but I ended up keeping a old PC a secondary to not deal with the hacking/workarounds to run some games. Using the older system for my Linux.

It's theoretically possible using a method like libvfio. This should allow you to split your gpu into 2 virtual gpus. It's designed for use with a vm, but could likely work with multi seat

Perhaps not the "best" source code I've ever read, but libVF.io had some beautiful code for what's generally gnarly system-glue code. The iommu setup code is a good example and inspires me to think that system-glue code doesn't need to be gross or impenetrable: https://github.com/Arc-Compute/LibVF.IO/blob/master/src/libv...

Another one I've appreciated reading (and learned more about 2d graphics from) is Pixie, a 2d graphics library written in Nim. Here's the implementation of a fair subset of SVG paths: https://github.com/treeform/pixie/blob/master/src/pixie/path...

And one last one for basic algorithms: https://github.com/nim-lang/Nim/blob/version-1-6/lib/pure/al...

Of course Knuth's original code is still some of the best classic code. K&R's original C book is a classic.

Yeah i read that too, I also found this.. https://github.com/intel/gvt-linux/issues/64

Intel has already confirmed that GVT-g is essentially dead and not supported on their Iris/Xe or anything newer graphics.. We can also confirm this via their own drivers source..

https://github.com/intel/gvt-linux/blob/gvt-staging/drivers/...

On Intel iGPUs, there are two methods: GVT-g and GVT-d. GVT-g is basically creating virtual instances of the iGPU for use in VMs, while GVT-d is passing through an entire iGPU to the guest in the same way you would do with a normal GPU.

From the Intel GVTg_Setup_Guide;

Not really pass through, no. If CONFIG_DRM_I915_GVT is enabled in your kernel, you can use Intel's graphics virtualization system... basically a virtio style virtual device that shares the GPU between VM and host. IMO this is way more convenient than real passthrough, where the device is only available either to the VM or the host. The downside is that you don't get full performance in the VM.

"Intel GVT-g is a full GPU virtualization solution with mediated pass-through (VFIO mediated device framework based), starting from 5th generation Intel Core(TM) processors with Intel Graphics processors. GVT-g supports both Xen and KVM (a.k.a XenGT & a.k.a KVMGT). A virtual GPU instance is maintained for each VM, with part of performance critical resources directly assigned. The capability of running native graphics driver inside a VM, without hypervisor intervention in performance critical paths, achieves a good balance among performance, feature, and sharing capability."

https://github.com/intel/gvt-linux/wiki/GVTg_Setup_Guide

Wait a minute. GVT-g with 11th gen iGPUs upwards does work in linux guest? Are you sure about that? See this github issue for reference.

To be clear, I never said it was dead, only a dead end.

As for GVT-g and Xe, according to a post in this[0] issue by one of the Intel devs, Rocket Lake (Xe) is not getting support and only does GVT-d.

Also in the same issue, someone pointed out that Intel themselves have states as much here[1].

I hope I am proven wrong in the end and GVT-g comes to then entire Xe and ARC lineup. Intel's communication on this matter has been...lacking.

0: https://github.com/intel/gvt-linux/issues/190

1: https://www.intel.com/content/www/us/en/support/articles/000...

After days of trial and error, I could not get it to work, maybe one of you knows it. Currently, I try to setup GVT-d with KVM on my Dell XPS 13 2 in 1 7390, which has a i7-1065G7. AFAIK GVT-g is not supported, so I gave GVT-d a chance. The virtual machine is booting without any errors, but the display stays black. I only found this guide, but couldn't get it to work...