2010-05-24 21:32:27 +00:00
|
|
|
/*
|
|
|
|
* linux/mm/compaction.c
|
|
|
|
*
|
|
|
|
* Memory compaction for the reduction of external fragmentation. Note that
|
|
|
|
* this heavily depends upon page migration to do all the real heavy
|
|
|
|
* lifting
|
|
|
|
*
|
|
|
|
* Copyright IBM Corp. 2007-2010 Mel Gorman <mel@csn.ul.ie>
|
|
|
|
*/
|
|
|
|
#include <linux/swap.h>
|
|
|
|
#include <linux/migrate.h>
|
|
|
|
#include <linux/compaction.h>
|
|
|
|
#include <linux/mm_inline.h>
|
|
|
|
#include <linux/backing-dev.h>
|
2010-05-24 21:32:28 +00:00
|
|
|
#include <linux/sysctl.h>
|
2010-05-24 21:32:29 +00:00
|
|
|
#include <linux/sysfs.h>
|
2012-12-12 00:02:42 +00:00
|
|
|
#include <linux/balloon_compaction.h>
|
2013-02-23 00:33:58 +00:00
|
|
|
#include <linux/page-isolation.h>
|
2010-05-24 21:32:27 +00:00
|
|
|
#include "internal.h"
|
|
|
|
|
2012-12-20 23:05:06 +00:00
|
|
|
#ifdef CONFIG_COMPACTION
|
|
|
|
static inline void count_compact_event(enum vm_event_item item)
|
|
|
|
{
|
|
|
|
count_vm_event(item);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void count_compact_events(enum vm_event_item item, long delta)
|
|
|
|
{
|
|
|
|
count_vm_events(item, delta);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define count_compact_event(item) do { } while (0)
|
|
|
|
#define count_compact_events(item, delta) do { } while (0)
|
|
|
|
#endif
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
#if defined CONFIG_COMPACTION || defined CONFIG_CMA
|
|
|
|
|
2011-01-13 23:45:54 +00:00
|
|
|
#define CREATE_TRACE_POINTS
|
|
|
|
#include <trace/events/compaction.h>
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
static unsigned long release_freepages(struct list_head *freelist)
|
|
|
|
{
|
|
|
|
struct page *page, *next;
|
|
|
|
unsigned long count = 0;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(page, next, freelist, lru) {
|
|
|
|
list_del(&page->lru);
|
|
|
|
__free_page(page);
|
|
|
|
count++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
static void map_pages(struct list_head *list)
|
|
|
|
{
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
list_for_each_entry(page, list, lru) {
|
|
|
|
arch_alloc_page(page, 0);
|
|
|
|
kernel_map_pages(page, 1, 1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
static inline bool migrate_async_suitable(int migratetype)
|
|
|
|
{
|
|
|
|
return is_migrate_cma(migratetype) || migratetype == MIGRATE_MOVABLE;
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
#ifdef CONFIG_COMPACTION
|
|
|
|
/* Returns true if the pageblock should be scanned for pages to isolate. */
|
|
|
|
static inline bool isolation_suitable(struct compact_control *cc,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
if (cc->ignore_skip_hint)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return !get_pageblock_skip(page);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is called to clear all cached information on pageblocks that
|
|
|
|
* should be skipped for page isolation when the migrate and free page scanner
|
|
|
|
* meet.
|
|
|
|
*/
|
2012-10-08 23:32:47 +00:00
|
|
|
static void __reset_isolation_suitable(struct zone *zone)
|
2012-10-08 23:32:41 +00:00
|
|
|
{
|
|
|
|
unsigned long start_pfn = zone->zone_start_pfn;
|
2013-02-23 00:35:23 +00:00
|
|
|
unsigned long end_pfn = zone_end_pfn(zone);
|
2012-10-08 23:32:41 +00:00
|
|
|
unsigned long pfn;
|
|
|
|
|
2012-10-08 23:32:45 +00:00
|
|
|
zone->compact_cached_migrate_pfn = start_pfn;
|
|
|
|
zone->compact_cached_free_pfn = end_pfn;
|
2012-10-08 23:32:47 +00:00
|
|
|
zone->compact_blockskip_flush = false;
|
2012-10-08 23:32:41 +00:00
|
|
|
|
|
|
|
/* Walk the zone and mark every pageblock as suitable for isolation */
|
|
|
|
for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
|
|
|
|
if (!pfn_valid(pfn))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
if (zone != page_zone(page))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
clear_pageblock_skip(page);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:32:47 +00:00
|
|
|
void reset_isolation_suitable(pg_data_t *pgdat)
|
|
|
|
{
|
|
|
|
int zoneid;
|
|
|
|
|
|
|
|
for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
|
|
|
|
struct zone *zone = &pgdat->node_zones[zoneid];
|
|
|
|
if (!populated_zone(zone))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Only flush if a full compaction finished recently */
|
|
|
|
if (zone->compact_blockskip_flush)
|
|
|
|
__reset_isolation_suitable(zone);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
/*
|
|
|
|
* If no pages were isolated then mark this pageblock to be skipped in the
|
2012-10-08 23:32:47 +00:00
|
|
|
* future. The information is later cleared by __reset_isolation_suitable().
|
2012-10-08 23:32:41 +00:00
|
|
|
*/
|
2012-10-08 23:32:45 +00:00
|
|
|
static void update_pageblock_skip(struct compact_control *cc,
|
|
|
|
struct page *page, unsigned long nr_isolated,
|
|
|
|
bool migrate_scanner)
|
2012-10-08 23:32:41 +00:00
|
|
|
{
|
2012-10-08 23:32:45 +00:00
|
|
|
struct zone *zone = cc->zone;
|
2013-12-19 01:08:52 +00:00
|
|
|
|
|
|
|
if (cc->ignore_skip_hint)
|
|
|
|
return;
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
if (!page)
|
|
|
|
return;
|
|
|
|
|
2012-10-08 23:32:45 +00:00
|
|
|
if (!nr_isolated) {
|
|
|
|
unsigned long pfn = page_to_pfn(page);
|
2012-10-08 23:32:41 +00:00
|
|
|
set_pageblock_skip(page);
|
2012-10-08 23:32:45 +00:00
|
|
|
|
|
|
|
/* Update where compaction should restart */
|
|
|
|
if (migrate_scanner) {
|
|
|
|
if (!cc->finished_update_migrate &&
|
|
|
|
pfn > zone->compact_cached_migrate_pfn)
|
|
|
|
zone->compact_cached_migrate_pfn = pfn;
|
|
|
|
} else {
|
|
|
|
if (!cc->finished_update_free &&
|
|
|
|
pfn < zone->compact_cached_free_pfn)
|
|
|
|
zone->compact_cached_free_pfn = pfn;
|
|
|
|
}
|
|
|
|
}
|
2012-10-08 23:32:41 +00:00
|
|
|
}
|
|
|
|
#else
|
|
|
|
static inline bool isolation_suitable(struct compact_control *cc,
|
|
|
|
struct page *page)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:32:45 +00:00
|
|
|
static void update_pageblock_skip(struct compact_control *cc,
|
|
|
|
struct page *page, unsigned long nr_isolated,
|
|
|
|
bool migrate_scanner)
|
2012-10-08 23:32:41 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_COMPACTION */
|
|
|
|
|
2012-10-08 23:32:33 +00:00
|
|
|
static inline bool should_release_lock(spinlock_t *lock)
|
|
|
|
{
|
|
|
|
return need_resched() || spin_is_contended(lock);
|
|
|
|
}
|
|
|
|
|
2012-08-21 23:16:17 +00:00
|
|
|
/*
|
|
|
|
* Compaction requires the taking of some coarse locks that are potentially
|
|
|
|
* very heavily contended. Check if the process needs to be scheduled or
|
|
|
|
* if the lock is contended. For async compaction, back out in the event
|
|
|
|
* if contention is severe. For sync compaction, schedule.
|
|
|
|
*
|
|
|
|
* Returns true if the lock is held.
|
|
|
|
* Returns false if the lock is released and compaction should abort
|
|
|
|
*/
|
|
|
|
static bool compact_checklock_irqsave(spinlock_t *lock, unsigned long *flags,
|
|
|
|
bool locked, struct compact_control *cc)
|
|
|
|
{
|
2012-10-08 23:32:33 +00:00
|
|
|
if (should_release_lock(lock)) {
|
2012-08-21 23:16:17 +00:00
|
|
|
if (locked) {
|
|
|
|
spin_unlock_irqrestore(lock, *flags);
|
|
|
|
locked = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* async aborts if taking too long or contended */
|
|
|
|
if (!cc->sync) {
|
2012-10-08 23:32:27 +00:00
|
|
|
cc->contended = true;
|
2012-08-21 23:16:17 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
cond_resched();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!locked)
|
|
|
|
spin_lock_irqsave(lock, *flags);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool compact_trylock_irqsave(spinlock_t *lock,
|
|
|
|
unsigned long *flags, struct compact_control *cc)
|
|
|
|
{
|
|
|
|
return compact_checklock_irqsave(lock, flags, false, cc);
|
|
|
|
}
|
|
|
|
|
2012-10-08 23:32:36 +00:00
|
|
|
/* Returns true if the page is within a block suitable for migration to */
|
|
|
|
static bool suitable_migration_target(struct page *page)
|
|
|
|
{
|
2014-04-07 22:37:03 +00:00
|
|
|
/* If the page is a large free page, then disallow migration */
|
2012-10-08 23:32:36 +00:00
|
|
|
if (PageBuddy(page) && page_order(page) >= pageblock_order)
|
2014-04-07 22:37:03 +00:00
|
|
|
return false;
|
2012-10-08 23:32:36 +00:00
|
|
|
|
|
|
|
/* If the block is MIGRATE_MOVABLE or MIGRATE_CMA, allow migration */
|
2014-04-07 22:37:03 +00:00
|
|
|
if (migrate_async_suitable(get_pageblock_migratetype(page)))
|
2012-10-08 23:32:36 +00:00
|
|
|
return true;
|
|
|
|
|
|
|
|
/* Otherwise skip the block */
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-01-30 12:24:03 +00:00
|
|
|
/*
|
2013-11-12 23:07:12 +00:00
|
|
|
* Isolate free pages onto a private freelist. If @strict is true, will abort
|
|
|
|
* returning 0 on any invalid PFNs or non-free pages inside of the pageblock
|
|
|
|
* (even though it may still end up isolating some pages).
|
2012-01-30 12:24:03 +00:00
|
|
|
*/
|
2012-10-08 23:32:36 +00:00
|
|
|
static unsigned long isolate_freepages_block(struct compact_control *cc,
|
|
|
|
unsigned long blockpfn,
|
2012-01-30 12:24:03 +00:00
|
|
|
unsigned long end_pfn,
|
|
|
|
struct list_head *freelist,
|
|
|
|
bool strict)
|
2010-05-24 21:32:27 +00:00
|
|
|
{
|
2011-01-13 23:45:54 +00:00
|
|
|
int nr_scanned = 0, total_isolated = 0;
|
2012-10-08 23:32:41 +00:00
|
|
|
struct page *cursor, *valid_page = NULL;
|
2012-10-08 23:32:36 +00:00
|
|
|
unsigned long flags;
|
|
|
|
bool locked = false;
|
2014-04-07 22:37:04 +00:00
|
|
|
bool checked_pageblock = false;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
cursor = pfn_to_page(blockpfn);
|
|
|
|
|
2012-10-08 23:32:36 +00:00
|
|
|
/* Isolate free pages. */
|
2010-05-24 21:32:27 +00:00
|
|
|
for (; blockpfn < end_pfn; blockpfn++, cursor++) {
|
|
|
|
int isolated, i;
|
|
|
|
struct page *page = cursor;
|
|
|
|
|
2011-01-13 23:45:54 +00:00
|
|
|
nr_scanned++;
|
2012-10-08 23:32:36 +00:00
|
|
|
if (!pfn_valid_within(blockpfn))
|
2014-03-10 22:49:44 +00:00
|
|
|
goto isolate_fail;
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
if (!valid_page)
|
|
|
|
valid_page = page;
|
2012-10-08 23:32:36 +00:00
|
|
|
if (!PageBuddy(page))
|
2014-03-10 22:49:44 +00:00
|
|
|
goto isolate_fail;
|
2012-10-08 23:32:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* The zone lock must be held to isolate freepages.
|
|
|
|
* Unfortunately this is a very coarse lock and can be
|
|
|
|
* heavily contended if there are parallel allocations
|
|
|
|
* or parallel compactions. For async compaction do not
|
|
|
|
* spin on the lock and we acquire the lock as late as
|
|
|
|
* possible.
|
|
|
|
*/
|
|
|
|
locked = compact_checklock_irqsave(&cc->zone->lock, &flags,
|
|
|
|
locked, cc);
|
|
|
|
if (!locked)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Recheck this is a suitable migration target under lock */
|
2014-04-07 22:37:04 +00:00
|
|
|
if (!strict && !checked_pageblock) {
|
|
|
|
/*
|
|
|
|
* We need to check suitability of pageblock only once
|
|
|
|
* and this isolate_freepages_block() is called with
|
|
|
|
* pageblock range, so just check once is sufficient.
|
|
|
|
*/
|
|
|
|
checked_pageblock = true;
|
|
|
|
if (!suitable_migration_target(page))
|
|
|
|
break;
|
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2012-10-08 23:32:36 +00:00
|
|
|
/* Recheck this is a buddy page under lock */
|
|
|
|
if (!PageBuddy(page))
|
2014-03-10 22:49:44 +00:00
|
|
|
goto isolate_fail;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
/* Found a free page, break it into order-0 pages */
|
|
|
|
isolated = split_free_page(page);
|
|
|
|
total_isolated += isolated;
|
|
|
|
for (i = 0; i < isolated; i++) {
|
|
|
|
list_add(&page->lru, freelist);
|
|
|
|
page++;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If a page was split, advance to the end of it */
|
|
|
|
if (isolated) {
|
|
|
|
blockpfn += isolated - 1;
|
|
|
|
cursor += isolated - 1;
|
2014-03-10 22:49:44 +00:00
|
|
|
continue;
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
2014-03-10 22:49:44 +00:00
|
|
|
|
|
|
|
isolate_fail:
|
|
|
|
if (strict)
|
|
|
|
break;
|
|
|
|
else
|
|
|
|
continue;
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
2011-01-13 23:45:54 +00:00
|
|
|
trace_mm_compaction_isolate_freepages(nr_scanned, total_isolated);
|
2012-10-08 23:32:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If strict isolation is requested by CMA then check that all the
|
|
|
|
* pages requested were isolated. If there were any failures, 0 is
|
|
|
|
* returned and CMA will fail.
|
|
|
|
*/
|
2014-03-10 22:49:44 +00:00
|
|
|
if (strict && blockpfn < end_pfn)
|
2012-10-08 23:32:36 +00:00
|
|
|
total_isolated = 0;
|
|
|
|
|
|
|
|
if (locked)
|
|
|
|
spin_unlock_irqrestore(&cc->zone->lock, flags);
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
/* Update the pageblock-skip if the whole pageblock was scanned */
|
|
|
|
if (blockpfn == end_pfn)
|
2012-10-08 23:32:45 +00:00
|
|
|
update_pageblock_skip(cc, valid_page, total_isolated, false);
|
2012-10-08 23:32:41 +00:00
|
|
|
|
2012-12-20 23:05:06 +00:00
|
|
|
count_compact_events(COMPACTFREE_SCANNED, nr_scanned);
|
2012-10-19 11:00:10 +00:00
|
|
|
if (total_isolated)
|
2012-12-20 23:05:06 +00:00
|
|
|
count_compact_events(COMPACTISOLATED, total_isolated);
|
2010-05-24 21:32:27 +00:00
|
|
|
return total_isolated;
|
|
|
|
}
|
|
|
|
|
2012-01-30 12:24:03 +00:00
|
|
|
/**
|
|
|
|
* isolate_freepages_range() - isolate free pages.
|
|
|
|
* @start_pfn: The first PFN to start isolating.
|
|
|
|
* @end_pfn: The one-past-last PFN.
|
|
|
|
*
|
|
|
|
* Non-free pages, invalid PFNs, or zone boundaries within the
|
|
|
|
* [start_pfn, end_pfn) range are considered errors, cause function to
|
|
|
|
* undo its actions and return zero.
|
|
|
|
*
|
|
|
|
* Otherwise, function returns one-past-the-last PFN of isolated page
|
|
|
|
* (which may be greater then end_pfn if end fell in a middle of
|
|
|
|
* a free page).
|
|
|
|
*/
|
2011-12-29 12:09:50 +00:00
|
|
|
unsigned long
|
2012-10-08 23:32:41 +00:00
|
|
|
isolate_freepages_range(struct compact_control *cc,
|
|
|
|
unsigned long start_pfn, unsigned long end_pfn)
|
2012-01-30 12:24:03 +00:00
|
|
|
{
|
2012-10-08 23:32:36 +00:00
|
|
|
unsigned long isolated, pfn, block_end_pfn;
|
2012-01-30 12:24:03 +00:00
|
|
|
LIST_HEAD(freelist);
|
|
|
|
|
|
|
|
for (pfn = start_pfn; pfn < end_pfn; pfn += isolated) {
|
2012-10-08 23:32:41 +00:00
|
|
|
if (!pfn_valid(pfn) || cc->zone != page_zone(pfn_to_page(pfn)))
|
2012-01-30 12:24:03 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* On subsequent iterations ALIGN() is actually not needed,
|
|
|
|
* but we keep it that we not to complicate the code.
|
|
|
|
*/
|
|
|
|
block_end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
|
|
|
|
block_end_pfn = min(block_end_pfn, end_pfn);
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
isolated = isolate_freepages_block(cc, pfn, block_end_pfn,
|
2012-01-30 12:24:03 +00:00
|
|
|
&freelist, true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In strict mode, isolate_freepages_block() returns 0 if
|
|
|
|
* there are any holes in the block (ie. invalid PFNs or
|
|
|
|
* non-free pages).
|
|
|
|
*/
|
|
|
|
if (!isolated)
|
|
|
|
break;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we managed to isolate pages, it is always (1 << n) *
|
|
|
|
* pageblock_nr_pages for some non-negative n. (Max order
|
|
|
|
* page may span two pageblocks).
|
|
|
|
*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/* split_free_page does not map the pages */
|
|
|
|
map_pages(&freelist);
|
|
|
|
|
|
|
|
if (pfn < end_pfn) {
|
|
|
|
/* Loop terminated early, cleanup. */
|
|
|
|
release_freepages(&freelist);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* We don't use freelists for anything. */
|
|
|
|
return pfn;
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
/* Update the number of anon and file isolated pages in the zone */
|
2012-08-21 23:16:17 +00:00
|
|
|
static void acct_isolated(struct zone *zone, bool locked, struct compact_control *cc)
|
2010-05-24 21:32:27 +00:00
|
|
|
{
|
|
|
|
struct page *page;
|
2011-11-01 00:06:44 +00:00
|
|
|
unsigned int count[2] = { 0, };
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2011-11-01 00:06:44 +00:00
|
|
|
list_for_each_entry(page, &cc->migratepages, lru)
|
|
|
|
count[!!page_is_file_cache(page)]++;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2012-08-21 23:16:17 +00:00
|
|
|
/* If locked we can use the interrupt unsafe versions */
|
|
|
|
if (locked) {
|
|
|
|
__mod_zone_page_state(zone, NR_ISOLATED_ANON, count[0]);
|
|
|
|
__mod_zone_page_state(zone, NR_ISOLATED_FILE, count[1]);
|
|
|
|
} else {
|
|
|
|
mod_zone_page_state(zone, NR_ISOLATED_ANON, count[0]);
|
|
|
|
mod_zone_page_state(zone, NR_ISOLATED_FILE, count[1]);
|
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Similar to reclaim, but different enough that they don't share logic */
|
|
|
|
static bool too_many_isolated(struct zone *zone)
|
|
|
|
{
|
2010-09-09 23:38:00 +00:00
|
|
|
unsigned long active, inactive, isolated;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
inactive = zone_page_state(zone, NR_INACTIVE_FILE) +
|
|
|
|
zone_page_state(zone, NR_INACTIVE_ANON);
|
2010-09-09 23:38:00 +00:00
|
|
|
active = zone_page_state(zone, NR_ACTIVE_FILE) +
|
|
|
|
zone_page_state(zone, NR_ACTIVE_ANON);
|
2010-05-24 21:32:27 +00:00
|
|
|
isolated = zone_page_state(zone, NR_ISOLATED_FILE) +
|
|
|
|
zone_page_state(zone, NR_ISOLATED_ANON);
|
|
|
|
|
2010-09-09 23:38:00 +00:00
|
|
|
return isolated > (inactive + active) / 2;
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
2012-01-30 12:16:26 +00:00
|
|
|
/**
|
|
|
|
* isolate_migratepages_range() - isolate all migrate-able pages in range.
|
|
|
|
* @zone: Zone pages are in.
|
|
|
|
* @cc: Compaction control structure.
|
|
|
|
* @low_pfn: The first PFN of the range.
|
|
|
|
* @end_pfn: The one-past-the-last PFN of the range.
|
2012-10-08 23:33:48 +00:00
|
|
|
* @unevictable: true if it allows to isolate unevictable pages
|
2012-01-30 12:16:26 +00:00
|
|
|
*
|
|
|
|
* Isolate all pages that can be migrated from the range specified by
|
|
|
|
* [low_pfn, end_pfn). Returns zero if there is a fatal signal
|
|
|
|
* pending), otherwise PFN of the first page that was not scanned
|
|
|
|
* (which may be both less, equal to or more then end_pfn).
|
|
|
|
*
|
|
|
|
* Assumes that cc->migratepages is empty and cc->nr_migratepages is
|
|
|
|
* zero.
|
|
|
|
*
|
|
|
|
* Apart from cc->migratepages and cc->nr_migratetypes this function
|
|
|
|
* does not modify any cc's fields, in particular it does not modify
|
|
|
|
* (or read for that matter) cc->migrate_pfn.
|
2010-05-24 21:32:27 +00:00
|
|
|
*/
|
2011-12-29 12:09:50 +00:00
|
|
|
unsigned long
|
2012-01-30 12:16:26 +00:00
|
|
|
isolate_migratepages_range(struct zone *zone, struct compact_control *cc,
|
2012-10-08 23:33:48 +00:00
|
|
|
unsigned long low_pfn, unsigned long end_pfn, bool unevictable)
|
2010-05-24 21:32:27 +00:00
|
|
|
{
|
2011-01-13 23:45:59 +00:00
|
|
|
unsigned long last_pageblock_nr = 0, pageblock_nr;
|
2011-01-13 23:45:54 +00:00
|
|
|
unsigned long nr_scanned = 0, nr_isolated = 0;
|
2010-05-24 21:32:27 +00:00
|
|
|
struct list_head *migratelist = &cc->migratepages;
|
2012-05-29 22:07:09 +00:00
|
|
|
struct lruvec *lruvec;
|
2012-08-21 23:16:17 +00:00
|
|
|
unsigned long flags;
|
2012-10-08 23:32:33 +00:00
|
|
|
bool locked = false;
|
2012-10-08 23:32:41 +00:00
|
|
|
struct page *page = NULL, *valid_page = NULL;
|
2014-01-21 23:51:10 +00:00
|
|
|
bool skipped_async_unsuitable = false;
|
2014-04-07 22:37:34 +00:00
|
|
|
const isolate_mode_t mode = (!cc->sync ? ISOLATE_ASYNC_MIGRATE : 0) |
|
|
|
|
(unevictable ? ISOLATE_UNEVICTABLE : 0);
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that there are not too many pages isolated from the LRU
|
|
|
|
* list by either parallel reclaimers or compaction. If there are,
|
|
|
|
* delay for some time until fewer pages are isolated
|
|
|
|
*/
|
|
|
|
while (unlikely(too_many_isolated(zone))) {
|
2011-06-15 22:08:52 +00:00
|
|
|
/* async migration should just abort */
|
2012-06-04 03:05:57 +00:00
|
|
|
if (!cc->sync)
|
2012-01-30 12:16:26 +00:00
|
|
|
return 0;
|
2011-06-15 22:08:52 +00:00
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
congestion_wait(BLK_RW_ASYNC, HZ/10);
|
|
|
|
|
|
|
|
if (fatal_signal_pending(current))
|
2012-01-30 12:16:26 +00:00
|
|
|
return 0;
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Time to isolate some pages for migration */
|
2011-03-22 23:33:10 +00:00
|
|
|
cond_resched();
|
2010-05-24 21:32:27 +00:00
|
|
|
for (; low_pfn < end_pfn; low_pfn++) {
|
2011-03-22 23:33:10 +00:00
|
|
|
/* give a chance to irqs before checking need_resched() */
|
2014-04-07 22:37:05 +00:00
|
|
|
if (locked && !(low_pfn % SWAP_CLUSTER_MAX)) {
|
2012-10-08 23:32:33 +00:00
|
|
|
if (should_release_lock(&zone->lru_lock)) {
|
|
|
|
spin_unlock_irqrestore(&zone->lru_lock, flags);
|
|
|
|
locked = false;
|
|
|
|
}
|
2011-03-22 23:33:10 +00:00
|
|
|
}
|
2012-08-21 23:16:17 +00:00
|
|
|
|
2012-02-03 23:37:18 +00:00
|
|
|
/*
|
|
|
|
* migrate_pfn does not necessarily start aligned to a
|
|
|
|
* pageblock. Ensure that pfn_valid is called when moving
|
|
|
|
* into a new MAX_ORDER_NR_PAGES range in case of large
|
|
|
|
* memory holes within the zone
|
|
|
|
*/
|
|
|
|
if ((low_pfn & (MAX_ORDER_NR_PAGES - 1)) == 0) {
|
|
|
|
if (!pfn_valid(low_pfn)) {
|
|
|
|
low_pfn += MAX_ORDER_NR_PAGES - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
if (!pfn_valid_within(low_pfn))
|
|
|
|
continue;
|
2011-01-13 23:45:54 +00:00
|
|
|
nr_scanned++;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2012-02-09 01:13:38 +00:00
|
|
|
/*
|
|
|
|
* Get the page and ensure the page is within the same zone.
|
|
|
|
* See the comment in isolate_freepages about overlapping
|
|
|
|
* nodes. It is deliberate that the new zone lock is not taken
|
|
|
|
* as memory compaction should not move pages between nodes.
|
|
|
|
*/
|
2010-05-24 21:32:27 +00:00
|
|
|
page = pfn_to_page(low_pfn);
|
2012-02-09 01:13:38 +00:00
|
|
|
if (page_zone(page) != zone)
|
|
|
|
continue;
|
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
if (!valid_page)
|
|
|
|
valid_page = page;
|
|
|
|
|
|
|
|
/* If isolation recently failed, do not retry */
|
|
|
|
pageblock_nr = low_pfn >> pageblock_order;
|
2014-04-07 22:37:06 +00:00
|
|
|
if (last_pageblock_nr != pageblock_nr) {
|
|
|
|
int mt;
|
|
|
|
|
|
|
|
last_pageblock_nr = pageblock_nr;
|
|
|
|
if (!isolation_suitable(cc, page))
|
|
|
|
goto next_pageblock;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* For async migration, also only scan in MOVABLE
|
|
|
|
* blocks. Async migration is optimistic to see if
|
|
|
|
* the minimum amount of work satisfies the allocation
|
|
|
|
*/
|
|
|
|
mt = get_pageblock_migratetype(page);
|
|
|
|
if (!cc->sync && !migrate_async_suitable(mt)) {
|
|
|
|
cc->finished_update_migrate = true;
|
|
|
|
skipped_async_unsuitable = true;
|
|
|
|
goto next_pageblock;
|
|
|
|
}
|
|
|
|
}
|
2012-10-08 23:32:41 +00:00
|
|
|
|
2014-01-23 23:53:38 +00:00
|
|
|
/*
|
|
|
|
* Skip if free. page_order cannot be used without zone->lock
|
|
|
|
* as nothing prevents parallel allocations or buddy merging.
|
|
|
|
*/
|
2010-05-24 21:32:27 +00:00
|
|
|
if (PageBuddy(page))
|
|
|
|
continue;
|
|
|
|
|
2012-12-12 00:02:42 +00:00
|
|
|
/*
|
|
|
|
* Check may be lockless but that's ok as we recheck later.
|
|
|
|
* It's possible to migrate LRU pages and balloon pages
|
|
|
|
* Skip any other type of page
|
|
|
|
*/
|
|
|
|
if (!PageLRU(page)) {
|
|
|
|
if (unlikely(balloon_page_movable(page))) {
|
|
|
|
if (locked && balloon_page_isolate(page)) {
|
|
|
|
/* Successfully isolated */
|
2014-04-07 22:37:07 +00:00
|
|
|
goto isolate_success;
|
2012-12-12 00:02:42 +00:00
|
|
|
}
|
|
|
|
}
|
2011-01-13 23:47:08 +00:00
|
|
|
continue;
|
2012-12-12 00:02:42 +00:00
|
|
|
}
|
2011-01-13 23:47:08 +00:00
|
|
|
|
|
|
|
/*
|
2012-10-08 23:32:33 +00:00
|
|
|
* PageLRU is set. lru_lock normally excludes isolation
|
|
|
|
* splitting and collapsing (collapsing has already happened
|
|
|
|
* if PageLRU is set) but the lock is not necessarily taken
|
|
|
|
* here and it is wasteful to take it just to check transhuge.
|
|
|
|
* Check TransHuge without lock and skip the whole pageblock if
|
|
|
|
* it's either a transhuge or hugetlbfs page, as calling
|
|
|
|
* compound_order() without preventing THP from splitting the
|
|
|
|
* page underneath us may return surprising results.
|
2011-01-13 23:47:08 +00:00
|
|
|
*/
|
2012-10-08 23:32:33 +00:00
|
|
|
if (PageTransHuge(page)) {
|
|
|
|
if (!locked)
|
|
|
|
goto next_pageblock;
|
|
|
|
low_pfn += (1 << compound_order(page)) - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2014-04-03 21:48:00 +00:00
|
|
|
/*
|
|
|
|
* Migration will fail if an anonymous page is pinned in memory,
|
|
|
|
* so avoid taking lru_lock and isolating it unnecessarily in an
|
|
|
|
* admittedly racy check.
|
|
|
|
*/
|
|
|
|
if (!page_mapping(page) &&
|
|
|
|
page_count(page) > page_mapcount(page))
|
|
|
|
continue;
|
|
|
|
|
2012-10-08 23:32:33 +00:00
|
|
|
/* Check if it is ok to still hold the lock */
|
|
|
|
locked = compact_checklock_irqsave(&zone->lru_lock, &flags,
|
|
|
|
locked, cc);
|
|
|
|
if (!locked || fatal_signal_pending(current))
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* Recheck PageLRU and PageTransHuge under lock */
|
|
|
|
if (!PageLRU(page))
|
|
|
|
continue;
|
2011-01-13 23:47:08 +00:00
|
|
|
if (PageTransHuge(page)) {
|
|
|
|
low_pfn += (1 << compound_order(page)) - 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-05-29 22:07:09 +00:00
|
|
|
lruvec = mem_cgroup_page_lruvec(page, zone);
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
/* Try isolate the page */
|
2012-05-29 22:06:54 +00:00
|
|
|
if (__isolate_lru_page(page, mode) != 0)
|
2010-05-24 21:32:27 +00:00
|
|
|
continue;
|
|
|
|
|
2014-01-23 23:52:54 +00:00
|
|
|
VM_BUG_ON_PAGE(PageTransCompound(page), page);
|
2011-01-13 23:47:08 +00:00
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
/* Successfully isolated */
|
2012-05-29 22:07:09 +00:00
|
|
|
del_page_from_lru_list(page, lruvec, page_lru(page));
|
2014-04-07 22:37:07 +00:00
|
|
|
|
|
|
|
isolate_success:
|
|
|
|
cc->finished_update_migrate = true;
|
2010-05-24 21:32:27 +00:00
|
|
|
list_add(&page->lru, migratelist);
|
|
|
|
cc->nr_migratepages++;
|
2011-01-13 23:45:54 +00:00
|
|
|
nr_isolated++;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
/* Avoid isolating too much */
|
2012-01-10 23:07:59 +00:00
|
|
|
if (cc->nr_migratepages == COMPACT_CLUSTER_MAX) {
|
|
|
|
++low_pfn;
|
2010-05-24 21:32:27 +00:00
|
|
|
break;
|
2012-01-10 23:07:59 +00:00
|
|
|
}
|
2012-10-08 23:32:33 +00:00
|
|
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
next_pageblock:
|
2013-02-23 00:32:25 +00:00
|
|
|
low_pfn = ALIGN(low_pfn + 1, pageblock_nr_pages) - 1;
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
2012-08-21 23:16:17 +00:00
|
|
|
acct_isolated(zone, locked, cc);
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2012-08-21 23:16:17 +00:00
|
|
|
if (locked)
|
|
|
|
spin_unlock_irqrestore(&zone->lru_lock, flags);
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2014-01-21 23:51:10 +00:00
|
|
|
/*
|
|
|
|
* Update the pageblock-skip information and cached scanner pfn,
|
|
|
|
* if the whole pageblock was scanned without isolating any page.
|
|
|
|
* This is not done when pageblock was skipped due to being unsuitable
|
|
|
|
* for async compaction, so that eventual sync compaction can try.
|
|
|
|
*/
|
|
|
|
if (low_pfn == end_pfn && !skipped_async_unsuitable)
|
2012-10-08 23:32:45 +00:00
|
|
|
update_pageblock_skip(cc, valid_page, nr_isolated, true);
|
2012-10-08 23:32:41 +00:00
|
|
|
|
2011-01-13 23:45:54 +00:00
|
|
|
trace_mm_compaction_isolate_migratepages(nr_scanned, nr_isolated);
|
|
|
|
|
2012-12-20 23:05:06 +00:00
|
|
|
count_compact_events(COMPACTMIGRATE_SCANNED, nr_scanned);
|
2012-10-19 11:00:10 +00:00
|
|
|
if (nr_isolated)
|
2012-12-20 23:05:06 +00:00
|
|
|
count_compact_events(COMPACTISOLATED, nr_isolated);
|
2012-10-19 11:00:10 +00:00
|
|
|
|
2012-01-30 12:16:26 +00:00
|
|
|
return low_pfn;
|
|
|
|
}
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
#endif /* CONFIG_COMPACTION || CONFIG_CMA */
|
|
|
|
#ifdef CONFIG_COMPACTION
|
2012-01-30 12:16:26 +00:00
|
|
|
/*
|
2011-12-29 12:09:50 +00:00
|
|
|
* Based on information in the current compact_control, find blocks
|
|
|
|
* suitable for isolating free pages from and then isolate them.
|
2012-01-30 12:16:26 +00:00
|
|
|
*/
|
2011-12-29 12:09:50 +00:00
|
|
|
static void isolate_freepages(struct zone *zone,
|
|
|
|
struct compact_control *cc)
|
2012-01-30 12:16:26 +00:00
|
|
|
{
|
2011-12-29 12:09:50 +00:00
|
|
|
struct page *page;
|
2013-02-23 00:35:23 +00:00
|
|
|
unsigned long high_pfn, low_pfn, pfn, z_end_pfn, end_pfn;
|
2011-12-29 12:09:50 +00:00
|
|
|
int nr_freepages = cc->nr_freepages;
|
|
|
|
struct list_head *freelist = &cc->freepages;
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
/*
|
|
|
|
* Initialise the free scanner. The starting point is where we last
|
|
|
|
* scanned from (or the end of the zone if starting). The low point
|
|
|
|
* is the end of the pageblock the migration scanner is using.
|
|
|
|
*/
|
|
|
|
pfn = cc->free_pfn;
|
mm: compaction: detect when scanners meet in isolate_freepages
Compaction of a zone is finished when the migrate scanner (which begins
at the zone's lowest pfn) meets the free page scanner (which begins at
the zone's highest pfn). This is detected in compact_zone() and in the
case of direct compaction, the compact_blockskip_flush flag is set so
that kswapd later resets the cached scanner pfn's, and a new compaction
may again start at the zone's borders.
The meeting of the scanners can happen during either scanner's activity.
However, it may currently fail to be detected when it occurs in the free
page scanner, due to two problems. First, isolate_freepages() keeps
free_pfn at the highest block where it isolated pages from, for the
purposes of not missing the pages that are returned back to allocator
when migration fails. Second, failing to isolate enough free pages due
to scanners meeting results in -ENOMEM being returned by
migrate_pages(), which makes compact_zone() bail out immediately without
calling compact_finished() that would detect scanners meeting.
This failure to detect scanners meeting might result in repeated
attempts at compaction of a zone that keep starting from the cached
pfn's close to the meeting point, and quickly failing through the
-ENOMEM path, without the cached pfns being reset, over and over. This
has been observed (through additional tracepoints) in the third phase of
the mmtests stress-highalloc benchmark, where the allocator runs on an
otherwise idle system. The problem was observed in the DMA32 zone,
which was used as a fallback to the preferred Normal zone, but on the
4GB system it was actually the largest zone. The problem is even
amplified for such fallback zone - the deferred compaction logic, which
could (after being fixed by a previous patch) reset the cached scanner
pfn's, is only applied to the preferred zone and not for the fallbacks.
The problem in the third phase of the benchmark was further amplified by
commit 81c0a2bb515f ("mm: page_alloc: fair zone allocator policy") which
resulted in a non-deterministic regression of the allocation success
rate from ~85% to ~65%. This occurs in about half of benchmark runs,
making bisection problematic. It is unlikely that the commit itself is
buggy, but it should put more pressure on the DMA32 zone during phases 1
and 2, which may leave it more fragmented in phase 3 and expose the bugs
that this patch fixes.
The fix is to make scanners meeting in isolate_freepage() stay that way,
and to check in compact_zone() for scanners meeting when migrate_pages()
returns -ENOMEM. The result is that compact_finished() also detects
scanners meeting and sets the compact_blockskip_flush flag to make
kswapd reset the scanner pfn's.
The results in stress-highalloc benchmark show that the "regression" by
commit 81c0a2bb515f in phase 3 no longer occurs, and phase 1 and 2
allocation success rates are also significantly improved.
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:09 +00:00
|
|
|
low_pfn = ALIGN(cc->migrate_pfn + 1, pageblock_nr_pages);
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
/*
|
|
|
|
* Take care that if the migration scanner is at the end of the zone
|
|
|
|
* that the free scanner does not accidentally move to the next zone
|
|
|
|
* in the next isolation cycle.
|
|
|
|
*/
|
|
|
|
high_pfn = min(low_pfn, pfn);
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2013-02-23 00:35:23 +00:00
|
|
|
z_end_pfn = zone_end_pfn(zone);
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
/*
|
|
|
|
* Isolate free pages until enough are available to migrate the
|
|
|
|
* pages on cc->migratepages. We stop searching if the migrate
|
|
|
|
* and free page scanners meet or enough free pages are isolated.
|
|
|
|
*/
|
mm: compaction: detect when scanners meet in isolate_freepages
Compaction of a zone is finished when the migrate scanner (which begins
at the zone's lowest pfn) meets the free page scanner (which begins at
the zone's highest pfn). This is detected in compact_zone() and in the
case of direct compaction, the compact_blockskip_flush flag is set so
that kswapd later resets the cached scanner pfn's, and a new compaction
may again start at the zone's borders.
The meeting of the scanners can happen during either scanner's activity.
However, it may currently fail to be detected when it occurs in the free
page scanner, due to two problems. First, isolate_freepages() keeps
free_pfn at the highest block where it isolated pages from, for the
purposes of not missing the pages that are returned back to allocator
when migration fails. Second, failing to isolate enough free pages due
to scanners meeting results in -ENOMEM being returned by
migrate_pages(), which makes compact_zone() bail out immediately without
calling compact_finished() that would detect scanners meeting.
This failure to detect scanners meeting might result in repeated
attempts at compaction of a zone that keep starting from the cached
pfn's close to the meeting point, and quickly failing through the
-ENOMEM path, without the cached pfns being reset, over and over. This
has been observed (through additional tracepoints) in the third phase of
the mmtests stress-highalloc benchmark, where the allocator runs on an
otherwise idle system. The problem was observed in the DMA32 zone,
which was used as a fallback to the preferred Normal zone, but on the
4GB system it was actually the largest zone. The problem is even
amplified for such fallback zone - the deferred compaction logic, which
could (after being fixed by a previous patch) reset the cached scanner
pfn's, is only applied to the preferred zone and not for the fallbacks.
The problem in the third phase of the benchmark was further amplified by
commit 81c0a2bb515f ("mm: page_alloc: fair zone allocator policy") which
resulted in a non-deterministic regression of the allocation success
rate from ~85% to ~65%. This occurs in about half of benchmark runs,
making bisection problematic. It is unlikely that the commit itself is
buggy, but it should put more pressure on the DMA32 zone during phases 1
and 2, which may leave it more fragmented in phase 3 and expose the bugs
that this patch fixes.
The fix is to make scanners meeting in isolate_freepage() stay that way,
and to check in compact_zone() for scanners meeting when migrate_pages()
returns -ENOMEM. The result is that compact_finished() also detects
scanners meeting and sets the compact_blockskip_flush flag to make
kswapd reset the scanner pfn's.
The results in stress-highalloc benchmark show that the "regression" by
commit 81c0a2bb515f in phase 3 no longer occurs, and phase 1 and 2
allocation success rates are also significantly improved.
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:09 +00:00
|
|
|
for (; pfn >= low_pfn && cc->nr_migratepages > nr_freepages;
|
2011-12-29 12:09:50 +00:00
|
|
|
pfn -= pageblock_nr_pages) {
|
|
|
|
unsigned long isolated;
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2013-09-30 20:45:03 +00:00
|
|
|
/*
|
|
|
|
* This can iterate a massively long zone without finding any
|
|
|
|
* suitable migration targets, so periodically check if we need
|
|
|
|
* to schedule.
|
|
|
|
*/
|
|
|
|
cond_resched();
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
if (!pfn_valid(pfn))
|
|
|
|
continue;
|
2012-01-30 12:16:26 +00:00
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
/*
|
|
|
|
* Check for overlapping nodes/zones. It's possible on some
|
|
|
|
* configurations to have a setup like
|
|
|
|
* node0 node1 node0
|
|
|
|
* i.e. it's possible that all pages within a zones range of
|
|
|
|
* pages do not belong to a single zone.
|
|
|
|
*/
|
|
|
|
page = pfn_to_page(pfn);
|
|
|
|
if (page_zone(page) != zone)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* Check the block is suitable for migration */
|
2012-06-04 03:05:57 +00:00
|
|
|
if (!suitable_migration_target(page))
|
2011-12-29 12:09:50 +00:00
|
|
|
continue;
|
2012-06-04 03:05:57 +00:00
|
|
|
|
2012-10-08 23:32:41 +00:00
|
|
|
/* If isolation recently failed, do not retry */
|
|
|
|
if (!isolation_suitable(cc, page))
|
|
|
|
continue;
|
|
|
|
|
2012-10-08 23:32:36 +00:00
|
|
|
/* Found a block suitable for isolating free pages from */
|
2011-12-29 12:09:50 +00:00
|
|
|
isolated = 0;
|
2012-12-06 19:01:14 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* As pfn may not start aligned, pfn+pageblock_nr_page
|
|
|
|
* may cross a MAX_ORDER_NR_PAGES boundary and miss
|
|
|
|
* a pfn_valid check. Ensure isolate_freepages_block()
|
|
|
|
* only scans within a pageblock
|
|
|
|
*/
|
|
|
|
end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
|
2013-02-23 00:35:23 +00:00
|
|
|
end_pfn = min(end_pfn, z_end_pfn);
|
2012-10-08 23:32:36 +00:00
|
|
|
isolated = isolate_freepages_block(cc, pfn, end_pfn,
|
|
|
|
freelist, false);
|
|
|
|
nr_freepages += isolated;
|
2011-12-29 12:09:50 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Record the highest PFN we isolated pages from. When next
|
|
|
|
* looking for free pages, the search will restart here as
|
|
|
|
* page migration may have returned some pages to the allocator
|
|
|
|
*/
|
2012-10-08 23:32:45 +00:00
|
|
|
if (isolated) {
|
|
|
|
cc->finished_update_free = true;
|
2011-12-29 12:09:50 +00:00
|
|
|
high_pfn = max(high_pfn, pfn);
|
2012-10-08 23:32:45 +00:00
|
|
|
}
|
2011-12-29 12:09:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* split_free_page does not map the pages */
|
|
|
|
map_pages(freelist);
|
|
|
|
|
mm: compaction: detect when scanners meet in isolate_freepages
Compaction of a zone is finished when the migrate scanner (which begins
at the zone's lowest pfn) meets the free page scanner (which begins at
the zone's highest pfn). This is detected in compact_zone() and in the
case of direct compaction, the compact_blockskip_flush flag is set so
that kswapd later resets the cached scanner pfn's, and a new compaction
may again start at the zone's borders.
The meeting of the scanners can happen during either scanner's activity.
However, it may currently fail to be detected when it occurs in the free
page scanner, due to two problems. First, isolate_freepages() keeps
free_pfn at the highest block where it isolated pages from, for the
purposes of not missing the pages that are returned back to allocator
when migration fails. Second, failing to isolate enough free pages due
to scanners meeting results in -ENOMEM being returned by
migrate_pages(), which makes compact_zone() bail out immediately without
calling compact_finished() that would detect scanners meeting.
This failure to detect scanners meeting might result in repeated
attempts at compaction of a zone that keep starting from the cached
pfn's close to the meeting point, and quickly failing through the
-ENOMEM path, without the cached pfns being reset, over and over. This
has been observed (through additional tracepoints) in the third phase of
the mmtests stress-highalloc benchmark, where the allocator runs on an
otherwise idle system. The problem was observed in the DMA32 zone,
which was used as a fallback to the preferred Normal zone, but on the
4GB system it was actually the largest zone. The problem is even
amplified for such fallback zone - the deferred compaction logic, which
could (after being fixed by a previous patch) reset the cached scanner
pfn's, is only applied to the preferred zone and not for the fallbacks.
The problem in the third phase of the benchmark was further amplified by
commit 81c0a2bb515f ("mm: page_alloc: fair zone allocator policy") which
resulted in a non-deterministic regression of the allocation success
rate from ~85% to ~65%. This occurs in about half of benchmark runs,
making bisection problematic. It is unlikely that the commit itself is
buggy, but it should put more pressure on the DMA32 zone during phases 1
and 2, which may leave it more fragmented in phase 3 and expose the bugs
that this patch fixes.
The fix is to make scanners meeting in isolate_freepage() stay that way,
and to check in compact_zone() for scanners meeting when migrate_pages()
returns -ENOMEM. The result is that compact_finished() also detects
scanners meeting and sets the compact_blockskip_flush flag to make
kswapd reset the scanner pfn's.
The results in stress-highalloc benchmark show that the "regression" by
commit 81c0a2bb515f in phase 3 no longer occurs, and phase 1 and 2
allocation success rates are also significantly improved.
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:09 +00:00
|
|
|
/*
|
|
|
|
* If we crossed the migrate scanner, we want to keep it that way
|
|
|
|
* so that compact_finished() may detect this
|
|
|
|
*/
|
|
|
|
if (pfn < low_pfn)
|
|
|
|
cc->free_pfn = max(pfn, zone->zone_start_pfn);
|
|
|
|
else
|
|
|
|
cc->free_pfn = high_pfn;
|
2011-12-29 12:09:50 +00:00
|
|
|
cc->nr_freepages = nr_freepages;
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is a migrate-callback that "allocates" freepages by taking pages
|
|
|
|
* from the isolated freelists in the block we are migrating to.
|
|
|
|
*/
|
|
|
|
static struct page *compaction_alloc(struct page *migratepage,
|
|
|
|
unsigned long data,
|
|
|
|
int **result)
|
|
|
|
{
|
|
|
|
struct compact_control *cc = (struct compact_control *)data;
|
|
|
|
struct page *freepage;
|
|
|
|
|
|
|
|
/* Isolate free pages if necessary */
|
|
|
|
if (list_empty(&cc->freepages)) {
|
|
|
|
isolate_freepages(cc->zone, cc);
|
|
|
|
|
|
|
|
if (list_empty(&cc->freepages))
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
freepage = list_entry(cc->freepages.next, struct page, lru);
|
|
|
|
list_del(&freepage->lru);
|
|
|
|
cc->nr_freepages--;
|
|
|
|
|
|
|
|
return freepage;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We cannot control nr_migratepages and nr_freepages fully when migration is
|
|
|
|
* running as migrate_pages() has no knowledge of compact_control. When
|
|
|
|
* migration is complete, we count the number of pages on the lists by hand.
|
|
|
|
*/
|
|
|
|
static void update_nr_listpages(struct compact_control *cc)
|
|
|
|
{
|
|
|
|
int nr_migratepages = 0;
|
|
|
|
int nr_freepages = 0;
|
|
|
|
struct page *page;
|
|
|
|
|
|
|
|
list_for_each_entry(page, &cc->migratepages, lru)
|
|
|
|
nr_migratepages++;
|
|
|
|
list_for_each_entry(page, &cc->freepages, lru)
|
|
|
|
nr_freepages++;
|
|
|
|
|
|
|
|
cc->nr_migratepages = nr_migratepages;
|
|
|
|
cc->nr_freepages = nr_freepages;
|
|
|
|
}
|
|
|
|
|
2011-12-29 12:09:50 +00:00
|
|
|
/* possible outcome of isolate_migratepages */
|
|
|
|
typedef enum {
|
|
|
|
ISOLATE_ABORT, /* Abort compaction now */
|
|
|
|
ISOLATE_NONE, /* No pages isolated, continue scanning */
|
|
|
|
ISOLATE_SUCCESS, /* Pages isolated, migrate */
|
|
|
|
} isolate_migrate_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Isolate all pages that can be migrated from the block pointed to by
|
|
|
|
* the migrate scanner within compact_control.
|
|
|
|
*/
|
|
|
|
static isolate_migrate_t isolate_migratepages(struct zone *zone,
|
|
|
|
struct compact_control *cc)
|
|
|
|
{
|
|
|
|
unsigned long low_pfn, end_pfn;
|
|
|
|
|
|
|
|
/* Do not scan outside zone boundaries */
|
|
|
|
low_pfn = max(cc->migrate_pfn, zone->zone_start_pfn);
|
|
|
|
|
|
|
|
/* Only scan within a pageblock boundary */
|
2013-02-23 00:32:25 +00:00
|
|
|
end_pfn = ALIGN(low_pfn + 1, pageblock_nr_pages);
|
2011-12-29 12:09:50 +00:00
|
|
|
|
|
|
|
/* Do not cross the free scanner or scan within a memory hole */
|
|
|
|
if (end_pfn > cc->free_pfn || !pfn_valid(low_pfn)) {
|
|
|
|
cc->migrate_pfn = end_pfn;
|
|
|
|
return ISOLATE_NONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Perform the isolation */
|
2012-10-08 23:33:48 +00:00
|
|
|
low_pfn = isolate_migratepages_range(zone, cc, low_pfn, end_pfn, false);
|
2012-10-08 23:32:27 +00:00
|
|
|
if (!low_pfn || cc->contended)
|
2011-12-29 12:09:50 +00:00
|
|
|
return ISOLATE_ABORT;
|
|
|
|
|
|
|
|
cc->migrate_pfn = low_pfn;
|
|
|
|
|
|
|
|
return ISOLATE_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
static int compact_finished(struct zone *zone,
|
2011-01-13 23:47:11 +00:00
|
|
|
struct compact_control *cc)
|
2010-05-24 21:32:27 +00:00
|
|
|
{
|
2013-01-11 22:32:16 +00:00
|
|
|
unsigned int order;
|
2011-01-13 23:47:11 +00:00
|
|
|
unsigned long watermark;
|
2010-05-24 21:32:30 +00:00
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
if (fatal_signal_pending(current))
|
|
|
|
return COMPACT_PARTIAL;
|
|
|
|
|
2012-10-08 23:32:40 +00:00
|
|
|
/* Compaction run completes if the migrate and free scanner meet */
|
2012-10-08 23:32:41 +00:00
|
|
|
if (cc->free_pfn <= cc->migrate_pfn) {
|
2014-01-21 23:51:11 +00:00
|
|
|
/* Let the next compaction start anew. */
|
|
|
|
zone->compact_cached_migrate_pfn = zone->zone_start_pfn;
|
|
|
|
zone->compact_cached_free_pfn = zone_end_pfn(zone);
|
|
|
|
|
2012-10-08 23:32:47 +00:00
|
|
|
/*
|
|
|
|
* Mark that the PG_migrate_skip information should be cleared
|
|
|
|
* by kswapd when it goes to sleep. kswapd does not set the
|
|
|
|
* flag itself as the decision to be clear should be directly
|
|
|
|
* based on an allocation request.
|
|
|
|
*/
|
|
|
|
if (!current_is_kswapd())
|
|
|
|
zone->compact_blockskip_flush = true;
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
return COMPACT_COMPLETE;
|
2012-10-08 23:32:41 +00:00
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2011-01-20 22:44:21 +00:00
|
|
|
/*
|
|
|
|
* order == -1 is expected when compacting via
|
|
|
|
* /proc/sys/vm/compact_memory
|
|
|
|
*/
|
2010-05-24 21:32:30 +00:00
|
|
|
if (cc->order == -1)
|
|
|
|
return COMPACT_CONTINUE;
|
|
|
|
|
2011-06-15 22:08:25 +00:00
|
|
|
/* Compaction run is not finished if the watermark is not met */
|
|
|
|
watermark = low_wmark_pages(zone);
|
|
|
|
watermark += (1 << cc->order);
|
|
|
|
|
|
|
|
if (!zone_watermark_ok(zone, cc->order, watermark, 0, 0))
|
|
|
|
return COMPACT_CONTINUE;
|
|
|
|
|
2010-05-24 21:32:30 +00:00
|
|
|
/* Direct compactor: Is a suitable page free? */
|
2013-01-11 22:32:16 +00:00
|
|
|
for (order = cc->order; order < MAX_ORDER; order++) {
|
|
|
|
struct free_area *area = &zone->free_area[order];
|
|
|
|
|
|
|
|
/* Job done if page is free of the right migratetype */
|
|
|
|
if (!list_empty(&area->free_list[cc->migratetype]))
|
|
|
|
return COMPACT_PARTIAL;
|
|
|
|
|
|
|
|
/* Job done if allocation would set block type */
|
|
|
|
if (cc->order >= pageblock_order && area->nr_free)
|
2010-05-24 21:32:30 +00:00
|
|
|
return COMPACT_PARTIAL;
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
return COMPACT_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2011-01-13 23:45:56 +00:00
|
|
|
/*
|
|
|
|
* compaction_suitable: Is this suitable to run compaction on this zone now?
|
|
|
|
* Returns
|
|
|
|
* COMPACT_SKIPPED - If there are too few free pages for compaction
|
|
|
|
* COMPACT_PARTIAL - If the allocation would succeed without compaction
|
|
|
|
* COMPACT_CONTINUE - If compaction should run now
|
|
|
|
*/
|
|
|
|
unsigned long compaction_suitable(struct zone *zone, int order)
|
|
|
|
{
|
|
|
|
int fragindex;
|
|
|
|
unsigned long watermark;
|
|
|
|
|
2011-06-15 22:08:25 +00:00
|
|
|
/*
|
|
|
|
* order == -1 is expected when compacting via
|
|
|
|
* /proc/sys/vm/compact_memory
|
|
|
|
*/
|
|
|
|
if (order == -1)
|
|
|
|
return COMPACT_CONTINUE;
|
|
|
|
|
2011-01-13 23:45:56 +00:00
|
|
|
/*
|
|
|
|
* Watermarks for order-0 must be met for compaction. Note the 2UL.
|
|
|
|
* This is because during migration, copies of pages need to be
|
|
|
|
* allocated and for a short time, the footprint is higher
|
|
|
|
*/
|
|
|
|
watermark = low_wmark_pages(zone) + (2UL << order);
|
|
|
|
if (!zone_watermark_ok(zone, 0, watermark, 0, 0))
|
|
|
|
return COMPACT_SKIPPED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* fragmentation index determines if allocation failures are due to
|
|
|
|
* low memory or external fragmentation
|
|
|
|
*
|
2011-06-15 22:08:49 +00:00
|
|
|
* index of -1000 implies allocations might succeed depending on
|
|
|
|
* watermarks
|
2011-01-13 23:45:56 +00:00
|
|
|
* index towards 0 implies failure is due to lack of memory
|
|
|
|
* index towards 1000 implies failure is due to fragmentation
|
|
|
|
*
|
|
|
|
* Only compact if a failure would be due to fragmentation.
|
|
|
|
*/
|
|
|
|
fragindex = fragmentation_index(zone, order);
|
|
|
|
if (fragindex >= 0 && fragindex <= sysctl_extfrag_threshold)
|
|
|
|
return COMPACT_SKIPPED;
|
|
|
|
|
2011-06-15 22:08:49 +00:00
|
|
|
if (fragindex == -1000 && zone_watermark_ok(zone, order, watermark,
|
|
|
|
0, 0))
|
2011-01-13 23:45:56 +00:00
|
|
|
return COMPACT_PARTIAL;
|
|
|
|
|
|
|
|
return COMPACT_CONTINUE;
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
static int compact_zone(struct zone *zone, struct compact_control *cc)
|
|
|
|
{
|
|
|
|
int ret;
|
2012-10-08 23:32:45 +00:00
|
|
|
unsigned long start_pfn = zone->zone_start_pfn;
|
2013-02-23 00:35:23 +00:00
|
|
|
unsigned long end_pfn = zone_end_pfn(zone);
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2011-01-13 23:45:56 +00:00
|
|
|
ret = compaction_suitable(zone, cc->order);
|
|
|
|
switch (ret) {
|
|
|
|
case COMPACT_PARTIAL:
|
|
|
|
case COMPACT_SKIPPED:
|
|
|
|
/* Compaction is likely to fail */
|
|
|
|
return ret;
|
|
|
|
case COMPACT_CONTINUE:
|
|
|
|
/* Fall through to compaction */
|
|
|
|
;
|
|
|
|
}
|
|
|
|
|
2014-01-21 23:51:08 +00:00
|
|
|
/*
|
|
|
|
* Clear pageblock skip if there were failures recently and compaction
|
|
|
|
* is about to be retried after being deferred. kswapd does not do
|
|
|
|
* this reset as it'll reset the cached information when going to sleep.
|
|
|
|
*/
|
|
|
|
if (compaction_restarting(zone, cc->order) && !current_is_kswapd())
|
|
|
|
__reset_isolation_suitable(zone);
|
|
|
|
|
2012-10-08 23:32:45 +00:00
|
|
|
/*
|
|
|
|
* Setup to move all movable pages to the end of the zone. Used cached
|
|
|
|
* information on where the scanners should start but check that it
|
|
|
|
* is initialised by ensuring the values are within zone boundaries.
|
|
|
|
*/
|
|
|
|
cc->migrate_pfn = zone->compact_cached_migrate_pfn;
|
|
|
|
cc->free_pfn = zone->compact_cached_free_pfn;
|
|
|
|
if (cc->free_pfn < start_pfn || cc->free_pfn > end_pfn) {
|
|
|
|
cc->free_pfn = end_pfn & ~(pageblock_nr_pages-1);
|
|
|
|
zone->compact_cached_free_pfn = cc->free_pfn;
|
|
|
|
}
|
|
|
|
if (cc->migrate_pfn < start_pfn || cc->migrate_pfn > end_pfn) {
|
|
|
|
cc->migrate_pfn = start_pfn;
|
|
|
|
zone->compact_cached_migrate_pfn = cc->migrate_pfn;
|
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
|
mm: compaction: trace compaction begin and end
The broad goal of the series is to improve allocation success rates for
huge pages through memory compaction, while trying not to increase the
compaction overhead. The original objective was to reintroduce
capturing of high-order pages freed by the compaction, before they are
split by concurrent activity. However, several bugs and opportunities
for simple improvements were found in the current implementation, mostly
through extra tracepoints (which are however too ugly for now to be
considered for sending).
The patches mostly deal with two mechanisms that reduce compaction
overhead, which is caching the progress of migrate and free scanners,
and marking pageblocks where isolation failed to be skipped during
further scans.
Patch 1 (from mgorman) adds tracepoints that allow calculate time spent in
compaction and potentially debug scanner pfn values.
Patch 2 encapsulates the some functionality for handling deferred compactions
for better maintainability, without a functional change
type is not determined without being actually needed.
Patch 3 fixes a bug where cached scanner pfn's are sometimes reset only after
they have been read to initialize a compaction run.
Patch 4 fixes a bug where scanners meeting is sometimes not properly detected
and can lead to multiple compaction attempts quitting early without
doing any work.
Patch 5 improves the chances of sync compaction to process pageblocks that
async compaction has skipped due to being !MIGRATE_MOVABLE.
Patch 6 improves the chances of sync direct compaction to actually do anything
when called after async compaction fails during allocation slowpath.
The impact of patches were validated using mmtests's stress-highalloc
benchmark with mmtests's stress-highalloc benchmark on a x86_64 machine
with 4GB memory.
Due to instability of the results (mostly related to the bugs fixed by
patches 2 and 3), 10 iterations were performed, taking min,mean,max
values for success rates and mean values for time and vmstat-based
metrics.
First, the default GFP_HIGHUSER_MOVABLE allocations were tested with the
patches stacked on top of v3.13-rc2. Patch 2 is OK to serve as baseline
due to no functional changes in 1 and 2. Comments below.
stress-highalloc
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
Success 1 Min 9.00 ( 0.00%) 10.00 (-11.11%) 43.00 (-377.78%) 43.00 (-377.78%) 33.00 (-266.67%)
Success 1 Mean 27.50 ( 0.00%) 25.30 ( 8.00%) 45.50 (-65.45%) 45.90 (-66.91%) 46.30 (-68.36%)
Success 1 Max 36.00 ( 0.00%) 36.00 ( 0.00%) 47.00 (-30.56%) 48.00 (-33.33%) 52.00 (-44.44%)
Success 2 Min 10.00 ( 0.00%) 8.00 ( 20.00%) 46.00 (-360.00%) 45.00 (-350.00%) 35.00 (-250.00%)
Success 2 Mean 26.40 ( 0.00%) 23.50 ( 10.98%) 47.30 (-79.17%) 47.60 (-80.30%) 48.10 (-82.20%)
Success 2 Max 34.00 ( 0.00%) 33.00 ( 2.94%) 48.00 (-41.18%) 50.00 (-47.06%) 54.00 (-58.82%)
Success 3 Min 65.00 ( 0.00%) 63.00 ( 3.08%) 85.00 (-30.77%) 84.00 (-29.23%) 85.00 (-30.77%)
Success 3 Mean 76.70 ( 0.00%) 70.50 ( 8.08%) 86.20 (-12.39%) 85.50 (-11.47%) 86.00 (-12.13%)
Success 3 Max 87.00 ( 0.00%) 86.00 ( 1.15%) 88.00 ( -1.15%) 87.00 ( 0.00%) 87.00 ( 0.00%)
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
User 6437.72 6459.76 5960.32 5974.55 6019.67
System 1049.65 1049.09 1029.32 1031.47 1032.31
Elapsed 1856.77 1874.48 1949.97 1994.22 1983.15
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
Minor Faults 253952267 254581900 250030122 250507333 250157829
Major Faults 420 407 506 530 530
Swap Ins 4 9 9 6 6
Swap Outs 398 375 345 346 333
Direct pages scanned 197538 189017 298574 287019 299063
Kswapd pages scanned 1809843 1801308 1846674 1873184 1861089
Kswapd pages reclaimed 1806972 1798684 1844219 1870509 1858622
Direct pages reclaimed 197227 188829 298380 286822 298835
Kswapd efficiency 99% 99% 99% 99% 99%
Kswapd velocity 953.382 970.449 952.243 934.569 922.286
Direct efficiency 99% 99% 99% 99% 99%
Direct velocity 104.058 101.832 153.961 143.200 148.205
Percentage direct scans 9% 9% 13% 13% 13%
Zone normal velocity 347.289 359.676 348.063 339.933 332.983
Zone dma32 velocity 710.151 712.605 758.140 737.835 737.507
Zone dma velocity 0.000 0.000 0.000 0.000 0.000
Page writes by reclaim 557.600 429.000 353.600 426.400 381.800
Page writes file 159 53 7 79 48
Page writes anon 398 375 345 346 333
Page reclaim immediate 825 644 411 575 420
Sector Reads 2781750 2769780 2878547 2939128 2910483
Sector Writes 12080843 12083351 12012892 12002132 12010745
Page rescued immediate 0 0 0 0 0
Slabs scanned 1575654 1545344 1778406 1786700 1794073
Direct inode steals 9657 10037 15795 14104 14645
Kswapd inode steals 46857 46335 50543 50716 51796
Kswapd skipped wait 0 0 0 0 0
THP fault alloc 97 91 81 71 77
THP collapse alloc 456 506 546 544 565
THP splits 6 5 5 4 4
THP fault fallback 0 1 0 0 0
THP collapse fail 14 14 12 13 12
Compaction stalls 1006 980 1537 1536 1548
Compaction success 303 284 562 559 578
Compaction failures 702 696 974 976 969
Page migrate success 1177325 1070077 3927538 3781870 3877057
Page migrate failure 0 0 0 0 0
Compaction pages isolated 2547248 2306457 8301218 8008500 8200674
Compaction migrate scanned 42290478 38832618 153961130 154143900 159141197
Compaction free scanned 89199429 79189151 356529027 351943166 356326727
Compaction cost 1566 1426 5312 5156 5294
NUMA PTE updates 0 0 0 0 0
NUMA hint faults 0 0 0 0 0
NUMA hint local faults 0 0 0 0 0
NUMA hint local percent 100 100 100 100 100
NUMA pages migrated 0 0 0 0 0
AutoNUMA cost 0 0 0 0 0
Observations:
- The "Success 3" line is allocation success rate with system idle
(phases 1 and 2 are with background interference). I used to get stable
values around 85% with vanilla 3.11. The lower min and mean values came
with 3.12. This was bisected to commit 81c0a2bb ("mm: page_alloc: fair
zone allocator policy") As explained in comment for patch 3, I don't
think the commit is wrong, but that it makes the effect of compaction
bugs worse. From patch 3 onwards, the results are OK and match the 3.11
results.
- Patch 4 also clearly helps phases 1 and 2, and exceeds any results
I've seen with 3.11 (I didn't measure it that thoroughly then, but it
was never above 40%).
- Compaction cost and number of scanned pages is higher, especially due
to patch 4. However, keep in mind that patches 3 and 4 fix existing
bugs in the current design of compaction overhead mitigation, they do
not change it. If overhead is found unacceptable, then it should be
decreased differently (and consistently, not due to random conditions)
than the current implementation does. In contrast, patches 5 and 6
(which are not strictly bug fixes) do not increase the overhead (but
also not success rates). This might be a limitation of the
stress-highalloc benchmark as it's quite uniform.
Another set of results is when configuring stress-highalloc t allocate
with similar flags as THP uses:
(GFP_HIGHUSER_MOVABLE|__GFP_NOMEMALLOC|__GFP_NORETRY|__GFP_NO_KSWAPD)
stress-highalloc
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
Success 1 Min 2.00 ( 0.00%) 7.00 (-250.00%) 18.00 (-800.00%) 19.00 (-850.00%) 26.00 (-1200.00%)
Success 1 Mean 19.20 ( 0.00%) 17.80 ( 7.29%) 29.20 (-52.08%) 29.90 (-55.73%) 32.80 (-70.83%)
Success 1 Max 27.00 ( 0.00%) 29.00 ( -7.41%) 35.00 (-29.63%) 36.00 (-33.33%) 37.00 (-37.04%)
Success 2 Min 3.00 ( 0.00%) 8.00 (-166.67%) 21.00 (-600.00%) 21.00 (-600.00%) 32.00 (-966.67%)
Success 2 Mean 19.30 ( 0.00%) 17.90 ( 7.25%) 32.20 (-66.84%) 32.60 (-68.91%) 35.70 (-84.97%)
Success 2 Max 27.00 ( 0.00%) 30.00 (-11.11%) 36.00 (-33.33%) 37.00 (-37.04%) 39.00 (-44.44%)
Success 3 Min 62.00 ( 0.00%) 62.00 ( 0.00%) 85.00 (-37.10%) 75.00 (-20.97%) 64.00 ( -3.23%)
Success 3 Mean 66.30 ( 0.00%) 65.50 ( 1.21%) 85.60 (-29.11%) 83.40 (-25.79%) 83.50 (-25.94%)
Success 3 Max 70.00 ( 0.00%) 69.00 ( 1.43%) 87.00 (-24.29%) 86.00 (-22.86%) 87.00 (-24.29%)
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
User 6547.93 6475.85 6265.54 6289.46 6189.96
System 1053.42 1047.28 1043.23 1042.73 1038.73
Elapsed 1835.43 1821.96 1908.67 1912.74 1956.38
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
Minor Faults 256805673 253106328 253222299 249830289 251184418
Major Faults 395 375 423 434 448
Swap Ins 12 10 10 12 9
Swap Outs 530 537 487 455 415
Direct pages scanned 71859 86046 153244 152764 190713
Kswapd pages scanned 1900994 1870240 1898012 1892864 1880520
Kswapd pages reclaimed 1897814 1867428 1894939 1890125 1877924
Direct pages reclaimed 71766 85908 153167 152643 190600
Kswapd efficiency 99% 99% 99% 99% 99%
Kswapd velocity 1029.000 1067.782 1000.091 991.049 951.218
Direct efficiency 99% 99% 99% 99% 99%
Direct velocity 38.897 49.127 80.747 79.983 96.468
Percentage direct scans 3% 4% 7% 7% 9%
Zone normal velocity 351.377 372.494 348.910 341.689 335.310
Zone dma32 velocity 716.520 744.414 731.928 729.343 712.377
Zone dma velocity 0.000 0.000 0.000 0.000 0.000
Page writes by reclaim 669.300 604.000 545.700 538.900 429.900
Page writes file 138 66 58 83 14
Page writes anon 530 537 487 455 415
Page reclaim immediate 806 655 772 548 517
Sector Reads 2711956 2703239 2811602 2818248 2839459
Sector Writes 12163238 12018662 12038248 11954736 11994892
Page rescued immediate 0 0 0 0 0
Slabs scanned 1385088 1388364 1507968 1513292 1558656
Direct inode steals 1739 2564 4622 5496 6007
Kswapd inode steals 47461 46406 47804 48013 48466
Kswapd skipped wait 0 0 0 0 0
THP fault alloc 110 82 84 69 70
THP collapse alloc 445 482 467 462 539
THP splits 6 5 4 5 3
THP fault fallback 3 0 0 0 0
THP collapse fail 15 14 14 14 13
Compaction stalls 659 685 1033 1073 1111
Compaction success 222 225 410 427 456
Compaction failures 436 460 622 646 655
Page migrate success 446594 439978 1085640 1095062 1131716
Page migrate failure 0 0 0 0 0
Compaction pages isolated 1029475 1013490 2453074 2482698 2565400
Compaction migrate scanned 9955461 11344259 24375202 27978356 30494204
Compaction free scanned 27715272 28544654 80150615 82898631 85756132
Compaction cost 552 555 1344 1379 1436
NUMA PTE updates 0 0 0 0 0
NUMA hint faults 0 0 0 0 0
NUMA hint local faults 0 0 0 0 0
NUMA hint local percent 100 100 100 100 100
NUMA pages migrated 0 0 0 0 0
AutoNUMA cost 0 0 0 0 0
There are some differences from the previous results for THP-like allocations:
- Here, the bad result for unpatched kernel in phase 3 is much more
consistent to be between 65-70% and not related to the "regression" in
3.12. Still there is the improvement from patch 4 onwards, which brings
it on par with simple GFP_HIGHUSER_MOVABLE allocations.
- Compaction costs have increased, but nowhere near as much as the
non-THP case. Again, the patches should be worth the gained
determininsm.
- Patches 5 and 6 somewhat increase the number of migrate-scanned pages.
This is most likely due to __GFP_NO_KSWAPD flag, which means the cached
pfn's and pageblock skip bits are not reset by kswapd that often (at
least in phase 3 where no concurrent activity would wake up kswapd) and
the patches thus help the sync-after-async compaction. It doesn't
however show that the sync compaction would help so much with success
rates, which can be again seen as a limitation of the benchmark
scenario.
This patch (of 6):
Add two tracepoints for compaction begin and end of a zone. Using this it
is possible to calculate how much time a workload is spending within
compaction and potentially debug problems related to cached pfns for
scanning. In combination with the direct reclaim and slab trace points it
should be possible to estimate most allocation-related overhead for a
workload.
Signed-off-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:05 +00:00
|
|
|
trace_mm_compaction_begin(start_pfn, cc->migrate_pfn, cc->free_pfn, end_pfn);
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
migrate_prep_local();
|
|
|
|
|
|
|
|
while ((ret = compact_finished(zone, cc)) == COMPACT_CONTINUE) {
|
|
|
|
unsigned long nr_migrate, nr_remaining;
|
2011-03-22 23:30:39 +00:00
|
|
|
int err;
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2011-06-15 22:08:52 +00:00
|
|
|
switch (isolate_migratepages(zone, cc)) {
|
|
|
|
case ISOLATE_ABORT:
|
|
|
|
ret = COMPACT_PARTIAL;
|
2012-12-12 00:02:47 +00:00
|
|
|
putback_movable_pages(&cc->migratepages);
|
2012-10-08 23:32:27 +00:00
|
|
|
cc->nr_migratepages = 0;
|
2011-06-15 22:08:52 +00:00
|
|
|
goto out;
|
|
|
|
case ISOLATE_NONE:
|
2010-05-24 21:32:27 +00:00
|
|
|
continue;
|
2011-06-15 22:08:52 +00:00
|
|
|
case ISOLATE_SUCCESS:
|
|
|
|
;
|
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
|
|
|
|
nr_migrate = cc->nr_migratepages;
|
2011-03-22 23:30:39 +00:00
|
|
|
err = migrate_pages(&cc->migratepages, compaction_alloc,
|
2013-02-23 00:35:14 +00:00
|
|
|
(unsigned long)cc,
|
2012-10-19 13:07:31 +00:00
|
|
|
cc->sync ? MIGRATE_SYNC_LIGHT : MIGRATE_ASYNC,
|
|
|
|
MR_COMPACTION);
|
2010-05-24 21:32:27 +00:00
|
|
|
update_nr_listpages(cc);
|
|
|
|
nr_remaining = cc->nr_migratepages;
|
|
|
|
|
2011-01-13 23:45:54 +00:00
|
|
|
trace_mm_compaction_migratepages(nr_migrate - nr_remaining,
|
|
|
|
nr_remaining);
|
2010-05-24 21:32:27 +00:00
|
|
|
|
2012-12-12 00:02:47 +00:00
|
|
|
/* Release isolated pages not migrated */
|
2011-03-22 23:30:39 +00:00
|
|
|
if (err) {
|
2012-12-12 00:02:47 +00:00
|
|
|
putback_movable_pages(&cc->migratepages);
|
2010-05-24 21:32:27 +00:00
|
|
|
cc->nr_migratepages = 0;
|
mm: compaction: detect when scanners meet in isolate_freepages
Compaction of a zone is finished when the migrate scanner (which begins
at the zone's lowest pfn) meets the free page scanner (which begins at
the zone's highest pfn). This is detected in compact_zone() and in the
case of direct compaction, the compact_blockskip_flush flag is set so
that kswapd later resets the cached scanner pfn's, and a new compaction
may again start at the zone's borders.
The meeting of the scanners can happen during either scanner's activity.
However, it may currently fail to be detected when it occurs in the free
page scanner, due to two problems. First, isolate_freepages() keeps
free_pfn at the highest block where it isolated pages from, for the
purposes of not missing the pages that are returned back to allocator
when migration fails. Second, failing to isolate enough free pages due
to scanners meeting results in -ENOMEM being returned by
migrate_pages(), which makes compact_zone() bail out immediately without
calling compact_finished() that would detect scanners meeting.
This failure to detect scanners meeting might result in repeated
attempts at compaction of a zone that keep starting from the cached
pfn's close to the meeting point, and quickly failing through the
-ENOMEM path, without the cached pfns being reset, over and over. This
has been observed (through additional tracepoints) in the third phase of
the mmtests stress-highalloc benchmark, where the allocator runs on an
otherwise idle system. The problem was observed in the DMA32 zone,
which was used as a fallback to the preferred Normal zone, but on the
4GB system it was actually the largest zone. The problem is even
amplified for such fallback zone - the deferred compaction logic, which
could (after being fixed by a previous patch) reset the cached scanner
pfn's, is only applied to the preferred zone and not for the fallbacks.
The problem in the third phase of the benchmark was further amplified by
commit 81c0a2bb515f ("mm: page_alloc: fair zone allocator policy") which
resulted in a non-deterministic regression of the allocation success
rate from ~85% to ~65%. This occurs in about half of benchmark runs,
making bisection problematic. It is unlikely that the commit itself is
buggy, but it should put more pressure on the DMA32 zone during phases 1
and 2, which may leave it more fragmented in phase 3 and expose the bugs
that this patch fixes.
The fix is to make scanners meeting in isolate_freepage() stay that way,
and to check in compact_zone() for scanners meeting when migrate_pages()
returns -ENOMEM. The result is that compact_finished() also detects
scanners meeting and sets the compact_blockskip_flush flag to make
kswapd reset the scanner pfn's.
The results in stress-highalloc benchmark show that the "regression" by
commit 81c0a2bb515f in phase 3 no longer occurs, and phase 1 and 2
allocation success rates are also significantly improved.
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:09 +00:00
|
|
|
/*
|
|
|
|
* migrate_pages() may return -ENOMEM when scanners meet
|
|
|
|
* and we want compact_finished() to detect it
|
|
|
|
*/
|
|
|
|
if (err == -ENOMEM && cc->free_pfn > cc->migrate_pfn) {
|
2012-07-11 21:02:13 +00:00
|
|
|
ret = COMPACT_PARTIAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2010-05-24 21:32:27 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-15 22:08:52 +00:00
|
|
|
out:
|
2010-05-24 21:32:27 +00:00
|
|
|
/* Release free pages and check accounting */
|
|
|
|
cc->nr_freepages -= release_freepages(&cc->freepages);
|
|
|
|
VM_BUG_ON(cc->nr_freepages != 0);
|
|
|
|
|
mm: compaction: trace compaction begin and end
The broad goal of the series is to improve allocation success rates for
huge pages through memory compaction, while trying not to increase the
compaction overhead. The original objective was to reintroduce
capturing of high-order pages freed by the compaction, before they are
split by concurrent activity. However, several bugs and opportunities
for simple improvements were found in the current implementation, mostly
through extra tracepoints (which are however too ugly for now to be
considered for sending).
The patches mostly deal with two mechanisms that reduce compaction
overhead, which is caching the progress of migrate and free scanners,
and marking pageblocks where isolation failed to be skipped during
further scans.
Patch 1 (from mgorman) adds tracepoints that allow calculate time spent in
compaction and potentially debug scanner pfn values.
Patch 2 encapsulates the some functionality for handling deferred compactions
for better maintainability, without a functional change
type is not determined without being actually needed.
Patch 3 fixes a bug where cached scanner pfn's are sometimes reset only after
they have been read to initialize a compaction run.
Patch 4 fixes a bug where scanners meeting is sometimes not properly detected
and can lead to multiple compaction attempts quitting early without
doing any work.
Patch 5 improves the chances of sync compaction to process pageblocks that
async compaction has skipped due to being !MIGRATE_MOVABLE.
Patch 6 improves the chances of sync direct compaction to actually do anything
when called after async compaction fails during allocation slowpath.
The impact of patches were validated using mmtests's stress-highalloc
benchmark with mmtests's stress-highalloc benchmark on a x86_64 machine
with 4GB memory.
Due to instability of the results (mostly related to the bugs fixed by
patches 2 and 3), 10 iterations were performed, taking min,mean,max
values for success rates and mean values for time and vmstat-based
metrics.
First, the default GFP_HIGHUSER_MOVABLE allocations were tested with the
patches stacked on top of v3.13-rc2. Patch 2 is OK to serve as baseline
due to no functional changes in 1 and 2. Comments below.
stress-highalloc
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
Success 1 Min 9.00 ( 0.00%) 10.00 (-11.11%) 43.00 (-377.78%) 43.00 (-377.78%) 33.00 (-266.67%)
Success 1 Mean 27.50 ( 0.00%) 25.30 ( 8.00%) 45.50 (-65.45%) 45.90 (-66.91%) 46.30 (-68.36%)
Success 1 Max 36.00 ( 0.00%) 36.00 ( 0.00%) 47.00 (-30.56%) 48.00 (-33.33%) 52.00 (-44.44%)
Success 2 Min 10.00 ( 0.00%) 8.00 ( 20.00%) 46.00 (-360.00%) 45.00 (-350.00%) 35.00 (-250.00%)
Success 2 Mean 26.40 ( 0.00%) 23.50 ( 10.98%) 47.30 (-79.17%) 47.60 (-80.30%) 48.10 (-82.20%)
Success 2 Max 34.00 ( 0.00%) 33.00 ( 2.94%) 48.00 (-41.18%) 50.00 (-47.06%) 54.00 (-58.82%)
Success 3 Min 65.00 ( 0.00%) 63.00 ( 3.08%) 85.00 (-30.77%) 84.00 (-29.23%) 85.00 (-30.77%)
Success 3 Mean 76.70 ( 0.00%) 70.50 ( 8.08%) 86.20 (-12.39%) 85.50 (-11.47%) 86.00 (-12.13%)
Success 3 Max 87.00 ( 0.00%) 86.00 ( 1.15%) 88.00 ( -1.15%) 87.00 ( 0.00%) 87.00 ( 0.00%)
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
User 6437.72 6459.76 5960.32 5974.55 6019.67
System 1049.65 1049.09 1029.32 1031.47 1032.31
Elapsed 1856.77 1874.48 1949.97 1994.22 1983.15
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-nothp 3-nothp 4-nothp 5-nothp 6-nothp
Minor Faults 253952267 254581900 250030122 250507333 250157829
Major Faults 420 407 506 530 530
Swap Ins 4 9 9 6 6
Swap Outs 398 375 345 346 333
Direct pages scanned 197538 189017 298574 287019 299063
Kswapd pages scanned 1809843 1801308 1846674 1873184 1861089
Kswapd pages reclaimed 1806972 1798684 1844219 1870509 1858622
Direct pages reclaimed 197227 188829 298380 286822 298835
Kswapd efficiency 99% 99% 99% 99% 99%
Kswapd velocity 953.382 970.449 952.243 934.569 922.286
Direct efficiency 99% 99% 99% 99% 99%
Direct velocity 104.058 101.832 153.961 143.200 148.205
Percentage direct scans 9% 9% 13% 13% 13%
Zone normal velocity 347.289 359.676 348.063 339.933 332.983
Zone dma32 velocity 710.151 712.605 758.140 737.835 737.507
Zone dma velocity 0.000 0.000 0.000 0.000 0.000
Page writes by reclaim 557.600 429.000 353.600 426.400 381.800
Page writes file 159 53 7 79 48
Page writes anon 398 375 345 346 333
Page reclaim immediate 825 644 411 575 420
Sector Reads 2781750 2769780 2878547 2939128 2910483
Sector Writes 12080843 12083351 12012892 12002132 12010745
Page rescued immediate 0 0 0 0 0
Slabs scanned 1575654 1545344 1778406 1786700 1794073
Direct inode steals 9657 10037 15795 14104 14645
Kswapd inode steals 46857 46335 50543 50716 51796
Kswapd skipped wait 0 0 0 0 0
THP fault alloc 97 91 81 71 77
THP collapse alloc 456 506 546 544 565
THP splits 6 5 5 4 4
THP fault fallback 0 1 0 0 0
THP collapse fail 14 14 12 13 12
Compaction stalls 1006 980 1537 1536 1548
Compaction success 303 284 562 559 578
Compaction failures 702 696 974 976 969
Page migrate success 1177325 1070077 3927538 3781870 3877057
Page migrate failure 0 0 0 0 0
Compaction pages isolated 2547248 2306457 8301218 8008500 8200674
Compaction migrate scanned 42290478 38832618 153961130 154143900 159141197
Compaction free scanned 89199429 79189151 356529027 351943166 356326727
Compaction cost 1566 1426 5312 5156 5294
NUMA PTE updates 0 0 0 0 0
NUMA hint faults 0 0 0 0 0
NUMA hint local faults 0 0 0 0 0
NUMA hint local percent 100 100 100 100 100
NUMA pages migrated 0 0 0 0 0
AutoNUMA cost 0 0 0 0 0
Observations:
- The "Success 3" line is allocation success rate with system idle
(phases 1 and 2 are with background interference). I used to get stable
values around 85% with vanilla 3.11. The lower min and mean values came
with 3.12. This was bisected to commit 81c0a2bb ("mm: page_alloc: fair
zone allocator policy") As explained in comment for patch 3, I don't
think the commit is wrong, but that it makes the effect of compaction
bugs worse. From patch 3 onwards, the results are OK and match the 3.11
results.
- Patch 4 also clearly helps phases 1 and 2, and exceeds any results
I've seen with 3.11 (I didn't measure it that thoroughly then, but it
was never above 40%).
- Compaction cost and number of scanned pages is higher, especially due
to patch 4. However, keep in mind that patches 3 and 4 fix existing
bugs in the current design of compaction overhead mitigation, they do
not change it. If overhead is found unacceptable, then it should be
decreased differently (and consistently, not due to random conditions)
than the current implementation does. In contrast, patches 5 and 6
(which are not strictly bug fixes) do not increase the overhead (but
also not success rates). This might be a limitation of the
stress-highalloc benchmark as it's quite uniform.
Another set of results is when configuring stress-highalloc t allocate
with similar flags as THP uses:
(GFP_HIGHUSER_MOVABLE|__GFP_NOMEMALLOC|__GFP_NORETRY|__GFP_NO_KSWAPD)
stress-highalloc
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
Success 1 Min 2.00 ( 0.00%) 7.00 (-250.00%) 18.00 (-800.00%) 19.00 (-850.00%) 26.00 (-1200.00%)
Success 1 Mean 19.20 ( 0.00%) 17.80 ( 7.29%) 29.20 (-52.08%) 29.90 (-55.73%) 32.80 (-70.83%)
Success 1 Max 27.00 ( 0.00%) 29.00 ( -7.41%) 35.00 (-29.63%) 36.00 (-33.33%) 37.00 (-37.04%)
Success 2 Min 3.00 ( 0.00%) 8.00 (-166.67%) 21.00 (-600.00%) 21.00 (-600.00%) 32.00 (-966.67%)
Success 2 Mean 19.30 ( 0.00%) 17.90 ( 7.25%) 32.20 (-66.84%) 32.60 (-68.91%) 35.70 (-84.97%)
Success 2 Max 27.00 ( 0.00%) 30.00 (-11.11%) 36.00 (-33.33%) 37.00 (-37.04%) 39.00 (-44.44%)
Success 3 Min 62.00 ( 0.00%) 62.00 ( 0.00%) 85.00 (-37.10%) 75.00 (-20.97%) 64.00 ( -3.23%)
Success 3 Mean 66.30 ( 0.00%) 65.50 ( 1.21%) 85.60 (-29.11%) 83.40 (-25.79%) 83.50 (-25.94%)
Success 3 Max 70.00 ( 0.00%) 69.00 ( 1.43%) 87.00 (-24.29%) 86.00 (-22.86%) 87.00 (-24.29%)
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
User 6547.93 6475.85 6265.54 6289.46 6189.96
System 1053.42 1047.28 1043.23 1042.73 1038.73
Elapsed 1835.43 1821.96 1908.67 1912.74 1956.38
3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2 3.13-rc2
2-thp 3-thp 4-thp 5-thp 6-thp
Minor Faults 256805673 253106328 253222299 249830289 251184418
Major Faults 395 375 423 434 448
Swap Ins 12 10 10 12 9
Swap Outs 530 537 487 455 415
Direct pages scanned 71859 86046 153244 152764 190713
Kswapd pages scanned 1900994 1870240 1898012 1892864 1880520
Kswapd pages reclaimed 1897814 1867428 1894939 1890125 1877924
Direct pages reclaimed 71766 85908 153167 152643 190600
Kswapd efficiency 99% 99% 99% 99% 99%
Kswapd velocity 1029.000 1067.782 1000.091 991.049 951.218
Direct efficiency 99% 99% 99% 99% 99%
Direct velocity 38.897 49.127 80.747 79.983 96.468
Percentage direct scans 3% 4% 7% 7% 9%
Zone normal velocity 351.377 372.494 348.910 341.689 335.310
Zone dma32 velocity 716.520 744.414 731.928 729.343 712.377
Zone dma velocity 0.000 0.000 0.000 0.000 0.000
Page writes by reclaim 669.300 604.000 545.700 538.900 429.900
Page writes file 138 66 58 83 14
Page writes anon 530 537 487 455 415
Page reclaim immediate 806 655 772 548 517
Sector Reads 2711956 2703239 2811602 2818248 2839459
Sector Writes 12163238 12018662 12038248 11954736 11994892
Page rescued immediate 0 0 0 0 0
Slabs scanned 1385088 1388364 1507968 1513292 1558656
Direct inode steals 1739 2564 4622 5496 6007
Kswapd inode steals 47461 46406 47804 48013 48466
Kswapd skipped wait 0 0 0 0 0
THP fault alloc 110 82 84 69 70
THP collapse alloc 445 482 467 462 539
THP splits 6 5 4 5 3
THP fault fallback 3 0 0 0 0
THP collapse fail 15 14 14 14 13
Compaction stalls 659 685 1033 1073 1111
Compaction success 222 225 410 427 456
Compaction failures 436 460 622 646 655
Page migrate success 446594 439978 1085640 1095062 1131716
Page migrate failure 0 0 0 0 0
Compaction pages isolated 1029475 1013490 2453074 2482698 2565400
Compaction migrate scanned 9955461 11344259 24375202 27978356 30494204
Compaction free scanned 27715272 28544654 80150615 82898631 85756132
Compaction cost 552 555 1344 1379 1436
NUMA PTE updates 0 0 0 0 0
NUMA hint faults 0 0 0 0 0
NUMA hint local faults 0 0 0 0 0
NUMA hint local percent 100 100 100 100 100
NUMA pages migrated 0 0 0 0 0
AutoNUMA cost 0 0 0 0 0
There are some differences from the previous results for THP-like allocations:
- Here, the bad result for unpatched kernel in phase 3 is much more
consistent to be between 65-70% and not related to the "regression" in
3.12. Still there is the improvement from patch 4 onwards, which brings
it on par with simple GFP_HIGHUSER_MOVABLE allocations.
- Compaction costs have increased, but nowhere near as much as the
non-THP case. Again, the patches should be worth the gained
determininsm.
- Patches 5 and 6 somewhat increase the number of migrate-scanned pages.
This is most likely due to __GFP_NO_KSWAPD flag, which means the cached
pfn's and pageblock skip bits are not reset by kswapd that often (at
least in phase 3 where no concurrent activity would wake up kswapd) and
the patches thus help the sync-after-async compaction. It doesn't
however show that the sync compaction would help so much with success
rates, which can be again seen as a limitation of the benchmark
scenario.
This patch (of 6):
Add two tracepoints for compaction begin and end of a zone. Using this it
is possible to calculate how much time a workload is spending within
compaction and potentially debug problems related to cached pfns for
scanning. In combination with the direct reclaim and slab trace points it
should be possible to estimate most allocation-related overhead for a
workload.
Signed-off-by: Mel Gorman <mgorman@suse.de>
Signed-off-by: Vlastimil Babka <vbabka@suse.cz>
Cc: Rik van Riel <riel@redhat.com>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2014-01-21 23:51:05 +00:00
|
|
|
trace_mm_compaction_end(ret);
|
|
|
|
|
2010-05-24 21:32:27 +00:00
|
|
|
return ret;
|
|
|
|
}
|
2010-05-24 21:32:28 +00:00
|
|
|
|
2011-11-01 00:09:08 +00:00
|
|
|
static unsigned long compact_zone_order(struct zone *zone,
|
2011-01-13 23:47:11 +00:00
|
|
|
int order, gfp_t gfp_mask,
|
2013-01-11 22:32:16 +00:00
|
|
|
bool sync, bool *contended)
|
2010-05-24 21:32:30 +00:00
|
|
|
{
|
2012-10-08 23:32:27 +00:00
|
|
|
unsigned long ret;
|
2010-05-24 21:32:30 +00:00
|
|
|
struct compact_control cc = {
|
|
|
|
.nr_freepages = 0,
|
|
|
|
.nr_migratepages = 0,
|
|
|
|
.order = order,
|
|
|
|
.migratetype = allocflags_to_migratetype(gfp_mask),
|
|
|
|
.zone = zone,
|
2012-06-04 03:05:57 +00:00
|
|
|
.sync = sync,
|
2010-05-24 21:32:30 +00:00
|
|
|
};
|
|
|
|
INIT_LIST_HEAD(&cc.freepages);
|
|
|
|
INIT_LIST_HEAD(&cc.migratepages);
|
|
|
|
|
2012-10-08 23:32:27 +00:00
|
|
|
ret = compact_zone(zone, &cc);
|
|
|
|
|
|
|
|
VM_BUG_ON(!list_empty(&cc.freepages));
|
|
|
|
VM_BUG_ON(!list_empty(&cc.migratepages));
|
|
|
|
|
|
|
|
*contended = cc.contended;
|
|
|
|
return ret;
|
2010-05-24 21:32:30 +00:00
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:31 +00:00
|
|
|
int sysctl_extfrag_threshold = 500;
|
|
|
|
|
2010-05-24 21:32:30 +00:00
|
|
|
/**
|
|
|
|
* try_to_compact_pages - Direct compact to satisfy a high-order allocation
|
|
|
|
* @zonelist: The zonelist used for the current allocation
|
|
|
|
* @order: The order of the current allocation
|
|
|
|
* @gfp_mask: The GFP mask of the current allocation
|
|
|
|
* @nodemask: The allowed nodes to allocate from
|
2011-01-13 23:45:57 +00:00
|
|
|
* @sync: Whether migration is synchronous or not
|
2012-10-08 23:32:31 +00:00
|
|
|
* @contended: Return value that is true if compaction was aborted due to lock contention
|
|
|
|
* @page: Optionally capture a free page of the requested order during compaction
|
2010-05-24 21:32:30 +00:00
|
|
|
*
|
|
|
|
* This is the main entry point for direct page compaction.
|
|
|
|
*/
|
|
|
|
unsigned long try_to_compact_pages(struct zonelist *zonelist,
|
2011-01-13 23:45:57 +00:00
|
|
|
int order, gfp_t gfp_mask, nodemask_t *nodemask,
|
2013-01-11 22:32:16 +00:00
|
|
|
bool sync, bool *contended)
|
2010-05-24 21:32:30 +00:00
|
|
|
{
|
|
|
|
enum zone_type high_zoneidx = gfp_zone(gfp_mask);
|
|
|
|
int may_enter_fs = gfp_mask & __GFP_FS;
|
|
|
|
int may_perform_io = gfp_mask & __GFP_IO;
|
|
|
|
struct zoneref *z;
|
|
|
|
struct zone *zone;
|
|
|
|
int rc = COMPACT_SKIPPED;
|
2012-10-08 23:32:05 +00:00
|
|
|
int alloc_flags = 0;
|
2010-05-24 21:32:30 +00:00
|
|
|
|
2012-10-08 23:29:09 +00:00
|
|
|
/* Check if the GFP flags allow compaction */
|
2011-01-13 23:47:11 +00:00
|
|
|
if (!order || !may_enter_fs || !may_perform_io)
|
2010-05-24 21:32:30 +00:00
|
|
|
return rc;
|
|
|
|
|
2012-12-20 23:05:06 +00:00
|
|
|
count_compact_event(COMPACTSTALL);
|
2010-05-24 21:32:30 +00:00
|
|
|
|
2012-10-08 23:32:05 +00:00
|
|
|
#ifdef CONFIG_CMA
|
|
|
|
if (allocflags_to_migratetype(gfp_mask) == MIGRATE_MOVABLE)
|
|
|
|
alloc_flags |= ALLOC_CMA;
|
|
|
|
#endif
|
2010-05-24 21:32:30 +00:00
|
|
|
/* Compact each zone in the list */
|
|
|
|
for_each_zone_zonelist_nodemask(zone, z, zonelist, high_zoneidx,
|
|
|
|
nodemask) {
|
|
|
|
int status;
|
|
|
|
|
2012-08-21 23:16:17 +00:00
|
|
|
status = compact_zone_order(zone, order, gfp_mask, sync,
|
2013-01-11 22:32:16 +00:00
|
|
|
contended);
|
2010-05-24 21:32:30 +00:00
|
|
|
rc = max(status, rc);
|
|
|
|
|
2011-01-13 23:45:56 +00:00
|
|
|
/* If a normal allocation would succeed, stop compacting */
|
2012-10-08 23:32:05 +00:00
|
|
|
if (zone_watermark_ok(zone, order, low_wmark_pages(zone), 0,
|
|
|
|
alloc_flags))
|
2010-05-24 21:32:30 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-24 21:32:28 +00:00
|
|
|
/* Compact all zones within a node */
|
2013-02-23 00:32:33 +00:00
|
|
|
static void __compact_pgdat(pg_data_t *pgdat, struct compact_control *cc)
|
2010-05-24 21:32:28 +00:00
|
|
|
{
|
|
|
|
int zoneid;
|
|
|
|
struct zone *zone;
|
|
|
|
|
|
|
|
for (zoneid = 0; zoneid < MAX_NR_ZONES; zoneid++) {
|
|
|
|
|
|
|
|
zone = &pgdat->node_zones[zoneid];
|
|
|
|
if (!populated_zone(zone))
|
|
|
|
continue;
|
|
|
|
|
2012-03-21 23:33:52 +00:00
|
|
|
cc->nr_freepages = 0;
|
|
|
|
cc->nr_migratepages = 0;
|
|
|
|
cc->zone = zone;
|
|
|
|
INIT_LIST_HEAD(&cc->freepages);
|
|
|
|
INIT_LIST_HEAD(&cc->migratepages);
|
2010-05-24 21:32:28 +00:00
|
|
|
|
2012-03-21 23:33:54 +00:00
|
|
|
if (cc->order == -1 || !compaction_deferred(zone, cc->order))
|
2012-03-21 23:33:52 +00:00
|
|
|
compact_zone(zone, cc);
|
2010-05-24 21:32:28 +00:00
|
|
|
|
2012-03-21 23:33:52 +00:00
|
|
|
if (cc->order > 0) {
|
2014-01-21 23:51:07 +00:00
|
|
|
if (zone_watermark_ok(zone, cc->order,
|
|
|
|
low_wmark_pages(zone), 0, 0))
|
|
|
|
compaction_defer_reset(zone, cc->order, false);
|
2012-03-21 23:33:52 +00:00
|
|
|
/* Currently async compaction is never deferred. */
|
2014-01-21 23:51:07 +00:00
|
|
|
else if (cc->sync)
|
2012-03-21 23:33:52 +00:00
|
|
|
defer_compaction(zone, cc->order);
|
|
|
|
}
|
|
|
|
|
2012-03-21 23:33:52 +00:00
|
|
|
VM_BUG_ON(!list_empty(&cc->freepages));
|
|
|
|
VM_BUG_ON(!list_empty(&cc->migratepages));
|
2010-05-24 21:32:28 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-23 00:32:33 +00:00
|
|
|
void compact_pgdat(pg_data_t *pgdat, int order)
|
2012-03-21 23:33:52 +00:00
|
|
|
{
|
|
|
|
struct compact_control cc = {
|
|
|
|
.order = order,
|
2012-06-04 03:05:57 +00:00
|
|
|
.sync = false,
|
2012-03-21 23:33:52 +00:00
|
|
|
};
|
|
|
|
|
2013-09-11 21:22:19 +00:00
|
|
|
if (!order)
|
|
|
|
return;
|
|
|
|
|
2013-02-23 00:32:33 +00:00
|
|
|
__compact_pgdat(pgdat, &cc);
|
2012-03-21 23:33:52 +00:00
|
|
|
}
|
|
|
|
|
2013-02-23 00:32:33 +00:00
|
|
|
static void compact_node(int nid)
|
2012-03-21 23:33:52 +00:00
|
|
|
{
|
|
|
|
struct compact_control cc = {
|
|
|
|
.order = -1,
|
2012-06-04 03:05:57 +00:00
|
|
|
.sync = true,
|
2014-04-03 21:47:23 +00:00
|
|
|
.ignore_skip_hint = true,
|
2012-03-21 23:33:52 +00:00
|
|
|
};
|
|
|
|
|
2013-02-23 00:32:33 +00:00
|
|
|
__compact_pgdat(NODE_DATA(nid), &cc);
|
2012-03-21 23:33:52 +00:00
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:28 +00:00
|
|
|
/* Compact all nodes in the system */
|
2013-01-11 22:31:47 +00:00
|
|
|
static void compact_nodes(void)
|
2010-05-24 21:32:28 +00:00
|
|
|
{
|
|
|
|
int nid;
|
|
|
|
|
2012-03-21 23:33:53 +00:00
|
|
|
/* Flush pending updates to the LRU lists */
|
|
|
|
lru_add_drain_all();
|
|
|
|
|
2010-05-24 21:32:28 +00:00
|
|
|
for_each_online_node(nid)
|
|
|
|
compact_node(nid);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The written value is actually unused, all memory is compacted */
|
|
|
|
int sysctl_compact_memory;
|
|
|
|
|
|
|
|
/* This is the entry point for compacting all nodes via /proc/sys/vm */
|
|
|
|
int sysctl_compaction_handler(struct ctl_table *table, int write,
|
|
|
|
void __user *buffer, size_t *length, loff_t *ppos)
|
|
|
|
{
|
|
|
|
if (write)
|
2013-01-11 22:31:47 +00:00
|
|
|
compact_nodes();
|
2010-05-24 21:32:28 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2010-05-24 21:32:29 +00:00
|
|
|
|
2010-05-24 21:32:31 +00:00
|
|
|
int sysctl_extfrag_handler(struct ctl_table *table, int write,
|
|
|
|
void __user *buffer, size_t *length, loff_t *ppos)
|
|
|
|
{
|
|
|
|
proc_dointvec_minmax(table, write, buffer, length, ppos);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-05-24 21:32:29 +00:00
|
|
|
#if defined(CONFIG_SYSFS) && defined(CONFIG_NUMA)
|
2014-04-03 21:48:01 +00:00
|
|
|
static ssize_t sysfs_compact_node(struct device *dev,
|
2011-12-21 22:48:43 +00:00
|
|
|
struct device_attribute *attr,
|
2010-05-24 21:32:29 +00:00
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2012-03-21 23:33:53 +00:00
|
|
|
int nid = dev->id;
|
|
|
|
|
|
|
|
if (nid >= 0 && nid < nr_node_ids && node_online(nid)) {
|
|
|
|
/* Flush pending updates to the LRU lists */
|
|
|
|
lru_add_drain_all();
|
|
|
|
|
|
|
|
compact_node(nid);
|
|
|
|
}
|
2010-05-24 21:32:29 +00:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2011-12-21 22:48:43 +00:00
|
|
|
static DEVICE_ATTR(compact, S_IWUSR, NULL, sysfs_compact_node);
|
2010-05-24 21:32:29 +00:00
|
|
|
|
|
|
|
int compaction_register_node(struct node *node)
|
|
|
|
{
|
2011-12-21 22:48:43 +00:00
|
|
|
return device_create_file(&node->dev, &dev_attr_compact);
|
2010-05-24 21:32:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void compaction_unregister_node(struct node *node)
|
|
|
|
{
|
2011-12-21 22:48:43 +00:00
|
|
|
return device_remove_file(&node->dev, &dev_attr_compact);
|
2010-05-24 21:32:29 +00:00
|
|
|
}
|
|
|
|
#endif /* CONFIG_SYSFS && CONFIG_NUMA */
|
2011-12-29 12:09:50 +00:00
|
|
|
|
|
|
|
#endif /* CONFIG_COMPACTION */
|