Memory coherence is a problem that occurs in a computer when a processor attempts to look at a memory sector. This problem only occurs on multicore systems, or computers that have more than one central processing unit (CPU). When the multiple processors look at the same memory sector and one updates the sector, the other may be left with an old version of the computer memory. To fix this issue, consistency rules are used to ensure the processors either do not access the same memory or that the updates are consistent between them. There are several different consistency models, so programmers and computer developers must know the exact model used.
The memory coherence problem is one that only occurs on computers that are using at least two CPUs because of how they access memory. When one CPU is accessing a memory sector, it is able to take, use and alter the memory without any conflict, because there are no other hardware pieces competing for memory. If two CPUs are used, then the two CPUs may grab the same memory sector. While there are no problems with the two CPUs sharing the memory, a problem does arise if one CPU updates the memory. This leaves the second CPU with outdated memory that, if left unchecked, can cause the entire computer to have two separate and conflicting versions of computer memory.
There are programming schemas made specifically to correct memory coherence, which can be a major issue. They are known collectively as memory consistency rules, and there are many versions. Overall, each version tells the multiple CPUs how to properly share the computer memory without causing the memory coherence problem. This can be done by updating both versions of the memory when one version is changed or by keeping the CPUs from accessing the same memory at the same time.
While using consistency rules helps avoid the memory coherence problem, another problem arises from this. Each consistency set has different programming and different rules, so programmers who are making programs or writing code that deal directly with the CPUs will have to tailor the coding for the exact consistency rules. If not, then this can either override the consistency or cause a major conflict between the programmer’s coding and the consistency rules, and the computer may cease to function.