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

equal deleted inserted replaced

-:26a697375de3
+:f91c482793e6
 bool _cms_start_registered;
 GCHeapSummary _last_heap_summary;
 MetaspaceSummary _last_metaspace_summary;
-void register_foreground_gc_start(GCCause::Cause cause);
 void register_gc_start(GCCause::Cause cause);
 void register_gc_end();
 void save_heap_summary();
 void report_heap_summary(GCWhen::Type when);
 bool _start_sampling;
 int    _numYields;
 size_t _numDirtyCards;
 size_t _sweep_count;
-// Number of full gc's since the last concurrent gc.
-uint   _full_gcs_since_conc_gc;
 // Occupancy used for bootstrapping stats
 double _bootstrap_occupancy;
 // Timer
 NOT_PRODUCT(int _overflow_counter;)
 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(); // Initial checkpoint work
 // A return value of false indicates failure due to stack overflow
-bool markFromRootsWork(bool asynch);  // Concurrent marking work
+bool markFromRootsWork();  // Concurrent marking work
 public:   // FIX ME!!! only for testing
-bool do_marking_st(bool asynch);      // Single-threaded marking
+bool do_marking_st();      // Single-threaded marking
-bool do_marking_mt(bool asynch);      // Multi-threaded  marking
+bool do_marking_mt();      // Multi-threaded  marking
 private:
 // Concurrent precleaning work
 size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen,
 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
-void checkpointRootsFinalWork(bool asynch, bool clear_all_soft_refs,
+void checkpointRootsFinalWork();
-bool init_mark_was_synchronous);
 // Work routine for parallel version of remark
 void do_remark_parallel();
 // Work routine for non-parallel version of remark
 void do_remark_non_parallel();
 // Reference processing work routine (during second checkpoint)
-void refProcessingWork(bool asynch, bool clear_all_soft_refs);
+void refProcessingWork();
 // Concurrent sweeping work
-void sweepWork(ConcurrentMarkSweepGeneration* gen, bool asynch);
+void sweepWork(ConcurrentMarkSweepGeneration* gen);
 // (Concurrent) resetting of support data structures
-void reset(bool asynch);
+void reset(bool concurrent);
 // Clear _expansion_cause fields of constituent generations
 void clear_expansion_cause();
 // 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)
-// it should do.
-void decide_foreground_collection_type(bool clear_all_soft_refs,
-bool* should_compact, bool* should_start_over);
 // A work method used by the foreground collector to do
 // a mark-sweep-compact.
 void do_compaction_work(bool clear_all_soft_refs);
-// A work method used by the foreground collector to do
-// a mark-sweep, after taking over from a possibly on-going
-// concurrent mark-sweep collection.
-void do_mark_sweep_work(bool clear_all_soft_refs,
-CollectorState first_state, bool should_start_over);
 // Work methods for reporting concurrent mode interruption or failure
 bool is_external_interruption();
 void report_concurrent_mode_interruption();
 ConcurrentMarkSweepGeneration* cmsGen() { return _cmsGen; }
 // Locking checks
 NOT_PRODUCT(static bool have_cms_token();)
-// XXXPERM bool should_collect(bool full, size_t size, bool tlab);
 bool shouldConcurrentCollect();
 void collect(bool   full,
 bool   clear_all_soft_refs,
 size_t size,
 bool   tlab);
-void collect_in_background(bool clear_all_soft_refs, GCCause::Cause cause);
+void collect_in_background(GCCause::Cause cause);
-void collect_in_foreground(bool clear_all_soft_refs, GCCause::Cause cause);
 // In support of ExplicitGCInvokesConcurrent
 static void request_full_gc(unsigned int full_gc_count, GCCause::Cause cause);
 // Should we unload classes in a particular concurrent cycle?
 bool should_unload_classes() const {
 CMSBitMap* markBitMap()  { return &_markBitMap; }
 void directAllocated(HeapWord* start, size_t size);
 // Main CMS steps and related support
-void checkpointRootsInitial(bool asynch);
+void checkpointRootsInitial();
-bool markFromRoots(bool asynch);  // a return value of false indicates failure
+bool markFromRoots();  // a return value of false indicates failure
 // due to stack overflow
 void preclean();
-void checkpointRootsFinal(bool asynch, bool clear_all_soft_refs,
+void checkpointRootsFinal();
-bool init_mark_was_synchronous);
+void sweep();
-void sweep(bool asynch);
 // Check that the currently executing thread is the expected
 // one (foreground collector or background collector).
 static void check_correct_thread_executing() PRODUCT_RETURN;
-// XXXPERM void print_statistics()           PRODUCT_RETURN;
 bool is_cms_reachable(HeapWord* addr);
 // Performance Counter Support
 CollectorCounters* counters()    { return _gc_counters; }
 CMSExpansionCause::Cause _expansion_cause;
 // In support of MinChunkSize being larger than min object size
 const double _dilatation_factor;
-enum CollectionTypes {
+bool _debug_concurrent_cycle;
-Concurrent_collection_type          = 0,
-MS_foreground_collection_type       = 1,
-MSC_foreground_collection_type      = 2,
-Unknown_collection_type             = 3
-};
-CollectionTypes _debug_collection_type;
 // True if a compacting collection was done.
 bool _did_compact;
 bool did_compact() { return _did_compact; }
 // Does a "full" (forced) collection invoked on this generation collect
 // all younger generations as well? Note that the second conjunct is a
 // hack to allow the collection of the younger gen first if the flag is
 // set.
 virtual bool full_collects_younger_generations() const {
-return UseCMSCompactAtFullCollection && !ScavengeBeforeFullGC;
+return !ScavengeBeforeFullGC;
 }
 void space_iterate(SpaceClosure* blk, bool usedOnly = false);
 // Support for compaction
 virtual void compute_new_size();
 // Resize the generation after a non-compacting
 // collection.
 void compute_new_size_free_list();
-CollectionTypes debug_collection_type() { return _debug_collection_type; }
+bool debug_concurrent_cycle() { return _debug_concurrent_cycle; }
 void rotate_debug_collection_type();
 };
 //
 // Closures of various sorts used by CMS to accomplish its work
 MemRegion      _span;
 CMSBitMap*     _bit_map;
 CMSBitMap*     _mut;
 OopTaskQueue*  _work_queue;
 CMSMarkStack*  _overflow_stack;
-bool           _yield;
 int            _skip_bits;
 HeapWord*      _finger;
 HeapWord*      _threshold;
 CMSConcMarkingTask* _task;
 public:
 Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector,
 MemRegion span,
 CMSBitMap* bit_map,
 OopTaskQueue* work_queue,
-CMSMarkStack*  overflow_stack,
+CMSMarkStack*  overflow_stack);
-bool should_yield);
 bool do_bit(size_t offset);
 inline void do_yield_check();
 private:
 void scan_oops_in_oop(HeapWord* ptr);

changeset 27686	f91c482793e6
parent 27625	07829380b8cd
child 27689	660857fcef8c