Programmable Devices
CPLDs, FPGAs, SoC FPGAs, Configuration, and Transceivers
Announcements
All support for Intel NUC 7 - 13 systems has transitioned to ASUS. Read latest update.
20592 Discussions

Logic cells vs Byte conversion

anonimcs
New Contributor I
635 Views

Hi,

I want to use an FPGA for a project but I was wondering which FPGA to pick. I know the memory usage of my cost-unfriendly blocks in terms of Bytes, but in the datasheets of FPGAs all I see is the logic cells (which ofc makes sense considering its architecture). I was wondering if there's any way to convert the amount of logic cells into Byte-based memory capacity.

Looking forward to your support,

Cheers

Labels (1)
0 Kudos
7 Replies
SyafieqS
Moderator
588 Views

 "I was wondering if there's any way to convert the amount of logic cells into Byte-based memory capacity"

-I don't think that is possible and practical in determine device need for your project.


0 Kudos
anonimcs
New Contributor I
560 Views
But then how would you pick the Fpga for your applications cinsidering its memory ?
0 Kudos
SyafieqS
Moderator
569 Views

Let me know if there is any update


0 Kudos
SyafieqS
Moderator
495 Views

Choosing the right FPGA for your application involves considering various factors beyond just memory requirements. Here's a step-by-step guide to help you select an FPGA for your project:


Define System Requirements:


Clearly define your project's requirements, including performance targets, I/O needs, processing power, and, of course, memory requirements.

Memory Requirements:


Identify the specific memory requirements of your design in terms of size, speed, and access patterns. Determine whether your application needs high-speed, low-latency memory, or if larger, slower memory is sufficient.

Consider Memory Types:


FPGAs offer different types of on-chip memory, such as Block RAM (BRAM), distributed RAM, and UltraRAM. Understand the characteristics and limitations of each type and choose the one that best fits your application.

Logic Cells and Resources:


Consider the number of logic cells and resources available on the FPGA. While logic cells are primarily used for logic functions, some FPGAs allow flexible use of resources, such as Look-Up Tables (LUTs) for memory-like functions.

Clock Speed and Performance:


Evaluate the FPGA's clock speed and overall performance. Ensure that the FPGA can meet the required performance targets for your application.

I/O and Connectivity:


Check the number and types of I/O ports available on the FPGA. Make sure it has the necessary interfaces (e.g., GPIO, PCIe, Ethernet) for your application.

Development Tools and Ecosystem:


Consider the quality of development tools and the FPGA's ecosystem. A robust set of tools, good documentation, and community support can significantly ease the development process.

Power Consumption:


Evaluate the power consumption of the FPGA. Depending on your application, power efficiency may be a critical factor.

Budget and Cost:


Consider your budget constraints. High-end FPGAs with extensive resources may be more expensive, so find a balance between the features you need and your budget.

Future Scalability:


Consider whether your project might need scalability in the future. Choosing an FPGA from a series that offers scalability can be beneficial for future upgrades.


0 Kudos
_AK6DN_
Valued Contributor I
477 Views

"...but in the datasheets of FPGAs all I see is the logic cells (which ofc makes sense considering its architecture). I was wondering if there's any way to convert the amount of logic cells into Byte-based memory capacity."

 

Not accurate. All the data sheets for FPGA devices with memory (virtually all these days) list the number of memory blocks (which may be of sizes like 4Kb, 9Kb, 10kb, etc per block) and the number of logic cells on the device. For example, for Cyclone V:

Capture.PNG

for each device the number of logic elements and the number of memory cells (of 10Kb capacity) are called out.

For most modern devices the memory cells and logic cells are independent. Using logic cells for memory is very
inefficient and only makes sense for very small memory arrays (like in the 16 to 64bit range). The dedicated memory
blocks are the way to efficiently implement memory on the device.

Your fundamental premise is not correct.

0 Kudos
anonimcs
New Contributor I
462 Views

Thanks for the response.


@_AK6DN_ wrote:

...Using logic cells for memory is very inefficient and only makes sense for very small memory arrays (like in the 16 to 64bit range). The dedicated memory blocks are the way to efficiently implement memory on the device...


I believe this is not right, the MLAB (memory logic array blocks) row should correspond to that if I'm not mistaken. But I still don't understand why we can't use the rest of the logic elements as MLAB memory. In the table you posted MLAB only adds around 10-15% more memory units, or why we have separate MLAB blocks instead of having less but larger arrays.. 

0 Kudos
_AK6DN_
Valued Contributor I
447 Views

From the Cyclone V User Manual. MLAB blocks reuse ALM logic blocks as memory. They are by design smaller memories as they are designed to function as either a logic cell ALM or a memory cell MLAB. Each MLAB is 640 bits, organized as 32x20 bits using  up to 10 32x2 bit slices. See the description below. So if you need a small register array or small single port memory an MLAB suffices. But for larger memory needs or dual port functionality the M10K (for Cyclone V) has much larger capacity. But it is dedicated memory. Use it or lose it.

Me thinks you should download a few device user guides and read them to understand the detailed device implementation issues.

Capture.PNG

Reply