AlphaFold3 Scalability Tests¶

General Information¶

• Version: Alphafold 3.0.1
• Cluster: Hyperion
• CPU: Intel Xeon Gold 6342, 48 cores per node
• Memory per node: 16 × 16 GB 3200 MHz DDR4 (total 256 GB)
• Interconnect: InfiniBand 200 Gb
• OS: Rocky Linux 8.10

Target audience: Users of AlphaFold3 on Hyperion (recommendations for requesting compute resources).

Methodology¶

Inputs: randomly generated protein sequences; each residue chosen independently (synthetic dataset). These sequences are sampled using typical amino-acid frequencies from natural proteins, include an initial M for longer sequences, and avoid excessive rare residues in short sequences. Sequence lengths tested: 10, 25, 50, 100, 150, 300, 600, 1000, 1500, 2000 residues.

For each length we measured:

total run time (HH:MM:SS), and CPU efficiency reported by the run.

Resource sweep: number of CPUs ∈ {1,2,4,8,16,32,48}; memory set to 32 GB and 64 GB in separate runs.

Speedup is computed relative to the 1-CPU time for the same protein length and memory allocation (speedup = T(1CPU)/T(NCPUs)).

Runs were executed on a single Hyperion node. No GPUs were used for the MSA computation (CPU-intensive). For the "Structure Inference" steps 2 GPU types where used: RTX3090 and A100-PCIE.

MSA Stage (CPU intensive)¶

In AlphaFold3 (and earlier versions), the MSA (Multiple Sequence Alignment) step is the most CPU-demanding and time-consuming part of the pipeline. MSA generation requires scanning your query sequence against massive sequence databases — often hundreds of gigabytes or even terabytes in size. Each search involves comparing your sequence to millions of potential homologs. These algorithms perform billions of short string alignments (with scoring matrices, gap penalties, etc.). This is highly parallelizable, but still compute-bound. GPUs are not efficient for this kind of workload.

Why it becomes the bottleneck ?? While the deep learning inference (structure prediction by AlphaFold3 model) is GPU-accelerated and can take just a few minutes per target, the MSA generation step often takes tens of minutes to hours, even on many cores, because: - Database search scales roughly with sequence length × database size - The neural net inference is comparatively constant-time once the MSA is ready Hence, even on HPC clusters, the MSA step dominates total wall time.

Raw results¶

Obteined results for increasing number of residue number, CPU and memory. The given values in the table are total wall time (HH:MM:SS )and the CPU efficiency (%).

Time vs CPU graphic

Efficiency vs CPU graphic

Speedup vs CPU graphic

Interpretation notes & practical recommendations for the MSA stage¶

For very small proteins (10–50 residues) you observe poor scaling beyond a modest number of CPUs: wall time often plateaus or even increases for high CPU counts (32/48). For those, use 1–8 CPUs depending on queue availability; giving many CPUs wastes resources and does not significantly reduce wall time.

For medium proteins (100–600 residues) you get better scaling up to 8–16 CPUs; beyond that benefits diminish but may still help for some lengths (600 res shows good improvements up to 32 CPUs in some runs). Recommended: 8–32 CPUs and 64 GB if memory bound; check your particular dataset.

For large proteins (1000–2000 residues) you typically need 8–32 CPUs to get good runtime; some 1-CPU runs are missing — but available data shows strong gains with 8–32 CPUs. For very large inputs, prefer 64 GB and 16–32 CPUs as a starting point.

Memory: in many tests 64 GB sometimes gives slightly better times, but not always — performance vs memory tradeoffs appear workload dependent. If uncertain, request 64 GB for larger proteins (>600 residues).

I/O / DB downloads: AlphaFold needs database access. If many users run many parallel jobs, consider staging databases locally or on fast scratch to avoid network bottlenecks.

Queue requests for users: in job scripts, request a realistic CPU count (see recommendations above), set a reasonable walltime based on the figures (generate plot and pick typical runtime) and request 64 GB for proteins >600 residues.

Structure Inference Step (GPU intensive)¶

The Structure Inference phase of AlphaFold 3 corresponds to the actual 3D structure generation from the previously computed multiple sequence alignments (MSAs) and templates. This stage relies heavily on deep neural network inference, which involves executing a fixed sequence of matrix multiplications, convolutions, and attention operations. These operations are GPU-bound rather than CPU-bound.

In this benchmark, a 300-residue protein system was evaluated while varying the number of CPUs, memory allocation, and GPU type. The following table summarizes the results:

Analysis¶

1. Lack of CPU scaling Increasing the number of CPUs does not reduce the total runtime. This is because the inference kernels (matrix multiplications and tensor contractions) are executed almost entirely on the GPU using CUDA libraries (e.g., cuBLAS, cuDNN). The CPU only handles lightweight orchestration tasks — data loading, batch preparation, and invoking GPU kernels — which represent a negligible fraction of the total runtime. Once the GPU is saturated with data, adding more CPU threads has no measurable impact.

2. Limited GPU performance gains Comparing RTX 3090 and A100 GPUs shows only marginal improvements in execution time. Although the A100 has more CUDA cores and higher theoretical FLOPS, AlphaFold’s inference workload is memory bandwidth and latency-bound, not compute-bound. The neural network uses a fixed model graph that fits well within the 24–40 GB of VRAM, and the additional GPU compute capacity is underutilized because the batch size and model architecture remain constant. Therefore, both GPUs reach similar throughput levels.

3. Impact of system memory (RAM) The system’s main memory (32GB vs 64GB) does not affect this stage either. Once the model weights and inputs are loaded into GPU memory, data transfers between host and device are minimal.

Inference conclusion¶

The Structure Inference step of AlphaFold 3 is fully dominated by GPU performance and shows no CPU scalability. Performance gains from using more CPUs or increasing system RAM are negligible. The choice of GPU affects runtime only slightly, with the A100 offering minor acceleration due to its larger bandwidth and memory size.

Final remarks¶

For performance optimization, allocate more CPU cores to the MSA step and use a GPU with sufficient VRAM for the inference stage. For larger proteins, prefer GPUs like the A100 (40–80GB) to avoid out-of-memory errors rather than for speed gains. Adding more CPUs or RAM does not improve inference performance.