What can we do to get ready for memory controller merge in 2.6.25

They say better strike when the iron is hot.

Since we have so many people discussing the memory controller, I would like to access the readiness of the memory controller for mainline merge.

At the VM-Summit we decided to try the current double LRU approach for memory control. At this juncture in the space-time continuum, I seek your support, feedback, comments and help to move the memory controller

Quoted 5 lines · On Thu, 29 Nov 2007 20:13:17 +0530 Balbir Singh <[email protected]>…

They say better strike when the iron is hot.

Since we have so many people discussing the memory controller, I would like to access the readiness of the memory controller for mainline merge.

Quoted 3 lines

At the VM-Summit we decided to try the current double LRU approach for memory control. At this juncture in the space-time continuum, I seek your support, feedback, comments and help to move the memory controller

The memory controller code currently in -mm seems fine to me, especially with the changes that got committed over the last days making reclaim more efficient.

I don't think there are any bugs left that can be found by code inspection - only the kind of testing that the mainline kernel gets might shake out more bugs.

I would like to see the memory controller code go into the mainline kernel ASAP.

They say better strike when the iron is hot.

Since we have so many people discussing the memory controller, I would like to access the readiness of the memory controller for mainline merge. Given that we have some time until the merge window, I'd like to set aside some time (from my other work items) to work on the memory controller, fix review comments and defects.

In the past, we've received several useful comments from Rik Van Riel, Lee Schermerhorn, Peter Zijlstra, Hugh Dickins, Nick Piggin, Paul Menage and code contributions and bug fixes from Hugh Dickins, Pavel Emelianov, Lee Schermerhorn, YAMAMOTO-San, Andrew Morton and KAMEZAWA-San. I apologize if I missed out any other names or contributions

At the VM-Summit we decided to try the current double LRU approach for memory control. At this juncture in the space-time continuum, I seek your support, feedback, comments and help to move the memory controller

Quoted 14 lines · Balbir Singh

They say better strike when the iron is hot.

Since we have so many people discussing the memory controller, I would like to access the readiness of the memory controller for mainline merge. Given that we have some time until the merge window, I'd like to set aside some time (from my other work items) to work on the memory controller, fix review comments and defects.

In the past, we've received several useful comments from Rik Van Riel, Lee Schermerhorn, Peter Zijlstra, Hugh Dickins, Nick Piggin, Paul Menage and code contributions and bug fixes from Hugh Dickins, Pavel Emelianov, Lee Schermerhorn, YAMAMOTO-San, Andrew Morton and KAMEZAWA-San. I apologize if I missed out any other names or contributions

Quoted 3 lines

At the VM-Summit we decided to try the current double LRU approach for memory control. At this juncture in the space-time continuum, I seek your support, feedback, comments and help to move the memory controller

Do you have any test cases, performance numbers, etc.? And also some results or even anecdotes of where this is going to be used would be interesting...

KAMEZAWA-San posted some test results on background reclaim and per zone reclaim

I'd like to post some patches below in the next week.
- throttling the number of callers of try_to_free_mem_cgroup_pages()
- background reclaim and high/low watermark.
- some cleanups.

And also some
results or even anecdotes of where this is going to be used would be interesting...

Quoted 3 lines · Nick Piggin

And also some
results or even anecdotes of where this is going to be used would be interesting...

We want to be able to run multiple isolated jobs on the same machine. So being able to limit how much memory each job can consume, in terms of anonymous memory and page cache, are useful. I've not had much time to look at the patches in great detail, but they seem to provide a sensible way to assign and enforce static limits on a bunch of jobs.

Some of our requirements are a bit beyond this, though:

In our experience, users are not good at figuring out how much memory they really need. In general they tend to massively over-estimate their requirements. So we want some way to determine how much of its allocated memory a job is actively using, and how much could be thrown away or swapped out without bothering the job too much.

Of course, the definition of "actve use" is tricky - one possibility that we're looking at is "has been accessed within the last N seconds", where N can be configured appropriately for different jobs depending on the job's latency requirements. Active use should also be reported for pages that can't be easily freed quickly, e.g. mlocked or dirty pages, or anon pages on a swapless system. Inactive pages should be easily freeable, and be the first ones to go in the event of memory pressure. (From a scheduling point of view we can treat them as free memory, and schedule more jobs on the machine)

The existing active/inactive distinction doesn't really capture this, since it's relative rather than absolute.

We want to be able to overcommit a machine, so the sums of the cgroup memory limits can add up to more than the total machine memory. So we need control over what happens when there's global memory pressure, and a way to ensure that the low-latency jobs don't get bogged down in reclaim (or OOM) due to the activity of batch jobs.

Paul

Quoted 5 lines

In our experience, users are not good at figuring out how much memory they really need. In general they tend to massively over-estimate their requirements. So we want some way to determine how much of its allocated memory a job is actively using, and how much could be thrown away or swapped out without bothering the job too much.

One would prefer the kernel provides the mechanism and user space provides the policy. The algorithms to assign limits can exist in user space and be supported by a good set of statistics.

With the /proc/refaults info, we can measure how much extra memory each process group needs, if any.

As for how much memory a process group needs, at pageout time we can check the fraction of pages that are accessed. If 60% of the pages were recently accessed at pageout time and this process group is spending little or no time waiting for refaults, 40% of the pages are *not* recently accessed and we can probably reduce the amount of memory assigned to this group.

Quoted 3 lines · Rik van Riel

With the /proc/refaults info, we can measure how much extra memory each process group needs, if any.

What's the status of that? It looks as though it would be better than the "accessed in the last N seconds" metric that we've been playing with, although it's possibly more intrusive?

Would it be practical to keep a non-resident set for each cgroup?

Quoted 6 lines

As for how much memory a process group needs, at pageout time we can check the fraction of pages that are accessed. If 60% of the pages were recently accessed at pageout time and this process group is spending little or no time waiting for refaults, 40% of the pages are *not* recently accessed and we can probably reduce the amount of memory assigned to this group.

It would probably be better to reduce its background-reclaim high watermark than to reduce its limit. If you do the latter, you risk triggering an OOM in the cgroup if it turns out that it did need all that memory after all.