graal-compiler: src/share/vm/memory/collectorPolicy.hpp comparison

comparison src/share/vm/memory/collectorPolicy.hpp @ 13102:f9f4503a4ab5

Merge

author	Christos Kotselidis <christos.kotselidis@oracle.com>
date	Thu, 21 Nov 2013 15:04:54 +0100
parents	236cecd9ec97
children	63a4eb8bcd23 1d01a7f3a336

comparison

equal deleted inserted replaced

-:790ebab62d23
+:f9f4503a4ab5
 class CollectorPolicy : public CHeapObj<mtGC> {
 protected:
 GCPolicyCounters* _gc_policy_counters;
-// Requires that the concrete subclass sets the alignment constraints
+virtual void initialize_alignments() = 0;
-// before calling.
 virtual void initialize_flags();
 virtual void initialize_size_info();
+DEBUG_ONLY(virtual void assert_flags();)
+DEBUG_ONLY(virtual void assert_size_info();)
 size_t _initial_heap_byte_size;
 size_t _max_heap_byte_size;
 size_t _min_heap_byte_size;
-size_t _min_alignment;
+size_t _space_alignment;
-size_t _max_alignment;
+size_t _heap_alignment;
+// Needed to keep information if MaxHeapSize was set on the command line
+// when the flag value is aligned etc by ergonomics
+bool _max_heap_size_cmdline;
 // The sizing of the heap are controlled by a sizing policy.
 AdaptiveSizePolicy* _size_policy;
 // Set to true when policy wants soft refs cleared.
 // Reset to false by gc after it clears all soft refs.
 bool _should_clear_all_soft_refs;
 // Set to true by the GC if the just-completed gc cleared all
 // softrefs.  This is set to true whenever a gc clears all softrefs, and
 // set to false each time gc returns to the mutator.  For example, in the
 // ParallelScavengeHeap case the latter would be done toward the end of
 // mem_allocate() where it returns op.result()
 bool _all_soft_refs_clear;
-CollectorPolicy() :
+CollectorPolicy();
-_min_alignment(1),
-_max_alignment(1),
+public:
-_initial_heap_byte_size(0),
+virtual void initialize_all() {
-_max_heap_byte_size(0),
+initialize_alignments();
-_min_heap_byte_size(0),
+initialize_flags();
-_size_policy(NULL),
+initialize_size_info();
-_should_clear_all_soft_refs(false),
+}
-_all_soft_refs_clear(false)
-{}
-public:
 // Return maximum heap alignment that may be imposed by the policy
-static size_t compute_max_alignment();
+static size_t compute_heap_alignment();
-void set_min_alignment(size_t align)         { _min_alignment = align; }
+size_t space_alignment()        { return _space_alignment; }
-size_t min_alignment()                       { return _min_alignment; }
+size_t heap_alignment()         { return _heap_alignment; }
-void set_max_alignment(size_t align)         { _max_alignment = align; }
-size_t max_alignment()                       { return _max_alignment; }
 size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
-void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
 size_t max_heap_byte_size()     { return _max_heap_byte_size; }
-void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
 size_t min_heap_byte_size()     { return _min_heap_byte_size; }
-void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
 enum Name {
 CollectorPolicyKind,
 TwoGenerationCollectorPolicyKind,
 ConcurrentMarkSweepPolicyKind,
 bool is_g1_policy()                    { return false; }
 #endif // INCLUDE_ALL_GCS
 virtual BarrierSet::Name barrier_set_name() = 0;
-virtual GenRemSet::Name  rem_set_name() = 0;
 // Create the remembered set (to cover the given reserved region,
 // allowing breaking up into at most "max_covered_regions").
 virtual GenRemSet* create_rem_set(MemRegion reserved,
 int max_covered_regions);
 // Returns true if a collector has eden space with soft end.
 virtual bool has_soft_ended_eden() {
 return false;
 }
+// Do any updates required to global flags that are due to heap initialization
+// changes
+virtual void post_heap_initialize() = 0;
 };
 class ClearedAllSoftRefs : public StackObj {
 bool _clear_all_soft_refs;
 CollectorPolicy* _collector_policy;
 protected:
 size_t _min_gen0_size;
 size_t _initial_gen0_size;
 size_t _max_gen0_size;
+// _gen_alignment and _space_alignment will have the same value most of the
+// time. When using large pages they can differ.
+size_t _gen_alignment;
 GenerationSpec **_generations;
 // Return true if an allocation should be attempted in the older
 // generation if it fails in the younger generation.  Return
 // false, otherwise.
 virtual bool should_try_older_generation_allocation(size_t word_size) const;
 void initialize_flags();
 void initialize_size_info();
+DEBUG_ONLY(void assert_flags();)
+DEBUG_ONLY(void assert_size_info();)
 // Try to allocate space by expanding the heap.
 virtual HeapWord* expand_heap_and_allocate(size_t size, bool is_tlab);
-// Scale the base_size by NewRation according to
+// Compute max heap alignment
+size_t compute_max_alignment();
+// Scale the base_size by NewRatio according to
 //     result = base_size / (NewRatio + 1)
 // and align by min_alignment()
 size_t scale_by_NewRatio_aligned(size_t base_size);
-// Bound the value by the given maximum minus the
+// Bound the value by the given maximum minus the min_alignment
-// min_alignment.
 size_t bound_minus_alignment(size_t desired_size, size_t maximum_size);
 public:
+GenCollectorPolicy();
 // Accessors
-size_t min_gen0_size() { return _min_gen0_size; }
+size_t min_gen0_size()     { return _min_gen0_size; }
-void set_min_gen0_size(size_t v) { _min_gen0_size = v; }
 size_t initial_gen0_size() { return _initial_gen0_size; }
-void set_initial_gen0_size(size_t v) { _initial_gen0_size = v; }
+size_t max_gen0_size()     { return _max_gen0_size; }
-size_t max_gen0_size() { return _max_gen0_size; }
+size_t gen_alignment()     { return _gen_alignment; }
-void set_max_gen0_size(size_t v) { _max_gen0_size = v; }
 virtual int number_of_generations() = 0;
-virtual GenerationSpec **generations()       {
+virtual GenerationSpec **generations() {
 assert(_generations != NULL, "Sanity check");
 return _generations;
 }
 virtual GenCollectorPolicy* as_generation_policy() { return this; }
-virtual void initialize_generations() = 0;
+virtual void initialize_generations() { };
 virtual void initialize_all() {
-initialize_flags();
+CollectorPolicy::initialize_all();
-initialize_size_info();
 initialize_generations();
 }
+size_t young_gen_size_lower_bound();
 HeapWord* mem_allocate_work(size_t size,
 bool is_tlab,
 bool* gc_overhead_limit_was_exceeded);
 // Adaptive size policy
 virtual void initialize_size_policy(size_t init_eden_size,
 size_t init_promo_size,
 size_t init_survivor_size);
+virtual void post_heap_initialize() {
+assert(_max_gen0_size == MaxNewSize, "Should be taken care of by initialize_size_info");
+}
 };
 // All of hotspot's current collectors are subtypes of this
 // class. Currently, these collectors all use the same gen[0],
 // but have different gen[1] types. If we add another subtype
 size_t _initial_gen1_size;
 size_t _max_gen1_size;
 void initialize_flags();
 void initialize_size_info();
-void initialize_generations()                { ShouldNotReachHere(); }
+DEBUG_ONLY(void assert_flags();)
-public:
+DEBUG_ONLY(void assert_size_info();)
+public:
+TwoGenerationCollectorPolicy() : GenCollectorPolicy(), _min_gen1_size(0),
+_initial_gen1_size(0), _max_gen1_size(0) {}
 // Accessors
-size_t min_gen1_size() { return _min_gen1_size; }
+size_t min_gen1_size()     { return _min_gen1_size; }
-void set_min_gen1_size(size_t v) { _min_gen1_size = v; }
 size_t initial_gen1_size() { return _initial_gen1_size; }
-void set_initial_gen1_size(size_t v) { _initial_gen1_size = v; }
+size_t max_gen1_size()     { return _max_gen1_size; }
-size_t max_gen1_size() { return _max_gen1_size; }
-void set_max_gen1_size(size_t v) { _max_gen1_size = v; }
 // Inherited methods
 TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
-int number_of_generations()                  { return 2; }
+int number_of_generations()          { return 2; }
-BarrierSet::Name barrier_set_name()          { return BarrierSet::CardTableModRef; }
+BarrierSet::Name barrier_set_name()  { return BarrierSet::CardTableModRef; }
-GenRemSet::Name rem_set_name()               { return GenRemSet::CardTable; }
 virtual CollectorPolicy::Name kind() {
 return CollectorPolicy::TwoGenerationCollectorPolicyKind;
 }
-// Returns true is gen0 sizes were adjusted
+// Returns true if gen0 sizes were adjusted
 bool adjust_gen0_sizes(size_t* gen0_size_ptr, size_t* gen1_size_ptr,
-const size_t heap_size, const size_t min_gen1_size);
+const size_t heap_size);
 };
 class MarkSweepPolicy : public TwoGenerationCollectorPolicy {
 protected:
+void initialize_alignments();
 void initialize_generations();
 public:
-MarkSweepPolicy();
+MarkSweepPolicy() {}
 MarkSweepPolicy* as_mark_sweep_policy() { return this; }
 void initialize_gc_policy_counters();
 };

Mercurial > hg > graal-compiler

comparison src/share/vm/memory/collectorPolicy.hpp @ 13102:f9f4503a4ab5