5.4. Data Hazards and ILP

To efficiently exploit ILP, data hazards need to be addressed. Data hazards occur when instructions depend on the results of previous instructions.

Data hazards are situations in computer programming where one instruction relies on the result of another instruction. This dependence can create a problem for processors trying to execute multiple instructions simultaneously, as they might start executing without having the needed data available. To effectively utilize instruction-level parallelism (ILP), we need to identify and manage these hazards.

Think of a relay race where one runner can only start once the previous runner has passed the baton. If the next runner starts too soon, they won't have the baton and will be unable to continue, just as a computer can't proceed with an instruction without the right data.

● Types of Data Hazards: ○ RAW (Read-After-Write): Occurs when an instruction tries to read a register before the previous instruction writes to it. ○ WAR (Write-After-Read): Occurs when an instruction tries to write to a register before another instruction reads it. ○ WAW (Write-After-Write): Occurs when two instructions try to write to the same register in the wrong order.

There are three primary types of data hazards that can occur:

1. RAW (Read-After-Write): This happens when an instruction needs to read data that hasn't been written yet, causing a delay.
2. WAR (Write-After-Read): This occurs if an instruction writes to a data location before another instruction has had the chance to read it.
3. WAW (Write-After-Write): This happens when two instructions attempt to write to the same location, and the order of writing matters.

Imagine a kitchen where you need to prepare a dish. If one chef is instructed to add salt before another chef has tasted the dish, you could end up with an overly salty meal (RAW). If the second chef tries to taste the dish after being told to add salt but hasn't yet tasted it, they won't know how much salt's already there (WAR). Finally, if two chefs try to season the dish simultaneously without knowing who did what first, the outcome could be confusing and inconsistent (WAW).

● Hazard Resolution Techniques: ○ Forwarding (Data Bypassing): Data from one pipeline stage is sent directly to another stage without waiting for it to be written to the register file. ○ Stall Cycles: When forwarding is not possible, a stall is introduced to delay the dependent instruction until the hazard is resolved. ○ Register Renaming: Used to eliminate WAR and WAW hazards by dynamically allocating new registers.

To manage data hazards, several techniques can be employed:

1. Forwarding: This method allows a processor to send the data directly from one stage of execution to another without waiting to write it back into memory first.
2. Stall Cycles: If forwarding isn't possible, the processor may pause (stall) the dependent instruction, waiting for the needed data to be ready.
3. Register Renaming: This technique involves using different registers to avoid conflicts from WAR and WAW situations. By dynamically allocating new registers, instructions can execute without waiting.

Consider a school where students must wait for one teacher to finish a lesson before another teacher can start with information that builds on it. Forwarding would be like allowing the second teacher to use the notes directly from the first teacher before they are officially recorded. Stall cycles are like postponing the second lesson until the first one is completely finished. Register renaming is akin to giving each student their own notebook instead of trying to share one, preventing the mix-up of notes.

--