Paper summary

Packets are Not Pages: Flow-Based Addressing Conserves Memory Bandwidth

Agur Adams, Hui Sub Shim, Colin Drewes, Ben O'Keefe, Philip Levis, Zakir Durumeric · Stanford University

CoNEXT '26, Proceedings of the ACM on Networking, Volume 4, Issue CoNEXT3 (September 2026) · ACM CoNEXT 2026, Utrecht, The Netherlands · December 2026

This page was written by an AI model to give a high-level overview of the paper. Please check the paper for detail: ACM Digital Library.

The big idea

A SmartNIC is a network card with its own general-purpose cores and accelerators, and cloud providers use them to take network work off host CPUs. Applications that analyze reassembled transport-layer data, such as intrusion detection and deep packet inspection, run into a memory bandwidth limit on these devices. An NVIDIA BlueField-3 supports 400 Gbps links but has only 717 Gbps of aggregate DRAM bandwidth, a 1.8:1 ratio that the paper notes is less than what is needed to write every packet to DRAM and read it back at line rate. Per core, the ratio of DRAM bandwidth to NIC bandwidth is 1.79 on the BlueField-3 against 24.93 on a Google Cloud C3 server (theoretical limits, the paper's Table 1).

The paper traces the problem to a mismatch of abstractions. Packets have variable length, and a link interleaves packets from many flows, so payloads land at scattered, unaligned places in DRAM. Memory, by contrast, is a contiguous address space of fixed-size pages, read in 64-byte cache lines. To process a stream, software copies the payloads into a contiguous buffer: it reads every segment, writes the buffer back to DRAM, and reads the buffer again. On a BlueField-3 core, copying took 69% of the execution time of a single-byte linear scan, and a software emulation that reads payloads in place raised per-core throughput by 40% and cut DRAM accesses by 32.1%. Scatter-gather DMA speeds up the copy, but it still builds the buffer in DRAM for the CPU to read back.

The proposal, flow-based addressing, makes the reassembled bytestream itself addressable. A per-core flow translation table maps byte offsets within a flow to the physical address and length of each payload in DRAM. A flow cache controller uses the table to read each payload from DRAM once, packs the unaligned bytes into contiguous 64-byte lines, and places them in a private, read-only, on-chip flow cache that the core addresses directly. In the paper's words, rather than accelerate an operation through a new offload, "it aims to remove the operation entirely."

As packets arrive, a packet handler writes each payload to DRAM and records its address, length and flow identifier (computed from the five-tuple), and software appends that record to a per-flow linked list. When the flow ends (last packet or timeout), software copies the list into the translation table, where each entry's offset is the sum of the lengths before it, and asks the controller for a byte range. The controller turns matching table entries into read descriptors, issues 64-byte DRAM reads, keeps only the valid bytes and signals completion. The flow cache is sized for 10 KB because 93.16% of 1.6 billion TCP flows measured on a university campus network are 10 KB or less; longer flows are processed in table-sized windows. The cache is not coherent with ordinary page-based memory, which the paper argues holds broadly because applications generally consume received payloads without modifying them in place.

The prototype runs on an AMD Alveo U250 FPGA-based SmartNIC, with a 300 MHz MicroBlaze soft CPU as the processing core, and is compared against a copy-based pipeline on the same hardware. Across synthetic microbenchmarks, a university campus trace and a datacenter web-search trace, for linear scan and regular expression search, flow-based addressing reduces DRAM traffic by 77 to 83%, execution time by 25 to 62%, and raises per-core throughput by 1.33 to 2.66×. Linear scan gains the most (about 62% less time and 2.6× throughput); regular expression search gains less because processing, not copying, dominates its runtime. The measurements exclude the cost of maintaining the per-flow linked lists, which the paper estimates separately (Appendix D).

Two ways to give a SmartNIC core a reassembled flow
copy into a DRAM buffer · or assemble once into an on-chip flow cache
Copy-based reassembly (baseline) DRAM seg 1 seg 2 seg 3 contiguous buffer 1 2 3 SmartNIC core 1 read every segment into cache 2 memcpy writes a contiguous buffer to DRAM 3 read the buffer back to process it DRAM traffic: 5.0 to 6.19× the payload Flow-based addressing (this paper) DRAM seg 1 seg 2 seg 3 no buffer copy flow cache controller packs unaligned payloads flow translation table private flow cache (BRAM) SmartNIC core 1 2 3 1 one DRAM read per payload, guided by the table 2 valid bytes packed into contiguous 64 B lines 3 the core reads the flow from the flow cache DRAM traffic: 1.05 to 1.18× the payload
Left panel after the paper's Figure 1 (Section 2); right panel after Figures 4 and 8 (Sections 3.1 and 4.3). Segment positions are illustrative. DRAM traffic ratios are the paper's measured values for linear scan on the FPGA prototype across the synthetic, campus and datacenter experiments (Section 5); regular expression search ranges from 5.0× to 1.05× in the synthetic case.

Key takeaways

  • SmartNICs have little DRAM bandwidth per unit of link bandwidth (1.79 per core on BlueField-3, 24.93 on a Google Cloud C3 server), so copying payloads to reassemble streams becomes the bottleneck.
  • The cause is an abstraction mismatch: variable-length, interleaved packets stored in memory built from fixed-size pages and cache lines, which forces a read, write and re-read of every payload.
  • Flow-based addressing: a per-core flow translation table maps flow byte offsets to payload addresses, and a flow cache controller assembles the bytestream once into a private, read-only, on-chip flow cache.
  • The controller handles unaligned payloads in hardware, and the cache is sized at 10 KB for the 93% of campus TCP flows at or below that size; longer flows are processed in windows.
  • On an Alveo U250 prototype with a 300 MHz MicroBlaze core: 77 to 83% less DRAM traffic, 25 to 62% less execution time and 1.33 to 2.66× per-core throughput. Linked-list maintenance is excluded from the measurements and estimated analytically.
Mechanism, step by step

From scattered packets to a contiguous flow in an on-chip cache

Why reassembly exhausts SmartNIC memory bandwidth, the flow translation table, the flow cache controller, and the prototype's results.

1 · Why SmartNIC memory bandwidth runs out

Link speeds keep rising while memory bandwidth stays comparatively flat. The paper compares aggregate DRAM bandwidth and NIC bandwidth per core on two cloud servers and two SmartNICs (its Table 1; vendor theoretical limits, not measurements):

PlatformCoresNIC interfaceDRAM BW per coreNIC BW per coreRatio
Google Cloud N2d (2× AMD Milan)224100 Gbps1.83 GB/s0.06 GB/s30.50
Google Cloud C3 (2× Sapphire Rapids)176200 Gbps3.49 GB/s0.14 GB/s24.93
Intel IPU E2000 SmartNIC16200 Gbps6.40 GB/s1.56 GB/s4.10
NVIDIA BlueField-3 SmartNIC16400 Gbps5.60 GB/s3.13 GB/s1.79

Packet-level work such as virtualization stacks touches only headers, a small fraction of traffic. Work on reassembled transport-layer data (HTTP traffic, RPC requests) touches every payload byte, and stream reassembly makes each byte cross the memory bus several times: written to DRAM on arrival, read and written again to build a contiguous buffer, and read once more to be processed.

2 · What reassembly costs on a BlueField-3

To size the problem, the authors ran two analyses on one core of an NVIDIA BlueField-3 (16 Arm A78 cores, 32 GB DDR5), receiving 1,518-byte packets sent at line rate by a second BlueField-3. A linear scan for the null byte stands for memory-bound work; a regular expression search for [a-z][0-9] stands for compute-bound work. Both are representative of patterns in the Snort intrusion detection ruleset, where a single null byte is the most common pattern (43.63% of 9,549 rules). A software emulation of flow-based addressing that reads payloads in place by walking a list of packets served as the comparison.

MeasureLinear scanRegular expression
Share of execution time spent copying69%6%
Per-core throughput, copy-based to in-place22.6 to 31.6 Gbps (+40%)2.5 to 2.7 Gbps (+11%)
DRAM accesses, copy-based to in-place465.6 to 316.2 GB (32.1% less)454.5 to 277.3 GB (39.1% less)

Because BlueField-3 does not expose last-level cache writeback counts, DRAM reads were counted as last-level cache load misses and DRAM writes approximated by L2 writebacks. The paper's reading: redundant copies cut throughput directly in memory-bound work, and still add substantial memory traffic in compute-bound work.

The paper's diagnosis: SmartNICs inherited page-based memory from the processors they incorporate. Pages are fixed-size and rely on locality; packets are variable-length and interleaved across flows. Even accessing payloads through pointers instead of copying them loads a full cache line from each scattered fragment. The fix the paper proposes is to make addressing match the units applications use: "packets are not pages."

3 · The flow translation table

Each core gets a flow translation table. Each row describes one transport-layer segment of one flow: the physical address of its payload in DRAM, its length, and its offset, the cumulative length of all preceding segments, starting from zero. Together the rows map any byte position in the flow to a location in memory, so the bytestream can be treated as one contiguous sequence without software recomputing physical addresses for each access.

Turning a flow byte range into DRAM reads
translation table · stream preprocessor · DRAM reader · contiguous flow cache
request from the core: <start_offset, length> flow translation table physical addresslengthoffset 0x0C0_00364980 0x080_0036498498 0x040_003628996 offset = sum of the lengths before it 0x36 = 54 B of headers before each payload stream preprocessor selects overlapping entries, emits one descriptor each DRAM reader 64 B reads; keeps the bytes TKEEP marks as valid read requests data + TKEEP DRAM: payloads stay where the NIC placed them private flow cache seg 1seg 2seg 3 04989961024 contiguous bytes; widths not to scale
Table rows from the paper's Figure 3; controller steps from Figure 8 and Section 4.3. The 1,024-byte total is this summary's arithmetic (996 + 28). The flow cache bar is schematic.

The flow cache that the table fills is read-only and not coherent with page-based addresses. The paper argues this restriction holds broadly because applications generally consume received payloads without modifying them in place. Because the cache is private to one core, software evicts flow data by overwriting it at points it chooses, with no inter-core contention or coherence traffic.

4 · From packet arrival to an assembled flow

The paper splits the work into flow storage, which runs as packets arrive, and flow assembly, which runs when a flow is ready to be processed (its Figure 4):

  1. Identify the flow. On arrival the NIC computes an identifier from the packet's unidirectional five-tuple.
  2. Record the segment. The payload is stored in DRAM through the NIC's normal receive descriptor ring, and the packet's metadata (payload address and length) is appended to that flow's linked list; a new list is created for a new flow. Flow storage continues until the last packet of the flow arrives or a timeout marks it complete.
  3. Fill the table. The SmartNIC CPU walks the linked list and copies each segment's address and length into the flow translation table, accumulating the offsets.
  4. Request assembly. The CPU sends the flow cache controller a <start_offset, length> request.
  5. Assemble. The controller reads the needed segments from DRAM, writes them into the flow cache in contiguous byte order, and notifies the CPU.
  6. Process. The CPU reads any part of the bytestream from the flow cache with no further DRAM transactions.

The design reuses the existing descriptor ring and packet placement path, which the paper presents as preserving compatibility with existing NIC drivers and software stacks. It contrasts this with Ensō, which introduces a new CPU-NIC interface, and Pigasus, which implements a fixed-function packet processing pipeline on the SmartNIC.

5 · Inside the flow cache controller

The controller has two cooperating units. The stream preprocessor scans the translation table for entries whose offsets overlap the requested range, computes the exact sub-range to take from each, and emits a StreamDescriptor (base physical address, valid byte count, end-of-stream flag). The DRAM reader issues reads through AMD's data mover IP core, receives data in 64-byte reads, uses the AXI TKEEP mask to extract the valid bytes, and appends them to the flow cache. The AXI TLAST signal on the final read of the final descriptor triggers the completion signal to the CPU. Separating table interpretation from memory access lets the reader concentrate on fetches and alignment.

Payloads rarely line up with 64-byte boundaries: on the Alveo U250 they typically begin after 54 bytes of headers. The paper distinguishes four cases (its Appendix A):

CaseStart offsetLengthHandlingHow common
1alignedaligned64 B reads go straight into the cache (e.g. offset 0, length 128: two reads)rare
2alignedunaligneda partial read at the endseldom
3unalignedalignedpartial reads at both ends (offset 54, length 128: three reads with 10, 64 and 54 valid bytes)common
4unalignedunalignedthe general case (offset 54, length 129: the third read holds 55 valid bytes), handled by the Flow Cache Data Alignercommon

For the general case, the controller still reads DRAM in aligned 64-byte bursts. The data mover runs in unaligned burst mode, which shifts the first valid byte to index 0, so the controller needs no shifting logic of its own. The Data Aligner then merges each read's valid bytes with residual bytes left from the previous read to form full 64-byte writes into the cache, carrying any overflow forward to the next write.

The controller supports on-demand access (fetch a small part of the stream to decide whether deeper inspection is needed) and speculative access (prefetch the whole flow when repeated access is expected, as in regular expression matching).

6 · Sizing, long flows and out-of-order segments

  1. Size for the common flow. Larger tables and caches cost on-chip area. Over 1.6 billion TCP flows measured on a university campus network in a four-hour period, 93.16% were 10 KB or less, so the paper sizes the flow cache and table for a 10 KB flow (assuming a 1,460-byte maximum segment size).
  2. Process long flows in windows. If the table holds W segments, software fills entries 0 to W−1, requests assembly, starts processing when the controller signals completion, and refills the table with the next group while advancing a logical window pointer, until the flow ends.
  3. Keep matches that span windows. For boundary-sensitive work such as regular expression matching, each window can repeat a small overlap from the end of the previous one, with duplicate matches in the overlap suppressed when results are reported.
  4. Reorder in software. Citing measurements that 0.3 to 3% of TCP segments arrive out of order, the table assumes in-order segments by default; when reordering is needed, the CPU reorders the linked list and updates the table.

7 · How it differs from scatter-gather DMA

Scatter-gather lets software name disjoint memory regions that a DMA engine copies into one contiguous buffer. The paper (Section 3.2 and Figure 6) separates the two designs on three points:

QuestionScatter-gatherFlow-based addressing
Where is the stream assembled?In a DRAM buffer, which the CPU then reads back: an extra write and read round trip to DRAMIn the private flow cache, after a single DRAM read of each payload
Who manages addresses?The CPU tracks physical addresses and prepares DMA descriptorsHardware maps logical flow offsets to physical addresses; the CPU sees only a contiguous flow
When can processing start?After the full bytestream is assembledAs segments become available in the flow cache, overlapping computation with assembly

The paper's summary: scatter-gather accelerates copying disjoint regions of DRAM, while flow-based addressing avoids the copies.

8 · The prototype and the experiments

The prototype runs on an AMD Alveo U250 FPGA-based SmartNIC at 300 MHz with 16 GB of off-chip DDR4. It has three parts (Figure 7):

  1. Packet handler (custom hardware). Writes each payload to DRAM and, from the L2 to L4 headers, emits a compact record at line rate: flow identifier from the five-tuple, TCP sequence number, payload DRAM address and length.
  2. MicroBlaze soft CPU (single-core, 64-bit, bare-bones configuration with no floating point unit or barrel shifter). Software maintains the per-flow linked lists with an open-addressed hash table in on-chip BRAM (head, tail and segment count per flow, O(1) lookup) and a shared node pool in DRAM with an intrusive free list. It populates the translation table, which holds one unidirectional flow at a time.
  3. Flow cache controller (custom hardware), as in Section 5 above, filling a flow cache in BRAM.

The flow cache and controller use 31,101 LUTs (1.80% of the FPGA), 43,569 registers (1.26%) and 113 Block RAM tiles (4.20%). That is 95 to 257% of the MicroBlaze and its L1 cache, which the paper attributes to the MicroBlaze being a minimal soft core; a more capable production CPU would shrink the relative share.

Two servers are connected by a 100 Gbps link; the sender replays traffic with DPDK-based pktgen on a U250 configured as a standard NIC (AMD OpenNIC), and the receiver runs the design. Firmware timers measure each stage, and an AXI performance monitor counts DRAM bytes and transactions. The copy-based baseline fetches all payloads into one contiguous DRAM buffer and processes it. The flow-based pipeline populates the table, has the controller fetch payloads into the flow cache, and processes from there. Packet processing time (identical in both) and linked-list maintenance are excluded.

ExperimentTraffic
Synthetic microbenchmarkTen 1,510-byte packets in a single flow
University campus traceFive minutes of anonymized per-packet TCP metadata from a 100 Gbps optical tap: 14.64 million packets in 100,211 flows (1% of flows sampled by five-tuple hash). Frames are rebuilt with zero-filled payloads of the recorded length, for privacy
Datacenter web-searchGenerated from the web-search flow-size distribution of the DCTCP and pFabric papers: 18,607 maximum-size (1,460-byte payload) packets in 10,000 flows

9 · Results

In the synthetic linear scan, building the contiguous buffer takes 5,836 µs in the copy-based design and 10 µs in the flow-based design, which adds a 12 µs table population step. Processing also gets faster (4,357 to 3,861 µs, 11.4%) because it reads from the flow cache instead of DRAM. The paper credits two factors for the near elimination of the copy step: the destination is on-chip BRAM instead of DRAM, and the writes are done by the controller at hardware speed instead of by memcpy on the CPU.

Where the time goes in the synthetic microbenchmark
copy stage + processing, in milliseconds · redrawn from the paper's Figure 10a and Table 4
copy stage processing 0510152025 execution time (ms) Linear scan copy-based 5.84 4.36 10.19 flow-based 3.86 3.88, 62% less Regular expression search copy-based 5.84 17.14 22.98 flow-based 17.14 17.16, 25% less
Values from the paper's Figure 10a, Table 4 and Section 5.1.1. In the flow-based bars the copy stage (0.02 ms in Figure 10a; 12 µs table population plus 10 µs buffer build in Table 4) is too small to draw. Absolute times reflect the 300 MHz MicroBlaze core.

The same pattern holds on the two traces (the paper's Table 5):

WorkloadTrafficExecution time reductionPer-core throughputDRAM traffic reduction
Linear scanSynthetic62%2.62×83%
Campus62%2.66×82%
Datacenter62%2.63×81%
Regular expressionSynthetic25%1.33×79%
Campus26%1.34×78%
Datacenter25%1.34×77%
  1. DRAM traffic. For linear scan it falls from 6.0× to 1.05× the payload size (synthetic), 6.03× to 1.09× (campus) and 6.19× to 1.18× (datacenter). The copy-based baseline reads DRAM to form the buffer, writes the buffer back, and reads it again to process it.
  2. Throughput. Synthetic linear scan per-core throughput rises from 11.4 to 29.9 Mbps, and regular expression search from 5.1 to 6.8 Mbps. The 6.31 ms saved is roughly 525 times the 12 µs table setup cost. The linear scan gain exceeds the 40% predicted by the BlueField-3 software emulation because the controller builds the contiguous buffer in hardware.
  3. Real traces. On the campus trace, linear scan time falls from 167.91 to 63.16 minutes, with copying down 99% (96.77 to 0.51 minutes). The paper notes that the top 1% of campus flows carry 96% of the bytes, so the savings land where most bytes are.
  4. Amdahl's law. Regular expression search is dominated by processing, which flow-based addressing does not speed up, so its gains are bounded near 25% in time and 1.34× in throughput.

The millisecond and megabit figures reflect the 300 MHz MicroBlaze, not the controller. Measured alone, the controller's assembly throughput rises with the number of 1,510-byte packets in a flow and saturates at about 76.48 Gbps at forty packets (goodput 72.30 Gbps; the gap is invalid bytes fetched at packet boundaries by 64-byte-aligned reads). Scaling by 7.11×, the ratio of the BlueField-3's 2.133 GHz Arm A78 clock to 300 MHz, the paper estimates that an ASIC controller could exceed 543.8 Gbps for a single core, against the 31.6 Gbps per-core linear scan throughput measured on BlueField-3. That estimate assumes the controller's speed scales with clock frequency.

10 · What the paper leaves open

  1. Linked-list maintenance. The prototype keeps per-flow lists in MicroBlaze software, and the measurements exclude that cost. Appendix D estimates it: a 48-byte node per packet, a node pool capped at 20,000 entries (at most 1 MiB), and 64 to 192 bytes of DRAM traffic per append. That adds 4 to 12% to the flow-based design's DRAM traffic, raising its ratio to at most 1.09 to 1.31× the payload, still a 79 to 82% reduction. The paper cites prior work showing list maintenance can be done in hardware at line rate.
  2. Further hardware offload. Header parsing, list maintenance and table population could move into dedicated hardware modules, which would also allow prefetching by flow offset and filtering by flow type (for example, skipping encrypted flows). These are described as options, not built.
  3. Flow tracking. The paper adopts linked-list flow tracking as one viable implementation and acknowledges that more efficient schemes may emerge; it also notes prior work cautioning against rigid TCP hardware implementations.
  4. Absolute performance. The processing core is a minimal 300 MHz soft CPU. The paper discusses a more powerful CPU for production systems and an ASIC version of the controller, but evaluates neither.
Common questions

FAQ

Q·What does the title mean?▾

SmartNIC memory is organized the way processor memory is: fixed-size pages read in cache lines. Network software works in packets and the streams they carry, which are variable-length and scattered. The title is the paper's key idea in short form: make addressing work in the units applications use (packets and flows), instead of relying on indirection such as scatter-gather and descriptors.

Q·Isn't this just scatter-gather DMA?▾

Both gather scattered pieces into one contiguous view, but scatter-gather copies them into a buffer in DRAM, which the CPU then reads back, and the CPU must track physical addresses and prepare DMA descriptors. Flow-based addressing reads each payload from DRAM once into an on-chip flow cache, keeps the offset-to-address mapping in hardware, and, by design, lets the CPU start on segments as they become available. The paper's summary: scatter-gather accelerates the copy; flow-based addressing avoids it.

Q·How does it relate to Ensō, Pigasus and ZeroNIC?▾

Ensō replaces the CPU-NIC interface with a streaming one; flow-based addressing instead reuses the existing descriptor ring and packet placement path. Pigasus builds a fixed-function packet processing pipeline on the SmartNIC; this design keeps general-purpose cores and changes how they address memory. The paper names ZeroNIC, which places payload data directly from the NIC into application buffers, as the closest parallel to the flow cache, with the difference that flow-based addressing targets transport-layer bytestreams rather than arbitrary accelerator destinations.

Q·Why is the flow cache read-only and not coherent?▾

A second addressing scheme over the same bytes would otherwise raise coherence problems with page-based addresses. The paper avoids them by making the flow cache read-only and non-coherent, arguing that this holds broadly because applications generally consume received payloads without modifying them in place. Since the cache is private to one core, software evicts data by overwriting it at points it chooses, with no coordination between cores.

Q·What happens to flows larger than the 10 KB flow cache?▾

Software processes them in windows that match the translation table's capacity: fill the table with the next group of segments, request assembly, process, and advance a logical window pointer until the flow ends. For patterns that can span a window boundary (regular expressions), each window can repeat a small overlap from the previous one, and duplicate matches in the overlap are suppressed when results are reported. The paper says this supports arbitrarily long flows without a proportionally larger cache or table.

Q·What about out-of-order segments?▾

The table assumes in-order segments by default, citing measurements that 0.3 to 3% of TCP segments arrive out of order. When reordering is needed, the SmartNIC CPU reorders the flow's linked list and updates the table. Packet handling also records TCP sequence numbers to maintain in-flow order.

Q·Does software running on the SmartNIC have to change?▾

The processing code sees a contiguous, read-only region of memory, so code written for a reassembled buffer can read the flow cache instead. Something must still fill the translation table and issue assembly requests; in the prototype that is software on the MicroBlaze, and the paper suggests it could move to hardware. On the NIC side, the design reuses the existing descriptor ring and packet placement path to stay compatible with existing drivers and software stacks.

Q·Why are the measured throughputs in megabits per second?▾

The processing core in the prototype is a bare-bones 300 MHz MicroBlaze soft CPU, so absolute times and throughputs reflect that CPU, not the flow cache controller. The comparison that matters is between the copy-based and flow-based pipelines on the same hardware. Measured on its own, the controller assembles flows at about 76.48 Gbps at 300 MHz.

Q·Why does regular expression search gain so much less than linear scan?▾

Amdahl's law. Flow-based addressing removes the copy stage but does not speed up processing, and processing dominates regular expression search (17.14 of 22.98 ms in the synthetic case). Removing the 5.84 ms copy gives about 25% less time and 1.33 to 1.34× throughput. Linear scan spends more of its time copying, so it gains about 62% and 2.6×. DRAM traffic falls sharply for both (77 to 83%).

Q·Do the measurements include the cost of tracking flows?▾

No. Maintaining the per-flow linked lists in MicroBlaze software is excluded from both time and DRAM measurements, as is packet processing time, which is the same in both pipelines. The paper's Appendix D estimates the list cost analytically at 64 to 192 bytes of DRAM traffic per packet, adding 4 to 12% to the flow-based design's DRAM traffic and leaving a 79 to 82% reduction against the baseline. It also cites prior work doing list maintenance in hardware at line rate.

Q·Could the controller keep up with a real SmartNIC core?▾

The paper argues yes, by projection. The controller saturates at about 76.48 Gbps at 300 MHz. Scaling by 7.11×, the ratio of the BlueField-3's 2.133 GHz Arm clock to 300 MHz, an ASIC version could exceed 543.8 Gbps for one core, against the 31.6 Gbps per-core linear scan throughput measured on BlueField-3. This assumes the controller scales with clock frequency; no ASIC was built.

Q·Is the campus trace real traffic?▾

Its structure is. A recorder on a 100 Gbps optical tap at a large university sampled 1% of TCP flows by a deterministic five-tuple hash and logged anonymized per-packet metadata (timestamps, keyed-hash IP addresses, ports, payload length, flags) for five minutes: 14.64 million packets in 100,211 flows. No payload bytes were stored. Frames were rebuilt with zero-filled payloads of the recorded lengths, which preserves sizes, timing and flow structure. The datacenter trace is generated from a published web-search flow-size distribution.

Q·How much FPGA area does it take?▾

The flow cache and controller use 1.80% of the U250's LUTs, 1.26% of its registers and 4.20% of its Block RAM tiles. That is 95 to 257% of what the MicroBlaze and its L1 cache use, a comparison the paper attributes to the MicroBlaze being a deliberately minimal soft core.

Background terms
SmartNICA network interface card that carries its own processors (general-purpose cores, FPGA logic or fixed-function accelerators) and memory, so it can run network functions and application code itself instead of passing every packet to the host CPU.
Line rateThe maximum data rate of a network link, for example 400 Gbps. Processing at line rate means keeping up with traffic arriving at that speed.
Memory bandwidthThe rate at which data can move between a processor and its DRAM, usually in GB/s. Every read and every write of a byte uses some of it.
Five-tuple and flowThe five-tuple is a packet's source and destination IP addresses, source and destination ports, and transport protocol. Packets with the same five-tuple in one direction form a unidirectional flow.
Transport-layer segment and payloadA segment is the unit TCP sends in one packet; its payload is the application data it carries after the Ethernet, IP and TCP headers.
Stream reassemblyPutting the payloads of a flow's segments back in order to recover the contiguous bytestream the sender wrote, as applications such as intrusion detection must do before inspecting it.
DMA and descriptor ringDirect memory access (DMA) is hardware moving data to or from memory without the CPU copying it. A descriptor ring is a circular queue of descriptors, records that tell the NIC where in memory to place each received packet.
Scatter-gather DMAA DMA mode in which software supplies a list of disjoint memory regions and the engine copies them into (or out of) one contiguous buffer.
Flow translation tableThe paper's per-core table with one row per segment of a flow: the payload's physical address, its length, and its offset in the flow's bytestream. It maps flow byte offsets to memory locations.
Flow cacheThe paper's private, read-only, directly addressable on-chip memory (BRAM in the prototype) into which the flow cache controller assembles a flow's bytestream for one core.
Cache lineThe fixed-size block (64 bytes here) in which memory is read and written between DRAM and caches. Reading one byte brings in its whole line.
Cache coherenceThe hardware guarantee that all caches and cores see a consistent value for each memory address. The flow cache is deliberately outside this mechanism.
FPGA and BRAMA field-programmable gate array is a chip whose logic can be reconfigured after manufacture. BRAM (block RAM) is the small, fast on-chip SRAM-like memory built into it.
MicroBlazeAMD's (formerly Xilinx's) soft processor: a CPU implemented in FPGA logic rather than as fixed silicon, configurable with or without features such as a floating point unit.
AXI stream, TKEEP and TLASTAXI is an on-chip bus protocol from Arm used across FPGA designs. In its stream form, TKEEP is a per-byte mask marking which bytes of a transfer are valid, and TLAST marks the final transfer of a packet or burst.
Amdahl's lawThe rule that speeding up one part of a task improves the whole only in proportion to that part's share of the total time.
GoodputThe rate of useful data delivered, here valid payload bytes, as opposed to throughput, which also counts extra bytes moved (such as padding fetched by aligned reads).
Summary of A. Adams, H. S. Shim, C. Drewes, B. O'Keefe, P. Levis and Z. Durumeric, "Packets are Not Pages: Flow-Based Addressing Conserves Memory Bandwidth," Proc. ACM Netw. 4, CoNEXT3 (CoNEXT '26). Numbers are from the paper unless marked as this summary's arithmetic.