I've read about Meltdown and Spectre attacks. They don't rely in any way on cache coherence bugs. At the same time the article specifically says about cache coherence violations:
Show me where in the description of Meltdown or Spectre attacks is a discussion about cache coherence violations.
The xdcbt instruction was an extended prefetch instruction that fetched straight from memory to the L1 d-cache, skipping L2. This meant that memory coherency was no longer guaranteed, but hey, we’re video game programmers, we know what we’re doing, it will be fine.
Problem with Xbox 360 CPU was that there was CPU instruction that violated cache coherence explicitly and by design. It was 100% intentional and it was an performance optimization. It turned out that it caused too much pain, had created much more damage than gain, so developers stopped using it entirely. When they stopped using that instruction the problem was gone. Speculative execution worsened the problem, but it could be alleviated just like Spectre is alleviated today. The code:
could be written using masks:
if (flags & PREFETCH_EX)
That would remove the problem as even speculative execution of xdcbt would not touch the sensitive cache line as 'use_xdbct_mask' would be 0 anyway and speculatively executed xdbct would prefetch cache line reserved for wrongly taken speculative executions.
// reserved_space can be prefetched safely
// if use_xdbct_mask == 0xffffffffh then the following equation reduces to (src+offset)
__xdcbt(reserved_space + ((src-reserved_space+offset) & use_xdbct_mask));
Today we're wiser because we all read about Meltdown and Spectre attacks and their mitigations. Xbox 360 programmers didn't have that luxury so probably they have given up altogether on using problematic instruction instead of using Spectre-like mitigations.
The key ingredient to Meltdown and Spectre attack is the ability to reconstruct other process' data by observing cache latencies alone (that's the side-channel articles about M&S attacks are telling about). Without that speculative cache loads gains you nothing. You can't read other process' data directly, regardless if your CPU is vulnerable to Meltdown and Spectre attacks or not.