How do you design processors / microprocessor [ not broad ]

Question

Apologies for this vague title, but my question is a little specific.

I have two concerns :

During my digital electronics class, I was told that the design of the processor is first carried on an FPGA board and verified. Only then it is finalized. In order to design the processors on FPGA board, you use Verilog and VHDL, and then let the tools do the heavy lifting. These tools then infer or deduce a schematic / design from our program. Also, simultaneously, another team of engineers is busy programming test benches and carry out verification and simulation etc.

My first question :

If you let the tools do the designing portion of your processor (or microprocessor), 
then wont it always infer the same circuit, or at least nearly same circuit 
for your processor ?

For example, as one of lab exercises, we were required to program a 4 bit ALU on xilinx ISE in verilog. As long as we had the same instructions / operations/ functionality for our ALU , if we let the tools design ALU, wont it always design the same circuit ? I believe this because ultimately at the transistor level, an AND gate (just an example )will always be composed of, lets say 5 mos transistors (as provided in the library of components ). Also ALU will always contain same blocks / nearly same blocks like adder, subtractor etc ( In other words, same design will be inferred).

My second question :

If I am correct above ( which obviously I doubt ), then how would the designs differ ? 
In other words, where lies the role of a human / engineer if everything is 
done by the tools .

As another example, Intel produces processors. If we for the time being assume that they produce on 28 nm, and will continue to do so for another 5 years ( just an example) . Then how is it that they come up with fast processors every year or so ? I am confused because at the end of the day, Intel itself will obviously be using these kind of tools (verilog / vhdl) to design their chips. So as long as they have a functionality which does not change, they should always come up with same design.

Please understand that this is not a broad question. It focus on the automation aspects / designing using tools only. Also I am not concerned with advances in computer science concepts, such as introduction of pipelines etc which improved performance. I am only interested in above mention aspects.

I am asking this because I am little interested in designing a small microprocessor before my graduation. But programming a couple of lines in Verilog / vhdl and letting the tools do the job does not seem to excite me at all.

Thank you.

Answer 1

If you let the tools do the designing portion of your processor (or microprocessor), then wont it always infer the same circuit, or at least nearly same circuit for your processor ?

No. There are several low-level details which will result in different circuitry. Suppose you design an adder. You are really only designing the functional specification of the adder, either in high level terms (e.g. verilog "+" operator) or lower level terms such as gates. However this design must be mapped onto the actual blocks or gates which will implement the design. On an FPGA you may have a macro-cell or a look-up table (LUT) structure which gets repeated in an array across the chip. For an ASIC you have raw gates.

As part of this there is typically some kind of "place and route" step which will map the functional blocks onto the two dimensional layout of the resources on the FPGA or ASIC. Placing an routing are not simple algorithms - my understanding is that they are "NP complete" as there is not a polynomial time algorithm to find the optimum layout and routing. As a typical part of a design you will specify timing constraints to be met, and the place and route will try to operate so that these constraints are met. Because the process is not exhaustive (it would take too much time) a "seed" value is typically used to determine how to start out, and then a solution is looked for that is close to where it needs to be. Different seeds will produce different layouts with the same functional characteristics but (usually slightly) different timings.

If I am correct above ( which obviously I doubt ), then how would the designs differ ? In other words, where lies the role of a human / engineer if everything is done by the tools .

As other answers have mentioned, the actual functional design is not done by the tools. But there is still room for human interaction with the tools in determining the actual functioning. In addition to specifying timing requirements it is sometimes necessary to go back and tweak the design to accomodate these requirements. For instance, the tools might identify a critical path which limits the clock frequency at which the design can run. This might be slower than is desired, and the engineering would need to go back and figure out how to make it meet timing, such as pipelining, reducing fan-out, and so forth.

Answer 2

I think you're misunderstanding the "design" that the tools do when you say "let the tools do the designing portion of your processor".

In general design progresses from a top-level spec to

1. Architecture,
2. Design
3. Implementation

The tools are very useful at all stages for simulation and modelling but really come into their own during implementation.

For example: the diagram below shows a top-level block for an ARM processor (source).

Once you have your top-level spec, you then need to design the architecture. You might model it and simulate it in Verilog or C++ or your favourite high-level language and arrive at something like this where you have added ALU, shifter etc.. to implement the required functions of the specifications:

Then at the design level you will design individual blocks in RTL Verilog (for example).

Once this simulates OK. You can use the tools to implement the design. Typically this means Synthesis from RTL to Cell-Library, Placement of the Cells, Routing of the cells, parasitic extraction, timing analysis etc.

The tools do a lot of the heavy lifting at the implementation stage but they do not do the design.

Several years ago there were tools to take Architectural level designs and synthesise them into RTL but they are not mainstream tools.

It should be said that companies provide configurable processors as IP in their synthesis flow. For example, Synopsys Designware ARC processor Cores, where the IP only needs to be configured in your SOC design.

Answer 3

If you take out all the complicated things like pipelines, then no it's not particularly complicated and you can do a reasonable 8 bit cpu in a few hundred lines of Verilog.

The pipelining, branch prediction, prefetch, cache etc is what gives designers the speed increases, and what consumes the development effort and chip area.

(Chip tapeout isn't entirely automated in the same way as software compilation, so going from Verilog to silicon involves quite a bit of configuring and hinting the tools to achieve good results at 28nm. Especially timing closure.)

Edit: have a browse of OpenCores OpenRisc design where you can get a feel for how much Verilog is required for a fully useful modern design.

Answer 4

The tools convert a functional specification into a physical implementation. And yes, if the specification doesn't change, then the implementation won't either.

The "human engineering" part of it is coming up with the functional specification in the first place. Different processors have different functionality, and are sometimes designed to have special features to support a particular class of applications.

Even when the basic architecture is well-defined (such as Intel x86), there are still variations in low-level details, such as speciallized instructions, and there are other options within the chip with regard to the number of cores, how they're interconnected, the number and the sizes of caches, etc.

Answer 5

There are also custom circuit designers who break blocks out of synthesis and design them at the transistor/gate level. This is typically done for the critical paths.