org.mmtk.utility.heap
Class MonotonePageResource

java.lang.Object
  org.mmtk.utility.heap.PageResource
      org.mmtk.utility.heap.MonotonePageResource

All Implemented Interfaces:

Constants

public final class MonotonePageResource
extends PageResource
implements Constants

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.

cursor

private Address cursor

Instance variables

sentinel

private Address sentinel

metaDataPagesPerRegion

private final int metaDataPagesPerRegion

currentChunk

private Address currentChunk

MonotonePageResource

public MonotonePageResource(int pageBudget,
                            Space space,
                            Address start,
                            Extent bytes,
                            int metaDataPagesPerRegion)

Constructor Contiguous monotone resource. The address range is pre-defined at initialization time and is immutable.

Parameters:

pageBudget - The budget of pages available to this memory manager before it must poll the collector.

space - The space to which this resource is attached

start - The start of the address range allocated to this resource

bytes - The size of the address rage allocated to this resource

metaDataPagesPerRegion - The number of pages of meta data that are embedded in each region.

MonotonePageResource

public MonotonePageResource(int pageBudget,
                            Space space,
                            int metaDataPagesPerRegion)

Constructor Discontiguous monotone resource. The address range is not pre-defined at initialization time and is dynamically defined to be some set of pages, according to demand and availability. CURRENTLY UNIMPLEMENTED

Parameters:

pageBudget - The budget of pages available to this memory manager before it must poll the collector.

space - The space to which this resource is attached

metaDataPagesPerRegion - The number of pages of meta data that are embedded in each region.

getAvailablePhysicalPages

public 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).

Specified by:

getAvailablePhysicalPages in class PageResource

Returns:

The number of available physical pages for this resource.

allocPages

protected Address allocPages(int requestPages)

Allocate pages pages from this resource. Simply bump the cursor, and fail if we hit the sentinel.

If the request can be satisfied, then ensure the pages are mmpapped and zeroed before returning the address of the start of the region. If the request cannot be satisfied, return zero.

Specified by:

allocPages in class PageResource

Parameters:

requestPages - The number of pages to be allocated.

Returns:

The start of the first page if successful, zero on failure.

adjustForMetaData

public int adjustForMetaData(int pages)

Adjust a page request to include metadata requirements, if any.

In this case we simply report the expected page cost. We can't use worst case here because we would exhaust our budget every time.

Specified by:

adjustForMetaData in class PageResource

Parameters:

pages - The size of the pending allocation in pages

Returns:

The number of required pages, inclusive of any metadata

adjustForMetaData

public int adjustForMetaData(int pages,
                             Address begin)

Adjust a page request to include metadata requirements, if any.

Note that there could be a race here, with multiple threads each adjusting their request on account of the same single metadata region. This should not be harmful, as the failing requests will just retry, and if multiple requests succeed, only one of them will actually have the metadata accounted against it, the others will simply have more space than they originally requested.

Parameters:

pages - The size of the pending allocation in pages

begin - The start address of the region assigned to this pending request

Returns:

The number of required pages, inclusive of any metadata

getRegionStart

private static Address getRegionStart(Address addr)

reset

public void reset()

Reset this page resource, freeing all pages and resetting reserved and committed pages appropriately.

unusePages

public void unusePages(int pages)

Notify that several pages are no longer in use.

Parameters:

pages - The number of pages

reusePages

public void reusePages(int pages)

Notify that previously unused pages are in use again.

Parameters:

pages - The number of pages

releasePages

private void releasePages()

Release all pages associated with this page resource, optionally zeroing on release and optionally memory protecting on release.

moveToNextChunk

private boolean moveToNextChunk()

Adjust the start and cursor fields to point to the next chunk in the linked list of chunks tied down by this page resource.

Returns:

True if we moved to the next chunk; false if we hit the end of the linked list.

releasePages

private void releasePages(Address first,
                          Extent bytes)

Release a range of pages associated with this page resource, optionally zeroing on release and optionally memory protecting on release.