On 10/07/2013 06:29 AM, Mel Gorman wrote: > Ideally it would be possible to distinguish between NUMA hinting faults that > are private to a task and those that are shared. If treated identically > there is a risk that shared pages bounce between nodes depending on > the order they are referenced by tasks. Ultimately what is desirable is > that task private pages remain local to the task while shared pages are > interleaved between sharing tasks running on different nodes to give good > average performance. This is further complicated by THP as even > applications that partition their data may not be partitioning on a huge > page boundary. > > To start with, this patch assumes that multi-threaded or multi-process > applications partition their data and that in general the private accesses > are more important for cpu->memory locality in the general case. Also, > no new infrastructure is required to treat private pages properly but > interleaving for shared pages requires additional infrastructure. > > To detect private accesses the pid of the last accessing task is required > but the storage requirements are a high. This patch borrows heavily from > Ingo Molnar's patch "numa, mm, sched: Implement last-CPU+PID hash tracking" > to encode some bits from the last accessing task in the page flags as > well as the node information. Collisions will occur but it is better than > just depending on the node information. Node information is then used to > determine if a page needs to migrate. The PID information is used to detect > private/shared accesses. The preferred NUMA node is selected based on where > the maximum number of approximately private faults were measured. Shared > faults are not taken into consideration for a few reasons. > > First, if there are many tasks sharing the page then they'll all move > towards the same node. The node will be compute overloaded and then > scheduled away later only to bounce back again. Alternatively the shared > tasks would just bounce around nodes because the fault information is > effectively noise. Either way accounting for shared faults the same as > private faults can result in lower performance overall. > > The second reason is based on a hypothetical workload that has a small > number of very important, heavily accessed private pages but a large shared > array. The shared array would dominate the number of faults and be selected > as a preferred node even though it's the wrong decision. > > The third reason is that multiple threads in a process will race each > other to fault the shared page making the fault information unreliable. > > [[email protected]: Fix complication error when !NUMA_BALANCING] > Signed-off-by: Mel Gorman <[email protected]>
Acked-by: Rik van Riel <[email protected]> -- All rights reversed -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/
