Even optimized models can exceed the memory capacity and computational throughput of a single accelerator device (like a GPU). When deploying truly large language models or aiming for very high inference throughput, distributing the workload across multiple devices becomes a necessity. Distributed inference strategies parallelize the computation, allowing models that are too large for one device to run, or enabling faster processing by leveraging the combined power of several accelerators.

There are several established methods for partitioning the inference workload:

Tensor Parallelism (TP)

Tensor Parallelism, often referred to as intra-layer model parallelism, focuses on splitting the execution of individual layers, or more precisely, the large matrix multiplications within them, across multiple devices. Instead of computing the entire operation $Y = XA$ on one device, the weight matrix $A$ is partitioned column-wise ( $A = [A_1, A_2, ..., A_N]$ ) or row-wise ( $A$ split horizontally) across $N$ devices.

Column Parallelism: If $A$ is split column-wise, each device $i$ computes $Y_i = X A_i$ . The results $Y_i$ are then concatenated ( $Y = [Y_1, Y_2, ..., Y_N]$ ). This typically requires communicating the input $X$ to all devices (broadcast or equivalent) but requires no communication after the local computation.
Row Parallelism: If $A$ is split row-wise, the input $X$ is also split row-wise ( $X = [X_1^T, X_2^T, ..., X_N^T]^T$ ). Each device $i$ computes a partial result using its portion of $A$ . These partial results must then be summed across all devices using an all-reduce communication operation to produce the final output $Y$ .

In the context of Transformers, TP is commonly applied to the weight matrices in the feed-forward network (FFN) layers and the attention mechanism's query, key, value, and output projection matrices.

Tensor Parallelism: Input X is processed concurrently on Device 0 (using weight shard W0) and Device 1 (using W1). Partial results are combined via All-Reduce or Concatenation.

Advantages:

Reduces memory usage per device for weights and, significantly, for activations, as activation sizes often scale with batch size and sequence length.
Can decrease the latency of individual layer computations if communication is fast.

Disadvantages:

Requires high-bandwidth interconnects between devices (e.g., NVLink, NVSwitch) because communication (especially all-reduce) happens frequently within the computation of each layer.
Communication overhead can limit scalability beyond a certain number of devices within a single node.

Pipeline Parallelism (PP)

Pipeline Parallelism takes a different approach by partitioning the model layer-wise across multiple devices. Each device, or stage, holds a subset of the model's layers. For example, in a 4-device setup, Device 0 might hold layers 1-10, Device 1 layers 11-20, and so on.

Input data flows sequentially through these stages. Device 0 processes the input and passes its output (intermediate activations) to Device 1, which processes it further and passes it to Device 2, continuing until the final device produces the output.

A naive implementation suffers from significant device underutilization ("pipeline bubbles"), as most devices are idle while waiting for data from the previous stage. To mitigate this, the input batch is typically split into smaller micro-batches. As soon as Device 0 finishes processing the first micro-batch, it sends the results to Device 1 and immediately starts processing the second micro-batch. This allows multiple micro-batches to be in flight simultaneously across the pipeline stages, improving hardware utilization.

Pipeline Parallelism: Micro-batches (MB1, MB2, ...) flow sequentially through stages (Devices 0, 1, ... N). Device i starts processing MB k after receiving activations from Device i-1.

Advantages:

Reduces memory per device for weights, as each device only holds a fraction of the layers. Also reduces activation memory compared to storing the full model's activations, though potentially more than TP depending on partitioning.
Communication is typically point-to-point between adjacent stages, potentially requiring less all-to-all bandwidth than TP's all-reduce operations. Can be more suitable for scaling across multiple nodes with slower interconnects.
Effective at increasing inference throughput.

Disadvantages:

Increases inference latency due to the sequential processing and pipeline fill/drain times, even with micro-batching. The latency is fundamentally lower-bounded by the sum of computations across stages plus communication delays.
Load balancing can be challenging; requires careful partitioning of layers to ensure each stage takes roughly the same amount of time.
Managing the pipeline schedule (e.g., GPipe, PipeDream) adds complexity.

Sequence Parallelism (SP)

While TP splits tensors within layers and PP splits layers across devices, Sequence Parallelism focuses on partitioning the input sequence itself along the sequence length dimension. This technique is particularly effective for attention mechanisms, where computation scales quadratically with sequence length ( $O(L^2)$ ).

In standard TP, activations for the entire sequence are often required on all TP devices, which can become a memory bottleneck for very long sequences. Sequence Parallelism allows splitting operations like LayerNorm, dropout, and specific parts of attention computation such that each device only handles a slice of the sequence length.

For example, within the attention calculation $Attention(Q, K, V) = softmax(\frac{QK^T}{\sqrt{d_k}})V$ , operations can often be reformulated so that communication (e.g., partial sums or partial softmax computations) occurs along the sequence dimension, allowing devices to work on different sequence chunks in parallel without needing the full intermediate activation tensors for the entire sequence. This often requires modifications to the standard layer implementations.

Advantages:

Directly addresses the memory bottleneck associated with long sequences, especially for activations within attention layers.
Can be combined with TP and PP.
Reduces the communication volume required for certain operations compared to TP when dealing with very long sequences.

Disadvantages:

Primarily benefits operations that are independent along the sequence dimension or can be parallelized with specific communication patterns (like attention). Less applicable to operations like FFNs applied independently at each token position.
May require custom kernel implementations or specific framework support (like DeepSpeed provides).
Adds another dimension of complexity to the distribution strategy.

Hybrid Approaches

In practice, deploying the largest models often involves combining these strategies. A common configuration is to use Tensor Parallelism within a node (leveraging fast intra-node interconnects like NVLink) and Pipeline Parallelism across nodes (where interconnect bandwidth is typically lower).

For example, a model might be split into 8 pipeline stages (PP degree = 8). Within each stage, the layers might be further parallelized across 8 GPUs using Tensor Parallelism (TP degree = 8). This results in a total of 64 GPUs being used. Sequence Parallelism can be added on top, especially if context lengths are very large.

The choice of strategy depends heavily on the specific model architecture, hardware configuration (number of devices, intra-node and inter-node bandwidth), and the primary optimization goal (latency vs. throughput).

Communication Overheads

A critical factor in the effectiveness of any distributed strategy is communication overhead.

TP: Often relies on bandwidth-intensive all-reduce operations within each layer. Performance is highly sensitive to interconnect speed.
PP: Relies on point-to-point communication of activations between stages. The volume depends on the activation size and micro-batch size. Latency is added by the sequential sends.
SP: Communication patterns depend on the specific operation being parallelized along the sequence axis.

Minimizing the volume of data transferred and overlapping communication with computation are essential optimization techniques implemented within distributed training and inference frameworks like PyTorch Fully Sharded Data Parallel (FSDP), DeepSpeed, Megatron-LM, and inference servers like NVIDIA Triton with multi-GPU backends or vLLM.

Understanding these distribution strategies is essential for scaling LLM inference beyond single-device limitations, enabling the deployment of massive models and achieving the required throughput for real-world applications. Frameworks abstract away some of the implementation details, but knowledge of the underlying principles helps in choosing the right strategy and debugging performance bottlenecks.