FPGA are devices where DSP algorithms fit perfectly. The MACC blocks in FPGA are almost designed for this kind of algorithms but they are also a limited resource. Small FPGA like Spartan 7 or Intel MAX10 have a reduced number of MACC blocks but well used, that little amount can be enough to implement even high-order filters. This session talks about how to optimize the number of MACC blocks used in DSP algorithms by applying technics like folding, optimizing the number of bits, or changing the structure of the DSP algorithm. During the session, we will see the implementation results of the different technics and how much we can reduce the amount of MACC blocks and also the number of general resources used.

This guide was created with the help of AI, based on the presentation's transcript. Its goal is to give you useful context and background so you can get the most out of the session.

What this presentation is about and why it matters

This talk walks through practical techniques to reduce FPGA resource usage when implementing digital signal processing (DSP) algorithms. The speaker uses an example eighth-order FIR filter and a Xilinx 7-series DSP slice (DSP48E1) to demonstrate how choices in algorithm structure and coding map directly to hardware cost: number of multipliers (MAC units), registers, and logic (LUTs). You will see concrete trade-offs such as using coefficient symmetry, registering the MAC, or folding computations into a single multiplier.

Why this matters: in many real systems (industrial controllers, embedded radios, audio processors, sensors) developers must fit signal-processing blocks into small, low-cost FPGAs that have a limited number of hardware multipliers. Making the right structural and coding choices can turn an impractical design into one that meets timing, cost, and power targets without changing the algorithmic behavior.

Who will benefit the most from this presentation

• FPGA engineers and developers implementing DSP (filters, PID controllers, IIR biquads).
• DSP engineers who want to understand hardware constraints and how algorithm structure affects resource use.
• Embedded system designers choosing devices and trade-offs between logic, DSP blocks, and clock frequency.
• Students learning how synthesis and place-and-route map code to real hardware and why coding style matters.

What you need to know

This presentation assumes basic familiarity with discrete-time DSP and some FPGA development concepts. The short list of useful background topics:

• MAC structure: Many DSP operations are repeated multiply-accumulate steps. A single MAC performs multiply then add — it is the inner loop of filters and many controllers.
• FIR filter math: The impulse-response form is useful to keep in mind: $y[n]=\sum_{k=0}^N b_k\,x[n-k]$. Implementing this directly needs one multiply per coefficient per output sample.
• FPGA primitives: Modern FPGAs include dedicated DSP slices that combine pre-adders, multipliers, accumulators, and registers. In Xilinx 7-series the DSP48E1 contains an 18×25 multiplier and a 48-bit accumulator plus configurable input/output registers.
• Bit-width and quantization: Hardware multipliers have fixed operand widths. Reducing operand width (for example, from 32-bit to 16-bit fixed-point) can let you use fewer DSP blocks or fit more parallelism into a device.
• Pipelining vs latency: Adding registers improves clock frequency (timing) but increases latency (pipeline depth). This is acceptable when there are many clock cycles between input samples (e.g., high clock, low sample rate).
• Folding / time-multiplexing: You can reuse a single multiplier for multiple coefficient products by sequencing operations across several clock cycles. Folding reduces multiplier count at the cost of control logic and increased computation latency.
• Synthesis/place-and-route behavior: The tools choose how to map RTL to primitives. You influence the result by coding style (e.g., using registers where DSP slice registers exist) and by selecting algorithm structures congenial to the DSP primitive.

Glossary

• FPGA — Field-Programmable Gate Array, a reconfigurable chip consisting of logic blocks, interconnect, RAM, and specialized blocks like DSP slices.
• DSP slice / DSP48E1 — A dedicated MAC block inside many FPGAs; contains pre-adder(s), multiplier, ALU/accumulator, and input/output registers.
• MAC — Multiply–Accumulate operation (multiply then add); the core operation of filters and many DSP algorithms.
• FIR filter — Finite Impulse Response filter implementing $y[n]=\sum b_k x[n-k]$ via a set of multiplies and adds.
• IIR filter — Infinite Impulse Response filter that uses feedback (poles) and often is implemented as cascaded biquad sections.
• Pipelining — Inserting registers to split long combinational paths, increasing maximum clock rate while adding latency.
• Folding (time-multiplexing) — Reusing a single hardware multiplier across multiple multiplication operations by sequencing them in time under control logic.
• Pre-adder — An adder located before the multiplier in a DSP slice; useful for symmetric coefficient exploitation (add samples then multiply).
• Bit-width / Quantization — Number of bits used to represent signals; reducing width lowers resource use but can affect numerical accuracy.
• Synthesis / Place-and-Route — Toolchain steps that translate RTL into FPGA primitives and then place and interconnect them on the chip.

Final note

Pablo Trujillo’s talk provides a clear, hands-on walk through how small design changes — coding style, choice of filter structure, and explicit use of DSP slice features — change the hardware cost and timing of DSP implementations. The examples (symmetric FIR, registered MAC, pipelined chain inside DSP slices, and folding) are practical patterns you can apply immediately. If you build DSP on FPGAs, this presentation is a compact, practical guide to thinking like the device: match your algorithmic diagram to what the silicon provides, and you’ll save multipliers, meet timing, and reduce board cost. Enjoy the talk — it’s a useful blend of theory-to-hardware lessons and real implementation results.