Why Hardware Description Language?

Question

Before moving to understand the purpose of Hardware Description Language(HDL), we need to know what is HDL?

From wiki,

A hardware description language enables a precise, formal description of an electronic circuit that allows for the automated analysis and simulation of an electronic circuit.

The above description is too hard for me to understand so I will attach a more easy definition from Quora.

A hardware description language allows you to define a logic circuit as a kind of program. This allows you to define a circuit's behavior and also to simulate its operation.

So, from the above two definitions what I understood was, HDL is some kind of script where we define the behavior of different gates, and why we need that script is to create a simulation world where we can do some tests before moving to the hardware level. And this script can be written in two different popular languages. Verilog and VHDL.

Please, help me to correct my concept on the purpose of HDL if I am wrong.

N.B My background is in Computer Science & Engineering. I will appreciate it if you use simple words in your answer.

Answer 1

Your interpretation is more or less correct at the first glance, but I think there are still some misunderstanding.

The term "script" you use isn't quite appropriate. The "script" term is typically used for languages that are interpreted by some software (e.g. a perl script is interpreted by the perl runtime, which is the software I'm talking about), it isn't usually used for languages that can be directly executed by the hardware (nobody use "script" to describe a C source code, which translates to machine code when compiled, which is directly executable by the target processor).

And that is probably a hint to the deeper misunderstanding you seem to have: the HDL code is not targeted to be interpreted by some runtime. The aim of HDL is to provide a way to describe hardware configurations of gates/flip-flops, and all kind of digital electronic blocks (you seem to have understood this), but the target can be more than just simulation. If the aim was just to simulate it, that wouldn't be very useful: you would write your HDL code, then simulate and test it, and then, when you want to make an actual chip with this very behavior... well, you do your design again with something else than HDL? What a waste of time, and the simulation you did was validating something that will have nothing to do with the final product.

HDL is typically used throughout the whole design from simulations to the final target chip, because it can sure be simulated (through some kind of interpreting runtime on a computer, as you indeed implied), but it can also be "compiled" (the term "synthesized" is actually used rather than "compiled" for HDL, but the principle is the same) into an actual chip design. The target can be FPGAs (generic chips containing lots of gates and flip-flops that can be dynamically configured in the way you want), or ASICs (actual custom chips that are engraved with the design you want). For FPGAs, synthesizing your HDL will produce some "bitstram" that you can load into the FPGA chip, and the chip will then physically behave as per your design. For ASICs, the synthesization will produce (very indirectly, but still) some masks used for silicon chip lithography.

That way, you can simulate, test, and go into production with the same design description, which avoids lots of mistakes and makes for a much faster design process. This is the whole point of HDL.

Answer 2

HDL is what you specified it to be, a type of code that describes the circuit you are trying to create. The main difference of HDL in comparison to other coding languages you already may know, such as C or python, is that the HDL is written such that the execution done in parallel, as is done in a real circuit, so the designer must take care in specifying which parts of the circuit happen in parallel (combinational logic) and which parts happen one after another (sequential logic). Within the HDL, the behavior of low-level gates can be specified, allowing the designer very specific control over the exact circuitry desired. High level design can also be specified, allowing the designer to build larger blocks and modules, such as memory arrays, ALUs, etc.

Once the behavior of the circuit is specified using the HDL, the design is synthesized. This means that the description of the circuit is taken and placed into actual circuit elements, such as logic gates. The synthesis is holistic, and elements from the behavioral description are inferred by the synthesis program. Once the circuit is implemented (defined in its hardware elements), it can be simulated in order to debug, fabricated into a chip, or ran on an FPGA.

Answer 3

Here is a schematic for a one-bit full adder with carry in (it's figure 5.3, here):

If you want to make that into a 16-bit adder, you'd need to replicate that 16 times. That would take up all of a letter-sized sheet of paper, if you stick to reasonably-sized elements.

• It would take an expert to look at the schematic and infer the function.
• If you're doing synchronous design, where the input comes from a set of registers or goes to a set of registers, those would have to be included.
• If you want to change to a different way of implementing the add, every schematic element would have to be changed.
• If you were using an FPGA that includes DSP blocks, the schematic would have to be changed to specifically call out the DSP blocks.

Here's a generic-HDL way of specifying a 16-bit adder, while latching into a register (I haven't done FPGA design much recently, so Verilog and VHDL are mixed up in my head - just trust me here, or if someone reading this is more facile than I am, they can edit my answer with actual HDL):

• Define a module that takes two 16-bit wide inputs called A and B, a clock, and has a 16-bit wide output called C.
• Somewhere in the code, say "on the rising edge of the clock, C = A + B, and use the form that implies the answer should be latched.

A simple "add two numbers module" would be about 10 lines (and trivial enough that you probably won't find it). People who don't know what it does would see that the only substantive line it it was C = A + B and think "gosh, I bet two numbers are being added, here".

If it is properly written, that code can be:

• simulated behaviorally to make sure the logic is right
• Synthesized for any brand of FPGA, regardless of the implementation details
• Synthesized for any process of ASIC, regardless of the implementation details
• Synthesized (if I'm correct about what open-source software is out there) for 7400-series logic on a board

That means -- if it's properly written -- that you can take stuff that module into a library of modules, and you can use it under any technology under the sun. You can sell it, you can share it open source, you can keep it as a company resource and no one needs to worry about the underlying schematic (unless it doesn't work).

In fact, the normal design flow for a new application that's going to end up on an ASIC is to first run it in simulation, then get it running on one or more FPGAs, and only then, when you have proved out the logic, actually start designing your ASIC. All of this is done using some HDL or another.

Answer 4

In order to describe hardware, you need a hardware description language...

The whole point is to synthetize it into hardware, for example in a FPGA or in a hard chip, and the language is how you tell the synthesis tools what to do. It's just not possible to draw schematics for modern chips with millions/billions of transistors.

Answer 5

So, from the above two definitions what I understood was, HDL is some kind of script where we define the behavior of different gates,

Yes, it can, but we can also use it at a much higher level, for instance to define the behaviour of adders, multipliers etc where we let the subsequent tools figure out how to implement the logic for them.

and why we need that script is to create a simulation world where we can do some tests before moving to the hardware level.

We need the script to define the behaviour of a design in a standard, high level, machine (and human) readable way, so that we can use it as input to downstream programs. Simulation is one thing, another is to use it as an input to a synthesis program that implements our design in hardware, whether FPGA or ASIC. It needs to be transportable between different vendors' tools (graphical was very popular early on when designs were small, but file formats for graphical representation were just too difficult to standardise and move between vendors, and it didn't scale well to large designs).

And this script can be written in two different popular languages. Verilog and VHDL.

Those are the two most popular in existence today.