Libra Graphics (v2.1.
0) User Guide
Update Date: 12 August 2022
What is Libra Graphics?
Libra Graphics virtualizes graphical processing units (GPUs) to provide a pool of shared,
network-accessible resources that support graphics rendering applications.
We will abbreviate “Libra Graphics” as “LibraX” below.
LibraX Architecture
LibraX has a client-server architecture. It allows multiple client virtual machine (VMs) or
physical machines running graphics rendering applications based on Direct3D or OpenGL to
share access to remote GPUs on virtual machines or physical machines running LibraX server
service. You run the applications on the LibraX client machines, while the GPUs that provide
acceleration are installed on the LibraX server machines across a network or a segment of
shared memory.
The following figure describes a small LibraX cluster which consists of two clients, two servers,
one Controller and GUI. What needs to be reminded is that the LibraX client and server only
supports running on Microsoft Windows operating system currently.
LibraX Components
LibraX consists of multiple components which are introduced as follows.
l LibraX Client Runtime
LibraX Client Runtime runs on a Windows machine which run the Direct3D or OpenGL
applications. It simulates the runtime environment of Direct3D/OpenGL and provides a new
Direct3D/OpenGL API interface-compatible implementation for upper-layer applications.
With the help of LibraX Client Runtime, Direct3D or OpenGL applications can run directly
without any modification above on LibraX vGPUs which are virtualized from a local or
remote physical GPU.
l LibraX Server Service
LibraX Server Service runs on a Windows machine with locally installed GPU as a server
node. It reports all physical GPU information to a centralized component of our GPU
resource pool, and responds to the LibraX client’s Direct3D/OpenGL API call request.
l LibraX Controller
LibraX Controller is the centralized component of our GPU resource pool. It can be
deployed on any node that the LibraX client and server network can reach. LibraX Controller
takes over all of the physical GPU reported by LibraX Server Service, responds to the LibraX
Client vGPU request, assigns and returns the LibraX vGPU resources to the LibraX Client-
side Direct3D/OpenGL application from the GPU resource pool.
l LibraX GUI
LibraX GUI is the management software that provides a centralized platform for monitoring
and controlling your whole LibraX environment.
LibraX Functionality
When you start a Direct3D or OpenGL application on the LibraX client machine, LibraX client
intercepts the Direct3D or OpenGL calls of the application, and sees the data and data
pointers of the calls. Then, the client transfers the data and the rest of the Direct3D or OpenGL
calls to the LibraX server. The LibraX server processes the calls and returns the results back to
the client.
Some operations will be performed by LibraX when you start a Direct3D or OpenGL
application.
l Dynamically allocate, access and release GPU resources
When a Direct3D or OpenGL application starts，the required GPU resources will be allocated
automatically from our LibraX GPU resource pool. The resources are consumed only for the
length of time that an application or session runs and released to the pool when applications
or sessions exit. In addition, the required GPU resources can be adjusted without restarting
the LibraX client machine.
l Share GPU resources
The memory of a physical GPU can be divided into fractions of an arbitrary size (minimum
unit: MB) and allocated to different applications at the same time. One LibraX client user can
access partitions of GPU resources for concurrent sharing with other users.
l Control the GPU memory usage
The Direct3D or OpenGL application using the GPU resource allocated from our GPU resource
pool cannot exceed the pre-requested GPU memory size, or it will be exited forcedly.
Hardware and Software Support
Supported Operating Systems
Host OS Ubuntu 16.04 LTS
Ubuntu 18.04 LTS
Ubuntu 20.04 LTS
Centos 7.x
Guest OS Microsoft Windows® Server 2019
Microsoft Windows® Server 2016
Microsoft Windows® 10
Supported Hypervisor
The following hypervisors are supported:
Hypervisor Notes
Red Hat KVM QEMU version 2.10 and later
Supported Graphics Cards
Vendor Boards Supported Notes
NVIDIA GeForce series Nvidia vGPU license is
Quadro series required when Tesla series
Tesla series cards are used.
AMD Radeon series
API Support
The LibraX vGPU supports the following APIs：
l DirectX 9
l DirectX 10
l DirectX 11
l DirectX 12
l OpenGL 4.6
How to deploy LibraX？
LibraX Software Package
LibraX software package contains the following components:
l LibraX GUI and Controller docker image
e.g. virtaitech-orion-gui-controller-all-in-one-3.1.0.img
l LibraX client installer
e.g. Libra_client_setup.exe
l LibraX server installer
e.g. Libra_server_setup.exe
l LibraX shared-memory auxiliary
e.g. Orion_shm_aux
Deployment environment preparation
Before deploying the LibraX，you should have a mainstream physical server with Linux
Operating System, like Ubuntu 18.04 LTS. At least one GPU card is required, like Nvidia
GeForce RTX 3090.
Then multiple Windows virtual machine should be created based on QEMU/KVM hypervisor.
At least one Windows virtual machine should have a dedicated GPU with GPU passthrough
technology.
The following figure shows the environment for deploying LibraX.
Deployment of LibraX
There will be some steps to deploy LibraX.
1. Deploy LibraX GUI and Controller
LibraX GUI and Controller can be deployed with Docker. You can install the Docker
environment on the host machine, then start LibraX GUI and Controller.
First, load the docker image:
docker load -i virtaitech-orion-gui-controller-all-in-one-3.1.0.img
Then, (optionally) create persistent data store directory:
mkdir /root/etcd
mkdir /root/mongodb
mkdir /root/prometheus
Copy license file to a specified directory(like /root). Note that the license file should be
applied from VirtAI Tech.
cp license.txt /root/license.txt
Start the container
docker run –name gui-controller-all-in-one -p 9123:9123 -p 9125:9125
-p 9129:9129 -v /root/license.txt:/root/licenset.txt -v
/root/mongodb:/root/data -v /root/etcd:/root/etcd -v
/root/Prometheus:/Prometheus -d virtaitech/orion-gui-controller-all-in-
one:3.1.0
// Remained to be completed.
2. Deploy Orion_shm_aux
For supporting one windows virtual machine can communicate with other windows virtual
machine through shared memory, Orion_shm_aux is required to run on the host machine.
You can start Orion_shm_aux as follows.
sudo ./Orion_shm_aux -b 192.168.122.1 -p 18000
// introduction remained to be completed.
Note that some “permission denied” problems may be met with you when
Orion_shm_aux is running on Ubuntu OS. If that happens, it’s suggested to add
“/dev/shm/ORIONAUXSHM* rw,”to the “/etc/apparmor.d/abstractions/libvirt-
qemu”file， restart the libvirtd service ( systemctl restart libvirtd), and restart all windows
virtual machine.
3. Deploy LibraX server
LibraX server service is expected to run inside a windows virtual machine with a dedicated
GPU. You can first install LibraX server by double-clicking “libra_server_setup.exe”. Then
“C:\Libra\Config\server.conf ” file will be created automatically. Before launching
LibraServe.exe, some preparations are required.
l Change the configuration of “bind_addr”
l Change the configuration of “server-shm” section
l Change the configuration of “controller_addr”
// remained to be completed.
4. Deploy LibraX client
LibraX client should be installed on a windows virtual machine which you want to run
graphical rendering applications. You can install LibraX client by double-clicking
“libra_client_setup.exe” and “C:\Libra\Config\server.conf ” file will be created
automatically. The configuration of “controller_addr” must be updated before
launching your 3D applications. LibraX provides a launcher to launch your 3D applications,
if and only if you launch a 3D application with LibraX launcher, you can accelerate the 3D
application with remote GPU，or the 3D application only use CPU to render images.
// Client configuration description remained to be added.
