diff --git a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp index 5edd8ccc9abc008a3c1d30cc36a77cd00dffc7a5..838e35fb599b64511990dfbfe042076c8322469d 100644 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.cpp @@ -1195,9 +1195,9 @@ void CMSAdaptiveSizePolicy::compute_tenured_generation_free_space( set_promo_size(desired_promo_size); } -int CMSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold( +uint CMSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold( bool is_survivor_overflow, - int tenuring_threshold, + uint tenuring_threshold, size_t survivor_limit) { assert(survivor_limit >= generation_alignment(), "survivor_limit too small"); @@ -1315,7 +1315,7 @@ int CMSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold( gclog_or_tty->print( " avg_promoted_padded_avg: %f" " avg_pretenured_padded_avg: %f" - " tenuring_thresh: %d" + " tenuring_thresh: %u" " target_size: " SIZE_FORMAT " survivor_limit: " SIZE_FORMAT, gch->gc_stats(1)->avg_promoted()->padded_average(), diff --git a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp index ec418e689b5430354eec11f3206dbbe4cfb80d43..6053b4323bde71258285272b2fc4a198af15082b 100644 --- a/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp +++ b/src/share/vm/gc_implementation/concurrentMarkSweep/cmsAdaptiveSizePolicy.hpp @@ -440,9 +440,9 @@ class CMSAdaptiveSizePolicy : public AdaptiveSizePolicy { size_t max_eden_size); // Calculates new survivor space size; returns a new tenuring threshold // value. Stores new survivor size in _survivor_size. - virtual int compute_survivor_space_size_and_threshold( + virtual uint compute_survivor_space_size_and_threshold( bool is_survivor_overflow, - int tenuring_threshold, + uint tenuring_threshold, size_t survivor_limit); virtual void compute_tenured_generation_free_space(size_t cur_tenured_free, diff --git a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp index 4a3f46c974d8b815cf532cd515df3360da9e2335..b7d810dbb603a3a0f420cab1597f391099989527 100644 --- a/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp +++ b/src/share/vm/gc_implementation/g1/g1CollectorPolicy.hpp @@ -840,8 +840,8 @@ private: // // Current tenuring threshold, set to 0 if the collector reaches the - // maximum amount of suvivors regions. - int _tenuring_threshold; + // maximum amount of survivors regions. + uint _tenuring_threshold; // The limit on the number of regions allocated for survivors. uint _max_survivor_regions; @@ -851,7 +851,7 @@ private: size_t _survivor_bytes_before_gc; size_t _capacity_before_gc; - // The amount of survor regions after a collection. + // The amount of survivor regions after a collection. uint _recorded_survivor_regions; // List of survivor regions. HeapRegion* _recorded_survivor_head; @@ -862,7 +862,7 @@ private: public: inline GCAllocPurpose - evacuation_destination(HeapRegion* src_region, int age, size_t word_sz) { + evacuation_destination(HeapRegion* src_region, uint age, size_t word_sz) { if (age < _tenuring_threshold && src_region->is_young()) { return GCAllocForSurvived; } else { diff --git a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp index e3909617fe3fb504a821ca09c93b28dae3d89ab3..3b24ed8866a758272c7a15daddc38091428afadd 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.cpp @@ -941,9 +941,9 @@ size_t PSAdaptiveSizePolicy::promo_decrement(size_t cur_promo) { return promo_heap_delta; } -int PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold( +uint PSAdaptiveSizePolicy::compute_survivor_space_size_and_threshold( bool is_survivor_overflow, - int tenuring_threshold, + uint tenuring_threshold, size_t survivor_limit) { assert(survivor_limit >= _intra_generation_alignment, "survivor_limit too small"); diff --git a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp index d9b86e8fb37737d751285db567e86d788fdcd170..030cb9da167408340312b87688f2ec3697339335 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psAdaptiveSizePolicy.hpp @@ -353,9 +353,9 @@ class PSAdaptiveSizePolicy : public AdaptiveSizePolicy { // Calculates new survivor space size; returns a new tenuring threshold // value. Stores new survivor size in _survivor_size. - int compute_survivor_space_size_and_threshold(bool is_survivor_overflow, - int tenuring_threshold, - size_t survivor_limit); + uint compute_survivor_space_size_and_threshold(bool is_survivor_overflow, + uint tenuring_threshold, + size_t survivor_limit); // Return the maximum size of a survivor space if the young generation were of // size gen_size. diff --git a/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp index d19d2b4e797edf35fcb7b4b8308cbd37556f451a..8822a481b3db60baa1db89775f3528e378d6a867 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psPromotionManager.inline.hpp @@ -85,7 +85,7 @@ oop PSPromotionManager::copy_to_survivor_space(oop o) { if (!promote_immediately) { // Find the objects age, MT safe. - int age = (test_mark->has_displaced_mark_helper() /* o->has_displaced_mark() */) ? + uint age = (test_mark->has_displaced_mark_helper() /* o->has_displaced_mark() */) ? test_mark->displaced_mark_helper()->age() : test_mark->age(); // Try allocating obj in to-space (unless too old) diff --git a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp index 45057db5231b64e286debd23978d031d4fc3a590..370311d1c9caeeccaa848da28bb07eadc6d2eee3 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.cpp @@ -59,7 +59,7 @@ int PSScavenge::_consecutive_skipped_scavenges = 0; ReferenceProcessor* PSScavenge::_ref_processor = NULL; CardTableExtension* PSScavenge::_card_table = NULL; bool PSScavenge::_survivor_overflow = false; -int PSScavenge::_tenuring_threshold = 0; +uint PSScavenge::_tenuring_threshold = 0; HeapWord* PSScavenge::_young_generation_boundary = NULL; elapsedTimer PSScavenge::_accumulated_time; Stack PSScavenge::_preserved_mark_stack; @@ -529,7 +529,7 @@ bool PSScavenge::invoke_no_policy() { if (PrintTenuringDistribution) { gclog_or_tty->cr(); - gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %d (max %d)", + gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %u (max %u)", size_policy->calculated_survivor_size_in_bytes(), _tenuring_threshold, MaxTenuringThreshold); } diff --git a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp index af753d6f40d4bb53ca0058b3913ce6172e616385..43e59ac9cfbb8fbd806f5bb5b089ab2406f94411 100644 --- a/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp +++ b/src/share/vm/gc_implementation/parallelScavenge/psScavenge.hpp @@ -66,14 +66,14 @@ class PSScavenge: AllStatic { static PSIsAliveClosure _is_alive_closure; // Closure used for reference processing static CardTableExtension* _card_table; // We cache the card table for fast access. static bool _survivor_overflow; // Overflow this collection - static int _tenuring_threshold; // tenuring threshold for next scavenge + static uint _tenuring_threshold; // tenuring threshold for next scavenge static elapsedTimer _accumulated_time; // total time spent on scavenge static HeapWord* _young_generation_boundary; // The lowest address possible for the young_gen. // This is used to decide if an oop should be scavenged, // cards should be marked, etc. static Stack _preserved_mark_stack; // List of marks to be restored after failed promotion static Stack _preserved_oop_stack; // List of oops that need their mark restored. - static CollectorCounters* _counters; // collector performance counters + static CollectorCounters* _counters; // collector performance counters static bool _promotion_failed; static void clean_up_failed_promotion(); @@ -88,7 +88,7 @@ class PSScavenge: AllStatic { public: // Accessors - static int tenuring_threshold() { return _tenuring_threshold; } + static uint tenuring_threshold() { return _tenuring_threshold; } static elapsedTimer* accumulated_time() { return &_accumulated_time; } static bool promotion_failed() { return _promotion_failed; } static int consecutive_skipped_scavenges() diff --git a/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp b/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp index 2b5858b725af252919c23bef6bcec7819ba93eec..90093a2cb2e2a82a445eefe6e489239dc9552546 100644 --- a/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp +++ b/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.cpp @@ -642,7 +642,7 @@ bool AdaptiveSizePolicy::print_adaptive_size_policy_on(outputStream* st) const { bool AdaptiveSizePolicy::print_adaptive_size_policy_on( outputStream* st, - int tenuring_threshold_arg) const { + uint tenuring_threshold_arg) const { if (!AdaptiveSizePolicy::print_adaptive_size_policy_on(st)) { return false; } @@ -663,7 +663,7 @@ bool AdaptiveSizePolicy::print_adaptive_size_policy_on( assert(!tenuring_threshold_change(), "(no change was attempted)"); } if (tenuring_threshold_changed) { - st->print_cr("%d", tenuring_threshold_arg); + st->print_cr("%u", tenuring_threshold_arg); } return true; } diff --git a/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp b/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp index 4becadce84be864eeb02db62239d0049819b41ac..6cdbe86f95ec7ec69697479f4541ce1efa2b40ea 100644 --- a/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp +++ b/src/share/vm/gc_implementation/shared/adaptiveSizePolicy.hpp @@ -489,8 +489,8 @@ class AdaptiveSizePolicy : public CHeapObj { // Printing support virtual bool print_adaptive_size_policy_on(outputStream* st) const; - bool print_adaptive_size_policy_on(outputStream* st, int - tenuring_threshold) const; + bool print_adaptive_size_policy_on(outputStream* st, + uint tenuring_threshold) const; }; // Class that can be used to print information about the diff --git a/src/share/vm/gc_implementation/shared/ageTable.cpp b/src/share/vm/gc_implementation/shared/ageTable.cpp index bc74db8f777d935073b48623f52a119695657f8d..50162a0adb19c8aa13c0b5a6b173222740066727 100644 --- a/src/share/vm/gc_implementation/shared/ageTable.cpp +++ b/src/share/vm/gc_implementation/shared/ageTable.cpp @@ -78,10 +78,10 @@ void ageTable::merge_par(ageTable* subTable) { } } -int ageTable::compute_tenuring_threshold(size_t survivor_capacity) { +uint ageTable::compute_tenuring_threshold(size_t survivor_capacity) { size_t desired_survivor_size = (size_t)((((double) survivor_capacity)*TargetSurvivorRatio)/100); size_t total = 0; - int age = 1; + uint age = 1; assert(sizes[0] == 0, "no objects with age zero should be recorded"); while (age < table_size) { total += sizes[age]; @@ -90,13 +90,13 @@ int ageTable::compute_tenuring_threshold(size_t survivor_capacity) { if (total > desired_survivor_size) break; age++; } - int result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold; + uint result = age < MaxTenuringThreshold ? age : MaxTenuringThreshold; if (PrintTenuringDistribution || UsePerfData) { if (PrintTenuringDistribution) { gclog_or_tty->cr(); - gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %d (max %d)", + gclog_or_tty->print_cr("Desired survivor size %ld bytes, new threshold %u (max %u)", desired_survivor_size*oopSize, result, MaxTenuringThreshold); } @@ -106,7 +106,7 @@ int ageTable::compute_tenuring_threshold(size_t survivor_capacity) { total += sizes[age]; if (sizes[age] > 0) { if (PrintTenuringDistribution) { - gclog_or_tty->print_cr("- age %3d: %10ld bytes, %10ld total", + gclog_or_tty->print_cr("- age %3u: %10ld bytes, %10ld total", age, sizes[age]*oopSize, total*oopSize); } } diff --git a/src/share/vm/gc_implementation/shared/ageTable.hpp b/src/share/vm/gc_implementation/shared/ageTable.hpp index d763157e4f248b09999ce7b4e990ac8bb6519d99..9e2ee99997f2e4668d256e5165d8ec2dbbfe1556 100644 --- a/src/share/vm/gc_implementation/shared/ageTable.hpp +++ b/src/share/vm/gc_implementation/shared/ageTable.hpp @@ -55,7 +55,7 @@ class ageTable VALUE_OBJ_CLASS_SPEC { // add entry void add(oop p, size_t oop_size) { - int age = p->age(); + uint age = p->age(); assert(age > 0 && age < table_size, "invalid age of object"); sizes[age] += oop_size; } @@ -66,7 +66,7 @@ class ageTable VALUE_OBJ_CLASS_SPEC { void merge_par(ageTable* subTable); // calculate new tenuring threshold based on age information - int compute_tenuring_threshold(size_t survivor_capacity); + uint compute_tenuring_threshold(size_t survivor_capacity); private: PerfVariable* _perf_sizes[table_size]; diff --git a/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp b/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp index 30e78244ac41098d0ad976dc14de0e85edb1797b..c1758a2fc19a94ecc899753c406303c176764e0c 100644 --- a/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp +++ b/src/share/vm/gc_implementation/shared/gcAdaptivePolicyCounters.hpp @@ -188,7 +188,7 @@ class GCAdaptivePolicyCounters : public GCPolicyCounters { inline void update_survivor_overflowed(bool survivor_overflowed) { _survivor_overflowed_counter->set_value(survivor_overflowed); } - inline void update_tenuring_threshold(int threshold) { + inline void update_tenuring_threshold(uint threshold) { tenuring_threshold()->set_value(threshold); } inline void update_increment_tenuring_threshold_for_gc_cost() { diff --git a/src/share/vm/memory/defNewGeneration.hpp b/src/share/vm/memory/defNewGeneration.hpp index 832782b149cc57d066669ad3d96d8c35159ace67..b7c794d86c2078d5621dd271da354058fbf923fa 100644 --- a/src/share/vm/memory/defNewGeneration.hpp +++ b/src/share/vm/memory/defNewGeneration.hpp @@ -43,7 +43,7 @@ class DefNewGeneration: public Generation { protected: Generation* _next_gen; - int _tenuring_threshold; // Tenuring threshold for next collection. + uint _tenuring_threshold; // Tenuring threshold for next collection. ageTable _age_table; // Size of object to pretenure in words; command line provides bytes size_t _pretenure_size_threshold_words; @@ -325,7 +325,7 @@ protected: bool parallel = false); oop copy_to_survivor_space(oop old); - int tenuring_threshold() { return _tenuring_threshold; } + uint tenuring_threshold() { return _tenuring_threshold; } // Performance Counter support void update_counters(); diff --git a/src/share/vm/memory/threadLocalAllocBuffer.hpp b/src/share/vm/memory/threadLocalAllocBuffer.hpp index c85a59de14eba471d42e0ed53c6903d6e8c1e532..c11c4994a2a233c0539ee74c7d06034352a9d13f 100644 --- a/src/share/vm/memory/threadLocalAllocBuffer.hpp +++ b/src/share/vm/memory/threadLocalAllocBuffer.hpp @@ -35,7 +35,7 @@ class GlobalTLABStats; // the threads for allocation. // It is thread-private at any time, but maybe multiplexed over // time across multiple threads. The park()/unpark() pair is -// used to make it avaiable for such multiplexing. +// used to make it available for such multiplexing. class ThreadLocalAllocBuffer: public CHeapObj { friend class VMStructs; private: diff --git a/src/share/vm/oops/markOop.hpp b/src/share/vm/oops/markOop.hpp index c5b35ee7a04250c43db875063f9e7994f237ffad..d49beb33bfc11a82ac9ef56b27ca5a93aa15b34b 100644 --- a/src/share/vm/oops/markOop.hpp +++ b/src/share/vm/oops/markOop.hpp @@ -318,7 +318,7 @@ class markOopDesc: public oopDesc { intptr_t tmp = (intptr_t) monitor; return (markOop) (tmp | monitor_value); } - static markOop encode(JavaThread* thread, int age, int bias_epoch) { + static markOop encode(JavaThread* thread, uint age, int bias_epoch) { intptr_t tmp = (intptr_t) thread; assert(UseBiasedLocking && ((tmp & (epoch_mask_in_place | age_mask_in_place | biased_lock_mask_in_place)) == 0), "misaligned JavaThread pointer"); assert(age <= max_age, "age too large"); @@ -333,10 +333,10 @@ class markOopDesc: public oopDesc { markOop set_marked() { return markOop((value() & ~lock_mask_in_place) | marked_value); } markOop set_unmarked() { return markOop((value() & ~lock_mask_in_place) | unlocked_value); } - int age() const { return mask_bits(value() >> age_shift, age_mask); } - markOop set_age(int v) const { + uint age() const { return mask_bits(value() >> age_shift, age_mask); } + markOop set_age(uint v) const { assert((v & ~age_mask) == 0, "shouldn't overflow age field"); - return markOop((value() & ~age_mask_in_place) | (((intptr_t)v & age_mask) << age_shift)); + return markOop((value() & ~age_mask_in_place) | (((uintptr_t)v & age_mask) << age_shift)); } markOop incr_age() const { return age() == max_age ? markOop(this) : set_age(age() + 1); } diff --git a/src/share/vm/oops/oop.hpp b/src/share/vm/oops/oop.hpp index ca79e348698c6845fad6a827d43539e6b2cad863..7cb04ff4c00cb1fb6ac87791af5621d68cf5a3be 100644 --- a/src/share/vm/oops/oop.hpp +++ b/src/share/vm/oops/oop.hpp @@ -327,7 +327,7 @@ class oopDesc { oop forwardee() const; // Age of object during scavenge - int age() const; + uint age() const; void incr_age(); // Adjust all pointers in this object to point at it's forwarded location and diff --git a/src/share/vm/oops/oop.inline.hpp b/src/share/vm/oops/oop.inline.hpp index c3099b36e1b9b3293ec6f20088f7edbc5fa42f97..a9b532c7e5357029931f17606a97b561de0068b9 100644 --- a/src/share/vm/oops/oop.inline.hpp +++ b/src/share/vm/oops/oop.inline.hpp @@ -693,7 +693,7 @@ inline void oopDesc::set_displaced_mark(markOop m) { } // The following method needs to be MT safe. -inline int oopDesc::age() const { +inline uint oopDesc::age() const { assert(!is_forwarded(), "Attempt to read age from forwarded mark"); if (has_displaced_mark()) { return displaced_mark()->age(); diff --git a/src/share/vm/runtime/arguments.cpp b/src/share/vm/runtime/arguments.cpp index 5cbe69275dbe54ea3c56a1c13936dcc086d7650c..f514f02c52f258bb4929e4764a4352fbffea9fd8 100644 --- a/src/share/vm/runtime/arguments.cpp +++ b/src/share/vm/runtime/arguments.cpp @@ -1112,7 +1112,7 @@ void Arguments::set_parnew_gc_flags() { // AlwaysTenure flag should make ParNew promote all at first collection. // See CR 6362902. if (AlwaysTenure) { - FLAG_SET_CMDLINE(intx, MaxTenuringThreshold, 0); + FLAG_SET_CMDLINE(uintx, MaxTenuringThreshold, 0); } // When using compressed oops, we use local overflow stacks, // rather than using a global overflow list chained through @@ -1231,7 +1231,7 @@ void Arguments::set_cms_and_parnew_gc_flags() { // promote all objects surviving "tenuring_default" scavenges. if (FLAG_IS_DEFAULT(MaxTenuringThreshold) && FLAG_IS_DEFAULT(SurvivorRatio)) { - FLAG_SET_ERGO(intx, MaxTenuringThreshold, tenuring_default); + FLAG_SET_ERGO(uintx, MaxTenuringThreshold, tenuring_default); } // If we decided above (or user explicitly requested) // `promote all' (via MaxTenuringThreshold := 0), diff --git a/src/share/vm/runtime/biasedLocking.cpp b/src/share/vm/runtime/biasedLocking.cpp index 469f46194728dccffc669fbb2806a2392e904ea6..3d9c279a2aec434d6e59a4d77a78450b2483d8b6 100644 --- a/src/share/vm/runtime/biasedLocking.cpp +++ b/src/share/vm/runtime/biasedLocking.cpp @@ -154,7 +154,7 @@ static BiasedLocking::Condition revoke_bias(oop obj, bool allow_rebias, bool is_ return BiasedLocking::NOT_BIASED; } - int age = mark->age(); + uint age = mark->age(); markOop biased_prototype = markOopDesc::biased_locking_prototype()->set_age(age); markOop unbiased_prototype = markOopDesc::prototype()->set_age(age); diff --git a/src/share/vm/runtime/globals.hpp b/src/share/vm/runtime/globals.hpp index e273bc75216ea522362ca184fc8117102fcfc22b..f0c93014f9df003ea591b2e4330fb50b6e53996b 100644 --- a/src/share/vm/runtime/globals.hpp +++ b/src/share/vm/runtime/globals.hpp @@ -473,7 +473,7 @@ class CommandLineFlags { develop(bool, CleanChunkPoolAsync, falseInEmbedded, \ "Whether to clean the chunk pool asynchronously") \ \ - /* Temporary: See 6948537 */ \ + /* Temporary: See 6948537 */ \ experimental(bool, UseMemSetInBOT, true, \ "(Unstable) uses memset in BOT updates in GC code") \ \ @@ -1626,7 +1626,7 @@ class CommandLineFlags { "Use BinaryTreeDictionary as default in the CMS generation") \ \ product(uintx, CMSIndexedFreeListReplenish, 4, \ - "Replenish an indexed free list with this number of chunks") \ + "Replenish an indexed free list with this number of chunks") \ \ product(bool, CMSReplenishIntermediate, true, \ "Replenish all intermediate free-list caches") \ @@ -2052,7 +2052,7 @@ class CommandLineFlags { product(uintx, TenuredGenerationSizeSupplementDecay, 2, \ "Decay factor to TenuredGenerationSizeIncrement") \ \ - product(uintx, MaxGCPauseMillis, max_uintx, \ + product(uintx, MaxGCPauseMillis, max_uintx, \ "Adaptive size policy maximum GC pause time goal in msec, " \ "or (G1 Only) the max. GC time per MMU time slice") \ \ @@ -2266,7 +2266,7 @@ class CommandLineFlags { develop(bool, TraceGCTaskQueue, false, \ "Trace actions of the GC task queues") \ \ - diagnostic(bool, TraceGCTaskThread, false, \ + diagnostic(bool, TraceGCTaskThread, false, \ "Trace actions of the GC task threads") \ \ product(bool, PrintParallelOldGCPhaseTimes, false, \ @@ -2781,7 +2781,7 @@ class CommandLineFlags { product(intx, SafepointTimeoutDelay, 10000, \ "Delay in milliseconds for option SafepointTimeout") \ \ - product(intx, NmethodSweepFraction, 16, \ + product(intx, NmethodSweepFraction, 16, \ "Number of invocations of sweeper to cover all nmethods") \ \ product(intx, NmethodSweepCheckInterval, 5, \ @@ -2904,7 +2904,7 @@ class CommandLineFlags { "if non-zero, start verifying C heap after Nth call to " \ "malloc/realloc/free") \ \ - product(intx, TypeProfileWidth, 2, \ + product(intx, TypeProfileWidth, 2, \ "number of receiver types to record in call/cast profile") \ \ develop(intx, BciProfileWidth, 2, \ @@ -3012,10 +3012,10 @@ class CommandLineFlags { product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \ "Min change in heap space due to GC (in bytes)") \ \ - product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K), \ + product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K), \ "Min expansion of permanent heap (in bytes)") \ \ - product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \ + product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \ "Max expansion of permanent heap without full GC (in bytes)") \ \ product(intx, QueuedAllocationWarningCount, 0, \ @@ -3028,10 +3028,10 @@ class CommandLineFlags { diagnostic(intx, VerifyGCLevel, 0, \ "Generation level at which to start +VerifyBefore/AfterGC") \ \ - product(intx, MaxTenuringThreshold, 15, \ + product(uintx, MaxTenuringThreshold, 15, \ "Maximum value for tenuring threshold") \ \ - product(intx, InitialTenuringThreshold, 7, \ + product(uintx, InitialTenuringThreshold, 7, \ "Initial value for tenuring threshold") \ \ product(intx, TargetSurvivorRatio, 50, \ diff --git a/src/share/vm/runtime/vmStructs.cpp b/src/share/vm/runtime/vmStructs.cpp index 1f0f2becce5103b9e2a3c3292f6dfe6e6528d264..bc0435a57f214e5099fcb9496e03f71a1723db29 100644 --- a/src/share/vm/runtime/vmStructs.cpp +++ b/src/share/vm/runtime/vmStructs.cpp @@ -508,7 +508,7 @@ typedef TwoOopHashtable SymbolTwoOopHashtable; nonstatic_field(ContiguousSpace, _saved_mark_word, HeapWord*) \ \ nonstatic_field(DefNewGeneration, _next_gen, Generation*) \ - nonstatic_field(DefNewGeneration, _tenuring_threshold, int) \ + nonstatic_field(DefNewGeneration, _tenuring_threshold, uint) \ nonstatic_field(DefNewGeneration, _age_table, ageTable) \ nonstatic_field(DefNewGeneration, _eden_space, EdenSpace*) \ nonstatic_field(DefNewGeneration, _from_space, ContiguousSpace*) \