Abstract:
A method of transforming a first integrated circuit design comprising a plurality of D-type flip-flops each having a clock signal and being associated with an enable signal into a second integrated circuit design using guard-flops, the method comprising: identifying D-type flip-flops in the first integrated circuit design, and transforming each of the identified D-type flip-flops into a guard-flop comprising a transparent catch latch and a transparent pass latch; generating a catch enable signal for controlling the transparent catch latch from the clock signal and enable signal of the D-type flip-flop in the first integrated circuit design; and generating a pass enable signal for controlling the transparent pass latch based on the catch signals of at least some of the guard-flops that take data from the D-type flip-flop in the first integrated circuit design.

Description:
RELATED CASES 
   This application claims priority to Great Britain Application No. 0210624.3 filed May 9, 2002. 
   FIELD OF THE INVENTION 
   This invention relates to a method of making and designing integrated circuits. 
   BACKGROUND OF THE INVENTION 
   Most digital integrated circuits today are fabricated using a CMOS process. One of the reasons that CMOS has become prevalent is because it dissipates less power than competing technologies, but now as chip speeds rise, even CMOS chips consume too much power. 
   Clock gating is a well-known technique in conventional synchronous CMOS circuits. 
   A clock is a global signal, distributed to all storage elements which are conventionally implemented as D-type flip-flops. In conventional circuits without clock gating, storage elements that do not need to capture new data are either disabled explicitly or a multiplexor is used to feed the current output of the storage element back to the input. These two options are shown in  FIG. 1 .  FIG. 1  also illustrates terminology which will be mentioned here because it is used in the following, a denotes a data input to the D-type flip-flop D-FF, where as b denotes the data output. Input data a is supplied to an input data terminal and the output data b is taken from an output data terminal. An enable signal is supplied to an enable input of the D-type flip-flop, and a clock signal φ is supplied to the clock terminal. The diagram on the right hand side of  FIG. 1  shows a multiplexer M receiving the input data a and the output data b and being controlled by the enable signal. 
   Applying a clock input to a flip-flop that does not change its output is a waste of power, so schemes have been developed that avoid useless clocking. One such scheme is shown in  FIG. 2 . An AND gate  100  only applies the clock φ when the flip-flop D-FF is enabled, and a transparent TL latch is used to make sure that glitches on the enable wire carrying the enable signal do not cause unintentional clock pulses on the clock input to the flip-flop. 
   This scheme has been proposed in various academic papers, such as:
           Automatic Insertion of Gated Clocks at Register Transfer Level , N. Raghavan, V. Akella and S. Bakshi, Proceedings of the Twelfth International Conference on VLSI Design, 1999, pp 48–54     Symbolic Synthesis of Clock - Gating Logic for Power Optimization of Synchronous Controllers , L, Benini, G. De Micheli, E. Macii, M. Poncino, R. Scarsi, ACM Transactions on Design Automation of Electronic Systems, vol 4 no 4, October 1999     Synthesis of Low - Power Selectively - Clocked Systems from High - Level Specification , L. Benini and G. De Micheli, ACM Transactions on Design Automation of Electronic Systems, vol 5 no 3, July 2000       

   Another power saving technique is referred to herein as “guarding”. Logic blocks in CMOS circuits only consume appreciable power when their inputs change. It is possible to reduce the power taken by the whole circuit if the inputs to small portions of the circuit are only permitted to change when the outputs of that small portion are needed.  FIG. 3  shows the basic idea. 
   The output of the logic block L may not always be clocked into the flip-flop. If the inputs to the logic change when the output is not required, energy will be needlessly, consumed inside the logic block. 
   Guarding solves this problem by placed additional guarding logic GL in the form of additional gates between the inputs of the logic block L and the registers (D-flip flops) that supply their output data b to those inputs, as shown on the right of  FIG. 3 . These additional gates, block any inputs to the logic L that do not produce a useful output! but the inputs are delayed by passing through the additional logic, and this can affect the speed of the circuit. Techniques for low-power design need to avoid slowing down the logic, because speed is almost always important. If speed is not important, it is easier to trade speed for power by simply lowering the supply voltage V dd . 
   The additional gates GL inserted for guarding can be either simple gates (AND or OR) or transparent latches, but there advantages and disadvantages associated with each:
         AND and OR gates have a small additional delay, and can often be absorbed into the logic block at the technology mapping stage. Unfortunately, they do not block input transitions, but simply force the output to one rail or the other—this can often lead to more input changes than without the guarding logic, which then outweighs the power saving.   Transparent latches block input changes effectively, but they have significant propagation delay, and this is likely to slow down the circuit.       

   Guarding using AND gates and OR gates is an established technique. Guarding using transparent latches is mentioned in the following two papers.
           Guarded Evaluation: Pushing Power Management to Logic Synthesis/Design , V. Tiwari, S. Malik, P. Ashar, IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems, Vol 17 iss 10, October 1998     Automating RT - Level Operand Isolation to Minimize Power Consumption in Datapaths , M. Munch, B. Wurth, R. Mehra, J. Sproch, N. When, Proceedings of the Design Automation and Test in Europe conference (DATE 2000), March 2000.       

   In the early days of synchronous circuits, two-phase clocking schemes were used [ Introduction to VLSI Systems , C. Mead and L. Conway, Addison Wesley 1980]. The storage elements used were transparent latches TL, with alternate latch banks clocked off opposite phases of the clock. A complete cycle of the circuit consists of a rising edge on φ 1 , a falling edge on φ 1 , a rising edge on φ 2  and then a falling edge on φ 2 . The two-phase clocking scheme is shown in  FIG. 4 . 
   As clock speeds rose, it became more difficult to distribute a pair of high-speed clocks with the correct timing relationships, so single-phase clocking started to dominate. Today, single-phase clocking is universally employed. Single-phase design still uses two latches per stage, as shown in  FIG. 5 , but the latches are combined into a single storage element, known as a D-type flip-flop. It is to be noted that in the present description φ is used to denote a clock input which provides both phases and which is conventionally referred to in the art as clk. 
   The D-type is considered to be a single state-holding element comprising two transparent latches, with the state held at the output of the right-hand transparent latch. In a clock-gated chip using D-types, the left-hand latch is only used to stop shoot-through, and there is no useful state held on the internal node of the D-type. 
   It is an aim of the present invention to allow a circuit using D-type flip-flops to be converted into a circuit using guard-flops without requiring any specialist knowledge on the part of the designer. 
   SUMMARY OF THE INVENTION 
   According to one aspect of the invention there is provided a method of transforming a first integrated circuit design comprising a plurality of D-type flip-flops each having a clock signal and being associated with an enable signal into a second integrated circuit design using guard-flops, the method comprising: identifying D-type flip-flops in the first integrated circuit design, and transforming each of the identified D-type flip-flops into a guard-flop comprising a transparent catch latch and a transparent pass latch; generating a catch enable signal for controlling the transparent catch latch from the clock signal and enable signal of the D-type flip-flop in the first integrated circuit design; and generating a pass enable signal for controlling the transparent pass latch based on the catch signals of at least some of the guard-flops that take data from the D-type flip-flop in the first integrated circuit design, 
   In the case of a D-type flip-flop having an enable input, the enable signal is the signal applied to that input. In the case of a D-type flip-flop having a multiplexer as its input, the enable signal is the select signal for the multiplexer. 
   In particular, there are discussed in the following a set of transformation rules which can be automatically applied by a software tool, without a circuit designer needing to be aware of what the techniques are or how they are being applied. The result of application of the rules is a circuit which draws less power than the first integrated circuit design, but which has been generated in a way that is compatible With industry standard design procedures and in particular without requiring any change in the specification of the circuit or any specialist knowledge on the part of the designer. 
   An additional benefit is that the circuit using guard-flops will save power without decreasing the speed of the circuit as compared with the original integrated circuit design using D-type flip-flops. 
   The invention also provides a method of operating a computer to implement the transformation technique, a suitably programmed computer and a computer program product. A method of making an integrated circuit is also provided, where the second integrated circuit design is implemented in silicon. 
   There is described in the following a method of making and designing synchronous circuits using guard-flops as a replacement for U-type flip-flops. There is discussed the concept of using guard-flops instead of D-type flip-flops, control structures to gain the benefits of guard-flops over D-type flip-flops and a set of rules to change a conventional circuit with D-types into an equivalent circuit guard-flops such that the speed of the circuit is not decreased. 
   Using the transformation rules discussed in the following, an equivalent circuit for one using D-type flip-flops can be derived using guard-flops which consumes less power than the original circuit but runs at the same clock rate. 

   
     BRIEF DESCRIPTION OF THE DRAWINGS 
     For a better understanding of the present invention and to show how the same may be carried into effect reference will now be made by way of example to the accompanying drawings in which: 
       FIG. 1  shows two versions of a D-type flip-flop holding old data; 
       FIG. 2  shows a conventional clock gating scheme; 
       FIG. 3  shows insertion of guarding logic into a circuit including D-type flip-flops; 
       FIG. 4  illustrates a two-phase clocking scheme for transparent latches; 
       FIG. 5  shows a single phase clocking scheme for a circuit involving D-type flip-flops; 
       FIGS. 6   a, b  and  c  illustrate respectively each of three elements in a guard-flop family; 
       FIG. 7  illustrates two phases of guard-flop control; 
       FIG. 8   a  is a schematic circuit diagram of a circuit involving D-type flip-flops and  FIG. 8   b  is the converted version of that circuit in guard-flops; 
       FIG. 9  is a circuit involving D-type flip-flops illustrating generation of an enable signal; 
       FIG. 10  is a circuit in accordance with one embodiment of the present invention utilising guard-flops and independent control signals for the transparent latches; 
       FIG. 11  illustrates the first transformation rule; 
       FIGS. 12 and 12   a  illustrate the second transformation rule; 
       FIGS. 13   a ,  13   b ,  13   c  and  13   d  illustrate the third transformation rule; 
       FIG. 14   a  is a circuit diagram illustrating timing nodes and  FIG. 14   b  is a timing diagram for the circuit of  FIG. 14   a;    
       FIG. 15  is a schematic block diagram of a computer environment implementing the transformation rules. 
   

   DETAILED DESCRIPTION 
   In order to understand the present invention, an understanding of guard-flops is needed, as provided in the following description. 
   Guard-flops are a family of state-holding elements built from transparent latches. For each natural number k=1, 2, . . . , there is a guard-flop with k data outputs and one data input. The first three are shown in  FIGS. 6   a ,  6   b  and  6   c . Each guard-flop has a transparent catch latch TL c  and one or more transparent pass latch TL p . 
   Guard-flops differ from D-types because the state is held on the internal node N. A guard-flop creates a controlled region in the middle—data can be captured from the data input node d In  by bringing a catch signal high, and data can be passed to other places in the circuit from the output node d out  by bringing one of the pass signals high. 
   Guard-flops are not new per se and are structurally very similar to D-type flip-flops—the one-output guard flop is identical to a D-type apart from a single inverter, Their construction is well known to a skilled person and so is not described further herein. 
   However, guard-flops differ from D-type flip-flops in an important respect. Guard-flops have two sets of control inputs: a catch input and one or more pass inputs. In the techniques and circuits described herein, these inputs are controlled independently to give the full benefits of guard-flops. 
   The catch and pass latches TL c , TL p  of a guard-flop are enabled in turn, with overlaps between them of less than one latch delay. This is shown in  FIG. 7 . 
     FIGS. 8   a  and  8   b  illustrate the comparison between data flow through a D-type flip-flop ( FIG. 8   a ) and data flow through a guard-flop ( FIG. 8   b ).  FIG. 8   a  shows two input D-type flip-flops D-FF 1 , D-FF 2  each having a data output node labelled  2 ,  4  connected to a logic circuit  6 . The output of the logic circuit is connected to an output D-type flip-flop D-FF 3  having an output node  8  and an enable input  10  for receiving an enable signal. The enable input to the D-type flip-flop D-FF 3  allows that flip-flop to be disabled when it does not need to catch new data. 
     FIG. 8   b  shows the “equivalent” guard-flop structure. There are two input guard-flops GF 1  GF 2  connected as inputs to the logic circuit  6 . The output of the logic circuit  6  is connected to an Output guard-flop GF 3 . Each guard-flop GF has an internal node N on which state is stored. This is denoted by the dotted arrows in  FIG. 8   b . As already mentioned, each guard-flop comprises a transparent catch latch TL c  and a transparent pass latch TL p . On the input guard-flops the important control element is the pass signal supplied to the transparent pass latch in each case. For the output guard-flop GF 3  the important signal is the catch signal supplied to the transparent catch latch TL c  of the guard-flop. 
   Note that although in  FIG. 8   a  the input clock signals φ to the D-type flip-flops are illustrated, the clock signals themselves are not illustrated in  FIG. 8   b . In fact, the catch and pass signals are generated from the clock signals in a manner to be described in more detail herein. 
   There follows a discussion of how to generate the catch and pass signals, without an end user of the “equivalent” circuit being aware that this is happening. The generation of the enable signal for a conventional D-type can be drawn as in  FIG. 9 .  FIG. 9  shows the data handling flip-flops D-FF 1 , D-FF 2 , D-FF 3  as illustrated in  FIG. 8   a . A further set of D-type flip-flops D-FF 4  . . . D-FF 5  are shown in  FIG. 9  which act as control flip-flops for generating the enable signal supplied to the enable input  10  of the output D-type flip-flop D-FF 3 . The inputs to these control D-type flip-flops are supplied from respective logic circuits  12 , 14  and their outputs are supplied to enable logic  16  which determines the state of the enable signal. In contrast, in order to control the guard-flop scheme illustrated in  FIG. 8   b , catch and pass signals need to be generated based on the movement of data through the circuit. 
   Instead of simply enabling a conventional D-type, the corresponding guard-flop in a guard-flop design must be instructed to catch data, and all the guard-flops in the input cone of the first guard-flop must be instructed to pass data. Furthermore, these catch and pass signals need to look like a two-phase clocking scheme, as was shown in  FIG. 7 , and they need to be glitch-free to avoid spurious activity. The circuit shown in  FIG. 10  satisfies these conditions. The lower part of  FIG. 10  shows the data handling guard-flops GF 1 , GF 2 , GF 3  as described above with reference to  FIG. 8   b . The upper half of  FIG. 10  shows a set of control guard-flops GF 4 , GF 5  used for generating the catch and pass signals. Note that although only two control guard-flops GF 4 , GF 5  are illustrated, in fact there could be a plurality of such guard-flops. Each of the control guard-flops has an internal node N 4 , N 5  on which state is stored as described earlier. Inputs to the control guard-flops GF 4 , GF 5  are from logic circuits  12 , 14  which are deliberately denoted by the same reference numeral as in  FIG. 9 , because they constitute the same logic as in the equivalent D-type flip-flop circuit. 
     FIG. 10  also illustrates the clock φ used in generation of the pass and catch signals. State from the internal nodes N 4 , N 5  is supplied to Read logic  18 , while the outputs of the control guard-flops GF 4 , GF 5  is supplied to Write logic  20 . The output of the read logic is supplied to gates  22 ,  24  which also receive the clock signal φ. These gates generate the pass signals for the transparent pass latches TL p  of the data handling guard-flops GF 1 , GF 2 . The output of the write logic  20  is supplied to a gate  26  which also receives an inverted version of the clock φ and which generates the catch signal for the transparent catch latch TL c  of the output guard-flop GF 3 . 
   The Read and Write logic blocks are identical to the Enable logic block in  FIG. 9 . The Read logic block needs its inputs slightly in advance of the rising clock edge, which is the reason why the internal node N of the guard-flops needs to be used. The conventional way to generate gated versions of the positive clock half-cycle is to use the transparent latch scheme that was shown in  FIG. 2 . Using the internal node N of the guard-flops eliminates this extra latch, which saves power and area. 
     FIG. 10  showed how guard-flops can be controlled in a digital circuit, but this does not demonstrate how a circuit using guard-flops can be created. There now follows a description of a set of rules which can be used to translate a conventional circuit using D-type flip-flops into a circuit using guard-flops. 
   Rule  1   
   This rule turns D-type flip-flops into single-output guard-flops. It saves no power, and has to satisfy no timing assumptions. 
   The rule is illustrated in  FIG. 11  and should be applied to all flip-flops in a design as a first step. That is, according to Rule  1 , the data input a of a D-type flip-flop is applied to a transparent catch latch of a guard-flop. The data output b is taken from the output of the transparent pass latch of the guard-flop. The clock signal φ is supplied as the pass signal to the transparent pass latch and, through an inverter, as the catch signal to the transparent catch latch. 
   Rule  2   
   This rule creates catch expressions for a single guard-flop and is shown in  FIG. 12 . It is used to gate the clock in situations where the input data to the guard-flop may not always change. The left hand side of  FIG. 12  illustrates the transformed guard-flop of  FIG. 11 , but noting that the pass signal is no longer taken from the clock signal φ, but is provided by an independent signal d.  FIG. 12  assumes that the guard-flop has been derived from a D-type flip-flop in the situation of a storage element holding old data as illustrated in  FIG. 1 . That is, there is a multiplexer M on the input receiving the input data a and the output data b. The multiplexer M is controlled by a control signal x which is derived from logic elsewhere in the circuit and not shown in  FIG. 12 . It is assumed that x is derived from combinational logic active on a number of inputs and that x can be expressed as a combination of two different signals (n AND m). It will be clear that x is the equivalent of the enable signal. The signal n is derived from the combinational logic which completes within half a clock cycle. If the rule is fully applied, m=1 (that is the multiplexer always passes the input data a), and n=x. As can be seen from  FIG. 12 , n is applied to the AND gate  26  the other input of which receives an inverted version of the clock φ. 
   The logic for n will be chosen in an iterative process, starting with m=1 and n=x, and progressively moving terms from n to m until n completes in the time limit. 
     FIG. 12   a  shows in more detail the relationship between the signal x which acts as the select signal for the multiplexer M prior to transformation according to Rule  2  and the signals n and m  FIG. 12   a  shows that the signal x is derived from outputs q 1 , q 2  . . . qp from flip-flops Q 1 , Q 2  . . . Qp by the application of logic function L x . When Rule  2  is applied, the logic block L x  is split apart into two logic blocks, L m , L n  for generating the signals m and n respectively. The criteria are that:
     1) n completes in half a clock period, and   2) (m AND n)=x   
   Criteria  1  means that the logic circuitry L n  from which the signal n is output operates faster than the other logic circuitry, such that the output n can be produced in half a clock cycle. If the above two conditions 1) and 2) are satisfied, then Rule  2  can be used and the results of the translation will be correct. It will be clear that where the logic circuitry L x  is complex, there may be a large number of possible m and n signals for any particular x, and the selection is made based on the timing restriction specified above and the likely power savings to result in each case. 
   Rule  3   
   Rule  3  is in effect a number of sub-rules, and implements what is called herein “pass on demand”. Rule  3   a  increases the number of outputs of a guard-flop, and groups together destinations for the output of the guard-flop. Rule  3   b  creates the pass signal for the guard-flop. Rule  3   c  generates “early signals”.  FIG. 13   a  illustrates Rule  3   a . The left hand side of  FIG. 13   a  illustrates an input data handling guard-flop GF i  with the clock signal supplied to the transparent pass latch TL p  labelled φ. Destinations of the data from that particular input guard-flop GF i  are “collected together” in groups. One group consists of the combinational logic circuits L 1  . . . L n  each of which receive as an input the data b output from the guard-flop GF i  and also each of which has a number of other inputs which are demonstrated diagrammatically by X 1  . . . X n  in  FIG. 13   a . The output of each combinational logic circuit L 1  . . . L n  is supplied to a respective output guard-flop GF 01  . . . GF 0n . Each of those guard-flops has a transparent catch latch receiving a catch signal labelled a 1  . . . a n . The output b of the input guard-flop GF i  may also be supplied as an input Y to other combinational logic which is not shown. Rule  3   a  can still be applied in these circumstances. Rule  3   a  has no timing assumptions. 
   The right hand side of  FIG. 13   a  shows how the input guard-flop GF i  in the scenario outlined in  FIG. 13   a  is converted to a multiple output guard-flop which is labelled GF i ′. This has a single input transparent catch latch and two transparent pass latches. One of these supplies the output b to the combinational logic circuits L 1  . . . L n , and the other supplies the output b to form the input Y to the other combinational logic circuit which is not shown in the diagram. The signal for each of the transparent pass latches is shown as the clock φ. 
     FIG. 13   b  illustrates Rule  3   b . This rule creates the pass signal for the transparent pass latch on the input guard-flop GF i ′. Note that in  FIG. 13   b , only a single transparent pass latch of the multiple output guard-flop of  FIG. 13   a  is illustrated. That is because this rule is applied to each transparent pass latch individually, regardless of the number of pass latches in a particular guard-flop. Z denotes the fact that there are other circuits coming off the internal node N i . Therefore Z denotes that there may be other output pass latches of that particular guard flop, or indeed other signals which are supplied to other logic circuits. 
   The left hand side of  FIG. 13   b  also shows that the catch signals for the right hand side guard-flops have been generated via gates  26   1  . . .  26   n  respectively. Each gate  26   1  . . .  26   n  receives the clock signal φ and a respective enable, input e 1  . . . e n . These enable inputs are derived from respective write logic blocks  20   1  . . .  20   n  as shown in  FIG. 13   d . It will be recalled from  FIG. 10  that each write logic block  20  receives the input from one or more control guard-flops and generates an enable signal e for gating the AND gate  26  which generates the catch signal for the transparent catch latch of the output guard-flop (GF 3  in  FIG. 10 ). In  FIG. 13   d , it is made clear that in any particular integrated circuit which is being transformed, there will of course be a plurality of write logic blocks. In  FIG. 13   d , these are shown as each having an input from a single bank of guard-flops labelled G 1  . . . G n  in  FIG. 13   d , but in practice each write logic block  20   1  . . .  20   n  could have inputs from any number of input guard-flops. 
   The right hand side of  FIG. 13   b  illustrates the result of the transformation of the rule implemented in Rule  3   b . That is, the pass signal for the transparent pass latch on the input guard-flop GF i ′ is generated by supplying the clock φ to a gate  22 , the other input of which receives a so-called “early” signal “early(f)”. The generation of an early signal is carried out in accordance with Rule  3   c  which is illustrated in  FIG. 13   c .  FIG. 13   c  shows a guard-flop GF the output b of which is connected to combinational logic L which generates a signal f depending on the state of b and any other signals input to the combinational logic which are denoted B in  FIG. 13   c . In  FIG. 13   c , Y denotes other circuit elements that are connected to the output of the guard-flop GF. According to Rule  3   c , an early signal, early(f), is created by taking the state of the node N and applying that as an input to the combinational logic L′ which is the same as the combinational logic L connected to the output b of the guard-flop. Other inputs B′ may also be connected to the combinational logic L′ generating the early(f) signal, assuming that B′ is constituted by the “early” version of the signals B supplied to the combinational logic L. That is, these other inputs can themselves be derived from the internal nodes of other guard-flops as illustrated in  FIG. 10 . That is, in  FIG. 10 , the signal on internal nodes N 4  and N 5  is applied to the read logic  18  and the output of this generates an early signal which is supplied to the inputs of the AND gates  22 ,  24 . The outputs of these AND gates  22 ,  24  supply the pass signal for the transparent pass latches of the guard-flops. 
   Referring to  FIG. 13   d , the outputs of each of the guard-flops G 1  . . . G n  are labelled g 1  . . . g n . The early versions of these signals, derived from the internal nodes of the respective guard-flops are labelled early(g 1 ) . . . early(g n ). These early signals are supplied to the read logic  18  which generates the early(f) signal which is then used to gate the transparent pass latch on the input guard-flop as shown in  FIG. 13   b.    
   Rule  3   b  has a timing assumption on early(f). The early(f) signal must be available one AND gate delay before the rising edge of the clock. With reference to Rule  3   c  the delay through the logic to produce early(f) from its early-tapped inputs, plus the delay to produce those inputs from their inputs, plus the AND gate delay, must all be less than one clock period. If this restriction cannot be satisfied, the rule can be partially applied: terms must be left out of the expression for f, making sure it still satisfies (e 1  OR e 2  OR . . . en)→f, where (A→B) means (NOT (A) OR B). 
     FIGS. 14   a  and  14   b  illustrate the timing of the circuit.  FIG. 14   a  illustrates the circuit of  FIG. 10 , with nodes A to E and the catch and pass signals being marked using dotted lines  FIG. 14   b  denotes the timing at these nodes relative to the clock φ, and can be used to determine the timing assumptions that need to be satisfied for the guard-flop circuit to work. 
   The pass signal will occur shortly after the rising edge on φ, so the data must have arrived on D just before the clock edge.  FIG. 14   b  shows that the data on D depends on the data at point B, and that the data at point B changes one latch delay after the calling edge on φ. Together, these imply that the delay of the Read logic in  FIG. 14   a , plus the delay of a transparent latch, must be less than half a clock period. 
   The data on B also depends on the data on A, and the data on A changes some time after the rising clock edge, according to the delay of the logic creating A. By following the arrows from φ, through A, B and D to the pass signal in  FIG. 14   b , it can be seen that the delay of the logic creating A, plus a transparent latch delay plus the delay of the read logic, must all be less than a clock period. 
   The catch signal is derived from the data at point E, which is in turn produced from the data at point C, which is valid one latch delay after the rising edge of φ. The catch signal is created as φ falls, so there is only half a clock period between the rising edge on φ and the catch signal being needed. Hence the delay through the write logic plus one latch delay must be less than half a clock period. 
     FIG. 15  is a schematic diagram illustrating how the rules are applied in a computer environment. In order to manufacture a silicon circuit, it is usual for a software version of the circuit to be created for simulation and other purposes. In  FIG. 15  this is denoted as VHDL  30 , although any other HDL could be used. The VHDL version is supplied to a netlist synthesis block  32  which generates a netlist labelled NETLIST 1  in  FIG. 15 . This netlist is subject to the rules in the transformation block  34 , and a transformed netlist labelled NETLIST 2  in  FIG. 15  is provided as the result of using the rules. The transformation block  34  can be implemented as any suitably programmed computer. The program includes algorithms implementing the rules as described above. 
   In order to apply the rules, timing data is normally needed and this can be provided by carrying out a timing analysis  36  on the first netlist NETLIST 1 , and applying the resulting timing data to the transformation block  34 . To enhance application of the rules, simulation data can be provided from a simulator  38  acting on the original VHDL. 
   It is a particular advantage of the rules described above that the transformation block  34  can be implemented as automated software tools to produce a guard-flop circuit from a circuit using D-type flip-flops without requiring any knowledge on the part of the designer. Thus, the fact that guard-flops have been used to implement the circuit is almost entirely hidden from the circuit designer. This allows the designer to apply his knowledge of D-type flip-flops to create a circuit, and then for the circuit to be converted into a low power version using guard-flops without him having to know and understand guard-op design styles. 
   A particular advantage of the rules described above as compared to conventional approaches such as guarding and clock gating is that they can be partially applied. Rule  2  and Rule  3   b  allow partial clock gating and partial guarding respectively. An all-or-nothing approach often leads to power saving opportunities being wasted, because the all-out solution was too costly. A partial solution can achieve some power benefits without incurring an unacceptable cost. 
   Moreover, the rules are designed to keep the behaviour of the circuit constant. Rule  1  is a preliminary rule and should be used first. Rule  2  should be applied in all cases that it can be before moving on to Rule  3 . Rules  3   a  and  3   b  need to be done together, whereas Rule  3   c  is an enabling rule which serves to define notation. As noted above, some of the rules have timing assumptions which must be checked, for example by a static timing analyser.