Integration of multiple storage and network IPs on a single FPGA

Integration of multiple storage and network IPs on a single FPGA

The hard part of integrating storage and networking IP on one FPGA is defining what crosses each boundary and who owns control, reset, and error behavior. We recommend settling those decisions in a shared architecture brief before selecting cores.

The short answer

The short answer: we recommend defining an architecture brief and an interface contract before shortlisting IP. For each connection, record the payload and metadata, producer and consumer, handoff, flow-control owner, reset and error behavior, clock domains, and latency tolerance. Set project-specific throughput, timing, and resource targets, and state what evidence will count as acceptance. Compare point-to-point and shared logic against the design’s bandwidth and routability priorities. Keep adapters tied to named mismatches, choose the data-flow pattern deliberately, and include shared-memory access in timing analysis when execution-time bounds matter.

What should an integration architecture specify before IP selection?

Before selecting FPGA IP, define the workload, interfaces, boundaries, ownership, and acceptance criteria, then assess each candidate against that architecture.

Describe what the FPGA must do in the intended system. Identify the storage and network functions in scope, the data paths they serve, and the operating scenarios the design must support. Record expected traffic patterns, concurrency, payload assumptions, and priorities. State the required behavior when a path is unavailable or a transfer does not meet its intended outcome. Treat these as project requirements, not assumptions inferred from an IP description.

Map each boundary between the FPGA, external devices, and surrounding logic. Specify the interfaces to connect, the control and status signals the design must expose, and the clock and reset assumptions candidates must accommodate. Assign ownership at each boundary, including responsibility for adaptation, arbitration, buffering, and error handling where the architecture requires it. Mark unresolved responsibilities as open decisions rather than silently assigning them to an IP.

If software participates, describe how it is expected to interact with the hardware, including configuration, status access, and the evidence needed to validate that interaction. Set project-specific targets for throughput, latency, timing, and resource use. Keep the system’s acceptance criteria separate from an IP description, and make assumptions visible so reviewers can challenge them.

Define what counts as acceptance before shortlisting candidates. Specify the verification evidence, integration artifacts, timing results, bring-up expectations, and delivery items the project requires, then identify who reviews each item. Our recommendation is to shortlist IP only when its responsibilities, interface assumptions, and acceptance evidence can be compared against the same written architecture brief.

How should storage and networking paths align at their shared interface?

Align storage and networking paths through an explicit interface contract that defines the payload, metadata, ownership, and handoff each side expects.

Write the contract from the perspective of both paths. For each item crossing the boundary, identify its producer and consumer, explain what it represents, and specify which side interprets its fields. Make assumptions visible rather than leaving either side to infer them. Record the required ordering, buffering assumptions, and behavior expected when a transfer pauses or resumes.

Make ownership clear in the contract:

  • Define the handoff. Describe what starts a transfer and how each side indicates readiness.
  • Assign control decisions. Name the owner for flow control and for handling reset or error conditions.
  • State the data expectations. Record the meaning of the payload and metadata, along with ordering and buffering assumptions.
  • Make the contract reviewable on its own. Give reviewers enough context to trace the handoff without relying on undocumented behavior elsewhere in the design.

We recommend using the same contract when reviewing both paths, then resolving mismatches at the boundary rather than letting each path carry a different interpretation. Keep unresolved choices marked as design decisions. The deciding criterion is whether both paths agree on what crosses the boundary and who owns each decision.

An engineer probes two clock sources beside an FPGA on a circuit board.

Which clock-domain boundaries need explicit treatment?

Treat each connection between synchronous IP cores in different clock domains as an explicit interface decision, with its acceptable transaction latency written down.

IBM Research presents an interface technique for hazard-free communication among synchronous IP cores in different clock domains. Use that framing to record the connection under review, its endpoints, their clock domains, and the interface between them. Keep the chosen treatment and its rationale attached to that boundary so reviewers can assess the decision in context.

For an OCP-style read/write interface, the Technical University of Denmark paper says that passing all control signals across a clock-domain boundary and synchronizing them may add significant transaction latency. Keep the qualification “may”: the statement does not give a fixed delay. We recommend writing down how much latency the integrated transaction can tolerate before choosing a treatment. Keep this finding scoped to OCP-style read/write interfaces rather than applying it to other protocols.

For each connection under review, record the endpoints, clock domains, interface, latency requirement, and assumptions behind the design decision. Separate a project-selected target from a property stated by a source. If the interface has not yet been characterized, leave the decision open rather than filling in unsupported details.

When should cores connect point-to-point rather than through shared logic?

Choose point-to-point interconnect when its bandwidth advantage matters to the design and its routability cost fits the project’s constraints. In a bus-based SoC context, the paper reports that point-to-point interconnect provides higher bandwidth at a routability cost.

Start with the required bandwidth, then state the routability constraints the design must accommodate. Compare both options against those same requirements instead of treating either topology as the default.

Decision criterion Point-to-point Shared logic
Bandwidth priority Consider it when bandwidth is a priority and the routability cost fits the design. Assess it against the path’s stated bandwidth requirement.
Routability constraint Include the routability tradeoff in the decision criteria. Keep it in consideration when the point-to-point tradeoff does not fit the project.
Decision record Record why the bandwidth priority justifies the tradeoff. Record how the option meets the same stated requirements.

The cited result concerns a bus-based SoC context, so use it as a tradeoff to assess, not as a universal ranking for FPGA topologies. We recommend making the choice for each connection and recording which requirement it serves and which constraint it accepts.

How can glue logic stay limited without hiding interface mismatches?

Keep glue logic limited to explicit, reviewable adaptations, and leave unresolved interface mismatches visible. If a wrapper would obscure a disagreement about ownership, handshake meaning, reset expectations, or error behavior, resolve the contract first.

Before adding an adapter, write down what each side expects for signal meaning, data ownership, reset behavior, and error handling. When those assumptions conflict, agree on a shared contract rather than making the glue layer the only place where the intended behavior can be inferred.

For a storage path feeding a network path, name the handoff and the decision each adapter is meant to handle. Name the mismatch each adapter resolves, then document its expected input, output contract, and owner. If the change also settles an unresolved design decision, make that decision explicit before adding the logic.

Keep exceptions traceable in the integration documentation and review them against both connected IPs. Ask whether another engineer could explain why the adaptation exists without guessing. If not, clarify the contract or the adapter’s purpose.

What does a memory-oriented streaming path change in the data flow?

In the Cambridge architecture account, the memory system understands some data structures and streams data to CPU cores as needed; Blocks & Files contrasts this with a CPU-led sequence involving instruction completion, cached instructions, cache misses, and DRAM access.

We recommend making the data-flow choice explicit at integration. Name the data structures in scope, state whether the memory system should stream them to CPU cores, and describe whether the CPU-led sequence is the intended alternative. The label “memory-oriented” alone does not define which structures the design should handle.

Blocks & Files reports that BlueShift developed an FPGA with an integrated RISC-V processor and modified Codasip core to maximize memory bandwidth and accelerate CPU-core-to-DRAM access. Use the design’s own requirements to decide whether a similar data-flow approach is relevant, and record the structures it is intended to cover.

When should storage and networking traffic stay on separate paths?

When execution-time bounds matter, include shared-memory access in the timing analysis before deciding whether storage and networking traffic should stay on separate paths. The paper identifies access to shared memories via the on-chip bus as the main source of unpredictability when bounding hardware-accelerator execution times.

We recommend treating that finding as a timing-related reason to examine the path, not as a universal topology rule. The paper identifies a source of unpredictability; it does not establish that separating paths alone produces a timing bound.

For the architecture review, record whether an execution-time bound is in scope and whether shared-memory access via the on-chip bus is relevant to it. Then state whether that concern supports separate paths in this design. Keep the requirement distinct from the response: explain the timing concern first, then the path decision it informs.

If timing bounds are not driving the decision, use the project’s other stated requirements to choose the topology rather than treating this finding as the sole reason to separate paths.

Frequently asked questions

What is integration architecture?

We use “integration architecture” for the written plan that sets a design’s functions, interfaces, boundaries, ownership, and acceptance criteria before IP selection; our FPGA development workflow places architecture before RTL and integration.

What are the top 5 integration tools?

For FPGA IP integration, our five practical engineering aids, not a universal software ranking, are an architecture brief, an interface contract, a connection decision record, timing analysis, and verification evidence.

What are the integration types?

For this FPGA integration context, we treat point-to-point and shared logic as the two interconnect options to assess; in a bus-based SoC, the cited paper reports higher bandwidth for point-to-point at a routability cost, so this is a tradeoff rather than a universal ranking (Tsinghua University Press).

What is the meaning of integration in business?

In this FPGA product-development context, we use “integration” to mean connecting IP cores and surrounding logic through defined interfaces, with responsibilities assigned at each boundary. Logic Design Solutions places integration after RTL and before timing closure in its eight-phase custom-development workflow.

In summary

We recommend turning the architecture into a connection-by-connection decision record before selecting IP. Name the endpoints and clock domains, write the interface contract, set latency and bandwidth requirements, assign ownership, and mark unresolved mismatches as open decisions. Then compare each topology and adapter against those requirements.

How we wrote this article

The sources we consulted are listed at the end of the article, consulted on 2 November 2026. Where we cite none, it is our opinion, and we write it as such.

This article gives buying criteria and our point of view. It does not replace a professional’s advice on a specific situation.

It is published by Logic Design Solutions, which therefore has an interest in the subject.

Sources
  1. UK startup wins gong for accelerating CPU memory access, blocksandfiles.com
  2. Modeling and Analysis of Bus Contention for Hardware Accelerators in FPGA SoCs, drops.dagstuhl.de
  3. Custom FPGA Development: From Spec to Validated Bitstream – Logic Design Solutions | Logic Design Solutions, logic-design-solutions.com
  4. A synchronous interface for SoCs with multiple clock domains for SOCC 2004 – IBM Research, research.ibm.com
  5. Clock domain crossing modules for OCP-style read/write interfaces – Welcome to DTU Research Database, orbit.dtu.dk
  6. Simultaneous Accelerator Parallelization and Point-to-Point Interconnect Insertion for Bus-Based Embedded SoCs, sciopen.com