Memory subsystems typically have an internal organization. So memory controllers have to perform very quickly some address arithmetic for each memory access, where the physical address of the memory access can be found in the internal organization of the memory.
As an analogy: You have got a city consisting of districts. Each district has 100 streets. Each street has 100 houses. Each house has 100 inhabitants. Now you can easily find the global id of each inhabitant with the following formula:
District_id * 100 * 100 * 100 + Street_id * 100 * 100+ House_id * 100 + Inhabitant_in_house_id
And if we put in some values for the ids:
3 * 100 * 100 * 100 + 13 * 100 * 100 + 51 * 100 + 23 =
3000000 + 130000 + 5100 + 23 =
3135123
Also if you know the global id of an inhabitant you can also easily inverse this computation to find its district_id, street_id, house_id and Inhabitant_in_house_id, which is similar to what a memory controller has to do for every memory access. As you notice, computing this in base ten if the structural units of the city are base also 10^n is easy. However, let us assume the same example with structural units not being base 10:
District_id * 123 * 103 * 121 + Street_id * 103 * 121 + House_id * 121+ Inhabitant_id
Putting in the same values from above:
3 * 123 * 103 * 121 + 13 * 103 * 121 + 51 * 121+ 23
As you can obviously see you cannot you cannot simply compute this in your head anymore, and inverting this even becomes more difficult. Since computers operate with base 2, they suffer the same problems if their memory does not have an internal organization of base 2.
As an interesting side note, there are cases where another factor than 2 is involved in the organization of the memory, e.g. GPUs having a memory size being the multiple of 3, e.g. 6 Gigabyte. Because of that, those GPUs have to do some nasty mathematical tricks for mapping their physical addresses to locations in their memory.
Latest Answers