[MUSIC] Hello and welcome back.

In this video, I'm going to explain

what a reconfigurable architecture is, and I will also talk about the main
features of field programmable gate arrays as an example of
reconfigurable architectures. Several FPGA platforms would be introduced
to you as well as their main features. The most efficient approach in
terms of energy consumption and performance to implement an embedded
system is to develop an application, a specific integrated circuit. However, one of
the main drawbacks
of this approach is the cost. Indeed, ASIC development cost
is much higher than let's say, software development for a processor. On the other
hand, a processor is much
cheaper option to be then embedded system on, but it does not give you
a good energy performance trade off. ASICs processors are in a way, two
extremes, but what do we have in between? The configurable architectures
are a good compromise here. These devices can be almost as fast
as the special purpose hardware and at the same time, their inner architecture can
be changed
which brings some degree of flexibility. Field programmable gate arrays are an
example of reconfigurable architectures, that we are going to focus on. An FPGA is
a semiconductor device which can be configured to
implement different algorithms. I would like to emphasize
that an FPGA implementation is a hardware base approach
to realize a certain task. Meaning that hardware changes,
whereas if you use a processor, the underlying hardware stays the same,
but the software can be changed. So what is the inner structure of
an FPGA that allows these devices to reconfigure its hardware? Its core compromises
a matrix of logic blocks, which can be connected to each
other via special interconnects. As mentioned before, an FPGA should be configured
to
realize a certain application. For that it can be programmed
with a new design. Program availability wise,
FPGAs can be one time programmable. These type of FPGA's is not meant for
applications where in field
reprogrammability is needed. On the other hand, reprogram level
FPGAs can be reconfigured by our user many times without
using any special equipment. Now let's go deeper in to the details
about the inner structure of FPGAs. The logic block plays the central role and it
can be considered as
the building block of an FPGA. The features of these
block might be different depending on certain types of an FPGA. But it usually has
combinational logic inside which is represented by look up tables. The lookup table
style of the logic was chosen because it makes easy to derive
the functionality of the logic block. Additionally, the logic block contains
a register to implement sequential logic, which introduces clocking and
synchronization into the design and it's a fundamental
component of digital logic. There are also multiplexers
inside of the logic block, which allow to select either the lookup
table or the flip flop output. Although the logic block is flexible
obviously with only one logic block, it is impossible to implement
any kind of logic function. Complex designs will require many
logic blocks to be connected together. The special interconnects inside
of an FPGA serve this purpose. These interconnects are an important and
one of the most complex aspects of an FPGA since wiring is a global
property of a logical designer. Note that the interconnection between
logic elements might be very complex. And therefore, not only connections
between logic elements are required but also between wires themselves. An SRAM
based FPGA uses a SRAM
to hold the information used to program the interconnects. In a design,
it is often necessary to source some data. For this purpose,
there are ground blocks available, these blocks use the same storage that
is used for the look up table function. The majority of FPGAs
nowadays are SRAM based. SRAM based FPGAs store the configuration
data in static memory. The drawback of SRAM is
that it is volatile and can't keep the data without power source. Because of that
such FPGAs must be
programmed or configured upon start. There are two basic ways
of programming an FPGA. It can be either done in a master mode
when the FPGA gets the configuration data from an external source for example, from
external flash memory or in a slave mode. When FPGA is configured by
an external master device. For example, a processor. This can be done via dedicated
programming interfaces. It is also worth mentioning
that some types of FPGA support partial reconfiguration, and
there are two types of it. First of them is dynamic partial
reconfiguration, that allows you to change the part of the design while
the rest of an FPGA is running. Another one is the static
partial reconfiguration when the FPGA is not running
during the reconfiguration. Before we continue,
let's mention the upsides and the downsides of FPGA implementation. So compared to
software solutions,
an FPGA implementation is faster and more efficient in terms
of energy consumption. On the other hand, FPGAs lose in
many aspects such as performance and energy consumption to ASICs. However, FPGA
design development
is much cheaper than ASIC designs. In other words FPGAs provide a tool
that lies in between fully software and fully hardware implementations. Due to
their reconfigurable nature FPGAs
are good for different applications and markets because of the high
cost of ASIC manufacturing, it is important to model
the design before then. Therefore, ASIC prototyping is
one of the application areas for FPGAs which allows accurate modeling and
verification as well as rapid software and firmware development and
reduces the risk of design errors. The wide domain of digital signal
processing can also benefit from FPGAs. Indeed, FPGAs provide high computational
throughput by using parallel architectures. Their ability to reconfigure
the inner hardware enables designers to develop customized architectures for
ideal implementation of their algorithms. FPGAs provide cheaper solutions and
faster time to markets for low to medium volume productions. Compared to ASICs
which usually
require a lot of money and time to get the first device. So you can buy FPGA
platforms
directly from the FPGA vendors. The biggest FPGA manufacturers are Xilnx,
Altera, and Actel. On their websites, you can find a lot
of information about their FPGA chips as well as about the platforms they sell. It
is sensible to make the platform choice based on the application that
you would like to implement. However, if you are in the phase
of discovering what FPGA is, the choice can be done
based on other parameters. For example, the platform can be
picked according to performance or overall amount of resources it has. Another way
to select the proper
device is to choose it based on the field where you like to apply it in. I will
introduce you FPGA
platforms based on Xilinx FPGAs. Xilinx separates its chips into families. There
are four of them. Low end devices, 7 devices,
UltraScale and UltraScale+. All families are different from each other
depending on the amount of available resources, performance and
application area. For example, Spartan-6 based platforms are
the most cost optimized solutions, whereas UltraScale+ family provides the highest
performance and integration capabilities. Here, I would like to introduce you
to Spartan-6 based FPGA platform. This platform is a good development
environment for discovering and evaluating a spartan 6 FPGA family. The evolution
kit has all the basic
components for system development, and also provides some example designs to
speed up the discovery of the features such as integrated memory interface core. So
such development platform is a good
starting point to discover FPGAs. In this video, we covered important
aspects of recomforial architectures, take a FPGA as an example. We covered the
main building blocks
of FPGAs and discussed the platform which might serve as a good start point
for you if you want to discover FPGAs. [MUSIC]