// A node in the VirtualSpaceList.

//

// VirtualSpaceNodes manage a single address range and a commit high water mark.

//

// The address range start and end are aligned to the highest Metachunk size (root chunk size)

// and memory is only ever requested in units of one root chunk size.

//

class VirtualSpaceNode : public CHeapObj<mtClass> {

  /////////////////////////////////

  //

  //  |---------------------     end()

  //  |

  //  |  (uncommitted)                  = words_uncommitted()

  //  |

  //  |---------------------     commit_top()

  //  |

  //  |  (committed unused)             = words_committed_unused()

  //  |

  //  |---------------------     top()

  //  |

  //  |  (committed used)               = words_used()

  //  |

  //  |

  //  |

  //  |--------------------      start()

  //

  // Current allocated words

  size_t _used_words;

  // Current committed words

  size_t _committed_words;

  VirtualSpace* virtual_space() const { return _virtual_space; }

  MetaWord* start() const {

    assert(virtual_space()->low() == virtual_space()->low_boundary(), "sanity");

    return (MetaWord*) virtual_space()->low_boundary();

  }

  // End of the used area.

  MetaWord* top() const { return start() + _used_words; }

  // End of the committed area.

  MetaWord* commit_top() const {

    assert(virtual_space()->high() == start() + _committed_words, "sanity");

    return start() + _committed_words;

  }

  // End of the reserved space; highest address in this node.

  MetaWord* end() const { return virtual_space()->high_boundary(); }

public:

  // Create a new empty node of the given size. Memory will be reserved but

  // completely uncommitted.

  VirtualSpaceNode(size_t wordsize);

  // Create a new empty node spanning the given reserved space.

  VirtualSpaceNode(ReservedSpace rs);

  // Releases the node memory.

  // Allocate a root chunk from this node. Will fail and return NULL

  // if the node is full.

  Metachunk* allocate_root_chunk();

  // Returns true if this node can be purged (all chunks are free).

  bool can_be_purged() const;

  // Purge this node: remove all the chunks in the node from the given chunk manager.

  // Assumption: all chunks are free (see can_be_purged()).

  // Verify counters and basic structure. Slow mode: verify all chunks in depth