Welcome to the Heart of the Computer!
Hello there! In this chapter, we are going to dive inside the computer to look at the "brain"—the Central Processing Unit (CPU). Don't worry if it sounds like science fiction at first. Think of the processor like a very fast, very obedient chef in a kitchen. Once you understand how the chef works, the whole computer starts to make sense!
1. CPU Architecture: The Basic Blueprint
Most modern computers follow the Von Neumann Model. This model is famous because of the Stored Program Concept. This simply means that both the instructions (the "recipes") and the data (the "ingredients") are stored together in the same memory.
Key Components (The CPU Team)
• Arithmetic and Logic Unit (ALU): This is the calculator. It does all the math (like \( 2 + 2 \)) and logic comparisons (like is A bigger than B?).
• Control Unit (CU): The "manager." It coordinates all the activities of the CPU and sends signals to tell other parts what to do.
• System Clock: Like a heartbeat. It sends out a pulse to keep everything in sync.
• Immediate Access Store (IAS): This is another name for the memory directly accessible by the CPU, holding the data and instructions it needs right now.
The Registers (The CPU's "Sticky Notes")
Registers are tiny, super-fast storage areas inside the CPU. They hold one piece of information at a time while the CPU is working on it.
Special Purpose Registers you need to know:
• Program Counter (PC): Holds the address of the next instruction to be fetched.
• Memory Address Register (MAR): Holds the address of the memory location currently being read from or written to.
• Memory Data Register (MDR): Holds the actual data that has just been read from memory or is about to be written to memory.
• Current Instruction Register (CIR): Holds the instruction that is currently being decoded and executed.
• Accumulator (ACC): A general-purpose register that stores the results of calculations from the ALU.
• Index Register (IX): Used for "indexed addressing" (we'll see this later!).
• Status Register: Contains "flags" (bits) that signal certain conditions, like whether a calculation resulted in a negative number or an overflow error.
The Buses (The Highways)
Information travels between components on "buses."
• Address Bus: Carries the address of where data is going. It is unidirectional (one-way only, from CPU to Memory).
• Data Bus: Carries the actual data. It is bidirectional (two-way).
• Control Bus: Carries signals from the Control Unit (like "Read" or "Write"). It is also bidirectional.
Quick Review: The Address Bus is the only one that is one-way! This is a very common exam question.
Factors Affecting Performance
Why are some computers faster than others?
1. Clock Speed: More "pulses" per second means more instructions processed.
2. Bus Width: A wider data bus can carry more bits at once (like adding more lanes to a highway).
3. Number of Cores: More cores mean the CPU can do multiple things at the same time.
4. Cache Memory: High-speed memory inside the CPU. It stores frequently used data so the CPU doesn't have to wait for the slower main RAM.
Key Takeaway: The CPU uses registers to hold data, buses to move it, and the CU to manage it all under the Von Neumann model.
2. The Fetch-Execute (F-E) Cycle
This is the "heartbeat" of the computer. It's a cycle that repeats billions of times a second.
Step-by-Step in Register Transfer Notation
We use a special shorthand to show how data moves. [PC] means "the contents of the PC," and the arrow ← means "moves into."
The Fetch Stage:
1. MAR ← [PC] (The address in the PC is copied to the MAR).
2. PC ← [PC] + 1 (The PC is incremented so it points to the next instruction).
3. MDR ← [[MAR]] (The data at the address in MAR is loaded into the MDR).
4. CIR ← [MDR] (The instruction in the MDR is copied to the CIR).
The Decode and Execute Stages:
The Control Unit looks at the instruction in the CIR to understand what to do (Decode) and then carries out the action, like adding a number to the ACC (Execute).
Interrupts
An Interrupt is a signal sent to the CPU that something needs immediate attention (like a printer running out of paper or a key being pressed).
• At the end of every F-E cycle, the CPU checks for interrupts.
• If one exists, the CPU saves its current work and runs an Interrupt Service Routine (ISR).
• Once the ISR is finished, the CPU goes back to exactly where it left off.
Key Takeaway: The F-E cycle is Fetch (get instruction), Decode (understand it), and Execute (do it). Interrupts can pause this cycle to handle urgent tasks.
3. Assembly Language
Computers only understand Machine Code (binary: \( 10110010 \)). Because that's hard for humans, we use Assembly Language, which uses short words called mnemonics (like ADD, LDM, STO).
Addressing Modes
This is how we tell the CPU where to find the data.
• Immediate: The value is part of the instruction. (Example: LDM #5 means "Load the actual number 5 into the ACC").
• Direct: The instruction gives the memory address. (Example: LDD 100 means "Go to memory address 100 and get whatever is inside").
• Indirect: The address given holds another address. (Example: "Go to address 100, find the number 200 there, then go to address 200 to get the data").
• Indexed: You add the contents of the Index Register (IX) to the given address to find the target address. Useful for looking through lists!
• Relative: The address is a certain number of steps away from the current instruction.
The Two-Pass Assembler
An Assembler converts Assembly into Machine Code. It usually does this in two "passes":
1. Pass 1: It looks for Labels (symbolic names for addresses) and stores them in a Symbol Table.
2. Pass 2: It converts the mnemonics into binary and fills in the addresses using the Symbol Table created in Pass 1.
Did you know? We need two passes because a program might tell the computer to "Jump to Label X" before it has actually reached the line where "Label X" is defined!
Key Takeaway: Assembly is a human-readable version of machine code. Addressing modes determine how the CPU finds the data it needs.
4. Bit Manipulation
Sometimes we want to change or check just one bit inside a byte. We use Logical Shifts and Masking for this.
Binary Shifts
• Logical Shift Left (LSL): Moves bits to the left and fills the right with 0s. (Shifting left by 1 place is like multiplying by 2!).
• Logical Shift Right (LSR): Moves bits to the right and fills the left with 0s. (Shifting right by 1 place is like dividing by 2).
• Arithmetic Shift: Similar to logical, but it preserves the "sign bit" (the leftmost bit) so that negative numbers stay negative.
• Cyclic Shift: Bits that fall off one end wrap around to the other end. No data is lost!
Bit Masking
We use AND, OR, and XOR to manipulate specific bits.
• AND with 0: Used to clear a bit (force it to 0).
• OR with 1: Used to set a bit (force it to 1).
• XOR with 1: Used to invert (flip) a bit.
Analogy: Masking is like using a stencil when painting. The "stencil" (the mask) only lets the paint (the operation) reach certain spots.
Key Takeaway: Shifts move bits to multiply/divide or move data. Masking uses logic gates to change or check specific bits.
Summary: Don't Panic!
Processor Fundamentals is all about how the CPU moves data around. Remember:
1. The Registers are the internal storage.
2. The Buses are the roads.
3. The F-E Cycle is the process.
4. Assembly is the language.
5. Bit Manipulation is the fine-tuning.
Keep practicing the Register Transfer Notation and the different addressing modes—they are the keys to acing this section!