Chapter 4

TOP-DOWN Design Flow

The graph below describes the top-down design flow to be used when designing complex systems. It is difficult to figure time in this flow. Locally, at each hierarchical level, time flows vertically from to to bottom, but globally, it flows horizontally from left to right.


This flow is based on the intrinsically hierarchical nature of complex designs:

  • Here, only two hierarchical levels are shown, but of course, there are generally much more.
  • Arrows on the left and right sides are intended to show that there are levels above and below.
  • Architecture, as already stated, consists in choosing the nature of sub-blocks and the way they are connected together.
  • Sizing consists in choosing the sub-blocks characteristics.
  • For implementation and validation, the top level loop differs from the lower levels loops.

The top level loop is the product development loop as defined above. For this loop:

  • Implementation consists in manufacturing the product.
  • Validation consists in measuring the parts in the lab.

For lower level loops :

  • Implementation consists in capturing architecture and sizing into a CAD system.
  • Validation mainly consists in simulation the circuit and checking design rules.

4.1 Recursive Loops

  • Specification is received from the upper level.
  • The first step is choosing or creating the architecture.
  • The second step is sizing every block in the architecture. Level N sizing defines specifications for level N-1 blocks.
  • The third step is implementation.Every sized block has to be translated into ready for manufacturing data.
  • The fourth step is validation. The sized architecture must be checked with respect to the specification.

Just like for the development loop, the design loop is ideally walked through only once...

  • If everything is correct, design for level N is over, level N-1 design can start.
  • If design validation fails, sizing must be changed first because this design loop is reasonably short.
  • If no suitable sizing can be found, the architecture must be changed. This design loop is much longer than the sizing loop. This is the reason why it is done in a second step. This is also why architecture choice should be secured before sizing even though this cannot be done with the help of simulation.
  • If specification cannot be met, it must be changed, but this requires agreement from level N+1 designer. This loop is extremely long and risky. It implies other people and can be a major risk for the project. This is why it is done only when nothing else can be done. This is also why the specification should not ask for more than what is required and what is reasonably achievable. This is also why risk analysis at the beginning should be done very carefully.

Globally the development phase is a large set of loops inside each others.

Again, it is basically by reducing the number of times loops are walked through that the development time can be made shorter.

4.2 Controlling recursion

Everyone knows that recursion must be controlled in software not to result in infinite execution time or infinite memory requirement. In real life, recursion should also be controlled so that design time and cost are finite.

4.2.1 Recursion depth

How many levels are there and when does the process stop? There is no simple answer to that simple question.

  • Number of levels depends on design complexity
    • The more complex the design, the larger the number of levels
  • The process stops when an existing object is met.
    • Existing object can be an already designed cell or a basic component.
    • Sometimes, a new component has to be created. This adds one more level down.
    • If a technology has to be developed, this pushes the level down even more...

4.2.2 Convergence

Since the number of items is finite, the time it takes to walk through the loops can be finite: The process can potentially converge.

This is good news but it is not sufficient.

Ensuring convergence and ideally fast convergence requires a method. The idea is that as the amount of design work already done increases, the probability of redoing it decreases.

  • This goal can be reached by ranking the requirements. The most stringent requirements have to be addressed first and the details have to be addressed at the end. The key is then to identify the hardest design issues.

This is basically what makes the difference between a skilled designer and a less experienced one. This is also why solving a new problem, addressing a new domain is harder than staying in a well known domain and solving new problems. However, trying to figure out the difficult issues is a must.

One practical approach is to consider the issues one after each other and wondering how each could be addressed. For some issues, possible solutions quickly come to mind. These will be addressed later on. For some issues, no obvious solution appears. These have to be moved up in the list.

That can seem strange but the immediate solutions have to be addressed at the end while the issues without solution have to be addressed first. Among these top issues, one can appear more difficult than the others. It should be addressed first. Even if this ranking is not the right one, it should not be so different from the right one. Doing so helps building design experience and makes it easier for the next times.