Cycles Per Instruction Formula: CPI Explained With Worked Examples

Short answer

• The cycles per instruction formula, usually shortened to CPI, is: CPI equals total clock cycles divided by total instructions executed. In symbols, CPI = C / I, where C is the total number of clock cycles used by a program and I is the total number of instructions that program executed. The result is read as cycles per instruction. For example, if a program uses 840,000 clock cycles to execute 350,000 instructions, its CPI is 840,000 divided by 350,000, which equals 2.4 cycles per instruction. That division is the whole formula, but it is easy to use badly. CPI is an average over a whole program, not a fixed property of one instruction or of a processor on its own, because instructions take different numbers of cycles, programs mix them in different proportions, and stalls add extra cycles. A correct CPI answer therefore always says what program, what instruction count, and what cycle count it came from.

What a Clock Cycle Is, and What an Instruction Is

A processor works to a steady beat called a clock. Each beat is one clock cycle, and the clock rate tells how many beats happen each second. A clock rate of 3 gigahertz (GHz) means 3 billion cycles per second. The time taken by one cycle, called the cycle time, is the reciprocal of the clock rate. At 3 GHz, one cycle takes 1 divided by 3 billion seconds, about 0.33 nanoseconds. At 2 GHz, one cycle takes 0.5 nanoseconds. A faster clock means shorter cycles, but not necessarily fewer cycles per instruction.

An instruction is one basic operation the processor is told to carry out, such as adding two numbers held in registers, loading a value from memory, or branching to a different part of the program. The number that actually run when a program executes is the dynamic instruction count. This matters because a loop running 100 times executes its body instructions 100 times, even though they appear only once in the written program, whose count is the static count. The CPI formula uses the dynamic count, because the cycles were spent executing those instructions.

CPI counts cycles, not seconds. Two programs can share a CPI and still differ greatly in running time if one executes far more instructions or runs at a different clock rate. CPI, instruction count, and clock rate are three separate factors, and performance depends on all three together, as the performance equation below shows.

The Basic Formula, Stated Carefully

The basic formula is:

CPI = total clock cycles / total instructions executed

Both quantities must describe the same run of the same program on the same machine. If the cycle count comes from one program and the instruction count comes from another, the division is meaningless. If the instruction count is the static count rather than the dynamic count, the result will usually be wrong, because loops and branches change how many instructions actually run.

The units help to check the work. Cycles divided by instructions gives cycles per instruction, so a CPI of 2.4 means that, on average across that program, each executed instruction accounted for 2.4 clock cycles. It does not mean every instruction took 2.4 cycles: no single instruction takes a fractional number of cycles. The fraction appears only because CPI averages whole cycle counts over many instructions.

University teaching material on this point is explicit. The University of California, San Diego slides describe CPI as a ratio, the cycles required to execute a program divided by the instruction count for that program, and stress that it is an average. The King Fahd University lectures likewise define CPI as an average number of clock cycles per instruction, and show it changing with the instruction mix. A single CPI number with no program attached should therefore be treated as shorthand at best.

Worked Example 1: The Basic Division

Suppose a program runs on a processor and a hardware counter records 840,000 clock cycles and 350,000 executed instructions. Find the CPI.

Step 1: Write down the formula. CPI = total clock cycles / total instructions.

Step 2: Substitute the numbers. CPI = 840,000 / 350,000.

Step 3: Divide. 350,000 multiplied by 2 equals 700,000. The remainder is 140,000. 140,000 divided by 350,000 equals 0.4. So the result is 2 plus 0.4, which is 2.4.

Answer: CPI = 2.4 cycles per instruction.

Check the answer by working backward. If CPI is 2.4 and 350,000 instructions executed, total cycles should be 350,000 multiplied by 2.4. That is 700,000 plus 140,000, which equals 840,000, matching the recorded count. Working backward catches the most common slip here, which is dividing the wrong way around and getting instructions per cycle instead of cycles per instruction.

A second quick check uses round numbers: 200 million cycles divided by 50 million instructions equals a CPI of 4. The formula itself is simple. The skill lies in getting the right cycle count and the right instruction count.

Why One Instruction Does Not Have One CPI

If every instruction took the same number of cycles, CPI would be a constant and this article would be short. In practice, instructions differ widely. Simple integer addition on values already held in registers is fast. Multiplication takes longer than addition. Floating point division and square root take longer still. Loading a value from memory can be fast if the value is already in a nearby cache, and very slow if the processor must wait for main memory. A branch can be cheap if the processor guessed its direction correctly, and expensive if it guessed wrong and must discard work already done.

The University of California, San Diego slides illustrate this spread with figures for one Intel Nehalem processor: integer addition, subtraction, and branches at 1 cycle; integer multiplication at 3 to 5 cycles; integer division at 11 to 100 cycles; floating point division and square root at 7 to 27 cycles; and loads and stores at 1 cycle to hundreds of cycles, depending on where the data is found. Those figures are for one older processor under stated conditions, so they must not be quoted as current figures for a modern chip. Their value is the shape of the picture: a range from 1 cycle to hundreds of cycles, not a single number.

Two programs on the same processor can therefore report very different CPI values: one dominated by simple register arithmetic will have a low average CPI, while one dominated by cache missing loads or divisions will have a high one. Neither result says the processor changed. The work changed. A CPI comparison is only fair when the workloads are comparable, ideally the same program on different machines.

Average CPI: The Weighted Average Formula

Most coursework questions do not give totals directly. Instead they give an instruction mix: the share of each instruction class in the program, and the cycles per instruction for each class. Average CPI is then a weighted average, with each class weighted by how often it occurs.

The average CPI formula is:

Average CPI = sum over each class of (fraction of instructions in that class multiplied by CPI of that class)

In plainer form: for each instruction class, multiply its share of the program by its cycles per instruction, then add all the results together. The shares must add up to 1, or to 100 percent, because every executed instruction belongs to exactly one class in the breakdown. If the shares add up to anything else, a class is missing, a class is counted twice, or a percentage has been mistaken for a fraction.

An equivalent form uses counts instead of fractions: total cycles equal the sum over all classes of count multiplied by class CPI, and average CPI equals that total divided by the total instruction count. Use whichever form matches the data given, and never mix counts and fractions in the same sum.

Note also that a class share of instructions is not its share of time. The time share for a class equals its fraction multiplied by its CPI, divided by the average CPI, which is why improving a frequent but cheap class may matter less than improving a rarer but expensive one.

Worked Example 2: Average CPI From an Instruction Mix

Suppose a program has the following instruction mix. All figures in this example are illustrative, chosen to make the arithmetic easy to follow, not measurements from a real processor.

Instruction class	Share of instructions	Cycles per instruction for that class
Integer arithmetic	60 percent	1
Load from memory	25 percent	4
Store to memory	5 percent	3
Branch	10 percent	2

Step 1: Convert each percentage to a fraction. 60 percent is 0.60, 25 percent is 0.25, 5 percent is 0.05, and 10 percent is 0.10. Check that the fractions add up to 1: 0.60 plus 0.25 plus 0.05 plus 0.10 equals 1.00.

Step 2: Multiply each fraction by its class CPI. Integer arithmetic contributes 0.60 multiplied by 1, which equals 0.60. Loads contribute 0.25 multiplied by 4, which equals 1.00. Stores contribute 0.05 multiplied by 3, which equals 0.15. Branches contribute 0.10 multiplied by 2, which equals 0.20.

Step 3: Add the contributions. 0.60 plus 1.00 equals 1.60. Adding 0.15 gives 1.75. Adding 0.20 gives 1.95.

Answer: Average CPI = 1.95 cycles per instruction.

Notice what the breakdown reveals. Loads are only a quarter of the instructions, but they contribute 1.00 of the 1.95 total, just over half of all cycles, while integer arithmetic at 60 percent of instructions contributes only 0.60. Reducing load cost would therefore matter far more than shaving a fraction off integer arithmetic.

As a cross check, the same method reproduces a standard textbook example: 50 percent arithmetic at 1 cycle, 20 percent loads at 5 cycles, 10 percent stores at 3 cycles, and 20 percent branches at 2 cycles gives 0.50 plus 1.00 plus 0.30 plus 0.40, an average CPI of 2.2.

Pipelined CPI: Base CPI Plus Stall Cycles

Modern processors do not finish one instruction completely before starting the next. They use pipelining, which splits execution into stages, such as fetching, decoding, executing, accessing memory, and writing back a result, and works on several instructions at once, one in each stage. In an ideal pipeline with no delays, one instruction completes every cycle, so the ideal CPI is 1. Real pipelines stall: a stall is a cycle in which no new instruction completes because the pipeline must wait for data, for a memory access, or because a branch was predicted wrongly and work must be thrown away.

For a pipelined processor, a useful form of the formula is:

CPI = base CPI + stall cycles per instruction

The base CPI is the CPI with no stalls, which is 1 for a simple ideal pipeline that completes one instruction per cycle. Stall cycles per instruction is itself a weighted sum: for each cause of stalls, multiply how often that cause occurs per instruction by how many cycles each occurrence costs, then add the results.

Worked example 3 uses illustrative figures. Suppose a pipelined processor has an ideal CPI of 1. Suppose 25 percent of instructions are loads that stall the pipeline by 1 extra cycle each, and 10 percent of instructions are branches that stall the pipeline by 2 extra cycles each.

Step 1: Compute the load stall contribution. 0.25 multiplied by 1 equals 0.25 stall cycles per instruction on average.

Step 2: Compute the branch stall contribution. 0.10 multiplied by 2 equals 0.20 stall cycles per instruction on average.

Step 3: Add the contributions to the base CPI. CPI = 1 plus 0.25 plus 0.20, which equals 1.45.

Answer: CPI = 1.45 cycles per instruction.

Two cautions apply. First, the base CPI is not always 1: a processor completing more than one instruction per cycle can have a base below 1, and a simple multicycle design has a base above 1. Second, stall frequencies must be per instruction, not per load or per branch. If loads are 30 percent of instructions and half of loads stall, then stalled loads are 15 percent of all instructions, and that 15 percent is the frequency to use.

The CPU Performance Equation: CPI, Instruction Count, and Clock Rate Together

CPI on its own does not give running time. Running time needs two more factors: how many instructions execute, and how long each cycle takes. The combination is called the CPU performance equation, and it is the most important equation in this article after the CPI formula itself.

CPU time = instruction count multiplied by CPI multiplied by cycle time

Since cycle time equals 1 divided by clock rate, the same equation can be written as:

CPU time = instruction count multiplied by CPI divided by clock rate

A program that executes more instructions takes longer, all else being equal, as does a program with a higher CPI, while a faster clock shortens the time. The phrase “all else being equal” does real work, because changing one factor often changes another: raising the clock rate can force more pipeline stages and extra stalls, raising CPI, while cutting instruction count can raise CPI if the remaining instructions are more complex.

Worked example 4 applies the equation with illustrative figures. Suppose a program executes 500 million instructions, its average CPI is 1.8, and the clock rate is 3 GHz. Total cycles = 500 million multiplied by 1.8, which equals 900 million cycles. CPU time = 900 million divided by 3 billion cycles per second, which equals 0.3 seconds.

Step 1: Compute total cycles. Total cycles = instruction count multiplied by CPI = 500 million multiplied by 1.8, which equals 900 million cycles.

Step 2: Convert clock rate to cycles per second. 3 GHz equals 3 billion cycles per second.

Step 3: Divide cycles by cycles per second. CPU time = 900 million divided by 3 billion, which equals 0.3 seconds.

Answer: CPU time = 0.3 seconds.

Worked example 5 shows why clock rate alone is a poor guide to speed. Suppose two implementations run the same program, so instruction count cancels out. Machine A has a clock rate of 2.5 GHz and a CPI of 1.6. Machine B has a clock rate of 4 GHz and a CPI of 2.8. CPU time is proportional to CPI divided by clock rate: 1.6 divided by 2.5 equals 0.64 for A, and 2.8 divided by 4 equals 0.70 for B. The smaller number means less time, so A is faster, by 0.70 divided by 0.64, about 1.09 times. This matches a standard lecture example in which 2.2 multiplied by 250 equals 550 against 1.0 multiplied by 500 equals 500, and the smaller product wins.

CPI, IPC, MIPS, and Clock Speed: How the Measures Relate

Instructions per cycle, shortened to IPC, is the reciprocal of CPI: IPC = 1 / CPI. If CPI is 2.5, IPC is 0.4; if CPI is 0.8, IPC is 1.25. An IPC above 1 is possible only on a processor completing more than one instruction per cycle on average. The common error is reporting one while labeling it the other: larger CPI means slower per instruction, while larger IPC means faster per cycle.

Instructions per second, and its scaled form MIPS (millions of instructions per second), bring clock rate into the picture. Instructions per second = clock rate divided by CPI. At 3 GHz and a CPI of 2, that is 3 billion divided by 2, which is 1.5 billion instructions per second, or 1,500 MIPS. The textbook warning is that MIPS can mislead when instruction sets differ: the King Fahd University lectures give a case in which a second compiler scores 3,200 MIPS against 2,800, yet takes 3.75 seconds against 2.5 seconds, because it executes more instructions in total. MIPS is a rate, not a time.

Clock speed, or clock rate, is neither CPI nor IPC. It is cycles per second, and a higher rate shortens each cycle without reducing the cycles each instruction needs. A processor at 5 GHz with a CPI of 4 executes 1.25 billion instructions per second, while one at 3 GHz with a CPI of 1.5 executes 2 billion per second. The slower clock wins, because its CPI advantage outweighs its clock disadvantage.

What Raises CPI and What Lowers It

CPI rises when the processor must wait or redo work. The main causes are memory delays, data dependencies, and branch mispredictions.

Memory delays are usually the largest cause. A load that finds its data in the fastest cache costs few cycles, while a load that misses every cache and must wait for main memory can cost tens or hundreds of cycles, during which the pipeline may stall. Programs that stream through large data sets with little reuse therefore tend to show high CPI, not because their arithmetic is slow, but because they spend much of their time waiting for data.

Data dependencies, also called hazards, occur when an instruction needs a result that an earlier instruction has not finished producing. The pipeline must either wait for the result or forward it directly from one stage to another where the design allows forwarding. Where neither fully hides the delay, stall cycles appear and CPI rises.

Branch mispredictions occur when the processor guesses which way a branch will go, starts executing down the guessed path, and then discovers the guess was wrong. The wrongly started work must be discarded and the correct path started instead, at a cost of several cycles per misprediction.

CPI falls when any of those waits shrink: better caches, more accurate branch prediction, forwarding paths, and parallel execution units. But deeper pipelines that raise clock rate can increase the misprediction penalty, raising CPI. An improvement counts only if the product of instruction count, CPI, and cycle time actually falls.

How to Use the Formula in Coursework: A Checklist

Most CPI errors are setup errors, made before any division happens. First, identify what the question asks for: basic CPI from totals, average CPI from a mix, pipelined CPI from stall data, or CPU time from the performance equation. Each form needs different inputs. Second, check that cycle counts and instruction counts describe the same program run, and note whether a static count is being used as a stated simplification. Third, convert percentages to fractions before multiplying, and check that the fractions sum to 1. Fourth, keep CPI and IPC the right way around: a CPI below 1 on a simple single issue pipeline is usually IPC mislabeled as CPI. Fifth, convert clock units before dividing: gigahertz means billions of cycles per second and megahertz means millions, so mixing them produces an answer wrong by a factor of 1,000 or 1,000,000. Sixth, work backward to verify: multiply the claimed CPI by the instruction count and check that the total cycles match. Seventh, state the assumptions: the program or mix, whether the count is dynamic, whether stalls are included, and whether the figures are measured or illustrative.

Common Misconceptions, Answered Directly

Misconception 1: CPI is a fixed number for a processor. Correction: CPI is an average over a program on a processor, so changing the program changes CPI.

Misconception 2: A lower CPI always means a faster computer. Correction: speed depends on instruction count, CPI, and clock rate together.

Misconception 3: A higher clock rate always means a faster computer. Correction: clock rate is only one factor, as worked example 5 shows.

Misconception 4: CPI counts the cycles for a single instruction. Correction: a single instruction has an individual cycle count or latency. CPI averages those counts over a whole program.

Misconception 5: CPI below 1 is impossible. Correction: CPI below 1 means IPC above 1, which is normal for processors that complete several instructions per cycle, though impossible on a design that completes at most one instruction per cycle.

Misconception 6: Adding more pipeline stages always lowers CPI. Correction: an ideal pipeline has a CPI of 1 regardless of stage count. Adding stages can raise clock rate but also increases stall penalties, for example after a branch misprediction.

Misconception 7: MIPS and CPI rank machines the same way. Correction: MIPS rewards executing many instructions quickly, so a machine can score higher on MIPS and still take longer on the same task.

Misconception 8: CPI and execution time are interchangeable. Correction: CPI has units of cycles per instruction, while execution time has units of seconds. They are related through instruction count and clock rate, but neither substitutes for the other without those two factors.

Frequently Asked Questions

What is the cycles per instruction formula?

CPI equals total clock cycles divided by total instructions executed, written as CPI = C / I. For example, 840,000 cycles divided by 350,000 instructions equals a CPI of 2.4. For an instruction mix, average CPI is the weighted sum of each class share multiplied by that class CPI.

How do you calculate average CPI?

Convert each class share to a fraction, multiply each fraction by its class CPI, and add the results. For example, 60 percent at 1 cycle, 25 percent at 4 cycles, 5 percent at 3 cycles, and 10 percent at 2 cycles gives 0.60 plus 1.00 plus 0.15 plus 0.20, which equals 1.95. Check that the shares add up to 100 percent before multiplying.

What is the difference between CPI and IPC?

CPI and IPC are reciprocals, so IPC = 1 / CPI. A CPI of 2.5 corresponds to an IPC of 0.4, and a CPI of 0.8 corresponds to an IPC of 1.25. Larger CPI means slower per instruction, while larger IPC means faster per cycle.

What is a good CPI value?

There is no single good value, because CPI depends on the program and the design. Near 1 is ideal for a simple pipeline with no stalls, below 1 is normal for a processor completing several instructions per cycle, and several cycles is normal for a simple multicycle processor with no pipelining.

How does CPI relate to CPU time?

CPU time equals instruction count multiplied by CPI divided by clock rate. For example, 500 million instructions at a CPI of 1.8 on a 3 GHz processor take 900 million cycles divided by 3 billion cycles per second, which equals 0.3 seconds.

Can CPI be less than 1?

Yes, on a processor that completes more than one instruction per cycle on average, since CPI = 1 / IPC. On a simple processor that completes at most one instruction per cycle, CPI cannot fall below 1.

Why does CPI change between programs on the same processor?

Because programs use different instruction mixes and suffer different stall patterns. The processor is unchanged. The work it is asked to do has changed.

What is the pipelined CPI formula?

CPI equals base CPI plus stall cycles per instruction. For an ideal pipeline completing one instruction per cycle, the base is 1, so a base of 1 plus 0.25 from load stalls plus 0.20 from branch stalls gives a CPI of 1.45.

Does a higher GHz processor always have a lower CPI?

No. Clock rate and CPI are separate factors. The faster machine is the one with the smaller value of CPI divided by clock rate for the same instruction count, not the one with the higher clock rate alone.

Should I use CPI or MIPS to compare two processors?

Use execution time on the same task for a fair comparison, and use CPI with instruction count and clock rate to explain why that time differs. MIPS alone can mislead, because it rewards executing more instructions.

Sources & references

• University of California, San Diego, CSE 141, "Measuring and Reasoning About Performance" slides, opened and read for the performance equation (latency equals instruction count multiplied by cycles per instruction multiplied by seconds per cycle), the definition of CPI as a ratio and an average rather than the cycles for one instruction, the Nehalem cycle ranges for integer, floating point, load and store instructions, and the worked average CPI calculation of (5 multiplied by 44 plus 1 multiplied by 52 plus 1 multiplied by 21) divided by 117, which equals 2.504.
• King Fahd University of Petroleum and Minerals, ICS 233, "Performance" lectures by Muhamed Mudawar, adapted by Aiman El-Maleh, opened and read for CPI defined as an average number of clock cycles per instruction, the performance equation (time equals instruction count multiplied by CPI multiplied by cycle time), the class based CPI derivation, the two code sequence example (10 cycles over 5 instructions equals a CPI of 2, and 9 cycles over 6 instructions equals a CPI of 1.5), the instruction mix example giving an average CPI of 2.2, the A versus B machine comparison (550 against 500, B faster by a factor of 1.1), and the MIPS warning example (3,200 MIPS with a 3.75 second time against 2,800 MIPS with a 2.5 second time).
• Search results read on 27 Oct 2026 for the literal phrase "cycles per instruction formula" (see the SERP determination at the end of this article) and for supporting background on calculator and explainer pages presenting CPI as total cycles divided by total instructions. No figure, quotation, or worked example in this article was copied from those calculator pages. All worked examples in the article are original illustrative calculations, checked by the writer by working backward from the stated answers.