jdk8-mips64-public/hotspot: comparison src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp

-:1c280e5b8d31
+:7994a5a35fcf
 /*
-* Copyright (c) 2001, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2001, 2012, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 class G1CollectedHeap;
 class G1BlockOffsetSharedArray;
 class HeapRegion;
 class HeapRegionRemSetIterator;
-class PosParPRT;
+class PerRegionTable;
 class SparsePRT;
 // Essentially a wrapper around SparsePRTCleanupTask. See
 // sparsePRT.hpp for more details.
 class HRRSCleanupTask : public SparsePRTCleanupTask {
 // These are protected by "_m".
 BitMap      _coarse_map;
 size_t      _n_coarse_entries;
 static jint _n_coarsenings;
-PosParPRT** _fine_grain_regions;
+PerRegionTable** _fine_grain_regions;
-size_t      _n_fine_entries;
+size_t           _n_fine_entries;
-#define SAMPLE_FOR_EVICTION 1
+// Used to sample a subset of the fine grain PRTs to determine which
-#if SAMPLE_FOR_EVICTION
+// PRT to evict and coarsen.
 size_t        _fine_eviction_start;
 static size_t _fine_eviction_stride;
 static size_t _fine_eviction_sample_size;
-#endif
 SparsePRT   _sparse_table;
 // These are static after init.
 static size_t _max_fine_entries;
 static size_t _mod_max_fine_entries_mask;
 // Requires "prt" to be the first element of the bucket list appropriate
 // for "hr".  If this list contains an entry for "hr", return it,
 // otherwise return "NULL".
-PosParPRT* find_region_table(size_t ind, HeapRegion* hr) const;
+PerRegionTable* find_region_table(size_t ind, HeapRegion* hr) const;
-// Find, delete, and return a candidate PosParPRT, if any exists,
+// Find, delete, and return a candidate PerRegionTable, if any exists,
 // adding the deleted region to the coarse bitmap.  Requires the caller
 // to hold _m, and the fine-grain table to be full.
-PosParPRT* delete_region_table();
+PerRegionTable* delete_region_table();
 // If a PRT for "hr" is in the bucket list indicated by "ind" (which must
 // be the correct index for "hr"), delete it and return true; else return
 // false.
 bool del_single_region_table(size_t ind, HeapRegion* hr);
-static jint _cache_probes;
-static jint _cache_hits;
 // Indexed by thread X heap region, to minimize thread contention.
 static int** _from_card_cache;
 static size_t _from_card_cache_max_regions;
 static size_t _from_card_cache_mem_size;
 HeapRegion* hr() const { return _hr; }
 // For now.  Could "expand" some tables in the future, so that this made
 // sense.
 void add_reference(OopOrNarrowOopStar from, int tid);
-void add_reference(OopOrNarrowOopStar from) {
-return add_reference(from, 0);
-}
 // Removes any entries shown by the given bitmaps to contain only dead
 // objects.
 void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm);
 return _other_regions.occ_sparse();
 }
 static jint n_coarsenings() { return OtherRegionsTable::n_coarsenings(); }
-/* Used in the sequential case.  Returns "true" iff this addition causes
+// Used in the sequential case.
-the size limit to be reached. */
 void add_reference(OopOrNarrowOopStar from) {
-_other_regions.add_reference(from);
+_other_regions.add_reference(from, 0);
 }
-/* Used in the parallel case.  Returns "true" iff this addition causes
+// Used in the parallel case.
-the size limit to be reached. */
 void add_reference(OopOrNarrowOopStar from, int tid) {
 _other_regions.add_reference(from, tid);
 }
 // Removes any entries shown by the given bitmaps to contain only dead
 void scrub(CardTableModRefBS* ctbs, BitMap* region_bm, BitMap* card_bm);
 // The region is being reclaimed; clear its remset, and any mention of
 // entries for this region in other remsets.
 void clear();
-// Forget any entries due to pointers from "from_hr".
-void clear_incoming_entry(HeapRegion* from_hr) {
-_other_regions.clear_incoming_entry(from_hr);
-}
-#if 0
-virtual void cleanup() = 0;
-#endif
 // Attempt to claim the region.  Returns true iff this call caused an
 // atomic transition from Unclaimed to Claimed.
 bool claim_iter();
 // Sets the iteration state to "complete".
 }
 // Initialize the given iterator to iterate over this rem set.
 void init_iterator(HeapRegionRemSetIterator* iter) const;
-#if 0
-// Apply the "do_card" method to the start address of every card in the
-// rem set.  Returns false if some application of the closure aborted.
-virtual bool card_iterate(CardClosure* iter) = 0;
-#endif
 // The actual # of bytes this hr_remset takes up.
 size_t mem_size() {
 return _other_regions.mem_size()
 // This correction is necessary because the above includes the second
 // part.
 return _other_regions.contains_reference(from);
 }
 void print() const;
 // Called during a stop-world phase to perform any deferred cleanups.
-// The second version may be called by parallel threads after then finish
-// collection work.
 static void cleanup();
-static void par_cleanup();
 // Declare the heap size (in # of regions) to the HeapRegionRemSet(s).
 // (Uses it to initialize from_card_cache).
 static void init_heap(uint max_regions) {
 OtherRegionsTable::init_from_card_cache((size_t) max_regions);
 // The region over which we're iterating.
 const HeapRegionRemSet* _hrrs;
 // Local caching of HRRS fields.
 const BitMap*             _coarse_map;
-PosParPRT**               _fine_grain_regions;
+PerRegionTable**          _fine_grain_regions;
 G1BlockOffsetSharedArray* _bosa;
 G1CollectedHeap*          _g1h;
 // The number yielded since initialization.
 // Fine table iteration fields:
 // Index of bucket-list we're working on.
 int _fine_array_index;
 // Per Region Table we're doing within current bucket list.
-PosParPRT* _fine_cur_prt;
+PerRegionTable* _fine_cur_prt;
 /* SparsePRT::*/ SparsePRTIter _sparse_iter;
 void fine_find_next_non_null_prt();
 size_t n_yielded() {
 return n_yielded_fine() + n_yielded_coarse() + n_yielded_sparse();
 }
 };
-#if 0
-class CardClosure: public Closure {
-public:
-virtual void do_card(HeapWord* card_start) = 0;
-};
-#endif
 #endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONREMSET_HPP

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp

src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp