Print this page
Split Close
Expand all
Collapse all
          --- old/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp
          +++ new/src/share/vm/gc_implementation/g1/concurrentG1Refine.hpp
   1    1  /*
   2      - * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
        2 + * Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
   3    3   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4    4   *
   5    5   * This code is free software; you can redistribute it and/or modify it
   6    6   * under the terms of the GNU General Public License version 2 only, as
   7    7   * published by the Free Software Foundation.
   8    8   *
   9    9   * This code is distributed in the hope that it will be useful, but WITHOUT
  10   10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11   11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12   12   * version 2 for more details (a copy is included in the LICENSE file that
↓ open down ↓ 74 lines elided ↑ open up ↑ 
  87   87    };
  88   88  
  89   89    const static julong card_num_mask_in_place =
  90   90                          (julong) card_num_mask << card_num_shift;
  91   91  
  92   92    typedef struct {
  93   93      julong _value;      // |  card_num   |  epoch   |
  94   94    } CardEpochCacheEntry;
  95   95  
  96   96    julong make_epoch_entry(unsigned int card_num, unsigned int epoch) {
  97      -    assert(0 <= card_num && card_num < _max_n_card_counts, "Bounds");
       97 +    assert(0 <= card_num && card_num < _max_cards, "Bounds");
  98   98      assert(0 <= epoch && epoch <= _n_periods, "must be");
  99   99  
 100  100      return ((julong) card_num << card_num_shift) | epoch;
 101  101    }
 102  102  
 103  103    unsigned int extract_epoch(julong v) {
 104  104      return (v & epoch_mask);
 105  105    }
 106  106  
 107  107    unsigned int extract_card_num(julong v) {
↓ open down ↓ 4 lines elided ↑ open up ↑ 
 112  112      unsigned char _count;
 113  113      unsigned char _evict_count;
 114  114    } CardCountCacheEntry;
 115  115  
 116  116    CardCountCacheEntry* _card_counts;
 117  117    CardEpochCacheEntry* _card_epochs;
 118  118  
 119  119    // The current number of buckets in the card count cache
 120  120    unsigned _n_card_counts;
 121  121  
 122      -  // The max number of buckets required for the number of
 123      -  // cards for the entire reserved heap
      122 +  // The number of cards for the entire reserved heap
      123 +  unsigned _max_cards;
      124 +
      125 +  // The max number of buckets for the card counts and epochs caches.
      126 +  // This is the maximum that the counts and epochs will grow to.
      127 +  // It is specified as a fraction or percentage of _max_cards using
      128 +  // G1MaxHotCardCountSizePercent (currently 50%).
 124  129    unsigned _max_n_card_counts;
 125  130  
 126  131    // Possible sizes of the cache: odd primes that roughly double in size.
 127  132    // (See jvmtiTagMap.cpp).
 128      -  static int _cc_cache_sizes[];
      133 +  enum {
      134 +    MAX_CC_CACHE_INDEX = 15    // maximum index into the cache size array.
      135 +  };
      136 +
      137 +  static int _cc_cache_sizes[MAX_CC_CACHE_INDEX];
 129  138  
 130  139    // The index in _cc_cache_sizes corresponding to the size of
 131  140    // _card_counts.
 132  141    int _cache_size_index;
 133  142  
 134  143    bool _expand_card_counts;
 135  144  
 136  145    const jbyte* _ct_bot;
 137  146  
 138  147    jbyte**      _hot_cache;
↓ open down ↓ 1 lines elided ↑ open up ↑ 
 140  149    int          _n_hot;
 141  150    int          _hot_cache_idx;
 142  151  
 143  152    int          _hot_cache_par_chunk_size;
 144  153    volatile int _hot_cache_par_claimed_idx;
 145  154  
 146  155    // Needed to workaround 6817995
 147  156    CardTableModRefBS* _ct_bs;
 148  157    G1CollectedHeap*   _g1h;
 149  158  
 150      -  // Expands the array that holds the card counts to the next size up
 151      -  void expand_card_count_cache();
      159 +  // Helper routine for expand_card_count_cache().
      160 +  // The arrays used to hold the card counts and the epochs must have
      161 +  // a 1:1 correspondence. Hence they are allocated and freed together.
      162 +  // Returns true if the allocations of both the counts and epochs
      163 +  // were successful; false otherwise.
      164 +  bool allocate_card_count_cache(int n, CardCountCacheEntry** counts,
      165 +                                        CardEpochCacheEntry** epochs);
      166 +
      167 +  // Expands the arrays that hold the card counts and epochs
      168 +  // to the cache size at index. Returns true if the expansion/
      169 +  // allocation was successful; false otherwise.
      170 +  bool expand_card_count_cache(int index);
 152  171  
 153  172    // hash a given key (index of card_ptr) with the specified size
 154  173    static unsigned int hash(size_t key, int size) {
 155  174      return (unsigned int) key % size;
 156  175    }
 157  176  
 158  177    // hash a given key (index of card_ptr)
 159  178    unsigned int hash(size_t key) {
 160  179      return hash(key, _n_card_counts);
 161  180    }
↓ open down ↓ 74 lines elided ↑ open up ↑ 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX