A Load Balancer for a Multi-Stage Router Architecture

Shadi Atalla, Andrea Bianco, Robert Birke, Luca Giraudo

Abstract: Multi-stage software router architectures permit to overcome several limitations inherent to single stage software routers. One of the key elements of the multi-stage architecture under study are the load balancers, which are used to distribute the load among backend routers. However, using a PC (Personal Computer) as a load balancer could create a performance bottleneck in the overall architecture. Since the operations performed by the load balancer are simple, we explore the possibility of an hardware-based implementation of load balancing functionality with the goal of improving its performance. In this paper, we describe the architecture of an FPGA-based load balancer and we present some performance results of its prototype implementation.

Introduction

Standard software routers (SRs) running on general-purpose PCs offer significant flexibility and ease of programming at a low cost. However, they frequently encounter performance limitations when compared to specialized ASIC-based commercial routers, particularly when handling high volumes of small packets. This performance gap is largely due to the architectural constraints of general-purpose PCs in high-speed networking environments.

To scale SR performance, researchers have proposed multi-stage architectures that aggregate several software routers. In such configurations, the Load Balancer (LB) at the front-end becomes the critical component. If the LB is implemented on a standard PC, it often becomes the bottleneck, failing to distribute traffic fast enough to saturate the back-end routers. This research addresses this bottleneck by offloading the LB functionality from software to a dedicated FPGA (Field Programmable Gate Array) implementation.

FPGA-Based Load Balancer Architecture

The proposed load balancer is implemented on the NetFPGA platform, utilizing a Xilinx Virtex-II Pro 50. The design follows a modular, pipelined architecture to ensure efficient packet processing at line rates.

The internal modular architecture of the FPGA-based load balancer, showing the input stage, packet processor, and output stage.

As shown in the architecture diagram, the system consists of three primary stages:

  1. Input Stage: An arbiter pulls packets from four physical MAC Rx queues into a central processing bus.
  2. Packet Processor: This core component features a Classifier that identifies packet types (e.g., ARP, OSPF, Data) and routes them to specialized modules. These include a Balance Module (using Weighted Round Robin or Hash-based balancing), ARP Modules for autonomous request handling, and an Int-to-Ext Module that uses VLAN tagging to map internal traffic to external ports.
  3. Output Stage: An arbiter distributes the processed packets to the appropriate MAC Tx queues for transmission.

The entire cluster is managed by a Virtual-CP (Control Plane), which handles complex routing protocols in software, allowing the multi-stage system to appear as a single logical router to external entities.

Performance Evaluation and Results

The prototype was evaluated using an Agilent N2X router tester to generate synthetic Gigabit Ethernet traffic. Testing covered frame sizes from 64 to 1518 bytes across various port configurations.

In 2-port and 3-port configurations, the LB achieved 100% throughput (wire-speed) for all packet sizes with minimal latency. However, in the 4-port bidirectional test, a performance degradation was observed for the smallest packet sizes.

Throughput results for the 4-port bidirectional test, highlighting the performance drop for 64-byte packets due to SRAM bandwidth limitations.

As illustrated in the throughput graph, while larger packets maintain linear performance, 64-byte packets experience a drop-off at higher transmission rates. This limitation is not a result of the FPGA's logic capacity, but rather the SRAM bandwidth. Managing multiple high-speed queues simultaneously exhausts the memory's ability to perform read/write operations at the required frequency. Despite this, the design remains highly efficient, utilizing less than 50% of the FPGA's logic resources.

Conclusion

The FPGA-based load balancer successfully demonstrates that offloading simple, high-volume tasks to hardware can significantly improve the performance of multi-stage software router architectures. By using VLAN tags for stateless mapping and handling ARP requests autonomously, the LB maintains high throughput while preserving the extensibility of the software back-end. Future work will focus on overcoming the SRAM bandwidth bottleneck by migrating to higher-speed hardware platforms and optimizing memory access patterns.

Summary updated

Abstract

Multi-stage software router architectures permit to overcome several limitations inherent to single stage software routers. One of the key elements of the multi-stage architecture under study are the load balancers, which are used to distribute the load among backend routers. However, using a PC (Personal Computer) as a load balancer could create a performance bottleneck in the overall architecture. Since the operations performed by the load balancer are simple, we explore the possibility of an hardware-based implementation of load balancing functionality with the goal of improving its performance. In this paper, we describe the architecture of an FPGA-based load balancer and we present some performance results of its prototype implementation.
BibTeX
@article{atalla2014load,
  author = {Shadi Atalla and Andrea Bianco and Robert Birke and Luca Giraudo},
  title = {{A Load Balancer for a Multi-Stage Router Architecture}},
  journal = {International Journal of Computer Applications},
  year = {2014},
  doi = {10.5120/15479-4193},
}
Figure