# HG changeset patch # User david # Date 1452672164 -3600 # Wed Jan 13 09:02:44 2016 +0100 # Node ID 9efd5df18f195273ccc20f12934ade38fa2b1816 # Parent 42f9334231a44ba8c1c7d0ad702436f1da43cac7 imported patch naming diff --git a/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp b/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp --- a/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp +++ b/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp @@ -1075,7 +1075,7 @@ } -// Check GC_locker::needs_gc and enter the runtime if it's true. This +// Check GCLocker::needs_gc and enter the runtime if it's true. This // keeps a new JNI critical region from starting until a GC has been // forced. Save down any oops in registers and describe them in an // OopMap. @@ -1257,14 +1257,14 @@ // GetPrimtiveArrayCritical and disallow the use of any other JNI // functions. The wrapper is expected to unpack the arguments before // passing them to the callee and perform checks before and after the -// native call to ensure that they GC_locker +// native call to ensure that they GCLocker // lock_critical/unlock_critical semantics are followed. Some other // parts of JNI setup are skipped like the tear down of the JNI handle // block and the check for pending exceptions it's impossible for them // to be thrown. // // They are roughly structured like this: -// if (GC_locker::needs_gc()) +// if (GCLocker::needs_gc()) // SharedRuntime::block_for_jni_critical(); // tranistion to thread_in_native // unpack arrray arguments and call native entry point diff --git a/src/cpu/ppc/vm/sharedRuntime_ppc.cpp b/src/cpu/ppc/vm/sharedRuntime_ppc.cpp --- a/src/cpu/ppc/vm/sharedRuntime_ppc.cpp +++ b/src/cpu/ppc/vm/sharedRuntime_ppc.cpp @@ -1474,7 +1474,7 @@ } } -// Check GC_locker::needs_gc and enter the runtime if it's true. This +// Check GCLocker::needs_gc and enter the runtime if it's true. This // keeps a new JNI critical region from starting until a GC has been // forced. Save down any oops in registers and describe them in an // OopMap. @@ -1486,9 +1486,9 @@ VMRegPair* in_regs, BasicType* in_sig_bt, Register tmp_reg ) { - __ block_comment("check GC_locker::needs_gc"); + __ block_comment("check GCLocker::needs_gc"); Label cont; - __ lbz(tmp_reg, (RegisterOrConstant)(intptr_t)GC_locker::needs_gc_address()); + __ lbz(tmp_reg, (RegisterOrConstant)(intptr_t)GCLocker::needs_gc_address()); __ cmplwi(CCR0, tmp_reg, 0); __ beq(CCR0, cont); @@ -1687,14 +1687,14 @@ // GetPrimtiveArrayCritical and disallow the use of any other JNI // functions. The wrapper is expected to unpack the arguments before // passing them to the callee and perform checks before and after the -// native call to ensure that they GC_locker +// native call to ensure that they GCLocker // lock_critical/unlock_critical semantics are followed. Some other // parts of JNI setup are skipped like the tear down of the JNI handle // block and the check for pending exceptions it's impossible for them // to be thrown. // // They are roughly structured like this: -// if (GC_locker::needs_gc()) +// if (GCLocker::needs_gc()) // SharedRuntime::block_for_jni_critical(); // tranistion to thread_in_native // unpack arrray arguments and call native entry point diff --git a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp --- a/src/cpu/sparc/vm/sharedRuntime_sparc.cpp +++ b/src/cpu/sparc/vm/sharedRuntime_sparc.cpp @@ -1748,7 +1748,7 @@ } -// Check GC_locker::needs_gc and enter the runtime if it's true. This +// Check GCLocker::needs_gc and enter the runtime if it's true. This // keeps a new JNI critical region from starting until a GC has been // forced. Save down any oops in registers and describe them in an // OopMap. @@ -1759,9 +1759,9 @@ OopMapSet* oop_maps, VMRegPair* in_regs, BasicType* in_sig_bt) { - __ block_comment("check GC_locker::needs_gc"); + __ block_comment("check GCLocker::needs_gc"); Label cont; - AddressLiteral sync_state(GC_locker::needs_gc_address()); + AddressLiteral sync_state(GCLocker::needs_gc_address()); __ load_bool_contents(sync_state, G3_scratch); __ cmp_zero_and_br(Assembler::equal, G3_scratch, cont); __ delayed()->nop(); @@ -1936,14 +1936,14 @@ // GetPrimtiveArrayCritical and disallow the use of any other JNI // functions. The wrapper is expected to unpack the arguments before // passing them to the callee and perform checks before and after the -// native call to ensure that they GC_locker +// native call to ensure that they GCLocker // lock_critical/unlock_critical semantics are followed. Some other // parts of JNI setup are skipped like the tear down of the JNI handle // block and the check for pending exceptions it's impossible for them // to be thrown. // // They are roughly structured like this: -// if (GC_locker::needs_gc()) +// if (GCLocker::needs_gc()) // SharedRuntime::block_for_jni_critical(); // tranistion to thread_in_native // unpack arrray arguments and call native entry point diff --git a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp --- a/src/cpu/x86/vm/sharedRuntime_x86_32.cpp +++ b/src/cpu/x86/vm/sharedRuntime_x86_32.cpp @@ -1271,7 +1271,7 @@ } } -// Check GC_locker::needs_gc and enter the runtime if it's true. This +// Check GCLocker::needs_gc and enter the runtime if it's true. This // keeps a new JNI critical region from starting until a GC has been // forced. Save down any oops in registers and describe them in an // OopMap. @@ -1284,9 +1284,9 @@ OopMapSet* oop_maps, VMRegPair* in_regs, BasicType* in_sig_bt) { - __ block_comment("check GC_locker::needs_gc"); + __ block_comment("check GCLocker::needs_gc"); Label cont; - __ cmp8(ExternalAddress((address)GC_locker::needs_gc_address()), false); + __ cmp8(ExternalAddress((address)GCLocker::needs_gc_address()), false); __ jcc(Assembler::equal, cont); // Save down any incoming oops and call into the runtime to halt for a GC @@ -1469,14 +1469,14 @@ // GetPrimtiveArrayCritical and disallow the use of any other JNI // functions. The wrapper is expected to unpack the arguments before // passing them to the callee and perform checks before and after the -// native call to ensure that they GC_locker +// native call to ensure that they GCLocker // lock_critical/unlock_critical semantics are followed. Some other // parts of JNI setup are skipped like the tear down of the JNI handle // block and the check for pending exceptions it's impossible for them // to be thrown. // // They are roughly structured like this: -// if (GC_locker::needs_gc()) +// if (GCLocker::needs_gc()) // SharedRuntime::block_for_jni_critical(); // tranistion to thread_in_native // unpack arrray arguments and call native entry point diff --git a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp --- a/src/cpu/x86/vm/sharedRuntime_x86_64.cpp +++ b/src/cpu/x86/vm/sharedRuntime_x86_64.cpp @@ -1416,7 +1416,7 @@ } -// Check GC_locker::needs_gc and enter the runtime if it's true. This +// Check GCLocker::needs_gc and enter the runtime if it's true. This // keeps a new JNI critical region from starting until a GC has been // forced. Save down any oops in registers and describe them in an // OopMap. @@ -1428,9 +1428,9 @@ OopMapSet* oop_maps, VMRegPair* in_regs, BasicType* in_sig_bt) { - __ block_comment("check GC_locker::needs_gc"); + __ block_comment("check GCLocker::needs_gc"); Label cont; - __ cmp8(ExternalAddress((address)GC_locker::needs_gc_address()), false); + __ cmp8(ExternalAddress((address)GCLocker::needs_gc_address()), false); __ jcc(Assembler::equal, cont); // Save down any incoming oops and call into the runtime to halt for a GC @@ -1795,14 +1795,14 @@ // GetPrimtiveArrayCritical and disallow the use of any other JNI // functions. The wrapper is expected to unpack the arguments before // passing them to the callee and perform checks before and after the -// native call to ensure that they GC_locker +// native call to ensure that they GCLocker // lock_critical/unlock_critical semantics are followed. Some other // parts of JNI setup are skipped like the tear down of the JNI handle // block and the check for pending exceptions it's impossible for them // to be thrown. // // They are roughly structured like this: -// if (GC_locker::needs_gc()) +// if (GCLocker::needs_gc()) // SharedRuntime::block_for_jni_critical(); // tranistion to thread_in_native // unpack arrray arguments and call native entry point diff --git a/src/share/vm/asm/codeBuffer.cpp b/src/share/vm/asm/codeBuffer.cpp --- a/src/share/vm/asm/codeBuffer.cpp +++ b/src/share/vm/asm/codeBuffer.cpp @@ -510,7 +510,7 @@ } void CodeBuffer::finalize_oop_references(const methodHandle& mh) { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; GrowableArray oops; diff --git a/src/share/vm/ci/ciEnv.cpp b/src/share/vm/ci/ciEnv.cpp --- a/src/share/vm/ci/ciEnv.cpp +++ b/src/share/vm/ci/ciEnv.cpp @@ -971,7 +971,7 @@ // and invalidating our dependencies until we install this method. // No safepoints are allowed. Otherwise, class redefinition can occur in between. MutexLocker ml(Compile_lock); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // Change in Jvmti state may invalidate compilation. if (!failing() && jvmti_state_changed()) { diff --git a/src/share/vm/classfile/classFileParser.cpp b/src/share/vm/classfile/classFileParser.cpp --- a/src/share/vm/classfile/classFileParser.cpp +++ b/src/share/vm/classfile/classFileParser.cpp @@ -863,7 +863,7 @@ initialize_hashtable(interface_names); bool dup = false; { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) for (index = 0; index < itfs_len; index++) { const Klass* const k = _local_interfaces->at(index); const Symbol* const name = InstanceKlass::cast(k)->name(); @@ -1620,7 +1620,7 @@ initialize_hashtable(names_and_sigs); bool dup = false; { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) for (AllFieldStream fs(_fields, cp); !fs.done(); fs.next()) { const Symbol* const name = fs.name(); const Symbol* const sig = fs.signature(); @@ -2885,7 +2885,7 @@ initialize_hashtable(names_and_sigs); bool dup = false; { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) for (int i = 0; i < length; i++) { const Method* const m = _methods->at(i); // If no duplicates, add name/signature in hashtable names_and_sigs. diff --git a/src/share/vm/classfile/classLoaderData.cpp b/src/share/vm/classfile/classLoaderData.cpp --- a/src/share/vm/classfile/classLoaderData.cpp +++ b/src/share/vm/classfile/classLoaderData.cpp @@ -574,9 +574,9 @@ // actual ClassLoaderData object. ClassLoaderData::Dependencies dependencies(CHECK_NULL); - No_Safepoint_Verifier no_safepoints; // we mustn't GC until we've installed the - // ClassLoaderData in the graph since the CLD - // contains unhandled oops + NoSafepointVerifier no_safepoints; // we mustn't GC until we've installed the + // ClassLoaderData in the graph since the CLD + // contains unhandled oops ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous, dependencies); diff --git a/src/share/vm/classfile/javaClasses.cpp b/src/share/vm/classfile/javaClasses.cpp --- a/src/share/vm/classfile/javaClasses.cpp +++ b/src/share/vm/classfile/javaClasses.cpp @@ -1536,7 +1536,7 @@ objArrayOop _mirrors; typeArrayOop _cprefs; // needed to insulate method name against redefinition int _index; - No_Safepoint_Verifier _nsv; + NoSafepointVerifier _nsv; public: @@ -1595,7 +1595,7 @@ void expand(TRAPS) { objArrayHandle old_head(THREAD, _head); - Pause_No_Safepoint_Verifier pnsv(&_nsv); + PauseNoSafepointVerifier pnsv(&_nsv); objArrayOop head = oopFactory::new_objectArray(trace_size, CHECK); objArrayHandle new_head(THREAD, head); diff --git a/src/share/vm/classfile/stringTable.cpp b/src/share/vm/classfile/stringTable.cpp --- a/src/share/vm/classfile/stringTable.cpp +++ b/src/share/vm/classfile/stringTable.cpp @@ -136,7 +136,7 @@ assert(java_lang_String::equals(string(), name, len), "string must be properly initialized"); // Cannot hit a safepoint in this function because the "this" pointer can move. - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // Check if the symbol table has been rehashed, if so, need to recalculate // the hash value and index before second lookup. diff --git a/src/share/vm/classfile/symbolTable.cpp b/src/share/vm/classfile/symbolTable.cpp --- a/src/share/vm/classfile/symbolTable.cpp +++ b/src/share/vm/classfile/symbolTable.cpp @@ -264,7 +264,7 @@ unsigned int hashValue; char* name; { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) name = (char*)sym->base() + begin; len = end - begin; @@ -288,7 +288,7 @@ buffer[i] = name[i]; } // Make sure there is no safepoint in the code above since name can't move. - // We can't include the code in No_Safepoint_Verifier because of the + // We can't include the code in NoSafepointVerifier because of the // ResourceMark. // Grab SymbolTable_lock first. @@ -405,7 +405,7 @@ } // Cannot hit a safepoint in this function because the "this" pointer can move. - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // Check if the symbol table has been rehashed, if so, need to recalculate // the hash value and index. @@ -454,7 +454,7 @@ } // Cannot hit a safepoint in this function because the "this" pointer can move. - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; for (int i=0; iadd_protection_domain(d_index, d_hash, klass, loader_data, protection_domain, THREAD); } @@ -908,11 +908,11 @@ MutexLocker mu(SystemDictionary_lock, THREAD); // Note that we have an entry, and entries can be deleted only during GC, // so we cannot allow GC to occur while we're holding this entry. - // We're using a No_Safepoint_Verifier to catch any place where we + // We're using a NoSafepointVerifier to catch any place where we // might potentially do a GC at all. // Dictionary::do_unloading() asserts that classes in SD are only // unloaded at a safepoint. Anonymous classes are not in SD. - No_Safepoint_Verifier nosafepoint; + NoSafepointVerifier nosafepoint; if (dictionary()->is_valid_protection_domain(d_index, d_hash, name, loader_data, protection_domain)) { @@ -961,11 +961,11 @@ { // Note that we have an entry, and entries can be deleted only during GC, // so we cannot allow GC to occur while we're holding this entry. - // We're using a No_Safepoint_Verifier to catch any place where we + // We're using a NoSafepointVerifier to catch any place where we // might potentially do a GC at all. // Dictionary::do_unloading() asserts that classes in SD are only // unloaded at a safepoint. Anonymous classes are not in SD. - No_Safepoint_Verifier nosafepoint; + NoSafepointVerifier nosafepoint; return dictionary()->find(d_index, d_hash, class_name, loader_data, protection_domain, THREAD); } @@ -2210,7 +2210,7 @@ MutexLocker mu_s(SystemDictionary_lock, THREAD); // Better never do a GC while we're holding these oops - No_Safepoint_Verifier nosafepoint; + NoSafepointVerifier nosafepoint; Klass* klass1 = find_class(d_index1, d_hash1, constraint_name, loader_data1); Klass* klass2 = find_class(d_index2, d_hash2, constraint_name, loader_data2); diff --git a/src/share/vm/classfile/verifier.cpp b/src/share/vm/classfile/verifier.cpp --- a/src/share/vm/classfile/verifier.cpp +++ b/src/share/vm/classfile/verifier.cpp @@ -2004,7 +2004,7 @@ Symbol* field_name, Symbol* field_sig, bool is_method) { - No_Safepoint_Verifier nosafepoint; + NoSafepointVerifier nosafepoint; // If target class isn't a super class of this class, we don't worry about this case if (!this_class->is_subclass_of(target_class)) { diff --git a/src/share/vm/code/codeCache.cpp b/src/share/vm/code/codeCache.cpp --- a/src/share/vm/code/codeCache.cpp +++ b/src/share/vm/code/codeCache.cpp @@ -1034,7 +1034,7 @@ // implementor. // nmethod::check_all_dependencies works only correctly, if no safepoint // can happen - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; for (DepChange::ContextStream str(changes, nsv); str.next(); ) { Klass* d = str.klass(); number_of_marked_CodeBlobs += InstanceKlass::cast(d)->mark_dependent_nmethods(changes); diff --git a/src/share/vm/code/dependencies.hpp b/src/share/vm/code/dependencies.hpp --- a/src/share/vm/code/dependencies.hpp +++ b/src/share/vm/code/dependencies.hpp @@ -59,7 +59,7 @@ class DepChange; class KlassDepChange; class CallSiteDepChange; -class No_Safepoint_Verifier; +class NoSafepointVerifier; class Dependencies: public ResourceObj { public: @@ -713,7 +713,7 @@ : _changes(changes) { start(); } - ContextStream(DepChange& changes, No_Safepoint_Verifier& nsv) + ContextStream(DepChange& changes, NoSafepointVerifier& nsv) : _changes(changes) // the nsv argument makes it safe to hold oops like _klass { start(); } diff --git a/src/share/vm/code/nmethod.cpp b/src/share/vm/code/nmethod.cpp --- a/src/share/vm/code/nmethod.cpp +++ b/src/share/vm/code/nmethod.cpp @@ -692,7 +692,7 @@ _native_basic_lock_sp_offset(basic_lock_sp_offset) { { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) assert_locked_or_safepoint(CodeCache_lock); init_defaults(); @@ -796,7 +796,7 @@ { assert(debug_info->oop_recorder() == code_buffer->oop_recorder(), "shared OR"); { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) assert_locked_or_safepoint(CodeCache_lock); init_defaults(); @@ -1404,7 +1404,7 @@ // Make sure neither the nmethod nor the method is flushed in case of a safepoint in code below. nmethodLocker nml(this); methodHandle the_method(method()); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // during patching, depending on the nmethod state we must notify the GC that // code has been unloaded, unregistering it. We cannot do this right while diff --git a/src/share/vm/compiler/compileBroker.cpp b/src/share/vm/compiler/compileBroker.cpp --- a/src/share/vm/compiler/compileBroker.cpp +++ b/src/share/vm/compiler/compileBroker.cpp @@ -373,7 +373,7 @@ CompileTask* task; { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; task = CompilationPolicy::policy()->select_task(this); } diff --git a/src/share/vm/gc/cms/cmsOopClosures.hpp b/src/share/vm/gc/cms/cmsOopClosures.hpp --- a/src/share/vm/gc/cms/cmsOopClosures.hpp +++ b/src/share/vm/gc/cms/cmsOopClosures.hpp @@ -37,7 +37,7 @@ class CMSMarkStack; class CMSCollector; class MarkFromRootsClosure; -class Par_MarkFromRootsClosure; +class ParMarkFromRootsClosure; // Decode the oop and call do_oop on it. #define DO_OOP_WORK_DEFN \ @@ -82,14 +82,14 @@ virtual void do_oop(narrowOop* p); }; -class Par_MarkRefsIntoClosure: public MetadataAwareOopsInGenClosure { +class ParMarkRefsIntoClosure: public MetadataAwareOopsInGenClosure { private: const MemRegion _span; CMSBitMap* _bitMap; protected: DO_OOP_WORK_DEFN public: - Par_MarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap); + ParMarkRefsIntoClosure(MemRegion span, CMSBitMap* bitMap); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); }; @@ -141,7 +141,7 @@ // synchronization (for instance, via CAS). The marking stack // used in the non-parallel case above is here replaced with // an OopTaskQueue structure to allow efficient work stealing. -class Par_PushAndMarkClosure: public MetadataAwareOopClosure { +class ParPushAndMarkClosure: public MetadataAwareOopClosure { private: CMSCollector* _collector; MemRegion _span; @@ -150,15 +150,15 @@ protected: DO_OOP_WORK_DEFN public: - Par_PushAndMarkClosure(CMSCollector* collector, - MemRegion span, - ReferenceProcessor* rp, - CMSBitMap* bit_map, - OopTaskQueue* work_queue); + ParPushAndMarkClosure(CMSCollector* collector, + MemRegion span, + ReferenceProcessor* rp, + CMSBitMap* bit_map, + OopTaskQueue* work_queue); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); - inline void do_oop_nv(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); } - inline void do_oop_nv(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } + inline void do_oop_nv(oop* p) { ParPushAndMarkClosure::do_oop_work(p); } + inline void do_oop_nv(narrowOop* p) { ParPushAndMarkClosure::do_oop_work(p); } }; // The non-parallel version (the parallel version appears further below). @@ -203,25 +203,25 @@ // stack and the bitMap are shared, so access needs to be suitably // synchronized. An OopTaskQueue structure, supporting efficient // work stealing, replaces a CMSMarkStack for storing grey objects. -class Par_MarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure { +class ParMarkRefsIntoAndScanClosure: public MetadataAwareOopsInGenClosure { private: - MemRegion _span; - CMSBitMap* _bit_map; - OopTaskQueue* _work_queue; - const uint _low_water_mark; - Par_PushAndMarkClosure _par_pushAndMarkClosure; + MemRegion _span; + CMSBitMap* _bit_map; + OopTaskQueue* _work_queue; + const uint _low_water_mark; + ParPushAndMarkClosure _parPushAndMarkClosure; protected: DO_OOP_WORK_DEFN public: - Par_MarkRefsIntoAndScanClosure(CMSCollector* collector, + ParMarkRefsIntoAndScanClosure(CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, CMSBitMap* bit_map, OopTaskQueue* work_queue); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); - inline void do_oop_nv(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } - inline void do_oop_nv(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } + inline void do_oop_nv(oop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } + inline void do_oop_nv(narrowOop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } void trim_queue(uint size); }; @@ -261,8 +261,8 @@ // A parallel (MT) version of the above. // This closure is used during the concurrent marking phase // following the first checkpoint. Its use is buried in -// the closure Par_MarkFromRootsClosure. -class Par_PushOrMarkClosure: public MetadataAwareOopClosure { +// the closure ParMarkFromRootsClosure. +class ParPushOrMarkClosure: public MetadataAwareOopClosure { private: CMSCollector* _collector; MemRegion _whole_span; @@ -272,23 +272,23 @@ CMSMarkStack* _overflow_stack; HeapWord* const _finger; HeapWord** const _global_finger_addr; - Par_MarkFromRootsClosure* const + ParMarkFromRootsClosure* const _parent; protected: DO_OOP_WORK_DEFN public: - Par_PushOrMarkClosure(CMSCollector* cms_collector, - MemRegion span, - CMSBitMap* bit_map, - OopTaskQueue* work_queue, - CMSMarkStack* mark_stack, - HeapWord* finger, - HeapWord** global_finger_addr, - Par_MarkFromRootsClosure* parent); + ParPushOrMarkClosure(CMSCollector* cms_collector, + MemRegion span, + CMSBitMap* bit_map, + OopTaskQueue* work_queue, + CMSMarkStack* mark_stack, + HeapWord* finger, + HeapWord** global_finger_addr, + ParMarkFromRootsClosure* parent); virtual void do_oop(oop* p); virtual void do_oop(narrowOop* p); - inline void do_oop_nv(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } - inline void do_oop_nv(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } + inline void do_oop_nv(oop* p) { ParPushOrMarkClosure::do_oop_work(p); } + inline void do_oop_nv(narrowOop* p) { ParPushOrMarkClosure::do_oop_work(p); } // Deal with a stack overflow condition void handle_stack_overflow(HeapWord* lost); diff --git a/src/share/vm/gc/cms/cmsOopClosures.inline.hpp b/src/share/vm/gc/cms/cmsOopClosures.inline.hpp --- a/src/share/vm/gc/cms/cmsOopClosures.inline.hpp +++ b/src/share/vm/gc/cms/cmsOopClosures.inline.hpp @@ -31,7 +31,7 @@ #include "oops/oop.inline.hpp" // Trim our work_queue so its length is below max at return -inline void Par_MarkRefsIntoAndScanClosure::trim_queue(uint max) { +inline void ParMarkRefsIntoAndScanClosure::trim_queue(uint max) { while (_work_queue->size() > max) { oop newOop; if (_work_queue->pop_local(newOop)) { @@ -40,7 +40,7 @@ "only grey objects on this stack"); // iterate over the oops in this oop, marking and pushing // the ones in CMS heap (i.e. in _span). - newOop->oop_iterate(&_par_pushAndMarkClosure); + newOop->oop_iterate(&_parPushAndMarkClosure); } } } diff --git a/src/share/vm/gc/cms/compactibleFreeListSpace.cpp b/src/share/vm/gc/cms/compactibleFreeListSpace.cpp --- a/src/share/vm/gc/cms/compactibleFreeListSpace.cpp +++ b/src/share/vm/gc/cms/compactibleFreeListSpace.cpp @@ -576,7 +576,7 @@ } } -class FreeListSpace_DCTOC : public Filtering_DCTOC { +class FreeListSpaceDCTOC : public FilteringDCTOC { CompactibleFreeListSpace* _cfls; CMSCollector* _collector; bool _parallel; @@ -596,21 +596,21 @@ walk_mem_region_with_cl_DECL(FilteringClosure); public: - FreeListSpace_DCTOC(CompactibleFreeListSpace* sp, - CMSCollector* collector, - ExtendedOopClosure* cl, - CardTableModRefBS::PrecisionStyle precision, - HeapWord* boundary, - bool parallel) : - Filtering_DCTOC(sp, cl, precision, boundary), + FreeListSpaceDCTOC(CompactibleFreeListSpace* sp, + CMSCollector* collector, + ExtendedOopClosure* cl, + CardTableModRefBS::PrecisionStyle precision, + HeapWord* boundary, + bool parallel) : + FilteringDCTOC(sp, cl, precision, boundary), _cfls(sp), _collector(collector), _parallel(parallel) {} }; // We de-virtualize the block-related calls below, since we know that our // space is a CompactibleFreeListSpace. -#define FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \ -void FreeListSpace_DCTOC::walk_mem_region_with_cl(MemRegion mr, \ +#define FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ClosureType) \ +void FreeListSpaceDCTOC::walk_mem_region_with_cl(MemRegion mr, \ HeapWord* bottom, \ HeapWord* top, \ ClosureType* cl) { \ @@ -620,10 +620,10 @@ walk_mem_region_with_cl_nopar(mr, bottom, top, cl); \ } \ } \ -void FreeListSpace_DCTOC::walk_mem_region_with_cl_par(MemRegion mr, \ - HeapWord* bottom, \ - HeapWord* top, \ - ClosureType* cl) { \ +void FreeListSpaceDCTOC::walk_mem_region_with_cl_par(MemRegion mr, \ + HeapWord* bottom, \ + HeapWord* top, \ + ClosureType* cl) { \ /* Skip parts that are before "mr", in case "block_start" sent us \ back too far. */ \ HeapWord* mr_start = mr.start(); \ @@ -647,10 +647,10 @@ } \ } \ } \ -void FreeListSpace_DCTOC::walk_mem_region_with_cl_nopar(MemRegion mr, \ - HeapWord* bottom, \ - HeapWord* top, \ - ClosureType* cl) { \ +void FreeListSpaceDCTOC::walk_mem_region_with_cl_nopar(MemRegion mr, \ + HeapWord* bottom, \ + HeapWord* top, \ + ClosureType* cl) { \ /* Skip parts that are before "mr", in case "block_start" sent us \ back too far. */ \ HeapWord* mr_start = mr.start(); \ @@ -678,15 +678,15 @@ // (There are only two of these, rather than N, because the split is due // only to the introduction of the FilteringClosure, a local part of the // impl of this abstraction.) -FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure) -FreeListSpace_DCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure) +FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(ExtendedOopClosure) +FreeListSpaceDCTOC__walk_mem_region_with_cl_DEFN(FilteringClosure) DirtyCardToOopClosure* CompactibleFreeListSpace::new_dcto_cl(ExtendedOopClosure* cl, CardTableModRefBS::PrecisionStyle precision, HeapWord* boundary, bool parallel) { - return new FreeListSpace_DCTOC(this, _collector, cl, precision, boundary, parallel); + return new FreeListSpaceDCTOC(this, _collector, cl, precision, boundary, parallel); } @@ -2413,7 +2413,7 @@ } /////////////////////////////////////////////////////////////////////////// -// CFLS_LAB +// CompactibleFreeListSpaceLAB /////////////////////////////////////////////////////////////////////////// #define VECTOR_257(x) \ @@ -2432,12 +2432,12 @@ // generic OldPLABSize, whose static default is different; if overridden at the // command-line, this will get reinitialized via a call to // modify_initialization() below. -AdaptiveWeightedAverage CFLS_LAB::_blocks_to_claim[] = - VECTOR_257(AdaptiveWeightedAverage(OldPLABWeight, (float)CFLS_LAB::_default_dynamic_old_plab_size)); -size_t CFLS_LAB::_global_num_blocks[] = VECTOR_257(0); -uint CFLS_LAB::_global_num_workers[] = VECTOR_257(0); +AdaptiveWeightedAverage CompactibleFreeListSpaceLAB::_blocks_to_claim[] = + VECTOR_257(AdaptiveWeightedAverage(OldPLABWeight, (float)CompactibleFreeListSpaceLAB::_default_dynamic_old_plab_size)); +size_t CompactibleFreeListSpaceLAB::_global_num_blocks[] = VECTOR_257(0); +uint CompactibleFreeListSpaceLAB::_global_num_workers[] = VECTOR_257(0); -CFLS_LAB::CFLS_LAB(CompactibleFreeListSpace* cfls) : +CompactibleFreeListSpaceLAB::CompactibleFreeListSpaceLAB(CompactibleFreeListSpace* cfls) : _cfls(cfls) { assert(CompactibleFreeListSpace::IndexSetSize == 257, "Modify VECTOR_257() macro above"); @@ -2451,7 +2451,7 @@ static bool _CFLS_LAB_modified = false; -void CFLS_LAB::modify_initialization(size_t n, unsigned wt) { +void CompactibleFreeListSpaceLAB::modify_initialization(size_t n, unsigned wt) { assert(!_CFLS_LAB_modified, "Call only once"); _CFLS_LAB_modified = true; for (size_t i = CompactibleFreeListSpace::IndexSetStart; @@ -2461,7 +2461,7 @@ } } -HeapWord* CFLS_LAB::alloc(size_t word_sz) { +HeapWord* CompactibleFreeListSpaceLAB::alloc(size_t word_sz) { FreeChunk* res; assert(word_sz == _cfls->adjustObjectSize(word_sz), "Error"); if (word_sz >= CompactibleFreeListSpace::IndexSetSize) { @@ -2491,7 +2491,7 @@ // Get a chunk of blocks of the right size and update related // book-keeping stats -void CFLS_LAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList* fl) { +void CompactibleFreeListSpaceLAB::get_from_global_pool(size_t word_sz, AdaptiveFreeList* fl) { // Get the #blocks we want to claim size_t n_blks = (size_t)_blocks_to_claim[word_sz].average(); assert(n_blks > 0, "Error"); @@ -2525,7 +2525,7 @@ _num_blocks[word_sz] += fl->count(); } -void CFLS_LAB::compute_desired_plab_size() { +void CompactibleFreeListSpaceLAB::compute_desired_plab_size() { for (size_t i = CompactibleFreeListSpace::IndexSetStart; i < CompactibleFreeListSpace::IndexSetSize; i += CompactibleFreeListSpace::IndexSetStride) { @@ -2551,7 +2551,7 @@ // access, one would need to take the FL locks and, // depending on how it is used, stagger access from // parallel threads to reduce contention. -void CFLS_LAB::retire(int tid) { +void CompactibleFreeListSpaceLAB::retire(int tid) { // We run this single threaded with the world stopped; // so no need for locks and such. NOT_PRODUCT(Thread* t = Thread::current();) diff --git a/src/share/vm/gc/cms/compactibleFreeListSpace.hpp b/src/share/vm/gc/cms/compactibleFreeListSpace.hpp --- a/src/share/vm/gc/cms/compactibleFreeListSpace.hpp +++ b/src/share/vm/gc/cms/compactibleFreeListSpace.hpp @@ -75,7 +75,7 @@ friend class ConcurrentMarkSweepGeneration; friend class CMSCollector; // Local alloc buffer for promotion into this space. - friend class CFLS_LAB; + friend class CompactibleFreeListSpaceLAB; // Allow scan_and_* functions to call (private) overrides of the auxiliary functions on this class template friend void CompactibleSpace::scan_and_adjust_pointers(SpaceType* space); @@ -662,7 +662,7 @@ // A parallel-GC-thread-local allocation buffer for allocation into a // CompactibleFreeListSpace. -class CFLS_LAB : public CHeapObj { +class CompactibleFreeListSpaceLAB : public CHeapObj { // The space that this buffer allocates into. CompactibleFreeListSpace* _cfls; @@ -686,7 +686,7 @@ static const int _default_dynamic_old_plab_size = 16; static const int _default_static_old_plab_size = 50; - CFLS_LAB(CompactibleFreeListSpace* cfls); + CompactibleFreeListSpaceLAB(CompactibleFreeListSpace* cfls); // Allocate and return a block of the given size, or else return NULL. HeapWord* alloc(size_t word_sz); diff --git a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp --- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp @@ -183,7 +183,7 @@ // young-gen collection. class CMSParGCThreadState: public CHeapObj { public: - CFLS_LAB lab; + CompactibleFreeListSpaceLAB lab; PromotionInfo promo; // Constructor. @@ -1110,7 +1110,7 @@ bool CMSCollector::shouldConcurrentCollect() { if (_full_gc_requested) { - log_trace(gc)("CMSCollector: collect because of explicit gc request (or gc_locker)"); + log_trace(gc)("CMSCollector: collect because of explicit gc request (or GCLocker)"); return true; } @@ -1269,12 +1269,12 @@ { // The following "if" branch is present for defensive reasons. // In the current uses of this interface, it can be replaced with: - // assert(!GC_locker.is_active(), "Can't be called otherwise"); + // assert(!GCLocker.is_active(), "Can't be called otherwise"); // But I am not placing that assert here to allow future // generality in invoking this interface. - if (GC_locker::is_active()) { - // A consistency test for GC_locker - assert(GC_locker::needs_gc(), "Should have been set already"); + if (GCLocker::is_active()) { + // A consistency test for GCLocker + assert(GCLocker::needs_gc(), "Should have been set already"); // Skip this foreground collection, instead // expanding the heap if necessary. // Need the free list locks for the call to free() in compute_new_size() @@ -3272,10 +3272,10 @@ // Do the marking work within a non-empty span -- // the last argument to the constructor indicates whether the // iteration should be incremental with periodic yields. - Par_MarkFromRootsClosure cl(this, _collector, my_span, - &_collector->_markBitMap, - work_queue(i), - &_collector->_markStack); + ParMarkFromRootsClosure cl(this, _collector, my_span, + &_collector->_markBitMap, + work_queue(i), + &_collector->_markStack); _collector->_markBitMap.iterate(&cl, my_span.start(), my_span.end()); } // else nothing to do for this task } // else nothing to do for this task @@ -3291,7 +3291,7 @@ pst->all_tasks_completed(); } -class Par_ConcMarkingClosure: public MetadataAwareOopClosure { +class ParConcMarkingClosure: public MetadataAwareOopClosure { private: CMSCollector* _collector; CMSConcMarkingTask* _task; @@ -3302,8 +3302,8 @@ protected: DO_OOP_WORK_DEFN public: - Par_ConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue, - CMSBitMap* bit_map, CMSMarkStack* overflow_stack): + ParConcMarkingClosure(CMSCollector* collector, CMSConcMarkingTask* task, OopTaskQueue* work_queue, + CMSBitMap* bit_map, CMSMarkStack* overflow_stack): MetadataAwareOopClosure(collector->ref_processor()), _collector(collector), _task(task), @@ -3330,7 +3330,7 @@ // already have been initialized (else they would not have // been published), so we do not need to check for // uninitialized objects before pushing here. -void Par_ConcMarkingClosure::do_oop(oop obj) { +void ParConcMarkingClosure::do_oop(oop obj) { assert(obj->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj)); HeapWord* addr = (HeapWord*)obj; // Check if oop points into the CMS generation @@ -3366,10 +3366,10 @@ } } -void Par_ConcMarkingClosure::do_oop(oop* p) { Par_ConcMarkingClosure::do_oop_work(p); } -void Par_ConcMarkingClosure::do_oop(narrowOop* p) { Par_ConcMarkingClosure::do_oop_work(p); } - -void Par_ConcMarkingClosure::trim_queue(size_t max) { +void ParConcMarkingClosure::do_oop(oop* p) { ParConcMarkingClosure::do_oop_work(p); } +void ParConcMarkingClosure::do_oop(narrowOop* p) { ParConcMarkingClosure::do_oop_work(p); } + +void ParConcMarkingClosure::trim_queue(size_t max) { while (_work_queue->size() > max) { oop new_oop; if (_work_queue->pop_local(new_oop)) { @@ -3385,7 +3385,7 @@ // Upon stack overflow, we discard (part of) the stack, // remembering the least address amongst those discarded // in CMSCollector's _restart_address. -void Par_ConcMarkingClosure::handle_stack_overflow(HeapWord* lost) { +void ParConcMarkingClosure::handle_stack_overflow(HeapWord* lost) { // We need to do this under a mutex to prevent other // workers from interfering with the work done below. MutexLockerEx ml(_overflow_stack->par_lock(), @@ -3404,7 +3404,7 @@ CMSBitMap* bm = &(_collector->_markBitMap); CMSMarkStack* ovflw = &(_collector->_markStack); int* seed = _collector->hash_seed(i); - Par_ConcMarkingClosure cl(_collector, this, work_q, bm, ovflw); + ParConcMarkingClosure cl(_collector, this, work_q, bm, ovflw); while (true) { cl.trim_queue(0); assert(work_q->size() == 0, "Should have been emptied above"); @@ -4246,7 +4246,7 @@ // ---------- scan from roots -------------- _timer.start(); GenCollectedHeap* gch = GenCollectedHeap::heap(); - Par_MarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap)); + ParMarkRefsIntoClosure par_mri_cl(_collector->_span, &(_collector->_markBitMap)); // ---------- young gen roots -------------- { @@ -4312,10 +4312,10 @@ private: // ... of dirty cards in old space void do_dirty_card_rescan_tasks(CompactibleFreeListSpace* sp, int i, - Par_MarkRefsIntoAndScanClosure* cl); + ParMarkRefsIntoAndScanClosure* cl); // ... work stealing for the above - void do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, int* seed); + void do_work_steal(int i, ParMarkRefsIntoAndScanClosure* cl, int* seed); }; class RemarkKlassClosure : public KlassClosure { @@ -4361,7 +4361,7 @@ } // work_queue(i) is passed to the closure -// Par_MarkRefsIntoAndScanClosure. The "i" parameter +// ParMarkRefsIntoAndScanClosure. The "i" parameter // also is passed to do_dirty_card_rescan_tasks() and to // do_work_steal() to select the i-th task_queue. @@ -4373,7 +4373,7 @@ // ---------- rescan from roots -------------- _timer.start(); GenCollectedHeap* gch = GenCollectedHeap::heap(); - Par_MarkRefsIntoAndScanClosure par_mrias_cl(_collector, + ParMarkRefsIntoAndScanClosure par_mrias_cl(_collector, _collector->_span, _collector->ref_processor(), &(_collector->_markBitMap), work_queue(worker_id)); @@ -4522,7 +4522,7 @@ void CMSParRemarkTask::do_dirty_card_rescan_tasks( CompactibleFreeListSpace* sp, int i, - Par_MarkRefsIntoAndScanClosure* cl) { + ParMarkRefsIntoAndScanClosure* cl) { // Until all tasks completed: // . claim an unclaimed task // . compute region boundaries corresponding to task claimed @@ -4614,7 +4614,7 @@ // . see if we can share work_queues with ParNew? XXX void -CMSParRemarkTask::do_work_steal(int i, Par_MarkRefsIntoAndScanClosure* cl, +CMSParRemarkTask::do_work_steal(int i, ParMarkRefsIntoAndScanClosure* cl, int* seed) { OopTaskQueue* work_q = work_queue(i); NOT_PRODUCT(int num_steals = 0;) @@ -5832,7 +5832,7 @@ void MarkRefsIntoClosure::do_oop(oop* p) { MarkRefsIntoClosure::do_oop_work(p); } void MarkRefsIntoClosure::do_oop(narrowOop* p) { MarkRefsIntoClosure::do_oop_work(p); } -Par_MarkRefsIntoClosure::Par_MarkRefsIntoClosure( +ParMarkRefsIntoClosure::ParMarkRefsIntoClosure( MemRegion span, CMSBitMap* bitMap): _span(span), _bitMap(bitMap) @@ -5841,7 +5841,7 @@ assert(_bitMap->covers(_span), "_bitMap/_span mismatch"); } -void Par_MarkRefsIntoClosure::do_oop(oop obj) { +void ParMarkRefsIntoClosure::do_oop(oop obj) { // if p points into _span, then mark corresponding bit in _markBitMap assert(obj->is_oop(), "expected an oop"); HeapWord* addr = (HeapWord*)obj; @@ -5851,8 +5851,8 @@ } } -void Par_MarkRefsIntoClosure::do_oop(oop* p) { Par_MarkRefsIntoClosure::do_oop_work(p); } -void Par_MarkRefsIntoClosure::do_oop(narrowOop* p) { Par_MarkRefsIntoClosure::do_oop_work(p); } +void ParMarkRefsIntoClosure::do_oop(oop* p) { ParMarkRefsIntoClosure::do_oop_work(p); } +void ParMarkRefsIntoClosure::do_oop(narrowOop* p) { ParMarkRefsIntoClosure::do_oop_work(p); } // A variant of the above, used for CMS marking verification. MarkRefsIntoVerifyClosure::MarkRefsIntoVerifyClosure( @@ -5989,10 +5989,10 @@ } /////////////////////////////////////////////////////////// -// Par_MarkRefsIntoAndScanClosure: a parallel version of -// MarkRefsIntoAndScanClosure +// ParMarkRefsIntoAndScanClosure: a parallel version of +// MarkRefsIntoAndScanClosure /////////////////////////////////////////////////////////// -Par_MarkRefsIntoAndScanClosure::Par_MarkRefsIntoAndScanClosure( +ParMarkRefsIntoAndScanClosure::ParMarkRefsIntoAndScanClosure( CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, CMSBitMap* bit_map, OopTaskQueue* work_queue): _span(span), @@ -6000,7 +6000,7 @@ _work_queue(work_queue), _low_water_mark(MIN2((work_queue->max_elems()/4), ((uint)CMSWorkQueueDrainThreshold * ParallelGCThreads))), - _par_pushAndMarkClosure(collector, span, rp, bit_map, work_queue) + _parPushAndMarkClosure(collector, span, rp, bit_map, work_queue) { // FIXME: Should initialize in base class constructor. assert(rp != NULL, "ref_processor shouldn't be NULL"); @@ -6014,7 +6014,7 @@ // the scan phase whence they are also available for stealing by parallel // threads. Since the marking bit map is shared, updates are // synchronized (via CAS). -void Par_MarkRefsIntoAndScanClosure::do_oop(oop obj) { +void ParMarkRefsIntoAndScanClosure::do_oop(oop obj) { if (obj != NULL) { // Ignore mark word because this could be an already marked oop // that may be chained at the end of the overflow list. @@ -6041,8 +6041,8 @@ } } -void Par_MarkRefsIntoAndScanClosure::do_oop(oop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } -void Par_MarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { Par_MarkRefsIntoAndScanClosure::do_oop_work(p); } +void ParMarkRefsIntoAndScanClosure::do_oop(oop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } +void ParMarkRefsIntoAndScanClosure::do_oop(narrowOop* p) { ParMarkRefsIntoAndScanClosure::do_oop_work(p); } // This closure is used to rescan the marked objects on the dirty cards // in the mod union table and the card table proper. @@ -6426,7 +6426,7 @@ assert(_markStack->isEmpty(), "tautology, emphasizing post-condition"); } -Par_MarkFromRootsClosure::Par_MarkFromRootsClosure(CMSConcMarkingTask* task, +ParMarkFromRootsClosure::ParMarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, MemRegion span, CMSBitMap* bit_map, OopTaskQueue* work_queue, @@ -6449,7 +6449,7 @@ // Should revisit to see if this should be restructured for // greater efficiency. -bool Par_MarkFromRootsClosure::do_bit(size_t offset) { +bool ParMarkFromRootsClosure::do_bit(size_t offset) { if (_skip_bits > 0) { _skip_bits--; return true; @@ -6474,7 +6474,7 @@ return true; } -void Par_MarkFromRootsClosure::scan_oops_in_oop(HeapWord* ptr) { +void ParMarkFromRootsClosure::scan_oops_in_oop(HeapWord* ptr) { assert(_bit_map->isMarked(ptr), "expected bit to be set"); // Should we assert that our work queue is empty or // below some drain limit? @@ -6524,12 +6524,12 @@ // Note: the local finger doesn't advance while we drain // the stack below, but the global finger sure can and will. HeapWord** gfa = _task->global_finger_addr(); - Par_PushOrMarkClosure pushOrMarkClosure(_collector, - _span, _bit_map, - _work_queue, - _overflow_stack, - _finger, - gfa, this); + ParPushOrMarkClosure pushOrMarkClosure(_collector, + _span, _bit_map, + _work_queue, + _overflow_stack, + _finger, + gfa, this); bool res = _work_queue->push(obj); // overflow could occur here assert(res, "Will hold once we use workqueues"); while (true) { @@ -6557,7 +6557,7 @@ // Yield in response to a request from VM Thread or // from mutators. -void Par_MarkFromRootsClosure::do_yield_work() { +void ParMarkFromRootsClosure::do_yield_work() { assert(_task != NULL, "sanity"); _task->yield(); } @@ -6684,14 +6684,14 @@ _parent(parent) { } -Par_PushOrMarkClosure::Par_PushOrMarkClosure(CMSCollector* collector, - MemRegion span, - CMSBitMap* bit_map, - OopTaskQueue* work_queue, - CMSMarkStack* overflow_stack, - HeapWord* finger, - HeapWord** global_finger_addr, - Par_MarkFromRootsClosure* parent) : +ParPushOrMarkClosure::ParPushOrMarkClosure(CMSCollector* collector, + MemRegion span, + CMSBitMap* bit_map, + OopTaskQueue* work_queue, + CMSMarkStack* overflow_stack, + HeapWord* finger, + HeapWord** global_finger_addr, + ParMarkFromRootsClosure* parent) : MetadataAwareOopClosure(collector->ref_processor()), _collector(collector), _whole_span(collector->_span), @@ -6729,7 +6729,7 @@ // Upon stack overflow, we discard (part of) the stack, // remembering the least address amongst those discarded // in CMSCollector's _restart_address. -void Par_PushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { +void ParPushOrMarkClosure::handle_stack_overflow(HeapWord* lost) { // We need to do this under a mutex to prevent other // workers from interfering with the work done below. MutexLockerEx ml(_overflow_stack->par_lock(), @@ -6776,7 +6776,7 @@ void PushOrMarkClosure::do_oop(oop* p) { PushOrMarkClosure::do_oop_work(p); } void PushOrMarkClosure::do_oop(narrowOop* p) { PushOrMarkClosure::do_oop_work(p); } -void Par_PushOrMarkClosure::do_oop(oop obj) { +void ParPushOrMarkClosure::do_oop(oop obj) { // Ignore mark word because we are running concurrent with mutators. assert(obj->is_oop_or_null(true), "Expected an oop or NULL at " PTR_FORMAT, p2i(obj)); HeapWord* addr = (HeapWord*)obj; @@ -6822,8 +6822,8 @@ } } -void Par_PushOrMarkClosure::do_oop(oop* p) { Par_PushOrMarkClosure::do_oop_work(p); } -void Par_PushOrMarkClosure::do_oop(narrowOop* p) { Par_PushOrMarkClosure::do_oop_work(p); } +void ParPushOrMarkClosure::do_oop(oop* p) { ParPushOrMarkClosure::do_oop_work(p); } +void ParPushOrMarkClosure::do_oop(narrowOop* p) { ParPushOrMarkClosure::do_oop_work(p); } PushAndMarkClosure::PushAndMarkClosure(CMSCollector* collector, MemRegion span, @@ -6900,7 +6900,7 @@ } } -Par_PushAndMarkClosure::Par_PushAndMarkClosure(CMSCollector* collector, +ParPushAndMarkClosure::ParPushAndMarkClosure(CMSCollector* collector, MemRegion span, ReferenceProcessor* rp, CMSBitMap* bit_map, @@ -6919,7 +6919,7 @@ // Grey object rescan during second checkpoint phase -- // the parallel version. -void Par_PushAndMarkClosure::do_oop(oop obj) { +void ParPushAndMarkClosure::do_oop(oop obj) { // In the assert below, we ignore the mark word because // this oop may point to an already visited object that is // on the overflow stack (in which case the mark word has @@ -6959,8 +6959,8 @@ } } -void Par_PushAndMarkClosure::do_oop(oop* p) { Par_PushAndMarkClosure::do_oop_work(p); } -void Par_PushAndMarkClosure::do_oop(narrowOop* p) { Par_PushAndMarkClosure::do_oop_work(p); } +void ParPushAndMarkClosure::do_oop(oop* p) { ParPushAndMarkClosure::do_oop_work(p); } +void ParPushAndMarkClosure::do_oop(narrowOop* p) { ParPushAndMarkClosure::do_oop_work(p); } void CMSPrecleanRefsYieldClosure::do_yield_work() { Mutex* bml = _collector->bitMapLock(); diff --git a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp --- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp @@ -510,17 +510,17 @@ friend class ScanMarkedObjectsAgainCarefullyClosure; // for sampling eden friend class SurvivorSpacePrecleanClosure; // --- ditto ------- friend class PushOrMarkClosure; // to access _restart_addr - friend class Par_PushOrMarkClosure; // to access _restart_addr + friend class ParPushOrMarkClosure; // to access _restart_addr friend class MarkFromRootsClosure; // -- ditto -- // ... and for clearing cards - friend class Par_MarkFromRootsClosure; // to access _restart_addr + friend class ParMarkFromRootsClosure; // to access _restart_addr // ... and for clearing cards - friend class Par_ConcMarkingClosure; // to access _restart_addr etc. + friend class ParConcMarkingClosure; // to access _restart_addr etc. friend class MarkFromRootsVerifyClosure; // to access _restart_addr friend class PushAndMarkVerifyClosure; // -- ditto -- friend class MarkRefsIntoAndScanClosure; // to access _overflow_list friend class PushAndMarkClosure; // -- ditto -- - friend class Par_PushAndMarkClosure; // -- ditto -- + friend class ParPushAndMarkClosure; // -- ditto -- friend class CMSKeepAliveClosure; // -- ditto -- friend class CMSDrainMarkingStackClosure; // -- ditto -- friend class CMSInnerParMarkAndPushClosure; // -- ditto -- @@ -1282,7 +1282,7 @@ // 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. -class Par_MarkFromRootsClosure: public BitMapClosure { +class ParMarkFromRootsClosure: public BitMapClosure { CMSCollector* _collector; MemRegion _whole_span; MemRegion _span; @@ -1295,11 +1295,11 @@ HeapWord* _threshold; CMSConcMarkingTask* _task; public: - Par_MarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, - MemRegion span, - CMSBitMap* bit_map, - OopTaskQueue* work_queue, - CMSMarkStack* overflow_stack); + ParMarkFromRootsClosure(CMSConcMarkingTask* task, CMSCollector* collector, + MemRegion span, + CMSBitMap* bit_map, + OopTaskQueue* work_queue, + CMSMarkStack* overflow_stack); bool do_bit(size_t offset); inline void do_yield_check(); @@ -1400,8 +1400,8 @@ bool _parallel; CMSBitMap* _bit_map; union { - MarkRefsIntoAndScanClosure* _scan_closure; - Par_MarkRefsIntoAndScanClosure* _par_scan_closure; + MarkRefsIntoAndScanClosure* _scan_closure; + ParMarkRefsIntoAndScanClosure* _par_scan_closure; }; public: @@ -1425,7 +1425,7 @@ ReferenceProcessor* rp, CMSBitMap* bit_map, OopTaskQueue* work_queue, - Par_MarkRefsIntoAndScanClosure* cl): + ParMarkRefsIntoAndScanClosure* cl): #ifdef ASSERT _collector(collector), _span(span), @@ -1470,7 +1470,7 @@ CompactibleFreeListSpace* space, CMSBitMap* bit_map, OopTaskQueue* work_queue, - Par_MarkRefsIntoAndScanClosure* cl): + ParMarkRefsIntoAndScanClosure* cl): _space(space), _num_dirty_cards(0), _scan_cl(collector, span, collector->ref_processor(), bit_map, diff --git a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp --- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp @@ -381,7 +381,7 @@ } } -inline void Par_MarkFromRootsClosure::do_yield_check() { +inline void ParMarkFromRootsClosure::do_yield_check() { if (ConcurrentMarkSweepThread::should_yield() && !_collector->foregroundGCIsActive()) { do_yield_work(); @@ -392,7 +392,7 @@ _parent->do_yield_check(); } -inline void Par_PushOrMarkClosure::do_yield_check() { +inline void ParPushOrMarkClosure::do_yield_check() { _parent->do_yield_check(); } diff --git a/src/share/vm/gc/cms/parNewGeneration.cpp b/src/share/vm/gc/cms/parNewGeneration.cpp --- a/src/share/vm/gc/cms/parNewGeneration.cpp +++ b/src/share/vm/gc/cms/parNewGeneration.cpp @@ -455,7 +455,7 @@ // Every thread has its own age table. We need to merge // them all into one. - ageTable *local_table = par_scan_state.age_table(); + AgeTable *local_table = par_scan_state.age_table(); _young_gen.age_table()->merge(local_table); // Inform old gen that we're done. @@ -469,7 +469,7 @@ // to avoid this by reorganizing the code a bit, I am loathe // to do that unless we find cases where ergo leads to bad // performance. - CFLS_LAB::compute_desired_plab_size(); + CompactibleFreeListSpaceLAB::compute_desired_plab_size(); } } diff --git a/src/share/vm/gc/cms/parNewGeneration.hpp b/src/share/vm/gc/cms/parNewGeneration.hpp --- a/src/share/vm/gc/cms/parNewGeneration.hpp +++ b/src/share/vm/gc/cms/parNewGeneration.hpp @@ -94,7 +94,7 @@ int _hash_seed; int _thread_num; - ageTable _ageTable; + AgeTable _ageTable; bool _to_space_full; @@ -132,7 +132,7 @@ ParallelTaskTerminator& term_); public: - ageTable* age_table() {return &_ageTable;} + AgeTable* age_table() {return &_ageTable;} ObjToScanQueue* work_queue() { return _work_queue; } diff --git a/src/share/vm/gc/cms/vmCMSOperations.cpp b/src/share/vm/gc/cms/vmCMSOperations.cpp --- a/src/share/vm/gc/cms/vmCMSOperations.cpp +++ b/src/share/vm/gc/cms/vmCMSOperations.cpp @@ -203,7 +203,7 @@ gch->do_full_collection(gch->must_clear_all_soft_refs(), GenCollectedHeap::YoungGen); } // Else no need for a foreground young gc assert((_gc_count_before < gch->total_collections()) || - (GC_locker::is_active() /* gc may have been skipped */ + (GCLocker::is_active() /* gc may have been skipped */ && (_gc_count_before == gch->total_collections())), "total_collections() should be monotonically increasing"); diff --git a/src/share/vm/gc/g1/g1CollectedHeap.cpp b/src/share/vm/gc/g1/g1CollectedHeap.cpp --- a/src/share/vm/gc/g1/g1CollectedHeap.cpp +++ b/src/share/vm/gc/g1/g1CollectedHeap.cpp @@ -601,7 +601,7 @@ return result; } - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { if (g1_policy()->can_expand_young_list()) { // No need for an ergo verbose message here, // can_expand_young_list() does this when it returns true. @@ -617,7 +617,7 @@ // returns true). In this case we do not try this GC and // wait until the GCLocker initiated GC is performed, and // then retry the allocation. - if (GC_locker::needs_gc()) { + if (GCLocker::needs_gc()) { should_try_gc = false; } else { // Read the GC count while still holding the Heap_lock. @@ -653,7 +653,7 @@ // The GCLocker is either active or the GCLocker initiated // GC has not yet been performed. Stall until it is and // then retry the allocation. - GC_locker::stall_until_clear(); + GCLocker::stall_until_clear(); (*gclocker_retry_count_ret) += 1; } @@ -1028,7 +1028,7 @@ return result; } - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { should_try_gc = false; } else { // The GCLocker may not be active but the GCLocker initiated @@ -1036,7 +1036,7 @@ // returns true). In this case we do not try this GC and // wait until the GCLocker initiated GC is performed, and // then retry the allocation. - if (GC_locker::needs_gc()) { + if (GCLocker::needs_gc()) { should_try_gc = false; } else { // Read the GC count while still holding the Heap_lock. @@ -1076,7 +1076,7 @@ // The GCLocker is either active or the GCLocker initiated // GC has not yet been performed. Stall until it is and // then retry the allocation. - GC_locker::stall_until_clear(); + GCLocker::stall_until_clear(); (*gclocker_retry_count_ret) += 1; } @@ -1211,7 +1211,7 @@ bool clear_all_soft_refs) { assert_at_safepoint(true /* should_be_vm_thread */); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return false; } @@ -2396,8 +2396,8 @@ } if (retry_gc) { - if (GC_locker::is_active_and_needs_gc()) { - GC_locker::stall_until_clear(); + if (GCLocker::is_active_and_needs_gc()) { + GCLocker::stall_until_clear(); } } } @@ -3629,7 +3629,7 @@ assert_at_safepoint(true /* should_be_vm_thread */); guarantee(!is_gc_active(), "collection is not reentrant"); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return false; } diff --git a/src/share/vm/gc/g1/g1CollectorPolicy.hpp b/src/share/vm/gc/g1/g1CollectorPolicy.hpp --- a/src/share/vm/gc/g1/g1CollectorPolicy.hpp +++ b/src/share/vm/gc/g1/g1CollectorPolicy.hpp @@ -841,7 +841,7 @@ HeapRegion* _recorded_survivor_head; HeapRegion* _recorded_survivor_tail; - ageTable _survivors_age_table; + AgeTable _survivors_age_table; public: uint tenuring_threshold() const { return _tenuring_threshold; } @@ -882,7 +882,7 @@ return _recorded_survivor_regions; } - void record_age_table(ageTable* age_table) { + void record_age_table(AgeTable* age_table) { _survivors_age_table.merge(age_table); } diff --git a/src/share/vm/gc/g1/g1ParScanThreadState.hpp b/src/share/vm/gc/g1/g1ParScanThreadState.hpp --- a/src/share/vm/gc/g1/g1ParScanThreadState.hpp +++ b/src/share/vm/gc/g1/g1ParScanThreadState.hpp @@ -50,7 +50,7 @@ G1PLABAllocator* _plab_allocator; - ageTable _age_table; + AgeTable _age_table; InCSetState _dest[InCSetState::Num]; // Local tenuring threshold. uint _tenuring_threshold; diff --git a/src/share/vm/gc/g1/g1StringDedupQueue.cpp b/src/share/vm/gc/g1/g1StringDedupQueue.cpp --- a/src/share/vm/gc/g1/g1StringDedupQueue.cpp +++ b/src/share/vm/gc/g1/g1StringDedupQueue.cpp @@ -96,7 +96,7 @@ oop G1StringDedupQueue::pop() { assert(!SafepointSynchronize::is_at_safepoint(), "Must not be at safepoint"); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // Try all queues before giving up for (size_t tries = 0; tries < _queue->_nqueues; tries++) { diff --git a/src/share/vm/gc/g1/g1StringDedupTable.cpp b/src/share/vm/gc/g1/g1StringDedupTable.cpp --- a/src/share/vm/gc/g1/g1StringDedupTable.cpp +++ b/src/share/vm/gc/g1/g1StringDedupTable.cpp @@ -299,7 +299,7 @@ void G1StringDedupTable::deduplicate(oop java_string, G1StringDedupStat& stat) { assert(java_lang_String::is_instance(java_string), "Must be a string"); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; stat.inc_inspected(); diff --git a/src/share/vm/gc/parallel/parallelScavengeHeap.cpp b/src/share/vm/gc/parallel/parallelScavengeHeap.cpp --- a/src/share/vm/gc/parallel/parallelScavengeHeap.cpp +++ b/src/share/vm/gc/parallel/parallelScavengeHeap.cpp @@ -250,7 +250,7 @@ } // Failed to allocate without a gc. - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { // If this thread is not in a jni critical section, we stall // the requestor until the critical section has cleared and // GC allowed. When the critical section clears, a GC is @@ -260,7 +260,7 @@ JavaThread* jthr = JavaThread::current(); if (!jthr->in_critical()) { MutexUnlocker mul(Heap_lock); - GC_locker::stall_until_clear(); + GCLocker::stall_until_clear(); gclocker_stalled_count += 1; continue; } else { @@ -350,7 +350,7 @@ } HeapWord* ParallelScavengeHeap::mem_allocate_old_gen(size_t size) { - if (!should_alloc_in_eden(size) || GC_locker::is_active_and_needs_gc()) { + if (!should_alloc_in_eden(size) || GCLocker::is_active_and_needs_gc()) { // Size is too big for eden, or gc is locked out. return old_gen()->allocate(size); } diff --git a/src/share/vm/gc/parallel/psMarkSweep.cpp b/src/share/vm/gc/parallel/psMarkSweep.cpp --- a/src/share/vm/gc/parallel/psMarkSweep.cpp +++ b/src/share/vm/gc/parallel/psMarkSweep.cpp @@ -109,7 +109,7 @@ assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); assert(ref_processor() != NULL, "Sanity"); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return false; } diff --git a/src/share/vm/gc/parallel/psOldGen.cpp b/src/share/vm/gc/parallel/psOldGen.cpp --- a/src/share/vm/gc/parallel/psOldGen.cpp +++ b/src/share/vm/gc/parallel/psOldGen.cpp @@ -257,7 +257,7 @@ success = expand_to_reserved(); } - if (success && GC_locker::is_active_and_needs_gc()) { + if (success && GCLocker::is_active_and_needs_gc()) { log_debug(gc)("Garbage collection disabled, expanded heap instead"); } } diff --git a/src/share/vm/gc/parallel/psParallelCompact.cpp b/src/share/vm/gc/parallel/psParallelCompact.cpp --- a/src/share/vm/gc/parallel/psParallelCompact.cpp +++ b/src/share/vm/gc/parallel/psParallelCompact.cpp @@ -1717,7 +1717,7 @@ assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); assert(ref_processor() != NULL, "Sanity"); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return false; } diff --git a/src/share/vm/gc/parallel/psScavenge.cpp b/src/share/vm/gc/parallel/psScavenge.cpp --- a/src/share/vm/gc/parallel/psScavenge.cpp +++ b/src/share/vm/gc/parallel/psScavenge.cpp @@ -268,7 +268,7 @@ scavenge_entry.update(); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return false; } diff --git a/src/share/vm/gc/parallel/vmPSOperations.cpp b/src/share/vm/gc/parallel/vmPSOperations.cpp --- a/src/share/vm/gc/parallel/vmPSOperations.cpp +++ b/src/share/vm/gc/parallel/vmPSOperations.cpp @@ -45,7 +45,7 @@ GCCauseSetter gccs(heap, _gc_cause); _result = heap->failed_mem_allocate(_word_size); - if (_result == NULL && GC_locker::is_active_and_needs_gc()) { + if (_result == NULL && GCLocker::is_active_and_needs_gc()) { set_gc_locked(); } } diff --git a/src/share/vm/gc/serial/defNewGeneration.cpp b/src/share/vm/gc/serial/defNewGeneration.cpp --- a/src/share/vm/gc/serial/defNewGeneration.cpp +++ b/src/share/vm/gc/serial/defNewGeneration.cpp @@ -357,7 +357,7 @@ // For example if the first expand fail for unknown reasons, // but the second succeeds and expands the heap to its maximum // value. - if (GC_locker::is_active()) { + if (GCLocker::is_active()) { log_debug(gc)("Garbage collection disabled, expanded heap instead"); } @@ -527,7 +527,7 @@ // The last collection bailed out, we are running out of heap space, // so we try to allocate the from-space, too. HeapWord* DefNewGeneration::allocate_from_space(size_t size) { - bool should_try_alloc = should_allocate_from_space() || GC_locker::is_active_and_needs_gc(); + bool should_try_alloc = should_allocate_from_space() || GCLocker::is_active_and_needs_gc(); // If the Heap_lock is not locked by this thread, this will be called // again later with the Heap_lock held. @@ -910,7 +910,7 @@ void DefNewGeneration::gc_epilogue(bool full) { DEBUG_ONLY(static bool seen_incremental_collection_failed = false;) - assert(!GC_locker::is_active(), "We should not be executing here"); + assert(!GCLocker::is_active(), "We should not be executing here"); // Check if the heap is approaching full after a collection has // been done. Generally the young generation is empty at // a minimum at the end of a collection. If it is not, then diff --git a/src/share/vm/gc/serial/defNewGeneration.hpp b/src/share/vm/gc/serial/defNewGeneration.hpp --- a/src/share/vm/gc/serial/defNewGeneration.hpp +++ b/src/share/vm/gc/serial/defNewGeneration.hpp @@ -47,11 +47,11 @@ protected: Generation* _old_gen; uint _tenuring_threshold; // Tenuring threshold for next collection. - ageTable _age_table; + AgeTable _age_table; // Size of object to pretenure in words; command line provides bytes size_t _pretenure_size_threshold_words; - ageTable* age_table() { return &_age_table; } + AgeTable* age_table() { return &_age_table; } // Initialize state to optimistically assume no promotion failure will // happen. diff --git a/src/share/vm/gc/shared/ageTable.cpp b/src/share/vm/gc/shared/ageTable.cpp --- a/src/share/vm/gc/shared/ageTable.cpp +++ b/src/share/vm/gc/shared/ageTable.cpp @@ -34,7 +34,7 @@ /* Copyright (c) 1992, 2015, Oracle and/or its affiliates, and Stanford University. See the LICENSE file for license information. */ -ageTable::ageTable(bool global) { +AgeTable::AgeTable(bool global) { clear(); @@ -61,19 +61,19 @@ } } -void ageTable::clear() { +void AgeTable::clear() { for (size_t* p = sizes; p < sizes + table_size; ++p) { *p = 0; } } -void ageTable::merge(ageTable* subTable) { +void AgeTable::merge(AgeTable* subTable) { for (int i = 0; i < table_size; i++) { sizes[i]+= subTable->sizes[i]; } } -uint ageTable::compute_tenuring_threshold(size_t survivor_capacity, GCPolicyCounters* gc_counters) { +uint AgeTable::compute_tenuring_threshold(size_t survivor_capacity, GCPolicyCounters* gc_counters) { size_t desired_survivor_size = (size_t)((((double) survivor_capacity)*TargetSurvivorRatio)/100); uint result; diff --git a/src/share/vm/gc/shared/ageTable.hpp b/src/share/vm/gc/shared/ageTable.hpp --- a/src/share/vm/gc/shared/ageTable.hpp +++ b/src/share/vm/gc/shared/ageTable.hpp @@ -38,7 +38,7 @@ // // Note: all sizes are in oops -class ageTable VALUE_OBJ_CLASS_SPEC { +class AgeTable VALUE_OBJ_CLASS_SPEC { friend class VMStructs; public: @@ -50,7 +50,7 @@ // constructor. "global" indicates that this is the global age table // (as opposed to gc-thread-local) - ageTable(bool global = true); + AgeTable(bool global = true); // clear table void clear(); @@ -67,7 +67,7 @@ // Merge another age table with the current one. Used // for parallel young generation gc. - void merge(ageTable* subTable); + void merge(AgeTable* subTable); // calculate new tenuring threshold based on age information uint compute_tenuring_threshold(size_t survivor_capacity, GCPolicyCounters* gc_counters); diff --git a/src/share/vm/gc/shared/cardGeneration.cpp b/src/share/vm/gc/shared/cardGeneration.cpp --- a/src/share/vm/gc/shared/cardGeneration.cpp +++ b/src/share/vm/gc/shared/cardGeneration.cpp @@ -131,7 +131,7 @@ if (!success) { success = grow_to_reserved(); } - if (success && GC_locker::is_active_and_needs_gc()) { + if (success && GCLocker::is_active_and_needs_gc()) { log_trace(gc, heap)("Garbage collection disabled, expanded heap instead"); } diff --git a/src/share/vm/gc/shared/collectorPolicy.cpp b/src/share/vm/gc/shared/collectorPolicy.cpp --- a/src/share/vm/gc/shared/collectorPolicy.cpp +++ b/src/share/vm/gc/shared/collectorPolicy.cpp @@ -620,7 +620,7 @@ return result; } - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { if (is_tlab) { return NULL; // Caller will retry allocating individual object. } @@ -647,7 +647,7 @@ if (!jthr->in_critical()) { MutexUnlocker mul(Heap_lock); // Wait for JNI critical section to be exited - GC_locker::stall_until_clear(); + GCLocker::stall_until_clear(); gclocker_stalled_count += 1; continue; } else { @@ -728,7 +728,7 @@ HeapWord* result = NULL; assert(size != 0, "Precondition violated"); - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { // GC locker is active; instead of a collection we will attempt // to expand the heap, if there's room for expansion. if (!gch->is_maximal_no_gc()) { @@ -815,8 +815,8 @@ return result; } - if (GC_locker::is_active_and_needs_gc()) { - // If the GC_locker is active, just expand and allocate. + if (GCLocker::is_active_and_needs_gc()) { + // If the GCLocker is active, just expand and allocate. // If that does not succeed, wait if this thread is not // in a critical section itself. result = @@ -828,7 +828,7 @@ JavaThread* jthr = JavaThread::current(); if (!jthr->in_critical()) { // Wait for JNI critical section to be exited - GC_locker::stall_until_clear(); + GCLocker::stall_until_clear(); // The GC invoked by the last thread leaving the critical // section will be a young collection and a full collection // is (currently) needed for unloading classes so continue @@ -887,7 +887,7 @@ GenCollectedHeap* gch = GenCollectedHeap::heap(); size_t young_capacity = gch->young_gen()->capacity_before_gc(); return (word_size > heap_word_size(young_capacity)) - || GC_locker::is_active_and_needs_gc() + || GCLocker::is_active_and_needs_gc() || gch->incremental_collection_failed(); } diff --git a/src/share/vm/gc/shared/gcLocker.cpp b/src/share/vm/gc/shared/gcLocker.cpp --- a/src/share/vm/gc/shared/gcLocker.cpp +++ b/src/share/vm/gc/shared/gcLocker.cpp @@ -30,17 +30,17 @@ #include "runtime/atomic.inline.hpp" #include "runtime/thread.inline.hpp" -volatile jint GC_locker::_jni_lock_count = 0; -volatile bool GC_locker::_needs_gc = false; -volatile bool GC_locker::_doing_gc = false; +volatile jint GCLocker::_jni_lock_count = 0; +volatile bool GCLocker::_needs_gc = false; +volatile bool GCLocker::_doing_gc = false; #ifdef ASSERT -volatile jint GC_locker::_debug_jni_lock_count = 0; +volatile jint GCLocker::_debug_jni_lock_count = 0; #endif #ifdef ASSERT -void GC_locker::verify_critical_count() { +void GCLocker::verify_critical_count() { if (SafepointSynchronize::is_at_safepoint()) { assert(!needs_gc() || _debug_jni_lock_count == _jni_lock_count, "must agree"); int count = 0; @@ -63,18 +63,18 @@ } // In debug mode track the locking state at all times -void GC_locker::increment_debug_jni_lock_count() { +void GCLocker::increment_debug_jni_lock_count() { assert(_debug_jni_lock_count >= 0, "bad value"); Atomic::inc(&_debug_jni_lock_count); } -void GC_locker::decrement_debug_jni_lock_count() { +void GCLocker::decrement_debug_jni_lock_count() { assert(_debug_jni_lock_count > 0, "bad value"); Atomic::dec(&_debug_jni_lock_count); } #endif -void GC_locker::log_debug_jni(const char* msg) { +void GCLocker::log_debug_jni(const char* msg) { LogHandle(gc, jni) log; if (log.is_debug()) { ResourceMark rm; // JavaThread::name() allocates to convert to UTF8 @@ -82,7 +82,7 @@ } } -bool GC_locker::check_active_before_gc() { +bool GCLocker::check_active_before_gc() { assert(SafepointSynchronize::is_at_safepoint(), "only read at safepoint"); if (is_active() && !_needs_gc) { verify_critical_count(); @@ -92,7 +92,7 @@ return is_active(); } -void GC_locker::stall_until_clear() { +void GCLocker::stall_until_clear() { assert(!JavaThread::current()->in_critical(), "Would deadlock"); MutexLocker ml(JNICritical_lock); @@ -106,7 +106,7 @@ } } -void GC_locker::jni_lock(JavaThread* thread) { +void GCLocker::jni_lock(JavaThread* thread) { assert(!thread->in_critical(), "shouldn't currently be in a critical region"); MutexLocker mu(JNICritical_lock); // Block entering threads if we know at least one thread is in a @@ -122,7 +122,7 @@ increment_debug_jni_lock_count(); } -void GC_locker::jni_unlock(JavaThread* thread) { +void GCLocker::jni_unlock(JavaThread* thread) { assert(thread->in_last_critical(), "should be exiting critical region"); MutexLocker mu(JNICritical_lock); _jni_lock_count--; @@ -143,49 +143,49 @@ } } -// Implementation of No_GC_Verifier +// Implementation of NoGCVerifier #ifdef ASSERT -No_GC_Verifier::No_GC_Verifier(bool verifygc) { +NoGCVerifier::NoGCVerifier(bool verifygc) { _verifygc = verifygc; if (_verifygc) { CollectedHeap* h = Universe::heap(); - assert(!h->is_gc_active(), "GC active during No_GC_Verifier"); + assert(!h->is_gc_active(), "GC active during NoGCVerifier"); _old_invocations = h->total_collections(); } } -No_GC_Verifier::~No_GC_Verifier() { +NoGCVerifier::~NoGCVerifier() { if (_verifygc) { CollectedHeap* h = Universe::heap(); - assert(!h->is_gc_active(), "GC active during No_GC_Verifier"); + assert(!h->is_gc_active(), "GC active during NoGCVerifier"); if (_old_invocations != h->total_collections()) { - fatal("collection in a No_GC_Verifier secured function"); + fatal("collection in a NoGCVerifier secured function"); } } } -Pause_No_GC_Verifier::Pause_No_GC_Verifier(No_GC_Verifier * ngcv) { +PauseNoGCVerifier::PauseNoGCVerifier(NoGCVerifier * ngcv) { _ngcv = ngcv; if (_ngcv->_verifygc) { // if we were verifying, then make sure that nothing is // wrong before we "pause" verification CollectedHeap* h = Universe::heap(); - assert(!h->is_gc_active(), "GC active during No_GC_Verifier"); + assert(!h->is_gc_active(), "GC active during NoGCVerifier"); if (_ngcv->_old_invocations != h->total_collections()) { - fatal("collection in a No_GC_Verifier secured function"); + fatal("collection in a NoGCVerifier secured function"); } } } -Pause_No_GC_Verifier::~Pause_No_GC_Verifier() { +PauseNoGCVerifier::~PauseNoGCVerifier() { if (_ngcv->_verifygc) { // if we were verifying before, then reenable verification CollectedHeap* h = Universe::heap(); - assert(!h->is_gc_active(), "GC active during No_GC_Verifier"); + assert(!h->is_gc_active(), "GC active during NoGCVerifier"); _ngcv->_old_invocations = h->total_collections(); } } @@ -201,16 +201,16 @@ // 6) reaching a safepoint // 7) running too long // Nor may any method it calls. -JRT_Leaf_Verifier::JRT_Leaf_Verifier() - : No_Safepoint_Verifier(true, JRT_Leaf_Verifier::should_verify_GC()) +JRTLeafVerifier::JRTLeafVerifier() + : NoSafepointVerifier(true, JRTLeafVerifier::should_verify_GC()) { } -JRT_Leaf_Verifier::~JRT_Leaf_Verifier() +JRTLeafVerifier::~JRTLeafVerifier() { } -bool JRT_Leaf_Verifier::should_verify_GC() { +bool JRTLeafVerifier::should_verify_GC() { switch (JavaThread::current()->thread_state()) { case _thread_in_Java: // is in a leaf routine, there must be no safepoint. diff --git a/src/share/vm/gc/shared/gcLocker.hpp b/src/share/vm/gc/shared/gcLocker.hpp --- a/src/share/vm/gc/shared/gcLocker.hpp +++ b/src/share/vm/gc/shared/gcLocker.hpp @@ -33,12 +33,12 @@ // The direct lock/unlock calls do not force a collection if an unlock // decrements the count to zero. Avoid calling these if at all possible. -class GC_locker: public AllStatic { +class GCLocker: public AllStatic { private: // The _jni_lock_count keeps track of the number of threads that are // currently in a critical region. It's only kept up to date when // _needs_gc is true. The current value is computed during - // safepointing and decremented during the slow path of GC_locker + // safepointing and decremented during the slow path of GCLocker // unlocking. static volatile jint _jni_lock_count; // number of jni active instances. static volatile bool _needs_gc; // heap is filling, we need a GC @@ -103,7 +103,7 @@ static void stall_until_clear(); // The following two methods are used for JNI critical regions. - // If we find that we failed to perform a GC because the GC_locker + // If we find that we failed to perform a GC because the GCLocker // was active, arrange for one as soon as possible by allowing // all threads in critical regions to complete, but not allowing // other critical regions to be entered. The reasons for that are: @@ -126,7 +126,7 @@ // _needs_gc is initially false and every java thread will go // through the fast path, which simply increments or decrements the // current thread's critical count. When GC happens at a safepoint, - // GC_locker::is_active() is checked. Since there is no safepoint in + // GCLocker::is_active() is checked. Since there is no safepoint in // the fast path of lock_critical() and unlock_critical(), there is // no race condition between the fast path and GC. After _needs_gc // is set at a safepoint, every thread will go through the slow path @@ -142,14 +142,14 @@ }; -// A No_GC_Verifier object can be placed in methods where one assumes that +// A NoGCVerifier object can be placed in methods where one assumes that // no garbage collection will occur. The destructor will verify this property // unless the constructor is called with argument false (not verifygc). // // The check will only be done in debug mode and if verifygc true. -class No_GC_Verifier: public StackObj { - friend class Pause_No_GC_Verifier; +class NoGCVerifier: public StackObj { + friend class PauseNoGCVerifier; protected: bool _verifygc; @@ -157,51 +157,51 @@ public: #ifdef ASSERT - No_GC_Verifier(bool verifygc = true); - ~No_GC_Verifier(); + NoGCVerifier(bool verifygc = true); + ~NoGCVerifier(); #else - No_GC_Verifier(bool verifygc = true) {} - ~No_GC_Verifier() {} + NoGCVerifier(bool verifygc = true) {} + ~NoGCVerifier() {} #endif }; -// A Pause_No_GC_Verifier is used to temporarily pause the behavior -// of a No_GC_Verifier object. If we are not in debug mode or if the -// No_GC_Verifier object has a _verifygc value of false, then there +// A PauseNoGCVerifier is used to temporarily pause the behavior +// of a NoGCVerifier object. If we are not in debug mode or if the +// NoGCVerifier object has a _verifygc value of false, then there // is nothing to do. -class Pause_No_GC_Verifier: public StackObj { +class PauseNoGCVerifier: public StackObj { private: - No_GC_Verifier * _ngcv; + NoGCVerifier * _ngcv; public: #ifdef ASSERT - Pause_No_GC_Verifier(No_GC_Verifier * ngcv); - ~Pause_No_GC_Verifier(); + PauseNoGCVerifier(NoGCVerifier * ngcv); + ~PauseNoGCVerifier(); #else - Pause_No_GC_Verifier(No_GC_Verifier * ngcv) {} - ~Pause_No_GC_Verifier() {} + PauseNoGCVerifier(NoGCVerifier * ngcv) {} + ~PauseNoGCVerifier() {} #endif }; -// A No_Safepoint_Verifier object will throw an assertion failure if +// A NoSafepointVerifier object will throw an assertion failure if // the current thread passes a possible safepoint while this object is // instantiated. A safepoint, will either be: an oop allocation, blocking // on a Mutex or JavaLock, or executing a VM operation. // -// If StrictSafepointChecks is turned off, it degrades into a No_GC_Verifier +// If StrictSafepointChecks is turned off, it degrades into a NoGCVerifier // -class No_Safepoint_Verifier : public No_GC_Verifier { - friend class Pause_No_Safepoint_Verifier; +class NoSafepointVerifier : public NoGCVerifier { + friend class PauseNoSafepointVerifier; private: bool _activated; Thread *_thread; public: #ifdef ASSERT - No_Safepoint_Verifier(bool activated = true, bool verifygc = true ) : - No_GC_Verifier(verifygc), + NoSafepointVerifier(bool activated = true, bool verifygc = true ) : + NoGCVerifier(verifygc), _activated(activated) { _thread = Thread::current(); if (_activated) { @@ -210,33 +210,33 @@ } } - ~No_Safepoint_Verifier() { + ~NoSafepointVerifier() { if (_activated) { _thread->_allow_allocation_count--; _thread->_allow_safepoint_count--; } } #else - No_Safepoint_Verifier(bool activated = true, bool verifygc = true) : No_GC_Verifier(verifygc){} - ~No_Safepoint_Verifier() {} + NoSafepointVerifier(bool activated = true, bool verifygc = true) : NoGCVerifier(verifygc){} + ~NoSafepointVerifier() {} #endif }; -// A Pause_No_Safepoint_Verifier is used to temporarily pause the -// behavior of a No_Safepoint_Verifier object. If we are not in debug -// mode then there is nothing to do. If the No_Safepoint_Verifier +// A PauseNoSafepointVerifier is used to temporarily pause the +// behavior of a NoSafepointVerifier object. If we are not in debug +// mode then there is nothing to do. If the NoSafepointVerifier // object has an _activated value of false, then there is nothing to // do for safepoint and allocation checking, but there may still be -// something to do for the underlying No_GC_Verifier object. +// something to do for the underlying NoGCVerifier object. -class Pause_No_Safepoint_Verifier : public Pause_No_GC_Verifier { +class PauseNoSafepointVerifier : public PauseNoGCVerifier { private: - No_Safepoint_Verifier * _nsv; + NoSafepointVerifier * _nsv; public: #ifdef ASSERT - Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv) - : Pause_No_GC_Verifier(nsv) { + PauseNoSafepointVerifier(NoSafepointVerifier * nsv) + : PauseNoGCVerifier(nsv) { _nsv = nsv; if (_nsv->_activated) { @@ -245,16 +245,16 @@ } } - ~Pause_No_Safepoint_Verifier() { + ~PauseNoSafepointVerifier() { if (_nsv->_activated) { _nsv->_thread->_allow_allocation_count++; _nsv->_thread->_allow_safepoint_count++; } } #else - Pause_No_Safepoint_Verifier(No_Safepoint_Verifier * nsv) - : Pause_No_GC_Verifier(nsv) {} - ~Pause_No_Safepoint_Verifier() {} + PauseNoSafepointVerifier(NoSafepointVerifier * nsv) + : PauseNoGCVerifier(nsv) {} + ~PauseNoSafepointVerifier() {} #endif }; @@ -287,19 +287,19 @@ // _thread_in_native mode. In _thread_in_native, it is ok // for another thread to trigger GC. The rest of the JRT_LEAF // rules apply. -class JRT_Leaf_Verifier : public No_Safepoint_Verifier { +class JRTLeafVerifier : public NoSafepointVerifier { static bool should_verify_GC(); public: #ifdef ASSERT - JRT_Leaf_Verifier(); - ~JRT_Leaf_Verifier(); + JRTLeafVerifier(); + ~JRTLeafVerifier(); #else - JRT_Leaf_Verifier() {} - ~JRT_Leaf_Verifier() {} + JRTLeafVerifier() {} + ~JRTLeafVerifier() {} #endif }; -// A No_Alloc_Verifier object can be placed in methods where one assumes that +// A NoAllocVerifier object can be placed in methods where one assumes that // no allocation will occur. The destructor will verify this property // unless the constructor is called with argument false (not activated). // @@ -307,23 +307,23 @@ // Note: this only makes sense at safepoints (otherwise, other threads may // allocate concurrently.) -class No_Alloc_Verifier : public StackObj { +class NoAllocVerifier : public StackObj { private: bool _activated; public: #ifdef ASSERT - No_Alloc_Verifier(bool activated = true) { + NoAllocVerifier(bool activated = true) { _activated = activated; if (_activated) Thread::current()->_allow_allocation_count++; } - ~No_Alloc_Verifier() { + ~NoAllocVerifier() { if (_activated) Thread::current()->_allow_allocation_count--; } #else - No_Alloc_Verifier(bool activated = true) {} - ~No_Alloc_Verifier() {} + NoAllocVerifier(bool activated = true) {} + ~NoAllocVerifier() {} #endif }; diff --git a/src/share/vm/gc/shared/gcLocker.inline.hpp b/src/share/vm/gc/shared/gcLocker.inline.hpp --- a/src/share/vm/gc/shared/gcLocker.inline.hpp +++ b/src/share/vm/gc/shared/gcLocker.inline.hpp @@ -27,7 +27,7 @@ #include "gc/shared/gcLocker.hpp" -inline void GC_locker::lock_critical(JavaThread* thread) { +inline void GCLocker::lock_critical(JavaThread* thread) { if (!thread->in_critical()) { if (needs_gc()) { // jni_lock call calls enter_critical under the lock so that the @@ -40,7 +40,7 @@ thread->enter_critical(); } -inline void GC_locker::unlock_critical(JavaThread* thread) { +inline void GCLocker::unlock_critical(JavaThread* thread) { if (thread->in_last_critical()) { if (needs_gc()) { // jni_unlock call calls exit_critical under the lock so that diff --git a/src/share/vm/gc/shared/genCollectedHeap.cpp b/src/share/vm/gc/shared/genCollectedHeap.cpp --- a/src/share/vm/gc/shared/genCollectedHeap.cpp +++ b/src/share/vm/gc/shared/genCollectedHeap.cpp @@ -409,7 +409,7 @@ "the requesting thread should have the Heap_lock"); guarantee(!is_gc_active(), "collection is not reentrant"); - if (GC_locker::check_active_before_gc()) { + if (GCLocker::check_active_before_gc()) { return; // GC is disabled (e.g. JNI GetXXXCritical operation) } diff --git a/src/share/vm/gc/shared/space.cpp b/src/share/vm/gc/shared/space.cpp --- a/src/share/vm/gc/shared/space.cpp +++ b/src/share/vm/gc/shared/space.cpp @@ -208,9 +208,9 @@ return top; } -void Filtering_DCTOC::walk_mem_region(MemRegion mr, - HeapWord* bottom, - HeapWord* top) { +void FilteringDCTOC::walk_mem_region(MemRegion mr, + HeapWord* bottom, + HeapWord* top) { // Note that this assumption won't hold if we have a concurrent // collector in this space, which may have freed up objects after // they were dirtied and before the stop-the-world GC that is diff --git a/src/share/vm/gc/shared/space.hpp b/src/share/vm/gc/shared/space.hpp --- a/src/share/vm/gc/shared/space.hpp +++ b/src/share/vm/gc/shared/space.hpp @@ -676,7 +676,7 @@ // A dirty card to oop closure that does filtering. // It knows how to filter out objects that are outside of the _boundary. -class Filtering_DCTOC : public DirtyCardToOopClosure { +class FilteringDCTOC : public DirtyCardToOopClosure { protected: // Override. void walk_mem_region(MemRegion mr, @@ -697,7 +697,7 @@ FilteringClosure* cl) = 0; public: - Filtering_DCTOC(Space* sp, ExtendedOopClosure* cl, + FilteringDCTOC(Space* sp, ExtendedOopClosure* cl, CardTableModRefBS::PrecisionStyle precision, HeapWord* boundary) : DirtyCardToOopClosure(sp, cl, precision, boundary) {} @@ -713,7 +713,7 @@ // 2. That the space is really made up of objects and not just // blocks. -class ContiguousSpaceDCTOC : public Filtering_DCTOC { +class ContiguousSpaceDCTOC : public FilteringDCTOC { protected: // Overrides. HeapWord* get_actual_top(HeapWord* top, HeapWord* top_obj); @@ -729,7 +729,7 @@ ContiguousSpaceDCTOC(ContiguousSpace* sp, ExtendedOopClosure* cl, CardTableModRefBS::PrecisionStyle precision, HeapWord* boundary) : - Filtering_DCTOC(sp, cl, precision, boundary) + FilteringDCTOC(sp, cl, precision, boundary) {} }; diff --git a/src/share/vm/gc/shared/specialized_oop_closures.hpp b/src/share/vm/gc/shared/specialized_oop_closures.hpp --- a/src/share/vm/gc/shared/specialized_oop_closures.hpp +++ b/src/share/vm/gc/shared/specialized_oop_closures.hpp @@ -49,11 +49,11 @@ class ParScanWithoutBarrierClosure; // CMS class MarkRefsIntoAndScanClosure; -class Par_MarkRefsIntoAndScanClosure; +class ParMarkRefsIntoAndScanClosure; class PushAndMarkClosure; -class Par_PushAndMarkClosure; +class ParPushAndMarkClosure; class PushOrMarkClosure; -class Par_PushOrMarkClosure; +class ParPushOrMarkClosure; class CMSKeepAliveClosure; class CMSInnerParMarkAndPushClosure; // Misc @@ -95,11 +95,11 @@ #if INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_CMS(f) \ f(MarkRefsIntoAndScanClosure,_nv) \ - f(Par_MarkRefsIntoAndScanClosure,_nv) \ + f(ParMarkRefsIntoAndScanClosure,_nv) \ f(PushAndMarkClosure,_nv) \ - f(Par_PushAndMarkClosure,_nv) \ + f(ParPushAndMarkClosure,_nv) \ f(PushOrMarkClosure,_nv) \ - f(Par_PushOrMarkClosure,_nv) \ + f(ParPushOrMarkClosure,_nv) \ f(CMSKeepAliveClosure,_nv) \ f(CMSInnerParMarkAndPushClosure,_nv) #endif @@ -136,8 +136,8 @@ #define SPECIALIZED_PAR_OOP_ITERATE_CLOSURES(f) \ f(MarkRefsIntoAndScanClosure,_nv) \ f(PushAndMarkClosure,_nv) \ - f(Par_MarkRefsIntoAndScanClosure,_nv) \ - f(Par_PushAndMarkClosure,_nv) + f(ParMarkRefsIntoAndScanClosure,_nv) \ + f(ParPushAndMarkClosure,_nv) #define ALL_PAR_OOP_ITERATE_CLOSURES(f) \ f(ExtendedOopClosure,_v) \ diff --git a/src/share/vm/gc/shared/vmGCOperations.cpp b/src/share/vm/gc/shared/vmGCOperations.cpp --- a/src/share/vm/gc/shared/vmGCOperations.cpp +++ b/src/share/vm/gc/shared/vmGCOperations.cpp @@ -84,10 +84,10 @@ if (_full && skip) { skip = (_full_gc_count_before != Universe::heap()->total_full_collections()); } - if (!skip && GC_locker::is_active_and_needs_gc()) { + if (!skip && GCLocker::is_active_and_needs_gc()) { skip = Universe::heap()->is_maximal_no_gc(); assert(!(skip && (_gc_cause == GCCause::_gc_locker)), - "GC_locker cannot be active when initiating GC"); + "GCLocker cannot be active when initiating GC"); } return skip; } @@ -136,7 +136,7 @@ } bool VM_GC_HeapInspection::collect() { - if (GC_locker::is_active()) { + if (GCLocker::is_active()) { return false; } Universe::heap()->collect_as_vm_thread(GCCause::_heap_inspection); @@ -146,7 +146,7 @@ void VM_GC_HeapInspection::doit() { HandleMark hm; Universe::heap()->ensure_parsability(false); // must happen, even if collection does - // not happen (e.g. due to GC_locker) + // not happen (e.g. due to GCLocker) // or _full_gc being false if (_full_gc) { if (!collect()) { @@ -177,7 +177,7 @@ _result = gch->satisfy_failed_allocation(_word_size, _tlab); assert(gch->is_in_reserved_or_null(_result), "result not in heap"); - if (_result == NULL && GC_locker::is_active_and_needs_gc()) { + if (_result == NULL && GCLocker::is_active_and_needs_gc()) { set_gc_locked(); } } @@ -289,7 +289,7 @@ log_debug(gc)("After Metaspace GC failed to allocate size " SIZE_FORMAT, _size); - if (GC_locker::is_active_and_needs_gc()) { + if (GCLocker::is_active_and_needs_gc()) { set_gc_locked(); } } diff --git a/src/share/vm/interpreter/rewriter.cpp b/src/share/vm/interpreter/rewriter.cpp --- a/src/share/vm/interpreter/rewriter.cpp +++ b/src/share/vm/interpreter/rewriter.cpp @@ -340,7 +340,7 @@ // We cannot tolerate a GC in this block, because we've // cached the bytecodes in 'code_base'. If the Method* // moves, the bytecodes will also move. - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; Bytecodes::Code c; // Bytecodes and their length diff --git a/src/share/vm/oops/constMethod.cpp b/src/share/vm/oops/constMethod.cpp --- a/src/share/vm/oops/constMethod.cpp +++ b/src/share/vm/oops/constMethod.cpp @@ -49,7 +49,7 @@ MethodType method_type, int size) { - No_Safepoint_Verifier no_safepoint; + NoSafepointVerifier no_safepoint; init_fingerprint(); set_constants(NULL); set_stackmap_data(NULL); diff --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp --- a/src/share/vm/oops/instanceKlass.cpp +++ b/src/share/vm/oops/instanceKlass.cpp @@ -2624,7 +2624,7 @@ bool InstanceKlass::add_member_name(Handle mem_name) { jweak mem_name_wref = JNIHandles::make_weak_global(mem_name); MutexLocker ml(MemberNameTable_lock); - DEBUG_ONLY(No_Safepoint_Verifier nsv); + DEBUG_ONLY(NoSafepointVerifier nsv); // Check if method has been redefined while taking out MemberNameTable_lock, if so // return false. We cannot cache obsolete methods. They will crash when the function diff --git a/src/share/vm/oops/klassVtable.cpp b/src/share/vm/oops/klassVtable.cpp --- a/src/share/vm/oops/klassVtable.cpp +++ b/src/share/vm/oops/klassVtable.cpp @@ -59,7 +59,7 @@ Array* methods, AccessFlags class_flags, Handle classloader, Symbol* classname, Array* local_interfaces, TRAPS) { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // set up default result values int vtable_length = 0; diff --git a/src/share/vm/oops/method.cpp b/src/share/vm/oops/method.cpp --- a/src/share/vm/oops/method.cpp +++ b/src/share/vm/oops/method.cpp @@ -77,7 +77,7 @@ } Method::Method(ConstMethod* xconst, AccessFlags access_flags) { - No_Safepoint_Verifier no_safepoint; + NoSafepointVerifier no_safepoint; set_constMethod(xconst); set_access_flags(access_flags); #ifdef CC_INTERP @@ -998,7 +998,7 @@ // or adapter that it points to is still live and valid. // This function must not hit a safepoint! address Method::verified_code_entry() { - debug_only(No_Safepoint_Verifier nsv;) + debug_only(NoSafepointVerifier nsv;) assert(_from_compiled_entry != NULL, "must be set"); return _from_compiled_entry; } @@ -1548,7 +1548,7 @@ int length = methods->length(); if (length > 1) { { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; QuickSort::sort(methods->data(), length, method_comparator, idempotent); } // Reset method ordering diff --git a/src/share/vm/oops/methodData.cpp b/src/share/vm/oops/methodData.cpp --- a/src/share/vm/oops/methodData.cpp +++ b/src/share/vm/oops/methodData.cpp @@ -1140,7 +1140,7 @@ } void MethodData::initialize() { - No_Safepoint_Verifier no_safepoint; // init function atomic wrt GC + NoSafepointVerifier no_safepoint; // init function atomic wrt GC ResourceMark rm; init(); diff --git a/src/share/vm/opto/runtime.cpp b/src/share/vm/opto/runtime.cpp --- a/src/share/vm/opto/runtime.cpp +++ b/src/share/vm/opto/runtime.cpp @@ -1383,7 +1383,7 @@ // However, there needs to be a safepoint check in the middle! So compiled // safepoints are completely watertight. // -// Thus, it cannot be a leaf since it contains the No_GC_Verifier. +// Thus, it cannot be a leaf since it contains the NoGCVerifier. // // *THIS IS NOT RECOMMENDED PROGRAMMING STYLE* // diff --git a/src/share/vm/prims/jni.cpp b/src/share/vm/prims/jni.cpp --- a/src/share/vm/prims/jni.cpp +++ b/src/share/vm/prims/jni.cpp @@ -204,7 +204,7 @@ field_klass = super_klass; // super contains the field also super_klass = field_klass->super(); } - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) uintptr_t klass_hash = field_klass->identity_hash(); return ((klass_hash & klass_mask) << klass_shift) | checked_mask_in_place; } else { @@ -224,7 +224,7 @@ uintptr_t as_uint = (uintptr_t) id; intptr_t klass_hash = (as_uint >> klass_shift) & klass_mask; do { - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) // Could use a non-blocking query for identity_hash here... if ((k->identity_hash() & klass_mask) == klass_hash) return true; @@ -1124,7 +1124,7 @@ selected_method = m; } else if (!m->has_itable_index()) { // non-interface call -- for that little speed boost, don't handlize - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) // jni_GetMethodID makes sure class is linked and initialized // so m should have a valid vtable index. assert(m->valid_vtable_index(), "no valid vtable index"); @@ -3157,7 +3157,7 @@ JNI_ENTRY(void*, jni_GetPrimitiveArrayCritical(JNIEnv *env, jarray array, jboolean *isCopy)) JNIWrapper("GetPrimitiveArrayCritical"); HOTSPOT_JNI_GETPRIMITIVEARRAYCRITICAL_ENTRY(env, array, (uintptr_t *) isCopy); - GC_locker::lock_critical(thread); + GCLocker::lock_critical(thread); if (isCopy != NULL) { *isCopy = JNI_FALSE; } @@ -3179,7 +3179,7 @@ JNIWrapper("ReleasePrimitiveArrayCritical"); HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_ENTRY(env, array, carray, mode); // The array, carray and mode arguments are ignored - GC_locker::unlock_critical(thread); + GCLocker::unlock_critical(thread); HOTSPOT_JNI_RELEASEPRIMITIVEARRAYCRITICAL_RETURN(); JNI_END @@ -3187,7 +3187,7 @@ JNI_ENTRY(const jchar*, jni_GetStringCritical(JNIEnv *env, jstring string, jboolean *isCopy)) JNIWrapper("GetStringCritical"); HOTSPOT_JNI_GETSTRINGCRITICAL_ENTRY(env, string, (uintptr_t *) isCopy); - GC_locker::lock_critical(thread); + GCLocker::lock_critical(thread); oop s = JNIHandles::resolve_non_null(string); typeArrayOop s_value = java_lang_String::value(s); bool is_latin1 = java_lang_String::is_latin1(s); @@ -3225,7 +3225,7 @@ // This assumes that ReleaseStringCritical bookends GetStringCritical. FREE_C_HEAP_ARRAY(jchar, chars); } - GC_locker::unlock_critical(thread); + GCLocker::unlock_critical(thread); HOTSPOT_JNI_RELEASESTRINGCRITICAL_RETURN(); JNI_END diff --git a/src/share/vm/prims/jvmtiEnvBase.cpp b/src/share/vm/prims/jvmtiEnvBase.cpp --- a/src/share/vm/prims/jvmtiEnvBase.cpp +++ b/src/share/vm/prims/jvmtiEnvBase.cpp @@ -95,7 +95,7 @@ { // This block of code must not contain any safepoints, as list deallocation // (which occurs at a safepoint) cannot occur simultaneously with this list - // addition. Note: No_Safepoint_Verifier cannot, currently, be used before + // addition. Note: NoSafepointVerifier cannot, currently, be used before // threads exist. JvmtiEnvIterator it; JvmtiEnvBase *previous_env = NULL; diff --git a/src/share/vm/prims/jvmtiExport.cpp b/src/share/vm/prims/jvmtiExport.cpp --- a/src/share/vm/prims/jvmtiExport.cpp +++ b/src/share/vm/prims/jvmtiExport.cpp @@ -1904,7 +1904,7 @@ Thread* thread = Thread::current_or_null(); if (thread != NULL && thread->is_Java_thread()) { // Can not take safepoint here. - No_Safepoint_Verifier no_sfpt; + NoSafepointVerifier no_sfpt; // Can not take safepoint here so can not use state_for to get // jvmti thread state. JvmtiThreadState *state = ((JavaThread*)thread)->jvmti_thread_state(); diff --git a/src/share/vm/prims/jvmtiRedefineClasses.cpp b/src/share/vm/prims/jvmtiRedefineClasses.cpp --- a/src/share/vm/prims/jvmtiRedefineClasses.cpp +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp @@ -1674,10 +1674,10 @@ // We cache a pointer to the bytecodes here in code_base. If GC // moves the Method*, then the bytecodes will also move which - // will likely cause a crash. We create a No_Safepoint_Verifier + // will likely cause a crash. We create a NoSafepointVerifier // object to detect whether we pass a possible safepoint in this // code block. - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; // Bytecodes and their length address code_base = method->code_base(); @@ -1735,7 +1735,7 @@ Relocator rc(method, NULL /* no RelocatorListener needed */); methodHandle m; { - Pause_No_Safepoint_Verifier pnsv(&nsv); + PauseNoSafepointVerifier pnsv(&nsv); // ldc is 2 bytes and ldc_w is 3 bytes m = rc.insert_space_at(bci, 3, inst_buffer, CHECK); diff --git a/src/share/vm/prims/jvmtiThreadState.cpp b/src/share/vm/prims/jvmtiThreadState.cpp --- a/src/share/vm/prims/jvmtiThreadState.cpp +++ b/src/share/vm/prims/jvmtiThreadState.cpp @@ -86,7 +86,7 @@ { // The thread state list manipulation code must not have safepoints. // See periodic_clean_up(). - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) _prev = NULL; _next = _head; @@ -123,7 +123,7 @@ { // The thread state list manipulation code must not have safepoints. // See periodic_clean_up(). - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) if (_prev == NULL) { assert(_head == this, "sanity check"); @@ -147,7 +147,7 @@ // This iteration is initialized with "_head" instead of "JvmtiThreadState::first()" // because the latter requires the JvmtiThreadState_lock. - // This iteration is safe at a safepoint as well, see the No_Safepoint_Verifier + // This iteration is safe at a safepoint as well, see the NoSafepointVerifier // asserts at all list manipulation sites. for (JvmtiThreadState *state = _head; state != NULL; state = state->next()) { // For each environment thread state corresponding to an invalid environment @@ -182,7 +182,7 @@ // add this environment thread state to the end of the list (order is important) { // list deallocation (which occurs at a safepoint) cannot occur simultaneously - debug_only(No_Safepoint_Verifier nosafepoint;) + debug_only(NoSafepointVerifier nosafepoint;) JvmtiEnvThreadStateIterator it(this); JvmtiEnvThreadState* previous_ets = NULL; diff --git a/src/share/vm/prims/methodHandles.cpp b/src/share/vm/prims/methodHandles.cpp --- a/src/share/vm/prims/methodHandles.cpp +++ b/src/share/vm/prims/methodHandles.cpp @@ -981,7 +981,7 @@ int marked = 0; CallSiteDepChange changes(call_site(), target()); { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; MutexLockerEx mu2(CodeCache_lock, Mutex::_no_safepoint_check_flag); oop context = java_lang_invoke_CallSite::context(call_site()); @@ -1339,7 +1339,7 @@ int marked = 0; { - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; MutexLockerEx mu2(CodeCache_lock, Mutex::_no_safepoint_check_flag); assert(safe_to_expunge(), "removal is not safe"); DependencyContext deps = java_lang_invoke_MethodHandleNatives_CallSiteContext::vmdependencies(context()); diff --git a/src/share/vm/runtime/arguments.cpp b/src/share/vm/runtime/arguments.cpp --- a/src/share/vm/runtime/arguments.cpp +++ b/src/share/vm/runtime/arguments.cpp @@ -1675,16 +1675,16 @@ // OldPLAB sizing manually turned off: Use a larger default setting, // unless it was manually specified. This is because a too-low value // will slow down scavenges. - FLAG_SET_ERGO(size_t, OldPLABSize, CFLS_LAB::_default_static_old_plab_size); // default value before 6631166 + FLAG_SET_ERGO(size_t, OldPLABSize, CompactibleFreeListSpaceLAB::_default_static_old_plab_size); // default value before 6631166 } else { - FLAG_SET_DEFAULT(OldPLABSize, CFLS_LAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default + FLAG_SET_DEFAULT(OldPLABSize, CompactibleFreeListSpaceLAB::_default_dynamic_old_plab_size); // old CMSParPromoteBlocksToClaim default } } // If either of the static initialization defaults have changed, note this // modification. if (!FLAG_IS_DEFAULT(OldPLABSize) || !FLAG_IS_DEFAULT(OldPLABWeight)) { - CFLS_LAB::modify_initialization(OldPLABSize, OldPLABWeight); + CompactibleFreeListSpaceLAB::modify_initialization(OldPLABSize, OldPLABWeight); } if (!ClassUnloading) { diff --git a/src/share/vm/runtime/deoptimization.cpp b/src/share/vm/runtime/deoptimization.cpp --- a/src/share/vm/runtime/deoptimization.cpp +++ b/src/share/vm/runtime/deoptimization.cpp @@ -296,7 +296,7 @@ // Ensure that no safepoint is taken after pointers have been stored // in fields of rematerialized objects. If a safepoint occurs from here on // out the java state residing in the vframeArray will be missed. - No_Safepoint_Verifier no_safepoint; + NoSafepointVerifier no_safepoint; vframeArray* array = create_vframeArray(thread, deoptee, &map, chunk, realloc_failures); #if defined(COMPILER2) || INCLUDE_JVMCI diff --git a/src/share/vm/runtime/globals.hpp b/src/share/vm/runtime/globals.hpp --- a/src/share/vm/runtime/globals.hpp +++ b/src/share/vm/runtime/globals.hpp @@ -883,7 +883,7 @@ \ notproduct(bool, StrictSafepointChecks, trueInDebug, \ "Enable strict checks that safepoints cannot happen for threads " \ - "that use No_Safepoint_Verifier") \ + "that use NoSafepointVerifier") \ \ notproduct(bool, VerifyLastFrame, false, \ "Verify oops on last frame on entry to VM") \ diff --git a/src/share/vm/runtime/interfaceSupport.hpp b/src/share/vm/runtime/interfaceSupport.hpp --- a/src/share/vm/runtime/interfaceSupport.hpp +++ b/src/share/vm/runtime/interfaceSupport.hpp @@ -451,7 +451,7 @@ #define IRT_LEAF(result_type, header) \ result_type header { \ VM_LEAF_BASE(result_type, header) \ - debug_only(No_Safepoint_Verifier __nspv(true);) + debug_only(NoSafepointVerifier __nspv(true);) #define IRT_ENTRY_NO_ASYNC(result_type, header) \ @@ -475,7 +475,7 @@ #define JRT_LEAF(result_type, header) \ result_type header { \ VM_LEAF_BASE(result_type, header) \ - debug_only(JRT_Leaf_Verifier __jlv;) + debug_only(JRTLeafVerifier __jlv;) #define JRT_ENTRY_NO_ASYNC(result_type, header) \ diff --git a/src/share/vm/runtime/safepoint.cpp b/src/share/vm/runtime/safepoint.cpp --- a/src/share/vm/runtime/safepoint.cpp +++ b/src/share/vm/runtime/safepoint.cpp @@ -363,7 +363,7 @@ #endif // ASSERT // Update the count of active JNI critical regions - GC_locker::set_jni_lock_count(_current_jni_active_count); + GCLocker::set_jni_lock_count(_current_jni_active_count); if (log_is_enabled(Debug, safepoint)) { VM_Operation *op = VMThread::vm_operation(); @@ -563,7 +563,7 @@ if (!thread->do_critical_native_unlock()) { #ifdef ASSERT if (!thread->in_critical()) { - GC_locker::increment_debug_jni_lock_count(); + GCLocker::increment_debug_jni_lock_count(); } #endif thread->enter_critical(); diff --git a/src/share/vm/runtime/sharedRuntime.cpp b/src/share/vm/runtime/sharedRuntime.cpp --- a/src/share/vm/runtime/sharedRuntime.cpp +++ b/src/share/vm/runtime/sharedRuntime.cpp @@ -2742,8 +2742,8 @@ return; } // Lock and unlock a critical section to give the system a chance to block - GC_locker::lock_critical(thread); - GC_locker::unlock_critical(thread); + GCLocker::lock_critical(thread); + GCLocker::unlock_critical(thread); JRT_END // ------------------------------------------------------------------------- diff --git a/src/share/vm/runtime/synchronizer.cpp b/src/share/vm/runtime/synchronizer.cpp --- a/src/share/vm/runtime/synchronizer.cpp +++ b/src/share/vm/runtime/synchronizer.cpp @@ -159,7 +159,7 @@ assert(!SafepointSynchronize::is_at_safepoint(), "invariant"); assert(self->is_Java_thread(), "invariant"); assert(((JavaThread *) self)->thread_state() == _thread_in_Java, "invariant"); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; if (obj == NULL) return false; // slow-path for invalid obj const markOop mark = obj->mark(); @@ -209,7 +209,7 @@ assert(!SafepointSynchronize::is_at_safepoint(), "invariant"); assert(Self->is_Java_thread(), "invariant"); assert(((JavaThread *) Self)->thread_state() == _thread_in_Java, "invariant"); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; if (obj == NULL) return false; // Need to throw NPE const markOop mark = obj->mark(); @@ -1734,7 +1734,7 @@ void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) { assert(THREAD == JavaThread::current(), "must be current Java thread"); - No_Safepoint_Verifier nsv; + NoSafepointVerifier nsv; ReleaseJavaMonitorsClosure rjmc(THREAD); Thread::muxAcquire(&gListLock, "release_monitors_owned_by_thread"); ObjectSynchronizer::monitors_iterate(&rjmc); diff --git a/src/share/vm/runtime/thread.cpp b/src/share/vm/runtime/thread.cpp --- a/src/share/vm/runtime/thread.cpp +++ b/src/share/vm/runtime/thread.cpp @@ -2440,7 +2440,7 @@ // normal checks but also performs the transition back into // thread_in_Java state. This is required so that critical natives // can potentially block and perform a GC if they are the last thread -// exiting the GC_locker. +// exiting the GCLocker. void JavaThread::check_special_condition_for_native_trans_and_transition(JavaThread *thread) { check_special_condition_for_native_trans(thread); @@ -2449,7 +2449,7 @@ if (thread->do_critical_native_unlock()) { ThreadInVMfromJavaNoAsyncException tiv(thread); - GC_locker::unlock_critical(thread); + GCLocker::unlock_critical(thread); thread->clear_critical_native_unlock(); } } diff --git a/src/share/vm/runtime/thread.hpp b/src/share/vm/runtime/thread.hpp --- a/src/share/vm/runtime/thread.hpp +++ b/src/share/vm/runtime/thread.hpp @@ -255,7 +255,7 @@ // If !allow_allocation(), then an assertion failure will happen during allocation // (Hence, !allow_safepoint() => !allow_allocation()). // - // The two classes No_Safepoint_Verifier and No_Allocation_Verifier are used to set these counters. + // The two classes NoSafepointVerifier and No_Allocation_Verifier are used to set these counters. // NOT_PRODUCT(int _allow_safepoint_count;) // If 0, thread allow a safepoint to happen debug_only(int _allow_allocation_count;) // If 0, the thread is allowed to allocate oops. @@ -263,10 +263,10 @@ // Used by SkipGCALot class. NOT_PRODUCT(bool _skip_gcalot;) // Should we elide gc-a-lot? - friend class No_Alloc_Verifier; - friend class No_Safepoint_Verifier; - friend class Pause_No_Safepoint_Verifier; - friend class GC_locker; + friend class NoAllocVerifier; + friend class NoSafepointVerifier; + friend class PauseNoSafepointVerifier; + friend class GCLocker; ThreadLocalAllocBuffer _tlab; // Thread-local eden jlong _allocated_bytes; // Cumulative number of bytes allocated on diff --git a/src/share/vm/runtime/vmStructs.cpp b/src/share/vm/runtime/vmStructs.cpp --- a/src/share/vm/runtime/vmStructs.cpp +++ b/src/share/vm/runtime/vmStructs.cpp @@ -503,7 +503,7 @@ /* Generation and Space hierarchies */ \ /**********************************************************************************/ \ \ - unchecked_nonstatic_field(ageTable, sizes, sizeof(ageTable::sizes)) \ + unchecked_nonstatic_field(AgeTable, sizes, sizeof(AgeTable::sizes)) \ \ nonstatic_field(BarrierSet, _fake_rtti, BarrierSet::FakeRtti) \ \ @@ -560,7 +560,7 @@ \ nonstatic_field(DefNewGeneration, _old_gen, Generation*) \ nonstatic_field(DefNewGeneration, _tenuring_threshold, uint) \ - nonstatic_field(DefNewGeneration, _age_table, ageTable) \ + nonstatic_field(DefNewGeneration, _age_table, AgeTable) \ nonstatic_field(DefNewGeneration, _eden_space, ContiguousSpace*) \ nonstatic_field(DefNewGeneration, _from_space, ContiguousSpace*) \ nonstatic_field(DefNewGeneration, _to_space, ContiguousSpace*) \ @@ -1600,7 +1600,7 @@ \ /* Miscellaneous other GC types */ \ \ - declare_toplevel_type(ageTable) \ + declare_toplevel_type(AgeTable) \ declare_toplevel_type(Generation::StatRecord) \ declare_toplevel_type(GenerationSpec) \ declare_toplevel_type(HeapWord) \ @@ -2310,7 +2310,7 @@ /* Generation and Space Hierarchy Constants */ \ /********************************************/ \ \ - declare_constant(ageTable::table_size) \ + declare_constant(AgeTable::table_size) \ \ declare_constant(BarrierSet::ModRef) \ declare_constant(BarrierSet::CardTableModRef) \ diff --git a/src/share/vm/services/heapDumper.cpp b/src/share/vm/services/heapDumper.cpp --- a/src/share/vm/services/heapDumper.cpp +++ b/src/share/vm/services/heapDumper.cpp @@ -1708,10 +1708,10 @@ CollectedHeap* ch = Universe::heap(); ch->ensure_parsability(false); // must happen, even if collection does - // not happen (e.g. due to GC_locker) + // not happen (e.g. due to GCLocker) if (_gc_before_heap_dump) { - if (GC_locker::is_active()) { + if (GCLocker::is_active()) { warning("GC locker is held; pre-heapdump GC was skipped"); } else { ch->collect_as_vm_thread(GCCause::_heap_dump);