v3: fix hugetlb vs. anon-thp copy page
Subsystems (3)
v3 cover v3: fix hugetlb vs. anon-thp copy page
This took some of Mel's comments in to consideration. Dave Jiang, could you retest this if you get a chance? These have only been lightly compile-tested.
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH v3 1/2 mm: hugetlbfs: Add VM_BUG_ON()s to catch non-hugetlbfs pages
From: Dave Hansen <[email protected]>
Changes from v2:
* Removed the VM_BUG_ON() from copy_huge_page() since the next patch makes it able to handle non-hugetlbfs pages
--
Dave Jiang reported that he was seeing oopses when running NUMA systems and default_hugepagesz=1G. I traced the issue down to migrate_page_copy() trying to use the same code for hugetlb pages and transparent hugepages. It should not have been trying to pass thp pages in there.
So, add a VM_BUG_ON()s for the next hapless developer that tries to use page_hstate() on a non-hugetlbfs page.
---
linux.git-davehans/include/linux/hugetlb.h | 1 + 1 file changed, 1 insertion(+)
include/linux/hugetlb.h renamed from include/linux/hugetlb.h~bug-not-hugetlbfs-in-copy_huge_page +1 -0
@@ -355,6 +355,7 @@ static inline pte_t arch_make_huge_pte(pstatic inline struct hstate *page_hstate (struct page *page) { +VM_BUG_ON (!PageHuge (page));return size_to_hstate (PAGE_SIZE <<compound_order (page)); }
_
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH v3 2/2 mm: thp: give transparent hugepage code a separate copy_page
In reply to Dave HansenChanges from v2:
*
Changes from v1:
* removed explicit might_sleep() in favor of the one that we get from the cond_resched();
--
From: Dave Hansen <[email protected]>
Right now, the migration code in migrate_page_copy() uses copy_huge_page() for hugetlbfs and thp pages:
if (PageHuge(page) || PageTransHuge(page))
copy_huge_page(newpage, page);So, yay for code reuse. But:
void copy_huge_page(struct page *dst, struct page *src)
{
struct hstate *h = page_hstate(src);and a non-hugetlbfs page has no page_hstate(). This works 99% of the time because page_hstate() determines the hstate from the page order alone. Since the page order of a THP page matches the default hugetlbfs page order, it works.
But, if you change the default huge page size on the boot command-line (say default_hugepagesz=1G), then we might not even *have* a 2MB hstate so page_hstate() returns null and copy_huge_page() oopses pretty fast since copy_huge_page() dereferences the hstate:
void copy_huge_page(struct page *dst, struct page *src)
{
struct hstate *h = page_hstate(src);
if (unlikely(pages_per_huge_page(h) > MAX_ORDER_NR_PAGES)) {...
Mel noticed that the migration code is really the only user of these functions. This moves all the copy code over to migrate.c and makes copy_huge_page() work for THP by checking for it explicitly.
I believe the bug was introduced in b32967ff101:
Author: Mel Gorman <[email protected]>
Date: Mon Nov 19 12:35:47 2012 +0000
mm: numa: Add THP migration for the NUMA working set scanning fault case.
---
linux.git-davehans/include/linux/hugetlb.h | 4 -- linux.git-davehans/mm/hugetlb.c | 34 -------------------- linux.git-davehans/mm/migrate.c | 48 +++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+), 38 deletions(-)
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +48 -0
@@ -442,6 +442,54 @@ int migrate_huge_page_move_mapping(struc }/* +* Gigantic pages are so large that the we do not guarantee +* that page++ pointer arithmetic will work across the +* entire page. We need something more specialized. +*/ +static void __copy_gigantic_page (struct page *dst,struct page *src, +int nr_pages) +{ +int i; +struct page *dst_base = dst; +struct page *src_base = src; + +for (i =0 ; i < nr_pages; ) { +cond_resched (); +copy_highpage (dst, src); + + i++; + dst =mem_map_next (dst, dst_base, i); + src =mem_map_next (src, src_base, i); + } +} + +static void copy_huge_page (struct page *dst,struct page *src) +{ +int i; +int nr_pages; + +if (PageHuge (src)) { +/* hugetlbfs page */ +struct hstate *h =page_hstate (src); + nr_pages =pages_per_huge_page (h); + +if (unlikely (nr_pages >MAX_ORDER_NR_PAGES )) { +__copy_gigantic_page (dst, src, nr_pages); +return ; + } + }else { +/* thp page */ +BUG_ON (!PageTransHuge (src)); + nr_pages =hpage_nr_pages (src); + } + +for (i =0 ; i < nr_pages; i++ ) { +cond_resched (); +copy_highpage (dst + i, src + i); + } +} + +/* * Copy the page to its new location */ void migrate_page_copy (struct page *newpage,struct page *page)
mm/hugetlb.c renamed from mm/hugetlb.c~copy-huge-separate-from-copy-transhuge +0 -34
@@ -476,40 +476,6 @@ static int vma_has_reserves(struct vm_arreturn 0 ; } -static void copy_gigantic_page (struct page *dst,struct page *src) -{ -int i; -struct hstate *h =page_hstate (src); -struct page *dst_base = dst; -struct page *src_base = src; - -for (i =0 ; i <pages_per_huge_page (h); ) { -cond_resched (); -copy_highpage (dst, src); - - i++; - dst =mem_map_next (dst, dst_base, i); - src =mem_map_next (src, src_base, i); - } -} - -void copy_huge_page (struct page *dst,struct page *src) -{ -int i; -struct hstate *h =page_hstate (src); - -if (unlikely (pages_per_huge_page (h) >MAX_ORDER_NR_PAGES )) { -copy_gigantic_page (dst, src); -return ; - } - -might_sleep (); -for (i =0 ; i <pages_per_huge_page (h); i++) { -cond_resched (); -copy_highpage (dst + i, src + i); - } -} -static void enqueue_huge_page (struct hstate *h,struct page *page) {int nid =page_to_nid (page);
include/linux/hugetlb.h renamed from include/linux/hugetlb.h~copy-huge-separate-from-copy-transhuge +0 -4
@@ -69,7 +69,6 @@ int dequeue_hwpoisoned_huge_page(structbool isolate_huge_page (struct page *page,struct list_head *list);void putback_active_hugepage (struct page *page);bool is_hugepage_active (struct page *page); -void copy_huge_page (struct page *dst,struct page *src);#ifdef CONFIG_ARCH_WANT_HUGE_PMD_SHARE pte_t *huge_pmd_share (struct mm_struct *mm,unsigned long addr,pud_t *pud);
@@ -140,9 +139,6 @@ static inline int dequeue_hwpoisoned_hug#define isolate_huge_page (p, l) false#define putback_active_hugepage (p) do {} while (0)#define is_hugepage_active (x) false -static inline void copy_huge_page (struct page *dst,struct page *src) -{ -}static inline unsigned long hugetlb_change_protection (struct vm_area_struct *vma,unsigned long address,unsigned long end,pgprot_t newprot)
_
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [v3][PATCH 2/2] mm: thp: give transparent hugepage code a separate copy_page
Quoted 45 lines · Dave Hansen
Changes from v2:
*
Changes from v1:
* removed explicitmight_sleep()in favor of the one that we get from thecond_resched();--
From: Dave Hansen <[email protected]>
Right now, the migration code in
migrate_page_copy()usescopy_huge_page()for hugetlbfs and thp pages:if (PageHuge(page) || PageTransHuge(page)) copy_huge_page(newpage, page);So, yay for code reuse. But:
void
copy_huge_page(struct page *dst, struct page *src){ struct hstate *h = page_hstate(src);and a non-hugetlbfs page has no
page_hstate(). This works 99% of the time becausepage_hstate()determines the hstate from the page order alone. Since the page order of a THP page matches the default hugetlbfs page order, it works.But, if you change the default huge page size on the boot command-line (say default_hugepagesz=1G), then we might not even *have* a 2MB hstate so
page_hstate()returns null andcopy_huge_page()oopses pretty fast sincecopy_huge_page()dereferences the hstate:void
copy_huge_page(struct page *dst, struct page *src){ struct hstate *h = page_hstate(src); if (unlikely(pages_per_huge_page(h) > MAX_ORDER_NR_PAGES)) {...
Mel noticed that the migration code is really the only user of these functions. This moves all the copy code over to
migrate.cand makescopy_huge_page()work for THP by checking for it explicitly.
Quoted 6 lines
I believe the bug was introduced in
b32967ff101:
Author: Mel Gorman <[email protected]>
Date: Mon Nov 19 12:35:47 2012 +0000
mm: numa: Add THP migration for the NUMA working set scanning fault case.Signed-off-by Dave Hansen <[email protected]>
Signature · 8 lines
Mel Gorman SUSE Labs -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [v3][PATCH 2/2] mm: thp: give transparent hugepage code aseparate copy_page
In reply to Dave HansenQuoted 45 lines · Dave Hansen
Changes from v2:
*
Changes from v1:
* removed explicitmight_sleep()in favor of the one that we get from thecond_resched();--
From: Dave Hansen <[email protected]>
Right now, the migration code in
migrate_page_copy()usescopy_huge_page()for hugetlbfs and thp pages:if (PageHuge(page) || PageTransHuge(page)) copy_huge_page(newpage, page);So, yay for code reuse. But:
void
copy_huge_page(struct page *dst, struct page *src){ struct hstate *h = page_hstate(src);and a non-hugetlbfs page has no
page_hstate(). This works 99% of the time becausepage_hstate()determines the hstate from the page order alone. Since the page order of a THP page matches the default hugetlbfs page order, it works.But, if you change the default huge page size on the boot command-line (say default_hugepagesz=1G), then we might not even *have* a 2MB hstate so
page_hstate()returns null andcopy_huge_page()oopses pretty fast sincecopy_huge_page()dereferences the hstate:void
copy_huge_page(struct page *dst, struct page *src){ struct hstate *h = page_hstate(src); if (unlikely(pages_per_huge_page(h) > MAX_ORDER_NR_PAGES)) {...
Mel noticed that the migration code is really the only user of these functions. This moves all the copy code over to
migrate.cand makescopy_huge_page()work for THP by checking for it explicitly.
Quoted 6 lines
I believe the bug was introduced in
b32967ff101:
Author: Mel Gorman <[email protected]>
Date: Mon Nov 19 12:35:47 2012 +0000
mm: numa: Add THP migration for the NUMA working set scanning fault case.Signed-off-by Dave Hansen <[email protected]>
Looks good to me with a few comments below. Thanks.
Quoted 11 lines
---
linux.git-davehans/include/linux/hugetlb.h | 4 -- linux.git-davehans/mm/hugetlb.c | 34 -------------------- linux.git-davehans/mm/migrate.c | 48 +++++++++++++++++++++++++++++ 3 files changed, 48 insertions(+), 38 deletions(-)diff -puN
mm/migrate.c~copy-huge-separate-from-copy-transhugemm/migrate.c
mm/migrate.c int migrate_huge_page_move_mapping(struc · line 445
Quoted 4 lines
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +1
-0@@ -442,6 +442,54 @@ int migrate_huge_page_move_mapping(struc }/* +* Gigantic pages are so large that the we do not guarantee
s/the // ?
mm/migrate.c int migrate_huge_page_move_mapping(struc · line 457
Quoted 12 lines
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +12
-0+* that page++ pointer arithmetic will work across the +* entire page. We need something more specialized. +*/ +static void __copy_gigantic_page (struct page *dst,struct page *src, +int nr_pages) +{ +int i; +struct page *dst_base = dst; +struct page *src_base = src; + +for (i =0 ; i < nr_pages; ) { +cond_resched ();
I think that this cond_resched() seems to be called too often. One cond_resched() per MAX_ORDER_NR_PAGES pages copy looks better than per single page copy. So I'll post a separate patch for this which is appled on top of your patches.
Quoted 19 lines
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +19
-0+copy_highpage (dst, src); + + i++; + dst =mem_map_next (dst, dst_base, i); + src =mem_map_next (src, src_base, i); + } +} + +static void copy_huge_page (struct page *dst,struct page *src) +{ +int i; +int nr_pages; + +if (PageHuge (src)) { +/* hugetlbfs page */ +struct hstate *h =page_hstate (src); + nr_pages =pages_per_huge_page (h); + +if (unlikely (nr_pages >MAX_ORDER_NR_PAGES )) {
mm/migrate.c int migrate_huge_page_move_mapping(struc · line 486
Quoted 10 lines
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +10
-0+__copy_gigantic_page (dst, src, nr_pages); +return ; + } + }else { +/* thp page */ +BUG_ON (!PageTransHuge (src)); + nr_pages =hpage_nr_pages (src); + } + +for (i =0 ; i < nr_pages; i++ ) {
Coding style violation?
ERROR: space prohibited before that close parenthesis ')' #177: FILE: mm/migrate.c:486:
+ for (i = 0; i < nr_pages; i++ ) {
Thanks,
Naoya Horiguchi
Quoted 76 lines
mm/migrate.c renamed from mm/migrate.c~copy-huge-separate-from-copy-transhuge +6
-0+cond_resched (); +copy_highpage (dst + i, src + i); + } +} + +/* * Copy the page to its new location */ void migrate_page_copy (struct page *newpage,struct page *page)diff -puN
mm/hugetlb.c~copy-huge-separate-from-copy-transhugemm/hugetlb.cmm/hugetlb.c renamed from mm/hugetlb.c~copy-huge-separate-from-copy-transhuge +0
-34@@ -476,40 +476,6 @@ static int vma_has_reserves(struct vm_arreturn 0 ; } -static void copy_gigantic_page (struct page *dst,struct page *src) -{ -int i; -struct hstate *h =page_hstate (src); -struct page *dst_base = dst; -struct page *src_base = src; - -for (i =0 ; i <pages_per_huge_page (h); ) { -cond_resched (); -copy_highpage (dst, src); - - i++; - dst =mem_map_next (dst, dst_base, i); - src =mem_map_next (src, src_base, i); - } -} - -void copy_huge_page (struct page *dst,struct page *src) -{ -int i; -struct hstate *h =page_hstate (src); - -if (unlikely (pages_per_huge_page (h) >MAX_ORDER_NR_PAGES )) { -copy_gigantic_page (dst, src); -return ; - } - -might_sleep (); -for (i =0 ; i <pages_per_huge_page (h); i++) { -cond_resched (); -copy_highpage (dst + i, src + i); - } -} -static void enqueue_huge_page (struct hstate *h,struct page *page) {int nid =page_to_nid (page);diff -puN
include/linux/hugetlb.h~copy-huge-separate-from-copy-transhugeinclude/linux/hugetlb.hinclude/linux/hugetlb.h renamed from include/linux/hugetlb.h~copy-huge-separate-from-copy-transhuge +0
-4@@ -69,7 +69,6 @@ int dequeue_hwpoisoned_huge_page(structbool isolate_huge_page (struct page *page,struct list_head *list);void putback_active_hugepage (struct page *page);bool is_hugepage_active (struct page *page); -void copy_huge_page (struct page *dst,struct page *src);#ifdef CONFIG_ARCH_WANT_HUGE_PMD_SHARE pte_t *huge_pmd_share (struct mm_struct *mm,unsigned long addr,pud_t *pud);@@ -140,9 +139,6 @@ static inline int dequeue_hwpoisoned_hug#define isolate_huge_page (p, l) false#define putback_active_hugepage (p) do {} while (0)#define is_hugepage_active (x) false -static inline void copy_huge_page (struct page *dst,struct page *src) -{ -}static inline unsigned long hugetlb_change_protection (struct vm_area_struct *vma,unsigned long address,unsigned long end,pgprot_t newprot)_
Quoted 6 lines
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 1/1 mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
In copy_huge_page() we call cond_resched() before every single page copy. This is an overkill because single page copy is not a heavy operation. This patch changes this to call cond_resched() per MAX_ORDER_NR_PAGES pages.
--- mm/migrate.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
mm/migrate.c +4 -4
@@ -454,7 +454,8 @@ static void __copy_gigantic_page(struct page *dst, struct page *src,struct page *src_base = src;for (i =0 ; i < nr_pages; ) { -cond_resched (); +if (i %MAX_ORDER_NR_PAGES ==0 ) +cond_resched ();copy_highpage (dst, src); i++;
@@ -483,10 +484,9 @@ static void copy_huge_page(struct page *dst, struct page *src) nr_pages =hpage_nr_pages (src); } -for (i =0 ; i < nr_pages; i++ ) { -cond_resched (); +cond_resched (); +for (i =0 ; i < nr_pages; i++)copy_highpage (dst + i, src + i); - } }/*
Signature · 7 lines
1.8.3.1 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
mm/migrate.c static void __copy_gigantic_page(struct page *dst, struct page *src, · line 459
Quoted 12 lines · Naoya Horiguchi
mm/migrate.c +2
-1@@ -454,7 +454,8 @@ static void __copy_gigantic_page(struct page *dst, struct page *src,struct page *src_base = src;for (i =0 ; i < nr_pages; ) { -cond_resched (); +if (i %MAX_ORDER_NR_PAGES ==0 ) +cond_resched ();copy_highpage (dst, src);
This is certainly OK on x86, but remember that MAX_ORDER can be overridden by a config variable. Just picking one at random:
config FORCE_MAX_ZONEORDER
int "Maximum zone order"
range 9 64 if PPC64 && PPC_64K_PAGES
...
Would it be OK to only resched once every 2^63 pages? ;)
Really, though, a lot of things seem to have MAX_ORDER set up so that it's at 256MB or 512MB. That's an awful lot to do between rescheds.
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
Quoted 17 lines · Dave Hansen
mm/migrate.c static void __copy_gigantic_page(struct page *dst, struct page *src, · line 459
Quoted 12 lines · Naoya Horiguchi
mm/migrate.c +2
-1@@ -454,7 +454,8 @@ static void __copy_gigantic_page(struct page *dst, struct page *src,struct page *src_base = src;for (i =0 ; i < nr_pages; ) { -cond_resched (); +if (i %MAX_ORDER_NR_PAGES ==0 ) +cond_resched ();copy_highpage (dst, src);This is certainly OK on x86, but remember that
MAX_ORDERcan be overridden by a config variable. Just picking one at random:
Quoted 6 lines
config
FORCE_MAX_ZONEORDER
int "Maximum zone order"
range 9 64 if PPC64 &&PPC_64K_PAGES
...Would it be OK to only resched once every 2^63 pages? ;)
You're right. We need use more reliable value here. HPAGE_SIZE/PAGE_SIZE looks better to me.
Quoted 2 lines
Really, though, a lot of things seem to have
MAX_ORDERset up so that it's at 256MB or 512MB. That's an awful lot to do between rescheds.
Yes.
BTW, I found that we have the same problem for other functions like copy_user_gigantic_page, copy_user_huge_page, and maybe clear_gigantic_page. So we had better handle them too.
Thanks,
Naoya
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
Quoted 7 lines · Naoya Horiguchi
Quoted 2 lines
Quoted 2 lines
Really, though, a lot of things seem to have
MAX_ORDERset up so that it's at 256MB or 512MB. That's an awful lot to do between rescheds.Yes.
BTW, I found that we have the same problem for other functions like
copy_user_gigantic_page,copy_user_huge_page, and maybeclear_gigantic_page. So we had better handle them too.
Is there a problem you're trying to solve here? The common case of the cond_resched() call boils down to a read of a percpu variable which will surely be in the L1 cache after the first run around the loop. In other words, it's about as cheap of an operation as we're going to get.
Why bother trying to "optimize" it?
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
Quoted 5 lines · Dave Hansen
Quoted 4 lines · Naoya Horiguchi
Quoted 2 lines
Quoted 2 lines
Really, though, a lot of things seem to have
MAX_ORDERset up so that it's at 256MB or 512MB. That's an awful lot to do between rescheds.Yes.
Quoted 8 lines
Quoted 3 lines
BTW, I found that we have the same problem for other functions like
copy_user_gigantic_page,copy_user_huge_page, and maybeclear_gigantic_page. So we had better handle them too.Is there a problem you're trying to solve here? The common case of the
cond_resched()call boils down to a read of a percpu variable which will surely be in the L1 cache after the first run around the loop. In other words, it's about as cheap of an operation as we're going to get.
Yes, cond_resched() is cheap if should_resched() is false (and it is in common case).
Quoted 1 line
Why bother trying to "optimize" it?
I thought that if we call cond_resched() too often, the copying thread can take too long in a heavy load system, because the copying thread always yields the CPU in every loop.
But it seems to be an extreme case, so I can't push it strongly.
Thanks,
Naoya
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
Quoted 4 lines · Naoya Horiguchi
Quoted 1 line
Quoted 1 line
Why bother trying to "optimize" it?
I thought that if we call
cond_resched()too often, the copying thread can take too long in a heavy load system, because the copying thread always yields the CPU in every loop.
I think you're confusing cond_resched() and yield(). The way I look at it:
yield() means: "Hey scheduler, go right now and run something else I'm done running"
cond_resched() means: "Schedule me off if the scheduler has already decided something else _should_ be running"
I'm sure I'm missing some of the subtleties, but as I see it, yield() actively goes off and finds something else to run. cond_resched() only schedules you off if you've *already* run too long.
Re: [PATCH] mm: call cond_resched() per MAX_ORDER_NR_PAGES pages copy
Quoted 11 lines · Dave Hansen
Quoted 4 lines · Naoya Horiguchi
Quoted 1 line
Quoted 1 line
Why bother trying to "optimize" it?
I thought that if we call
cond_resched()too often, the copying thread can take too long in a heavy load system, because the copying thread always yields the CPU in every loop.I think you're confusing
cond_resched()andyield(). The way I look at it:
yield()means: "Hey scheduler, go right now and run something else I'm done running"
Quoted 6 lines
cond_resched()means: "Schedule me off if the scheduler has already decided something else _should_ be running"I'm sure I'm missing some of the subtleties, but as I see it,
yield()actively goes off and finds something else to run.cond_resched()only schedules you off if you've *already* run too long.
I see.
Thanks for the explanation!
Naoya
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
T24gRnJpLCAyMDEzLTExLTE1IGF0IDE0OjU1IC0wODAwLCBEYXZlIEhhbnNlbiB3cm90ZToNCj4g VGhpcyB0b29rIHNvbWUgb2YgTWVsJ3MgY29tbWVudHMgaW4gdG8gY29uc2lkZXJhdGlvbi4gIERh dmUNCj4gSmlhbmcsIGNvdWxkIHlvdSByZXRlc3QgdGhpcyBpZiB5b3UgZ2V0IGEgY2hhbmNlPyAg VGhlc2UgaGF2ZQ0KPiBvbmx5IGJlZW4gbGlnaHRseSBjb21waWxlLXRlc3RlZC4NCj4gDQoNCkV2 ZXJ5dGhpbmcgbG9va3MgZ29vZC4gDQoNClRlc3RlZC1ieTogRGF2ZSBKaWFuZyA8ZGF2ZS5qaWFu Z0BpbnRlbC5jb20+DQo=
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>