AI & HPC

Shared GPU: MIG and vGPU to Maximize Your AI Investment

Datacenter GPUs like the H100, H200 or L40S are expensive and often underused. Sharing a single GPU across several workloads or users lets you get the most out of the investment. We explain the three ways to do it — time-slicing, MIG and vGPU — and when to choose each one.

business EasyDataHost calendar_today November 17, 2026 schedule 9 min read

A modern datacenter GPU is one of the most expensive pieces of hardware you can put in a server. An NVIDIA H100, H200 or L40S costs several times more than the rest of the system, and yet in many real deployments it sits almost idle most of the time. A light inference workload, a small model or a development environment does not come close to filling the 80 GB of memory and the thousands of CUDA cores of a high-end GPU.

The result is that you pay for capacity you never use. The answer is to share the GPU: split a single card across several workloads, users or teams so the investment actually pays off. Sharing a GPU well can multiply by five or ten the number of tasks it serves without degrading the experience of any of them.

There are three ways to share a GPU, with very different levels of isolation, complexity and cost: software time multiplexing (time-slicing), hardware partitioning (MIG) and virtualization for virtual machines (vGPU). In this article we compare them in detail and explain which scenario each one fits, how to orchestrate them in Kubernetes and when it makes sense not to share at all.

The Problem: Expensive, Underused GPUs

The cost of a datacenter GPU is not only its purchase price: you have to add power, cooling, rack space and depreciation. When that GPU runs a single workload that uses 15% of its memory and 20% of its compute, you are wasting 80% of the investment. And this is the norm in many use cases: inference of a small model, an embeddings service, a low-traffic chatbot or a data scientist's notebook used only now and then.

Training large models does fill a GPU — or several — but it represents a fraction of the total work. Most GPU hours in production go to inference and light workloads that do not justify dedicating a whole card. You can see how these workloads fit into your infrastructure in our guide to GPU servers for AI and machine learning.

Sharing the GPU turns that waste into density. Instead of one workload per card, several run in parallel, taking advantage of the spare memory and compute. The key is choosing the right sharing mechanism based on the level of isolation you need: sharing between processes from your own team is not the same as offering GPU to different customers who must not interfere with each other.

schedule Time-slicing

Software

Processes take turns on the GPU. Simple, no memory isolation or QoS.

grid_view MIG

Hardware

Up to 7 isolated instances with their own memory and compute. Real QoS.

dns vGPU

Virtualization

Splits the GPU across VMs with profiles. Requires NVIDIA vGPU license.

Time-Slicing: Software Time Multiplexing

Time-slicing is the simplest way to share a GPU. It has several processes take turns using the card: the GPU scheduler hands out small time slices to each one, much like an operating system shares the CPU between processes. Everything happens in software, with the NVIDIA driver managing the split, and it needs no special GPU or additional license.

Its big advantage is simplicity and compatibility: it works on virtually any modern GPU and can be enabled with very little configuration. It is ideal for squeezing a card when the workloads come from a single trusted team and it does not matter that they compete for resources. For example, several development notebooks, model tests or occasional inference tasks that rarely peak at the same time.

The downside is that there is no memory isolation and no quality-of-service guarantees. All processes share the same GPU memory with no barriers: if one reserves too much, the others run out of space and fail with an out-of-memory error. There is also no QoS: a heavy workload can hog the compute time and cause interference, degrading the latency of the others unpredictably. That is why time-slicing is not suitable for environments where different users or customers must not affect each other.

MIG: Hardware Partitioning with Real Isolation

MIG (Multi-Instance GPU) is NVIDIA's answer to the isolation problem. Available on GPUs based on the Ampere and Hopper architectures — A100, H100 and H200 — MIG physically partitions a GPU into up to seven independent instances, each with its own memory, its own L2 cache and its own compute units (SMs). It is not a time split: it is a real division of the silicon.

Each MIG instance behaves like a smaller but fully isolated GPU. A workload running in one instance cannot access another's memory or steal its compute cycles, and a failure or saturation in one instance does not affect the others. This provides guaranteed quality of service and multi-tenant-grade isolation, something impossible with time-slicing. You can find the technical detail in the official NVIDIA Multi-Instance GPU documentation.

MIG lets you create profiles of different sizes by combining blocks of memory and compute: on an 80 GB H100, for example, you can define seven 10 GB instances, three 20 GB ones, or asymmetric mixes to match your needs. This makes it ideal for serving many small inference models at once, for multi-tenant platforms where each customer gets a guaranteed slice, and for environments where predictable latency is a requirement. The main limit is that instances are static: reconfiguring the partition requires stopping the workloads — it cannot be changed on the fly.

vGPU: Virtualization for Virtual Machines and VDI

NVIDIA vGPU solves a different problem: how to share a GPU across several virtual machines. While time-slicing and MIG operate at the process or hardware-partition level within a single system, vGPU integrates into the hypervisor (VMware vSphere, KVM, Nutanix AHV, Citrix) and presents each VM with a virtual GPU that has its assigned resource profile.

The administrator defines vGPU profiles that split the card's memory across VMs, and the hypervisor manages compute access through time scheduling. This makes it the natural choice for VDI (virtual desktops with graphics acceleration), remote workstations for design and CAD, and deployments where each user needs their own isolated GPU-enabled virtual machine. On MIG-capable GPUs, vGPU can be combined with hardware partitions to deliver VMs with full isolation.

The trade-off is that vGPU requires an NVIDIA vGPU software license for each VM that receives a slice of the GPU, with a subscription cost on top of the hardware. It also adds a slight virtualization overhead. In return, you get full integration with virtual machine management, live migration and hypervisor tooling — something neither time-slicing nor MIG provide on their own.

Comparison Table: Time-Slicing vs MIG vs vGPU

The following table summarizes the key differences between the three mechanisms across the parameters that matter most when deciding how to share your GPU:

Criterion Time-slicing MIG vGPU
Level Software (processes) Hardware Virtualization (VMs)
Memory isolation No Yes (real) Yes (per VM)
QoS / guaranteed performance No Yes Partial
Overhead Minimal Very low Low-medium
Compatible GPUs Almost all A100 / H100 / H200 Datacenter range
Number of partitions No fixed limit Up to 7 instances Depends on profile
Additional license No No Yes (NVIDIA vGPU)
Typical use case Dev / trusted team Inference / multi-tenant VDI / GPU-enabled VMs

Rule of thumb:

Use time-slicing when the workloads are from your own team and you want simplicity; MIG when you need guaranteed isolation and QoS for inference or multi-tenant; and vGPU when you split the GPU across virtual machines or virtual desktops.

Use Cases: When Sharing Pays Off

Sharing the GPU is not a niche technique: it fits a large share of the AI workloads running in production today. These are the scenarios where it makes a difference:

  • check_circle Inference of many small models: serving dozens of embeddings, classification or lightweight LLM models that individually do not fill a GPU. MIG gives each one its isolated instance.
  • check_circle Multi-tenant or multi-team environments: splitting a GPU across several customers or departments with the guarantee that none interferes with the others' performance.
  • check_circle VDI and graphics workstations: GPU-accelerated virtual desktops for design, CAD or editing, where vGPU assigns each user their slice.
  • check_circle Labs and teaching: giving GPU access to many students or researchers at once without dedicating a full card to each one.
  • check_circle Development and experimentation: notebooks, model tests and CI pipelines where workloads are intermittent and time-slicing is enough to share cheaply.

Orchestration in Kubernetes

Sharing GPU really comes into its own when it is orchestrated at scale. In Kubernetes, GPUs are exposed to pods through the NVIDIA device plugin, which registers each card as a schedulable cluster resource. The Kubernetes scheduler then assigns GPU to pods just as it assigns CPU or memory.

The NVIDIA GPU Operator automates the whole stack: it installs the drivers, the device plugin, the container runtime and monitoring tools, and lets you configure the sharing strategy declaratively. With it you can enable time-slicing in Kubernetes — advertising each physical GPU as several logical GPUs so multiple pods take turns on it — or expose the MIG instances as independent resources, so each pod gets its isolated partition with guaranteed memory and compute.

The combination of MIG and Kubernetes is especially powerful for inference platforms: the cluster can pack many inference pods onto few GPUs, each in its MIG instance, maximizing density without sacrificing isolation. The GPU Operator also manages MIG profile reconfiguration and vGPU exposure when running on top of a hypervisor.

When NOT to Share the GPU

Sharing is not always the answer. Some workloads need the whole GPU — or several — and partitioning only introduces limitations. It is best to dedicate the full GPU in these cases:

  • arrow_right Large model training: a large LLM or vision model needs all the card's memory and, often, several GPUs interconnected with NVLink. Partitioning here would only make it unworkable.
  • arrow_right HPC and intensive simulation: calculations that saturate the GPU continuously do not benefit from sharing, because they leave no idle capacity to split.
  • arrow_right Latency-critical inference at the limit: when a single large model already consumes the whole GPU to meet its SLA, there is no room to share without degrading the service.

The rule is simple: share when the workload leaves resources unused; dedicate the whole GPU when the workload needs them all. Many infrastructures combine both approaches, with nodes dedicated to training and partitioned nodes for inference.

EasyDataHost: GPU Servers and DGX Spark in Spain

All of this needs a solid hardware base. At EasyDataHost we offer GPU servers with H100, H200 and L40S datacenter cards, ready to configure the sharing strategy that best fits your workload:

  • arrow_right Servers with MIG-capable GPUs to partition into up to seven isolated instances, ideal for inference platforms and multi-tenant environments.
  • arrow_right vGPU configurations on a hypervisor for VDI and accelerated virtual machines, with license management included.
  • arrow_right The NVIDIA DGX Spark hosted in Madrid as a compact base for development, prototyping and AI workloads with partitioning options.
  • arrow_right Orchestration in Kubernetes with the GPU Operator to expose time-slicing or MIG declaratively and maximize pod density per GPU.

All our infrastructure runs in our own datacenter in Spain, with ISO 27001 certification and ENS compliance. If you want to maximize your GPU investment by sharing it securely, contact our team for a technical assessment with no obligation.

Frequently Asked Questions

What is the difference between MIG and time-slicing?

MIG partitions the GPU at the hardware level into instances with isolated memory, cache and compute units, guaranteeing quality of service and preventing interference between workloads. Time-slicing only multiplexes time in software: processes take turns on the same GPU with no memory isolation and no performance guarantees, so one workload can affect the others.

Do I need a license to share a GPU?

Time-slicing and MIG are part of the NVIDIA driver and the compatible GPUs (A100, H100, H200), so they require no additional license. vGPU does need an NVIDIA vGPU software license for every virtual machine that receives a slice of the GPU, because it is a virtualization technology built for hypervisors and VDI.

Can I use a shared GPU to train large models?

It is not recommended. Sharing is designed for inference, small workloads and multi-tenant environments. A large training run needs all the memory and compute of a full GPU, and often several GPUs interconnected with NVLink. In those cases it is best not to partition and to dedicate the whole GPU, or even a whole node, to the task.

Conclusion

A datacenter GPU is too expensive to leave idle. Sharing it across several workloads turns wasted capacity into real density, as long as you pick the mechanism that matches the isolation you need:

  • arrow_right Time-slicing is the simplest: processes taking turns on the GPU. No license or isolation, ideal for development and trusted teams.
  • arrow_right MIG partitions the hardware into up to seven instances with real isolation and guaranteed QoS. The choice for inference and multi-tenant on A100, H100 and H200.
  • arrow_right vGPU splits the GPU across virtual machines with profiles. The choice for VDI and virtualized environments, at the cost of the NVIDIA vGPU license.
  • arrow_right Do not share when the workload needs the whole GPU: large training, intensive HPC or latency-critical inference at the limit demand the entire card.
GPU MIG vGPU AI HPC Kubernetes
grid_view

Get the most out of every euro you invest in GPU

EasyDataHost: H100, H200 and L40S GPU servers and NVIDIA DGX Spark with MIG, vGPU and Kubernetes orchestration. Infrastructure in Spain, 24/7 support.