* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.

  // The index of the next candidate old region to be considered for

  // addition to the CSet.

  int _curr_index;

  // The number of candidate old regions added to the CSet chooser.

  int _length;

  CSetChooserCache _cache;

  jint _first_par_unreserved_idx;

  // If a region has more live bytes than this threshold, it will not

  // be added to the CSet chooser and will not be a candidate for

  // collection.

  size_t _regionLiveThresholdBytes;

  // The sum of reclaimable bytes over all the regions in the CSet chooser.

  size_t _remainingReclaimableBytes;

  // Return the current candidate region to be considered for

  // collection without removing it from the CSet chooser.

  HeapRegion* peek() {

    HeapRegion* res = NULL;

    if (_curr_index < _length) {

      res = _markedRegions.at(_curr_index);

      assert(res != NULL,

             err_msg("Unexpected NULL hr in _markedRegions at index %d",

                     _curr_index));

    }

    return res;

  }

  // Remove the given region from the CSet chooser and move to the

  // next one. The given region should be the current candidate region

  // in the CSet chooser.

  void remove_and_move_to_next(HeapRegion* hr) {

    assert(hr != NULL, "pre-condition");

    assert(_curr_index < _length, "pre-condition");

    assert(_markedRegions.at(_curr_index) == hr, "pre-condition");

    hr->set_sort_index(-1);

    _markedRegions.at_put(_curr_index, NULL);

    assert(hr->reclaimable_bytes() <= _remainingReclaimableBytes,

           err_msg("remaining reclaimable bytes inconsistent "

                   "from region: "SIZE_FORMAT" remaining: "SIZE_FORMAT,

                   hr->reclaimable_bytes(), _remainingReclaimableBytes));

    _remainingReclaimableBytes -= hr->reclaimable_bytes();

    _curr_index += 1;

  }

  // Determine whether to add the given region to the CSet chooser or

  // not. Currently, we skip humongous regions (we never add them to

  // the CSet, we only reclaim them during cleanup) and regions whose

  // live bytes are over the threshold.

  bool shouldAdd(HeapRegion* hr) {

    assert(hr->is_marked(), "pre-condition");

    assert(!hr->is_young(), "should never consider young regions");

    return !hr->isHumongous() &&

            hr->live_bytes() < _regionLiveThresholdBytes;

  }

  // Calculate the minimum number of old regions we'll add to the CSet

  // during a mixed GC.

  size_t calcMinOldCSetLength();

  // Calculate the maximum number of old regions we'll add to the CSet

  // during a mixed GC.

  size_t calcMaxOldCSetLength();

  // Serial version.

  // Atomically increment the number of added regions by region_num

  // and the amount of reclaimable bytes by reclaimable_bytes.

  void updateTotals(jint region_num, size_t reclaimable_bytes);

  // Return the number of candidate regions that remain to be collected.

  size_t remainingRegions() { return _length - _curr_index; }

  // Determine whether the CSet chooser has more candidate regions or not.

  bool isEmpty() { return remainingRegions() == 0; }

  // Return the reclaimable bytes that remain to be collected on

  // all the candidate regions in the CSet chooser.

  size_t remainingReclaimableBytes () { return _remainingReclaimableBytes; }

    if (si > -1) {

      guarantee(_curr_index <= si && si < _length,

                err_msg("curr: %d sort index: %d: length: %d",

                        _curr_index, si, _length));

      guarantee(_markedRegions.at(si) == r,

                err_msg("sort index: %d at: "PTR_FORMAT" r: "PTR_FORMAT,

                        si, _markedRegions.at(si), r));

    } else {

      guarantee(si == -1, err_msg("sort index: %d", si));

    }

    return true;