# Patent

## Title
Early decoupling capacitor optimization method for hierarchical circuit design

## Abstract

Methods, systems, computer programs, etc., determine the required number of decoupling capacitors, and approximate locations for the decoupling capacitors, for a region of an integrated circuit. Switching elements of the region are entered into a simulation program running on a computerized device. Also, a power distribution model of the region is entered into the simulation program, and a power-supply voltage compression target is entered into the simulation program. These methods, systems, etc., generate an upper number of decoupling capacitors required to satisfy the compression target when all the switching elements concurrently switch. For each switching element, the methods, systems, etc., generate a specific number of decoupling capacitors required to satisfy the compression when only the element switches, calculate a fraction of the specific number to the upper number, assign the fraction of the total number of decoupling capacitors to each switching circuit element, and place the fraction of the total number of decoupling capacitors in electrical proximity to the element.

## Background
BACKGROUND
The embodiments herein relate to integrated circuit (IC) design, and more specifically, to methods, systems, and computers that optimize the number of decoupling capacitors within integrated circuit designs.
In integrated circuits, decoupling capacitors help to stabilize the on-chip VDD to GND power supply. A common design objective involves satisfying a power-supply compression target, which is a quantitative measure of how much voltage stability the decoupling capacitors provide when the circuits on the chip are switching. Specifically, power-supply compression can be described as the difference between the nominal on-chip power supply voltage value (i.e., VDD−GND) before a switching event, and the minimum on-chip power supply voltage value that occurs during a switching event.
Very early in the process of integrated circuit design, one of the major challenges is to determine how many decoupling capacitors are required to meet the voltage compression specification. Another challenge involves properly allocating the decoupling capacitors to ensure that they are placed in optimal proximity to the switching circuits that induce power-supply voltage variation. Some early design strategies assume worst-case switching scenarios and yield correspondingly conservative estimates of required decoupling capacitance. These approaches may drive unnecessary costs due to the finite and non-negligible area consumed by the decoupling capacitors. Conversely, less conservative approaches may underpredict decoupling capacitor requirements, and actually compromise circuit function or performance. This can occur if the constraints imposed by early design decisions prohibit the inclusion of additional decoupling capacitors ultimately deemed necessary following more “detailed” voltage compression analysis. Thus, it is desirable to obtain accurate estimates of the decoupling capacitor requirements very early in the design cycle.
Accurate early decoupling capacitor estimation is a challenging design problem. Simple guidelines have frequently been utilized, but these are commonly derived solely from the charge-sharing relationships between the decoupling capacitance and the representative switching-event “switched” capacitance. This approach makes it difficult to account for the contribution of decoupling capacitor resistance to power-supply voltage compression. Moreover, practical IC designs contain multiple IP (intellectual property) circuit components, which may interactively switch in complex ways. These interactions are known to play a significant role in determining how many decoupling capacitors are required. Finally, the switched-capacitance equivalent of any switching circuit is a function of its operating frequency, and its corresponding charge demand is typically provided not only by assigned decoupling capacitors, but also by system-level charge reservoirs like package- and circuit-board capacitors, and even the board voltage regulation module. It is extremely difficult to quantify the effect of these charge transfer mechanisms using a guideline-based design approach.
Alternative techniques for decoupling capacitor allocation use circuit simulation, and vary widely in scope and complexity. Rigorous analysis using highly detailed simulation models can address all of the drawbacks inherent to “guideline-based” strategies, but suffer from their reliance on extracted power bus models and/or physical layout data. Lumped simulation models, which use engineering approximations to simplify their complexity, have also proven useful for decoupling capacitor estimation.
Lumped element analysis can intelligently combine the effects of parasitic circuit elements which comprise more elaborate power distribution models, but typically model the power demand of individual switching circuits collectively. As a result, any individual circuits deemed power-supply “aggressors” may not be uniquely modeled. While this approach provides a clear performance advantage and is useful for estimating the total decoupling capacitor requirement, the results of lumped-element results provide little guidance for assigning decoupling capacitors to the individual aggressors, whose details are “lost” in any modeling approximation. Any attempts to represent aggressors individually in a lumped-element model, again, create dependencies on circuit placement and layout which, practically speaking, are best avoided during early-stage design analysis. The approach described herein overcomes these limitations by providing clear guidance on decoupling capacitor assignment to individual circuits without utilizing or assuming any knowledge of circuit placement or layout.
SUMMARY
An exemplary method herein determines the required number of decoupling capacitors, and approximate locations for the decoupling capacitors, for a region of an integrated circuit. The embodiments herein enter the switching elements of the region, a power distribution model of the region, and a power-supply voltage compression target into a simulation program running on a computerized device. The embodiments herein generate, using the computerized device, a total number of decoupling capacitors required to satisfy the compression target when all the switching elements concurrently switch. Additionally, for each switching element, the embodiments herein generate a normalized number of decoupling capacitors required to satisfy the compression target when only that element switches. Finally, the embodiments herein use the relative ratios of the normalized numbers of decoupling capacitors to allocate a fraction of the total number of decoupling capacitors to each switching circuit element. The allocated quantity of decoupling capacitors is then placed in close electrical proximity (a predetermined area percentage or other distance measure) to each corresponding switching element.
Another method herein determines the required number of decoupling capacitors, and approximate locations for the decoupling capacitors, for a region of an integrated circuit. The embodiments herein enter switching elements of the region into a simulation program running on a computerized device, enter a power-supply voltage compression target into the simulation program, and generate, using the computerized device, a total number of decoupling capacitors required to satisfy the compression target when all the switching elements concurrently switch. Additionally, for each element, the embodiments generate, using the computerized device, a normalized number of decoupling capacitors required to satisfy the compression target when only the element switches. The embodiments herein calculate a fraction that the normalized number is to the total number, and place the fraction of the total number of decoupling capacitors in electrical proximity to the element.
Another method herein determines a required number of decoupling capacitors, and approximate locations for the decoupling capacitors, for a region of an integrated circuit. The embodiments herein enter switching elements of the region into a simulation program running on a computerized device, enter a power-supply voltage compression target into the simulation program, and generate, using the computerized device, a total number of decoupling capacitors required to satisfy the compression target when all the switching elements concurrently switch. Additionally, for each element, the embodiments herein iteratively generate, using the computerized device, a normalized number of decoupling capacitors required to satisfy the compression target when only the element switches. The embodiments herein calculate a fraction that the normalized number is to the total number. Lastly, the embodiments place the fraction of the total number of decoupling capacitors in electrical proximity to the element.
Computer storage device embodiments herein comprise a non-transitory, computer-readable storage medium storing instructions executable by a computer to perform a method of determining a required number of decoupling capacitors, and approximate locations for the decoupling capacitors, for a region of an integrated circuit. The embodiments herein enter switching elements of the region into a simulation program running on a computerized device, enter a power distribution model of the region into the simulation program, and enter a power-supply voltage compression target into the simulation program. The embodiments herein generate, using the computerized device, a total number of decoupling capacitors required to satisfy the compression target when all the switching elements concurrently switch. Additionally, for each element, the embodiments generate, using the computerized device, a specific number of decoupling capacitors required to satisfy the compression target when only the element switches. Next, the embodiments calculate a fraction that the specific number is to the total number. Lastly, the embodiments herein place the fraction of the total number of decoupling capacitors in electrical proximity to the element.



BRIEF DESCRIPTION OF THE SEVERAL VIEWS OF THE DRAWINGS
The embodiments herein will be better understood from the following detailed description with reference to the drawings, which are not necessarily drawn to scale and in which:
FIG. 1 is a flow diagram illustrating embodiments herein;
FIG. 2 is an illustration of an exemplary user interface screen that can be used with embodiments herein;
FIG. 3 is an illustration of an exemplary user interface screen that can be used with embodiments herein;
FIG. 4 is a schematic diagram of a circuit model that can be used with embodiments herein;
FIG. 5 is a graphical representation of a transient voltage waveform illustrating embodiments herein;
FIG. 6 is a flow diagram illustrating embodiments herein;
FIG. 7 is a flow diagram illustrating embodiments herein;
FIG. 8 is a schematic diagram of a circuit model that can be used with embodiments herein;
FIG. 9 is a schematic diagram of a hardware system according to embodiments herein;
FIG. 10 is a schematic diagram of a deployment system according to embodiments herein;
FIG. 11 is a schematic diagram of an integration system according to embodiments herein;
FIG. 12 is a schematic diagram of an on demand system according to embodiments herein;
FIG. 13 is a schematic diagram of a virtual private network system according to embodiments herein; and
FIG. 14 is a flow diagram illustrating embodiments herein.



DETAILED DESCRIPTION
The present embodiment relates to integrated circuit design, and more specifically, to methods, systems, and computers that provide decoupling capacitor optimization and allocation very early in the design process. While existing decoupling capacitor optimization methodologies typically require a power grid with detailed post layout information, or use lumped models that do not provide guidance for allocating decoupling capacitors to individual IP components, the method discusses these shortcomings by allowing for a pre-layout, per-IP-component decoupling capacitor optimization. This reduces churn in post-layout design stages, resulting in quicker time to market. The embodiment herein provides descriptions of the methods, systems, and computers that receive user specifications, technology definitions, and library element information, and compute a per-IP-component estimate of the amount of decoupling capacitors required to satisfy target voltage compression criteria.
The embodiment provides a building-block-based analysis where a “building block” is a constituent element of the design that is frequently designed independently of the other building blocks and which, when assembled with the other building blocks, constitute the overall chip design. This building-block-based approach to designing semiconductor integrated circuits is called “hierarchical” circuit design. Since the ultimate objective involves allocating a “correct” number of decoupling capacitors to each IP component within a building block, the method assumes that each building block contains one or more IP components. For each building block, the embodiments herein utilize the netlist content, but do not require detailed layout information.
This embodiment utilizes building-block-based decoupling capacitor optimization that targets decoupling capacitor allocation on a building-block-by-building-block basis, where each building block is considered and analyzed out-of-context, i.e., independently. There is no loss of generality in assuming a hierarchical design strategy. In a non-hierarchical design, the overall chip can be subdivided into constituent building blocks which can be analyzed out-of-context, in accordance with the described embodiments.
This method describes several steps for determining a per-IP-component decoupling capacitor allocation for a design building block. In a first step, the building-block circuit elements and their switching characteristics, the decoupling capacitor library content, any required technology rules, and the user specifications for process, voltage, temperature, power-supply compression target(s), etc., are assembled to appropriately model the electrical behavior of the building block. Next, the switching circuit elements of the region of the building block are collectively simulated to determine the total number of library decoupling capacitors required to satisfy the specified power-supply compression criteria. Subsequent simulations are then exercised to quantify a corresponding “normalized” decoupling capacitor requirement associated with each individual IP component. These simulations reflect a scenario where the IP component is switching independently of the other IP components in the building block. Finally, the normalized per-IP-component estimates are used to allocate a fraction of the total building-block decoupling capacitor to each IP component within the building block to satisfy its requirement.
As shown in the flowchart in FIG. 1, the process begins in item 500 and inputs data 502 such as building block circuits, building block current demand, library decoupling capacitor models, technology rules, process, voltage, and temperature compression target. In item 504, the process generates a list of IP components within the building block. Next, the process makes a list of ‘N’ IP components in the building block 506, and then proceeds to item 508 and generates a simulation netlist for the building block. The process then builds the block simulation netlist in item 510. In item 512, the process uses circuit simulation to compute the total decoupling capacitor quantity, CT, required to satisfy the compression target. In item 514, the process initializes the variable ‘n’ to one, to reference the first IP component in the list. Next, in item 516, the process generates a simulation netlist for IP component ‘n’. The process simulates the netlist for IP component ‘n’ in item 518. Next, the process uses circuit simulation to compute the decap quantity, Cn, required to satisfy the IP component compression target in item 520. The process proceeds to item 522 to determine if the decoupling capacitor quantities have been computed for each and every IP component in the list. If yes, the process proceeds to item 526 and uses the Cn values (n=1 . . . N) to allocate some fraction of CT to each IP component within the building block. If no, the process proceeds to item 524, increments ‘n’, and continues back to item 516. If yes, the process is finished in item 528.
FIGS. 2 and 3 provide graphical representations of some exemplary user interfaces, and illustrate some of the information and user-specified data required to generate the building block and IP component simulation models. In this example, it is assumed that embedded memory arrays are the principle power supply noise aggressors, and it is the objective of the described process to assign an adequate number of decoupling capacitors to each memory array to satisfy a specified voltage compression criteria. Thus, the building block memory arrays are the IP components of interest in this exemplary design exercise.
FIG. 2 illustrates an exemplary user interface 600 which prompts an input specification that describes or specifies the chip area, the static power demand of the block, an estimate of the block size, the block memory array content, the simulation time interval, the temperature, the power-supply compression target, a targeted decoupling capacitor library element, and the filename for the netlist or “deck” which will be provided as input to the circuit simulation program.
FIG. 3 illustrates an exemplary supplemental interface 602 which prompts for more detailed information on the IP components which comprise the building block (i.e., memory arrays), and also represent the switching circuits which generate power supply noise within the building block. This interface supports the specification of library rules for each memory array as well as the application-specific parameters which define the contextual operation of each memory array within the building block. These parameters include, but are not limited to, quantity, area, switching frequency, operating mode, etc.
The input specification provides the requisite information for constructing a simulation netlist or “deck” that includes electrical models for the building block, the corresponding package, and, optionally, the printed circuit board. An exemplary model topology is shown in FIG. 4.
The “building block” (400) portion of the model accounts for the block's intrinsic quiet capacitance, Ci,bb, the library decoupling capacitors, Mdecap,bb, the resistance of the on-chip power distribution, R3bb and R4bb, and the switching activity of the block's active circuits (modeled by the time-varying current source, ibb). The parasitic inductance and resistance of the package and, optionally, the printed circuit board, are indicated by L1bb and L2bb, and R1bb and R2bb, respectively. These component values are appropriately scaled to account for the estimated size of the building block.
The netlist is read by a circuit simulator, and a transient simulation is exercised to estimate the on-chip power-supply compression that occurs in response to the block's switching activity. Referring to FIG. 4, the on-chip power supply value is the (VDD−GND) potential difference, as measured between circuit nodes nv,bb and ng,bb. Compression is defined as the difference between the nominal and minimum VDD−GND potential. The nominal supply voltage value is demonstrated during “steady state”, prior to circuit switching, and the minimum voltage value occurs after a step in current demand, when on-die capacitance becomes depleted of the charge required to support the switching event. Note that the calculated compression can be expressed absolutely, in volts, or as a percentage of the nominal power supply.
FIG. 5 shows an exemplary on-die transient voltage waveform and illustrates the waveform metrics used to quantitatively determine the voltage compression. Exercising the block simulation, as described, only demonstrates a single level of power-supply compression that is characteristic of the model described in the simulation deck. Thus far, the process described herein does not provide the means to directly perform decoupling capacitor optimization. However, in order to achieve a pre-specified compression target, one can simply vary the number of decoupling capacitors in the block, iteratively, until the compression requirement is precisely satisfied. Note, that in FIG. 4, Mdecap,bb parameters in the simulation model can be easily adjusted to reflect any specified number of decoupling capacitors in the building block (to the extent that the number of added or removed decoupling capacitors significantly alter the size of the building block, other model parameters may also be modified to reflect this change).
In order to achieve a targeted power-supply compression, the embodiment first calculates the decoupling capacitance low and high bounds which produce power-supply compression above and below the target specification, respectively. As a starting point, the algorithm uses 0 F (farads) as a low bound and an arbitrary non-zero value for the high bound. The high bound value is employed in the simulation. In successive simulations, the prior value of decoupling capacitance is used as the low bound, and the high bound value is doubled. This process is exercised until the simulated building-block model is shown to satisfy the target limit by any margin. Valid low and high bounds have been identified when the power-supply compression corresponding to the low bound exceeds the specification, and the power-supply compression corresponding to the high bound is lower than the target.
Once the decoupling capacitance bounds have been identified, the algorithm employs a simulation “test” capacitance that is determined by computing the average of the high and low bounds. After the simulation model is adjusted to reflect the number of decoupling capacitors corresponding to the test capacitance, the simulation is exercised and the power-supply (VDD−GND) compression is calculated (refer, again, to FIG. 5). If the simulated compression is less than the target, but is not yet within some predetermined percentage of the compression specification (e.g. 1%, 2%, etc.), then the test capacitance becomes the new high bound for the subsequent simulation. Alternatively, if the test compression is larger than the target, then the test capacitance becomes the next low bound. At each simulation step, a new test capacitance is determined by computing the average of the high and low bounds. This process is repeated until the simulated (VDD−GND) compression is within a predetermined percentage of the compression target, and the final value of the test capacitance is used to compute the total number of required decoupling capacitors for the building block.
This process is illustrated in the flowchart in FIG. 6. In item 300, the process initializes the variable ‘n’ to one. Then, in item 301, the process selects an arbitrary non-zero quantity of decoupling capacitors, Csim,n. Next, in item 302, the process incorporates Csim,n into the simulation netlist. In item 304, the circuit is simulated and the voltage response is evaluated. As shown in item 306, if the resulting supply compression exceeds the target value, the process increments ‘n’ in item 312, doubles the number of decoupling capacitors in item 308, and proceeds back to item 302. If, in item 306, the supply compression does not exceed the target value, then a high bound of decoupling capacitors, Chigh, is set equal to Csim,n in item 310. Next, in item 316, if the supply compression has not previously been exceeded, the process proceeds to item 314 and the low bound of decoupling capacitors, Clow, is set to zero. Otherwise, the process proceeds to item 318 and Clow is set to Csim,n-1.
As illustrated in FIG. 7, the process converges on the final solution using a binary search methodology. The process calculates the “test” number of decoupling capacitors, Ctest, which is defined as the average of Chigh and Clow, in item 320. Next, Ctest is incorporated into the simulation netlist in item 322. The process then simulates the circuit and evaluates the voltage response in item 324. If the resulting supply compression exceeds the target value in item 326, the process proceeds to item 328, sets Clow to Ctest, and proceeds to item 320 to recalculate Ctest. If, in item 326, the supply compression does not exceed the target value, the process proceeds to item 330 to determine if the compression is within a specified percentage of the target. If no, the process proceeds to item 332, sets Chigh to Ctest, and proceeds to item 320 to recalculate Ctest. If yes, the process proceeds to item 334 and Ctest corresponds to the number of decoupling capacitors which satisfies the design objectives.
Table 1 (below) demonstrates a series of iterated simulations that are characteristics of the described embodiments. In an exemplary case, the building block is powered using a 1-volt VDD power supply and the design objective warrants adding decoupling capacitors to restrict the power-supply compression to 8% (=0.080V=80 mV). The iterative process is terminated (i.e., complete) when the simulated (VDD−GND) maximum power-supply compression is less than 80 mV, but does not deviate from the target by more than 1%.
In a first simulation (Solve #1 in Table 1), the high bound (and simulation decoupling capacitance) is arbitrarily chosen to be 619 nF. The compression criteria is not satisfied. In a second simulation (Solve #2), the low and high bounds are appropriately updated, and the simulation decoupling capacitance is doubled. The compression criteria is still not satisfied. In a third simulation (Solve #3), the simulation decoupling capacitance is again doubled, the bounds are adjusted in accordance with the described process, and the simulated compression is observed to be less than the 80 mV target.
At this point, the high and low bounds are appropriately established for the next simulation, Solve #4 in Table 1. In Solve #4, the method employs a simulation “test” capacitance that is determined by computing the average of the high and low bounds. The resulting power-supply compression is less than the 80-mV target, but deviates from the target by more than 1%. This implies that the model incorporates more decoupling capacitance than is really required. In this case, the test capacitance from Solve #4 becomes the high bound for Solve #5, the low bound remains the same, and the test capacitance is recomputed by computing the average of the low and high bounds. In Solve #5, the test capacitance is applied to the simulation model and the resulting compression is once again compared to the compression limit. The percentage by which the simulated compression deviates from the limit is also checked. Since the simulated (VDD−GND) compression is not within a predetermined percentage of the compression target, the process is continued, and more simulations are performed.
Finally, after 8 simulations, the simulated (VDD−GND) compression is within 1% of the compression target, and the final value of the test capacitance is used to compute the total number of required decoupling capacitors for the building block.

















Low 
High 
Test 
Simulated




Iterative
Capacitance
Capacitance
Capacitance 
Compression
Compression
Compression


Solve #
Bound (nF)
Bound (nF)
(nF)
(mV)
<80.0 mV ?
>79.2 mV ?





















1
0
619
619
155.9
No
Yes


2
619
1238
1238
113.2
No
Yes


3
1238
2476
2476
63.9
Yes
No


4
1238
2477
1858
70.8
Yes
No


5
1238
1858
1548
75.5
Yes
No


6
1238
1548
1393
78.9
Yes
No


7
1238
1393
1316
80.7
No
Yes


8
1316
1393
1355
79.8
Yes
Yes









The process described thus far calculate the required decoupling capacitor quantity for the entire building block, providing one summed total decoupling capacitor allotment for all of the IP components within the block. No capacitance-per-IP-block guidance is provided at this point.
In order to calculate the actual number of decoupling capacitors required for each IP component within the building block, the process first computes a so-called “normalized” worst-case decoupling capacitor requirement for each IP component. To calculate the normalized per IP component capacitor requirement, a set of iterative simulations are performed for each IP component, using models that are topologically equivalent to the one shown in FIG. 4.
In this case, and for each IP component, the process is used to construct a simulation netlist or “deck” that includes electrical models for the IP component, the corresponding package, and, optionally, the printed circuit board. An exemplary model topology for an exemplary IP component is shown in FIG. 8. The “IP component” (402) portion of the model accounts for the IP component's intrinsic quiet capacitance, Ci,ipc, the library decoupling capacitors, Mdecap,ipc, the resistance of the on-chip power distribution, R3ipc and R4ipc, and the switching activity of the IP component (modeled by the time-varying current source, Iipc). The parasitic inductance and resistance of the package and, optionally, the printed circuit board, are indicated by L1ipc and L2ipc, and R1ipc and R2ipc, respectively. These component values are appropriately scaled to account for the size of the individual IP component.
The netlist is read by a circuit simulator, and a transient simulation is exercised to estimate the on-chip power-supply compression that occurs in response to the IP component's switching activity. To achieve the pre-specified compression target, one then varies the number of decoupling capacitors allocated to the IP component, iteratively, until the compression requirement is precisely satisfied. To this end, the process first calculate the decoupling capacitance low and high bounds which produce power-supply compression above and below the target specification, respectively. As a starting point, the algorithm uses 0 F (farads) as a low bound. In successive simulations, decoupling capacitance is added to the low bound until the simulated IP-component model is shown to satisfy the target limit; this value then becomes the high bound. Valid low and high bounds have been identified when the power-supply compression corresponding to the low bound exceeds the specification, and the power-supply compression corresponding to the high bound is lower than the target.
Once the decoupling capacitance bounds have been identified, the algorithm employs a simulation “test” capacitance that is determined by computing the average of the high and low bounds. After the simulation model is adjusted to reflect the number of decoupling capacitors corresponding to the test capacitance, the simulation is exercised and the power-supply (VDD−GND) compression is calculated.
If the simulated compression is less than the target, but is not yet within some predetermined percentage of the compression specification (e.g., 1%, 2% etc.), then the test capacitance becomes the new high bound for the subsequent simulation. Alternatively, if the test compression is larger than the target, then the test capacitance becomes the next low bound. At each simulation step, a new test capacitance is determined by computing the average of the high and low bounds. This process is repeated until the simulated (VDD−GND) compression is within a predetermined percentage of the compression target, and the final value of the test capacitance is used to compute the total number of required decoupling capacitors assigned to the IP component under consideration.
This iterative, simulation-based process is repeated for each IP component in the building block, and yields a set of so-called “normalized” per-IP-component decoupling capacitor requirements. In order to calculate the actual, individual per-IP-component decoupling capacitor quantities, the summed total quantity determined for the entire building block is scaled on a per IP-component basis using the normalized per-IP-component decoupling capacitor requirements. As would be understood by those ordinarily skilled in the art, the process can use various scaling methods to distribute fractions of the total building-block quantity to the individual IP components which comprise the block.
In one straightforward example, a fraction of the total building-block decoupling capacitor quantity is allocated to each IP component in accordance with the relative ratios of the normalized per-IP-component values. In this exemplary case, refer to the total summed decoupling capacitor requirement for the entire building block as Ndecaps,Total. According to the process described herein, this quantity can be determined by collectively examining (in a first set of simulations) the switching activity of all of the IP components that comprise the building block. If IP components A, B, and C comprise the building block, subsequent IP-component simulations that independently and individually examine the switching activity of each IP component (i.e., a second set of simulations examining only component A, a third set of simulations examining only component B, and so forth) can be exercised to determine the normalized quantity of decoupling capacitors required for each IP component, N′decaps,A, N′decaps,B, and N′decaps,C. In a next step, the decoupling capacitor quantities determined in all of the simulations are used to formulate a scaling factor, k, where:

k=Ndecaps,Total/(N′decaps,A+N′decaps,B+N′decaps,C).

A final step allocates a fraction of the total building-block decoupling capacitor quantity to each IP component in accordance with the relative ratios of the normalized per-IP-component quantities, i.e.,

Ndecaps,A=k×N′decaps, A,

Ndecaps,B=k×N′decaps, B, and

Ndecaps,C=k×N′decaps,C,

where Ndecaps,A+Ndecaps,B+Ndecaps,C=Ndecaps,Total, and
Ndecaps,A, Ndecaps,B, and Ndecaps,C represent the final actual quantity of decoupling capacitors required for IP components A, B, and C, respectively.
The usefulness of this strategy is multifold. In addition to allowing one to estimate the total decoupling capacitor requirements for the entire building block, the process provides a means to appropriately distribute the decoupling capacitors to the individual IP components within the block. Moreover, since the process relies only on simple simulation models, and has no dependency on placement or layout information, the process provides guidance very early in the design process. Reliable early estimates for decoupling capacitor allocation are invaluable. Exercising the process can shorten the overall design cycle.
This method can be used in any conventional computer analysis. For example, a system built on a tcl programming language platform could utilize a SPICE simulator, and target (VDD−GND) compression. As would be understood by those ordinarily skilled in the art, the method can employ any circuit simulator (e.g., commercially available products like HSPICE, SPECTRE, ULTRASIM, etc.), can be applied to any power supply rail or power supply net, and can be implemented in any programming language, or manually. Block diagrams and generalized circuit schematic illustrations have been used to avoid obscuring the process, and the specifics of the design may be altered depending upon the specific implementation. While specific details are used to illustrate the process, the process should be apparent to one skilled in the art that alternate design details may achieve similar objectives.
As will be appreciated by one skilled in the art, aspects herein may be embodied as a system, method or computer program product. Accordingly, embodiments herein may take the form of an entirely hardware embodiment, an entirely software embodiment (including firmware, resident software, micro-code, etc.) or an embodiment combining software and hardware aspects that may all generally be referred to herein as a “circuit,” “module” or “system.” Furthermore, the embodiments may take the form of a computer program product embodied in one or more computer readable medium(s) having computer readable program code embodied thereon.
Any combination of one or more computer readable medium(s) may be utilized. The computer readable medium may be a computer readable signal medium or a computer readable storage medium. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples (a non-exhaustive list) of the computer readable storage medium would include the following: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or Flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this document, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device.
A computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device.
Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to wireless, wireline, optical fiber cable, RF, etc., or any suitable combination of the foregoing.
Computer program code for carrying out operations for aspects of the present embodiments may be written in any combination of one or more programming languages, including an object oriented programming language such as Java, Smalltalk, C++ or the like and conventional procedural programming languages, such as the “C” programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (for example, through the Internet using an Internet Service Provider).
Embodiments herein are described below with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to the embodiments herein. It will be understood that each block of the flowchart illustrations and/or D-2 block diagrams, and combinations of blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer readable medium that can direct a computer, other programmable data processing apparatus, or other devices to function in a particular manner, such that the instructions stored in the computer readable medium produce an article of manufacture including instructions which implement the function/act specified in the flowchart and/or block diagram block or blocks.
The computer program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other devices to cause a series of operational steps to be performed on the computer, other programmable apparatus or other devices to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide processes for implementing the functions/acts specified in the flowchart and/or block diagram block or blocks.
A representative hardware environment for practicing this process is depicted in FIG. 9. This schematic drawing illustrates a hardware configuration of an information handling/computer system in accordance with this process. The system comprises at least one processor or central processing unit (CPU) 10. The CPUs 10 are interconnected via system bus 12 to various devices such as a random access memory (RAM) 14, read-only memory (ROM) 16, and an input/output (I/O) adapter 18. The I/O adapter 18 can connect to peripheral devices, such as disk units 11 and tape drives 13, or other program storage devices that are readable by the system. The system can read the inventive instructions on the program storage devices and follow these instructions to execute the methodology of the embodiment. The system further includes a user interface adapter 19 that connects a keyboard 15, mouse 17, speaker 24, microphone 22, and/or other user interface devices such as a touch screen device (not shown) to the bus 12 to gather user input. Additionally, a communication adapter 20 connects the bus 12 to a data processing network 25, and a display adapter 21 connects the bus 12 to a display device 23 which may be embodied as an output device such as a monitor, printer, or transmitter, for example.
The flowchart and block diagrams in the Figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments herein. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems that perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.
Deployment Types include loading directly in the client, server and proxy computers via loading a storage medium such as a CD, DVD, etc. The process software may also be automatically or semi-automatically deployed into a computer system by sending the process software to a central server or a group of central servers. The process software is then downloaded into the client computers that will execute the process software. The process software is sent directly to the client system via e-mail. The process software is then either detached to a directory or loaded into a directory by a button on the e-mail that executes a program that detaches the process software into a directory. Send the process software directly to a directory on the client computer hard drive. When there are proxy servers, the process will, select the proxy server code, determine on which computers to place the proxy servers' code, transmit the proxy server code, then install the proxy server code on the proxy computer. The process software will be transmitted to the proxy server then stored on the proxy server.
While it is understood that the process software may be deployed by manually loading directly in the client, server and proxy computers via loading a storage medium such as a CD, DVD, etc., the process software may also be automatically or semi-automatically deployed into a computer system by sending the process software to a central server or a group of central servers. The process software is then downloaded into the client computers that will execute the process software. Alternatively the process software is sent directly to the client system via e-mail. The process software is then either detached to a directory or loaded into a directory by a button on the e-mail that executes a program that detaches the process software into a directory. Another alternative is to send the process software directly to a directory on the client computer hard drive. When there are proxy servers, the process will, select the proxy server code, determine on which computers to place the proxy servers' code, transmit the proxy server code, then install the proxy server code on the proxy computer. The process software will be transmitted to the proxy server then stored on the proxy server.
As shown in FIG. 10, Step 100 begins the deployment of the process software. The first thing is to determine if there are any programs that will reside on a server or servers when the process software is executed 101. If this is the case then the servers that will contain the executables are identified 209. The process software for the server or servers is transferred directly to the servers' storage via FTP or some other protocol or by copying though the use of a shared file system 210. The process software is then installed on the servers 211.
Next, a determination is made on whether the process software is be deployed by having users access the process software on a server or servers 102. If the users are to access the process software on servers then the server addresses that will store the process software are identified 103.
A determination is made if a proxy server is to be built 200 to store the process software. A proxy server is a server that sits between a client application, such as a Web browser, and a real server. The process intercepts all requests to the real server to see if it can fulfill the requests itself. If not, the process forwards the request to the real server. The two primary benefits of a proxy server are to improve performance and to filter requests. If a proxy server is required then the proxy server is installed 201. The process software is sent to the servers either via a protocol such as FTP, or the process is copied directly from the source files to the server files via file sharing 202. Another embodiment would be to send a transaction to the servers that contained the process software and have the server process the transaction, then receive and copy the process software to the server's file system. Once the process software is stored at the servers, the users via their client computers, then access the process software on the servers and copy to their client computers file systems 203. Another embodiment is to have the servers automatically copy the process software to each client and then run the installation program for the process software at each client computer. The user executes the program that installs the process software on his client computer 212 then exits the process 108.
In step 104 a determination is made whether the process software is to be deployed by sending the process software to users via e-mail. The set of users where the process software will be deployed are identified together with the addresses of the user client computers 105. The process software is sent via e-mail to each of the users' client computers. The users then receive the e-mail 205 and then detach the process software from the e-mail to a directory on their client computers 206. The user executes the program that installs the process software on his client computer 212 then exits the process 108.
Lastly, a determination is made on whether the process software will be sent directly to user directories on their client computers 106. If so, the user directories are identified 107. The process software is transferred directly to the user's client computer directory 207. This can be done in several ways such as but not limited to sharing of the file system directories and then copying from the sender's file system to the recipient user's file system or alternatively using a transfer protocol such as File Transfer Protocol (FTP). The users access the directories on their client file systems in preparation for installing the process software 208. The user executes the program that installs the process software on his client computer 212 then exits the process 108.
The process software is integrated into a client, server and network environment by providing for the process software to coexist with applications, operating systems and network operating systems software and then installing the process software on the clients and servers in the environment where the process software will function.
The first step is to identify any software on the clients and servers including the network operating system where the process software will be deployed that are required by the process software or that work in conjunction with the process software. This includes the network operating system that is software that enhances a basic operating system by adding networking features.
Next, the software applications and version numbers will be identified and compared to the list of software applications and version numbers that have been tested to work with the process software. Those software applications that are missing or that do not match the correct version will be upgraded with the correct version numbers. Program instructions that pass parameters from the process software to the software applications will be checked to ensure the parameter lists matches the parameter lists required by the process software. Conversely parameters passed by the software applications to the process software will be checked to ensure the parameters match the parameters required by the process software. The client and server operating systems including the network operating systems will be identified and compared to the list of operating systems, version numbers and network software that have been tested to work with the process software. Those operating systems, version numbers and network software that do not match the list of tested operating systems and version numbers will be upgraded on the clients and servers to the required level.
After ensuring that the software, where the process software is to be deployed, is at the correct version level that has been tested to work with the process software, the integration is completed by installing the process software on the clients and servers.
Referring to “Integration” Drawing FIG. 11, step 220 begins the integration of the process software. The first thing is to determine if there are any process software programs that will execute on a server or servers 221. If this is not the case, then integration proceeds to 227. If this is the case, then the server addresses are identified 222. The servers are checked to see if they contain software that includes the operating system (OS), applications, and network operating systems (NOS), together with their version numbers, that have been tested with the process software 223. The servers are also checked to determine if there is any missing software that is required by the process software 223.
A determination is made if the version numbers match the version numbers of OS, applications and NOS that have been tested with the process software 224. If all of the versions match and there is no missing required software the integration continues in 227.
If one or more of the version numbers do not match, then the unmatched versions are updated on the server or servers with the correct versions 225. Additionally if there is missing required software, then the process is updated on the server or servers 225. The server integration is completed by installing the process software 226.
Step 227 which follows either 221, 224 or 226 determines if there are any programs of the process software that will execute on the clients. If no process software programs execute on the clients the integration proceeds to 230 and exits. If this not the case, then the client addresses are identified 228.
The clients are checked to see if they contain software that includes the operating system (OS), applications, and network operating systems (NOS), together with their version numbers, that have been tested with the process software 229. The clients are also checked to determine if there is any missing software that is required by the process software 229.
A determination is made as to whether the version numbers match the version numbers of OS, applications and NOS that have been tested with the process software 231. If all of the versions match and there is no missing required software, then the integration proceeds to 230 and exits.
If one or more of the version numbers do not match, then the unmatched versions are updated on the clients with the correct versions 232. In addition, if there is missing required software then the process is updated on the clients 232. The client integration is completed by installing the process software on the clients 233. The integration proceeds to 230 and exits.
The process software can be stored on a shared file system accessible from one or more servers. The process software is executed via transactions that contain data and server processing requests that use CPU units on the accessed server. CPU units are units of time such as minutes, seconds, hours on the central processor of the server. Additionally the assessed server may make requests of other servers that require CPU units. CPU units are an example that represents but one measurement of use. Other measurements of use include but are not limited to network bandwidth, memory usage, storage usage, packet transfers, complete transactions etc. When multiple customers use the same process software application, their transactions are differentiated by the parameters included in the transactions that identify the unique customer and the type of service for that customer. All of the CPU units and other measurements of use that are used for the services for each customer are recorded. When the number of transactions to any one server reaches a number that begins to effect the performance of that server, other servers are accessed to increase the capacity and to share the workload. Likewise when other measurements of use such as network bandwidth, memory usage, storage usage, etc. approach a capacity so as to effect performance, additional network bandwidth, memory usage, storage etc. are added to share the workload. The measurements of use used for each service and customer are sent to a collecting server that sums the measurements of use for each customer for each service that was processed anywhere in the network of servers that provide the shared execution of the process software. The summed measurements of use units are periodically multiplied by unit costs and the resulting total process software application service costs are alternatively sent to the customer and or indicated on a web site accessed by the customer which then remits payment to the service provider. In another embodiment, the service provider requests payment directly from a customer account at a banking or financial institution. In another embodiment, if the service provider is also a customer of the customer that uses the process software application, the payment owed to the service provider is reconciled to the payment owed by the service provider to minimize the transfer of payments.
The process software is shared, simultaneously serving multiple customers in a flexible, automated fashion. The process is standardized, requiring little customization and the process is scalable, providing capacity on demand in a pay as-you-go model.
The process software can be stored on a shared file system accessible from one or more servers. The process software is executed via transactions that contain data and server processing requests that use CPU units on the accessed server. CPU units are units of time such as minutes, seconds, hours on the central processor of the server. Additionally the assessed server may make requests of other servers that require CPU units. CPU units are an example that represents but one measurement of use. Other measurements of use include but are not limited to network bandwidth, memory usage, storage usage, packet transfers, complete transactions etc.
When multiple customers use the same process software application, their transactions are differentiated by the parameters included in the transactions that identify the unique customer and the type of service for that customer. All of the CPU units and other measurements of use that are used for the services for each customer are recorded. When the number of transactions to any one server reaches a number that begins to effect the performance of that server, other servers are accessed to increase the capacity and to share the workload. Likewise when other measurements of use such as network bandwidth, memory usage, storage usage, etc. approach a capacity so as to effect performance, additional network bandwidth, memory usage, storage etc. are added to share the workload.
The measurements of use used for each service and customer are sent to a collecting server that sums the measurements of use for each customer for each service that was processed anywhere in the network of servers that provide the shared execution of the process software. The summed measurements of use units are periodically multiplied by unit costs and the resulting total process software application service costs are alternatively sent to the customer and or indicated on a web site accessed by the customer which then remits payment to the service provider.
In another embodiment, the service provider requests payment directly from a customer account at a banking or financial institution.
In another embodiment, if the service provider is also a customer of the customer that uses the process software application, the payment owed to the service provider is reconciled to the payment owed by the service provider to minimize the transfer of payments.
As shown in FIG. 12, Step 240 begins the On Demand process. A transaction is created that contains the unique customer identification, the requested service type and any service parameters that further specify the type of service 241. The transaction is then sent to the main server 242. In an On Demand environment the main server can initially be the only server, then as capacity is consumed other servers are added to the On Demand environment.
The server central processing unit (CPU) capacities in the On Demand environment are queried 243. The CPU requirement of the transaction is estimated, then the servers available CPU capacity in the On Demand environment are compared to the transaction CPU requirement to see if there is sufficient CPU available capacity in any server to process the transaction 244. If there is not sufficient server CPU available capacity, then additional server CPU capacity is allocated to process the transaction 248. If there was already sufficient Available CPU capacity then the transaction is sent to a selected server 245.
Before executing the transaction, a check is made of the remaining On Demand environment to determine if the environment has sufficient available capacity for processing the transaction. This environment capacity consists of such things as but not limited to network bandwidth, processor memory, storage etc. 246. If there is not sufficient available capacity, then capacity will be added to the On Demand environment 247. Next, the required software to process the transaction is accessed, loaded into memory, then the transaction is executed 249.
The usage measurements are recorded 250. The usage measurements consist of the portions of those functions in the On Demand environment that are used to process the transaction. The usage of such functions is, but not limited to, network bandwidth, processor memory, storage and CPU cycles are what is recorded. The usage measurements are summed, multiplied by unit costs and then recorded as a charge to the requesting customer 251. If the customer has requested that the On Demand costs be posted to a web site 252 then they are posted 253.
If the customer has requested that the On Demand costs be sent via e-mail to a customer address 254, then they are sent 255. If the customer has requested that the On Demand costs be paid directly from a customer account 256, then payment is received directly from the customer account 257. The last step is to exit the On Demand process.
The process software may be deployed, accessed and executed through the use of a virtual private network (VPN), which is any combination of technologies that can be used to secure a connection through an otherwise unsecured or untrusted network. The use of VPNs is to improve security and for reduced operational costs. The VPN makes use of a public network, usually the Internet, to connect remote sites or users together. Instead of using a dedicated, real-world connection such as leased line, the VPN uses “virtual” connections routed through the Internet from the company's private network to the remote site or employee.
The process software may be deployed, accessed and executed through either a remote-access or a site-to-site VPN. When using the remote-access VPNs the process software is deployed, accessed and executed via the secure, encrypted connections between a company's private network and remote users through a third-party service provider. The enterprise service provider (ESP) sets a network access server (NAS) and provides the remote users with desktop client software for their computers. The telecommuters can then dial a toll-free number or attach directly via a cable or DSL modem to reach the NAS and use their VPN client software to access the corporate network and to access, download and execute the process software.
When using the site-to-site VPN, the process software is deployed, accessed and executed through the use of dedicated equipment and large-scale encryption that are used to connect a companies multiple fixed sites over a public network such as the Internet.
The process software is transported over the VPN via tunneling which is the process of placing an entire packet within another packet and sending the process over a network. The protocol of the outer packet is understood by the network and both points, called tunnel interfaces, where the packet enters and exits the network.
As shown in FIG. 13, Step 260 begins the Virtual Private Network (VPN) process. A determination is made to see if a VPN for remote access is required 261. If the process is not required, then proceed to 262. If the process is required, then determine if the remote access VPN exists 264.
If the process does exist, then proceed to 265. Otherwise identify the third party provider that will provide the secure, encrypted connections between the company's private network and the company's remote users 276. The company's remote users are identified 277. The third party provider then sets up a network access server (NAS) 278 that allows the remote users to dial a toll free number or attach directly via a cable or DSL modem to access, download and install the desktop client software for the remote-access VPN 279.
After the remote access VPN has been built, or if the process has been previously installed, the remote users can then access the process software by dialing into the NAS or attaching directly via a cable or DSL modem into the NAS 265. This allows entry into the corporate network where the process software is accessed 266. The process software is transported to the remote user's desktop over the network via tunneling. That is, the process software is divided into packets, and each packet including the data and protocol is placed within another packet 267. When the process software arrives at the remote user's desktop, the process is removed from the packets, reconstituted, and then is executed on the remote users desktop 268.
A determination is made to see if a VPN for site to site access is required 262. If it is not required, then proceed to exit the process 263. Otherwise, determine if the site to site VPN exists 269. If it does exist, then proceed to 272. Otherwise, install the dedicated equipment required to establish a site to site VPN 270. Then build the large scale encryption into the VPN 271.
After the site to site VPN has been built, or if it had been previously established, the users access the process software via the VPN 272. The process software is transported to the site users over the network via tunneling. That is, the process software is divided into packets and each packet including the data and protocol is placed within another packet 274. When the process software arrives at the remote user's desktop, it is removed from the packets, reconstituted, and is executed on the site users desktop 275. Proceed to exit the process 263.
In FIG. 14, step 260 begins the Virtual Private Network (VPN) process. A determination is made to see if a VPN for remote access is required 261. If it is not required, then proceed to 262. If it is required, then determine if the remote access VPN exists 264. If it does exist, then proceed to 265. Otherwise, the embodiments identify the third party provider that will provide the secure, encrypted connections between the company's private network and the company's remote users 276. The company's remote users are identified 277. The third party provider then sets up a network access server (NAS) 278 that allows the remote users to dial a toll free number or attach directly via a cable or DSL modem to access, download and install the desktop client software for the remote-access VPN 279.
After the remote access VPN has been built or if it been previously installed, the remote users can then access the process software by dialing into the NAS or attaching directly via a cable or DSL modem into the NAS 265. This allows entry into the corporate network where the process software is accessed 266. The process software is transported to the remote user's desktop over the network via tunneling. That is, the process software is divided into packets and each packet including the data and protocol is placed within another packet 267. When the process software arrives at the remote user's desktop, it is removed from the packets, reconstituted and then is executed on the remote user's desktop 268.
A determination is made to see if a VPN for site to site access is required 262. If it is not required, then proceed to exit the process 263. Otherwise, determine if the site to site VPN exists 269. If it does exist, then proceed to 272. Otherwise, install the dedicated equipment required to establish a site to site VPN 270. Then build the large scale encryption into the VPN 271. After the site to site VPN has been built or if it had been previously established, the users access the process software via the VPN 272. The process software is transported to the site users over the network via tunneling. That is, the process software is divided into packets and each packet including the data and protocol is placed within another packet 274. When the process software arrives at the remote user's desktop, it is removed from the packets, reconstituted and is executed on the site user's desktop 275. Proceed to exit the process 263.
The terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of the method. As used herein, the singular forms “a”, “an” and “the” are intended to include the plural forms as well, unless the context clearly indicates otherwise. It will be further understood that the terms “comprises” and/or “comprising,” when used in this specification, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
The corresponding structures, materials, acts, and equivalents of all means or step plus function elements in the claims below are intended to include any structure, material, or act for performing the function in combination with other claimed elements as specifically claimed. The embodiments herein have been presented for purposes of illustration and description, but is not intended to be exhaustive or limited to the method disclosed. Many modifications and variations will be apparent to those of ordinary skill in the art without departing from the scope and spirit of the embodiment. The embodiment was chosen and described in order to best explain the principles of the method and the practical application, and to enable others of ordinary skill in the art to understand the method for various embodiments with various modifications as are suited to the particular use contemplated.

## Claims

1. A method of determining a required number of decoupling capacitors, and approximate locations for said decoupling capacitors, for a region of an integrated circuit, comprising:
entering switching elements of said region into a simulation program running on a computerized device;
entering a power-supply voltage compression target into said simulation program, said power-supply voltage compression target comprising a quantitative measure of a difference between a first power supply voltage value that occurs before a switching event and a second power supply voltage value that occurs during a switching event;
generating, using said simulation program, a total number of decoupling capacitors required to satisfy said compression target when all said switching elements concurrently switch; and
for each element of said switching elements:
generating, using said simulation program, a secondary number of decoupling capacitors required to satisfy said compression target when only said element switches;
calculating a fraction of said secondary number to said total number; and
placing said fraction of said total number of decoupling capacitors in electrical proximity to said element.

2. The method according to claim 1, said region comprising a building block of a hierarchical design of said integrated circuit.

3. The method according to claim 1, said compression target being specific to said region of said integrated circuit.

4. The method according to claim 1, said switching elements producing noise in said region.

5. The method according to claim 1, said switching elements comprising memory arrays.

6. The method according to claim 1, said electrical proximity comprising a predetermined distance measure.

7. A method of determining a required number of decoupling capacitors, and approximate locations for said decoupling capacitors, for a region of an integrated circuit, comprising:
entering switching elements of said region into a simulation program running on a computerized device;
entering a power-supply voltage compression target into said simulation program, said power-supply voltage compression target comprising a quantitative measure of a difference between a first power supply voltage value that occurs before a switching event and a second power supply voltage value that occurs during a switching event;
generating, using said simulation program, a total number of decoupling capacitors required to satisfy said compression target when all said switching elements concurrently switch; and
for each element of said switching elements:
generating, using said simulation program, a normalized number of decoupling capacitors required to satisfy said compression target when only said element switches;
calculating a fraction of said normalized number to said total number; and
placing said fraction of said total number of decoupling capacitors in electrical proximity to said element.

8. The method according to claim 7, said region comprising a building block of a hierarchical design of said integrated circuit.

9. The method according to claim 7, said compression target being normalized to said region of said integrated circuit.

10. The method according to claim 7, said switching elements producing noise in said region.

11. The method according to claim 7, said switching elements comprising memory arrays.

12. The method according to claim 7, said electrical proximity comprising a predetermined distance measure.

13. A method of determining a required number of decoupling capacitors, and approximate locations for said decoupling capacitors, for a region of an integrated circuit, comprising:
entering switching elements of said region into a simulation program running on a computerized device;
entering a power-supply voltage compression target into said simulation program, said power-supply voltage compression target comprising a quantitative measure of a difference between a first power supply voltage value that occurs before a switching event and a second power supply voltage value that occurs during a switching event;
generating, using said simulation program, a total number of decoupling capacitors required to satisfy said compression target when all said switching elements concurrently switch; and
for each element of said switching elements iteratively until said power-supply voltage compression target is satisfied:
generating, using said simulation program, a normalized number of decoupling capacitors required to satisfy said compression target when only said element switches;
calculating a fraction of said normalized number to said total number; and
placing said fraction of said total number of decoupling capacitors in electrical proximity to said element.

14. The method according to claim 13, said region comprising a building block of a hierarchical design of said integrated circuit.

15. The method according to claim 13, said compression target being normalized to said region of said integrated circuit.

16. The method according to claim 13, said switching elements producing noise in said region.

17. The method according to claim 13, said switching elements comprising memory arrays.

18. The method according to claim 13, said electrical proximity comprising a predetermined distance measure.

19. A computer storage device comprising a non-transitory, computer-readable storage medium storing instructions executable by a computer to perform a method of determining a required number of decoupling capacitors, and approximate locations for said decoupling capacitors, for a region of an integrated circuit, comprising:
entering switching elements of said region into a simulation program running on a computerized device;
entering a power-supply voltage compression target into said simulation program, said power-supply voltage compression target comprising a quantitative measure of a difference between a first power supply voltage value that occurs before a switching event and a second power supply voltage value that occurs during a switching event;
generating, using said simulation program, a total number of decoupling capacitors required to satisfy said compression target when all said switching elements concurrently switch; and
for each element of said switching elements:
generating, using said simulation program, a specific number of decoupling capacitors required to satisfy said compression target when only said element switches;
calculating a fraction said specific number is to said total number; and
placing said fraction of said total number of decoupling capacitors in electrical proximity to said element.

20. The computer storage device according to claim 19, said region comprising a building block of a hierarchical design of said integrated circuit.

21. The computer storage device according to claim 19, said compression target being specific to said region of said integrated circuit.

22. The computer storage device according to claim 19, said switching elements producing noise in said region.

23. The computer storage device according to claim 19, said switching elements comprising memory arrays.

24. The computer storage device according to claim 19, said electrical proximity comprising a predetermined distance measure.