jdk-sandbox: comparison hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.hpp

equal deleted inserted replaced

-:820966182ab9
+:9bf46d16dcc6
 // Represents a marking stack used by the CMS collector.
 // Ideally this should be GrowableArray<> just like MSC's marking stack(s).
 class CMSMarkStack: public CHeapObj<mtGC>  {
 //
-friend class CMSCollector;   // to get at expasion stats further below
+friend class CMSCollector;   // To get at expansion stats further below.
 //
-VirtualSpace _virtual_space;  // space for the stack
+VirtualSpace _virtual_space;  // Space for the stack
-oop*   _base;      // bottom of stack
+oop*   _base;      // Bottom of stack
-size_t _index;     // one more than last occupied index
+size_t _index;     // One more than last occupied index
-size_t _capacity;  // max #elements
+size_t _capacity;  // Max #elements
-Mutex  _par_lock;  // an advisory lock used in case of parallel access
+Mutex  _par_lock;  // An advisory lock used in case of parallel access
-NOT_PRODUCT(size_t _max_depth;)  // max depth plumbed during run
+NOT_PRODUCT(size_t _max_depth;)  // Max depth plumbed during run
 protected:
-size_t _hit_limit;      // we hit max stack size limit
+size_t _hit_limit;      // We hit max stack size limit
-size_t _failed_double;  // we failed expansion before hitting limit
+size_t _failed_double;  // We failed expansion before hitting limit
 public:
 CMSMarkStack():
 _par_lock(Mutex::event, "CMSMarkStack._par_lock", true),
 _hit_limit(0),
 // Forcibly reset the stack, losing all of its contents.
 void reset() {
 _index = 0;
 }
-// Expand the stack, typically in response to an overflow condition
+// Expand the stack, typically in response to an overflow condition.
 void expand();
 // Compute the least valued stack element.
 oop least_value(HeapWord* low) {
 oop least = (oop)low;
 least = MIN2(least, _base[i]);
 }
 return least;
 }
-// Exposed here to allow stack expansion in || case
+// Exposed here to allow stack expansion in || case.
 Mutex* par_lock() { return &_par_lock; }
 };
 class CardTableRS;
 class CMSParGCThreadState;
 // Overflow list of grey objects, threaded through mark-word
 // Manipulated with CAS in the parallel/multi-threaded case.
 oop _overflow_list;
 // The following array-pair keeps track of mark words
-// displaced for accomodating overflow list above.
+// displaced for accommodating overflow list above.
 // This code will likely be revisited under RFE#4922830.
 Stack<oop, mtGC>     _preserved_oop_stack;
 Stack<markOop, mtGC> _preserved_mark_stack;
 int*             _hash_seed;
 // Verification support
 CMSBitMap     _verification_mark_bm;
 void verify_after_remark_work_1();
 void verify_after_remark_work_2();
-// true if any verification flag is on.
+// True if any verification flag is on.
 bool _verifying;
 bool verifying() const { return _verifying; }
 void set_verifying(bool v) { _verifying = v; }
 // Collector policy
 ConcurrentMarkSweepPolicy* collector_policy() { return _collector_policy; }
 void set_did_compact(bool v);
 // XXX Move these to CMSStats ??? FIX ME !!!
-elapsedTimer _inter_sweep_timer;   // time between sweeps
+elapsedTimer _inter_sweep_timer;   // Time between sweeps
-elapsedTimer _intra_sweep_timer;   // time _in_ sweeps
+elapsedTimer _intra_sweep_timer;   // Time _in_ sweeps
-// padded decaying average estimates of the above
+// Padded decaying average estimates of the above
 AdaptivePaddedAverage _inter_sweep_estimate;
 AdaptivePaddedAverage _intra_sweep_estimate;
 CMSTracer* _gc_tracer_cm;
 ConcurrentGCTimer* _gc_timer_cm;
 void register_gc_end();
 void save_heap_summary();
 void report_heap_summary(GCWhen::Type when);
 protected:
-ConcurrentMarkSweepGeneration* _cmsGen;  // old gen (CMS)
+ConcurrentMarkSweepGeneration* _cmsGen;  // Old gen (CMS)
-MemRegion                      _span;    // span covering above two
+MemRegion                      _span;    // Span covering above two
-CardTableRS*                   _ct;      // card table
+CardTableRS*                   _ct;      // Card table
 // CMS marking support structures
 CMSBitMap     _markBitMap;
 CMSBitMap     _modUnionTable;
 CMSMarkStack  _markStack;
-HeapWord*     _restart_addr; // in support of marking stack overflow
+HeapWord*     _restart_addr; // In support of marking stack overflow
 void          lower_restart_addr(HeapWord* low);
 // Counters in support of marking stack / work queue overflow handling:
 // a non-zero value indicates certain types of overflow events during
 // the current CMS cycle and could lead to stack resizing efforts at
 size_t        _ser_kac_preclean_ovflw;
 size_t        _ser_kac_ovflw;
 size_t        _par_kac_ovflw;
 NOT_PRODUCT(ssize_t _num_par_pushes;)
-// ("Weak") Reference processing support
+// ("Weak") Reference processing support.
 ReferenceProcessor*            _ref_processor;
 CMSIsAliveClosure              _is_alive_closure;
-// keep this textually after _markBitMap and _span; c'tor dependency
+// Keep this textually after _markBitMap and _span; c'tor dependency.
-ConcurrentMarkSweepThread*     _cmsThread;   // the thread doing the work
+ConcurrentMarkSweepThread*     _cmsThread;   // The thread doing the work
 ModUnionClosure    _modUnionClosure;
 ModUnionClosurePar _modUnionClosurePar;
 // CMS abstract state machine
 // initial_state: Idling
 static CollectorState _collectorState;
 // State related to prologue/epilogue invocation for my generations
 bool _between_prologue_and_epilogue;
-// Signalling/State related to coordination between fore- and backgroud GC
+// Signaling/State related to coordination between fore- and background GC
 // Note: When the baton has been passed from background GC to foreground GC,
 // _foregroundGCIsActive is true and _foregroundGCShouldWait is false.
 static bool _foregroundGCIsActive;    // true iff foreground collector is active or
 // wants to go active
 static bool _foregroundGCShouldWait;  // true iff background GC is active and has not
 bool _start_sampling;
 int    _numYields;
 size_t _numDirtyCards;
 size_t _sweep_count;
-// number of full gc's since the last concurrent gc.
+// Number of full gc's since the last concurrent gc.
 uint   _full_gcs_since_conc_gc;
-// occupancy used for bootstrapping stats
+// Occupancy used for bootstrapping stats
 double _bootstrap_occupancy;
-// timer
+// Timer
 elapsedTimer _timer;
 // Timing, allocation and promotion statistics, used for scheduling.
 CMSStats      _stats;
 bool par_take_from_overflow_list(size_t num,
 OopTaskQueue* to_work_q,
 int no_of_gc_threads);
 void push_on_overflow_list(oop p);
 void par_push_on_overflow_list(oop p);
-// the following is, obviously, not, in general, "MT-stable"
+// The following is, obviously, not, in general, "MT-stable"
 bool overflow_list_is_empty() const;
 void preserve_mark_if_necessary(oop p);
 void par_preserve_mark_if_necessary(oop p);
 void preserve_mark_work(oop p, markOop m);
 void restore_preserved_marks_if_any();
 NOT_PRODUCT(bool no_preserved_marks() const;)
-// in support of testing overflow code
+// In support of testing overflow code
 NOT_PRODUCT(int _overflow_counter;)
-NOT_PRODUCT(bool simulate_overflow();)       // sequential
+NOT_PRODUCT(bool simulate_overflow();)       // Sequential
 NOT_PRODUCT(bool par_simulate_overflow();)   // MT version
 // CMS work methods
-void checkpointRootsInitialWork(bool asynch); // initial checkpoint work
+void checkpointRootsInitialWork(bool asynch); // Initial checkpoint work
-// a return value of false indicates failure due to stack overflow
+// A return value of false indicates failure due to stack overflow
-bool markFromRootsWork(bool asynch);  // concurrent marking work
+bool markFromRootsWork(bool asynch);  // Concurrent marking work
 public:   // FIX ME!!! only for testing
-bool do_marking_st(bool asynch);      // single-threaded marking
+bool do_marking_st(bool asynch);      // Single-threaded marking
-bool do_marking_mt(bool asynch);      // multi-threaded  marking
+bool do_marking_mt(bool asynch);      // Multi-threaded  marking
 private:
-// concurrent precleaning work
+// Concurrent precleaning work
 size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl);
 size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen,
 ScanMarkedObjectsAgainCarefullyClosure* cl);
 // Does precleaning work, returning a quantity indicative of
 // Helper function for above; merge-sorts the per-thread plab samples
 void merge_survivor_plab_arrays(ContiguousSpace* surv, int no_of_gc_threads);
 // Resets (i.e. clears) the per-thread plab sample vectors
 void reset_survivor_plab_arrays();
-// final (second) checkpoint work
+// Final (second) checkpoint work
 void checkpointRootsFinalWork(bool asynch, bool clear_all_soft_refs,
 bool init_mark_was_synchronous);
-// work routine for parallel version of remark
+// Work routine for parallel version of remark
 void do_remark_parallel();
-// work routine for non-parallel version of remark
+// Work routine for non-parallel version of remark
 void do_remark_non_parallel();
-// reference processing work routine (during second checkpoint)
+// Reference processing work routine (during second checkpoint)
 void refProcessingWork(bool asynch, bool clear_all_soft_refs);
-// concurrent sweeping work
+// Concurrent sweeping work
 void sweepWork(ConcurrentMarkSweepGeneration* gen, bool asynch);
-// (concurrent) resetting of support data structures
+// (Concurrent) resetting of support data structures
 void reset(bool asynch);
 // Clear _expansion_cause fields of constituent generations
 void clear_expansion_cause();
-// An auxilliary method used to record the ends of
+// An auxiliary method used to record the ends of
 // used regions of each generation to limit the extent of sweep
 void save_sweep_limits();
 // A work method used by foreground collection to determine
 // what type of collection (compacting or not, continuing or fresh)
 // Work methods for reporting concurrent mode interruption or failure
 bool is_external_interruption();
 void report_concurrent_mode_interruption();
-// If the backgrould GC is active, acquire control from the background
+// If the background GC is active, acquire control from the background
 // GC and do the collection.
 void acquire_control_and_collect(bool   full, bool clear_all_soft_refs);
 // For synchronizing passing of control from background to foreground
 // GC.  waitForForegroundGC() is called by the background
 size_t get_eden_used() const;
 size_t get_eden_capacity() const;
 ConcurrentMarkSweepGeneration* cmsGen() { return _cmsGen; }
-// locking checks
+// Locking checks
 NOT_PRODUCT(static bool have_cms_token();)
 // XXXPERM bool should_collect(bool full, size_t size, bool tlab);
 bool shouldConcurrentCollect();
 void sample_eden_chunk();
 CMSBitMap* markBitMap()  { return &_markBitMap; }
 void directAllocated(HeapWord* start, size_t size);
-// main CMS steps and related support
+// Main CMS steps and related support
 void checkpointRootsInitial(bool asynch);
 bool markFromRoots(bool asynch);  // a return value of false indicates failure
 // due to stack overflow
 void preclean();
 void checkpointRootsFinal(bool asynch, bool clear_all_soft_refs,
 bool is_cms_reachable(HeapWord* addr);
 // Performance Counter Support
 CollectorCounters* counters()    { return _gc_counters; }
-// timer stuff
+// Timer stuff
 void    startTimer() { assert(!_timer.is_active(), "Error"); _timer.start();   }
 void    stopTimer()  { assert( _timer.is_active(), "Error"); _timer.stop();    }
 void    resetTimer() { assert(!_timer.is_active(), "Error"); _timer.reset();   }
 double  timerValue() { assert(!_timer.is_active(), "Error"); return _timer.seconds(); }
 CMSAdaptiveSizePolicy* size_policy();
 CMSGCAdaptivePolicyCounters* gc_adaptive_policy_counters();
 static void print_on_error(outputStream* st);
-// debugging
+// Debugging
 void verify();
 bool verify_after_remark(bool silent = VerifySilently);
 void verify_ok_to_terminate() const PRODUCT_RETURN;
 void verify_work_stacks_empty() const PRODUCT_RETURN;
 void verify_overflow_empty() const PRODUCT_RETURN;
-// convenience methods in support of debugging
+// Convenience methods in support of debugging
 static const size_t skip_header_HeapWords() PRODUCT_RETURN0;
 HeapWord* block_start(const void* p) const PRODUCT_RETURN0;
-// accessors
+// Accessors
 CMSMarkStack* verification_mark_stack() { return &_markStack; }
 CMSBitMap*    verification_mark_bm()    { return &_verification_mark_bm; }
 // Initialization errors
 bool completed_initialization() { return _completed_initialization; }
 Unknown_collection_type             = 3
 };
 CollectionTypes _debug_collection_type;
-// True if a compactiing collection was done.
+// True if a compacting collection was done.
 bool _did_compact;
 bool did_compact() { return _did_compact; }
 // Fraction of current occupancy at which to start a CMS collection which
 // will collect this generation (at least).
 void space_iterate(SpaceClosure* blk, bool usedOnly = false);
 // Support for compaction
 CompactibleSpace* first_compaction_space() const;
-// Adjust quantites in the generation affected by
+// Adjust quantities in the generation affected by
 // the compaction.
 void reset_after_compaction();
 // Allocation support
 HeapWord* allocate(size_t size, bool tlab);
 // Smart allocation  XXX -- move to CFLSpace?
 void setNearLargestChunk();
 bool isNearLargestChunk(HeapWord* addr);
-// Get the chunk at the end of the space.  Delagates to
+// Get the chunk at the end of the space.  Delegates to
 // the space.
 FreeChunk* find_chunk_at_end();
 void post_compact();
 // This closure is used to do concurrent multi-threaded
 // marking from the roots following the first checkpoint.
 // XXX This should really be a subclass of The serial version
 // above, but i have not had the time to refactor things cleanly.
-// That willbe done for Dolphin.
 class Par_MarkFromRootsClosure: public BitMapClosure {
 CMSCollector*  _collector;
 MemRegion      _whole_span;
 MemRegion      _span;
 CMSBitMap*     _bit_map;
 void do_post_free_or_garbage_chunk(FreeChunk *fc, size_t chunkSize);
 // Process a free chunk during sweeping.
 void do_already_free_chunk(FreeChunk *fc);
 // Work method called when processing an already free or a
 // freshly garbage chunk to do a lookahead and possibly a
-// premptive flush if crossing over _limit.
+// preemptive flush if crossing over _limit.
 void lookahead_and_flush(FreeChunk* fc, size_t chunkSize);
 // Process a garbage chunk during sweeping.
 size_t do_garbage_chunk(FreeChunk *fc);
 // Process a live chunk during sweeping.
 size_t do_live_chunk(FreeChunk* fc);
 void trim_queue(uint max);
 void do_void();
 };
 // Allow yielding or short-circuiting of reference list
-// prelceaning work.
+// precleaning work.
 class CMSPrecleanRefsYieldClosure: public YieldClosure {
 CMSCollector* _collector;
 void do_yield_work();
 public:
 CMSPrecleanRefsYieldClosure(CMSCollector* collector):

changeset 22551	9bf46d16dcc6
parent 18996	05c86e558c94
child 22882	195c8f70d605