src/share/vm/gc/cms/compactibleFreeListSpace.cpp

rev 12906 : [mq]: gc_interface

*** 83,95 ****
    _freelistLock(_lockRank--, "CompactibleFreeListSpace._lock", true,
                  Monitor::_safepoint_check_sometimes),
    _parDictionaryAllocLock(Mutex::leaf - 1,  // == rank(ExpandHeap_lock) - 1
                            "CompactibleFreeListSpace._dict_par_lock", true,
                            Monitor::_safepoint_check_never),
!   _rescan_task_size(CardTableModRefBS::card_size_in_words * BitsPerWord *
                      CMSRescanMultiple),
!   _marking_task_size(CardTableModRefBS::card_size_in_words * BitsPerWord *
                      CMSConcMarkMultiple),
    _collector(NULL),
    _preconsumptionDirtyCardClosure(NULL)
  {
    assert(sizeof(FreeChunk) / BytesPerWord <= MinChunkSize,
--- 83,95 ----
    _freelistLock(_lockRank--, "CompactibleFreeListSpace._lock", true,
                  Monitor::_safepoint_check_sometimes),
    _parDictionaryAllocLock(Mutex::leaf - 1,  // == rank(ExpandHeap_lock) - 1
                            "CompactibleFreeListSpace._dict_par_lock", true,
                            Monitor::_safepoint_check_never),
!   _rescan_task_size(CardTable::card_size_in_words * BitsPerWord *
                      CMSRescanMultiple),
!   _marking_task_size(CardTable::card_size_in_words * BitsPerWord *
                      CMSConcMarkMultiple),
    _collector(NULL),
    _preconsumptionDirtyCardClosure(NULL)
  {
    assert(sizeof(FreeChunk) / BytesPerWord <= MinChunkSize,
*** 604,614 ****
  
  public:
    FreeListSpaceDCTOC(CompactibleFreeListSpace* sp,
                       CMSCollector* collector,
                       ExtendedOopClosure* cl,
!                      CardTableModRefBS::PrecisionStyle precision,
                       HeapWord* boundary,
                       bool parallel) :
      FilteringDCTOC(sp, cl, precision, boundary),
      _cfls(sp), _collector(collector), _parallel(parallel) {}
  };
--- 604,614 ----
  
  public:
    FreeListSpaceDCTOC(CompactibleFreeListSpace* sp,
                       CMSCollector* collector,
                       ExtendedOopClosure* cl,
!                      CardTable::PrecisionStyle precision,
                       HeapWord* boundary,
                       bool parallel) :
      FilteringDCTOC(sp, cl, precision, boundary),
      _cfls(sp), _collector(collector), _parallel(parallel) {}
  };
*** 688,698 ****
  FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure)
  FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure)
  
  DirtyCardToOopClosure*
  CompactibleFreeListSpace::new_dcto_cl(ExtendedOopClosure* cl,
!                                       CardTableModRefBS::PrecisionStyle precision,
                                        HeapWord* boundary,
                                        bool parallel) {
    return new FreeListSpaceDCTOC(this, _collector, cl, precision, boundary, parallel);
  }
  
--- 688,698 ----
  FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure)
  FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure)
  
  DirtyCardToOopClosure*
  CompactibleFreeListSpace::new_dcto_cl(ExtendedOopClosure* cl,
!                                       CardTable::PrecisionStyle precision,
                                        HeapWord* boundary,
                                        bool parallel) {
    return new FreeListSpaceDCTOC(this, _collector, cl, precision, boundary, parallel);
  }
  
*** 2826,2836 ****
    // Otherwise, we'll split a block from the dictionary.
    par_get_chunk_of_blocks_dictionary(word_sz, n, fl);
  }
  
  const size_t CompactibleFreeListSpace::max_flag_size_for_task_size() const {
!   const size_t ergo_max = _old_gen->reserved().word_size() / (CardTableModRefBS::card_size_in_words * BitsPerWord);
    return ergo_max;
  }
  
  // Set up the space's par_seq_tasks structure for work claiming
  // for parallel rescan. See CMSParRemarkTask where this is currently used.
--- 2826,2836 ----
    // Otherwise, we'll split a block from the dictionary.
    par_get_chunk_of_blocks_dictionary(word_sz, n, fl);
  }
  
  const size_t CompactibleFreeListSpace::max_flag_size_for_task_size() const {
!   const size_t ergo_max = _old_gen->reserved().word_size() / (CardTable::card_size_in_words * BitsPerWord);
    return ergo_max;
  }
  
  // Set up the space's par_seq_tasks structure for work claiming
  // for parallel rescan. See CMSParRemarkTask where this is currently used.
*** 2863,2890 ****
  initialize_sequential_subtasks_for_marking(int n_threads,
                                             HeapWord* low) {
    // The "size" of each task is fixed according to rescan_task_size.
    assert(n_threads > 0, "Unexpected n_threads argument");
    const size_t task_size = marking_task_size();
!   assert(task_size > CardTableModRefBS::card_size_in_words &&
!          (task_size %  CardTableModRefBS::card_size_in_words == 0),
           "Otherwise arithmetic below would be incorrect");
    MemRegion span = _old_gen->reserved();
    if (low != NULL) {
      if (span.contains(low)) {
        // Align low down to  a card boundary so that
        // we can use block_offset_careful() on span boundaries.
        HeapWord* aligned_low = (HeapWord*)align_size_down((uintptr_t)low,
!                                  CardTableModRefBS::card_size);
        // Clip span prefix at aligned_low
        span = span.intersection(MemRegion(aligned_low, span.end()));
      } else if (low > span.end()) {
        span = MemRegion(low, low);  // Null region
      } // else use entire span
    }
    assert(span.is_empty() ||
!          ((uintptr_t)span.start() %  CardTableModRefBS::card_size == 0),
          "span should start at a card boundary");
    size_t n_tasks = (span.word_size() + task_size - 1)/task_size;
    assert((n_tasks == 0) == span.is_empty(), "Inconsistency");
    assert(n_tasks == 0 ||
           ((span.start() + (n_tasks - 1)*task_size < span.end()) &&
--- 2863,2890 ----
  initialize_sequential_subtasks_for_marking(int n_threads,
                                             HeapWord* low) {
    // The "size" of each task is fixed according to rescan_task_size.
    assert(n_threads > 0, "Unexpected n_threads argument");
    const size_t task_size = marking_task_size();
!   assert(task_size > CardTable::card_size_in_words &&
!          (task_size %  CardTable::card_size_in_words == 0),
           "Otherwise arithmetic below would be incorrect");
    MemRegion span = _old_gen->reserved();
    if (low != NULL) {
      if (span.contains(low)) {
        // Align low down to  a card boundary so that
        // we can use block_offset_careful() on span boundaries.
        HeapWord* aligned_low = (HeapWord*)align_size_down((uintptr_t)low,
!                                  CardTable::card_size);
        // Clip span prefix at aligned_low
        span = span.intersection(MemRegion(aligned_low, span.end()));
      } else if (low > span.end()) {
        span = MemRegion(low, low);  // Null region
      } // else use entire span
    }
    assert(span.is_empty() ||
!          ((uintptr_t)span.start() %  CardTable::card_size == 0),
          "span should start at a card boundary");
    size_t n_tasks = (span.word_size() + task_size - 1)/task_size;
    assert((n_tasks == 0) == span.is_empty(), "Inconsistency");
    assert(n_tasks == 0 ||
           ((span.start() + (n_tasks - 1)*task_size < span.end()) &&