org.mmtk.utility.heap

Class PageResource

java.lang.Object

org.mmtk.utility.heap.PageResource

Direct Known Subclasses:

FreeListPageResource, MonotonePageResource

public abstract class PageResource
extends Object

This class manages the allocation of pages for a space. When a page is requested by the space both a page budget and the use of virtual address space are checked. If the request for space can't be satisfied (for either reason) a GC may be triggered.

This class is abstract, and is subclassed with monotone and freelist variants, which reflect monotonic and ad hoc space usage respectively. Monotonic use is easier to manage, but is obviously more restrictive (useful for copying collectors which allocate monotonically before freeing the entire space and starting over).

Field Summary

Fields

Modifier and Type	Field and Description
private static Lock	classLock lock protecting count of total cumulative pages committed
protected int	committed
protected boolean	contiguous
private static long	cumulativeCommitted cumulative count of pages ever committed
private Lock	lock
protected int	reserved
protected Space	space
protected Address	start only for contiguous spaces
protected boolean	zeroConcurrent
protected ConcurrentZeroingContext	zeroingContext
protected boolean	zeroNT

Constructor Summary

Constructors

Modifier	Constructor and Description
(package private)	PageResource(Space space) Constructor for discontiguous spaces.
(package private)	PageResource(Space space, Address start) Constructor for contiguous spaces.
private	PageResource(Space space, boolean contiguous)

Method Summary

Modifier and Type	Method and Description
private static void	addToCommitted(int pages) Add to the total cumulative committed page count.
abstract int	adjustForMetaData(int pages) Adjust a page request to include metadata requirements for a request of the given size.
(package private) abstract Address	allocPages(int reservedPages, int requiredPages, boolean zeroed)
void	clearRequest(int reservedPages) Remove a request to the space.
protected void	commitPages(int reservedPages, int actualPages) Commit pages to the page budget.
int	committedPages() Return the number of committed pages
void	concurrentZeroing() The entry point for the concurrent zeroing context.
static long	cumulativeCommittedPages() Return the cumulative number of committed pages
abstract int	getAvailablePhysicalPages() Return the number of available physical pages for this resource.
Address	getNewPages(int pagesReserved, int pages, boolean zeroed) Allocate pages in virtual memory, returning zero on failure.
protected void	lock() Acquire the lock.
int	reservedPages() Return the number of reserved pages
int	reservePages(int pages) Reserve pages.
void	skipConcurrentZeroing() Skip concurrent zeroing (fall back to bulk zeroing).
void	triggerConcurrentZeroing() Trigger concurrent zeroing.
protected void	unlock() Release the lock.
void	updateZeroingApproach(boolean nontemporal, boolean concurrent) Update the zeroing approach for this page resource.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

classLock

private static final Lock classLock

lock protecting count of total cumulative pages committed

cumulativeCommitted

private static long cumulativeCommitted

cumulative count of pages ever committed

reserved

protected int reserved

committed

protected int committed

contiguous

protected final boolean contiguous

space

protected final Space space

start

protected Address start

only for contiguous spaces

lock

private final Lock lock

zeroNT

protected boolean zeroNT

zeroConcurrent

protected boolean zeroConcurrent

zeroingContext

protected ConcurrentZeroingContext zeroingContext

Constructor Detail

PageResource

private PageResource(Space space,
                     boolean contiguous)

Parameters:

space - The space to which this resource is attached

contiguous - whether the space is contiguous or discontiguous

PageResource

PageResource(Space space)

Constructor for discontiguous spaces.

Parameters:

space - The space to which this resource is attached

PageResource

PageResource(Space space,
             Address start)

Constructor for contiguous spaces.

Parameters:

space - The space to which this resource is attached

start - start address of the space

Method Detail

getAvailablePhysicalPages

public abstract int getAvailablePhysicalPages()

Return the number of available physical pages for this resource. This includes all pages currently unused by this resource's page cursor. If the resource is using discontiguous space it also includes currently unassigned discontiguous space.

Note: This just considers physical pages (ie virtual memory pages allocated for use by this resource). This calculation is orthogonal to and does not consider any restrictions on the number of pages this resource may actually use at any time (ie the number of committed and reserved pages).

Note: The calculation is made on the assumption that all space that could be assigned to this resource would be assigned to this resource (ie the unused discontiguous space could just as likely be assigned to another competing resource).

Returns:

The number of available physical pages for this resource.

reservePages

public final int reservePages(int pages)

Reserve pages.

The role of reserving pages is that it allows the request to be noted as pending (the difference between committed and reserved indicates pending requests). If the request would exceed the page budget then the caller must poll in case a GC is necessary.

Parameters:

pages - The number of pages requested

Returns:

The actual number of pages reserved (including metadata, etc.)

clearRequest

public final void clearRequest(int reservedPages)

Remove a request to the space.

Parameters:

reservedPages - The number of pages returned due to the request.

updateZeroingApproach

public void updateZeroingApproach(boolean nontemporal,
                                  boolean concurrent)

Update the zeroing approach for this page resource.

Parameters:

nontemporal - whether to use non-temporal instructions for zeroing

concurrent - whether to do the zeroing concurrently

skipConcurrentZeroing

public void skipConcurrentZeroing()

Skip concurrent zeroing (fall back to bulk zeroing).

triggerConcurrentZeroing

public void triggerConcurrentZeroing()

Trigger concurrent zeroing.

concurrentZeroing

public void concurrentZeroing()

The entry point for the concurrent zeroing context.

allocPages

abstract Address allocPages(int reservedPages,
                            int requiredPages,
                            boolean zeroed)

adjustForMetaData

public abstract int adjustForMetaData(int pages)

Adjust a page request to include metadata requirements for a request of the given size. This must be a pure function, that is it does not depend on the state of the PageResource.

Parameters:

pages - The size of the pending allocation in pages

Returns:

The number of required pages, inclusive of any metadata

getNewPages

public final Address getNewPages(int pagesReserved,
                                 int pages,
                                 boolean zeroed)

Allocate pages in virtual memory, returning zero on failure.

If the request cannot be satisfied, zero is returned and it falls to the caller to trigger the GC. Call allocPages (subclass) to find the pages in virtual memory. If successful then commit the pending page request and return the address of the first page.

Parameters:

pagesReserved - The number of pages reserved by the initial request

pages - The number of pages requested

zeroed - If true allocated pages are zeroed.

Returns:

The address of the first of pages pages, or zero on failure.

commitPages

protected void commitPages(int reservedPages,
                           int actualPages)

Commit pages to the page budget. This is called after successfully determining that the request can be satisfied by both the page budget and virtual memory. This simply accounts for the discrepancy between committed and reserved while the request was pending. This *MUST* be called by each PageResource during the allocPages, and the caller must hold the lock.

Parameters:

reservedPages - The number of pages initially reserved due to this request

actualPages - The number of pages actually allocated.

reservedPages

public final int reservedPages()

Return the number of reserved pages

Returns:

The number of reserved pages.

committedPages

public final int committedPages()

Return the number of committed pages

Returns:

The number of committed pages.

cumulativeCommittedPages

public static long cumulativeCommittedPages()

Return the cumulative number of committed pages

Returns:

The cumulative number of committed pages.

addToCommitted

private static void addToCommitted(int pages)

Add to the total cumulative committed page count.

Parameters:

pages - The number of pages to be added.

lock

protected final void lock()

Acquire the lock.

unlock

protected final void unlock()

Release the lock.