Why do write-after-read and read-after-read hazards only require execution dependencies to synchronize?

[flowerdancedatou]

Memory dependencies are used to solve data hazards, e.g. to ensure that write operations are visible to subsequent read operations (read-after-write hazard), as well as write-after-write hazards. Write-after-read and read-after-read hazards only require execution dependencies to synchronize.

Why? Can you help me? Thanks

[AttilioProvenzano-ARM]

Hi,

This is a complex topic to tackle, so it's useful to develop a simpler mental model of it.

Suppose we have a main memory that is relatively slow to access, so we'll want to use caches to reduce memory accesses to a minimum. In this scheme we would want to implement a write back policy so we keep written data in cache and only propagate them to the main memory when necessary.

Let us now suppose that we have a command buffer with asynchronous operations and we add execution dependencies. Here are the possible cases:

• Read-after-read: no memory writes are involved, so there is no hazard really ✔️
• Write-after-read: the execution dependency will ensure that the previous data is correctly read before it's overwritten ✔️
• Read-after-write: the execution dependency will ensure that the write operation happens before the subsequent read, but written data may still be in the cache, so we risk reading old data from main memory! ❌
• Write-after-write: the execution dependency will ensure that the write operations happen in order, but due to caching it is not guaranteed that they will reach the main memory in the correct order. Other operations may rely on the writes being in order! ❌

As you can see for the latter operations it is not enough to have an execution dependency, we have to add a memory dependency to guarantee that write operations are visible.

Hope that helps!

[flowerdancedatou]

Thank you very much!