Parallel AES Encryption Using OpenMP and MPI

Modern applications generate and process massive amounts of data, making both security and performance critical concerns. Encryption algorithms must not only be secure but also fast enough to keep up with today’s high-throughput systems. One of the most widely used symmetric encryption algorithms, Advanced Encryption Standard (AES), naturally fits this requirement thanks to its block-based structure.

In this article, I explore how AES encryption can be accelerated using parallel programming, focusing on two popular models: OpenMP for shared-memory systems and MPI for distributed-memory systems. The goal is not cryptographic innovation, but a clear performance comparison of these approaches in a high-performance computing (HPC) context.

Why AES Is Suitable for Parallelism

AES encrypts data in independent 128-bit blocks. Each block can be processed without any dependency on the others, which makes AES an excellent candidate for data-level parallelism.

This characteristic allows us to:

• Distribute blocks across multiple CPU cores (shared memory),
• Or spread them among multiple processes (distributed memory).

By exploiting this independence, we can significantly reduce total encryption time.

Parallelization Approaches

OpenMP: Shared-Memory Parallelization

In the OpenMP-based implementation, AES blocks are divided among threads running on the same machine. Each thread encrypts a distinct subset of blocks using a parallel loop construct.

This approach benefits from:

• Low synchronization overhead
• Fast access to shared memory
• Efficient utilization of multicore CPUs

Because all threads operate within a single address space, communication costs are minimal.

MPI: Distributed-Memory Parallelization

The MPI-based implementation targets distributed-memory environments. The input data is partitioned across multiple processes:

1. Data is distributed using a scatter operation
2. Each process encrypts its local blocks independently
3. Results are collected back using a gather operation

While MPI introduces communication overhead, it enables scalability across multiple nodes, making it suitable for larger systems and workloads.

Experimental Setup

All experiments were conducted on a multicore CPU system. Three implementations were evaluated:

• Sequential AES
• Parallel AES with OpenMP
• Parallel AES with MPI

The test workload consisted of 1,000,000 AES blocks, corresponding to 16 MB of input data. To ensure fair performance comparison, memory allocation and I/O operations were excluded from timing measurements.

Performance Results

The benchmark results clearly show the impact of parallelization:

Key Observations

• OpenMP achieved the highest throughput, thanks to low overhead and shared-memory efficiency.
• MPI provided moderate speedup, limited by communication costs for this problem size.
• Parallel execution significantly outperformed the sequential version in all cases.

Speedup and Efficiency Analysis

Speedup measures how much faster the parallel version runs compared to the sequential one, while efficiency shows how well parallel resources are utilized.

• OpenMP showed good speedup but lower efficiency at higher thread counts due to memory bandwidth limitations.
• MPI maintained higher efficiency per process, but overall speedup was constrained by data communication.

These results highlight a common trade-off in parallel computing: communication vs. computation.

What Do These Results Actually Tell Us?

The experiments make one thing very clear: AES is a great candidate for parallelization. Since each block can be encrypted independently, splitting the workload across multiple cores or processes works extremely well.

On a single machine with multiple cores, OpenMP clearly performs better. The reason is simple: threads share the same memory, so there is almost no communication overhead. This makes OpenMP a very practical choice for multicore CPUs.

MPI, however, tells a different story. For relatively small inputs, communication costs reduce its benefits. But as the data size grows or when multiple machines are involved, MPI becomes increasingly valuable thanks to its ability to scale across nodes.

It’s also worth mentioning that this implementation uses a simplified AES kernel. The goal here was not cryptographic accuracy, but to understand how parallelization affects performance.

Final Thoughts

Parallelizing AES encryption can significantly improve performance when done correctly.

• OpenMP is an excellent choice for shared-memory multicore systems
• MPI shines when scalability across processes or nodes is required
• The “best” model depends heavily on hardware architecture and workload size

As a next step, it would be interesting to test this approach on larger clusters, experiment with communication optimizations, and evaluate performance using a fully standard-compliant AES implementation.

Source Code: https://github.com/Zcerens/aes-parallel/tree/main