On 05/06/2014 10:55 AM, Mel Gorman wrote:
On Fri, May 02, 2014 at 01:29:33PM -0700, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
On Fri, May 02, 2014 at 01:29:33PM -0700, David Rientjes wrote:
> On Fri, 2 May 2014, Mel Gorman wrote:
>
> > > The page locks I'm referring to is the lock_page() in __unmap_and_move()
> > > that gets called for sync compaction after the migrate_pages() iteration
> > > makes a few passes and
On Fri, May 02, 2014 at 01:29:33PM -0700, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
makes a few passes and
On 05/06/2014 10:55 AM, Mel Gorman wrote:
On Fri, May 02, 2014 at 01:29:33PM -0700, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
On 05/02/2014 10:29 PM, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
makes a few passes and unsuccessfully grabs it. This becomes a
On 05/02/2014 10:29 PM, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
makes a few passes and unsuccessfully grabs it. This becomes a
On Fri, 2 May 2014, Mel Gorman wrote:
> > The page locks I'm referring to is the lock_page() in __unmap_and_move()
> > that gets called for sync compaction after the migrate_pages() iteration
> > makes a few passes and unsuccessfully grabs it. This becomes a forced
> > migration since
On Fri, May 02, 2014 at 04:22:03AM -0700, David Rientjes wrote:
> On Fri, 2 May 2014, Mel Gorman wrote:
>
> > > Synchronous memory compaction can be very expensive: it can iterate an
> > > enormous
> > > amount of memory without aborting, constantly rescheduling, waiting on
> > > page
> > >
On Fri, 2 May 2014, Mel Gorman wrote:
> > Synchronous memory compaction can be very expensive: it can iterate an
> > enormous
> > amount of memory without aborting, constantly rescheduling, waiting on page
> > locks and lru_lock, etc, if a pageblock cannot be defragmented.
> >
> >
On Thu, May 01, 2014 at 02:35:48PM -0700, David Rientjes wrote:
> Synchronous memory compaction can be very expensive: it can iterate an
> enormous
> amount of memory without aborting, constantly rescheduling, waiting on page
> locks and lru_lock, etc, if a pageblock cannot be defragmented.
>
>
On Thu, May 01, 2014 at 02:35:48PM -0700, David Rientjes wrote:
Synchronous memory compaction can be very expensive: it can iterate an
enormous
amount of memory without aborting, constantly rescheduling, waiting on page
locks and lru_lock, etc, if a pageblock cannot be defragmented.
On Fri, 2 May 2014, Mel Gorman wrote:
Synchronous memory compaction can be very expensive: it can iterate an
enormous
amount of memory without aborting, constantly rescheduling, waiting on page
locks and lru_lock, etc, if a pageblock cannot be defragmented.
Unfortunately, it's too
On Fri, May 02, 2014 at 04:22:03AM -0700, David Rientjes wrote:
On Fri, 2 May 2014, Mel Gorman wrote:
Synchronous memory compaction can be very expensive: it can iterate an
enormous
amount of memory without aborting, constantly rescheduling, waiting on
page
locks and lru_lock,
On Fri, 2 May 2014, Mel Gorman wrote:
The page locks I'm referring to is the lock_page() in __unmap_and_move()
that gets called for sync compaction after the migrate_pages() iteration
makes a few passes and unsuccessfully grabs it. This becomes a forced
migration since
Synchronous memory compaction can be very expensive: it can iterate an enormous
amount of memory without aborting, constantly rescheduling, waiting on page
locks and lru_lock, etc, if a pageblock cannot be defragmented.
Unfortunately, it's too expensive for pagefault for transparent hugepages
Synchronous memory compaction can be very expensive: it can iterate an enormous
amount of memory without aborting, constantly rescheduling, waiting on page
locks and lru_lock, etc, if a pageblock cannot be defragmented.
Unfortunately, it's too expensive for pagefault for transparent hugepages
16 matches
Mail list logo
