Main Memory and CPU Data Movement

Registers are small CPU memory units that hold individual numbers for immediate access.

Programming

Storage and Processing Inside the CPU

When a processor needs to work with numbers, two of its resources have different jobs. One job is holding data. The other job is operating on that data. Thinking of the CPU as a combination of temporary storage and a processing unit makes it much easier to follow what happens when a program runs. In this article you will trace a value as it moves from main memory into the processor, gets combined with another value, and is kept again as a result.

The two resources are the registers, which provide small, immediately accessible places for holding data values, and the Arithmetic Logic Unit, usually called the ALU, which performs operations on those values. Keep both roles in mind as you read: registers hold, and the ALU computes.

Registers: Small and Immediately Accessible

Definition

A register is a small CPU memory unit that holds an individual number for immediate access.

The key word in that definition is immediate. A register is part of the processor itself, so the processor can use the value it holds without first going out to fetch it from somewhere else. This is why registers are the places where values are placed when processing needs to happen. Each register holds one individual value at a time, and that value is what an instruction works with.

Because the contents of a register are immediately accessible to the processor, a computation does not have to wait on a long trip to a separate storage area each time it needs an operand. The values a calculation uses are arranged in registers first, and then the processing unit operates on them.

The ALU Performs the Operations

Definition

The Arithmetic Logic Unit, or ALU, is the processor component that carries out arithmetic and logical operations on values.

The ALU does not decide what a program is for, and it does not keep long-term records of values. Its job is to take the values it is given and perform the requested operation on them. The values it works on come from registers, and the result it produces is then placed in a register. Notice the division of labor: the ALU computes, while registers hold both the inputs and the outputs.

Tracing a Two-Register Addition

One instruction can specify two registers as the sources of its operation, ask the ALU to add their values, and identify a register for the result. The following example walks through that pattern using invented values so you can follow each state change.

Worked example

Adding two register values into a third register

Register A holds 5 and register B holds 3. An instruction names A and B as the sources, asks the ALU to add them, and names register C as the destination. What does register C hold afterward?

1
Identify the source registers
The instruction names register A and register B as the two sources, so their current values, 5 and 3, are the inputs to the operation.
2
Send both values to the ALU
The values from the two source registers are directed into the ALU. Neither value has to be fetched from main memory, because both already sit in registers.
3
Perform the addition
The ALU performs the arithmetic operation on 5 and 3, producing 8.
4
Place the result in the destination register
The result, 8, is placed in register C, the register the instruction identified for the result. Registers A and B still hold 5 and 3, because they were only sources.

Result

Register C holds 8. Registers A and B are unchanged. The values were combined by the ALU and the result was kept in a register.

What happens step by step when an instruction takes the values in two source registers, adds them in the ALU, and returns the result to a destination register? Source values 5 and 3 are invented for this example.

Read the diagram from left to right. Both source registers feed the ALU, the ALU produces one result, and that result is returned to a register. The diagram shows only the flow of values. The prose above is the part that explains why the sources could be used directly: they were already in registers.

Moving Values Between Memory and Registers

Calculations do not always start with values already sitting in registers. Values can be copied between main memory and registers as part of instruction execution. Machine language instructions connect the storage role of registers with the processing role of the ALU. Some instructions copy a data value from main memory into a register, and other instructions copy a value from a register back into main memory.

Taken together, these instructions form a practical pattern: obtain a value, place it where processing can access it, perform an operation, and preserve the result in a register or in memory. Movement is what gets a value from storage into the processor and what gets a result back out to storage.

What changes step by step when an instruction loads a value from main memory into a register, and when a later instruction stores a register value back to main memory? The value 5 is an invented example.

The diagram traces one value through the full cycle. The load instruction copies the value into a register, which is the point where the processor can use it. The store instruction then copies a value from the register back into main memory, so the result is preserved outside the processor. In a real program, an operation such as the addition from the previous section would sit between these two movements.

How the CPU Parts Connect

The pieces discussed so far fit together into one picture. The registers and the ALU are both resources inside the CPU. Main memory is the store that instructions copy values to and from. The concept map below shows how these parts relate.

What is contained inside the CPU, what sits outside it, and how are the registers, the ALU, and main memory connected?

Registers Versus Main Memory

A useful way to read data movement is to compare the two places a value can live. The table summarizes the distinctions that the source material makes explicit. Registers are small and immediately accessible to the processor, while main memory is where values are copied to and from through instructions.

Feature	Registers	Main memory
Role	Hold individual values for the processor	Holds values that instructions copy to and from registers
Location relative to processing	Part of the CPU, directly available to the ALU	Reached by copying values into or out of registers
Size	Small	Source and destination for values copied through instructions
Access by the processor	Immediate	Requires a load or store instruction to move a value

Registers and main memory, as described in the source material

Mistakes When Reading Data Movement

Common mistake
Thinking the ALU stores values
Why it fails
The ALU carries out arithmetic and logical operations. The values it works with and the results it produces are held in registers.
Do this instead
Treat the ALU as the computing step and registers as the holding places for its inputs and outputs.
Common mistake
Assuming every value must come from main memory before it can be added
What it looks like
Registers A and B already hold 5 and 3, so an instruction can send them straight to the ALU.
Why it fails
Registers are immediately accessible to the processor, so a value already in a register does not need to be copied from main memory first.
Do this instead
Check whether the operands are already in registers. Only values that are not yet in registers need a load instruction.
Common mistake
Believing a store overwrites the register with the memory value
What it looks like
A store instruction copies the register's value into main memory.
Why it fails
A store copies a value from a register into main memory. The data direction is from the register outward.
Do this instead
Read load as memory to register and store as register to memory.
Common mistake
Forgetting that the destination register is where the result of an ALU operation is kept

Practice Tracing Data Movement

What do you think happens?

Register A holds 4 and register B holds 6. An instruction adds A and B and places the result in register C. What does register C hold?

Reveal answer

Answer:

The ALU receives the values 4 and 6 from registers A and B, performs the addition to get 10, and the instruction places that result in register C. Registers A and B keep their values.

MEDIUM

Trace this sequence on paper. First, a load instruction copies the value 7 from main memory into register A. Then a second value, 2, is already in register B. An instruction adds A and B and places the result in register C. Finally, a store instruction copies the value in register C into main memory. Describe what each register and the main memory hold after each step, and say which step used the ALU.

Hints

Track each register separately and write down its value after every step.
Only the addition uses the ALU. Load and store instructions copy values.
The store instruction copies the value out of register C, so register C keeps its value.

Your attempt (not saved)

Key Takeaways

Registers are small CPU memory units that hold individual values for immediate access by the processor.
The Arithmetic Logic Unit, or ALU, carries out arithmetic and logical operations on values, and the source material describes it as the processing half of the CPU.
An instruction can take the values in two registers, send them to the ALU, and place the result in a register.
Load and store instructions copy values between main memory and registers, so a value can be brought into the processor for use and results can be preserved.
Together, storage in registers and processing in the ALU, linked by movement to and from main memory, form the basic pattern of data handling in the CPU.