#ifndef SHARE_VM_RUNTIME_VIRTUALSPACE_HPP

#define SHARE_VM_RUNTIME_VIRTUALSPACE_HPP

#include "memory/allocation.hpp"

class ReservedSpace VALUE_OBJ_CLASS_SPEC {

friend class VMStructs;

private:

char* _base;

size_t _size;

size_t _noaccess_prefix;

// The base and size prior to any alignment done by this class; used only on

// systems that cannot release part of a region.

char* _raw_base;

size_t _raw_size;

size_t _alignment;

bool _special;

bool _executable;

// ReservedSpace

ReservedSpace(char* base, size_t size, size_t alignment, bool special,

bool executable);

bool failed_to_reserve_as_requested(char* base, char* requested_address,

const size_t size, bool special);

void initialize(size_t size, size_t alignment, bool large,

char* requested_address,

const size_t noaccess_prefix,

bool executable);

inline void set_raw_base_and_size(char * const raw_base, size_t raw_size);

// Release virtual address space. If alignment was done, use the saved

// address and size when releasing.

void release_memory(char * default_addr, size_t default_size);

// Release parts of an already-reserved memory region [addr, addr + len) to

// get a new region that has "compound alignment." Return the start of the

// resulting region, or NULL on failure.

//

// The region is logically divided into a prefix and a suffix. The prefix

// starts at the result address, which is aligned to prefix_align. The suffix

// starts at result address + prefix_size, which is aligned to suffix_align.

// The total size of the result region is size prefix_size + suffix_size.

char* align_reserved_region(char* addr, const size_t len,

const size_t prefix_size,

const size_t prefix_align,

const size_t suffix_size,

const size_t suffix_align);

// Reserve memory, call align_reserved_region() to alignment it and return the

// result.

char* reserve_and_align(const size_t reserve_size,

const size_t prefix_size,

const size_t prefix_align,

const size_t suffix_size,

const size_t suffix_align);

protected:

// Create protection page at the beginning of the space.

void protect_noaccess_prefix(const size_t size);

public:

// Constructor

ReservedSpace(size_t size);

ReservedSpace(size_t size, size_t alignment, bool large,

char* requested_address = NULL,

const size_t noaccess_prefix = 0);

ReservedSpace(const size_t prefix_size, const size_t prefix_align,

const size_t suffix_size, const size_t suffix_align,

char* requested_address,

const size_t noaccess_prefix = 0);

ReservedSpace(size_t size, size_t alignment, bool large, bool executable);

// Accessors

char* base() const { return _base; }

size_t size() const { return _size; }

size_t alignment() const { return _alignment; }

bool special() const { return _special; }

bool executable() const { return _executable; }

size_t noaccess_prefix() const { return _noaccess_prefix; }

bool is_reserved() const { return _base != NULL; }

void release();

// Splitting

ReservedSpace first_part(size_t partition_size, size_t alignment,

bool split = false, bool realloc = true);

ReservedSpace last_part (size_t partition_size, size_t alignment);

// These simply call the above using the default alignment.

inline ReservedSpace first_part(size_t partition_size,

bool split = false, bool realloc = true);

inline ReservedSpace last_part (size_t partition_size);

// Alignment

static size_t page_align_size_up(size_t size);

static size_t page_align_size_down(size_t size);

static size_t allocation_align_size_up(size_t size);

static size_t allocation_align_size_down(size_t size);

};

ReservedSpace::first_part(size_t partition_size, bool split, bool realloc)

{

return first_part(partition_size, alignment(), split, realloc);

}

ReservedSpace ReservedSpace::last_part(size_t partition_size)

{

return last_part(partition_size, alignment());

}

class ReservedHeapSpace : public ReservedSpace {

public:

// Constructor

ReservedHeapSpace(size_t size, size_t forced_base_alignment,

bool large, char* requested_address);

ReservedHeapSpace(const size_t prefix_size, const size_t prefix_align,

const size_t suffix_size, const size_t suffix_align,

char* requested_address);

};

class ReservedCodeSpace : public ReservedSpace {

public:

// Constructor

ReservedCodeSpace(size_t r_size, size_t rs_align, bool large);

};

class VirtualSpace VALUE_OBJ_CLASS_SPEC {

friend class VMStructs;

private:

// Reserved area

char* _low_boundary;

char* _high_boundary;

// Committed area

char* _low;

char* _high;

// The entire space has been committed and pinned in memory, no

// os::commit_memory() or os::uncommit_memory().

bool _special;

// Need to know if commit should be executable.

bool _executable;

// MPSS Support

// Each virtualspace region has a lower, middle, and upper region.

// Each region has an end boundary and a high pointer which is the

// high water mark for the last allocated byte.

// The lower and upper unaligned to LargePageSizeInBytes uses default page.

// size. The middle region uses large page size.

char* _lower_high;

char* _middle_high;

char* _upper_high;

char* _lower_high_boundary;

char* _middle_high_boundary;

char* _upper_high_boundary;

size_t _lower_alignment;

size_t _middle_alignment;

size_t _upper_alignment;

// MPSS Accessors

char* lower_high() const { return _lower_high; }

char* middle_high() const { return _middle_high; }

char* upper_high() const { return _upper_high; }

char* lower_high_boundary() const { return _lower_high_boundary; }

char* middle_high_boundary() const { return _middle_high_boundary; }

char* upper_high_boundary() const { return _upper_high_boundary; }

size_t lower_alignment() const { return _lower_alignment; }

size_t middle_alignment() const { return _middle_alignment; }

size_t upper_alignment() const { return _upper_alignment; }

public:

// Committed area

char* low() const { return _low; }

char* high() const { return _high; }

// Reserved area

char* low_boundary() const { return _low_boundary; }

char* high_boundary() const { return _high_boundary; }

bool special() const { return _special; }

public:

// Initialization

VirtualSpace();

bool initialize(ReservedSpace rs, size_t committed_byte_size);

// Destruction

~VirtualSpace();

// Testers (all sizes are byte sizes)

size_t committed_size() const;

size_t reserved_size() const;

size_t uncommitted_size() const;

bool contains(const void* p) const;

// Operations

// returns true on success, false otherwise

bool expand_by(size_t bytes, bool pre_touch = false);

void shrink_by(size_t bytes);

void release();

void check_for_contiguity() PRODUCT_RETURN;

// Debugging

void print() PRODUCT_RETURN;

};

#endif // SHARE_VM_RUNTIME_VIRTUALSPACE_HPP