Formal gated clock conversion for Field Programmable Gate Array (FPGA) synthesis
By using formal logic methods and functional analysis techniques to separate the enable function of the gated clock function in FPGA synthesis, the problem of minimizing the unique clock signal set is solved, achieving resource optimization and power saving.
Patent Information
- Application Number
- CN202110984239.7
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- Priority Date
- 2020-08-25
- Filing Date
- 2021-08-25
- Publication Date
- 2026-11-10
- Estimated Expiration
- 2041-08-25
AI Technical Summary
Existing EDA systems struggle to effectively minimize the set of unique clock signals during FPGA synthesis, leading to resource constraints and power waste.
By employing formal logic methods and functional analysis techniques, the enable functions in the gated clock function are identified and separated, edge functions are constructed, the clock signal set is minimized, and the master clock signal is directly connected to the clock pin of the target register.
It effectively reduces the number of unique clock signals in FPGA synthesis, optimizes resource utilization, and saves power consumption.
Smart Images

Figure CN114756085B_ABST
Abstract
Description
[0001] Related applications
[0002] This application claims the benefit of U.S. Provisional Patent Application No. 63 / 069,979, filed August 25, 2020, entitled “Formal Gated Clock Conversion for Field Programmable Gate Array (FPGA) Synthesis,” the entire contents of which are incorporated herein by reference. Technical Field
[0003] This disclosure generally relates to electronic design automation (EDA) systems. Specifically, this disclosure relates to gated clock switching for field-programmable gate array (FPGA) synthesis. Background Technology
[0004] EDA systems using Field-Programmable Gate Arrays (FPGAs) enable rapid prototyping and shorten time-to-market. These EDA systems can perform logic synthesis from Register-Transfer Level (RTL) hardware description languages to FPGA netlists. FPGAs can support a relatively small number of unique clock signals. However, hardware designers writing RTL can create a relatively large number of unique clock signals by including extensive embedded clock gating in the clock functions. Hardware designers can create a large number of unique clock signals because their primary design target can be Application-Specific Integrated Circuits (ASICs) rather than FPGAs.
[0005] EDA systems performing FPGA synthesis for ASIC prototyping must include methods to minimize the set of unique clock signals in the design during synthesis. This can be achieved using a process called Gated Clock Conversion (GCC). Performing GCC involves identifying and separating enable functions from embedded gated clock functions, leaving only the master clock signal. The derived enable function can be attached to a dedicated enable pin of the target register, and the master clock signal can be attached to the clock pin of the target register. Summary of the Invention
[0006] Some aspects of this disclosure relate to a method for implementing formal gated clock conversion in field-programmable gate array (FPGA) synthesis. For example, some aspects of this disclosure include: receiving a network representation of a circuit design, determining a gated clock function corresponding to a target component of the network representation, and constructing an edge function based at least in part on the gated clock function. The method further includes: performing minimization of the edge function, and determining whether the minimization of the edge function includes a first term and a second term, providing a clock enable signal to the target component based on the first term, and providing a clock signal to the target component based on the second term.
[0007] Some aspects of this disclosure relate to a method for constructing an edge function, which is also based on multiple inputs corresponding to a support set of a gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the multiple inputs creates a positive edge on the gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the multiple inputs creates a negative edge on the gated clock function. According to some aspects of this disclosure, the method further includes constructing the edge function based on inputs including a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch. According to some aspects, the edge function is recursively constructed based on edge-sensitive inputs. According to some aspects, the edge function is constructed by determining whether edge-sensitive inputs remain to the gated clock function. Based on the determination that edge-sensitive inputs remain, the edge function is further constructed based on the edge-sensitive inputs. According to some aspects, the target component is a flip-flop or a flip-flop-based memory. According to some aspects, the target component is a latch or a latch-based memory.
[0008] Some aspects of this disclosure relate to a system for implementing formal gated clock conversion in field-programmable gate array (FPGA) synthesis. For example, some aspects of this disclosure relate to a memory storing instructions and a processor coupled to the memory and executing the instructions. According to some aspects, when executed, the instructions cause the processor to: receive a network representation of a circuit design, determine a gated clock function corresponding to a target component of the network representation, and construct an edge function based at least in part on the gated clock function. According to some aspects, when executed, the instructions also cause the processor to: perform a minimization of the edge function, and in response to determining that the minimization of the edge function includes a first term and a second term, provide a clock enable signal to the target component based on the first term, and provide a clock signal to the target component based on the second term.
[0009] Some aspects of this disclosure relate to a memory storing instructions, and a processor coupled to the memory and used to execute the instructions, wherein, when the instructions are executed, the processor constructs an edge function based on a plurality of inputs corresponding to a support set of a gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a positive edge on the gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a negative edge on the gated clock function. According to some aspects of this disclosure, the method further includes constructing the edge function based on inputs including a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch. According to some aspects, the edge function is recursively constructed based on edge-sensitive inputs. According to some aspects, the edge function is constructed by determining whether edge-sensitive inputs to the gated clock function remain. Based on the determination that edge-sensitive inputs remain, the edge function is further constructed based on the edge-sensitive inputs. According to some aspects, the target component is a flip-flop. According to some aspects, the target component is a latch.
[0010] Some aspects of this disclosure relate to a non-transitory computer-readable medium including stored instructions that, when executed by a processor, cause the processor to: receive a network representation of a circuit design, determine a gated clock function corresponding to a target component of the network representation, and construct an edge function at least in part based on the gated clock function. According to some aspects, the processor performs minimization of the edge function, and in response to determining that minimization of the edge function includes a first term and a second term, provides a clock enable signal to the target component based on the first term, and provides a clock signal to the target component based on the second term.
[0011] Some aspects of this disclosure relate to a non-transitory computer-readable medium including stored instructions that, when executed by a processor, cause the processor to construct an edge function based on a plurality of inputs corresponding to a support set of a gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a positive edge on the gated clock function. According to some aspects, the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a negative edge on the gated clock function. According to some aspects of this disclosure, the method further includes constructing the edge function based on inputs including a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch. According to some aspects, the edge function is recursively constructed based on edge-sensitive inputs. According to some aspects, the edge function is constructed by determining whether edge-sensitive inputs to the gated clock function remain. Based on the determination that edge-sensitive inputs remain, the edge function is further constructed based on the edge-sensitive inputs. According to some aspects, the target component is a flip-flop. According to some aspects, the target component is a latch.
[0012] The summary is not intended to provide a complete picture of any particular innovation, embodiment, or example, as it is commercially usable. Furthermore, the summary is not intended to identify key or essential elements of any innovation, embodiment, or example, or to limit the scope of the subject matter of this disclosure. The innovations, embodiments, and / or examples found in this disclosure are not exhaustive, but rather describe the essential meaning of the subject matter. Therefore, one use of the summary is as a preamble to the detailed descriptions given below. Attached Figure Description
[0013] This disclosure will be more fully understood with reference to the accompanying drawings, which provide detailed descriptions and embodiments of the present disclosure. The drawings are intended to provide knowledge and understanding of embodiments of the present disclosure and are not intended to limit the scope of the disclosure to these specific embodiments. Furthermore, the drawings are not necessarily drawn to scale.
[0014] Figure 1 An exemplary latch-based clock gating circuit is shown.
[0015] Figure 2 An exemplary clock gating circuit based on the generated clock is shown.
[0016] Figure 3 An exemplary post-gated clock conversion (GCC) transformation based on the generated clock is shown.
[0017] Figure 4 The GCC transformation of multiple gated clocks to unique clocks according to exemplary embodiments of the present disclosure is illustrated.
[0018] Figure 5 A flowchart for performing a formal gated clock transition is shown, according to some aspects of this disclosure.
[0019] Figure 6 Flowcharts depict various processes used during the design and manufacture of integrated circuits according to some embodiments of this disclosure.
[0020] Figure 7 A diagram depicts an example simulation system according to some embodiments of the present disclosure.
[0021] Figure 8 A diagram depicts an example computer system in which embodiments of the present disclosure may operate. Detailed Implementation
[0022] Various aspects of this disclosure relate to formal gated clock conversion for field-programmable gate array (FPGA) synthesis.
[0023] EDA systems using Field Programmable Gate Arrays (FPGAs) to prototype electronic designs can perform logic synthesis from Register Transfer Level Hardware Description Language (RTL) to FPGA netlists. FPGAs only support a limited set of unique clock signals. According to some aspects, EDA systems performing FPGA synthesis for ASIC prototyping can address the limited availability of unique clock signals by minimizing the set of unique clock signals in the design during synthesis.
[0024] Depending on several aspects, gated clock conversion (GCC) can be used to minimize the number of unique clock signals in a design. Performing GCC may involve identifying and separating enable functions from embedded gated clock functions, leaving only the master clock signal. The derived enable function can be attached to a dedicated enable pin of the target register, and the master clock signal can be attached to the clock pin of the target register.
[0025] GCC can be performed using a pure structural approach. Using a structural approach involves examining the topography of the design to be synthesized to identify specific structural patterns for known clock-gated structures. The identified specific structural patterns can be remapped to individual enable and clock signals. However, the structural approach is inherently limited to success only if a known pattern exists and can be matched. Since clock gating is a functional design method, structural pattern matching will inevitably fail to match and transform many gated clock functions.
[0026] Digital circuits (such as Application-Specific Integrated Circuits (ASICs)) use gated clock functions. A gated clock function can be a logic function with inputs including one or more master clocks and one or more control signals containing one or more enable signals. According to some aspects, a gated clock function "gated_clock" can be represented as a Boolean AND of the master clock signal "primary_clock" and the enable control signal: gated_clock = AND(primary_clock, enable). According to some aspects, when the master clock signal "primary_clock" rises, it produces a rising edge on the gated clock function "gated_clock" when the enable control signal is high. According to some aspects, the goal of GCC is to identify and separate the enable function from the embedded gated clock function, leaving only the master clock signal. According to some aspects, the derived enable function can be attached to a dedicated enable pin of the target register, and the master clock signal can be attached to the clock pin of the target register.
[0027] According to some aspects, given a gated clock function, the GCC procedure can extract the enable function between the clock pin of the read register and the master clock. According to some aspects, the completed GCC may include extracting the enable function from complex combinational and timing-based gated clock functions, which include unspecified arrangements of combinational gates, timing gates, and clock generators.
[0028] According to some aspects, formal logic methods can be applied to distinguish and separate the clock function and enable function in a gated clock function. According to some aspects, instead of analyzing the circuit to be synthesized into a physical structure, the circuit is represented as a function of Boolean functions. According to some aspects, functional analysis allows the application of Boolean minimization techniques to derive the specific enable functions that gate each master clock.
[0029] Based on several aspects, functional analysis, rather than structural analysis, is used to achieve a complete transformation of the gated clock function, thus separating the clock function from the enable function. Using functional analysis methods allows for successful FPGA prototyping of designs that would otherwise be impossible to prototype.
[0030] Each of these and other aspects of this disclosure offers the following technical advantages: it addresses the problem of limited clock resources during FPGA synthesis by minimizing the set of unique clock signals in the design. Furthermore, according to some aspects of the invention, using functional analysis to separate the clock enable function from the gated clock function results in a complete gated clock transition. Other technical advantages are also apparent from the description and figures throughout this disclosure.
[0031] According to some aspects, gated clocks are included in circuit designs to shut down unused portions of the circuit, thereby saving power. According to some aspects, a gated clock is a clock signal that is a function of a master clock signal and one or more inputs, such as a clock enable signal. According to some aspects, gated clock signals can be generated using latch-based or generator-based circuitry.
[0032] Figure 1An exemplary latch-based clock gating circuit is illustrated. Latch-based clock gating features a level-sensitive latch to hold an enable signal from the active edge of the clock until the inactive edge of the clock. For example, sequential clock gate 100 includes a latch 102 with a data pin 104 and a clock pin 108. The data pin 104 is electrically coupled to an enable signal 106, and the clock pin 108 is electrically coupled to the inverted state of the master clock signal 110 to be gated. In this example, because the latch captures the state of the enable signal and holds it until a complete clock pulse has been generated, the enable signal only needs to stabilize around the rising edge of the clock. Sequential clock gate 100 can suppress glitches that occur in combined clock gates on edge enable. Flip-flop 112 can receive input data at pin 114 and generate output data at pin 116. The output of latch 102 is AND-gated with clock signal 110 to generate a gated clock signal 118 that is input to the clock pin of flip-flop 112.
[0033] Figure 2 An exemplary clock gating circuit based on the generated clock is shown. For example, the gated clock function includes a clock generator. In this example, clock generator 200 includes a flip-flop 202 having a data pin 206 electrically coupled to an enable signal 204 and a clock pin electrically coupled to a clock pin 208, which is the master clock to be gated. Flip-flop 202 is a D flip-flop with a clear (CLR) pin, a preset (PRE) pin, and an enable (CE) pin. The output of flip-flop 202 is a gated clock signal 216. The gated clock signal passes through a buffer 218. Flip-flop 210 receives the gated clock signal as input at its clock pin and receives data input at its data pin 212 to produce an output at its pin 214.
[0034] like Figures 1 to 2 As shown, the types of gated clocks include latch-based clocks and generated clocks. According to some aspects, GCC involves identifying and separating the enable function from the embedded gated clock function, leaving only the master clock signal. According to some aspects, the derived enable function can be attached to a dedicated enable pin of the target register, and the master clock signal can be attached to the clock pin of the target register.
[0035] Figure 3An exemplary post-GCC transformation of a clock-gated circuit based on the generated clock is shown. The GCC transformation of a clock-gated circuit according to some aspects of the invention will be discussed in detail below. After GCC, the master clock signal 310 is directly connected to the clock pin of flip-flop 304. Flip-flops 302 and 304 are each D flip-flops with a clear (CLR) pin, a preset (PRE) pin, and an enable (CE) pin. Flip-flop 302 can also receive an enable signal 306 at its data pin 308 and a clock signal 310 at its clock pin 312. The enable pin 314 of flip-flop 302 can be set to an active high voltage level. In this example, the output signal of flip-flop 302 is inverted, AND-gated with the enable signal 306, and input to the enable pin 316 of flip-flop 304. In this example, the clock signal at the clock pin of flip-flop 304 is the master clock signal 310. Flip-flop 304 can receive data at its data pin 318 and generate an output at its output data pin 320.
[0036] GCC transformation is useful in several ways when sampling multiple timing devices on different gated clocks. For example, in an FPGA, sampling multiple timing devices on different gated clocks requires significant clock resources. After GCC is performed, each enable function can be extracted independently of each gated clock and reconnected to the clock enable pin (CE) of each timing device. The clock pin (C) can then be directly connected to the master clock, thus optimizing FPGA resources.
[0037] Figure 4 A GCC transformation of multiple gated clocks to unique clocks according to an exemplary embodiment of the present disclosure is illustrated. Flip-flops 402, 404, and 406 are connected to gated clocks 408, 410, and 412, respectively. Gated clocks 408, 410, and 412 are generated based on enable signals 414, 416, and 418, and a master clock signal 420, respectively. Figure 4 As shown, before GCC is performed, the circuit has three gated clock functions, resulting in three unique clock signals. However, after GCC is performed according to some aspects of this disclosure, the circuit has only a single unique clock directly connected to the clock pins of flip-flops 402, 204, and 406. Furthermore, in this example, enable functions 414, 416, and 418 are connected to the clock enable (CE) pins of flip-flops 402, 404, and 406, respectively. Therefore, performing GCC can reduce the number of unique clock signals present in the circuit.
[0038] Figure 5 An example method for performing a formally gated clock transition according to some aspects of the present invention is shown. (This can be discussed regarding...) Figures 6 to 8 Component description Figure 5 Method 500 can be derived from... Figure 7 The simulation system 702 and / or Figure 8 The computer system 800 executes. Method 500 can be used. Figures 1 to 2 This is executed on the circuit to separate the master clock from the gated clock. Method 500 can be executed to obtain... Figure 3 An exemplary post-GCC circuit. Method 500 can be performed to obtain Figure 4 The exemplary GCC transformation of multiple gated clocks is shown in the figure. Method 500 is not limited to the specific aspects depicted in the figure, and other systems can be used to perform the methods that those skilled in the art will understand. It should be understood that not all operations are required, and operations may not be consistent with... Figure 5 The same order of execution is shown.
[0039] At point 502, a high-level description language (such as System Verilog, SystemC, MyHDL, or OpenVera) can be used to receive the network representation or specification of the circuit design to be simulated on the FPGA. At point 504, the model for the gated clock function can be determined based on the received network representation or specification of the circuit design. For example, in Figure 1 In this context, the gated clock function 118 can be determined by performing a Boolean AND operation on the clock 110 and the output Q of latch 102. Similarly, in Figure 3 For example, the gated clock function 216 is determined as the output of the flip-flop 202, which has a clock input 208 connected to a clock pin and an enable 204 connected to a data pin 206.
[0040] According to some aspects, a gated clock function has a set of inputs, which include the master clock signal, enable signal, drive flip-flops, and latches in the support set of the gated clock function. According to some aspects, the inputs are in the support set of the gated clock function when a positive or negative transition in the inputs can cause a change in the value or state of the gated clock function. As a non-limiting example, the gated clock function `gated_clock` has a set of inputs {i0,…,i...} n According to some aspects, gated_clock can be represented as a set {i0,…,i...}. n The function F: gated_clock = F(i0…i n For example, in Figure 2 In this context, enable 204 and clock 208 are inputs to the support set of the gated clock function connected to flip-flop 210. Similarly, in Figure 4For example, enable 414 and clock 420 are inputs in the support set of the gated clock function connected to flip-flop 403, enable 416 and clock 420 are inputs in the support set of the gated clock function connected to flip-flop 404, and enable 418 and clock 420 are inputs in the support set of the gated clock function connected to flip-flop 406.
[0041] Depending on several aspects, for each register that is the target of a GCC transformation, a function can be defined to identify the set of transformations (positive or negative) it supports, such as the master clock, flip-flops, latches, etc. As a non-restrictive example, if the function is defined as PosEdge(F), then PosEdge(F) can return true when the transformation creates a positive edge on F.
[0042] At position 506, construct the Boolean representation of the function PosEdge(F). According to some aspects, the function PosEdge(F) can be constructed as follows: for the support set of the target {i0,…,i...} n For each input in}, determine whether a positive or negative transition in the input corresponds to a gated clock function transitioning from logical false to logical true. Based on some aspects, given the target, the input i in the support set... k When input i k The logic changes from false to true and the gated clock function F changes from false to true, or the input i... k The function PosEdge(F) returns true when the logic changes from true to false and the gated clock function F changes from false to true.
[0043] Based on several factors, the function PosEdge(F) can be described using the following function:
[0044]
[0045] In the example function for PosEdge(F) above, the operator "|" represents the Boolean OR operator, and the operator "&" represents the Boolean AND operator. Furthermore, in the example function for PosEdge(F) above, the item PosEdge(i k ) is when input "i k "A Boolean predicate that becomes true when it changes from false to true, and the term NegEdge(i k ) is when input "i k "A Boolean predicate that is true when it changes from a true to a false state."
[0046] In the example function above for PosEdge(F), the term PosEdgeEnable-i k It is if and only if the function F is at input ik Boolean predicates that are true when they change from logically false to logically true, and vice versa. The term `NegEdgeEnable-i`... k It is if and only if the function F is at input i k A Boolean predicate that is true when it changes from logically true to logically false, and vice versa. The term PosEdgeEnable-i k and NegEdgeEnable-i k Simple Boolean algebra calculations can be performed as follows: PosEdgeEnable-i k =~F(i k =0)&F(i k =1) and NegEdgeEnable-i k =~F(i k =1)&F(i k =0), where the "~" operator represents the Boolean NOT operator, and the term F(i k =0) is when the input i k It is the value of the logically false function F, and the term F(i) k =1) is when the input i k It is the value of the function F when the logic is true.
[0047] Depending on several factors, a function "NegEdge(F)" can be defined for each register that is the target of a GCC transformation. The function NegEdge(F) can return a logical truth value when the transformation (positive or negative) of its supporting set (e.g., master clock, flip-flops, latches, etc.) creates a negative edge on F.
[0048] Based on certain aspects, a Boolean function for NegEdge(F) is constructed at position 506. Based on certain aspects, the function NegEdge(F) can be constructed as follows: for the support set of the target {i0,…,i...} n For each input in}, determine whether a positive or negative transition in the input corresponds to a gated clock function transitioning from logical true to logical false. Based on some aspects, given the target, the input i in the support set... k When input i k When the logic changes from false to true and the gated clock function F changes from true to false, or when the input i... k The function NegEdge(F) returns true when the logic changes from true to false and the gated clock function F changes from true to false.
[0049] Based on several aspects, the function NegEdge(F) can be described using the following function:
[0050]
[0051] In the example function for NegEdge(F) above, the operator "|" represents the Boolean OR operator, and the operator "&" represents the Boolean AND operator. Furthermore, in the example function for NegEdge(F) above, the item PosEdge(i k ) is when input "i k "A Boolean predicate that becomes true when it changes from logically false to logically true, and the term NegEdge(i k ) is when input "i k "A Boolean predicate that is logically true when it changes from logically true to logically false."
[0052] In the example function above for NegEdge(F), the term PosEdgeEnable-i k It is if and only if the function F is at input i k Boolean predicates that are true when they change from logically false to logically true, and vice versa. The term `NegEdgeEnable-i` is an example of a Boolean predicate that is true when it changes from logically false to logically true. k It is if and only if the function F is at input i k A Boolean predicate that is true when it changes from logically true to logically false, and vice versa.
[0053] In the exemplary functions above for PosEdge(F) and NegEdge(F), the input i of the trigger or latch of interest (e.g., a clock-gated latch and a clock generator) is... k , item PosEdge(i k ) and NegEdge(i k PosEdge can be recursively defined as follows: PosEdge(i k )=~i k .Q&i k .next-state and NegEdge(i k ) = i k .Q&~i k .next-state. In other words, if the current state of a latch or flip-flop is 0 and the next state is 1, then a rising edge will be generated when the latch or flip-flop changes state. Similarly, if the current state of a latch or flip-flop is 1 and the previous state was zero, then a falling edge will be generated when the latch or flip-flop changes state.
[0054] Depending on some aspects, the target of a GCC flip-flop can be a positive-edge triggered flip-flop. As a non-limiting example, the register inputs can be represented as follows: PRE is asynchronous set, CL is asynchronous reset, CLK is the positive-edge sensitive clock for the flip-flop, SET is synchronous set, RST is synchronous reset, EN is latch level sensitive enable, and D is the data input.
[0055] According to some aspects, the next state of a flip-flop can be represented as: flop.next-state = PRE? 1:CLR? 0:PosEdge(CLK)? (SET.prev? 1:RST.prev? 0:D.prev):Q, where the operator "?" represents a Boolean if-then-else operation. In other words, the next state of a flip-flop can be determined as follows: if PRE is true, the next state is 1; otherwise, if CLR is true, the next state is zero; otherwise, if PosEdge exists on CLK, it loads one, zero, or D depending on SET and RST; and if none of the above are true, the register holds its state and the next state is Q. Furthermore, in the above example expression for the next state flop.next-state of a flip-flop, "s.prev" indicates the value of s before the rising edge of CLK. In other words, if the functions of s and CLK overlap, the value of any shared signal is its value when CLK is 0.
[0056] According to some aspects, the latch target can be enabled at the positive edge of the enable signal. According to some aspects, the next state of the latch can be represented as: latch.next-state = PRE? 1:CLR? 0:EN? D:NegEdge(EN)? D.prev:Q, where the operator "?" represents the Boolean if-then-other operation. In other words, the next state of the latch can be determined as follows: if PRE is true, the next state is 1; otherwise, if CLR is true, the next state is zero; otherwise, if the latch is enabled, the next state is the data input D; otherwise, if the enable is decremented, the next state is the previous state of the data; otherwise, the next state is the state the data had when the enable was high; and if none of the above are true, then the latch holds its state and the next state is Q.
[0057] At 508, it can be determined, according to some aspects, whether any edge-sensitive inputs remain to the gated clock function F. According to some aspects, an edge-sensitive input is an input that can generate a clock edge. If any edge-sensitive inputs remain, the process repeats to 504. According to some aspects, after minimizing PosEdge(F), if any term PosEdge(i... k ) or NegEdge(ik The remaining input i is not for the main input of the circuit. k Minimize, and the edge-sensitive inputs remain. According to some aspects, the main input is the circuit's top-level input port. According to some aspects, the main input can be an edge-sensitive clock signal. According to some aspects, the main input can be a non-edge-sensitive enable signal. According to some aspects, the PosEdge(F) function is constructed recursively until no edge-sensitive inputs remain for the function. According to some aspects, the recursion continues until the only PosEdge / NegEdge inputs of the minimized function are the main inputs.
[0058] If there are no further edge inputs to the Boolean function F, the function PosEdge(F) can be minimized by applying a Boolean minimization technique at 510. Boolean minimization can be performed using algebraic manipulation or the Karnaugh map method, depending on the context. One approach to minimizing a Boolean expression is to formulate its truth table as a matrix where minterms with distinct values of individual variables are adjacent to each other. The adjacent cells of the matrix are then grouped to identify the product terms that eliminate complemented literals, thus obtaining a minimized version of the Boolean expression.
[0059] At 512, for the trigger objective, it can be determined whether PosEdge(F) can be minimized to a Boolean expression that is a Boolean AND of the first and second terms, where the first term is the combined Boolean function E and the second term is the Boolean predicate PosEdge(master clock), which returns true when the master clock transitions from false to true. According to some aspects, for the trigger objective, it can be determined whether PosEdge(F) can be minimized to a Boolean expression that is a Boolean AND of the first and second terms, where the first term is the combined Boolean function E and the second term is the Boolean predicate NegEdge(master clock), which returns true when the master clock transitions from true to false. Therefore, if it can be determined that PosEdge(F) can be minimized to one of the following forms:
[0060] PosEdge(F) <=> E & PosEdge (master clock), or PosEdge(F) <=> E & NegEdge (master clock);
[0061] Wherein, the symbol "<=>" refers to the equivalent via Boolean minimization, the primary-clock refers to a single primary clock, and the combined Boolean function E is not a function of the primary clock, then GCC is possible. According to some aspects, when GCC is possible, the combined function E is used as the clock enable for the target, and the primary clock or its inverse is used as the clock for the target. According to some aspects, for a trigger target, at 514 it can be determined whether PosEdge(F) can be minimized to a Boolean expression of the form of a Boolean AND of the first and second terms, where the first term is the combined Boolean function E and the second term is the primary clock. According to some aspects, for a trigger target, it can be determined whether PosEdge(F) can be minimized to a Boolean expression of the form of a Boolean AND of the first and second terms, where the first term is the combined Boolean function E and the second term is the complement of the primary clock. Therefore, if it can be determined that PosEdge(F) can be minimized to one of the following forms:
[0062] PosEdge(F) <=> E& master clock, or PosEdge(F) <=> E& ~ master clock;
[0063] Where the master clock is a single master clock, and the combinational Boolean function E is independent of the master clock, then GCC is possible. According to some aspects, when GCC is possible, the combinational function E is used as the clock enable for the target, and the master clock or its inversion is used as the clock for the target.
[0064] At 514, for a trigger target, if the minimum match of PosEdge(F) is PosEdge(F) <=> E&PosEdge(master clock), GCC can be performed by directly connecting the master clock to the target's clock pin, and the first term "E" is used as the clock enable function. Depending on some aspects, for a latch target, if the minimum match of PosEdge(F) is PosEdge(F) <=> E&master clock, GCC can be performed by directly connecting the master clock to the target's clock pin, and "E" is used as the clock enable function.
[0065] According to some aspects, for a trigger target, if the minimization of PosEdge(F) matches PosEdge(F) <=> E&NegEdge (master clock), GCC can be performed at 514 by connecting the inverted master clock to the target's clock pin, and "E" is used as the clock enable function. According to some aspects, for a latch target, if the minimization of PosEdge(F) matches PosEdge(F) <=> E&~master clock, GCC can be performed by connecting the inverted master clock to the target's clock pin, and "E" is used as the clock enable function. Additionally or alternatively, at 516, if the minimization of PosEdge(F) does not match any of the forms specified above, it is determined that GCC is not feasible.
[0066] Figure 6 The illustration depicts a set of example processes 600 used during the design, verification, and manufacturing of an in-process, such as an integrated circuit, to convert and verify design data and instructions representing that integrated circuit. Each of these processes can be configured and enabled as multiple modules or operations. The term "EDA" stands for "Electronic Design Automation." These processes begin by creating a product concept 610 using information provided by the designer, which is then converted to create an article of art using a set of EDA processes 612. When the design is complete, it is tape-out 634, at which point the artwork (e.g., geometric pattern) for the integrated circuit is sent to a manufacturing facility to create a mask set, which is then used to manufacture the integrated circuit. After tape-out, semiconductor dies are manufactured 636, and packaging and assembly processes 638 are performed to produce a finished integrated circuit 640.
[0067] Specifications for circuits or electronic structures can range from low-level transistor material placement to high-level description languages. High-level representations can be used to design circuits and systems using hardware description languages (HDLs) such as VHDL, Verilog, SystemVerilog, SystemC, MyHDL, or OpenVera. HDL descriptions can be translated into logic-level register-transfer-level (RTL) descriptions, gate-level descriptions, placement-level descriptions, or mask-level descriptions. Each lower-level representation, as a more detailed description, adds more useful details to the design description, such as more details about the modules that include that description. Lower-level representations, as more detailed descriptions, can be computer-generated, exported from design libraries, or created by another design automation process. An example of a specification language used to specify lower-level representations with more detailed descriptions is SPICE, which is used for detailed descriptions of circuits with many analog components. Descriptions at each representation level can be used by the corresponding tools for that layer (e.g., formal verification tools). Design processes can use... Figure 6 The sequence described herein. The process described is implemented by EDA products (or tools).
[0068] During system design 614, the functionality of the integrated circuit to be manufactured is specified. The design can be optimized for desired characteristics, such as power consumption, performance, area (physical and / or lines of code), and cost reduction. At this stage, it may be possible to divide the design into different types of modules or components.
[0069] During logic design and functional verification 616, modules or components in a circuit are specified in one or more descriptive languages, and specifications are checked for functional accuracy. For example, components of a circuit can be verified to generate outputs that match the requirements of the specifications of the circuit or system being designed. Functional verification can use simulators and other programs, such as testbed generators, static HDL checkers, and formal verifiers. In some embodiments, a special system of components referred to as a “simulator” or “prototype system” is used to accelerate functional verification.
[0070] During synthesis and design 618 for testing, HDL code is converted into a netlist. In some embodiments, the netlist may be a graphical structure, where edges represent components of the circuit, and nodes represent how the components are interconnected. Both HDL code and netlist are hierarchical artifacts that can be used by EDA products to verify that the integrated circuit performs as specified in the design when manufactured. The netlist may be optimized for a target semiconductor manufacturing technology. Additionally, the completed integrated circuit can be tested to verify that it meets specifications.
[0071] During netlist verification 620, the netlist is checked for compliance with timing constraints and for correspondence with HDL code. During design planning 622, the overall layout plan for the integrated circuit is constructed and analyzed for timing and top-level routing.
[0072] During layout or physical implementation 624, physical placement (placement of circuit components such as transistors or capacitors) and wiring (connection of circuit components through multiple conductors) occur, and selection of cells from a library can be performed to enable specific logic functions. As used herein, the term "cell" can specify a set of transistors, other components, and interconnections that provide Boolean logic functions (e.g., AND, OR, NOT, XOR) or storage functions (e.g., flip-flops or latches). As used herein, a circuit "block" can refer to two or more cells. Both cells and circuit blocks can be referred to as modules or components and can be used as both physical structures and in simulations. Parameters, such as size, are specified for the selected cells (based on "standard cells"), and these parameters are made accessible in a database for use in EDA products.
[0073] During analysis and extraction (626), circuit functionality is verified at the placement level, allowing for refinement of the placement design. During physical verification (628), the placement design is checked to ensure that manufacturing constraints are correct, such as DRC constraints, electrical constraints, and lithographic constraints, and to ensure that circuit functionality matches the HDL design specifications. During resolution enhancement (630), the geometry of the placement is transformed to improve the fabrication of the circuit design.
[0074] During the tape-out process, data is created for use in the production of the photomask (if appropriate, after photolithography enhancement is applied). During mask data preparation 632, the "tape-out" data is used to generate the photomask, which is then used to produce the finished integrated circuit.
[0075] Computer systems (such as) Figure 8 Computer system 800 or Figure 7 The storage subsystem of the host system (707) can be used to store programs and data structures as well as products used by some or all of the EDA products described herein, and these products are used for the development of units of the library and for the physical and logical design of the library.
[0076] Figure 7A schematic diagram of an example simulation environment 700 is depicted. Simulation environment 700 can be configured to verify the functionality of a circuit design. Simulation environment 700 may include a host system 707 (e.g., a computer as part of an EDA system) and a simulation system 702 (e.g., a set of programmable devices such as a field-programmable gate array (FPGA) or a processor). The host system constructs the simulation system to simulate the circuit design by generating data and information using compiler 710. The circuit design to be simulated is also called the design under test (DUT), where data and information from the simulation are used to verify the functionality of the DUT.
[0077] The host system 707 may include one or more processors. In embodiments where the host system includes multiple processors, the functions performed by the host system as described herein may be distributed across multiple processors. The host system 707 may include a compiler 710 for transforming a specification representing the DUT written in a description language and for generating data (e.g., binary data) and information for constructing the simulation system 702 to simulate the DUT. The compiler 710 may transform, modify, refactor the DUT, add new functionality to the DUT, and / or control the timing of the DUT.
[0078] The host system 707 and the emulation system 702 exchange data and information using signals carried by the emulation connection. The connection can be, but is not limited to, one or more cables, such as cables with pin configurations compatible with recommended standard RS232 or Universal Serial Bus (USB) protocols. The connection can be a wired communication medium, or a network such as a local area network (LAN) or a wide area network (WAN) such as the Internet. The connection can also be a wireless communication medium or a network with one or more access points using wireless protocols such as BlueTooth or IEEE 702.11. The host system 707 and the emulation system 702 can exchange data and information via a third device such as a network server.
[0079] The simulation system 702 includes multiple FPGAs (or other modules), such as FPGAs 7041 and 7042, and up to 704. N Additional FPGAs. Each FPGA may include one or more FPGA interfaces through which the FPGA is connected to other FPGAs (and possibly other emulation components) to enable signal exchange between them. FPGA interfaces may be referred to as input / output pins or FPGA pads. Although the emulator may include an FPGA, embodiments of the emulator may include other types of logic blocks that do not include the FPGA used to emulate the DUT, or may include other types of logic blocks that are used in conjunction with the FPGA used to emulate the DUT. For example, emulation system 702 may include a custom FPGA, a dedicated ASIC for emulation or prototyping, memory, and input / output devices.
[0080] Programmable devices may include arrays of programmable logic blocks and hierarchical interconnections that allow the programmable logic blocks to be interconnected according to a description in HDL code. Each of the programmable logic blocks may enable complex combinational functions or logic gates such as AND and XOR logic blocks. In some embodiments, the logic blocks may also include memory elements / devices, which may be simple latches, flip-flops, or other memory blocks. Depending on the length of the interconnections between different logic blocks, signals may arrive at the input terminals of the logic blocks at different times and can therefore be temporarily stored in the memory elements / devices.
[0081] FPGA 7041-704 N It can be placed on one or more plates 7121 and 7122 and up to 712. M Additional boards. Multiple boards can be placed within simulation unit 7141. Boards within the simulation unit can be connected using the simulation unit's backplane or any other type of connection. Additionally, multiple simulation units (e.g., 7141 and 7142 up to 714) can be... K They can be connected to each other via cables or any other means to form a multi-simulation unit system.
[0082] For the DUT to be simulated, the host system 707 transmits one or more bit files to the simulation system 702. The bit files can specify a description of the DUT and can further specify partitions of the DUT created by the host system 707 with tracing and injection logic, map these partitions to the simulator's FPGA, and design constraints. Using the bit files, the simulator constructs the FPGA to perform the functionality of the DUT. In some embodiments, one or more FPGAs of the simulator can have tracing and injection logic built into the silicon of the FPGA. In such embodiments, the FPGA may not be constructed by the host system to simulate the tracing and injection logic.
[0083] The host system 707 receives a description of the DUT to be emulated. In some embodiments, the DUT description uses a description language (e.g., Register Transfer Language (RTL)). In some embodiments, the DUT description uses a netlist-level file or a mixture of a netlist-level file and an HDL file. If part or all of the DUT description is in HDL, the host system can synthesize the DUT description to create a gate-level netlist using the DUT description. The host system can use the DUT's netlist to partition the DUT into multiple partitions, where one or more partitions include tracing and injection logic. The tracing and injection logic tracks interface signals exchanged via the FPGA interface. Additionally, the tracing and injection logic can inject the tracked interface signals into the FPGA's logic. The host system maps each partition to the emulator's FPGA. In some embodiments, the tracing and injection logic is included in selected partitions of a set of FPGAs. The tracing and injection logic can be built into one or more FPGAs of the emulator. The host system can synthesize a multiplexer to be mapped into the FPGA. The multiplexer can be used by the tracing and injection logic to inject interface signals into the DUT logic.
[0084] The host system creates a bit file that describes each partition of the DUT and how that partition will be mapped to an FPGA. For partitions that include tracing and injection logic, the bit file also describes the included logic. The bit file may include placement and routing information as well as design constraints. The host system stores the bit files and information that describes which FPGAs will emulate each component of the DUT (e.g., which FPGA each component is mapped to).
[0085] Upon request, the host system transmits the bit file to the emulator. The host system signals the emulator to begin emulation of the DUT. During or at the end of the DUT simulation, the host system receives simulation results from the emulator via the emulation connection. The simulation results are data and information generated by the emulator during the DUT simulation, including interface signals and their states, which have been tracked through the trace and injection logic of each FPGA. The host system can store the simulation results and / or transmit them to another processing system.
[0086] After the DUT simulation, the circuit designer can request to debug components of the DUT. If such a request is made, the circuit designer can specify the time period for debugging the simulation. The host system uses stored information to identify which FPGAs are simulating the components. The host system retrieves the stored interface signals, which are associated with the time period and traced by the trace and injection logic of each identified FPGA. The host system signals the emulator to re-emulate the identified FPGA. The host system transmits the retrieved interface signals to the emulator to re-emulate the components within the specified time period. The trace and injection logic of each identified FPGA injects its corresponding interface signal received from the host system into the FPGA's DUT logic. In the case of multiple FPGA re-simulations, the combined results produce a complete debug view.
[0087] The host system receives signals traced by the logic of the identified FPGA during component re-simulation from the simulation system. The host system stores the signals received from the simulator. Signals traced during re-simulation can have a higher sampling rate than during the initial simulation. For example, in the initial simulation, the traced signals may include saved state of the component every X milliseconds. However, in the re-simulation, the traced signals may include saved state every Y milliseconds, where Y is less than X. If the circuit designer requests to view the waveform of the signals traced during re-simulation, the host system can retrieve the stored signals and display a graph of the signals. For example, the host system can generate the waveform of the signals. Subsequently, the circuit designer can request to re-simulate the same component at different time periods, or request to re-simulate a different component.
[0088] The host system 707 and / or compiler 710 may include subsystems, such as, but not limited to, a design synthesizer subsystem, a mapping subsystem, a runtime subsystem, a results subsystem, a debugging subsystem, a waveform subsystem, and a storage subsystem. Subsystems may be constructed and enabled as a single module or multiple modules, or two or more subsystems may be constructed as a single module. These subsystems work together to construct the simulator and monitor simulation results.
[0089] The design synthesizer subsystem converts the HDL 705 representing the DUT into gate-level logic. For the DUT to be simulated, the design synthesizer subsystem receives the description of the DUT. If the description of the DUT is in HDL (e.g., RTL or other representation levels), the design synthesizer subsystem synthesizes the HDL of the DUT to create a gate-level netlist with the description of the DUT in terms of gate-level logic.
[0090] The mapping subsystem partitions the DUT and maps the partitions to the simulator FPGA. The mapping subsystem uses the DUT's netlist to divide the gate-level DUT into multiple partitions. For each partition, the mapping subsystem retrieves the gate-level description of the trace and injection logic and adds the logic to that partition. As described above, the trace and injection logic included in the partition is used to trace the signals exchanged at the interface of the FPGA mapped to that partition (trace interface signals). The trace and injection logic can be added to the DUT before partitioning. For example, the trace and injection logic can be added by the design synthesizer subsystem before or after synthesizing the HDL of the DUT.
[0091] In addition to including tracing and injection logic, the mapping subsystem can also include additional tracing logic within partitions to track the state of certain DUT components not tracked by the tracing and injection logic. The mapping subsystem can include this additional tracing logic in the DUT before or after partitioning. The design synthesizer subsystem can also include additional tracing logic in the DUT's HDL description before the synthesis HDL description.
[0092] The mapping subsystem maps each partition of the DUT to an FPGA of the simulator. For partitioning and mapping, the mapping subsystem uses design rules, design constraints (e.g., timing or logic constraints), and information about the simulator. For components of the DUT, the mapping subsystem stores information in the storage subsystem that describes which FPGAs will simulate each component.
[0093] Using partitioning and mapping, the mapping subsystem generates one or more bit files that describe the created partitions and the mapping of logic to each FPGA in the simulator. The bit files may include additional information such as DUT constraints and wiring information for connections between FPGAs and connections within each FPGA. The mapping subsystem can generate a bit file for each partition of the DUT and can store this bit file in the storage subsystem. Upon request from the circuit designer, the mapping subsystem transmits the bit file to the simulator, and the simulator can use the bit file to construct the FPGA to simulate the DUT.
[0094] If the simulator includes a dedicated ASIC with tracking and injection logic, the mapping subsystem can generate a specific structure for connecting the dedicated ASIC to the DUT. In some embodiments, the mapping subsystem can store information about the tracked / injected signals and the location on the dedicated ASIC where that information is stored.
[0095] The runtime subsystem controls the simulation performed by the emulator. The runtime subsystem can cause the emulator to start or stop executing the simulation. Additionally, the runtime subsystem can provide input signals and data to the emulator. Input signals can be provided directly to the emulator via a connection or indirectly via other input signaling devices. For example, the host system can control input signaling devices to provide input signals to the emulator. Input signaling devices can be, for example, test boards (directly or via cable), signal generators, another emulator, or another host system.
[0096] The results subsystem processes the simulation results generated by the simulator. During and / or after simulation, the results subsystem receives the simulation results generated during simulation from the simulator. The simulation results include signals tracked during simulation. Specifically, the simulation results include interface signals tracked by the tracking and injection logic simulated by each FPGA, and may include signals tracked by additional logic included in the DUT. Each tracked signal may span multiple cycles of the simulation. The tracked signals include multiple states, and each state is associated with a time period of the simulation. The results subsystem stores the tracked signals in the storage subsystem. For each stored signal, the results subsystem may store information indicating which FPGA generated the tracked signal.
[0097] The debugging subsystem allows circuit designers to debug DUT components. After the simulator has simulated the DUT and the results subsystem has received the interface signals traced by the tracking and injection logic during simulation, the circuit designer can request to debug a component by resimulating the DUT for a specific time period. In the request to debug a component, the circuit designer identifies the component and indicates the time period of the simulation to be debugged. The circuit designer's request may include a sampling rate, which indicates the frequency at which the state of the component being debugged should be preserved by the logic of the traced signals.
[0098] The debug subsystem identifies one or more FPGAs of the simulator that are emulating components using information stored in the storage subsystem by the mapping subsystem. For each identified FPGA, the debug subsystem retrieves from the storage subsystem the interface signals traced by the FPGA's trace and injection logic during a time period specified by the circuit designer. For example, the debug subsystem retrieves the state traced by the trace and injection logic associated with the time period.
[0099] The debug subsystem transmits the retrieved interface signals to the simulator. The debug subsystem instructs the tracing and injection logic of each identified FPGA to inject the corresponding traced signals into the FPGA's logic to re-emulate the component within the requested time period. The debug subsystem can further transmit a sampling rate provided by the circuit designer to the simulator, allowing the tracing logic to track the state at appropriate intervals.
[0100] To debug a component, the simulator can use the FPGA to which the component has been mapped. Additionally, component re-simulation can be performed at any point specified by the circuit designer.
[0101] For the identified FPGA, the debug subsystem can send instructions to the emulator to load multiple emulator FPGAs with the same configuration as the identified FPGA. The debug subsystem additionally signals the emulator to use the multiple FPGAs in parallel. Each of the multiple FPGAs is used with different time windows of interface signals to generate larger time windows within shorter time amounts. For example, the identified FPGA might require an hour or more to use a certain number of cycles. However, if the multiple FPGAs have the same data and structure as the identified FPGA, and each of these FPGAs runs a subset of the cycles, the emulator might require several minutes to allow the FPGAs to share all cycles.
[0102] Circuit designers can identify the hierarchy or list of DUT signals to be re-emulated. To achieve this, the debug subsystem determines the hierarchy or list of signals needed for emulation, retrieves the necessary interface signals, and transmits the retrieved interface signals to the emulator for re-emulation of the FPGA. Therefore, circuit designers can identify any component (e.g., component, device, or signal) of the DUT for debugging / re-emulation.
[0103] The waveform subsystem generates waveforms using the tracked signals. If the circuit designer requests to view the waveform of a signal tracked during simulation, the host system retrieves the signal from the storage subsystem. The waveform subsystem displays a graph of the signal. For one or more signals, the waveform subsystem can automatically generate a graph of the signal when it is received from the simulator.
[0104] Figure 8An example machine of computer system 800 is illustrated, in which a set of instructions can be executed to cause the machine to perform any or more of the methods discussed herein. In alternative implementations, the machine can be connected (e.g., networked) to other machines in a LAN, intranet, extranet, and / or the Internet. The machine can operate at the capacity of a server or client machine in a client-server network environment, as a peer machine in a peer-to-peer (or distributed) network environment, or as a server or client machine in a cloud computing infrastructure or environment.
[0105] A machine can be a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular phone, a web device, a server, a network router, a switch or bridge, or any machine capable of executing a set of instructions (sequentially or otherwise) specifying the actions to be taken by that machine. Furthermore, while a single machine is described, the term "machine" should also be understood to include any collection of machines that, individually or collectively, execute a set (or more) of instructions to perform any one or more methods discussed herein.
[0106] Example computer system 800 includes processing device 802 communicating with each other via bus 830, main memory 804 (e.g., read-only memory (ROM), flash memory, dynamic random access memory (DRAM) such as synchronous DRAM (SDRAM), static memory 806 (e.g., flash memory, static random access memory (SRAM) and the like), and data storage device 818.
[0107] Processing device 802 represents one or more processors, such as microprocessors, central process units, etc. More specifically, processing device may be a Complex Instruction Set Computing (CISC) microprocessor, a Reduced Instruction Set Computing (RISC) microprocessor, a Very Long Instruction Word (VLIW) microprocessor, or a processor that implements other instruction sets, or a processor that implements combinations of instruction sets. Processing device 802 may also be one or more special-purpose processing devices, such as application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), network processors, etc. Processing device 802 may be configured to execute instructions 826 to perform the operations and steps described herein.
[0108] The computer system 800 may also include a network interface device 808 for communication via a network 820. The computer system 800 may also include a video display unit 810 (e.g., a liquid crystal display (LCD) or a cathode ray tube (CRT)), an alphanumeric input device 812 (e.g., a keyboard), a cursor control device 814 (e.g., a mouse), a graphics processing unit 822, a signal generation device 816 (e.g., a speaker), a graphics processing unit 822, a video processing unit 828, and an audio processing unit 832.
[0109] Data storage device 818 may include machine-readable storage medium 824 (also referred to as non-transient computer-readable medium) storing one or more sets of instructions 826 or software embodying any one or more of the methods or functions described herein. During execution of the instructions 826 by computer system 800, main memory 804, and processing device 802, which also constitutes a machine-readable storage medium, the instructions 826 may also reside wholly or at least partially in main memory 804 and / or processing device 802.
[0110] In some implementations, instruction 826 includes instructions for implementing functionality corresponding to this disclosure. Although machine-readable storage medium 824 is shown as a single medium in the example implementation, the term "machine-readable storage medium" should be considered to include a single medium or multiple media (e.g., a centralized or distributed database, and / or associated caches and servers) that store one or more sets of instructions. The term "machine-readable storage medium" should also be considered to include any medium capable of storing or encoding a set of instructions for machine execution and causing the machine and processing device 802 to perform any one or more methods of this disclosure. The term "machine-readable storage medium" should be accordingly considered to include, but is not limited to, solid-state memory, optical media, and magnetic media.
[0111] Some of the foregoing detailed descriptions have already been presented in terms of algorithms and symbolic representations of operations on data bits within computer memory. These algorithmic descriptions and representations are used by those skilled in the art of data processing in a way that most effectively communicates the substance of their work to others skilled in the art. An algorithm can be a series of operations leading to a desired result. These operations are those that require physical manipulation of physical quantities. Such quantities can take the form of electrical or magnetic signals that can be stored, combined, compared, and otherwise manipulated. Such signals can be referred to as bits, values, elements, symbols, characters, items, numbers, etc.
[0112] However, it should be remembered that all these terms and similar terms should be associated with appropriate physical quantities, and all these terms and similar terms are merely convenient labels applied to these quantities. Unless otherwise expressly stated in this disclosure, it should be understood that throughout the description, certain terms refer to the actions and processes of a computer system or similar electronic computing device that manipulate and convert data represented as physical (electronic) quantities within the registers and memory of the computer system into other data similarly represented as physical quantities within the computer system's memory or registers or other such information storage devices.
[0113] This disclosure also relates to means for performing the operations described herein. Such means may be specifically constructed for an intended purpose, or may include a computer selectively activated or reconfigured by a computer program stored in the computer. Such a computer program may be stored in a computer-readable storage medium, such as, but not limited to, any type of disk, including floppy disks, optical disks, CD-ROMs and magneto-optical disks, read-only memory (ROM), random access memory (RAM), EPROM, EEPROM, magnetic cards or optical cards, or any type of medium suitable for storing electronic instructions, each computer-readable storage medium being coupled to a computer system bus.
[0114] The algorithms and displays presented herein are not inherently related to any particular computer or other device. Various other systems may be used with the programs taught herein, or it may be convenient to construct more specialized devices to perform the methods. Furthermore, this disclosure is not described with reference to any particular programming language. It should be understood that the teachings of this disclosure can be implemented using various programming languages as described herein.
[0115] This disclosure can be provided as a computer program product or software, which may include a machine-readable medium having instructions stored thereon that can be used to program a computer system (or other electronic device) to perform processes according to this disclosure. Machine-readable media include any means for storing information in a machine-readable (e.g., computer-readable) form. For example, machine-readable (e.g., computer-readable) media include machine-readable (e.g., computer-readable) storage media, such as read-only memory (“ROM”), random access memory (“RAM”), disk storage media, optical storage media, flash memory devices, etc.
[0116] In the foregoing disclosure, implementations of the present disclosure have been described with reference to specific examples. It will be apparent that various modifications may be made thereto without departing from the broader spirit and scope of the present disclosure as described in the appended claims. While elements are referred to in the singular in this disclosure, more than one element may be depicted in the drawings, and the same elements are labeled with the same numbers. Therefore, this disclosure and the drawings should be considered illustrative rather than restrictive.
Claims
1. A method comprising: Network representation of receiver circuit design; Determine the gated clock function corresponding to the target component represented by the network; The edge function is constructed at least in part based on the gated clock function; Perform Boolean minimization of the edge function; as well as In response to determining the minimization of the edge function, which includes a first term and a second term, a clock enable signal is provided to the target component based on the first term, and a clock signal is provided to the target component based on the second term.
2. The method of claim 1, wherein the gated clock function is based on a plurality of inputs corresponding to a support set of the gated clock function.
3. The method of claim 2, wherein the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a positive edge on the gated clock function.
4. The method of claim 2, wherein when a transition of one of the plurality of inputs creates a negative edge on the gated clock function, the edge function returns a logical true value.
5. The method of claim 2, wherein the plurality of inputs includes one or more of the following: a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch.
6. The method according to claim 1, further comprising: Determine whether the edge-sensitive input to the gated clock function remains; as well as The edge function is constructed based on the determined edge-sensitive input remainder.
7. The method of claim 1, wherein the target component is a trigger or a latch.
8. A system comprising: Memory that stores instructions; as well as A processor, coupled to the memory, and configured to execute the instructions, which, when executed, cause the processor to: Network representation of receiver circuit design; Determine the gated clock function corresponding to the target component represented by the network; The edge function is constructed at least in part based on the gated clock function; Perform Boolean minimization of the edge function; as well as In response to determining the minimization of the edge function, which includes a first term and a second term, a clock enable signal is provided to the target component based on the first term, and a clock signal is provided to the target component based on the second term.
9. The system of claim 8, wherein the gated clock function is based on a plurality of inputs corresponding to a support set of the gated clock function.
10. The system of claim 9, wherein the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a positive edge on the gated clock function.
11. The system of claim 9, wherein the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a negative edge on the gated clock function.
12. The system of claim 9, wherein the plurality of inputs includes one or more of the following: a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch.
13. The system of claim 8, wherein the instructions further cause the processor to: Determine whether the edge-sensitive input to the gated clock function remains; and The edge function is constructed based on the determined edge-sensitive input remainder.
14. The system of claim 8, wherein the target component is a trigger.
15. A non-transitory computer-readable medium comprising stored instructions that, when executed by a processor, cause the processor to: Network representation of receiver circuit design; Determine the gated clock function corresponding to the target component represented by the network; The edge function is constructed at least in part based on the gated clock function; Perform Boolean minimization of the edge function; as well as In response to determining the minimization of the edge function, which includes a first term and a second term, a clock enable signal is provided to the target component based on the first term, and a clock signal is provided to the target component based on the second term.
16. The non-transitory computer-readable medium of claim 15, wherein the gated clock function is based on a plurality of inputs corresponding to a support set of the gated clock function.
17. The non-transitory computer-readable medium of claim 16, wherein the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a positive edge on the gated clock function.
18. The non-transitory computer-readable medium of claim 16, wherein the edge function returns a logical truth value when a transition of one of the plurality of inputs creates a negative edge on the gated clock function.
19. The non-transitory computer-readable medium of claim 16, wherein the plurality of inputs includes one or more of the following: a master clock signal, an enable signal, a control signal, the output of a flip-flop, and the output of a latch.
20. The non-transitory computer-readable medium of claim 15, wherein the stored instructions, when executed, further cause the processor to perform: Determine whether the edge-sensitive input to the gated clock function remains; and The edge function is constructed based on the determined edge-sensitive input remainder.
Citation Information
Patent Citations
Methods for construction and optimization of a clock tree plan for reduced power consumption
US9135375B1
