Mercurial > hg > jdk9-shenandoah > hotspot
changeset 9753:82e2de7b5401
Merge
line wrap: on
line diff
--- a/.hgtags Tue Sep 29 16:51:31 2015 +0200 +++ b/.hgtags Tue Sep 29 18:47:52 2015 +0200 @@ -484,3 +484,6 @@ 20dc06b04fe5ec373879414d60ef82ac70faef98 jdk9-b78 e9e63d93bbfe2c6c23447e2c1f5cc71c98671cba jdk9-b79 8e8377739c06b99b9011c003c77e0bef84c91e09 jdk9-b80 +4142c190cd5ca4fb70ec367b4f97ef936272d8ef jdk9-b81 +1c453a12be3036d482abef1dd470f8aff536b6b9 jdk9-b82 +3ed0df2c553a80e0e26b91a6ce08806ea17a066a jdk9-b83
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/Address.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/Address.java Tue Sep 29 18:47:52 2015 +0200 @@ -209,4 +209,7 @@ returns the result as an Address. Returns null if the result was zero. */ public Address xorWithMask(long mask) throws UnsupportedOperationException; + + // return address as long integer. + public long asLongValue(); }
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/bsd/BsdAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -288,7 +288,7 @@ return new BsdAddress(debugger, value); } - + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point //
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/dummy/DummyAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/dummy/DummyAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -275,6 +275,7 @@ return new DummyAddress(debugger, value); } + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point //
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -288,6 +288,7 @@ return new LinuxAddress(debugger, value); } + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -283,7 +283,7 @@ return new ProcAddress(debugger, value); } - + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point //
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -281,7 +281,7 @@ return new RemoteAddress(debugger, value); } - + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point //
--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgAddress.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgAddress.java Tue Sep 29 18:47:52 2015 +0200 @@ -292,6 +292,7 @@ return new WindbgAddress(debugger, value); } + public long asLongValue() { return addr; } //-------------------------------------------------------------------------------- // Internals only below this point
--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Symbol.java Tue Sep 29 16:51:31 2015 +0200 +++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Symbol.java Tue Sep 29 18:47:52 2015 +0200 @@ -80,10 +80,19 @@ public byte getByteAt(long index) { return addr.getJByteAt(baseOffset + index); } - + // _identity_hash is a short private static CIntegerField idHash; - public int identityHash() { return (int)idHash.getValue(this.addr); } + public int identityHash() { + long addr_value = getAddress().asLongValue(); + int addr_bits = (int)(addr_value >> (VM.getVM().getLogMinObjAlignmentInBytes() + 3)); + int length = (int)getLength(); + int byte0 = getByteAt(0); + int byte1 = getByteAt(1); + int id_hash = (int)(0xffff & idHash.getValue(this.addr)); + return id_hash | + ((addr_bits ^ (length << 8) ^ ((byte0 << 8) | byte1)) << 16); + } public boolean equals(byte[] modUTF8Chars) { int l = (int) getLength();
--- a/make/Makefile Tue Sep 29 16:51:31 2015 +0200 +++ b/make/Makefile Tue Sep 29 18:47:52 2015 +0200 @@ -633,9 +633,9 @@ update_jdk: export_product_jdk export_fastdebug_jdk test_jdk -copy_jdk: $(JDK_IMAGE_DIR)/jre/lib/rt.jar +copy_jdk: $(JDK_IMAGE_DIR)/bin/java -$(JDK_IMAGE_DIR)/jre/lib/rt.jar: +$(JDK_IMAGE_DIR)/bin/java: $(RM) -r $(JDK_IMAGE_DIR) $(MKDIR) -p $(JDK_IMAGE_DIR) ($(CD) $(JDK_IMPORT_PATH) && \
--- a/make/aix/makefiles/mapfile-vers-debug Tue Sep 29 16:51:31 2015 +0200 +++ b/make/aix/makefiles/mapfile-vers-debug Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/aix/makefiles/mapfile-vers-product Tue Sep 29 16:51:31 2015 +0200 +++ b/make/aix/makefiles/mapfile-vers-product Tue Sep 29 18:47:52 2015 +0200 @@ -139,18 +139,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/bsd/makefiles/mapfile-vers-darwin-debug Tue Sep 29 16:51:31 2015 +0200 +++ b/make/bsd/makefiles/mapfile-vers-darwin-debug Tue Sep 29 18:47:52 2015 +0200 @@ -139,18 +139,6 @@ _JVM_Halt _JVM_HoldsLock _JVM_IHashCode - _JVM_ImageAttributeOffsets - _JVM_ImageAttributeOffsetsLength - _JVM_ImageClose - _JVM_ImageFindAttributes - _JVM_ImageGetAttributes - _JVM_ImageGetAttributesCount - _JVM_ImageGetDataAddress - _JVM_ImageGetIndexAddress - _JVM_ImageGetStringBytes - _JVM_ImageOpen - _JVM_ImageRead - _JVM_ImageReadCompressed _JVM_InitAgentProperties _JVM_InitProperties _JVM_InternString
--- a/make/bsd/makefiles/mapfile-vers-darwin-product Tue Sep 29 16:51:31 2015 +0200 +++ b/make/bsd/makefiles/mapfile-vers-darwin-product Tue Sep 29 18:47:52 2015 +0200 @@ -139,18 +139,6 @@ _JVM_Halt _JVM_HoldsLock _JVM_IHashCode - _JVM_ImageAttributeOffsets - _JVM_ImageAttributeOffsetsLength - _JVM_ImageClose - _JVM_ImageFindAttributes - _JVM_ImageGetAttributes - _JVM_ImageGetAttributesCount - _JVM_ImageGetDataAddress - _JVM_ImageGetIndexAddress - _JVM_ImageGetStringBytes - _JVM_ImageOpen - _JVM_ImageRead - _JVM_ImageReadCompressed _JVM_InitAgentProperties _JVM_InitProperties _JVM_InternString
--- a/make/bsd/makefiles/mapfile-vers-debug Tue Sep 29 16:51:31 2015 +0200 +++ b/make/bsd/makefiles/mapfile-vers-debug Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/bsd/makefiles/mapfile-vers-product Tue Sep 29 16:51:31 2015 +0200 +++ b/make/bsd/makefiles/mapfile-vers-product Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/bsd/makefiles/vm.make Tue Sep 29 16:51:31 2015 +0200 +++ b/make/bsd/makefiles/vm.make Tue Sep 29 18:47:52 2015 +0200 @@ -131,7 +131,7 @@ # By default, link the *.o into the library, not the executable. LINK_INTO$(LINK_INTO) = LIBJVM -JDK_LIBDIR = $(JAVA_HOME)/jre/lib/$(LIBARCH) +JDK_LIBDIR = $(JAVA_HOME)/lib/$(LIBARCH) #---------------------------------------------------------------------- # jvm_db & dtrace
--- a/make/build.sh Tue Sep 29 16:51:31 2015 +0200 +++ b/make/build.sh Tue Sep 29 18:47:52 2015 +0200 @@ -49,7 +49,7 @@ # Just in case: JAVA_HOME=`( cd $JAVA_HOME; pwd )` -if [ "${ALT_BOOTDIR-}" = "" -o ! -d "${ALT_BOOTDIR-}" -o ! -d ${ALT_BOOTDIR-}/jre/lib/ ]; then +if [ "${ALT_BOOTDIR-}" = "" -o ! -d "${ALT_BOOTDIR-}" -o ! -d ${ALT_BOOTDIR-}/lib/ ]; then ALT_BOOTDIR=${JAVA_HOME} fi
--- a/make/hotspot.script Tue Sep 29 16:51:31 2015 +0200 +++ b/make/hotspot.script Tue Sep 29 18:47:52 2015 +0200 @@ -127,7 +127,7 @@ # o $JRE/lib/$ARCH # followed by the user's previous effective LD_LIBRARY_PATH, if # any. -JRE=$JDK/jre +JRE=$JDK JAVA_HOME=$JDK export JAVA_HOME
--- a/make/linux/makefiles/mapfile-vers-debug Tue Sep 29 16:51:31 2015 +0200 +++ b/make/linux/makefiles/mapfile-vers-debug Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/linux/makefiles/mapfile-vers-product Tue Sep 29 16:51:31 2015 +0200 +++ b/make/linux/makefiles/mapfile-vers-product Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/solaris/makefiles/adlc.make Tue Sep 29 16:51:31 2015 +0200 +++ b/make/solaris/makefiles/adlc.make Tue Sep 29 18:47:52 2015 +0200 @@ -76,6 +76,11 @@ ifeq ($(shell expr $(COMPILER_REV_NUMERIC) \>= 509), 1) CFLAGS_WARN = +w -errwarn endif +# When using compiler version 5.13 (Solaris Studio 12.4), calls to explicitly +# instantiated template functions trigger this warning when +w is active. +ifeq ($(shell expr $(COMPILER_REV_NUMERIC) \>= 513), 1) + CFLAGS_WARN += -erroff=notemsource +endif CFLAGS += $(CFLAGS_WARN) ifeq ("${Platform_compiler}", "sparcWorks")
--- a/make/solaris/makefiles/buildtree.make Tue Sep 29 16:51:31 2015 +0200 +++ b/make/solaris/makefiles/buildtree.make Tue Sep 29 18:47:52 2015 +0200 @@ -270,6 +270,7 @@ echo "CP ?= cp"; \ echo "MV ?= mv"; \ echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(VARIANT).make"; \ + echo "include \$$(GAMMADIR)/make/excludeSrc.make"; \ echo "include \$$(GAMMADIR)/make/$(OS_FAMILY)/makefiles/$(COMPILER).make"; \ ) > $@
--- a/make/solaris/makefiles/mapfile-vers Tue Sep 29 16:51:31 2015 +0200 +++ b/make/solaris/makefiles/mapfile-vers Tue Sep 29 18:47:52 2015 +0200 @@ -141,18 +141,6 @@ JVM_Halt; JVM_HoldsLock; JVM_IHashCode; - JVM_ImageAttributeOffsets; - JVM_ImageAttributeOffsetsLength; - JVM_ImageClose; - JVM_ImageFindAttributes; - JVM_ImageGetAttributes; - JVM_ImageGetAttributesCount; - JVM_ImageGetDataAddress; - JVM_ImageGetIndexAddress; - JVM_ImageGetStringBytes; - JVM_ImageOpen; - JVM_ImageRead; - JVM_ImageReadCompressed; JVM_InitAgentProperties; JVM_InitProperties; JVM_InternString;
--- a/make/solaris/makefiles/vm.make Tue Sep 29 16:51:31 2015 +0200 +++ b/make/solaris/makefiles/vm.make Tue Sep 29 18:47:52 2015 +0200 @@ -197,7 +197,7 @@ Src_Dirs/COMPILER2 := $(CORE_PATHS) $(COMPILER2_PATHS) Src_Dirs/TIERED := $(CORE_PATHS) $(COMPILER1_PATHS) $(COMPILER2_PATHS) Src_Dirs/ZERO := $(CORE_PATHS) -Src_Dirs/SHARK := $(CORE_PATHS) +Src_Dirs/SHARK := $(CORE_PATHS) $(SHARK_PATHS) Src_Dirs := $(Src_Dirs/$(TYPE)) COMPILER2_SPECIFIC_FILES := opto libadt bcEscapeAnalyzer.cpp c2_\* runtime_\* @@ -206,7 +206,7 @@ ZERO_SPECIFIC_FILES := zero # Always exclude these. -Src_Files_EXCLUDE := dtrace jsig.c jvmtiEnvRecommended.cpp jvmtiEnvStub.cpp +Src_Files_EXCLUDE += dtrace jsig.c jvmtiEnvRecommended.cpp jvmtiEnvStub.cpp # Exclude per type. Src_Files_EXCLUDE/CORE := $(COMPILER1_SPECIFIC_FILES) $(COMPILER2_SPECIFIC_FILES) $(ZERO_SPECIFIC_FILES) $(SHARK_SPECIFIC_FILES) ciTypeFlow.cpp
--- a/src/cpu/aarch64/vm/aarch64.ad Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/aarch64.ad Tue Sep 29 18:47:52 2015 +0200 @@ -1033,27 +1033,39 @@ }; // graph traversal helpers - MemBarNode *has_parent_membar(const Node *n, - ProjNode *&ctl, ProjNode *&mem); - MemBarNode *has_child_membar(const MemBarNode *n, - ProjNode *&ctl, ProjNode *&mem); + + MemBarNode *parent_membar(const Node *n); + MemBarNode *child_membar(const MemBarNode *n); + bool leading_membar(const MemBarNode *barrier); + + bool is_card_mark_membar(const MemBarNode *barrier); + + MemBarNode *leading_to_normal(MemBarNode *leading); + MemBarNode *normal_to_leading(const MemBarNode *barrier); + MemBarNode *card_mark_to_trailing(const MemBarNode *barrier); + MemBarNode *trailing_to_card_mark(const MemBarNode *trailing); + MemBarNode *trailing_to_leading(const MemBarNode *trailing); // predicates controlling emit of ldr<x>/ldar<x> and associated dmb + bool unnecessary_acquire(const Node *barrier); bool needs_acquiring_load(const Node *load); // predicates controlling emit of str<x>/stlr<x> and associated dmbs + bool unnecessary_release(const Node *barrier); bool unnecessary_volatile(const Node *barrier); bool needs_releasing_store(const Node *store); - // Use barrier instructions for unsafe volatile gets rather than - // trying to identify an exact signature for them - const bool UseBarriersForUnsafeVolatileGet = false; + // predicate controlling translation of StoreCM + bool unnecessary_storestore(const Node *storecm); %} source %{ + // Optimizaton of volatile gets and puts + // ------------------------------------- + // // AArch64 has ldar<x> and stlr<x> instructions which we can safely // use to implement volatile reads and writes. For a volatile read // we simply need @@ -1102,15 +1114,19 @@ // A volatile write is translated to the node sequence // // MemBarRelease - // StoreX[mo_release] + // StoreX[mo_release] {CardMark}-optional // MemBarVolatile // // n.b. the above node patterns are generated with a strict // 'signature' configuration of input and output dependencies (see - // the predicates below for exact details). The two signatures are - // unique to translated volatile reads/stores -- they will not - // appear as a result of any other bytecode translation or inlining - // nor as a consequence of optimizing transforms. + // the predicates below for exact details). The card mark may be as + // simple as a few extra nodes or, in a few GC configurations, may + // include more complex control flow between the leading and + // trailing memory barriers. However, whatever the card mark + // configuration these signatures are unique to translated volatile + // reads/stores -- they will not appear as a result of any other + // bytecode translation or inlining nor as a consequence of + // optimizing transforms. // // We also want to catch inlined unsafe volatile gets and puts and // be able to implement them using either ldar<x>/stlr<x> or some @@ -1122,7 +1138,7 @@ // // MemBarRelease // MemBarCPUOrder - // StoreX[mo_release] + // StoreX[mo_release] {CardMark}-optional // MemBarVolatile // // n.b. as an aside, the cpuorder membar is not itself subject to @@ -1130,7 +1146,7 @@ // predicates need to detect its presence in order to correctly // select the desired adlc rules. // - // Inlined unsafe volatiles gets manifest as a somewhat different + // Inlined unsafe volatile gets manifest as a somewhat different // node sequence to a normal volatile get // // MemBarCPUOrder @@ -1173,33 +1189,22 @@ // n.b. the translation rules below which rely on detection of the // volatile signatures and insert ldar<x> or stlr<x> are failsafe. // If we see anything other than the signature configurations we - // always just translate the loads and stors to ldr<x> and str<x> + // always just translate the loads and stores to ldr<x> and str<x> // and translate acquire, release and volatile membars to the // relevant dmb instructions. // - // n.b.b as a case in point for the above comment, the current - // predicates don't detect the precise signature for certain types - // of volatile object stores (where the heap_base input type is not - // known at compile-time to be non-NULL). In those cases the - // MemBarRelease and MemBarVolatile bracket an if-then-else sequence - // with a store in each branch (we need a different store depending - // on whether heap_base is actually NULL). In such a case we will - // just plant a dmb both before and after the branch/merge. The - // predicate could (and probably should) be fixed later to also - // detect this case. - - // graph traversal helpers + + // graph traversal helpers used for volatile put/get optimization + + // 1) general purpose helpers // if node n is linked to a parent MemBarNode by an intervening - // Control or Memory ProjNode return the MemBarNode otherwise return + // Control and Memory ProjNode return the MemBarNode otherwise return // NULL. // // n may only be a Load or a MemBar. - // - // The ProjNode* references c and m are used to return the relevant - // nodes. - - MemBarNode *has_parent_membar(const Node *n, ProjNode *&c, ProjNode *&m) + + MemBarNode *parent_membar(const Node *n) { Node *ctl = NULL; Node *mem = NULL; @@ -1218,15 +1223,11 @@ if (!ctl || !mem || !ctl->is_Proj() || !mem->is_Proj()) return NULL; - c = ctl->as_Proj(); - membar = ctl->lookup(0); if (!membar || !membar->is_MemBar()) return NULL; - m = mem->as_Proj(); - if (mem->lookup(0) != membar) return NULL; @@ -1235,12 +1236,8 @@ // if n is linked to a child MemBarNode by intervening Control and // Memory ProjNodes return the MemBarNode otherwise return NULL. - // - // The ProjNode** arguments c and m are used to return pointers to - // the relevant nodes. A null argument means don't don't return a - // value. - - MemBarNode *has_child_membar(const MemBarNode *n, ProjNode *&c, ProjNode *&m) + + MemBarNode *child_membar(const MemBarNode *n) { ProjNode *ctl = n->proj_out(TypeFunc::Control); ProjNode *mem = n->proj_out(TypeFunc::Memory); @@ -1249,9 +1246,6 @@ if (! ctl || ! mem) return NULL; - c = ctl; - m = mem; - MemBarNode *child = NULL; Node *x; @@ -1279,9 +1273,838 @@ return NULL; } + // helper predicate use to filter candidates for a leading memory + // barrier + // + // returns true if barrier is a MemBarRelease or a MemBarCPUOrder + // whose Ctl and Mem feeds come from a MemBarRelease otherwise false + + bool leading_membar(const MemBarNode *barrier) + { + int opcode = barrier->Opcode(); + // if this is a release membar we are ok + if (opcode == Op_MemBarRelease) + return true; + // if its a cpuorder membar . . . + if (opcode != Op_MemBarCPUOrder) + return false; + // then the parent has to be a release membar + MemBarNode *parent = parent_membar(barrier); + if (!parent) + return false; + opcode = parent->Opcode(); + return opcode == Op_MemBarRelease; + } + + // 2) card mark detection helper + + // helper predicate which can be used to detect a volatile membar + // introduced as part of a conditional card mark sequence either by + // G1 or by CMS when UseCondCardMark is true. + // + // membar can be definitively determined to be part of a card mark + // sequence if and only if all the following hold + // + // i) it is a MemBarVolatile + // + // ii) either UseG1GC or (UseConcMarkSweepGC && UseCondCardMark) is + // true + // + // iii) the node's Mem projection feeds a StoreCM node. + + bool is_card_mark_membar(const MemBarNode *barrier) + { + if (!UseG1GC && !(UseConcMarkSweepGC && UseCondCardMark)) + return false; + + if (barrier->Opcode() != Op_MemBarVolatile) + return false; + + ProjNode *mem = barrier->proj_out(TypeFunc::Memory); + + for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax ; i++) { + Node *y = mem->fast_out(i); + if (y->Opcode() == Op_StoreCM) { + return true; + } + } + + return false; + } + + + // 3) helper predicates to traverse volatile put graphs which may + // contain GC barrier subgraphs + + // Preamble + // -------- + // + // for volatile writes we can omit generating barriers and employ a + // releasing store when we see a node sequence sequence with a + // leading MemBarRelease and a trailing MemBarVolatile as follows + // + // MemBarRelease + // { || } -- optional + // {MemBarCPUOrder} + // || \\ + // || StoreX[mo_release] + // | \ / + // | MergeMem + // | / + // MemBarVolatile + // + // where + // || and \\ represent Ctl and Mem feeds via Proj nodes + // | \ and / indicate further routing of the Ctl and Mem feeds + // + // this is the graph we see for non-object stores. however, for a + // volatile Object store (StoreN/P) we may see other nodes below the + // leading membar because of the need for a GC pre- or post-write + // barrier. + // + // with most GC configurations we with see this simple variant which + // includes a post-write barrier card mark. + // + // MemBarRelease______________________________ + // || \\ Ctl \ \\ + // || StoreN/P[mo_release] CastP2X StoreB/CM + // | \ / . . . / + // | MergeMem + // | / + // || / + // MemBarVolatile + // + // i.e. the leading membar feeds Ctl to a CastP2X (which converts + // the object address to an int used to compute the card offset) and + // Ctl+Mem to a StoreB node (which does the actual card mark). + // + // n.b. a StoreCM node will only appear in this configuration when + // using CMS. StoreCM differs from a normal card mark write (StoreB) + // because it implies a requirement to order visibility of the card + // mark (StoreCM) relative to the object put (StoreP/N) using a + // StoreStore memory barrier (arguably this ought to be represented + // explicitly in the ideal graph but that is not how it works). This + // ordering is required for both non-volatile and volatile + // puts. Normally that means we need to translate a StoreCM using + // the sequence + // + // dmb ishst + // stlrb + // + // However, in the case of a volatile put if we can recognise this + // configuration and plant an stlr for the object write then we can + // omit the dmb and just plant an strb since visibility of the stlr + // is ordered before visibility of subsequent stores. StoreCM nodes + // also arise when using G1 or using CMS with conditional card + // marking. In these cases (as we shall see) we don't need to insert + // the dmb when translating StoreCM because there is already an + // intervening StoreLoad barrier between it and the StoreP/N. + // + // It is also possible to perform the card mark conditionally on it + // currently being unmarked in which case the volatile put graph + // will look slightly different + // + // MemBarRelease + // MemBarCPUOrder___________________________________________ + // || \\ Ctl \ Ctl \ \\ Mem \ + // || StoreN/P[mo_release] CastP2X If LoadB | + // | \ / \ | + // | MergeMem . . . StoreB + // | / / + // || / + // MemBarVolatile + // + // It is worth noting at this stage that both the above + // configurations can be uniquely identified by checking that the + // memory flow includes the following subgraph: + // + // MemBarRelease + // MemBarCPUOrder + // | \ . . . + // | StoreX[mo_release] . . . + // | / + // MergeMem + // | + // MemBarVolatile + // + // This is referred to as a *normal* subgraph. It can easily be + // detected starting from any candidate MemBarRelease, + // StoreX[mo_release] or MemBarVolatile. + // + // the code below uses two helper predicates, leading_to_normal and + // normal_to_leading to identify this configuration, one validating + // the layout starting from the top membar and searching down and + // the other validating the layout starting from the lower membar + // and searching up. + // + // There are two special case GC configurations when a normal graph + // may not be generated: when using G1 (which always employs a + // conditional card mark); and when using CMS with conditional card + // marking configured. These GCs are both concurrent rather than + // stop-the world GCs. So they introduce extra Ctl+Mem flow into the + // graph between the leading and trailing membar nodes, in + // particular enforcing stronger memory serialisation beween the + // object put and the corresponding conditional card mark. CMS + // employs a post-write GC barrier while G1 employs both a pre- and + // post-write GC barrier. Of course the extra nodes may be absent -- + // they are only inserted for object puts. This significantly + // complicates the task of identifying whether a MemBarRelease, + // StoreX[mo_release] or MemBarVolatile forms part of a volatile put + // when using these GC configurations (see below). + // + // In both cases the post-write subtree includes an auxiliary + // MemBarVolatile (StoreLoad barrier) separating the object put and + // the read of the corresponding card. This poses two additional + // problems. + // + // Firstly, a card mark MemBarVolatile needs to be distinguished + // from a normal trailing MemBarVolatile. Resolving this first + // problem is straightforward: a card mark MemBarVolatile always + // projects a Mem feed to a StoreCM node and that is a unique marker + // + // MemBarVolatile (card mark) + // C | \ . . . + // | StoreCM . . . + // . . . + // + // The second problem is how the code generator is to translate the + // card mark barrier? It always needs to be translated to a "dmb + // ish" instruction whether or not it occurs as part of a volatile + // put. A StoreLoad barrier is needed after the object put to ensure + // i) visibility to GC threads of the object put and ii) visibility + // to the mutator thread of any card clearing write by a GC + // thread. Clearly a normal store (str) will not guarantee this + // ordering but neither will a releasing store (stlr). The latter + // guarantees that the object put is visible but does not guarantee + // that writes by other threads have also been observed. + // + // So, returning to the task of translating the object put and the + // leading/trailing membar nodes: what do the non-normal node graph + // look like for these 2 special cases? and how can we determine the + // status of a MemBarRelease, StoreX[mo_release] or MemBarVolatile + // in both normal and non-normal cases? + // + // A CMS GC post-barrier wraps its card write (StoreCM) inside an If + // which selects conditonal execution based on the value loaded + // (LoadB) from the card. Ctl and Mem are fed to the If via an + // intervening StoreLoad barrier (MemBarVolatile). + // + // So, with CMS we may see a node graph which looks like this + // + // MemBarRelease + // MemBarCPUOrder_(leading)__________________ + // C | M \ \\ C \ + // | \ StoreN/P[mo_release] CastP2X + // | Bot \ / + // | MergeMem + // | / + // MemBarVolatile (card mark) + // C | || M | + // | LoadB | + // | | | + // | Cmp |\ + // | / | \ + // If | \ + // | \ | \ + // IfFalse IfTrue | \ + // \ / \ | \ + // \ / StoreCM | + // \ / | | + // Region . . . | + // | \ / + // | . . . \ / Bot + // | MergeMem + // | | + // MemBarVolatile (trailing) + // + // The first MergeMem merges the AliasIdxBot Mem slice from the + // leading membar and the oopptr Mem slice from the Store into the + // card mark membar. The trailing MergeMem merges the AliasIdxBot + // Mem slice from the card mark membar and the AliasIdxRaw slice + // from the StoreCM into the trailing membar (n.b. the latter + // proceeds via a Phi associated with the If region). + // + // G1 is quite a lot more complicated. The nodes inserted on behalf + // of G1 may comprise: a pre-write graph which adds the old value to + // the SATB queue; the releasing store itself; and, finally, a + // post-write graph which performs a card mark. + // + // The pre-write graph may be omitted, but only when the put is + // writing to a newly allocated (young gen) object and then only if + // there is a direct memory chain to the Initialize node for the + // object allocation. This will not happen for a volatile put since + // any memory chain passes through the leading membar. + // + // The pre-write graph includes a series of 3 If tests. The outermost + // If tests whether SATB is enabled (no else case). The next If tests + // whether the old value is non-NULL (no else case). The third tests + // whether the SATB queue index is > 0, if so updating the queue. The + // else case for this third If calls out to the runtime to allocate a + // new queue buffer. + // + // So with G1 the pre-write and releasing store subgraph looks like + // this (the nested Ifs are omitted). + // + // MemBarRelease (leading)____________ + // C | || M \ M \ M \ M \ . . . + // | LoadB \ LoadL LoadN \ + // | / \ \ + // If |\ \ + // | \ | \ \ + // IfFalse IfTrue | \ \ + // | | | \ | + // | If | /\ | + // | | \ | + // | \ | + // | . . . \ | + // | / | / | | + // Region Phi[M] | | + // | \ | | | + // | \_____ | ___ | | + // C | C \ | C \ M | | + // | CastP2X | StoreN/P[mo_release] | + // | | | | + // C | M | M | M | + // \ | | / + // . . . + // (post write subtree elided) + // . . . + // C \ M / + // MemBarVolatile (trailing) + // + // n.b. the LoadB in this subgraph is not the card read -- it's a + // read of the SATB queue active flag. + // + // The G1 post-write subtree is also optional, this time when the + // new value being written is either null or can be identified as a + // newly allocated (young gen) object with no intervening control + // flow. The latter cannot happen but the former may, in which case + // the card mark membar is omitted and the memory feeds from the + // leading membar and the StoreN/P are merged direct into the + // trailing membar as per the normal subgraph. So, the only special + // case which arises is when the post-write subgraph is generated. + // + // The kernel of the post-write G1 subgraph is the card mark itself + // which includes a card mark memory barrier (MemBarVolatile), a + // card test (LoadB), and a conditional update (If feeding a + // StoreCM). These nodes are surrounded by a series of nested Ifs + // which try to avoid doing the card mark. The top level If skips if + // the object reference does not cross regions (i.e. it tests if + // (adr ^ val) >> log2(regsize) != 0) -- intra-region references + // need not be recorded. The next If, which skips on a NULL value, + // may be absent (it is not generated if the type of value is >= + // OopPtr::NotNull). The 3rd If skips writes to young regions (by + // checking if card_val != young). n.b. although this test requires + // a pre-read of the card it can safely be done before the StoreLoad + // barrier. However that does not bypass the need to reread the card + // after the barrier. + // + // (pre-write subtree elided) + // . . . . . . . . . . . . + // C | M | M | M | + // Region Phi[M] StoreN | + // | / \ | | + // / \_______ / \ | | + // C / C \ . . . \ | | + // If CastP2X . . . | | | + // / \ | | | + // / \ | | | + // IfFalse IfTrue | | | + // | | | | /| + // | If | | / | + // | / \ | | / | + // | / \ \ | / | + // | IfFalse IfTrue MergeMem | + // | . . . / \ / | + // | / \ / | + // | IfFalse IfTrue / | + // | . . . | / | + // | If / | + // | / \ / | + // | / \ / | + // | IfFalse IfTrue / | + // | . . . | / | + // | \ / | + // | \ / | + // | MemBarVolatile__(card mark) | + // | || C | M \ M \ | + // | LoadB If | | | + // | / \ | | | + // | . . . | | | + // | \ | | / + // | StoreCM | / + // | . . . | / + // | _________/ / + // | / _____________/ + // | . . . . . . | / / + // | | | / _________/ + // | | Phi[M] / / + // | | | / / + // | | | / / + // | Region . . . Phi[M] _____/ + // | / | / + // | | / + // | . . . . . . | / + // | / | / + // Region | | Phi[M] + // | | | / Bot + // \ MergeMem + // \ / + // MemBarVolatile + // + // As with CMS the initial MergeMem merges the AliasIdxBot Mem slice + // from the leading membar and the oopptr Mem slice from the Store + // into the card mark membar i.e. the memory flow to the card mark + // membar still looks like a normal graph. + // + // The trailing MergeMem merges an AliasIdxBot Mem slice with other + // Mem slices (from the StoreCM and other card mark queue stores). + // However in this case the AliasIdxBot Mem slice does not come + // direct from the card mark membar. It is merged through a series + // of Phi nodes. These are needed to merge the AliasIdxBot Mem flow + // from the leading membar with the Mem feed from the card mark + // membar. Each Phi corresponds to one of the Ifs which may skip + // around the card mark membar. So when the If implementing the NULL + // value check has been elided the total number of Phis is 2 + // otherwise it is 3. + // + // So, the upshot is that in all cases the volatile put graph will + // include a *normal* memory subgraph betwen the leading membar and + // its child membar. When that child is not a card mark membar then + // it marks the end of a volatile put subgraph. If the child is a + // card mark membar then the normal subgraph will form part of a + // volatile put subgraph if and only if the child feeds an + // AliasIdxBot Mem feed to a trailing barrier via a MergeMem. That + // feed is either direct (for CMS) or via 2 or 3 Phi nodes merging + // the leading barrier memory flow (for G1). + // + // The predicates controlling generation of instructions for store + // and barrier nodes employ a few simple helper functions (described + // below) which identify the presence or absence of these subgraph + // configurations and provide a means of traversing from one node in + // the subgraph to another. + + // leading_to_normal + // + //graph traversal helper which detects the normal case Mem feed + // from a release membar (or, optionally, its cpuorder child) to a + // dependent volatile membar i.e. it ensures that the following Mem + // flow subgraph is present. + // + // MemBarRelease + // MemBarCPUOrder + // | \ . . . + // | StoreN/P[mo_release] . . . + // | / + // MergeMem + // | + // MemBarVolatile + // + // if the correct configuration is present returns the volatile + // membar otherwise NULL. + // + // the input membar is expected to be either a cpuorder membar or a + // release membar. in the latter case it should not have a cpu membar + // child. + // + // the returned membar may be a card mark membar rather than a + // trailing membar. + + MemBarNode *leading_to_normal(MemBarNode *leading) + { + assert((leading->Opcode() == Op_MemBarRelease || + leading->Opcode() == Op_MemBarCPUOrder), + "expecting a volatile or cpuroder membar!"); + + // check the mem flow + ProjNode *mem = leading->proj_out(TypeFunc::Memory); + + if (!mem) + return NULL; + + Node *x = NULL; + StoreNode * st = NULL; + MergeMemNode *mm = NULL; + + for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) { + x = mem->fast_out(i); + if (x->is_MergeMem()) { + if (mm != NULL) + return NULL; + // two merge mems is one too many + mm = x->as_MergeMem(); + } else if (x->is_Store() && x->as_Store()->is_release() && x->Opcode() != Op_StoreCM) { + // two releasing stores is one too many + if (st != NULL) + return NULL; + st = x->as_Store(); + } + } + + if (!mm || !st) + return NULL; + + bool found = false; + // ensure the store feeds the merge + for (DUIterator_Fast imax, i = st->fast_outs(imax); i < imax; i++) { + if (st->fast_out(i) == mm) { + found = true; + break; + } + } + + if (!found) + return NULL; + + MemBarNode *mbvol = NULL; + // ensure the merge feeds a volatile membar + for (DUIterator_Fast imax, i = mm->fast_outs(imax); i < imax; i++) { + x = mm->fast_out(i); + if (x->is_MemBar() && x->Opcode() == Op_MemBarVolatile) { + mbvol = x->as_MemBar(); + break; + } + } + + return mbvol; + } + + // normal_to_leading + // + // graph traversal helper which detects the normal case Mem feed + // from either a card mark or a trailing membar to a preceding + // release membar (optionally its cpuorder child) i.e. it ensures + // that the following Mem flow subgraph is present. + // + // MemBarRelease + // MemBarCPUOrder {leading} + // | \ . . . + // | StoreN/P[mo_release] . . . + // | / + // MergeMem + // | + // MemBarVolatile + // + // this predicate checks for the same flow as the previous predicate + // but starting from the bottom rather than the top. + // + // if the configuration is present returns the cpuorder member for + // preference or when absent the release membar otherwise NULL. + // + // n.b. the input membar is expected to be a MemBarVolatile but + // need not be a card mark membar. + + MemBarNode *normal_to_leading(const MemBarNode *barrier) + { + // input must be a volatile membar + assert(barrier->Opcode() == Op_MemBarVolatile, "expecting a volatile membar"); + Node *x; + + // the Mem feed to the membar should be a merge + x = barrier->in(TypeFunc::Memory); + if (!x->is_MergeMem()) + return NULL; + + MergeMemNode *mm = x->as_MergeMem(); + + // the AliasIdxBot slice should be another MemBar projection + x = mm->in(Compile::AliasIdxBot); + // ensure this is a non control projection + if (!x->is_Proj() || x->is_CFG()) + return NULL; + // if it is fed by a membar that's the one we want + x = x->in(0); + + if (!x->is_MemBar()) + return NULL; + + MemBarNode *leading = x->as_MemBar(); + // reject invalid candidates + if (!leading_membar(leading)) + return NULL; + + // ok, we have a leading ReleaseMembar, now for the sanity clauses + + // the leading membar must feed Mem to a releasing store + ProjNode *mem = leading->proj_out(TypeFunc::Memory); + StoreNode *st = NULL; + for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) { + x = mem->fast_out(i); + if (x->is_Store() && x->as_Store()->is_release() && x->Opcode() != Op_StoreCM) { + st = x->as_Store(); + break; + } + } + if (st == NULL) + return NULL; + + // the releasing store has to feed the same merge + for (DUIterator_Fast imax, i = st->fast_outs(imax); i < imax; i++) { + if (st->fast_out(i) == mm) + return leading; + } + + return NULL; + } + + // card_mark_to_trailing + // + // graph traversal helper which detects extra, non-normal Mem feed + // from a card mark volatile membar to a trailing membar i.e. it + // ensures that one of the following three GC post-write Mem flow + // subgraphs is present. + // + // 1) + // . . . + // | + // MemBarVolatile (card mark) + // | | + // | StoreCM + // | | + // | . . . + // Bot | / + // MergeMem + // | + // MemBarVolatile (trailing) + // + // + // 2) + // MemBarRelease/CPUOrder (leading) + // | + // | + // |\ . . . + // | \ | + // | \ MemBarVolatile (card mark) + // | \ | | + // \ \ | StoreCM . . . + // \ \ | + // \ Phi + // \ / + // Phi . . . + // Bot | / + // MergeMem + // | + // MemBarVolatile (trailing) + // + // 3) + // MemBarRelease/CPUOrder (leading) + // | + // |\ + // | \ + // | \ . . . + // | \ | + // |\ \ MemBarVolatile (card mark) + // | \ \ | | + // | \ \ | StoreCM . . . + // | \ \ | + // \ \ Phi + // \ \ / + // \ Phi + // \ / + // Phi . . . + // Bot | / + // MergeMem + // | + // MemBarVolatile (trailing) + // + // configuration 1 is only valid if UseConcMarkSweepGC && + // UseCondCardMark + // + // configurations 2 and 3 are only valid if UseG1GC. + // + // if a valid configuration is present returns the trailing membar + // otherwise NULL. + // + // n.b. the supplied membar is expected to be a card mark + // MemBarVolatile i.e. the caller must ensure the input node has the + // correct operand and feeds Mem to a StoreCM node + + MemBarNode *card_mark_to_trailing(const MemBarNode *barrier) + { + // input must be a card mark volatile membar + assert(is_card_mark_membar(barrier), "expecting a card mark membar"); + + Node *feed = barrier->proj_out(TypeFunc::Memory); + Node *x; + MergeMemNode *mm = NULL; + + const int MAX_PHIS = 3; // max phis we will search through + int phicount = 0; // current search count + + bool retry_feed = true; + while (retry_feed) { + // see if we have a direct MergeMem feed + for (DUIterator_Fast imax, i = feed->fast_outs(imax); i < imax; i++) { + x = feed->fast_out(i); + // the correct Phi will be merging a Bot memory slice + if (x->is_MergeMem()) { + mm = x->as_MergeMem(); + break; + } + } + if (mm) { + retry_feed = false; + } else if (UseG1GC & phicount++ < MAX_PHIS) { + // the barrier may feed indirectly via one or two Phi nodes + PhiNode *phi = NULL; + for (DUIterator_Fast imax, i = feed->fast_outs(imax); i < imax; i++) { + x = feed->fast_out(i); + // the correct Phi will be merging a Bot memory slice + if (x->is_Phi() && x->adr_type() == TypePtr::BOTTOM) { + phi = x->as_Phi(); + break; + } + } + if (!phi) + return NULL; + // look for another merge below this phi + feed = phi; + } else { + // couldn't find a merge + return NULL; + } + } + + // sanity check this feed turns up as the expected slice + assert(mm->as_MergeMem()->in(Compile::AliasIdxBot) == feed, "expecting membar to feed AliasIdxBot slice to Merge"); + + MemBarNode *trailing = NULL; + // be sure we have a volatile membar below the merge + for (DUIterator_Fast imax, i = mm->fast_outs(imax); i < imax; i++) { + x = mm->fast_out(i); + if (x->is_MemBar() && x->Opcode() == Op_MemBarVolatile) { + trailing = x->as_MemBar(); + break; + } + } + + return trailing; + } + + // trailing_to_card_mark + // + // graph traversal helper which detects extra, non-normal Mem feed + // from a trailing membar to a preceding card mark volatile membar + // i.e. it identifies whether one of the three possible extra GC + // post-write Mem flow subgraphs is present + // + // this predicate checks for the same flow as the previous predicate + // but starting from the bottom rather than the top. + // + // if the configurationis present returns the card mark membar + // otherwise NULL + + MemBarNode *trailing_to_card_mark(const MemBarNode *trailing) + { + assert(!is_card_mark_membar(trailing), "not expecting a card mark membar"); + + Node *x = trailing->in(TypeFunc::Memory); + // the Mem feed to the membar should be a merge + if (!x->is_MergeMem()) + return NULL; + + MergeMemNode *mm = x->as_MergeMem(); + + x = mm->in(Compile::AliasIdxBot); + // with G1 we may possibly see a Phi or two before we see a Memory + // Proj from the card mark membar + + const int MAX_PHIS = 3; // max phis we will search through + int phicount = 0; // current search count + + bool retry_feed = !x->is_Proj(); + + while (retry_feed) { + if (UseG1GC && x->is_Phi() && phicount++ < MAX_PHIS) { + PhiNode *phi = x->as_Phi(); + ProjNode *proj = NULL; + PhiNode *nextphi = NULL; + bool found_leading = false; + for (uint i = 1; i < phi->req(); i++) { + x = phi->in(i); + if (x->is_Phi()) { + nextphi = x->as_Phi(); + } else if (x->is_Proj()) { + int opcode = x->in(0)->Opcode(); + if (opcode == Op_MemBarVolatile) { + proj = x->as_Proj(); + } else if (opcode == Op_MemBarRelease || + opcode == Op_MemBarCPUOrder) { + // probably a leading membar + found_leading = true; + } + } + } + // if we found a correct looking proj then retry from there + // otherwise we must see a leading and a phi or this the + // wrong config + if (proj != NULL) { + x = proj; + retry_feed = false; + } else if (found_leading && nextphi != NULL) { + // retry from this phi to check phi2 + x = nextphi; + } else { + // not what we were looking for + return NULL; + } + } else { + return NULL; + } + } + // the proj has to come from the card mark membar + x = x->in(0); + if (!x->is_MemBar()) + return NULL; + + MemBarNode *card_mark_membar = x->as_MemBar(); + + if (!is_card_mark_membar(card_mark_membar)) + return NULL; + + return card_mark_membar; + } + + // trailing_to_leading + // + // graph traversal helper which checks the Mem flow up the graph + // from a (non-card mark) volatile membar attempting to locate and + // return an associated leading membar. it first looks for a + // subgraph in the normal configuration (relying on helper + // normal_to_leading). failing that it then looks for one of the + // possible post-write card mark subgraphs linking the trailing node + // to a the card mark membar (relying on helper + // trailing_to_card_mark), and then checks that the card mark membar + // is fed by a leading membar (once again relying on auxiliary + // predicate normal_to_leading). + // + // if the configuration is valid returns the cpuorder member for + // preference or when absent the release membar otherwise NULL. + // + // n.b. the input membar is expected to be a volatile membar but + // must *not* be a card mark membar. + + MemBarNode *trailing_to_leading(const MemBarNode *trailing) + { + assert(!is_card_mark_membar(trailing), "not expecting a card mark membar"); + + MemBarNode *leading = normal_to_leading(trailing); + + if (leading) + return leading; + + MemBarNode *card_mark_membar = trailing_to_card_mark(trailing); + + if (!card_mark_membar) + return NULL; + + return normal_to_leading(card_mark_membar); + } + // predicates controlling emit of ldr<x>/ldar<x> and associated dmb -bool unnecessary_acquire(const Node *barrier) { +bool unnecessary_acquire(const Node *barrier) +{ // assert barrier->is_MemBar(); if (UseBarriersForVolatile) // we need to plant a dmb @@ -1323,13 +2146,11 @@ return (x->is_Load() && x->as_Load()->is_acquire()); } - // only continue if we want to try to match unsafe volatile gets - if (UseBarriersForUnsafeVolatileGet) - return false; + // now check for an unsafe volatile get // need to check for // - // MemBarCPUOrder + // MemBarCPUOrder // || \\ // MemBarAcquire* LoadX[mo_acquire] // || @@ -1341,9 +2162,13 @@ // check for a parent MemBarCPUOrder ProjNode *ctl; ProjNode *mem; - MemBarNode *parent = has_parent_membar(barrier, ctl, mem); + MemBarNode *parent = parent_membar(barrier); if (!parent || parent->Opcode() != Op_MemBarCPUOrder) return false; + ctl = parent->proj_out(TypeFunc::Control); + mem = parent->proj_out(TypeFunc::Memory); + if (!ctl || !mem) + return false; // ensure the proj nodes both feed a LoadX[mo_acquire] LoadNode *ld = NULL; for (DUIterator_Fast imax, i = ctl->fast_outs(imax); i < imax; i++) { @@ -1369,7 +2194,7 @@ if (ld) return false; // check for a child cpuorder membar - MemBarNode *child = has_child_membar(barrier->as_MemBar(), ctl, mem); + MemBarNode *child = child_membar(barrier->as_MemBar()); if (!child || child->Opcode() != Op_MemBarCPUOrder) return false; @@ -1422,9 +2247,7 @@ return true; } - // only continue if we want to try to match unsafe volatile gets - if (UseBarriersForUnsafeVolatileGet) - return false; + // now check for an unsafe volatile get // check if Ctl and Proj feed comes from a MemBarCPUOrder // @@ -1435,22 +2258,20 @@ // MemBarCPUOrder MemBarNode *membar; - ProjNode *ctl; - ProjNode *mem; - - membar = has_parent_membar(ld, ctl, mem); + + membar = parent_membar(ld); if (!membar || !membar->Opcode() == Op_MemBarCPUOrder) return false; // ensure that there is a CPUOrder->Acquire->CPUOrder membar chain - membar = has_child_membar(membar, ctl, mem); + membar = child_membar(membar); if (!membar || !membar->Opcode() == Op_MemBarAcquire) return false; - membar = has_child_membar(membar, ctl, mem); + membar = child_membar(membar); if (!membar || !membar->Opcode() == Op_MemBarCPUOrder) return false; @@ -1458,194 +2279,81 @@ return true; } -bool unnecessary_release(const Node *n) { +bool unnecessary_release(const Node *n) +{ + assert((n->is_MemBar() && + n->Opcode() == Op_MemBarRelease), + "expecting a release membar"); + + if (UseBarriersForVolatile) + // we need to plant a dmb + return false; + + // if there is a dependent CPUOrder barrier then use that as the + // leading + + MemBarNode *barrier = n->as_MemBar(); + // check for an intervening cpuorder membar + MemBarNode *b = child_membar(barrier); + if (b && b->Opcode() == Op_MemBarCPUOrder) { + // ok, so start the check from the dependent cpuorder barrier + barrier = b; + } + + // must start with a normal feed + MemBarNode *child_barrier = leading_to_normal(barrier); + + if (!child_barrier) + return false; + + if (!is_card_mark_membar(child_barrier)) + // this is the trailing membar and we are done + return true; + + // must be sure this card mark feeds a trailing membar + MemBarNode *trailing = card_mark_to_trailing(child_barrier); + return (trailing != NULL); +} + +bool unnecessary_volatile(const Node *n) +{ // assert n->is_MemBar(); if (UseBarriersForVolatile) // we need to plant a dmb return false; - // ok, so we can omit this release barrier if it has been inserted - // as part of a volatile store sequence - // - // MemBarRelease - // { || } - // {MemBarCPUOrder} -- optional - // || \\ - // || StoreX[mo_release] - // | \ / - // | MergeMem - // | / - // MemBarVolatile - // - // where - // || and \\ represent Ctl and Mem feeds via Proj nodes - // | \ and / indicate further routing of the Ctl and Mem feeds - // - // so we need to check that - // - // ia) the release membar (or its dependent cpuorder membar) feeds - // control to a store node (via a Control project node) - // - // ii) the store is ordered release - // - // iii) the release membar (or its dependent cpuorder membar) feeds - // control to a volatile membar (via the same Control project node) - // - // iv) the release membar feeds memory to a merge mem and to the - // same store (both via a single Memory proj node) - // - // v) the store outputs to the merge mem - // - // vi) the merge mem outputs to the same volatile membar - // - // n.b. if this is an inlined unsafe node then the release membar - // may feed its control and memory links via an intervening cpuorder - // membar. this case can be dealt with when we check the release - // membar projections. if they both feed a single cpuorder membar - // node continue to make the same checks as above but with the - // cpuorder membar substituted for the release membar. if they don't - // both feed a cpuorder membar then the check fails. - // - // n.b.b. for an inlined unsafe store of an object in the case where - // !TypePtr::NULL_PTR->higher_equal(type(heap_base_oop)) we may see - // an embedded if then else where we expect the store. this is - // needed to do the right type of store depending on whether - // heap_base is NULL. We could check for that but for now we can - // just take the hit of on inserting a redundant dmb for this - // redundant volatile membar - - MemBarNode *barrier = n->as_MemBar(); - ProjNode *ctl; - ProjNode *mem; - // check for an intervening cpuorder membar - MemBarNode *b = has_child_membar(barrier, ctl, mem); - if (b && b->Opcode() == Op_MemBarCPUOrder) { - // ok, so start form the dependent cpuorder barrier - barrier = b; - } - // check the ctl and mem flow - ctl = barrier->proj_out(TypeFunc::Control); - mem = barrier->proj_out(TypeFunc::Memory); - - // the barrier needs to have both a Ctl and Mem projection - if (! ctl || ! mem) + MemBarNode *mbvol = n->as_MemBar(); + + // first we check if this is part of a card mark. if so then we have + // to generate a StoreLoad barrier + + if (is_card_mark_membar(mbvol)) + return false; + + // ok, if it's not a card mark then we still need to check if it is + // a trailing membar of a volatile put hgraph. + + return (trailing_to_leading(mbvol) != NULL); +} + +// predicates controlling emit of str<x>/stlr<x> and associated dmbs + +bool needs_releasing_store(const Node *n) +{ + // assert n->is_Store(); + if (UseBarriersForVolatile) + // we use a normal store and dmb combination return false; - Node *x = NULL; - Node *mbvol = NULL; - StoreNode * st = NULL; - - // For a normal volatile write the Ctl ProjNode should have output - // to a MemBarVolatile and a Store marked as releasing - // - // n.b. for an inlined unsafe store of an object in the case where - // !TypePtr::NULL_PTR->higher_equal(type(heap_base_oop)) we may see - // an embedded if then else where we expect the store. this is - // needed to do the right type of store depending on whether - // heap_base is NULL. We could check for that case too but for now - // we can just take the hit of inserting a dmb and a non-volatile - // store to implement the volatile store - - for (DUIterator_Fast imax, i = ctl->fast_outs(imax); i < imax; i++) { - x = ctl->fast_out(i); - if (x->is_MemBar() && x->Opcode() == Op_MemBarVolatile) { - if (mbvol) { - return false; - } - mbvol = x; - } else if (x->is_Store()) { - st = x->as_Store(); - if (! st->is_release()) { - return false; - } - } else if (!x->is_Mach()) { - // we may see mach nodes added during matching but nothing else - return false; - } - } - - if (!mbvol || !st) - return false; - - // the Mem ProjNode should output to a MergeMem and the same Store - Node *mm = NULL; - for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) { - x = mem->fast_out(i); - if (!mm && x->is_MergeMem()) { - mm = x; - } else if (x != st && !x->is_Mach()) { - // we may see mach nodes added during matching but nothing else - return false; - } - } - - if (!mm) + StoreNode *st = n->as_Store(); + + // the store must be marked as releasing + if (!st->is_release()) return false; - // the MergeMem should output to the MemBarVolatile - for (DUIterator_Fast imax, i = mm->fast_outs(imax); i < imax; i++) { - x = mm->fast_out(i); - if (x != mbvol && !x->is_Mach()) { - // we may see mach nodes added during matching but nothing else - return false; - } - } - - return true; -} - -bool unnecessary_volatile(const Node *n) { - // assert n->is_MemBar(); - if (UseBarriersForVolatile) - // we need to plant a dmb - return false; - - // ok, so we can omit this volatile barrier if it has been inserted - // as part of a volatile store sequence - // - // MemBarRelease - // { || } - // {MemBarCPUOrder} -- optional - // || \\ - // || StoreX[mo_release] - // | \ / - // | MergeMem - // | / - // MemBarVolatile - // - // where - // || and \\ represent Ctl and Mem feeds via Proj nodes - // | \ and / indicate further routing of the Ctl and Mem feeds - // - // we need to check that - // - // i) the volatile membar gets its control feed from a release - // membar (or its dependent cpuorder membar) via a Control project - // node - // - // ii) the release membar (or its dependent cpuorder membar) also - // feeds control to a store node via the same proj node - // - // iii) the store is ordered release - // - // iv) the release membar (or its dependent cpuorder membar) feeds - // memory to a merge mem and to the same store (both via a single - // Memory proj node) - // - // v) the store outputs to the merge mem - // - // vi) the merge mem outputs to the volatile membar - // - // n.b. for an inlined unsafe store of an object in the case where - // !TypePtr::NULL_PTR->higher_equal(type(heap_base_oop)) we may see - // an embedded if then else where we expect the store. this is - // needed to do the right type of store depending on whether - // heap_base is NULL. We could check for that but for now we can - // just take the hit of on inserting a redundant dmb for this - // redundant volatile membar - - MemBarNode *mbvol = n->as_MemBar(); - Node *x = n->lookup(TypeFunc::Control); + // the store must be fed by a membar + + Node *x = st->lookup(StoreNode::Memory); if (! x || !x->is_Proj()) return false; @@ -1659,200 +2367,78 @@ MemBarNode *barrier = x->as_MemBar(); - // if the barrier is a release membar we have what we want. if it is - // a cpuorder membar then we need to ensure that it is fed by a - // release membar in which case we proceed to check the graph below - // this cpuorder membar as the feed - - if (x->Opcode() != Op_MemBarRelease) { - if (x->Opcode() != Op_MemBarCPUOrder) - return false; - ProjNode *ctl; - ProjNode *mem; - MemBarNode *b = has_parent_membar(x, ctl, mem); - if (!b || !b->Opcode() == Op_MemBarRelease) - return false; - } - - ProjNode *ctl = barrier->proj_out(TypeFunc::Control); - ProjNode *mem = barrier->proj_out(TypeFunc::Memory); - - // barrier needs to have both a Ctl and Mem projection - // and we need to have reached it via the Ctl projection - if (! ctl || ! mem || ctl != proj) - return false; - - StoreNode * st = NULL; - - // The Ctl ProjNode should have output to a MemBarVolatile and - // a Store marked as releasing - for (DUIterator_Fast imax, i = ctl->fast_outs(imax); i < imax; i++) { - x = ctl->fast_out(i); - if (x->is_MemBar() && x->Opcode() == Op_MemBarVolatile) { - if (x != mbvol) { - return false; - } - } else if (x->is_Store()) { - st = x->as_Store(); - if (! st->is_release()) { - return false; - } - } else if (!x->is_Mach()){ - // we may see mach nodes added during matching but nothing else - return false; - } - } - - if (!st) - return false; - - // the Mem ProjNode should output to a MergeMem and the same Store - Node *mm = NULL; - for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) { - x = mem->fast_out(i); - if (!mm && x->is_MergeMem()) { - mm = x; - } else if (x != st && !x->is_Mach()) { - // we may see mach nodes added during matching but nothing else - return false; - } - } - - if (!mm) - return false; - - // the MergeMem should output to the MemBarVolatile - for (DUIterator_Fast imax, i = mm->fast_outs(imax); i < imax; i++) { - x = mm->fast_out(i); - if (x != mbvol && !x->is_Mach()) { - // we may see mach nodes added during matching but nothing else - return false; - } - } - - return true; -} - - - -bool needs_releasing_store(const Node *n) -{ - // assert n->is_Store(); - if (UseBarriersForVolatile) - // we use a normal store and dmb combination + // if the barrier is a release membar or a cpuorder mmebar fed by a + // release membar then we need to check whether that forms part of a + // volatile put graph. + + // reject invalid candidates + if (!leading_membar(barrier)) return false; - StoreNode *st = n->as_Store(); - - if (!st->is_release()) - return false; - - // check if this store is bracketed by a release (or its dependent - // cpuorder membar) and a volatile membar - // - // MemBarRelease - // { || } - // {MemBarCPUOrder} -- optional - // || \\ - // || StoreX[mo_release] - // | \ / - // | MergeMem - // | / - // MemBarVolatile - // - // where - // || and \\ represent Ctl and Mem feeds via Proj nodes - // | \ and / indicate further routing of the Ctl and Mem feeds - // - - - Node *x = st->lookup(TypeFunc::Control); - - if (! x || !x->is_Proj()) - return false; - - ProjNode *proj = x->as_Proj(); - - x = proj->lookup(0); - - if (!x || !x->is_MemBar()) - return false; - - MemBarNode *barrier = x->as_MemBar(); - - // if the barrier is a release membar we have what we want. if it is - // a cpuorder membar then we need to ensure that it is fed by a - // release membar in which case we proceed to check the graph below - // this cpuorder membar as the feed - - if (x->Opcode() != Op_MemBarRelease) { - if (x->Opcode() != Op_MemBarCPUOrder) - return false; - Node *ctl = x->lookup(TypeFunc::Control); - Node *mem = x->lookup(TypeFunc::Memory); - if (!ctl || !ctl->is_Proj() || !mem || !mem->is_Proj()) - return false; - x = ctl->lookup(0); - if (!x || !x->is_MemBar() || !x->Opcode() == Op_MemBarRelease) - return false; - Node *y = mem->lookup(0); - if (!y || y != x) - return false; - } - - ProjNode *ctl = barrier->proj_out(TypeFunc::Control); - ProjNode *mem = barrier->proj_out(TypeFunc::Memory); - - // MemBarRelease needs to have both a Ctl and Mem projection - // and we need to have reached it via the Ctl projection - if (! ctl || ! mem || ctl != proj) - return false; - - MemBarNode *mbvol = NULL; - - // The Ctl ProjNode should have output to a MemBarVolatile and - // a Store marked as releasing - for (DUIterator_Fast imax, i = ctl->fast_outs(imax); i < imax; i++) { - x = ctl->fast_out(i); - if (x->is_MemBar() && x->Opcode() == Op_MemBarVolatile) { - mbvol = x->as_MemBar(); - } else if (x->is_Store()) { - if (x != st) { - return false; - } - } else if (!x->is_Mach()){ - return false; - } - } + // does this lead a normal subgraph? + MemBarNode *mbvol = leading_to_normal(barrier); if (!mbvol) return false; - // the Mem ProjNode should output to a MergeMem and the same Store - Node *mm = NULL; - for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) { - x = mem->fast_out(i); - if (!mm && x->is_MergeMem()) { - mm = x; - } else if (x != st && !x->is_Mach()) { - return false; - } - } - - if (!mm) + // all done unless this is a card mark + if (!is_card_mark_membar(mbvol)) + return true; + + // we found a card mark -- just make sure we have a trailing barrier + + return (card_mark_to_trailing(mbvol) != NULL); +} + +// predicate controlling translation of StoreCM +// +// returns true if a StoreStore must precede the card write otherwise +// false + +bool unnecessary_storestore(const Node *storecm) +{ + assert(storecm->Opcode() == Op_StoreCM, "expecting a StoreCM"); + + // we only ever need to generate a dmb ishst between an object put + // and the associated card mark when we are using CMS without + // conditional card marking + + if (!UseConcMarkSweepGC || UseCondCardMark) + return true; + + // if we are implementing volatile puts using barriers then the + // object put as an str so we must insert the dmb ishst + + if (UseBarriersForVolatile) return false; - // the MergeMem should output to the MemBarVolatile - for (DUIterator_Fast imax, i = mm->fast_outs(imax); i < imax; i++) { - x = mm->fast_out(i); - if (x != mbvol && !x->is_Mach()) { - return false; - } - } - - return true; -} - + // we can omit the dmb ishst if this StoreCM is part of a volatile + // put because in thta case the put will be implemented by stlr + // + // we need to check for a normal subgraph feeding this StoreCM. + // that means the StoreCM must be fed Memory from a leading membar, + // either a MemBarRelease or its dependent MemBarCPUOrder, and the + // leading membar must be part of a normal subgraph + + Node *x = storecm->in(StoreNode::Memory); + + if (!x->is_Proj()) + return false; + + x = x->in(0); + + if (!x->is_MemBar()) + return false; + + MemBarNode *leading = x->as_MemBar(); + + // reject invalid candidates + if (!leading_membar(leading)) + return false; + + // we can omit the StoreStore if it is the head of a normal subgraph + return (leading_to_normal(leading) != NULL); +} #define __ _masm. @@ -2944,6 +3530,13 @@ as_Register($mem$$base), $mem$$index, $mem$$scale, $mem$$disp); %} + enc_class aarch64_enc_strb0_ordered(memory mem) %{ + MacroAssembler _masm(&cbuf); + __ membar(Assembler::StoreStore); + loadStore(_masm, &MacroAssembler::strb, zr, $mem->opcode(), + as_Register($mem$$base), $mem$$index, $mem$$scale, $mem$$disp); + %} + enc_class aarch64_enc_strh(iRegI src, memory mem) %{ Register src_reg = as_Register($src$$reg); loadStore(MacroAssembler(&cbuf), &MacroAssembler::strh, src_reg, $mem->opcode(), @@ -3780,12 +4373,12 @@ return; } - if (UseBiasedLocking) { - __ biased_locking_enter(disp_hdr, oop, box, tmp, true, cont); + if (UseBiasedLocking && !UseOptoBiasInlining) { + __ biased_locking_enter(box, oop, disp_hdr, tmp, true, cont); } // Handle existing monitor - if (EmitSync & 0x02) { + if ((EmitSync & 0x02) == 0) { // we can use AArch64's bit test and branch here but // markoopDesc does not define a bit index just the bit value // so assert in case the bit pos changes @@ -3925,7 +4518,7 @@ return; } - if (UseBiasedLocking) { + if (UseBiasedLocking && !UseOptoBiasInlining) { __ biased_locking_exit(oop, tmp, cont); } @@ -6613,6 +7206,7 @@ instruct storeimmCM0(immI0 zero, memory mem) %{ match(Set mem (StoreCM mem zero)); + predicate(unnecessary_storestore(n)); ins_cost(INSN_COST); format %{ "strb zr, $mem\t# byte" %} @@ -6622,6 +7216,21 @@ ins_pipe(istore_mem); %} +// Store CMS card-mark Immediate with intervening StoreStore +// needed when using CMS with no conditional card marking +instruct storeimmCM0_ordered(immI0 zero, memory mem) +%{ + match(Set mem (StoreCM mem zero)); + + ins_cost(INSN_COST * 2); + format %{ "dmb ishst" + "\n\tstrb zr, $mem\t# byte" %} + + ins_encode(aarch64_enc_strb0_ordered(mem)); + + ins_pipe(istore_mem); +%} + // Store Byte instruct storeB(iRegIorL2I src, memory mem) %{ @@ -6643,7 +7252,7 @@ predicate(!needs_releasing_store(n)); ins_cost(INSN_COST); - format %{ "strb zr, $mem\t# byte" %} + format %{ "strb rscractch2, $mem\t# byte" %} ins_encode(aarch64_enc_strb0(mem)); @@ -7396,6 +8005,7 @@ format %{ "membar_acquire" %} ins_encode %{ + __ block_comment("membar_acquire"); __ membar(Assembler::LoadLoad|Assembler::LoadStore); %} @@ -7448,6 +8058,7 @@ format %{ "membar_release" %} ins_encode %{ + __ block_comment("membar_release"); __ membar(Assembler::LoadStore|Assembler::StoreStore); %} ins_pipe(pipe_serial); @@ -7499,6 +8110,7 @@ format %{ "membar_volatile" %} ins_encode %{ + __ block_comment("membar_volatile"); __ membar(Assembler::StoreLoad); %} @@ -9429,7 +10041,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9465,7 +10077,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9501,7 +10113,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9537,7 +10149,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9573,7 +10185,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9609,7 +10221,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9645,7 +10257,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9681,7 +10293,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9717,7 +10329,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9754,7 +10366,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9792,7 +10404,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9830,7 +10442,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9868,7 +10480,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9906,7 +10518,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9944,7 +10556,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -9982,7 +10594,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10020,7 +10632,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10058,7 +10670,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10096,7 +10708,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10134,7 +10746,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10172,7 +10784,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10210,7 +10822,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10248,7 +10860,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::ASR, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift); @@ -10286,7 +10898,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::LSL, - $src3$$constant & 0x3f); + $src3$$constant & 0x1f); %} ins_pipe(ialu_reg_reg_shift);
--- a/src/cpu/aarch64/vm/aarch64_ad.m4 Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/aarch64_ad.m4 Tue Sep 29 18:47:52 2015 +0200 @@ -42,7 +42,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::$5, - $src3$$constant & 0x3f); + $src3$$constant & ifelse($1,I,0x1f,0x3f)); %} ins_pipe(ialu_reg_reg_shift); @@ -87,7 +87,7 @@ as_Register($src1$$reg), as_Register($src2$$reg), Assembler::$5, - $src3$$constant & 0x3f); + $src3$$constant & ifelse($1,I,0x1f,0x3f)); %} ins_pipe(ialu_reg_reg_shift);
--- a/src/cpu/aarch64/vm/assembler_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/assembler_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -268,7 +268,7 @@ __ ldar(r21, r28); // ldar x21, [x28] // LoadStoreExclusiveOp - __ stxrw(r24, r24, r7); // stxr w24, w24, [x7] + __ stxrw(r21, r24, r7); // stxr w21, w24, [x7] __ stlxrw(r21, r26, r28); // stlxr w21, w26, [x28] __ ldxrw(r21, r6); // ldxr w21, [x6] __ ldaxrw(r15, r30); // ldaxr w15, [x30] @@ -299,7 +299,7 @@ // LoadStoreExclusiveOp __ ldxpw(r25, r4, r22); // ldxp w25, w4, [x22] - __ ldaxpw(r14, r14, r15); // ldaxp w14, w14, [x15] + __ ldaxpw(r13, r14, r15); // ldaxp w13, w14, [x15] __ stxpw(r20, r26, r8, r10); // stxp w20, w26, w8, [x10] __ stlxpw(r23, r18, r18, r18); // stlxp w23, w18, w18, [x18] @@ -773,7 +773,7 @@ 260: c85fffbb ldaxr x27, [x29] 264: c89fffa0 stlr x0, [x29] 268: c8dfff95 ldar x21, [x28] - 26c: 88187cf8 stxr w24, w24, [x7] + 26c: 88157cf8 stxr w21, w24, [x7] 270: 8815ff9a stlxr w21, w26, [x28] 274: 885f7cd5 ldxr w21, [x6] 278: 885fffcf ldaxr w15, [x30] @@ -796,7 +796,7 @@ 2bc: c82870bb stxp w8, x27, x28, [x5] 2c0: c825b8c8 stlxp w5, x8, x14, [x6] 2c4: 887f12d9 ldxp w25, w4, [x22] - 2c8: 887fb9ee ldaxp w14, w14, [x15] + 2c8: 887fb9ed ldaxp w13, w14, [x15] 2cc: 8834215a stxp w20, w26, w8, [x10] 2d0: 8837ca52 stlxp w23, w18, w18, [x18] 2d4: f806317e str x30, [x11,#99] @@ -1085,13 +1085,13 @@ 0xd444c320, 0xd503201f, 0xd69f03e0, 0xd6bf03e0, 0xd5033fdf, 0xd5033f9f, 0xd5033abf, 0xd61f0040, 0xd63f00a0, 0xc8147c55, 0xc805fcfd, 0xc85f7e05, - 0xc85fffbb, 0xc89fffa0, 0xc8dfff95, 0x88187cf8, + 0xc85fffbb, 0xc89fffa0, 0xc8dfff95, 0x88157cf8, 0x8815ff9a, 0x885f7cd5, 0x885fffcf, 0x889ffc73, 0x88dffc56, 0x48127c0f, 0x480bff85, 0x485f7cdd, 0x485ffcf2, 0x489fff99, 0x48dffe62, 0x080a7c3e, 0x0814fed5, 0x085f7c59, 0x085ffcb8, 0x089ffc70, 0x08dfffb6, 0xc87f0a68, 0xc87fcdc7, 0xc82870bb, - 0xc825b8c8, 0x887f12d9, 0x887fb9ee, 0x8834215a, + 0xc825b8c8, 0x887f12d9, 0x887fb9ed, 0x8834215a, 0x8837ca52, 0xf806317e, 0xb81b3337, 0x39000dc2, 0x78005149, 0xf84391f4, 0xb85b220c, 0x385fd356, 0x785d127e, 0x389f4149, 0x79801e3c, 0x79c014a3,
--- a/src/cpu/aarch64/vm/assembler_aarch64.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/assembler_aarch64.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -1106,13 +1106,13 @@ #define INSN4(NAME, sz, op, o0) /* Four registers */ \ void NAME(Register Rs, Register Rt1, Register Rt2, Register Rn) { \ - assert(Rs != Rn, "unpredictable instruction"); \ + guarantee(Rs != Rn && Rs != Rt1 && Rs != Rt2, "unpredictable instruction"); \ load_store_exclusive(Rs, Rt1, Rt2, Rn, sz, op, o0); \ } #define INSN3(NAME, sz, op, o0) /* Three registers */ \ void NAME(Register Rs, Register Rt, Register Rn) { \ - assert(Rs != Rn, "unpredictable instruction"); \ + guarantee(Rs != Rn && Rs != Rt, "unpredictable instruction"); \ load_store_exclusive(Rs, Rt, (Register)0b11111, Rn, sz, op, o0); \ } @@ -1124,6 +1124,7 @@ #define INSN_FOO(NAME, sz, op, o0) /* Three registers, encoded differently */ \ void NAME(Register Rt1, Register Rt2, Register Rn) { \ + guarantee(Rt1 != Rt2, "unpredictable instruction"); \ load_store_exclusive((Register)0b11111, Rt1, Rt2, Rn, sz, op, o0); \ } @@ -1209,7 +1210,7 @@ INSN(ldrs, 0b00, 1); INSN(ldrd, 0b01, 1); - INSN(ldrq, 0x10, 1); + INSN(ldrq, 0b10, 1); #undef INSN @@ -2284,13 +2285,13 @@ #undef INSN // Table vector lookup -#define INSN(NAME, op) \ - void NAME(FloatRegister Vd, SIMD_Arrangement T, FloatRegister Vn, unsigned registers, FloatRegister Vm) { \ - starti; \ - assert(T == T8B || T == T16B, "invalid arrangement"); \ - assert(0 < registers && registers <= 4, "invalid number of registers"); \ - f(0, 31), f((int)T & 1, 30), f(0b001110000, 29, 21), rf(Vm, 16), f(0, 15); \ - f(registers - 1, 14, 13), f(op, 12),f(0b00, 11, 10), rf(Vn, 5), rf(Vd, 0); \ +#define INSN(NAME, op) \ + void NAME(FloatRegister Vd, SIMD_Arrangement T, FloatRegister Vn, unsigned registers, FloatRegister Vm) { \ + starti; \ + assert(T == T8B || T == T16B, "invalid arrangement"); \ + assert(0 < registers && registers <= 4, "invalid number of registers"); \ + f(0, 31), f((int)T & 1, 30), f(0b001110000, 29, 21), rf(Vm, 16), f(0, 15); \ + f(registers - 1, 14, 13), f(op, 12),f(0b00, 11, 10), rf(Vn, 5), rf(Vd, 0); \ } INSN(tbl, 0); @@ -2298,6 +2299,7 @@ #undef INSN + // AdvSIMD two-reg misc #define INSN(NAME, U, opcode) \ void NAME(FloatRegister Vd, SIMD_Arrangement T, FloatRegister Vn) { \ starti; \ @@ -2315,10 +2317,19 @@ #define ASSERTION (T == T8B || T == T16B || T == T4H || T == T8H) INSN(rev32, 1, 0b00000); +private: + INSN(_rbit, 1, 0b00101); +public: + #undef ASSERTION #define ASSERTION (T == T8B || T == T16B) INSN(rev16, 0, 0b00001); + // RBIT only allows T8B and T16B but encodes them oddly. Argh... + void rbit(FloatRegister Vd, SIMD_Arrangement T, FloatRegister Vn) { + assert((ASSERTION), MSG); + _rbit(Vd, SIMD_Arrangement(T & 1 | 0b010), Vn); + } #undef ASSERTION #undef MSG
--- a/src/cpu/aarch64/vm/interp_masm_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/interp_masm_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -611,6 +611,7 @@ Label done; const Register swap_reg = r0; + const Register tmp = c_rarg2; const Register obj_reg = c_rarg3; // Will contain the oop const int obj_offset = BasicObjectLock::obj_offset_in_bytes(); @@ -624,7 +625,7 @@ ldr(obj_reg, Address(lock_reg, obj_offset)); if (UseBiasedLocking) { - biased_locking_enter(lock_reg, obj_reg, swap_reg, rscratch2, false, done, &slow_case); + biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp, false, done, &slow_case); } // Load (object->mark() | 1) into swap_reg @@ -643,7 +644,7 @@ cmpxchgptr(swap_reg, lock_reg, obj_reg, rscratch1, fast, &fail); bind(fast); atomic_incw(Address((address)BiasedLocking::fast_path_entry_count_addr()), - rscratch2, rscratch1); + rscratch2, rscratch1, tmp); b(done); bind(fail); } else { @@ -671,7 +672,7 @@ if (PrintBiasedLockingStatistics) { br(Assembler::NE, slow_case); atomic_incw(Address((address)BiasedLocking::fast_path_entry_count_addr()), - rscratch2, rscratch1); + rscratch2, rscratch1, tmp); } br(Assembler::EQ, done);
--- a/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -34,6 +34,7 @@ #include "memory/resourceArea.hpp" #include "nativeInst_aarch64.hpp" #include "oops/klass.inline.hpp" +#include "oops/oop.inline.hpp" #include "opto/compile.hpp" #include "opto/node.hpp" #include "runtime/biasedLocking.hpp" @@ -398,11 +399,7 @@ if (PrintBiasedLockingStatistics && counters == NULL) counters = BiasedLocking::counters(); - bool need_tmp_reg = false; - if (tmp_reg == noreg) { - tmp_reg = rscratch2; - } - assert_different_registers(lock_reg, obj_reg, swap_reg, tmp_reg, rscratch1); + assert_different_registers(lock_reg, obj_reg, swap_reg, tmp_reg, rscratch1, rscratch2, noreg); assert(markOopDesc::age_shift == markOopDesc::lock_bits + markOopDesc::biased_lock_bits, "biased locking makes assumptions about bit layout"); Address mark_addr (obj_reg, oopDesc::mark_offset_in_bytes()); Address klass_addr (obj_reg, oopDesc::klass_offset_in_bytes()); @@ -432,7 +429,7 @@ if (counters != NULL) { Label around; cbnz(tmp_reg, around); - atomic_incw(Address((address)counters->biased_lock_entry_count_addr()), tmp_reg, rscratch1); + atomic_incw(Address((address)counters->biased_lock_entry_count_addr()), tmp_reg, rscratch1, rscratch2); b(done); bind(around); } else { @@ -485,7 +482,7 @@ bind(here); if (counters != NULL) { atomic_incw(Address((address)counters->anonymously_biased_lock_entry_count_addr()), - tmp_reg, rscratch1); + tmp_reg, rscratch1, rscratch2); } } b(done); @@ -511,7 +508,7 @@ bind(here); if (counters != NULL) { atomic_incw(Address((address)counters->rebiased_lock_entry_count_addr()), - tmp_reg, rscratch1); + tmp_reg, rscratch1, rscratch2); } } b(done); @@ -539,7 +536,7 @@ // removing the bias bit from the object's header. if (counters != NULL) { atomic_incw(Address((address)counters->revoked_lock_entry_count_addr()), tmp_reg, - rscratch1); + rscratch1, rscratch2); } bind(nope); } @@ -1640,15 +1637,15 @@ return Address(Rd); } -void MacroAssembler::atomic_incw(Register counter_addr, Register tmp) { +void MacroAssembler::atomic_incw(Register counter_addr, Register tmp, Register tmp2) { Label retry_load; bind(retry_load); // flush and load exclusive from the memory location ldxrw(tmp, counter_addr); addw(tmp, tmp, 1); // if we store+flush with no intervening write tmp wil be zero - stxrw(tmp, tmp, counter_addr); - cbnzw(tmp, retry_load); + stxrw(tmp2, tmp, counter_addr); + cbnzw(tmp2, retry_load); } @@ -2021,6 +2018,14 @@ } } +void MacroAssembler::subw(Register Rd, Register Rn, RegisterOrConstant decrement) { + if (decrement.is_register()) { + subw(Rd, Rn, decrement.as_register()); + } else { + subw(Rd, Rn, decrement.as_constant()); + } +} + void MacroAssembler::reinit_heapbase() { if (UseCompressedOops) { @@ -2110,7 +2115,7 @@ return a != b.as_register() && a != c && b.as_register() != c; } -#define ATOMIC_OP(LDXR, OP, STXR) \ +#define ATOMIC_OP(LDXR, OP, IOP, STXR) \ void MacroAssembler::atomic_##OP(Register prev, RegisterOrConstant incr, Register addr) { \ Register result = rscratch2; \ if (prev->is_valid()) \ @@ -2120,14 +2125,15 @@ bind(retry_load); \ LDXR(result, addr); \ OP(rscratch1, result, incr); \ - STXR(rscratch1, rscratch1, addr); \ - cbnzw(rscratch1, retry_load); \ - if (prev->is_valid() && prev != result) \ - mov(prev, result); \ + STXR(rscratch2, rscratch1, addr); \ + cbnzw(rscratch2, retry_load); \ + if (prev->is_valid() && prev != result) { \ + IOP(prev, rscratch1, incr); \ + } \ } -ATOMIC_OP(ldxr, add, stxr) -ATOMIC_OP(ldxrw, addw, stxrw) +ATOMIC_OP(ldxr, add, sub, stxr) +ATOMIC_OP(ldxrw, addw, subw, stxrw) #undef ATOMIC_OP @@ -3037,7 +3043,9 @@ // register obj is destroyed afterwards. BarrierSet* bs = Universe::heap()->barrier_set(); - assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); + assert(bs->kind() == BarrierSet::CardTableForRS || + bs->kind() == BarrierSet::CardTableExtension, + "Wrong barrier set kind"); CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(bs); assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
--- a/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -107,9 +107,7 @@ // Biased locking support // lock_reg and obj_reg must be loaded up with the appropriate values. // swap_reg is killed. - // tmp_reg is optional. If it is supplied (i.e., != noreg) it will - // be killed; if not supplied, push/pop will be used internally to - // allocate a temporary (inefficient, avoid if possible). + // tmp_reg must be supplied and must not be rscratch1 or rscratch2 // Optional slow case is for implementations (interpreter and C1) which branch to // slow case directly. Leaves condition codes set for C2's Fast_Lock node. // Returns offset of first potentially-faulting instruction for null @@ -126,10 +124,10 @@ // Helper functions for statistics gathering. // Unconditional atomic increment. - void atomic_incw(Register counter_addr, Register tmp); - void atomic_incw(Address counter_addr, Register tmp1, Register tmp2) { + void atomic_incw(Register counter_addr, Register tmp, Register tmp2); + void atomic_incw(Address counter_addr, Register tmp1, Register tmp2, Register tmp3) { lea(tmp1, counter_addr); - atomic_incw(tmp1, tmp2); + atomic_incw(tmp1, tmp2, tmp3); } // Load Effective Address void lea(Register r, const Address &a) { @@ -1057,6 +1055,7 @@ void add(Register Rd, Register Rn, RegisterOrConstant increment); void addw(Register Rd, Register Rn, RegisterOrConstant increment); void sub(Register Rd, Register Rn, RegisterOrConstant decrement); + void subw(Register Rd, Register Rn, RegisterOrConstant decrement); void adrp(Register reg1, const Address &dest, unsigned long &byte_offset);
--- a/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/sharedRuntime_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1774,6 +1774,7 @@ const Register obj_reg = r19; // Will contain the oop const Register lock_reg = r13; // Address of compiler lock object (BasicLock) const Register old_hdr = r13; // value of old header at unlock time + const Register tmp = c_rarg3; Label slow_path_lock; Label lock_done; @@ -1795,7 +1796,7 @@ __ ldr(obj_reg, Address(oop_handle_reg, 0)); if (UseBiasedLocking) { - __ biased_locking_enter(lock_reg, obj_reg, swap_reg, rscratch2, false, lock_done, &slow_path_lock); + __ biased_locking_enter(lock_reg, obj_reg, swap_reg, tmp, false, lock_done, &slow_path_lock); } // Load (object->mark() | 1) into swap_reg %r0
--- a/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/stubGenerator_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -691,7 +691,7 @@ __ call_VM_leaf(CAST_FROM_FN_PTR(address, BarrierSet::static_write_ref_array_pre), 2); __ pop(RegSet::range(r0, r29), sp); // integer registers except lr & sp } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -731,7 +731,7 @@ __ pop(RegSet::range(r0, r29), sp); // integer registers except lr & sp } } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { CardTableModRefBS* ct = (CardTableModRefBS*)bs; @@ -2364,7 +2364,7 @@ * c_rarg3 - int* table * * Ouput: - * rax - int crc result + * r0 - int crc result */ address generate_updateBytesCRC32C() { assert(UseCRC32CIntrinsics, "what are we doing here?"); @@ -2435,6 +2435,69 @@ return start; } + void ghash_multiply(FloatRegister result_lo, FloatRegister result_hi, + FloatRegister a, FloatRegister b, FloatRegister a1_xor_a0, + FloatRegister tmp1, FloatRegister tmp2, FloatRegister tmp3, FloatRegister tmp4) { + // Karatsuba multiplication performs a 128*128 -> 256-bit + // multiplication in three 128-bit multiplications and a few + // additions. + // + // (C1:C0) = A1*B1, (D1:D0) = A0*B0, (E1:E0) = (A0+A1)(B0+B1) + // (A1:A0)(B1:B0) = C1:(C0+C1+D1+E1):(D1+C0+D0+E0):D0 + // + // Inputs: + // + // A0 in a.d[0] (subkey) + // A1 in a.d[1] + // (A1+A0) in a1_xor_a0.d[0] + // + // B0 in b.d[0] (state) + // B1 in b.d[1] + + __ ext(tmp1, __ T16B, b, b, 0x08); + __ pmull2(result_hi, __ T1Q, b, a, __ T2D); // A1*B1 + __ eor(tmp1, __ T16B, tmp1, b); // (B1+B0) + __ pmull(result_lo, __ T1Q, b, a, __ T1D); // A0*B0 + __ pmull(tmp2, __ T1Q, tmp1, a1_xor_a0, __ T1D); // (A1+A0)(B1+B0) + + __ ext(tmp4, __ T16B, result_lo, result_hi, 0x08); + __ eor(tmp3, __ T16B, result_hi, result_lo); // A1*B1+A0*B0 + __ eor(tmp2, __ T16B, tmp2, tmp4); + __ eor(tmp2, __ T16B, tmp2, tmp3); + + // Register pair <result_hi:result_lo> holds the result of carry-less multiplication + __ ins(result_hi, __ D, tmp2, 0, 1); + __ ins(result_lo, __ D, tmp2, 1, 0); + } + + void ghash_reduce(FloatRegister result, FloatRegister lo, FloatRegister hi, + FloatRegister p, FloatRegister z, FloatRegister t1) { + const FloatRegister t0 = result; + + // The GCM field polynomial f is z^128 + p(z), where p = + // z^7+z^2+z+1. + // + // z^128 === -p(z) (mod (z^128 + p(z))) + // + // so, given that the product we're reducing is + // a == lo + hi * z^128 + // substituting, + // === lo - hi * p(z) (mod (z^128 + p(z))) + // + // we reduce by multiplying hi by p(z) and subtracting the result + // from (i.e. XORing it with) lo. Because p has no nonzero high + // bits we can do this with two 64-bit multiplications, lo*p and + // hi*p. + + __ pmull2(t0, __ T1Q, hi, p, __ T2D); + __ ext(t1, __ T16B, t0, z, 8); + __ eor(hi, __ T16B, hi, t1); + __ ext(t1, __ T16B, z, t0, 8); + __ eor(lo, __ T16B, lo, t1); + __ pmull(t0, __ T1Q, hi, p, __ T1D); + __ eor(result, __ T16B, lo, t0); + } + /** * Arguments: * @@ -2448,10 +2511,27 @@ * Updated state at c_rarg0 */ address generate_ghash_processBlocks() { - __ align(CodeEntryAlignment); - Label L_ghash_loop, L_exit; + // Bafflingly, GCM uses little-endian for the byte order, but + // big-endian for the bit order. For example, the polynomial 1 is + // represented as the 16-byte string 80 00 00 00 | 12 bytes of 00. + // + // So, we must either reverse the bytes in each word and do + // everything big-endian or reverse the bits in each byte and do + // it little-endian. On AArch64 it's more idiomatic to reverse + // the bits in each byte (we have an instruction, RBIT, to do + // that) and keep the data in little-endian bit order throught the + // calculation, bit-reversing the inputs and outputs. StubCodeMark mark(this, "StubRoutines", "ghash_processBlocks"); + __ align(wordSize * 2); + address p = __ pc(); + __ emit_int64(0x87); // The low-order bits of the field + // polynomial (i.e. p = z^7+z^2+z+1) + // repeated in the low and high parts of a + // 128-bit vector + __ emit_int64(0x87); + + __ align(CodeEntryAlignment); address start = __ pc(); Register state = c_rarg0; @@ -2462,104 +2542,43 @@ FloatRegister vzr = v30; __ eor(vzr, __ T16B, vzr, vzr); // zero register - __ mov(v26, __ T16B, 1); - __ mov(v27, __ T16B, 63); - __ mov(v28, __ T16B, 62); - __ mov(v29, __ T16B, 57); - - __ ldrq(v6, Address(state)); - __ ldrq(v16, Address(subkeyH)); - - __ ext(v0, __ T16B, v6, v6, 0x08); - __ ext(v1, __ T16B, v16, v16, 0x08); - __ eor(v16, __ T16B, v16, v1); - - __ bind(L_ghash_loop); - - __ ldrq(v2, Address(__ post(data, 0x10))); - __ rev64(v2, __ T16B, v2); // swap data - - __ ext(v6, __ T16B, v0, v0, 0x08); - __ eor(v6, __ T16B, v6, v2); - __ ext(v2, __ T16B, v6, v6, 0x08); - - __ pmull2(v7, __ T1Q, v2, v1, __ T2D); // A1*B1 - __ eor(v6, __ T16B, v6, v2); - __ pmull(v5, __ T1Q, v2, v1, __ T1D); // A0*B0 - __ pmull(v20, __ T1Q, v6, v16, __ T1D); // (A1 + A0)(B1 + B0) - - __ ext(v21, __ T16B, v5, v7, 0x08); - __ eor(v18, __ T16B, v7, v5); // A1*B1 xor A0*B0 - __ eor(v20, __ T16B, v20, v21); - __ eor(v20, __ T16B, v20, v18); - - // Registers pair <v7:v5> holds the result of carry-less multiplication - __ ins(v7, __ D, v20, 0, 1); - __ ins(v5, __ D, v20, 1, 0); - - // Result of the multiplication is shifted by one bit position - // [X3:X2:X1:X0] = [X3:X2:X1:X0] << 1 - __ ushr(v18, __ T2D, v5, -63 & 63); - __ ins(v25, __ D, v18, 1, 0); - __ ins(v25, __ D, vzr, 0, 0); - __ ushl(v5, __ T2D, v5, v26); - __ orr(v5, __ T16B, v5, v25); - - __ ushr(v19, __ T2D, v7, -63 & 63); - __ ins(v19, __ D, v19, 1, 0); - __ ins(v19, __ D, v18, 0, 1); - __ ushl(v7, __ T2D, v7, v26); - __ orr(v6, __ T16B, v7, v19); - - __ ins(v24, __ D, v5, 0, 1); - - // A = X0 << 63 - __ ushl(v21, __ T2D, v5, v27); - - // A = X0 << 62 - __ ushl(v22, __ T2D, v5, v28); - - // A = X0 << 57 - __ ushl(v23, __ T2D, v5, v29); - - // D = X1^A^B^C - __ eor(v21, __ T16B, v21, v22); - __ eor(v21, __ T16B, v21, v23); - __ eor(v21, __ T16B, v21, v24); - __ ins(v5, __ D, v21, 1, 0); - - // [E1:E0] = [D:X0] >> 1 - __ ushr(v20, __ T2D, v5, -1 & 63); - __ ushl(v18, __ T2D, v5, v27); - __ ext(v25, __ T16B, v18, vzr, 0x08); - __ orr(v19, __ T16B, v20, v25); - - __ eor(v7, __ T16B, v5, v19); - - // [F1:F0] = [D:X0] >> 2 - __ ushr(v20, __ T2D, v5, -2 & 63); - __ ushl(v18, __ T2D, v5, v28); - __ ins(v25, __ D, v18, 0, 1); - __ orr(v19, __ T16B, v20, v25); - - __ eor(v7, __ T16B, v7, v19); - - // [G1:G0] = [D:X0] >> 7 - __ ushr(v20, __ T2D, v5, -7 & 63); - __ ushl(v18, __ T2D, v5, v29); - __ ins(v25, __ D, v18, 0, 1); - __ orr(v19, __ T16B, v20, v25); - - // [H1:H0] = [D^E1^F1^G1:X0^E0^F0^G0] - __ eor(v7, __ T16B, v7, v19); - - // Result = [H1:H0]^[X3:X2] - __ eor(v0, __ T16B, v7, v6); - - __ subs(blocks, blocks, 1); - __ cbnz(blocks, L_ghash_loop); - - __ ext(v1, __ T16B, v0, v0, 0x08); + __ ldrq(v0, Address(state)); + __ ldrq(v1, Address(subkeyH)); + + __ rev64(v0, __ T16B, v0); // Bit-reverse words in state and subkeyH + __ rbit(v0, __ T16B, v0); + __ rev64(v1, __ T16B, v1); + __ rbit(v1, __ T16B, v1); + + __ ldrq(v26, p); + + __ ext(v16, __ T16B, v1, v1, 0x08); // long-swap subkeyH into v1 + __ eor(v16, __ T16B, v16, v1); // xor subkeyH into subkeyL (Karatsuba: (A1+A0)) + + { + Label L_ghash_loop; + __ bind(L_ghash_loop); + + __ ldrq(v2, Address(__ post(data, 0x10))); // Load the data, bit + // reversing each byte + __ rbit(v2, __ T16B, v2); + __ eor(v2, __ T16B, v0, v2); // bit-swapped data ^ bit-swapped state + + // Multiply state in v2 by subkey in v1 + ghash_multiply(/*result_lo*/v5, /*result_hi*/v7, + /*a*/v1, /*b*/v2, /*a1_xor_a0*/v16, + /*temps*/v6, v20, v18, v21); + // Reduce v7:v5 by the field polynomial + ghash_reduce(v0, v5, v7, v26, vzr, v20); + + __ sub(blocks, blocks, 1); + __ cbnz(blocks, L_ghash_loop); + } + + // The bit-reversed result is at this point in v0 + __ rev64(v1, __ T16B, v0); + __ rbit(v1, __ T16B, v1); + __ st1(v1, __ T16B, state); __ ret(lr);
--- a/src/cpu/aarch64/vm/templateInterpreter_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/templateInterpreter_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1913,15 +1913,18 @@ } void TemplateInterpreterGenerator::count_bytecode() { + Register rscratch3 = r0; __ push(rscratch1); __ push(rscratch2); + __ push(rscratch3); Label L; __ mov(rscratch2, (address) &BytecodeCounter::_counter_value); __ bind(L); __ ldxr(rscratch1, rscratch2); __ add(rscratch1, rscratch1, 1); - __ stxr(rscratch1, rscratch1, rscratch2); - __ cbnzw(rscratch1, L); + __ stxr(rscratch3, rscratch1, rscratch2); + __ cbnzw(rscratch3, L); + __ pop(rscratch3); __ pop(rscratch2); __ pop(rscratch1); }
--- a/src/cpu/aarch64/vm/templateTable_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/templateTable_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -186,7 +186,7 @@ } break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { if (val == noreg) {
--- a/src/cpu/aarch64/vm/vm_version_aarch64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/aarch64/vm/vm_version_aarch64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -177,6 +177,12 @@ if (UseCRC32 && (auxv & HWCAP_CRC32) == 0) { warning("UseCRC32 specified, but not supported on this CPU"); } + + if (UseAdler32Intrinsics) { + warning("Adler32Intrinsics not available on this CPU."); + FLAG_SET_DEFAULT(UseAdler32Intrinsics, false); + } + if (auxv & HWCAP_AES) { UseAES = UseAES || FLAG_IS_DEFAULT(UseAES); UseAESIntrinsics =
--- a/src/cpu/ppc/vm/macroAssembler_ppc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/ppc/vm/macroAssembler_ppc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -2614,7 +2614,7 @@ void MacroAssembler::card_write_barrier_post(Register Rstore_addr, Register Rnew_val, Register Rtmp) { CardTableModRefBS* bs = barrier_set_cast<CardTableModRefBS>(Universe::heap()->barrier_set()); - assert(bs->kind() == BarrierSet::CardTableModRef || + assert(bs->kind() == BarrierSet::CardTableForRS || bs->kind() == BarrierSet::CardTableExtension, "wrong barrier"); #ifdef ASSERT cmpdi(CCR0, Rnew_val, 0);
--- a/src/cpu/ppc/vm/stubGenerator_ppc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/ppc/vm/stubGenerator_ppc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -656,7 +656,7 @@ __ bind(filtered); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -697,7 +697,7 @@ } } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { Label Lskip_loop, Lstore_loop;
--- a/src/cpu/ppc/vm/templateTable_ppc_64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/ppc/vm/templateTable_ppc_64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -105,7 +105,7 @@ } break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { Label Lnull, Ldone;
--- a/src/cpu/ppc/vm/vm_version_ppc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/ppc/vm/vm_version_ppc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -200,6 +200,11 @@ FLAG_SET_DEFAULT(UseSHA512Intrinsics, false); } + if (UseAdler32Intrinsics) { + warning("Adler32Intrinsics not available on this CPU."); + FLAG_SET_DEFAULT(UseAdler32Intrinsics, false); + } + if (FLAG_IS_DEFAULT(UseMultiplyToLenIntrinsic)) { UseMultiplyToLenIntrinsic = true; }
--- a/src/cpu/sparc/vm/macroAssembler_sparc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/sparc/vm/macroAssembler_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3958,7 +3958,7 @@ if (new_val == G0) return; CardTableModRefBS* bs = barrier_set_cast<CardTableModRefBS>(Universe::heap()->barrier_set()); - assert(bs->kind() == BarrierSet::CardTableModRef || + assert(bs->kind() == BarrierSet::CardTableForRS || bs->kind() == BarrierSet::CardTableExtension, "wrong barrier"); card_table_write(bs->byte_map_base, tmp, store_addr); }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/cpu/sparc/vm/memset_with_concurrent_readers_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,159 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" + +#include "gc/shared/memset_with_concurrent_readers.hpp" +#include "runtime/prefetch.inline.hpp" +#include "utilities/debug.hpp" +#include "utilities/globalDefinitions.hpp" +#include "utilities/macros.hpp" + +#if INCLUDE_ALL_GCS + +// An implementation of memset, for use when there may be concurrent +// readers of the region being stored into. +// +// We can't use the standard library memset if it is implemented using +// block initializing stores. Doing so can result in concurrent readers +// seeing spurious zeros. +// +// We can't use the obvious C/C++ for-loop, because the compiler may +// recognize the idiomatic loop and optimize it into a call to the +// standard library memset; we've seen exactly this happen with, for +// example, Solaris Studio 12.3. Hence the use of inline assembly +// code, hiding loops from the compiler's optimizer. +// +// We don't attempt to use the standard library memset when it is safe +// to do so. We could conservatively do so by detecting the presence +// of block initializing stores (VM_Version::has_blk_init()), but the +// implementation provided here should be sufficient. + +inline void fill_subword(void* start, void* end, int value) { + STATIC_ASSERT(BytesPerWord == 8); + assert(pointer_delta(end, start, 1) < BytesPerWord, "precondition"); + // Dispatch on (end - start). + void* pc; + __asm__ volatile( + // offset := (7 - (end - start)) + 3 + // 3 instructions from rdpc to DISPATCH + " sub %[offset], %[end], %[offset]\n\t" // offset := start - end + " sllx %[offset], 2, %[offset]\n\t" // scale offset for instruction size of 4 + " add %[offset], 40, %[offset]\n\t" // offset += 10 * instruction size + " rd %pc, %[pc]\n\t" // dispatch on scaled offset + " jmpl %[pc]+%[offset], %g0\n\t" + " nop\n\t" + // DISPATCH: no direct reference, but without it the store block may be elided. + "1:\n\t" + " stb %[value], [%[end]-7]\n\t" // end[-7] = value + " stb %[value], [%[end]-6]\n\t" + " stb %[value], [%[end]-5]\n\t" + " stb %[value], [%[end]-4]\n\t" + " stb %[value], [%[end]-3]\n\t" + " stb %[value], [%[end]-2]\n\t" + " stb %[value], [%[end]-1]\n\t" // end[-1] = value + : /* no outputs */ + [pc] "&=r" (pc) // temp + : [offset] "&+r" (start), + [end] "r" (end), + [value] "r" (value) + : "memory"); +} + +void memset_with_concurrent_readers(void* to, int value, size_t size) { + Prefetch::write(to, 0); + void* end = static_cast<char*>(to) + size; + if (size >= BytesPerWord) { + // Fill any partial word prefix. + uintx* aligned_to = static_cast<uintx*>(align_ptr_up(to, BytesPerWord)); + fill_subword(to, aligned_to, value); + + // Compute fill word. + STATIC_ASSERT(BitsPerByte == 8); + STATIC_ASSERT(BitsPerWord == 64); + uintx xvalue = value & 0xff; + xvalue |= (xvalue << 8); + xvalue |= (xvalue << 16); + xvalue |= (xvalue << 32); + + uintx* aligned_end = static_cast<uintx*>(align_ptr_down(end, BytesPerWord)); + assert(aligned_to <= aligned_end, "invariant"); + + // for ( ; aligned_to < aligned_end; ++aligned_to) { + // *aligned_to = xvalue; + // } + uintptr_t temp; + __asm__ volatile( + // Unroll loop x8. + " sub %[aend], %[ato], %[temp]\n\t" + " cmp %[temp], 56\n\t" // cc := (aligned_end - aligned_to) > 7 words + " ba %xcc, 2f\n\t" // goto TEST always + " sub %[aend], 56, %[temp]\n\t" // limit := aligned_end - 7 words + // LOOP: + "1:\n\t" // unrolled x8 store loop top + " cmp %[temp], %[ato]\n\t" // cc := limit > (next) aligned_to + " stx %[xvalue], [%[ato]-64]\n\t" // store 8 words, aligned_to pre-incremented + " stx %[xvalue], [%[ato]-56]\n\t" + " stx %[xvalue], [%[ato]-48]\n\t" + " stx %[xvalue], [%[ato]-40]\n\t" + " stx %[xvalue], [%[ato]-32]\n\t" + " stx %[xvalue], [%[ato]-24]\n\t" + " stx %[xvalue], [%[ato]-16]\n\t" + " stx %[xvalue], [%[ato]-8]\n\t" + // TEST: + "2:\n\t" + " bgu,a %xcc, 1b\n\t" // goto LOOP if more than 7 words remaining + " add %[ato], 64, %[ato]\n\t" // aligned_to += 8, for next iteration + // Fill remaining < 8 full words. + // Dispatch on (aligned_end - aligned_to). + // offset := (7 - (aligned_end - aligned_to)) + 3 + // 3 instructions from rdpc to DISPATCH + " sub %[ato], %[aend], %[ato]\n\t" // offset := aligned_to - aligned_end + " srax %[ato], 1, %[ato]\n\t" // scale offset for instruction size of 4 + " add %[ato], 40, %[ato]\n\t" // offset += 10 * instruction size + " rd %pc, %[temp]\n\t" // dispatch on scaled offset + " jmpl %[temp]+%[ato], %g0\n\t" + " nop\n\t" + // DISPATCH: no direct reference, but without it the store block may be elided. + "3:\n\t" + " stx %[xvalue], [%[aend]-56]\n\t" // aligned_end[-7] = xvalue + " stx %[xvalue], [%[aend]-48]\n\t" + " stx %[xvalue], [%[aend]-40]\n\t" + " stx %[xvalue], [%[aend]-32]\n\t" + " stx %[xvalue], [%[aend]-24]\n\t" + " stx %[xvalue], [%[aend]-16]\n\t" + " stx %[xvalue], [%[aend]-8]\n\t" // aligned_end[-1] = xvalue + : /* no outputs */ + [temp] "&=r" (temp) + : [ato] "&+r" (aligned_to), + [aend] "r" (aligned_end), + [xvalue] "r" (xvalue) + : "cc", "memory"); + to = aligned_end; // setup for suffix + } + // Fill any partial word suffix. Also the prefix if size < BytesPerWord. + fill_subword(to, end, value); +} + +#endif // INCLUDE_ALL_GCS
--- a/src/cpu/sparc/vm/stubGenerator_sparc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/sparc/vm/stubGenerator_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -981,7 +981,7 @@ __ restore(); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -1014,7 +1014,7 @@ __ restore(); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(bs); @@ -5110,6 +5110,188 @@ return start; } +#define ADLER32_NUM_TEMPS 16 + + /** + * Arguments: + * + * Inputs: + * O0 - int adler + * O1 - byte* buff + * O2 - int len + * + * Output: + * O0 - int adler result + */ + address generate_updateBytesAdler32() { + __ align(CodeEntryAlignment); + StubCodeMark mark(this, "StubRoutines", "updateBytesAdler32"); + address start = __ pc(); + + Label L_cleanup_loop, L_cleanup_loop_check; + Label L_main_loop_check, L_main_loop, L_inner_loop, L_inner_loop_check; + Label L_nmax_check_done; + + // Aliases + Register s1 = O0; + Register s2 = O3; + Register buff = O1; + Register len = O2; + Register temp[ADLER32_NUM_TEMPS] = {L0, L1, L2, L3, L4, L5, L6, L7, I0, I1, I2, I3, I4, I5, G3, I7}; + + // Max number of bytes we can process before having to take the mod + // 0x15B0 is 5552 in decimal, the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 + unsigned long NMAX = 0x15B0; + + // Zero-out the upper bits of len + __ clruwu(len); + + // Create the mask 0xFFFF + __ set64(0x00FFFF, O4, O5); // O5 is the temp register + + // s1 is initialized to the lower 16 bits of adler + // s2 is initialized to the upper 16 bits of adler + __ srlx(O0, 16, O5); // adler >> 16 + __ and3(O0, O4, s1); // s1 = (adler & 0xFFFF) + __ and3(O5, O4, s2); // s2 = ((adler >> 16) & 0xFFFF) + + // The pipelined loop needs at least 16 elements for 1 iteration + // It does check this, but it is more effective to skip to the cleanup loop + // Setup the constant for cutoff checking + __ mov(15, O4); + + // Check if we are above the cutoff, if not go to the cleanup loop immediately + __ cmp_and_br_short(len, O4, Assembler::lessEqualUnsigned, Assembler::pt, L_cleanup_loop_check); + + // Free up some registers for our use + for (int i = 0; i < ADLER32_NUM_TEMPS; i++) { + __ movxtod(temp[i], as_FloatRegister(2*i)); + } + + // Loop maintenance stuff is done at the end of the loop, so skip to there + __ ba_short(L_main_loop_check); + + __ BIND(L_main_loop); + + // Prologue for inner loop + __ ldub(buff, 0, L0); + __ dec(O5); + + for (int i = 1; i < 8; i++) { + __ ldub(buff, i, temp[i]); + } + + __ inc(buff, 8); + + // Inner loop processes 16 elements at a time, might never execute if only 16 elements + // to be processed by the outter loop + __ ba_short(L_inner_loop_check); + + __ BIND(L_inner_loop); + + for (int i = 0; i < 8; i++) { + __ ldub(buff, (2*i), temp[(8+(2*i)) % ADLER32_NUM_TEMPS]); + __ add(s1, temp[i], s1); + __ ldub(buff, (2*i)+1, temp[(8+(2*i)+1) % ADLER32_NUM_TEMPS]); + __ add(s2, s1, s2); + } + + // Original temp 0-7 used and new loads to temp 0-7 issued + // temp 8-15 ready to be consumed + __ add(s1, I0, s1); + __ dec(O5); + __ add(s2, s1, s2); + __ add(s1, I1, s1); + __ inc(buff, 16); + __ add(s2, s1, s2); + + for (int i = 0; i < 6; i++) { + __ add(s1, temp[10+i], s1); + __ add(s2, s1, s2); + } + + __ BIND(L_inner_loop_check); + __ nop(); + __ cmp_and_br_short(O5, 0, Assembler::notEqual, Assembler::pt, L_inner_loop); + + // Epilogue + for (int i = 0; i < 4; i++) { + __ ldub(buff, (2*i), temp[8+(2*i)]); + __ add(s1, temp[i], s1); + __ ldub(buff, (2*i)+1, temp[8+(2*i)+1]); + __ add(s2, s1, s2); + } + + __ add(s1, temp[4], s1); + __ inc(buff, 8); + + for (int i = 0; i < 11; i++) { + __ add(s2, s1, s2); + __ add(s1, temp[5+i], s1); + } + + __ add(s2, s1, s2); + + // Take the mod for s1 and s2 + __ set64(0xFFF1, L0, L1); + __ udivx(s1, L0, L1); + __ udivx(s2, L0, L2); + __ mulx(L0, L1, L1); + __ mulx(L0, L2, L2); + __ sub(s1, L1, s1); + __ sub(s2, L2, s2); + + // Make sure there is something left to process + __ BIND(L_main_loop_check); + __ set64(NMAX, L0, L1); + // k = len < NMAX ? len : NMAX + __ cmp_and_br_short(len, L0, Assembler::greaterEqualUnsigned, Assembler::pt, L_nmax_check_done); + __ andn(len, 0x0F, L0); // only loop a multiple of 16 times + __ BIND(L_nmax_check_done); + __ mov(L0, O5); + __ sub(len, L0, len); // len -= k + + __ srlx(O5, 4, O5); // multiplies of 16 + __ cmp_and_br_short(O5, 0, Assembler::notEqual, Assembler::pt, L_main_loop); + + // Restore anything we used, take the mod one last time, combine and return + // Restore any registers we saved + for (int i = 0; i < ADLER32_NUM_TEMPS; i++) { + __ movdtox(as_FloatRegister(2*i), temp[i]); + } + + // There might be nothing left to process + __ ba_short(L_cleanup_loop_check); + + __ BIND(L_cleanup_loop); + __ ldub(buff, 0, O4); // load single byte form buffer + __ inc(buff); // buff++ + __ add(s1, O4, s1); // s1 += *buff++; + __ dec(len); // len-- + __ add(s1, s2, s2); // s2 += s1; + __ BIND(L_cleanup_loop_check); + __ nop(); + __ cmp_and_br_short(len, 0, Assembler::notEqual, Assembler::pt, L_cleanup_loop); + + // Take the mod one last time + __ set64(0xFFF1, O1, O2); + __ udivx(s1, O1, O2); + __ udivx(s2, O1, O5); + __ mulx(O1, O2, O2); + __ mulx(O1, O5, O5); + __ sub(s1, O2, s1); + __ sub(s2, O5, s2); + + // Combine lower bits and higher bits + __ sllx(s2, 16, s2); // s2 = s2 << 16 + __ or3(s1, s2, s1); // adler = s2 | s1 + // Final return value is in O0 + __ retl(); + __ delayed()->nop(); + + return start; + } + void generate_initial() { // Generates all stubs and initializes the entry points @@ -5206,6 +5388,11 @@ if (UseCRC32CIntrinsics) { StubRoutines::_updateBytesCRC32C = generate_updateBytesCRC32C(); } + + // generate Adler32 intrinsics code + if (UseAdler32Intrinsics) { + StubRoutines::_updateBytesAdler32 = generate_updateBytesAdler32(); + } }
--- a/src/cpu/sparc/vm/stubRoutines_sparc.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/sparc/vm/stubRoutines_sparc.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -41,7 +41,7 @@ enum /* platform_dependent_constants */ { // %%%%%%%% May be able to shrink this a lot code_size1 = 20000, // simply increase if too small (assembler will crash if too small) - code_size2 = 24000 // simply increase if too small (assembler will crash if too small) + code_size2 = 27000 // simply increase if too small (assembler will crash if too small) }; class Sparc {
--- a/src/cpu/sparc/vm/templateTable_sparc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/sparc/vm/templateTable_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -91,7 +91,7 @@ } break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { if (index == noreg ) {
--- a/src/cpu/sparc/vm/vm_version_sparc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/sparc/vm/vm_version_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -85,27 +85,6 @@ _supports_cx8 = has_v9(); _supports_atomic_getset4 = true; // swap instruction - // There are Fujitsu Sparc64 CPUs which support blk_init as well so - // we have to take this check out of the 'is_niagara()' block below. - if (has_blk_init()) { - // When using CMS or G1, we cannot use memset() in BOT updates - // because the sun4v/CMT version in libc_psr uses BIS which - // exposes "phantom zeros" to concurrent readers. See 6948537. - if (FLAG_IS_DEFAULT(UseMemSetInBOT) && (UseConcMarkSweepGC || UseG1GC)) { - FLAG_SET_DEFAULT(UseMemSetInBOT, false); - } - // Issue a stern warning if the user has explicitly set - // UseMemSetInBOT (it is known to cause issues), but allow - // use for experimentation and debugging. - if (UseConcMarkSweepGC || UseG1GC) { - if (UseMemSetInBOT) { - assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error"); - warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability" - " on sun4v; please understand that you are using at your own risk!"); - } - } - } - if (is_niagara()) { // Indirect branch is the same cost as direct if (FLAG_IS_DEFAULT(UseInlineCaches)) { @@ -377,6 +356,15 @@ FLAG_SET_DEFAULT(UseCRC32CIntrinsics, false); } + if (UseVIS > 2) { + if (FLAG_IS_DEFAULT(UseAdler32Intrinsics)) { + FLAG_SET_DEFAULT(UseAdler32Intrinsics, true); + } + } else if (UseAdler32Intrinsics) { + warning("SPARC Adler32 intrinsics require VIS3 instruction support. Intrinsics will be disabled."); + FLAG_SET_DEFAULT(UseAdler32Intrinsics, false); + } + if (FLAG_IS_DEFAULT(ContendedPaddingWidth) && (cache_line_size > ContendedPaddingWidth)) ContendedPaddingWidth = cache_line_size;
--- a/src/cpu/x86/vm/assembler_x86.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/assembler_x86.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1674,6 +1674,13 @@ emit_simd_arith(0x2A, dst, src, VEX_SIMD_F3, true); } +void Assembler::cvtsi2ssq(XMMRegister dst, Register src) { + NOT_LP64(assert(VM_Version::supports_sse(), "")); + int encode = simd_prefix_and_encode_q(dst, dst, src, VEX_SIMD_F3, true); + emit_int8(0x2A); + emit_int8((unsigned char)(0xC0 | encode)); +} + void Assembler::cvtss2sd(XMMRegister dst, XMMRegister src) { NOT_LP64(assert(VM_Version::supports_sse2(), "")); emit_simd_arith(0x5A, dst, src, VEX_SIMD_F3); @@ -6604,13 +6611,6 @@ emit_operand(dst, src); } -void Assembler::cvtsi2ssq(XMMRegister dst, Register src) { - NOT_LP64(assert(VM_Version::supports_sse(), "")); - int encode = simd_prefix_and_encode_q(dst, dst, src, VEX_SIMD_F3, true); - emit_int8(0x2A); - emit_int8((unsigned char)(0xC0 | encode)); -} - void Assembler::cvtsi2ssq(XMMRegister dst, Address src) { NOT_LP64(assert(VM_Version::supports_sse(), "")); if (VM_Version::supports_evex()) {
--- a/src/cpu/x86/vm/interp_masm_x86.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/interp_masm_x86.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -355,8 +355,8 @@ case ctos: // fall through case stos: // fall through case itos: movl(rax, val_addr); break; - case ftos: movflt(xmm0, val_addr); break; - case dtos: movdbl(xmm0, val_addr); break; + case ftos: load_float(val_addr); break; + case dtos: load_double(val_addr); break; case vtos: /* nothing to do */ break; default : ShouldNotReachHere(); } @@ -376,8 +376,8 @@ case ctos: // fall through case stos: // fall through case itos: movl(rax, val_addr); break; - case ftos: fld_s(val_addr); break; - case dtos: fld_d(val_addr); break; + case ftos: load_float(val_addr); break; + case dtos: load_double(val_addr); break; case vtos: /* nothing to do */ break; default : ShouldNotReachHere(); } @@ -578,6 +578,26 @@ push(r); } +void InterpreterMacroAssembler::push_f(XMMRegister r) { + subptr(rsp, wordSize); + movflt(Address(rsp, 0), r); +} + +void InterpreterMacroAssembler::pop_f(XMMRegister r) { + movflt(r, Address(rsp, 0)); + addptr(rsp, wordSize); +} + +void InterpreterMacroAssembler::push_d(XMMRegister r) { + subptr(rsp, 2 * wordSize); + movdbl(Address(rsp, 0), r); +} + +void InterpreterMacroAssembler::pop_d(XMMRegister r) { + movdbl(r, Address(rsp, 0)); + addptr(rsp, 2 * Interpreter::stackElementSize); +} + #ifdef _LP64 void InterpreterMacroAssembler::pop_i(Register r) { // XXX can't use pop currently, upper half non clean @@ -590,31 +610,11 @@ addptr(rsp, 2 * Interpreter::stackElementSize); } -void InterpreterMacroAssembler::pop_f(XMMRegister r) { - movflt(r, Address(rsp, 0)); - addptr(rsp, wordSize); -} - -void InterpreterMacroAssembler::pop_d(XMMRegister r) { - movdbl(r, Address(rsp, 0)); - addptr(rsp, 2 * Interpreter::stackElementSize); -} - void InterpreterMacroAssembler::push_l(Register r) { subptr(rsp, 2 * wordSize); movq(Address(rsp, 0), r); } -void InterpreterMacroAssembler::push_f(XMMRegister r) { - subptr(rsp, wordSize); - movflt(Address(rsp, 0), r); -} - -void InterpreterMacroAssembler::push_d(XMMRegister r) { - subptr(rsp, 2 * wordSize); - movdbl(Address(rsp, 0), r); -} - void InterpreterMacroAssembler::pop(TosState state) { switch (state) { case atos: pop_ptr(); break; @@ -623,8 +623,8 @@ case stos: case itos: pop_i(); break; case ltos: pop_l(); break; - case ftos: pop_f(); break; - case dtos: pop_d(); break; + case ftos: pop_f(xmm0); break; + case dtos: pop_d(xmm0); break; case vtos: /* nothing to do */ break; default: ShouldNotReachHere(); } @@ -640,8 +640,8 @@ case stos: case itos: push_i(); break; case ltos: push_l(); break; - case ftos: push_f(); break; - case dtos: push_d(); break; + case ftos: push_f(xmm0); break; + case dtos: push_d(xmm0); break; case vtos: /* nothing to do */ break; default : ShouldNotReachHere(); } @@ -675,8 +675,20 @@ case stos: // fall through case itos: pop_i(rax); break; case ltos: pop_l(rax, rdx); break; - case ftos: pop_f(); break; - case dtos: pop_d(); break; + case ftos: + if (UseSSE >= 1) { + pop_f(xmm0); + } else { + pop_f(); + } + break; + case dtos: + if (UseSSE >= 2) { + pop_d(xmm0); + } else { + pop_d(); + } + break; case vtos: /* nothing to do */ break; default : ShouldNotReachHere(); } @@ -695,7 +707,7 @@ fstp_s(Address(rsp, 0)); } -void InterpreterMacroAssembler::push_d(Register r) { +void InterpreterMacroAssembler::push_d() { // Do not schedule for no AGI! Never write beyond rsp! subptr(rsp, 2 * wordSize); fstp_d(Address(rsp, 0)); @@ -711,8 +723,20 @@ case stos: // fall through case itos: push_i(rax); break; case ltos: push_l(rax, rdx); break; - case ftos: push_f(); break; - case dtos: push_d(rax); break; + case ftos: + if (UseSSE >= 1) { + push_f(xmm0); + } else { + push_f(); + } + break; + case dtos: + if (UseSSE >= 2) { + push_d(xmm0); + } else { + push_d(); + } + break; case vtos: /* nothing to do */ break; default : ShouldNotReachHere(); } @@ -995,22 +1019,6 @@ leave(); // remove frame anchor pop(ret_addr); // get return address mov(rsp, rbx); // set sp to sender sp -#ifndef _LP64 - if (UseSSE) { - // float and double are returned in xmm register in SSE-mode - if (state == ftos && UseSSE >= 1) { - subptr(rsp, wordSize); - fstp_s(Address(rsp, 0)); - movflt(xmm0, Address(rsp, 0)); - addptr(rsp, wordSize); - } else if (state == dtos && UseSSE >= 2) { - subptr(rsp, 2*wordSize); - fstp_d(Address(rsp, 0)); - movdbl(xmm0, Address(rsp, 0)); - addptr(rsp, 2*wordSize); - } - } -#endif // _LP64 } #endif // !CC_INTERP @@ -1789,7 +1797,10 @@ void InterpreterMacroAssembler::verify_FPU(int stack_depth, TosState state) { #ifndef _LP64 - if (state == ftos || state == dtos) MacroAssembler::verify_FPU(stack_depth); + if ((state == ftos && UseSSE < 1) || + (state == dtos && UseSSE < 2)) { + MacroAssembler::verify_FPU(stack_depth); + } #endif }
--- a/src/cpu/x86/vm/interp_masm_x86.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/interp_masm_x86.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -140,20 +140,20 @@ void push_ptr(Register r = rax); void push_i(Register r = rax); + void push_f(XMMRegister r); + void pop_f(XMMRegister r); + void pop_d(XMMRegister r); + void push_d(XMMRegister r); #ifdef _LP64 void pop_l(Register r = rax); - void pop_f(XMMRegister r = xmm0); - void pop_d(XMMRegister r = xmm0); void push_l(Register r = rax); - void push_f(XMMRegister r = xmm0); - void push_d(XMMRegister r = xmm0); #else void pop_l(Register lo = rax, Register hi = rdx); void pop_f(); void pop_d(); void push_l(Register lo = rax, Register hi = rdx); - void push_d(Register r = rax); + void push_d(); void push_f(); #endif // _LP64
--- a/src/cpu/x86/vm/interpreterGenerator_x86.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/interpreterGenerator_x86.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -42,6 +42,12 @@ address generate_Reference_get_entry(); address generate_CRC32_update_entry(); address generate_CRC32_updateBytes_entry(AbstractInterpreter::MethodKind kind); +#ifndef _LP64 + address generate_Float_intBitsToFloat_entry(); + address generate_Float_floatToRawIntBits_entry(); + address generate_Double_longBitsToDouble_entry(); + address generate_Double_doubleToRawLongBits_entry(); +#endif void lock_method(void); void generate_stack_overflow_check(void);
--- a/src/cpu/x86/vm/macroAssembler_x86.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/macroAssembler_x86.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3314,6 +3314,42 @@ fincstp(); } +void MacroAssembler::load_float(Address src) { + if (UseSSE >= 1) { + movflt(xmm0, src); + } else { + LP64_ONLY(ShouldNotReachHere()); + NOT_LP64(fld_s(src)); + } +} + +void MacroAssembler::store_float(Address dst) { + if (UseSSE >= 1) { + movflt(dst, xmm0); + } else { + LP64_ONLY(ShouldNotReachHere()); + NOT_LP64(fstp_s(dst)); + } +} + +void MacroAssembler::load_double(Address src) { + if (UseSSE >= 2) { + movdbl(xmm0, src); + } else { + LP64_ONLY(ShouldNotReachHere()); + NOT_LP64(fld_d(src)); + } +} + +void MacroAssembler::store_double(Address dst) { + if (UseSSE >= 2) { + movdbl(dst, xmm0); + } else { + LP64_ONLY(ShouldNotReachHere()); + NOT_LP64(fstp_d(dst)); + } +} + void MacroAssembler::fremr(Register tmp) { save_rax(tmp); { Label L; @@ -4296,7 +4332,9 @@ // register obj is destroyed afterwards. BarrierSet* bs = Universe::heap()->barrier_set(); - assert(bs->kind() == BarrierSet::CardTableModRef, "Wrong barrier set kind"); + assert(bs->kind() == BarrierSet::CardTableForRS || + bs->kind() == BarrierSet::CardTableExtension, + "Wrong barrier set kind"); CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(bs); assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
--- a/src/cpu/x86/vm/macroAssembler_x86.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/macroAssembler_x86.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -471,6 +471,22 @@ // Pop ST (ffree & fincstp combined) void fpop(); + // Load float value from 'address'. If UseSSE >= 1, the value is loaded into + // register xmm0. Otherwise, the value is loaded onto the FPU stack. + void load_float(Address src); + + // Store float value to 'address'. If UseSSE >= 1, the value is stored + // from register xmm0. Otherwise, the value is stored from the FPU stack. + void store_float(Address dst); + + // Load double value from 'address'. If UseSSE >= 2, the value is loaded into + // register xmm0. Otherwise, the value is loaded onto the FPU stack. + void load_double(Address src); + + // Store double value to 'address'. If UseSSE >= 2, the value is stored + // from register xmm0. Otherwise, the value is stored from the FPU stack. + void store_double(Address dst); + // pushes double TOS element of FPU stack on CPU stack; pops from FPU stack void push_fTOS();
--- a/src/cpu/x86/vm/stubGenerator_x86_32.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/stubGenerator_x86_32.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -722,7 +722,7 @@ __ popa(); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -754,7 +754,7 @@ } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(bs);
--- a/src/cpu/x86/vm/stubGenerator_x86_64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/stubGenerator_x86_64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -367,16 +367,20 @@ #ifdef ASSERT // verify that threads correspond { - Label L, S; + Label L1, L2, L3; __ cmpptr(r15_thread, thread); - __ jcc(Assembler::notEqual, S); + __ jcc(Assembler::equal, L1); + __ stop("StubRoutines::call_stub: r15_thread is corrupted"); + __ bind(L1); __ get_thread(rbx); + __ cmpptr(r15_thread, thread); + __ jcc(Assembler::equal, L2); + __ stop("StubRoutines::call_stub: r15_thread is modified by call"); + __ bind(L2); __ cmpptr(r15_thread, rbx); - __ jcc(Assembler::equal, L); - __ bind(S); - __ jcc(Assembler::equal, L); + __ jcc(Assembler::equal, L3); __ stop("StubRoutines::call_stub: threads must correspond"); - __ bind(L); + __ bind(L3); } #endif @@ -450,15 +454,20 @@ #ifdef ASSERT // verify that threads correspond { - Label L, S; + Label L1, L2, L3; __ cmpptr(r15_thread, thread); - __ jcc(Assembler::notEqual, S); + __ jcc(Assembler::equal, L1); + __ stop("StubRoutines::catch_exception: r15_thread is corrupted"); + __ bind(L1); __ get_thread(rbx); + __ cmpptr(r15_thread, thread); + __ jcc(Assembler::equal, L2); + __ stop("StubRoutines::catch_exception: r15_thread is modified by call"); + __ bind(L2); __ cmpptr(r15_thread, rbx); - __ jcc(Assembler::equal, L); - __ bind(S); + __ jcc(Assembler::equal, L3); __ stop("StubRoutines::catch_exception: threads must correspond"); - __ bind(L); + __ bind(L3); } #endif @@ -1331,7 +1340,7 @@ __ popa(); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -1372,7 +1381,7 @@ __ popa(); } break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { CardTableModRefBS* ct = barrier_set_cast<CardTableModRefBS>(bs);
--- a/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/templateInterpreter_x86_32.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -170,22 +170,12 @@ __ MacroAssembler::verify_FPU(0, "generate_return_entry_for compiled"); } - // In SSE mode, interpreter returns FP results in xmm0 but they need - // to end up back on the FPU so it can operate on them. - if (state == ftos && UseSSE >= 1) { - __ subptr(rsp, wordSize); - __ movflt(Address(rsp, 0), xmm0); - __ fld_s(Address(rsp, 0)); - __ addptr(rsp, wordSize); - } else if (state == dtos && UseSSE >= 2) { - __ subptr(rsp, 2*wordSize); - __ movdbl(Address(rsp, 0), xmm0); - __ fld_d(Address(rsp, 0)); - __ addptr(rsp, 2*wordSize); + if (state == ftos) { + __ MacroAssembler::verify_FPU(UseSSE >= 1 ? 0 : 1, "generate_return_entry_for in interpreter"); + } else if (state == dtos) { + __ MacroAssembler::verify_FPU(UseSSE >= 2 ? 0 : 1, "generate_return_entry_for in interpreter"); } - __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_return_entry_for in interpreter"); - // Restore stack bottom in case i2c adjusted stack __ movptr(rsp, Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize)); // and NULL it as marker that rsp is now tos until next java call @@ -217,21 +207,12 @@ address TemplateInterpreterGenerator::generate_deopt_entry_for(TosState state, int step) { address entry = __ pc(); - // In SSE mode, FP results are in xmm0 - if (state == ftos && UseSSE > 0) { - __ subptr(rsp, wordSize); - __ movflt(Address(rsp, 0), xmm0); - __ fld_s(Address(rsp, 0)); - __ addptr(rsp, wordSize); - } else if (state == dtos && UseSSE >= 2) { - __ subptr(rsp, 2*wordSize); - __ movdbl(Address(rsp, 0), xmm0); - __ fld_d(Address(rsp, 0)); - __ addptr(rsp, 2*wordSize); + if (state == ftos) { + __ MacroAssembler::verify_FPU(UseSSE >= 1 ? 0 : 1, "generate_deopt_entry_for in interpreter"); + } else if (state == dtos) { + __ MacroAssembler::verify_FPU(UseSSE >= 2 ? 0 : 1, "generate_deopt_entry_for in interpreter"); } - __ MacroAssembler::verify_FPU(state == ftos || state == dtos ? 1 : 0, "generate_deopt_entry_for in interpreter"); - // The stack is not extended by deopt but we must NULL last_sp as this // entry is like a "return". __ movptr(Address(rbp, frame::interpreter_frame_last_sp_offset * wordSize), NULL_WORD); @@ -735,7 +716,7 @@ if (UseCRC32Intrinsics) { address entry = __ pc(); - // rbx,: Method* + // rbx: Method* // rsi: senderSP must preserved for slow path, set SP to it on fast path // rdx: scratch // rdi: scratch @@ -841,6 +822,124 @@ return generate_native_entry(false); } +/** + * Method entry for static native method: + * java.lang.Float.intBitsToFloat(int bits) + */ +address InterpreterGenerator::generate_Float_intBitsToFloat_entry() { + address entry; + + if (UseSSE >= 1) { + entry = __ pc(); + + // rsi: the sender's SP + + // Skip safepoint check (compiler intrinsic versions of this method + // do not perform safepoint checks either). + + // Load 'bits' into xmm0 (interpreter returns results in xmm0) + __ movflt(xmm0, Address(rsp, wordSize)); + + // Return + __ pop(rdi); // get return address + __ mov(rsp, rsi); // set rsp to the sender's SP + __ jmp(rdi); + } else { + entry = generate_native_entry(false); + } + + return entry; +} + +/** + * Method entry for static native method: + * java.lang.Float.floatToRawIntBits(float value) + */ +address InterpreterGenerator::generate_Float_floatToRawIntBits_entry() { + address entry; + + if (UseSSE >= 1) { + entry = __ pc(); + + // rsi: the sender's SP + + // Skip safepoint check (compiler intrinsic versions of this method + // do not perform safepoint checks either). + + // Load the parameter (a floating-point value) into rax. + __ movl(rax, Address(rsp, wordSize)); + + // Return + __ pop(rdi); // get return address + __ mov(rsp, rsi); // set rsp to the sender's SP + __ jmp(rdi); + } else { + entry = generate_native_entry(false); + } + + return entry; +} + + +/** + * Method entry for static native method: + * java.lang.Double.longBitsToDouble(long bits) + */ +address InterpreterGenerator::generate_Double_longBitsToDouble_entry() { + address entry; + + if (UseSSE >= 2) { + entry = __ pc(); + + // rsi: the sender's SP + + // Skip safepoint check (compiler intrinsic versions of this method + // do not perform safepoint checks either). + + // Load 'bits' into xmm0 (interpreter returns results in xmm0) + __ movdbl(xmm0, Address(rsp, wordSize)); + + // Return + __ pop(rdi); // get return address + __ mov(rsp, rsi); // set rsp to the sender's SP + __ jmp(rdi); + } else { + entry = generate_native_entry(false); + } + + return entry; +} + +/** + * Method entry for static native method: + * java.lang.Double.doubleToRawLongBits(double value) + */ +address InterpreterGenerator::generate_Double_doubleToRawLongBits_entry() { + address entry; + + if (UseSSE >= 2) { + entry = __ pc(); + + // rsi: the sender's SP + + // Skip safepoint check (compiler intrinsic versions of this method + // do not perform safepoint checks either). + + // Load the parameter (a floating-point value) into rax. + __ movl(rdx, Address(rsp, 2*wordSize)); + __ movl(rax, Address(rsp, wordSize)); + + // Return + __ pop(rdi); // get return address + __ mov(rsp, rsi); // set rsp to the sender's SP + __ jmp(rdi); + } else { + entry = generate_native_entry(false); + } + + return entry; +} + // // Interpreter stub for calling a native method. (asm interpreter) // This sets up a somewhat different looking stack for calling the native method @@ -1090,7 +1189,7 @@ double_handler.addr()); __ jcc(Assembler::notEqual, L); __ bind(push_double); - __ push(dtos); + __ push_d(); // FP values are returned using the FPU, so push FPU contents (even if UseSSE > 0). __ bind(L); } __ push(ltos);
--- a/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/templateInterpreter_x86_64.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1711,10 +1711,10 @@ address& vep) { assert(t->is_valid() && t->tos_in() == vtos, "illegal template"); Label L; - aep = __ pc(); __ push_ptr(); __ jmp(L); - fep = __ pc(); __ push_f(); __ jmp(L); - dep = __ pc(); __ push_d(); __ jmp(L); - lep = __ pc(); __ push_l(); __ jmp(L); + aep = __ pc(); __ push_ptr(); __ jmp(L); + fep = __ pc(); __ push_f(xmm0); __ jmp(L); + dep = __ pc(); __ push_d(xmm0); __ jmp(L); + lep = __ pc(); __ push_l(); __ jmp(L); bep = cep = sep = iep = __ pc(); __ push_i(); vep = __ pc();
--- a/src/cpu/x86/vm/templateTable_x86.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/templateTable_x86.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -204,7 +204,7 @@ } break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: { if (val == noreg) { @@ -353,53 +353,60 @@ void TemplateTable::fconst(int value) { transition(vtos, ftos); + if (UseSSE >= 1) { + static float one = 1.0f, two = 2.0f; + switch (value) { + case 0: + __ xorps(xmm0, xmm0); + break; + case 1: + __ movflt(xmm0, ExternalAddress((address) &one)); + break; + case 2: + __ movflt(xmm0, ExternalAddress((address) &two)); + break; + default: + ShouldNotReachHere(); + break; + } + } else { #ifdef _LP64 - static float one = 1.0f, two = 2.0f; - switch (value) { - case 0: - __ xorps(xmm0, xmm0); - break; - case 1: - __ movflt(xmm0, ExternalAddress((address) &one)); - break; - case 2: - __ movflt(xmm0, ExternalAddress((address) &two)); - break; - default: ShouldNotReachHere(); - break; +#else + if (value == 0) { __ fldz(); + } else if (value == 1) { __ fld1(); + } else if (value == 2) { __ fld1(); __ fld1(); __ faddp(); // should do a better solution here + } else { ShouldNotReachHere(); + } +#endif // _LP64 } -#else - if (value == 0) { __ fldz(); - } else if (value == 1) { __ fld1(); - } else if (value == 2) { __ fld1(); __ fld1(); __ faddp(); // should do a better solution here - } else { ShouldNotReachHere(); - } -#endif } void TemplateTable::dconst(int value) { transition(vtos, dtos); + if (UseSSE >= 2) { + static double one = 1.0; + switch (value) { + case 0: + __ xorpd(xmm0, xmm0); + break; + case 1: + __ movdbl(xmm0, ExternalAddress((address) &one)); + break; + default: + ShouldNotReachHere(); + break; + } + } else { #ifdef _LP64 - static double one = 1.0; - switch (value) { - case 0: - __ xorpd(xmm0, xmm0); - break; - case 1: - __ movdbl(xmm0, ExternalAddress((address) &one)); - break; - default: ShouldNotReachHere(); - break; +#else + if (value == 0) { __ fldz(); + } else if (value == 1) { __ fld1(); + } else { ShouldNotReachHere(); + } +#endif } - -#else - if (value == 0) { __ fldz(); - } else if (value == 1) { __ fld1(); - } else { ShouldNotReachHere(); - } -#endif } void TemplateTable::bipush() { @@ -458,8 +465,7 @@ __ jccb(Assembler::notEqual, notFloat); // ftos - LP64_ONLY(__ movflt(xmm0, Address(rcx, rbx, Address::times_8, base_offset))); - NOT_LP64(__ fld_s( Address(rcx, rbx, Address::times_ptr, base_offset))); + __ load_float(Address(rcx, rbx, Address::times_ptr, base_offset)); __ push(ftos); __ jmp(Done); @@ -526,8 +532,7 @@ __ jccb(Assembler::notEqual, Long); // dtos - LP64_ONLY(__ movdbl(xmm0, Address(rcx, rbx, Address::times_8, base_offset))); - NOT_LP64(__ fld_d( Address(rcx, rbx, Address::times_ptr, base_offset))); + __ load_double(Address(rcx, rbx, Address::times_ptr, base_offset)); __ push(dtos); __ jmpb(Done); @@ -621,15 +626,13 @@ void TemplateTable::fload() { transition(vtos, ftos); locals_index(rbx); - LP64_ONLY(__ movflt(xmm0, faddress(rbx))); - NOT_LP64(__ fld_s(faddress(rbx))); + __ load_float(faddress(rbx)); } void TemplateTable::dload() { transition(vtos, dtos); locals_index(rbx); - LP64_ONLY(__ movdbl(xmm0, daddress(rbx))); - NOT_LP64(__ fld_d(daddress(rbx))); + __ load_double(daddress(rbx)); } void TemplateTable::aload() { @@ -661,15 +664,13 @@ void TemplateTable::wide_fload() { transition(vtos, ftos); locals_index_wide(rbx); - LP64_ONLY(__ movflt(xmm0, faddress(rbx))); - NOT_LP64(__ fld_s(faddress(rbx))); + __ load_float(faddress(rbx)); } void TemplateTable::wide_dload() { transition(vtos, dtos); locals_index_wide(rbx); - LP64_ONLY(__ movdbl(xmm0, daddress(rbx))); - NOT_LP64(__ fld_d(daddress(rbx))); + __ load_double(daddress(rbx)); } void TemplateTable::wide_aload() { @@ -738,10 +739,9 @@ // rdx: array index_check(rdx, rax); // kills rbx oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx); - LP64_ONLY(__ movflt(xmm0, Address(rdx, rax, - Address::times_4, - arrayOopDesc::base_offset_in_bytes(T_FLOAT)))); - NOT_LP64(__ fld_s(Address(rdx, rax, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_FLOAT)))); + __ load_float(Address(rdx, rax, + Address::times_4, + arrayOopDesc::base_offset_in_bytes(T_FLOAT))); } void TemplateTable::daload() { @@ -750,10 +750,9 @@ // rdx: array index_check(rdx, rax); // kills rbx oopDesc::bs()->interpreter_read_barrier_not_null(_masm, rdx); - LP64_ONLY(__ movdbl(xmm0, Address(rdx, rax, - Address::times_8, - arrayOopDesc::base_offset_in_bytes(T_DOUBLE)))); - NOT_LP64(__ fld_d(Address(rdx, rax, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_DOUBLE)))); + __ load_double(Address(rdx, rax, + Address::times_8, + arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); } void TemplateTable::aaload() { @@ -825,14 +824,12 @@ void TemplateTable::fload(int n) { transition(vtos, ftos); - LP64_ONLY(__ movflt(xmm0, faddress(n))); - NOT_LP64(__ fld_s(faddress(n))); + __ load_float(faddress(n)); } void TemplateTable::dload(int n) { transition(vtos, dtos); - LP64_ONLY(__ movdbl(xmm0, daddress(n))); - NOT_LP64(__ fld_d(daddress(n))); + __ load_double(daddress(n)); } void TemplateTable::aload(int n) { @@ -937,15 +934,13 @@ void TemplateTable::fstore() { transition(ftos, vtos); locals_index(rbx); - LP64_ONLY(__ movflt(faddress(rbx), xmm0)); - NOT_LP64(__ fstp_s(faddress(rbx))); + __ store_float(faddress(rbx)); } void TemplateTable::dstore() { transition(dtos, vtos); locals_index(rbx); - LP64_ONLY(__ movdbl(daddress(rbx), xmm0)); - NOT_LP64(__ fstp_d(daddress(rbx))); + __ store_double(daddress(rbx)); } void TemplateTable::astore() { @@ -974,7 +969,7 @@ void TemplateTable::wide_fstore() { #ifdef _LP64 transition(vtos, vtos); - __ pop_f(); + __ pop_f(xmm0); locals_index_wide(rbx); __ movflt(faddress(rbx), xmm0); #else @@ -985,7 +980,7 @@ void TemplateTable::wide_dstore() { #ifdef _LP64 transition(vtos, vtos); - __ pop_d(); + __ pop_d(xmm0); locals_index_wide(rbx); __ movdbl(daddress(rbx), xmm0); #else @@ -1031,31 +1026,23 @@ void TemplateTable::fastore() { transition(ftos, vtos); __ pop_i(rbx); - // xmm0: value + // value is in UseSSE >= 1 ? xmm0 : ST(0) // rbx: index // rdx: array index_check(rdx, rbx); // prefer index in rbx oopDesc::bs()->interpreter_write_barrier(_masm, rdx); - LP64_ONLY(__ movflt(Address(rdx, rbx, - Address::times_4, - arrayOopDesc::base_offset_in_bytes(T_FLOAT)), - xmm0)); - NOT_LP64(__ fstp_s(Address(rdx, rbx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_FLOAT)))); + __ store_float(Address(rdx, rbx, Address::times_4, arrayOopDesc::base_offset_in_bytes(T_FLOAT))); } void TemplateTable::dastore() { transition(dtos, vtos); __ pop_i(rbx); - // xmm0: value + // value is in UseSSE >= 2 ? xmm0 : ST(0) // rbx: index // rdx: array index_check(rdx, rbx); // prefer index in rbx oopDesc::bs()->interpreter_write_barrier(_masm, rdx); - LP64_ONLY(__ movdbl(Address(rdx, rbx, - Address::times_8, - arrayOopDesc::base_offset_in_bytes(T_DOUBLE)), - xmm0)); - NOT_LP64(__ fstp_d(Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_DOUBLE)))); + __ store_double(Address(rdx, rbx, Address::times_8, arrayOopDesc::base_offset_in_bytes(T_DOUBLE))); } void TemplateTable::aastore() { @@ -1159,14 +1146,12 @@ void TemplateTable::fstore(int n) { transition(ftos, vtos); - LP64_ONLY(__ movflt(faddress(n), xmm0)); - NOT_LP64(__ fstp_s(faddress(n))); + __ store_float(faddress(n)); } void TemplateTable::dstore(int n) { transition(dtos, vtos); - LP64_ONLY(__ movdbl(daddress(n), xmm0)); - NOT_LP64(__ fstp_d(daddress(n))); + __ store_double(daddress(n)); } @@ -1450,82 +1435,127 @@ void TemplateTable::fop2(Operation op) { transition(ftos, ftos); + + if (UseSSE >= 1) { + switch (op) { + case add: + __ addss(xmm0, at_rsp()); + __ addptr(rsp, Interpreter::stackElementSize); + break; + case sub: + __ movflt(xmm1, xmm0); + __ pop_f(xmm0); + __ subss(xmm0, xmm1); + break; + case mul: + __ mulss(xmm0, at_rsp()); + __ addptr(rsp, Interpreter::stackElementSize); + break; + case div: + __ movflt(xmm1, xmm0); + __ pop_f(xmm0); + __ divss(xmm0, xmm1); + break; + case rem: + // On x86_64 platforms the SharedRuntime::frem method is called to perform the + // modulo operation. The frem method calls the function + // double fmod(double x, double y) in math.h. The documentation of fmod states: + // "If x or y is a NaN, a NaN is returned." without specifying what type of NaN + // (signalling or quiet) is returned. + // + // On x86_32 platforms the FPU is used to perform the modulo operation. The + // reason is that on 32-bit Windows the sign of modulo operations diverges from + // what is considered the standard (e.g., -0.0f % -3.14f is 0.0f (and not -0.0f). + // The fprem instruction used on x86_32 is functionally equivalent to + // SharedRuntime::frem in that it returns a NaN. #ifdef _LP64 - switch (op) { - case add: - __ addss(xmm0, at_rsp()); - __ addptr(rsp, Interpreter::stackElementSize); - break; - case sub: - __ movflt(xmm1, xmm0); - __ pop_f(xmm0); - __ subss(xmm0, xmm1); - break; - case mul: - __ mulss(xmm0, at_rsp()); - __ addptr(rsp, Interpreter::stackElementSize); - break; - case div: - __ movflt(xmm1, xmm0); - __ pop_f(xmm0); - __ divss(xmm0, xmm1); - break; - case rem: - __ movflt(xmm1, xmm0); - __ pop_f(xmm0); - __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem), 2); - break; - default: + __ movflt(xmm1, xmm0); + __ pop_f(xmm0); + __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::frem), 2); +#else + __ push_f(xmm0); + __ pop_f(); + __ fld_s(at_rsp()); + __ fremr(rax); + __ f2ieee(); + __ pop(rax); // pop second operand off the stack + __ push_f(); + __ pop_f(xmm0); +#endif + break; + default: + ShouldNotReachHere(); + break; + } + } else { +#ifdef _LP64 ShouldNotReachHere(); - break; - } #else - switch (op) { + switch (op) { case add: __ fadd_s (at_rsp()); break; case sub: __ fsubr_s(at_rsp()); break; case mul: __ fmul_s (at_rsp()); break; case div: __ fdivr_s(at_rsp()); break; case rem: __ fld_s (at_rsp()); __ fremr(rax); break; default : ShouldNotReachHere(); + } + __ f2ieee(); + __ pop(rax); // pop second operand off the stack +#endif // _LP64 } - __ f2ieee(); - __ pop(rax); // pop float thing off -#endif } void TemplateTable::dop2(Operation op) { transition(dtos, dtos); + if (UseSSE >= 2) { + switch (op) { + case add: + __ addsd(xmm0, at_rsp()); + __ addptr(rsp, 2 * Interpreter::stackElementSize); + break; + case sub: + __ movdbl(xmm1, xmm0); + __ pop_d(xmm0); + __ subsd(xmm0, xmm1); + break; + case mul: + __ mulsd(xmm0, at_rsp()); + __ addptr(rsp, 2 * Interpreter::stackElementSize); + break; + case div: + __ movdbl(xmm1, xmm0); + __ pop_d(xmm0); + __ divsd(xmm0, xmm1); + break; + case rem: + // Similar to fop2(), the modulo operation is performed using the + // SharedRuntime::drem method (on x86_64 platforms) or using the + // FPU (on x86_32 platforms) for the same reasons as mentioned in fop2(). #ifdef _LP64 - switch (op) { - case add: - __ addsd(xmm0, at_rsp()); - __ addptr(rsp, 2 * Interpreter::stackElementSize); - break; - case sub: - __ movdbl(xmm1, xmm0); - __ pop_d(xmm0); - __ subsd(xmm0, xmm1); - break; - case mul: - __ mulsd(xmm0, at_rsp()); - __ addptr(rsp, 2 * Interpreter::stackElementSize); - break; - case div: - __ movdbl(xmm1, xmm0); - __ pop_d(xmm0); - __ divsd(xmm0, xmm1); - break; - case rem: - __ movdbl(xmm1, xmm0); - __ pop_d(xmm0); - __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem), 2); - break; - default: + __ movdbl(xmm1, xmm0); + __ pop_d(xmm0); + __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::drem), 2); +#else + __ push_d(xmm0); + __ pop_d(); + __ fld_d(at_rsp()); + __ fremr(rax); + __ d2ieee(); + __ pop(rax); + __ pop(rdx); + __ push_d(); + __ pop_d(xmm0); +#endif + break; + default: + ShouldNotReachHere(); + break; + } + } else { +#ifdef _LP64 ShouldNotReachHere(); - break; - } #else - switch (op) { + switch (op) { case add: __ fadd_d (at_rsp()); break; case sub: __ fsubr_d(at_rsp()); break; case mul: { @@ -1568,12 +1598,13 @@ } case rem: __ fld_d (at_rsp()); __ fremr(rax); break; default : ShouldNotReachHere(); + } + __ d2ieee(); + // Pop double precision number from rsp. + __ pop(rax); + __ pop(rdx); +#endif } - __ d2ieee(); - // Pop double precision number from rsp. - __ pop(rax); - __ pop(rdx); -#endif } void TemplateTable::ineg() { @@ -1587,7 +1618,6 @@ NOT_LP64(__ lneg(rdx, rax)); } -#ifdef _LP64 // Note: 'double' and 'long long' have 32-bits alignment on x86. static jlong* double_quadword(jlong *adr, jlong lo, jlong hi) { // Use the expression (adr)&(~0xF) to provide 128-bits aligned address @@ -1602,26 +1632,30 @@ // Buffer for 128-bits masks used by SSE instructions. static jlong float_signflip_pool[2*2]; static jlong double_signflip_pool[2*2]; -#endif void TemplateTable::fneg() { transition(ftos, ftos); -#ifdef _LP64 - static jlong *float_signflip = double_quadword(&float_signflip_pool[1], 0x8000000080000000, 0x8000000080000000); - __ xorps(xmm0, ExternalAddress((address) float_signflip)); -#else - __ fchs(); -#endif + if (UseSSE >= 1) { + static jlong *float_signflip = double_quadword(&float_signflip_pool[1], 0x8000000080000000, 0x8000000080000000); + __ xorps(xmm0, ExternalAddress((address) float_signflip)); + } else { + LP64_ONLY(ShouldNotReachHere()); + NOT_LP64(__ fchs()); + } } void TemplateTable::dneg() { transition(dtos, dtos); + if (UseSSE >= 2) { + static jlong *double_signflip = double_quadword(&double_signflip_pool[1], 0x8000000000000000, 0x8000000000000000); + __ xorpd(xmm0, ExternalAddress((address) double_signflip)); + } else { #ifdef _LP64 - static jlong *double_signflip = double_quadword(&double_signflip_pool[1], 0x8000000000000000, 0x8000000000000000); - __ xorpd(xmm0, ExternalAddress((address) double_signflip)); + ShouldNotReachHere(); #else - __ fchs(); + __ fchs(); #endif + } } void TemplateTable::iinc() { @@ -1823,18 +1857,26 @@ __ extend_sign(rdx, rax); break; case Bytecodes::_i2f: - __ push(rax); // store int on tos - __ fild_s(at_rsp()); // load int to ST0 - __ f2ieee(); // truncate to float size - __ pop(rcx); // adjust rsp + if (UseSSE >= 1) { + __ cvtsi2ssl(xmm0, rax); + } else { + __ push(rax); // store int on tos + __ fild_s(at_rsp()); // load int to ST0 + __ f2ieee(); // truncate to float size + __ pop(rcx); // adjust rsp + } break; case Bytecodes::_i2d: + if (UseSSE >= 2) { + __ cvtsi2sdl(xmm0, rax); + } else { __ push(rax); // add one slot for d2ieee() __ push(rax); // store int on tos __ fild_s(at_rsp()); // load int to ST0 __ d2ieee(); // truncate to double size __ pop(rcx); // adjust rsp __ pop(rcx); + } break; case Bytecodes::_i2b: __ shll(rax, 24); // truncate upper 24 bits @@ -1854,50 +1896,102 @@ /* nothing to do */ break; case Bytecodes::_l2f: + // On 64-bit platforms, the cvtsi2ssq instruction is used to convert + // 64-bit long values to floats. On 32-bit platforms it is not possible + // to use that instruction with 64-bit operands, therefore the FPU is + // used to perform the conversion. __ push(rdx); // store long on tos __ push(rax); __ fild_d(at_rsp()); // load long to ST0 __ f2ieee(); // truncate to float size __ pop(rcx); // adjust rsp __ pop(rcx); + if (UseSSE >= 1) { + __ push_f(); + __ pop_f(xmm0); + } break; case Bytecodes::_l2d: + // On 32-bit platforms the FPU is used for conversion because on + // 32-bit platforms it is not not possible to use the cvtsi2sdq + // instruction with 64-bit operands. __ push(rdx); // store long on tos __ push(rax); __ fild_d(at_rsp()); // load long to ST0 __ d2ieee(); // truncate to double size __ pop(rcx); // adjust rsp __ pop(rcx); + if (UseSSE >= 2) { + __ push_d(); + __ pop_d(xmm0); + } break; case Bytecodes::_f2i: - __ push(rcx); // reserve space for argument - __ fstp_s(at_rsp()); // pass float argument on stack + // SharedRuntime::f2i does not differentiate between sNaNs and qNaNs + // as it returns 0 for any NaN. + if (UseSSE >= 1) { + __ push_f(xmm0); + } else { + __ push(rcx); // reserve space for argument + __ fstp_s(at_rsp()); // pass float argument on stack + } __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2i), 1); break; case Bytecodes::_f2l: - __ push(rcx); // reserve space for argument - __ fstp_s(at_rsp()); // pass float argument on stack + // SharedRuntime::f2l does not differentiate between sNaNs and qNaNs + // as it returns 0 for any NaN. + if (UseSSE >= 1) { + __ push_f(xmm0); + } else { + __ push(rcx); // reserve space for argument + __ fstp_s(at_rsp()); // pass float argument on stack + } __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::f2l), 1); break; case Bytecodes::_f2d: - /* nothing to do */ + if (UseSSE < 1) { + /* nothing to do */ + } else if (UseSSE == 1) { + __ push_f(xmm0); + __ pop_f(); + } else { // UseSSE >= 2 + __ cvtss2sd(xmm0, xmm0); + } break; case Bytecodes::_d2i: - __ push(rcx); // reserve space for argument - __ push(rcx); - __ fstp_d(at_rsp()); // pass double argument on stack + if (UseSSE >= 2) { + __ push_d(xmm0); + } else { + __ push(rcx); // reserve space for argument + __ push(rcx); + __ fstp_d(at_rsp()); // pass double argument on stack + } __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2i), 2); break; case Bytecodes::_d2l: - __ push(rcx); // reserve space for argument - __ push(rcx); - __ fstp_d(at_rsp()); // pass double argument on stack + if (UseSSE >= 2) { + __ push_d(xmm0); + } else { + __ push(rcx); // reserve space for argument + __ push(rcx); + __ fstp_d(at_rsp()); // pass double argument on stack + } __ call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::d2l), 2); break; case Bytecodes::_d2f: - __ push(rcx); // reserve space for f2ieee() - __ f2ieee(); // truncate to float size - __ pop(rcx); // adjust rsp + if (UseSSE <= 1) { + __ push(rcx); // reserve space for f2ieee() + __ f2ieee(); // truncate to float size + __ pop(rcx); // adjust rsp + if (UseSSE == 1) { + // The cvtsd2ss instruction is not available if UseSSE==1, therefore + // the conversion is performed using the FPU in this case. + __ push_f(); + __ pop_f(xmm0); + } + } else { // UseSSE >= 2 + __ cvtsd2ss(xmm0, xmm0); + } break; default : ShouldNotReachHere(); @@ -1926,42 +2020,47 @@ } void TemplateTable::float_cmp(bool is_float, int unordered_result) { -#ifdef _LP64 - Label done; - if (is_float) { - // XXX get rid of pop here, use ... reg, mem32 - __ pop_f(xmm1); - __ ucomiss(xmm1, xmm0); - } else { - // XXX get rid of pop here, use ... reg, mem64 - __ pop_d(xmm1); - __ ucomisd(xmm1, xmm0); - } - if (unordered_result < 0) { - __ movl(rax, -1); - __ jccb(Assembler::parity, done); - __ jccb(Assembler::below, done); - __ setb(Assembler::notEqual, rdx); - __ movzbl(rax, rdx); + if ((is_float && UseSSE >= 1) || + (!is_float && UseSSE >= 2)) { + Label done; + if (is_float) { + // XXX get rid of pop here, use ... reg, mem32 + __ pop_f(xmm1); + __ ucomiss(xmm1, xmm0); + } else { + // XXX get rid of pop here, use ... reg, mem64 + __ pop_d(xmm1); + __ ucomisd(xmm1, xmm0); + } + if (unordered_result < 0) { + __ movl(rax, -1); + __ jccb(Assembler::parity, done); + __ jccb(Assembler::below, done); + __ setb(Assembler::notEqual, rdx); + __ movzbl(rax, rdx); + } else { + __ movl(rax, 1); + __ jccb(Assembler::parity, done); + __ jccb(Assembler::above, done); + __ movl(rax, 0); + __ jccb(Assembler::equal, done); + __ decrementl(rax); + } + __ bind(done); } else { - __ movl(rax, 1); - __ jccb(Assembler::parity, done); - __ jccb(Assembler::above, done); - __ movl(rax, 0); - __ jccb(Assembler::equal, done); - __ decrementl(rax); - } - __ bind(done); +#ifdef _LP64 + ShouldNotReachHere(); #else - if (is_float) { - __ fld_s(at_rsp()); - } else { - __ fld_d(at_rsp()); - __ pop(rdx); + if (is_float) { + __ fld_s(at_rsp()); + } else { + __ fld_d(at_rsp()); + __ pop(rdx); + } + __ pop(rcx); + __ fcmp2int(rax, unordered_result < 0); +#endif // _LP64 } - __ pop(rcx); - __ fcmp2int(rax, unordered_result < 0); -#endif } void TemplateTable::branch(bool is_jsr, bool is_wide) { @@ -2039,6 +2138,7 @@ __ pop(rcx); __ pop(rdx); __ movptr(rax, Address(rcx, Method::method_counters_offset())); + __ testptr(rax, rax); __ jcc(Assembler::zero, dispatch); __ bind(has_counters); @@ -2784,8 +2884,7 @@ __ jcc(Assembler::notEqual, notFloat); // ftos - LP64_ONLY(__ movflt(xmm0, field)); - NOT_LP64(__ fld_s(field)); + __ load_float(field); __ push(ftos); // Rewrite bytecode to be faster if (!is_static && rc == may_rewrite) { @@ -2799,8 +2898,7 @@ __ jcc(Assembler::notEqual, notDouble); #endif // dtos - LP64_ONLY(__ movdbl(xmm0, field)); - NOT_LP64(__ fld_d(field)); + __ load_double(field); __ push(dtos); // Rewrite bytecode to be faster if (!is_static && rc == may_rewrite) { @@ -3099,12 +3197,9 @@ // ftos { __ pop(ftos); - if (!is_static) { - pop_and_check_object(obj); - } + if (!is_static) pop_and_check_object(obj); oopDesc::bs()->interpreter_write_barrier(_masm, obj); - NOT_LP64( __ fstp_s(field);) - LP64_ONLY( __ movflt(field, xmm0);) + __ store_float(field); if (!is_static && rc == may_rewrite) { patch_bytecode(Bytecodes::_fast_fputfield, bc, rbx, true, byte_no); } @@ -3120,12 +3215,9 @@ // dtos { __ pop(dtos); - if (!is_static) { - pop_and_check_object(obj); - } + if (!is_static) pop_and_check_object(obj); oopDesc::bs()->interpreter_write_barrier(_masm, obj); - NOT_LP64( __ fstp_d(field);) - LP64_ONLY( __ movdbl(field, xmm0);) + __ store_double(field); if (!is_static && rc == may_rewrite) { patch_bytecode(Bytecodes::_fast_dputfield, bc, rbx, true, byte_no); } @@ -3183,8 +3275,8 @@ case Bytecodes::_fast_sputfield: // fall through case Bytecodes::_fast_cputfield: // fall through case Bytecodes::_fast_iputfield: __ push_i(rax); break; - case Bytecodes::_fast_dputfield: __ push_d(); break; - case Bytecodes::_fast_fputfield: __ push_f(); break; + case Bytecodes::_fast_dputfield: __ push(dtos); break; + case Bytecodes::_fast_fputfield: __ push(ftos); break; case Bytecodes::_fast_lputfield: __ push_l(rax); break; default: @@ -3207,8 +3299,8 @@ case Bytecodes::_fast_sputfield: // fall through case Bytecodes::_fast_cputfield: // fall through case Bytecodes::_fast_iputfield: __ pop_i(rax); break; - case Bytecodes::_fast_dputfield: __ pop_d(); break; - case Bytecodes::_fast_fputfield: __ pop_f(); break; + case Bytecodes::_fast_dputfield: __ pop(dtos); break; + case Bytecodes::_fast_fputfield: __ pop(ftos); break; case Bytecodes::_fast_lputfield: __ pop_l(rax); break; } __ bind(L2); @@ -3278,13 +3370,11 @@ break; case Bytecodes::_fast_fputfield: oopDesc::bs()->interpreter_write_barrier(_masm, rcx); - NOT_LP64( __ fstp_s(field); ) - LP64_ONLY( __ movflt(field, xmm0);) + __ store_float(field); break; case Bytecodes::_fast_dputfield: oopDesc::bs()->interpreter_write_barrier(_masm, rcx); - NOT_LP64( __ fstp_d(field); ) - LP64_ONLY( __ movdbl(field, xmm0);) + __ store_double(field); break; default: ShouldNotReachHere(); @@ -3370,12 +3460,10 @@ __ load_unsigned_short(rax, field); break; case Bytecodes::_fast_fgetfield: - LP64_ONLY(__ movflt(xmm0, field)); - NOT_LP64(__ fld_s(field)); + __ load_float(field); break; case Bytecodes::_fast_dgetfield: - LP64_ONLY(__ movdbl(xmm0, field)); - NOT_LP64(__ fld_d(field)); + __ load_double(field); break; default: ShouldNotReachHere(); @@ -3416,8 +3504,7 @@ __ verify_oop(rax); break; case ftos: - LP64_ONLY(__ movflt(xmm0, field)); - NOT_LP64(__ fld_s(field)); + __ load_float(field); break; default: ShouldNotReachHere();
--- a/src/cpu/x86/vm/vm_version_x86.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/cpu/x86/vm/vm_version_x86.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -714,6 +714,11 @@ FLAG_SET_DEFAULT(UseCRC32CIntrinsics, false); } + if (UseAdler32Intrinsics) { + warning("Adler32Intrinsics not available on this CPU."); + FLAG_SET_DEFAULT(UseAdler32Intrinsics, false); + } + // Adjust RTM (Restricted Transactional Memory) flags if (!supports_rtm() && UseRTMLocking) { // Can't continue because UseRTMLocking affects UseBiasedLocking flag
--- a/src/os/aix/vm/perfMemory_aix.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os/aix/vm/perfMemory_aix.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * Copyright 2012, 2013 SAP AG. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * @@ -454,13 +454,27 @@ *saved_cwd_fd = result; } - // Set the current directory to dirname by using the fd of the directory. + // Set the current directory to dirname by using the fd of the directory and + // handle errors, otherwise shared memory files will be created in cwd. result = fchdir(fd); - - return dirp; + if (result == OS_ERR) { + if (PrintMiscellaneous && Verbose) { + warning("could not change to directory %s", dirname); + } + if (*saved_cwd_fd != -1) { + ::close(*saved_cwd_fd); + *saved_cwd_fd = -1; + } + // Close the directory. + os::closedir(dirp); + return NULL; + } else { + return dirp; + } } // Close the directory and restore the current working directory. +// static void close_directory_secure_cwd(DIR* dirp, int saved_cwd_fd) { int result;
--- a/src/os/bsd/vm/perfMemory_bsd.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os/bsd/vm/perfMemory_bsd.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -375,10 +375,23 @@ *saved_cwd_fd = result; } - // Set the current directory to dirname by using the fd of the directory. + // Set the current directory to dirname by using the fd of the directory and + // handle errors, otherwise shared memory files will be created in cwd. result = fchdir(fd); - - return dirp; + if (result == OS_ERR) { + if (PrintMiscellaneous && Verbose) { + warning("could not change to directory %s", dirname); + } + if (*saved_cwd_fd != -1) { + ::close(*saved_cwd_fd); + *saved_cwd_fd = -1; + } + // Close the directory. + os::closedir(dirp); + return NULL; + } else { + return dirp; + } } // Close the directory and restore the current working directory.
--- a/src/os/linux/vm/os_linux.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os/linux/vm/os_linux.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -5785,9 +5785,11 @@ status = pthread_mutex_unlock(_mutex); assert(status == 0, "invariant"); } else { + // must capture correct index before unlocking + int index = _cur_index; status = pthread_mutex_unlock(_mutex); assert(status == 0, "invariant"); - status = pthread_cond_signal(&_cond[_cur_index]); + status = pthread_cond_signal(&_cond[index]); assert(status == 0, "invariant"); } } else {
--- a/src/os/linux/vm/perfMemory_linux.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os/linux/vm/perfMemory_linux.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -374,10 +374,23 @@ *saved_cwd_fd = result; } - // Set the current directory to dirname by using the fd of the directory. + // Set the current directory to dirname by using the fd of the directory and + // handle errors, otherwise shared memory files will be created in cwd. result = fchdir(fd); - - return dirp; + if (result == OS_ERR) { + if (PrintMiscellaneous && Verbose) { + warning("could not change to directory %s", dirname); + } + if (*saved_cwd_fd != -1) { + ::close(*saved_cwd_fd); + *saved_cwd_fd = -1; + } + // Close the directory. + os::closedir(dirp); + return NULL; + } else { + return dirp; + } } // Close the directory and restore the current working directory.
--- a/src/os/solaris/vm/perfMemory_solaris.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os/solaris/vm/perfMemory_solaris.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -377,10 +377,23 @@ *saved_cwd_fd = result; } - // Set the current directory to dirname by using the fd of the directory. + // Set the current directory to dirname by using the fd of the directory and + // handle errors, otherwise shared memory files will be created in cwd. result = fchdir(fd); - - return dirp; + if (result == OS_ERR) { + if (PrintMiscellaneous && Verbose) { + warning("could not change to directory %s", dirname); + } + if (*saved_cwd_fd != -1) { + ::close(*saved_cwd_fd); + *saved_cwd_fd = -1; + } + // Close the directory. + os::closedir(dirp); + return NULL; + } else { + return dirp; + } } // Close the directory and restore the current working directory.
--- a/src/os_cpu/linux_sparc/vm/vm_version_linux_sparc.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/os_cpu/linux_sparc/vm/vm_version_linux_sparc.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2006, 2010, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2006, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -53,6 +53,10 @@ return cpuinfo_field_contains("cpu", "Niagara"); } +static bool detect_M_family() { + return cpuinfo_field_contains("cpu", "SPARC-M"); +} + static bool detect_blkinit() { return cpuinfo_field_contains("cpucaps", "blkinit"); } @@ -66,6 +70,11 @@ features = niagara1_m | T_family_m; } + if (detect_M_family()) { + NOT_PRODUCT(if (PrintMiscellaneous && Verbose) tty->print_cr("Detected Linux on M family");) + features = sun4v_m | generic_v9_m | M_family_m | T_family_m; + } + if (detect_blkinit()) { features |= blk_init_instructions_m; }
--- a/src/share/vm/adlc/Doc/Syntax.doc Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/adlc/Doc/Syntax.doc Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ # -# Copyright (c) 1997, 1998, Oracle and/or its affiliates. All rights reserved. +# Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved. # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. # # This code is free software; you can redistribute it and/or modify it @@ -33,7 +33,7 @@ the architecture of a processor, and is the input to the ADL Compiler. The ADL Compiler compiles an ADL file into code which is incorporated into the Optimizing Just In Time Compiler (OJIT) to generate efficient and correct code -for the target architecture. The ADL describes three bassic different types +for the target architecture. The ADL describes three basic different types of architectural features. It describes the instruction set (and associated operands) of the target architecture. It describes the register set of the target architecture along with relevant information for the register allocator.
--- a/src/share/vm/c1/c1_Compiler.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/c1/c1_Compiler.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,7 +32,6 @@ #include "c1/c1_Runtime1.hpp" #include "c1/c1_ValueType.hpp" #include "compiler/compileBroker.hpp" -#include "compiler/compilerOracle.hpp" #include "interpreter/linkResolver.hpp" #include "memory/allocation.hpp" #include "memory/allocation.inline.hpp"
--- a/src/share/vm/c1/c1_GraphBuilder.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/c1/c1_GraphBuilder.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -4212,7 +4212,7 @@ if (!PrintInlining && !compilation()->method()->has_option("PrintInlining")) { return; } - CompileTask::print_inlining(callee, scope()->level(), bci(), msg); + CompileTask::print_inlining_tty(callee, scope()->level(), bci(), msg); if (success && CIPrintMethodCodes) { callee->print_codes(); }
--- a/src/share/vm/c1/c1_LIRGenerator.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/c1/c1_LIRGenerator.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1437,7 +1437,7 @@ break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: // No pre barriers break; @@ -1459,7 +1459,7 @@ case BarrierSet::ShenandoahBarrierSet: break; #endif // INCLUDE_ALL_GCS - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: CardTableModRef_post_barrier(addr, new_val); break;
--- a/src/share/vm/ci/bcEscapeAnalyzer.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/ci/bcEscapeAnalyzer.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1447,7 +1447,6 @@ if (methodData() == NULL) return; - bool printit = _method->should_print_assembly(); if (methodData()->has_escape_info()) { TRACE_BCEA(2, tty->print_cr("[EA] Reading previous results for %s.%s", method->holder()->name()->as_utf8(),
--- a/src/share/vm/classfile/classLoader.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/classLoader.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,8 +28,8 @@ #include "classfile/classLoader.hpp" #include "classfile/classLoaderData.inline.hpp" #include "classfile/classLoaderExt.hpp" -#include "classfile/imageFile.hpp" #include "classfile/javaClasses.hpp" +#include "classfile/jimage.hpp" #include "classfile/systemDictionary.hpp" #include "classfile/vmSymbols.hpp" #include "compiler/compileBroker.hpp" @@ -58,6 +58,7 @@ #include "runtime/os.hpp" #include "runtime/threadCritical.hpp" #include "runtime/timer.hpp" +#include "runtime/vm_version.hpp" #include "services/management.hpp" #include "services/threadService.hpp" #include "utilities/events.hpp" @@ -68,7 +69,7 @@ #include "classfile/sharedPathsMiscInfo.hpp" #endif -// Entry points in zip.dll for loading zip/jar file entries and image file entries +// Entry points in zip.dll for loading zip/jar file entries typedef void * * (JNICALL *ZipOpen_t)(const char *name, char **pmsg); typedef void (JNICALL *ZipClose_t)(jzfile *zip); @@ -89,6 +90,15 @@ static ZipInflateFully_t ZipInflateFully = NULL; static Crc32_t Crc32 = NULL; +// Entry points for jimage.dll for loading jimage file entries + +static JImageOpen_t JImageOpen = NULL; +static JImageClose_t JImageClose = NULL; +static JImagePackageToModule_t JImagePackageToModule = NULL; +static JImageFindResource_t JImageFindResource = NULL; +static JImageGetResource_t JImageGetResource = NULL; +static JImageResourceIterator_t JImageResourceIterator = NULL; + // Globals PerfCounter* ClassLoader::_perf_accumulated_time = NULL; @@ -141,6 +151,15 @@ return (strncmp(str, str_to_find, str_to_find_len) == 0); } +static const char* get_jimage_version_string() { + static char version_string[10] = ""; + if (version_string[0] == '\0') { + jio_snprintf(version_string, sizeof(version_string), "%d.%d", + Abstract_VM_Version::vm_minor_version(), Abstract_VM_Version::vm_micro_version()); + } + return (const char*)version_string; +} + bool string_ends_with(const char* str, const char* str_to_find) { size_t str_len = strlen(str); size_t str_to_find_len = strlen(str_to_find); @@ -272,98 +291,114 @@ } } -ClassPathImageEntry::ClassPathImageEntry(ImageFileReader* image) : +ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) : ClassPathEntry(), - _image(image), - _module_data(NULL) { - guarantee(image != NULL, "image file is null"); - - char module_data_name[JVM_MAXPATHLEN]; - ImageModuleData::module_data_name(module_data_name, _image->name()); - _module_data = new ImageModuleData(_image, module_data_name); + _jimage(jimage) { + guarantee(jimage != NULL, "jimage file is null"); + guarantee(name != NULL, "jimage file name is null"); + size_t len = strlen(name) + 1; + _name = NEW_C_HEAP_ARRAY(const char, len, mtClass); + strncpy((char *)_name, name, len); } ClassPathImageEntry::~ClassPathImageEntry() { - if (_module_data != NULL) { - delete _module_data; - _module_data = NULL; + if (_name != NULL) { + FREE_C_HEAP_ARRAY(const char, _name); + _name = NULL; } - - if (_image != NULL) { - ImageFileReader::close(_image); - _image = NULL; + if (_jimage != NULL) { + (*JImageClose)(_jimage); + _jimage = NULL; } } -const char* ClassPathImageEntry::name() { - return _image ? _image->name() : ""; +void ClassPathImageEntry::name_to_package(const char* name, char* buffer, int length) { + const char *pslash = strrchr(name, '/'); + if (pslash == NULL) { + buffer[0] = '\0'; + return; + } + int len = pslash - name; +#if INCLUDE_CDS + if (len <= 0 && DumpSharedSpaces) { + buffer[0] = '\0'; + return; + } +#endif + assert(len > 0, "Bad length for package name"); + if (len >= length) { + buffer[0] = '\0'; + return; + } + // drop name after last slash (including slash) + // Ex., "java/lang/String.class" => "java/lang" + strncpy(buffer, name, len); + // ensure string termination (strncpy does not guarantee) + buffer[len] = '\0'; } +// For a class in a named module, look it up in the jimage file using this syntax: +// /<module-name>/<package-name>/<base-class> +// +// Assumptions: +// 1. There are no unnamed modules in the jimage file. +// 2. A package is in at most one module in the jimage file. +// ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) { - ImageLocation location; - bool found = _image->find_location(name, location); - - if (!found) { - const char *pslash = strrchr(name, '/'); - int len = pslash - name; + jlong size; + JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size); - // NOTE: IMAGE_MAX_PATH is used here since this path is internal to the jimage - // (effectively unlimited.) There are several JCK tests that use paths over - // 1024 characters long, the limit on Windows systems. - if (pslash && 0 < len && len < IMAGE_MAX_PATH) { - - char path[IMAGE_MAX_PATH]; - strncpy(path, name, len); - path[len] = '\0'; - const char* moduleName = _module_data->package_to_module(path); - - if (moduleName != NULL && (len + strlen(moduleName) + 2) < IMAGE_MAX_PATH) { - jio_snprintf(path, IMAGE_MAX_PATH - 1, "/%s/%s", moduleName, name); - location.clear_data(); - found = _image->find_location(path, location); - } + if (location == 0) { + char package[JIMAGE_MAX_PATH]; + name_to_package(name, package, JIMAGE_MAX_PATH); + if (package[0] != '\0') { + const char* module = (*JImagePackageToModule)(_jimage, package); + if (module == NULL) { + module = "java.base"; + } + location = (*JImageFindResource)(_jimage, module, get_jimage_version_string(), name, &size); } } - if (found) { - u8 size = location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); + if (location != 0) { if (UsePerfData) { ClassLoader::perf_sys_classfile_bytes_read()->inc(size); } - u1* data = NEW_RESOURCE_ARRAY(u1, size); - _image->get_resource(location, data); - return new ClassFileStream(data, (int)size, _image->name()); // Resource allocated + char* data = NEW_RESOURCE_ARRAY(char, size); + (*JImageGetResource)(_jimage, location, data, size); + return new ClassFileStream((u1*)data, (int)size, _name); // Resource allocated } return NULL; } #ifndef PRODUCT +bool ctw_visitor(JImageFile* jimage, + const char* module_name, const char* version, const char* package, + const char* name, const char* extension, void* arg) { + if (strcmp(extension, "class") == 0) { + Thread* THREAD = Thread::current(); + char path[JIMAGE_MAX_PATH]; + jio_snprintf(path, JIMAGE_MAX_PATH - 1, "%s/%s.class", package, name); + ClassLoader::compile_the_world_in(path, *(Handle*)arg, THREAD); + return !HAS_PENDING_EXCEPTION; + } + return true; +} + void ClassPathImageEntry::compile_the_world(Handle loader, TRAPS) { tty->print_cr("CompileTheWorld : Compiling all classes in %s", name()); tty->cr(); - const ImageStrings strings = _image->get_strings(); - // Retrieve each path component string. - u4 length = _image->table_length(); - for (u4 i = 0; i < length; i++) { - u1* location_data = _image->get_location_data(i); - - if (location_data != NULL) { - ImageLocation location(location_data); - char path[IMAGE_MAX_PATH]; - _image->location_path(location, path, IMAGE_MAX_PATH); - ClassLoader::compile_the_world_in(path, loader, CHECK); + (*JImageResourceIterator)(_jimage, (JImageResourceVisitor_t)ctw_visitor, (void *)&loader); + if (HAS_PENDING_EXCEPTION) { + if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) { + CLEAR_PENDING_EXCEPTION; + tty->print_cr("\nCompileTheWorld : Ran out of memory\n"); + tty->print_cr("Increase class metadata storage if a limit was set"); + } else { + tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n"); } } - if (HAS_PENDING_EXCEPTION) { - if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) { - CLEAR_PENDING_EXCEPTION; - tty->print_cr("\nCompileTheWorld : Ran out of memory\n"); - tty->print_cr("Increase class metadata storage if a limit was set"); - } else { - tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n"); - } - } } bool ClassPathImageEntry::is_jrt() { @@ -490,7 +525,7 @@ JavaThread* thread = JavaThread::current(); ClassPathEntry* new_entry = NULL; if ((st->st_mode & S_IFREG) == S_IFREG) { - // Regular file, should be a zip or image file + // Regular file, should be a zip or jimage file // Canonicalized filename char canonical_path[JVM_MAXPATHLEN]; if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) { @@ -501,9 +536,10 @@ return NULL; } } - ImageFileReader* image = ImageFileReader::open(canonical_path); - if (image != NULL) { - new_entry = new ClassPathImageEntry(image); + jint error; + JImageFile* jimage =(*JImageOpen)(canonical_path, &error); + if (jimage != NULL) { + new_entry = new ClassPathImageEntry(jimage, canonical_path); } else { char* error_msg = NULL; jzfile* zip; @@ -682,6 +718,35 @@ // This lookup only works on 1.3. Do not check for non-null here } +void ClassLoader::load_jimage_library() { + // First make sure native library is loaded + os::native_java_library(); + // Load jimage library + char path[JVM_MAXPATHLEN]; + char ebuf[1024]; + void* handle = NULL; + if (os::dll_build_name(path, sizeof(path), Arguments::get_dll_dir(), "jimage")) { + handle = os::dll_load(path, ebuf, sizeof ebuf); + } + if (handle == NULL) { + vm_exit_during_initialization("Unable to load jimage library", path); + } + + // Lookup jimage entry points + JImageOpen = CAST_TO_FN_PTR(JImageOpen_t, os::dll_lookup(handle, "JIMAGE_Open")); + guarantee(JImageOpen != NULL, "function JIMAGE_Open not found"); + JImageClose = CAST_TO_FN_PTR(JImageClose_t, os::dll_lookup(handle, "JIMAGE_Close")); + guarantee(JImageClose != NULL, "function JIMAGE_Close not found"); + JImagePackageToModule = CAST_TO_FN_PTR(JImagePackageToModule_t, os::dll_lookup(handle, "JIMAGE_PackageToModule")); + guarantee(JImagePackageToModule != NULL, "function JIMAGE_PackageToModule not found"); + JImageFindResource = CAST_TO_FN_PTR(JImageFindResource_t, os::dll_lookup(handle, "JIMAGE_FindResource")); + guarantee(JImageFindResource != NULL, "function JIMAGE_FindResource not found"); + JImageGetResource = CAST_TO_FN_PTR(JImageGetResource_t, os::dll_lookup(handle, "JIMAGE_GetResource")); + guarantee(JImageGetResource != NULL, "function JIMAGE_GetResource not found"); + JImageResourceIterator = CAST_TO_FN_PTR(JImageResourceIterator_t, os::dll_lookup(handle, "JIMAGE_ResourceIterator")); + guarantee(JImageResourceIterator != NULL, "function JIMAGE_ResourceIterator not found"); +} + jboolean ClassLoader::decompress(void *in, u8 inSize, void *out, u8 outSize, char **pmsg) { return (*ZipInflateFully)(in, inSize, out, outSize, pmsg); } @@ -1086,6 +1151,8 @@ // lookup zip library entry points load_zip_library(); + // lookup jimage library entry points + load_jimage_library(); #if INCLUDE_CDS // initialize search path if (DumpSharedSpaces) {
--- a/src/share/vm/classfile/classLoader.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/classLoader.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -37,8 +37,7 @@ // Class path entry (directory or zip file) -class ImageFileReader; -class ImageModuleData; +class JImageFile; class ClassPathEntry: public CHeapObj<mtClass> { private: @@ -52,7 +51,7 @@ } virtual bool is_jar_file() = 0; virtual const char* name() = 0; - virtual ImageFileReader* image() = 0; + virtual JImageFile* jimage() = 0; // Constructor ClassPathEntry(); // Attempt to locate file_name through this class path entry. @@ -70,7 +69,7 @@ public: bool is_jar_file() { return false; } const char* name() { return _dir; } - ImageFileReader* image() { return NULL; } + JImageFile* jimage() { return NULL; } ClassPathDirEntry(const char* dir); ClassFileStream* open_stream(const char* name, TRAPS); // Debugging @@ -100,7 +99,7 @@ public: bool is_jar_file() { return true; } const char* name() { return _zip_name; } - ImageFileReader* image() { return NULL; } + JImageFile* jimage() { return NULL; } ClassPathZipEntry(jzfile* zip, const char* zip_name); ~ClassPathZipEntry(); u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS); @@ -115,16 +114,16 @@ // For java image files class ClassPathImageEntry: public ClassPathEntry { private: - ImageFileReader* _image; - ImageModuleData* _module_data; + JImageFile* _jimage; + const char* _name; public: bool is_jar_file() { return false; } - bool is_open() { return _image != NULL; } - const char* name(); - ImageFileReader* image() { return _image; } - ImageModuleData* module_data() { return _module_data; } - ClassPathImageEntry(ImageFileReader* image); + bool is_open() { return _jimage != NULL; } + const char* name() { return _name == NULL ? "" : _name; } + JImageFile* jimage() { return _jimage; } + ClassPathImageEntry(JImageFile* jimage, const char* name); ~ClassPathImageEntry(); + static void name_to_package(const char* name, char* buffer, int length); ClassFileStream* open_stream(const char* name, TRAPS); // Debugging @@ -206,6 +205,7 @@ static void setup_search_path(const char *class_path); static void load_zip_library(); + static void load_jimage_library(); static ClassPathEntry* create_class_path_entry(const char *path, const struct stat* st, bool throw_exception, TRAPS);
--- a/src/share/vm/classfile/imageDecompressor.cpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,121 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "runtime/thread.inline.hpp" -#include "classfile/imageDecompressor.hpp" -#include "runtime/thread.hpp" -#include "utilities/bytes.hpp" - -/* - * Allocate in C Heap not in resource area, otherwise JVM crashes. - * This array life time is the VM life time. Array is never freed and - * is not expected to contain more than few references. - */ -GrowableArray<ImageDecompressor*>* ImageDecompressor::_decompressors = - new(ResourceObj::C_HEAP, mtInternal) GrowableArray<ImageDecompressor*>(2, true); - -static Symbol* createSymbol(const char* str) { - Thread* THREAD = Thread::current(); - Symbol* sym = SymbolTable::lookup(str, (int) strlen(str), THREAD); - if (HAS_PENDING_EXCEPTION) { - warning("can't create symbol\n"); - CLEAR_PENDING_EXCEPTION; - return NULL; - } - return sym; -} - -/* - * Initialize the array of decompressors. - */ -bool image_decompressor_init() { - Symbol* zipSymbol = createSymbol("zip"); - if (zipSymbol == NULL) { - return false; - } - ImageDecompressor::add_decompressor(new ZipDecompressor(zipSymbol)); - - return true; -} - -/* - * Decompression entry point. Called from ImageFileReader::get_resource. - */ -void ImageDecompressor::decompress_resource(u1* compressed, u1* uncompressed, - u4 uncompressed_size, const ImageStrings* strings, bool is_C_heap) { - bool has_header = false; - u1* decompressed_resource = compressed; - u1* compressed_resource = compressed; - - // Resource could have been transformed by a stack of decompressors. - // Iterate and decompress resources until there is no more header. - do { - ResourceHeader _header; - memcpy(&_header, compressed_resource, sizeof (ResourceHeader)); - has_header = _header._magic == ResourceHeader::resource_header_magic; - if (has_header) { - // decompressed_resource array contains the result of decompression - // when a resource content is terminal, it means that it is an actual resource, - // not an intermediate not fully uncompressed content. In this case - // the resource is allocated as an mtClass, otherwise as an mtOther - decompressed_resource = is_C_heap && _header._is_terminal ? - NEW_C_HEAP_ARRAY(u1, _header._uncompressed_size, mtClass) : - NEW_C_HEAP_ARRAY(u1, _header._uncompressed_size, mtOther); - // Retrieve the decompressor name - const char* decompressor_name = strings->get(_header._decompressor_name_offset); - if (decompressor_name == NULL) warning("image decompressor not found\n"); - guarantee(decompressor_name, "image decompressor not found"); - // Retrieve the decompressor instance - ImageDecompressor* decompressor = get_decompressor(decompressor_name); - if (decompressor == NULL) { - warning("image decompressor %s not found\n", decompressor_name); - } - guarantee(decompressor, "image decompressor not found"); - u1* compressed_resource_base = compressed_resource; - compressed_resource += ResourceHeader::resource_header_length; - // Ask the decompressor to decompress the compressed content - decompressor->decompress_resource(compressed_resource, decompressed_resource, - &_header, strings); - if (compressed_resource_base != compressed) { - FREE_C_HEAP_ARRAY(char, compressed_resource_base); - } - compressed_resource = decompressed_resource; - } - } while (has_header); - memcpy(uncompressed, decompressed_resource, uncompressed_size); -} - -// Zip decompressor - -void ZipDecompressor::decompress_resource(u1* data, u1* uncompressed, - ResourceHeader* header, const ImageStrings* strings) { - char* msg = NULL; - jboolean res = ClassLoader::decompress(data, header->_size, uncompressed, - header->_uncompressed_size, &msg); - if (!res) warning("decompression failed due to %s\n", msg); - guarantee(res, "decompression failed"); -} - -// END Zip Decompressor
--- a/src/share/vm/classfile/imageDecompressor.hpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,136 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_CLASSFILE_IMAGEDECOMPRESSOR_HPP -#define SHARE_VM_CLASSFILE_IMAGEDECOMPRESSOR_HPP - -#include "runtime/thread.inline.hpp" -#include "classfile/classLoader.hpp" -#include "classfile/imageFile.hpp" -#include "classfile/symbolTable.hpp" -#include "oops/symbol.hpp" -#include "utilities/growableArray.hpp" - -/* - * Compressed resources located in image have an header. - * This header contains: - * - _magic: A magic u4, required to retrieved the header in the compressed content - * - _size: The size of the compressed resource. - * - _uncompressed_size: The uncompressed size of the compressed resource. - * - _decompressor_name_offset: The ImageDecompressor instance name StringsTable offset. - * - _decompressor_config_offset: StringsTable offset of configuration that could be needed by - * the decompressor in order to decompress. - * - _is_terminal: 1: the compressed content is terminal. Uncompressing it would - * create the actual resource. 0: the compressed content is not terminal. Uncompressing it - * will result in a compressed content to be decompressed (This occurs when a stack of compressors - * have been used to compress the resource. - */ -struct ResourceHeader { - /* Length of header, needed to retrieve content offset */ - static const u1 resource_header_length = 21; - /* magic bytes that identifies a compressed resource header*/ - static const u4 resource_header_magic = 0xCAFEFAFA; - u4 _magic; // Resource header - u4 _size; // Resource size - u4 _uncompressed_size; // Expected uncompressed size - u4 _decompressor_name_offset; // Strings table decompressor offset - u4 _decompressor_config_offset; // Strings table config offset - u1 _is_terminal; // Last decompressor 1, otherwise 0. -}; - -/* - * Resources located in jimage file can be compressed. Compression occurs at - * jimage file creation time. When compressed a resource is added an header that - * contains the name of the compressor that compressed it. - * Various compression strategies can be applied to compress a resource. - * The same resource can even be compressed multiple time by a stack of compressors. - * At runtime, a resource is decompressed in a loop until there is no more header - * meaning that the resource is equivalent to the not compressed resource. - * In each iteration, the name of the compressor located in the current header - * is used to retrieve the associated instance of ImageDecompressor. - * For example “zip” is the name of the compressor that compresses resources - * using the zip algorithm. The ZipDecompressor class name is also “zip”. - * ImageDecompressor instances are retrieved from a static array in which - * they are registered. - */ -class ImageDecompressor: public CHeapObj<mtClass> { - -private: - const Symbol* _name; - - /* - * Array of concrete decompressors. This array is used to retrieve the decompressor - * that can handle resource decompression. - */ - static GrowableArray<ImageDecompressor*>* _decompressors; - - /* - * Identifier of a decompressor. This name is the identification key to retrieve - * decompressor from a resource header. - */ - inline const Symbol* get_name() const { return _name; } - -protected: - ImageDecompressor(const Symbol* name) : _name(name) { - } - virtual void decompress_resource(u1* data, u1* uncompressed, - ResourceHeader* header, const ImageStrings* strings) = 0; - -public: - inline static void add_decompressor(ImageDecompressor* decompressor) { - _decompressors->append(decompressor); - } - inline static ImageDecompressor* get_decompressor(const char * decompressor_name) { - Thread* THREAD = Thread::current(); - TempNewSymbol sym = SymbolTable::new_symbol(decompressor_name, - (int) strlen(decompressor_name), CHECK_NULL); - if (HAS_PENDING_EXCEPTION) { - warning("can't create symbol\n"); - CLEAR_PENDING_EXCEPTION; - return NULL; - } - for (int i = 0; i < _decompressors->length(); i++) { - ImageDecompressor* decompressor = _decompressors->at(i); - if (decompressor->get_name()->fast_compare(sym) == 0) { - return decompressor; - } - } - guarantee(false, "No decompressor found."); - return NULL; - } - static void decompress_resource(u1* compressed, u1* uncompressed, - u4 uncompressed_size, const ImageStrings* strings, bool is_C_heap); -}; - -/** - * Zip decompressor. - */ -class ZipDecompressor : public ImageDecompressor { -public: - ZipDecompressor(const Symbol* sym) : ImageDecompressor(sym) { } - void decompress_resource(u1* data, u1* uncompressed, ResourceHeader* header, - const ImageStrings* strings); -}; - -#endif // SHARE_VM_CLASSFILE_IMAGEDECOMPRESSOR_HPP
--- a/src/share/vm/classfile/imageFile.cpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,546 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "classfile/imageDecompressor.hpp" -#include "classfile/imageFile.hpp" -#include "memory/resourceArea.hpp" -#include "runtime/mutex.hpp" -#include "runtime/mutexLocker.hpp" -#include "runtime/os.inline.hpp" -#include "utilities/endian.hpp" -#include "utilities/growableArray.hpp" - -// Image files are an alternate file format for storing classes and resources. The -// goal is to supply file access which is faster and smaller than the jar format. -// -// (More detailed nodes in the header.) -// - -// Compute the Perfect Hashing hash code for the supplied UTF-8 string. -s4 ImageStrings::hash_code(const char* string, s4 seed) { - // Access bytes as unsigned. - u1* bytes = (u1*)string; - // Compute hash code. - for (u1 byte = *bytes++; byte; byte = *bytes++) { - seed = (seed * HASH_MULTIPLIER) ^ byte; - } - // Ensure the result is not signed. - return seed & 0x7FFFFFFF; -} - -// Match up a string in a perfect hash table. Result still needs validation -// for precise match (false positive.) -s4 ImageStrings::find(Endian* endian, const char* name, s4* redirect, u4 length) { - // If the table is empty, then short cut. - if (redirect == NULL || length == 0) { - return NOT_FOUND; - } - // Compute the basic perfect hash for name. - s4 hash_code = ImageStrings::hash_code(name); - // Modulo table size. - s4 index = hash_code % length; - // Get redirect entry. - // value == 0 then not found - // value < 0 then -1 - value is true index - // value > 0 then value is seed for recomputing hash. - s4 value = endian->get(redirect[index]); - // if recompute is required. - if (value > 0) { - // Entry collision value, need to recompute hash. - hash_code = ImageStrings::hash_code(name, value); - // Modulo table size. - return hash_code % length; - } else if (value < 0) { - // Compute direct index. - return -1 - value; - } - // No entry found. - return NOT_FOUND; -} - -// Test to see if UTF-8 string begins with the start UTF-8 string. If so, -// return non-NULL address of remaining portion of string. Otherwise, return -// NULL. Used to test sections of a path without copying from image string -// table. -const char* ImageStrings::starts_with(const char* string, const char* start) { - char ch1, ch2; - // Match up the strings the best we can. - while ((ch1 = *string) && (ch2 = *start)) { - if (ch1 != ch2) { - // Mismatch, return NULL. - return NULL; - } - // Next characters. - string++, start++; - } - // Return remainder of string. - return string; -} - -// Inflates the attribute stream into individual values stored in the long -// array _attributes. This allows an attribute value to be quickly accessed by -// direct indexing. Unspecified values default to zero (from constructor.) -void ImageLocation::set_data(u1* data) { - // Deflate the attribute stream into an array of attributes. - u1 byte; - // Repeat until end header is found. - while ((byte = *data)) { - // Extract kind from header byte. - u1 kind = attribute_kind(byte); - guarantee(kind < ATTRIBUTE_COUNT, "invalid image location attribute"); - // Extract length of data (in bytes). - u1 n = attribute_length(byte); - // Read value (most significant first.) - _attributes[kind] = attribute_value(data + 1, n); - // Position to next attribute by skipping attribute header and data bytes. - data += n + 1; - } -} - -// Zero all attribute values. -void ImageLocation::clear_data() { - // Set defaults to zero. - memset(_attributes, 0, sizeof(_attributes)); -} - -// ImageModuleData constructor maps out sub-tables for faster access. -ImageModuleData::ImageModuleData(const ImageFileReader* image_file, - const char* module_data_name) : - _image_file(image_file), - _endian(image_file->endian()), - _strings(image_file->get_strings()) { - // Retrieve the resource containing the module data for the image file. - ImageLocation location; - bool found = image_file->find_location(module_data_name, location); - guarantee(found, "missing module data"); - u8 data_size = location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); - _data = (u1*)NEW_C_HEAP_ARRAY(char, data_size, mtClass); - _image_file->get_resource(location, _data); - // Map out the header. - _header = (Header*)_data; - // Get the package to module entry count. - u4 ptm_count = _header->ptm_count(_endian); - // Get the module to package entry count. - u4 mtp_count = _header->mtp_count(_endian); - // Compute the offset of the package to module perfect hash redirect. - u4 ptm_redirect_offset = sizeof(Header); - // Compute the offset of the package to module data. - u4 ptm_data_offset = ptm_redirect_offset + ptm_count * sizeof(s4); - // Compute the offset of the module to package perfect hash redirect. - u4 mtp_redirect_offset = ptm_data_offset + ptm_count * sizeof(PTMData); - // Compute the offset of the module to package data. - u4 mtp_data_offset = mtp_redirect_offset + mtp_count * sizeof(s4); - // Compute the offset of the module to package tables. - u4 mtp_packages_offset = mtp_data_offset + mtp_count * sizeof(MTPData); - // Compute the address of the package to module perfect hash redirect. - _ptm_redirect = (s4*)(_data + ptm_redirect_offset); - // Compute the address of the package to module data. - _ptm_data = (PTMData*)(_data + ptm_data_offset); - // Compute the address of the module to package perfect hash redirect. - _mtp_redirect = (s4*)(_data + mtp_redirect_offset); - // Compute the address of the module to package data. - _mtp_data = (MTPData*)(_data + mtp_data_offset); - // Compute the address of the module to package tables. - _mtp_packages = (s4*)(_data + mtp_packages_offset); -} - -// Release module data resource. -ImageModuleData::~ImageModuleData() { - if (_data != NULL) { - FREE_C_HEAP_ARRAY(u1, _data); - } -} - -// Return the name of the module data resource. Ex. "./lib/modules/file.jimage" -// yields "file.jdata" -void ImageModuleData::module_data_name(char* buffer, const char* image_file_name) { - // Locate the last slash in the file name path. - const char* slash = strrchr(image_file_name, os::file_separator()[0]); - // Trim the path to name and extension. - const char* name = slash != NULL ? slash + 1 : (char *)image_file_name; - // Locate the extension period. - const char* dot = strrchr(name, '.'); - guarantee(dot, "missing extension on jimage name"); - // Trim to only base name. - int length = dot - name; - strncpy(buffer, name, length); - buffer[length] = '\0'; - // Append extension. - strcat(buffer, ".jdata"); -} - -// Return the module in which a package resides. Returns NULL if not found. -const char* ImageModuleData::package_to_module(const char* package_name) { - // Search the package to module table. - s4 index = ImageStrings::find(_endian, package_name, _ptm_redirect, - _header->ptm_count(_endian)); - // If entry is found. - if (index != ImageStrings::NOT_FOUND) { - // Retrieve the package to module entry. - PTMData* data = _ptm_data + index; - // Verify that it is the correct data. - if (strcmp(package_name, get_string(data->name_offset(_endian))) != 0) { - return NULL; - } - // Return the module name. - return get_string(data->module_name_offset(_endian)); - } - return NULL; -} - -// Returns all the package names in a module. Returns NULL if module not found. -GrowableArray<const char*>* ImageModuleData::module_to_packages(const char* module_name) { - // Search the module to package table. - s4 index = ImageStrings::find(_endian, module_name, _mtp_redirect, - _header->mtp_count(_endian)); - // If entry is found. - if (index != ImageStrings::NOT_FOUND) { - // Retrieve the module to package entry. - MTPData* data = _mtp_data + index; - // Verify that it is the correct data. - if (strcmp(module_name, get_string(data->name_offset(_endian))) != 0) { - return NULL; - } - // Construct an array of all the package entries. - GrowableArray<const char*>* packages = new GrowableArray<const char*>(); - s4 package_offset = data->package_offset(_endian); - for (u4 i = 0; i < data->package_count(_endian); i++) { - u4 package_name_offset = mtp_package(package_offset + i); - const char* package_name = get_string(package_name_offset); - packages->append(package_name); - } - return packages; - } - return NULL; -} - -// Table to manage multiple opens of an image file. -GrowableArray<ImageFileReader*>* ImageFileReader::_reader_table = - new(ResourceObj::C_HEAP, mtInternal) GrowableArray<ImageFileReader*>(2, true); - -// Open an image file, reuse structure if file already open. -ImageFileReader* ImageFileReader::open(const char* name, bool big_endian) { - // Lock out _reader_table. - MutexLocker ml(ImageFileReaderTable_lock); - ImageFileReader* reader; - // Search for an exist image file. - for (int i = 0; i < _reader_table->length(); i++) { - // Retrieve table entry. - reader = _reader_table->at(i); - // If name matches, then reuse (bump up use count.) - if (strcmp(reader->name(), name) == 0) { - reader->inc_use(); - return reader; - } - } - // Need a new image reader. - reader = new ImageFileReader(name, big_endian); - bool opened = reader->open(); - // If failed to open. - if (!opened) { - delete reader; - return NULL; - } - // Bump use count and add to table. - reader->inc_use(); - _reader_table->append(reader); - return reader; -} - -// Close an image file if the file is not in use elsewhere. -void ImageFileReader::close(ImageFileReader *reader) { - // Lock out _reader_table. - MutexLocker ml(ImageFileReaderTable_lock); - // If last use then remove from table and then close. - if (reader->dec_use()) { - _reader_table->remove(reader); - delete reader; - } -} - -// Return an id for the specifed ImageFileReader. -u8 ImageFileReader::readerToID(ImageFileReader *reader) { - // ID is just the cloaked reader address. - return (u8)reader; -} - -// Validate the image id. -bool ImageFileReader::idCheck(u8 id) { - // Make sure the ID is a managed (_reader_table) reader. - MutexLocker ml(ImageFileReaderTable_lock); - return _reader_table->contains((ImageFileReader*)id); -} - -// Return an id for the specifed ImageFileReader. -ImageFileReader* ImageFileReader::idToReader(u8 id) { -#ifdef PRODUCT - // Fast convert. - return (ImageFileReader*)id; -#else - // Do a slow check before fast convert. - return idCheck(id) ? (ImageFileReader*)id : NULL; -#endif -} - -// Constructor intializes to a closed state. -ImageFileReader::ImageFileReader(const char* name, bool big_endian) { - // Copy the image file name. - _name = NEW_C_HEAP_ARRAY(char, strlen(name) + 1, mtClass); - strcpy(_name, name); - // Initialize for a closed file. - _fd = -1; - _endian = Endian::get_handler(big_endian); - _index_data = NULL; -} - -// Close image and free up data structures. -ImageFileReader::~ImageFileReader() { - // Ensure file is closed. - close(); - // Free up name. - if (_name != NULL) { - FREE_C_HEAP_ARRAY(char, _name); - _name = NULL; - } -} - -// Open image file for read access. -bool ImageFileReader::open() { - // If file exists open for reading. - struct stat st; - if (os::stat(_name, &st) != 0 || - (st.st_mode & S_IFREG) != S_IFREG || - (_fd = os::open(_name, 0, O_RDONLY)) == -1) { - return false; - } - // Retrieve the file size. - _file_size = (u8)st.st_size; - // Read image file header and verify it has a valid header. - size_t header_size = sizeof(ImageHeader); - if (_file_size < header_size || - !read_at((u1*)&_header, header_size, 0) || - _header.magic(_endian) != IMAGE_MAGIC || - _header.major_version(_endian) != MAJOR_VERSION || - _header.minor_version(_endian) != MINOR_VERSION) { - close(); - return false; - } - // Size of image index. - _index_size = index_size(); - // Make sure file is large enough to contain the index. - if (_file_size < _index_size) { - return false; - } - // Determine how much of the image is memory mapped. - off_t map_size = (off_t)(MemoryMapImage ? _file_size : _index_size); - // Memory map image (minimally the index.) - _index_data = (u1*)os::map_memory(_fd, _name, 0, NULL, map_size, true, false); - guarantee(_index_data, "image file not memory mapped"); - // Retrieve length of index perfect hash table. - u4 length = table_length(); - // Compute offset of the perfect hash table redirect table. - u4 redirect_table_offset = (u4)header_size; - // Compute offset of index attribute offsets. - u4 offsets_table_offset = redirect_table_offset + length * sizeof(s4); - // Compute offset of index location attribute data. - u4 location_bytes_offset = offsets_table_offset + length * sizeof(u4); - // Compute offset of index string table. - u4 string_bytes_offset = location_bytes_offset + locations_size(); - // Compute address of the perfect hash table redirect table. - _redirect_table = (s4*)(_index_data + redirect_table_offset); - // Compute address of index attribute offsets. - _offsets_table = (u4*)(_index_data + offsets_table_offset); - // Compute address of index location attribute data. - _location_bytes = _index_data + location_bytes_offset; - // Compute address of index string table. - _string_bytes = _index_data + string_bytes_offset; - // Successful open. - return true; -} - -// Close image file. -void ImageFileReader::close() { - // Dealllocate the index. - if (_index_data != NULL) { - os::unmap_memory((char*)_index_data, _index_size); - _index_data = NULL; - } - // Close file. - if (_fd != -1) { - os::close(_fd); - _fd = -1; - } -} - -// Read directly from the file. -bool ImageFileReader::read_at(u1* data, u8 size, u8 offset) const { - return os::read_at(_fd, data, size, offset) == size; -} - -// Find the location attributes associated with the path. Returns true if -// the location is found, false otherwise. -bool ImageFileReader::find_location(const char* path, ImageLocation& location) const { - // Locate the entry in the index perfect hash table. - s4 index = ImageStrings::find(_endian, path, _redirect_table, table_length()); - // If is found. - if (index != ImageStrings::NOT_FOUND) { - // Get address of first byte of location attribute stream. - u1* data = get_location_data(index); - // Expand location attributes. - location.set_data(data); - // Make sure result is not a false positive. - return verify_location(location, path); - } - return false; -} - -// Assemble the location path from the string fragments indicated in the location attributes. -void ImageFileReader::location_path(ImageLocation& location, char* path, size_t max) const { - // Manage the image string table. - ImageStrings strings(_string_bytes, _header.strings_size(_endian)); - // Position to first character of the path buffer. - char* next = path; - // Temp for string length. - size_t length; - // Get module string. - const char* module = location.get_attribute(ImageLocation::ATTRIBUTE_MODULE, strings); - // If module string is not empty string. - if (*module != '\0') { - // Get length of module name. - length = strlen(module); - // Make sure there is no buffer overflow. - guarantee(next - path + length + 2 < max, "buffer overflow"); - // Append '/module/'. - *next++ = '/'; - strcpy(next, module); next += length; - *next++ = '/'; - } - // Get parent (package) string. - const char* parent = location.get_attribute(ImageLocation::ATTRIBUTE_PARENT, strings); - // If parent string is not empty string. - if (*parent != '\0') { - // Get length of module string. - length = strlen(parent); - // Make sure there is no buffer overflow. - guarantee(next - path + length + 1 < max, "buffer overflow"); - // Append 'patent/' . - strcpy(next, parent); next += length; - *next++ = '/'; - } - // Get base name string. - const char* base = location.get_attribute(ImageLocation::ATTRIBUTE_BASE, strings); - // Get length of base name. - length = strlen(base); - // Make sure there is no buffer overflow. - guarantee(next - path + length < max, "buffer overflow"); - // Append base name. - strcpy(next, base); next += length; - // Get extension string. - const char* extension = location.get_attribute(ImageLocation::ATTRIBUTE_EXTENSION, strings); - // If extension string is not empty string. - if (*extension != '\0') { - // Get length of extension string. - length = strlen(extension); - // Make sure there is no buffer overflow. - guarantee(next - path + length + 1 < max, "buffer overflow"); - // Append '.extension' . - *next++ = '.'; - strcpy(next, extension); next += length; - } - // Make sure there is no buffer overflow. - guarantee((size_t)(next - path) < max, "buffer overflow"); - // Terminate string. - *next = '\0'; -} - -// Verify that a found location matches the supplied path (without copying.) -bool ImageFileReader::verify_location(ImageLocation& location, const char* path) const { - // Manage the image string table. - ImageStrings strings(_string_bytes, _header.strings_size(_endian)); - // Position to first character of the path string. - const char* next = path; - // Get module name string. - const char* module = location.get_attribute(ImageLocation::ATTRIBUTE_MODULE, strings); - // If module string is not empty. - if (*module != '\0') { - // Compare '/module/' . - if (*next++ != '/') return false; - if (!(next = ImageStrings::starts_with(next, module))) return false; - if (*next++ != '/') return false; - } - // Get parent (package) string - const char* parent = location.get_attribute(ImageLocation::ATTRIBUTE_PARENT, strings); - // If parent string is not empty string. - if (*parent != '\0') { - // Compare 'parent/' . - if (!(next = ImageStrings::starts_with(next, parent))) return false; - if (*next++ != '/') return false; - } - // Get base name string. - const char* base = location.get_attribute(ImageLocation::ATTRIBUTE_BASE, strings); - // Compare with basne name. - if (!(next = ImageStrings::starts_with(next, base))) return false; - // Get extension string. - const char* extension = location.get_attribute(ImageLocation::ATTRIBUTE_EXTENSION, strings); - // If extension is not empty. - if (*extension != '\0') { - // Compare '.extension' . - if (*next++ != '.') return false; - if (!(next = ImageStrings::starts_with(next, extension))) return false; - } - // True only if complete match and no more characters. - return *next == '\0'; -} - -// Return the resource data for the supplied location. -void ImageFileReader::get_resource(ImageLocation& location, u1* uncompressed_data) const { - // Retrieve the byte offset and size of the resource. - u8 offset = location.get_attribute(ImageLocation::ATTRIBUTE_OFFSET); - u8 uncompressed_size = location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED); - u8 compressed_size = location.get_attribute(ImageLocation::ATTRIBUTE_COMPRESSED); - if (compressed_size != 0) { - ResourceMark rm; - u1* compressed_data; - // If not memory mapped read in bytes. - if (!MemoryMapImage) { - // Allocate buffer for compression. - compressed_data = NEW_RESOURCE_ARRAY(u1, compressed_size); - // Read bytes from offset beyond the image index. - bool is_read = read_at(compressed_data, compressed_size, _index_size + offset); - guarantee(is_read, "error reading from image or short read"); - } else { - compressed_data = get_data_address() + offset; - } - // Get image string table. - const ImageStrings strings = get_strings(); - // Decompress resource. - ImageDecompressor::decompress_resource(compressed_data, uncompressed_data, uncompressed_size, - &strings, false); - } else { - // Read bytes from offset beyond the image index. - bool is_read = read_at(uncompressed_data, uncompressed_size, _index_size + offset); - guarantee(is_read, "error reading from image or short read"); - } -}
--- a/src/share/vm/classfile/imageFile.hpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,602 +0,0 @@ -/* - * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_CLASSFILE_IMAGEFILE_HPP -#define SHARE_VM_CLASSFILE_IMAGEFILE_HPP - -#include "classfile/classLoader.hpp" -#include "memory/allocation.hpp" -#include "memory/allocation.inline.hpp" -#include "utilities/endian.hpp" -#include "utilities/globalDefinitions.hpp" -#include "utilities/growableArray.hpp" - -// Image files are an alternate file format for storing classes and resources. The -// goal is to supply file access which is faster and smaller than the jar format. -// It should be noted that unlike jars, information stored in an image is in native -// endian format. This allows the image to be mapped into memory without endian -// translation. This also means that images are platform dependent. -// -// Image files are structured as three sections; -// -// +-----------+ -// | Header | -// +-----------+ -// | | -// | Index | -// | | -// +-----------+ -// | | -// | | -// | Resources | -// | | -// | | -// +-----------+ -// -// The header contains information related to identification and description of -// contents. -// -// +-------------------------+ -// | Magic (0xCAFEDADA) | -// +------------+------------+ -// | Major Vers | Minor Vers | -// +------------+------------+ -// | Flags | -// +-------------------------+ -// | Resource Count | -// +-------------------------+ -// | Table Length | -// +-------------------------+ -// | Attributes Size | -// +-------------------------+ -// | Strings Size | -// +-------------------------+ -// -// Magic - means of identifying validity of the file. This avoids requiring a -// special file extension. -// Major vers, minor vers - differences in version numbers indicate structural -// changes in the image. -// Flags - various image wide flags (future). -// Resource count - number of resources in the file. -// Table length - the length of lookup tables used in the index. -// Attributes size - number of bytes in the region used to store location attribute -// streams. -// Strings size - the size of the region used to store strings used by the -// index and meta data. -// -// The index contains information related to resource lookup. The algorithm -// used for lookup is "A Practical Minimal Perfect Hashing Method" -// (http://homepages.dcc.ufmg.br/~nivio/papers/wea05.pdf). Given a path string -// in the form /<module>/<package>/<base>.<extension> return the resource location -// information; -// -// redirectIndex = hash(path, DEFAULT_SEED) % table_length; -// redirect = redirectTable[redirectIndex]; -// if (redirect == 0) return not found; -// locationIndex = redirect < 0 ? -1 - redirect : hash(path, redirect) % table_length; -// location = locationTable[locationIndex]; -// if (!verify(location, path)) return not found; -// return location; -// -// Note: The hash function takes an initial seed value. A different seed value -// usually returns a different result for strings that would otherwise collide with -// other seeds. The verify function guarantees the found resource location is -// indeed the resource we are looking for. -// -// The following is the format of the index; -// -// +-------------------+ -// | Redirect Table | -// +-------------------+ -// | Attribute Offsets | -// +-------------------+ -// | Attribute Data | -// +-------------------+ -// | Strings | -// +-------------------+ -// -// Redirect Table - Array of 32-bit signed values representing actions that -// should take place for hashed strings that map to that -// value. Negative values indicate no hash collision and can be -// quickly converted to indices into attribute offsets. Positive -// values represent a new seed for hashing an index into attribute -// offsets. Zero indicates not found. -// Attribute Offsets - Array of 32-bit unsigned values representing offsets into -// attribute data. Attribute offsets can be iterated to do a -// full survey of resources in the image. Offset of zero -// indicates no attributes. -// Attribute Data - Bytes representing compact attribute data for locations. (See -// comments in ImageLocation.) -// Strings - Collection of zero terminated UTF-8 strings used by the index and -// image meta data. Each string is accessed by offset. Each string is -// unique. Offset zero is reserved for the empty string. -// -// Note that the memory mapped index assumes 32 bit alignment of each component -// in the index. -// -// Endianness of an image. -// An image booted by hotspot is always in native endian. However, it is possible -// to read (by the JDK) in alternate endian format. Primarily, this is during -// cross platform scenarios. Ex, where javac needs to read an embedded image -// to access classes for crossing compilation. -// - -class ImageFileReader; // forward declaration - -// Manage image file string table. -class ImageStrings VALUE_OBJ_CLASS_SPEC { -private: - u1* _data; // Data bytes for strings. - u4 _size; // Number of bytes in the string table. -public: - enum { - // Not found result from find routine. - NOT_FOUND = -1, - // Prime used to generate hash for Perfect Hashing. - HASH_MULTIPLIER = 0x01000193 - }; - - ImageStrings(u1* data, u4 size) : _data(data), _size(size) {} - - // Return the UTF-8 string beginning at offset. - inline const char* get(u4 offset) const { - guarantee(offset < _size, "offset exceeds string table size"); - return (const char*)(_data + offset); - } - - // Compute the Perfect Hashing hash code for the supplied UTF-8 string. - inline static u4 hash_code(const char* string) { - return hash_code(string, HASH_MULTIPLIER); - } - - // Compute the Perfect Hashing hash code for the supplied string, starting at seed. - static s4 hash_code(const char* string, s4 seed); - - // Match up a string in a perfect hash table. Result still needs validation - // for precise match. - static s4 find(Endian* endian, const char* name, s4* redirect, u4 length); - - // Test to see if UTF-8 string begins with the start UTF-8 string. If so, - // return non-NULL address of remaining portion of string. Otherwise, return - // NULL. Used to test sections of a path without copying from image string - // table. - static const char* starts_with(const char* string, const char* start); - - // Test to see if UTF-8 string begins with start char. If so, return non-NULL - // address of remaining portion of string. Otherwise, return NULL. Used - // to test a character of a path without copying. - inline static const char* starts_with(const char* string, const char ch) { - return *string == ch ? string + 1 : NULL; - } -}; - -// Manage image file location attribute data. Within an image, a location's -// attributes are compressed into a stream of bytes. An attribute stream is -// composed of individual attribute sequences. Each attribute sequence begins with -// a header byte containing the attribute 'kind' (upper 5 bits of header) and the -// 'length' less 1 (lower 3 bits of header) of bytes that follow containing the -// attribute value. Attribute values present as most significant byte first. -// -// Ex. Container offset (ATTRIBUTE_OFFSET) 0x33562 would be represented as 0x22 -// (kind = 4, length = 3), 0x03, 0x35, 0x62. -// -// An attribute stream is terminated with a header kind of ATTRIBUTE_END (header -// byte of zero.) -// -// ImageLocation inflates the stream into individual values stored in the long -// array _attributes. This allows an attribute value can be quickly accessed by -// direct indexing. Unspecified values default to zero. -// -// Notes: -// - Even though ATTRIBUTE_END is used to mark the end of the attribute stream, -// streams will contain zero byte values to represent lesser significant bits. -// Thus, detecting a zero byte is not sufficient to detect the end of an attribute -// stream. -// - ATTRIBUTE_OFFSET represents the number of bytes from the beginning of the region -// storing the resources. Thus, in an image this represents the number of bytes -// after the index. -// - Currently, compressed resources are represented by having a non-zero -// ATTRIBUTE_COMPRESSED value. This represents the number of bytes stored in the -// image, and the value of ATTRIBUTE_UNCOMPRESSED represents number of bytes of the -// inflated resource in memory. If the ATTRIBUTE_COMPRESSED is zero then the value -// of ATTRIBUTE_UNCOMPRESSED represents both the number of bytes in the image and -// in memory. In the future, additional compression techniques will be used and -// represented differently. -// - Package strings include trailing slash and extensions include prefix period. -// -class ImageLocation VALUE_OBJ_CLASS_SPEC { -public: - enum { - ATTRIBUTE_END, // End of attribute stream marker - ATTRIBUTE_MODULE, // String table offset of module name - ATTRIBUTE_PARENT, // String table offset of resource path parent - ATTRIBUTE_BASE, // String table offset of resource path base - ATTRIBUTE_EXTENSION, // String table offset of resource path extension - ATTRIBUTE_OFFSET, // Container byte offset of resource - ATTRIBUTE_COMPRESSED, // In image byte size of the compressed resource - ATTRIBUTE_UNCOMPRESSED, // In memory byte size of the uncompressed resource - ATTRIBUTE_COUNT // Number of attribute kinds - }; - -private: - // Values of inflated attributes. - u8 _attributes[ATTRIBUTE_COUNT]; - - // Return the attribute value number of bytes. - inline static u1 attribute_length(u1 data) { - return (data & 0x7) + 1; - } - - // Return the attribute kind. - inline static u1 attribute_kind(u1 data) { - u1 kind = data >> 3; - guarantee(kind < ATTRIBUTE_COUNT, "invalid attribute kind"); - return kind; - } - - // Return the attribute length. - inline static u8 attribute_value(u1* data, u1 n) { - guarantee(0 < n && n <= 8, "invalid attribute value length"); - u8 value = 0; - // Most significant bytes first. - for (u1 i = 0; i < n; i++) { - value <<= 8; - value |= data[i]; - } - return value; - } - -public: - ImageLocation() { - clear_data(); - } - - ImageLocation(u1* data) { - clear_data(); - set_data(data); - } - - // Inflates the attribute stream into individual values stored in the long - // array _attributes. This allows an attribute value to be quickly accessed by - // direct indexing. Unspecified values default to zero. - void set_data(u1* data); - - // Zero all attribute values. - void clear_data(); - - // Retrieve an attribute value from the inflated array. - inline u8 get_attribute(u1 kind) const { - guarantee(ATTRIBUTE_END < kind && kind < ATTRIBUTE_COUNT, "invalid attribute kind"); - return _attributes[kind]; - } - - // Retrieve an attribute string value from the inflated array. - inline const char* get_attribute(u4 kind, const ImageStrings& strings) const { - return strings.get((u4)get_attribute(kind)); - } -}; - -// -// NOTE: needs revision. -// Each loader requires set of module meta data to identify which modules and -// packages are managed by that loader. Currently, there is one image file per -// builtin loader, so only one module meta data resource per file. -// -// Each element in the module meta data is a native endian 4 byte integer. Note -// that entries with zero offsets for string table entries should be ignored ( -// padding for hash table lookup.) -// -// Format: -// Count of package to module entries -// Count of module to package entries -// Perfect Hash redirect table[Count of package to module entries] -// Package to module entries[Count of package to module entries] -// Offset to package name in string table -// Offset to module name in string table -// Perfect Hash redirect table[Count of module to package entries] -// Module to package entries[Count of module to package entries] -// Offset to module name in string table -// Count of packages in module -// Offset to first package in packages table -// Packages[] -// Offset to package name in string table -// -// Manage the image module meta data. -class ImageModuleData : public CHeapObj<mtClass> { - class Header VALUE_OBJ_CLASS_SPEC { - private: - u4 _ptm_count; // Count of package to module entries - u4 _mtp_count; // Count of module to package entries - public: - inline u4 ptm_count(Endian* endian) const { return endian->get(_ptm_count); } - inline u4 mtp_count(Endian* endian) const { return endian->get(_mtp_count); } - }; - - // Hashtable entry - class HashData VALUE_OBJ_CLASS_SPEC { - private: - u4 _name_offset; // Name offset in string table - public: - inline s4 name_offset(Endian* endian) const { return endian->get(_name_offset); } - }; - - // Package to module hashtable entry - class PTMData : public HashData { - private: - u4 _module_name_offset; // Module name offset in string table - public: - inline s4 module_name_offset(Endian* endian) const { return endian->get(_module_name_offset); } - }; - - // Module to package hashtable entry - class MTPData : public HashData { - private: - u4 _package_count; // Number of packages in module - u4 _package_offset; // Offset in package list - public: - inline u4 package_count(Endian* endian) const { return endian->get(_package_count); } - inline u4 package_offset(Endian* endian) const { return endian->get(_package_offset); } - }; - - const ImageFileReader* _image_file; // Source image file - Endian* _endian; // Endian handler - ImageStrings _strings; // Image file strings - u1* _data; // Module data resource data - u8 _data_size; // Size of resource data - Header* _header; // Module data header - s4* _ptm_redirect; // Package to module hashtable redirect - PTMData* _ptm_data; // Package to module data - s4* _mtp_redirect; // Module to packages hashtable redirect - MTPData* _mtp_data; // Module to packages data - s4* _mtp_packages; // Package data (name offsets) - - // Return a string from the string table. - inline const char* get_string(u4 offset) { - return _strings.get(offset); - } - - inline u4 mtp_package(u4 index) { - return _endian->get(_mtp_packages[index]); - } - -public: - ImageModuleData(const ImageFileReader* image_file, const char* module_data_name); - ~ImageModuleData(); - - // Return the name of the module data resource. - static void module_data_name(char* buffer, const char* image_file_name); - - // Return the module in which a package resides. Returns NULL if not found. - const char* package_to_module(const char* package_name); - - // Returns all the package names in a module. Returns NULL if module not found. - GrowableArray<const char*>* module_to_packages(const char* module_name); -}; - -// Image file header, starting at offset 0. -class ImageHeader VALUE_OBJ_CLASS_SPEC { -private: - u4 _magic; // Image file marker - u4 _version; // Image file major version number - u4 _flags; // Image file flags - u4 _resource_count; // Number of resources in file - u4 _table_length; // Number of slots in index tables - u4 _locations_size; // Number of bytes in attribute table - u4 _strings_size; // Number of bytes in string table - -public: - u4 magic() const { return _magic; } - u4 magic(Endian* endian) const { return endian->get(_magic); } - void set_magic(Endian* endian, u4 magic) { return endian->set(_magic, magic); } - - u4 major_version(Endian* endian) const { return endian->get(_version) >> 16; } - u4 minor_version(Endian* endian) const { return endian->get(_version) & 0xFFFF; } - void set_version(Endian* endian, u4 major_version, u4 minor_version) { - return endian->set(_version, major_version << 16 | minor_version); - } - - u4 flags(Endian* endian) const { return endian->get(_flags); } - void set_flags(Endian* endian, u4 value) { return endian->set(_flags, value); } - - u4 resource_count(Endian* endian) const { return endian->get(_resource_count); } - void set_resource_count(Endian* endian, u4 count) { return endian->set(_resource_count, count); } - - u4 table_length(Endian* endian) const { return endian->get(_table_length); } - void set_table_length(Endian* endian, u4 count) { return endian->set(_table_length, count); } - - u4 locations_size(Endian* endian) const { return endian->get(_locations_size); } - void set_locations_size(Endian* endian, u4 size) { return endian->set(_locations_size, size); } - - u4 strings_size(Endian* endian) const { return endian->get(_strings_size); } - void set_strings_size(Endian* endian, u4 size) { return endian->set(_strings_size, size); } -}; - -// Max path length limit independent of platform. Windows max path is 1024, -// other platforms use 4096. The JCK fails several tests when 1024 is used. -#define IMAGE_MAX_PATH 4096 - -// Manage the image file. -// ImageFileReader manages the content of an image file. -// Initially, the header of the image file is read for validation. If valid, -// values in the header are used calculate the size of the image index. The -// index is then memory mapped to allow load on demand and sharing. The -// -XX:+MemoryMapImage flag determines if the entire file is loaded (server use.) -// An image can be used by Hotspot and multiple reference points in the JDK, thus -// it is desirable to share a reader. To accomodate sharing, a share table is -// defined (see ImageFileReaderTable in imageFile.cpp) To track the number of -// uses, ImageFileReader keeps a use count (_use). Use is incremented when -// 'opened' by reference point and decremented when 'closed'. Use of zero -// leads the ImageFileReader to be actually closed and discarded. -class ImageFileReader : public CHeapObj<mtClass> { -private: - // Manage a number of image files such that an image can be shared across - // multiple uses (ex. loader.) - static GrowableArray<ImageFileReader*>* _reader_table; - - char* _name; // Name of image - s4 _use; // Use count - int _fd; // File descriptor - Endian* _endian; // Endian handler - u8 _file_size; // File size in bytes - ImageHeader _header; // Image header - size_t _index_size; // Total size of index - u1* _index_data; // Raw index data - s4* _redirect_table; // Perfect hash redirect table - u4* _offsets_table; // Location offset table - u1* _location_bytes; // Location attributes - u1* _string_bytes; // String table - - ImageFileReader(const char* name, bool big_endian); - ~ImageFileReader(); - - // Compute number of bytes in image file index. - inline u8 index_size() { - return sizeof(ImageHeader) + - table_length() * sizeof(u4) * 2 + locations_size() + strings_size(); - } - -public: - enum { - // Image file marker. - IMAGE_MAGIC = 0xCAFEDADA, - // Endian inverted Image file marker. - IMAGE_MAGIC_INVERT = 0xDADAFECA, - // Image file major version number. - MAJOR_VERSION = 1, - // Image file minor version number. - MINOR_VERSION = 0 - }; - - // Open an image file, reuse structure if file already open. - static ImageFileReader* open(const char* name, bool big_endian = Endian::is_big_endian()); - - // Close an image file if the file is not in use elsewhere. - static void close(ImageFileReader *reader); - - // Return an id for the specifed ImageFileReader. - static u8 readerToID(ImageFileReader *reader); - - // Validate the image id. - static bool idCheck(u8 id); - - // Return an id for the specifed ImageFileReader. - static ImageFileReader* idToReader(u8 id); - - // Open image file for read access. - bool open(); - - // Close image file. - void close(); - - // Read directly from the file. - bool read_at(u1* data, u8 size, u8 offset) const; - - inline Endian* endian() const { return _endian; } - - // Retrieve name of image file. - inline const char* name() const { - return _name; - } - - // Retrieve size of image file. - inline u8 file_size() const { - return _file_size; - } - - // Return first address of index data. - inline u1* get_index_address() const { - return _index_data; - } - - // Return first address of resource data. - inline u1* get_data_address() const { - return _index_data + _index_size; - } - - // Get the size of the index data. - size_t get_index_size() const { - return _index_size; - } - - inline u4 table_length() const { - return _header.table_length(_endian); - } - - inline u4 locations_size() const { - return _header.locations_size(_endian); - } - - inline u4 strings_size()const { - return _header.strings_size(_endian); - } - - inline u4* offsets_table() const { - return _offsets_table; - } - - // Increment use count. - inline void inc_use() { - _use++; - } - - // Decrement use count. - inline bool dec_use() { - return --_use == 0; - } - - // Return a string table accessor. - inline const ImageStrings get_strings() const { - return ImageStrings(_string_bytes, _header.strings_size(_endian)); - } - - // Return location attribute stream at offset. - inline u1* get_location_offset_data(u4 offset) const { - guarantee((u4)offset < _header.locations_size(_endian), - "offset exceeds location attributes size"); - return offset != 0 ? _location_bytes + offset : NULL; - } - - // Return location attribute stream for location i. - inline u1* get_location_data(u4 index) const { - guarantee((u4)index < _header.table_length(_endian), - "index exceeds location count"); - u4 offset = _endian->get(_offsets_table[index]); - - return get_location_offset_data(offset); - } - - // Find the location attributes associated with the path. Returns true if - // the location is found, false otherwise. - bool find_location(const char* path, ImageLocation& location) const; - - // Assemble the location path. - void location_path(ImageLocation& location, char* path, size_t max) const; - - // Verify that a found location matches the supplied path. - bool verify_location(ImageLocation& location, const char* path) const; - - // Return the resource for the supplied path. - void get_resource(ImageLocation& location, u1* uncompressed_data) const; -}; -#endif // SHARE_VM_CLASSFILE_IMAGEFILE_HPP
--- a/src/share/vm/classfile/javaClasses.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/javaClasses.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -29,7 +29,6 @@ #include "classfile/vmSymbols.hpp" #include "code/debugInfo.hpp" #include "code/pcDesc.hpp" -#include "compiler/compilerOracle.hpp" #include "interpreter/interpreter.hpp" #include "memory/oopFactory.hpp" #include "memory/resourceArea.hpp"
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/classfile/jimage.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "jni.h" + +// Opaque reference to a JImage file. +class JImageFile; +// Opaque reference to an image file resource location. +typedef jlong JImageLocationRef; + +// Max path length limit independent of platform. Windows max path is 1024, +// other platforms use 4096. The JCK fails several tests when 1024 is used. +#define JIMAGE_MAX_PATH 4096 + +// JImage Error Codes + +// The image file is not prefixed with 0xCAFEDADA +#define JIMAGE_BAD_MAGIC (-1) +// The image file does not have a compatible (translatable) version +#define JIMAGE_BAD_VERSION (-2) +// The image file content is malformed +#define JIMAGE_CORRUPTED (-3) + +/* + * JImageOpen - Given the supplied full path file name, open an image file. This + * function will also initialize tables and retrieve meta-data necessary to + * satisfy other functions in the API. If the image file has been previously + * open, a new open request will share memory and resources used by the previous + * open. A call to JImageOpen should be balanced by a call to JImageClose, to + * release memory and resources used. If the image file is not found or cannot + * be open, then NULL is returned and error will contain a reason for the + * failure; a positive value for a system error number, negative for a jimage + * specific error (see JImage Error Codes.) + * + * Ex. + * jint error; + * JImageFile* jimage = (*JImageOpen)(JAVA_HOME "lib/modules/bootmodules.jimage", &error); + * if (image == NULL) { + * tty->print_cr("JImage failed to open: %d", error); + * ... + * } + * ... + */ + +extern "C" JImageFile* JIMAGE_Open(const char *name, jint* error); + +typedef JImageFile* (*JImageOpen_t)(const char *name, jint* error); + +/* + * JImageClose - Given the supplied open image file (see JImageOpen), release + * memory and resources used by the open file and close the file. If the image + * file is shared by other uses, release and close is deferred until the last use + * is also closed. + * + * Ex. + * (*JImageClose)(image); + */ + +extern "C" void JIMAGE_Close(JImageFile* jimage); + +typedef void (*JImageClose_t)(JImageFile* jimage); + + +/* + * JImagePackageToModule - Given an open image file (see JImageOpen) and the name + * of a package, return the name of module where the package resides. If the + * package does not exist in the image file, the function returns NULL. + * The resulting string does/should not have to be released. All strings are + * utf-8, zero byte terminated. + * + * Ex. + * const char* package = (*JImagePackageToModule)(image, "java/lang"); + * tty->print_cr(package); + * —> java.base + */ + +extern "C" const char * JIMAGE_PackageToModule(JImageFile* jimage, const char* package_name); + +typedef const char* (*JImagePackageToModule_t)(JImageFile* jimage, const char* package_name); + + +/* + * JImageFindResource - Given an open image file (see JImageOpen), a module + * name, a version string and the name of a class/resource, return location + * information describing the resource and its size. If no resource is found, the + * function returns JIMAGE_NOT_FOUND and the value of size is undefined. + * The version number should be "9.0" and is not used in locating the resource. + * The resulting location does/should not have to be released. + * All strings are utf-8, zero byte terminated. + * + * Ex. + * jlong size; + * JImageLocationRef location = (*JImageFindResource)(image, "java.base", "9.0", "java/lang/String.class", &size); + */ +extern "C" JImageLocationRef JIMAGE_FindResource(JImageFile* jimage, + const char* module_name, const char* version, const char* name, + jlong* size); + +typedef JImageLocationRef(*JImageFindResource_t)(JImageFile* jimage, + const char* module_name, const char* version, const char* name, + jlong* size); + + +/* + * JImageGetResource - Given an open image file (see JImageOpen), a resource’s + * location information (see JImageFindResource), a buffer of appropriate + * size and the size, retrieve the bytes associated with the + * resource. If the size is less than the resource size then the read is truncated. + * If the size is greater than the resource size then the remainder of the buffer + * is zero filled. The function will return the actual size of the resource. + * + * Ex. + * jlong size; + * JImageLocationRef location = (*JImageFindResource)(image, "java.base", "9.0", "java/lang/String.class", &size); + * char* buffer = new char[size]; + * (*JImageGetResource)(image, location, buffer, size); + */ +extern "C" jlong JIMAGE_GetResource(JImageFile* jimage, JImageLocationRef location, + char* buffer, jlong size); + +typedef jlong(*JImageGetResource_t)(JImageFile* jimage, JImageLocationRef location, + char* buffer, jlong size); + + +/* + * JImageResourceIterator - Given an open image file (see JImageOpen), a visitor + * function and a visitor argument, iterator through each of the image's resources. + * The visitor function is called with the image file, the module name, the + * package name, the base name, the extension and the visitor argument. The return + * value of the visitor function should be true, unless an early iteration exit is + * required. All strings are utf-8, zero byte terminated.file. + * + * Ex. + * bool ctw_visitor(JImageFile* jimage, const char* module_name, const char* version, const char* package, const char* name, const char* extension, void* arg) { + * if (strcmp(extension, “class”) == 0) { + * char path[JIMAGE_MAX_PATH]; + * Thread* THREAD = Thread::current(); + * jio_snprintf(path, JIMAGE_MAX_PATH - 1, "/%s/%s", package, name); + * ClassLoader::compile_the_world_in(path, (Handle)arg, THREAD); + * return !HAS_PENDING_EXCEPTION; + * } + * return true; + * } + * (*JImageResourceIterator)(image, ctw_visitor, loader); + */ + +typedef bool (*JImageResourceVisitor_t)(JImageFile* jimage, + const char* module_name, const char* version, const char* package, + const char* name, const char* extension, void* arg); + +extern "C" void JIMAGE_ResourceIterator(JImageFile* jimage, + JImageResourceVisitor_t visitor, void *arg); + +typedef void (*JImageResourceIterator_t)(JImageFile* jimage, + JImageResourceVisitor_t visitor, void* arg);
--- a/src/share/vm/classfile/systemDictionary.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/systemDictionary.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -2680,187 +2680,3 @@ #endif // INCLUDE_TRACE } -#ifndef PRODUCT - -// statistics code -class ClassStatistics: AllStatic { - private: - static int nclasses; // number of classes - static int nmethods; // number of methods - static int nmethoddata; // number of methodData - static int class_size; // size of class objects in words - static int method_size; // size of method objects in words - static int debug_size; // size of debug info in methods - static int methoddata_size; // size of methodData objects in words - - static void do_class(Klass* k) { - nclasses++; - class_size += k->size(); - if (k->oop_is_instance()) { - InstanceKlass* ik = (InstanceKlass*)k; - class_size += ik->methods()->size(); - class_size += ik->constants()->size(); - class_size += ik->local_interfaces()->size(); - class_size += ik->transitive_interfaces()->size(); - // We do not have to count implementors, since we only store one! - // SSS: How should these be accounted now that they have moved? - // class_size += ik->fields()->length(); - } - } - - static void do_method(Method* m) { - nmethods++; - method_size += m->size(); - // class loader uses same objArray for empty vectors, so don't count these - if (m->has_stackmap_table()) { - method_size += m->stackmap_data()->size(); - } - - MethodData* mdo = m->method_data(); - if (mdo != NULL) { - nmethoddata++; - methoddata_size += mdo->size(); - } - } - - public: - static void print() { - SystemDictionary::classes_do(do_class); - SystemDictionary::methods_do(do_method); - tty->print_cr("Class statistics:"); - tty->print_cr("%d classes (%d bytes)", nclasses, class_size * oopSize); - tty->print_cr("%d methods (%d bytes = %d base + %d debug info)", nmethods, - (method_size + debug_size) * oopSize, method_size * oopSize, debug_size * oopSize); - tty->print_cr("%d methoddata (%d bytes)", nmethoddata, methoddata_size * oopSize); - } -}; - - -int ClassStatistics::nclasses = 0; -int ClassStatistics::nmethods = 0; -int ClassStatistics::nmethoddata = 0; -int ClassStatistics::class_size = 0; -int ClassStatistics::method_size = 0; -int ClassStatistics::debug_size = 0; -int ClassStatistics::methoddata_size = 0; - -void SystemDictionary::print_class_statistics() { - ResourceMark rm; - ClassStatistics::print(); -} - - -class MethodStatistics: AllStatic { - public: - enum { - max_parameter_size = 10 - }; - private: - - static int _number_of_methods; - static int _number_of_final_methods; - static int _number_of_static_methods; - static int _number_of_native_methods; - static int _number_of_synchronized_methods; - static int _number_of_profiled_methods; - static int _number_of_bytecodes; - static int _parameter_size_profile[max_parameter_size]; - static int _bytecodes_profile[Bytecodes::number_of_java_codes]; - - static void initialize() { - _number_of_methods = 0; - _number_of_final_methods = 0; - _number_of_static_methods = 0; - _number_of_native_methods = 0; - _number_of_synchronized_methods = 0; - _number_of_profiled_methods = 0; - _number_of_bytecodes = 0; - for (int i = 0; i < max_parameter_size ; i++) _parameter_size_profile[i] = 0; - for (int j = 0; j < Bytecodes::number_of_java_codes; j++) _bytecodes_profile [j] = 0; - }; - - static void do_method(Method* m) { - _number_of_methods++; - // collect flag info - if (m->is_final() ) _number_of_final_methods++; - if (m->is_static() ) _number_of_static_methods++; - if (m->is_native() ) _number_of_native_methods++; - if (m->is_synchronized()) _number_of_synchronized_methods++; - if (m->method_data() != NULL) _number_of_profiled_methods++; - // collect parameter size info (add one for receiver, if any) - _parameter_size_profile[MIN2(m->size_of_parameters() + (m->is_static() ? 0 : 1), max_parameter_size - 1)]++; - // collect bytecodes info - { - Thread *thread = Thread::current(); - HandleMark hm(thread); - BytecodeStream s(methodHandle(thread, m)); - Bytecodes::Code c; - while ((c = s.next()) >= 0) { - _number_of_bytecodes++; - _bytecodes_profile[c]++; - } - } - } - - public: - static void print() { - initialize(); - SystemDictionary::methods_do(do_method); - // generate output - tty->cr(); - tty->print_cr("Method statistics (static):"); - // flag distribution - tty->cr(); - tty->print_cr("%6d final methods %6.1f%%", _number_of_final_methods , _number_of_final_methods * 100.0F / _number_of_methods); - tty->print_cr("%6d static methods %6.1f%%", _number_of_static_methods , _number_of_static_methods * 100.0F / _number_of_methods); - tty->print_cr("%6d native methods %6.1f%%", _number_of_native_methods , _number_of_native_methods * 100.0F / _number_of_methods); - tty->print_cr("%6d synchronized methods %6.1f%%", _number_of_synchronized_methods, _number_of_synchronized_methods * 100.0F / _number_of_methods); - tty->print_cr("%6d profiled methods %6.1f%%", _number_of_profiled_methods, _number_of_profiled_methods * 100.0F / _number_of_methods); - // parameter size profile - tty->cr(); - { int tot = 0; - int avg = 0; - for (int i = 0; i < max_parameter_size; i++) { - int n = _parameter_size_profile[i]; - tot += n; - avg += n*i; - tty->print_cr("parameter size = %1d: %6d methods %5.1f%%", i, n, n * 100.0F / _number_of_methods); - } - assert(tot == _number_of_methods, "should be the same"); - tty->print_cr(" %6d methods 100.0%%", _number_of_methods); - tty->print_cr("(average parameter size = %3.1f including receiver, if any)", (float)avg / _number_of_methods); - } - // bytecodes profile - tty->cr(); - { int tot = 0; - for (int i = 0; i < Bytecodes::number_of_java_codes; i++) { - if (Bytecodes::is_defined(i)) { - Bytecodes::Code c = Bytecodes::cast(i); - int n = _bytecodes_profile[c]; - tot += n; - tty->print_cr("%9d %7.3f%% %s", n, n * 100.0F / _number_of_bytecodes, Bytecodes::name(c)); - } - } - assert(tot == _number_of_bytecodes, "should be the same"); - tty->print_cr("%9d 100.000%%", _number_of_bytecodes); - } - tty->cr(); - } -}; - -int MethodStatistics::_number_of_methods; -int MethodStatistics::_number_of_final_methods; -int MethodStatistics::_number_of_static_methods; -int MethodStatistics::_number_of_native_methods; -int MethodStatistics::_number_of_synchronized_methods; -int MethodStatistics::_number_of_profiled_methods; -int MethodStatistics::_number_of_bytecodes; -int MethodStatistics::_parameter_size_profile[MethodStatistics::max_parameter_size]; -int MethodStatistics::_bytecodes_profile[Bytecodes::number_of_java_codes]; - - -void SystemDictionary::print_method_statistics() { - MethodStatistics::print(); -} - -#endif // PRODUCT
--- a/src/share/vm/classfile/systemDictionary.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/systemDictionary.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -366,8 +366,6 @@ // Printing static void print(bool details = true); static void print_shared(bool details = true); - static void print_class_statistics() PRODUCT_RETURN; - static void print_method_statistics() PRODUCT_RETURN; // Number of contained klasses // This is both fully loaded classes and classes in the process
--- a/src/share/vm/classfile/vmSymbols.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/vmSymbols.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -625,6 +625,10 @@ case vmIntrinsics::_updateDirectByteBufferCRC32C: if (!UseCRC32CIntrinsics) return true; break; + case vmIntrinsics::_updateBytesAdler32: + case vmIntrinsics::_updateByteBufferAdler32: + if (!UseAdler32Intrinsics) return true; + break; case vmIntrinsics::_copyMemory: if (!InlineArrayCopy || !InlineUnsafeOps) return true; break;
--- a/src/share/vm/classfile/vmSymbols.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/classfile/vmSymbols.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -927,6 +927,12 @@ do_intrinsic(_updateDirectByteBufferCRC32C, java_util_zip_CRC32C, updateDirectByteBuffer_C_name, updateByteBuffer_signature, F_S) \ do_name( updateDirectByteBuffer_C_name, "updateDirectByteBuffer") \ \ + /* support for java.util.zip.Adler32 */ \ + do_class(java_util_zip_Adler32, "java/util/zip/Adler32") \ + do_intrinsic(_updateBytesAdler32, java_util_zip_Adler32, updateBytes_C_name, updateBytes_signature, F_SN) \ + do_intrinsic(_updateByteBufferAdler32, java_util_zip_Adler32, updateByteBuffer_A_name, updateByteBuffer_signature, F_SN) \ + do_name( updateByteBuffer_A_name, "updateByteBuffer") \ + \ /* support for sun.misc.Unsafe */ \ do_class(sun_misc_Unsafe, "sun/misc/Unsafe") \ \
--- a/src/share/vm/code/codeCache.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/codeCache.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -745,15 +745,17 @@ void CodeCache::gc_epilogue() { assert_locked_or_safepoint(CodeCache_lock); - NMethodIterator iter; - while(iter.next_alive()) { - nmethod* nm = iter.method(); - assert(!nm->is_unloaded(), "Tautology"); - if (needs_cache_clean()) { - nm->cleanup_inline_caches(); + NOT_DEBUG(if (needs_cache_clean())) { + NMethodIterator iter; + while(iter.next_alive()) { + nmethod* nm = iter.method(); + assert(!nm->is_unloaded(), "Tautology"); + DEBUG_ONLY(if (needs_cache_clean())) { + nm->cleanup_inline_caches(); + } + DEBUG_ONLY(nm->verify()); + DEBUG_ONLY(nm->verify_oop_relocations()); } - DEBUG_ONLY(nm->verify()); - DEBUG_ONLY(nm->verify_oop_relocations()); } set_needs_cache_clean(false); prune_scavenge_root_nmethods(); @@ -993,29 +995,6 @@ return number_of_marked_CodeBlobs; } -void CodeCache::make_marked_nmethods_zombies() { - assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint"); - NMethodIterator iter; - while(iter.next_alive()) { - nmethod* nm = iter.method(); - if (nm->is_marked_for_deoptimization()) { - - // If the nmethod has already been made non-entrant and it can be converted - // then zombie it now. Otherwise make it non-entrant and it will eventually - // be zombied when it is no longer seen on the stack. Note that the nmethod - // might be "entrant" and not on the stack and so could be zombied immediately - // but we can't tell because we don't track it on stack until it becomes - // non-entrant. - - if (nm->is_not_entrant() && nm->can_not_entrant_be_converted()) { - nm->make_zombie(); - } else { - nm->make_not_entrant(); - } - } - } -} - void CodeCache::make_marked_nmethods_not_entrant() { assert_locked_or_safepoint(CodeCache_lock); NMethodIterator iter; @@ -1072,7 +1051,7 @@ // Deoptimize all activations depending on marked nmethods Deoptimization::deoptimize_dependents(); - // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) + // Make the dependent methods not entrant make_marked_nmethods_not_entrant(); } } @@ -1102,7 +1081,7 @@ // Deoptimize all activations depending on marked nmethods Deoptimization::deoptimize_dependents(); - // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) + // Make the dependent methods not entrant make_marked_nmethods_not_entrant(); } }
--- a/src/share/vm/code/codeCache.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/codeCache.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -225,7 +225,6 @@ public: static void mark_all_nmethods_for_deoptimization(); static int mark_for_deoptimization(Method* dependee); - static void make_marked_nmethods_zombies(); static void make_marked_nmethods_not_entrant(); // Flushing and deoptimization
--- a/src/share/vm/code/compiledIC.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/compiledIC.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -287,6 +287,7 @@ assert( is_c1_method || !is_monomorphic || is_optimized() || + !caller->is_alive() || (cached_metadata() != NULL && cached_metadata()->is_klass()), "sanity check"); #endif // ASSERT return is_monomorphic; @@ -321,7 +322,7 @@ } -void CompiledIC::set_to_clean() { +void CompiledIC::set_to_clean(bool in_use) { assert(SafepointSynchronize::is_at_safepoint() || CompiledIC_lock->is_locked() , "MT-unsafe call"); if (TraceInlineCacheClearing || TraceICs) { tty->print_cr("IC@" INTPTR_FORMAT ": set to clean", p2i(instruction_address())); @@ -337,14 +338,14 @@ // A zombie transition will always be safe, since the metadata has already been set to NULL, so // we only need to patch the destination - bool safe_transition = is_optimized() || SafepointSynchronize::is_at_safepoint(); + bool safe_transition = !in_use || is_optimized() || SafepointSynchronize::is_at_safepoint(); if (safe_transition) { // Kill any leftover stub we might have too clear_ic_stub(); if (is_optimized()) { - set_ic_destination(entry); - } else { + set_ic_destination(entry); + } else { set_ic_destination_and_value(entry, (void*)NULL); } } else {
--- a/src/share/vm/code/compiledIC.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/compiledIC.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -214,7 +214,7 @@ // // They all takes a TRAP argument, since they can cause a GC if the inline-cache buffer is full. // - void set_to_clean(); // Can only be called during a safepoint operation + void set_to_clean(bool in_use = true); void set_to_monomorphic(CompiledICInfo& info); void clear_ic_stub();
--- a/src/share/vm/code/nmethod.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/nmethod.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -848,10 +848,10 @@ if (st != NULL) { ttyLocker ttyl; if (WizardMode) { - CompileTask::print_compilation(st, this, msg, /*short_form:*/ true); + CompileTask::print(st, this, msg, /*short_form:*/ true); st->print_cr(" (" INTPTR_FORMAT ")", this); } else { - CompileTask::print_compilation(st, this, msg, /*short_form:*/ false); + CompileTask::print(st, this, msg, /*short_form:*/ false); } } } @@ -1021,7 +1021,6 @@ void nmethod::cleanup_inline_caches() { - assert_locked_or_safepoint(CompiledIC_lock); // If the method is not entrant or zombie then a JMP is plastered over the @@ -1037,7 +1036,8 @@ // In fact, why are we bothering to look at oops in a non-entrant method?? } - // Find all calls in an nmethod, and clear the ones that points to zombie methods + // Find all calls in an nmethod and clear the ones that point to non-entrant, + // zombie and unloaded nmethods. ResourceMark rm; RelocIterator iter(this, low_boundary); while(iter.next()) { @@ -1049,8 +1049,8 @@ CodeBlob *cb = CodeCache::find_blob_unsafe(ic->ic_destination()); if( cb != NULL && cb->is_nmethod() ) { nmethod* nm = (nmethod*)cb; - // Clean inline caches pointing to both zombie and not_entrant methods - if (!nm->is_in_use() || (nm->method()->code() != nm)) ic->set_to_clean(); + // Clean inline caches pointing to zombie, non-entrant and unloaded methods + if (!nm->is_in_use() || (nm->method()->code() != nm)) ic->set_to_clean(is_alive()); } break; } @@ -1059,7 +1059,7 @@ CodeBlob *cb = CodeCache::find_blob_unsafe(csc->destination()); if( cb != NULL && cb->is_nmethod() ) { nmethod* nm = (nmethod*)cb; - // Clean inline caches pointing to both zombie and not_entrant methods + // Clean inline caches pointing to zombie, non-entrant and unloaded methods if (!nm->is_in_use() || (nm->method()->code() != nm)) csc->set_to_clean(); } break; @@ -1150,7 +1150,7 @@ // Tell if a non-entrant method can be converted to a zombie (i.e., // there are no activations on the stack, not in use by the VM, // and not in use by the ServiceThread) -bool nmethod::can_not_entrant_be_converted() { +bool nmethod::can_convert_to_zombie() { assert(is_not_entrant(), "must be a non-entrant method"); // Since the nmethod sweeper only does partial sweep the sweeper's traversal @@ -2529,7 +2529,7 @@ // Hmm. OSR methods can be deopted but not marked as zombie or not_entrant // seems odd. - if( is_zombie() || is_not_entrant() ) + if (is_zombie() || is_not_entrant() || is_unloaded()) return; // Make sure all the entry points are correctly aligned for patching.
--- a/src/share/vm/code/nmethod.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/code/nmethod.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -577,7 +577,7 @@ // See comment at definition of _last_seen_on_stack void mark_as_seen_on_stack(); - bool can_not_entrant_be_converted(); + bool can_convert_to_zombie(); // Evolution support. We make old (discarded) compiled methods point to new Method*s. void set_method(Method* method) { _method = method; }
--- a/src/share/vm/compiler/compileBroker.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/compiler/compileBroker.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -157,7 +157,6 @@ CompileQueue* CompileBroker::_c2_compile_queue = NULL; CompileQueue* CompileBroker::_c1_compile_queue = NULL; - class CompilationLog : public StringEventLog { public: CompilationLog() : StringEventLog("Compilation events") { @@ -167,7 +166,7 @@ StringLogMessage lm; stringStream sstr = lm.stream(); // msg.time_stamp().update_to(tty->time_stamp().ticks()); - task->print_compilation(&sstr, NULL, true, false); + task->print(&sstr, NULL, true, false); log(thread, "%s", (const char*)lm); } @@ -233,371 +232,6 @@ } } - -CompileTask* CompileTask::_task_free_list = NULL; -#ifdef ASSERT -int CompileTask::_num_allocated_tasks = 0; -#endif -/** - * Allocate a CompileTask, from the free list if possible. - */ -CompileTask* CompileTask::allocate() { - MutexLocker locker(CompileTaskAlloc_lock); - CompileTask* task = NULL; - - if (_task_free_list != NULL) { - task = _task_free_list; - _task_free_list = task->next(); - task->set_next(NULL); - } else { - task = new CompileTask(); - DEBUG_ONLY(_num_allocated_tasks++;) - assert (WhiteBoxAPI || _num_allocated_tasks < 10000, "Leaking compilation tasks?"); - task->set_next(NULL); - task->set_is_free(true); - } - assert(task->is_free(), "Task must be free."); - task->set_is_free(false); - return task; -} - - -/** - * Add a task to the free list. - */ -void CompileTask::free(CompileTask* task) { - MutexLocker locker(CompileTaskAlloc_lock); - if (!task->is_free()) { - task->set_code(NULL); - assert(!task->lock()->is_locked(), "Should not be locked when freed"); - JNIHandles::destroy_global(task->_method_holder); - JNIHandles::destroy_global(task->_hot_method_holder); - - task->set_is_free(true); - task->set_next(_task_free_list); - _task_free_list = task; - } -} - -void CompileTask::initialize(int compile_id, - methodHandle method, - int osr_bci, - int comp_level, - methodHandle hot_method, - int hot_count, - const char* comment, - bool is_blocking) { - assert(!_lock->is_locked(), "bad locking"); - - _compile_id = compile_id; - _method = method(); - _method_holder = JNIHandles::make_global(method->method_holder()->klass_holder()); - _osr_bci = osr_bci; - _is_blocking = is_blocking; - _comp_level = comp_level; - _num_inlined_bytecodes = 0; - - _is_complete = false; - _is_success = false; - _code_handle = NULL; - - _hot_method = NULL; - _hot_method_holder = NULL; - _hot_count = hot_count; - _time_queued = 0; // tidy - _comment = comment; - _failure_reason = NULL; - - if (LogCompilation) { - _time_queued = os::elapsed_counter(); - if (hot_method.not_null()) { - if (hot_method == method) { - _hot_method = _method; - } else { - _hot_method = hot_method(); - // only add loader or mirror if different from _method_holder - _hot_method_holder = JNIHandles::make_global(hot_method->method_holder()->klass_holder()); - } - } - } - - _next = NULL; -} - -// ------------------------------------------------------------------ -// CompileTask::code/set_code -nmethod* CompileTask::code() const { - if (_code_handle == NULL) return NULL; - return _code_handle->code(); -} -void CompileTask::set_code(nmethod* nm) { - if (_code_handle == NULL && nm == NULL) return; - guarantee(_code_handle != NULL, ""); - _code_handle->set_code(nm); - if (nm == NULL) _code_handle = NULL; // drop the handle also -} - -void CompileTask::mark_on_stack() { - // Mark these methods as something redefine classes cannot remove. - _method->set_on_stack(true); - if (_hot_method != NULL) { - _hot_method->set_on_stack(true); - } -} - -// RedefineClasses support -void CompileTask::metadata_do(void f(Metadata*)) { - f(method()); - if (hot_method() != NULL && hot_method() != method()) { - f(hot_method()); - } -} - -// ------------------------------------------------------------------ -// CompileTask::print_line_on_error -// -// This function is called by fatal error handler when the thread -// causing troubles is a compiler thread. -// -// Do not grab any lock, do not allocate memory. -// -// Otherwise it's the same as CompileTask::print_line() -// -void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) { - // print compiler name - st->print("%s:", CompileBroker::compiler_name(comp_level())); - print_compilation(st); -} - -// ------------------------------------------------------------------ -// CompileTask::print_line -void CompileTask::print_tty() { - ttyLocker ttyl; // keep the following output all in one block - // print compiler name if requested - if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler_name(comp_level())); - print_compilation(tty); -} - -// ------------------------------------------------------------------ -// CompileTask::print_compilation_impl -void CompileTask::print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level, - bool is_osr_method, int osr_bci, bool is_blocking, - const char* msg, bool short_form, bool cr) { - if (!short_form) { - st->print("%7d ", (int) st->time_stamp().milliseconds()); // print timestamp - } - st->print("%4d ", compile_id); // print compilation number - - // For unloaded methods the transition to zombie occurs after the - // method is cleared so it's impossible to report accurate - // information for that case. - bool is_synchronized = false; - bool has_exception_handler = false; - bool is_native = false; - if (method != NULL) { - is_synchronized = method->is_synchronized(); - has_exception_handler = method->has_exception_handler(); - is_native = method->is_native(); - } - // method attributes - const char compile_type = is_osr_method ? '%' : ' '; - const char sync_char = is_synchronized ? 's' : ' '; - const char exception_char = has_exception_handler ? '!' : ' '; - const char blocking_char = is_blocking ? 'b' : ' '; - const char native_char = is_native ? 'n' : ' '; - - // print method attributes - st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, native_char); - - if (TieredCompilation) { - if (comp_level != -1) st->print("%d ", comp_level); - else st->print("- "); - } - st->print(" "); // more indent - - if (method == NULL) { - st->print("(method)"); - } else { - method->print_short_name(st); - if (is_osr_method) { - st->print(" @ %d", osr_bci); - } - if (method->is_native()) - st->print(" (native)"); - else - st->print(" (%d bytes)", method->code_size()); - } - - if (msg != NULL) { - st->print(" %s", msg); - } - if (cr) { - st->cr(); - } -} - -// ------------------------------------------------------------------ -// CompileTask::print_inlining -void CompileTask::print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) { - // 1234567 - st->print(" "); // print timestamp - // 1234 - st->print(" "); // print compilation number - - // method attributes - if (method->is_loaded()) { - const char sync_char = method->is_synchronized() ? 's' : ' '; - const char exception_char = method->has_exception_handlers() ? '!' : ' '; - const char monitors_char = method->has_monitor_bytecodes() ? 'm' : ' '; - - // print method attributes - st->print(" %c%c%c ", sync_char, exception_char, monitors_char); - } else { - // %s!bn - st->print(" "); // print method attributes - } - - if (TieredCompilation) { - st->print(" "); - } - st->print(" "); // more indent - st->print(" "); // initial inlining indent - - for (int i = 0; i < inline_level; i++) st->print(" "); - - st->print("@ %d ", bci); // print bci - method->print_short_name(st); - if (method->is_loaded()) - st->print(" (%d bytes)", method->code_size()); - else - st->print(" (not loaded)"); - - if (msg != NULL) { - st->print(" %s", msg); - } - st->cr(); -} - -// ------------------------------------------------------------------ -// CompileTask::print_inline_indent -void CompileTask::print_inline_indent(int inline_level, outputStream* st) { - // 1234567 - st->print(" "); // print timestamp - // 1234 - st->print(" "); // print compilation number - // %s!bn - st->print(" "); // print method attributes - if (TieredCompilation) { - st->print(" "); - } - st->print(" "); // more indent - st->print(" "); // initial inlining indent - for (int i = 0; i < inline_level; i++) st->print(" "); -} - -// ------------------------------------------------------------------ -// CompileTask::print_compilation -void CompileTask::print_compilation(outputStream* st, const char* msg, bool short_form, bool cr) { - bool is_osr_method = osr_bci() != InvocationEntryBci; - print_compilation_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), msg, short_form, cr); -} - -// ------------------------------------------------------------------ -// CompileTask::log_task -void CompileTask::log_task(xmlStream* log) { - Thread* thread = Thread::current(); - methodHandle method(thread, this->method()); - ResourceMark rm(thread); - - // <task compiler='Cx' id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'> - log->print(" compiler='%s' compile_id='%d'", _comp_level <= CompLevel_full_profile ? "C1" : "C2", _compile_id); - if (_osr_bci != CompileBroker::standard_entry_bci) { - log->print(" compile_kind='osr'"); // same as nmethod::compile_kind - } // else compile_kind='c2c' - if (!method.is_null()) log->method(method); - if (_osr_bci != CompileBroker::standard_entry_bci) { - log->print(" osr_bci='%d'", _osr_bci); - } - if (_comp_level != CompLevel_highest_tier) { - log->print(" level='%d'", _comp_level); - } - if (_is_blocking) { - log->print(" blocking='1'"); - } - log->stamp(); -} - - -// ------------------------------------------------------------------ -// CompileTask::log_task_queued -void CompileTask::log_task_queued() { - Thread* thread = Thread::current(); - ttyLocker ttyl; - ResourceMark rm(thread); - - xtty->begin_elem("task_queued"); - log_task(xtty); - if (_comment != NULL) { - xtty->print(" comment='%s'", _comment); - } - if (_hot_method != NULL) { - methodHandle hot(thread, _hot_method); - methodHandle method(thread, _method); - if (hot() != method()) { - xtty->method(hot); - } - } - if (_hot_count != 0) { - xtty->print(" hot_count='%d'", _hot_count); - } - xtty->end_elem(); -} - - -// ------------------------------------------------------------------ -// CompileTask::log_task_start -void CompileTask::log_task_start(CompileLog* log) { - log->begin_head("task"); - log_task(log); - log->end_head(); -} - - -// ------------------------------------------------------------------ -// CompileTask::log_task_done -void CompileTask::log_task_done(CompileLog* log) { - Thread* thread = Thread::current(); - methodHandle method(thread, this->method()); - ResourceMark rm(thread); - - if (!_is_success) { - const char* reason = _failure_reason != NULL ? _failure_reason : "unknown"; - log->elem("failure reason='%s'", reason); - } - - // <task_done ... stamp='1.234'> </task> - nmethod* nm = code(); - log->begin_elem("task_done success='%d' nmsize='%d' count='%d'", - _is_success, nm == NULL ? 0 : nm->content_size(), - method->invocation_count()); - int bec = method->backedge_count(); - if (bec != 0) log->print(" backedge_count='%d'", bec); - // Note: "_is_complete" is about to be set, but is not. - if (_num_inlined_bytecodes != 0) { - log->print(" inlined_bytes='%d'", _num_inlined_bytecodes); - } - log->stamp(); - log->end_elem(); - log->tail("task"); - log->clear_identities(); // next task will have different CI - if (log->unflushed_count() > 2000) { - log->flush(); - } - log->mark_file_end(); -} - - - /** * Add a CompileTask to a CompileQueue. */ @@ -807,7 +441,7 @@ st->print_cr("Empty"); } else { while (task != NULL) { - task->print_compilation(st, NULL, true, true); + task->print(st, NULL, true, true); task = task->next(); } } @@ -1349,7 +983,7 @@ #ifndef TIERED // seems like an assert of dubious value assert(comp_level == CompLevel_highest_tier, - "all OSR compiles are assumed to be at a single compilation lavel"); + "all OSR compiles are assumed to be at a single compilation level"); #endif // TIERED // We accept a higher level osr method nmethod* nm = method->lookup_osr_nmethod_for(osr_bci, comp_level, false); @@ -1399,6 +1033,28 @@ // do the compilation if (method->is_native()) { if (!PreferInterpreterNativeStubs || method->is_method_handle_intrinsic()) { + // The following native methods: + // + // java.lang.Float.intBitsToFloat + // java.lang.Float.floatToRawIntBits + // java.lang.Double.longBitsToDouble + // java.lang.Double.doubleToRawLongBits + // + // are called through the interpreter even if interpreter native stubs + // are not preferred (i.e., calling through adapter handlers is preferred). + // The reason is that on x86_32 signaling NaNs (sNaNs) are not preserved + // if the version of the methods from the native libraries is called. + // As the interpreter and the C2-intrinsified version of the methods preserves + // sNaNs, that would result in an inconsistent way of handling of sNaNs. + if ((UseSSE >= 1 && + (method->intrinsic_id() == vmIntrinsics::_intBitsToFloat || + method->intrinsic_id() == vmIntrinsics::_floatToRawIntBits)) || + (UseSSE >= 2 && + (method->intrinsic_id() == vmIntrinsics::_longBitsToDouble || + method->intrinsic_id() == vmIntrinsics::_doubleToRawLongBits))) { + return NULL; + } + // To properly handle the appendix argument for out-of-line calls we are using a small trampoline that // pops off the appendix argument and jumps to the target (see gen_special_dispatch in SharedRuntime). // @@ -2015,7 +1671,7 @@ FormatBufferResource msg = retry_message != NULL ? err_msg_res("COMPILE SKIPPED: %s (%s)", ci_env.failure_reason(), retry_message) : err_msg_res("COMPILE SKIPPED: %s", ci_env.failure_reason()); - task->print_compilation(tty, msg); + task->print(tty, msg); } } else { task->mark_success();
--- a/src/share/vm/compiler/compileBroker.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/compiler/compileBroker.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,127 +27,12 @@ #include "ci/compilerInterface.hpp" #include "compiler/abstractCompiler.hpp" +#include "compiler/compileTask.hpp" #include "runtime/perfData.hpp" class nmethod; class nmethodLocker; -// CompileTask -// -// An entry in the compile queue. It represents a pending or current -// compilation. -class CompileTask : public CHeapObj<mtCompiler> { - friend class VMStructs; - - private: - static CompileTask* _task_free_list; -#ifdef ASSERT - static int _num_allocated_tasks; -#endif - - Monitor* _lock; - uint _compile_id; - Method* _method; - jobject _method_holder; - int _osr_bci; - bool _is_complete; - bool _is_success; - bool _is_blocking; - int _comp_level; - int _num_inlined_bytecodes; - nmethodLocker* _code_handle; // holder of eventual result - CompileTask* _next, *_prev; - bool _is_free; - // Fields used for logging why the compilation was initiated: - jlong _time_queued; // in units of os::elapsed_counter() - Method* _hot_method; // which method actually triggered this task - jobject _hot_method_holder; - int _hot_count; // information about its invocation counter - const char* _comment; // more info about the task - const char* _failure_reason; - - public: - CompileTask() { - _lock = new Monitor(Mutex::nonleaf+2, "CompileTaskLock"); - } - - void initialize(int compile_id, methodHandle method, int osr_bci, int comp_level, - methodHandle hot_method, int hot_count, const char* comment, - bool is_blocking); - - static CompileTask* allocate(); - static void free(CompileTask* task); - - int compile_id() const { return _compile_id; } - Method* method() const { return _method; } - Method* hot_method() const { return _hot_method; } - int osr_bci() const { return _osr_bci; } - bool is_complete() const { return _is_complete; } - bool is_blocking() const { return _is_blocking; } - bool is_success() const { return _is_success; } - - nmethodLocker* code_handle() const { return _code_handle; } - void set_code_handle(nmethodLocker* l) { _code_handle = l; } - nmethod* code() const; // _code_handle->code() - void set_code(nmethod* nm); // _code_handle->set_code(nm) - - Monitor* lock() const { return _lock; } - - void mark_complete() { _is_complete = true; } - void mark_success() { _is_success = true; } - - int comp_level() { return _comp_level;} - void set_comp_level(int comp_level) { _comp_level = comp_level;} - - int num_inlined_bytecodes() const { return _num_inlined_bytecodes; } - void set_num_inlined_bytecodes(int n) { _num_inlined_bytecodes = n; } - - CompileTask* next() const { return _next; } - void set_next(CompileTask* next) { _next = next; } - CompileTask* prev() const { return _prev; } - void set_prev(CompileTask* prev) { _prev = prev; } - bool is_free() const { return _is_free; } - void set_is_free(bool val) { _is_free = val; } - - // RedefineClasses support - void metadata_do(void f(Metadata*)); - -private: - static void print_compilation_impl(outputStream* st, Method* method, int compile_id, int comp_level, - bool is_osr_method = false, int osr_bci = -1, bool is_blocking = false, - const char* msg = NULL, bool short_form = false, bool cr = true); - -public: - void print_compilation(outputStream* st = tty, const char* msg = NULL, bool short_form = false, bool cr = true); - static void print_compilation(outputStream* st, const nmethod* nm, const char* msg = NULL, bool short_form = false, bool cr = true) { - print_compilation_impl(st, nm->method(), nm->compile_id(), nm->comp_level(), - nm->is_osr_method(), nm->is_osr_method() ? nm->osr_entry_bci() : -1, /*is_blocking*/ false, - msg, short_form, cr); - } - - static void print_inlining(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg = NULL); - static void print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) { - print_inlining(tty, method, inline_level, bci, msg); - } - - // Redefine Classes support - void mark_on_stack(); - - static void print_inline_indent(int inline_level, outputStream* st = tty); - - void print_tty(); - void print_line_on_error(outputStream* st, char* buf, int buflen); - - void log_task(xmlStream* log); - void log_task_queued(); - void log_task_start(CompileLog* log); - void log_task_done(CompileLog* log); - - void set_failure_reason(const char* reason) { - _failure_reason = reason; - } -}; - // CompilerCounters // // Per Compiler Performance Counters.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/compiler/compileTask.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,391 @@ +/* + * Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "compiler/compileTask.hpp" +#include "compiler/compileLog.hpp" +#include "compiler/compileBroker.hpp" + +CompileTask* CompileTask::_task_free_list = NULL; +#ifdef ASSERT +int CompileTask::_num_allocated_tasks = 0; +#endif + +/** + * Allocate a CompileTask, from the free list if possible. + */ +CompileTask* CompileTask::allocate() { + MutexLocker locker(CompileTaskAlloc_lock); + CompileTask* task = NULL; + + if (_task_free_list != NULL) { + task = _task_free_list; + _task_free_list = task->next(); + task->set_next(NULL); + } else { + task = new CompileTask(); + DEBUG_ONLY(_num_allocated_tasks++;) + assert (WhiteBoxAPI || _num_allocated_tasks < 10000, "Leaking compilation tasks?"); + task->set_next(NULL); + task->set_is_free(true); + } + assert(task->is_free(), "Task must be free."); + task->set_is_free(false); + return task; +} + +/** +* Add a task to the free list. +*/ + +void CompileTask::free(CompileTask* task) { + MutexLocker locker(CompileTaskAlloc_lock); + if (!task->is_free()) { + task->set_code(NULL); + assert(!task->lock()->is_locked(), "Should not be locked when freed"); + JNIHandles::destroy_global(task->_method_holder); + JNIHandles::destroy_global(task->_hot_method_holder); + + task->set_is_free(true); + task->set_next(_task_free_list); + _task_free_list = task; + } +} + + +void CompileTask::initialize(int compile_id, + methodHandle method, + int osr_bci, + int comp_level, + methodHandle hot_method, + int hot_count, + const char* comment, + bool is_blocking) { + assert(!_lock->is_locked(), "bad locking"); + + _compile_id = compile_id; + _method = method(); + _method_holder = JNIHandles::make_global(method->method_holder()->klass_holder()); + _osr_bci = osr_bci; + _is_blocking = is_blocking; + _comp_level = comp_level; + _num_inlined_bytecodes = 0; + + _is_complete = false; + _is_success = false; + _code_handle = NULL; + + _hot_method = NULL; + _hot_method_holder = NULL; + _hot_count = hot_count; + _time_queued = 0; // tidy + _comment = comment; + _failure_reason = NULL; + + if (LogCompilation) { + _time_queued = os::elapsed_counter(); + if (hot_method.not_null()) { + if (hot_method == method) { + _hot_method = _method; + } else { + _hot_method = hot_method(); + // only add loader or mirror if different from _method_holder + _hot_method_holder = JNIHandles::make_global(hot_method->method_holder()->klass_holder()); + } + } + } + + _next = NULL; +} + +// ------------------------------------------------------------------ +// CompileTask::code/set_code +// +nmethod* CompileTask::code() const { + if (_code_handle == NULL) return NULL; + return _code_handle->code(); +} + +void CompileTask::set_code(nmethod* nm) { + if (_code_handle == NULL && nm == NULL) return; + guarantee(_code_handle != NULL, ""); + _code_handle->set_code(nm); + if (nm == NULL) _code_handle = NULL; // drop the handle also +} + +void CompileTask::mark_on_stack() { + // Mark these methods as something redefine classes cannot remove. + _method->set_on_stack(true); + if (_hot_method != NULL) { + _hot_method->set_on_stack(true); + } +} + +// RedefineClasses support +void CompileTask::metadata_do(void f(Metadata*)) { + f(method()); + if (hot_method() != NULL && hot_method() != method()) { + f(hot_method()); + } +} + +// ------------------------------------------------------------------ +// CompileTask::print_line_on_error +// +// This function is called by fatal error handler when the thread +// causing troubles is a compiler thread. +// +// Do not grab any lock, do not allocate memory. +// +// Otherwise it's the same as CompileTask::print_line() +// +void CompileTask::print_line_on_error(outputStream* st, char* buf, int buflen) { + // print compiler name + st->print("%s:", CompileBroker::compiler_name(comp_level())); + print(st); +} + +// ------------------------------------------------------------------ +// CompileTask::print_tty +void CompileTask::print_tty() { + ttyLocker ttyl; // keep the following output all in one block + // print compiler name if requested + if (CIPrintCompilerName) tty->print("%s:", CompileBroker::compiler_name(comp_level())); + print(tty); +} + +// ------------------------------------------------------------------ +// CompileTask::print_impl +void CompileTask::print_impl(outputStream* st, Method* method, int compile_id, int comp_level, + bool is_osr_method, int osr_bci, bool is_blocking, + const char* msg, bool short_form, bool cr) { + if (!short_form) { + st->print("%7d ", (int) st->time_stamp().milliseconds()); // print timestamp + } + st->print("%4d ", compile_id); // print compilation number + + // For unloaded methods the transition to zombie occurs after the + // method is cleared so it's impossible to report accurate + // information for that case. + bool is_synchronized = false; + bool has_exception_handler = false; + bool is_native = false; + if (method != NULL) { + is_synchronized = method->is_synchronized(); + has_exception_handler = method->has_exception_handler(); + is_native = method->is_native(); + } + // method attributes + const char compile_type = is_osr_method ? '%' : ' '; + const char sync_char = is_synchronized ? 's' : ' '; + const char exception_char = has_exception_handler ? '!' : ' '; + const char blocking_char = is_blocking ? 'b' : ' '; + const char native_char = is_native ? 'n' : ' '; + + // print method attributes + st->print("%c%c%c%c%c ", compile_type, sync_char, exception_char, blocking_char, native_char); + + if (TieredCompilation) { + if (comp_level != -1) st->print("%d ", comp_level); + else st->print("- "); + } + st->print(" "); // more indent + + if (method == NULL) { + st->print("(method)"); + } else { + method->print_short_name(st); + if (is_osr_method) { + st->print(" @ %d", osr_bci); + } + if (method->is_native()) + st->print(" (native)"); + else + st->print(" (%d bytes)", method->code_size()); + } + + if (msg != NULL) { + st->print(" %s", msg); + } + if (cr) { + st->cr(); + } +} + +void CompileTask::print_inline_indent(int inline_level, outputStream* st) { + // 1234567 + st->print(" "); // print timestamp + // 1234 + st->print(" "); // print compilation number + // %s!bn + st->print(" "); // print method attributes + if (TieredCompilation) { + st->print(" "); + } + st->print(" "); // more indent + st->print(" "); // initial inlining indent + for (int i = 0; i < inline_level; i++) st->print(" "); +} + +// ------------------------------------------------------------------ +// CompileTask::print_compilation +void CompileTask::print(outputStream* st, const char* msg, bool short_form, bool cr) { + bool is_osr_method = osr_bci() != InvocationEntryBci; + print_impl(st, method(), compile_id(), comp_level(), is_osr_method, osr_bci(), is_blocking(), msg, short_form, cr); +} + +// ------------------------------------------------------------------ +// CompileTask::log_task +void CompileTask::log_task(xmlStream* log) { + Thread* thread = Thread::current(); + methodHandle method(thread, this->method()); + ResourceMark rm(thread); + + // <task id='9' method='M' osr_bci='X' level='1' blocking='1' stamp='1.234'> + log->print(" compile_id='%d'", _compile_id); + if (_osr_bci != CompileBroker::standard_entry_bci) { + log->print(" compile_kind='osr'"); // same as nmethod::compile_kind + } // else compile_kind='c2c' + if (!method.is_null()) log->method(method); + if (_osr_bci != CompileBroker::standard_entry_bci) { + log->print(" osr_bci='%d'", _osr_bci); + } + if (_comp_level != CompLevel_highest_tier) { + log->print(" level='%d'", _comp_level); + } + if (_is_blocking) { + log->print(" blocking='1'"); + } + log->stamp(); +} + +// ------------------------------------------------------------------ +// CompileTask::log_task_queued +void CompileTask::log_task_queued() { + Thread* thread = Thread::current(); + ttyLocker ttyl; + ResourceMark rm(thread); + + xtty->begin_elem("task_queued"); + log_task(xtty); + if (_comment != NULL) { + xtty->print(" comment='%s'", _comment); + } + if (_hot_method != NULL) { + methodHandle hot(thread, _hot_method); + methodHandle method(thread, _method); + if (hot() != method()) { + xtty->method(hot); + } + } + if (_hot_count != 0) { + xtty->print(" hot_count='%d'", _hot_count); + } + xtty->end_elem(); +} + + +// ------------------------------------------------------------------ +// CompileTask::log_task_start +void CompileTask::log_task_start(CompileLog* log) { + log->begin_head("task"); + log_task(log); + log->end_head(); +} + + +// ------------------------------------------------------------------ +// CompileTask::log_task_done +void CompileTask::log_task_done(CompileLog* log) { + Thread* thread = Thread::current(); + methodHandle method(thread, this->method()); + ResourceMark rm(thread); + + if (!_is_success) { + const char* reason = _failure_reason != NULL ? _failure_reason : "unknown"; + log->elem("failure reason='%s'", reason); + } + + // <task_done ... stamp='1.234'> </task> + nmethod* nm = code(); + log->begin_elem("task_done success='%d' nmsize='%d' count='%d'", + _is_success, nm == NULL ? 0 : nm->content_size(), + method->invocation_count()); + int bec = method->backedge_count(); + if (bec != 0) log->print(" backedge_count='%d'", bec); + // Note: "_is_complete" is about to be set, but is not. + if (_num_inlined_bytecodes != 0) { + log->print(" inlined_bytes='%d'", _num_inlined_bytecodes); + } + log->stamp(); + log->end_elem(); + log->clear_identities(); // next task will have different CI + log->tail("task"); + if (log->unflushed_count() > 2000) { + log->flush(); + } + log->mark_file_end(); +} + +// ------------------------------------------------------------------ +// CompileTask::print_inlining +void CompileTask::print_inlining_inner(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg) { + // 1234567 + st->print(" "); // print timestamp + // 1234 + st->print(" "); // print compilation number + + // method attributes + if (method->is_loaded()) { + const char sync_char = method->is_synchronized() ? 's' : ' '; + const char exception_char = method->has_exception_handlers() ? '!' : ' '; + const char monitors_char = method->has_monitor_bytecodes() ? 'm' : ' '; + + // print method attributes + st->print(" %c%c%c ", sync_char, exception_char, monitors_char); + } else { + // %s!bn + st->print(" "); // print method attributes + } + + if (TieredCompilation) { + st->print(" "); + } + st->print(" "); // more indent + st->print(" "); // initial inlining indent + + for (int i = 0; i < inline_level; i++) st->print(" "); + + st->print("@ %d ", bci); // print bci + method->print_short_name(st); + if (method->is_loaded()) + st->print(" (%d bytes)", method->code_size()); + else + st->print(" (not loaded)"); + + if (msg != NULL) { + st->print(" %s", msg); + } + st->cr(); +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/compiler/compileTask.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,151 @@ +/* + * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_COMPILER_COMPILETASK_HPP +#define SHARE_VM_COMPILER_COMPILETASK_HPP + +#include "code/nmethod.hpp" +#include "ci/ciMethod.hpp" +#include "compiler/compileLog.hpp" +#include "memory/allocation.inline.hpp" +#include "utilities/xmlstream.hpp" + +// CompileTask +// +// An entry in the compile queue. It represents a pending or current +// compilation. + +class CompileTask : public CHeapObj<mtCompiler> { + friend class VMStructs; + + private: + static CompileTask* _task_free_list; +#ifdef ASSERT + static int _num_allocated_tasks; +#endif + + Monitor* _lock; + uint _compile_id; + Method* _method; + jobject _method_holder; + int _osr_bci; + bool _is_complete; + bool _is_success; + bool _is_blocking; + int _comp_level; + int _num_inlined_bytecodes; + nmethodLocker* _code_handle; // holder of eventual result + CompileTask* _next, *_prev; + bool _is_free; + // Fields used for logging why the compilation was initiated: + jlong _time_queued; // in units of os::elapsed_counter() + Method* _hot_method; // which method actually triggered this task + jobject _hot_method_holder; + int _hot_count; // information about its invocation counter + const char* _comment; // more info about the task + const char* _failure_reason; + + public: + CompileTask() { + _lock = new Monitor(Mutex::nonleaf+2, "CompileTaskLock"); + } + + void initialize(int compile_id, methodHandle method, int osr_bci, int comp_level, + methodHandle hot_method, int hot_count, const char* comment, + bool is_blocking); + + static CompileTask* allocate(); + static void free(CompileTask* task); + + int compile_id() const { return _compile_id; } + Method* method() const { return _method; } + Method* hot_method() const { return _hot_method; } + int osr_bci() const { return _osr_bci; } + bool is_complete() const { return _is_complete; } + bool is_blocking() const { return _is_blocking; } + bool is_success() const { return _is_success; } + + nmethodLocker* code_handle() const { return _code_handle; } + void set_code_handle(nmethodLocker* l) { _code_handle = l; } + nmethod* code() const; // _code_handle->code() + void set_code(nmethod* nm); // _code_handle->set_code(nm) + + Monitor* lock() const { return _lock; } + + void mark_complete() { _is_complete = true; } + void mark_success() { _is_success = true; } + + int comp_level() { return _comp_level;} + void set_comp_level(int comp_level) { _comp_level = comp_level;} + + int num_inlined_bytecodes() const { return _num_inlined_bytecodes; } + void set_num_inlined_bytecodes(int n) { _num_inlined_bytecodes = n; } + + CompileTask* next() const { return _next; } + void set_next(CompileTask* next) { _next = next; } + CompileTask* prev() const { return _prev; } + void set_prev(CompileTask* prev) { _prev = prev; } + bool is_free() const { return _is_free; } + void set_is_free(bool val) { _is_free = val; } + + // RedefineClasses support + void metadata_do(void f(Metadata*)); + void mark_on_stack(); + +private: + static void print_impl(outputStream* st, Method* method, int compile_id, int comp_level, + bool is_osr_method = false, int osr_bci = -1, bool is_blocking = false, + const char* msg = NULL, bool short_form = false, bool cr = true); + +public: + void print(outputStream* st = tty, const char* msg = NULL, bool short_form = false, bool cr = true); + static void print(outputStream* st, const nmethod* nm, const char* msg = NULL, bool short_form = false, bool cr = true) { + print_impl(st, nm->method(), nm->compile_id(), nm->comp_level(), + nm->is_osr_method(), nm->is_osr_method() ? nm->osr_entry_bci() : -1, /*is_blocking*/ false, + msg, short_form, cr); + } + + static void print_inline_indent(int inline_level, outputStream* st = tty); + + void print_tty(); + void print_line_on_error(outputStream* st, char* buf, int buflen); + + void log_task(xmlStream* log); + void log_task_queued(); + void log_task_start(CompileLog* log); + void log_task_done(CompileLog* log); + + void set_failure_reason(const char* reason) { + _failure_reason = reason; + } + + bool check_break_at_flags(); + + static void print_inlining_inner(outputStream* st, ciMethod* method, int inline_level, int bci, const char* msg = NULL); + static void print_inlining_tty(ciMethod* method, int inline_level, int bci, const char* msg = NULL) { + print_inlining_inner(tty, method, inline_level, bci, msg); + } +}; + +#endif // SHARE_VM_COMPILER_COMPILETASK_HPP
--- a/src/share/vm/gc/cms/cmsOopClosures.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/cmsOopClosures.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -66,7 +66,8 @@ virtual void do_klass(Klass* k); void do_klass_nv(Klass* k); - virtual void do_class_loader_data(ClassLoaderData* cld); + virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } + void do_cld_nv(ClassLoaderData* cld); }; class MarkRefsIntoClosure: public MetadataAwareOopsInGenClosure {
--- a/src/share/vm/gc/cms/cmsOopClosures.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/cmsOopClosures.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -50,11 +50,11 @@ inline void MetadataAwareOopsInGenClosure::do_klass_nv(Klass* k) { ClassLoaderData* cld = k->class_loader_data(); - do_class_loader_data(cld); + do_cld_nv(cld); } inline void MetadataAwareOopsInGenClosure::do_klass(Klass* k) { do_klass_nv(k); } -inline void MetadataAwareOopsInGenClosure::do_class_loader_data(ClassLoaderData* cld) { +inline void MetadataAwareOopsInGenClosure::do_cld_nv(ClassLoaderData* cld) { assert(_klass_closure._oop_closure == this, "Must be"); bool claim = true; // Must claim the class loader data before processing.
--- a/src/share/vm/gc/cms/compactibleFreeListSpace.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/compactibleFreeListSpace.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -702,7 +702,7 @@ !_cfls->CompactibleFreeListSpace::obj_allocated_since_save_marks( \ oop(bottom)) && \ !_collector->CMSCollector::is_dead_obj(oop(bottom))) { \ - size_t word_sz = oop(bottom)->oop_iterate(cl, mr); \ + size_t word_sz = oop(bottom)->oop_iterate_size(cl, mr); \ bottom += _cfls->adjustObjectSize(word_sz); \ } else { \ bottom += _cfls->CompactibleFreeListSpace::block_size(bottom); \ @@ -729,7 +729,7 @@ !_cfls->CompactibleFreeListSpace::obj_allocated_since_save_marks( \ oop(bottom)) && \ !_collector->CMSCollector::is_dead_obj(oop(bottom))) { \ - size_t word_sz = oop(bottom)->oop_iterate(cl, mr); \ + size_t word_sz = oop(bottom)->oop_iterate_size(cl, mr); \ bottom += _cfls->adjustObjectSize(word_sz); \ } else { \ bottom += _cfls->CompactibleFreeListSpace::block_size_nopar(bottom); \ @@ -2989,7 +2989,7 @@ assert(task_size > CardTableModRefBS::card_size_in_words && (task_size % CardTableModRefBS::card_size_in_words == 0), "Otherwise arithmetic below would be incorrect"); - MemRegion span = _gen->reserved(); + MemRegion span = _old_gen->reserved(); if (low != NULL) { if (span.contains(low)) { // Align low down to a card boundary so that
--- a/src/share/vm/gc/cms/compactibleFreeListSpace.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/compactibleFreeListSpace.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -99,7 +99,7 @@ BlockOffsetArrayNonContigSpace _bt; CMSCollector* _collector; - ConcurrentMarkSweepGeneration* _gen; + ConcurrentMarkSweepGeneration* _old_gen; // Data structures for free blocks (used during allocation/sweeping)
--- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -212,7 +212,7 @@ use_adaptive_freelists, dictionaryChoice); NOT_PRODUCT(debug_cms_space = _cmsSpace;) - _cmsSpace->_gen = this; + _cmsSpace->_old_gen = this; _gc_stats = new CMSGCStats(); @@ -359,13 +359,13 @@ (size_t) _cms_gen->gc_stats()->avg_promoted()->padded_average()); if (cms_free > expected_promotion) { // Start a cms collection if there isn't enough space to promote - // for the next minor collection. Use the padded average as + // for the next young collection. Use the padded average as // a safety factor. cms_free -= expected_promotion; // Adjust by the safety factor. double cms_free_dbl = (double)cms_free; - double cms_adjustment = (100.0 - CMSIncrementalSafetyFactor)/100.0; + double cms_adjustment = (100.0 - CMSIncrementalSafetyFactor) / 100.0; // Apply a further correction factor which tries to adjust // for recent occurance of concurrent mode failures. cms_adjustment = cms_adjustment * cms_free_adjustment_factor(cms_free); @@ -531,7 +531,7 @@ if (CMSConcurrentMTEnabled) { if (FLAG_IS_DEFAULT(ConcGCThreads)) { // just for now - FLAG_SET_DEFAULT(ConcGCThreads, (ParallelGCThreads + 3)/4); + FLAG_SET_DEFAULT(ConcGCThreads, (ParallelGCThreads + 3) / 4); } if (ConcGCThreads > 1) { _conc_workers = new YieldingFlexibleWorkGang("CMS Thread", @@ -592,7 +592,7 @@ _cmsGen ->init_initiating_occupancy(CMSInitiatingOccupancyFraction, CMSTriggerRatio); // Clip CMSBootstrapOccupancy between 0 and 100. - _bootstrap_occupancy = ((double)CMSBootstrapOccupancy)/(double)100; + _bootstrap_occupancy = CMSBootstrapOccupancy / 100.0; // Now tell CMS generations the identity of their collector ConcurrentMarkSweepGeneration::set_collector(this); @@ -613,14 +613,14 @@ _end_addr = gch->end_addr(); assert(_young_gen != NULL, "no _young_gen"); _eden_chunk_index = 0; - _eden_chunk_capacity = (_young_gen->max_capacity()+CMSSamplingGrain)/CMSSamplingGrain; + _eden_chunk_capacity = (_young_gen->max_capacity() + CMSSamplingGrain) / CMSSamplingGrain; _eden_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, _eden_chunk_capacity, mtGC); } // Support for parallelizing survivor space rescan if ((CMSParallelRemarkEnabled && CMSParallelSurvivorRemarkEnabled) || CMSParallelInitialMarkEnabled) { const size_t max_plab_samples = - _young_gen->max_survivor_size() / (ThreadLocalAllocBuffer::min_size() * HeapWordSize); + _young_gen->max_survivor_size() / (PLAB::min_size() * HeapWordSize); _survivor_plab_array = NEW_C_HEAP_ARRAY(ChunkArray, ParallelGCThreads, mtGC); _survivor_chunk_array = NEW_C_HEAP_ARRAY(HeapWord*, max_plab_samples, mtGC); @@ -795,29 +795,22 @@ size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); gclog_or_tty->print_cr("\nFrom compute_new_size: "); gclog_or_tty->print_cr(" Free fraction %f", free_percentage); - gclog_or_tty->print_cr(" Desired free fraction %f", - desired_free_percentage); - gclog_or_tty->print_cr(" Maximum free fraction %f", - maximum_free_percentage); - gclog_or_tty->print_cr(" Capacity " SIZE_FORMAT, capacity()/1000); - gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT, - desired_capacity/1000); + gclog_or_tty->print_cr(" Desired free fraction %f", desired_free_percentage); + gclog_or_tty->print_cr(" Maximum free fraction %f", maximum_free_percentage); + gclog_or_tty->print_cr(" Capacity " SIZE_FORMAT, capacity() / 1000); + gclog_or_tty->print_cr(" Desired capacity " SIZE_FORMAT, desired_capacity / 1000); GenCollectedHeap* gch = GenCollectedHeap::heap(); assert(gch->is_old_gen(this), "The CMS generation should always be the old generation"); size_t young_size = gch->young_gen()->capacity(); gclog_or_tty->print_cr(" Young gen size " SIZE_FORMAT, young_size / 1000); - gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT, - unsafe_max_alloc_nogc()/1000); - gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT, - contiguous_available()/1000); - gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)", - expand_bytes); + gclog_or_tty->print_cr(" unsafe_max_alloc_nogc " SIZE_FORMAT, unsafe_max_alloc_nogc() / 1000); + gclog_or_tty->print_cr(" contiguous available " SIZE_FORMAT, contiguous_available() / 1000); + gclog_or_tty->print_cr(" Expand by " SIZE_FORMAT " (bytes)", expand_bytes); } // safe if expansion fails expand_for_gc_cause(expand_bytes, 0, CMSExpansionCause::_satisfy_free_ratio); if (PrintGCDetails && Verbose) { - gclog_or_tty->print_cr(" Expanded free fraction %f", - ((double) free()) / capacity()); + gclog_or_tty->print_cr(" Expanded free fraction %f", ((double) free()) / capacity()); } } else { size_t desired_capacity = (size_t)(used() / ((double) 1 - desired_free_percentage)); @@ -834,16 +827,14 @@ return cmsSpace()->freelistLock(); } -HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size, - bool tlab) { +HeapWord* ConcurrentMarkSweepGeneration::allocate(size_t size, bool tlab) { CMSSynchronousYieldRequest yr; - MutexLockerEx x(freelistLock(), - Mutex::_no_safepoint_check_flag); + MutexLockerEx x(freelistLock(), Mutex::_no_safepoint_check_flag); return have_lock_and_allocate(size, tlab); } HeapWord* ConcurrentMarkSweepGeneration::have_lock_and_allocate(size_t size, - bool tlab /* ignored */) { + bool tlab /* ignored */) { assert_lock_strong(freelistLock()); size_t adjustedSize = CompactibleFreeListSpace::adjustObjectSize(size); HeapWord* res = cmsSpace()->allocate(adjustedSize); @@ -2426,7 +2417,7 @@ gch->gen_process_roots(&srs, GenCollectedHeap::OldGen, - true, // younger gens are roots + true, // young gen as roots GenCollectedHeap::ScanningOption(roots_scanning_options()), should_unload_classes(), ¬Older, @@ -2498,7 +2489,7 @@ gch->gen_process_roots(&srs, GenCollectedHeap::OldGen, - true, // younger gens are roots + true, // young gen as roots GenCollectedHeap::ScanningOption(roots_scanning_options()), should_unload_classes(), ¬Older, @@ -2952,12 +2943,7 @@ assert(SafepointSynchronize::is_at_safepoint(), "world should be stopped"); assert(_collectorState == InitialMarking, "just checking"); - // If there has not been a GC[n-1] since last GC[n] cycle completed, - // precede our marking with a collection of all - // younger generations to keep floating garbage to a minimum. - // XXX: we won't do this for now -- it's an optimization to be done later. - - // already have locks + // Already have locks. assert_lock_strong(bitMapLock()); assert(_markBitMap.isAllClear(), "was reset at end of previous cycle"); @@ -3005,7 +2991,7 @@ COMPILER2_PRESENT(DerivedPointerTableDeactivate dpt_deact;) if (CMSParallelInitialMarkEnabled) { // The parallel version. - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); uint n_workers = workers->active_workers(); @@ -3027,7 +3013,7 @@ gch->gen_process_roots(&srs, GenCollectedHeap::OldGen, - true, // younger gens are roots + true, // young gen as roots GenCollectedHeap::ScanningOption(roots_scanning_options()), should_unload_classes(), ¬Older, @@ -3037,7 +3023,7 @@ } // Clear mod-union table; it will be dirtied in the prologue of - // CMS generation per each younger generation collection. + // CMS generation per each young generation collection. assert(_modUnionTable.isAllClear(), "Was cleared in most recent final checkpoint phase" @@ -3057,7 +3043,7 @@ // assert(!SafepointSynchronize::is_at_safepoint(), // "inconsistent argument?"); // However that wouldn't be right, because it's possible that - // a safepoint is indeed in progress as a younger generation + // a safepoint is indeed in progress as a young generation // stop-the-world GC happens even as we mark in this generation. assert(_collectorState == Marking, "inconsistent state?"); check_correct_thread_executing(); @@ -3065,7 +3051,7 @@ // Weak ref discovery note: We may be discovering weak // refs in this generation concurrent (but interleaved) with - // weak ref discovery by a younger generation collector. + // weak ref discovery by the young generation collector. CMSTokenSyncWithLocks ts(true, bitMapLock()); TraceCPUTime tcpu(PrintGCDetails, true, gclog_or_tty); @@ -3095,7 +3081,7 @@ // Note that when we do a marking step we need to hold the // bit map lock -- recall that direct allocation (by mutators) - // and promotion (by younger generation collectors) is also + // and promotion (by the young generation collector) is also // marking the bit map. [the so-called allocate live policy.] // Because the implementation of bit map marking is not // robust wrt simultaneous marking of bits in the same word, @@ -4049,7 +4035,7 @@ // one of these methods, please check the other method too. size_t CMSCollector::preclean_mod_union_table( - ConcurrentMarkSweepGeneration* gen, + ConcurrentMarkSweepGeneration* old_gen, ScanMarkedObjectsAgainCarefullyClosure* cl) { verify_work_stacks_empty(); verify_overflow_empty(); @@ -4064,10 +4050,10 @@ // generation, but we might potentially miss cards when the // generation is rapidly expanding while we are in the midst // of precleaning. - HeapWord* startAddr = gen->reserved().start(); - HeapWord* endAddr = gen->reserved().end(); - - cl->setFreelistLock(gen->freelistLock()); // needed for yielding + HeapWord* startAddr = old_gen->reserved().start(); + HeapWord* endAddr = old_gen->reserved().end(); + + cl->setFreelistLock(old_gen->freelistLock()); // needed for yielding size_t numDirtyCards, cumNumDirtyCards; HeapWord *nextAddr, *lastAddr; @@ -4109,7 +4095,7 @@ HeapWord* stop_point = NULL; stopTimer(); // Potential yield point - CMSTokenSyncWithLocks ts(true, gen->freelistLock(), + CMSTokenSyncWithLocks ts(true, old_gen->freelistLock(), bitMapLock()); startTimer(); { @@ -4117,7 +4103,7 @@ verify_overflow_empty(); sample_eden(); stop_point = - gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); + old_gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); } if (stop_point != NULL) { // The careful iteration stopped early either because it found an @@ -4152,15 +4138,15 @@ // below are largely identical; if you need to modify // one of these methods, please check the other method too. -size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* gen, +size_t CMSCollector::preclean_card_table(ConcurrentMarkSweepGeneration* old_gen, ScanMarkedObjectsAgainCarefullyClosure* cl) { // strategy: it's similar to precleamModUnionTable above, in that // we accumulate contiguous ranges of dirty cards, mark these cards // precleaned, then scan the region covered by these cards. - HeapWord* endAddr = (HeapWord*)(gen->_virtual_space.high()); - HeapWord* startAddr = (HeapWord*)(gen->_virtual_space.low()); - - cl->setFreelistLock(gen->freelistLock()); // needed for yielding + HeapWord* endAddr = (HeapWord*)(old_gen->_virtual_space.high()); + HeapWord* startAddr = (HeapWord*)(old_gen->_virtual_space.low()); + + cl->setFreelistLock(old_gen->freelistLock()); // needed for yielding size_t numDirtyCards, cumNumDirtyCards; HeapWord *lastAddr, *nextAddr; @@ -4197,13 +4183,13 @@ if (!dirtyRegion.is_empty()) { stopTimer(); - CMSTokenSyncWithLocks ts(true, gen->freelistLock(), bitMapLock()); + CMSTokenSyncWithLocks ts(true, old_gen->freelistLock(), bitMapLock()); startTimer(); sample_eden(); verify_work_stacks_empty(); verify_overflow_empty(); HeapWord* stop_point = - gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); + old_gen->cmsSpace()->object_iterate_careful_m(dirtyRegion, cl); if (stop_point != NULL) { assert((_collectorState == AbortablePreclean && should_abort_preclean()), "Should only be AbortablePreclean."); @@ -4488,7 +4474,7 @@ // workers to be taken from the active workers in the work gang. CMSParRemarkTask(CMSCollector* collector, CompactibleFreeListSpace* cms_space, - uint n_workers, FlexibleWorkGang* workers, + uint n_workers, WorkGang* workers, OopTaskQueueSet* task_queues, StrongRootsScope* strong_roots_scope): CMSParMarkTask("Rescan roots and grey objects in parallel", @@ -4623,7 +4609,7 @@ ResourceMark rm; GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds(); for (int i = 0; i < array->length(); i++) { - par_mrias_cl.do_class_loader_data(array->at(i)); + par_mrias_cl.do_cld_nv(array->at(i)); } // We don't need to keep track of new CLDs anymore. @@ -5061,7 +5047,7 @@ // Parallel version of remark void CMSCollector::do_remark_parallel() { GenCollectedHeap* gch = GenCollectedHeap::heap(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); // Choose to use the number of GC workers most recently set // into "active_workers". @@ -5086,7 +5072,7 @@ // preclean phase did of eden, plus the [two] tasks of // scanning the [two] survivor spaces. Further fine-grain // parallelization of the scanning of the survivor spaces - // themselves, and of precleaning of the younger gen itself + // themselves, and of precleaning of the young gen itself // is deferred to the future. initialize_sequential_subtasks_for_young_gen_rescan(n_workers); @@ -5177,7 +5163,7 @@ gch->gen_process_roots(&srs, GenCollectedHeap::OldGen, - true, // younger gens as roots + true, // young gen as roots GenCollectedHeap::ScanningOption(roots_scanning_options()), should_unload_classes(), &mrias_cl, @@ -5199,7 +5185,7 @@ ResourceMark rm; GrowableArray<ClassLoaderData*>* array = ClassLoaderDataGraph::new_clds(); for (int i = 0; i < array->length(); i++) { - mrias_cl.do_class_loader_data(array->at(i)); + mrias_cl.do_cld_nv(array->at(i)); } // We don't need to keep track of new CLDs anymore. @@ -5236,6 +5222,16 @@ //////////////////////////////////////////////////////// // Parallel Reference Processing Task Proxy Class //////////////////////////////////////////////////////// +class AbstractGangTaskWOopQueues : public AbstractGangTask { + OopTaskQueueSet* _queues; + ParallelTaskTerminator _terminator; + public: + AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues, uint n_threads) : + AbstractGangTask(name), _queues(queues), _terminator(n_threads, _queues) {} + ParallelTaskTerminator* terminator() { return &_terminator; } + OopTaskQueueSet* queues() { return _queues; } +}; + class CMSRefProcTaskProxy: public AbstractGangTaskWOopQueues { typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; CMSCollector* _collector; @@ -5372,7 +5368,7 @@ void CMSRefProcTaskExecutor::execute(ProcessTask& task) { GenCollectedHeap* gch = GenCollectedHeap::heap(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); CMSRefProcTaskProxy rp_task(task, &_collector, _collector.ref_processor()->span(), @@ -5385,7 +5381,7 @@ { GenCollectedHeap* gch = GenCollectedHeap::heap(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); CMSRefEnqueueTaskProxy enq_task(task); workers->run_task(&enq_task); @@ -5419,7 +5415,7 @@ // balance_all_queues() and balance_queues()). GenCollectedHeap* gch = GenCollectedHeap::heap(); uint active_workers = ParallelGCThreads; - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); if (workers != NULL) { active_workers = workers->active_workers(); // The expectation is that active_workers will have already @@ -5651,7 +5647,7 @@ } } -void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* gen) { +void CMSCollector::sweepWork(ConcurrentMarkSweepGeneration* old_gen) { // We iterate over the space(s) underlying this generation, // checking the mark bit map to see if the bits corresponding // to specific blocks are marked or not. Blocks that are @@ -5680,26 +5676,26 @@ // check that we hold the requisite locks assert(have_cms_token(), "Should hold cms token"); assert(ConcurrentMarkSweepThread::cms_thread_has_cms_token(), "Should possess CMS token to sweep"); - assert_lock_strong(gen->freelistLock()); + assert_lock_strong(old_gen->freelistLock()); assert_lock_strong(bitMapLock()); assert(!_inter_sweep_timer.is_active(), "Was switched off in an outer context"); assert(_intra_sweep_timer.is_active(), "Was switched on in an outer context"); - gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()), - _inter_sweep_estimate.padded_average(), - _intra_sweep_estimate.padded_average()); - gen->setNearLargestChunk(); + old_gen->cmsSpace()->beginSweepFLCensus((float)(_inter_sweep_timer.seconds()), + _inter_sweep_estimate.padded_average(), + _intra_sweep_estimate.padded_average()); + old_gen->setNearLargestChunk(); { - SweepClosure sweepClosure(this, gen, &_markBitMap, CMSYield); - gen->cmsSpace()->blk_iterate_careful(&sweepClosure); + SweepClosure sweepClosure(this, old_gen, &_markBitMap, CMSYield); + old_gen->cmsSpace()->blk_iterate_careful(&sweepClosure); // We need to free-up/coalesce garbage/blocks from a // co-terminal free run. This is done in the SweepClosure // destructor; so, do not remove this scope, else the // end-of-sweep-census below will be off by a little bit. } - gen->cmsSpace()->sweep_completed(); - gen->cmsSpace()->endSweepFLCensus(sweep_count()); + old_gen->cmsSpace()->sweep_completed(); + old_gen->cmsSpace()->endSweepFLCensus(sweep_count()); if (should_unload_classes()) { // unloaded classes this cycle, _concurrent_cycles_since_last_unload = 0; // ... reset count } else { // did not unload classes, @@ -6314,12 +6310,12 @@ // objArrays are precisely marked; restrict scanning // to dirty cards only. size = CompactibleFreeListSpace::adjustObjectSize( - p->oop_iterate(_scanningClosure, mr)); + p->oop_iterate_size(_scanningClosure, mr)); } else { // A non-array may have been imprecisely marked; we need // to scan object in its entirety. size = CompactibleFreeListSpace::adjustObjectSize( - p->oop_iterate(_scanningClosure)); + p->oop_iterate_size(_scanningClosure)); } #ifdef ASSERT size_t direct_size = @@ -6407,7 +6403,7 @@ // Note that we do not yield while we iterate over // the interior oops of p, pushing the relevant ones // on our marking stack. - size_t size = p->oop_iterate(_scanning_closure); + size_t size = p->oop_iterate_size(_scanning_closure); do_yield_check(); // Observe that below, we do not abandon the preclean // phase as soon as we should; rather we empty the
--- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -723,7 +723,7 @@ private: // Support for parallelizing young gen rescan in CMS remark phase - ParNewGeneration* _young_gen; // the younger gen + ParNewGeneration* _young_gen; HeapWord** _top_addr; // ... Top of Eden HeapWord** _end_addr; // ... End of Eden @@ -772,9 +772,9 @@ private: // Concurrent precleaning work - size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* gen, + size_t preclean_mod_union_table(ConcurrentMarkSweepGeneration* old_gen, ScanMarkedObjectsAgainCarefullyClosure* cl); - size_t preclean_card_table(ConcurrentMarkSweepGeneration* gen, + size_t preclean_card_table(ConcurrentMarkSweepGeneration* old_gen, ScanMarkedObjectsAgainCarefullyClosure* cl); // Does precleaning work, returning a quantity indicative of // the amount of "useful work" done. @@ -797,7 +797,7 @@ void refProcessingWork(); // Concurrent sweeping work - void sweepWork(ConcurrentMarkSweepGeneration* gen); + void sweepWork(ConcurrentMarkSweepGeneration* old_gen); // (Concurrent) resetting of support data structures void reset(bool concurrent); @@ -1120,10 +1120,8 @@ MemRegion used_region_at_save_marks() const; // Does a "full" (forced) collection invoked on this generation collect - // all younger generations as well? Note that the second conjunct is a - // hack to allow the collection of the younger gen first if the flag is - // set. - virtual bool full_collects_younger_generations() const { + // the young generation as well? + virtual bool full_collects_young_generation() const { return !ScavengeBeforeFullGC; } @@ -1153,9 +1151,8 @@ virtual bool promotion_attempt_is_safe(size_t promotion_in_bytes) const; - // Inform this (non-young) generation that a promotion failure was - // encountered during a collection of a younger generation that - // promotes into this generation. + // Inform this (old) generation that a promotion failure was + // encountered during a collection of the young generation. virtual void promotion_failure_occurred(); bool should_collect(bool full, size_t size, bool tlab);
--- a/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/concurrentMarkSweepGeneration.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -295,7 +295,7 @@ promoted_bytes = _cms_used_at_gc0_end - _cms_used_at_gc0_begin; } - // If the younger gen collections were skipped, then the + // If the young gen collection was skipped, then the // number of promoted bytes will be 0 and adding it to the // average will incorrectly lessen the average. It is, however, // also possible that no promotion was needed.
--- a/src/share/vm/gc/cms/concurrentMarkSweepThread.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/concurrentMarkSweepThread.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -39,23 +39,17 @@ // ======= Concurrent Mark Sweep Thread ======== -// The CMS thread is created when Concurrent Mark Sweep is used in the -// older of two generations in a generational memory system. +ConcurrentMarkSweepThread* ConcurrentMarkSweepThread::_cmst = NULL; +CMSCollector* ConcurrentMarkSweepThread::_collector = NULL; +bool ConcurrentMarkSweepThread::_should_terminate = false; +int ConcurrentMarkSweepThread::_CMS_flag = CMS_nil; -ConcurrentMarkSweepThread* - ConcurrentMarkSweepThread::_cmst = NULL; -CMSCollector* ConcurrentMarkSweepThread::_collector = NULL; -bool ConcurrentMarkSweepThread::_should_terminate = false; -int ConcurrentMarkSweepThread::_CMS_flag = CMS_nil; +volatile jint ConcurrentMarkSweepThread::_pending_yields = 0; -volatile jint ConcurrentMarkSweepThread::_pending_yields = 0; - -SurrogateLockerThread* - ConcurrentMarkSweepThread::_slt = NULL; +SurrogateLockerThread* ConcurrentMarkSweepThread::_slt = NULL; SurrogateLockerThread::SLT_msg_type ConcurrentMarkSweepThread::_sltBuffer = SurrogateLockerThread::empty; -Monitor* - ConcurrentMarkSweepThread::_sltMonitor = NULL; +Monitor* ConcurrentMarkSweepThread::_sltMonitor = NULL; ConcurrentMarkSweepThread::ConcurrentMarkSweepThread(CMSCollector* collector) : ConcurrentGCThread() {
--- a/src/share/vm/gc/cms/parNewGeneration.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/parNewGeneration.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,7 +25,7 @@ #include "precompiled.hpp" #include "gc/cms/compactibleFreeListSpace.hpp" #include "gc/cms/concurrentMarkSweepGeneration.hpp" -#include "gc/cms/parNewGeneration.hpp" +#include "gc/cms/parNewGeneration.inline.hpp" #include "gc/cms/parOopClosures.inline.hpp" #include "gc/serial/defNewGeneration.inline.hpp" #include "gc/shared/adaptiveSizePolicy.hpp" @@ -69,20 +69,28 @@ Stack<oop, mtGC>* overflow_stacks_, size_t desired_plab_sz_, ParallelTaskTerminator& term_) : - _to_space(to_space_), _old_gen(old_gen_), _young_gen(young_gen_), _thread_num(thread_num_), - _work_queue(work_queue_set_->queue(thread_num_)), _to_space_full(false), + _to_space(to_space_), + _old_gen(old_gen_), + _young_gen(young_gen_), + _thread_num(thread_num_), + _work_queue(work_queue_set_->queue(thread_num_)), + _to_space_full(false), _overflow_stack(overflow_stacks_ ? overflow_stacks_ + thread_num_ : NULL), _ageTable(false), // false ==> not the global age table, no perf data. _to_space_alloc_buffer(desired_plab_sz_), - _to_space_closure(young_gen_, this), _old_gen_closure(young_gen_, this), - _to_space_root_closure(young_gen_, this), _old_gen_root_closure(young_gen_, this), + _to_space_closure(young_gen_, this), + _old_gen_closure(young_gen_, this), + _to_space_root_closure(young_gen_, this), + _old_gen_root_closure(young_gen_, this), _older_gen_closure(young_gen_, this), _evacuate_followers(this, &_to_space_closure, &_old_gen_closure, &_to_space_root_closure, young_gen_, &_old_gen_root_closure, work_queue_set_, &term_), - _is_alive_closure(young_gen_), _scan_weak_ref_closure(young_gen_, this), + _is_alive_closure(young_gen_), + _scan_weak_ref_closure(young_gen_, this), _keep_alive_closure(&_scan_weak_ref_closure), - _strong_roots_time(0.0), _term_time(0.0) + _strong_roots_time(0.0), + _term_time(0.0) { #if TASKQUEUE_STATS _term_attempts = 0; @@ -90,8 +98,7 @@ _overflow_refill_objs = 0; #endif // TASKQUEUE_STATS - _survivor_chunk_array = - (ChunkArray*) old_gen()->get_data_recorder(thread_num()); + _survivor_chunk_array = (ChunkArray*) old_gen()->get_data_recorder(thread_num()); _hash_seed = 17; // Might want to take time-based random value. _start = os::elapsedTime(); _old_gen_closure.set_generation(old_gen_); @@ -154,7 +161,6 @@ } } - void ParScanThreadState::trim_queues(int max_size) { ObjToScanQueue* queue = work_queue(); do { @@ -222,15 +228,12 @@ } HeapWord* ParScanThreadState::alloc_in_to_space_slow(size_t word_sz) { - - // Otherwise, if the object is small enough, try to reallocate the - // buffer. + // If the object is small enough, try to reallocate the buffer. HeapWord* obj = NULL; if (!_to_space_full) { PLAB* const plab = to_space_alloc_buffer(); - Space* const sp = to_space(); - if (word_sz * 100 < - ParallelGCBufferWastePct * plab->word_sz()) { + Space* const sp = to_space(); + if (word_sz * 100 < ParallelGCBufferWastePct * plab->word_sz()) { // Is small enough; abandon this buffer and start a new one. plab->retire(); size_t buf_size = plab->word_sz(); @@ -241,15 +244,13 @@ size_t free_bytes = sp->free(); while(buf_space == NULL && free_bytes >= min_bytes) { buf_size = free_bytes >> LogHeapWordSize; - assert(buf_size == (size_t)align_object_size(buf_size), - "Invariant"); + assert(buf_size == (size_t)align_object_size(buf_size), "Invariant"); buf_space = sp->par_allocate(buf_size); free_bytes = sp->free(); } } if (buf_space != NULL) { - plab->set_word_size(buf_size); - plab->set_buf(buf_space); + plab->set_buf(buf_space, buf_size); record_survivor_plab(buf_space, buf_size); obj = plab->allocate_aligned(word_sz, SurvivorAlignmentInBytes); // Note that we cannot compare buf_size < word_sz below @@ -263,7 +264,6 @@ // We're used up. _to_space_full = true; } - } else { // Too large; allocate the object individually. obj = sp->par_allocate(word_sz); @@ -272,7 +272,6 @@ return obj; } - void ParScanThreadState::undo_alloc_in_to_space(HeapWord* obj, size_t word_sz) { to_space_alloc_buffer()->undo_allocation(obj, word_sz); } @@ -289,7 +288,7 @@ // Initializes states for the specified number of threads; ParScanThreadStateSet(int num_threads, Space& to_space, - ParNewGeneration& gen, + ParNewGeneration& young_gen, Generation& old_gen, ObjToScanQueueSet& queue_set, Stack<oop, mtGC>* overflow_stacks_, @@ -316,21 +315,25 @@ private: ParallelTaskTerminator& _term; - ParNewGeneration& _gen; + ParNewGeneration& _young_gen; Generation& _old_gen; public: bool is_valid(int id) const { return id < length(); } ParallelTaskTerminator* terminator() { return &_term; } }; - -ParScanThreadStateSet::ParScanThreadStateSet( - int num_threads, Space& to_space, ParNewGeneration& gen, - Generation& old_gen, ObjToScanQueueSet& queue_set, - Stack<oop, mtGC>* overflow_stacks, - size_t desired_plab_sz, ParallelTaskTerminator& term) +ParScanThreadStateSet::ParScanThreadStateSet(int num_threads, + Space& to_space, + ParNewGeneration& young_gen, + Generation& old_gen, + ObjToScanQueueSet& queue_set, + Stack<oop, mtGC>* overflow_stacks, + size_t desired_plab_sz, + ParallelTaskTerminator& term) : ResourceArray(sizeof(ParScanThreadState), num_threads), - _gen(gen), _old_gen(old_gen), _term(term) + _young_gen(young_gen), + _old_gen(old_gen), + _term(term) { assert(num_threads > 0, "sanity check!"); assert(ParGCUseLocalOverflow == (overflow_stacks != NULL), @@ -338,13 +341,12 @@ // Initialize states. for (int i = 0; i < num_threads; ++i) { new ((ParScanThreadState*)_data + i) - ParScanThreadState(&to_space, &gen, &old_gen, i, &queue_set, + ParScanThreadState(&to_space, &young_gen, &old_gen, i, &queue_set, overflow_stacks, desired_plab_sz, term); } } -inline ParScanThreadState& ParScanThreadStateSet::thread_state(int i) -{ +inline ParScanThreadState& ParScanThreadStateSet::thread_state(int i) { assert(i >= 0 && i < length(), "sanity check!"); return ((ParScanThreadState*)_data)[i]; } @@ -358,8 +360,7 @@ } } -void ParScanThreadStateSet::reset(uint active_threads, bool promotion_failed) -{ +void ParScanThreadStateSet::reset(uint active_threads, bool promotion_failed) { _term.reset_for_reuse(active_threads); if (promotion_failed) { for (int i = 0; i < length(); ++i) { @@ -369,36 +370,27 @@ } #if TASKQUEUE_STATS -void -ParScanThreadState::reset_stats() -{ +void ParScanThreadState::reset_stats() { taskqueue_stats().reset(); _term_attempts = 0; _overflow_refills = 0; _overflow_refill_objs = 0; } -void ParScanThreadStateSet::reset_stats() -{ +void ParScanThreadStateSet::reset_stats() { for (int i = 0; i < length(); ++i) { thread_state(i).reset_stats(); } } -void -ParScanThreadStateSet::print_termination_stats_hdr(outputStream* const st) -{ +void ParScanThreadStateSet::print_termination_stats_hdr(outputStream* const st) { st->print_raw_cr("GC Termination Stats"); - st->print_raw_cr(" elapsed --strong roots-- " - "-------termination-------"); - st->print_raw_cr("thr ms ms % " - " ms % attempts"); - st->print_raw_cr("--- --------- --------- ------ " - "--------- ------ --------"); + st->print_raw_cr(" elapsed --strong roots-- -------termination-------"); + st->print_raw_cr("thr ms ms % ms % attempts"); + st->print_raw_cr("--- --------- --------- ------ --------- ------ --------"); } -void ParScanThreadStateSet::print_termination_stats(outputStream* const st) -{ +void ParScanThreadStateSet::print_termination_stats(outputStream* const st) { print_termination_stats_hdr(st); for (int i = 0; i < length(); ++i) { @@ -406,23 +398,20 @@ const double elapsed_ms = pss.elapsed_time() * 1000.0; const double s_roots_ms = pss.strong_roots_time() * 1000.0; const double term_ms = pss.term_time() * 1000.0; - st->print_cr("%3d %9.2f %9.2f %6.2f " - "%9.2f %6.2f " SIZE_FORMAT_W(8), + st->print_cr("%3d %9.2f %9.2f %6.2f %9.2f %6.2f " SIZE_FORMAT_W(8), i, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms, term_ms, term_ms * 100 / elapsed_ms, pss.term_attempts()); } } // Print stats related to work queue activity. -void ParScanThreadStateSet::print_taskqueue_stats_hdr(outputStream* const st) -{ +void ParScanThreadStateSet::print_taskqueue_stats_hdr(outputStream* const st) { st->print_raw_cr("GC Task Stats"); st->print_raw("thr "); TaskQueueStats::print_header(1, st); st->cr(); st->print_raw("--- "); TaskQueueStats::print_header(2, st); st->cr(); } -void ParScanThreadStateSet::print_taskqueue_stats(outputStream* const st) -{ +void ParScanThreadStateSet::print_taskqueue_stats(outputStream* const st) { print_taskqueue_stats_hdr(st); TaskQueueStats totals; @@ -444,8 +433,7 @@ } #endif // TASKQUEUE_STATS -void ParScanThreadStateSet::flush() -{ +void ParScanThreadStateSet::flush() { // Work in this loop should be kept as lightweight as // possible since this might otherwise become a bottleneck // to scaling. Should we add heavy-weight work into this @@ -455,12 +443,12 @@ // Flush stats related to To-space PLAB activity and // retire the last buffer. - par_scan_state.to_space_alloc_buffer()->flush_and_retire_stats(_gen.plab_stats()); + par_scan_state.to_space_alloc_buffer()->flush_and_retire_stats(_young_gen.plab_stats()); // Every thread has its own age table. We need to merge // them all into one. ageTable *local_table = par_scan_state.age_table(); - _gen.age_table()->merge(local_table); + _young_gen.age_table()->merge(local_table); // Inform old gen that we're done. _old_gen.par_promote_alloc_done(i); @@ -479,8 +467,7 @@ ParScanClosure::ParScanClosure(ParNewGeneration* g, ParScanThreadState* par_scan_state) : - OopsInKlassOrGenClosure(g), _par_scan_state(par_scan_state), _g(g) -{ + OopsInKlassOrGenClosure(g), _par_scan_state(par_scan_state), _g(g) { _boundary = _g->reserved().end(); } @@ -532,24 +519,23 @@ ObjToScanQueue* work_q = par_scan_state()->work_queue(); while (true) { - // Scan to-space and old-gen objs until we run out of both. oop obj_to_scan; par_scan_state()->trim_queues(0); // We have no local work, attempt to steal from other threads. - // attempt to steal work from promoted. + // Attempt to steal work from promoted. if (task_queues()->steal(par_scan_state()->thread_num(), par_scan_state()->hash_seed(), obj_to_scan)) { bool res = work_q->push(obj_to_scan); assert(res, "Empty queue should have room for a push."); - // if successful, goto Start. + // If successful, goto Start. continue; - // try global overflow list. + // Try global overflow list. } else if (par_gen()->take_from_overflow_list(par_scan_state())) { continue; } @@ -565,15 +551,17 @@ par_scan_state()->end_term_time(); } -ParNewGenTask::ParNewGenTask(ParNewGeneration* young_gen, Generation* old_gen, - HeapWord* young_old_boundary, ParScanThreadStateSet* state_set, +ParNewGenTask::ParNewGenTask(ParNewGeneration* young_gen, + Generation* old_gen, + HeapWord* young_old_boundary, + ParScanThreadStateSet* state_set, StrongRootsScope* strong_roots_scope) : AbstractGangTask("ParNewGeneration collection"), _young_gen(young_gen), _old_gen(old_gen), _young_old_boundary(young_old_boundary), _state_set(state_set), _strong_roots_scope(strong_roots_scope) - {} +{} void ParNewGenTask::work(uint worker_id) { GenCollectedHeap* gch = GenCollectedHeap::heap(); @@ -596,8 +584,7 @@ par_scan_state.start_strong_roots(); gch->gen_process_roots(_strong_roots_scope, GenCollectedHeap::YoungGen, - true, // Process younger gens, if any, - // as strong roots. + true, // Process younger gens, if any, as strong roots. GenCollectedHeap::SO_ScavengeCodeCache, GenCollectedHeap::StrongAndWeakRoots, &par_scan_state.to_space_root_closure(), @@ -614,8 +601,7 @@ #pragma warning( push ) #pragma warning( disable:4355 ) // 'this' : used in base member initializer list #endif -ParNewGeneration:: -ParNewGeneration(ReservedSpace rs, size_t initial_byte_size) +ParNewGeneration::ParNewGeneration(ReservedSpace rs, size_t initial_byte_size) : DefNewGeneration(rs, initial_byte_size, "PCopy"), _overflow_list(NULL), _is_alive_closure(this), @@ -626,20 +612,19 @@ _task_queues = new ObjToScanQueueSet(ParallelGCThreads); guarantee(_task_queues != NULL, "task_queues allocation failure."); - for (uint i1 = 0; i1 < ParallelGCThreads; i1++) { + for (uint i = 0; i < ParallelGCThreads; i++) { ObjToScanQueue *q = new ObjToScanQueue(); guarantee(q != NULL, "work_queue Allocation failure."); - _task_queues->register_queue(i1, q); + _task_queues->register_queue(i, q); } - for (uint i2 = 0; i2 < ParallelGCThreads; i2++) - _task_queues->queue(i2)->initialize(); + for (uint i = 0; i < ParallelGCThreads; i++) { + _task_queues->queue(i)->initialize(); + } _overflow_stacks = NULL; if (ParGCUseLocalOverflow) { - - // typedef to workaround NEW_C_HEAP_ARRAY macro, which can not deal - // with ',' + // typedef to workaround NEW_C_HEAP_ARRAY macro, which can not deal with ',' typedef Stack<oop, mtGC> GCOopStack; _overflow_stacks = NEW_C_HEAP_ARRAY(GCOopStack, ParallelGCThreads, mtGC); @@ -743,7 +728,7 @@ typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; public: ParNewRefProcTaskProxy(ProcessTask& task, - ParNewGeneration& gen, + ParNewGeneration& young_gen, Generation& old_gen, HeapWord* young_old_boundary, ParScanThreadStateSet& state_set); @@ -769,11 +754,9 @@ _old_gen(old_gen), _young_old_boundary(young_old_boundary), _state_set(state_set) -{ -} +{ } -void ParNewRefProcTaskProxy::work(uint worker_id) -{ +void ParNewRefProcTaskProxy::work(uint worker_id) { ResourceMark rm; HandleMark hm; ParScanThreadState& par_scan_state = _state_set.thread_state(worker_id); @@ -793,17 +776,14 @@ _task(task) { } - virtual void work(uint worker_id) - { + virtual void work(uint worker_id) { _task.work(worker_id); } }; - -void ParNewRefProcTaskExecutor::execute(ProcessTask& task) -{ +void ParNewRefProcTaskExecutor::execute(ProcessTask& task) { GenCollectedHeap* gch = GenCollectedHeap::heap(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); _state_set.reset(workers->active_workers(), _young_gen.promotion_failed()); ParNewRefProcTaskProxy rp_task(task, _young_gen, _old_gen, @@ -813,17 +793,15 @@ _young_gen.promotion_failed()); } -void ParNewRefProcTaskExecutor::execute(EnqueueTask& task) -{ +void ParNewRefProcTaskExecutor::execute(EnqueueTask& task) { GenCollectedHeap* gch = GenCollectedHeap::heap(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need parallel worker threads."); ParNewRefEnqueueTaskProxy enq_task(task); workers->run_task(&enq_task); } -void ParNewRefProcTaskExecutor::set_single_threaded_mode() -{ +void ParNewRefProcTaskExecutor::set_single_threaded_mode() { _state_set.flush(); GenCollectedHeap* gch = GenCollectedHeap::heap(); gch->save_marks(); @@ -831,7 +809,8 @@ ScanClosureWithParBarrier:: ScanClosureWithParBarrier(ParNewGeneration* g, bool gc_barrier) : - ScanClosure(g, gc_barrier) {} + ScanClosure(g, gc_barrier) +{ } EvacuateFollowersClosureGeneral:: EvacuateFollowersClosureGeneral(GenCollectedHeap* gch, @@ -839,7 +818,7 @@ OopsInGenClosure* older) : _gch(gch), _scan_cur_or_nonheap(cur), _scan_older(older) -{} +{ } void EvacuateFollowersClosureGeneral::do_void() { do { @@ -851,7 +830,6 @@ } while (!_gch->no_allocs_since_save_marks()); } - // A Generation that does parallel young-gen collection. void ParNewGeneration::handle_promotion_failed(GenCollectedHeap* gch, ParScanThreadStateSet& thread_state_set) { @@ -890,7 +868,7 @@ _gc_timer->register_gc_start(); AdaptiveSizePolicy* size_policy = gch->gen_policy()->size_policy(); - FlexibleWorkGang* workers = gch->workers(); + WorkGang* workers = gch->workers(); assert(workers != NULL, "Need workgang for parallel work"); uint active_workers = AdaptiveSizePolicy::calc_active_workers(workers->total_workers(), @@ -997,9 +975,9 @@ if (ZapUnusedHeapArea) { // This is now done here because of the piece-meal mangling which // can check for valid mangling at intermediate points in the - // collection(s). When a minor collection fails to collect + // collection(s). When a young collection fails to collect // sufficient space resizing of the young generation can occur - // an redistribute the spaces in the young generation. Mangle + // and redistribute the spaces in the young generation. Mangle // here so that unzapped regions don't get distributed to // other spaces. to()->mangle_unused_area(); @@ -1114,8 +1092,10 @@ // thus avoiding the need to undo the copy as in // copy_to_survivor_space_avoiding_with_undo. -oop ParNewGeneration::copy_to_survivor_space( - ParScanThreadState* par_scan_state, oop old, size_t sz, markOop m) { +oop ParNewGeneration::copy_to_survivor_space(ParScanThreadState* par_scan_state, + oop old, + size_t sz, + markOop m) { // In the sequential version, this assert also says that the object is // not forwarded. That might not be the case here. It is the case that // the caller observed it to be not forwarded at some time in the past. @@ -1142,8 +1122,7 @@ } if (new_obj == NULL) { - // Either to-space is full or we decided to promote - // try allocating obj tenured + // Either to-space is full or we decided to promote try allocating obj tenured // Attempt to install a null forwarding pointer (atomically), // to claim the right to install the real forwarding pointer.
--- a/src/share/vm/gc/cms/parNewGeneration.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/parNewGeneration.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -71,11 +71,7 @@ ParScanWithoutBarrierClosure _to_space_closure; // scan_without_gc_barrier ParScanWithBarrierClosure _old_gen_closure; // scan_with_gc_barrier ParRootScanWithoutBarrierClosure _to_space_root_closure; // scan_root_without_gc_barrier - // One of these two will be passed to process_roots, which will - // set its generation. The first is for two-gen configs where the - // old gen collects the perm gen; the second is for arbitrary configs. - // The second isn't used right now (it used to be used for the train, an - // incremental collector) but the declaration has been left as a reminder. + // Will be passed to process_roots to set its generation. ParRootScanWithBarrierTwoGensClosure _older_gen_closure; // This closure will always be bound to the old gen; it will be used // in evacuate_followers. @@ -85,7 +81,6 @@ ParScanWeakRefClosure _scan_weak_ref_closure; ParKeepAliveClosure _keep_alive_closure; - Space* _to_space; Space* to_space() { return _to_space; } @@ -169,11 +164,7 @@ // Allocate a to-space block of size "sz", or else return NULL. HeapWord* alloc_in_to_space_slow(size_t word_sz); - HeapWord* alloc_in_to_space(size_t word_sz) { - HeapWord* obj = to_space_alloc_buffer()->allocate_aligned(word_sz, SurvivorAlignmentInBytes); - if (obj != NULL) return obj; - else return alloc_in_to_space_slow(word_sz); - } + inline HeapWord* alloc_in_to_space(size_t word_sz); HeapWord* young_old_boundary() { return _young_old_boundary; }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/cms/parNewGeneration.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_GC_CMS_PARNEWGENERATION_INLINE_HPP +#define SHARE_VM_GC_CMS_PARNEWGENERATION_INLINE_HPP + +#include "gc/cms/parNewGeneration.hpp" +#include "gc/shared/plab.inline.hpp" +#include "utilities/globalDefinitions.hpp" + +inline HeapWord* ParScanThreadState::alloc_in_to_space(size_t word_sz) { + HeapWord* obj = to_space_alloc_buffer()->allocate_aligned(word_sz, SurvivorAlignmentInBytes); + if (obj != NULL) return obj; + else return alloc_in_to_space_slow(word_sz); +} +#endif // SHARE_VM_GC_CMS_PARNEWGENERATION_INLINE_HPP
--- a/src/share/vm/gc/cms/yieldingWorkgroup.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/yieldingWorkgroup.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,20 +26,45 @@ #include "gc/cms/yieldingWorkgroup.hpp" #include "utilities/macros.hpp" -// Forward declaration of classes declared here. - -class GangWorker; -class WorkData; +YieldingFlexibleGangWorker::YieldingFlexibleGangWorker(YieldingFlexibleWorkGang* gang, int id) + : AbstractGangWorker(gang, id) {} YieldingFlexibleWorkGang::YieldingFlexibleWorkGang( - const char* name, uint workers, bool are_GC_task_threads) : - FlexibleWorkGang(name, workers, are_GC_task_threads, false), - _yielded_workers(0) {} + const char* name, uint workers, bool are_GC_task_threads) : + AbstractWorkGang(name, workers, are_GC_task_threads, false), + _yielded_workers(0), + _started_workers(0), + _finished_workers(0), + _sequence_number(0), + _task(NULL) { + + // Other initialization. + _monitor = new Monitor(/* priority */ Mutex::leaf, + /* name */ "WorkGroup monitor", + /* allow_vm_block */ are_GC_task_threads, + Monitor::_safepoint_check_sometimes); + + assert(monitor() != NULL, "Failed to allocate monitor"); +} -GangWorker* YieldingFlexibleWorkGang::allocate_worker(uint which) { - YieldingFlexibleGangWorker* new_member = - new YieldingFlexibleGangWorker(this, which); - return (YieldingFlexibleGangWorker*) new_member; +AbstractGangWorker* YieldingFlexibleWorkGang::allocate_worker(uint which) { + return new YieldingFlexibleGangWorker(this, which); +} + +void YieldingFlexibleWorkGang::internal_worker_poll(YieldingWorkData* data) const { + assert(data != NULL, "worker data is null"); + data->set_task(task()); + data->set_sequence_number(sequence_number()); +} + +void YieldingFlexibleWorkGang::internal_note_start() { + assert(monitor()->owned_by_self(), "note_finish is an internal method"); + _started_workers += 1; +} + +void YieldingFlexibleWorkGang::internal_note_finish() { + assert(monitor()->owned_by_self(), "note_finish is an internal method"); + _finished_workers += 1; } // Run a task; returns when the task is done, or the workers yield, @@ -292,37 +317,37 @@ /////////////////////////////// void YieldingFlexibleGangWorker::loop() { int previous_sequence_number = 0; - Monitor* gang_monitor = gang()->monitor(); + Monitor* gang_monitor = yf_gang()->monitor(); MutexLockerEx ml(gang_monitor, Mutex::_no_safepoint_check_flag); - WorkData data; + YieldingWorkData data; int id; while (true) { // Check if there is work to do. - gang()->internal_worker_poll(&data); + yf_gang()->internal_worker_poll(&data); if (data.task() != NULL && data.sequence_number() != previous_sequence_number) { // There is work to be done. // First check if we need to become active or if there // are already the requisite number of workers - if (gang()->started_workers() == yf_gang()->active_workers()) { + if (yf_gang()->started_workers() == yf_gang()->active_workers()) { // There are already enough workers, we do not need to // to run; fall through and wait on monitor. } else { // We need to pitch in and do the work. - assert(gang()->started_workers() < yf_gang()->active_workers(), + assert(yf_gang()->started_workers() < yf_gang()->active_workers(), "Unexpected state"); - id = gang()->started_workers(); - gang()->internal_note_start(); + id = yf_gang()->started_workers(); + yf_gang()->internal_note_start(); // Now, release the gang mutex and do the work. { MutexUnlockerEx mul(gang_monitor, Mutex::_no_safepoint_check_flag); data.task()->work(id); // This might include yielding } // Reacquire monitor and note completion of this worker - gang()->internal_note_finish(); + yf_gang()->internal_note_finish(); // Update status of task based on whether all workers have // finished or some have yielded - assert(data.task() == gang()->task(), "Confused task binding"); - if (gang()->finished_workers() == yf_gang()->active_workers()) { + assert(data.task() == yf_gang()->task(), "Confused task binding"); + if (yf_gang()->finished_workers() == yf_gang()->active_workers()) { switch (data.yf_task()->status()) { case ABORTING: { data.yf_task()->set_status(ABORTED); @@ -338,7 +363,7 @@ } gang_monitor->notify_all(); // Notify overseer } else { // at least one worker is still working or yielded - assert(gang()->finished_workers() < yf_gang()->active_workers(), + assert(yf_gang()->finished_workers() < yf_gang()->active_workers(), "Counts inconsistent"); switch (data.yf_task()->status()) { case ACTIVE: { @@ -347,7 +372,7 @@ break; } case YIELDING: { - if (gang()->finished_workers() + yf_gang()->yielded_workers() + if (yf_gang()->finished_workers() + yf_gang()->yielded_workers() == yf_gang()->active_workers()) { data.yf_task()->set_status(YIELDED); gang_monitor->notify_all(); // notify overseer
--- a/src/share/vm/gc/cms/yieldingWorkgroup.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/cms/yieldingWorkgroup.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -29,6 +29,7 @@ #include "utilities/macros.hpp" // Forward declarations +class YieldingFlexibleGangTask; class YieldingFlexibleWorkGang; // Status of tasks @@ -43,13 +44,32 @@ COMPLETED }; +class YieldingWorkData: public StackObj { + // This would be a struct, but I want accessor methods. +private: + AbstractGangTask* _task; + int _sequence_number; +public: + // Constructor and destructor + YieldingWorkData() : _task(NULL), _sequence_number(0) {} + ~YieldingWorkData() {} + + // Accessors and modifiers + AbstractGangTask* task() const { return _task; } + void set_task(AbstractGangTask* value) { _task = value; } + int sequence_number() const { return _sequence_number; } + void set_sequence_number(int value) { _sequence_number = value; } + + YieldingFlexibleGangTask* yf_task() const { + return (YieldingFlexibleGangTask*)_task; + } +}; + // Class YieldingFlexibleGangWorker: // Several instances of this class run in parallel as workers for a gang. -class YieldingFlexibleGangWorker: public GangWorker { +class YieldingFlexibleGangWorker: public AbstractGangWorker { public: - // Ctor - YieldingFlexibleGangWorker(AbstractWorkGang* gang, int id) : - GangWorker(gang, id) { } + YieldingFlexibleGangWorker(YieldingFlexibleWorkGang* gang, int id); public: YieldingFlexibleWorkGang* yf_gang() const @@ -108,9 +128,6 @@ friend class YieldingFlexibleWorkGang; friend class YieldingFlexibleGangWorker; - NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const { - return true; - }) void set_status(Status s) { _status = s; @@ -160,7 +177,7 @@ // YieldingGangWorkers, and provides infrastructure // supporting yielding to the "GangOverseer", // being the thread that orchestrates the WorkGang via run_task(). -class YieldingFlexibleWorkGang: public FlexibleWorkGang { +class YieldingFlexibleWorkGang: public AbstractWorkGang { // Here's the public interface to this class. public: // Constructor and destructor. @@ -168,12 +185,10 @@ bool are_GC_task_threads); YieldingFlexibleGangTask* yielding_task() const { - assert(task() == NULL || task()->is_YieldingFlexibleGang_task(), - "Incorrect cast"); - return (YieldingFlexibleGangTask*)task(); + return task(); } // Allocate a worker and return a pointer to it. - GangWorker* allocate_worker(uint which); + AbstractGangWorker* allocate_worker(uint which); // Run a task; returns when the task is done, or the workers yield, // or the task is aborted. @@ -216,6 +231,42 @@ private: friend class YieldingFlexibleGangWorker; void reset(); // NYI + + + // The monitor which protects these data, + // and notifies of changes in it. + Monitor* _monitor; + // Accessors for fields + Monitor* monitor() const { + return _monitor; + } + + // The number of started workers. + uint _started_workers; + // The number of finished workers. + uint _finished_workers; + + uint started_workers() const { + return _started_workers; + } + uint finished_workers() const { + return _finished_workers; + } + + // A sequence number for the current task. + int _sequence_number; + int sequence_number() const { + return _sequence_number; + } + + YieldingFlexibleGangTask* _task; + YieldingFlexibleGangTask* task() const { + return _task; + } + + void internal_worker_poll(YieldingWorkData* data) const; + void internal_note_start(); + void internal_note_finish(); }; #endif // SHARE_VM_GC_CMS_YIELDINGWORKGROUP_HPP
--- a/src/share/vm/gc/g1/concurrentMark.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/concurrentMark.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -524,7 +524,7 @@ gclog_or_tty->print_cr("CL Sleep Factor %1.4lf", cleanup_sleep_factor()); #endif - _parallel_workers = new FlexibleWorkGang("G1 Marker", + _parallel_workers = new WorkGang("G1 Marker", _max_parallel_marking_threads, false, true); if (_parallel_workers == NULL) { vm_exit_during_initialization("Failed necessary allocation."); @@ -1038,7 +1038,7 @@ while (curr < end) { Prefetch::read(curr, interval); oop obj = oop(curr); - int size = obj->oop_iterate(&cl); + int size = obj->oop_iterate_size(&cl); assert(size == obj->size(), "sanity"); curr += size; } @@ -2983,29 +2983,6 @@ } #endif -template<bool scan> -inline void CMTask::process_grey_object(oop obj) { - assert(scan || obj->is_typeArray(), "Skipping scan of grey non-typeArray"); - assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant"); - - if (_cm->verbose_high()) { - gclog_or_tty->print_cr("[%u] processing grey object " PTR_FORMAT, - _worker_id, p2i((void*) obj)); - } - - size_t obj_size = obj->size(); - _words_scanned += obj_size; - - if (scan) { - obj->oop_iterate(_cm_oop_closure); - } - statsOnly( ++_objs_scanned ); - check_limits(); -} - -template void CMTask::process_grey_object<true>(oop); -template void CMTask::process_grey_object<false>(oop); - // Closure for iteration over bitmaps class CMBitMapClosure : public BitMapClosure { private:
--- a/src/share/vm/gc/g1/concurrentMark.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/concurrentMark.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -365,7 +365,7 @@ double* _accum_task_vtime; // Accumulated task vtime - FlexibleWorkGang* _parallel_workers; + WorkGang* _parallel_workers; ForceOverflowSettings _force_overflow_conc; ForceOverflowSettings _force_overflow_stw; @@ -1040,7 +1040,7 @@ inline void deal_with_reference(oop obj); // It scans an object and visits its children. - void scan_object(oop obj) { process_grey_object<true>(obj); } + inline void scan_object(oop obj); // It pushes an object on the local queue. inline void push(oop obj);
--- a/src/share/vm/gc/g1/concurrentMark.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/concurrentMark.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -175,6 +175,9 @@ } } +// It scans an object and visits its children. +inline void CMTask::scan_object(oop obj) { process_grey_object<true>(obj); } + inline void CMTask::push(oop obj) { HeapWord* objAddr = (HeapWord*) obj; assert(_g1h->is_in_g1_reserved(objAddr), "invariant"); @@ -242,6 +245,28 @@ return objAddr < global_finger; } +template<bool scan> +inline void CMTask::process_grey_object(oop obj) { + assert(scan || obj->is_typeArray(), "Skipping scan of grey non-typeArray"); + assert(_nextMarkBitMap->isMarked((HeapWord*) obj), "invariant"); + + if (_cm->verbose_high()) { + gclog_or_tty->print_cr("[%u] processing grey object " PTR_FORMAT, + _worker_id, p2i((void*) obj)); + } + + size_t obj_size = obj->size(); + _words_scanned += obj_size; + + if (scan) { + obj->oop_iterate(_cm_oop_closure); + } + statsOnly( ++_objs_scanned ); + check_limits(); +} + + + inline void CMTask::make_reference_grey(oop obj, HeapRegion* hr) { if (_cm->par_mark_and_count(obj, hr, _marked_bytes_array, _card_bm)) {
--- a/src/share/vm/gc/g1/g1AllocRegion.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1AllocRegion.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -46,10 +46,11 @@ _dummy_region = dummy_region; } -void G1AllocRegion::fill_up_remaining_space(HeapRegion* alloc_region, - bool bot_updates) { +size_t G1AllocRegion::fill_up_remaining_space(HeapRegion* alloc_region, + bool bot_updates) { assert(alloc_region != NULL && alloc_region != _dummy_region, "pre-condition"); + size_t result = 0; // Other threads might still be trying to allocate using a CAS out // of the region we are trying to retire, as they can do so without @@ -73,6 +74,7 @@ // If the allocation was successful we should fill in the space. CollectedHeap::fill_with_object(dummy, free_word_size); alloc_region->set_pre_dummy_top(dummy); + result += free_word_size * HeapWordSize; break; } @@ -81,13 +83,18 @@ // allocation and they fill up the region. In that case, we can // just get out of the loop. } + result += alloc_region->free(); + assert(alloc_region->free() / HeapWordSize < min_word_size_to_fill, "post-condition"); + return result; } -void G1AllocRegion::retire(bool fill_up) { +size_t G1AllocRegion::retire(bool fill_up) { assert(_alloc_region != NULL, ar_ext_msg(this, "not initialized properly")); + size_t result = 0; + trace("retiring"); HeapRegion* alloc_region = _alloc_region; if (alloc_region != _dummy_region) { @@ -98,7 +105,7 @@ ar_ext_msg(this, "the alloc region should never be empty")); if (fill_up) { - fill_up_remaining_space(alloc_region, _bot_updates); + result = fill_up_remaining_space(alloc_region, _bot_updates); } assert(alloc_region->used() >= _used_bytes_before, @@ -109,6 +116,8 @@ _alloc_region = _dummy_region; } trace("retired"); + + return result; } HeapWord* G1AllocRegion::new_alloc_region_and_allocate(size_t word_size, @@ -196,11 +205,11 @@ } #if G1_ALLOC_REGION_TRACING -void G1AllocRegion::trace(const char* str, size_t word_size, HeapWord* result) { +void G1AllocRegion::trace(const char* str, size_t min_word_size, size_t desired_word_size, size_t actual_word_size, HeapWord* result) { // All the calls to trace that set either just the size or the size // and the result are considered part of level 2 tracing and are // skipped during level 1 tracing. - if ((word_size == 0 && result == NULL) || (G1_ALLOC_REGION_TRACING > 1)) { + if ((actual_word_size == 0 && result == NULL) || (G1_ALLOC_REGION_TRACING > 1)) { const size_t buffer_length = 128; char hr_buffer[buffer_length]; char rest_buffer[buffer_length]; @@ -217,10 +226,10 @@ if (G1_ALLOC_REGION_TRACING > 1) { if (result != NULL) { - jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT " " PTR_FORMAT, - word_size, result); - } else if (word_size != 0) { - jio_snprintf(rest_buffer, buffer_length, SIZE_FORMAT, word_size); + jio_snprintf(rest_buffer, buffer_length, "min " SIZE_FORMAT " desired " SIZE_FORMAT " actual " SIZE_FORMAT " " PTR_FORMAT, + min_word_size, desired_word_size, actual_word_size, result); + } else if (min_word_size != 0) { + jio_snprintf(rest_buffer, buffer_length, "min " SIZE_FORMAT " desired " SIZE_FORMAT, min_word_size, desired_word_size); } else { jio_snprintf(rest_buffer, buffer_length, ""); } @@ -251,26 +260,25 @@ _g1h->retire_mutator_alloc_region(alloc_region, allocated_bytes); } -HeapRegion* SurvivorGCAllocRegion::allocate_new_region(size_t word_size, - bool force) { +HeapRegion* G1GCAllocRegion::allocate_new_region(size_t word_size, + bool force) { assert(!force, "not supported for GC alloc regions"); - return _g1h->new_gc_alloc_region(word_size, count(), InCSetState::Young); + return _g1h->new_gc_alloc_region(word_size, count(), _purpose); } -void SurvivorGCAllocRegion::retire_region(HeapRegion* alloc_region, - size_t allocated_bytes) { - _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, InCSetState::Young); +void G1GCAllocRegion::retire_region(HeapRegion* alloc_region, + size_t allocated_bytes) { + _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, _purpose); } -HeapRegion* OldGCAllocRegion::allocate_new_region(size_t word_size, - bool force) { - assert(!force, "not supported for GC alloc regions"); - return _g1h->new_gc_alloc_region(word_size, count(), InCSetState::Old); -} - -void OldGCAllocRegion::retire_region(HeapRegion* alloc_region, - size_t allocated_bytes) { - _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes, InCSetState::Old); +size_t G1GCAllocRegion::retire(bool fill_up) { + HeapRegion* retired = get(); + size_t end_waste = G1AllocRegion::retire(fill_up); + // Do not count retirement of the dummy allocation region. + if (retired != NULL) { + _stats->add_region_end_waste(end_waste / HeapWordSize); + } + return end_waste; } HeapRegion* OldGCAllocRegion::release() {
--- a/src/share/vm/gc/g1/g1AllocRegion.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1AllocRegion.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,6 +26,8 @@ #define SHARE_VM_GC_G1_G1ALLOCREGION_HPP #include "gc/g1/heapRegion.hpp" +#include "gc/g1/g1EvacStats.hpp" +#include "gc/g1/g1InCSetState.hpp" class G1CollectedHeap; @@ -102,16 +104,22 @@ static inline HeapWord* par_allocate(HeapRegion* alloc_region, size_t word_size, bool bot_updates); + // Perform a MT-safe allocation out of the given region, with the given + // minimum and desired size. Returns the actual size allocated (between + // minimum and desired size) in actual_word_size if the allocation has been + // successful. + static inline HeapWord* par_allocate(HeapRegion* alloc_region, + size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, + bool bot_updates); // Ensure that the region passed as a parameter has been filled up // so that noone else can allocate out of it any more. - static void fill_up_remaining_space(HeapRegion* alloc_region, - bool bot_updates); - - // Retire the active allocating region. If fill_up is true then make - // sure that the region is full before we retire it so that noone - // else can allocate out of it. - void retire(bool fill_up); + // Returns the number of bytes that have been wasted by filled up + // the space. + static size_t fill_up_remaining_space(HeapRegion* alloc_region, + bool bot_updates); // After a region is allocated by alloc_new_region, this // method is used to set it as the active alloc_region @@ -126,6 +134,12 @@ void fill_in_ext_msg(ar_ext_msg* msg, const char* message); protected: + // Retire the active allocating region. If fill_up is true then make + // sure that the region is full before we retire it so that no one + // else can allocate out of it. + // Returns the number of bytes that have been filled up during retire. + virtual size_t retire(bool fill_up); + // For convenience as subclasses use it. static G1CollectedHeap* _g1h; @@ -154,7 +168,18 @@ // First-level allocation: Should be called without holding a // lock. It will try to allocate lock-free out of the active region, // or return NULL if it was unable to. - inline HeapWord* attempt_allocation(size_t word_size, bool bot_updates); + inline HeapWord* attempt_allocation(size_t word_size, + bool bot_updates); + // Perform an allocation out of the current allocation region, with the given + // minimum and desired size. Returns the actual size allocated (between + // minimum and desired size) in actual_word_size if the allocation has been + // successful. + // Should be called without holding a lock. It will try to allocate lock-free + // out of the active region, or return NULL if it was unable to. + inline HeapWord* attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, + bool bot_updates); // Second-level allocation: Should be called while holding a // lock. It will try to first allocate lock-free out of the active @@ -164,6 +189,14 @@ // it conform to its locking protocol. inline HeapWord* attempt_allocation_locked(size_t word_size, bool bot_updates); + // Same as attempt_allocation_locked(size_t, bool), but allowing specification + // of minimum word size of the block in min_word_size, and the maximum word + // size of the allocation in desired_word_size. The actual size of the block is + // returned in actual_word_size. + inline HeapWord* attempt_allocation_locked(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, + bool bot_updates); // Should be called to allocate a new region even if the max of this // type of regions has been reached. Should only be called if other @@ -186,9 +219,17 @@ virtual HeapRegion* release(); #if G1_ALLOC_REGION_TRACING - void trace(const char* str, size_t word_size = 0, HeapWord* result = NULL); + void trace(const char* str, + size_t min_word_size = 0, + size_t desired_word_size = 0, + size_t actual_word_size = 0, + HeapWord* result = NULL); #else // G1_ALLOC_REGION_TRACING - void trace(const char* str, size_t word_size = 0, HeapWord* result = NULL) { } + void trace(const char* str, + size_t min_word_size = 0, + size_t desired_word_size = 0, + size_t actual_word_size = 0, + HeapWord* result = NULL) { } #endif // G1_ALLOC_REGION_TRACING }; @@ -201,22 +242,33 @@ : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { } }; -class SurvivorGCAllocRegion : public G1AllocRegion { +// Common base class for allocation regions used during GC. +class G1GCAllocRegion : public G1AllocRegion { protected: + G1EvacStats* _stats; + InCSetState::in_cset_state_t _purpose; + virtual HeapRegion* allocate_new_region(size_t word_size, bool force); virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes); + + virtual size_t retire(bool fill_up); public: - SurvivorGCAllocRegion() - : G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { } + G1GCAllocRegion(const char* name, bool bot_updates, G1EvacStats* stats, InCSetState::in_cset_state_t purpose) + : G1AllocRegion(name, bot_updates), _stats(stats), _purpose(purpose) { + assert(stats != NULL, "Must pass non-NULL PLAB statistics"); + } }; -class OldGCAllocRegion : public G1AllocRegion { -protected: - virtual HeapRegion* allocate_new_region(size_t word_size, bool force); - virtual void retire_region(HeapRegion* alloc_region, size_t allocated_bytes); +class SurvivorGCAllocRegion : public G1GCAllocRegion { public: - OldGCAllocRegion() - : G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { } + SurvivorGCAllocRegion(G1EvacStats* stats) + : G1GCAllocRegion("Survivor GC Alloc Region", false /* bot_updates */, stats, InCSetState::Young) { } +}; + +class OldGCAllocRegion : public G1GCAllocRegion { +public: + OldGCAllocRegion(G1EvacStats* stats) + : G1GCAllocRegion("Old GC Alloc Region", true /* bot_updates */, stats, InCSetState::Old) { } // This specialization of release() makes sure that the last card that has // been allocated into has been completely filled by a dummy object. This
--- a/src/share/vm/gc/g1/g1AllocRegion.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1AllocRegion.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -40,52 +40,74 @@ } } +inline HeapWord* G1AllocRegion::par_allocate(HeapRegion* alloc_region, size_t word_size, bool bot_updates) { + size_t temp; + return par_allocate(alloc_region, word_size, word_size, &temp, bot_updates); +} + inline HeapWord* G1AllocRegion::par_allocate(HeapRegion* alloc_region, - size_t word_size, + size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, bool bot_updates) { assert(alloc_region != NULL, err_msg("pre-condition")); assert(!alloc_region->is_empty(), err_msg("pre-condition")); if (!bot_updates) { - return alloc_region->par_allocate_no_bot_updates(word_size); + return alloc_region->par_allocate_no_bot_updates(min_word_size, desired_word_size, actual_word_size); } else { - return alloc_region->par_allocate(word_size); + return alloc_region->par_allocate(min_word_size, desired_word_size, actual_word_size); } } -inline HeapWord* G1AllocRegion::attempt_allocation(size_t word_size, +inline HeapWord* G1AllocRegion::attempt_allocation(size_t word_size, bool bot_updates) { + size_t temp; + return attempt_allocation(word_size, word_size, &temp, bot_updates); +} + +inline HeapWord* G1AllocRegion::attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, bool bot_updates) { assert(bot_updates == _bot_updates, ar_ext_msg(this, "pre-condition")); HeapRegion* alloc_region = _alloc_region; assert(alloc_region != NULL, ar_ext_msg(this, "not initialized properly")); - HeapWord* result = par_allocate(alloc_region, word_size, bot_updates); + HeapWord* result = par_allocate(alloc_region, min_word_size, desired_word_size, actual_word_size, bot_updates); if (result != NULL) { - trace("alloc", word_size, result); + trace("alloc", min_word_size, desired_word_size, *actual_word_size, result); return result; } - trace("alloc failed", word_size); + trace("alloc failed", min_word_size, desired_word_size); return NULL; } -inline HeapWord* G1AllocRegion::attempt_allocation_locked(size_t word_size, +inline HeapWord* G1AllocRegion::attempt_allocation_locked(size_t word_size, bool bot_updates) { + size_t temp; + return attempt_allocation_locked(word_size, word_size, &temp, bot_updates); +} + +inline HeapWord* G1AllocRegion::attempt_allocation_locked(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, bool bot_updates) { // First we have to redo the allocation, assuming we're holding the // appropriate lock, in case another thread changed the region while // we were waiting to get the lock. - HeapWord* result = attempt_allocation(word_size, bot_updates); + HeapWord* result = attempt_allocation(min_word_size, desired_word_size, actual_word_size, bot_updates); if (result != NULL) { return result; } retire(true /* fill_up */); - result = new_alloc_region_and_allocate(word_size, false /* force */); + result = new_alloc_region_and_allocate(desired_word_size, false /* force */); if (result != NULL) { - trace("alloc locked (second attempt)", word_size, result); + *actual_word_size = desired_word_size; + trace("alloc locked (second attempt)", min_word_size, desired_word_size, *actual_word_size, result); return result; } - trace("alloc locked failed", word_size); + trace("alloc locked failed", min_word_size, desired_word_size); return NULL; } @@ -94,13 +116,13 @@ assert(bot_updates == _bot_updates, ar_ext_msg(this, "pre-condition")); assert(_alloc_region != NULL, ar_ext_msg(this, "not initialized properly")); - trace("forcing alloc"); + trace("forcing alloc", word_size, word_size); HeapWord* result = new_alloc_region_and_allocate(word_size, true /* force */); if (result != NULL) { - trace("alloc forced", word_size, result); + trace("alloc forced", word_size, word_size, word_size, result); return result; } - trace("alloc forced failed", word_size); + trace("alloc forced failed", word_size, word_size); return NULL; }
--- a/src/share/vm/gc/g1/g1Allocator.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1Allocator.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -24,12 +24,20 @@ #include "precompiled.hpp" #include "gc/g1/g1Allocator.inline.hpp" +#include "gc/g1/g1AllocRegion.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1MarkSweep.hpp" #include "gc/g1/heapRegion.inline.hpp" #include "gc/g1/heapRegionSet.inline.hpp" +G1DefaultAllocator::G1DefaultAllocator(G1CollectedHeap* heap) : + G1Allocator(heap), + _retained_old_gc_alloc_region(NULL), + _survivor_gc_alloc_region(heap->alloc_buffer_stats(InCSetState::Young)), + _old_gc_alloc_region(heap->alloc_buffer_stats(InCSetState::Old)) { +} + void G1DefaultAllocator::init_mutator_alloc_region() { assert(_mutator_alloc_region.get() == NULL, "pre-condition"); _mutator_alloc_region.init(); @@ -79,6 +87,8 @@ void G1DefaultAllocator::init_gc_alloc_regions(EvacuationInfo& evacuation_info) { assert_at_safepoint(true /* should_be_vm_thread */); + G1Allocator::init_gc_alloc_regions(evacuation_info); + _survivor_gc_alloc_region.init(); _old_gc_alloc_region.init(); reuse_retained_old_region(evacuation_info, @@ -101,10 +111,8 @@ _retained_old_gc_alloc_region->record_retained_region(); } - if (ResizePLAB) { - _g1h->alloc_buffer_stats(InCSetState::Young)->adjust_desired_plab_sz(); - _g1h->alloc_buffer_stats(InCSetState::Old)->adjust_desired_plab_sz(); - } + _g1h->alloc_buffer_stats(InCSetState::Young)->adjust_desired_plab_sz(); + _g1h->alloc_buffer_stats(InCSetState::Old)->adjust_desired_plab_sz(); } void G1DefaultAllocator::abandon_gc_alloc_regions() { @@ -136,78 +144,159 @@ HeapWord* G1Allocator::par_allocate_during_gc(InCSetState dest, size_t word_size, AllocationContext_t context) { + size_t temp = 0; + HeapWord* result = par_allocate_during_gc(dest, word_size, word_size, &temp, context); + assert(result == NULL || temp == word_size, + err_msg("Requested " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT, + word_size, temp, p2i(result))); + return result; +} + +HeapWord* G1Allocator::par_allocate_during_gc(InCSetState dest, + size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, + AllocationContext_t context) { switch (dest.value()) { case InCSetState::Young: - return survivor_attempt_allocation(word_size, context); + return survivor_attempt_allocation(min_word_size, desired_word_size, actual_word_size, context); case InCSetState::Old: - return old_attempt_allocation(word_size, context); + return old_attempt_allocation(min_word_size, desired_word_size, actual_word_size, context); default: ShouldNotReachHere(); return NULL; // Keep some compilers happy } } -HeapWord* G1Allocator::survivor_attempt_allocation(size_t word_size, +bool G1Allocator::survivor_is_full(AllocationContext_t context) const { + return _survivor_is_full; +} + +bool G1Allocator::old_is_full(AllocationContext_t context) const { + return _old_is_full; +} + +void G1Allocator::set_survivor_full(AllocationContext_t context) { + _survivor_is_full = true; +} + +void G1Allocator::set_old_full(AllocationContext_t context) { + _old_is_full = true; +} + +HeapWord* G1Allocator::survivor_attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, AllocationContext_t context) { - assert(!_g1h->is_humongous(word_size), + assert(!_g1h->is_humongous(desired_word_size), "we should not be seeing humongous-size allocations in this path"); - HeapWord* result = survivor_gc_alloc_region(context)->attempt_allocation(word_size, + HeapWord* result = survivor_gc_alloc_region(context)->attempt_allocation(min_word_size, + desired_word_size, + actual_word_size, false /* bot_updates */); - if (result == NULL) { + if (result == NULL && !survivor_is_full(context)) { MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag); - result = survivor_gc_alloc_region(context)->attempt_allocation_locked(word_size, + result = survivor_gc_alloc_region(context)->attempt_allocation_locked(min_word_size, + desired_word_size, + actual_word_size, false /* bot_updates */); + if (result == NULL) { + set_survivor_full(context); + } } if (result != NULL) { - _g1h->dirty_young_block(result, word_size); + _g1h->dirty_young_block(result, *actual_word_size); } return result; } -HeapWord* G1Allocator::old_attempt_allocation(size_t word_size, +HeapWord* G1Allocator::old_attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, AllocationContext_t context) { - assert(!_g1h->is_humongous(word_size), + assert(!_g1h->is_humongous(desired_word_size), "we should not be seeing humongous-size allocations in this path"); - HeapWord* result = old_gc_alloc_region(context)->attempt_allocation(word_size, + HeapWord* result = old_gc_alloc_region(context)->attempt_allocation(min_word_size, + desired_word_size, + actual_word_size, true /* bot_updates */); - if (result == NULL) { + if (result == NULL && !old_is_full(context)) { MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag); - result = old_gc_alloc_region(context)->attempt_allocation_locked(word_size, + result = old_gc_alloc_region(context)->attempt_allocation_locked(min_word_size, + desired_word_size, + actual_word_size, true /* bot_updates */); + if (result == NULL) { + set_old_full(context); + } } return result; } +void G1Allocator::init_gc_alloc_regions(EvacuationInfo& evacuation_info) { + _survivor_is_full = false; + _old_is_full = false; +} + G1PLABAllocator::G1PLABAllocator(G1Allocator* allocator) : _g1h(G1CollectedHeap::heap()), _allocator(allocator), _survivor_alignment_bytes(calc_survivor_alignment_bytes()) { + for (size_t i = 0; i < ARRAY_SIZE(_direct_allocated); i++) { + _direct_allocated[i] = 0; + } +} + +bool G1PLABAllocator::may_throw_away_buffer(size_t const allocation_word_sz, size_t const buffer_size) const { + return (allocation_word_sz * 100 < buffer_size * ParallelGCBufferWastePct); } HeapWord* G1PLABAllocator::allocate_direct_or_new_plab(InCSetState dest, size_t word_sz, - AllocationContext_t context) { - size_t gclab_word_size = _g1h->desired_plab_sz(dest); - if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) { + AllocationContext_t context, + bool* plab_refill_failed) { + size_t plab_word_size = G1CollectedHeap::heap()->desired_plab_sz(dest); + size_t required_in_plab = PLAB::size_required_for_allocation(word_sz); + + // Only get a new PLAB if the allocation fits and it would not waste more than + // ParallelGCBufferWastePct in the existing buffer. + if ((required_in_plab <= plab_word_size) && + may_throw_away_buffer(required_in_plab, plab_word_size)) { + G1PLAB* alloc_buf = alloc_buffer(dest, context); alloc_buf->retire(); - HeapWord* buf = _allocator->par_allocate_during_gc(dest, gclab_word_size, context); - if (buf == NULL) { - return NULL; // Let caller handle allocation failure. + size_t actual_plab_size = 0; + HeapWord* buf = _allocator->par_allocate_during_gc(dest, + required_in_plab, + plab_word_size, + &actual_plab_size, + context); + + assert(buf == NULL || ((actual_plab_size >= required_in_plab) && (actual_plab_size <= plab_word_size)), + err_msg("Requested at minimum " SIZE_FORMAT ", desired " SIZE_FORMAT " words, but got " SIZE_FORMAT " at " PTR_FORMAT, + required_in_plab, plab_word_size, actual_plab_size, p2i(buf))); + + if (buf != NULL) { + alloc_buf->set_buf(buf, actual_plab_size); + + HeapWord* const obj = alloc_buf->allocate(word_sz); + assert(obj != NULL, err_msg("PLAB should have been big enough, tried to allocate " + SIZE_FORMAT " requiring " SIZE_FORMAT " PLAB size " SIZE_FORMAT, + word_sz, required_in_plab, plab_word_size)); + return obj; } // Otherwise. - alloc_buf->set_word_size(gclab_word_size); - alloc_buf->set_buf(buf); - - HeapWord* const obj = alloc_buf->allocate(word_sz); - assert(obj != NULL, "buffer was definitely big enough..."); - return obj; - } else { - return _allocator->par_allocate_during_gc(dest, word_sz, context); + *plab_refill_failed = true; } + // Try direct allocation. + HeapWord* result = _allocator->par_allocate_during_gc(dest, word_sz, context); + if (result != NULL) { + _direct_allocated[dest.value()] += word_sz; + } + return result; } void G1PLABAllocator::undo_allocation(InCSetState dest, HeapWord* obj, size_t word_sz, AllocationContext_t context) { @@ -225,11 +314,14 @@ _alloc_buffers[InCSetState::Old] = &_tenured_alloc_buffer; } -void G1DefaultPLABAllocator::retire_alloc_buffers() { +void G1DefaultPLABAllocator::flush_and_retire_stats() { for (uint state = 0; state < InCSetState::Num; state++) { G1PLAB* const buf = _alloc_buffers[state]; if (buf != NULL) { - buf->flush_and_retire_stats(_g1h->alloc_buffer_stats(state)); + G1EvacStats* stats = _g1h->alloc_buffer_stats(state); + buf->flush_and_retire_stats(stats); + stats->add_direct_allocated(_direct_allocated[state]); + _direct_allocated[state] = 0; } } } @@ -275,7 +367,7 @@ _max = _bottom + HeapRegion::min_region_size_in_words(); // Tell mark-sweep that objects in this region are not to be marked. - G1MarkSweep::mark_range_archive(MemRegion(_bottom, HeapRegion::GrainWords)); + G1MarkSweep::set_range_archive(MemRegion(_bottom, HeapRegion::GrainWords), true); // Since we've modified the old set, call update_sizes. _g1h->g1mm()->update_sizes();
--- a/src/share/vm/gc/g1/g1Allocator.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1Allocator.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -38,23 +38,36 @@ // Also keeps track of retained regions across GCs. class G1Allocator : public CHeapObj<mtGC> { friend class VMStructs; +private: + bool _survivor_is_full; + bool _old_is_full; protected: G1CollectedHeap* _g1h; virtual MutatorAllocRegion* mutator_alloc_region(AllocationContext_t context) = 0; + virtual bool survivor_is_full(AllocationContext_t context) const; + virtual bool old_is_full(AllocationContext_t context) const; + + virtual void set_survivor_full(AllocationContext_t context); + virtual void set_old_full(AllocationContext_t context); + // Accessors to the allocation regions. virtual SurvivorGCAllocRegion* survivor_gc_alloc_region(AllocationContext_t context) = 0; virtual OldGCAllocRegion* old_gc_alloc_region(AllocationContext_t context) = 0; // Allocation attempt during GC for a survivor object / PLAB. - inline HeapWord* survivor_attempt_allocation(size_t word_size, + inline HeapWord* survivor_attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, AllocationContext_t context); // Allocation attempt during GC for an old object / PLAB. - inline HeapWord* old_attempt_allocation(size_t word_size, + inline HeapWord* old_attempt_allocation(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, AllocationContext_t context); public: - G1Allocator(G1CollectedHeap* heap) : _g1h(heap) { } + G1Allocator(G1CollectedHeap* heap) : _g1h(heap), _survivor_is_full(false), _old_is_full(false) { } virtual ~G1Allocator() { } static G1Allocator* create_allocator(G1CollectedHeap* g1h); @@ -66,7 +79,7 @@ virtual void init_mutator_alloc_region() = 0; virtual void release_mutator_alloc_region() = 0; - virtual void init_gc_alloc_regions(EvacuationInfo& evacuation_info) = 0; + virtual void init_gc_alloc_regions(EvacuationInfo& evacuation_info); virtual void release_gc_alloc_regions(EvacuationInfo& evacuation_info) = 0; virtual void abandon_gc_alloc_regions() = 0; @@ -93,6 +106,12 @@ size_t word_size, AllocationContext_t context); + HeapWord* par_allocate_during_gc(InCSetState dest, + size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size, + AllocationContext_t context); + virtual size_t used_in_alloc_regions() = 0; }; @@ -114,7 +133,7 @@ HeapRegion* _retained_old_gc_alloc_region; public: - G1DefaultAllocator(G1CollectedHeap* heap) : G1Allocator(heap), _retained_old_gc_alloc_region(NULL) { } + G1DefaultAllocator(G1CollectedHeap* heap); virtual void init_mutator_alloc_region(); virtual void release_mutator_alloc_region(); @@ -163,8 +182,12 @@ guarantee(_retired, "Allocation buffer has not been retired"); } - virtual void set_buf(HeapWord* buf) { - PLAB::set_buf(buf); + // The amount of space in words wasted within the PLAB including + // waste due to refills and alignment. + size_t wasted() const { return _wasted; } + + virtual void set_buf(HeapWord* buf, size_t word_size) { + PLAB::set_buf(buf, word_size); _retired = false; } @@ -198,7 +221,10 @@ // architectures have a special compare against zero instructions. const uint _survivor_alignment_bytes; - virtual void retire_alloc_buffers() = 0; + // Number of words allocated directly (not counting PLAB allocation). + size_t _direct_allocated[InCSetState::Num]; + + virtual void flush_and_retire_stats() = 0; virtual G1PLAB* alloc_buffer(InCSetState dest, AllocationContext_t context) = 0; // Calculate the survivor space object alignment in bytes. Returns that or 0 if @@ -215,6 +241,11 @@ } } + HeapWord* allocate_new_plab(InCSetState dest, + size_t word_sz, + AllocationContext_t context); + + bool may_throw_away_buffer(size_t const allocation_word_sz, size_t const buffer_size) const; public: G1PLABAllocator(G1Allocator* allocator); virtual ~G1PLABAllocator() { } @@ -225,31 +256,28 @@ // Allocate word_sz words in dest, either directly into the regions or by // allocating a new PLAB. Returns the address of the allocated memory, NULL if - // not successful. + // not successful. Plab_refill_failed indicates whether an attempt to refill the + // PLAB failed or not. HeapWord* allocate_direct_or_new_plab(InCSetState dest, size_t word_sz, - AllocationContext_t context); + AllocationContext_t context, + bool* plab_refill_failed); // Allocate word_sz words in the PLAB of dest. Returns the address of the // allocated memory, NULL if not successful. - HeapWord* plab_allocate(InCSetState dest, - size_t word_sz, - AllocationContext_t context) { - G1PLAB* buffer = alloc_buffer(dest, context); - if (_survivor_alignment_bytes == 0 || !dest.is_young()) { - return buffer->allocate(word_sz); - } else { - return buffer->allocate_aligned(word_sz, _survivor_alignment_bytes); - } - } + inline HeapWord* plab_allocate(InCSetState dest, + size_t word_sz, + AllocationContext_t context); - HeapWord* allocate(InCSetState dest, size_t word_sz, - AllocationContext_t context) { + HeapWord* allocate(InCSetState dest, + size_t word_sz, + AllocationContext_t context, + bool* refill_failed) { HeapWord* const obj = plab_allocate(dest, word_sz, context); if (obj != NULL) { return obj; } - return allocate_direct_or_new_plab(dest, word_sz, context); + return allocate_direct_or_new_plab(dest, word_sz, context, refill_failed); } void undo_allocation(InCSetState dest, HeapWord* obj, size_t word_sz, AllocationContext_t context); @@ -273,7 +301,7 @@ return _alloc_buffers[dest.value()]; } - virtual void retire_alloc_buffers(); + virtual void flush_and_retire_stats(); virtual void waste(size_t& wasted, size_t& undo_wasted); };
--- a/src/share/vm/gc/g1/g1Allocator.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1Allocator.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,6 +27,7 @@ #include "gc/g1/g1Allocator.hpp" #include "gc/g1/g1AllocRegion.inline.hpp" +#include "gc/shared/plab.inline.hpp" HeapWord* G1Allocator::attempt_allocation(size_t word_size, AllocationContext_t context) { return mutator_alloc_region(context)->attempt_allocation(word_size, false /* bot_updates */); @@ -43,4 +44,15 @@ return mutator_alloc_region(context)->attempt_allocation_force(word_size, false /* bot_updates */); } +inline HeapWord* G1PLABAllocator::plab_allocate(InCSetState dest, + size_t word_sz, + AllocationContext_t context) { + G1PLAB* buffer = alloc_buffer(dest, context); + if (_survivor_alignment_bytes == 0 || !dest.is_young()) { + return buffer->allocate(word_sz); + } else { + return buffer->allocate_aligned(word_sz, _survivor_alignment_bytes); + } +} + #endif // SHARE_VM_GC_G1_G1ALLOCATOR_HPP
--- a/src/share/vm/gc/g1/g1Allocator_ext.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1Allocator_ext.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -23,7 +23,7 @@ */ #include "precompiled.hpp" -#include "gc/g1/g1Allocator.hpp" +#include "gc/g1/g1Allocator.inline.hpp" #include "gc/g1/g1CollectedHeap.hpp" G1Allocator* G1Allocator::create_allocator(G1CollectedHeap* g1h) {
--- a/src/share/vm/gc/g1/g1BlockOffsetTable.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1BlockOffsetTable.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,7 +26,8 @@ #define SHARE_VM_GC_G1_G1BLOCKOFFSETTABLE_INLINE_HPP #include "gc/g1/g1BlockOffsetTable.hpp" -#include "gc/g1/heapRegion.inline.hpp" +#include "gc/g1/heapRegion.hpp" +#include "gc/shared/memset_with_concurrent_readers.hpp" #include "gc/shared/space.hpp" inline HeapWord* G1BlockOffsetTable::block_start(const void* addr) { @@ -68,15 +69,7 @@ check_index(right, "right index out of range"); assert(left <= right, "indexes out of order"); size_t num_cards = right - left + 1; - if (UseMemSetInBOT) { - memset(&_offset_array[left], offset, num_cards); - } else { - size_t i = left; - const size_t end = i + num_cards; - for (; i < end; i++) { - _offset_array[i] = offset; - } - } + memset_with_concurrent_readers(&_offset_array[left], offset, num_cards); } // Variant of index_for that does not check the index for validity.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/g1/g1CodeBlobClosure.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "code/nmethod.hpp" +#include "gc/g1/g1CodeBlobClosure.hpp" +#include "gc/g1/g1CollectedHeap.inline.hpp" +#include "gc/g1/heapRegion.hpp" +#include "gc/g1/heapRegionRemSet.hpp" +#include "oops/oop.inline.hpp" + +template <typename T> +void G1CodeBlobClosure::HeapRegionGatheringOopClosure::do_oop_work(T* p) { + _work->do_oop(p); + T oop_or_narrowoop = oopDesc::load_heap_oop(p); + if (!oopDesc::is_null(oop_or_narrowoop)) { + oop o = oopDesc::decode_heap_oop_not_null(oop_or_narrowoop); + HeapRegion* hr = _g1h->heap_region_containing_raw(o); + assert(!_g1h->obj_in_cs(o) || hr->rem_set()->strong_code_roots_list_contains(_nm), "if o still in collection set then evacuation failed and nm must already be in the remset"); + hr->add_strong_code_root(_nm); + } +} + +void G1CodeBlobClosure::HeapRegionGatheringOopClosure::do_oop(oop* o) { + do_oop_work(o); +} + +void G1CodeBlobClosure::HeapRegionGatheringOopClosure::do_oop(narrowOop* o) { + do_oop_work(o); +} + +void G1CodeBlobClosure::do_code_blob(CodeBlob* cb) { + nmethod* nm = cb->as_nmethod_or_null(); + if (nm != NULL) { + if (!nm->test_set_oops_do_mark()) { + _oc.set_nm(nm); + nm->oops_do(&_oc); + nm->fix_oop_relocations(); + } + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/g1/g1CodeBlobClosure.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "gc/g1/g1CollectedHeap.hpp" +#include "memory/iterator.hpp" + +class nmethod; + +class G1CodeBlobClosure : public CodeBlobClosure { + class HeapRegionGatheringOopClosure : public OopClosure { + G1CollectedHeap* _g1h; + OopClosure* _work; + nmethod* _nm; + + template <typename T> + void do_oop_work(T* p); + + public: + HeapRegionGatheringOopClosure(OopClosure* oc) : _g1h(G1CollectedHeap::heap()), _work(oc), _nm(NULL) {} + + void do_oop(oop* o); + void do_oop(narrowOop* o); + + void set_nm(nmethod* nm) { + _nm = nm; + } + }; + + HeapRegionGatheringOopClosure _oc; +public: + G1CodeBlobClosure(OopClosure* oc) : _oc(oc) {} + + void do_code_blob(CodeBlob* cb); +};
--- a/src/share/vm/gc/g1/g1CollectedHeap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectedHeap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -65,6 +65,7 @@ #include "memory/iterator.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" +#include "runtime/init.hpp" #include "runtime/orderAccess.inline.hpp" #include "runtime/vmThread.hpp" #include "utilities/globalDefinitions.hpp" @@ -949,6 +950,7 @@ } bool G1CollectedHeap::alloc_archive_regions(MemRegion* ranges, size_t count) { + assert(!is_init_completed(), "Expect to be called at JVM init time"); assert(ranges != NULL, "MemRegion array NULL"); assert(count != 0, "No MemRegions provided"); MutexLockerEx x(Heap_lock); @@ -1037,12 +1039,13 @@ } // Notify mark-sweep of the archive range. - G1MarkSweep::mark_range_archive(curr_range); + G1MarkSweep::set_range_archive(curr_range, true); } return true; } void G1CollectedHeap::fill_archive_regions(MemRegion* ranges, size_t count) { + assert(!is_init_completed(), "Expect to be called at JVM init time"); assert(ranges != NULL, "MemRegion array NULL"); assert(count != 0, "No MemRegions provided"); MemRegion reserved = _hrm.reserved(); @@ -1125,6 +1128,81 @@ return result; } +void G1CollectedHeap::dealloc_archive_regions(MemRegion* ranges, size_t count) { + assert(!is_init_completed(), "Expect to be called at JVM init time"); + assert(ranges != NULL, "MemRegion array NULL"); + assert(count != 0, "No MemRegions provided"); + MemRegion reserved = _hrm.reserved(); + HeapWord* prev_last_addr = NULL; + HeapRegion* prev_last_region = NULL; + size_t size_used = 0; + size_t uncommitted_regions = 0; + + // For each Memregion, free the G1 regions that constitute it, and + // notify mark-sweep that the range is no longer to be considered 'archive.' + MutexLockerEx x(Heap_lock); + for (size_t i = 0; i < count; i++) { + HeapWord* start_address = ranges[i].start(); + HeapWord* last_address = ranges[i].last(); + + assert(reserved.contains(start_address) && reserved.contains(last_address), + err_msg("MemRegion outside of heap [" PTR_FORMAT ", " PTR_FORMAT "]", + p2i(start_address), p2i(last_address))); + assert(start_address > prev_last_addr, + err_msg("Ranges not in ascending order: " PTR_FORMAT " <= " PTR_FORMAT , + p2i(start_address), p2i(prev_last_addr))); + size_used += ranges[i].byte_size(); + prev_last_addr = last_address; + + HeapRegion* start_region = _hrm.addr_to_region(start_address); + HeapRegion* last_region = _hrm.addr_to_region(last_address); + + // Check for ranges that start in the same G1 region in which the previous + // range ended, and adjust the start address so we don't try to free + // the same region again. If the current range is entirely within that + // region, skip it. + if (start_region == prev_last_region) { + start_address = start_region->end(); + if (start_address > last_address) { + continue; + } + start_region = _hrm.addr_to_region(start_address); + } + prev_last_region = last_region; + + // After verifying that each region was marked as an archive region by + // alloc_archive_regions, set it free and empty and uncommit it. + HeapRegion* curr_region = start_region; + while (curr_region != NULL) { + guarantee(curr_region->is_archive(), + err_msg("Expected archive region at index %u", curr_region->hrm_index())); + uint curr_index = curr_region->hrm_index(); + _old_set.remove(curr_region); + curr_region->set_free(); + curr_region->set_top(curr_region->bottom()); + if (curr_region != last_region) { + curr_region = _hrm.next_region_in_heap(curr_region); + } else { + curr_region = NULL; + } + _hrm.shrink_at(curr_index, 1); + uncommitted_regions++; + } + + // Notify mark-sweep that this is no longer an archive range. + G1MarkSweep::set_range_archive(ranges[i], false); + } + + if (uncommitted_regions != 0) { + ergo_verbose1(ErgoHeapSizing, + "attempt heap shrinking", + ergo_format_reason("uncommitted archive regions") + ergo_format_byte("total size"), + HeapRegion::GrainWords * HeapWordSize * uncommitted_regions); + } + decrease_used(size_used); +} + HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size, uint* gc_count_before_ret, uint* gclocker_retry_count_ret) { @@ -1944,8 +2022,8 @@ _young_list(new YoungList(this)), _gc_time_stamp(0), _summary_bytes_used(0), - _survivor_plab_stats(YoungPLABSize, PLABWeight), - _old_plab_stats(OldPLABSize, PLABWeight), + _survivor_evac_stats(YoungPLABSize, PLABWeight), + _old_evac_stats(OldPLABSize, PLABWeight), _expand_heap_after_alloc_failure(true), _surviving_young_words(NULL), _old_marking_cycles_started(0), @@ -1960,7 +2038,7 @@ _gc_tracer_stw(new (ResourceObj::C_HEAP, mtGC) G1NewTracer()), _gc_tracer_cm(new (ResourceObj::C_HEAP, mtGC) G1OldTracer()) { - _workers = new FlexibleWorkGang("GC Thread", ParallelGCThreads, + _workers = new WorkGang("GC Thread", ParallelGCThreads, /* are_GC_task_threads */true, /* are_ConcurrentGC_threads */false); _workers->initialize_workers(); @@ -2845,9 +2923,9 @@ } // For G1 TLABs should not contain humongous objects, so the maximum TLAB size -// must be smaller than the humongous object limit. +// must be equal to the humongous object limit. size_t G1CollectedHeap::max_tlab_size() const { - return align_size_down(_humongous_object_threshold_in_words - 1, MinObjAlignment); + return align_size_down(_humongous_object_threshold_in_words, MinObjAlignment); } size_t G1CollectedHeap::unsafe_max_tlab_alloc(Thread* ignored) const { @@ -3504,6 +3582,13 @@ return G1HeapSummary(heap_summary, used(), eden_used_bytes, eden_capacity_bytes, survivor_used_bytes); } +G1EvacSummary G1CollectedHeap::create_g1_evac_summary(G1EvacStats* stats) { + return G1EvacSummary(stats->allocated(), stats->wasted(), stats->undo_wasted(), + stats->unused(), stats->used(), stats->region_end_waste(), + stats->regions_filled(), stats->direct_allocated(), + stats->failure_used(), stats->failure_waste()); +} + void G1CollectedHeap::trace_heap(GCWhen::Type when, const GCTracer* gc_tracer) { const G1HeapSummary& heap_summary = create_g1_heap_summary(); gc_tracer->report_gc_heap_summary(when, heap_summary); @@ -3753,8 +3838,7 @@ cl.flush_rem_set_entries(); } -void -G1CollectedHeap::setup_surviving_young_words() { +void G1CollectedHeap::setup_surviving_young_words() { assert(_surviving_young_words == NULL, "pre-condition"); uint array_length = g1_policy()->young_cset_region_length(); _surviving_young_words = NEW_C_HEAP_ARRAY(size_t, (size_t) array_length, mtGC); @@ -3770,17 +3854,15 @@ #endif // !ASSERT } -void -G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { - MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); +void G1CollectedHeap::update_surviving_young_words(size_t* surv_young_words) { + assert_at_safepoint(true); uint array_length = g1_policy()->young_cset_region_length(); for (uint i = 0; i < array_length; ++i) { _surviving_young_words[i] += surv_young_words[i]; } } -void -G1CollectedHeap::cleanup_surviving_young_words() { +void G1CollectedHeap::cleanup_surviving_young_words() { guarantee( _surviving_young_words != NULL, "pre-condition" ); FREE_C_HEAP_ARRAY(size_t, _surviving_young_words); _surviving_young_words = NULL; @@ -4047,7 +4129,9 @@ g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty); #endif // YOUNG_LIST_VERBOSE - g1_policy()->finalize_cset(target_pause_time_ms, evacuation_info); + g1_policy()->finalize_cset(target_pause_time_ms); + + evacuation_info.set_collectionset_regions(g1_policy()->cset_region_length()); register_humongous_regions_with_cset(); @@ -4171,7 +4255,10 @@ // investigate this in CR 7178365. double sample_end_time_sec = os::elapsedTime(); double pause_time_ms = (sample_end_time_sec - sample_start_time_sec) * MILLIUNITS; - g1_policy()->record_collection_pause_end(pause_time_ms, evacuation_info); + g1_policy()->record_collection_pause_end(pause_time_ms); + + evacuation_info.set_collectionset_used_before(g1_policy()->collection_set_bytes_used_before()); + evacuation_info.set_bytes_copied(g1_policy()->bytes_copied_during_gc()); MemoryService::track_memory_usage(); @@ -4375,6 +4462,13 @@ } class G1ParEvacuateFollowersClosure : public VoidClosure { +private: + double _start_term; + double _term_time; + size_t _term_attempts; + + void start_term_time() { _term_attempts++; _start_term = os::elapsedTime(); } + void end_term_time() { _term_time += os::elapsedTime() - _start_term; } protected: G1CollectedHeap* _g1h; G1ParScanThreadState* _par_scan_state; @@ -4391,19 +4485,23 @@ RefToScanQueueSet* queues, ParallelTaskTerminator* terminator) : _g1h(g1h), _par_scan_state(par_scan_state), - _queues(queues), _terminator(terminator) {} + _queues(queues), _terminator(terminator), + _start_term(0.0), _term_time(0.0), _term_attempts(0) {} void do_void(); + double term_time() const { return _term_time; } + size_t term_attempts() const { return _term_attempts; } + private: inline bool offer_termination(); }; bool G1ParEvacuateFollowersClosure::offer_termination() { G1ParScanThreadState* const pss = par_scan_state(); - pss->start_term_time(); + start_term_time(); const bool res = terminator()->offer_termination(); - pss->end_term_time(); + end_term_time(); return res; } @@ -4444,15 +4542,17 @@ class G1ParTask : public AbstractGangTask { protected: G1CollectedHeap* _g1h; - RefToScanQueueSet *_queues; + G1ParScanThreadState** _pss; + RefToScanQueueSet* _queues; G1RootProcessor* _root_processor; ParallelTaskTerminator _terminator; uint _n_workers; public: - G1ParTask(G1CollectedHeap* g1h, RefToScanQueueSet *task_queues, G1RootProcessor* root_processor, uint n_workers) + G1ParTask(G1CollectedHeap* g1h, G1ParScanThreadState** per_thread_states, RefToScanQueueSet *task_queues, G1RootProcessor* root_processor, uint n_workers) : AbstractGangTask("G1 collection"), _g1h(g1h), + _pss(per_thread_states), _queues(task_queues), _root_processor(root_processor), _terminator(n_workers, _queues), @@ -4484,8 +4584,7 @@ bool only_young, bool claim) : _oop_closure(oop_closure), _oop_in_klass_closure(oop_closure->g1(), - oop_closure->pss(), - oop_closure->rp()), + oop_closure->pss()), _klass_in_cld_closure(&_oop_in_klass_closure, only_young), _claim(claim) { @@ -4499,7 +4598,8 @@ void work(uint worker_id) { if (worker_id >= _n_workers) return; // no work needed this round - _g1h->g1_policy()->phase_times()->record_time_secs(G1GCPhaseTimes::GCWorkerStart, worker_id, os::elapsedTime()); + double start_sec = os::elapsedTime(); + _g1h->g1_policy()->phase_times()->record_time_secs(G1GCPhaseTimes::GCWorkerStart, worker_id, start_sec); { ResourceMark rm; @@ -4507,23 +4607,24 @@ ReferenceProcessor* rp = _g1h->ref_processor_stw(); - G1ParScanThreadState pss(_g1h, worker_id, rp); + G1ParScanThreadState* pss = _pss[worker_id]; + pss->set_ref_processor(rp); bool only_young = _g1h->collector_state()->gcs_are_young(); // Non-IM young GC. - G1ParCopyClosure<G1BarrierNone, G1MarkNone> scan_only_root_cl(_g1h, &pss, rp); + G1ParCopyClosure<G1BarrierNone, G1MarkNone> scan_only_root_cl(_g1h, pss); G1CLDClosure<G1MarkNone> scan_only_cld_cl(&scan_only_root_cl, only_young, // Only process dirty klasses. false); // No need to claim CLDs. // IM young GC. // Strong roots closures. - G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> scan_mark_root_cl(_g1h, &pss, rp); + G1ParCopyClosure<G1BarrierNone, G1MarkFromRoot> scan_mark_root_cl(_g1h, pss); G1CLDClosure<G1MarkFromRoot> scan_mark_cld_cl(&scan_mark_root_cl, false, // Process all klasses. true); // Need to claim CLDs. // Weak roots closures. - G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> scan_mark_weak_root_cl(_g1h, &pss, rp); + G1ParCopyClosure<G1BarrierNone, G1MarkPromotedFromRoot> scan_mark_weak_root_cl(_g1h, pss); G1CLDClosure<G1MarkPromotedFromRoot> scan_mark_weak_cld_cl(&scan_mark_weak_root_cl, false, // Process all klasses. true); // Need to claim CLDs. @@ -4554,8 +4655,7 @@ weak_cld_cl = &scan_only_cld_cl; } - pss.start_strong_roots(); - + double start_strong_roots_sec = os::elapsedTime(); _root_processor->evacuate_roots(strong_root_cl, weak_root_cl, strong_cld_cl, @@ -4563,32 +4663,45 @@ trace_metadata, worker_id); - G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, &pss); - _root_processor->scan_remembered_sets(&push_heap_rs_cl, - weak_root_cl, - worker_id); - pss.end_strong_roots(); - + G1ParPushHeapRSClosure push_heap_rs_cl(_g1h, pss); + _g1h->g1_rem_set()->oops_into_collection_set_do(&push_heap_rs_cl, + weak_root_cl, + worker_id); + double strong_roots_sec = os::elapsedTime() - start_strong_roots_sec; + + double term_sec = 0.0; + size_t evac_term_attempts = 0; { double start = os::elapsedTime(); - G1ParEvacuateFollowersClosure evac(_g1h, &pss, _queues, &_terminator); + G1ParEvacuateFollowersClosure evac(_g1h, pss, _queues, &_terminator); evac.do_void(); + + evac_term_attempts = evac.term_attempts(); + term_sec = evac.term_time(); double elapsed_sec = os::elapsedTime() - start; - double term_sec = pss.term_time(); _g1h->g1_policy()->phase_times()->add_time_secs(G1GCPhaseTimes::ObjCopy, worker_id, elapsed_sec - term_sec); _g1h->g1_policy()->phase_times()->record_time_secs(G1GCPhaseTimes::Termination, worker_id, term_sec); - _g1h->g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::Termination, worker_id, pss.term_attempts()); + _g1h->g1_policy()->phase_times()->record_thread_work_item(G1GCPhaseTimes::Termination, worker_id, evac_term_attempts); } - _g1h->g1_policy()->record_thread_age_table(pss.age_table()); - _g1h->update_surviving_young_words(pss.surviving_young_words()+1); + + assert(pss->queue_is_empty(), "should be empty"); if (PrintTerminationStats) { MutexLockerEx x(ParGCRareEvent_lock, Mutex::_no_safepoint_check_flag); - pss.print_termination_stats(); + size_t lab_waste; + size_t lab_undo_waste; + pss->waste(lab_waste, lab_undo_waste); + _g1h->print_termination_stats(gclog_or_tty, + worker_id, + (os::elapsedTime() - start_sec) * 1000.0, /* elapsed time */ + strong_roots_sec * 1000.0, /* strong roots time */ + term_sec * 1000.0, /* evac term time */ + evac_term_attempts, /* evac term attempts */ + lab_waste, /* alloc buffer waste */ + lab_undo_waste /* undo waste */ + ); } - assert(pss.queue_is_empty(), "should be empty"); - // Close the inner scope so that the ResourceMark and HandleMark // destructors are executed here and are included as part of the // "GC Worker Time". @@ -4597,6 +4710,31 @@ } }; +void G1CollectedHeap::print_termination_stats_hdr(outputStream* const st) { + st->print_raw_cr("GC Termination Stats"); + st->print_raw_cr(" elapsed --strong roots-- -------termination------- ------waste (KiB)------"); + st->print_raw_cr("thr ms ms % ms % attempts total alloc undo"); + st->print_raw_cr("--- --------- --------- ------ --------- ------ -------- ------- ------- -------"); +} + +void G1CollectedHeap::print_termination_stats(outputStream* const st, + uint worker_id, + double elapsed_ms, + double strong_roots_ms, + double term_ms, + size_t term_attempts, + size_t alloc_buffer_waste, + size_t undo_waste) const { + st->print_cr("%3d %9.2f %9.2f %6.2f " + "%9.2f %6.2f " SIZE_FORMAT_W(8) " " + SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), + worker_id, elapsed_ms, strong_roots_ms, strong_roots_ms * 100 / elapsed_ms, + term_ms, term_ms * 100 / elapsed_ms, term_attempts, + (alloc_buffer_waste + undo_waste) * HeapWordSize / K, + alloc_buffer_waste * HeapWordSize / K, + undo_waste * HeapWordSize / K); +} + class G1StringSymbolTableUnlinkTask : public AbstractGangTask { private: BoolObjectClosure* _is_alive; @@ -5125,17 +5263,20 @@ class G1STWRefProcTaskExecutor: public AbstractRefProcTaskExecutor { private: - G1CollectedHeap* _g1h; - RefToScanQueueSet* _queues; - FlexibleWorkGang* _workers; - uint _active_workers; + G1CollectedHeap* _g1h; + G1ParScanThreadState** _pss; + RefToScanQueueSet* _queues; + WorkGang* _workers; + uint _active_workers; public: G1STWRefProcTaskExecutor(G1CollectedHeap* g1h, - FlexibleWorkGang* workers, + G1ParScanThreadState** per_thread_states, + WorkGang* workers, RefToScanQueueSet *task_queues, uint n_workers) : _g1h(g1h), + _pss(per_thread_states), _queues(task_queues), _workers(workers), _active_workers(n_workers) @@ -5154,17 +5295,20 @@ typedef AbstractRefProcTaskExecutor::ProcessTask ProcessTask; ProcessTask& _proc_task; G1CollectedHeap* _g1h; - RefToScanQueueSet *_task_queues; + G1ParScanThreadState** _pss; + RefToScanQueueSet* _task_queues; ParallelTaskTerminator* _terminator; public: G1STWRefProcTaskProxy(ProcessTask& proc_task, - G1CollectedHeap* g1h, - RefToScanQueueSet *task_queues, - ParallelTaskTerminator* terminator) : + G1CollectedHeap* g1h, + G1ParScanThreadState** per_thread_states, + RefToScanQueueSet *task_queues, + ParallelTaskTerminator* terminator) : AbstractGangTask("Process reference objects in parallel"), _proc_task(proc_task), _g1h(g1h), + _pss(per_thread_states), _task_queues(task_queues), _terminator(terminator) {} @@ -5176,11 +5320,12 @@ G1STWIsAliveClosure is_alive(_g1h); - G1ParScanThreadState pss(_g1h, worker_id, NULL); - - G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); - - G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); + G1ParScanThreadState* pss = _pss[worker_id]; + pss->set_ref_processor(NULL); + + G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, pss); + + G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, pss); OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; @@ -5190,10 +5335,10 @@ } // Keep alive closure. - G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, &pss); + G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, pss); // Complete GC closure - G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _task_queues, _terminator); + G1ParEvacuateFollowersClosure drain_queue(_g1h, pss, _task_queues, _terminator); // Call the reference processing task's work routine. _proc_task.work(worker_id, is_alive, keep_alive, drain_queue); @@ -5212,7 +5357,7 @@ assert(_workers != NULL, "Need parallel worker threads."); ParallelTaskTerminator terminator(_active_workers, _queues); - G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _queues, &terminator); + G1STWRefProcTaskProxy proc_task_proxy(proc_task, _g1h, _pss, _queues, &terminator); _workers->run_task(&proc_task_proxy); } @@ -5254,15 +5399,17 @@ class G1ParPreserveCMReferentsTask: public AbstractGangTask { protected: - G1CollectedHeap* _g1h; - RefToScanQueueSet *_queues; + G1CollectedHeap* _g1h; + G1ParScanThreadState** _pss; + RefToScanQueueSet* _queues; ParallelTaskTerminator _terminator; uint _n_workers; public: - G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h, uint workers, RefToScanQueueSet *task_queues) : + G1ParPreserveCMReferentsTask(G1CollectedHeap* g1h, G1ParScanThreadState** per_thread_states, int workers, RefToScanQueueSet *task_queues) : AbstractGangTask("ParPreserveCMReferents"), _g1h(g1h), + _pss(per_thread_states), _queues(task_queues), _terminator(workers, _queues), _n_workers(workers) @@ -5272,12 +5419,13 @@ ResourceMark rm; HandleMark hm; - G1ParScanThreadState pss(_g1h, worker_id, NULL); - assert(pss.queue_is_empty(), "both queue and overflow should be empty"); - - G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, &pss, NULL); - - G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, &pss, NULL); + G1ParScanThreadState* pss = _pss[worker_id]; + pss->set_ref_processor(NULL); + assert(pss->queue_is_empty(), "both queue and overflow should be empty"); + + G1ParScanExtRootClosure only_copy_non_heap_cl(_g1h, pss); + + G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(_g1h, pss); OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; @@ -5291,7 +5439,7 @@ // Copying keep alive closure. Applied to referent objects that need // to be copied. - G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, &pss); + G1CopyingKeepAliveClosure keep_alive(_g1h, copy_non_heap_cl, pss); ReferenceProcessor* rp = _g1h->ref_processor_cm(); @@ -5324,15 +5472,15 @@ } // Drain the queue - which may cause stealing - G1ParEvacuateFollowersClosure drain_queue(_g1h, &pss, _queues, &_terminator); + G1ParEvacuateFollowersClosure drain_queue(_g1h, pss, _queues, &_terminator); drain_queue.do_void(); // Allocation buffers were retired at the end of G1ParEvacuateFollowersClosure - assert(pss.queue_is_empty(), "should be"); + assert(pss->queue_is_empty(), "should be"); } }; // Weak Reference processing during an evacuation pause (part 1). -void G1CollectedHeap::process_discovered_references() { +void G1CollectedHeap::process_discovered_references(G1ParScanThreadState** per_thread_states) { double ref_proc_start = os::elapsedTime(); ReferenceProcessor* rp = _ref_processor_stw; @@ -5362,6 +5510,7 @@ uint no_of_gc_workers = workers()->active_workers(); G1ParPreserveCMReferentsTask keep_cm_referents(this, + per_thread_states, no_of_gc_workers, _task_queues); @@ -5376,16 +5525,17 @@ // JNI refs. // Use only a single queue for this PSS. - G1ParScanThreadState pss(this, 0, NULL); - assert(pss.queue_is_empty(), "pre-condition"); + G1ParScanThreadState* pss = per_thread_states[0]; + pss->set_ref_processor(NULL); + assert(pss->queue_is_empty(), "pre-condition"); // We do not embed a reference processor in the copying/scanning // closures while we're actually processing the discovered // reference objects. - G1ParScanExtRootClosure only_copy_non_heap_cl(this, &pss, NULL); - - G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, &pss, NULL); + G1ParScanExtRootClosure only_copy_non_heap_cl(this, pss); + + G1ParScanAndMarkExtRootClosure copy_mark_non_heap_cl(this, pss); OopClosure* copy_non_heap_cl = &only_copy_non_heap_cl; @@ -5395,10 +5545,10 @@ } // Keep alive closure. - G1CopyingKeepAliveClosure keep_alive(this, copy_non_heap_cl, &pss); + G1CopyingKeepAliveClosure keep_alive(this, copy_non_heap_cl, pss); // Serial Complete GC closure - G1STWDrainQueueClosure drain_queue(this, &pss); + G1STWDrainQueueClosure drain_queue(this, pss); // Setup the soft refs policy... rp->setup_policy(false); @@ -5417,7 +5567,7 @@ assert(rp->num_q() == no_of_gc_workers, "sanity"); assert(no_of_gc_workers <= rp->max_num_q(), "sanity"); - G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, no_of_gc_workers); + G1STWRefProcTaskExecutor par_task_executor(this, per_thread_states, workers(), _task_queues, no_of_gc_workers); stats = rp->process_discovered_references(&is_alive, &keep_alive, &drain_queue, @@ -5429,14 +5579,14 @@ _gc_tracer_stw->report_gc_reference_stats(stats); // We have completed copying any necessary live referent objects. - assert(pss.queue_is_empty(), "both queue and overflow should be empty"); + assert(pss->queue_is_empty(), "both queue and overflow should be empty"); double ref_proc_time = os::elapsedTime() - ref_proc_start; g1_policy()->phase_times()->record_ref_proc_time(ref_proc_time * 1000.0); } // Weak Reference processing during an evacuation pause (part 2). -void G1CollectedHeap::enqueue_discovered_references() { +void G1CollectedHeap::enqueue_discovered_references(G1ParScanThreadState** per_thread_states) { double ref_enq_start = os::elapsedTime(); ReferenceProcessor* rp = _ref_processor_stw; @@ -5455,7 +5605,7 @@ assert(rp->num_q() == n_workers, "sanity"); assert(n_workers <= rp->max_num_q(), "sanity"); - G1STWRefProcTaskExecutor par_task_executor(this, workers(), _task_queues, n_workers); + G1STWRefProcTaskExecutor par_task_executor(this, per_thread_states, workers(), _task_queues, n_workers); rp->enqueue_discovered_references(&par_task_executor); } @@ -5491,9 +5641,14 @@ double start_par_time_sec = os::elapsedTime(); double end_par_time_sec; + G1ParScanThreadState** per_thread_states = NEW_C_HEAP_ARRAY(G1ParScanThreadState*, n_workers, mtGC); + for (uint i = 0; i < n_workers; i++) { + per_thread_states[i] = new_par_scan_state(i); + } + { G1RootProcessor root_processor(this, n_workers); - G1ParTask g1_par_task(this, _task_queues, &root_processor, n_workers); + G1ParTask g1_par_task(this, per_thread_states, _task_queues, &root_processor, n_workers); // InitialMark needs claim bits to keep track of the marked-through CLDs. if (collector_state()->during_initial_mark_pause()) { ClassLoaderDataGraph::clear_claimed_marks(); @@ -5501,7 +5656,7 @@ // The individual threads will set their evac-failure closures. if (PrintTerminationStats) { - G1ParScanThreadState::print_termination_stats_hdr(); + print_termination_stats_hdr(gclog_or_tty); } workers()->run_task(&g1_par_task); @@ -5528,7 +5683,7 @@ // as we may have to copy some 'reachable' referent // objects (and their reachable sub-graphs) that were // not copied during the pause. - process_discovered_references(); + process_discovered_references(per_thread_states); if (G1StringDedup::is_enabled()) { double fixup_start = os::elapsedTime(); @@ -5544,6 +5699,14 @@ _allocator->release_gc_alloc_regions(evacuation_info); g1_rem_set()->cleanup_after_oops_into_collection_set_do(); + for (uint i = 0; i < n_workers; i++) { + G1ParScanThreadState* pss = per_thread_states[i]; + delete pss; + } + FREE_C_HEAP_ARRAY(G1ParScanThreadState*, per_thread_states); + + record_obj_copy_mem_stats(); + // Reset and re-enable the hot card cache. // Note the counts for the cards in the regions in the // collection set are reset when the collection set is freed. @@ -5568,12 +5731,17 @@ // will log these updates (and dirty their associated // cards). We need these updates logged to update any // RSets. - enqueue_discovered_references(); + enqueue_discovered_references(per_thread_states); redirty_logged_cards(); COMPILER2_PRESENT(DerivedPointerTable::update_pointers()); } +void G1CollectedHeap::record_obj_copy_mem_stats() { + _gc_tracer_stw->report_evacuation_statistics(create_g1_evac_summary(&_survivor_evac_stats), + create_g1_evac_summary(&_old_evac_stats)); +} + void G1CollectedHeap::free_region(HeapRegion* hr, FreeRegionList* free_list, bool par, @@ -5972,6 +6140,11 @@ cur->set_evacuation_failed(false); // The region is now considered to be old. cur->set_old(); + // Do some allocation statistics accounting. Regions that failed evacuation + // are always made old, so there is no need to update anything in the young + // gen statistics, but we need to update old gen statistics. + size_t used_words = cur->marked_bytes() / HeapWordSize; + _old_evac_stats.add_failure_used_and_waste(used_words, HeapRegion::GrainWords - used_words); _old_set.add(cur); evacuation_info.increment_collectionset_used_after(cur->used()); } @@ -6217,6 +6390,10 @@ } } +bool G1CollectedHeap::is_old_gc_alloc_region(HeapRegion* hr) { + return _allocator->is_retained_old_region(hr); +} + void G1CollectedHeap::set_region_short_lived_locked(HeapRegion* hr) { _young_list->push_region(hr); }
--- a/src/share/vm/gc/g1/g1CollectedHeap.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectedHeap.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,12 +28,12 @@ #include "gc/g1/concurrentMark.hpp" #include "gc/g1/evacuationInfo.hpp" #include "gc/g1/g1AllocationContext.hpp" -#include "gc/g1/g1Allocator.hpp" #include "gc/g1/g1BiasedArray.hpp" #include "gc/g1/g1CollectorState.hpp" #include "gc/g1/g1HRPrinter.hpp" #include "gc/g1/g1InCSetState.hpp" #include "gc/g1/g1MonitoringSupport.hpp" +#include "gc/g1/g1EvacStats.hpp" #include "gc/g1/g1SATBCardTableModRefBS.hpp" #include "gc/g1/g1YCTypes.hpp" #include "gc/g1/hSpaceCounters.hpp" @@ -41,6 +41,7 @@ #include "gc/g1/heapRegionSet.hpp" #include "gc/shared/barrierSet.hpp" #include "gc/shared/collectedHeap.hpp" +#include "gc/shared/plab.hpp" #include "memory/memRegion.hpp" #include "utilities/stack.hpp" @@ -54,6 +55,7 @@ class HRRSCleanupTask; class GenerationSpec; class OopsInHeapRegionClosure; +class G1ParScanThreadState; class G1KlassScanClosure; class G1ParScanThreadState; class ObjectClosure; @@ -75,7 +77,9 @@ class EvacuationFailedInfo; class nmethod; class Ticks; -class FlexibleWorkGang; +class WorkGang; +class G1Allocator; +class G1ArchiveAllocator; typedef OverflowTaskQueue<StarTask, mtGC> RefToScanQueue; typedef GenericTaskQueueSet<RefToScanQueue, mtGC> RefToScanQueueSet; @@ -184,8 +188,7 @@ friend class VM_G1IncCollectionPause; friend class VMStructs; friend class MutatorAllocRegion; - friend class SurvivorGCAllocRegion; - friend class OldGCAllocRegion; + friend class G1GCAllocRegion; // Closures used in implementation. friend class G1ParScanThreadState; @@ -200,7 +203,7 @@ friend class G1CheckCSetFastTableClosure; private: - FlexibleWorkGang* _workers; + WorkGang* _workers; static size_t _humongous_object_threshold_in_words; @@ -245,7 +248,7 @@ // The sequence of all heap regions in the heap. HeapRegionManager _hrm; - // Handles non-humongous allocations in the G1CollectedHeap. + // Manages all allocations with regions except humongous object allocations. G1Allocator* _allocator; // Outside of GC pauses, the number of bytes used in all regions other @@ -263,11 +266,11 @@ // Statistics for each allocation context AllocationContextStats _allocation_context_stats; - // PLAB sizing policy for survivors. - PLABStats _survivor_plab_stats; + // GC allocation statistics policy for survivors. + G1EvacStats _survivor_evac_stats; - // PLAB sizing policy for tenured objects. - PLABStats _old_plab_stats; + // GC allocation statistics policy for tenured objects. + G1EvacStats _old_evac_stats; // It specifies whether we should attempt to expand the heap after a // region allocation failure. If heap expansion fails we set this to @@ -581,14 +584,14 @@ // Process any reference objects discovered during // an incremental evacuation pause. - void process_discovered_references(); + void process_discovered_references(G1ParScanThreadState** per_thread_states); // Enqueue any remaining discovered references // after processing. - void enqueue_discovered_references(); + void enqueue_discovered_references(G1ParScanThreadState** per_thread_states); public: - FlexibleWorkGang* workers() const { return _workers; } + WorkGang* workers() const { return _workers; } G1Allocator* allocator() { return _allocator; @@ -606,7 +609,7 @@ bool expand(size_t expand_bytes); // Returns the PLAB statistics for a given destination. - inline PLABStats* alloc_buffer_stats(InCSetState dest); + inline G1EvacStats* alloc_buffer_stats(InCSetState dest); // Determines PLAB size for a given destination. inline size_t desired_plab_sz(InCSetState dest); @@ -680,6 +683,9 @@ // Allocates a new heap region instance. HeapRegion* new_heap_region(uint hrs_index, MemRegion mr); + // Allocates a new per thread par scan state for the given thread id. + G1ParScanThreadState* new_par_scan_state(uint worker_id); + // Allocate the highest free region in the reserved heap. This will commit // regions as necessary. HeapRegion* alloc_highest_free_region(); @@ -751,6 +757,12 @@ // alloc_archive_regions, and after class loading has occurred. void fill_archive_regions(MemRegion* range, size_t count); + // For each of the specified MemRegions, uncommit the containing G1 regions + // which had been allocated by alloc_archive_regions. This should be called + // rather than fill_archive_regions at JVM init time if the archive file + // mapping failed, with the same non-overlapping and sorted MemRegion array. + void dealloc_archive_regions(MemRegion* range, size_t count); + protected: // Shrink the garbage-first heap by at most the given size (in bytes!). @@ -789,6 +801,20 @@ // Actually do the work of evacuating the collection set. void evacuate_collection_set(EvacuationInfo& evacuation_info); + // Print the header for the per-thread termination statistics. + static void print_termination_stats_hdr(outputStream* const st); + // Print actual per-thread termination statistics. + void print_termination_stats(outputStream* const st, + uint worker_id, + double elapsed_ms, + double strong_roots_ms, + double term_ms, + size_t term_attempts, + size_t alloc_buffer_waste, + size_t undo_waste) const; + // Update object copying statistics. + void record_obj_copy_mem_stats(); + // The g1 remembered set of the heap. G1RemSet* _g1_rem_set; @@ -1195,9 +1221,7 @@ // Determine whether the given region is one that we are using as an // old GC alloc region. - bool is_old_gc_alloc_region(HeapRegion* hr) { - return _allocator->is_retained_old_region(hr); - } + bool is_old_gc_alloc_region(HeapRegion* hr); // Perform a collection of the heap; intended for use in implementing // "System.gc". This probably implies as full a collection as the @@ -1566,6 +1590,7 @@ const VerifyOption vo) const; G1HeapSummary create_g1_heap_summary(); + G1EvacSummary create_g1_evac_summary(G1EvacStats* stats); // Printing
--- a/src/share/vm/gc/g1/g1CollectedHeap.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectedHeap.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -35,12 +35,12 @@ #include "gc/shared/taskqueue.hpp" #include "runtime/orderAccess.inline.hpp" -PLABStats* G1CollectedHeap::alloc_buffer_stats(InCSetState dest) { +G1EvacStats* G1CollectedHeap::alloc_buffer_stats(InCSetState dest) { switch (dest.value()) { case InCSetState::Young: - return &_survivor_plab_stats; + return &_survivor_evac_stats; case InCSetState::Old: - return &_old_plab_stats; + return &_old_evac_stats; default: ShouldNotReachHere(); return NULL; // Keep some compilers happy
--- a/src/share/vm/gc/g1/g1CollectedHeap_ext.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectedHeap_ext.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -24,6 +24,7 @@ #include "precompiled.hpp" #include "gc/g1/g1CollectedHeap.hpp" +#include "gc/g1/g1ParScanThreadState.hpp" #include "gc/g1/heapRegion.inline.hpp" bool G1CollectedHeap::copy_allocation_context_stats(const jint* contexts, @@ -37,3 +38,7 @@ MemRegion mr) { return new HeapRegion(hrs_index, bot_shared(), mr); } + +G1ParScanThreadState* G1CollectedHeap::new_par_scan_state(uint worker_id) { + return new G1ParScanThreadState(this, worker_id); +}
--- a/src/share/vm/gc/g1/g1CollectorPolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectorPolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -181,15 +181,6 @@ G1ErgoVerbose::set_enabled(false); } - // Verify PLAB sizes - const size_t region_size = HeapRegion::GrainWords; - if (YoungPLABSize > region_size || OldPLABSize > region_size) { - char buffer[128]; - jio_snprintf(buffer, sizeof(buffer), "%sPLABSize should be at most " SIZE_FORMAT, - OldPLABSize > region_size ? "Old" : "Young", region_size); - vm_exit_during_initialization(buffer); - } - _recent_prev_end_times_for_all_gcs_sec->add(os::elapsedTime()); _prev_collection_pause_end_ms = os::elapsedTime() * 1000.0; @@ -932,7 +923,7 @@ // Anything below that is considered to be zero #define MIN_TIMER_GRANULARITY 0.0000001 -void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms, EvacuationInfo& evacuation_info) { +void G1CollectorPolicy::record_collection_pause_end(double pause_time_ms) { double end_time_sec = os::elapsedTime(); assert(_cur_collection_pause_used_regions_at_start >= cset_region_length(), "otherwise, the subtraction below does not make sense"); @@ -964,9 +955,6 @@ _mmu_tracker->add_pause(end_time_sec - pause_time_ms/1000.0, end_time_sec, _g1->gc_tracer_stw()->gc_id()); - evacuation_info.set_collectionset_used_before(_collection_set_bytes_used_before); - evacuation_info.set_bytes_copied(_bytes_copied_during_gc); - if (update_stats) { _trace_young_gen_time_data.record_end_collection(pause_time_ms, phase_times()); // this is where we update the allocation rate of the application @@ -1582,7 +1570,7 @@ G1CollectorPolicy::record_concurrent_mark_cleanup_end() { _collectionSetChooser->clear(); - FlexibleWorkGang* workers = _g1->workers(); + WorkGang* workers = _g1->workers(); uint n_workers = workers->active_workers(); uint n_regions = _g1->num_regions(); @@ -1883,7 +1871,7 @@ } -void G1CollectorPolicy::finalize_cset(double target_pause_time_ms, EvacuationInfo& evacuation_info) { +void G1CollectorPolicy::finalize_cset(double target_pause_time_ms) { double young_start_time_sec = os::elapsedTime(); YoungList* young_list = _g1->young_list(); @@ -2093,7 +2081,6 @@ double non_young_end_time_sec = os::elapsedTime(); phase_times()->record_non_young_cset_choice_time_ms((non_young_end_time_sec - non_young_start_time_sec) * 1000.0); - evacuation_info.set_collectionset_regions(cset_region_length()); } void TraceYoungGenTimeData::record_start_collection(double time_to_stop_the_world_ms) {
--- a/src/share/vm/gc/g1/g1CollectorPolicy.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1CollectorPolicy.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,8 +26,8 @@ #define SHARE_VM_GC_G1_G1COLLECTORPOLICY_HPP #include "gc/g1/collectionSetChooser.hpp" -#include "gc/g1/g1Allocator.hpp" #include "gc/g1/g1CollectorState.hpp" +#include "gc/g1/g1InCSetState.hpp" #include "gc/g1/g1MMUTracker.hpp" #include "gc/shared/collectorPolicy.hpp" @@ -604,10 +604,6 @@ virtual G1CollectorPolicy* as_g1_policy() { return this; } - virtual CollectorPolicy::Name kind() { - return CollectorPolicy::G1CollectorPolicyKind; - } - G1CollectorState* collector_state(); G1GCPhaseTimes* phase_times() const { return _phase_times; } @@ -634,13 +630,11 @@ virtual HeapWord* satisfy_failed_allocation(size_t size, bool is_tlab); - BarrierSet::Name barrier_set_name() { return BarrierSet::G1SATBCTLogging; } - bool need_to_start_conc_mark(const char* source, size_t alloc_word_size = 0); // Record the start and end of an evacuation pause. void record_collection_pause_start(double start_time_sec); - void record_collection_pause_end(double pause_time_ms, EvacuationInfo& evacuation_info); + void record_collection_pause_end(double pause_time_ms); // Record the start and end of a full collection. void record_full_collection_start(); @@ -682,6 +676,10 @@ return _bytes_copied_during_gc; } + size_t collection_set_bytes_used_before() const { + return _collection_set_bytes_used_before; + } + // Determine whether there are candidate regions so that the // next GC should be mixed. The two action strings are used // in the ergo output when the method returns true or false. @@ -691,7 +689,7 @@ // Choose a new collection set. Marks the chosen regions as being // "in_collection_set", and links them together. The head and number of // the collection set are available via access methods. - void finalize_cset(double target_pause_time_ms, EvacuationInfo& evacuation_info); + void finalize_cset(double target_pause_time_ms); // The head of the list (via "next_in_collection_set()") representing the // current collection set.
--- a/src/share/vm/gc/g1/g1CollectorPolicy_ext.hpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,32 +0,0 @@ -/* - * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_GC_G1_G1COLLECTORPOLICY_EXT_HPP -#define SHARE_VM_GC_G1_G1COLLECTORPOLICY_EXT_HPP - -#include "gc/g1/g1CollectorPolicy.hpp" - -class G1CollectorPolicyExt : public G1CollectorPolicy { }; - -#endif // SHARE_VM_GC_G1_G1COLLECTORPOLICY_EXT_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/g1/g1EvacStats.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "gc/g1/g1EvacStats.hpp" +#include "gc/shared/gcId.hpp" +#include "trace/tracing.hpp" + +void G1EvacStats::adjust_desired_plab_sz() { + if (PrintPLAB) { + gclog_or_tty->print(" (allocated = " SIZE_FORMAT " wasted = " SIZE_FORMAT " " + "unused = " SIZE_FORMAT " used = " SIZE_FORMAT " " + "undo_waste = " SIZE_FORMAT " region_end_waste = " SIZE_FORMAT " " + "regions filled = %u direct_allocated = " SIZE_FORMAT " " + "failure_used = " SIZE_FORMAT " failure_waste = " SIZE_FORMAT ") ", + _allocated, _wasted, _unused, used(), _undo_wasted, _region_end_waste, + _regions_filled, _direct_allocated, _failure_used, _failure_waste); + } + + if (ResizePLAB) { + + assert(is_object_aligned(max_size()) && min_size() <= max_size(), + "PLAB clipping computation may be incorrect"); + + if (_allocated == 0) { + assert((_unused == 0), + err_msg("Inconsistency in PLAB stats: " + "_allocated: "SIZE_FORMAT", " + "_wasted: "SIZE_FORMAT", " + "_region_end_waste: "SIZE_FORMAT", " + "_unused: "SIZE_FORMAT", " + "_used : "SIZE_FORMAT, + _allocated, _wasted, _region_end_waste, _unused, used())); + _allocated = 1; + } + // The size of the PLAB caps the amount of space that can be wasted at the + // end of the collection. In the worst case the last PLAB could be completely + // empty. + // This allows us to calculate the new PLAB size to achieve the + // TargetPLABWastePct given the latest memory usage and that the last buffer + // will be G1LastPLABAverageOccupancy full. + // + // E.g. assume that if in the current GC 100 words were allocated and a + // TargetPLABWastePct of 10 had been set. + // + // So we could waste up to 10 words to meet that percentage. Given that we + // also assume that that buffer is typically half-full, the new desired PLAB + // size is set to 20 words. + // + // The amount of allocation performed should be independent of the number of + // threads, so should the maximum waste we can spend in total. So if + // we used n threads to allocate, each of them can spend maximum waste/n words in + // a first rough approximation. The number of threads only comes into play later + // when actually retrieving the actual desired PLAB size. + // + // After calculating this optimal PLAB size the algorithm applies the usual + // exponential decaying average over this value to guess the next PLAB size. + // + // We account region end waste fully to PLAB allocation (in the calculation of + // what we consider as "used_for_waste_calculation" below). This is not + // completely fair, but is a conservative assumption because PLABs may be sized + // flexibly while we cannot adjust inline allocations. + // Allocation during GC will try to minimize region end waste so this impact + // should be minimal. + // + // We need to cover overflow when calculating the amount of space actually used + // by objects in PLABs when subtracting the region end waste. + // Region end waste may be higher than actual allocation. This may occur if many + // threads do not allocate anything but a few rather large objects. In this + // degenerate case the PLAB size would simply quickly tend to minimum PLAB size, + // which is an okay reaction. + size_t const used_for_waste_calculation = used() > _region_end_waste ? used() - _region_end_waste : 0; + + size_t const total_waste_allowed = used_for_waste_calculation * TargetPLABWastePct; + size_t const cur_plab_sz = (double)total_waste_allowed / G1LastPLABAverageOccupancy; + // Take historical weighted average + _filter.sample(cur_plab_sz); + // Clip from above and below, and align to object boundary + size_t plab_sz; + plab_sz = MAX2(min_size(), (size_t)_filter.average()); + plab_sz = MIN2(max_size(), plab_sz); + plab_sz = align_object_size(plab_sz); + // Latch the result + _desired_net_plab_sz = plab_sz; + if (PrintPLAB) { + gclog_or_tty->print_cr(" (plab_sz = " SIZE_FORMAT " desired_plab_sz = " SIZE_FORMAT ") ", cur_plab_sz, plab_sz); + } + } + // Clear accumulators for next round. + reset(); +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/g1/g1EvacStats.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,93 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_VM_gc_G1_G1EVACSTATS_HPP +#define SHARE_VM_gc_G1_G1EVACSTATS_HPP + +#include "gc/shared/plab.hpp" +#include "runtime/atomic.hpp" + +// Records various memory allocation statistics gathered during evacuation. +class G1EvacStats : public PLABStats { + private: + size_t _region_end_waste; // Number of words wasted due to skipping to the next region. + uint _regions_filled; // Number of regions filled completely. + size_t _direct_allocated; // Number of words allocated directly into the regions. + + // Number of words in live objects remaining in regions that ultimately suffered an + // evacuation failure. This is used in the regions when the regions are made old regions. + size_t _failure_used; + // Number of words wasted in regions which failed evacuation. This is the sum of space + // for objects successfully copied out of the regions (now dead space) plus waste at the + // end of regions. + size_t _failure_waste; + + virtual void reset() { + PLABStats::reset(); + _region_end_waste = 0; + _regions_filled = 0; + _direct_allocated = 0; + _failure_used = 0; + _failure_waste = 0; + } + + public: + G1EvacStats(size_t desired_plab_sz_, unsigned wt) : PLABStats(desired_plab_sz_, wt), + _region_end_waste(0), _regions_filled(0), _direct_allocated(0), + _failure_used(0), _failure_waste(0) { + } + + virtual void adjust_desired_plab_sz(); + + size_t allocated() const { return _allocated; } + size_t wasted() const { return _wasted; } + size_t unused() const { return _unused; } + size_t used() const { return allocated() - (wasted() + unused()); } + size_t undo_wasted() const { return _undo_wasted; } + + uint regions_filled() const { return _regions_filled; } + size_t region_end_waste() const { return _region_end_waste; } + size_t direct_allocated() const { return _direct_allocated; } + + // Amount of space in heapwords used in the failing regions when an evacuation failure happens. + size_t failure_used() const { return _failure_used; } + // Amount of space in heapwords wasted (unused) in the failing regions when an evacuation failure happens. + size_t failure_waste() const { return _failure_waste; } + + void add_direct_allocated(size_t value) { + Atomic::add_ptr(value, &_direct_allocated); + } + + void add_region_end_waste(size_t value) { + Atomic::add_ptr(value, &_region_end_waste); + Atomic::add_ptr(1, &_regions_filled); + } + + void add_failure_used_and_waste(size_t used, size_t waste) { + Atomic::add_ptr(used, &_failure_used); + Atomic::add_ptr(waste, &_failure_waste); + } +}; + +#endif // SHARE_VM_gc_G1_G1EVACSTATS_HPP
--- a/src/share/vm/gc/g1/g1MarkSweep.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1MarkSweep.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -74,7 +74,7 @@ assert(rp != NULL, "should be non-NULL"); assert(rp == G1CollectedHeap::heap()->ref_processor_stw(), "Precondition"); - GenMarkSweep::_ref_processor = rp; + GenMarkSweep::set_ref_processor(rp); rp->setup_policy(clear_all_softrefs); // When collecting the permanent generation Method*s may be moving, @@ -108,7 +108,7 @@ JvmtiExport::gc_epilogue(); // refs processing: clean slate - GenMarkSweep::_ref_processor = NULL; + GenMarkSweep::set_ref_processor(NULL); } @@ -310,9 +310,9 @@ HeapRegion::GrainBytes); } -void G1MarkSweep::mark_range_archive(MemRegion range) { +void G1MarkSweep::set_range_archive(MemRegion range, bool is_archive) { assert(_archive_check_enabled, "archive range check not enabled"); - _archive_region_map.set_by_address(range, true); + _archive_region_map.set_by_address(range, is_archive); } bool G1MarkSweep::in_archive_range(oop object) {
--- a/src/share/vm/gc/g1/g1MarkSweep.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1MarkSweep.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -58,8 +58,8 @@ // Create the _archive_region_map which is used to identify archive objects. static void enable_archive_object_check(); - // Mark the regions containing the specified address range as archive regions. - static void mark_range_archive(MemRegion range); + // Set the regions containing the specified address range as archive/non-archive. + static void set_range_archive(MemRegion range, bool is_archive); // Check if an object is in an archive region using the _archive_region_map. static bool in_archive_range(oop object);
--- a/src/share/vm/gc/g1/g1OopClosures.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1OopClosures.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,7 +32,11 @@ G1ParCopyHelper::G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : G1ParClosureSuper(g1, par_scan_state), _scanned_klass(NULL), - _cm(_g1->concurrent_mark()) {} + _cm(_g1->concurrent_mark()) { } + +G1ParCopyHelper::G1ParCopyHelper(G1CollectedHeap* g1) : + G1ParClosureSuper(g1), _scanned_klass(NULL), + _cm(_g1->concurrent_mark()) { } G1ParClosureSuper::G1ParClosureSuper(G1CollectedHeap* g1) : _g1(g1), _par_scan_state(NULL), _worker_id(UINT_MAX) { }
--- a/src/share/vm/gc/g1/g1OopClosures.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1OopClosures.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -76,15 +76,13 @@ class G1ParScanClosure : public G1ParClosureSuper { public: - G1ParScanClosure(G1CollectedHeap* g1, ReferenceProcessor* rp) : - G1ParClosureSuper(g1) { - assert(_ref_processor == NULL, "sanity"); - _ref_processor = rp; - } + G1ParScanClosure(G1CollectedHeap* g1) : G1ParClosureSuper(g1) { } template <class T> void do_oop_nv(T* p); virtual void do_oop(oop* p) { do_oop_nv(p); } virtual void do_oop(narrowOop* p) { do_oop_nv(p); } + + void set_ref_processor(ReferenceProcessor* ref_processor) { _ref_processor = ref_processor; } }; // Add back base class for metadata @@ -104,6 +102,7 @@ void mark_forwarded_object(oop from_obj, oop to_obj); public: G1ParCopyHelper(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state); + G1ParCopyHelper(G1CollectedHeap* g1); void set_scanned_klass(Klass* k) { _scanned_klass = k; } template <class T> void do_klass_barrier(T* p, oop new_obj); @@ -126,19 +125,21 @@ template <class T> void do_oop_work(T* p); public: - G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state, - ReferenceProcessor* rp) : + G1ParCopyClosure(G1CollectedHeap* g1, G1ParScanThreadState* par_scan_state) : G1ParCopyHelper(g1, par_scan_state) { assert(_ref_processor == NULL, "sanity"); } + G1ParCopyClosure(G1CollectedHeap* g1) : G1ParCopyHelper(g1) { + assert(_ref_processor == NULL, "sanity"); + } + template <class T> void do_oop_nv(T* p) { do_oop_work(p); } virtual void do_oop(oop* p) { do_oop_nv(p); } virtual void do_oop(narrowOop* p) { do_oop_nv(p); } G1CollectedHeap* g1() { return _g1; }; G1ParScanThreadState* pss() { return _par_scan_state; } - ReferenceProcessor* rp() { return _ref_processor; }; }; typedef G1ParCopyClosure<G1BarrierNone, G1MarkNone> G1ParScanExtRootClosure;
--- a/src/share/vm/gc/g1/g1ParScanThreadState.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1ParScanThreadState.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -23,6 +23,7 @@ */ #include "precompiled.hpp" +#include "gc/g1/g1Allocator.inline.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1OopClosures.inline.hpp" #include "gc/g1/g1ParScanThreadState.inline.hpp" @@ -31,17 +32,19 @@ #include "oops/oop.inline.hpp" #include "runtime/prefetch.inline.hpp" -G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint worker_id, ReferenceProcessor* rp) +G1ParScanThreadState::G1ParScanThreadState(G1CollectedHeap* g1h, uint worker_id) : _g1h(g1h), _refs(g1h->task_queue(worker_id)), _dcq(&g1h->dirty_card_queue_set()), _ct_bs(g1h->g1_barrier_set()), _g1_rem(g1h->g1_rem_set()), - _hash_seed(17), _worker_id(worker_id), - _term_attempts(0), + _hash_seed(17), + _worker_id(worker_id), _tenuring_threshold(g1h->g1_policy()->tenuring_threshold()), - _age_table(false), _scanner(g1h, rp), - _strong_roots_time(0), _term_time(0) { + _age_table(false), + _scanner(g1h), + _old_gen_is_full(false) +{ _scanner.set_par_scan_thread_state(this); // we allocate G1YoungSurvRateNumRegions plus one entries, since // we "sacrifice" entry 0 to keep track of surviving bytes for @@ -66,38 +69,20 @@ // need to be moved to the next space. _dest[InCSetState::Young] = InCSetState::Old; _dest[InCSetState::Old] = InCSetState::Old; - - _start = os::elapsedTime(); } G1ParScanThreadState::~G1ParScanThreadState() { - _plab_allocator->retire_alloc_buffers(); + // Update allocation statistics. + _plab_allocator->flush_and_retire_stats(); delete _plab_allocator; + _g1h->g1_policy()->record_thread_age_table(&_age_table); + // Update heap statistics. + _g1h->update_surviving_young_words(_surviving_young_words); FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base); } -void G1ParScanThreadState::print_termination_stats_hdr(outputStream* const st) { - st->print_raw_cr("GC Termination Stats"); - st->print_raw_cr(" elapsed --strong roots-- -------termination------- ------waste (KiB)------"); - st->print_raw_cr("thr ms ms % ms % attempts total alloc undo"); - st->print_raw_cr("--- --------- --------- ------ --------- ------ -------- ------- ------- -------"); -} - -void G1ParScanThreadState::print_termination_stats(outputStream* const st) const { - const double elapsed_ms = elapsed_time() * 1000.0; - const double s_roots_ms = strong_roots_time() * 1000.0; - const double term_ms = term_time() * 1000.0; - size_t alloc_buffer_waste = 0; - size_t undo_waste = 0; - _plab_allocator->waste(alloc_buffer_waste, undo_waste); - st->print_cr("%3u %9.2f %9.2f %6.2f " - "%9.2f %6.2f " SIZE_FORMAT_W(8) " " - SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7) " " SIZE_FORMAT_W(7), - _worker_id, elapsed_ms, s_roots_ms, s_roots_ms * 100 / elapsed_ms, - term_ms, term_ms * 100 / elapsed_ms, term_attempts(), - (alloc_buffer_waste + undo_waste) * HeapWordSize / K, - alloc_buffer_waste * HeapWordSize / K, - undo_waste * HeapWordSize / K); +void G1ParScanThreadState::waste(size_t& wasted, size_t& undo_wasted) { + _plab_allocator->waste(wasted, undo_wasted); } #ifdef ASSERT @@ -152,26 +137,38 @@ HeapWord* G1ParScanThreadState::allocate_in_next_plab(InCSetState const state, InCSetState* dest, size_t word_sz, - AllocationContext_t const context) { + AllocationContext_t const context, + bool previous_plab_refill_failed) { assert(state.is_in_cset_or_humongous(), err_msg("Unexpected state: " CSETSTATE_FORMAT, state.value())); assert(dest->is_in_cset_or_humongous(), err_msg("Unexpected dest: " CSETSTATE_FORMAT, dest->value())); // Right now we only have two types of regions (young / old) so // let's keep the logic here simple. We can generalize it when necessary. if (dest->is_young()) { + bool plab_refill_in_old_failed = false; HeapWord* const obj_ptr = _plab_allocator->allocate(InCSetState::Old, word_sz, - context); - if (obj_ptr == NULL) { - return NULL; - } + context, + &plab_refill_in_old_failed); // Make sure that we won't attempt to copy any other objects out // of a survivor region (given that apparently we cannot allocate - // any new ones) to avoid coming into this slow path. - _tenuring_threshold = 0; - dest->set_old(); + // any new ones) to avoid coming into this slow path again and again. + // Only consider failed PLAB refill here: failed inline allocations are + // typically large, so not indicative of remaining space. + if (previous_plab_refill_failed) { + _tenuring_threshold = 0; + } + + if (obj_ptr != NULL) { + dest->set_old(); + } else { + // We just failed to allocate in old gen. The same idea as explained above + // for making survivor gen unavailable for allocation applies for old gen. + _old_gen_is_full = plab_refill_in_old_failed; + } return obj_ptr; } else { + _old_gen_is_full = previous_plab_refill_failed; assert(dest->is_old(), err_msg("Unexpected dest: " CSETSTATE_FORMAT, dest->value())); // no other space to try. return NULL; @@ -189,6 +186,21 @@ return dest(state); } +void G1ParScanThreadState::report_promotion_event(InCSetState const dest_state, + oop const old, size_t word_sz, uint age, + HeapWord * const obj_ptr, + const AllocationContext_t context) const { + G1PLAB* alloc_buf = _plab_allocator->alloc_buffer(dest_state, context); + if (alloc_buf->contains(obj_ptr)) { + _g1h->_gc_tracer_stw->report_promotion_in_new_plab_event(old->klass(), word_sz, age, + dest_state.value() == InCSetState::Old, + alloc_buf->word_sz()); + } else { + _g1h->_gc_tracer_stw->report_promotion_outside_plab_event(old->klass(), word_sz, age, + dest_state.value() == InCSetState::Old); + } +} + oop G1ParScanThreadState::copy_to_survivor_space(InCSetState const state, oop const old, markOop const old_mark) { @@ -202,20 +214,30 @@ uint age = 0; InCSetState dest_state = next_state(state, old_mark, age); + // The second clause is to prevent premature evacuation failure in case there + // is still space in survivor, but old gen is full. + if (_old_gen_is_full && dest_state.is_old()) { + return handle_evacuation_failure_par(old, old_mark); + } HeapWord* obj_ptr = _plab_allocator->plab_allocate(dest_state, word_sz, context); // PLAB allocations should succeed most of the time, so we'll // normally check against NULL once and that's it. if (obj_ptr == NULL) { - obj_ptr = _plab_allocator->allocate_direct_or_new_plab(dest_state, word_sz, context); + bool plab_refill_failed = false; + obj_ptr = _plab_allocator->allocate_direct_or_new_plab(dest_state, word_sz, context, &plab_refill_failed); if (obj_ptr == NULL) { - obj_ptr = allocate_in_next_plab(state, &dest_state, word_sz, context); + obj_ptr = allocate_in_next_plab(state, &dest_state, word_sz, context, plab_refill_failed); if (obj_ptr == NULL) { // This will either forward-to-self, or detect that someone else has // installed a forwarding pointer. return handle_evacuation_failure_par(old, old_mark); } } + if (_g1h->_gc_tracer_stw->should_report_promotion_events()) { + // The events are checked individually as part of the actual commit + report_promotion_event(dest_state, old, word_sz, age, obj_ptr, context); + } } assert(obj_ptr != NULL, "when we get here, allocation should have succeeded"); @@ -253,7 +275,7 @@ } else { obj->set_mark(old_mark->set_age(age)); } - age_table()->add(age, word_sz); + _age_table.add(age, word_sz); } else { obj->set_mark(old_mark); } @@ -271,8 +293,7 @@ obj); } - size_t* const surv_young_words = surviving_young_words(); - surv_young_words[young_index] += word_sz; + _surviving_young_words[young_index] += word_sz; if (obj->is_objArray() && arrayOop(obj)->length() >= ParGCArrayScanChunk) { // We keep track of the next start index in the length field of
--- a/src/share/vm/gc/g1/g1ParScanThreadState.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1ParScanThreadState.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -35,16 +35,17 @@ #include "memory/allocation.hpp" #include "oops/oop.hpp" +class G1PLABAllocator; class HeapRegion; class outputStream; -class G1ParScanThreadState : public StackObj { +class G1ParScanThreadState : public CHeapObj<mtGC> { private: G1CollectedHeap* _g1h; RefToScanQueue* _refs; DirtyCardQueue _dcq; G1SATBCardTableModRefBS* _ct_bs; - G1RemSet* _g1_rem; + G1RemSet* _g1_rem; G1PLABAllocator* _plab_allocator; @@ -57,20 +58,16 @@ int _hash_seed; uint _worker_id; - size_t _term_attempts; - - double _start; - double _start_strong_roots; - double _strong_roots_time; - double _start_term; - double _term_time; - // Map from young-age-index (0 == not young, 1 is youngest) to // surviving words. base is what we get back from the malloc call size_t* _surviving_young_words_base; // this points into the array, as we use the first few entries for padding size_t* _surviving_young_words; + // Indicates whether in the last generation (old) there is no more space + // available for allocation. + bool _old_gen_is_full; + #define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t)) DirtyCardQueue& dirty_card_queue() { return _dcq; } @@ -85,10 +82,10 @@ } public: - G1ParScanThreadState(G1CollectedHeap* g1h, uint worker_id, ReferenceProcessor* rp); + G1ParScanThreadState(G1CollectedHeap* g1h, uint worker_id); ~G1ParScanThreadState(); - ageTable* age_table() { return &_age_table; } + void set_ref_processor(ReferenceProcessor* rp) { _scanner.set_ref_processor(rp); } #ifdef ASSERT bool queue_is_empty() const { return _refs->is_empty(); } @@ -114,40 +111,14 @@ uint worker_id() { return _worker_id; } - size_t term_attempts() const { return _term_attempts; } - void note_term_attempt() { _term_attempts++; } - - void start_strong_roots() { - _start_strong_roots = os::elapsedTime(); - } - void end_strong_roots() { - _strong_roots_time += (os::elapsedTime() - _start_strong_roots); - } - double strong_roots_time() const { return _strong_roots_time; } - - void start_term_time() { - note_term_attempt(); - _start_term = os::elapsedTime(); - } - void end_term_time() { - _term_time += (os::elapsedTime() - _start_term); - } - double term_time() const { return _term_time; } - - double elapsed_time() const { - return os::elapsedTime() - _start; - } - - // Print the header for the per-thread termination statistics. - static void print_termination_stats_hdr(outputStream* const st = gclog_or_tty); - - // Print actual per-thread termination statistics. - void print_termination_stats(outputStream* const st = gclog_or_tty) const; + // Returns the current amount of waste due to alignment or not being able to fit + // objects within LABs and the undo waste. + virtual void waste(size_t& wasted, size_t& undo_wasted); size_t* surviving_young_words() { - // We add on to hide entry 0 which accumulates surviving words for + // We add one to hide entry 0 which accumulates surviving words for // age -1 regions (i.e. non-young ones) - return _surviving_young_words; + return _surviving_young_words + 1; } private: @@ -190,14 +161,22 @@ // Tries to allocate word_sz in the PLAB of the next "generation" after trying to // allocate into dest. State is the original (source) cset state for the object - // that is allocated for. + // that is allocated for. Previous_plab_refill_failed indicates whether previously + // a PLAB refill into "state" failed. // Returns a non-NULL pointer if successful, and updates dest if required. + // Also determines whether we should continue to try to allocate into the various + // generations or just end trying to allocate. HeapWord* allocate_in_next_plab(InCSetState const state, InCSetState* dest, size_t word_sz, - AllocationContext_t const context); + AllocationContext_t const context, + bool previous_plab_refill_failed); inline InCSetState next_state(InCSetState const state, markOop const m, uint& age); + + void report_promotion_event(InCSetState const dest_state, + oop const old, size_t word_sz, uint age, + HeapWord * const obj_ptr, const AllocationContext_t context) const; public: oop copy_to_survivor_space(InCSetState const state, oop const obj, markOop const old_mark);
--- a/src/share/vm/gc/g1/g1RemSet.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1RemSet.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,6 +26,7 @@ #include "gc/g1/concurrentG1Refine.hpp" #include "gc/g1/concurrentG1RefineThread.hpp" #include "gc/g1/g1BlockOffsetTable.inline.hpp" +#include "gc/g1/g1CodeBlobClosure.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1GCPhaseTimes.hpp" @@ -228,12 +229,15 @@ }; void G1RemSet::scanRS(G1ParPushHeapRSClosure* oc, - CodeBlobClosure* code_root_cl, + OopClosure* non_heap_roots, uint worker_i) { double rs_time_start = os::elapsedTime(); + + G1CodeBlobClosure code_root_cl(non_heap_roots); + HeapRegion *startRegion = _g1->start_cset_region_for_worker(worker_i); - ScanRSClosure scanRScl(oc, code_root_cl, worker_i); + ScanRSClosure scanRScl(oc, &code_root_cl, worker_i); _g1->collection_set_iterate_from(startRegion, &scanRScl); scanRScl.set_try_claimed(); @@ -295,7 +299,7 @@ } void G1RemSet::oops_into_collection_set_do(G1ParPushHeapRSClosure* oc, - CodeBlobClosure* code_root_cl, + OopClosure* non_heap_roots, uint worker_i) { #if CARD_REPEAT_HISTO ct_freq_update_histo_and_reset(); @@ -318,7 +322,7 @@ DirtyCardQueue into_cset_dcq(&_g1->into_cset_dirty_card_queue_set()); updateRS(&into_cset_dcq, worker_i); - scanRS(oc, code_root_cl, worker_i); + scanRS(oc, non_heap_roots, worker_i); // We now clear the cached values of _cset_rs_update_cl for this worker _cset_rs_update_cl[worker_i] = NULL;
--- a/src/share/vm/gc/g1/g1RemSet.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1RemSet.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -85,7 +85,7 @@ // invoked "blk->set_region" to set the "from" region correctly // beforehand.) // - // Invoke code_root_cl->do_code_blob on the unmarked nmethods + // Apply non_heap_roots on the oops of the unmarked nmethods // on the strong code roots list for each region in the // collection set. // @@ -95,7 +95,7 @@ // the "i" passed to the calling thread's work(i) function. // In the sequential case this param will be ignored. void oops_into_collection_set_do(G1ParPushHeapRSClosure* blk, - CodeBlobClosure* code_root_cl, + OopClosure* non_heap_roots, uint worker_i); // Prepare for and cleanup after an oops_into_collection_set_do @@ -107,7 +107,7 @@ void cleanup_after_oops_into_collection_set_do(); void scanRS(G1ParPushHeapRSClosure* oc, - CodeBlobClosure* code_root_cl, + OopClosure* non_heap_roots, uint worker_i); void updateRS(DirtyCardQueue* into_cset_dcq, uint worker_i);
--- a/src/share/vm/gc/g1/g1RootProcessor.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1RootProcessor.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,6 +28,7 @@ #include "classfile/systemDictionary.hpp" #include "code/codeCache.hpp" #include "gc/g1/bufferingOopClosure.hpp" +#include "gc/g1/g1CodeBlobClosure.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/g1CollectorPolicy.hpp" #include "gc/g1/g1CollectorState.hpp" @@ -40,57 +41,6 @@ #include "runtime/mutex.hpp" #include "services/management.hpp" -class G1CodeBlobClosure : public CodeBlobClosure { - class HeapRegionGatheringOopClosure : public OopClosure { - G1CollectedHeap* _g1h; - OopClosure* _work; - nmethod* _nm; - - template <typename T> - void do_oop_work(T* p) { - _work->do_oop(p); - T oop_or_narrowoop = oopDesc::load_heap_oop(p); - if (!oopDesc::is_null(oop_or_narrowoop)) { - oop o = oopDesc::decode_heap_oop_not_null(oop_or_narrowoop); - HeapRegion* hr = _g1h->heap_region_containing_raw(o); - assert(!_g1h->obj_in_cs(o) || hr->rem_set()->strong_code_roots_list_contains(_nm), "if o still in CS then evacuation failed and nm must already be in the remset"); - hr->add_strong_code_root(_nm); - } - } - - public: - HeapRegionGatheringOopClosure(OopClosure* oc) : _g1h(G1CollectedHeap::heap()), _work(oc), _nm(NULL) {} - - void do_oop(oop* o) { - do_oop_work(o); - } - - void do_oop(narrowOop* o) { - do_oop_work(o); - } - - void set_nm(nmethod* nm) { - _nm = nm; - } - }; - - HeapRegionGatheringOopClosure _oc; -public: - G1CodeBlobClosure(OopClosure* oc) : _oc(oc) {} - - void do_code_blob(CodeBlob* cb) { - nmethod* nm = cb->as_nmethod_or_null(); - if (nm != NULL) { - if (!nm->test_set_oops_do_mark()) { - _oc.set_nm(nm); - nm->oops_do(&_oc); - nm->fix_oop_relocations(); - } - } - } -}; - - void G1RootProcessor::worker_has_discovered_all_strong_classes() { assert(ClassUnloadingWithConcurrentMark, "Currently only needed when doing G1 Class Unloading"); @@ -115,7 +65,7 @@ G1RootProcessor::G1RootProcessor(G1CollectedHeap* g1h, uint n_workers) : _g1h(g1h), - _process_strong_tasks(new SubTasksDone(G1RP_PS_NumElements)), + _process_strong_tasks(G1RP_PS_NumElements), _srs(n_workers), _lock(Mutex::leaf, "G1 Root Scanning barrier lock", false, Monitor::_safepoint_check_never), _n_workers_discovered_strong_classes(0) {} @@ -158,7 +108,7 @@ { // Now the CM ref_processor roots. G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::CMRefRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_refProcessor_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_refProcessor_oops_do)) { // We need to treat the discovered reference lists of the // concurrent mark ref processor as roots and keep entries // (which are added by the marking threads) on them live @@ -201,12 +151,12 @@ // as implicitly live). { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::SATBFiltering, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_filter_satb_buffers) && _g1h->collector_state()->mark_in_progress()) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_filter_satb_buffers) && _g1h->collector_state()->mark_in_progress()) { JavaThread::satb_mark_queue_set().filter_thread_buffers(); } } - _process_strong_tasks->all_tasks_completed(n_workers()); + _process_strong_tasks.all_tasks_completed(n_workers()); } void G1RootProcessor::process_strong_roots(OopClosure* oops, @@ -216,7 +166,7 @@ process_java_roots(oops, clds, clds, NULL, blobs, NULL, 0); process_vm_roots(oops, NULL, NULL, 0); - _process_strong_tasks->all_tasks_completed(n_workers()); + _process_strong_tasks.all_tasks_completed(n_workers()); } void G1RootProcessor::process_all_roots(OopClosure* oops, @@ -226,11 +176,11 @@ process_java_roots(oops, NULL, clds, clds, NULL, NULL, 0); process_vm_roots(oops, oops, NULL, 0); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_CodeCache_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_CodeCache_oops_do)) { CodeCache::blobs_do(blobs); } - _process_strong_tasks->all_tasks_completed(n_workers()); + _process_strong_tasks.all_tasks_completed(n_workers()); } void G1RootProcessor::process_java_roots(OopClosure* strong_roots, @@ -246,7 +196,7 @@ // let the thread process the weak CLDs and nmethods. { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::CLDGRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_ClassLoaderDataGraph_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_ClassLoaderDataGraph_oops_do)) { ClassLoaderDataGraph::roots_cld_do(strong_clds, weak_clds); } } @@ -264,49 +214,49 @@ uint worker_i) { { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::UniverseRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_Universe_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_Universe_oops_do)) { Universe::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::JNIRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_JNIHandles_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_JNIHandles_oops_do)) { JNIHandles::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::ObjectSynchronizerRoots, worker_i); - if (!_process_strong_tasks-> is_task_claimed(G1RP_PS_ObjectSynchronizer_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_ObjectSynchronizer_oops_do)) { ObjectSynchronizer::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::FlatProfilerRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_FlatProfiler_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_FlatProfiler_oops_do)) { FlatProfiler::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::ManagementRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_Management_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_Management_oops_do)) { Management::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::JVMTIRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_jvmti_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_jvmti_oops_do)) { JvmtiExport::oops_do(strong_roots); } } { G1GCParPhaseTimesTracker x(phase_times, G1GCPhaseTimes::SystemDictionaryRoots, worker_i); - if (!_process_strong_tasks->is_task_claimed(G1RP_PS_SystemDictionary_oops_do)) { + if (!_process_strong_tasks.is_task_claimed(G1RP_PS_SystemDictionary_oops_do)) { SystemDictionary::roots_oops_do(strong_roots, weak_roots); } } @@ -321,14 +271,6 @@ } } -void G1RootProcessor::scan_remembered_sets(G1ParPushHeapRSClosure* scan_rs, - OopClosure* scan_non_heap_weak_roots, - uint worker_i) { - G1CodeBlobClosure scavenge_cs_nmethods(scan_non_heap_weak_roots); - - _g1h->g1_rem_set()->oops_into_collection_set_do(scan_rs, &scavenge_cs_nmethods, worker_i); -} - uint G1RootProcessor::n_workers() const { return _srs.n_threads(); }
--- a/src/share/vm/gc/g1/g1RootProcessor.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1RootProcessor.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -45,7 +45,7 @@ // worker thread call the process_roots methods. class G1RootProcessor : public StackObj { G1CollectedHeap* _g1h; - SubTasksDone* _process_strong_tasks; + SubTasksDone _process_strong_tasks; StrongRootsScope _srs; // Used to implement the Thread work barrier. @@ -107,13 +107,6 @@ CLDClosure* clds, CodeBlobClosure* blobs); - // Apply scan_rs to all locations in the union of the remembered sets for all - // regions in the collection set - // (having done "set_region" to indicate the region in which the root resides), - void scan_remembered_sets(G1ParPushHeapRSClosure* scan_rs, - OopClosure* scan_non_heap_weak_roots, - uint worker_i); - // Number of worker threads used by the root processor. uint n_workers() const; };
--- a/src/share/vm/gc/g1/g1SATBCardTableModRefBS.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1SATBCardTableModRefBS.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,6 +27,7 @@ #include "gc/g1/g1SATBCardTableModRefBS.hpp" #include "gc/g1/heapRegion.hpp" #include "gc/g1/satbQueue.hpp" +#include "gc/shared/memset_with_concurrent_readers.hpp" #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/mutexLocker.hpp" @@ -108,15 +109,7 @@ jbyte *const first = byte_for(mr.start()); jbyte *const last = byte_after(mr.last()); - // Below we may use an explicit loop instead of memset() because on - // certain platforms memset() can give concurrent readers phantom zeros. - if (UseMemSetInBOT) { - memset(first, g1_young_gen, last - first); - } else { - for (jbyte* i = first; i < last; i++) { - *i = g1_young_gen; - } - } + memset_with_concurrent_readers(first, g1_young_gen, last - first); } #ifndef PRODUCT @@ -207,7 +200,7 @@ // Otherwise, log it. G1SATBCardTableLoggingModRefBS* g1_bs = barrier_set_cast<G1SATBCardTableLoggingModRefBS>(G1CollectedHeap::heap()->barrier_set()); - g1_bs->write_ref_field_work(field, new_val); + g1_bs->write_ref_field_work(field, new_val, false); } void
--- a/src/share/vm/gc/g1/g1SATBCardTableModRefBS.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1SATBCardTableModRefBS.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -147,6 +147,10 @@ private: G1SATBCardTableLoggingModRefBSChangedListener _listener; DirtyCardQueueSet& _dcqs; + + protected: + virtual void write_ref_field_work(void* field, oop new_val, bool release); + public: static size_t compute_size(size_t mem_region_size_in_words) { size_t number_of_slots = (mem_region_size_in_words / card_size_in_words); @@ -165,8 +169,6 @@ virtual void resize_covered_region(MemRegion new_region) { ShouldNotReachHere(); } - void write_ref_field_work(void* field, oop new_val, bool release = false); - // Can be called from static contexts. static void write_ref_field_static(void* field, oop new_val);
--- a/src/share/vm/gc/g1/g1_globals.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/g1_globals.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -82,6 +82,11 @@ "If true, enable reference discovery during concurrent " \ "marking and reference processing at the end of remark.") \ \ + experimental(double, G1LastPLABAverageOccupancy, 50.0, \ + "The expected average occupancy of the last PLAB in " \ + "percent.") \ + range(0.001, 100.0) \ + \ product(size_t, G1SATBBufferSize, 1*K, \ "Number of entries in an SATB log buffer.") \ \
--- a/src/share/vm/gc/g1/heapRegion.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegion.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -68,7 +68,7 @@ // or it was allocated after marking finished, then we add it. Otherwise // we can safely ignore the object. if (!g1h->is_obj_dead(oop(cur), _hr)) { - oop_size = oop(cur)->oop_iterate(_rs_scan, mr); + oop_size = oop(cur)->oop_iterate_size(_rs_scan, mr); } else { oop_size = _hr->block_size(cur); }
--- a/src/share/vm/gc/g1/heapRegion.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegion.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -109,7 +109,7 @@ // evacuation pauses between two cleanups, which is _highly_ unlikely. class G1OffsetTableContigSpace: public CompactibleSpace { friend class VMStructs; - HeapWord* _top; + HeapWord* volatile _top; HeapWord* volatile _scan_top; protected: G1BlockOffsetArrayContigSpace _offsets; @@ -134,10 +134,18 @@ // Reset the G1OffsetTableContigSpace. virtual void initialize(MemRegion mr, bool clear_space, bool mangle_space); - HeapWord** top_addr() { return &_top; } - // Allocation helpers (return NULL if full). - inline HeapWord* allocate_impl(size_t word_size, HeapWord* end_value); - inline HeapWord* par_allocate_impl(size_t word_size, HeapWord* end_value); + HeapWord* volatile* top_addr() { return &_top; } + // Try to allocate at least min_word_size and up to desired_size from this Space. + // Returns NULL if not possible, otherwise sets actual_word_size to the amount of + // space allocated. + // This version assumes that all allocation requests to this Space are properly + // synchronized. + inline HeapWord* allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size); + // Try to allocate at least min_word_size and up to desired_size from this Space. + // Returns NULL if not possible, otherwise sets actual_word_size to the amount of + // space allocated. + // This version synchronizes with other calls to par_allocate_impl(). + inline HeapWord* par_allocate_impl(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size); public: void reset_after_compaction() { set_top(compaction_top()); } @@ -179,9 +187,14 @@ HeapWord* block_start(const void* p); HeapWord* block_start_const(const void* p) const; - // Add offset table update. + // Allocation (return NULL if full). Assumes the caller has established + // mutually exclusive access to the space. + HeapWord* allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size); + // Allocation (return NULL if full). Enforces mutual exclusion internally. + HeapWord* par_allocate(size_t min_word_size, size_t desired_word_size, size_t* actual_word_size); + virtual HeapWord* allocate(size_t word_size); - HeapWord* par_allocate(size_t word_size); + virtual HeapWord* par_allocate(size_t word_size); HeapWord* saved_mark_word() const { ShouldNotReachHere(); return NULL; } @@ -351,8 +364,9 @@ // Override for scan_and_forward support. void prepare_for_compaction(CompactPoint* cp); - inline HeapWord* par_allocate_no_bot_updates(size_t word_size); + inline HeapWord* par_allocate_no_bot_updates(size_t min_word_size, size_t desired_word_size, size_t* word_size); inline HeapWord* allocate_no_bot_updates(size_t word_size); + inline HeapWord* allocate_no_bot_updates(size_t min_word_size, size_t desired_word_size, size_t* actual_size); // If this region is a member of a HeapRegionManager, the index in that // sequence, otherwise -1.
--- a/src/share/vm/gc/g1/heapRegion.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegion.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,33 +32,39 @@ #include "oops/oop.inline.hpp" #include "runtime/atomic.inline.hpp" -// This version requires locking. -inline HeapWord* G1OffsetTableContigSpace::allocate_impl(size_t size, - HeapWord* const end_value) { +inline HeapWord* G1OffsetTableContigSpace::allocate_impl(size_t min_word_size, + size_t desired_word_size, + size_t* actual_size) { HeapWord* obj = top(); - if (pointer_delta(end_value, obj) >= size) { - HeapWord* new_top = obj + size; + size_t available = pointer_delta(end(), obj); + size_t want_to_allocate = MIN2(available, desired_word_size); + if (want_to_allocate >= min_word_size) { + HeapWord* new_top = obj + want_to_allocate; set_top(new_top); assert(is_aligned(obj) && is_aligned(new_top), "checking alignment"); + *actual_size = want_to_allocate; return obj; } else { return NULL; } } -// This version is lock-free. -inline HeapWord* G1OffsetTableContigSpace::par_allocate_impl(size_t size, - HeapWord* const end_value) { +inline HeapWord* G1OffsetTableContigSpace::par_allocate_impl(size_t min_word_size, + size_t desired_word_size, + size_t* actual_size) { do { HeapWord* obj = top(); - if (pointer_delta(end_value, obj) >= size) { - HeapWord* new_top = obj + size; + size_t available = pointer_delta(end(), obj); + size_t want_to_allocate = MIN2(available, desired_word_size); + if (want_to_allocate >= min_word_size) { + HeapWord* new_top = obj + want_to_allocate; HeapWord* result = (HeapWord*)Atomic::cmpxchg_ptr(new_top, top_addr(), obj); // result can be one of two: // the old top value: the exchange succeeded // otherwise: the new value of the top is returned. if (result == obj) { assert(is_aligned(obj) && is_aligned(new_top), "checking alignment"); + *actual_size = want_to_allocate; return obj; } } else { @@ -67,20 +73,34 @@ } while (true); } -inline HeapWord* G1OffsetTableContigSpace::allocate(size_t size) { - HeapWord* res = allocate_impl(size, end()); +inline HeapWord* G1OffsetTableContigSpace::allocate(size_t min_word_size, + size_t desired_word_size, + size_t* actual_size) { + HeapWord* res = allocate_impl(min_word_size, desired_word_size, actual_size); if (res != NULL) { - _offsets.alloc_block(res, size); + _offsets.alloc_block(res, *actual_size); } return res; } +inline HeapWord* G1OffsetTableContigSpace::allocate(size_t word_size) { + size_t temp; + return allocate(word_size, word_size, &temp); +} + +inline HeapWord* G1OffsetTableContigSpace::par_allocate(size_t word_size) { + size_t temp; + return par_allocate(word_size, word_size, &temp); +} + // Because of the requirement of keeping "_offsets" up to date with the // allocations, we sequentialize these with a lock. Therefore, best if // this is used for larger LAB allocations only. -inline HeapWord* G1OffsetTableContigSpace::par_allocate(size_t size) { +inline HeapWord* G1OffsetTableContigSpace::par_allocate(size_t min_word_size, + size_t desired_word_size, + size_t* actual_size) { MutexLocker x(&_par_alloc_lock); - return allocate(size); + return allocate(min_word_size, desired_word_size, actual_size); } inline HeapWord* G1OffsetTableContigSpace::block_start(const void* p) { @@ -128,14 +148,23 @@ return pointer_delta(next, addr); } -inline HeapWord* HeapRegion::par_allocate_no_bot_updates(size_t word_size) { +inline HeapWord* HeapRegion::par_allocate_no_bot_updates(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size) { assert(is_young(), "we can only skip BOT updates on young regions"); - return par_allocate_impl(word_size, end()); + return par_allocate_impl(min_word_size, desired_word_size, actual_word_size); } inline HeapWord* HeapRegion::allocate_no_bot_updates(size_t word_size) { + size_t temp; + return allocate_no_bot_updates(word_size, word_size, &temp); +} + +inline HeapWord* HeapRegion::allocate_no_bot_updates(size_t min_word_size, + size_t desired_word_size, + size_t* actual_word_size) { assert(is_young(), "we can only skip BOT updates on young regions"); - return allocate_impl(word_size, end()); + return allocate_impl(min_word_size, desired_word_size, actual_word_size); } inline void HeapRegion::note_start_of_marking() {
--- a/src/share/vm/gc/g1/heapRegionManager.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegionManager.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -426,9 +426,9 @@ (num_last_found = find_empty_from_idx_reverse(cur, &idx_last_found)) > 0) { uint to_remove = MIN2(num_regions_to_remove - removed, num_last_found); - uncommit_regions(idx_last_found + num_last_found - to_remove, to_remove); + shrink_at(idx_last_found + num_last_found - to_remove, to_remove); - cur -= num_last_found; + cur = idx_last_found; removed += to_remove; } @@ -437,6 +437,17 @@ return removed; } +void HeapRegionManager::shrink_at(uint index, size_t num_regions) { +#ifdef ASSERT + for (uint i = index; i < (index + num_regions); i++) { + assert(is_available(i), err_msg("Expected available region at index %u", i)); + assert(at(i)->is_empty(), err_msg("Expected empty region at index %u", i)); + assert(at(i)->is_free(), err_msg("Expected free region at index %u", i)); + } +#endif + uncommit_regions(index, num_regions); +} + uint HeapRegionManager::find_empty_from_idx_reverse(uint start_idx, uint* res_idx) const { guarantee(start_idx < _allocated_heapregions_length, "checking"); guarantee(res_idx != NULL, "checking");
--- a/src/share/vm/gc/g1/heapRegionManager.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegionManager.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -241,6 +241,10 @@ // Return the actual number of uncommitted regions. uint shrink_by(uint num_regions_to_remove); + // Uncommit a number of regions starting at the specified index, which must be available, + // empty, and free. + void shrink_at(uint index, size_t num_regions); + void verify(); // Do some sanity checking.
--- a/src/share/vm/gc/g1/heapRegionType.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/heapRegionType.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -35,7 +35,7 @@ // We encode the value of the heap region type so the generation can be // determined quickly. The tag is split into two parts: // - // major type (young, humongous) : top N-1 bits + // major type (young, old, humongous, archive) : top N-1 bits // minor type (eden / survivor, starts / cont hum, etc.) : bottom 1 bit // // If there's need to increase the number of minor types in the
--- a/src/share/vm/gc/g1/vmStructs_g1.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/g1/vmStructs_g1.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -34,7 +34,7 @@ static_field(HeapRegion, GrainBytes, size_t) \ static_field(HeapRegion, LogOfHRGrainBytes, int) \ \ - nonstatic_field(G1OffsetTableContigSpace, _top, HeapWord*) \ + nonstatic_field(G1OffsetTableContigSpace, _top, HeapWord* volatile) \ \ nonstatic_field(G1HeapRegionTable, _base, address) \ nonstatic_field(G1HeapRegionTable, _length, size_t) \
--- a/src/share/vm/gc/parallel/cardTableExtension.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/cardTableExtension.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -89,7 +89,7 @@ CheckForUnmarkedOops object_check(_young_gen, _card_table); obj->oop_iterate_no_header(&object_check); if (object_check.has_unmarked_oop()) { - assert(_card_table->addr_is_marked_imprecise(obj), "Found unmarked young_gen object"); + guarantee(_card_table->addr_is_marked_imprecise(obj), "Found unmarked young_gen object"); } } };
--- a/src/share/vm/gc/parallel/cardTableExtension.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/cardTableExtension.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -56,13 +56,7 @@ CardTableExtension(MemRegion whole_heap) : CardTableModRefBS( whole_heap, - // Concrete tag should be BarrierSet::CardTableExtension. - // That will presently break things in a bunch of places though. - // The concrete tag is used as a dispatch key in many places, and - // CardTableExtension does not correctly dispatch in some of those - // uses. This will be addressed as part of a reorganization of the - // BarrierSet hierarchy. - BarrierSet::FakeRtti(BarrierSet::CardTableModRef, 0).add_tag(BarrierSet::CardTableExtension)) + BarrierSet::FakeRtti(BarrierSet::CardTableExtension)) { } // Scavenge support
--- a/src/share/vm/gc/parallel/immutableSpace.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/immutableSpace.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -44,7 +44,7 @@ HeapWord* t = end(); // Could call objects iterate, but this is easier. while (obj_addr < t) { - obj_addr += oop(obj_addr)->oop_iterate(cl); + obj_addr += oop(obj_addr)->oop_iterate_size(cl); } }
--- a/src/share/vm/gc/parallel/mutableSpace.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/mutableSpace.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -213,15 +213,6 @@ return (HeapWord*)Atomic::cmpxchg_ptr(obj, top_addr(), expected_top) == expected_top; } -void MutableSpace::oop_iterate(ExtendedOopClosure* cl) { - HeapWord* obj_addr = bottom(); - HeapWord* t = top(); - // Could call objects iterate, but this is easier. - while (obj_addr < t) { - obj_addr += oop(obj_addr)->oop_iterate(cl); - } -} - void MutableSpace::oop_iterate_no_header(OopClosure* cl) { HeapWord* obj_addr = bottom(); HeapWord* t = top();
--- a/src/share/vm/gc/parallel/mutableSpace.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/mutableSpace.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -134,7 +134,6 @@ bool cas_deallocate(HeapWord *obj, size_t size); // Iteration. - void oop_iterate(ExtendedOopClosure* cl); void oop_iterate_no_header(OopClosure* cl); void object_iterate(ObjectClosure* cl);
--- a/src/share/vm/gc/parallel/parallelScavengeHeap.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/parallelScavengeHeap.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -30,26 +30,22 @@ #include "gc/parallel/psParallelCompact.hpp" #include "gc/parallel/psScavenge.hpp" -inline size_t ParallelScavengeHeap::total_invocations() -{ +inline size_t ParallelScavengeHeap::total_invocations() { return UseParallelOldGC ? PSParallelCompact::total_invocations() : PSMarkSweep::total_invocations(); } -inline bool ParallelScavengeHeap::should_alloc_in_eden(const size_t size) const -{ +inline bool ParallelScavengeHeap::should_alloc_in_eden(const size_t size) const { const size_t eden_size = young_gen()->eden_space()->capacity_in_words(); return size < eden_size / 2; } -inline void ParallelScavengeHeap::invoke_scavenge() -{ +inline void ParallelScavengeHeap::invoke_scavenge() { PSScavenge::invoke(); } inline bool ParallelScavengeHeap::is_in_young(oop p) { // Assumes the the old gen address range is lower than that of the young gen. - const void* loc = (void*) p; bool result = ((HeapWord*)p) >= young_gen()->reserved().start(); assert(result == young_gen()->is_in_reserved(p), err_msg("incorrect test - result=%d, p=" PTR_FORMAT, result, p2i((void*)p)));
--- a/src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psAdaptiveSizePolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -299,7 +299,7 @@ // subtracted out. size_t eden_limit = max_eden_size; - const double gc_cost_limit = GCTimeLimit/100.0; + const double gc_cost_limit = GCTimeLimit / 100.0; // Which way should we go? // if pause requirement is not met
--- a/src/share/vm/gc/parallel/psMarkSweep.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psMarkSweep.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -60,7 +60,7 @@ void PSMarkSweep::initialize() { MemRegion mr = ParallelScavengeHeap::heap()->reserved_region(); - _ref_processor = new ReferenceProcessor(mr); // a vanilla ref proc + set_ref_processor(new ReferenceProcessor(mr)); // a vanilla ref proc _counters = new CollectorCounters("PSMarkSweep", 1); }
--- a/src/share/vm/gc/parallel/psOldGen.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psOldGen.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -486,12 +486,12 @@ object_space()->verify(); } class VerifyObjectStartArrayClosure : public ObjectClosure { - PSOldGen* _gen; + PSOldGen* _old_gen; ObjectStartArray* _start_array; public: - VerifyObjectStartArrayClosure(PSOldGen* gen, ObjectStartArray* start_array) : - _gen(gen), _start_array(start_array) { } + VerifyObjectStartArrayClosure(PSOldGen* old_gen, ObjectStartArray* start_array) : + _old_gen(old_gen), _start_array(start_array) { } virtual void do_object(oop obj) { HeapWord* test_addr = (HeapWord*)obj + 1;
--- a/src/share/vm/gc/parallel/psParallelCompact.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psParallelCompact.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -958,7 +958,7 @@ { // Update the from & to space pointers in space_info, since they are swapped // at each young gen gc. Do the update unconditionally (even though a - // promotion failure does not swap spaces) because an unknown number of minor + // promotion failure does not swap spaces) because an unknown number of young // collections will have swapped the spaces an unknown number of times. GCTraceTime tm("pre compact", print_phases(), true, &_gc_timer, _gc_tracer.gc_id()); ParallelScavengeHeap* heap = ParallelScavengeHeap::heap();
--- a/src/share/vm/gc/parallel/psParallelCompact.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psParallelCompact.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -303,7 +303,7 @@ // completed(), which is desirable since a region must be claimed before it // can be completed. bool available() const { return _dc_and_los < dc_one; } - bool claimed() const { return _dc_and_los >= dc_claimed; } + bool claimed() const { return _dc_and_los >= dc_claimed; } bool completed() const { return _dc_and_los >= dc_completed; } // These are not atomic. @@ -979,7 +979,6 @@ static bool _dwl_initialized; #endif // #ifdef ASSERT - public: static ParallelOldTracer* gc_tracer() { return &_gc_tracer; }
--- a/src/share/vm/gc/parallel/psScavenge.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psScavenge.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -597,9 +597,9 @@ // to allow resizes that may have been inhibited by the // relative location of the "to" and "from" spaces. - // Resizing the old gen at minor collects can cause increases + // Resizing the old gen at young collections can cause increases // that don't feed back to the generation sizing policy until - // a major collection. Don't resize the old gen here. + // a full collection. Don't resize the old gen here. heap->resize_young_gen(size_policy->calculated_eden_size_in_bytes(), size_policy->calculated_survivor_size_in_bytes());
--- a/src/share/vm/gc/parallel/psTasks.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psTasks.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -172,10 +172,10 @@ void OldToYoungRootsTask::do_it(GCTaskManager* manager, uint which) { // There are not old-to-young pointers if the old gen is empty. - assert(!_gen->object_space()->is_empty(), + assert(!_old_gen->object_space()->is_empty(), "Should not be called is there is no work"); - assert(_gen != NULL, "Sanity"); - assert(_gen->object_space()->contains(_gen_top) || _gen_top == _gen->object_space()->top(), "Sanity"); + assert(_old_gen != NULL, "Sanity"); + assert(_old_gen->object_space()->contains(_gen_top) || _gen_top == _old_gen->object_space()->top(), "Sanity"); assert(_stripe_number < ParallelGCThreads, "Sanity"); { @@ -183,8 +183,8 @@ CardTableExtension* card_table = barrier_set_cast<CardTableExtension>(ParallelScavengeHeap::heap()->barrier_set()); - card_table->scavenge_contents_parallel(_gen->start_array(), - _gen->object_space(), + card_table->scavenge_contents_parallel(_old_gen->start_array(), + _old_gen->object_space(), _gen_top, pm, _stripe_number,
--- a/src/share/vm/gc/parallel/psTasks.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/parallel/psTasks.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -160,17 +160,17 @@ class OldToYoungRootsTask : public GCTask { private: - PSOldGen* _gen; + PSOldGen* _old_gen; HeapWord* _gen_top; uint _stripe_number; uint _stripe_total; public: - OldToYoungRootsTask(PSOldGen *gen, + OldToYoungRootsTask(PSOldGen *old_gen, HeapWord* gen_top, uint stripe_number, uint stripe_total) : - _gen(gen), + _old_gen(old_gen), _gen_top(gen_top), _stripe_number(stripe_number), _stripe_total(stripe_total) { }
--- a/src/share/vm/gc/serial/defNewGeneration.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/defNewGeneration.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -106,14 +106,14 @@ _gch(gch), _scan_cur_or_nonheap(cur), _scan_older(older) { assert(_gch->young_gen()->kind() == Generation::DefNew, "Generation should be DefNew"); - _gen = (DefNewGeneration*)_gch->young_gen(); + _young_gen = (DefNewGeneration*)_gch->young_gen(); } void DefNewGeneration::FastEvacuateFollowersClosure::do_void() { do { _gch->oop_since_save_marks_iterate(GenCollectedHeap::YoungGen, _scan_cur_or_nonheap, _scan_older); } while (!_gch->no_allocs_since_save_marks()); - guarantee(_gen->promo_failure_scan_is_complete(), "Failed to finish scan"); + guarantee(_young_gen->promo_failure_scan_is_complete(), "Failed to finish scan"); } ScanClosure::ScanClosure(DefNewGeneration* g, bool gc_barrier) : @@ -200,8 +200,9 @@ _from_space = new ContiguousSpace(); _to_space = new ContiguousSpace(); - if (_eden_space == NULL || _from_space == NULL || _to_space == NULL) + if (_eden_space == NULL || _from_space == NULL || _to_space == NULL) { vm_exit_during_initialization("Could not allocate a new gen space"); + } // Compute the maximum eden and survivor space sizes. These sizes // are computed assuming the entire reserved space is committed. @@ -655,7 +656,7 @@ if (ZapUnusedHeapArea) { // This is now done here because of the piece-meal mangling which // can check for valid mangling at intermediate points in the - // collection(s). When a minor collection fails to collect + // collection(s). When a young collection fails to collect // sufficient space resizing of the young generation can occur // an redistribute the spaces in the young generation. Mangle // here so that unzapped regions don't get distributed to
--- a/src/share/vm/gc/serial/defNewGeneration.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/defNewGeneration.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -193,7 +193,7 @@ class FastEvacuateFollowersClosure: public VoidClosure { GenCollectedHeap* _gch; - DefNewGeneration* _gen; + DefNewGeneration* _young_gen; FastScanClosure* _scan_cur_or_nonheap; FastScanClosure* _scan_older; public:
--- a/src/share/vm/gc/serial/defNewGeneration.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/defNewGeneration.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -57,8 +57,8 @@ // each generation, allowing them in turn to examine the modified // field. // - // We could check that p is also in an older generation, but - // dirty cards in the youngest gen are never scanned, so the + // We could check that p is also in the old generation, but + // dirty cards in the young gen are never scanned, so the // extra check probably isn't worthwhile. if (GenCollectedHeap::heap()->is_in_reserved(p)) { oop obj = oopDesc::load_decode_heap_oop_not_null(p);
--- a/src/share/vm/gc/serial/genMarkSweep.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/genMarkSweep.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -67,7 +67,7 @@ // hook up weak ref data so it can be used during Mark-Sweep assert(ref_processor() == NULL, "no stomping"); assert(rp != NULL, "should be non-NULL"); - _ref_processor = rp; + set_ref_processor(rp); rp->setup_policy(clear_all_softrefs); GCTraceTime t1(GCCauseString("Full GC", gch->gc_cause()), PrintGC && !PrintGCDetails, true, NULL, _gc_tracer->gc_id()); @@ -136,7 +136,7 @@ } // refs processing: clean slate - _ref_processor = NULL; + set_ref_processor(NULL); // Update heap occupancy information which is used as // input to soft ref clearing policy at the next gc.
--- a/src/share/vm/gc/serial/markSweep.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/markSweep.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,11 +28,20 @@ #include "gc/shared/collectedHeap.inline.hpp" #include "gc/shared/gcTimer.hpp" #include "gc/shared/gcTrace.hpp" +#include "gc/shared/specialized_oop_closures.hpp" +#include "memory/iterator.inline.hpp" +#include "oops/instanceClassLoaderKlass.inline.hpp" #include "oops/instanceKlass.inline.hpp" #include "oops/instanceMirrorKlass.inline.hpp" +#include "oops/instanceRefKlass.inline.hpp" #include "oops/methodData.hpp" #include "oops/objArrayKlass.inline.hpp" #include "oops/oop.inline.hpp" +#include "utilities/macros.hpp" +#include "utilities/stack.inline.hpp" +#if INCLUDE_ALL_GCS +#include "gc/g1/g1StringDedup.hpp" +#endif // INCLUDE_ALL_GCS uint MarkSweep::_total_invocations = 0; @@ -50,179 +59,101 @@ MarkSweep::FollowRootClosure MarkSweep::follow_root_closure; -void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } -void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } - -MarkSweep::MarkAndPushClosure MarkSweep::mark_and_push_closure; +MarkAndPushClosure MarkSweep::mark_and_push_closure; CLDToOopClosure MarkSweep::follow_cld_closure(&mark_and_push_closure); CLDToOopClosure MarkSweep::adjust_cld_closure(&adjust_pointer_closure); -template <typename T> -void MarkSweep::MarkAndPushClosure::do_oop_nv(T* p) { mark_and_push(p); } -void MarkSweep::MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } -void MarkSweep::MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } +inline void MarkSweep::mark_object(oop obj) { +#if INCLUDE_ALL_GCS + if (G1StringDedup::is_enabled()) { + // We must enqueue the object before it is marked + // as we otherwise can't read the object's age. + G1StringDedup::enqueue_from_mark(obj); + } +#endif + // some marks may contain information we need to preserve so we store them away + // and overwrite the mark. We'll restore it at the end of markSweep. + markOop mark = obj->mark(); + obj->set_mark(markOopDesc::prototype()->set_marked()); -void MarkSweep::follow_class_loader(ClassLoaderData* cld) { - MarkSweep::follow_cld_closure.do_cld(cld); -} - -void InstanceKlass::oop_ms_follow_contents(oop obj) { - assert(obj != NULL, "can't follow the content of NULL object"); - MarkSweep::follow_klass(this); - - oop_oop_iterate_oop_maps<true>(obj, &MarkSweep::mark_and_push_closure); + if (mark->must_be_preserved(obj)) { + preserve_mark(obj, mark); + } } -void InstanceMirrorKlass::oop_ms_follow_contents(oop obj) { - InstanceKlass::oop_ms_follow_contents(obj); - - // Follow the klass field in the mirror - Klass* klass = java_lang_Class::as_Klass(obj); - if (klass != NULL) { - // An anonymous class doesn't have its own class loader, so the call - // to follow_klass will mark and push its java mirror instead of the - // class loader. When handling the java mirror for an anonymous class - // we need to make sure its class loader data is claimed, this is done - // by calling follow_class_loader explicitly. For non-anonymous classes - // the call to follow_class_loader is made when the class loader itself - // is handled. - if (klass->oop_is_instance() && InstanceKlass::cast(klass)->is_anonymous()) { - MarkSweep::follow_class_loader(klass->class_loader_data()); - } else { - MarkSweep::follow_klass(klass); +template <class T> inline void MarkSweep::mark_and_push(T* p) { + T heap_oop = oopDesc::load_heap_oop(p); + if (!oopDesc::is_null(heap_oop)) { + oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); + if (!obj->mark()->is_marked() && + !is_archive_object(obj)) { + mark_object(obj); + _marking_stack.push(obj); } - } else { - // If klass is NULL then this a mirror for a primitive type. - // We don't have to follow them, since they are handled as strong - // roots in Universe::oops_do. - assert(java_lang_Class::is_primitive(obj), "Sanity check"); - } - - oop_oop_iterate_statics<true>(obj, &MarkSweep::mark_and_push_closure); -} - -void InstanceClassLoaderKlass::oop_ms_follow_contents(oop obj) { - InstanceKlass::oop_ms_follow_contents(obj); - - ClassLoaderData * const loader_data = java_lang_ClassLoader::loader_data(obj); - - // We must NULL check here, since the class loader - // can be found before the loader data has been set up. - if(loader_data != NULL) { - MarkSweep::follow_class_loader(loader_data); } } -template <class T> -static void oop_ms_follow_contents_specialized(InstanceRefKlass* klass, oop obj) { - T* referent_addr = (T*)java_lang_ref_Reference::referent_addr(obj); - T heap_oop = oopDesc::load_heap_oop(referent_addr); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr("InstanceRefKlass::oop_ms_follow_contents_specialized " PTR_FORMAT, p2i(obj)); - } - ) - if (!oopDesc::is_null(heap_oop)) { - oop referent = oopDesc::decode_heap_oop_not_null(heap_oop); - if (UseShenandoahGC) { - referent = ShenandoahBarrierSet::resolve_and_update_oop_static(referent_addr, referent); - } - if (!referent->is_gc_marked() && - MarkSweep::ref_processor()->discover_reference(obj, klass->reference_type())) { - // reference was discovered, referent will be traversed later - klass->InstanceKlass::oop_ms_follow_contents(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Non NULL enqueued " PTR_FORMAT, p2i(obj)); - } - ) - return; - } else { - // treat referent as normal oop - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Non NULL normal " PTR_FORMAT, p2i(obj)); - } - ) - MarkSweep::mark_and_push(referent_addr); - } - } - T* next_addr = (T*)java_lang_ref_Reference::next_addr(obj); - // Treat discovered as normal oop, if ref is not "active", - // i.e. if next is non-NULL. - T next_oop = oopDesc::load_heap_oop(next_addr); - if (!oopDesc::is_null(next_oop)) { // i.e. ref is not "active" - T* discovered_addr = (T*)java_lang_ref_Reference::discovered_addr(obj); - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process discovered as normal " - PTR_FORMAT, p2i(discovered_addr)); - } - ) - MarkSweep::mark_and_push(discovered_addr); - } - // treat next as normal oop. next is a link in the reference queue. - debug_only( - if(TraceReferenceGC && PrintGCDetails) { - gclog_or_tty->print_cr(" Process next as normal " PTR_FORMAT, p2i(next_addr)); - } - ) - MarkSweep::mark_and_push(next_addr); - klass->InstanceKlass::oop_ms_follow_contents(obj); +inline void MarkSweep::follow_klass(Klass* klass) { + oop op = klass->klass_holder(); + MarkSweep::mark_and_push(&op); +} + +inline void MarkSweep::follow_cld(ClassLoaderData* cld) { + MarkSweep::follow_cld_closure.do_cld(cld); } -void InstanceRefKlass::oop_ms_follow_contents(oop obj) { - if (UseCompressedOops) { - oop_ms_follow_contents_specialized<narrowOop>(this, obj); - } else { - oop_ms_follow_contents_specialized<oop>(this, obj); +template <typename T> +inline void MarkAndPushClosure::do_oop_nv(T* p) { MarkSweep::mark_and_push(p); } +void MarkAndPushClosure::do_oop(oop* p) { do_oop_nv(p); } +void MarkAndPushClosure::do_oop(narrowOop* p) { do_oop_nv(p); } +inline bool MarkAndPushClosure::do_metadata_nv() { return true; } +bool MarkAndPushClosure::do_metadata() { return do_metadata_nv(); } +inline void MarkAndPushClosure::do_klass_nv(Klass* k) { MarkSweep::follow_klass(k); } +void MarkAndPushClosure::do_klass(Klass* k) { do_klass_nv(k); } +inline void MarkAndPushClosure::do_cld_nv(ClassLoaderData* cld) { MarkSweep::follow_cld(cld); } +void MarkAndPushClosure::do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } + +template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { + mark_and_push(p); +} + +void MarkSweep::push_objarray(oop obj, size_t index) { + ObjArrayTask task(obj, index); + assert(task.is_valid(), "bad ObjArrayTask"); + _objarray_stack.push(task); +} + +inline void MarkSweep::follow_array(objArrayOop array) { + MarkSweep::follow_klass(array->klass()); + // Don't push empty arrays to avoid unnecessary work. + if (array->length() > 0) { + MarkSweep::push_objarray(array, 0); } } -template <class T> -static void oop_ms_follow_contents_specialized(oop obj, int index) { - objArrayOop a = objArrayOop(obj); - const size_t len = size_t(a->length()); - const size_t beg_index = size_t(index); - assert(beg_index < len || len == 0, "index too large"); - - const size_t stride = MIN2(len - beg_index, ObjArrayMarkingStride); - const size_t end_index = beg_index + stride; - T* const base = (T*)a->base(); - T* const beg = base + beg_index; - T* const end = base + end_index; - - // Push the non-NULL elements of the next stride on the marking stack. - for (T* e = beg; e < end; e++) { - MarkSweep::mark_and_push<T>(e); - } - - if (end_index < len) { - MarkSweep::push_objarray(a, end_index); // Push the continuation. +inline void MarkSweep::follow_object(oop obj) { + assert(obj->is_gc_marked(), "should be marked"); + if (obj->is_objArray()) { + // Handle object arrays explicitly to allow them to + // be split into chunks if needed. + MarkSweep::follow_array((objArrayOop)obj); + } else { + obj->oop_iterate(&mark_and_push_closure); } } -void ObjArrayKlass::oop_ms_follow_contents(oop obj) { - assert (obj->is_array(), "obj must be array"); - MarkSweep::follow_klass(this); - if (UseCompressedOops) { - oop_ms_follow_contents_specialized<narrowOop>(obj, 0); - } else { - oop_ms_follow_contents_specialized<oop>(obj, 0); - } -} +void MarkSweep::follow_array_chunk(objArrayOop array, int index) { + const int len = array->length(); + const int beg_index = index; + assert(beg_index < len || len == 0, "index too large"); -void TypeArrayKlass::oop_ms_follow_contents(oop obj) { - assert(obj->is_typeArray(),"must be a type array"); - // Performance tweak: We skip iterating over the klass pointer since we - // know that Universe::TypeArrayKlass never moves. -} + const int stride = MIN2(len - beg_index, (int) ObjArrayMarkingStride); + const int end_index = beg_index + stride; -void MarkSweep::follow_array(objArrayOop array, int index) { - if (UseCompressedOops) { - oop_ms_follow_contents_specialized<narrowOop>(array, index); - } else { - oop_ms_follow_contents_specialized<oop>(array, index); + array->oop_iterate_range(&mark_and_push_closure, beg_index, end_index); + + if (end_index < len) { + MarkSweep::push_objarray(array, end_index); // Push the continuation. } } @@ -236,7 +167,7 @@ // Process ObjArrays one at a time to avoid marking stack bloat. if (!_objarray_stack.is_empty()) { ObjArrayTask task = _objarray_stack.pop(); - follow_array(objArrayOop(task.obj()), task.index()); + follow_array_chunk(objArrayOop(task.obj()), task.index()); } } while (!_marking_stack.is_empty() || !_objarray_stack.is_empty()); } @@ -245,6 +176,24 @@ void MarkSweep::FollowStackClosure::do_void() { follow_stack(); } +template <class T> inline void MarkSweep::follow_root(T* p) { + assert(!Universe::heap()->is_in_reserved(p), + "roots shouldn't be things within the heap"); + T heap_oop = oopDesc::load_heap_oop(p); + if (!oopDesc::is_null(heap_oop)) { + oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); + if (!obj->mark()->is_marked() && + !is_archive_object(obj)) { + mark_object(obj); + follow_object(obj); + } + } + follow_stack(); +} + +void MarkSweep::FollowRootClosure::do_oop(oop* p) { follow_root(p); } +void MarkSweep::FollowRootClosure::do_oop(narrowOop* p) { follow_root(p); } + void PreservedMark::adjust_pointer() { MarkSweep::adjust_pointer(&_obj); } @@ -269,6 +218,11 @@ } } +void MarkSweep::set_ref_processor(ReferenceProcessor* rp) { + _ref_processor = rp; + mark_and_push_closure.set_ref_processor(_ref_processor); +} + MarkSweep::AdjustPointerClosure MarkSweep::adjust_pointer_closure; template <typename T> @@ -408,3 +362,6 @@ // know that Universe::TypeArrayKlass never moves. return t->object_size(); } + +// Generate MS specialized oop_oop_iterate functions. +SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(ALL_KLASS_OOP_OOP_ITERATE_DEFN)
--- a/src/share/vm/gc/serial/markSweep.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/markSweep.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -49,6 +49,7 @@ // declared at end class PreservedMark; +class MarkAndPushClosure; class MarkSweep : AllStatic { // @@ -60,13 +61,6 @@ virtual void do_oop(narrowOop* p); }; - class MarkAndPushClosure: public ExtendedOopClosure { - public: - template <typename T> void do_oop_nv(T* p); - virtual void do_oop(oop* p); - virtual void do_oop(narrowOop* p); - }; - class FollowStackClosure: public VoidClosure { public: virtual void do_void(); @@ -146,6 +140,7 @@ // Reference Processing static ReferenceProcessor* const ref_processor() { return _ref_processor; } + static void set_ref_processor(ReferenceProcessor* rp); // Archive Object handling static inline bool is_archive_object(oop object); @@ -153,34 +148,55 @@ static STWGCTimer* gc_timer() { return _gc_timer; } static SerialOldTracer* gc_tracer() { return _gc_tracer; } + static void preserve_mark(oop p, markOop mark); + // Save the mark word so it can be restored later + static void adjust_marks(); // Adjust the pointers in the preserved marks table + static void restore_marks(); // Restore the marks that we saved in preserve_mark + + static int adjust_pointers(oop obj); + + static void follow_stack(); // Empty marking stack. + + static void follow_klass(Klass* klass); + + static void follow_cld(ClassLoaderData* cld); + + template <class T> static inline void adjust_pointer(T* p); + + // Check mark and maybe push on marking stack + template <class T> static void mark_and_push(T* p); + + private: // Call backs for marking static void mark_object(oop obj); // Mark pointer and follow contents. Empty marking stack afterwards. template <class T> static inline void follow_root(T* p); - // Check mark and maybe push on marking stack - template <class T> static void mark_and_push(T* p); - static inline void push_objarray(oop obj, size_t index); - static void follow_stack(); // Empty marking stack. - static void follow_object(oop obj); - static void follow_array(objArrayOop array, int index); + static void follow_array(objArrayOop array); + + static void follow_array_chunk(objArrayOop array, int index); +}; - static void follow_klass(Klass* klass); - - static void follow_class_loader(ClassLoaderData* cld); +class MarkAndPushClosure: public ExtendedOopClosure { +public: + template <typename T> void do_oop_nv(T* p); + virtual void do_oop(oop* p); + virtual void do_oop(narrowOop* p); - static int adjust_pointers(oop obj); + virtual bool do_metadata(); + bool do_metadata_nv(); - static void preserve_mark(oop p, markOop mark); - // Save the mark word so it can be restored later - static void adjust_marks(); // Adjust the pointers in the preserved marks table - static void restore_marks(); // Restore the marks that we saved in preserve_mark + virtual void do_klass(Klass* k); + void do_klass_nv(Klass* k); - template <class T> static inline void adjust_pointer(T* p); + virtual void do_cld(ClassLoaderData* cld); + void do_cld_nv(ClassLoaderData* cld); + + void set_ref_processor(ReferenceProcessor* rp) { _ref_processor = rp; } }; class PreservedMark VALUE_OBJ_CLASS_SPEC {
--- a/src/share/vm/gc/serial/markSweep.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/markSweep.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,38 +26,13 @@ #define SHARE_VM_GC_SERIAL_MARKSWEEP_INLINE_HPP #include "gc/serial/markSweep.hpp" -#include "gc/shared/collectedHeap.hpp" -#include "oops/instanceClassLoaderKlass.inline.hpp" -#include "oops/instanceKlass.inline.hpp" -#include "oops/instanceMirrorKlass.inline.hpp" -#include "oops/instanceRefKlass.inline.hpp" +#include "memory/universe.hpp" #include "oops/markOop.inline.hpp" -#include "oops/objArrayKlass.inline.hpp" -#include "utilities/macros.hpp" -#include "utilities/stack.inline.hpp" +#include "oops/oop.inline.hpp" #if INCLUDE_ALL_GCS -#include "gc/g1/g1StringDedup.hpp" #include "gc/g1/g1MarkSweep.hpp" #endif // INCLUDE_ALL_GCS -inline void MarkSweep::mark_object(oop obj) { -#if INCLUDE_ALL_GCS - if (G1StringDedup::is_enabled()) { - // We must enqueue the object before it is marked - // as we otherwise can't read the object's age. - G1StringDedup::enqueue_from_mark(obj); - } -#endif - // some marks may contain information we need to preserve so we store them away - // and overwrite the mark. We'll restore it at the end of markSweep. - markOop mark = obj->mark(); - obj->set_mark(markOopDesc::prototype()->set_marked()); - - if (mark->must_be_preserved(obj)) { - preserve_mark(obj, mark); - } -} - inline bool MarkSweep::is_archive_object(oop object) { #if INCLUDE_ALL_GCS return (G1MarkSweep::archive_check_enabled() && @@ -67,57 +42,6 @@ #endif } -inline void MarkSweep::follow_klass(Klass* klass) { - oop op = klass->klass_holder(); - MarkSweep::mark_and_push(&op); -} - -inline void MarkSweep::follow_object(oop obj) { - assert(obj->is_gc_marked(), "should be marked"); - - obj->ms_follow_contents(); -} - -template <class T> inline void MarkSweep::follow_root(T* p) { - assert(!Universe::heap()->is_in_reserved(p), - "roots shouldn't be things within the heap"); - T heap_oop = oopDesc::load_heap_oop(p); - if (!oopDesc::is_null(heap_oop)) { - oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); - if (UseShenandoahGC) { - obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj); - } - if (!obj->mark()->is_marked() && - !is_archive_object(obj)) { - mark_object(obj); - follow_object(obj); - } - } - follow_stack(); -} - -template <class T> inline void MarkSweep::mark_and_push(T* p) { -// assert(Universe::heap()->is_in_reserved(p), "should be in object space"); - T heap_oop = oopDesc::load_heap_oop(p); - if (!oopDesc::is_null(heap_oop)) { - oop obj = oopDesc::decode_heap_oop_not_null(heap_oop); - if (UseShenandoahGC) { - obj = ShenandoahBarrierSet::resolve_and_update_oop_static(p, obj); - } - if (!obj->mark()->is_marked() && - !is_archive_object(obj)) { - mark_object(obj); - _marking_stack.push(obj); - } - } -} - -void MarkSweep::push_objarray(oop obj, size_t index) { - ObjArrayTask task(obj, index); - assert(task.is_valid(), "bad ObjArrayTask"); - _objarray_stack.push(task); -} - inline int MarkSweep::adjust_pointers(oop obj) { return obj->ms_adjust_pointers(); } @@ -145,8 +69,4 @@ } } -template <class T> inline void MarkSweep::KeepAliveClosure::do_oop_work(T* p) { - mark_and_push(p); -} - #endif // SHARE_VM_GC_SERIAL_MARKSWEEP_INLINE_HPP
--- a/src/share/vm/gc/serial/tenuredGeneration.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/tenuredGeneration.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -108,7 +108,7 @@ free()); } } - // If we had to expand to accommodate promotions from younger generations + // If we had to expand to accommodate promotions from the young generation if (!result && _capacity_at_prologue < capacity()) { result = true; if (PrintGC && Verbose) { @@ -140,11 +140,11 @@ // that are of interest at this point. bool current_is_young = GenCollectedHeap::heap()->is_young_gen(current_generation); if (!full && current_is_young) { - // Calculate size of data promoted from the younger generations + // Calculate size of data promoted from the young generation // before doing the collection. size_t used_before_gc = used(); - // If the younger gen collections were skipped, then the + // If the young gen collection was skipped, then the // number of promoted bytes will be 0 and adding it to the // average will incorrectly lessen the average. It is, however, // also possible that no promotion was needed.
--- a/src/share/vm/gc/serial/tenuredGeneration.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/serial/tenuredGeneration.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -42,10 +42,10 @@ friend class VM_PopulateDumpSharedSpace; protected: - ContiguousSpace* _the_space; // Actual space holding objects + ContiguousSpace* _the_space; // Actual space holding objects - GenerationCounters* _gen_counters; - CSpaceCounters* _space_counters; + GenerationCounters* _gen_counters; + CSpaceCounters* _space_counters; // Allocation failure virtual bool expand(size_t bytes, size_t expand_bytes); @@ -54,6 +54,7 @@ ContiguousSpace* space() const { return _the_space; } void assert_correct_size_change_locking(); + public: TenuredGeneration(ReservedSpace rs, size_t initial_byte_size, @@ -66,10 +67,9 @@ const char* short_name() const { return "Tenured"; } // Does a "full" (forced) collection invoked on this generation collect - // all younger generations as well? Note that this is a - // hack to allow the collection of the younger gen first if the flag is - // set. - virtual bool full_collects_younger_generations() const { + // the young generation as well? Note that this is a hack to allow the + // collection of the young gen first if the flag is set. + virtual bool full_collects_young_generation() const { return !ScavengeBeforeFullGC; } @@ -99,15 +99,16 @@ bool clear_all_soft_refs, size_t size, bool is_tlab); + HeapWord* expand_and_allocate(size_t size, bool is_tlab, bool parallel = false); virtual void prepare_for_verify(); - virtual void gc_prologue(bool full); virtual void gc_epilogue(bool full); + bool should_collect(bool full, size_t word_size, bool is_tlab);
--- a/src/share/vm/gc/shared/adaptiveSizePolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/adaptiveSizePolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -266,22 +266,22 @@ } // The policy does not have enough data until at least some - // minor collections have been done. + // young collections have been done. _young_gen_policy_is_ready = (_avg_minor_gc_cost->count() >= AdaptiveSizePolicyReadyThreshold); // Calculate variables used to estimate pause time vs. gen sizes - double eden_size_in_mbytes = ((double)_eden_size)/((double)M); + double eden_size_in_mbytes = ((double)_eden_size) / ((double)M); update_minor_pause_young_estimator(minor_pause_in_ms); update_minor_pause_old_estimator(minor_pause_in_ms); if (PrintAdaptiveSizePolicy && Verbose) { gclog_or_tty->print("AdaptiveSizePolicy::minor_collection_end: " - "minor gc cost: %f average: %f", collection_cost, - _avg_minor_gc_cost->average()); + "minor gc cost: %f average: %f", collection_cost, + _avg_minor_gc_cost->average()); gclog_or_tty->print_cr(" minor pause: %f minor period %f", - minor_pause_in_ms, - _latest_minor_mutator_interval_seconds * MILLIUNITS); + minor_pause_in_ms, + _latest_minor_mutator_interval_seconds * MILLIUNITS); } // Calculate variable used to estimate collection cost vs. gen sizes @@ -295,8 +295,7 @@ _minor_timer.start(); } -size_t AdaptiveSizePolicy::eden_increment(size_t cur_eden, - uint percent_change) { +size_t AdaptiveSizePolicy::eden_increment(size_t cur_eden, uint percent_change) { size_t eden_heap_delta; eden_heap_delta = cur_eden / 100 * percent_change; return eden_heap_delta; @@ -312,8 +311,7 @@ return eden_heap_delta; } -size_t AdaptiveSizePolicy::promo_increment(size_t cur_promo, - uint percent_change) { +size_t AdaptiveSizePolicy::promo_increment(size_t cur_promo, uint percent_change) { size_t promo_heap_delta; promo_heap_delta = cur_promo / 100 * percent_change; return promo_heap_delta;
--- a/src/share/vm/gc/shared/barrierSet.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/barrierSet.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -136,6 +136,9 @@ // First the pre-write versions... template <class T> inline void write_ref_field_pre(T* field, oop new_val); private: + // Helper for write_ref_field_pre and friends, testing for specialized cases. + bool devirtualize_reference_writes() const; + // Keep this private so as to catch violations at build time. virtual void write_ref_field_pre_work( void* field, oop new_val) { guarantee(false, "Not needed"); }; protected: @@ -146,7 +149,7 @@ // ...then the post-write version. inline void write_ref_field(void* field, oop new_val, bool release = false); protected: - virtual void write_ref_field_work(void* field, oop new_val, bool release = false) = 0; + virtual void write_ref_field_work(void* field, oop new_val, bool release) = 0; public: // Invoke the barrier, if any, necessary when writing the "bytes"-byte
--- a/src/share/vm/gc/shared/barrierSet.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/barrierSet.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,8 +32,18 @@ // performance-critical calls when the barrier is the most common // card-table kind. +inline bool BarrierSet::devirtualize_reference_writes() const { + switch (kind()) { + case CardTableForRS: + case CardTableExtension: + return true; + default: + return false; + } +} + template <class T> void BarrierSet::write_ref_field_pre(T* field, oop new_val) { - if (kind() == CardTableModRef) { + if (devirtualize_reference_writes()) { barrier_set_cast<CardTableModRefBS>(this)->inline_write_ref_field_pre(field, new_val); } else { write_ref_field_pre_work(field, new_val); @@ -41,7 +51,7 @@ } void BarrierSet::write_ref_field(void* field, oop new_val, bool release) { - if (kind() == CardTableModRef) { + if (devirtualize_reference_writes()) { barrier_set_cast<CardTableModRefBS>(this)->inline_write_ref_field(field, new_val, release); } else { write_ref_field_work(field, new_val, release); @@ -77,7 +87,7 @@ inline void BarrierSet::write_region(MemRegion mr) { - if (kind() == CardTableModRef) { + if (devirtualize_reference_writes()) { barrier_set_cast<CardTableModRefBS>(this)->inline_write_region(mr); } else { write_region_work(mr);
--- a/src/share/vm/gc/shared/blockOffsetTable.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/blockOffsetTable.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,9 +25,12 @@ #ifndef SHARE_VM_GC_SHARED_BLOCKOFFSETTABLE_HPP #define SHARE_VM_GC_SHARED_BLOCKOFFSETTABLE_HPP +#include "gc/shared/memset_with_concurrent_readers.hpp" #include "memory/memRegion.hpp" #include "memory/virtualspace.hpp" +#include "runtime/globals.hpp" #include "utilities/globalDefinitions.hpp" +#include "utilities/macros.hpp" // The CollectedHeap type requires subtypes to implement a method // "block_start". For some subtypes, notably generational @@ -126,6 +129,19 @@ VirtualSpace _vs; u_char* _offset_array; // byte array keeping backwards offsets + void fill_range(size_t start, size_t num_cards, u_char offset) { + void* start_ptr = &_offset_array[start]; +#if INCLUDE_ALL_GCS + // If collector is concurrent, special handling may be needed. + assert(!UseG1GC, "Shouldn't be here when using G1"); + if (UseConcMarkSweepGC) { + memset_with_concurrent_readers(start_ptr, offset, num_cards); + return; + } +#endif // INCLUDE_ALL_GCS + memset(start_ptr, offset, num_cards); + } + protected: // Bounds checking accessors: // For performance these have to devolve to array accesses in product builds. @@ -160,20 +176,7 @@ assert(left < right, "Heap addresses out of order"); size_t num_cards = pointer_delta(right, left) >> LogN_words; - // Below, we may use an explicit loop instead of memset() - // because on certain platforms memset() can give concurrent - // readers "out-of-thin-air," phantom zeros; see 6948537. - if (UseMemSetInBOT) { - memset(&_offset_array[index_for(left)], offset, num_cards); - } else { - size_t i = index_for(left); - const size_t end = i + num_cards; - for (; i < end; i++) { - // Elided until CR 6977974 is fixed properly. - // assert(!reducing || _offset_array[i] >= offset, "Not reducing"); - _offset_array[i] = offset; - } - } + fill_range(index_for(left), num_cards, offset); } void set_offset_array(size_t left, size_t right, u_char offset, bool reducing = false) { @@ -182,20 +185,7 @@ assert(left <= right, "indexes out of order"); size_t num_cards = right - left + 1; - // Below, we may use an explicit loop instead of memset - // because on certain platforms memset() can give concurrent - // readers "out-of-thin-air," phantom zeros; see 6948537. - if (UseMemSetInBOT) { - memset(&_offset_array[left], offset, num_cards); - } else { - size_t i = left; - const size_t end = i + num_cards; - for (; i < end; i++) { - // Elided until CR 6977974 is fixed properly. - // assert(!reducing || _offset_array[i] >= offset, "Not reducing"); - _offset_array[i] = offset; - } - } + fill_range(left, num_cards, offset); } void check_offset_array(size_t index, HeapWord* high, HeapWord* low) const {
--- a/src/share/vm/gc/shared/cardTableModRefBS.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/cardTableModRefBS.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -183,7 +183,7 @@ // these functions here for performance. void write_ref_field_work(oop obj, size_t offset, oop newVal); - virtual void write_ref_field_work(void* field, oop newVal, bool release = false); + virtual void write_ref_field_work(void* field, oop newVal, bool release); public: bool has_write_ref_array_opt() { return true; }
--- a/src/share/vm/gc/shared/cardTableModRefBSForCTRS.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/cardTableModRefBSForCTRS.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -31,13 +31,7 @@ CardTableModRefBSForCTRS::CardTableModRefBSForCTRS(MemRegion whole_heap) : CardTableModRefBS( whole_heap, - // Concrete tag should be BarrierSet::CardTableForRS. - // That will presently break things in a bunch of places though. - // The concrete tag is used as a dispatch key in many places, and - // CardTableForRS does not correctly dispatch in some of those - // uses. This will be addressed as part of a reorganization of the - // BarrierSet hierarchy. - BarrierSet::FakeRtti(BarrierSet::CardTableModRef, 0).add_tag(BarrierSet::CardTableForRS)), + BarrierSet::FakeRtti(BarrierSet::CardTableForRS)), // LNC functionality _lowest_non_clean(NULL), _lowest_non_clean_chunk_size(NULL),
--- a/src/share/vm/gc/shared/cardTableRS.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/cardTableRS.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -80,7 +80,9 @@ break; } } - if (!seen) return v; + if (!seen) { + return v; + } } ShouldNotReachHere(); return 0; @@ -502,7 +504,7 @@ // // The main point below is that the parallel card scanning code // deals correctly with these stale card values. There are two main - // cases to consider where we have a stale "younger gen" value and a + // cases to consider where we have a stale "young gen" value and a // "derivative" case to consider, where we have a stale // "cur_younger_gen_and_prev_non_clean" value, as will become // apparent in the case analysis below.
--- a/src/share/vm/gc/shared/collectedHeap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/collectedHeap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -160,16 +160,20 @@ // Memory state functions. -CollectedHeap::CollectedHeap() { +CollectedHeap::CollectedHeap() : + _barrier_set(NULL), + _is_gc_active(false), + _total_collections(0), + _total_full_collections(0), + _gc_cause(GCCause::_no_gc), + _gc_lastcause(GCCause::_no_gc), + _defer_initial_card_mark(false) // strengthened by subclass in pre_initialize() below. +{ const size_t max_len = size_t(arrayOopDesc::max_array_length(T_INT)); const size_t elements_per_word = HeapWordSize / sizeof(jint); _filler_array_max_size = align_object_size(filler_array_hdr_size() + max_len / elements_per_word); - _barrier_set = NULL; - _is_gc_active = false; - _total_collections = _total_full_collections = 0; - _gc_cause = _gc_lastcause = GCCause::_no_gc; NOT_PRODUCT(_promotion_failure_alot_count = 0;) NOT_PRODUCT(_promotion_failure_alot_gc_number = 0;) @@ -184,7 +188,7 @@ PerfDataManager::create_string_variable(SUN_GC, "lastCause", 80, GCCause::to_string(_gc_lastcause), CHECK); } - _defer_initial_card_mark = false; // strengthened by subclass in pre_initialize() below. + // Create the ring log if (LogEvents) { _gc_heap_log = new GCHeapLog(); @@ -570,8 +574,8 @@ void CollectedHeap::pre_full_gc_dump(GCTimer* timer) { if (HeapDumpBeforeFullGC) { GCTraceTime tt("Heap Dump (before full gc): ", PrintGCDetails, false, timer, GCId::create()); - // We are doing a "major" collection and a heap dump before - // major collection has been requested. + // We are doing a full collection and a heap dump before + // full collection has been requested. HeapDumper::dump_heap(); } if (PrintClassHistogramBeforeFullGC) {
--- a/src/share/vm/gc/shared/collectorPolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/collectorPolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -225,6 +225,10 @@ return align_size_up(3 * _space_alignment, _gen_alignment); } +size_t GenCollectorPolicy::old_gen_size_lower_bound() { + return align_size_up(_space_alignment, _gen_alignment); +} + #ifdef ASSERT void GenCollectorPolicy::assert_flags() { CollectorPolicy::assert_flags(); @@ -284,7 +288,7 @@ // Make sure the heap is large enough for two generations size_t smallest_new_size = young_gen_size_lower_bound(); - size_t smallest_heap_size = align_size_up(smallest_new_size + align_size_up(_space_alignment, _gen_alignment), + size_t smallest_heap_size = align_size_up(smallest_new_size + old_gen_size_lower_bound(), _heap_alignment); if (MaxHeapSize < smallest_heap_size) { FLAG_SET_ERGO(size_t, MaxHeapSize, smallest_heap_size); @@ -356,6 +360,7 @@ vm_exit_during_initialization("Invalid young gen ratio specified"); } + OldSize = MAX2(OldSize, old_gen_size_lower_bound()); if (!is_size_aligned(OldSize, _gen_alignment)) { // Setting OldSize directly to preserve information about the possible // setting of OldSize on the command line.
--- a/src/share/vm/gc/shared/collectorPolicy.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/collectorPolicy.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -112,14 +112,6 @@ size_t max_heap_byte_size() { return _max_heap_byte_size; } size_t min_heap_byte_size() { return _min_heap_byte_size; } - enum Name { - CollectorPolicyKind, - GenCollectorPolicyKind, - ConcurrentMarkSweepPolicyKind, - G1CollectorPolicyKind, - ShenandoahCollectorPolicyKind - }; - AdaptiveSizePolicy* size_policy() { return _size_policy; } bool should_clear_all_soft_refs() { return _should_clear_all_soft_refs; } void set_should_clear_all_soft_refs(bool v) { _should_clear_all_soft_refs = v; } @@ -155,8 +147,6 @@ #endif // INCLUDE_ALL_GCS - virtual BarrierSet::Name barrier_set_name() = 0; - virtual GenRemSet* create_rem_set(MemRegion reserved); // This method controls how a collector satisfies a request @@ -187,10 +177,6 @@ ShouldNotReachHere(); } - virtual CollectorPolicy::Name kind() { - return CollectorPolicy::CollectorPolicyKind; - } - // Do any updates required to global flags that are due to heap initialization // changes virtual void post_heap_initialize() = 0; @@ -287,6 +273,8 @@ size_t young_gen_size_lower_bound(); + size_t old_gen_size_lower_bound(); + HeapWord* mem_allocate_work(size_t size, bool is_tlab, bool* gc_overhead_limit_was_exceeded); @@ -301,12 +289,6 @@ virtual void post_heap_initialize() { assert(_max_young_size == MaxNewSize, "Should be taken care of by initialize_size_info"); } - - BarrierSet::Name barrier_set_name() { return BarrierSet::CardTableModRef; } - - virtual CollectorPolicy::Name kind() { - return CollectorPolicy::GenCollectorPolicyKind; - } }; class MarkSweepPolicy : public GenCollectorPolicy {
--- a/src/share/vm/gc/shared/gcHeapSummary.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/gcHeapSummary.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -189,4 +189,44 @@ }; +class G1EvacSummary : public StackObj { +private: + size_t _allocated; // Total allocated + size_t _wasted; // of which wasted (internal fragmentation) + size_t _undo_wasted; // of which wasted on undo (is not used for calculation of PLAB size) + size_t _unused; // Unused in last buffer + size_t _used; + + size_t _region_end_waste; // Number of words wasted due to skipping to the next region. + uint _regions_filled; // Number of regions filled completely. + size_t _direct_allocated; // Number of words allocated directly into the regions. + + // Number of words in live objects remaining in regions that ultimately suffered an + // evacuation failure. This is used in the regions when the regions are made old regions. + size_t _failure_used; + // Number of words wasted in regions which failed evacuation. This is the sum of space + // for objects successfully copied out of the regions (now dead space) plus waste at the + // end of regions. + size_t _failure_waste; +public: + G1EvacSummary(size_t allocated, size_t wasted, size_t undo_wasted, size_t unused, + size_t used, size_t region_end_waste, uint regions_filled, size_t direct_allocated, + size_t failure_used, size_t failure_waste) : + _allocated(allocated), _wasted(wasted), _undo_wasted(undo_wasted), _unused(unused), + _used(used), _region_end_waste(region_end_waste), _regions_filled(regions_filled), + _direct_allocated(direct_allocated), _failure_used(failure_used), _failure_waste(failure_waste) + { } + + size_t allocated() const { return _allocated; } + size_t wasted() const { return _wasted; } + size_t undo_wasted() const { return _undo_wasted; } + size_t unused() const { return _unused; } + size_t used() const { return _used; } + size_t region_end_waste() const { return _region_end_waste; } + uint regions_filled() const { return _regions_filled; } + size_t direct_allocated() const { return _direct_allocated; } + size_t failure_used() const { return _failure_used; } + size_t failure_waste() const { return _failure_waste; } +}; + #endif // SHARE_VM_GC_SHARED_GCHEAPSUMMARY_HPP
--- a/src/share/vm/gc/shared/gcTrace.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/gcTrace.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -88,6 +88,8 @@ send_reference_stats_event(REF_WEAK, rps.weak_count()); send_reference_stats_event(REF_FINAL, rps.final_count()); send_reference_stats_event(REF_PHANTOM, rps.phantom_count()); + send_reference_stats_event(REF_CLEANER, rps.cleaner_count()); + send_reference_stats_event(REF_JNI, rps.jni_weak_ref_count()); } #if INCLUDE_SERVICES @@ -173,6 +175,11 @@ _tenuring_threshold = tenuring_threshold; } +bool YoungGCTracer::should_report_promotion_events() const { + return should_report_promotion_in_new_plab_event() || + should_report_promotion_outside_plab_event(); +} + bool YoungGCTracer::should_report_promotion_in_new_plab_event() const { return should_send_promotion_in_new_plab_event(); } @@ -252,4 +259,12 @@ send_evacuation_failed_event(ef_info); ef_info.reset(); } + +void G1NewTracer::report_evacuation_statistics(const G1EvacSummary& young_summary, const G1EvacSummary& old_summary) const { + assert_set_gc_id(); + + send_young_evacuation_statistics(young_summary); + send_old_evacuation_statistics(old_summary); +} + #endif
--- a/src/share/vm/gc/shared/gcTrace.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/gcTrace.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -45,6 +45,7 @@ class MetaspaceSummary; class PSHeapSummary; class G1HeapSummary; +class G1EvacSummary; class ReferenceProcessorStats; class TimePartitions; class BoolObjectClosure; @@ -171,6 +172,7 @@ * * plab_size is the size of the newly allocated PLAB in bytes. */ + bool should_report_promotion_events() const; bool should_report_promotion_in_new_plab_event() const; bool should_report_promotion_outside_plab_event() const; void report_promotion_in_new_plab_event(Klass* klass, size_t obj_size, @@ -262,10 +264,14 @@ void report_evacuation_info(EvacuationInfo* info); void report_evacuation_failed(EvacuationFailedInfo& ef_info); + void report_evacuation_statistics(const G1EvacSummary& young_summary, const G1EvacSummary& old_summary) const; private: void send_g1_young_gc_event(); void send_evacuation_info_event(EvacuationInfo* info); void send_evacuation_failed_event(const EvacuationFailedInfo& ef_info) const; + + void send_young_evacuation_statistics(const G1EvacSummary& summary) const; + void send_old_evacuation_statistics(const G1EvacSummary& summary) const; }; #endif
--- a/src/share/vm/gc/shared/gcTraceSend.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/gcTraceSend.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -234,6 +234,37 @@ e.commit(); } } + +static TraceStructG1EvacStats create_g1_evacstats(unsigned gcid, const G1EvacSummary& summary) { + TraceStructG1EvacStats s; + s.set_gcId(gcid); + s.set_allocated(summary.allocated() * HeapWordSize); + s.set_wasted(summary.wasted() * HeapWordSize); + s.set_used(summary.used() * HeapWordSize); + s.set_undoWaste(summary.undo_wasted() * HeapWordSize); + s.set_regionEndWaste(summary.region_end_waste() * HeapWordSize); + s.set_regionsRefilled(summary.regions_filled()); + s.set_directAllocated(summary.direct_allocated() * HeapWordSize); + s.set_failureUsed(summary.failure_used() * HeapWordSize); + s.set_failureWaste(summary.failure_waste() * HeapWordSize); + return s; +} + +void G1NewTracer::send_young_evacuation_statistics(const G1EvacSummary& summary) const { + EventGCG1EvacuationYoungStatistics surv_evt; + if (surv_evt.should_commit()) { + surv_evt.set_stats(create_g1_evacstats(_shared_gc_info.gc_id().id(), summary)); + surv_evt.commit(); + } +} + +void G1NewTracer::send_old_evacuation_statistics(const G1EvacSummary& summary) const { + EventGCG1EvacuationOldStatistics old_evt; + if (old_evt.should_commit()) { + old_evt.set_stats(create_g1_evacstats(_shared_gc_info.gc_id().id(), summary)); + old_evt.commit(); + } +} #endif static TraceStructVirtualSpace to_trace_struct(const VirtualSpaceSummary& summary) {
--- a/src/share/vm/gc/shared/genCollectedHeap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/genCollectedHeap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -86,7 +86,7 @@ { assert(policy != NULL, "Sanity check"); if (UseConcMarkSweepGC) { - _workers = new FlexibleWorkGang("GC Thread", ParallelGCThreads, + _workers = new WorkGang("GC Thread", ParallelGCThreads, /* are_GC_task_threads */true, /* are_ConcurrentGC_threads */false); _workers->initialize_workers(); @@ -464,7 +464,7 @@ bool prepared_for_verification = false; bool collected_old = false; bool old_collects_young = complete && - _old_gen->full_collects_younger_generations(); + _old_gen->full_collects_young_generation(); if (!old_collects_young && _young_gen->should_collect(full, size, is_tlab)) { if (run_verification && VerifyGCLevel <= 0 && VerifyBeforeGC) { @@ -521,7 +521,7 @@ // a whole heap collection. complete = complete || collected_old; - if (complete) { // We did a "major" collection + if (complete) { // We did a full collection // FIXME: See comment at pre_full_gc_dump call post_full_gc_dump(NULL); // do any post full gc dumps } @@ -668,13 +668,13 @@ void GenCollectedHeap::gen_process_roots(StrongRootsScope* scope, GenerationType type, - bool younger_gens_as_roots, + bool young_gen_as_roots, ScanningOption so, bool only_strong_roots, OopsInGenClosure* not_older_gens, OopsInGenClosure* older_gens, CLDClosure* cld_closure) { - const bool is_adjust_phase = !only_strong_roots && !younger_gens_as_roots; + const bool is_adjust_phase = !only_strong_roots && !young_gen_as_roots; bool is_moving_collection = false; if (type == YoungGen || is_adjust_phase) { @@ -691,7 +691,7 @@ cld_closure, weak_cld_closure, &mark_code_closure); - if (younger_gens_as_roots) { + if (young_gen_as_roots) { if (!_process_strong_tasks->is_task_claimed(GCH_PS_younger_gens)) { if (type == OldGen) { not_older_gens->set_generation(_young_gen); @@ -763,25 +763,25 @@ void GenCollectedHeap::collect(GCCause::Cause cause) { if (should_do_concurrent_full_gc(cause)) { #if INCLUDE_ALL_GCS - // mostly concurrent full collection + // Mostly concurrent full collection. collect_mostly_concurrent(cause); #else // INCLUDE_ALL_GCS ShouldNotReachHere(); #endif // INCLUDE_ALL_GCS } else if (cause == GCCause::_wb_young_gc) { - // minor collection for WhiteBox API + // Young collection for the WhiteBox API. collect(cause, YoungGen); } else { #ifdef ASSERT if (cause == GCCause::_scavenge_alot) { - // minor collection only + // Young collection only. collect(cause, YoungGen); } else { - // Stop-the-world full collection + // Stop-the-world full collection. collect(cause, OldGen); } #else - // Stop-the-world full collection + // Stop-the-world full collection. collect(cause, OldGen); #endif }
--- a/src/share/vm/gc/shared/genCollectedHeap.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/genCollectedHeap.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -30,9 +30,9 @@ #include "gc/shared/collectorPolicy.hpp" #include "gc/shared/generation.hpp" -class FlexibleWorkGang; class StrongRootsScope; class SubTasksDone; +class WorkGang; // A "GenCollectedHeap" is a CollectedHeap that uses generational // collection. It has two generations, young and old. @@ -90,7 +90,7 @@ // In block contents verification, the number of header words to skip NOT_PRODUCT(static size_t _skip_header_HeapWords;) - FlexibleWorkGang* _workers; + WorkGang* _workers; protected: // Helper functions for allocation @@ -124,7 +124,7 @@ public: GenCollectedHeap(GenCollectorPolicy *policy); - FlexibleWorkGang* workers() const { return _workers; } + WorkGang* workers() const { return _workers; } GCStats* gc_stats(Generation* generation) const; @@ -173,8 +173,7 @@ size_t max_capacity() const; - HeapWord* mem_allocate(size_t size, - bool* gc_overhead_limit_was_exceeded); + HeapWord* mem_allocate(size_t size, bool* gc_overhead_limit_was_exceeded); // We may support a shared contiguous allocation area, if the youngest // generation does. @@ -403,7 +402,7 @@ void gen_process_roots(StrongRootsScope* scope, GenerationType type, - bool younger_gens_as_roots, + bool young_gen_as_roots, ScanningOption so, bool only_strong_roots, OopsInGenClosure* not_older_gens,
--- a/src/share/vm/gc/shared/genRemSet.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/genRemSet.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -110,13 +110,11 @@ virtual void print() {} // Informs the RS that the given memregion contains no references to - // younger generations. + // the young generation. virtual void clear(MemRegion mr) = 0; - // Informs the RS that there are no references to generations - // younger than gen from generations gen and older. - // The parameter clear_perm indicates if the perm_gen's - // remembered set should also be processed/cleared. + // Informs the RS that there are no references to the young generation + // from old_gen. virtual void clear_into_younger(Generation* old_gen) = 0; // Informs the RS that refs in the given "mr" may have changed
--- a/src/share/vm/gc/shared/generation.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/generation.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -80,7 +80,6 @@ // first two fields are word-sized.) }; - class Generation: public CHeapObj<mtGC> { friend class VMStructs; private: @@ -299,8 +298,7 @@ // word of "obj" may have been overwritten with a forwarding pointer, and // also taking care to copy the klass pointer *last*. Returns the new // object if successful, or else NULL. - virtual oop par_promote(int thread_num, - oop obj, markOop m, size_t word_sz); + virtual oop par_promote(int thread_num, oop obj, markOop m, size_t word_sz); // Informs the current generation that all par_promote_alloc's in the // collection have been completed; any supporting data structures can be @@ -315,7 +313,7 @@ // This generation will collect all younger generations // during a full collection. - virtual bool full_collects_younger_generations() const { return false; } + virtual bool full_collects_young_generation() const { return false; } // This generation does in-place marking, meaning that mark words // are mutated during the marking phase and presumably reinitialized @@ -370,18 +368,18 @@ // Some generations may require some cleanup or preparation actions before // allowing a collection. The default is to do nothing. - virtual void gc_prologue(bool full) {}; + virtual void gc_prologue(bool full) {} // Some generations may require some cleanup actions after a collection. // The default is to do nothing. - virtual void gc_epilogue(bool full) {}; + virtual void gc_epilogue(bool full) {} // Save the high water marks for the used space in a generation. - virtual void record_spaces_top() {}; + virtual void record_spaces_top() {} // Some generations may need to be "fixed-up" after some allocation // activity to make them parsable again. The default is to do nothing. - virtual void ensure_parsability() {}; + virtual void ensure_parsability() {} // Time (in ms) when we were last collected or now if a collection is // in progress. @@ -417,7 +415,7 @@ virtual void adjust_pointers(); // Mark sweep support phase4 virtual void compact(); - virtual void post_compact() {ShouldNotReachHere();} + virtual void post_compact() { ShouldNotReachHere(); } // Support for CMS's rescan. In this general form we return a pointer // to an abstract object that can be used, based on specific previously @@ -432,7 +430,7 @@ // Some generations may require some cleanup actions before allowing // a verification. - virtual void prepare_for_verify() {}; + virtual void prepare_for_verify() {} // Accessing "marks". @@ -483,7 +481,7 @@ // Give each generation an opportunity to do clean up for any // contributed scratch. - virtual void reset_scratch() {}; + virtual void reset_scratch() {} // When an older generation has been collected, and perhaps resized, // this method will be invoked on all younger generations (from older to
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/shared/memset_with_concurrent_readers.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,104 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" + +#include <string.h> +#include "gc/shared/memset_with_concurrent_readers.hpp" +#include "utilities/debug.hpp" +#include "utilities/globalDefinitions.hpp" +#include "utilities/macros.hpp" +#include "utilities/ostream.hpp" + +#if INCLUDE_ALL_GCS + +// Unit test +#ifdef ASSERT + +static unsigned line_byte(const char* line, size_t i) { + return unsigned(line[i]) & 0xFF; +} + +// Verify memset_with_concurrent_readers mimics memset. +// We don't attempt to verify the concurrent reader case. +void test_memset_with_concurrent_readers() { + const size_t chunk_size = 8 * BytesPerWord; + const unsigned chunk_count = 4; + const size_t block_size = (chunk_count + 4) * chunk_size; + char block[block_size]; + char clear_block[block_size]; + char set_block[block_size]; + + // block format: + // 0: unused leading chunk + // 1: chunk written from start index to end of chunk + // ... nchunks fully written chunks + // N: chunk written from start of chunk to end index + // N+1: unused trailing chunk + + const int clear_value = 0; + const int set_value = 0xAC; + + memset(clear_block, clear_value, block_size); + memset(set_block, set_value, block_size); + + for (unsigned nchunks = 0; nchunks <= chunk_count; ++nchunks) { + for (size_t start = 1; start <= chunk_size; ++start) { + for (size_t end = 0; end <= chunk_size; ++end) { + size_t set_start = chunk_size + start; + size_t set_end = (2 + nchunks) * chunk_size + end; + size_t set_size = set_end - set_start; + + memset(block, clear_value, block_size); + memset_with_concurrent_readers(&block[set_start], set_value, set_size); + bool head_clear = !memcmp(clear_block, block, set_start); + bool middle_set = !memcmp(set_block, block + set_start, set_size); + bool tail_clear = !memcmp(clear_block, block + set_end, block_size - set_end); + if (!(head_clear && middle_set && tail_clear)) { + tty->print_cr("*** memset_with_concurrent_readers failed: " + "set start " SIZE_FORMAT ", set end " SIZE_FORMAT, + set_start, set_end); + for (unsigned chunk = 0; chunk < (block_size / chunk_size); ++chunk) { + for (unsigned line = 0; line < (chunk_size / BytesPerWord); ++line) { + const char* lp = &block[chunk * chunk_size + line * BytesPerWord]; + tty->print_cr("%d,%d: %2x %2x %2x %2x %2x %2x %2x %2x", + chunk, line, + line_byte(lp, 0), line_byte(lp, 1), + line_byte(lp, 2), line_byte(lp, 3), + line_byte(lp, 4), line_byte(lp, 5), + line_byte(lp, 6), line_byte(lp, 7)); + } + } + assert(head_clear, "leading byte not clear"); + assert(middle_set, "memset byte not set"); + assert(tail_clear, "trailing bye not clear"); + } + } + } + } +} + +#endif // end unit test + +#endif // INCLUDE_ALL_GCS
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/gc/shared/memset_with_concurrent_readers.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SRC_SHARE_VM_GC_SHARED_MEMSETWITHCONCURRENTREADERS_HPP +#define SRC_SHARE_VM_GC_SHARED_MEMSETWITHCONCURRENTREADERS_HPP + +#include <stddef.h> +#include <string.h> +#include "utilities/macros.hpp" + +// Only used by concurrent collectors. +#if INCLUDE_ALL_GCS + +// Fill a block of memory with value, like memset, but with the +// understanding that there may be concurrent readers of that memory. +void memset_with_concurrent_readers(void* to, int value, size_t size); + +#ifdef TARGET_ARCH_sparc + +// SPARC requires special handling. See SPARC-specific definition. + +#else +// All others just use memset. + +inline void memset_with_concurrent_readers(void* to, int value, size_t size) { + ::memset(to, value, size); +} + +#endif // End of target dispatch. + +#endif // INCLUDE_ALL_GCS + +#endif // include guard
--- a/src/share/vm/gc/shared/modRefBarrierSet.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/modRefBarrierSet.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -60,7 +60,6 @@ : BarrierSet(fake_rtti.add_tag(BarrierSet::ModRef)) { } ~ModRefBarrierSet() { } - virtual void write_ref_field_work(void* field, oop new_val, bool release = false) = 0; public: void write_prim_field(HeapWord* field, size_t bytes, juint val1, juint val2) {}
--- a/src/share/vm/gc/shared/plab.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/plab.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -24,7 +24,7 @@ #include "precompiled.hpp" #include "gc/shared/collectedHeap.hpp" -#include "gc/shared/plab.hpp" +#include "gc/shared/plab.inline.hpp" #include "gc/shared/threadLocalAllocBuffer.hpp" #include "oops/arrayOop.hpp" #include "oops/oop.inline.hpp"
--- a/src/share/vm/gc/shared/plab.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/plab.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,7 +27,6 @@ #include "gc/shared/gcUtil.hpp" #include "memory/allocation.hpp" -#include "runtime/atomic.hpp" #include "utilities/globalDefinitions.hpp" // Forward declarations. @@ -75,6 +74,8 @@ PLAB(size_t word_sz); virtual ~PLAB() {} + static size_t size_required_for_allocation(size_t word_size) { return word_size + AlignmentReserve; } + // Minimum PLAB size. static size_t min_size(); // Maximum PLAB size. @@ -95,7 +96,7 @@ } // Allocate the object aligned to "alignment_in_bytes". - HeapWord* allocate_aligned(size_t word_sz, unsigned short alignment_in_bytes); + inline HeapWord* allocate_aligned(size_t word_sz, unsigned short alignment_in_bytes); // Undo any allocation in the buffer, which is required to be of the // "obj" of the given "word_sz". @@ -108,13 +109,6 @@ size_t waste() { return _wasted; } size_t undo_waste() { return _undo_wasted; } - // Should only be done if we are about to reset with a new buffer of the - // given size. - void set_word_size(size_t new_word_sz) { - assert(new_word_sz > AlignmentReserve, "Too small"); - _word_sz = new_word_sz; - } - // The number of words of unallocated space remaining in the buffer. size_t words_remaining() { assert(_end >= _top, "Negative buffer"); @@ -126,7 +120,10 @@ } // Sets the space of the buffer to be [buf, space+word_sz()). - virtual void set_buf(HeapWord* buf) { + virtual void set_buf(HeapWord* buf, size_t new_word_sz) { + assert(new_word_sz > AlignmentReserve, "Too small"); + _word_sz = new_word_sz; + _bottom = buf; _top = _bottom; _hard_end = _bottom + word_sz(); @@ -149,7 +146,8 @@ }; // PLAB book-keeping. -class PLABStats VALUE_OBJ_CLASS_SPEC { +class PLABStats : public CHeapObj<mtGC> { + protected: size_t _allocated; // Total allocated size_t _wasted; // of which wasted (internal fragmentation) size_t _undo_wasted; // of which wasted on undo (is not used for calculation of PLAB size) @@ -158,7 +156,7 @@ AdaptiveWeightedAverage _filter; // Integrator with decay - void reset() { + virtual void reset() { _allocated = 0; _wasted = 0; _undo_wasted = 0; @@ -174,6 +172,8 @@ _filter(wt) { } + virtual ~PLABStats() { } + static const size_t min_size() { return PLAB::min_size(); } @@ -187,23 +187,15 @@ // Updates the current desired PLAB size. Computes the new desired PLAB size with one gc worker thread, // updates _desired_plab_sz and clears sensor accumulators. - void adjust_desired_plab_sz(); + virtual void adjust_desired_plab_sz(); - void add_allocated(size_t v) { - Atomic::add_ptr(v, &_allocated); - } + inline void add_allocated(size_t v); - void add_unused(size_t v) { - Atomic::add_ptr(v, &_unused); - } + inline void add_unused(size_t v); - void add_wasted(size_t v) { - Atomic::add_ptr(v, &_wasted); - } + inline void add_wasted(size_t v); - void add_undo_wasted(size_t v) { - Atomic::add_ptr(v, &_undo_wasted); - } + inline void add_undo_wasted(size_t v); }; #endif // SHARE_VM_GC_SHARED_PLAB_HPP
--- a/src/share/vm/gc/shared/plab.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/plab.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,9 +27,10 @@ #include "gc/shared/collectedHeap.inline.hpp" #include "gc/shared/plab.hpp" +#include "memory/allocation.inline.hpp" +#include "runtime/atomic.inline.hpp" -HeapWord* PLAB::allocate_aligned(size_t word_sz, unsigned short alignment_in_bytes) { - +inline HeapWord* PLAB::allocate_aligned(size_t word_sz, unsigned short alignment_in_bytes) { HeapWord* res = CollectedHeap::align_allocation_or_fail(_top, _end, alignment_in_bytes); if (res == NULL) { return NULL; @@ -41,4 +42,20 @@ return allocate(word_sz); } +void PLABStats::add_allocated(size_t v) { + Atomic::add_ptr(v, &_allocated); +} + +void PLABStats::add_unused(size_t v) { + Atomic::add_ptr(v, &_unused); +} + +void PLABStats::add_wasted(size_t v) { + Atomic::add_ptr(v, &_wasted); +} + +void PLABStats::add_undo_wasted(size_t v) { + Atomic::add_ptr(v, &_undo_wasted); +} + #endif // SHARE_VM_GC_SHARED_PLAB_INLINE_HPP
--- a/src/share/vm/gc/shared/referenceProcessor.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/referenceProcessor.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -243,10 +243,13 @@ process_discovered_reflist(_discoveredPhantomRefs, NULL, false, is_alive, keep_alive, complete_gc, task_executor); - // Process cleaners, but include them in phantom statistics. We expect - // Cleaner references to be temporary, and don't want to deal with - // possible incompatibilities arising from making it more visible. - phantom_count += + } + + // Cleaners + size_t cleaner_count = 0; + { + GCTraceTime tt("Cleaners", trace_time, false, gc_timer, gc_id); + cleaner_count = process_discovered_reflist(_discoveredCleanerRefs, NULL, true, is_alive, keep_alive, complete_gc, task_executor); } @@ -256,15 +259,17 @@ // that is not how the JDK1.2 specification is. See #4126360. Native code can // thus use JNI weak references to circumvent the phantom references and // resurrect a "post-mortem" object. + size_t jni_weak_ref_count = 0; { GCTraceTime tt("JNI Weak Reference", trace_time, false, gc_timer, gc_id); if (task_executor != NULL) { task_executor->set_single_threaded_mode(); } - process_phaseJNI(is_alive, keep_alive, complete_gc); + jni_weak_ref_count = + process_phaseJNI(is_alive, keep_alive, complete_gc); } - return ReferenceProcessorStats(soft_count, weak_count, final_count, phantom_count); + return ReferenceProcessorStats(soft_count, weak_count, final_count, phantom_count, cleaner_count, jni_weak_ref_count); } #ifndef PRODUCT @@ -291,17 +296,17 @@ } #endif -void ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive, - OopClosure* keep_alive, - VoidClosure* complete_gc) { -#ifndef PRODUCT +size_t ReferenceProcessor::process_phaseJNI(BoolObjectClosure* is_alive, + OopClosure* keep_alive, + VoidClosure* complete_gc) { + DEBUG_ONLY(size_t check_count = count_jni_refs();) + size_t count = JNIHandles::weak_oops_do(is_alive, keep_alive); + assert(count == check_count, "Counts didn't match"); + complete_gc->do_void(); if (PrintGCDetails && PrintReferenceGC) { - unsigned int count = count_jni_refs(); - gclog_or_tty->print(", %u refs", count); + gclog_or_tty->print(", " SIZE_FORMAT " refs", count); } -#endif - JNIHandles::weak_oops_do(is_alive, keep_alive); - complete_gc->do_void(); + return count; } @@ -944,9 +949,10 @@ list = &_discoveredCleanerRefs[id]; break; case REF_NONE: + case REF_JNI: // we should not reach here if we are an InstanceRefKlass default: - ShouldNotReachHere(); + guarantee(false, err_msg("rt should not be %d", rt)); } if (TraceReferenceGC && PrintGCDetails) { gclog_or_tty->print_cr("Thread %d gets list " INTPTR_FORMAT, id, p2i(list)); @@ -1067,7 +1073,7 @@ // can mark through them now, rather than delaying that // to the reference-processing phase. Since all current // time-stamp policies advance the soft-ref clock only - // at a major collection cycle, this is always currently + // at a full collection cycle, this is always currently // accurate. if (!_current_soft_ref_policy->should_clear_reference(obj, _soft_ref_timestamp_clock)) { return false;
--- a/src/share/vm/gc/shared/referenceProcessor.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/referenceProcessor.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -247,7 +247,7 @@ DiscoveredList* _discoveredCleanerRefs; public: - static int number_of_subclasses_of_ref() { return (REF_CLEANER - REF_OTHER); } + static int number_of_subclasses_of_ref() { return REF_LISTS_COUNT; } uint num_q() { return _num_q; } uint max_num_q() { return _max_num_q; } @@ -271,9 +271,9 @@ VoidClosure* complete_gc, AbstractRefProcTaskExecutor* task_executor); - void process_phaseJNI(BoolObjectClosure* is_alive, - OopClosure* keep_alive, - VoidClosure* complete_gc); + size_t process_phaseJNI(BoolObjectClosure* is_alive, + OopClosure* keep_alive, + VoidClosure* complete_gc); // Work methods used by the method process_discovered_reflist // Phase1: keep alive all those referents that are otherwise
--- a/src/share/vm/gc/shared/referenceProcessorStats.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/referenceProcessorStats.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -36,22 +36,30 @@ size_t _weak_count; size_t _final_count; size_t _phantom_count; + size_t _cleaner_count; + size_t _jni_weak_ref_count; public: ReferenceProcessorStats() : _soft_count(0), _weak_count(0), _final_count(0), - _phantom_count(0) {} + _phantom_count(0), + _cleaner_count(0), + _jni_weak_ref_count(0) {} ReferenceProcessorStats(size_t soft_count, size_t weak_count, size_t final_count, - size_t phantom_count) : + size_t phantom_count, + size_t cleaner_count, + size_t jni_weak_ref_count) : _soft_count(soft_count), _weak_count(weak_count), _final_count(final_count), - _phantom_count(phantom_count) + _phantom_count(phantom_count), + _cleaner_count(cleaner_count), + _jni_weak_ref_count(jni_weak_ref_count) {} size_t soft_count() const { @@ -69,5 +77,13 @@ size_t phantom_count() const { return _phantom_count; } + + size_t cleaner_count() const { + return _cleaner_count; + } + + size_t jni_weak_ref_count() const { + return _jni_weak_ref_count; + } }; #endif
--- a/src/share/vm/gc/shared/space.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/space.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -237,7 +237,7 @@ HeapWord* bottom, \ HeapWord* top, \ ClosureType* cl) { \ - bottom += oop(bottom)->oop_iterate(cl, mr); \ + bottom += oop(bottom)->oop_iterate_size(cl, mr); \ if (bottom < top) { \ HeapWord* next_obj = bottom + oop(bottom)->size(); \ while (next_obj < top) { \ @@ -508,7 +508,7 @@ HeapWord* t = mr.end(); \ while (obj_addr < t) { \ assert(oop(obj_addr)->is_oop(), "Should be an oop"); \ - obj_addr += oop(obj_addr)->oop_iterate(blk); \ + obj_addr += oop(obj_addr)->oop_iterate_size(blk); \ } \ } @@ -523,7 +523,7 @@ HeapWord* t = top(); // Could call objects iterate, but this is easier. while (obj_addr < t) { - obj_addr += oop(obj_addr)->oop_iterate(blk); + obj_addr += oop(obj_addr)->oop_iterate_size(blk); } } @@ -578,7 +578,7 @@ Prefetch::write(p, interval); \ debug_only(HeapWord* prev = p); \ oop m = oop(p); \ - p += m->oop_iterate(blk); \ + p += m->oop_iterate_size(blk); \ } \ } while (t < top()); \ \
--- a/src/share/vm/gc/shared/specialized_oop_closures.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/specialized_oop_closures.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -42,6 +42,8 @@ class ScanClosure; class FastScanClosure; class FilteringClosure; +// MarkSweep +class MarkAndPushClosure; // ParNew class ParScanWithBarrierClosure; class ParScanWithoutBarrierClosure; @@ -87,6 +89,9 @@ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_S(f) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_P(f) +#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(f) \ + f(MarkAndPushClosure,_nv) + #if INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_CMS(f) \ f(MarkRefsIntoAndScanClosure,_nv) \ @@ -101,10 +106,12 @@ #if INCLUDE_ALL_GCS #define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) \ + SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(f) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_CMS(f) \ SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_G1(f) #else // INCLUDE_ALL_GCS -#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) +#define SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_2(f) \ + SPECIALIZED_OOP_OOP_ITERATE_CLOSURES_MS(f) #endif // INCLUDE_ALL_GCS
--- a/src/share/vm/gc/shared/taskqueue.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/taskqueue.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -269,8 +269,8 @@ #ifdef ASSERT bool ObjArrayTask::is_valid() const { - return _obj != NULL && _obj->is_objArray() && _index > 0 && - _index < objArrayOop(_obj)->length(); + return _obj != NULL && _obj->is_objArray() && _index >= 0 && + _index < objArrayOop(_obj)->length(); } #endif // ASSERT
--- a/src/share/vm/gc/shared/vmGCOperations.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/vmGCOperations.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -213,15 +213,18 @@ size_t _size; // size of object to be allocated Metaspace::MetadataType _mdtype; ClassLoaderData* _loader_data; + public: VM_CollectForMetadataAllocation(ClassLoaderData* loader_data, - size_t size, Metaspace::MetadataType mdtype, + size_t size, + Metaspace::MetadataType mdtype, uint gc_count_before, uint full_gc_count_before, GCCause::Cause gc_cause) : VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true), _loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) { } + virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; } virtual void doit(); MetaWord* result() const { return _result; }
--- a/src/share/vm/gc/shared/workgroup.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/workgroup.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,58 +28,25 @@ #include "memory/allocation.inline.hpp" #include "runtime/atomic.inline.hpp" #include "runtime/os.hpp" +#include "runtime/semaphore.hpp" +#include "runtime/thread.inline.hpp" // Definitions of WorkGang methods. -AbstractWorkGang::AbstractWorkGang(const char* name, - bool are_GC_task_threads, - bool are_ConcurrentGC_threads) : - _name(name), - _are_GC_task_threads(are_GC_task_threads), - _are_ConcurrentGC_threads(are_ConcurrentGC_threads) { - - assert(!(are_GC_task_threads && are_ConcurrentGC_threads), - "They cannot both be STW GC and Concurrent threads" ); - - // Other initialization. - _monitor = new Monitor(/* priority */ Mutex::leaf, - /* name */ "WorkGroup monitor", - /* allow_vm_block */ are_GC_task_threads, - Monitor::_safepoint_check_sometimes); - assert(monitor() != NULL, "Failed to allocate monitor"); - _task = NULL; - _sequence_number = 0; - _started_workers = 0; - _finished_workers = 0; -} - -WorkGang::WorkGang(const char* name, - uint workers, - bool are_GC_task_threads, - bool are_ConcurrentGC_threads) : - AbstractWorkGang(name, are_GC_task_threads, are_ConcurrentGC_threads) { - _total_workers = workers; -} - -GangWorker* WorkGang::allocate_worker(uint which) { - GangWorker* new_worker = new GangWorker(this, which); - return new_worker; -} - // The current implementation will exit if the allocation // of any worker fails. Still, return a boolean so that // a future implementation can possibly do a partial // initialization of the workers and report such to the // caller. -bool WorkGang::initialize_workers() { +bool AbstractWorkGang::initialize_workers() { if (TraceWorkGang) { tty->print_cr("Constructing work gang %s with %d threads", name(), total_workers()); } - _gang_workers = NEW_C_HEAP_ARRAY(GangWorker*, total_workers(), mtInternal); - if (gang_workers() == NULL) { + _workers = NEW_C_HEAP_ARRAY(AbstractGangWorker*, total_workers(), mtInternal); + if (_workers == NULL) { vm_exit_out_of_memory(0, OOM_MALLOC_ERROR, "Cannot create GangWorker array."); return false; } @@ -90,9 +57,9 @@ worker_type = os::pgc_thread; } for (uint worker = 0; worker < total_workers(); worker += 1) { - GangWorker* new_worker = allocate_worker(worker); + AbstractGangWorker* new_worker = allocate_worker(worker); assert(new_worker != NULL, "Failed to allocate GangWorker"); - _gang_workers[worker] = new_worker; + _workers[worker] = new_worker; if (new_worker == NULL || !os::create_thread(new_worker, worker_type)) { vm_exit_out_of_memory(0, OOM_MALLOC_ERROR, "Cannot create worker GC thread. Out of system resources."); @@ -105,110 +72,208 @@ return true; } -GangWorker* AbstractWorkGang::gang_worker(uint i) const { +AbstractGangWorker* AbstractWorkGang::worker(uint i) const { // Array index bounds checking. - GangWorker* result = NULL; - assert(gang_workers() != NULL, "No workers for indexing"); + AbstractGangWorker* result = NULL; + assert(_workers != NULL, "No workers for indexing"); assert(i < total_workers(), "Worker index out of bounds"); - result = _gang_workers[i]; + result = _workers[i]; assert(result != NULL, "Indexing to null worker"); return result; } -void WorkGang::run_task(AbstractGangTask* task) { - run_task(task, total_workers()); -} - -void WorkGang::run_task(AbstractGangTask* task, uint no_of_parallel_workers) { - // This thread is executed by the VM thread which does not block - // on ordinary MutexLocker's. - MutexLockerEx ml(monitor(), Mutex::_no_safepoint_check_flag); - if (TraceWorkGang) { - tty->print_cr("Running work gang %s task %s", name(), task->name()); - } - // Tell all the workers to run a task. - assert(task != NULL, "Running a null task"); - // Initialize. - _task = task; - _sequence_number += 1; - _started_workers = 0; - _finished_workers = 0; - // Tell the workers to get to work. - monitor()->notify_all(); - // Wait for them to be finished - while (finished_workers() < no_of_parallel_workers) { - if (TraceWorkGang) { - tty->print_cr("Waiting in work gang %s: %u/%u finished sequence %d", - name(), finished_workers(), no_of_parallel_workers, - _sequence_number); - } - monitor()->wait(/* no_safepoint_check */ true); - } - _task = NULL; - if (TraceWorkGang) { - tty->print_cr("\nFinished work gang %s: %u/%u sequence %d", - name(), finished_workers(), no_of_parallel_workers, - _sequence_number); - Thread* me = Thread::current(); - tty->print_cr(" T: " PTR_FORMAT " VM_thread: %d", p2i(me), me->is_VM_thread()); - } -} - -void FlexibleWorkGang::run_task(AbstractGangTask* task) { - // If active_workers() is passed, _finished_workers - // must only be incremented for workers that find non_null - // work (as opposed to all those that just check that the - // task is not null). - WorkGang::run_task(task, (uint) active_workers()); -} - -void AbstractWorkGang::internal_worker_poll(WorkData* data) const { - assert(monitor()->owned_by_self(), "worker_poll is an internal method"); - assert(data != NULL, "worker data is null"); - data->set_task(task()); - data->set_sequence_number(sequence_number()); -} - -void AbstractWorkGang::internal_note_start() { - assert(monitor()->owned_by_self(), "note_finish is an internal method"); - _started_workers += 1; -} - -void AbstractWorkGang::internal_note_finish() { - assert(monitor()->owned_by_self(), "note_finish is an internal method"); - _finished_workers += 1; -} - void AbstractWorkGang::print_worker_threads_on(outputStream* st) const { - uint num_thr = total_workers(); - for (uint i = 0; i < num_thr; i++) { - gang_worker(i)->print_on(st); + uint workers = total_workers(); + for (uint i = 0; i < workers; i++) { + worker(i)->print_on(st); st->cr(); } } void AbstractWorkGang::threads_do(ThreadClosure* tc) const { assert(tc != NULL, "Null ThreadClosure"); - uint num_thr = total_workers(); - for (uint i = 0; i < num_thr; i++) { - tc->do_thread(gang_worker(i)); + uint workers = total_workers(); + for (uint i = 0; i < workers; i++) { + tc->do_thread(worker(i)); } } -// GangWorker methods. +// WorkGang dispatcher implemented with semaphores. +// +// Semaphores don't require the worker threads to re-claim the lock when they wake up. +// This helps lowering the latency when starting and stopping the worker threads. +class SemaphoreGangTaskDispatcher : public GangTaskDispatcher { + // The task currently being dispatched to the GangWorkers. + AbstractGangTask* _task; + + volatile uint _started; + volatile uint _not_finished; + + // Semaphore used to start the GangWorkers. + Semaphore* _start_semaphore; + // Semaphore used to notify the coordinator that all workers are done. + Semaphore* _end_semaphore; + +public: + SemaphoreGangTaskDispatcher() : + _task(NULL), + _started(0), + _not_finished(0), + _start_semaphore(new Semaphore()), + _end_semaphore(new Semaphore()) +{ } + + ~SemaphoreGangTaskDispatcher() { + delete _start_semaphore; + delete _end_semaphore; + } + + void coordinator_execute_on_workers(AbstractGangTask* task, uint num_workers) { + // No workers are allowed to read the state variables until they have been signaled. + _task = task; + _not_finished = num_workers; + + // Dispatch 'num_workers' number of tasks. + _start_semaphore->signal(num_workers); + + // Wait for the last worker to signal the coordinator. + _end_semaphore->wait(); + + // No workers are allowed to read the state variables after the coordinator has been signaled. + assert(_not_finished == 0, err_msg("%d not finished workers?", _not_finished)); + _task = NULL; + _started = 0; + + } + + WorkData worker_wait_for_task() { + // Wait for the coordinator to dispatch a task. + _start_semaphore->wait(); + + uint num_started = (uint) Atomic::add(1, (volatile jint*)&_started); + + // Subtract one to get a zero-indexed worker id. + uint worker_id = num_started - 1; + + return WorkData(_task, worker_id); + } + + void worker_done_with_task() { + // Mark that the worker is done with the task. + // The worker is not allowed to read the state variables after this line. + uint not_finished = (uint) Atomic::add(-1, (volatile jint*)&_not_finished); + + // The last worker signals to the coordinator that all work is completed. + if (not_finished == 0) { + _end_semaphore->signal(); + } + } +}; + +class MutexGangTaskDispatcher : public GangTaskDispatcher { + AbstractGangTask* _task; + + volatile uint _started; + volatile uint _finished; + volatile uint _num_workers; + + Monitor* _monitor; -GangWorker::GangWorker(AbstractWorkGang* gang, uint id) { + public: + MutexGangTaskDispatcher() + : _task(NULL), + _monitor(new Monitor(Monitor::leaf, "WorkGang dispatcher lock", false, Monitor::_safepoint_check_never)), + _started(0), + _finished(0), + _num_workers(0) {} + + ~MutexGangTaskDispatcher() { + delete _monitor; + } + + void coordinator_execute_on_workers(AbstractGangTask* task, uint num_workers) { + MutexLockerEx ml(_monitor, Mutex::_no_safepoint_check_flag); + + _task = task; + _num_workers = num_workers; + + // Tell the workers to get to work. + _monitor->notify_all(); + + // Wait for them to finish. + while (_finished < _num_workers) { + _monitor->wait(/* no_safepoint_check */ true); + } + + _task = NULL; + _num_workers = 0; + _started = 0; + _finished = 0; + } + + WorkData worker_wait_for_task() { + MonitorLockerEx ml(_monitor, Mutex::_no_safepoint_check_flag); + + while (_num_workers == 0 || _started == _num_workers) { + _monitor->wait(/* no_safepoint_check */ true); + } + + _started++; + + // Subtract one to get a zero-indexed worker id. + uint worker_id = _started - 1; + + return WorkData(_task, worker_id); + } + + void worker_done_with_task() { + MonitorLockerEx ml(_monitor, Mutex::_no_safepoint_check_flag); + + _finished++; + + if (_finished == _num_workers) { + // This will wake up all workers and not only the coordinator. + _monitor->notify_all(); + } + } +}; + +static GangTaskDispatcher* create_dispatcher() { + if (UseSemaphoreGCThreadsSynchronization) { + return new SemaphoreGangTaskDispatcher(); + } + + return new MutexGangTaskDispatcher(); +} + +WorkGang::WorkGang(const char* name, + uint workers, + bool are_GC_task_threads, + bool are_ConcurrentGC_threads) : + AbstractWorkGang(name, workers, are_GC_task_threads, are_ConcurrentGC_threads), + _dispatcher(create_dispatcher()) +{ } + +AbstractGangWorker* WorkGang::allocate_worker(uint worker_id) { + return new GangWorker(this, worker_id); +} + +void WorkGang::run_task(AbstractGangTask* task) { + _dispatcher->coordinator_execute_on_workers(task, active_workers()); +} + +AbstractGangWorker::AbstractGangWorker(AbstractWorkGang* gang, uint id) { _gang = gang; set_id(id); set_name("%s#%d", gang->name(), id); } -void GangWorker::run() { +void AbstractGangWorker::run() { initialize(); loop(); } -void GangWorker::initialize() { +void AbstractGangWorker::initialize() { this->initialize_thread_local_storage(); this->record_stack_base_and_size(); this->initialize_named_thread(); @@ -224,112 +289,59 @@ " of a work gang"); } -void GangWorker::loop() { - int previous_sequence_number = 0; - Monitor* gang_monitor = gang()->monitor(); - for ( ; ; ) { - WorkData data; - int part; // Initialized below. - { - // Grab the gang mutex. - MutexLocker ml(gang_monitor); - // Wait for something to do. - // Polling outside the while { wait } avoids missed notifies - // in the outer loop. - gang()->internal_worker_poll(&data); - if (TraceWorkGang) { - tty->print("Polled outside for work in gang %s worker %u", - gang()->name(), id()); - tty->print(" sequence: %d (prev: %d)", - data.sequence_number(), previous_sequence_number); - if (data.task() != NULL) { - tty->print(" task: %s", data.task()->name()); - } else { - tty->print(" task: NULL"); - } - tty->cr(); - } - for ( ; /* break */; ) { - // Check for new work. - if ((data.task() != NULL) && - (data.sequence_number() != previous_sequence_number)) { - if (gang()->needs_more_workers()) { - gang()->internal_note_start(); - gang_monitor->notify_all(); - part = gang()->started_workers() - 1; - break; - } - } - // Nothing to do. - gang_monitor->wait(/* no_safepoint_check */ true); - gang()->internal_worker_poll(&data); - if (TraceWorkGang) { - tty->print("Polled inside for work in gang %s worker %u", - gang()->name(), id()); - tty->print(" sequence: %d (prev: %d)", - data.sequence_number(), previous_sequence_number); - if (data.task() != NULL) { - tty->print(" task: %s", data.task()->name()); - } else { - tty->print(" task: NULL"); - } - tty->cr(); - } - } - // Drop gang mutex. - } - if (TraceWorkGang) { - tty->print("Work for work gang %s id %u task %s part %d", - gang()->name(), id(), data.task()->name(), part); - } - assert(data.task() != NULL, "Got null task"); - data.task()->work(part); - { - if (TraceWorkGang) { - tty->print("Finish for work gang %s id %u task %s part %d", - gang()->name(), id(), data.task()->name(), part); - } - // Grab the gang mutex. - MutexLocker ml(gang_monitor); - gang()->internal_note_finish(); - // Tell the gang you are done. - gang_monitor->notify_all(); - // Drop the gang mutex. - } - previous_sequence_number = data.sequence_number(); - } -} - -bool GangWorker::is_GC_task_thread() const { +bool AbstractGangWorker::is_GC_task_thread() const { return gang()->are_GC_task_threads(); } -bool GangWorker::is_ConcurrentGC_thread() const { +bool AbstractGangWorker::is_ConcurrentGC_thread() const { return gang()->are_ConcurrentGC_threads(); } -void GangWorker::print_on(outputStream* st) const { +void AbstractGangWorker::print_on(outputStream* st) const { st->print("\"%s\" ", name()); Thread::print_on(st); st->cr(); } -// Printing methods +WorkData GangWorker::wait_for_task() { + return gang()->dispatcher()->worker_wait_for_task(); +} -const char* AbstractWorkGang::name() const { - return _name; +void GangWorker::signal_task_done() { + gang()->dispatcher()->worker_done_with_task(); +} + +void GangWorker::print_task_started(WorkData data) { + if (TraceWorkGang) { + tty->print_cr("Running work gang %s task %s worker %u", name(), data._task->name(), data._worker_id); + } } -#ifndef PRODUCT - -const char* AbstractGangTask::name() const { - return _name; +void GangWorker::print_task_done(WorkData data) { + if (TraceWorkGang) { + tty->print_cr("\nFinished work gang %s task %s worker %u", name(), data._task->name(), data._worker_id); + Thread* me = Thread::current(); + tty->print_cr(" T: " PTR_FORMAT " VM_thread: %d", p2i(me), me->is_VM_thread()); + } } -#endif /* PRODUCT */ +void GangWorker::run_task(WorkData data) { + print_task_started(data); + + data._task->work(data._worker_id); + + print_task_done(data); +} -// FlexibleWorkGang +void GangWorker::loop() { + while (true) { + WorkData data = wait_for_task(); + run_task(data); + + signal_task_done(); + } +} // *** WorkGangBarrierSync
--- a/src/share/vm/gc/shared/workgroup.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shared/workgroup.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,282 +25,111 @@ #ifndef SHARE_VM_GC_SHARED_WORKGROUP_HPP #define SHARE_VM_GC_SHARED_WORKGROUP_HPP -#include "gc/shared/taskqueue.hpp" -#include "runtime/thread.inline.hpp" +#include "memory/allocation.hpp" +#include "runtime/globals.hpp" +#include "runtime/thread.hpp" +#include "utilities/debug.hpp" +#include "utilities/globalDefinitions.hpp" // Task class hierarchy: // AbstractGangTask -// AbstractGangTaskWOopQueues // // Gang/Group class hierarchy: // AbstractWorkGang // WorkGang -// FlexibleWorkGang -// YieldingFlexibleWorkGang (defined in another file) +// YieldingFlexibleWorkGang (defined in another file) // // Worker class hierarchy: -// GangWorker (subclass of WorkerThread) +// AbstractGangWorker (subclass of WorkerThread) +// GangWorker // YieldingFlexibleGangWorker (defined in another file) // Forward declarations of classes defined here +class AbstractGangWorker; +class Semaphore; class WorkGang; -class GangWorker; -class YieldingFlexibleGangWorker; -class YieldingFlexibleGangTask; -class WorkData; -class AbstractWorkGang; // An abstract task to be worked on by a gang. // You subclass this to supply your own work() method class AbstractGangTask VALUE_OBJ_CLASS_SPEC { -public: + const char* _name; + + public: + AbstractGangTask(const char* name) : _name(name) {} + // The abstract work method. // The argument tells you which member of the gang you are. virtual void work(uint worker_id) = 0; // Debugging accessor for the name. - const char* name() const PRODUCT_RETURN_(return NULL;); - int counter() { return _counter; } - void set_counter(int value) { _counter = value; } - int *address_of_counter() { return &_counter; } - - // RTTI - NOT_PRODUCT(virtual bool is_YieldingFlexibleGang_task() const { - return false; - }) + const char* name() const { return _name; } +}; -private: - NOT_PRODUCT(const char* _name;) - // ??? Should a task have a priority associated with it? - // ??? Or can the run method adjust priority as needed? - int _counter; - -protected: - // Constructor and desctructor: only construct subclasses. - AbstractGangTask(const char* name) - { - NOT_PRODUCT(_name = name); - _counter = 0; - } - ~AbstractGangTask() { } - -public: +struct WorkData { + AbstractGangTask* _task; + uint _worker_id; + WorkData(AbstractGangTask* task, uint worker_id) : _task(task), _worker_id(worker_id) {} }; -class AbstractGangTaskWOopQueues : public AbstractGangTask { - OopTaskQueueSet* _queues; - ParallelTaskTerminator _terminator; +// Interface to handle the synchronization between the coordinator thread and the worker threads, +// when a task is dispatched out to the worker threads. +class GangTaskDispatcher : public CHeapObj<mtGC> { public: - AbstractGangTaskWOopQueues(const char* name, OopTaskQueueSet* queues, uint n_threads) : - AbstractGangTask(name), _queues(queues), _terminator(n_threads, _queues) {} - ParallelTaskTerminator* terminator() { return &_terminator; } - OopTaskQueueSet* queues() { return _queues; } + virtual ~GangTaskDispatcher() {} + + // Coordinator API. + + // Distributes the task out to num_workers workers. + // Returns when the task has been completed by all workers. + virtual void coordinator_execute_on_workers(AbstractGangTask* task, uint num_workers) = 0; + + // Worker API. + + // Waits for a task to become available to the worker. + // Returns when the worker has been assigned a task. + virtual WorkData worker_wait_for_task() = 0; + + // Signal to the coordinator that the worker is done with the assigned task. + virtual void worker_done_with_task() = 0; }; +// The work gang is the collection of workers to execute tasks. +// The number of workers run for a task is "_active_workers" +// while "_total_workers" is the number of available of workers. +class AbstractWorkGang : public CHeapObj<mtInternal> { + protected: + // The array of worker threads for this gang. + AbstractGangWorker** _workers; + // The count of the number of workers in the gang. + uint _total_workers; + // The currently active workers in this gang. + uint _active_workers; + // Printing support. + const char* _name; -// Class AbstractWorkGang: -// An abstract class representing a gang of workers. -// You subclass this to supply an implementation of run_task(). -class AbstractWorkGang: public CHeapObj<mtInternal> { -protected: - // Work gangs are never deleted, so no need to cleanup. - ~AbstractWorkGang() { ShouldNotReachHere(); } -public: - // Constructor. - AbstractWorkGang(const char* name, bool are_GC_task_threads, - bool are_ConcurrentGC_threads); - // Run a task, returns when the task is done (or terminated). - virtual void run_task(AbstractGangTask* task) = 0; - // Return true if more workers should be applied to the task. - virtual bool needs_more_workers() const { return true; } -public: - // Debugging. - const char* name() const; -protected: + private: // Initialize only instance data. const bool _are_GC_task_threads; const bool _are_ConcurrentGC_threads; - // Printing support. - const char* _name; - // The monitor which protects these data, - // and notifies of changes in it. - Monitor* _monitor; - // The count of the number of workers in the gang. - uint _total_workers; - // The array of worker threads for this gang. - // This is only needed for cleaning up. - GangWorker** _gang_workers; - // The task for this gang. - AbstractGangTask* _task; - // A sequence number for the current task. - int _sequence_number; - // The number of started workers. - uint _started_workers; - // The number of finished workers. - uint _finished_workers; -public: - // Accessors for fields - Monitor* monitor() const { - return _monitor; - } - uint total_workers() const { - return _total_workers; - } - virtual uint active_workers() const { - return _total_workers; - } - GangWorker** gang_workers() const { - return _gang_workers; - } - AbstractGangTask* task() const { - return _task; - } - int sequence_number() const { - return _sequence_number; - } - uint started_workers() const { - return _started_workers; - } - uint finished_workers() const { - return _finished_workers; - } - bool are_GC_task_threads() const { - return _are_GC_task_threads; - } - bool are_ConcurrentGC_threads() const { - return _are_ConcurrentGC_threads; - } - // Predicates. - bool is_idle() const { - return (task() == NULL); - } - // Return the Ith gang worker. - GangWorker* gang_worker(uint i) const; - - void threads_do(ThreadClosure* tc) const; - - // Printing - void print_worker_threads_on(outputStream *st) const; - void print_worker_threads() const { - print_worker_threads_on(tty); - } - -protected: - friend class GangWorker; - friend class YieldingFlexibleGangWorker; - // Note activation and deactivation of workers. - // These methods should only be called with the mutex held. - void internal_worker_poll(WorkData* data) const; - void internal_note_start(); - void internal_note_finish(); -}; -class WorkData: public StackObj { - // This would be a struct, but I want accessor methods. -private: - AbstractGangTask* _task; - int _sequence_number; -public: - // Constructor and destructor - WorkData() { - _task = NULL; - _sequence_number = 0; - } - ~WorkData() { - } - AbstractGangTask* task() const { return _task; } - void set_task(AbstractGangTask* value) { _task = value; } - int sequence_number() const { return _sequence_number; } - void set_sequence_number(int value) { _sequence_number = value; } - - YieldingFlexibleGangTask* yf_task() const { - return (YieldingFlexibleGangTask*)_task; - } -}; - -// Class WorkGang: -class WorkGang: public AbstractWorkGang { -public: - // Constructor - WorkGang(const char* name, uint workers, - bool are_GC_task_threads, bool are_ConcurrentGC_threads); - // Run a task, returns when the task is done (or terminated). - virtual void run_task(AbstractGangTask* task); - void run_task(AbstractGangTask* task, uint no_of_parallel_workers); - // Allocate a worker and return a pointer to it. - virtual GangWorker* allocate_worker(uint which); - // Initialize workers in the gang. Return true if initialization - // succeeded. The type of the worker can be overridden in a derived - // class with the appropriate implementation of allocate_worker(). - bool initialize_workers(); -}; - -// Class GangWorker: -// Several instances of this class run in parallel as workers for a gang. -class GangWorker: public WorkerThread { -public: - // Constructors and destructor. - GangWorker(AbstractWorkGang* gang, uint id); + public: + AbstractWorkGang(const char* name, uint workers, bool are_GC_task_threads, bool are_ConcurrentGC_threads) : + _name(name), + _total_workers(workers), + _active_workers(UseDynamicNumberOfGCThreads ? 1U : workers), + _are_GC_task_threads(are_GC_task_threads), + _are_ConcurrentGC_threads(are_ConcurrentGC_threads) + { } - // The only real method: run a task for the gang. - virtual void run(); - // Predicate for Thread - virtual bool is_GC_task_thread() const; - virtual bool is_ConcurrentGC_thread() const; - // Printing - void print_on(outputStream* st) const; - virtual void print() const { print_on(tty); } -protected: - AbstractWorkGang* _gang; - - virtual void initialize(); - virtual void loop(); - -public: - AbstractWorkGang* gang() const { return _gang; } -}; + // Initialize workers in the gang. Return true if initialization succeeded. + bool initialize_workers(); -// Dynamic number of worker threads -// -// This type of work gang is used to run different numbers of -// worker threads at different times. The -// number of workers run for a task is "_active_workers" -// instead of "_total_workers" in a WorkGang. The method -// "needs_more_workers()" returns true until "_active_workers" -// have been started and returns false afterwards. The -// implementation of "needs_more_workers()" in WorkGang always -// returns true so that all workers are started. The method -// "loop()" in GangWorker was modified to ask "needs_more_workers()" -// in its loop to decide if it should start working on a task. -// A worker in "loop()" waits for notification on the WorkGang -// monitor and execution of each worker as it checks for work -// is serialized via the same monitor. The "needs_more_workers()" -// call is serialized and additionally the calculation for the -// "part" (effectively the worker id for executing the task) is -// serialized to give each worker a unique "part". Workers that -// are not needed for this tasks (i.e., "_active_workers" have -// been started before it, continue to wait for work. + bool are_GC_task_threads() const { return _are_GC_task_threads; } + bool are_ConcurrentGC_threads() const { return _are_ConcurrentGC_threads; } -class FlexibleWorkGang: public WorkGang { - // The currently active workers in this gang. - // This is a number that is dynamically adjusted - // and checked in the run_task() method at each invocation. - // As described above _active_workers determines the number - // of threads started on a task. It must also be used to - // determine completion. + uint total_workers() const { return _total_workers; } - protected: - uint _active_workers; - public: - // Constructor and destructor. - FlexibleWorkGang(const char* name, uint workers, - bool are_GC_task_threads, - bool are_ConcurrentGC_threads) : - WorkGang(name, workers, are_GC_task_threads, are_ConcurrentGC_threads), - _active_workers(UseDynamicNumberOfGCThreads ? 1U : workers) {} - - // Accessors for fields. virtual uint active_workers() const { assert(_active_workers <= _total_workers, err_msg("_active_workers: %u > _total_workers: %u", _active_workers, _total_workers)); @@ -317,10 +146,90 @@ assert(UseDynamicNumberOfGCThreads || _active_workers == _total_workers, "Unless dynamic should use total workers"); } + + // Return the Ith worker. + AbstractGangWorker* worker(uint i) const; + + void threads_do(ThreadClosure* tc) const; + + // Debugging. + const char* name() const { return _name; } + + // Printing + void print_worker_threads_on(outputStream *st) const; + void print_worker_threads() const { + print_worker_threads_on(tty); + } + + protected: + virtual AbstractGangWorker* allocate_worker(uint which) = 0; +}; + +// An class representing a gang of workers. +class WorkGang: public AbstractWorkGang { + // To get access to the GangTaskDispatcher instance. + friend class GangWorker; + + // Never deleted. + ~WorkGang(); + + GangTaskDispatcher* const _dispatcher; + GangTaskDispatcher* dispatcher() const { + return _dispatcher; + } + +public: + WorkGang(const char* name, + uint workers, + bool are_GC_task_threads, + bool are_ConcurrentGC_threads); + + // Run a task, returns when the task is done. virtual void run_task(AbstractGangTask* task); - virtual bool needs_more_workers() const { - return _started_workers < _active_workers; - } + +protected: + virtual AbstractGangWorker* allocate_worker(uint which); +}; + +// Several instances of this class run in parallel as workers for a gang. +class AbstractGangWorker: public WorkerThread { +public: + AbstractGangWorker(AbstractWorkGang* gang, uint id); + + // The only real method: run a task for the gang. + virtual void run(); + // Predicate for Thread + virtual bool is_GC_task_thread() const; + virtual bool is_ConcurrentGC_thread() const; + // Printing + void print_on(outputStream* st) const; + virtual void print() const { print_on(tty); } + +protected: + AbstractWorkGang* _gang; + + virtual void initialize(); + virtual void loop() = 0; + + AbstractWorkGang* gang() const { return _gang; } +}; + +class GangWorker: public AbstractGangWorker { +public: + GangWorker(WorkGang* gang, uint id) : AbstractGangWorker(gang, id) {} + +protected: + virtual void loop(); + +private: + WorkData wait_for_task(); + void run_task(WorkData work); + void signal_task_done(); + + void print_task_started(WorkData data); + void print_task_done(WorkData data); + + WorkGang* gang() const { return (WorkGang*)_gang; } }; // A class that acts as a synchronisation barrier. Workers enter
--- a/src/share/vm/gc/shenandoah/shenandoahCollectorPolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shenandoah/shenandoahCollectorPolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -628,10 +628,6 @@ return this; } -ShenandoahCollectorPolicy::Name ShenandoahCollectorPolicy::kind() { - return CollectorPolicy::ShenandoahCollectorPolicyKind; -} - BarrierSet::Name ShenandoahCollectorPolicy::barrier_set_name() { return BarrierSet::ShenandoahBarrierSet; }
--- a/src/share/vm/gc/shenandoah/shenandoahCollectorPolicy.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shenandoah/shenandoahCollectorPolicy.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -70,8 +70,6 @@ virtual ShenandoahCollectorPolicy* as_pgc_policy(); - virtual ShenandoahCollectorPolicy::Name kind(); - BarrierSet::Name barrier_set_name(); HeapWord* mem_allocate_work(size_t size,
--- a/src/share/vm/gc/shenandoah/shenandoahConcurrentMark.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shenandoah/shenandoahConcurrentMark.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -243,9 +243,9 @@ sh->conc_workers()->run_task(&markingTask); if (ShenandoahGCVerbose) { - tty->print("total workers = %u finished workers = %u\n", - sh->conc_workers()->started_workers(), - sh->conc_workers()->finished_workers()); + tty->print("total workers = %u active workers = %u\n", + sh->conc_workers()->total_workers(), + sh->conc_workers()->active_workers()); TASKQUEUE_STATS_ONLY(print_taskqueue_stats()); TASKQUEUE_STATS_ONLY(reset_taskqueue_stats()); }
--- a/src/share/vm/gc/shenandoah/shenandoahHeap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shenandoah/shenandoahHeap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -211,10 +211,10 @@ _used = 0; // This is odd. They are concurrent gc threads, but they are also task threads. // Framework doesn't allow both. - _workers = new FlexibleWorkGang("Concurrent GC Threads", ParallelGCThreads, + _workers = new WorkGang("Concurrent GC Threads", ParallelGCThreads, /* are_GC_task_threads */true, /* are_ConcurrentGC_threads */false); - _conc_workers = new FlexibleWorkGang("Concurrent GC Threads", ConcGCThreads, + _conc_workers = new WorkGang("Concurrent GC Threads", ConcGCThreads, /* are_GC_task_threads */true, /* are_ConcurrentGC_threads */false); if ((_workers == NULL) || (_conc_workers == NULL)) { @@ -2416,7 +2416,7 @@ if ((! Thread::current()->is_GC_task_thread()) && (! Thread::current()->is_ConcurrentGC_thread())) { tty->print_cr("OOM during evacuation. Let Java thread wait until evacuation settlded.."); - while (! conc_workers()->is_idle()) { // wait. + while (_evacuation_in_progress) { // wait. Thread::current()->_ParkEvent->park(1) ; } } @@ -2719,7 +2719,7 @@ } if ((! Thread::current()->is_GC_task_thread()) && (! Thread::current()->is_ConcurrentGC_thread())) { - while (! conc_workers()->is_idle()) { // wait. + while (_evacuation_in_progress) { // wait. Thread::current()->_ParkEvent->park(1) ; } }
--- a/src/share/vm/gc/shenandoah/shenandoahHeap.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/gc/shenandoah/shenandoahHeap.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -95,8 +95,8 @@ int _max_conc_workers; int _max_workers; - FlexibleWorkGang* _conc_workers; - FlexibleWorkGang* _workers; + WorkGang* _conc_workers; + WorkGang* _workers; volatile size_t _used; @@ -349,8 +349,8 @@ int max_workers(); int max_conc_workers(); int max_parallel_workers(); - FlexibleWorkGang* conc_workers() const{ return _conc_workers;} - FlexibleWorkGang* workers() const{ return _workers;} + WorkGang* conc_workers() const{ return _conc_workers;} + WorkGang* workers() const{ return _workers;} ShenandoahHeapRegion** heap_regions(); size_t num_regions();
--- a/src/share/vm/interpreter/abstractInterpreter.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/interpreter/abstractInterpreter.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -90,6 +90,10 @@ java_util_zip_CRC32_update, // implementation of java.util.zip.CRC32.update() java_util_zip_CRC32_updateBytes, // implementation of java.util.zip.CRC32.updateBytes() java_util_zip_CRC32_updateByteBuffer, // implementation of java.util.zip.CRC32.updateByteBuffer() + java_lang_Float_intBitsToFloat, // implementation of java.lang.Float.intBitsToFloat() + java_lang_Float_floatToRawIntBits, // implementation of java.lang.Float.floatToRawIntBits() + java_lang_Double_longBitsToDouble, // implementation of java.lang.Double.longBitsToDouble() + java_lang_Double_doubleToRawLongBits, // implementation of java.lang.Double.doubleToRawLongBits() number_of_method_entries, invalid = -1 };
--- a/src/share/vm/interpreter/interpreter.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/interpreter/interpreter.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -234,7 +234,15 @@ case vmIntrinsics::_updateByteBufferCRC32 : return java_util_zip_CRC32_updateByteBuffer; } } -#endif + + switch(m->intrinsic_id()) { + case vmIntrinsics::_intBitsToFloat: return java_lang_Float_intBitsToFloat; + case vmIntrinsics::_floatToRawIntBits: return java_lang_Float_floatToRawIntBits; + case vmIntrinsics::_longBitsToDouble: return java_lang_Double_longBitsToDouble; + case vmIntrinsics::_doubleToRawLongBits: return java_lang_Double_doubleToRawLongBits; + } + +#endif // CC_INTERP // Native method? // Note: This test must come _before_ the test for intrinsic @@ -559,6 +567,25 @@ : // fall thru case Interpreter::java_util_zip_CRC32_updateByteBuffer : entry_point = generate_CRC32_updateBytes_entry(kind); break; +#if defined(TARGET_ARCH_x86) && !defined(_LP64) + // On x86_32 platforms, a special entry is generated for the following four methods. + // On other platforms the normal entry is used to enter these methods. + case Interpreter::java_lang_Float_intBitsToFloat + : entry_point = generate_Float_intBitsToFloat_entry(); break; + case Interpreter::java_lang_Float_floatToRawIntBits + : entry_point = generate_Float_floatToRawIntBits_entry(); break; + case Interpreter::java_lang_Double_longBitsToDouble + : entry_point = generate_Double_longBitsToDouble_entry(); break; + case Interpreter::java_lang_Double_doubleToRawLongBits + : entry_point = generate_Double_doubleToRawLongBits_entry(); break; +#else + case Interpreter::java_lang_Float_intBitsToFloat: + case Interpreter::java_lang_Float_floatToRawIntBits: + case Interpreter::java_lang_Double_longBitsToDouble: + case Interpreter::java_lang_Double_doubleToRawLongBits: + entry_point = generate_native_entry(false); + break; +#endif // defined(TARGET_ARCH_x86) && !defined(_LP64) #endif // CC_INTERP default: fatal(err_msg("unexpected method kind: %d", kind));
--- a/src/share/vm/interpreter/templateInterpreter.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/interpreter/templateInterpreter.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -397,34 +397,39 @@ // all non-native method kinds method_entry(zerolocals) - method_entry(zerolocals_synchronized) - method_entry(empty) - method_entry(accessor) - method_entry(abstract) - method_entry(java_lang_math_sin ) - method_entry(java_lang_math_cos ) - method_entry(java_lang_math_tan ) - method_entry(java_lang_math_abs ) - method_entry(java_lang_math_sqrt ) - method_entry(java_lang_math_log ) - method_entry(java_lang_math_log10) - method_entry(java_lang_math_exp ) - method_entry(java_lang_math_pow ) - method_entry(java_lang_ref_reference_get) + method_entry(zerolocals_synchronized) + method_entry(empty) + method_entry(accessor) + method_entry(abstract) + method_entry(java_lang_math_sin ) + method_entry(java_lang_math_cos ) + method_entry(java_lang_math_tan ) + method_entry(java_lang_math_abs ) + method_entry(java_lang_math_sqrt ) + method_entry(java_lang_math_log ) + method_entry(java_lang_math_log10) + method_entry(java_lang_math_exp ) + method_entry(java_lang_math_pow ) + method_entry(java_lang_ref_reference_get) - if (UseCRC32Intrinsics) { - method_entry(java_util_zip_CRC32_update) - method_entry(java_util_zip_CRC32_updateBytes) - method_entry(java_util_zip_CRC32_updateByteBuffer) - } + if (UseCRC32Intrinsics) { + method_entry(java_util_zip_CRC32_update) + method_entry(java_util_zip_CRC32_updateBytes) + method_entry(java_util_zip_CRC32_updateByteBuffer) + } + + method_entry(java_lang_Float_intBitsToFloat); + method_entry(java_lang_Float_floatToRawIntBits); + method_entry(java_lang_Double_longBitsToDouble); + method_entry(java_lang_Double_doubleToRawLongBits); initialize_method_handle_entries(); // all native method kinds (must be one contiguous block) Interpreter::_native_entry_begin = Interpreter::code()->code_end(); method_entry(native) - method_entry(native_synchronized) - Interpreter::_native_entry_end = Interpreter::code()->code_end(); + method_entry(native_synchronized) + Interpreter::_native_entry_end = Interpreter::code()->code_end(); #undef method_entry
--- a/src/share/vm/memory/filemap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/filemap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -707,12 +707,16 @@ addr, string_ranges[i].byte_size(), si->_read_only, si->_allow_exec); if (base == NULL || base != addr) { + // dealloc the string regions from java heap + dealloc_string_regions(); fail_continue("Unable to map shared string space at required address."); return false; } } if (!verify_string_regions()) { + // dealloc the string regions from java heap + dealloc_string_regions(); fail_continue("Shared string regions are corrupt"); return false; } @@ -745,12 +749,14 @@ } void FileMapInfo::fixup_string_regions() { +#if INCLUDE_ALL_GCS // If any string regions were found, call the fill routine to make them parseable. // Note that string_ranges may be non-NULL even if no ranges were found. if (num_ranges != 0) { assert(string_ranges != NULL, "Null string_ranges array with non-zero count"); G1CollectedHeap::heap()->fill_archive_regions(string_ranges, num_ranges); } +#endif } bool FileMapInfo::verify_region_checksum(int i) { @@ -793,20 +799,14 @@ } } -void FileMapInfo::unmap_string_regions() { - for (int i = MetaspaceShared::first_string; - i < MetaspaceShared::first_string + MetaspaceShared::max_strings; i++) { - struct FileMapInfo::FileMapHeader::space_info* si = &_header->_space[i]; - size_t used = si->_used; - if (used > 0) { - size_t size = align_size_up(used, os::vm_allocation_granularity()); - char* addr = (char*)((void*)oopDesc::decode_heap_oop_not_null( - (narrowOop)si->_addr._offset)); - if (!os::unmap_memory(addr, size)) { - fail_stop("Unable to unmap shared space."); - } - } +// dealloc the archived string region from java heap +void FileMapInfo::dealloc_string_regions() { +#if INCLUDE_ALL_GCS + if (num_ranges > 0) { + assert(string_ranges != NULL, "Null string_ranges array with non-zero count"); + G1CollectedHeap::heap()->dealloc_archive_regions(string_ranges, num_ranges); } +#endif } void FileMapInfo::assert_mark(bool check) { @@ -967,7 +967,9 @@ map_info->_header->_space[i]._addr._base = NULL; } } - map_info->unmap_string_regions(); + // Dealloc the string regions only without unmapping. The string regions are part + // of the java heap. Unmapping of the heap regions are managed by GC. + map_info->dealloc_string_regions(); } else if (DumpSharedSpaces) { fail_stop("%s", msg); }
--- a/src/share/vm/memory/filemap.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/filemap.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -208,7 +208,7 @@ bool verify_string_regions(); void fixup_string_regions(); void unmap_region(int i); - void unmap_string_regions(); + void dealloc_string_regions(); bool verify_region_checksum(int i); void close(); bool is_open() { return _file_open; }
--- a/src/share/vm/memory/iterator.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/iterator.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -61,7 +61,7 @@ // // 1) do_klass on the header klass pointer. // 2) do_klass on the klass pointer in the mirrors. - // 3) do_class_loader_data on the class loader data in class loaders. + // 3) do_cld on the class loader data in class loaders. // // The virtual (without suffix) and the non-virtual (with _nv suffix) need // to be updated together, or else the devirtualization will break. @@ -71,13 +71,14 @@ // ExtendedOopClosures that don't need to walk the metadata. // Currently, only CMS and G1 need these. + bool do_metadata_nv() { return false; } virtual bool do_metadata() { return do_metadata_nv(); } - bool do_metadata_nv() { return false; } - virtual void do_klass(Klass* k) { do_klass_nv(k); } - void do_klass_nv(Klass* k) { ShouldNotReachHere(); } + void do_klass_nv(Klass* k) { ShouldNotReachHere(); } + virtual void do_klass(Klass* k) { do_klass_nv(k); } - virtual void do_class_loader_data(ClassLoaderData* cld) { ShouldNotReachHere(); } + void do_cld_nv(ClassLoaderData* cld) { ShouldNotReachHere(); } + virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } // True iff this closure may be safely applied more than once to an oop // location without an intervening "major reset" (like the end of a GC). @@ -180,13 +181,14 @@ _klass_closure.initialize(this); } - virtual bool do_metadata() { return do_metadata_nv(); } - inline bool do_metadata_nv() { return true; } + bool do_metadata_nv() { return true; } + virtual bool do_metadata() { return do_metadata_nv(); } - virtual void do_klass(Klass* k); void do_klass_nv(Klass* k); + virtual void do_klass(Klass* k) { do_klass_nv(k); } - virtual void do_class_loader_data(ClassLoaderData* cld); + void do_cld_nv(ClassLoaderData* cld); + virtual void do_cld(ClassLoaderData* cld) { do_cld_nv(cld); } }; // ObjectClosure is used for iterating through an object space @@ -370,6 +372,7 @@ public: template <class OopClosureType, typename T> static void do_oop(OopClosureType* closure, T* p); template <class OopClosureType> static void do_klass(OopClosureType* closure, Klass* k); + template <class OopClosureType> static void do_cld(OopClosureType* closure, ClassLoaderData* cld); template <class OopClosureType> static bool do_metadata(OopClosureType* closure); }; @@ -378,6 +381,7 @@ public: template <class OopClosureType, typename T> static void do_oop(OopClosureType* closure, T* p); template <class OopClosureType> static void do_klass(OopClosureType* closure, Klass* k); + template <class OopClosureType> static void do_cld(OopClosureType* closure, ClassLoaderData* cld); template <class OopClosureType> static bool do_metadata(OopClosureType* closure); };
--- a/src/share/vm/memory/iterator.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/iterator.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -36,7 +36,7 @@ #include "oops/typeArrayKlass.inline.hpp" #include "utilities/debug.hpp" -inline void MetadataAwareOopClosure::do_class_loader_data(ClassLoaderData* cld) { +inline void MetadataAwareOopClosure::do_cld_nv(ClassLoaderData* cld) { assert(_klass_closure._oop_closure == this, "Must be"); bool claim = true; // Must claim the class loader data before processing. @@ -45,11 +45,9 @@ inline void MetadataAwareOopClosure::do_klass_nv(Klass* k) { ClassLoaderData* cld = k->class_loader_data(); - do_class_loader_data(cld); + do_cld_nv(cld); } -inline void MetadataAwareOopClosure::do_klass(Klass* k) { do_klass_nv(k); } - #ifdef ASSERT // This verification is applied to all visited oops. // The closures can turn is off by overriding should_verify_oops(). @@ -78,6 +76,10 @@ closure->do_klass_nv(k); } template <class OopClosureType> +void Devirtualizer<true>::do_cld(OopClosureType* closure, ClassLoaderData* cld) { + closure->do_cld_nv(cld); +} +template <class OopClosureType> inline bool Devirtualizer<true>::do_metadata(OopClosureType* closure) { // Make sure the non-virtual and the virtual versions match. assert(closure->do_metadata_nv() == closure->do_metadata(), "Inconsistency in do_metadata"); @@ -96,6 +98,10 @@ closure->do_klass(k); } template <class OopClosureType> +void Devirtualizer<false>::do_cld(OopClosureType* closure, ClassLoaderData* cld) { + closure->do_cld(cld); +} +template <class OopClosureType> bool Devirtualizer<false>::do_metadata(OopClosureType* closure) { return closure->do_metadata(); }
--- a/src/share/vm/memory/metaspace.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/metaspace.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -254,7 +254,7 @@ // Debugging support void verify(); - static void print_compressed_class_space(outputStream* st, const char* requested_addr = 0); + static void print_compressed_class_space(outputStream* st, const char* requested_addr = 0) NOT_LP64({}); class AllocRecordClosure : public StackObj { public:
--- a/src/share/vm/memory/referenceType.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/referenceType.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,11 +32,15 @@ enum ReferenceType { REF_NONE, // Regular class REF_OTHER, // Subclass of java/lang/ref/Reference, but not subclass of one of the classes below + ///////////////// Only the types below have their own discovered lists REF_SOFT, // Subclass of java/lang/ref/SoftReference REF_WEAK, // Subclass of java/lang/ref/WeakReference REF_FINAL, // Subclass of java/lang/ref/FinalReference REF_PHANTOM, // Subclass of java/lang/ref/PhantomReference - REF_CLEANER // Subclass of sun/misc/Cleaner + REF_CLEANER, // Subclass of sun/misc/Cleaner + ///////////////// Only the types in the above range have their own discovered lists + REF_JNI, // JNI weak refs + REF_LISTS_COUNT = REF_CLEANER - REF_OTHER // Number of discovered lists }; #endif // SHARE_VM_MEMORY_REFERENCETYPE_HPP
--- a/src/share/vm/memory/universe.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/universe.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -79,7 +79,7 @@ #include "gc/shenandoah/shenandoahCollectorPolicy.hpp" #include "gc/cms/cmsCollectorPolicy.hpp" #include "gc/g1/g1CollectedHeap.inline.hpp" -#include "gc/g1/g1CollectorPolicy_ext.hpp" +#include "gc/g1/g1CollectorPolicy.hpp" #include "gc/parallel/parallelScavengeHeap.hpp" #include "gc/shared/adaptiveSizePolicy.hpp" #endif // INCLUDE_ALL_GCS @@ -699,13 +699,34 @@ return JNI_OK; } -template <class Heap, class Policy> -jint Universe::create_heap() { +CollectedHeap* Universe::create_heap() { assert(_collectedHeap == NULL, "Heap already created"); - Policy* policy = new Policy(); - policy->initialize_all(); - _collectedHeap = new Heap(policy); - return _collectedHeap->initialize(); +#if !INCLUDE_ALL_GCS + if (UseParallelGC) { + fatal("UseParallelGC not supported in this VM."); + } else if (UseG1GC) { + fatal("UseG1GC not supported in this VM."); + } else if (UseConcMarkSweepGC) { + fatal("UseConcMarkSweepGC not supported in this VM."); + } else if (UseShenandoahGC) { + fatal("UseShenandoahGC not supported in this VM."); + } +#else + if (UseParallelGC) { + return Universe::create_heap_with_policy<ParallelScavengeHeap, GenerationSizer>(); + } else if (UseG1GC) { + return Universe::create_heap_with_policy<G1CollectedHeap, G1CollectorPolicy>(); + } else if (UseConcMarkSweepGC) { + return Universe::create_heap_with_policy<GenCollectedHeap, ConcurrentMarkSweepPolicy>(); + } else if (UseShenandoahGC) { + return Universe::create_heap_with_policy<ShenandoahHeap, ShenandoahCollectorPolicy>(); +#endif + } else if (UseSerialGC) { + return Universe::create_heap_with_policy<GenCollectedHeap, MarkSweepPolicy>(); + } + + ShouldNotReachHere(); + return NULL; } // Choose the heap base address and oop encoding mode @@ -719,31 +740,12 @@ jint Universe::initialize_heap() { jint status = JNI_ERR; -#if !INCLUDE_ALL_GCS - if (UseShenandoahGC) { - fatal("UseShenandoahGC not supported in this VM."); - } else if (UseParallelGC) { - fatal("UseParallelGC not supported in this VM."); - } else if (UseG1GC) { - fatal("UseG1GC not supported in this VM."); - } else if (UseConcMarkSweepGC) { - fatal("UseConcMarkSweepGC not supported in this VM."); -#else - if (UseShenandoahGC) { - status = Universe::create_heap<ShenandoahHeap, ShenandoahCollectorPolicy>(); - } else if (UseParallelGC) { - status = Universe::create_heap<ParallelScavengeHeap, GenerationSizer>(); - } else if (UseG1GC) { - status = Universe::create_heap<G1CollectedHeap, G1CollectorPolicyExt>(); - } else if (UseConcMarkSweepGC) { - status = Universe::create_heap<GenCollectedHeap, ConcurrentMarkSweepPolicy>(); -#endif - } else if (UseSerialGC) { - status = Universe::create_heap<GenCollectedHeap, MarkSweepPolicy>(); - } else { - ShouldNotReachHere(); + _collectedHeap = create_heap_ext(); + if (_collectedHeap == NULL) { + _collectedHeap = create_heap(); } + status = _collectedHeap->initialize(); if (status != JNI_OK) { return status; }
--- a/src/share/vm/memory/universe.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/universe.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -219,7 +219,9 @@ static size_t _heap_capacity_at_last_gc; static size_t _heap_used_at_last_gc; - template <class Heap, class Policy> static jint create_heap(); + template <class Heap, class Policy> static CollectedHeap* create_heap_with_policy(); + static CollectedHeap* create_heap(); + static CollectedHeap* create_heap_ext(); static jint initialize_heap(); static void initialize_basic_type_mirrors(TRAPS); static void fixup_mirrors(TRAPS);
--- a/src/share/vm/memory/universe.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/memory/universe.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -49,4 +49,11 @@ _allocation_context_notification_obj = obj; } +template <class Heap, class Policy> +CollectedHeap* Universe::create_heap_with_policy() { + Policy* policy = new Policy(); + policy->initialize_all(); + return new Heap(policy); +} + #endif // SHARE_VM_MEMORY_UNIVERSE_INLINE_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/share/vm/memory/universe_ext.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,30 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#include "precompiled.hpp" +#include "memory/universe.hpp" + +CollectedHeap* Universe::create_heap_ext() { + return NULL; +}
--- a/src/share/vm/oops/arrayKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/arrayKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -147,30 +147,30 @@ // Array oop iteration macros for declarations. // Used to generate the declarations in the *ArrayKlass header files. -#define OOP_OOP_ITERATE_DECL_RANGE(OopClosureType, nv_suffix) \ - int oop_oop_iterate_range##nv_suffix(oop obj, OopClosureType* closure, int start, int end); +#define OOP_OOP_ITERATE_DECL_RANGE(OopClosureType, nv_suffix) \ + void oop_oop_iterate_range##nv_suffix(oop obj, OopClosureType* closure, int start, int end); #if INCLUDE_ALL_GCS // Named NO_BACKWARDS because the definition used by *ArrayKlass isn't reversed, see below. -#define OOP_OOP_ITERATE_DECL_NO_BACKWARDS(OopClosureType, nv_suffix) \ - int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure); +#define OOP_OOP_ITERATE_DECL_NO_BACKWARDS(OopClosureType, nv_suffix) \ + void oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure); #endif // INCLUDE_ALL_GCS // Array oop iteration macros for definitions. // Used to generate the definitions in the *ArrayKlass.inline.hpp files. -#define OOP_OOP_ITERATE_DEFN_RANGE(KlassType, OopClosureType, nv_suffix) \ - \ -int KlassType::oop_oop_iterate_range##nv_suffix(oop obj, OopClosureType* closure, int start, int end) { \ - return oop_oop_iterate_range<nvs_to_bool(nv_suffix)>(obj, closure, start, end); \ +#define OOP_OOP_ITERATE_DEFN_RANGE(KlassType, OopClosureType, nv_suffix) \ + \ +void KlassType::oop_oop_iterate_range##nv_suffix(oop obj, OopClosureType* closure, int start, int end) { \ + oop_oop_iterate_range<nvs_to_bool(nv_suffix)>(obj, closure, start, end); \ } #if INCLUDE_ALL_GCS -#define OOP_OOP_ITERATE_DEFN_NO_BACKWARDS(KlassType, OopClosureType, nv_suffix) \ -int KlassType::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ - /* No reverse implementation ATM. */ \ - return oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure); \ +#define OOP_OOP_ITERATE_DEFN_NO_BACKWARDS(KlassType, OopClosureType, nv_suffix) \ +void KlassType::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ + /* No reverse implementation ATM. */ \ + oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure); \ } #else #define OOP_OOP_ITERATE_DEFN_NO_BACKWARDS(KlassType, OopClosureType, nv_suffix)
--- a/src/share/vm/oops/instanceClassLoaderKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceClassLoaderKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -51,7 +51,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -71,19 +70,19 @@ // Forward iteration // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate(oop obj, OopClosureType* closure); + inline void oop_oop_iterate(oop obj, OopClosureType* closure); #if INCLUDE_ALL_GCS // Reverse iteration // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_reverse(oop obj, OopClosureType* closure); + inline void oop_oop_iterate_reverse(oop obj, OopClosureType* closure); #endif // Bounded range iteration // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); + inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); public:
--- a/src/share/vm/oops/instanceClassLoaderKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceClassLoaderKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,6 +26,7 @@ #define SHARE_VM_OOPS_INSTANCECLASSLOADERKLASS_INLINE_HPP #include "classfile/javaClasses.hpp" +#include "memory/iterator.inline.hpp" #include "oops/instanceClassLoaderKlass.hpp" #include "oops/instanceKlass.inline.hpp" #include "oops/oop.inline.hpp" @@ -34,48 +35,42 @@ #include "utilities/macros.hpp" template <bool nv, class OopClosureType> -inline int InstanceClassLoaderKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { - int size = InstanceKlass::oop_oop_iterate<nv>(obj, closure); +inline void InstanceClassLoaderKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { + InstanceKlass::oop_oop_iterate<nv>(obj, closure); if (Devirtualizer<nv>::do_metadata(closure)) { ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj); // cld can be null if we have a non-registered class loader. if (cld != NULL) { - closure->do_class_loader_data(cld); + Devirtualizer<nv>::do_cld(closure, cld); } } - - return size; } #if INCLUDE_ALL_GCS template <bool nv, class OopClosureType> -inline int InstanceClassLoaderKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { - int size = InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); +inline void InstanceClassLoaderKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { + InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); assert(!Devirtualizer<nv>::do_metadata(closure), "Code to handle metadata is not implemented"); - - return size; } #endif // INCLUDE_ALL_GCS template <bool nv, class OopClosureType> -inline int InstanceClassLoaderKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { - int size = InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); +inline void InstanceClassLoaderKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { + InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); if (Devirtualizer<nv>::do_metadata(closure)) { if (mr.contains(obj)) { ClassLoaderData* cld = java_lang_ClassLoader::loader_data(obj); // cld can be null if we have a non-registered class loader. if (cld != NULL) { - closure->do_class_loader_data(cld); + Devirtualizer<nv>::do_cld(closure, cld); } } } - - return size; } #define ALL_INSTANCE_CLASS_LOADER_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
--- a/src/share/vm/oops/instanceKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -1014,7 +1014,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge
--- a/src/share/vm/oops/instanceKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -38,6 +38,8 @@ // as the previous macro based implementation. #ifdef TARGET_COMPILER_visCPP #define INLINE __forceinline +#elif defined(TARGET_COMPILER_sparcWorks) +#define INLINE __attribute__((always_inline)) #else #define INLINE inline #endif
--- a/src/share/vm/oops/instanceMirrorKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceMirrorKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -91,7 +91,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -121,21 +120,21 @@ // Forward iteration // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate(oop obj, OopClosureType* closure); + inline void oop_oop_iterate(oop obj, OopClosureType* closure); // Reverse iteration #if INCLUDE_ALL_GCS // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_reverse(oop obj, OopClosureType* closure); + inline void oop_oop_iterate_reverse(oop obj, OopClosureType* closure); #endif // Bounded range iteration // Iterate over the oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); + inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); // Iterate over the static fields. template <bool nv, class OopClosureType>
--- a/src/share/vm/oops/instanceMirrorKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceMirrorKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -53,30 +53,40 @@ } template <bool nv, class OopClosureType> -int InstanceMirrorKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { +void InstanceMirrorKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { InstanceKlass::oop_oop_iterate<nv>(obj, closure); if (Devirtualizer<nv>::do_metadata(closure)) { Klass* klass = java_lang_Class::as_Klass(obj); // We'll get NULL for primitive mirrors. if (klass != NULL) { - Devirtualizer<nv>::do_klass(closure, klass); + if (klass->oop_is_instance() && InstanceKlass::cast(klass)->is_anonymous()) { + // An anonymous class doesn't have its own class loader, so when handling + // the java mirror for an anonymous class we need to make sure its class + // loader data is claimed, this is done by calling do_cld explicitly. + // For non-anonymous classes the call to do_cld is made when the class + // loader itself is handled. + Devirtualizer<nv>::do_cld(closure, klass->class_loader_data()); + } else { + Devirtualizer<nv>::do_klass(closure, klass); + } + } else { + // If klass is NULL then this a mirror for a primitive type. + // We don't have to follow them, since they are handled as strong + // roots in Universe::oops_do. + assert(java_lang_Class::is_primitive(obj), "Sanity check"); } } oop_oop_iterate_statics<nv>(obj, closure); - - return oop_size(obj); } #if INCLUDE_ALL_GCS template <bool nv, class OopClosureType> -int InstanceMirrorKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { +void InstanceMirrorKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); InstanceMirrorKlass::oop_oop_iterate_statics<nv>(obj, closure); - - return oop_size(obj); } #endif @@ -115,7 +125,7 @@ } template <bool nv, class OopClosureType> -int InstanceMirrorKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { +void InstanceMirrorKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); if (Devirtualizer<nv>::do_metadata(closure)) { @@ -129,8 +139,6 @@ } oop_oop_iterate_statics_bounded<nv>(obj, closure, mr); - - return oop_size(obj); } #define ALL_INSTANCE_MIRROR_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
--- a/src/share/vm/oops/instanceRefKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceRefKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -67,7 +67,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -88,19 +87,19 @@ private: // Iterate over all oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate(oop obj, OopClosureType* closure); + inline void oop_oop_iterate(oop obj, OopClosureType* closure); // Reverse iteration #if INCLUDE_ALL_GCS // Iterate over all oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_reverse(oop obj, OopClosureType* closure); + inline void oop_oop_iterate_reverse(oop obj, OopClosureType* closure); #endif // INCLUDE_ALL_GCS // Bounded range iteration // Iterate over all oop fields and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); + inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); // Reference processing part of the iterators.
--- a/src/share/vm/oops/instanceRefKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/instanceRefKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -106,37 +106,27 @@ } template <bool nv, class OopClosureType> -int InstanceRefKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { - // Get size before changing pointers - int size = InstanceKlass::oop_oop_iterate<nv>(obj, closure); +void InstanceRefKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { + InstanceKlass::oop_oop_iterate<nv>(obj, closure); oop_oop_iterate_ref_processing<nv>(obj, closure); - - return size; } #if INCLUDE_ALL_GCS template <bool nv, class OopClosureType> -int InstanceRefKlass:: -oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { - // Get size before changing pointers - int size = InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); +void InstanceRefKlass::oop_oop_iterate_reverse(oop obj, OopClosureType* closure) { + InstanceKlass::oop_oop_iterate_reverse<nv>(obj, closure); oop_oop_iterate_ref_processing<nv>(obj, closure); - - return size; } #endif // INCLUDE_ALL_GCS template <bool nv, class OopClosureType> -int InstanceRefKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { - // Get size before changing pointers - int size = InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); +void InstanceRefKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { + InstanceKlass::oop_oop_iterate_bounded<nv>(obj, closure, mr); oop_oop_iterate_ref_processing_bounded<nv>(obj, closure, mr); - - return size; } // Macro to define InstanceRefKlass::oop_oop_iterate for virtual/nonvirtual for
--- a/src/share/vm/oops/klass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/klass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -573,7 +573,6 @@ // GC specific object visitors // // Mark Sweep - virtual void oop_ms_follow_contents(oop obj) = 0; virtual int oop_ms_adjust_pointers(oop obj) = 0; #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -585,17 +584,17 @@ // Iterators specialized to particular subtypes // of ExtendedOopClosure, to avoid closure virtual calls. -#define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ - virtual int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) = 0; \ - /* Iterates "closure" over all the oops in "obj" (of type "this") within "mr". */ \ - virtual int oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) = 0; +#define Klass_OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ + virtual void oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) = 0; \ + /* Iterates "closure" over all the oops in "obj" (of type "this") within "mr". */ \ + virtual void oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) = 0; ALL_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL) ALL_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL) #if INCLUDE_ALL_GCS -#define Klass_OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ - virtual int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) = 0; +#define Klass_OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ + virtual void oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) = 0; ALL_OOP_OOP_ITERATE_CLOSURES_1(Klass_OOP_OOP_ITERATE_DECL_BACKWARDS) ALL_OOP_OOP_ITERATE_CLOSURES_2(Klass_OOP_OOP_ITERATE_DECL_BACKWARDS) @@ -662,35 +661,35 @@ // Used to generate declarations in the *Klass header files. #define OOP_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ - int oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure); \ - int oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr); + void oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure); \ + void oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr); #if INCLUDE_ALL_GCS -#define OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ - int oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure); +#define OOP_OOP_ITERATE_DECL_BACKWARDS(OopClosureType, nv_suffix) \ + void oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure); #endif // INCLUDE_ALL_GCS // Oop iteration macros for definitions. // Used to generate definitions in the *Klass.inline.hpp files. -#define OOP_OOP_ITERATE_DEFN(KlassType, OopClosureType, nv_suffix) \ -int KlassType::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ - return oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure); \ +#define OOP_OOP_ITERATE_DEFN(KlassType, OopClosureType, nv_suffix) \ +void KlassType::oop_oop_iterate##nv_suffix(oop obj, OopClosureType* closure) { \ + oop_oop_iterate<nvs_to_bool(nv_suffix)>(obj, closure); \ } #if INCLUDE_ALL_GCS -#define OOP_OOP_ITERATE_DEFN_BACKWARDS(KlassType, OopClosureType, nv_suffix) \ -int KlassType::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ - return oop_oop_iterate_reverse<nvs_to_bool(nv_suffix)>(obj, closure); \ +#define OOP_OOP_ITERATE_DEFN_BACKWARDS(KlassType, OopClosureType, nv_suffix) \ +void KlassType::oop_oop_iterate_backwards##nv_suffix(oop obj, OopClosureType* closure) { \ + oop_oop_iterate_reverse<nvs_to_bool(nv_suffix)>(obj, closure); \ } #else #define OOP_OOP_ITERATE_DEFN_BACKWARDS(KlassType, OopClosureType, nv_suffix) #endif -#define OOP_OOP_ITERATE_DEFN_BOUNDED(KlassType, OopClosureType, nv_suffix) \ -int KlassType::oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) { \ - return oop_oop_iterate_bounded<nvs_to_bool(nv_suffix)>(obj, closure, mr); \ +#define OOP_OOP_ITERATE_DEFN_BOUNDED(KlassType, OopClosureType, nv_suffix) \ +void KlassType::oop_oop_iterate_bounded##nv_suffix(oop obj, OopClosureType* closure, MemRegion mr) { \ + oop_oop_iterate_bounded<nvs_to_bool(nv_suffix)>(obj, closure, mr); \ } #endif // SHARE_VM_OOPS_KLASS_HPP
--- a/src/share/vm/oops/objArrayKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/objArrayKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -105,7 +105,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -125,15 +124,15 @@ // Iterate over oop elements and metadata. template <bool nv, typename OopClosureType> - inline int oop_oop_iterate(oop obj, OopClosureType* closure); + inline void oop_oop_iterate(oop obj, OopClosureType* closure); // Iterate over oop elements within mr, and metadata. template <bool nv, typename OopClosureType> - inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); + inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); // Iterate over oop elements with indices within [start, end), and metadata. template <bool nv, class OopClosureType> - inline int oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end); + inline void oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end); // Iterate over oop elements within [start, end), and metadata. // Specialized for [T = oop] or [T = narrowOop].
--- a/src/share/vm/oops/objArrayKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/objArrayKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -85,46 +85,31 @@ } template <bool nv, typename OopClosureType> -int ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { +void ObjArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { assert (obj->is_array(), "obj must be array"); objArrayOop a = objArrayOop(obj); - // Get size before changing pointers. - // Don't call size() or oop_size() since that is a virtual call. - int size = a->object_size(); if (Devirtualizer<nv>::do_metadata(closure)) { Devirtualizer<nv>::do_klass(closure, obj->klass()); } oop_oop_iterate_elements<nv>(a, closure); - - return size; } template <bool nv, typename OopClosureType> -int ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { +void ObjArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { assert(obj->is_array(), "obj must be array"); objArrayOop a = objArrayOop(obj); - // Get size before changing pointers. - // Don't call size() or oop_size() since that is a virtual call - int size = a->object_size(); - if (Devirtualizer<nv>::do_metadata(closure)) { Devirtualizer<nv>::do_klass(closure, a->klass()); } oop_oop_iterate_elements_bounded<nv>(a, closure, mr); - - return size; } template <bool nv, typename T, class OopClosureType> void ObjArrayKlass::oop_oop_iterate_range_specialized(objArrayOop a, OopClosureType* closure, int start, int end) { - if (Devirtualizer<nv>::do_metadata(closure)) { - Devirtualizer<nv>::do_klass(closure, a->klass()); - } - T* low = start == 0 ? cast_from_oop<T*>(a) : a->obj_at_addr<T>(start); T* high = (T*)a->base() + end; @@ -134,21 +119,15 @@ // Like oop_oop_iterate but only iterates over a specified range and only used // for objArrayOops. template <bool nv, class OopClosureType> -int ObjArrayKlass::oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end) { +void ObjArrayKlass::oop_oop_iterate_range(oop obj, OopClosureType* closure, int start, int end) { assert(obj->is_array(), "obj must be array"); objArrayOop a = objArrayOop(obj); - // Get size before changing pointers. - // Don't call size() or oop_size() since that is a virtual call - int size = a->object_size(); - if (UseCompressedOops) { oop_oop_iterate_range_specialized<nv, narrowOop>(a, closure, start, end); } else { oop_oop_iterate_range_specialized<nv, oop>(a, closure, start, end); } - - return size; } #define ALL_OBJ_ARRAY_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
--- a/src/share/vm/oops/objArrayOop.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/objArrayOop.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -46,8 +46,8 @@ #define ObjArrayOop_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ \ -int objArrayOopDesc::oop_iterate_range(OopClosureType* blk, int start, int end) { \ - return ((ObjArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \ +void objArrayOopDesc::oop_iterate_range(OopClosureType* blk, int start, int end) { \ + ((ObjArrayKlass*)klass())->oop_oop_iterate_range##nv_suffix(this, blk, start, end); \ } ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayOop_OOP_ITERATE_DEFN)
--- a/src/share/vm/oops/objArrayOop.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/objArrayOop.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -111,7 +111,7 @@ // special iterators for index ranges, returns size of object #define ObjArrayOop_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ - int oop_iterate_range(OopClosureType* blk, int start, int end); + void oop_iterate_range(OopClosureType* blk, int start, int end); ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayOop_OOP_ITERATE_DECL) ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayOop_OOP_ITERATE_DECL)
--- a/src/share/vm/oops/oop.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/oop.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -334,7 +334,6 @@ // Garbage Collection support // Mark Sweep - void ms_follow_contents(); // Adjust all pointers in this object to point at it's forwarded location and // return the size of this oop. This is used by the MarkSweep collector. int ms_adjust_pointers(); @@ -348,17 +347,25 @@ // iterators, returns size of object -#define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ - int oop_iterate(OopClosureType* blk); \ - int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr. +#define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \ + void oop_iterate(OopClosureType* blk); \ + void oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr. ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL) ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL) +#define OOP_ITERATE_SIZE_DECL(OopClosureType, nv_suffix) \ + int oop_iterate_size(OopClosureType* blk); \ + int oop_iterate_size(OopClosureType* blk, MemRegion mr); // Only in mr. + + ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_SIZE_DECL) + ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_SIZE_DECL) + + #if INCLUDE_ALL_GCS -#define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ - int oop_iterate_backwards(OopClosureType* blk); +#define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \ + void oop_iterate_backwards(OopClosureType* blk); ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL) ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL)
--- a/src/share/vm/oops/oop.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/oop.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -853,10 +853,6 @@ } } -inline void oopDesc::ms_follow_contents() { - klass()->oop_ms_follow_contents(this); -} - inline int oopDesc::ms_adjust_pointers() { debug_only(int check_size = size()); int s = klass()->oop_ms_adjust_pointers(this); @@ -888,34 +884,50 @@ } #endif -#define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ - \ -inline int oopDesc::oop_iterate(OopClosureType* blk) { \ - return klass()->oop_oop_iterate##nv_suffix(this, blk); \ -} \ - \ -inline int oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ - return klass()->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ +#define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ + \ +inline void oopDesc::oop_iterate(OopClosureType* blk) { \ + klass()->oop_oop_iterate##nv_suffix(this, blk); \ +} \ + \ +inline void oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \ + klass()->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ } +#define OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ + \ +inline int oopDesc::oop_iterate_size(OopClosureType* blk) { \ + Klass* k = klass(); \ + int size = size_given_klass(k); \ + k->oop_oop_iterate##nv_suffix(this, blk); \ + return size; \ +} \ + \ +inline int oopDesc::oop_iterate_size(OopClosureType* blk, \ + MemRegion mr) { \ + Klass* k = klass(); \ + int size = size_given_klass(k); \ + k->oop_oop_iterate_bounded##nv_suffix(this, blk, mr); \ + return size; \ +} inline int oopDesc::oop_iterate_no_header(OopClosure* blk) { // The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all // the do_oop calls, but turns off all other features in ExtendedOopClosure. NoHeaderExtendedOopClosure cl(blk); - return oop_iterate(&cl); + return oop_iterate_size(&cl); } inline int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) { NoHeaderExtendedOopClosure cl(blk); - return oop_iterate(&cl, mr); + return oop_iterate_size(&cl, mr); } #if INCLUDE_ALL_GCS #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \ \ -inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ - return klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ +inline void oopDesc::oop_iterate_backwards(OopClosureType* blk) { \ + klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \ } #else #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) @@ -923,6 +935,7 @@ #define ALL_OOPDESC_OOP_ITERATE(OopClosureType, nv_suffix) \ OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \ + OOP_ITERATE_SIZE_DEFN(OopClosureType, nv_suffix) \ OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) ALL_OOP_OOP_ITERATE_CLOSURES_1(ALL_OOPDESC_OOP_ITERATE)
--- a/src/share/vm/oops/symbol.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/symbol.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -35,7 +35,7 @@ Symbol::Symbol(const u1* name, int length, int refcount) { _refcount = refcount; _length = length; - _identity_hash = os::random(); + _identity_hash = (short)os::random(); for (int i = 0; i < _length; i++) { byte_at_put(i, name[i]); }
--- a/src/share/vm/oops/symbol.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/symbol.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -106,23 +106,18 @@ #define PERM_REFCOUNT -1 #endif -// We separate the fields in SymbolBase from Symbol::_body so that -// Symbol::size(int) can correctly calculate the space needed. -class SymbolBase : public MetaspaceObj { - public: +class Symbol : public MetaspaceObj { + friend class VMStructs; + friend class SymbolTable; + friend class MoveSymbols; + + private: ATOMIC_SHORT_PAIR( volatile short _refcount, // needs atomic operation unsigned short _length // number of UTF8 characters in the symbol (does not need atomic op) ); - int _identity_hash; -}; - -class Symbol : private SymbolBase { - friend class VMStructs; - friend class SymbolTable; - friend class MoveSymbols; - private: - jbyte _body[1]; + short _identity_hash; + jbyte _body[2]; enum { // max_symbol_length is constrained by type of _length @@ -130,7 +125,7 @@ }; static int size(int length) { - size_t sz = heap_word_size(sizeof(SymbolBase) + (length > 0 ? length : 0)); + size_t sz = heap_word_size(sizeof(Symbol) + (length > 2 ? length - 2 : 0)); return align_object_size(sz); } @@ -154,8 +149,11 @@ // Returns the largest size symbol we can safely hold. static int max_length() { return max_symbol_length; } - - int identity_hash() { return _identity_hash; } + unsigned identity_hash() { + unsigned addr_bits = (unsigned)((uintptr_t)this >> (LogMinObjAlignmentInBytes + 3)); + return ((unsigned)_identity_hash & 0xffff) | + ((addr_bits ^ (_length << 8) ^ (( _body[0] << 8) | _body[1])) << 16); + } // For symbol table alternate hashing unsigned int new_hash(juint seed);
--- a/src/share/vm/oops/typeArrayKlass.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/typeArrayKlass.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -75,7 +75,6 @@ // GC specific object visitors // // Mark Sweep - void oop_ms_follow_contents(oop obj); int oop_ms_adjust_pointers(oop obj); #if INCLUDE_ALL_GCS // Parallel Scavenge @@ -90,15 +89,15 @@ private: // The implementation used by all oop_oop_iterate functions in TypeArrayKlasses. - inline int oop_oop_iterate_impl(oop obj, ExtendedOopClosure* closure); + inline void oop_oop_iterate_impl(oop obj, ExtendedOopClosure* closure); // Wraps oop_oop_iterate_impl to conform to macros. template <bool nv, typename OopClosureType> - inline int oop_oop_iterate(oop obj, OopClosureType* closure); + inline void oop_oop_iterate(oop obj, OopClosureType* closure); // Wraps oop_oop_iterate_impl to conform to macros. template <bool nv, typename OopClosureType> - inline int oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); + inline void oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr); public:
--- a/src/share/vm/oops/typeArrayKlass.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/oops/typeArrayKlass.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -33,22 +33,20 @@ class ExtendedOopClosure; -inline int TypeArrayKlass::oop_oop_iterate_impl(oop obj, ExtendedOopClosure* closure) { +inline void TypeArrayKlass::oop_oop_iterate_impl(oop obj, ExtendedOopClosure* closure) { assert(obj->is_typeArray(),"must be a type array"); - typeArrayOop t = typeArrayOop(obj); // Performance tweak: We skip iterating over the klass pointer since we // know that Universe::TypeArrayKlass never moves. - return t->object_size(); } template <bool nv, typename OopClosureType> -int TypeArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { - return oop_oop_iterate_impl(obj, closure); +void TypeArrayKlass::oop_oop_iterate(oop obj, OopClosureType* closure) { + oop_oop_iterate_impl(obj, closure); } template <bool nv, typename OopClosureType> -int TypeArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { - return oop_oop_iterate_impl(obj, closure); +void TypeArrayKlass::oop_oop_iterate_bounded(oop obj, OopClosureType* closure, MemRegion mr) { + oop_oop_iterate_impl(obj, closure); } #define ALL_TYPE_ARRAY_KLASS_OOP_OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
--- a/src/share/vm/opto/arraycopynode.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/arraycopynode.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -632,3 +632,75 @@ return CallNode::may_modify_arraycopy_helper(dest_t, t_oop, phase); } + +bool ArrayCopyNode::may_modify_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase) { + if (n->is_Proj()) { + n = n->in(0); + if (n->is_Call() && n->as_Call()->may_modify(t_oop, phase)) { + return true; + } + } + return false; +} + +bool ArrayCopyNode::may_modify(const TypeOopPtr *t_oop, MemBarNode* mb, PhaseTransform *phase) { + Node* mem = mb->in(TypeFunc::Memory); + + if (mem->is_MergeMem()) { + Node* n = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw); + if (may_modify_helper(t_oop, n, phase)) { + return true; + } else if (n->is_Phi()) { + for (uint i = 1; i < n->req(); i++) { + if (n->in(i) != NULL) { + if (may_modify_helper(t_oop, n->in(i), phase)) { + return true; + } + } + } + } + } + + return false; +} + +// Does this array copy modify offsets between offset_lo and offset_hi +// in the destination array +// if must_modify is false, return true if the copy could write +// between offset_lo and offset_hi +// if must_modify is true, return true if the copy is guaranteed to +// write between offset_lo and offset_hi +bool ArrayCopyNode::modifies(intptr_t offset_lo, intptr_t offset_hi, PhaseTransform* phase, bool must_modify) { + assert(_kind == ArrayCopy || _kind == CopyOf || _kind == CopyOfRange, "only for real array copies"); + + Node* dest = in(ArrayCopyNode::Dest); + Node* src_pos = in(ArrayCopyNode::SrcPos); + Node* dest_pos = in(ArrayCopyNode::DestPos); + Node* len = in(ArrayCopyNode::Length); + + const TypeInt *dest_pos_t = phase->type(dest_pos)->isa_int(); + const TypeInt *len_t = phase->type(len)->isa_int(); + const TypeAryPtr* ary_t = phase->type(dest)->isa_aryptr(); + + if (dest_pos_t != NULL && len_t != NULL && ary_t != NULL) { + BasicType ary_elem = ary_t->klass()->as_array_klass()->element_type()->basic_type(); + uint header = arrayOopDesc::base_offset_in_bytes(ary_elem); + uint elemsize = type2aelembytes(ary_elem); + + jlong dest_pos_plus_len_lo = (((jlong)dest_pos_t->_lo) + len_t->_lo) * elemsize + header; + jlong dest_pos_plus_len_hi = (((jlong)dest_pos_t->_hi) + len_t->_hi) * elemsize + header; + jlong dest_pos_lo = ((jlong)dest_pos_t->_lo) * elemsize + header; + jlong dest_pos_hi = ((jlong)dest_pos_t->_hi) * elemsize + header; + + if (must_modify) { + if (offset_lo >= dest_pos_hi && offset_hi < dest_pos_plus_len_lo) { + return true; + } + } else { + if (offset_hi >= dest_pos_lo && offset_lo < dest_pos_plus_len_hi) { + return true; + } + } + } + return false; +}
--- a/src/share/vm/opto/arraycopynode.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/arraycopynode.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -108,6 +108,7 @@ BasicType copy_type, const Type* value_type, int count); bool finish_transform(PhaseGVN *phase, bool can_reshape, Node* ctl, Node *mem); + static bool may_modify_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase); public: @@ -162,6 +163,9 @@ bool is_alloc_tightly_coupled() const { return _alloc_tightly_coupled; } + static bool may_modify(const TypeOopPtr *t_oop, MemBarNode* mb, PhaseTransform *phase); + bool modifies(intptr_t offset_lo, intptr_t offset_hi, PhaseTransform* phase, bool must_modify); + #ifndef PRODUCT virtual void dump_spec(outputStream *st) const; virtual void dump_compact_spec(outputStream* st) const;
--- a/src/share/vm/opto/c2compiler.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/c2compiler.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -161,7 +161,7 @@ vmIntrinsics::ID id = method->intrinsic_id(); assert(id != vmIntrinsics::_none, "must be a VM intrinsic"); - if (id < vmIntrinsics::FIRST_ID || id >= vmIntrinsics::LAST_COMPILER_INLINE) { + if (id < vmIntrinsics::FIRST_ID || id > vmIntrinsics::LAST_COMPILER_INLINE) { return false; } @@ -419,6 +419,8 @@ case vmIntrinsics::_updateByteBufferCRC32: case vmIntrinsics::_updateBytesCRC32C: case vmIntrinsics::_updateDirectByteBufferCRC32C: + case vmIntrinsics::_updateBytesAdler32: + case vmIntrinsics::_updateByteBufferAdler32: case vmIntrinsics::_profileBoolean: case vmIntrinsics::_isCompileConstant: break;
--- a/src/share/vm/opto/callnode.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/callnode.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -742,7 +742,7 @@ // bool CallNode::may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { assert((t_oop != NULL), "sanity"); - if (is_call_to_arraycopystub()) { + if (is_call_to_arraycopystub() && strcmp(_name, "unsafe_arraycopy") != 0) { const TypeTuple* args = _tf->domain(); Node* dest = NULL; // Stubs that can be called once an ArrayCopyNode is expanded have
--- a/src/share/vm/opto/chaitin.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/chaitin.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1008,9 +1008,13 @@ // FOUR registers! #ifdef ASSERT if (is_vect) { - assert(lrgmask.is_aligned_sets(lrg.num_regs()), "vector should be aligned"); - assert(!lrg._fat_proj, "sanity"); - assert(RegMask::num_registers(kreg) == lrg.num_regs(), "sanity"); + if (lrg.num_regs() != 0) { + assert(lrgmask.is_aligned_sets(lrg.num_regs()), "vector should be aligned"); + assert(!lrg._fat_proj, "sanity"); + assert(RegMask::num_registers(kreg) == lrg.num_regs(), "sanity"); + } else { + assert(n->is_Phi(), "not all inputs processed only if Phi"); + } } #endif if (!is_vect && lrg.num_regs() == 2 && !lrg._fat_proj && rm.is_misaligned_pair()) {
--- a/src/share/vm/opto/compile.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/compile.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -93,7 +93,7 @@ public: void set_idx(node_idx_t idx) { - _idx_clone_orig = _idx_clone_orig & 0xFFFFFFFF00000000 | idx; + _idx_clone_orig = _idx_clone_orig & CONST64(0xFFFFFFFF00000000) | idx; } node_idx_t idx() const { return (node_idx_t)(_idx_clone_orig & 0xFFFFFFFF); } @@ -523,7 +523,7 @@ void print_inlining(ciMethod* method, int inline_level, int bci, const char* msg = NULL) { stringStream ss; - CompileTask::print_inlining(&ss, method, inline_level, bci, msg); + CompileTask::print_inlining_inner(&ss, method, inline_level, bci, msg); print_inlining_stream()->print("%s", ss.as_string()); }
--- a/src/share/vm/opto/doCall.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/doCall.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -49,7 +49,7 @@ method->print_short_name(); tty->cr(); } - CompileTask::print_inlining(prof_method, depth, bci); + CompileTask::print_inlining_tty(prof_method, depth, bci); } else { out = C->print_inlining_stream(); }
--- a/src/share/vm/opto/escape.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/escape.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -979,6 +979,7 @@ strcmp(call->as_CallLeaf()->_name, "shenandoah_cas_obj") == 0 || strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32") == 0 || strcmp(call->as_CallLeaf()->_name, "updateBytesCRC32C") == 0 || + strcmp(call->as_CallLeaf()->_name, "updateBytesAdler32") == 0 || strcmp(call->as_CallLeaf()->_name, "aescrypt_encryptBlock") == 0 || strcmp(call->as_CallLeaf()->_name, "aescrypt_decryptBlock") == 0 || strcmp(call->as_CallLeaf()->_name, "cipherBlockChaining_encryptAESCrypt") == 0 || @@ -3264,7 +3265,7 @@ // Note 2: MergeMem may already contains instance memory slices added // during find_inst_mem() call when memory nodes were processed above. igvn->hash_delete(nmm); - uint nslices = nmm->req(); + uint nslices = MIN2(nmm->req(), new_index_start); for (uint i = Compile::AliasIdxRaw+1; i < nslices; i++) { Node* mem = nmm->in(i); Node* cur = NULL;
--- a/src/share/vm/opto/graphKit.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/graphKit.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1533,7 +1533,7 @@ g1_write_barrier_pre(do_load, obj, adr, adr_idx, val, val_type, pre_val, bt); break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: break; @@ -1551,7 +1551,7 @@ case BarrierSet::ShenandoahBarrierSet: return true; // Can move it if no safepoint - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: case BarrierSet::ModRef: return true; // There is no pre-barrier @@ -1577,7 +1577,7 @@ g1_write_barrier_post(store, obj, adr, adr_idx, val, bt, use_precise); break; - case BarrierSet::CardTableModRef: + case BarrierSet::CardTableForRS: case BarrierSet::CardTableExtension: write_barrier_post(store, obj, adr, adr_idx, val, use_precise); break; @@ -3823,7 +3823,7 @@ Node* cast = __ CastPX(__ ctrl(), adr); // Divide by card size - assert(Universe::heap()->barrier_set()->kind() == BarrierSet::CardTableModRef, + assert(Universe::heap()->barrier_set()->is_a(BarrierSet::CardTableModRef), "Only one we handle so far."); Node* card_offset = __ URShiftX( cast, __ ConI(CardTableModRefBS::card_shift) );
--- a/src/share/vm/opto/library_call.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/library_call.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -299,6 +299,8 @@ Node* get_table_from_crc32c_class(ciInstanceKlass *crc32c_class); bool inline_updateBytesCRC32C(); bool inline_updateDirectByteBufferCRC32C(); + bool inline_updateBytesAdler32(); + bool inline_updateByteBufferAdler32(); bool inline_multiplyToLen(); bool inline_squareToLen(); bool inline_mulAdd(); @@ -702,6 +704,11 @@ case vmIntrinsics::_updateDirectByteBufferCRC32C: return inline_updateDirectByteBufferCRC32C(); + case vmIntrinsics::_updateBytesAdler32: + return inline_updateBytesAdler32(); + case vmIntrinsics::_updateByteBufferAdler32: + return inline_updateByteBufferAdler32(); + case vmIntrinsics::_profileBoolean: return inline_profileBoolean(); case vmIntrinsics::_isCompileConstant: @@ -2840,7 +2847,22 @@ } } - post_barrier(control(), result, base, adr, alias_idx, newval, T_OBJECT, true); + if (kind == LS_cmpxchg) { + // Emit the post barrier only when the actual store happened. + // This makes sense to check only for compareAndSet that can fail to set the value. + // CAS success path is marked more likely since we anticipate this is a performance + // critical path, while CAS failure path can use the penalty for going through unlikely + // path as backoff. Which is still better than doing a store barrier there. + IdealKit ideal(this); + ideal.if_then(result, BoolTest::ne, ideal.ConI(0), PROB_STATIC_FREQUENT); { + sync_kit(ideal); + post_barrier(ideal.ctrl(), result, base, adr, alias_idx, newval, T_OBJECT, true); + ideal.sync_kit(this); + } ideal.end_if(); + final_sync(ideal); + } else { + post_barrier(control(), result, base, adr, alias_idx, newval, T_OBJECT, true); + } break; default: fatal(err_msg_res("unexpected type %d: %s", type, type2name(type))); @@ -5710,6 +5732,87 @@ return true; } +//------------------------------inline_updateBytesAdler32---------------------- +// +// Calculate Adler32 checksum for byte[] array. +// int java.util.zip.Adler32.updateBytes(int crc, byte[] buf, int off, int len) +// +bool LibraryCallKit::inline_updateBytesAdler32() { + assert(UseAdler32Intrinsics, "Adler32 Instrinsic support need"); // check if we actually need to check this flag or check a different one + assert(callee()->signature()->size() == 4, "updateBytes has 4 parameters"); + assert(callee()->holder()->is_loaded(), "Adler32 class must be loaded"); + // no receiver since it is static method + Node* crc = argument(0); // type: int + Node* src = argument(1); // type: oop + Node* offset = argument(2); // type: int + Node* length = argument(3); // type: int + + const Type* src_type = src->Value(&_gvn); + const TypeAryPtr* top_src = src_type->isa_aryptr(); + if (top_src == NULL || top_src->klass() == NULL) { + // failed array check + return false; + } + + // Figure out the size and type of the elements we will be copying. + BasicType src_elem = src_type->isa_aryptr()->klass()->as_array_klass()->element_type()->basic_type(); + if (src_elem != T_BYTE) { + return false; + } + + // 'src_start' points to src array + scaled offset + Node* src_start = array_element_address(src, offset, src_elem); + + // We assume that range check is done by caller. + // TODO: generate range check (offset+length < src.length) in debug VM. + + // Call the stub. + address stubAddr = StubRoutines::updateBytesAdler32(); + const char *stubName = "updateBytesAdler32"; + + Node* call = make_runtime_call(RC_LEAF, OptoRuntime::updateBytesAdler32_Type(), + stubAddr, stubName, TypePtr::BOTTOM, + crc, src_start, length); + Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms)); + set_result(result); + return true; +} + +//------------------------------inline_updateByteBufferAdler32--------------- +// +// Calculate Adler32 checksum for DirectByteBuffer. +// int java.util.zip.Adler32.updateByteBuffer(int crc, long buf, int off, int len) +// +bool LibraryCallKit::inline_updateByteBufferAdler32() { + assert(UseAdler32Intrinsics, "Adler32 Instrinsic support need"); // check if we actually need to check this flag or check a different one + assert(callee()->signature()->size() == 5, "updateByteBuffer has 4 parameters and one is long"); + assert(callee()->holder()->is_loaded(), "Adler32 class must be loaded"); + // no receiver since it is static method + Node* crc = argument(0); // type: int + Node* src = argument(1); // type: long + Node* offset = argument(3); // type: int + Node* length = argument(4); // type: int + + src = ConvL2X(src); // adjust Java long to machine word + Node* base = _gvn.transform(new CastX2PNode(src)); + offset = ConvI2X(offset); + + // 'src_start' points to src array + scaled offset + Node* src_start = basic_plus_adr(top(), base, offset); + + // Call the stub. + address stubAddr = StubRoutines::updateBytesAdler32(); + const char *stubName = "updateBytesAdler32"; + + Node* call = make_runtime_call(RC_LEAF, OptoRuntime::updateBytesAdler32_Type(), + stubAddr, stubName, TypePtr::BOTTOM, + crc, src_start, length); + + Node* result = _gvn.transform(new ProjNode(call, TypeFunc::Parms)); + set_result(result); + return true; +} + //----------------------------inline_reference_get---------------------------- // public T java.lang.ref.Reference.get(); bool LibraryCallKit::inline_reference_get() {
--- a/src/share/vm/opto/loopnode.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/loopnode.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1175,7 +1175,7 @@ //============================================================================= //------------------------------is_member-------------------------------------- // Is 'l' a member of 'this'? -int IdealLoopTree::is_member( const IdealLoopTree *l ) const { +bool IdealLoopTree::is_member(const IdealLoopTree *l) const { while( l->_nest > _nest ) l = l->_parent; return l == this; }
--- a/src/share/vm/opto/loopnode.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/loopnode.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -384,7 +384,7 @@ { } // Is 'l' a member of 'this'? - int is_member( const IdealLoopTree *l ) const; // Test for nested membership + bool is_member(const IdealLoopTree *l) const; // Test for nested membership // Set loop nesting depth. Accumulate has_call bits. int set_nest( uint depth ); @@ -1088,6 +1088,8 @@ bool split_up( Node *n, Node *blk1, Node *blk2 ); void sink_use( Node *use, Node *post_loop ); Node *place_near_use( Node *useblock ) const; + Node* try_move_store_before_loop(Node* n, Node *n_ctrl); + void try_move_store_after_loop(Node* n); bool _created_loop_node; public:
--- a/src/share/vm/opto/loopopts.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/loopopts.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -694,6 +694,207 @@ return iff->in(1); } +#ifdef ASSERT +static void enqueue_cfg_uses(Node* m, Unique_Node_List& wq) { + for (DUIterator_Fast imax, i = m->fast_outs(imax); i < imax; i++) { + Node* u = m->fast_out(i); + if (u->is_CFG()) { + if (u->Opcode() == Op_NeverBranch) { + u = ((NeverBranchNode*)u)->proj_out(0); + enqueue_cfg_uses(u, wq); + } else { + wq.push(u); + } + } + } +} +#endif + +// Try moving a store out of a loop, right before the loop +Node* PhaseIdealLoop::try_move_store_before_loop(Node* n, Node *n_ctrl) { + // Store has to be first in the loop body + IdealLoopTree *n_loop = get_loop(n_ctrl); + if (n->is_Store() && n_loop != _ltree_root && n_loop->is_loop() && n->in(0) != NULL) { + Node* address = n->in(MemNode::Address); + Node* value = n->in(MemNode::ValueIn); + Node* mem = n->in(MemNode::Memory); + IdealLoopTree* address_loop = get_loop(get_ctrl(address)); + IdealLoopTree* value_loop = get_loop(get_ctrl(value)); + + // - address and value must be loop invariant + // - memory must be a memory Phi for the loop + // - Store must be the only store on this memory slice in the + // loop: if there's another store following this one then value + // written at iteration i by the second store could be overwritten + // at iteration i+n by the first store: it's not safe to move the + // first store out of the loop + // - nothing must observe the Phi memory: it guarantees no read + // before the store and no early exit out of the loop + // With those conditions, we are also guaranteed the store post + // dominates the loop head. Otherwise there would be extra Phi + // involved between the loop's Phi and the store. + + if (!n_loop->is_member(address_loop) && + !n_loop->is_member(value_loop) && + mem->is_Phi() && mem->in(0) == n_loop->_head && + mem->outcnt() == 1 && + mem->in(LoopNode::LoopBackControl) == n) { + +#ifdef ASSERT + // Verify that store's control does post dominate loop entry and + // that there's no early exit of the loop before the store. + bool ctrl_ok = false; + { + // Follow control from loop head until n, we exit the loop or + // we reach the tail + ResourceMark rm; + Unique_Node_List wq; + wq.push(n_loop->_head); + assert(n_loop->_tail != NULL, "need a tail"); + for (uint next = 0; next < wq.size(); ++next) { + Node *m = wq.at(next); + if (m == n->in(0)) { + ctrl_ok = true; + continue; + } + assert(!has_ctrl(m), "should be CFG"); + if (!n_loop->is_member(get_loop(m)) || m == n_loop->_tail) { + ctrl_ok = false; + break; + } + enqueue_cfg_uses(m, wq); + } + } + assert(ctrl_ok, "bad control"); +#endif + + // move the Store + _igvn.replace_input_of(mem, LoopNode::LoopBackControl, mem); + _igvn.replace_input_of(n, 0, n_loop->_head->in(LoopNode::EntryControl)); + _igvn.replace_input_of(n, MemNode::Memory, mem->in(LoopNode::EntryControl)); + // Disconnect the phi now. An empty phi can confuse other + // optimizations in this pass of loop opts. + _igvn.replace_node(mem, mem->in(LoopNode::EntryControl)); + n_loop->_body.yank(mem); + + IdealLoopTree* new_loop = get_loop(n->in(0)); + set_ctrl_and_loop(n, n->in(0)); + + return n; + } + } + return NULL; +} + +// Try moving a store out of a loop, right after the loop +void PhaseIdealLoop::try_move_store_after_loop(Node* n) { + if (n->is_Store() && n->in(0) != NULL) { + Node *n_ctrl = get_ctrl(n); + IdealLoopTree *n_loop = get_loop(n_ctrl); + // Store must be in a loop + if (n_loop != _ltree_root && !n_loop->_irreducible) { + Node* address = n->in(MemNode::Address); + Node* value = n->in(MemNode::ValueIn); + IdealLoopTree* address_loop = get_loop(get_ctrl(address)); + // address must be loop invariant + if (!n_loop->is_member(address_loop)) { + // Store must be last on this memory slice in the loop and + // nothing in the loop must observe it + Node* phi = NULL; + for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) { + Node* u = n->fast_out(i); + if (has_ctrl(u)) { // control use? + IdealLoopTree *u_loop = get_loop(get_ctrl(u)); + if (!n_loop->is_member(u_loop)) { + continue; + } + if (u->is_Phi() && u->in(0) == n_loop->_head) { + assert(_igvn.type(u) == Type::MEMORY, "bad phi"); + assert(phi == NULL, "already found"); + phi = u; + continue; + } + } + phi = NULL; + break; + } + if (phi != NULL) { + // Nothing in the loop before the store (next iteration) + // must observe the stored value + bool mem_ok = true; + { + ResourceMark rm; + Unique_Node_List wq; + wq.push(phi); + for (uint next = 0; next < wq.size() && mem_ok; ++next) { + Node *m = wq.at(next); + for (DUIterator_Fast imax, i = m->fast_outs(imax); i < imax && mem_ok; i++) { + Node* u = m->fast_out(i); + if (u->is_Store() || u->is_Phi()) { + if (u != n) { + wq.push(u); + mem_ok = (wq.size() <= 10); + } + } else { + mem_ok = false; + break; + } + } + } + } + if (mem_ok) { + // Move the Store out of the loop creating clones along + // all paths out of the loop that observe the stored value + _igvn.rehash_node_delayed(phi); + int count = phi->replace_edge(n, n->in(MemNode::Memory)); + assert(count > 0, "inconsistent phi"); + for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) { + Node* u = n->fast_out(i); + Node* c = get_ctrl(u); + + if (u->is_Phi()) { + c = u->in(0)->in(u->find_edge(n)); + } + IdealLoopTree *u_loop = get_loop(c); + assert (!n_loop->is_member(u_loop), "only the phi should have been a use in the loop"); + while(true) { + Node* next_c = find_non_split_ctrl(idom(c)); + if (n_loop->is_member(get_loop(next_c))) { + break; + } + c = next_c; + } + + Node* st = n->clone(); + st->set_req(0, c); + _igvn.register_new_node_with_optimizer(st); + + set_ctrl(st, c); + IdealLoopTree* new_loop = get_loop(c); + assert(new_loop != n_loop, "should be moved out of loop"); + if (new_loop->_child == NULL) new_loop->_body.push(st); + + _igvn.replace_input_of(u, u->find_edge(n), st); + --imax; + --i; + } + + + assert(n->outcnt() == 0, "all uses should be gone"); + _igvn.replace_input_of(n, MemNode::Memory, C->top()); + // Disconnect the phi now. An empty phi can confuse other + // optimizations in this pass of loop opts.. + if (phi->in(LoopNode::LoopBackControl) == phi) { + _igvn.replace_node(phi, phi->in(LoopNode::EntryControl)); + n_loop->_body.yank(phi); + } + } + } + } + } + } +} + //------------------------------split_if_with_blocks_pre----------------------- // Do the real work in a non-recursive function. Data nodes want to be // cloned in the pre-order so they can feed each other nicely. @@ -724,6 +925,11 @@ Node *n_ctrl = get_ctrl(n); if( !n_ctrl ) return n; // Dead node + Node* res = try_move_store_before_loop(n, n_ctrl); + if (res != NULL) { + return n; + } + // Attempt to remix address expressions for loop invariants Node *m = remix_address_expressions( n ); if( m ) return m; @@ -732,16 +938,18 @@ // Returns the block to clone thru. Node *n_blk = has_local_phi_input( n ); if( !n_blk ) return n; + // Do not clone the trip counter through on a CountedLoop // (messes up the canonical shape). if( n_blk->is_CountedLoop() && n->Opcode() == Op_AddI ) return n; // Check for having no control input; not pinned. Allow // dominating control. - if( n->in(0) ) { + if (n->in(0)) { Node *dom = idom(n_blk); - if( dom_lca( n->in(0), dom ) != n->in(0) ) + if (dom_lca(n->in(0), dom) != n->in(0)) { return n; + } } // Policy: when is it profitable. You must get more wins than // policy before it is considered profitable. Policy is usually 0, @@ -1080,6 +1288,8 @@ } } + try_move_store_after_loop(n); + // Check for Opaque2's who's loop has disappeared - who's input is in the // same loop nest as their output. Remove 'em, they are no longer useful. if( n_op == Op_Opaque2 &&
--- a/src/share/vm/opto/macro.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/macro.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -325,18 +325,28 @@ return in; } else if (in->is_Call()) { CallNode *call = in->as_Call(); - if (!call->may_modify(tinst, phase)) { - mem = call->in(TypeFunc::Memory); + if (call->may_modify(tinst, phase)) { + assert(call->is_ArrayCopy(), "ArrayCopy is the only call node that doesn't make allocation escape"); + + if (call->as_ArrayCopy()->modifies(offset, offset, phase, false)) { + return in; + } } mem = in->in(TypeFunc::Memory); } else if (in->is_MemBar()) { + if (ArrayCopyNode::may_modify(tinst, in->as_MemBar(), phase)) { + assert(in->in(0)->is_Proj() && in->in(0)->in(0)->is_ArrayCopy(), "should be arraycopy"); + ArrayCopyNode* ac = in->in(0)->in(0)->as_ArrayCopy(); + assert(ac->is_clonebasic(), "Only basic clone is a non escaping clone"); + return ac; + } mem = in->in(TypeFunc::Memory); } else { assert(false, "unexpected projection"); } } else if (mem->is_Store()) { const TypePtr* atype = mem->as_Store()->adr_type(); - int adr_idx = Compile::current()->get_alias_index(atype); + int adr_idx = phase->C->get_alias_index(atype); if (adr_idx == alias_idx) { assert(atype->isa_oopptr(), "address type must be oopptr"); int adr_offset = atype->offset(); @@ -374,7 +384,7 @@ adr = mem->in(3); // Destination array } const TypePtr* atype = adr->bottom_type()->is_ptr(); - int adr_idx = Compile::current()->get_alias_index(atype); + int adr_idx = phase->C->get_alias_index(atype); if (adr_idx == alias_idx) { assert(false, "Object is not scalar replaceable if a LoadStore node access its field"); return NULL; @@ -387,12 +397,63 @@ } } +// Generate loads from source of the arraycopy for fields of +// destination needed at a deoptimization point +Node* PhaseMacroExpand::make_arraycopy_load(ArrayCopyNode* ac, intptr_t offset, Node* ctl, BasicType ft, const Type *ftype, AllocateNode *alloc) { + BasicType bt = ft; + const Type *type = ftype; + if (ft == T_NARROWOOP) { + bt = T_OBJECT; + type = ftype->make_oopptr(); + } + Node* res = NULL; + if (ac->is_clonebasic()) { + Node* base = ac->in(ArrayCopyNode::Src)->in(AddPNode::Base); + Node* adr = _igvn.transform(new AddPNode(base, base, MakeConX(offset))); + const TypePtr* adr_type = _igvn.type(base)->is_ptr()->add_offset(offset); + Node* m = ac->in(TypeFunc::Memory); + while (m->is_MergeMem()) { + m = m->as_MergeMem()->memory_at(C->get_alias_index(adr_type)); + if (m->is_Proj() && m->in(0)->is_MemBar()) { + m = m->in(0)->in(TypeFunc::Memory); + } + } + res = LoadNode::make(_igvn, ctl, m, adr, adr_type, type, bt, MemNode::unordered, LoadNode::Pinned); + } else { + if (ac->modifies(offset, offset, &_igvn, true)) { + assert(ac->in(ArrayCopyNode::Dest) == alloc->result_cast(), "arraycopy destination should be allocation's result"); + uint shift = exact_log2(type2aelembytes(bt)); + Node* diff = _igvn.transform(new SubINode(ac->in(ArrayCopyNode::SrcPos), ac->in(ArrayCopyNode::DestPos))); +#ifdef _LP64 + diff = _igvn.transform(new ConvI2LNode(diff)); +#endif + diff = _igvn.transform(new LShiftXNode(diff, intcon(shift))); + + Node* off = _igvn.transform(new AddXNode(MakeConX(offset), diff)); + Node* base = ac->in(ArrayCopyNode::Src); + Node* adr = _igvn.transform(new AddPNode(base, base, off)); + const TypePtr* adr_type = _igvn.type(base)->is_ptr()->add_offset(offset); + Node* m = ac->in(TypeFunc::Memory); + res = LoadNode::make(_igvn, ctl, m, adr, adr_type, type, bt, MemNode::unordered, LoadNode::Pinned); + } + } + if (res != NULL) { + res = _igvn.transform(res); + if (ftype->isa_narrowoop()) { + // PhaseMacroExpand::scalar_replacement adds DecodeN nodes + res = _igvn.transform(new EncodePNode(res, ftype)); + } + return res; + } + return NULL; +} + // // Given a Memory Phi, compute a value Phi containing the values from stores // on the input paths. -// Note: this function is recursive, its depth is limied by the "level" argument +// Note: this function is recursive, its depth is limited by the "level" argument // Returns the computed Phi, or NULL if it cannot compute it. -Node *PhaseMacroExpand::value_from_mem_phi(Node *mem, BasicType ft, const Type *phi_type, const TypeOopPtr *adr_t, Node *alloc, Node_Stack *value_phis, int level) { +Node *PhaseMacroExpand::value_from_mem_phi(Node *mem, BasicType ft, const Type *phi_type, const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis, int level) { assert(mem->is_Phi(), "sanity"); int alias_idx = C->get_alias_index(adr_t); int offset = adr_t->offset(); @@ -459,6 +520,12 @@ assert(val->in(0)->is_LoadStore() || val->in(0)->Opcode() == Op_EncodeISOArray, "sanity"); assert(false, "Object is not scalar replaceable if a LoadStore node access its field"); return NULL; + } else if (val->is_ArrayCopy()) { + Node* res = make_arraycopy_load(val->as_ArrayCopy(), offset, val->in(0), ft, phi_type, alloc); + if (res == NULL) { + return NULL; + } + values.at_put(j, res); } else { #ifdef ASSERT val->dump(); @@ -480,7 +547,7 @@ } // Search the last value stored into the object's field. -Node *PhaseMacroExpand::value_from_mem(Node *sfpt_mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc) { +Node *PhaseMacroExpand::value_from_mem(Node *sfpt_mem, Node *sfpt_ctl, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc) { assert(adr_t->is_known_instance_field(), "instance required"); int instance_id = adr_t->instance_id(); assert((uint)instance_id == alloc->_idx, "wrong allocation"); @@ -539,6 +606,8 @@ } else { done = true; } + } else if (mem->is_ArrayCopy()) { + done = true; } else { assert(false, "unexpected node"); } @@ -563,6 +632,13 @@ value_phis.pop(); } } + } else if (mem->is_ArrayCopy()) { + Node* ctl = mem->in(0); + if (sfpt_ctl->is_Proj() && sfpt_ctl->as_Proj()->is_uncommon_trap_proj(Deoptimization::Reason_none)) { + // pin the loads in the uncommon trap path + ctl = sfpt_ctl; + } + return make_arraycopy_load(mem->as_ArrayCopy(), offset, ctl, ft, ftype, alloc); } } // Something go wrong. @@ -739,6 +815,7 @@ while (safepoints.length() > 0) { SafePointNode* sfpt = safepoints.pop(); Node* mem = sfpt->memory(); + Node* ctl = sfpt->control(); assert(sfpt->jvms() != NULL, "missed JVMS"); // Fields of scalar objs are referenced only at the end // of regular debuginfo at the last (youngest) JVMS. @@ -790,7 +867,7 @@ const TypeOopPtr *field_addr_type = res_type->add_offset(offset)->isa_oopptr(); - Node *field_val = value_from_mem(mem, basic_elem_type, field_type, field_addr_type, alloc); + Node *field_val = value_from_mem(mem, ctl, basic_elem_type, field_type, field_addr_type, alloc); if (field_val == NULL) { // We weren't able to find a value for this field, // give up on eliminating this allocation.
--- a/src/share/vm/opto/macro.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/macro.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -87,8 +87,8 @@ Node* length, const TypeFunc* slow_call_type, address slow_call_address); - Node *value_from_mem(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc); - Node *value_from_mem_phi(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, Node *alloc, Node_Stack *value_phis, int level); + Node *value_from_mem(Node *mem, Node *ctl, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc); + Node *value_from_mem_phi(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis, int level); bool eliminate_boxing_node(CallStaticJavaNode *boxing); bool eliminate_allocate_node(AllocateNode *alloc); @@ -202,6 +202,8 @@ Node* old_eden_top, Node* new_eden_top, Node* length); + Node* make_arraycopy_load(ArrayCopyNode* ac, intptr_t offset, Node* ctl, BasicType ft, const Type *ftype, AllocateNode *alloc); + public: PhaseMacroExpand(PhaseIterGVN &igvn) : Phase(Macro_Expand), _igvn(igvn), _has_locks(false) { _igvn.set_delay_transform(true);
--- a/src/share/vm/opto/memnode.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/memnode.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -109,37 +109,6 @@ #endif -static bool membar_for_arraycopy_helper(const TypeOopPtr *t_oop, Node* n, PhaseTransform *phase) { - if (n->is_Proj()) { - n = n->in(0); - if (n->is_Call() && n->as_Call()->may_modify(t_oop, phase)) { - return true; - } - } - return false; -} - -static bool membar_for_arraycopy(const TypeOopPtr *t_oop, MemBarNode* mb, PhaseTransform *phase) { - Node* mem = mb->in(TypeFunc::Memory); - - if (mem->is_MergeMem()) { - Node* n = mem->as_MergeMem()->memory_at(Compile::AliasIdxRaw); - if (membar_for_arraycopy_helper(t_oop, n, phase)) { - return true; - } else if (n->is_Phi()) { - for (uint i = 1; i < n->req(); i++) { - if (n->in(i) != NULL) { - if (membar_for_arraycopy_helper(t_oop, n->in(i), phase)) { - return true; - } - } - } - } - } - - return false; -} - Node *MemNode::optimize_simple_memory_chain(Node *mchain, const TypeOopPtr *t_oop, Node *load, PhaseGVN *phase) { assert((t_oop != NULL), "sanity"); bool is_instance = t_oop->is_known_instance_field(); @@ -184,7 +153,7 @@ } } } else if (proj_in->is_MemBar()) { - if (membar_for_arraycopy(t_oop, proj_in->as_MemBar(), phase)) { + if (ArrayCopyNode::may_modify(t_oop, proj_in->as_MemBar(), phase)) { break; } result = proj_in->in(TypeFunc::Memory); @@ -546,35 +515,12 @@ Node* dest = ac->in(ArrayCopyNode::Dest); if (dest == ld_base) { - Node* src_pos = ac->in(ArrayCopyNode::SrcPos); - Node* dest_pos = ac->in(ArrayCopyNode::DestPos); - Node* len = ac->in(ArrayCopyNode::Length); - - const TypeInt *dest_pos_t = phase->type(dest_pos)->isa_int(); const TypeX *ld_offs_t = phase->type(ld_offs)->isa_intptr_t(); - const TypeInt *len_t = phase->type(len)->isa_int(); - const TypeAryPtr* ary_t = phase->type(dest)->isa_aryptr(); - - if (dest_pos_t != NULL && ld_offs_t != NULL && len_t != NULL && ary_t != NULL) { - BasicType ary_elem = ary_t->klass()->as_array_klass()->element_type()->basic_type(); - uint header = arrayOopDesc::base_offset_in_bytes(ary_elem); - uint elemsize = type2aelembytes(ary_elem); - - intptr_t dest_pos_plus_len_lo = (((intptr_t)dest_pos_t->_lo) + len_t->_lo) * elemsize + header; - intptr_t dest_pos_plus_len_hi = (((intptr_t)dest_pos_t->_hi) + len_t->_hi) * elemsize + header; - intptr_t dest_pos_lo = ((intptr_t)dest_pos_t->_lo) * elemsize + header; - intptr_t dest_pos_hi = ((intptr_t)dest_pos_t->_hi) * elemsize + header; - - if (can_see_stored_value) { - if (ld_offs_t->_lo >= dest_pos_hi && ld_offs_t->_hi < dest_pos_plus_len_lo) { - return ac; - } - } else { - if (ld_offs_t->_hi < dest_pos_lo || ld_offs_t->_lo >= dest_pos_plus_len_hi) { - mem = ac->in(TypeFunc::Memory); - } - return ac; - } + if (ac->modifies(ld_offs_t->_lo, ld_offs_t->_hi, phase, can_see_stored_value)) { + return ac; + } + if (!can_see_stored_value) { + mem = ac->in(TypeFunc::Memory); } } } @@ -704,7 +650,7 @@ continue; // (a) advance through independent call memory } } else if (mem->is_Proj() && mem->in(0)->is_MemBar()) { - if (membar_for_arraycopy(addr_t, mem->in(0)->as_MemBar(), phase)) { + if (ArrayCopyNode::may_modify(addr_t, mem->in(0)->as_MemBar(), phase)) { break; } mem = mem->in(0)->in(TypeFunc::Memory); @@ -884,18 +830,17 @@ // Is the value loaded previously stored by an arraycopy? If so return // a load node that reads from the source array so we may be able to // optimize out the ArrayCopy node later. -Node* MemNode::can_see_arraycopy_value(Node* st, PhaseTransform* phase) const { +Node* LoadNode::can_see_arraycopy_value(Node* st, PhaseTransform* phase) const { Node* ld_adr = in(MemNode::Address); intptr_t ld_off = 0; AllocateNode* ld_alloc = AllocateNode::Ideal_allocation(ld_adr, phase, ld_off); Node* ac = find_previous_arraycopy(phase, ld_alloc, st, true); if (ac != NULL) { assert(ac->is_ArrayCopy(), "what kind of node can this be?"); - assert(is_Load(), "only for loads"); - + + Node* ld = clone(); if (ac->as_ArrayCopy()->is_clonebasic()) { assert(ld_alloc != NULL, "need an alloc"); - Node* ld = clone(); Node* addp = in(MemNode::Address)->clone(); assert(addp->is_AddP(), "address must be addp"); assert(addp->in(AddPNode::Base) == ac->in(ArrayCopyNode::Dest)->in(AddPNode::Base), "strange pattern"); @@ -907,9 +852,7 @@ assert(ld_alloc->in(0) != NULL, "alloc must have control"); ld->set_req(0, ld_alloc->in(0)); } - return ld; } else { - Node* ld = clone(); Node* addp = in(MemNode::Address)->clone(); assert(addp->in(AddPNode::Base) == addp->in(AddPNode::Address), "should be"); addp->set_req(AddPNode::Base, ac->in(ArrayCopyNode::Src)); @@ -934,8 +877,10 @@ assert(ac->in(0) != NULL, "alloc must have control"); ld->set_req(0, ac->in(0)); } - return ld; } + // load depends on the tests that validate the arraycopy + ld->as_Load()->_depends_only_on_test = Pinned; + return ld; } return NULL; } @@ -1738,6 +1683,9 @@ if (klass == env->String_klass() && adr->is_AddP() && off != Type::OffsetBot) { // For constant Strings treat the final fields as compile time constants. + // While we can list what field types java.lang.String has, it is more + // future-proof to handle all possible field types, anticipating future + // changes and experiments in String code. Node* base = adr->in(AddPNode::Base); const TypeOopPtr* t = phase->type(base)->isa_oopptr(); if (t != NULL && t->singleton()) { @@ -1745,14 +1693,13 @@ if (field != NULL && field->is_final()) { ciObject* string = t->const_oop(); ciConstant constant = string->as_instance()->field_value(field); - if (constant.basic_type() == T_INT) { - return TypeInt::make(constant.as_int()); - } else if (constant.basic_type() == T_ARRAY) { - if (adr->bottom_type()->is_ptr_to_narrowoop()) { - return TypeNarrowOop::make_from_constant(constant.as_object(), true); - } else { - return TypeOopPtr::make_from_constant(constant.as_object(), true); - } + // Type::make_from_constant does not handle narrow oops, so handle it here. + // Everything else can use the factory method. + if ((constant.basic_type() == T_ARRAY || constant.basic_type() == T_OBJECT) + && adr->bottom_type()->is_ptr_to_narrowoop()) { + return TypeNarrowOop::make_from_constant(constant.as_object(), true); + } else { + return Type::make_from_constant(constant, true); } } } @@ -2432,40 +2379,47 @@ Node* mem = in(MemNode::Memory); Node* address = in(MemNode::Address); - // Back-to-back stores to same address? Fold em up. Generally // unsafe if I have intervening uses... Also disallowed for StoreCM // since they must follow each StoreP operation. Redundant StoreCMs // are eliminated just before matching in final_graph_reshape. - if (mem->is_Store() && mem->in(MemNode::Address)->eqv_uncast(address) && - mem->Opcode() != Op_StoreCM) { - // Looking at a dead closed cycle of memory? - assert(mem != mem->in(MemNode::Memory), "dead loop in StoreNode::Ideal"); - - assert(Opcode() == mem->Opcode() || - phase->C->get_alias_index(adr_type()) == Compile::AliasIdxRaw, - "no mismatched stores, except on raw memory"); - - if (mem->outcnt() == 1 && // check for intervening uses - mem->as_Store()->memory_size() <= this->memory_size()) { - // If anybody other than 'this' uses 'mem', we cannot fold 'mem' away. - // For example, 'mem' might be the final state at a conditional return. - // Or, 'mem' might be used by some node which is live at the same time - // 'this' is live, which might be unschedulable. So, require exactly - // ONE user, the 'this' store, until such time as we clone 'mem' for - // each of 'mem's uses (thus making the exactly-1-user-rule hold true). - if (can_reshape) { // (%%% is this an anachronism?) - set_req_X(MemNode::Memory, mem->in(MemNode::Memory), - phase->is_IterGVN()); - } else { - // It's OK to do this in the parser, since DU info is always accurate, - // and the parser always refers to nodes via SafePointNode maps. - set_req(MemNode::Memory, mem->in(MemNode::Memory)); + { + Node* st = mem; + // If Store 'st' has more than one use, we cannot fold 'st' away. + // For example, 'st' might be the final state at a conditional + // return. Or, 'st' might be used by some node which is live at + // the same time 'st' is live, which might be unschedulable. So, + // require exactly ONE user until such time as we clone 'mem' for + // each of 'mem's uses (thus making the exactly-1-user-rule hold + // true). + while (st->is_Store() && st->outcnt() == 1 && st->Opcode() != Op_StoreCM) { + // Looking at a dead closed cycle of memory? + assert(st != st->in(MemNode::Memory), "dead loop in StoreNode::Ideal"); + assert(Opcode() == st->Opcode() || + st->Opcode() == Op_StoreVector || + Opcode() == Op_StoreVector || + phase->C->get_alias_index(adr_type()) == Compile::AliasIdxRaw || + (Opcode() == Op_StoreL && st->Opcode() == Op_StoreI), // expanded ClearArrayNode + err_msg_res("no mismatched stores, except on raw memory: %s %s", NodeClassNames[Opcode()], NodeClassNames[st->Opcode()])); + + if (st->in(MemNode::Address)->eqv_uncast(address) && + st->as_Store()->memory_size() <= this->memory_size()) { + Node* use = st->raw_out(0); + phase->igvn_rehash_node_delayed(use); + if (can_reshape) { + use->set_req_X(MemNode::Memory, st->in(MemNode::Memory), phase->is_IterGVN()); + } else { + // It's OK to do this in the parser, since DU info is always accurate, + // and the parser always refers to nodes via SafePointNode maps. + use->set_req(MemNode::Memory, st->in(MemNode::Memory)); + } + return this; } - return this; + st = st->in(MemNode::Memory); } } + // Capture an unaliased, unconditional, simple store into an initializer. // Or, if it is independent of the allocation, hoist it above the allocation. if (ReduceFieldZeroing && /*can_reshape &&*/
--- a/src/share/vm/opto/memnode.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/memnode.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -126,7 +126,6 @@ // Can this node (load or store) accurately see a stored value in // the given memory state? (The state may or may not be in(Memory).) Node* can_see_stored_value(Node* st, PhaseTransform* phase) const; - Node* can_see_arraycopy_value(Node* st, PhaseTransform* phase) const; #ifndef PRODUCT static void dump_adr_type(const Node* mem, const TypePtr* adr_type, outputStream *st); @@ -252,6 +251,9 @@ protected: const Type* load_array_final_field(const TypeKlassPtr *tkls, ciKlass* klass) const; + + Node* can_see_arraycopy_value(Node* st, PhaseTransform* phase) const; + // depends_only_on_test is almost always true, and needs to be almost always // true to enable key hoisting & commoning optimizations. However, for the // special case of RawPtr loads from TLS top & end, and other loads performed by
--- a/src/share/vm/opto/runtime.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/runtime.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -33,7 +33,6 @@ #include "code/scopeDesc.hpp" #include "code/vtableStubs.hpp" #include "compiler/compileBroker.hpp" -#include "compiler/compilerOracle.hpp" #include "compiler/oopMap.hpp" #include "gc/shenandoah/shenandoahBarrierSet.hpp" #include "gc/g1/g1SATBCardTableModRefBS.hpp" @@ -951,6 +950,28 @@ return TypeFunc::make(domain, range); } +/** +* int updateBytesAdler32(int adler, bytes* b, int off, int len) +*/ +const TypeFunc* OptoRuntime::updateBytesAdler32_Type() { + // create input type (domain) + int num_args = 3; + int argcnt = num_args; + const Type** fields = TypeTuple::fields(argcnt); + int argp = TypeFunc::Parms; + fields[argp++] = TypeInt::INT; // crc + fields[argp++] = TypePtr::NOTNULL; // src + offset + fields[argp++] = TypeInt::INT; // len + assert(argp == TypeFunc::Parms+argcnt, "correct decoding"); + const TypeTuple* domain = TypeTuple::make(TypeFunc::Parms+argcnt, fields); + + // result type needed + fields = TypeTuple::fields(1); + fields[TypeFunc::Parms+0] = TypeInt::INT; // crc result + const TypeTuple* range = TypeTuple::make(TypeFunc::Parms+1, fields); + return TypeFunc::make(domain, range); +} + // for cipherBlockChaining calls of aescrypt encrypt/decrypt, four pointers and a length, returning int const TypeFunc* OptoRuntime::cipherBlockChaining_aescrypt_Type() { // create input type (domain)
--- a/src/share/vm/opto/runtime.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/runtime.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -335,6 +335,8 @@ static const TypeFunc* updateBytesCRC32_Type(); static const TypeFunc* updateBytesCRC32C_Type(); + static const TypeFunc* updateBytesAdler32_Type(); + // leaf on stack replacement interpreter accessor types static const TypeFunc* osr_end_Type();
--- a/src/share/vm/opto/stringopts.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/opto/stringopts.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1576,53 +1576,59 @@ Node* result; if (!kit.stopped()) { + Node* char_array = NULL; + if (sc->num_arguments() == 1 && + (sc->mode(0) == StringConcat::StringMode || + sc->mode(0) == StringConcat::StringNullCheckMode)) { + // Handle the case when there is only a single String argument. + // In this case, we can just pull the value from the String itself. + char_array = kit.load_String_value(kit.control(), sc->argument(0)); + } else { + // length now contains the number of characters needed for the + // char[] so create a new AllocateArray for the char[] + { + PreserveReexecuteState preexecs(&kit); + // The original jvms is for an allocation of either a String or + // StringBuffer so no stack adjustment is necessary for proper + // reexecution. If we deoptimize in the slow path the bytecode + // will be reexecuted and the char[] allocation will be thrown away. + kit.jvms()->set_should_reexecute(true); + char_array = kit.new_array(__ makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_CHAR))), + length, 1); + } - // length now contains the number of characters needed for the - // char[] so create a new AllocateArray for the char[] - Node* char_array = NULL; - { - PreserveReexecuteState preexecs(&kit); - // The original jvms is for an allocation of either a String or - // StringBuffer so no stack adjustment is necessary for proper - // reexecution. If we deoptimize in the slow path the bytecode - // will be reexecuted and the char[] allocation will be thrown away. - kit.jvms()->set_should_reexecute(true); - char_array = kit.new_array(__ makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_CHAR))), - length, 1); - } - - // Mark the allocation so that zeroing is skipped since the code - // below will overwrite the entire array - AllocateArrayNode* char_alloc = AllocateArrayNode::Ideal_array_allocation(char_array, _gvn); - char_alloc->maybe_set_complete(_gvn); - - char_array = __ shenandoah_write_barrier(char_array); + // Mark the allocation so that zeroing is skipped since the code + // below will overwrite the entire array + AllocateArrayNode* char_alloc = AllocateArrayNode::Ideal_array_allocation(char_array, _gvn); + char_alloc->maybe_set_complete(_gvn); - // Now copy the string representations into the final char[] - Node* start = __ intcon(0); - for (int argi = 0; argi < sc->num_arguments(); argi++) { - Node* arg = sc->argument(argi); - switch (sc->mode(argi)) { - case StringConcat::IntMode: { - Node* end = __ AddI(start, string_sizes->in(argi)); - // getChars words backwards so pass the ending point as well as the start - int_getChars(kit, arg, char_array, start, end); - start = end; - break; + // Now copy the string representations into the final char[] + char_array = __ shenandoah_write_barrier(char_array); + Node* start = __ intcon(0); + for (int argi = 0; argi < sc->num_arguments(); argi++) { + Node* arg = sc->argument(argi); + switch (sc->mode(argi)) { + case StringConcat::IntMode: { + Node* end = __ AddI(start, string_sizes->in(argi)); + // getChars words backwards so pass the ending point as well as the start + int_getChars(kit, arg, char_array, start, end); + start = end; + break; + } + case StringConcat::StringNullCheckMode: + case StringConcat::StringMode: { + start = copy_string(kit, arg, char_array, start); + break; + } + case StringConcat::CharMode: { + __ store_to_memory(kit.control(), kit.array_element_address(char_array, start, T_CHAR), + arg, T_CHAR, char_adr_idx, MemNode::unordered); + start = __ AddI(start, __ intcon(1)); + break; + } + default: + ShouldNotReachHere(); } - case StringConcat::StringNullCheckMode: - case StringConcat::StringMode: { - start = copy_string(kit, arg, char_array, start); - break; - } - case StringConcat::CharMode: { - __ store_to_memory(kit.control(), kit.array_element_address(char_array, start, T_CHAR), - arg, T_CHAR, char_adr_idx, MemNode::unordered); - start = __ AddI(start, __ intcon(1)); - break; - } - default: - ShouldNotReachHere(); } }
--- a/src/share/vm/precompiled/precompiled.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/precompiled/precompiled.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -57,8 +57,6 @@ # include "classfile/classFileParser.hpp" # include "classfile/classFileStream.hpp" # include "classfile/classLoader.hpp" -# include "classfile/imageDecompressor.hpp" -# include "classfile/imageFile.hpp" # include "classfile/javaClasses.hpp" # include "classfile/symbolTable.hpp" # include "classfile/systemDictionary.hpp" @@ -232,7 +230,6 @@ # include "utilities/constantTag.hpp" # include "utilities/copy.hpp" # include "utilities/debug.hpp" -# include "utilities/endian.hpp" # include "utilities/exceptions.hpp" # include "utilities/globalDefinitions.hpp" # include "utilities/growableArray.hpp"
--- a/src/share/vm/prims/jni.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jni.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3882,6 +3882,7 @@ void TestBufferingOopClosure_test(); void TestCodeCacheRemSet_test(); void FreeRegionList_test(); +void test_memset_with_concurrent_readers(); #endif void execute_internal_vm_tests() { @@ -3923,6 +3924,7 @@ if (UseG1GC) { run_unit_test(FreeRegionList_test()); } + run_unit_test(test_memset_with_concurrent_readers()); #endif tty->print_cr("All internal VM tests passed"); }
--- a/src/share/vm/prims/jvm.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvm.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -24,8 +24,6 @@ #include "precompiled.hpp" #include "classfile/classLoader.hpp" -#include "classfile/imageDecompressor.hpp" -#include "classfile/imageFile.hpp" #include "classfile/javaAssertions.hpp" #include "classfile/javaClasses.inline.hpp" #include "classfile/stringTable.hpp" @@ -71,7 +69,6 @@ #include "utilities/copy.hpp" #include "utilities/defaultStream.hpp" #include "utilities/dtrace.hpp" -#include "utilities/endian.hpp" #include "utilities/events.hpp" #include "utilities/histogram.hpp" #include "utilities/macros.hpp" @@ -3676,244 +3673,3 @@ info->is_attachable = AttachListener::is_attach_supported(); } JVM_END - -// jdk.internal.jimage ///////////////////////////////////////////////////////// -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. - -// Java entry to open an image file for sharing. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jlong, -JVM_ImageOpen(JNIEnv *env, const char *nativePath, jboolean big_endian)) { - JVMWrapper("JVM_ImageOpen"); - // Open image file for reading. - ImageFileReader* reader = ImageFileReader::open(nativePath, big_endian != JNI_FALSE); - // Return image ID as a jlong. - return ImageFileReader::readerToID(reader); -} -JVM_END - -// Java entry for closing a shared image file. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(void, -JVM_ImageClose(JNIEnv *env, jlong id)) { - JVMWrapper("JVM_ImageClose"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // If valid reader the close. - if (reader != NULL) { - ImageFileReader::close(reader); - } -} -JVM_END - -// Java entry for accessing the base address of the image index. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jlong, -JVM_ImageGetIndexAddress(JNIEnv *env, jlong id)) { - JVMWrapper("JVM_ImageGetIndexAddress"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // If valid reader return index base address (as jlong) else zero. - return reader != NULL ? (jlong)reader->get_index_address() : 0L; -} -JVM_END - -// Java entry for accessing the base address of the image data. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jlong, -JVM_ImageGetDataAddress(JNIEnv *env, jlong id)) { - JVMWrapper("JVM_ImageGetDataAddress"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // If valid reader return data base address (as jlong) else zero. - return MemoryMapImage && reader != NULL ? (jlong)reader->get_data_address() : 0L; -} -JVM_END - -// Java entry for reading an uncompressed resource from the image. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jboolean, -JVM_ImageRead(JNIEnv *env, jlong id, jlong offset, - unsigned char* uncompressedAddress, jlong uncompressed_size)) { - JVMWrapper("JVM_ImageRead"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id);\ - // If not a valid reader the fail the read. - if (reader == NULL) return false; - // Get the file offset of resource data. - u8 file_offset = reader->get_index_size() + offset; - // Check validity of arguments. - if (offset < 0 || - uncompressed_size < 0 || - file_offset > reader->file_size() - uncompressed_size) { - return false; - } - // Read file content into buffer. - return (jboolean)reader->read_at((u1*)uncompressedAddress, uncompressed_size, - file_offset); -} -JVM_END - -// Java entry for reading a compressed resource from the image. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jboolean, -JVM_ImageReadCompressed(JNIEnv *env, - jlong id, jlong offset, - unsigned char* compressedAddress, jlong compressed_size, - unsigned char* uncompressedAddress, jlong uncompressed_size)) { - JVMWrapper("JVM_ImageReadCompressed"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // If not a valid reader the fail the read. - if (reader == NULL) return false; - // Get the file offset of resource data. - u8 file_offset = reader->get_index_size() + offset; - // Check validity of arguments. - if (offset < 0 || - compressed_size < 0 || - uncompressed_size < 0 || - file_offset > reader->file_size() - compressed_size) { - return false; - } - - // Read file content into buffer. - bool is_read = reader->read_at(compressedAddress, compressed_size, - file_offset); - // If successfully read then decompress. - if (is_read) { - const ImageStrings strings = reader->get_strings(); - ImageDecompressor::decompress_resource(compressedAddress, uncompressedAddress, - uncompressed_size, &strings, true); - } - return (jboolean)is_read; -} -JVM_END - -// Java entry for retrieving UTF-8 bytes from image string table. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(const char*, JVM_ImageGetStringBytes(JNIEnv *env, jlong id, jint offset)) { - JVMWrapper("JVM_ImageGetStringBytes"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // Fail if not valid reader. - if (reader == NULL) return NULL; - // Manage image string table. - ImageStrings strings = reader->get_strings(); - // Retrieve string adrress from table. - const char* data = strings.get(offset); - return data; -} -JVM_END - -// Utility function to copy location information into a jlong array. -// WARNING: This function is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -static void image_expand_location(JNIEnv *env, jlong* rawAttributes, ImageLocation& location) { - // Copy attributes from location. - for (int kind = ImageLocation::ATTRIBUTE_END + 1; - kind < ImageLocation::ATTRIBUTE_COUNT; - kind++) { - rawAttributes[kind] = location.get_attribute(kind); - } -} - -// Java entry for retrieving location attributes for attribute offset. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jlong*, JVM_ImageGetAttributes(JNIEnv *env, jlong* rawAttributes, jlong id, jint offset)) { - JVMWrapper("JVM_ImageGetAttributes"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // Fail if not valid reader. - if (reader == NULL) return NULL; - // Retrieve first byte address of resource's location attribute stream. - u1* data = reader->get_location_offset_data(offset); - // Fail if not valid offset. - if (data == NULL) return NULL; - // Expand stream into array. - ImageLocation location(data); - image_expand_location(env, rawAttributes, location); - return rawAttributes; -} -JVM_END - -// Java entry for retrieving location attributes count for attribute offset. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jsize, JVM_ImageGetAttributesCount(JNIEnv *env)) { - JVMWrapper("JVM_ImageGetAttributesCount"); - return ImageLocation::ATTRIBUTE_COUNT; -} -JVM_END - -// Java entry for retrieving location attributes for named resource. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jlong*, -JVM_ImageFindAttributes(JNIEnv *env, jlong* rawAttributes, jbyte* rawBytes, jsize size, jlong id)) { - JVMWrapper("JVM_ImageFindAttributes"); - // Mark for temporary buffers. - ResourceMark rm; - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // Fail if not valid reader. - if (reader == NULL) return NULL; - // Convert byte array to a cstring. - char* path = NEW_RESOURCE_ARRAY(char, size + 1); - memcpy(path, rawBytes, size); - path[size] = '\0'; - // Locate resource location data. - ImageLocation location; - bool found = reader->find_location(path, location); - // Resource not found. - if (!found) return NULL; - // Expand stream into array. - image_expand_location(env, rawAttributes, location); - return rawAttributes; -} -JVM_END - -// Java entry for retrieving all the attribute stream offsets from an image. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(jint*, JVM_ImageAttributeOffsets(JNIEnv *env, jint* rawOffsets, unsigned int length, jlong id)) { - JVMWrapper("JVM_ImageAttributeOffsets"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // Fail if not valid reader. - if (reader == NULL) return NULL; - // Determine endian for reader. - Endian* endian = reader->endian(); - // Get base address of attribute stream offsets table. - u4* offsets_table = reader->offsets_table(); - // Allocate int array result. - // Copy values to result (converting endian.) - for (u4 i = 0; i < length; i++) { - rawOffsets[i] = endian->get(offsets_table[i]); - } - return rawOffsets; -} -JVM_END - -// Java entry for retrieving all the attribute stream offsets length from an image. -// WARNING: This API is experimental and temporary during JDK 9 development -// cycle. It will not be supported in the eventual JDK 9 release. -JVM_ENTRY(unsigned int, JVM_ImageAttributeOffsetsLength(JNIEnv *env, jlong id)) { - JVMWrapper("JVM_ImageAttributeOffsetsLength"); - // Convert image ID to image reader structure. - ImageFileReader* reader = ImageFileReader::idToReader(id); - // Fail if not valid reader. - if (reader == NULL) return 0; - // Get perfect hash table length. - u4 length = reader->table_length(); - return (jint) length; -} -JVM_END
--- a/src/share/vm/prims/jvm.h Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvm.h Tue Sep 29 18:47:52 2015 +0200 @@ -571,52 +571,6 @@ JNIEXPORT jboolean JNICALL JVM_SupportsCX8(void); -/* - * jdk.internal.jimage - * WARNING: This API is experimental and temporary during JDK 9 development - * cycle. It will not be supported in the eventual JDK 9 release. - */ - -JNIEXPORT jlong JNICALL -JVM_ImageOpen(JNIEnv *env, const char *nativePath, jboolean big_endian); - -JNIEXPORT void JNICALL -JVM_ImageClose(JNIEnv *env, jlong id); - -JNIEXPORT jlong JNICALL -JVM_ImageGetIndexAddress(JNIEnv *env, jlong id); - -JNIEXPORT jlong JNICALL -JVM_ImageGetDataAddress(JNIEnv *env,jlong id); - -JNIEXPORT jboolean JNICALL -JVM_ImageRead(JNIEnv *env, jlong id, jlong offset, - unsigned char* uncompressedAddress, jlong uncompressed_size); - - -JNIEXPORT jboolean JNICALL -JVM_ImageReadCompressed(JNIEnv *env, jlong id, jlong offset, - unsigned char* compressedBuffer, jlong compressed_size, - unsigned char* uncompressedBuffer, jlong uncompressed_size); - -JNIEXPORT const char* JNICALL -JVM_ImageGetStringBytes(JNIEnv *env, jlong id, jint offset); - -JNIEXPORT jlong* JNICALL -JVM_ImageGetAttributes(JNIEnv *env, jlong* rawAttributes, jlong id, jint offset); - -JNIEXPORT jsize JNICALL -JVM_ImageGetAttributesCount(JNIEnv *env); - -JNIEXPORT jlong* JNICALL -JVM_ImageFindAttributes(JNIEnv *env, jlong* rawAttributes, jbyte* rawBytes, jsize size, jlong id); - -JNIEXPORT jint* JNICALL -JVM_ImageAttributeOffsets(JNIEnv *env, jint* rawOffsets, unsigned int length, jlong id); - -JNIEXPORT unsigned int JNICALL -JVM_ImageAttributeOffsetsLength(JNIEnv *env, jlong id); - /************************************************************************* PART 2: Support for the Verifier and Class File Format Checker ************************************************************************/
--- a/src/share/vm/prims/jvmtiEnv.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiEnv.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3482,7 +3482,7 @@ for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) { if (strcmp(property, p->key()) == 0) { - if (p->set_value((char *)value_ptr)) { + if (p->set_value(value_ptr)) { err = JVMTI_ERROR_NONE; } }
--- a/src/share/vm/prims/jvmtiExport.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiExport.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -2181,8 +2181,8 @@ JvmtiVMObjectAllocEventCollector::oops_do_for_all_threads(f); } -void JvmtiExport::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { - JvmtiTagMap::weak_oops_do(is_alive, f); +size_t JvmtiExport::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { + return JvmtiTagMap::weak_oops_do(is_alive, f); } void JvmtiExport::gc_epilogue() {
--- a/src/share/vm/prims/jvmtiExport.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiExport.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -366,7 +366,7 @@ static void clear_detected_exception (JavaThread* thread) NOT_JVMTI_RETURN; static void oops_do(OopClosure* f) NOT_JVMTI_RETURN; - static void weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN; + static size_t weak_oops_do(BoolObjectClosure* b, OopClosure* f) NOT_JVMTI_RETURN_(0); static void gc_epilogue() NOT_JVMTI_RETURN; static void transition_pending_onload_raw_monitors() NOT_JVMTI_RETURN;
--- a/src/share/vm/prims/jvmtiRedefineClasses.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiRedefineClasses.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3771,7 +3771,7 @@ // Deoptimize all activations depending on marked nmethods Deoptimization::deoptimize_dependents(); - // Make the dependent methods not entrant (in VM_Deoptimize they are made zombies) + // Make the dependent methods not entrant CodeCache::make_marked_nmethods_not_entrant(); // From now on we know that the dependency information is complete
--- a/src/share/vm/prims/jvmtiTagMap.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiTagMap.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3284,32 +3284,35 @@ } -void JvmtiTagMap::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { +size_t JvmtiTagMap::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { // No locks during VM bring-up (0 threads) and no safepoints after main // thread creation and before VMThread creation (1 thread); initial GC // verification can happen in that window which gets to here. assert(Threads::number_of_threads() <= 1 || SafepointSynchronize::is_at_safepoint(), "must be executed at a safepoint"); + size_t count = 0; if (JvmtiEnv::environments_might_exist()) { JvmtiEnvIterator it; for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) { JvmtiTagMap* tag_map = env->tag_map(); if (tag_map != NULL && !tag_map->is_empty()) { - tag_map->do_weak_oops(is_alive, f); + count += tag_map->do_weak_oops(is_alive, f); } } } + return count; } -void JvmtiTagMap::do_weak_oops(BoolObjectClosure* is_alive, OopClosure* f) { +size_t JvmtiTagMap::do_weak_oops(BoolObjectClosure* is_alive, OopClosure* f) { // does this environment have the OBJECT_FREE event enabled bool post_object_free = env()->is_enabled(JVMTI_EVENT_OBJECT_FREE); // counters used for trace message - int freed = 0; - int moved = 0; + size_t freed = 0; + size_t moved = 0; + size_t stayed = 0; JvmtiTagHashmap* hashmap = this->hashmap(); @@ -3318,7 +3321,7 @@ // if the hashmap is empty then we can skip it if (hashmap->_entry_count == 0) { - return; + return 0; } // now iterate through each entry in the table @@ -3380,6 +3383,7 @@ } else { // object didn't move prev = entry; + stayed++; } } @@ -3398,10 +3402,12 @@ // stats if (TraceJVMTIObjectTagging) { - int post_total = hashmap->_entry_count; - int pre_total = post_total + freed; - - tty->print_cr("(%d->%d, %d freed, %d total moves)", - pre_total, post_total, freed, moved); + size_t post_total = hashmap->_entry_count; + size_t pre_total = post_total + freed; + + tty->print_cr("(" SIZE_FORMAT "->" SIZE_FORMAT ", " SIZE_FORMAT " freed, " SIZE_FORMAT " stayed, " SIZE_FORMAT " moved)", + pre_total, post_total, freed, stayed, moved); } + + return (freed + stayed + moved); }
--- a/src/share/vm/prims/jvmtiTagMap.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/jvmtiTagMap.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -60,7 +60,7 @@ inline Mutex* lock() { return &_lock; } inline JvmtiEnv* env() const { return _env; } - void do_weak_oops(BoolObjectClosure* is_alive, OopClosure* f); + size_t do_weak_oops(BoolObjectClosure* is_alive, OopClosure* f); // iterate over all entries in this tag map void entry_iterate(JvmtiTagHashmapEntryClosure* closure); @@ -122,8 +122,8 @@ jint* count_ptr, jobject** object_result_ptr, jlong** tag_result_ptr); - static void weak_oops_do( - BoolObjectClosure* is_alive, OopClosure* f) NOT_JVMTI_RETURN; + static size_t weak_oops_do(BoolObjectClosure* is_alive, + OopClosure* f) NOT_JVMTI_RETURN_(0); }; #endif // SHARE_VM_PRIMS_JVMTITAGMAP_HPP
--- a/src/share/vm/prims/whitebox.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/prims/whitebox.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,7 +27,6 @@ #include <new> #include "classfile/classLoaderData.hpp" -#include "classfile/imageFile.hpp" #include "classfile/stringTable.hpp" #include "code/codeCache.hpp" #include "jvmtifiles/jvmtiEnv.hpp" @@ -56,6 +55,7 @@ #include "gc/g1/g1CollectedHeap.inline.hpp" #include "gc/g1/heapRegionRemSet.hpp" #include "gc/parallel/parallelScavengeHeap.inline.hpp" +#include "gc/parallel/adjoiningGenerations.hpp" #endif // INCLUDE_ALL_GCS #if INCLUDE_NMT #include "services/mallocSiteTable.hpp" @@ -297,6 +297,11 @@ return p->size() * HeapWordSize; WB_END +WB_ENTRY(jlong, WB_GetHeapSpaceAlignment(JNIEnv* env, jobject o)) + size_t alignment = Universe::heap()->collector_policy()->space_alignment(); + return (jlong)alignment; +WB_END + #if INCLUDE_ALL_GCS WB_ENTRY(jboolean, WB_G1IsHumongous(JNIEnv* env, jobject o, jobject obj)) G1CollectedHeap* g1 = G1CollectedHeap::heap(); @@ -335,6 +340,17 @@ return (jint)HeapRegion::GrainBytes; WB_END +WB_ENTRY(jlong, WB_PSVirtualSpaceAlignment(JNIEnv* env, jobject o)) + ParallelScavengeHeap* ps = ParallelScavengeHeap::heap(); + size_t alignment = ps->gens()->virtual_spaces()->alignment(); + return (jlong)alignment; +WB_END + +WB_ENTRY(jlong, WB_PSHeapGenerationAlignment(JNIEnv* env, jobject o)) + size_t alignment = ParallelScavengeHeap::heap()->generation_alignment(); + return (jlong)alignment; +WB_END + WB_ENTRY(jobject, WB_G1AuxiliaryMemoryUsage(JNIEnv* env)) ResourceMark rm(THREAD); G1CollectedHeap* g1h = G1CollectedHeap::heap(); @@ -1144,131 +1160,7 @@ return (jlong) MetaspaceGC::capacity_until_GC(); WB_END -WB_ENTRY(jboolean, WB_ReadImageFile(JNIEnv* env, jobject wb, jstring imagefile)) - const char* filename = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(imagefile)); - return ImageFileReader::open(filename) != NULL; -WB_END -WB_ENTRY(jlong, WB_imageOpenImage(JNIEnv *env, jobject wb, jstring path, jboolean big_endian)) - ThreadToNativeFromVM ttn(thread); - const char *nativePath = env->GetStringUTFChars(path, NULL); - jlong ret = JVM_ImageOpen(env, nativePath, big_endian); - - env->ReleaseStringUTFChars(path, nativePath); - return ret; -WB_END - -WB_ENTRY(void, WB_imageCloseImage(JNIEnv *env, jobject wb, jlong id)) - ThreadToNativeFromVM ttn(thread); - JVM_ImageClose(env, id); -WB_END - -WB_ENTRY(jlong, WB_imageGetIndexAddress(JNIEnv *env, jobject wb, jlong id)) - ThreadToNativeFromVM ttn(thread); - return JVM_ImageGetIndexAddress(env, id); -WB_END - -WB_ENTRY(jlong, WB_imageGetDataAddress(JNIEnv *env, jobject wb, jlong id)) - ThreadToNativeFromVM ttn(thread); - return JVM_ImageGetDataAddress(env, id); -WB_END - -WB_ENTRY(jboolean, WB_imageRead(JNIEnv *env, jobject wb, jlong id, jlong offset, jobject uncompressedBuffer, jlong uncompressed_size)) - ThreadToNativeFromVM ttn(thread); - if (uncompressedBuffer == NULL) { - return JNI_FALSE; - } - unsigned char* uncompressedAddress = - (unsigned char*) env->GetDirectBufferAddress(uncompressedBuffer); - return JVM_ImageRead(env, id, offset, uncompressedAddress, uncompressed_size); -WB_END - -WB_ENTRY(jboolean, WB_imageReadCompressed(JNIEnv *env, jobject wb, jlong id, jlong offset, jobject compressedBuffer, jlong compressed_size, jobject uncompressedBuffer, jlong uncompressed_size)) - ThreadToNativeFromVM ttn(thread); - if (uncompressedBuffer == NULL || compressedBuffer == NULL) { - return false; - } - // Get address of read direct buffer. - unsigned char* compressedAddress = - (unsigned char*) env->GetDirectBufferAddress(compressedBuffer); - // Get address of decompression direct buffer. - unsigned char* uncompressedAddress = - (unsigned char*) env->GetDirectBufferAddress(uncompressedBuffer); - return JVM_ImageReadCompressed(env, id, offset, compressedAddress, compressed_size, uncompressedAddress, uncompressed_size); -WB_END - -WB_ENTRY(jbyteArray, WB_imageGetStringBytes(JNIEnv *env, jobject wb, jlong id, jlong offset)) - ThreadToNativeFromVM ttn(thread); - const char* data = JVM_ImageGetStringBytes(env, id, offset); - // Determine String length. - size_t size = strlen(data); - // Allocate byte array. - jbyteArray byteArray = env->NewByteArray((jsize) size); - // Get array base address. - jbyte* rawBytes = env->GetByteArrayElements(byteArray, NULL); - // Copy bytes from image string table. - memcpy(rawBytes, data, size); - // Release byte array base address. - env->ReleaseByteArrayElements(byteArray, rawBytes, 0); - return byteArray; -WB_END - -WB_ENTRY(jlong, WB_imageGetStringsSize(JNIEnv *env, jobject wb, jlong id)) - ImageFileReader* reader = ImageFileReader::idToReader(id); - return reader? reader->strings_size() : 0L; -WB_END - -WB_ENTRY(jlongArray, WB_imageGetAttributes(JNIEnv *env, jobject wb, jlong id, jint offset)) - ThreadToNativeFromVM ttn(thread); - // Allocate a jlong large enough for all location attributes. - jlongArray attributes = env->NewLongArray(JVM_ImageGetAttributesCount(env)); - // Get base address for jlong array. - jlong* rawAttributes = env->GetLongArrayElements(attributes, NULL); - jlong* ret = JVM_ImageGetAttributes(env, rawAttributes, id, offset); - // Release jlong array base address. - env->ReleaseLongArrayElements(attributes, rawAttributes, 0); - return ret == NULL ? NULL : attributes; -WB_END - -WB_ENTRY(jlongArray, WB_imageFindAttributes(JNIEnv *env, jobject wb, jlong id, jbyteArray utf8)) - ThreadToNativeFromVM ttn(thread); - // Allocate a jlong large enough for all location attributes. - jlongArray attributes = env->NewLongArray(JVM_ImageGetAttributesCount(env)); - // Get base address for jlong array. - jlong* rawAttributes = env->GetLongArrayElements(attributes, NULL); - jsize size = env->GetArrayLength(utf8); - jbyte* rawBytes = env->GetByteArrayElements(utf8, NULL); - jlong* ret = JVM_ImageFindAttributes(env, rawAttributes, rawBytes, size, id); - env->ReleaseByteArrayElements(utf8, rawBytes, 0); - env->ReleaseLongArrayElements(attributes, rawAttributes, 0); - return ret == NULL ? NULL : attributes; -WB_END - -WB_ENTRY(jintArray, WB_imageAttributeOffsets(JNIEnv *env, jobject wb, jlong id)) - ThreadToNativeFromVM ttn(thread); - unsigned int length = JVM_ImageAttributeOffsetsLength(env, id); - if (length == 0) { - return NULL; - } - jintArray offsets = env->NewIntArray(length); - // Get base address of result. - jint* rawOffsets = env->GetIntArrayElements(offsets, NULL); - jint* ret = JVM_ImageAttributeOffsets(env, rawOffsets, length, id); - // Release result base address. - env->ReleaseIntArrayElements(offsets, rawOffsets, 0); - return ret == NULL ? NULL : offsets; -WB_END - -WB_ENTRY(jint, WB_imageGetIntAtAddress(JNIEnv *env, jobject wb, jlong address, jint offset, jboolean big_endian)) - unsigned char* arr = (unsigned char*) address + offset; - jint uraw; - if (big_endian) { - uraw = arr[0] << 24 | arr[1]<<16 | (arr[2]<<8) | arr[3]; - } else { - uraw = arr[0] | arr[1]<<8 | (arr[2]<<16) | arr[3]<<24; - } - return uraw; -WB_END WB_ENTRY(void, WB_AssertMatchingSafepointCalls(JNIEnv* env, jobject o, jboolean mutexSafepointValue, jboolean attemptedNoSafepointValue)) Monitor::SafepointCheckRequired sfpt_check_required = mutexSafepointValue ? @@ -1457,6 +1349,7 @@ {CC"getVMPageSize", CC"()I", (void*)&WB_GetVMPageSize }, {CC"getVMAllocationGranularity", CC"()J", (void*)&WB_GetVMAllocationGranularity }, {CC"getVMLargePageSize", CC"()J", (void*)&WB_GetVMLargePageSize}, + {CC"getHeapSpaceAlignment", CC"()J", (void*)&WB_GetHeapSpaceAlignment}, {CC"isClassAlive0", CC"(Ljava/lang/String;)Z", (void*)&WB_IsClassAlive }, {CC"parseCommandLine0", CC"(Ljava/lang/String;C[Lsun/hotspot/parser/DiagnosticCommand;)[Ljava/lang/Object;", @@ -1481,6 +1374,8 @@ {CC"g1StartConcMarkCycle", CC"()Z", (void*)&WB_G1StartMarkCycle }, {CC"g1AuxiliaryMemoryUsage", CC"()Ljava/lang/management/MemoryUsage;", (void*)&WB_G1AuxiliaryMemoryUsage }, + {CC"psVirtualSpaceAlignment",CC"()J", (void*)&WB_PSVirtualSpaceAlignment}, + {CC"psHeapGenerationAlignment",CC"()J", (void*)&WB_PSHeapGenerationAlignment}, #endif // INCLUDE_ALL_GCS #if INCLUDE_NMT {CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc }, @@ -1576,21 +1471,6 @@ {CC"getCodeBlob", CC"(J)[Ljava/lang/Object;",(void*)&WB_GetCodeBlob }, {CC"getThreadStackSize", CC"()J", (void*)&WB_GetThreadStackSize }, {CC"getThreadRemainingStackSize", CC"()J", (void*)&WB_GetThreadRemainingStackSize }, - {CC"readImageFile", CC"(Ljava/lang/String;)Z", (void*)&WB_ReadImageFile }, - {CC"imageOpenImage", CC"(Ljava/lang/String;Z)J",(void*)&WB_imageOpenImage }, - {CC"imageCloseImage", CC"(J)V", (void*)&WB_imageCloseImage }, - {CC"imageGetIndexAddress",CC"(J)J", (void*)&WB_imageGetIndexAddress}, - {CC"imageGetDataAddress",CC"(J)J", (void*)&WB_imageGetDataAddress}, - {CC"imageRead", CC"(JJLjava/nio/ByteBuffer;J)Z", - (void*)&WB_imageRead }, - {CC"imageReadCompressed",CC"(JJLjava/nio/ByteBuffer;JLjava/nio/ByteBuffer;J)Z", - (void*)&WB_imageReadCompressed}, - {CC"imageGetStringBytes",CC"(JI)[B", (void*)&WB_imageGetStringBytes}, - {CC"imageGetStringsSize",CC"(J)J", (void*)&WB_imageGetStringsSize}, - {CC"imageGetAttributes", CC"(JI)[J", (void*)&WB_imageGetAttributes}, - {CC"imageFindAttributes",CC"(J[B)[J", (void*)&WB_imageFindAttributes}, - {CC"imageAttributeOffsets",CC"(J)[I", (void*)&WB_imageAttributeOffsets}, - {CC"imageGetIntAtAddress",CC"(JIZ)I", (void*)&WB_imageGetIntAtAddress}, {CC"assertMatchingSafepointCalls", CC"(ZZ)V", (void*)&WB_AssertMatchingSafepointCalls }, {CC"isMonitorInflated0", CC"(Ljava/lang/Object;)Z", (void*)&WB_IsMonitorInflated }, {CC"forceSafepoint", CC"()V", (void*)&WB_ForceSafepoint },
--- a/src/share/vm/runtime/arguments.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/arguments.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -28,7 +28,6 @@ #include "classfile/stringTable.hpp" #include "classfile/symbolTable.hpp" #include "code/codeCacheExtensions.hpp" -#include "compiler/compilerOracle.hpp" #include "gc/shared/cardTableRS.hpp" #include "gc/shared/genCollectedHeap.hpp" #include "gc/shared/referenceProcessor.hpp" @@ -82,8 +81,6 @@ bool Arguments::_has_profile = false; size_t Arguments::_conservative_max_heap_alignment = 0; size_t Arguments::_min_heap_size = 0; -uintx Arguments::_min_heap_free_ratio = 0; -uintx Arguments::_max_heap_free_ratio = 0; Arguments::Mode Arguments::_mode = _mixed; bool Arguments::_java_compiler = false; bool Arguments::_xdebug_mode = false; @@ -986,53 +983,61 @@ bool Arguments::add_property(const char* prop) { const char* eq = strchr(prop, '='); - char* key; - // ns must be static--its address may be stored in a SystemProperty object. - const static char ns[1] = {0}; - char* value = (char *)ns; - - size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop); - key = AllocateHeap(key_len + 1, mtInternal); - strncpy(key, prop, key_len); - key[key_len] = '\0'; - - if (eq != NULL) { - size_t value_len = strlen(prop) - key_len - 1; - value = AllocateHeap(value_len + 1, mtInternal); - strncpy(value, &prop[key_len + 1], value_len + 1); + const char* key; + const char* value = ""; + + if (eq == NULL) { + // property doesn't have a value, thus use passed string + key = prop; + } else { + // property have a value, thus extract it and save to the + // allocated string + size_t key_len = eq - prop; + char* tmp_key = AllocateHeap(key_len + 1, mtInternal); + + strncpy(tmp_key, prop, key_len); + tmp_key[key_len] = '\0'; + key = tmp_key; + + value = &prop[key_len + 1]; } if (strcmp(key, "java.compiler") == 0) { process_java_compiler_argument(value); - FreeHeap(key); - if (eq != NULL) { - FreeHeap(value); - } - return true; - } else if (strcmp(key, "sun.java.command") == 0) { - _java_command = value; - // Record value in Arguments, but let it get passed to Java. } else if (strcmp(key, "sun.java.launcher.is_altjvm") == 0 || strcmp(key, "sun.java.launcher.pid") == 0) { // sun.java.launcher.is_altjvm and sun.java.launcher.pid property are // private and are processed in process_sun_java_launcher_properties(); // the sun.java.launcher property is passed on to the java application - FreeHeap(key); - if (eq != NULL) { - FreeHeap(value); - } - return true; - } else if (strcmp(key, "java.vendor.url.bug") == 0) { - // save it in _java_vendor_url_bug, so JVM fatal error handler can access - // its value without going through the property list or making a Java call. - _java_vendor_url_bug = value; } else if (strcmp(key, "sun.boot.library.path") == 0) { PropertyList_unique_add(&_system_properties, key, value, true); - return true; - } - // Create new property and add at the end of the list - PropertyList_unique_add(&_system_properties, key, value); + } else { + if (strcmp(key, "sun.java.command") == 0) { + if (_java_command != NULL) { + os::free(_java_command); + } + _java_command = os::strdup_check_oom(value, mtInternal); + } else if (strcmp(key, "java.vendor.url.bug") == 0) { + if (_java_vendor_url_bug != DEFAULT_VENDOR_URL_BUG) { + assert(_java_vendor_url_bug != NULL, "_java_vendor_url_bug is NULL"); + os::free((void *)_java_vendor_url_bug); + } + // save it in _java_vendor_url_bug, so JVM fatal error handler can access + // its value without going through the property list or making a Java call. + _java_vendor_url_bug = os::strdup_check_oom(value, mtInternal); + } + + // Create new property and add at the end of the list + PropertyList_unique_add(&_system_properties, key, value); + } + + if (key != prop) { + // SystemProperty copy passed value, thus free previously allocated + // memory + FreeHeap((void *)key); + } + return true; } @@ -1049,7 +1054,7 @@ // Ensure Agent_OnLoad has the correct initial values. // This may not be the final mode; mode may change later in onload phase. PropertyList_unique_add(&_system_properties, "java.vm.info", - (char*)VM_Version::vm_info_string(), false); + VM_Version::vm_info_string(), false); UseInterpreter = true; UseCompiler = true; @@ -1595,9 +1600,6 @@ #endif // _LP64 #endif // !ZERO - // Set up runtime image flags. - set_runtime_image_flags(); - CodeCacheExtensions::set_ergonomics_flags(); } @@ -1624,11 +1626,9 @@ // unless the user actually sets these flags. if (FLAG_IS_DEFAULT(MinHeapFreeRatio)) { FLAG_SET_DEFAULT(MinHeapFreeRatio, 0); - _min_heap_free_ratio = MinHeapFreeRatio; } if (FLAG_IS_DEFAULT(MaxHeapFreeRatio)) { FLAG_SET_DEFAULT(MaxHeapFreeRatio, 100); - _max_heap_free_ratio = MaxHeapFreeRatio; } } @@ -1871,16 +1871,6 @@ } } - // Set up runtime image flags -void Arguments::set_runtime_image_flags() { -#ifdef _LP64 - // Memory map image file by default on 64 bit machines. - if (FLAG_IS_DEFAULT(MemoryMapImage)) { - FLAG_SET_ERGO(bool, MemoryMapImage, true); - } -#endif -} - // This must be called after ergonomics. void Arguments::set_bytecode_flags() { if (!RewriteBytecodes) { @@ -1889,7 +1879,7 @@ } // Aggressive optimization flags -XX:+AggressiveOpts -void Arguments::set_aggressive_opts_flags() { +jint Arguments::set_aggressive_opts_flags() { #ifdef COMPILER2 if (AggressiveUnboxing) { if (FLAG_IS_DEFAULT(EliminateAutoBox)) { @@ -1916,7 +1906,9 @@ // Feed the cache size setting into the JDK char buffer[1024]; sprintf(buffer, "java.lang.Integer.IntegerCache.high=" INTX_FORMAT, AutoBoxCacheMax); - add_property(buffer); + if (!add_property(buffer)) { + return JNI_ENOMEM; + } } if (AggressiveOpts && FLAG_IS_DEFAULT(BiasedLockingStartupDelay)) { FLAG_SET_DEFAULT(BiasedLockingStartupDelay, 500); @@ -1929,12 +1921,14 @@ // FLAG_SET_DEFAULT(EliminateZeroing, true); // } } + + return JNI_OK; } //=========================================================================================================== // Parsing of java.compiler property -void Arguments::process_java_compiler_argument(char* arg) { +void Arguments::process_java_compiler_argument(const char* arg) { // For backwards compatibility, Djava.compiler=NONE or "" // causes us to switch to -Xint mode UNLESS -Xdebug // is also specified. @@ -3161,8 +3155,10 @@ jio_fprintf(defaultStream::output_stream(), "CreateMinidumpOnCrash is replaced by CreateCoredumpOnCrash: CreateCoredumpOnCrash is off\n"); } else if (match_option(option, "-XX:", &tail)) { // -XX:xxxx - // Skip -XX:Flags= since that case has already been handled - if (strncmp(tail, "Flags=", strlen("Flags=")) != 0) { + // Skip -XX:Flags= and -XX:VMOptionsFile= since those cases have + // already been handled + if ((strncmp(tail, "Flags=", strlen("Flags=")) != 0) && + (strncmp(tail, "VMOptionsFile=", strlen("VMOptionsFile=")) != 0)) { if (!process_argument(tail, args->ignoreUnrecognized, origin)) { return JNI_EINVAL; } @@ -3414,6 +3410,7 @@ class ScopedVMInitArgs : public StackObj { private: JavaVMInitArgs _args; + bool _is_set; public: ScopedVMInitArgs() { @@ -3421,6 +3418,7 @@ _args.nOptions = 0; _args.options = NULL; _args.ignoreUnrecognized = false; + _is_set = false; } // Populates the JavaVMInitArgs object represented by this @@ -3429,6 +3427,7 @@ // returns anything other than JNI_OK, then this object is in a // partially constructed state, and should be abandoned. jint set_args(GrowableArray<JavaVMOption>* options) { + _is_set = true; JavaVMOption* options_arr = NEW_C_HEAP_ARRAY_RETURN_NULL( JavaVMOption, options->length(), mtInternal); if (options_arr == NULL) { @@ -3452,6 +3451,7 @@ } JavaVMInitArgs* get() { return &_args; } + bool is_set() { return _is_set; } ~ScopedVMInitArgs() { if (_args.options == NULL) return; @@ -3460,6 +3460,35 @@ } FREE_C_HEAP_ARRAY(JavaVMOption, _args.options); } + + // Insert options into this option list, to replace option at + // vm_options_file_pos (-XX:VMOptionsFile) + jint insert(const JavaVMInitArgs* args, + const JavaVMInitArgs* args_to_insert, + const int vm_options_file_pos) { + assert(_args.options == NULL, "shouldn't be set yet"); + assert(args_to_insert->nOptions != 0, "there should be args to insert"); + assert(vm_options_file_pos != -1, "vm_options_file_pos should be set"); + + int length = args->nOptions + args_to_insert->nOptions - 1; + GrowableArray<JavaVMOption> *options = new (ResourceObj::C_HEAP, mtInternal) + GrowableArray<JavaVMOption>(length, true); // Construct new option array + for (int i = 0; i < args->nOptions; i++) { + if (i == vm_options_file_pos) { + // insert the new options starting at the same place as the + // -XX:VMOptionsFile option + for (int j = 0; j < args_to_insert->nOptions; j++) { + options->push(args_to_insert->options[j]); + } + } else { + options->push(args->options[i]); + } + } + // make into options array + jint result = set_args(options); + delete options; + return result; + } }; jint Arguments::parse_java_options_environment_variable(ScopedVMInitArgs* args) { @@ -3484,54 +3513,137 @@ return JNI_ENOMEM; } + int retcode = parse_options_buffer(name, buffer, strlen(buffer), vm_args); + + os::free(buffer); + return retcode; +} + +const int OPTION_BUFFER_SIZE = 1024; + +jint Arguments::parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args) { + // read file into buffer + int fd = ::open(file_name, O_RDONLY); + if (fd < 0) { + jio_fprintf(defaultStream::error_stream(), + "Could not open options file '%s'\n", + file_name); + return JNI_ERR; + } + + // '+ 1' for NULL termination even with max bytes + int bytes_alloc = OPTION_BUFFER_SIZE + 1; + + char *buf = NEW_C_HEAP_ARRAY_RETURN_NULL(char, bytes_alloc, mtInternal); + if (NULL == buf) { + jio_fprintf(defaultStream::error_stream(), + "Could not allocate read buffer for options file parse\n"); + os::close(fd); + return JNI_ENOMEM; + } + + memset(buf, 0, (unsigned)bytes_alloc); + + // Fill buffer + // Use ::read() instead of os::read because os::read() + // might do a thread state transition + // and it is too early for that here + + int bytes_read = ::read(fd, (void *)buf, (unsigned)bytes_alloc); + os::close(fd); + if (bytes_read < 0) { + FREE_C_HEAP_ARRAY(char, buf); + jio_fprintf(defaultStream::error_stream(), + "Could not read options file '%s'\n", file_name); + return JNI_ERR; + } + + if (bytes_read == 0) { + // tell caller there is no option data and that is ok + FREE_C_HEAP_ARRAY(char, buf); + return JNI_OK; + } + + // file is larger than OPTION_BUFFER_SIZE + if (bytes_read > bytes_alloc - 1) { + FREE_C_HEAP_ARRAY(char, buf); + jio_fprintf(defaultStream::error_stream(), + "Options file '%s' is larger than %d bytes.\n", + file_name, bytes_alloc - 1); + return JNI_EINVAL; + } + + int retcode = parse_options_buffer(file_name, buf, bytes_read, vm_args); + + FREE_C_HEAP_ARRAY(char, buf); + return retcode; +} + +jint Arguments::parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args) { GrowableArray<JavaVMOption> *options = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<JavaVMOption>(2, true); // Construct option array - jio_fprintf(defaultStream::error_stream(), - "Picked up %s: %s\n", name, buffer); - char* rd = buffer; // pointer to the input string (rd) - while (true) { // repeat for all options in the input string - while (isspace(*rd)) rd++; // skip whitespace - if (*rd == 0) break; // we re done when the input string is read completely - - // The output, option string, overwrites the input string. - // Because of quoting, the pointer to the option string (wrt) may lag the pointer to - // input string (rd). - char* wrt = rd; - - JavaVMOption option; - option.optionString = wrt; - options->append(option); // Fill in option - while (*rd != 0 && !isspace(*rd)) { // unquoted strings terminate with a space or NULL + + // some pointers to help with parsing + char *buffer_end = buffer + buf_len; + char *opt_hd = buffer; + char *wrt = buffer; + char *rd = buffer; + + // parse all options + while (rd < buffer_end) { + // skip leading white space from the input string + while (rd < buffer_end && isspace(*rd)) { + rd++; + } + + if (rd >= buffer_end) { + break; + } + + // Remember this is where we found the head of the token. + opt_hd = wrt; + + // Tokens are strings of non white space characters separated + // by one or more white spaces. + while (rd < buffer_end && !isspace(*rd)) { if (*rd == '\'' || *rd == '"') { // handle a quoted string int quote = *rd; // matching quote to look for rd++; // don't copy open quote - while (*rd != quote) { // include everything (even spaces) up until quote - if (*rd == 0) { // string termination means unmatched string - jio_fprintf(defaultStream::error_stream(), - "Unmatched quote in %s\n", name); - delete options; - os::free(buffer); - return JNI_ERR; - } + while (rd < buffer_end && *rd != quote) { + // include everything (even spaces) + // up until the close quote *wrt++ = *rd++; // copy to option string } - rd++; // don't copy close quote + + if (rd < buffer_end) { + rd++; // don't copy close quote + } else { + // did not see closing quote + jio_fprintf(defaultStream::error_stream(), + "Unmatched quote in %s\n", name); + delete options; + return JNI_ERR; + } } else { *wrt++ = *rd++; // copy to option string } } - if (*rd != 0) { - // In this case, the assignment to wrt below will make *rd nul, - // which will interfere with the next loop iteration. - rd++; - } - *wrt = 0; // Zero terminate option + + // steal a white space character and set it to NULL + *wrt++ = '\0'; + // We now have a complete token + + JavaVMOption option; + option.optionString = opt_hd; + + options->append(option); // Fill in option + + rd++; // Advance to next character } // Fill out JavaVMInitArgs structure. jint status = vm_args->set_args(options); delete options; - os::free(buffer); return status; } @@ -3613,12 +3725,44 @@ return false; } + #endif // PRODUCT -static jint match_special_option_and_act(const JavaVMInitArgs* args, - char** flags_file) { +jint Arguments::insert_vm_options_file(const JavaVMInitArgs* args, + char** flags_file, + char** vm_options_file, + const int vm_options_file_pos, + ScopedVMInitArgs *vm_options_file_args, + ScopedVMInitArgs* args_out) { + jint code = parse_vm_options_file(*vm_options_file, vm_options_file_args); + if (code != JNI_OK) { + return code; + } + + // Now set global settings from the vm_option file, giving an error if + // it has VMOptionsFile in it + code = match_special_option_and_act(vm_options_file_args->get(), flags_file, + NULL, NULL, NULL); + if (code != JNI_OK) { + return code; + } + + if (vm_options_file_args->get()->nOptions < 1) { + return 0; + } + + return args_out->insert(args, vm_options_file_args->get(), + vm_options_file_pos); +} + +jint Arguments::match_special_option_and_act(const JavaVMInitArgs* args, + char ** flags_file, + char ** vm_options_file, + ScopedVMInitArgs* vm_options_file_args, + ScopedVMInitArgs* args_out) { // Remaining part of option string const char* tail; + int vm_options_file_pos = -1; for (int index = 0; index < args->nOptions; index++) { const JavaVMOption* option = args->options + index; @@ -3627,6 +3771,35 @@ } if (match_option(option, "-XX:Flags=", &tail)) { *flags_file = (char *) tail; + if (*flags_file == NULL) { + jio_fprintf(defaultStream::error_stream(), + "Cannot copy flags_file name.\n"); + return JNI_ENOMEM; + } + continue; + } + if (match_option(option, "-XX:VMOptionsFile=", &tail)) { + if (vm_options_file != NULL) { + // The caller accepts -XX:VMOptionsFile + if (*vm_options_file != NULL) { + jio_fprintf(defaultStream::error_stream(), + "Only one VM Options file is supported " + "on the command line\n"); + return JNI_EINVAL; + } + + *vm_options_file = (char *) tail; + vm_options_file_pos = index; // save position of -XX:VMOptionsFile + if (*vm_options_file == NULL) { + jio_fprintf(defaultStream::error_stream(), + "Cannot copy vm_options_file name.\n"); + return JNI_ENOMEM; + } + } else { + jio_fprintf(defaultStream::error_stream(), + "VM options file is only supported on the command line\n"); + return JNI_EINVAL; + } continue; } if (match_option(option, "-XX:+PrintVMOptions")) { @@ -3680,6 +3853,12 @@ } #endif } + + // If there's a VMOptionsFile, parse that (also can set flags_file) + if ((vm_options_file != NULL) && (*vm_options_file != NULL)) { + return insert_vm_options_file(args, flags_file, vm_options_file, + vm_options_file_pos, vm_options_file_args, args_out); + } return JNI_OK; } @@ -3704,10 +3883,15 @@ // If flag "-XX:Flags=flags-file" is used it will be the first option to be processed. const char* hotspotrc = ".hotspotrc"; char* flags_file = NULL; + char* vm_options_file = NULL; bool settings_file_specified = false; bool needs_hotspotrc_warning = false; ScopedVMInitArgs java_tool_options_args; ScopedVMInitArgs java_options_args; + ScopedVMInitArgs modified_cmd_line_args; + // Pass in vm_options_file_args to keep memory for flags_file from being + // deallocated if found in the vm options file. + ScopedVMInitArgs vm_options_file_args; jint code = parse_java_tool_options_environment_variable(&java_tool_options_args); @@ -3720,18 +3904,27 @@ return code; } - code = - match_special_option_and_act(java_tool_options_args.get(), &flags_file); + code = match_special_option_and_act(java_tool_options_args.get(), + &flags_file, NULL, NULL, NULL); + if (code != JNI_OK) { + return code; + } + + code = match_special_option_and_act(args, &flags_file, &vm_options_file, + &vm_options_file_args, + &modified_cmd_line_args); if (code != JNI_OK) { return code; } - code = match_special_option_and_act(args, &flags_file); - if (code != JNI_OK) { - return code; - } - - code = match_special_option_and_act(java_options_args.get(), &flags_file); + + // The command line arguments have been modified to include VMOptionsFile arguments. + if (modified_cmd_line_args.is_set()) { + args = modified_cmd_line_args.get(); + } + + code = match_special_option_and_act(java_options_args.get(), &flags_file, + NULL, NULL, NULL); if (code != JNI_OK) { return code; } @@ -3772,7 +3965,8 @@ // Parse JavaVMInitArgs structure passed in, as well as JAVA_TOOL_OPTIONS and _JAVA_OPTIONS jint result = parse_vm_init_args(java_tool_options_args.get(), - java_options_args.get(), args); + java_options_args.get(), + args); // command line arguments if (result != JNI_OK) { return result; @@ -3901,7 +4095,10 @@ set_bytecode_flags(); // Set flags if Aggressive optimization flags (-XX:+AggressiveOpts) enabled - set_aggressive_opts_flags(); + jint code = set_aggressive_opts_flags(); + if (code != JNI_OK) { + return code; + } // Turn off biased locking for locking debug mode flags, // which are subtly different from each other but neither works with @@ -4005,15 +4202,6 @@ return JNI_OK; } -// Any custom code post the 'CommandLineFlagConstraint::AfterErgo' constraint check -// can be done here. We pass a flag that specifies whether -// the check passed successfully -void Arguments::post_after_ergo_constraint_check(bool check_passed) { - // This does not set the flag itself, but stores the value in a safe place for later usage. - _min_heap_free_ratio = MinHeapFreeRatio; - _max_heap_free_ratio = MaxHeapFreeRatio; -} - int Arguments::PropertyList_count(SystemProperty* pl) { int count = 0; while(pl != NULL) { @@ -4076,7 +4264,7 @@ } } -void Arguments::PropertyList_add(SystemProperty** plist, const char* k, char* v) { +void Arguments::PropertyList_add(SystemProperty** plist, const char* k, const char* v) { if (plist == NULL) return; @@ -4089,7 +4277,7 @@ } // This add maintains unique property key in the list. -void Arguments::PropertyList_unique_add(SystemProperty** plist, const char* k, char* v, jboolean append) { +void Arguments::PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v, jboolean append) { if (plist == NULL) return;
--- a/src/share/vm/runtime/arguments.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/arguments.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -60,7 +60,7 @@ char* value() const { return _value; } SystemProperty* next() const { return _next; } void set_next(SystemProperty* next) { _next = next; } - bool set_value(char *value) { + bool set_value(const char *value) { if (writeable()) { if (_value != NULL) { FreeHeap(_value); @@ -288,10 +288,6 @@ static uintx _min_heap_size; - // Used to store original flag values - static uintx _min_heap_free_ratio; - static uintx _max_heap_free_ratio; - // -Xrun arguments static AgentLibraryList _libraryList; static void add_init_library(const char* name, char* options) @@ -352,8 +348,6 @@ static julong limit_by_allocatable_memory(julong size); // Setup heap size static void set_heap_size(); - // Set up runtime image flags - static void set_runtime_image_flags(); // Based on automatic selection criteria, should the // low pause collector be used. static bool should_auto_select_low_pause_collector(); @@ -370,17 +364,31 @@ static bool add_property(const char* prop); // Aggressive optimization flags. - static void set_aggressive_opts_flags(); + static jint set_aggressive_opts_flags(); // Argument parsing static void do_pd_flag_adjustments(); static bool parse_argument(const char* arg, Flag::Flags origin); static bool process_argument(const char* arg, jboolean ignore_unrecognized, Flag::Flags origin); static void process_java_launcher_argument(const char*, void*); - static void process_java_compiler_argument(char* arg); + static void process_java_compiler_argument(const char* arg); static jint parse_options_environment_variable(const char* name, ScopedVMInitArgs* vm_args); static jint parse_java_tool_options_environment_variable(ScopedVMInitArgs* vm_args); static jint parse_java_options_environment_variable(ScopedVMInitArgs* vm_args); + static jint parse_vm_options_file(const char* file_name, ScopedVMInitArgs* vm_args); + static jint parse_options_buffer(const char* name, char* buffer, const size_t buf_len, ScopedVMInitArgs* vm_args); + static jint insert_vm_options_file(const JavaVMInitArgs* args, + char** flags_file, + char** vm_options_file, + const int vm_options_file_pos, + ScopedVMInitArgs* vm_options_file_args, + ScopedVMInitArgs* args_out); + static jint match_special_option_and_act(const JavaVMInitArgs* args, + char** flags_file, + char** vm_options_file, + ScopedVMInitArgs* vm_options_file_args, + ScopedVMInitArgs* args_out); + static jint parse_vm_init_args(const JavaVMInitArgs *java_tool_options_args, const JavaVMInitArgs *java_options_args, const JavaVMInitArgs *cmd_line_args); @@ -465,8 +473,6 @@ static jint apply_ergo(); // Adjusts the arguments after the OS have adjusted the arguments static jint adjust_after_os(); - // Set any arguments that need to be set after the 'CommandLineFlagConstraint::AfterErgo' constraint check - static void post_after_ergo_constraint_check(bool check_passed); static void set_gc_specific_flags(); static inline bool gc_selected(); // whether a gc has been selected @@ -528,10 +534,6 @@ static size_t min_heap_size() { return _min_heap_size; } static void set_min_heap_size(size_t v) { _min_heap_size = v; } - // Returns the original values of -XX:MinHeapFreeRatio and -XX:MaxHeapFreeRatio - static uintx min_heap_free_ratio() { return _min_heap_free_ratio; } - static uintx max_heap_free_ratio() { return _max_heap_free_ratio; } - // -Xrun static AgentLibrary* libraries() { return _libraryList.first(); } static bool init_libraries_at_startup() { return !_libraryList.is_empty(); } @@ -573,22 +575,22 @@ // Property List manipulation static void PropertyList_add(SystemProperty *element); static void PropertyList_add(SystemProperty** plist, SystemProperty *element); - static void PropertyList_add(SystemProperty** plist, const char* k, char* v); - static void PropertyList_unique_add(SystemProperty** plist, const char* k, char* v) { + static void PropertyList_add(SystemProperty** plist, const char* k, const char* v); + static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v) { PropertyList_unique_add(plist, k, v, false); } - static void PropertyList_unique_add(SystemProperty** plist, const char* k, char* v, jboolean append); + static void PropertyList_unique_add(SystemProperty** plist, const char* k, const char* v, jboolean append); static const char* PropertyList_get_value(SystemProperty* plist, const char* key); static int PropertyList_count(SystemProperty* pl); static const char* PropertyList_get_key_at(SystemProperty* pl,int index); static char* PropertyList_get_value_at(SystemProperty* pl,int index); // Miscellaneous System property value getter and setters. - static void set_dll_dir(char *value) { _sun_boot_library_path->set_value(value); } - static void set_java_home(char *value) { _java_home->set_value(value); } - static void set_library_path(char *value) { _java_library_path->set_value(value); } + static void set_dll_dir(const char *value) { _sun_boot_library_path->set_value(value); } + static void set_java_home(const char *value) { _java_home->set_value(value); } + static void set_library_path(const char *value) { _java_library_path->set_value(value); } static void set_ext_dirs(char *value) { _ext_dirs = os::strdup_check_oom(value); } - static void set_sysclasspath(char *value) { _sun_boot_class_path->set_value(value); } + static void set_sysclasspath(const char *value) { _sun_boot_class_path->set_value(value); } static void append_sysclasspath(const char *value) { _sun_boot_class_path->append_value(value); } static char* get_java_home() { return _java_home->value(); }
--- a/src/share/vm/runtime/commandLineFlagConstraintList.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintList.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -45,8 +45,8 @@ _constraint=func; } - Flag::Error apply_bool(bool* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_bool(bool value, bool verbose) { + return _constraint(value, verbose); } }; @@ -61,8 +61,8 @@ _constraint=func; } - Flag::Error apply_int(int* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_int(int value, bool verbose) { + return _constraint(value, verbose); } }; @@ -77,8 +77,8 @@ _constraint=func; } - Flag::Error apply_intx(intx* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_intx(intx value, bool verbose) { + return _constraint(value, verbose); } }; @@ -93,8 +93,8 @@ _constraint=func; } - Flag::Error apply_uint(uint* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_uint(uint value, bool verbose) { + return _constraint(value, verbose); } }; @@ -109,8 +109,8 @@ _constraint=func; } - Flag::Error apply_uintx(uintx* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_uintx(uintx value, bool verbose) { + return _constraint(value, verbose); } }; @@ -125,8 +125,8 @@ _constraint=func; } - Flag::Error apply_uint64_t(uint64_t* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_uint64_t(uint64_t value, bool verbose) { + return _constraint(value, verbose); } }; @@ -141,8 +141,8 @@ _constraint=func; } - Flag::Error apply_size_t(size_t* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_size_t(size_t value, bool verbose) { + return _constraint(value, verbose); } }; @@ -157,8 +157,8 @@ _constraint=func; } - Flag::Error apply_double(double* value, bool verbose) { - return _constraint(verbose, value); + Flag::Error apply_double(double value, bool verbose) { + return _constraint(value, verbose); } }; @@ -226,7 +226,6 @@ // Check the ranges of all flags that have them or print them out and exit if requested void CommandLineFlagConstraintList::init(void) { - _constraints = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<CommandLineFlagConstraint*>(INITIAL_CONSTRAINTS_SIZE, true); emit_constraint_no(NULL RUNTIME_FLAGS(EMIT_CONSTRAINT_DEVELOPER_FLAG, @@ -306,40 +305,6 @@ // Check constraints for specific constraint type. bool CommandLineFlagConstraintList::check_constraints(CommandLineFlagConstraint::ConstraintType type) { -//#define PRINT_CONSTRAINTS_SIZES -#ifdef PRINT_CONSTRAINTS_SIZES - { - size_t size_constraints = sizeof(CommandLineFlagConstraintList); - for (int i=0; i<length(); i++) { - size_constraints += sizeof(CommandLineFlagConstraint); - CommandLineFlagConstraint* constraint = at(i); - const char* name = constraint->name(); - Flag* flag = Flag::find_flag(name, strlen(name), true, true); - if (flag->is_bool()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_bool); - size_constraints += sizeof(CommandLineFlagConstraint*); - } else if (flag->is_intx()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_intx); - size_constraints += sizeof(CommandLineFlagConstraint*); - } else if (flag->is_uintx()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_uintx); - size_constraints += sizeof(CommandLineFlagConstraint*); - } else if (flag->is_uint64_t()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_uint64_t); - size_constraints += sizeof(CommandLineFlagConstraint*); - } else if (flag->is_size_t()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_size_t); - size_constraints += sizeof(CommandLineFlagConstraint*); - } else if (flag->is_double()) { - size_constraints += sizeof(CommandLineFlagConstraintFunc_double); - size_constraints += sizeof(CommandLineFlagConstraint*); - } - } - fprintf(stderr, "Size of %d constraints: " SIZE_FORMAT " bytes\n", - length(), size_constraints); - } -#endif // PRINT_CONSTRAINTS_SIZES - // Skip if we already checked. if (type < _validating_type) { return true; @@ -350,27 +315,36 @@ for (int i=0; i<length(); i++) { CommandLineFlagConstraint* constraint = at(i); if (type != constraint->type()) continue; - const char*name = constraint->name(); + const char* name = constraint->name(); Flag* flag = Flag::find_flag(name, strlen(name), true, true); + // We must check for NULL here as lp64_product flags on 32 bit architecture + // can generate constraint check (despite that they are declared as constants), + // but they will not be returned by Flag::find_flag() if (flag != NULL) { if (flag->is_bool()) { bool value = flag->get_bool(); - if (constraint->apply_bool(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_bool(value, true) != Flag::SUCCESS) status = false; + } else if (flag->is_int()) { + int value = flag->get_int(); + if (constraint->apply_int(value, true) != Flag::SUCCESS) status = false; + } else if (flag->is_uint()) { + uint value = flag->get_uint(); + if (constraint->apply_uint(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_intx()) { intx value = flag->get_intx(); - if (constraint->apply_intx(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_intx(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_uintx()) { uintx value = flag->get_uintx(); - if (constraint->apply_uintx(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_uintx(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_uint64_t()) { uint64_t value = flag->get_uint64_t(); - if (constraint->apply_uint64_t(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_uint64_t(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_size_t()) { size_t value = flag->get_size_t(); - if (constraint->apply_size_t(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_size_t(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_double()) { double value = flag->get_double(); - if (constraint->apply_double(&value, true) != Flag::SUCCESS) status = false; + if (constraint->apply_double(value, true) != Flag::SUCCESS) status = false; } } }
--- a/src/share/vm/runtime/commandLineFlagConstraintList.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintList.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -39,14 +39,14 @@ * "runtime/commandLineFlagConstraintsRuntime.hpp" for the functions themselves. */ -typedef Flag::Error (*CommandLineFlagConstraintFunc_bool)(bool verbose, bool* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_int)(bool verbose, int* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_intx)(bool verbose, intx* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_uint)(bool verbose, uint* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_uintx)(bool verbose, uintx* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_uint64_t)(bool verbose, uint64_t* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_size_t)(bool verbose, size_t* value); -typedef Flag::Error (*CommandLineFlagConstraintFunc_double)(bool verbose, double* value); +typedef Flag::Error (*CommandLineFlagConstraintFunc_bool)(bool value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_int)(int value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_intx)(intx value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_uint)(uint value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_uintx)(uintx value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_uint64_t)(uint64_t value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_size_t)(size_t value, bool verbose); +typedef Flag::Error (*CommandLineFlagConstraintFunc_double)(double value, bool verbose); class CommandLineFlagConstraint : public CHeapObj<mtInternal> { public: @@ -70,14 +70,14 @@ ~CommandLineFlagConstraint() {}; const char* name() const { return _name; } ConstraintType type() const { return _validate_type; } - virtual Flag::Error apply_bool(bool* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_int(int* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_intx(intx* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_uint(uint* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_uintx(uintx* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_uint64_t(uint64_t* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_size_t(size_t* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; - virtual Flag::Error apply_double(double* value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_bool(bool value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_int(int value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_intx(intx value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_uint(uint value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_uintx(uintx value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_uint64_t(uint64_t value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_size_t(size_t value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; + virtual Flag::Error apply_double(double value, bool verbose = true) { ShouldNotReachHere(); return Flag::ERR_OTHER; }; }; class CommandLineFlagConstraintList : public AllStatic {
--- a/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsCompiler.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,17 +25,16 @@ #include "precompiled.hpp" #include "runtime/arguments.hpp" #include "runtime/commandLineFlagConstraintsCompiler.hpp" +#include "runtime/commandLineFlagRangeList.hpp" #include "runtime/globals.hpp" #include "utilities/defaultStream.hpp" -Flag::Error AliasLevelConstraintFunc(bool verbose, intx* value) { - if ((*value <= 1) && (Arguments::mode() == Arguments::_comp)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "AliasLevel (" INTX_FORMAT ") is not compatible " - "with -Xcomp \n", - *value); - } +Flag::Error AliasLevelConstraintFunc(intx value, bool verbose) { + if ((value <= 1) && (Arguments::mode() == Arguments::_comp)) { + CommandLineError::print(verbose, + "AliasLevel (" INTX_FORMAT ") is not " + "compatible with -Xcomp \n", + value); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; @@ -57,7 +56,7 @@ * 'TieredStopAtLevel = CompLevel_full_optimization' (the default value). As a result, * the minimum number of compiler threads is 2. */ -Flag::Error CICompilerCountConstraintFunc(bool verbose, intx* value) { +Flag::Error CICompilerCountConstraintFunc(intx value, bool verbose) { int min_number_of_compiler_threads = 0; #if !defined(COMPILER1) && !defined(COMPILER2) && !defined(SHARK) // case 1 @@ -75,12 +74,11 @@ // min_number_of_compiler_threads to exceed CI_COMPILER_COUNT. min_number_of_compiler_threads = MIN2(min_number_of_compiler_threads, CI_COMPILER_COUNT); - if (*value < (intx)min_number_of_compiler_threads) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "CICompilerCount=" INTX_FORMAT " must be at least %d \n", - *value, min_number_of_compiler_threads); - } + if (value < (intx)min_number_of_compiler_threads) { + CommandLineError::print(verbose, + "CICompilerCount (" INTX_FORMAT ") must be " + "at least %d \n", + value, min_number_of_compiler_threads); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS;
--- a/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsCompiler.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -34,8 +34,8 @@ * an appropriate error value. */ -Flag::Error AliasLevelConstraintFunc(bool verbose, intx* value); +Flag::Error AliasLevelConstraintFunc(intx value, bool verbose); -Flag::Error CICompilerCountConstraintFunc(bool verbose, intx* value); +Flag::Error CICompilerCountConstraintFunc(intx value, bool verbose); #endif /* SHARE_VM_RUNTIME_COMMANDLINEFLAGCONSTRAINTSCOMPILER_HPP */
--- a/src/share/vm/runtime/commandLineFlagConstraintsGC.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsGC.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,6 +25,7 @@ #include "precompiled.hpp" #include "runtime/arguments.hpp" #include "runtime/commandLineFlagConstraintsGC.hpp" +#include "runtime/commandLineFlagRangeList.hpp" #include "runtime/globals.hpp" #include "utilities/defaultStream.hpp" @@ -41,97 +42,85 @@ #include "opto/c2_globals.hpp" #endif // COMPILER2 -static Flag::Error MinPLABSizeBounds(const char* name, bool verbose, size_t* value) { +static Flag::Error MinPLABSizeBounds(const char* name, size_t value, bool verbose) { #if INCLUDE_ALL_GCS - if ((UseConcMarkSweepGC || UseG1GC) && (*value < PLAB::min_size())) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "%s (" SIZE_FORMAT ") must be greater than " - "ergonomic PLAB minimum size (" SIZE_FORMAT ")\n", - name, *value, PLAB::min_size()); - } + if ((UseConcMarkSweepGC || UseG1GC) && (value < PLAB::min_size())) { + CommandLineError::print(verbose, + "%s (" SIZE_FORMAT ") must be " + "greater than or equal to ergonomic PLAB minimum size (" SIZE_FORMAT ")\n", + name, value, PLAB::min_size()); return Flag::VIOLATES_CONSTRAINT; } #endif // INCLUDE_ALL_GCS return Flag::SUCCESS; } -static Flag::Error MaxPLABSizeBounds(const char* name, bool verbose, size_t* value) { +static Flag::Error MaxPLABSizeBounds(const char* name, size_t value, bool verbose) { #if INCLUDE_ALL_GCS - if ((UseConcMarkSweepGC || UseG1GC) && (*value > PLAB::max_size())) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "%s (" SIZE_FORMAT ") must be less than " - "ergonomic PLAB maximum size (" SIZE_FORMAT ")\n", - name, *value, PLAB::max_size()); - } + if ((UseConcMarkSweepGC || UseG1GC) && (value > PLAB::max_size())) { + CommandLineError::print(verbose, + "%s (" SIZE_FORMAT ") must be " + "less than or equal to ergonomic PLAB maximum size (" SIZE_FORMAT ")\n", + name, value, PLAB::max_size()); return Flag::VIOLATES_CONSTRAINT; } #endif // INCLUDE_ALL_GCS return Flag::SUCCESS; } -static Flag::Error MinMaxPLABSizeBounds(const char* name, bool verbose, size_t* value) { - if (MinPLABSizeBounds(name, verbose, value) == Flag::SUCCESS) { - return MaxPLABSizeBounds(name, verbose, value); +static Flag::Error MinMaxPLABSizeBounds(const char* name, size_t value, bool verbose) { + if (MinPLABSizeBounds(name, value, verbose) == Flag::SUCCESS) { + return MaxPLABSizeBounds(name, value, verbose); } return Flag::VIOLATES_CONSTRAINT; } -Flag::Error YoungPLABSizeConstraintFunc(bool verbose, size_t* value) { - return MinMaxPLABSizeBounds("YoungPLABSize", verbose, value); +Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose) { + return MinMaxPLABSizeBounds("YoungPLABSize", value, verbose); } -Flag::Error MinHeapFreeRatioConstraintFunc(bool verbose, uintx* value) { - if (*value > MaxHeapFreeRatio) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or " - "equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n", - *value, MaxHeapFreeRatio); - } +Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose) { + if (value > MaxHeapFreeRatio) { + CommandLineError::print(verbose, + "MinHeapFreeRatio (" UINTX_FORMAT ") must be " + "less than or equal to MaxHeapFreeRatio (" UINTX_FORMAT ")\n", + value, MaxHeapFreeRatio); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error MaxHeapFreeRatioConstraintFunc(bool verbose, uintx* value) { - if (*value < MinHeapFreeRatio) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "MaxHeapFreeRatio (" UINTX_FORMAT ") must be greater than or " - "equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n", - *value, MinHeapFreeRatio); - } +Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose) { + if (value < MinHeapFreeRatio) { + CommandLineError::print(verbose, + "MaxHeapFreeRatio (" UINTX_FORMAT ") must be " + "greater than or equal to MinHeapFreeRatio (" UINTX_FORMAT ")\n", + value, MinHeapFreeRatio); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error MinMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value) { - if (*value > MaxMetaspaceFreeRatio) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "MinMetaspaceFreeRatio (" UINTX_FORMAT ") must be less than or " - "equal to MaxMetaspaceFreeRatio (" UINTX_FORMAT ")\n", - *value, MaxMetaspaceFreeRatio); - } +Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) { + if (value > MaxMetaspaceFreeRatio) { + CommandLineError::print(verbose, + "MinMetaspaceFreeRatio (" UINTX_FORMAT ") must be " + "less than or equal to MaxMetaspaceFreeRatio (" UINTX_FORMAT ")\n", + value, MaxMetaspaceFreeRatio); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error MaxMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value) { - if (*value < MinMetaspaceFreeRatio) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be greater than or " - "equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n", - *value, MinMetaspaceFreeRatio); - } +Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose) { + if (value < MinMetaspaceFreeRatio) { + CommandLineError::print(verbose, + "MaxMetaspaceFreeRatio (" UINTX_FORMAT ") must be " + "greater than or equal to MinMetaspaceFreeRatio (" UINTX_FORMAT ")\n", + value, MinMetaspaceFreeRatio); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; @@ -147,32 +136,28 @@ } \ } -Flag::Error InitialTenuringThresholdConstraintFunc(bool verbose, uintx* value) { - UseConcMarkSweepGCWorkaroundIfNeeded(*value, MaxTenuringThreshold); +Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose) { + UseConcMarkSweepGCWorkaroundIfNeeded(value, MaxTenuringThreshold); - if (*value > MaxTenuringThreshold) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "InitialTenuringThreshold (" UINTX_FORMAT ") must be less than or " - "equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n", - *value, MaxTenuringThreshold); - } + if (value > MaxTenuringThreshold) { + CommandLineError::print(verbose, + "InitialTenuringThreshold (" UINTX_FORMAT ") must be " + "less than or equal to MaxTenuringThreshold (" UINTX_FORMAT ")\n", + value, MaxTenuringThreshold); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error MaxTenuringThresholdConstraintFunc(bool verbose, uintx* value) { - UseConcMarkSweepGCWorkaroundIfNeeded(InitialTenuringThreshold, *value); +Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose) { + UseConcMarkSweepGCWorkaroundIfNeeded(InitialTenuringThreshold, value); - if (*value < InitialTenuringThreshold) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "MaxTenuringThreshold (" UINTX_FORMAT ") must be greater than or " - "equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n", - *value, InitialTenuringThreshold); - } + if (value < InitialTenuringThreshold) { + CommandLineError::print(verbose, + "MaxTenuringThreshold (" UINTX_FORMAT ") must be " + "greater than or equal to InitialTenuringThreshold (" UINTX_FORMAT ")\n", + value, InitialTenuringThreshold); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; @@ -180,28 +165,24 @@ } #if INCLUDE_ALL_GCS -Flag::Error G1NewSizePercentConstraintFunc(bool verbose, uintx* value) { - if (*value > G1MaxNewSizePercent) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "G1NewSizePercent (" UINTX_FORMAT ") must be less than or " - "equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n", - *value, G1MaxNewSizePercent); - } +Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose) { + if (value > G1MaxNewSizePercent) { + CommandLineError::print(verbose, + "G1NewSizePercent (" UINTX_FORMAT ") must be " + "less than or equal to G1MaxNewSizePercent (" UINTX_FORMAT ")\n", + value, G1MaxNewSizePercent); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error G1MaxNewSizePercentConstraintFunc(bool verbose, uintx* value) { - if (*value < G1NewSizePercent) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "G1MaxNewSizePercent (" UINTX_FORMAT ") must be greater than or " - "equal to G1NewSizePercent (" UINTX_FORMAT ")\n", - *value, G1NewSizePercent); - } +Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose) { + if (value < G1NewSizePercent) { + CommandLineError::print(verbose, + "G1MaxNewSizePercent (" UINTX_FORMAT ") must be " + "greater than or equal to G1NewSizePercent (" UINTX_FORMAT ")\n", + value, G1NewSizePercent); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; @@ -210,65 +191,56 @@ #endif // INCLUDE_ALL_GCS -Flag::Error CMSOldPLABMinConstraintFunc(bool verbose, size_t* value) { - if (*value > CMSOldPLABMax) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "CMSOldPLABMin (" SIZE_FORMAT ") must be less than or " - "equal to CMSOldPLABMax (" SIZE_FORMAT ")\n", - *value, CMSOldPLABMax); - } +Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose) { + if (value > CMSOldPLABMax) { + CommandLineError::print(verbose, + "CMSOldPLABMin (" SIZE_FORMAT ") must be " + "less than or equal to CMSOldPLABMax (" SIZE_FORMAT ")\n", + value, CMSOldPLABMax); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error CMSPrecleanDenominatorConstraintFunc(bool verbose, uintx* value) { - if (*value <= CMSPrecleanNumerator) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "CMSPrecleanDenominator (" UINTX_FORMAT ") must be strickly greater than " - "CMSPrecleanNumerator (" UINTX_FORMAT ")\n", - *value, CMSPrecleanNumerator); - } +Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose) { + if (value <= CMSPrecleanNumerator) { + CommandLineError::print(verbose, + "CMSPrecleanDenominator (" UINTX_FORMAT ") must be " + "strickly greater than CMSPrecleanNumerator (" UINTX_FORMAT ")\n", + value, CMSPrecleanNumerator); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error CMSPrecleanNumeratorConstraintFunc(bool verbose, uintx* value) { - if (*value > (CMSPrecleanDenominator - 1)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "CMSPrecleanNumerator (" UINTX_FORMAT ") must be less than or " - "equal to CMSPrecleanDenominator - 1 (" UINTX_FORMAT ")\n", *value, - CMSPrecleanDenominator - 1); - } +Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose) { + if (value > (CMSPrecleanDenominator - 1)) { + CommandLineError::print(verbose, + "CMSPrecleanNumerator (" UINTX_FORMAT ") must be " + "less than or equal to CMSPrecleanDenominator - 1 (" UINTX_FORMAT ")\n", + value, CMSPrecleanDenominator - 1); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS; } } -Flag::Error SurvivorAlignmentInBytesConstraintFunc(bool verbose, intx* value) { - if (*value != 0) { - if (!is_power_of_2(*value)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be power of 2\n", - *value); - } +Flag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose) { + if (value != 0) { + if (!is_power_of_2(value)) { + CommandLineError::print(verbose, + "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be " + "power of 2\n", + value); return Flag::VIOLATES_CONSTRAINT; } - if (*value < ObjectAlignmentInBytes) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be greater than or " - "equal to ObjectAlignmentInBytes (" INTX_FORMAT ")\n", - *value, ObjectAlignmentInBytes); - } + if (value < ObjectAlignmentInBytes) { + CommandLineError::print(verbose, + "SurvivorAlignmentInBytes (" INTX_FORMAT ") must be " + "greater than or equal to ObjectAlignmentInBytes (" INTX_FORMAT ")\n", + value, ObjectAlignmentInBytes); return Flag::VIOLATES_CONSTRAINT; } }
--- a/src/share/vm/runtime/commandLineFlagConstraintsGC.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsGC.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -34,27 +34,27 @@ * an appropriate error value. */ -Flag::Error YoungPLABSizeConstraintFunc(bool verbose, size_t* value); +Flag::Error YoungPLABSizeConstraintFunc(size_t value, bool verbose); -Flag::Error MinHeapFreeRatioConstraintFunc(bool verbose, uintx* value); -Flag::Error MaxHeapFreeRatioConstraintFunc(bool verbose, uintx* value); +Flag::Error MinHeapFreeRatioConstraintFunc(uintx value, bool verbose); +Flag::Error MaxHeapFreeRatioConstraintFunc(uintx value, bool verbose); -Flag::Error MinMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value); -Flag::Error MaxMetaspaceFreeRatioConstraintFunc(bool verbose, uintx* value); +Flag::Error MinMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose); +Flag::Error MaxMetaspaceFreeRatioConstraintFunc(uintx value, bool verbose); -Flag::Error InitialTenuringThresholdConstraintFunc(bool verbose, uintx* value); -Flag::Error MaxTenuringThresholdConstraintFunc(bool verbose, uintx* value); +Flag::Error InitialTenuringThresholdConstraintFunc(uintx value, bool verbose); +Flag::Error MaxTenuringThresholdConstraintFunc(uintx value, bool verbose); #if INCLUDE_ALL_GCS -Flag::Error G1NewSizePercentConstraintFunc(bool verbose, uintx* value); -Flag::Error G1MaxNewSizePercentConstraintFunc(bool verbose, uintx* value); +Flag::Error G1NewSizePercentConstraintFunc(uintx value, bool verbose); +Flag::Error G1MaxNewSizePercentConstraintFunc(uintx value, bool verbose); #endif // INCLUDE_ALL_GCS -Flag::Error CMSOldPLABMinConstraintFunc(bool verbose, size_t* value); +Flag::Error CMSOldPLABMinConstraintFunc(size_t value, bool verbose); -Flag::Error CMSPrecleanDenominatorConstraintFunc(bool verbose, uintx* value); -Flag::Error CMSPrecleanNumeratorConstraintFunc(bool verbose, uintx* value); +Flag::Error CMSPrecleanDenominatorConstraintFunc(uintx value, bool verbose); +Flag::Error CMSPrecleanNumeratorConstraintFunc(uintx value, bool verbose); -Flag::Error SurvivorAlignmentInBytesConstraintFunc(bool verbose, intx* value); +Flag::Error SurvivorAlignmentInBytesConstraintFunc(intx value, bool verbose); #endif /* SHARE_VM_RUNTIME_COMMANDLINEFLAGCONSTRAINTSGC_HPP */
--- a/src/share/vm/runtime/commandLineFlagConstraintsRuntime.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsRuntime.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -25,25 +25,24 @@ #include "precompiled.hpp" #include "runtime/arguments.hpp" #include "runtime/commandLineFlagConstraintsRuntime.hpp" +#include "runtime/commandLineFlagRangeList.hpp" #include "runtime/globals.hpp" #include "utilities/defaultStream.hpp" -Flag::Error ObjectAlignmentInBytesConstraintFunc(bool verbose, intx* value) { - if (!is_power_of_2(*value)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "ObjectAlignmentInBytes=" INTX_FORMAT " must be power of 2\n", - *value); - } +Flag::Error ObjectAlignmentInBytesConstraintFunc(intx value, bool verbose) { + if (!is_power_of_2(value)) { + CommandLineError::print(verbose, + "ObjectAlignmentInBytes (" INTX_FORMAT ") must be " + "power of 2\n", + value); return Flag::VIOLATES_CONSTRAINT; } // In case page size is very small. - if (*value >= (intx)os::vm_page_size()) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "ObjectAlignmentInBytes=" INTX_FORMAT " must be less than page size " INTX_FORMAT "\n", - *value, (intx)os::vm_page_size()); - } + if (value >= (intx)os::vm_page_size()) { + CommandLineError::print(verbose, + "ObjectAlignmentInBytes (" INTX_FORMAT ") must be " + "less than page size " INTX_FORMAT "\n", + value, (intx)os::vm_page_size()); return Flag::VIOLATES_CONSTRAINT; } return Flag::SUCCESS; @@ -51,13 +50,12 @@ // Need to enforce the padding not to break the existing field alignments. // It is sufficient to check against the largest type size. -Flag::Error ContendedPaddingWidthConstraintFunc(bool verbose, intx* value) { - if ((*value != 0) && ((*value % BytesPerLong) != 0)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "ContendedPaddingWidth=" INTX_FORMAT " must be a multiple of %d\n", - *value, BytesPerLong); - } +Flag::Error ContendedPaddingWidthConstraintFunc(intx value, bool verbose) { + if ((value != 0) && ((value % BytesPerLong) != 0)) { + CommandLineError::print(verbose, + "ContendedPaddingWidth (" INTX_FORMAT ") must be " + "a multiple of %d\n", + value, BytesPerLong); return Flag::VIOLATES_CONSTRAINT; } else { return Flag::SUCCESS;
--- a/src/share/vm/runtime/commandLineFlagConstraintsRuntime.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagConstraintsRuntime.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -34,8 +34,8 @@ * an appropriate error value. */ -Flag::Error ObjectAlignmentInBytesConstraintFunc(bool verbose, intx* value); +Flag::Error ObjectAlignmentInBytesConstraintFunc(intx value, bool verbose); -Flag::Error ContendedPaddingWidthConstraintFunc(bool verbose, intx* value); +Flag::Error ContendedPaddingWidthConstraintFunc(intx value, bool verbose); #endif /* SHARE_VM_RUNTIME_COMMANDLINEFLAGCONSTRAINTSRUNTIME_HPP */
--- a/src/share/vm/runtime/commandLineFlagRangeList.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagRangeList.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,6 +32,15 @@ #include "utilities/defaultStream.hpp" #include "utilities/macros.hpp" +void CommandLineError::print(bool verbose, const char* msg, ...) { + if (verbose) { + va_list listPointer; + va_start(listPointer, msg); + jio_vfprintf(defaultStream::error_stream(), msg, listPointer); + va_end(listPointer); + } +} + class CommandLineFlagRange_int : public CommandLineFlagRange { int _min; int _max; @@ -44,11 +53,10 @@ Flag::Error check_int(int value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "int %s=%d is outside the allowed range [ %d ... %d ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "int %s=%d is outside the allowed range " + "[ %d ... %d ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -72,11 +80,10 @@ Flag::Error check_intx(intx value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "intx %s=" INTX_FORMAT " is outside the allowed range [ " INTX_FORMAT " ... " INTX_FORMAT " ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "intx %s=" INTX_FORMAT " is outside the allowed range " + "[ " INTX_FORMAT " ... " INTX_FORMAT " ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -100,11 +107,10 @@ Flag::Error check_uint(uint value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "uintx %s=%u is outside the allowed range [ %u ... %u ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "uint %s=%u is outside the allowed range " + "[ %u ... %u ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -128,11 +134,10 @@ Flag::Error check_uintx(uintx value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "uintx %s=" UINTX_FORMAT " is outside the allowed range [ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "uintx %s=" UINTX_FORMAT " is outside the allowed range " + "[ " UINTX_FORMAT " ... " UINTX_FORMAT " ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -156,11 +161,10 @@ Flag::Error check_uint64_t(uint64_t value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "uint64_t %s=" UINT64_FORMAT " is outside the allowed range [ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "uint64_t %s=" UINT64_FORMAT " is outside the allowed range " + "[ " UINT64_FORMAT " ... " UINT64_FORMAT " ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -184,11 +188,10 @@ Flag::Error check_size_t(size_t value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "size_t %s=" SIZE_FORMAT " is outside the allowed range [ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "size_t %s=" SIZE_FORMAT " is outside the allowed range " + "[ " SIZE_FORMAT " ... " SIZE_FORMAT " ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -212,11 +215,10 @@ Flag::Error check_double(double value, bool verbose = true) { if ((value < _min) || (value > _max)) { - if (verbose == true) { - jio_fprintf(defaultStream::error_stream(), - "double %s=%f is outside the allowed range [ %f ... %f ]\n", - name(), value, _min, _max); - } + CommandLineError::print(verbose, + "double %s=%f is outside the allowed range " + "[ %f ... %f ]\n", + name(), value, _min, _max); return Flag::OUT_OF_BOUNDS; } else { return Flag::SUCCESS; @@ -300,48 +302,48 @@ EMIT_RANGES_FOR_GLOBALS_EXT emit_range_no(NULL ARCH_FLAGS(EMIT_RANGE_DEVELOPER_FLAG, - EMIT_RANGE_PRODUCT_FLAG, - EMIT_RANGE_DIAGNOSTIC_FLAG, - EMIT_RANGE_EXPERIMENTAL_FLAG, - EMIT_RANGE_NOTPRODUCT_FLAG, - EMIT_RANGE_CHECK, - IGNORE_CONSTRAINT)); + EMIT_RANGE_PRODUCT_FLAG, + EMIT_RANGE_DIAGNOSTIC_FLAG, + EMIT_RANGE_EXPERIMENTAL_FLAG, + EMIT_RANGE_NOTPRODUCT_FLAG, + EMIT_RANGE_CHECK, + IGNORE_CONSTRAINT)); #ifdef COMPILER1 emit_range_no(NULL C1_FLAGS(EMIT_RANGE_DEVELOPER_FLAG, - EMIT_RANGE_PD_DEVELOPER_FLAG, - EMIT_RANGE_PRODUCT_FLAG, - EMIT_RANGE_PD_PRODUCT_FLAG, - EMIT_RANGE_DIAGNOSTIC_FLAG, - EMIT_RANGE_NOTPRODUCT_FLAG, - EMIT_RANGE_CHECK, - IGNORE_CONSTRAINT)); + EMIT_RANGE_PD_DEVELOPER_FLAG, + EMIT_RANGE_PRODUCT_FLAG, + EMIT_RANGE_PD_PRODUCT_FLAG, + EMIT_RANGE_DIAGNOSTIC_FLAG, + EMIT_RANGE_NOTPRODUCT_FLAG, + EMIT_RANGE_CHECK, + IGNORE_CONSTRAINT)); #endif // COMPILER1 #ifdef COMPILER2 emit_range_no(NULL C2_FLAGS(EMIT_RANGE_DEVELOPER_FLAG, - EMIT_RANGE_PD_DEVELOPER_FLAG, - EMIT_RANGE_PRODUCT_FLAG, - EMIT_RANGE_PD_PRODUCT_FLAG, - EMIT_RANGE_DIAGNOSTIC_FLAG, - EMIT_RANGE_EXPERIMENTAL_FLAG, - EMIT_RANGE_NOTPRODUCT_FLAG, - EMIT_RANGE_CHECK, - IGNORE_CONSTRAINT)); + EMIT_RANGE_PD_DEVELOPER_FLAG, + EMIT_RANGE_PRODUCT_FLAG, + EMIT_RANGE_PD_PRODUCT_FLAG, + EMIT_RANGE_DIAGNOSTIC_FLAG, + EMIT_RANGE_EXPERIMENTAL_FLAG, + EMIT_RANGE_NOTPRODUCT_FLAG, + EMIT_RANGE_CHECK, + IGNORE_CONSTRAINT)); #endif // COMPILER2 #if INCLUDE_ALL_GCS emit_range_no(NULL G1_FLAGS(EMIT_RANGE_DEVELOPER_FLAG, - EMIT_RANGE_PD_DEVELOPER_FLAG, - EMIT_RANGE_PRODUCT_FLAG, - EMIT_RANGE_PD_PRODUCT_FLAG, - EMIT_RANGE_DIAGNOSTIC_FLAG, - EMIT_RANGE_EXPERIMENTAL_FLAG, - EMIT_RANGE_NOTPRODUCT_FLAG, - EMIT_RANGE_MANAGEABLE_FLAG, - EMIT_RANGE_PRODUCT_RW_FLAG, - EMIT_RANGE_CHECK, - IGNORE_CONSTRAINT)); + EMIT_RANGE_PD_DEVELOPER_FLAG, + EMIT_RANGE_PRODUCT_FLAG, + EMIT_RANGE_PD_PRODUCT_FLAG, + EMIT_RANGE_DIAGNOSTIC_FLAG, + EMIT_RANGE_EXPERIMENTAL_FLAG, + EMIT_RANGE_NOTPRODUCT_FLAG, + EMIT_RANGE_MANAGEABLE_FLAG, + EMIT_RANGE_PRODUCT_RW_FLAG, + EMIT_RANGE_CHECK, + IGNORE_CONSTRAINT)); #endif // INCLUDE_ALL_GCS } @@ -367,45 +369,23 @@ } bool CommandLineFlagRangeList::check_ranges() { -//#define PRINT_RANGES_SIZES -#ifdef PRINT_RANGES_SIZES - { - size_t size_ranges = sizeof(CommandLineFlagRangeList); - for (int i=0; i<length(); i++) { - size_ranges += sizeof(CommandLineFlagRange); - CommandLineFlagRange* range = at(i); - const char* name = range->name(); - Flag* flag = Flag::find_flag(name, strlen(name), true, true); - if (flag->is_intx()) { - size_ranges += 2*sizeof(intx); - size_ranges += sizeof(CommandLineFlagRange*); - } else if (flag->is_uintx()) { - size_ranges += 2*sizeof(uintx); - size_ranges += sizeof(CommandLineFlagRange*); - } else if (flag->is_uint64_t()) { - size_ranges += 2*sizeof(uint64_t); - size_ranges += sizeof(CommandLineFlagRange*); - } else if (flag->is_size_t()) { - size_ranges += 2*sizeof(size_t); - size_ranges += sizeof(CommandLineFlagRange*); - } else if (flag->is_double()) { - size_ranges += 2*sizeof(double); - size_ranges += sizeof(CommandLineFlagRange*); - } - } - fprintf(stderr, "Size of %d ranges: " SIZE_FORMAT " bytes\n", - length(), size_ranges); - } -#endif // PRINT_RANGES_SIZES - // Check ranges. bool status = true; for (int i=0; i<length(); i++) { CommandLineFlagRange* range = at(i); const char* name = range->name(); Flag* flag = Flag::find_flag(name, strlen(name), true, true); + // We must check for NULL here as lp64_product flags on 32 bit architecture + // can generate range check (despite that they are declared as constants), + // but they will not be returned by Flag::find_flag() if (flag != NULL) { - if (flag->is_intx()) { + if (flag->is_int()) { + int value = flag->get_int(); + if (range->check_int(value, true) != Flag::SUCCESS) status = false; + } else if (flag->is_uint()) { + uint value = flag->get_uint(); + if (range->check_uint(value, true) != Flag::SUCCESS) status = false; + } else if (flag->is_intx()) { intx value = flag->get_intx(); if (range->check_intx(value, true) != Flag::SUCCESS) status = false; } else if (flag->is_uintx()) {
--- a/src/share/vm/runtime/commandLineFlagRangeList.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/commandLineFlagRangeList.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -38,6 +38,11 @@ * then we need to use constraint instead. */ +class CommandLineError : public AllStatic { +public: + static void print(bool verbose, const char* msg, ...); +}; + class CommandLineFlagRange : public CHeapObj<mtInternal> { private: const char* _name;
--- a/src/share/vm/runtime/compilationPolicy.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/compilationPolicy.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -26,7 +26,6 @@ #include "code/compiledIC.hpp" #include "code/nmethod.hpp" #include "code/scopeDesc.hpp" -#include "compiler/compilerOracle.hpp" #include "interpreter/interpreter.hpp" #include "oops/methodData.hpp" #include "oops/method.hpp"
--- a/src/share/vm/runtime/globals.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/globals.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -310,13 +310,17 @@ void Flag::get_locked_message(char* buf, int buflen) const { buf[0] = '\0'; if (is_diagnostic() && !is_unlocked()) { - jio_snprintf(buf, buflen, "Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n", - _name); + jio_snprintf(buf, buflen, + "Error: VM option '%s' is diagnostic and must be enabled via -XX:+UnlockDiagnosticVMOptions.\n" + "Error: The unlock option must precede '%s'.\n", + _name, _name); return; } if (is_experimental() && !is_unlocked()) { - jio_snprintf(buf, buflen, "Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n", - _name); + jio_snprintf(buf, buflen, + "Error: VM option '%s' is experimental and must be enabled via -XX:+UnlockExperimentalVMOptions.\n" + "Error: The unlock option must precede '%s'.\n", + _name, _name); return; } if (is_develop() && is_product_build()) { @@ -515,6 +519,20 @@ } } +const char* Flag::flag_error_str(Flag::Error error) { + switch (error) { + case Flag::MISSING_NAME: return "MISSING_NAME"; + case Flag::MISSING_VALUE: return "MISSING_VALUE"; + case Flag::NON_WRITABLE: return "NON_WRITABLE"; + case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS"; + case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT"; + case Flag::INVALID_FLAG: return "INVALID_FLAG"; + case Flag::ERR_OTHER: return "ERR_OTHER"; + case Flag::SUCCESS: return "SUCCESS"; + default: ShouldNotReachHere(); return "NULL"; + } +} + // 4991491 do not "optimize out" the was_set false values: omitting them // tickles a Microsoft compiler bug causing flagTable to be malformed @@ -758,17 +776,7 @@ e.commit(); } -static Flag::Error get_status_error(Flag::Error status_range, Flag::Error status_constraint) { - if (status_range != Flag::SUCCESS) { - return status_range; - } else if (status_constraint != Flag::SUCCESS) { - return status_constraint; - } else { - return Flag::SUCCESS; - } -} - -static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool* new_value, bool verbose = true) { +static Flag::Error apply_constraint_and_check_range_bool(const char* name, bool new_value, bool verbose = true) { Flag::Error status = Flag::SUCCESS; CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); if (constraint != NULL) { @@ -789,7 +797,7 @@ Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_bool()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_bool(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_bool(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; bool old_value = result->get_bool(); trace_flag_changed<EventBooleanFlagChanged, bool>(name, old_value, *value, origin); @@ -802,7 +810,7 @@ Flag::Error CommandLineFlagsEx::boolAtPut(CommandLineFlagWithType flag, bool value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_bool(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_bool(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventBooleanFlagChanged, bool>(faddr->_name, faddr->get_bool(), value, origin); faddr->set_bool(value); @@ -810,18 +818,19 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_int(const char* name, int* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_int(const char* name, int new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_int(*new_value, verbose); + status = range->check_int(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_int(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_int(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::intAt(const char* name, size_t len, int* value, bool allow_locked, bool return_flag) { @@ -836,7 +845,7 @@ Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_int()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_int(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_int(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; int old_value = result->get_int(); trace_flag_changed<EventIntFlagChanged, s4>(name, old_value, *value, origin); @@ -849,24 +858,27 @@ Flag::Error CommandLineFlagsEx::intAtPut(CommandLineFlagWithType flag, int value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_int(), "wrong flag type"); + Flag::Error check = apply_constraint_and_check_range_int(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + if (check != Flag::SUCCESS) return check; trace_flag_changed<EventIntFlagChanged, s4>(faddr->_name, faddr->get_int(), value, origin); faddr->set_int(value); faddr->set_origin(origin); return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_uint(const char* name, uint new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_uint(*new_value, verbose); + status = range->check_uint(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_uint(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_uint(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::uintAt(const char* name, size_t len, uint* value, bool allow_locked, bool return_flag) { @@ -881,7 +893,7 @@ Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_uint()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_uint(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_uint(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; uint old_value = result->get_uint(); trace_flag_changed<EventUnsignedIntFlagChanged, u4>(name, old_value, *value, origin); @@ -894,6 +906,8 @@ Flag::Error CommandLineFlagsEx::uintAtPut(CommandLineFlagWithType flag, uint value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_uint(), "wrong flag type"); + Flag::Error check = apply_constraint_and_check_range_uint(faddr->_name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + if (check != Flag::SUCCESS) return check; trace_flag_changed<EventUnsignedIntFlagChanged, u4>(faddr->_name, faddr->get_uint(), value, origin); faddr->set_uint(value); faddr->set_origin(origin); @@ -908,25 +922,26 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_intx(const char* name, intx new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_intx(*new_value, verbose); + status = range->check_intx(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_intx(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_intx(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::intxAtPut(const char* name, size_t len, intx* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_intx()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_intx(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_intx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; intx old_value = result->get_intx(); trace_flag_changed<EventLongFlagChanged, intx>(name, old_value, *value, origin); @@ -939,7 +954,7 @@ Flag::Error CommandLineFlagsEx::intxAtPut(CommandLineFlagWithType flag, intx value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_intx(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_intx(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventLongFlagChanged, intx>(faddr->_name, faddr->get_intx(), value, origin); faddr->set_intx(value); @@ -955,25 +970,26 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_uintx(const char* name, uintx new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_uintx(*new_value, verbose); + status = range->check_uintx(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_uintx(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_uintx(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::uintxAtPut(const char* name, size_t len, uintx* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_uintx()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_uintx(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_uintx(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; uintx old_value = result->get_uintx(); trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); @@ -986,7 +1002,7 @@ Flag::Error CommandLineFlagsEx::uintxAtPut(CommandLineFlagWithType flag, uintx value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_uintx(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_uintx(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uintx(), value, origin); faddr->set_uintx(value); @@ -1002,25 +1018,26 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_uint64_t(const char* name, uint64_t new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_uint64_t(*new_value, verbose); + status = range->check_uint64_t(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_uint64_t(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_uint64_t(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::uint64_tAtPut(const char* name, size_t len, uint64_t* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_uint64_t()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_uint64_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_uint64_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; uint64_t old_value = result->get_uint64_t(); trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); @@ -1033,7 +1050,7 @@ Flag::Error CommandLineFlagsEx::uint64_tAtPut(CommandLineFlagWithType flag, uint64_t value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_uint64_t(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_uint64_t(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_uint64_t(), value, origin); faddr->set_uint64_t(value); @@ -1049,25 +1066,26 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_size_t(const char* name, size_t new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_size_t(*new_value, verbose); + status = range->check_size_t(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_size_t(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_size_t(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::size_tAtPut(const char* name, size_t len, size_t* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_size_t()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_size_t(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_size_t(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; size_t old_value = result->get_size_t(); trace_flag_changed<EventUnsignedLongFlagChanged, u8>(name, old_value, *value, origin); @@ -1080,7 +1098,7 @@ Flag::Error CommandLineFlagsEx::size_tAtPut(CommandLineFlagWithType flag, size_t value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_size_t(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_size_t(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventUnsignedLongFlagChanged, u8>(faddr->_name, faddr->get_size_t(), value, origin); faddr->set_size_t(value); @@ -1096,25 +1114,26 @@ return Flag::SUCCESS; } -static Flag::Error apply_constraint_and_check_range_double(const char* name, double* new_value, bool verbose = true) { - Flag::Error range_status = Flag::SUCCESS; +static Flag::Error apply_constraint_and_check_range_double(const char* name, double new_value, bool verbose = true) { + Flag::Error status = Flag::SUCCESS; CommandLineFlagRange* range = CommandLineFlagRangeList::find(name); if (range != NULL) { - range_status = range->check_double(*new_value, verbose); + status = range->check_double(new_value, verbose); } - Flag::Error constraint_status = Flag::SUCCESS; - CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); - if (constraint != NULL) { - constraint_status = constraint->apply_double(new_value, verbose); + if (status == Flag::SUCCESS) { + CommandLineFlagConstraint* constraint = CommandLineFlagConstraintList::find_if_needs_check(name); + if (constraint != NULL) { + status = constraint->apply_double(new_value, verbose); + } } - return get_status_error(range_status, constraint_status); + return status; } Flag::Error CommandLineFlags::doubleAtPut(const char* name, size_t len, double* value, Flag::Flags origin) { Flag* result = Flag::find_flag(name, len); if (result == NULL) return Flag::INVALID_FLAG; if (!result->is_double()) return Flag::WRONG_FORMAT; - Flag::Error check = apply_constraint_and_check_range_double(name, value, !CommandLineFlagConstraintList::validated_after_ergo()); + Flag::Error check = apply_constraint_and_check_range_double(name, *value, !CommandLineFlagConstraintList::validated_after_ergo()); if (check != Flag::SUCCESS) return check; double old_value = result->get_double(); trace_flag_changed<EventDoubleFlagChanged, double>(name, old_value, *value, origin); @@ -1127,7 +1146,7 @@ Flag::Error CommandLineFlagsEx::doubleAtPut(CommandLineFlagWithType flag, double value, Flag::Flags origin) { Flag* faddr = address_of_flag(flag); guarantee(faddr != NULL && faddr->is_double(), "wrong flag type"); - Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, &value); + Flag::Error check = apply_constraint_and_check_range_double(faddr->_name, value); if (check != Flag::SUCCESS) return check; trace_flag_changed<EventDoubleFlagChanged, double>(faddr->_name, faddr->get_double(), value, origin); faddr->set_double(value);
--- a/src/share/vm/runtime/globals.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/globals.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -372,19 +372,7 @@ void print_kind(outputStream* st); void print_as_flag(outputStream* st); - static const char* flag_error_str(Flag::Error error) { - switch (error) { - case Flag::MISSING_NAME: return "MISSING_NAME"; - case Flag::MISSING_VALUE: return "MISSING_VALUE"; - case Flag::NON_WRITABLE: return "NON_WRITABLE"; - case Flag::OUT_OF_BOUNDS: return "OUT_OF_BOUNDS"; - case Flag::VIOLATES_CONSTRAINT: return "VIOLATES_CONSTRAINT"; - case Flag::INVALID_FLAG: return "INVALID_FLAG"; - case Flag::ERR_OTHER: return "ERR_OTHER"; - case Flag::SUCCESS: return "SUCCESS"; - default: return "NULL"; - } - } + static const char* flag_error_str(Flag::Error error); }; // debug flags control various aspects of the VM and are global accessible @@ -650,10 +638,6 @@ experimental(bool, AlwaysSafeConstructors, false, \ "Force safe construction, as if all fields are final.") \ \ - /* Temporary: See 6948537 */ \ - experimental(bool, UseMemSetInBOT, true, \ - "(Unstable) uses memset in BOT updates in GC code") \ - \ diagnostic(bool, UnlockDiagnosticVMOptions, trueInDebug, \ "Enable normal processing of flags relating to field diagnostics")\ \ @@ -832,7 +816,7 @@ \ product(bool, UseSHA1Intrinsics, false, \ "Use intrinsics for SHA-1 crypto hash function. " \ - "Requires that UseSHA is enabled.") \ + "Requires that UseSHA is enabled.") \ \ product(bool, UseSHA256Intrinsics, false, \ "Use intrinsics for SHA-224 and SHA-256 crypto hash functions. " \ @@ -848,6 +832,9 @@ product(bool, UseCRC32CIntrinsics, false, \ "use intrinsics for java.util.zip.CRC32C") \ \ + product(bool, UseAdler32Intrinsics, false, \ + "use intrinsics for java.util.zip.Adler32") \ + \ diagnostic(ccstrlist, DisableIntrinsic, "", \ "do not expand intrinsics whose (internal) names appear here") \ \ @@ -1103,9 +1090,6 @@ product(bool, AlwaysRestoreFPU, false, \ "Restore the FPU control word after every JNI call (expensive)") \ \ - product(bool, MemoryMapImage, false, \ - "Memory map entire runtime image") \ - \ diagnostic(bool, PrintCompilation2, false, \ "Print additional statistics per compilation") \ \ @@ -1683,6 +1667,10 @@ product(uint, ParallelGCThreads, 0, \ "Number of parallel threads parallel gc will use") \ \ + diagnostic(bool, UseSemaphoreGCThreadsSynchronization, true, \ + "Use semaphore synchronization for the GC Threads, " \ + "instead of synchronization based on mutexes") \ + \ product(bool, UseDynamicNumberOfGCThreads, false, \ "Dynamically choose the number of parallel threads " \ "parallel gc will use") \ @@ -1694,7 +1682,7 @@ product(size_t, HeapSizePerGCThread, ScaleForWordSize(64*M), \ "Size of heap (bytes) per GC thread used in calculating the " \ "number of GC threads") \ - range((uintx)os::vm_page_size(), max_uintx) \ + range((size_t)os::vm_page_size(), (size_t)max_uintx) \ \ product(bool, TraceDynamicGCThreads, false, \ "Trace the dynamic GC thread usage") \ @@ -1730,7 +1718,7 @@ "(ParallelGC only)") \ \ product(bool, ScavengeBeforeFullGC, true, \ - "Scavenge youngest generation before each full GC.") \ + "Scavenge young generation before each full GC.") \ \ develop(bool, ScavengeWithObjectsInToSpace, false, \ "Allow scavenges to occur when to-space contains objects") \ @@ -1975,6 +1963,7 @@ product(size_t, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \ "Size of marking stack") \ \ + /* where does the range max value of (max_jint - 1) come from? */ \ product(size_t, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \ "Maximum size of marking stack") \ range(1, (max_jint - 1)) \ @@ -2227,11 +2216,11 @@ "promotion failure") \ \ notproduct(bool, PromotionFailureALot, false, \ - "Use promotion failure handling on every youngest generation " \ + "Use promotion failure handling on every young generation " \ "collection") \ \ develop(uintx, PromotionFailureALotCount, 1000, \ - "Number of promotion failures occurring at PLAB " \ + "Number of promotion failures occurring at PLAB " \ "refill attempts (ParNew) or promotion attempts " \ "(other young collectors)") \ \ @@ -3039,12 +3028,6 @@ notproduct(bool, ICMissHistogram, false, \ "Produce histogram of IC misses") \ \ - notproduct(bool, PrintClassStatistics, false, \ - "Print class statistics at end of run") \ - \ - notproduct(bool, PrintMethodStatistics, false, \ - "Print method statistics at end of run") \ - \ /* interpreter */ \ develop(bool, ClearInterpreterLocals, false, \ "Always clear local variables of interpreter activations upon " \
--- a/src/share/vm/runtime/init.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/init.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -83,7 +83,6 @@ // during VM shutdown void perfMemory_exit(); void ostream_exit(); -bool image_decompressor_init(); void vm_init_globals() { check_ThreadShadow(); @@ -122,9 +121,6 @@ templateTable_init(); InterfaceSupport_init(); SharedRuntime::generate_stubs(); - if (!image_decompressor_init()) { - return JNI_ERR; - } universe2_init(); // dependent on codeCache_init and stubRoutines_init1 referenceProcessor_init(); jni_handles_init();
--- a/src/share/vm/runtime/java.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/java.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -304,13 +304,6 @@ CodeCache::print_internals(); } - if (PrintClassStatistics) { - SystemDictionary::print_class_statistics(); - } - if (PrintMethodStatistics) { - SystemDictionary::print_method_statistics(); - } - if (PrintVtableStats) { klassVtable::print_statistics(); klassItable::print_statistics();
--- a/src/share/vm/runtime/jniHandles.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/jniHandles.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -124,8 +124,8 @@ } -void JNIHandles::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { - _weak_global_handles->weak_oops_do(is_alive, f); +size_t JNIHandles::weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f) { + return _weak_global_handles->weak_oops_do(is_alive, f); } @@ -380,8 +380,9 @@ } -void JNIHandleBlock::weak_oops_do(BoolObjectClosure* is_alive, - OopClosure* f) { +size_t JNIHandleBlock::weak_oops_do(BoolObjectClosure* is_alive, + OopClosure* f) { + size_t count = 0; for (JNIHandleBlock* current = this; current != NULL; current = current->_next) { assert(current->pop_frame_link() == NULL, "blocks holding weak global JNI handles should not have pop frame link set"); @@ -390,6 +391,7 @@ oop value = *root; // traverse heap pointers only, not deleted handles or free list pointers if (value != NULL && Universe::heap()->is_in_reserved(value)) { + count++; if (is_alive->do_object_b(value)) { // The weakly referenced object is alive, update pointer f->do_oop(root); @@ -412,7 +414,9 @@ * JVMTI data structures may also contain weak oops. The iteration of them * is placed here so that we don't need to add it to each of the collectors. */ - JvmtiExport::weak_oops_do(is_alive, f); + count += JvmtiExport::weak_oops_do(is_alive, f); + + return count; }
--- a/src/share/vm/runtime/jniHandles.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/jniHandles.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -86,7 +86,7 @@ // Traversal of regular global handles static void oops_do(OopClosure* f); // Traversal of weak global handles. Unreachable oops are cleared. - static void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f); + static size_t weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f); }; @@ -154,7 +154,7 @@ // Traversal of regular handles void oops_do(OopClosure* f); // Traversal of weak handles. Unreachable oops are cleared. - void weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f); + size_t weak_oops_do(BoolObjectClosure* is_alive, OopClosure* f); // Checked JNI support void set_planned_capacity(size_t planned_capacity) { _planned_capacity = planned_capacity; }
--- a/src/share/vm/runtime/mutexLocker.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/mutexLocker.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -105,8 +105,6 @@ Mutex* OsrList_lock = NULL; Monitor* ShenandoahMemProtect_lock = NULL; -Mutex* ImageFileReaderTable_lock = NULL; - #ifndef PRODUCT Mutex* FullGCALot_lock = NULL; #endif @@ -241,7 +239,6 @@ def(ProfilePrint_lock , Mutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing def(ExceptionCache_lock , Mutex , leaf, false, Monitor::_safepoint_check_always); // serial profile printing def(OsrList_lock , Mutex , leaf, true, Monitor::_safepoint_check_never); - def(ImageFileReaderTable_lock , Mutex , nonleaf, false, Monitor::_safepoint_check_always); // synchronize image readers open/close def(Debug1_lock , Mutex , leaf, true, Monitor::_safepoint_check_never); #ifndef PRODUCT def(FullGCALot_lock , Mutex , leaf, false, Monitor::_safepoint_check_always); // a lock to make FullGCALot MT safe
--- a/src/share/vm/runtime/mutexLocker.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/mutexLocker.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -107,8 +107,6 @@ extern Mutex* OsrList_lock; // a lock used to serialize access to OSR queues extern Monitor* ShenandoahMemProtect_lock; // ShenandoahGC uses this for memory protection to verify operations on the heap. -extern Mutex* ImageFileReaderTable_lock; // a lock used to synchronize image readers open/close - #ifndef PRODUCT extern Mutex* FullGCALot_lock; // a lock to make FullGCALot MT safe #endif // PRODUCT
--- a/src/share/vm/runtime/objectMonitor.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/objectMonitor.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -184,7 +184,8 @@ // // * The monitor entry list operations avoid locks, but strictly speaking // they're not lock-free. Enter is lock-free, exit is not. -// See http://j2se.east/~dice/PERSIST/040825-LockFreeQueues.html +// For a description of 'Methods and apparatus providing non-blocking access +// to a resource,' see U.S. Pat. No. 7844973. // // * The cxq can have multiple concurrent "pushers" but only one concurrent // detaching thread. This mechanism is immune from the ABA corruption. @@ -405,9 +406,7 @@ event.commit(); } - if (ObjectMonitor::_sync_ContendedLockAttempts != NULL) { - ObjectMonitor::_sync_ContendedLockAttempts->inc(); - } + OM_PERFDATA_OP(ContendedLockAttempts, inc()); } @@ -574,9 +573,9 @@ // That is by design - we trade "lossy" counters which are exposed to // races during updates for a lower probe effect. TEVENT(Inflated enter - Futile wakeup); - if (ObjectMonitor::_sync_FutileWakeups != NULL) { - ObjectMonitor::_sync_FutileWakeups->inc(); - } + // This PerfData object can be used in parallel with a safepoint. + // See the work around in PerfDataManager::destroy(). + OM_PERFDATA_OP(FutileWakeups, inc()); ++nWakeups; // Assuming this is not a spurious wakeup we'll normally find _succ == Self. @@ -748,9 +747,9 @@ // *must* retry _owner before parking. OrderAccess::fence(); - if (ObjectMonitor::_sync_FutileWakeups != NULL) { - ObjectMonitor::_sync_FutileWakeups->inc(); - } + // This PerfData object can be used in parallel with a safepoint. + // See the work around in PerfDataManager::destroy(). + OM_PERFDATA_OP(FutileWakeups, inc()); } // Self has acquired the lock -- Unlink Self from the cxq or EntryList . @@ -1302,9 +1301,7 @@ Trigger->unpark(); // Maintain stats and report events to JVMTI - if (ObjectMonitor::_sync_Parks != NULL) { - ObjectMonitor::_sync_Parks->inc(); - } + OM_PERFDATA_OP(Parks, inc()); } @@ -1765,9 +1762,7 @@ } DTRACE_MONITOR_PROBE(notify, this, object(), THREAD); INotify(THREAD); - if (ObjectMonitor::_sync_Notifications != NULL) { - ObjectMonitor::_sync_Notifications->inc(1); - } + OM_PERFDATA_OP(Notifications, inc(1)); } @@ -1792,9 +1787,7 @@ INotify(THREAD); } - if (tally != 0 && ObjectMonitor::_sync_Notifications != NULL) { - ObjectMonitor::_sync_Notifications->inc(tally); - } + OM_PERFDATA_OP(Notifications, inc(tally)); } // ----------------------------------------------------------------------------- @@ -1816,7 +1809,8 @@ // (duration) or we can fix the count at approximately the duration of // a context switch and vary the frequency. Of course we could also // vary both satisfying K == Frequency * Duration, where K is adaptive by monitor. -// See http://j2se.east/~dice/PERSIST/040824-AdaptiveSpinning.html. +// For a description of 'Adaptive spin-then-block mutual exclusion in +// multi-threaded processing,' see U.S. Pat. No. 8046758. // // This implementation varies the duration "D", where D varies with // the success rate of recent spin attempts. (D is capped at approximately
--- a/src/share/vm/runtime/objectMonitor.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/objectMonitor.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -177,6 +177,19 @@ public: static void Initialize(); + + // Only perform a PerfData operation if the PerfData object has been + // allocated and if the PerfDataManager has not freed the PerfData + // objects which can happen at normal VM shutdown. + // + #define OM_PERFDATA_OP(f, op_str) \ + do { \ + if (ObjectMonitor::_sync_ ## f != NULL && \ + PerfDataManager::has_PerfData()) { \ + ObjectMonitor::_sync_ ## f->op_str; \ + } \ + } while (0) + static PerfCounter * _sync_ContendedLockAttempts; static PerfCounter * _sync_FutileWakeups; static PerfCounter * _sync_Parks;
--- a/src/share/vm/runtime/perfData.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/perfData.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -39,6 +39,7 @@ PerfDataList* PerfDataManager::_all = NULL; PerfDataList* PerfDataManager::_sampled = NULL; PerfDataList* PerfDataManager::_constants = NULL; +volatile bool PerfDataManager::_has_PerfData = 0; /* * The jvmstat global and subsystem jvmstat counter name spaces. The top @@ -272,16 +273,22 @@ } - - - - void PerfDataManager::destroy() { if (_all == NULL) // destroy already called, or initialization never happened return; + // Clear the flag before we free the PerfData counters. Thus begins + // the race between this thread and another thread that has just + // queried PerfDataManager::has_PerfData() and gotten back 'true'. + // The hope is that the other thread will finish its PerfData + // manipulation before we free the memory. The two alternatives are + // 1) leak the PerfData memory or 2) do some form of synchronized + // access or check before every PerfData operation. + _has_PerfData = false; + os::naked_short_sleep(1); // 1ms sleep to let other thread(s) run + for (int index = 0; index < _all->length(); index++) { PerfData* p = _all->at(index); delete p; @@ -302,6 +309,7 @@ if (_all == NULL) { _all = new PerfDataList(100); + _has_PerfData = true; } assert(!_all->contains(p->name()), "duplicate name added");
--- a/src/share/vm/runtime/perfData.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/perfData.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -668,6 +668,7 @@ static PerfDataList* _sampled; static PerfDataList* _constants; static const char* _name_spaces[]; + static volatile bool _has_PerfData; // add a PerfData item to the list(s) of know PerfData objects static void add_item(PerfData* p, bool sampled); @@ -869,6 +870,7 @@ } static void destroy(); + static bool has_PerfData() { return _has_PerfData; } }; // Useful macros to create the performance counters
--- a/src/share/vm/runtime/perfMemory.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/perfMemory.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2001, 2014, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2001, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -32,6 +32,7 @@ #include "runtime/os.hpp" #include "runtime/perfData.hpp" #include "runtime/perfMemory.hpp" +#include "runtime/safepoint.hpp" #include "runtime/statSampler.hpp" #include "utilities/globalDefinitions.hpp" @@ -64,16 +65,20 @@ if (!UsePerfData) return; if (!PerfMemory::is_initialized()) return; - // if the StatSampler is active, then we don't want to remove - // resources it may be dependent on. Typically, the StatSampler - // is disengaged from the watcher thread when this method is called, - // but it is not disengaged if this method is invoked during a - // VM abort. + // Only destroy PerfData objects if we're at a safepoint and the + // StatSampler is not active. Otherwise, we risk removing PerfData + // objects that are currently being used by running JavaThreads + // or the StatSampler. This method is invoked while we are not at + // a safepoint during a VM abort so leaving the PerfData objects + // around may also help diagnose the failure. In rare cases, + // PerfData objects are used in parallel with a safepoint. See + // the work around in PerfDataManager::destroy(). // - if (!StatSampler::is_active()) + if (SafepointSynchronize::is_at_safepoint() && !StatSampler::is_active()) { PerfDataManager::destroy(); + } - // remove the persistent external resources, if any. this method + // Remove the persistent external resources, if any. This method // does not unmap or invalidate any virtual memory allocated during // initialization. //
--- a/src/share/vm/runtime/sharedRuntime.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/sharedRuntime.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -32,7 +32,6 @@ #include "code/vtableStubs.hpp" #include "compiler/abstractCompiler.hpp" #include "compiler/compileBroker.hpp" -#include "compiler/compilerOracle.hpp" #include "compiler/disassembler.hpp" #include "gc/shared/gcLocker.inline.hpp" #include "interpreter/interpreter.hpp" @@ -2631,7 +2630,7 @@ if (nm != NULL) { if (PrintCompilation) { ttyLocker ttyl; - CompileTask::print_compilation(tty, nm, method->is_static() ? "(static)" : ""); + CompileTask::print(tty, nm, method->is_static() ? "(static)" : ""); } nm->post_compiled_method_load_event(); }
--- a/src/share/vm/runtime/stubRoutines.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/stubRoutines.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -139,6 +139,7 @@ address StubRoutines::_crc_table_adr = NULL; address StubRoutines::_updateBytesCRC32C = NULL; +address StubRoutines::_updateBytesAdler32 = NULL; address StubRoutines::_multiplyToLen = NULL; address StubRoutines::_squareToLen = NULL; @@ -181,7 +182,7 @@ StubGenerator_generate(&buffer, false); // When new stubs added we need to make sure there is some space left // to catch situation when we should increase size again. - assert(buffer.insts_remaining() > 200, "increase code_size1"); + assert(code_size1 == 0 || buffer.insts_remaining() > 200, "increase code_size1"); } } @@ -274,7 +275,7 @@ StubGenerator_generate(&buffer, true); // When new stubs added we need to make sure there is some space left // to catch situation when we should increase size again. - assert(buffer.insts_remaining() > 200, "increase code_size2"); + assert(code_size2 == 0 || buffer.insts_remaining() > 200, "increase code_size2"); } #ifdef ASSERT
--- a/src/share/vm/runtime/stubRoutines.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/stubRoutines.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -198,6 +198,7 @@ static address _crc_table_adr; static address _updateBytesCRC32C; + static address _updateBytesAdler32; static address _multiplyToLen; static address _squareToLen; @@ -364,6 +365,7 @@ static address crc_table_addr() { return _crc_table_adr; } static address updateBytesCRC32C() { return _updateBytesCRC32C; } + static address updateBytesAdler32() { return _updateBytesAdler32; } static address multiplyToLen() {return _multiplyToLen; } static address squareToLen() {return _squareToLen; }
--- a/src/share/vm/runtime/sweeper.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/sweeper.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -611,26 +611,21 @@ } else if (nm->is_not_entrant()) { // If there are no current activations of this method on the // stack we can safely convert it to a zombie method - if (nm->can_not_entrant_be_converted()) { + if (nm->can_convert_to_zombie()) { // Clear ICStubs to prevent back patching stubs of zombie or unloaded // nmethods during the next safepoint (see ICStub::finalize). { MutexLocker cl(CompiledIC_lock); nm->clear_ic_stubs(); } - // Acquiring the CompiledIC_lock may block for a safepoint and set the - // nmethod to zombie (see 'CodeCache::make_marked_nmethods_zombies'). - // Check if nmethod is still non-entrant at this point. - if (nm->is_not_entrant()) { - if (PrintMethodFlushing && Verbose) { - tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm); - } - // Code cache state change is tracked in make_zombie() - nm->make_zombie(); - SWEEP(nm); - assert(result == None, "sanity"); - result = MadeZombie; + if (PrintMethodFlushing && Verbose) { + tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm); } + // Code cache state change is tracked in make_zombie() + nm->make_zombie(); + SWEEP(nm); + assert(result == None, "sanity"); + result = MadeZombie; assert(nm->is_zombie(), "nmethod must be zombie"); } else { // Still alive, clean up its inline caches @@ -650,6 +645,12 @@ assert(result == None, "sanity"); result = Flushed; } else { + { + // Clean ICs of unloaded nmethods as well because they may reference other + // unloaded nmethods that may be flushed earlier in the sweeper cycle. + MutexLocker cl(CompiledIC_lock); + nm->cleanup_inline_caches(); + } // Code cache state change is tracked in make_zombie() nm->make_zombie(); SWEEP(nm);
--- a/src/share/vm/runtime/synchronizer.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/synchronizer.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -189,9 +189,7 @@ mon->INotify(self); ++tally; } while (mon->first_waiter() != NULL && all); - if (ObjectMonitor::_sync_Notifications != NULL) { - ObjectMonitor::_sync_Notifications->inc(tally); - } + OM_PERFDATA_OP(Notifications, inc(tally)); } return true; } @@ -1370,7 +1368,7 @@ } // We've successfully installed INFLATING (0) into the mark-word. - // This is the only case where 0 will appear in a mark-work. + // This is the only case where 0 will appear in a mark-word. // Only the singular thread that successfully swings the mark-word // to 0 can perform (or more precisely, complete) inflation. // @@ -1421,7 +1419,7 @@ // Hopefully the performance counters are allocated on distinct cache lines // to avoid false sharing on MP systems ... - if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc(); + OM_PERFDATA_OP(Inflations, inc()); TEVENT(Inflate: overwrite stacklock); if (TraceMonitorInflation) { if (object->is_instance()) { @@ -1469,7 +1467,7 @@ // Hopefully the performance counters are allocated on distinct // cache lines to avoid false sharing on MP systems ... - if (ObjectMonitor::_sync_Inflations != NULL) ObjectMonitor::_sync_Inflations->inc(); + OM_PERFDATA_OP(Inflations, inc()); TEVENT(Inflate: overwrite neutral); if (TraceMonitorInflation) { if (object->is_instance()) { @@ -1687,8 +1685,8 @@ } Thread::muxRelease(&gListLock); - if (ObjectMonitor::_sync_Deflations != NULL) ObjectMonitor::_sync_Deflations->inc(nScavenged); - if (ObjectMonitor::_sync_MonExtant != NULL) ObjectMonitor::_sync_MonExtant ->set_value(nInCirculation); + OM_PERFDATA_OP(Deflations, inc(nScavenged)); + OM_PERFDATA_OP(MonExtant, set_value(nInCirculation)); // TODO: Add objectMonitor leak detection. // Audit/inventory the objectMonitors -- make sure they're all accounted for.
--- a/src/share/vm/runtime/thread.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/thread.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -3359,7 +3359,6 @@ // Final check of all 'AfterErgo' constraints after ergonomics which may change values. bool constraint_result = CommandLineFlagConstraintList::check_constraints(CommandLineFlagConstraint::AfterErgo); - Arguments::post_after_ergo_constraint_check(constraint_result); if (!constraint_result) { return JNI_EINVAL; }
--- a/src/share/vm/runtime/thread.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/thread.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -373,9 +373,17 @@ inline void clear_critical_native_unlock(); // Support for Unhandled Oop detection + // Add the field for both, fastdebug and debug, builds to keep + // Thread's fields layout the same. + // Note: CHECK_UNHANDLED_OOPS is defined only for fastdebug build. #ifdef CHECK_UNHANDLED_OOPS private: UnhandledOops* _unhandled_oops; +#elif defined(ASSERT) + private: + void* _unhandled_oops; +#endif +#ifdef CHECK_UNHANDLED_OOPS public: UnhandledOops* unhandled_oops() { return _unhandled_oops; } // Mark oop safe for gc. It may be stack allocated but won't move. @@ -388,12 +396,12 @@ } #endif // CHECK_UNHANDLED_OOPS + public: #ifndef PRODUCT bool skip_gcalot() { return _skip_gcalot; } void set_skip_gcalot(bool v) { _skip_gcalot = v; } #endif - public: // Installs a pending exception to be inserted later static void send_async_exception(oop thread_oop, oop java_throwable);
--- a/src/share/vm/runtime/vmStructs.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/vmStructs.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -284,17 +284,17 @@ volatile_nonstatic_field(ArrayKlass, _higher_dimension, Klass*) \ volatile_nonstatic_field(ArrayKlass, _lower_dimension, Klass*) \ nonstatic_field(ArrayKlass, _vtable_len, int) \ - nonstatic_field(CompiledICHolder, _holder_method, Method*) \ - nonstatic_field(CompiledICHolder, _holder_klass, Klass*) \ - nonstatic_field(ConstantPool, _tags, Array<u1>*) \ - nonstatic_field(ConstantPool, _cache, ConstantPoolCache*) \ - nonstatic_field(ConstantPool, _pool_holder, InstanceKlass*) \ - nonstatic_field(ConstantPool, _operands, Array<u2>*) \ - nonstatic_field(ConstantPool, _length, int) \ - nonstatic_field(ConstantPool, _resolved_references, jobject) \ - nonstatic_field(ConstantPool, _reference_map, Array<u2>*) \ - nonstatic_field(ConstantPoolCache, _length, int) \ - nonstatic_field(ConstantPoolCache, _constant_pool, ConstantPool*) \ + nonstatic_field(CompiledICHolder, _holder_method, Method*) \ + nonstatic_field(CompiledICHolder, _holder_klass, Klass*) \ + nonstatic_field(ConstantPool, _tags, Array<u1>*) \ + nonstatic_field(ConstantPool, _cache, ConstantPoolCache*) \ + nonstatic_field(ConstantPool, _pool_holder, InstanceKlass*) \ + nonstatic_field(ConstantPool, _operands, Array<u2>*) \ + nonstatic_field(ConstantPool, _length, int) \ + nonstatic_field(ConstantPool, _resolved_references, jobject) \ + nonstatic_field(ConstantPool, _reference_map, Array<u2>*) \ + nonstatic_field(ConstantPoolCache, _length, int) \ + nonstatic_field(ConstantPoolCache, _constant_pool, ConstantPool*) \ nonstatic_field(InstanceKlass, _array_klasses, Klass*) \ nonstatic_field(InstanceKlass, _methods, Array<Method*>*) \ nonstatic_field(InstanceKlass, _default_methods, Array<Method*>*) \ @@ -304,12 +304,12 @@ nonstatic_field(InstanceKlass, _java_fields_count, u2) \ nonstatic_field(InstanceKlass, _constants, ConstantPool*) \ nonstatic_field(InstanceKlass, _class_loader_data, ClassLoaderData*) \ - nonstatic_field(InstanceKlass, _source_file_name_index, u2) \ + nonstatic_field(InstanceKlass, _source_file_name_index, u2) \ nonstatic_field(InstanceKlass, _source_debug_extension, char*) \ - nonstatic_field(InstanceKlass, _inner_classes, Array<jushort>*) \ + nonstatic_field(InstanceKlass, _inner_classes, Array<jushort>*) \ nonstatic_field(InstanceKlass, _nonstatic_field_size, int) \ nonstatic_field(InstanceKlass, _static_field_size, int) \ - nonstatic_field(InstanceKlass, _static_oop_field_count, u2) \ + nonstatic_field(InstanceKlass, _static_oop_field_count, u2) \ nonstatic_field(InstanceKlass, _nonstatic_oop_map_size, int) \ nonstatic_field(InstanceKlass, _is_marked_dependent, bool) \ nonstatic_field(InstanceKlass, _minor_version, u2) \ @@ -347,66 +347,66 @@ nonstatic_field(Klass, _prototype_header, markOop) \ nonstatic_field(Klass, _next_sibling, Klass*) \ nonstatic_field(vtableEntry, _method, Method*) \ - nonstatic_field(MethodData, _size, int) \ - nonstatic_field(MethodData, _method, Method*) \ - nonstatic_field(MethodData, _data_size, int) \ - nonstatic_field(MethodData, _data[0], intptr_t) \ - nonstatic_field(MethodData, _parameters_type_data_di, int) \ - nonstatic_field(MethodData, _nof_decompiles, uint) \ - nonstatic_field(MethodData, _nof_overflow_recompiles, uint) \ - nonstatic_field(MethodData, _nof_overflow_traps, uint) \ - nonstatic_field(MethodData, _trap_hist._array[0], u1) \ - nonstatic_field(MethodData, _eflags, intx) \ - nonstatic_field(MethodData, _arg_local, intx) \ - nonstatic_field(MethodData, _arg_stack, intx) \ - nonstatic_field(MethodData, _arg_returned, intx) \ - nonstatic_field(MethodData, _tenure_traps, uint) \ - nonstatic_field(MethodData, _invoke_mask, int) \ - nonstatic_field(MethodData, _backedge_mask, int) \ - nonstatic_field(DataLayout, _header._struct._tag, u1) \ - nonstatic_field(DataLayout, _header._struct._flags, u1) \ - nonstatic_field(DataLayout, _header._struct._bci, u2) \ - nonstatic_field(DataLayout, _cells[0], intptr_t) \ - nonstatic_field(MethodCounters, _nmethod_age, int) \ - nonstatic_field(MethodCounters, _interpreter_invocation_limit, int) \ - nonstatic_field(MethodCounters, _interpreter_backward_branch_limit, int) \ - nonstatic_field(MethodCounters, _interpreter_profile_limit, int) \ - nonstatic_field(MethodCounters, _invoke_mask, int) \ - nonstatic_field(MethodCounters, _backedge_mask, int) \ - nonstatic_field(MethodCounters, _interpreter_invocation_count, int) \ - nonstatic_field(MethodCounters, _interpreter_throwout_count, u2) \ - nonstatic_field(MethodCounters, _number_of_breakpoints, u2) \ - nonstatic_field(MethodCounters, _invocation_counter, InvocationCounter) \ - nonstatic_field(MethodCounters, _backedge_counter, InvocationCounter) \ - nonstatic_field(Method, _constMethod, ConstMethod*) \ - nonstatic_field(Method, _method_data, MethodData*) \ - nonstatic_field(Method, _method_counters, MethodCounters*) \ - nonstatic_field(Method, _access_flags, AccessFlags) \ - nonstatic_field(Method, _vtable_index, int) \ - nonstatic_field(Method, _method_size, u2) \ - nonstatic_field(Method, _intrinsic_id, u1) \ - nonproduct_nonstatic_field(Method, _compiled_invocation_count, int) \ - volatile_nonstatic_field(Method, _code, nmethod*) \ - nonstatic_field(Method, _i2i_entry, address) \ - nonstatic_field(Method, _adapter, AdapterHandlerEntry*) \ - volatile_nonstatic_field(Method, _from_compiled_entry, address) \ - volatile_nonstatic_field(Method, _from_interpreted_entry, address) \ - volatile_nonstatic_field(ConstMethod, _fingerprint, uint64_t) \ - nonstatic_field(ConstMethod, _constants, ConstantPool*) \ - nonstatic_field(ConstMethod, _stackmap_data, Array<u1>*) \ - nonstatic_field(ConstMethod, _constMethod_size, int) \ - nonstatic_field(ConstMethod, _flags, u2) \ - nonstatic_field(ConstMethod, _code_size, u2) \ - nonstatic_field(ConstMethod, _name_index, u2) \ - nonstatic_field(ConstMethod, _signature_index, u2) \ - nonstatic_field(ConstMethod, _method_idnum, u2) \ - nonstatic_field(ConstMethod, _max_stack, u2) \ - nonstatic_field(ConstMethod, _max_locals, u2) \ - nonstatic_field(ConstMethod, _size_of_parameters, u2) \ + nonstatic_field(MethodData, _size, int) \ + nonstatic_field(MethodData, _method, Method*) \ + nonstatic_field(MethodData, _data_size, int) \ + nonstatic_field(MethodData, _data[0], intptr_t) \ + nonstatic_field(MethodData, _parameters_type_data_di, int) \ + nonstatic_field(MethodData, _nof_decompiles, uint) \ + nonstatic_field(MethodData, _nof_overflow_recompiles, uint) \ + nonstatic_field(MethodData, _nof_overflow_traps, uint) \ + nonstatic_field(MethodData, _trap_hist._array[0], u1) \ + nonstatic_field(MethodData, _eflags, intx) \ + nonstatic_field(MethodData, _arg_local, intx) \ + nonstatic_field(MethodData, _arg_stack, intx) \ + nonstatic_field(MethodData, _arg_returned, intx) \ + nonstatic_field(MethodData, _tenure_traps, uint) \ + nonstatic_field(MethodData, _invoke_mask, int) \ + nonstatic_field(MethodData, _backedge_mask, int) \ + nonstatic_field(DataLayout, _header._struct._tag, u1) \ + nonstatic_field(DataLayout, _header._struct._flags, u1) \ + nonstatic_field(DataLayout, _header._struct._bci, u2) \ + nonstatic_field(DataLayout, _cells[0], intptr_t) \ + nonstatic_field(MethodCounters, _nmethod_age, int) \ + nonstatic_field(MethodCounters, _interpreter_invocation_limit, int) \ + nonstatic_field(MethodCounters, _interpreter_backward_branch_limit, int) \ + nonstatic_field(MethodCounters, _interpreter_profile_limit, int) \ + nonstatic_field(MethodCounters, _invoke_mask, int) \ + nonstatic_field(MethodCounters, _backedge_mask, int) \ + nonstatic_field(MethodCounters, _interpreter_invocation_count, int) \ + nonstatic_field(MethodCounters, _interpreter_throwout_count, u2) \ + nonstatic_field(MethodCounters, _number_of_breakpoints, u2) \ + nonstatic_field(MethodCounters, _invocation_counter, InvocationCounter) \ + nonstatic_field(MethodCounters, _backedge_counter, InvocationCounter) \ + nonstatic_field(Method, _constMethod, ConstMethod*) \ + nonstatic_field(Method, _method_data, MethodData*) \ + nonstatic_field(Method, _method_counters, MethodCounters*) \ + nonstatic_field(Method, _access_flags, AccessFlags) \ + nonstatic_field(Method, _vtable_index, int) \ + nonstatic_field(Method, _method_size, u2) \ + nonstatic_field(Method, _intrinsic_id, u1) \ + nonproduct_nonstatic_field(Method, _compiled_invocation_count, int) \ + volatile_nonstatic_field(Method, _code, nmethod*) \ + nonstatic_field(Method, _i2i_entry, address) \ + nonstatic_field(Method, _adapter, AdapterHandlerEntry*) \ + volatile_nonstatic_field(Method, _from_compiled_entry, address) \ + volatile_nonstatic_field(Method, _from_interpreted_entry, address) \ + volatile_nonstatic_field(ConstMethod, _fingerprint, uint64_t) \ + nonstatic_field(ConstMethod, _constants, ConstantPool*) \ + nonstatic_field(ConstMethod, _stackmap_data, Array<u1>*) \ + nonstatic_field(ConstMethod, _constMethod_size, int) \ + nonstatic_field(ConstMethod, _flags, u2) \ + nonstatic_field(ConstMethod, _code_size, u2) \ + nonstatic_field(ConstMethod, _name_index, u2) \ + nonstatic_field(ConstMethod, _signature_index, u2) \ + nonstatic_field(ConstMethod, _method_idnum, u2) \ + nonstatic_field(ConstMethod, _max_stack, u2) \ + nonstatic_field(ConstMethod, _max_locals, u2) \ + nonstatic_field(ConstMethod, _size_of_parameters, u2) \ nonstatic_field(ObjArrayKlass, _element_klass, Klass*) \ nonstatic_field(ObjArrayKlass, _bottom_klass, Klass*) \ volatile_nonstatic_field(Symbol, _refcount, short) \ - nonstatic_field(Symbol, _identity_hash, int) \ + nonstatic_field(Symbol, _identity_hash, short) \ nonstatic_field(Symbol, _length, unsigned short) \ unchecked_nonstatic_field(Symbol, _body, sizeof(jbyte)) /* NOTE: no type */ \ nonstatic_field(TypeArrayKlass, _max_length, int) \ @@ -415,10 +415,10 @@ /* Constant Pool Cache */ \ /***********************/ \ \ - volatile_nonstatic_field(ConstantPoolCacheEntry, _indices, intx) \ - nonstatic_field(ConstantPoolCacheEntry, _f1, volatile Metadata*) \ - volatile_nonstatic_field(ConstantPoolCacheEntry, _f2, intx) \ - volatile_nonstatic_field(ConstantPoolCacheEntry, _flags, intx) \ + volatile_nonstatic_field(ConstantPoolCacheEntry, _indices, intx) \ + nonstatic_field(ConstantPoolCacheEntry, _f1, volatile Metadata*) \ + volatile_nonstatic_field(ConstantPoolCacheEntry, _f2, intx) \ + volatile_nonstatic_field(ConstantPoolCacheEntry, _flags, intx) \ \ /********************************/ \ /* MethodOop-related structures */ \ @@ -632,83 +632,83 @@ /* SymbolTable */ \ /***************/ \ \ - static_field(SymbolTable, _the_table, SymbolTable*) \ - static_field(SymbolTable, _shared_table, SymbolCompactHashTable) \ + static_field(SymbolTable, _the_table, SymbolTable*) \ + static_field(SymbolTable, _shared_table, SymbolCompactHashTable) \ \ /***************/ \ /* StringTable */ \ /***************/ \ \ - static_field(StringTable, _the_table, StringTable*) \ + static_field(StringTable, _the_table, StringTable*) \ \ /********************/ \ /* CompactHashTable */ \ /********************/ \ \ - nonstatic_field(SymbolCompactHashTable, _base_address, uintx) \ - nonstatic_field(SymbolCompactHashTable, _entry_count, juint) \ - nonstatic_field(SymbolCompactHashTable, _bucket_count, juint) \ - nonstatic_field(SymbolCompactHashTable, _table_end_offset, juint) \ - nonstatic_field(SymbolCompactHashTable, _buckets, juint*) \ + nonstatic_field(SymbolCompactHashTable, _base_address, uintx) \ + nonstatic_field(SymbolCompactHashTable, _entry_count, juint) \ + nonstatic_field(SymbolCompactHashTable, _bucket_count, juint) \ + nonstatic_field(SymbolCompactHashTable, _table_end_offset, juint) \ + nonstatic_field(SymbolCompactHashTable, _buckets, juint*) \ \ /********************/ \ /* SystemDictionary */ \ /********************/ \ \ - static_field(SystemDictionary, _dictionary, Dictionary*) \ - static_field(SystemDictionary, _placeholders, PlaceholderTable*) \ - static_field(SystemDictionary, _shared_dictionary, Dictionary*) \ - static_field(SystemDictionary, _system_loader_lock_obj, oop) \ - static_field(SystemDictionary, _loader_constraints, LoaderConstraintTable*) \ - static_field(SystemDictionary, WK_KLASS(Object_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(String_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Class_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Cloneable_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ClassLoader_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Serializable_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(System_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Throwable_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ThreadDeath_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Error_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Exception_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(RuntimeException_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ClassNotFoundException_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(NoClassDefFoundError_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(LinkageError_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ClassCastException_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ArrayStoreException_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(VirtualMachineError_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(OutOfMemoryError_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(StackOverflowError_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ProtectionDomain_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(AccessControlContext_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(SecureClassLoader_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Reference_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(SoftReference_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(WeakReference_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(FinalReference_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(PhantomReference_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Cleaner_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Finalizer_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Thread_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(ThreadGroup_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(Properties_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(StringBuffer_klass), Klass*) \ - static_field(SystemDictionary, WK_KLASS(MethodHandle_klass), Klass*) \ - static_field(SystemDictionary, _box_klasses[0], Klass*) \ - static_field(SystemDictionary, _java_system_loader, oop) \ + static_field(SystemDictionary, _dictionary, Dictionary*) \ + static_field(SystemDictionary, _placeholders, PlaceholderTable*) \ + static_field(SystemDictionary, _shared_dictionary, Dictionary*) \ + static_field(SystemDictionary, _system_loader_lock_obj, oop) \ + static_field(SystemDictionary, _loader_constraints, LoaderConstraintTable*) \ + static_field(SystemDictionary, WK_KLASS(Object_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(String_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Class_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Cloneable_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ClassLoader_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Serializable_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(System_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Throwable_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ThreadDeath_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Error_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Exception_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(RuntimeException_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ClassNotFoundException_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(NoClassDefFoundError_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(LinkageError_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ClassCastException_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ArrayStoreException_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(VirtualMachineError_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(OutOfMemoryError_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(StackOverflowError_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ProtectionDomain_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(AccessControlContext_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(SecureClassLoader_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Reference_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(SoftReference_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(WeakReference_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(FinalReference_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(PhantomReference_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Cleaner_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Finalizer_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Thread_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(ThreadGroup_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(Properties_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(StringBuffer_klass), Klass*) \ + static_field(SystemDictionary, WK_KLASS(MethodHandle_klass), Klass*) \ + static_field(SystemDictionary, _box_klasses[0], Klass*) \ + static_field(SystemDictionary, _java_system_loader, oop) \ \ /*************/ \ /* vmSymbols */ \ /*************/ \ \ - static_field(vmSymbols, _symbols[0], Symbol*) \ + static_field(vmSymbols, _symbols[0], Symbol*) \ \ /*******************/ \ /* HashtableBucket */ \ /*******************/ \ \ - nonstatic_field(HashtableBucket<mtInternal>, _entry, BasicHashtableEntry<mtInternal>*) \ + nonstatic_field(HashtableBucket<mtInternal>, _entry, BasicHashtableEntry<mtInternal>*) \ \ /******************/ \ /* HashtableEntry */ \ @@ -722,12 +722,12 @@ /* Hashtable */ \ /*************/ \ \ - nonstatic_field(BasicHashtable<mtInternal>, _table_size, int) \ - nonstatic_field(BasicHashtable<mtInternal>, _buckets, HashtableBucket<mtInternal>*) \ - nonstatic_field(BasicHashtable<mtInternal>, _free_list, BasicHashtableEntry<mtInternal>*) \ - nonstatic_field(BasicHashtable<mtInternal>, _first_free_entry, char*) \ - nonstatic_field(BasicHashtable<mtInternal>, _end_block, char*) \ - nonstatic_field(BasicHashtable<mtInternal>, _entry_size, int) \ + nonstatic_field(BasicHashtable<mtInternal>, _table_size, int) \ + nonstatic_field(BasicHashtable<mtInternal>, _buckets, HashtableBucket<mtInternal>*) \ + nonstatic_field(BasicHashtable<mtInternal>, _free_list, BasicHashtableEntry<mtInternal>*) \ + nonstatic_field(BasicHashtable<mtInternal>, _first_free_entry, char*) \ + nonstatic_field(BasicHashtable<mtInternal>, _end_block, char*) \ + nonstatic_field(BasicHashtable<mtInternal>, _entry_size, int) \ \ /*******************/ \ /* DictionaryEntry */ \ @@ -765,7 +765,7 @@ nonstatic_field(ClassLoaderData, _class_loader, oop) \ nonstatic_field(ClassLoaderData, _next, ClassLoaderData*) \ \ - static_field(ClassLoaderDataGraph, _head, ClassLoaderData*) \ + static_field(ClassLoaderDataGraph, _head, ClassLoaderData*) \ \ /**********/ \ /* Arrays */ \ @@ -787,8 +787,8 @@ /* CodeCache (NOTE: incomplete) */ \ /********************************/ \ \ - static_field(CodeCache, _heaps, GrowableArray<CodeHeap*>*) \ - static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \ + static_field(CodeCache, _heaps, GrowableArray<CodeHeap*>*) \ + static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \ \ /*******************************/ \ /* CodeHeap (NOTE: incomplete) */ \ @@ -874,37 +874,37 @@ /* NMethods (NOTE: incomplete, but only a little) */ \ /**************************************************/ \ \ - nonstatic_field(nmethod, _method, Method*) \ - nonstatic_field(nmethod, _entry_bci, int) \ - nonstatic_field(nmethod, _osr_link, nmethod*) \ - nonstatic_field(nmethod, _scavenge_root_link, nmethod*) \ - nonstatic_field(nmethod, _scavenge_root_state, jbyte) \ - nonstatic_field(nmethod, _state, volatile unsigned char) \ - nonstatic_field(nmethod, _exception_offset, int) \ - nonstatic_field(nmethod, _deoptimize_offset, int) \ - nonstatic_field(nmethod, _deoptimize_mh_offset, int) \ - nonstatic_field(nmethod, _orig_pc_offset, int) \ - nonstatic_field(nmethod, _stub_offset, int) \ - nonstatic_field(nmethod, _consts_offset, int) \ - nonstatic_field(nmethod, _oops_offset, int) \ - nonstatic_field(nmethod, _metadata_offset, int) \ - nonstatic_field(nmethod, _scopes_data_offset, int) \ - nonstatic_field(nmethod, _scopes_pcs_offset, int) \ - nonstatic_field(nmethod, _dependencies_offset, int) \ - nonstatic_field(nmethod, _handler_table_offset, int) \ - nonstatic_field(nmethod, _nul_chk_table_offset, int) \ - nonstatic_field(nmethod, _nmethod_end_offset, int) \ - nonstatic_field(nmethod, _entry_point, address) \ - nonstatic_field(nmethod, _verified_entry_point, address) \ - nonstatic_field(nmethod, _osr_entry_point, address) \ - volatile_nonstatic_field(nmethod, _lock_count, jint) \ - nonstatic_field(nmethod, _stack_traversal_mark, long) \ - nonstatic_field(nmethod, _compile_id, int) \ - nonstatic_field(nmethod, _comp_level, int) \ - nonstatic_field(nmethod, _exception_cache, ExceptionCache*) \ - nonstatic_field(nmethod, _marked_for_deoptimization, bool) \ - \ - unchecked_c2_static_field(Deoptimization, _trap_reason_name, void*) \ + nonstatic_field(nmethod, _method, Method*) \ + nonstatic_field(nmethod, _entry_bci, int) \ + nonstatic_field(nmethod, _osr_link, nmethod*) \ + nonstatic_field(nmethod, _scavenge_root_link, nmethod*) \ + nonstatic_field(nmethod, _scavenge_root_state, jbyte) \ + nonstatic_field(nmethod, _state, volatile unsigned char) \ + nonstatic_field(nmethod, _exception_offset, int) \ + nonstatic_field(nmethod, _deoptimize_offset, int) \ + nonstatic_field(nmethod, _deoptimize_mh_offset, int) \ + nonstatic_field(nmethod, _orig_pc_offset, int) \ + nonstatic_field(nmethod, _stub_offset, int) \ + nonstatic_field(nmethod, _consts_offset, int) \ + nonstatic_field(nmethod, _oops_offset, int) \ + nonstatic_field(nmethod, _metadata_offset, int) \ + nonstatic_field(nmethod, _scopes_data_offset, int) \ + nonstatic_field(nmethod, _scopes_pcs_offset, int) \ + nonstatic_field(nmethod, _dependencies_offset, int) \ + nonstatic_field(nmethod, _handler_table_offset, int) \ + nonstatic_field(nmethod, _nul_chk_table_offset, int) \ + nonstatic_field(nmethod, _nmethod_end_offset, int) \ + nonstatic_field(nmethod, _entry_point, address) \ + nonstatic_field(nmethod, _verified_entry_point, address) \ + nonstatic_field(nmethod, _osr_entry_point, address) \ + volatile_nonstatic_field(nmethod, _lock_count, jint) \ + nonstatic_field(nmethod, _stack_traversal_mark, long) \ + nonstatic_field(nmethod, _compile_id, int) \ + nonstatic_field(nmethod, _comp_level, int) \ + nonstatic_field(nmethod, _exception_cache, ExceptionCache*) \ + nonstatic_field(nmethod, _marked_for_deoptimization, bool) \ + \ + unchecked_c2_static_field(Deoptimization, _trap_reason_name, void*) \ \ /********************************/ \ /* JavaCalls (NOTE: incomplete) */ \ @@ -929,7 +929,7 @@ nonstatic_field(ThreadShadow, _pending_exception, oop) \ nonstatic_field(ThreadShadow, _exception_file, const char*) \ nonstatic_field(ThreadShadow, _exception_line, int) \ - volatile_nonstatic_field(Thread, _suspend_flags, uint32_t) \ + volatile_nonstatic_field(Thread, _suspend_flags, uint32_t) \ nonstatic_field(Thread, _active_handles, JNIHandleBlock*) \ nonstatic_field(Thread, _tlab, ThreadLocalAllocBuffer) \ nonstatic_field(Thread, _allocated_bytes, jlong) \ @@ -949,7 +949,7 @@ volatile_nonstatic_field(JavaThread, _is_method_handle_return, int) \ nonstatic_field(JavaThread, _special_runtime_exit_condition, JavaThread::AsyncRequests) \ nonstatic_field(JavaThread, _saved_exception_pc, address) \ - volatile_nonstatic_field(JavaThread, _thread_state, JavaThreadState) \ + volatile_nonstatic_field(JavaThread, _thread_state, JavaThreadState) \ nonstatic_field(JavaThread, _osthread, OSThread*) \ nonstatic_field(JavaThread, _stack_base, address) \ nonstatic_field(JavaThread, _stack_size, size_t) \ @@ -992,7 +992,7 @@ static_field(JNIHandles, _weak_global_handles, JNIHandleBlock*) \ static_field(JNIHandles, _deleted_handle, oop) \ \ - unchecked_nonstatic_field(JNIHandleBlock, _handles, JNIHandleBlock::block_size_in_oops * sizeof(Oop)) /* Note: no type */ \ + unchecked_nonstatic_field(JNIHandleBlock, _handles, JNIHandleBlock::block_size_in_oops * sizeof(Oop)) /* Note: no type */ \ nonstatic_field(JNIHandleBlock, _top, int) \ nonstatic_field(JNIHandleBlock, _next, JNIHandleBlock*) \ \ @@ -1020,80 +1020,80 @@ /* allocation */ \ /**************/ \ \ - nonstatic_field(Chunk, _next, Chunk*) \ - nonstatic_field(Chunk, _len, const size_t) \ + nonstatic_field(Chunk, _next, Chunk*) \ + nonstatic_field(Chunk, _len, const size_t) \ \ - nonstatic_field(Arena, _first, Chunk*) \ - nonstatic_field(Arena, _chunk, Chunk*) \ - nonstatic_field(Arena, _hwm, char*) \ - nonstatic_field(Arena, _max, char*) \ + nonstatic_field(Arena, _first, Chunk*) \ + nonstatic_field(Arena, _chunk, Chunk*) \ + nonstatic_field(Arena, _hwm, char*) \ + nonstatic_field(Arena, _max, char*) \ \ /************/ \ /* CI */ \ /************/ \ \ - nonstatic_field(ciEnv, _system_dictionary_modification_counter, int) \ - nonstatic_field(ciEnv, _compiler_data, void*) \ - nonstatic_field(ciEnv, _failure_reason, const char*) \ - nonstatic_field(ciEnv, _factory, ciObjectFactory*) \ - nonstatic_field(ciEnv, _dependencies, Dependencies*) \ - nonstatic_field(ciEnv, _task, CompileTask*) \ - nonstatic_field(ciEnv, _arena, Arena*) \ + nonstatic_field(ciEnv, _system_dictionary_modification_counter, int) \ + nonstatic_field(ciEnv, _compiler_data, void*) \ + nonstatic_field(ciEnv, _failure_reason, const char*) \ + nonstatic_field(ciEnv, _factory, ciObjectFactory*) \ + nonstatic_field(ciEnv, _dependencies, Dependencies*) \ + nonstatic_field(ciEnv, _task, CompileTask*) \ + nonstatic_field(ciEnv, _arena, Arena*) \ \ - nonstatic_field(ciBaseObject, _ident, uint) \ + nonstatic_field(ciBaseObject, _ident, uint) \ \ - nonstatic_field(ciObject, _handle, jobject) \ - nonstatic_field(ciObject, _klass, ciKlass*) \ + nonstatic_field(ciObject, _handle, jobject) \ + nonstatic_field(ciObject, _klass, ciKlass*) \ \ - nonstatic_field(ciMetadata, _metadata, Metadata*) \ + nonstatic_field(ciMetadata, _metadata, Metadata*) \ \ - nonstatic_field(ciSymbol, _symbol, Symbol*) \ + nonstatic_field(ciSymbol, _symbol, Symbol*) \ \ - nonstatic_field(ciType, _basic_type, BasicType) \ + nonstatic_field(ciType, _basic_type, BasicType) \ \ - nonstatic_field(ciKlass, _name, ciSymbol*) \ + nonstatic_field(ciKlass, _name, ciSymbol*) \ \ - nonstatic_field(ciArrayKlass, _dimension, jint) \ + nonstatic_field(ciArrayKlass, _dimension, jint) \ \ - nonstatic_field(ciObjArrayKlass, _element_klass, ciKlass*) \ - nonstatic_field(ciObjArrayKlass, _base_element_klass, ciKlass*) \ + nonstatic_field(ciObjArrayKlass, _element_klass, ciKlass*) \ + nonstatic_field(ciObjArrayKlass, _base_element_klass, ciKlass*) \ \ - nonstatic_field(ciInstanceKlass, _init_state, InstanceKlass::ClassState) \ - nonstatic_field(ciInstanceKlass, _is_shared, bool) \ + nonstatic_field(ciInstanceKlass, _init_state, InstanceKlass::ClassState) \ + nonstatic_field(ciInstanceKlass, _is_shared, bool) \ \ - nonstatic_field(ciMethod, _interpreter_invocation_count, int) \ - nonstatic_field(ciMethod, _interpreter_throwout_count, int) \ - nonstatic_field(ciMethod, _instructions_size, int) \ + nonstatic_field(ciMethod, _interpreter_invocation_count, int) \ + nonstatic_field(ciMethod, _interpreter_throwout_count, int) \ + nonstatic_field(ciMethod, _instructions_size, int) \ \ - nonstatic_field(ciMethodData, _data_size, int) \ - nonstatic_field(ciMethodData, _state, u_char) \ - nonstatic_field(ciMethodData, _extra_data_size, int) \ - nonstatic_field(ciMethodData, _data, intptr_t*) \ - nonstatic_field(ciMethodData, _hint_di, int) \ - nonstatic_field(ciMethodData, _eflags, intx) \ - nonstatic_field(ciMethodData, _arg_local, intx) \ - nonstatic_field(ciMethodData, _arg_stack, intx) \ - nonstatic_field(ciMethodData, _arg_returned, intx) \ - nonstatic_field(ciMethodData, _current_mileage, int) \ - nonstatic_field(ciMethodData, _orig, MethodData) \ + nonstatic_field(ciMethodData, _data_size, int) \ + nonstatic_field(ciMethodData, _state, u_char) \ + nonstatic_field(ciMethodData, _extra_data_size, int) \ + nonstatic_field(ciMethodData, _data, intptr_t*) \ + nonstatic_field(ciMethodData, _hint_di, int) \ + nonstatic_field(ciMethodData, _eflags, intx) \ + nonstatic_field(ciMethodData, _arg_local, intx) \ + nonstatic_field(ciMethodData, _arg_stack, intx) \ + nonstatic_field(ciMethodData, _arg_returned, intx) \ + nonstatic_field(ciMethodData, _current_mileage, int) \ + nonstatic_field(ciMethodData, _orig, MethodData) \ \ - nonstatic_field(ciField, _holder, ciInstanceKlass*) \ - nonstatic_field(ciField, _name, ciSymbol*) \ - nonstatic_field(ciField, _signature, ciSymbol*) \ - nonstatic_field(ciField, _offset, int) \ - nonstatic_field(ciField, _is_constant, bool) \ - nonstatic_field(ciField, _constant_value, ciConstant) \ + nonstatic_field(ciField, _holder, ciInstanceKlass*) \ + nonstatic_field(ciField, _name, ciSymbol*) \ + nonstatic_field(ciField, _signature, ciSymbol*) \ + nonstatic_field(ciField, _offset, int) \ + nonstatic_field(ciField, _is_constant, bool) \ + nonstatic_field(ciField, _constant_value, ciConstant) \ \ - nonstatic_field(ciObjectFactory, _ci_metadata, GrowableArray<ciMetadata*>*) \ - nonstatic_field(ciObjectFactory, _symbols, GrowableArray<ciSymbol*>*) \ - nonstatic_field(ciObjectFactory, _unloaded_methods, GrowableArray<ciMethod*>*) \ + nonstatic_field(ciObjectFactory, _ci_metadata, GrowableArray<ciMetadata*>*) \ + nonstatic_field(ciObjectFactory, _symbols, GrowableArray<ciSymbol*>*) \ + nonstatic_field(ciObjectFactory, _unloaded_methods, GrowableArray<ciMethod*>*) \ \ - nonstatic_field(ciConstant, _type, BasicType) \ - nonstatic_field(ciConstant, _value._int, jint) \ - nonstatic_field(ciConstant, _value._long, jlong) \ - nonstatic_field(ciConstant, _value._float, jfloat) \ - nonstatic_field(ciConstant, _value._double, jdouble) \ - nonstatic_field(ciConstant, _value._object, ciObject*) \ + nonstatic_field(ciConstant, _type, BasicType) \ + nonstatic_field(ciConstant, _value._int, jint) \ + nonstatic_field(ciConstant, _value._long, jlong) \ + nonstatic_field(ciConstant, _value._float, jfloat) \ + nonstatic_field(ciConstant, _value._double, jdouble) \ + nonstatic_field(ciConstant, _value._object, ciObject*) \ \ /************/ \ /* Monitors */ \ @@ -1109,7 +1109,7 @@ volatile_nonstatic_field(BasicLock, _displaced_header, markOop) \ nonstatic_field(BasicObjectLock, _lock, BasicLock) \ nonstatic_field(BasicObjectLock, _obj, oop) \ - static_field(ObjectSynchronizer, gBlockList, ObjectMonitor*) \ + static_field(ObjectSynchronizer, gBlockList, ObjectMonitor*) \ \ /*********************/ \ /* Matcher (C2 only) */ \ @@ -1117,111 +1117,111 @@ \ unchecked_c2_static_field(Matcher, _regEncode, sizeof(Matcher::_regEncode)) /* NOTE: no type */ \ \ - c2_nonstatic_field(Node, _in, Node**) \ - c2_nonstatic_field(Node, _out, Node**) \ - c2_nonstatic_field(Node, _cnt, node_idx_t) \ - c2_nonstatic_field(Node, _max, node_idx_t) \ - c2_nonstatic_field(Node, _outcnt, node_idx_t) \ - c2_nonstatic_field(Node, _outmax, node_idx_t) \ - c2_nonstatic_field(Node, _idx, const node_idx_t) \ - c2_nonstatic_field(Node, _class_id, jushort) \ - c2_nonstatic_field(Node, _flags, jushort) \ + c2_nonstatic_field(Node, _in, Node**) \ + c2_nonstatic_field(Node, _out, Node**) \ + c2_nonstatic_field(Node, _cnt, node_idx_t) \ + c2_nonstatic_field(Node, _max, node_idx_t) \ + c2_nonstatic_field(Node, _outcnt, node_idx_t) \ + c2_nonstatic_field(Node, _outmax, node_idx_t) \ + c2_nonstatic_field(Node, _idx, const node_idx_t) \ + c2_nonstatic_field(Node, _class_id, jushort) \ + c2_nonstatic_field(Node, _flags, jushort) \ \ - c2_nonstatic_field(Compile, _root, RootNode*) \ - c2_nonstatic_field(Compile, _unique, uint) \ - c2_nonstatic_field(Compile, _entry_bci, int) \ - c2_nonstatic_field(Compile, _top, Node*) \ - c2_nonstatic_field(Compile, _cfg, PhaseCFG*) \ - c2_nonstatic_field(Compile, _regalloc, PhaseRegAlloc*) \ - c2_nonstatic_field(Compile, _method, ciMethod*) \ - c2_nonstatic_field(Compile, _compile_id, const int) \ - c2_nonstatic_field(Compile, _save_argument_registers, const bool) \ - c2_nonstatic_field(Compile, _subsume_loads, const bool) \ - c2_nonstatic_field(Compile, _do_escape_analysis, const bool) \ - c2_nonstatic_field(Compile, _eliminate_boxing, const bool) \ - c2_nonstatic_field(Compile, _ilt, InlineTree*) \ + c2_nonstatic_field(Compile, _root, RootNode*) \ + c2_nonstatic_field(Compile, _unique, uint) \ + c2_nonstatic_field(Compile, _entry_bci, int) \ + c2_nonstatic_field(Compile, _top, Node*) \ + c2_nonstatic_field(Compile, _cfg, PhaseCFG*) \ + c2_nonstatic_field(Compile, _regalloc, PhaseRegAlloc*) \ + c2_nonstatic_field(Compile, _method, ciMethod*) \ + c2_nonstatic_field(Compile, _compile_id, const int) \ + c2_nonstatic_field(Compile, _save_argument_registers, const bool) \ + c2_nonstatic_field(Compile, _subsume_loads, const bool) \ + c2_nonstatic_field(Compile, _do_escape_analysis, const bool) \ + c2_nonstatic_field(Compile, _eliminate_boxing, const bool) \ + c2_nonstatic_field(Compile, _ilt, InlineTree*) \ \ - c2_nonstatic_field(InlineTree, _caller_jvms, JVMState*) \ - c2_nonstatic_field(InlineTree, _method, ciMethod*) \ - c2_nonstatic_field(InlineTree, _caller_tree, InlineTree*) \ - c2_nonstatic_field(InlineTree, _subtrees, GrowableArray<InlineTree*>) \ + c2_nonstatic_field(InlineTree, _caller_jvms, JVMState*) \ + c2_nonstatic_field(InlineTree, _method, ciMethod*) \ + c2_nonstatic_field(InlineTree, _caller_tree, InlineTree*) \ + c2_nonstatic_field(InlineTree, _subtrees, GrowableArray<InlineTree*>) \ \ - c2_nonstatic_field(OptoRegPair, _first, short) \ - c2_nonstatic_field(OptoRegPair, _second, short) \ + c2_nonstatic_field(OptoRegPair, _first, short) \ + c2_nonstatic_field(OptoRegPair, _second, short) \ \ - c2_nonstatic_field(JVMState, _caller, JVMState*) \ - c2_nonstatic_field(JVMState, _depth, uint) \ - c2_nonstatic_field(JVMState, _locoff, uint) \ - c2_nonstatic_field(JVMState, _stkoff, uint) \ - c2_nonstatic_field(JVMState, _monoff, uint) \ - c2_nonstatic_field(JVMState, _scloff, uint) \ - c2_nonstatic_field(JVMState, _endoff, uint) \ - c2_nonstatic_field(JVMState, _sp, uint) \ - c2_nonstatic_field(JVMState, _bci, int) \ - c2_nonstatic_field(JVMState, _method, ciMethod*) \ - c2_nonstatic_field(JVMState, _map, SafePointNode*) \ + c2_nonstatic_field(JVMState, _caller, JVMState*) \ + c2_nonstatic_field(JVMState, _depth, uint) \ + c2_nonstatic_field(JVMState, _locoff, uint) \ + c2_nonstatic_field(JVMState, _stkoff, uint) \ + c2_nonstatic_field(JVMState, _monoff, uint) \ + c2_nonstatic_field(JVMState, _scloff, uint) \ + c2_nonstatic_field(JVMState, _endoff, uint) \ + c2_nonstatic_field(JVMState, _sp, uint) \ + c2_nonstatic_field(JVMState, _bci, int) \ + c2_nonstatic_field(JVMState, _method, ciMethod*) \ + c2_nonstatic_field(JVMState, _map, SafePointNode*) \ \ - c2_nonstatic_field(SafePointNode, _jvms, JVMState* const) \ + c2_nonstatic_field(SafePointNode, _jvms, JVMState* const) \ \ - c2_nonstatic_field(MachSafePointNode, _jvms, JVMState*) \ - c2_nonstatic_field(MachSafePointNode, _jvmadj, uint) \ + c2_nonstatic_field(MachSafePointNode, _jvms, JVMState*) \ + c2_nonstatic_field(MachSafePointNode, _jvmadj, uint) \ \ - c2_nonstatic_field(MachIfNode, _prob, jfloat) \ - c2_nonstatic_field(MachIfNode, _fcnt, jfloat) \ + c2_nonstatic_field(MachIfNode, _prob, jfloat) \ + c2_nonstatic_field(MachIfNode, _fcnt, jfloat) \ \ - c2_nonstatic_field(CallNode, _entry_point, address) \ + c2_nonstatic_field(CallNode, _entry_point, address) \ \ - c2_nonstatic_field(CallJavaNode, _method, ciMethod*) \ + c2_nonstatic_field(CallJavaNode, _method, ciMethod*) \ \ - c2_nonstatic_field(CallRuntimeNode, _name, const char*) \ + c2_nonstatic_field(CallRuntimeNode, _name, const char*) \ \ - c2_nonstatic_field(CallStaticJavaNode, _name, const char*) \ + c2_nonstatic_field(CallStaticJavaNode, _name, const char*) \ \ - c2_nonstatic_field(MachCallJavaNode, _method, ciMethod*) \ - c2_nonstatic_field(MachCallJavaNode, _bci, int) \ + c2_nonstatic_field(MachCallJavaNode, _method, ciMethod*) \ + c2_nonstatic_field(MachCallJavaNode, _bci, int) \ \ - c2_nonstatic_field(MachCallStaticJavaNode, _name, const char*) \ + c2_nonstatic_field(MachCallStaticJavaNode, _name, const char*) \ \ - c2_nonstatic_field(MachCallRuntimeNode, _name, const char*) \ + c2_nonstatic_field(MachCallRuntimeNode, _name, const char*) \ \ - c2_nonstatic_field(PhaseCFG, _number_of_blocks, uint) \ - c2_nonstatic_field(PhaseCFG, _blocks, Block_List) \ - c2_nonstatic_field(PhaseCFG, _node_to_block_mapping, Block_Array) \ - c2_nonstatic_field(PhaseCFG, _root_block, Block*) \ + c2_nonstatic_field(PhaseCFG, _number_of_blocks, uint) \ + c2_nonstatic_field(PhaseCFG, _blocks, Block_List) \ + c2_nonstatic_field(PhaseCFG, _node_to_block_mapping, Block_Array) \ + c2_nonstatic_field(PhaseCFG, _root_block, Block*) \ \ - c2_nonstatic_field(PhaseRegAlloc, _node_regs, OptoRegPair*) \ - c2_nonstatic_field(PhaseRegAlloc, _node_regs_max_index, uint) \ - c2_nonstatic_field(PhaseRegAlloc, _framesize, uint) \ - c2_nonstatic_field(PhaseRegAlloc, _max_reg, OptoReg::Name) \ + c2_nonstatic_field(PhaseRegAlloc, _node_regs, OptoRegPair*) \ + c2_nonstatic_field(PhaseRegAlloc, _node_regs_max_index, uint) \ + c2_nonstatic_field(PhaseRegAlloc, _framesize, uint) \ + c2_nonstatic_field(PhaseRegAlloc, _max_reg, OptoReg::Name) \ \ - c2_nonstatic_field(PhaseChaitin, _trip_cnt, int) \ - c2_nonstatic_field(PhaseChaitin, _alternate, int) \ - c2_nonstatic_field(PhaseChaitin, _lo_degree, uint) \ - c2_nonstatic_field(PhaseChaitin, _lo_stk_degree, uint) \ - c2_nonstatic_field(PhaseChaitin, _hi_degree, uint) \ - c2_nonstatic_field(PhaseChaitin, _simplified, uint) \ + c2_nonstatic_field(PhaseChaitin, _trip_cnt, int) \ + c2_nonstatic_field(PhaseChaitin, _alternate, int) \ + c2_nonstatic_field(PhaseChaitin, _lo_degree, uint) \ + c2_nonstatic_field(PhaseChaitin, _lo_stk_degree, uint) \ + c2_nonstatic_field(PhaseChaitin, _hi_degree, uint) \ + c2_nonstatic_field(PhaseChaitin, _simplified, uint) \ \ - c2_nonstatic_field(Block, _nodes, Node_List) \ - c2_nonstatic_field(Block, _succs, Block_Array) \ - c2_nonstatic_field(Block, _num_succs, uint) \ - c2_nonstatic_field(Block, _pre_order, uint) \ - c2_nonstatic_field(Block, _dom_depth, uint) \ - c2_nonstatic_field(Block, _idom, Block*) \ - c2_nonstatic_field(Block, _freq, jdouble) \ + c2_nonstatic_field(Block, _nodes, Node_List) \ + c2_nonstatic_field(Block, _succs, Block_Array) \ + c2_nonstatic_field(Block, _num_succs, uint) \ + c2_nonstatic_field(Block, _pre_order, uint) \ + c2_nonstatic_field(Block, _dom_depth, uint) \ + c2_nonstatic_field(Block, _idom, Block*) \ + c2_nonstatic_field(Block, _freq, jdouble) \ \ - c2_nonstatic_field(CFGElement, _freq, jdouble) \ + c2_nonstatic_field(CFGElement, _freq, jdouble) \ \ - c2_nonstatic_field(Block_List, _cnt, uint) \ + c2_nonstatic_field(Block_List, _cnt, uint) \ \ - c2_nonstatic_field(Block_Array, _size, uint) \ - c2_nonstatic_field(Block_Array, _blocks, Block**) \ - c2_nonstatic_field(Block_Array, _arena, Arena*) \ + c2_nonstatic_field(Block_Array, _size, uint) \ + c2_nonstatic_field(Block_Array, _blocks, Block**) \ + c2_nonstatic_field(Block_Array, _arena, Arena*) \ \ - c2_nonstatic_field(Node_List, _cnt, uint) \ + c2_nonstatic_field(Node_List, _cnt, uint) \ \ - c2_nonstatic_field(Node_Array, _max, uint) \ - c2_nonstatic_field(Node_Array, _nodes, Node**) \ - c2_nonstatic_field(Node_Array, _a, Arena*) \ + c2_nonstatic_field(Node_Array, _max, uint) \ + c2_nonstatic_field(Node_Array, _nodes, Node**) \ + c2_nonstatic_field(Node_Array, _a, Arena*) \ \ \ /*********************/ \ @@ -1232,22 +1232,22 @@ nonstatic_field(Flag, _name, const char*) \ unchecked_nonstatic_field(Flag, _addr, sizeof(void*)) /* NOTE: no type */ \ nonstatic_field(Flag, _flags, Flag::Flags) \ - static_field(Flag, flags, Flag*) \ - static_field(Flag, numFlags, size_t) \ + static_field(Flag, flags, Flag*) \ + static_field(Flag, numFlags, size_t) \ \ /*************************/ \ /* JDK / VM version info */ \ /*************************/ \ \ - static_field(Abstract_VM_Version, _s_vm_release, const char*) \ - static_field(Abstract_VM_Version, _s_internal_vm_info_string, const char*) \ - static_field(Abstract_VM_Version, _vm_major_version, int) \ - static_field(Abstract_VM_Version, _vm_minor_version, int) \ - static_field(Abstract_VM_Version, _vm_micro_version, int) \ - static_field(Abstract_VM_Version, _vm_build_number, int) \ - static_field(Abstract_VM_Version, _reserve_for_allocation_prefetch, int) \ + static_field(Abstract_VM_Version, _s_vm_release, const char*) \ + static_field(Abstract_VM_Version, _s_internal_vm_info_string, const char*) \ + static_field(Abstract_VM_Version, _vm_major_version, int) \ + static_field(Abstract_VM_Version, _vm_minor_version, int) \ + static_field(Abstract_VM_Version, _vm_micro_version, int) \ + static_field(Abstract_VM_Version, _vm_build_number, int) \ + static_field(Abstract_VM_Version, _reserve_for_allocation_prefetch, int) \ \ - static_field(JDK_Version, _current, JDK_Version) \ + static_field(JDK_Version, _current, JDK_Version) \ nonstatic_field(JDK_Version, _partially_initialized, bool) \ nonstatic_field(JDK_Version, _major, unsigned char) \ \ @@ -1261,65 +1261,65 @@ /* Arguments */ \ /*************/ \ \ - static_field(Arguments, _jvm_flags_array, char**) \ - static_field(Arguments, _num_jvm_flags, int) \ - static_field(Arguments, _jvm_args_array, char**) \ - static_field(Arguments, _num_jvm_args, int) \ - static_field(Arguments, _java_command, char*) \ + static_field(Arguments, _jvm_flags_array, char**) \ + static_field(Arguments, _num_jvm_flags, int) \ + static_field(Arguments, _jvm_args_array, char**) \ + static_field(Arguments, _num_jvm_args, int) \ + static_field(Arguments, _java_command, char*) \ \ /************/ \ /* Array<T> */ \ /************/ \ \ - nonstatic_field(Array<int>, _length, int) \ - unchecked_nonstatic_field(Array<int>, _data, sizeof(int)) \ - unchecked_nonstatic_field(Array<u1>, _data, sizeof(u1)) \ - unchecked_nonstatic_field(Array<u2>, _data, sizeof(u2)) \ - unchecked_nonstatic_field(Array<Method*>, _data, sizeof(Method*)) \ - unchecked_nonstatic_field(Array<Klass*>, _data, sizeof(Klass*)) \ + nonstatic_field(Array<int>, _length, int) \ + unchecked_nonstatic_field(Array<int>, _data, sizeof(int)) \ + unchecked_nonstatic_field(Array<u1>, _data, sizeof(u1)) \ + unchecked_nonstatic_field(Array<u2>, _data, sizeof(u2)) \ + unchecked_nonstatic_field(Array<Method*>, _data, sizeof(Method*)) \ + unchecked_nonstatic_field(Array<Klass*>, _data, sizeof(Klass*)) \ \ /*********************************/ \ /* java_lang_Class fields */ \ /*********************************/ \ \ - static_field(java_lang_Class, _klass_offset, int) \ - static_field(java_lang_Class, _array_klass_offset, int) \ - static_field(java_lang_Class, _oop_size_offset, int) \ - static_field(java_lang_Class, _static_oop_field_count_offset, int) \ + static_field(java_lang_Class, _klass_offset, int) \ + static_field(java_lang_Class, _array_klass_offset, int) \ + static_field(java_lang_Class, _oop_size_offset, int) \ + static_field(java_lang_Class, _static_oop_field_count_offset, int) \ \ /************************/ \ /* Miscellaneous fields */ \ /************************/ \ \ - nonstatic_field(CompileTask, _method, Method*) \ - nonstatic_field(CompileTask, _osr_bci, int) \ - nonstatic_field(CompileTask, _comp_level, int) \ - nonstatic_field(CompileTask, _compile_id, uint) \ - nonstatic_field(CompileTask, _next, CompileTask*) \ - nonstatic_field(CompileTask, _prev, CompileTask*) \ + nonstatic_field(CompileTask, _method, Method*) \ + nonstatic_field(CompileTask, _osr_bci, int) \ + nonstatic_field(CompileTask, _comp_level, int) \ + nonstatic_field(CompileTask, _compile_id, uint) \ + nonstatic_field(CompileTask, _next, CompileTask*) \ + nonstatic_field(CompileTask, _prev, CompileTask*) \ \ - nonstatic_field(vframeArray, _next, vframeArray*) \ - nonstatic_field(vframeArray, _original, frame) \ - nonstatic_field(vframeArray, _caller, frame) \ - nonstatic_field(vframeArray, _frames, int) \ + nonstatic_field(vframeArray, _next, vframeArray*) \ + nonstatic_field(vframeArray, _original, frame) \ + nonstatic_field(vframeArray, _caller, frame) \ + nonstatic_field(vframeArray, _frames, int) \ \ - nonstatic_field(vframeArrayElement, _frame, frame) \ - nonstatic_field(vframeArrayElement, _bci, int) \ - nonstatic_field(vframeArrayElement, _method, Method*) \ + nonstatic_field(vframeArrayElement, _frame, frame) \ + nonstatic_field(vframeArrayElement, _bci, int) \ + nonstatic_field(vframeArrayElement, _method, Method*) \ \ - nonstatic_field(PtrQueue, _active, bool) \ - nonstatic_field(PtrQueue, _buf, void**) \ - nonstatic_field(PtrQueue, _index, size_t) \ + nonstatic_field(PtrQueue, _active, bool) \ + nonstatic_field(PtrQueue, _buf, void**) \ + nonstatic_field(PtrQueue, _index, size_t) \ \ - nonstatic_field(AccessFlags, _flags, jint) \ - nonstatic_field(elapsedTimer, _counter, jlong) \ - nonstatic_field(elapsedTimer, _active, bool) \ - nonstatic_field(InvocationCounter, _counter, unsigned int) \ - volatile_nonstatic_field(FreeChunk, _size, size_t) \ - nonstatic_field(FreeChunk, _next, FreeChunk*) \ - nonstatic_field(FreeChunk, _prev, FreeChunk*) \ - nonstatic_field(AdaptiveFreeList<FreeChunk>, _size, size_t) \ - nonstatic_field(AdaptiveFreeList<FreeChunk>, _count, ssize_t) + nonstatic_field(AccessFlags, _flags, jint) \ + nonstatic_field(elapsedTimer, _counter, jlong) \ + nonstatic_field(elapsedTimer, _active, bool) \ + nonstatic_field(InvocationCounter, _counter, unsigned int) \ + volatile_nonstatic_field(FreeChunk, _size, size_t) \ + nonstatic_field(FreeChunk, _next, FreeChunk*) \ + nonstatic_field(FreeChunk, _prev, FreeChunk*) \ + nonstatic_field(AdaptiveFreeList<FreeChunk>, _size, size_t) \ + nonstatic_field(AdaptiveFreeList<FreeChunk>, _count, ssize_t) //-------------------------------------------------------------------------------- @@ -1566,6 +1566,7 @@ declare_toplevel_type(Generation*) \ declare_toplevel_type(GenerationSpec**) \ declare_toplevel_type(HeapWord*) \ + declare_toplevel_type(HeapWord* volatile) \ declare_toplevel_type(MemRegion*) \ declare_toplevel_type(OffsetTableContigSpace*) \ declare_toplevel_type(Space*) \ @@ -2256,6 +2257,7 @@ \ declare_constant(BarrierSet::ModRef) \ declare_constant(BarrierSet::CardTableModRef) \ + declare_constant(BarrierSet::CardTableForRS) \ declare_constant(BarrierSet::CardTableExtension) \ declare_constant(BarrierSet::G1SATBCT) \ declare_constant(BarrierSet::G1SATBCTLogging) \
--- a/src/share/vm/runtime/vm_operations.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/runtime/vm_operations.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -109,8 +109,8 @@ // Deoptimize all activations depending on marked nmethods Deoptimization::deoptimize_dependents(); - // Make the dependent methods zombies - CodeCache::make_marked_nmethods_zombies(); + // Make the dependent methods not entrant + CodeCache::make_marked_nmethods_not_entrant(); } void VM_MarkActiveNMethods::doit() {
--- a/src/share/vm/services/memoryPool.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/memoryPool.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -204,21 +204,21 @@ return MemoryUsage(initial_size(), used, committed, maxSize); } -SurvivorContiguousSpacePool::SurvivorContiguousSpacePool(DefNewGeneration* gen, +SurvivorContiguousSpacePool::SurvivorContiguousSpacePool(DefNewGeneration* young_gen, const char* name, PoolType type, size_t max_size, bool support_usage_threshold) : - CollectedMemoryPool(name, type, gen->from()->capacity(), max_size, - support_usage_threshold), _gen(gen) { + CollectedMemoryPool(name, type, young_gen->from()->capacity(), max_size, + support_usage_threshold), _young_gen(young_gen) { } size_t SurvivorContiguousSpacePool::used_in_bytes() { - return _gen->from()->used(); + return _young_gen->from()->used(); } size_t SurvivorContiguousSpacePool::committed_in_bytes() { - return _gen->from()->capacity(); + return _young_gen->from()->capacity(); } MemoryUsage SurvivorContiguousSpacePool::get_memory_usage() {
--- a/src/share/vm/services/memoryPool.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/memoryPool.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -163,10 +163,10 @@ class SurvivorContiguousSpacePool : public CollectedMemoryPool { private: - DefNewGeneration* _gen; + DefNewGeneration* _young_gen; public: - SurvivorContiguousSpacePool(DefNewGeneration* gen, + SurvivorContiguousSpacePool(DefNewGeneration* young_gen, const char* name, PoolType type, size_t max_size,
--- a/src/share/vm/services/memoryService.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/memoryService.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -231,13 +231,13 @@ return (MemoryPool*) pool; } -MemoryPool* MemoryService::add_survivor_spaces(DefNewGeneration* gen, +MemoryPool* MemoryService::add_survivor_spaces(DefNewGeneration* young_gen, const char* name, bool is_heap, size_t max_size, bool support_usage_threshold) { MemoryPool::PoolType type = (is_heap ? MemoryPool::Heap : MemoryPool::NonHeap); - SurvivorContiguousSpacePool* pool = new SurvivorContiguousSpacePool(gen, name, type, max_size, support_usage_threshold); + SurvivorContiguousSpacePool* pool = new SurvivorContiguousSpacePool(young_gen, name, type, max_size, support_usage_threshold); _pools_list->append(pool); return (MemoryPool*) pool; @@ -347,18 +347,18 @@ #if INCLUDE_ALL_GCS -void MemoryService::add_psYoung_memory_pool(PSYoungGen* gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) { +void MemoryService::add_psYoung_memory_pool(PSYoungGen* young_gen, MemoryManager* major_mgr, MemoryManager* minor_mgr) { assert(major_mgr != NULL && minor_mgr != NULL, "Should have two managers"); // Add a memory pool for each space and young gen doesn't // support low memory detection as it is expected to get filled up. - EdenMutableSpacePool* eden = new EdenMutableSpacePool(gen, - gen->eden_space(), + EdenMutableSpacePool* eden = new EdenMutableSpacePool(young_gen, + young_gen->eden_space(), "PS Eden Space", MemoryPool::Heap, false /* support_usage_threshold */); - SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(gen, + SurvivorMutableSpacePool* survivor = new SurvivorMutableSpacePool(young_gen, "PS Survivor Space", MemoryPool::Heap, false /* support_usage_threshold */); @@ -371,13 +371,13 @@ _pools_list->append(survivor); } -void MemoryService::add_psOld_memory_pool(PSOldGen* gen, MemoryManager* mgr) { - PSGenerationPool* old_gen = new PSGenerationPool(gen, - "PS Old Gen", - MemoryPool::Heap, - true /* support_usage_threshold */); - mgr->add_pool(old_gen); - _pools_list->append(old_gen); +void MemoryService::add_psOld_memory_pool(PSOldGen* old_gen, MemoryManager* mgr) { + PSGenerationPool* old_gen_pool = new PSGenerationPool(old_gen, + "PS Old Gen", + MemoryPool::Heap, + true /* support_usage_threshold */); + mgr->add_pool(old_gen_pool); + _pools_list->append(old_gen_pool); } void MemoryService::add_g1YoungGen_memory_pool(G1CollectedHeap* g1h, @@ -580,7 +580,7 @@ } // // GC manager type depends on the type of Generation. Depending on the space -// availablity and vm options the gc uses major gc manager or minor gc +// availability and vm options the gc uses major gc manager or minor gc // manager or both. The type of gc manager depends on the generation kind. // For DefNew and ParNew generation doing scavenge gc uses minor gc manager (so // _fullGC is set to false ) and for other generation kinds doing
--- a/src/share/vm/services/memoryService.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/memoryService.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -81,10 +81,10 @@ } - static void add_psYoung_memory_pool(PSYoungGen* gen, + static void add_psYoung_memory_pool(PSYoungGen* young_gen, MemoryManager* major_mgr, MemoryManager* minor_mgr); - static void add_psOld_memory_pool(PSOldGen* gen, + static void add_psOld_memory_pool(PSOldGen* old_gen, MemoryManager* mgr); static void add_g1YoungGen_memory_pool(G1CollectedHeap* g1h, @@ -101,7 +101,7 @@ bool is_heap, size_t max_size, bool support_usage_threshold); - static MemoryPool* add_survivor_spaces(DefNewGeneration* gen, + static MemoryPool* add_survivor_spaces(DefNewGeneration* young_gen, const char* name, bool is_heap, size_t max_size, @@ -168,7 +168,6 @@ bool recordGCEndTime, bool countCollection, GCCause::Cause cause); - static void oops_do(OopClosure* f); static bool get_verbose() { return PrintGC; }
--- a/src/share/vm/services/psMemoryPool.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/psMemoryPool.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -33,18 +33,18 @@ #include "services/memoryManager.hpp" #include "services/psMemoryPool.hpp" -PSGenerationPool::PSGenerationPool(PSOldGen* gen, +PSGenerationPool::PSGenerationPool(PSOldGen* old_gen, const char* name, PoolType type, bool support_usage_threshold) : - CollectedMemoryPool(name, type, gen->capacity_in_bytes(), - gen->reserved().byte_size(), support_usage_threshold), _gen(gen) { + CollectedMemoryPool(name, type, old_gen->capacity_in_bytes(), + old_gen->reserved().byte_size(), support_usage_threshold), _old_gen(old_gen) { } MemoryUsage PSGenerationPool::get_memory_usage() { size_t maxSize = (available_for_allocation() ? max_size() : 0); size_t used = used_in_bytes(); - size_t committed = _gen->capacity_in_bytes(); + size_t committed = _old_gen->capacity_in_bytes(); return MemoryUsage(initial_size(), used, committed, maxSize); } @@ -55,15 +55,16 @@ // Max size of PS eden space is changing due to ergonomic. // PSYoungGen, PSOldGen, Eden, Survivor spaces are all resizable. // -EdenMutableSpacePool::EdenMutableSpacePool(PSYoungGen* gen, +EdenMutableSpacePool::EdenMutableSpacePool(PSYoungGen* young_gen, MutableSpace* space, const char* name, PoolType type, bool support_usage_threshold) : CollectedMemoryPool(name, type, space->capacity_in_bytes(), - (gen->max_size() - gen->from_space()->capacity_in_bytes() - gen->to_space()->capacity_in_bytes()), + (young_gen->max_size() - young_gen->from_space()->capacity_in_bytes() - young_gen->to_space()->capacity_in_bytes()), support_usage_threshold), - _gen(gen), _space(space) { + _young_gen(young_gen), + _space(space) { } MemoryUsage EdenMutableSpacePool::get_memory_usage() { @@ -79,13 +80,13 @@ // // PS from and to survivor spaces could have different sizes. // -SurvivorMutableSpacePool::SurvivorMutableSpacePool(PSYoungGen* gen, +SurvivorMutableSpacePool::SurvivorMutableSpacePool(PSYoungGen* young_gen, const char* name, PoolType type, bool support_usage_threshold) : - CollectedMemoryPool(name, type, gen->from_space()->capacity_in_bytes(), - gen->from_space()->capacity_in_bytes(), - support_usage_threshold), _gen(gen) { + CollectedMemoryPool(name, type, young_gen->from_space()->capacity_in_bytes(), + young_gen->from_space()->capacity_in_bytes(), + support_usage_threshold), _young_gen(young_gen) { } MemoryUsage SurvivorMutableSpacePool::get_memory_usage() {
--- a/src/share/vm/services/psMemoryPool.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/services/psMemoryPool.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -39,23 +39,23 @@ class PSGenerationPool : public CollectedMemoryPool { private: - PSOldGen* _gen; + PSOldGen* _old_gen; public: PSGenerationPool(PSOldGen* pool, const char* name, PoolType type, bool support_usage_threshold); MemoryUsage get_memory_usage(); - size_t used_in_bytes() { return _gen->used_in_bytes(); } - size_t max_size() const { return _gen->reserved().byte_size(); } + size_t used_in_bytes() { return _old_gen->used_in_bytes(); } + size_t max_size() const { return _old_gen->reserved().byte_size(); } }; class EdenMutableSpacePool : public CollectedMemoryPool { private: - PSYoungGen* _gen; + PSYoungGen* _young_gen; MutableSpace* _space; public: - EdenMutableSpacePool(PSYoungGen* gen, + EdenMutableSpacePool(PSYoungGen* young_gen, MutableSpace* space, const char* name, PoolType type, @@ -66,16 +66,16 @@ size_t used_in_bytes() { return space()->used_in_bytes(); } size_t max_size() const { // Eden's max_size = max_size of Young Gen - the current committed size of survivor spaces - return _gen->max_size() - _gen->from_space()->capacity_in_bytes() - _gen->to_space()->capacity_in_bytes(); + return _young_gen->max_size() - _young_gen->from_space()->capacity_in_bytes() - _young_gen->to_space()->capacity_in_bytes(); } }; class SurvivorMutableSpacePool : public CollectedMemoryPool { private: - PSYoungGen* _gen; + PSYoungGen* _young_gen; public: - SurvivorMutableSpacePool(PSYoungGen* gen, + SurvivorMutableSpacePool(PSYoungGen* young_gen, const char* name, PoolType type, bool support_usage_threshold); @@ -83,14 +83,14 @@ MemoryUsage get_memory_usage(); size_t used_in_bytes() { - return _gen->from_space()->used_in_bytes(); + return _young_gen->from_space()->used_in_bytes(); } size_t committed_in_bytes() { - return _gen->from_space()->capacity_in_bytes(); + return _young_gen->from_space()->capacity_in_bytes(); } size_t max_size() const { // Return current committed size of the from-space - return _gen->from_space()->capacity_in_bytes(); + return _young_gen->from_space()->capacity_in_bytes(); } };
--- a/src/share/vm/shark/sharkBuilder.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/shark/sharkBuilder.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -440,8 +440,10 @@ // HotSpot memory barriers void SharkBuilder::CreateUpdateBarrierSet(BarrierSet* bs, Value* field) { - if (bs->kind() != BarrierSet::CardTableModRef) + if (bs->kind() != BarrierSet::CardTableForRS && + bs->kind() != BarrierSet::CardTableExtension) { Unimplemented(); + } CreateStore( LLVMValue::jbyte_constant(CardTableModRefBS::dirty_card_val()),
--- a/src/share/vm/trace/trace.xml Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/trace/trace.xml Tue Sep 29 18:47:52 2015 +0200 @@ -346,6 +346,29 @@ <value type="BYTES64" field="totalSize" label="Total Size" /> </event> + <struct id="G1EvacStats"> + <value type="UINT" field="gcId" label="GC ID" relation="GC_ID"/> + <value type="BYTES64" field="allocated" label="Allocated" description="Total memory allocated by PLABs"/> + <value type="BYTES64" field="wasted" label="Wasted" description="Total memory wasted within PLABs due to alignment or refill"/> + <value type="BYTES64" field="used" label="Used" description="Total memory occupied by objects within PLABs"/> + <value type="BYTES64" field="undoWaste" label="Undo Wasted" description="Total memory wasted due to allocation undo within PLABs"/> + <value type="BYTES64" field="regionEndWaste" label="Region End Wasted" description="Total memory wasted at the end of regions due to refill"/> + <value type="UINT" field="regionsRefilled" label="Region Refills" description="Total memory wasted at the end of regions due to refill"/> + <value type="BYTES64" field="directAllocated" label="Allocated (direct)" description="Total memory allocated using direct allocation outside of PLABs"/> + <value type="BYTES64" field="failureUsed" label="Used (failure)" description="Total memory occupied by objects in regions where evacuation failed"/> + <value type="BYTES64" field="failureWaste" label="Wasted (failure)" description="Total memory left unused in regions where evacuation failed"/> + </struct> + + <event id="GCG1EvacuationYoungStatistics" path="vm/gc/detailed/g1_evac_young_stats" label="G1 Evacuation Statistics for Young" is_instant="true" + description="Memory related evacuation statistics during GC for the young generation"> + <structvalue type="G1EvacStats" field="stats" label="Evacuation statistics"/> + </event> + + <event id="GCG1EvacuationOldStatistics" path="vm/gc/detailed/g1_evac_old_stats" label="G1 Evacuation Memory Statistics for Old" is_instant="true" + description="Memory related evacuation statistics during GC for the old generation"> + <structvalue type="G1EvacStats" field="stats" label="Evacuation statistics"/> + </event> + <!-- Promotion events, Supported GCs are Parallel Scavange, G1 and CMS with Parallel New. --> <event id="PromoteObjectInNewPLAB" path="vm/gc/detailed/object_promotion_in_new_PLAB" label="Promotion in new PLAB" description="Object survived scavenge and was copied to a new Promotion Local Allocation Buffer (PLAB). Supported GCs are Parallel Scavange, G1 and CMS with Parallel New. Due to promotion being done in parallel an object might be reported multiple times as the GC threads race to copy all objects."
--- a/src/share/vm/utilities/endian.cpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,97 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#include "precompiled.hpp" -#include "utilities/endian.hpp" -#include "utilities/bytes.hpp" - -#ifndef bswap_16 -extern "C" inline u2 bswap_16(u2 x) { - return ((x & 0xFF) << 8) | - ((x >> 8) & 0xFF); -} -#endif - -#ifndef bswap_32 -extern "C" inline u4 bswap_32(u4 x) { - return ((x & 0xFF) << 24) | - ((x & 0xFF00) << 8) | - ((x >> 8) & 0xFF00) | - ((x >> 24) & 0xFF); -} -#endif - -#ifndef bswap_64 -extern "C" inline u8 bswap_64(u8 x) { - return (u8)bswap_32((u4)x) << 32 | - (u8)bswap_32((u4)(x >> 32)); -} -#endif - -u2 NativeEndian::get(u2 x) { return x; } -u4 NativeEndian::get(u4 x) { return x; } -u8 NativeEndian::get(u8 x) { return x; } -s2 NativeEndian::get(s2 x) { return x; } -s4 NativeEndian::get(s4 x) { return x; } -s8 NativeEndian::get(s8 x) { return x; } - -void NativeEndian::set(u2& x, u2 y) { x = y; } -void NativeEndian::set(u4& x, u4 y) { x = y; } -void NativeEndian::set(u8& x, u8 y) { x = y; } -void NativeEndian::set(s2& x, s2 y) { x = y; } -void NativeEndian::set(s4& x, s4 y) { x = y; } -void NativeEndian::set(s8& x, s8 y) { x = y; } - -NativeEndian NativeEndian::_native; - -u2 SwappingEndian::get(u2 x) { return bswap_16(x); } -u4 SwappingEndian::get(u4 x) { return bswap_32(x); } -u8 SwappingEndian::get(u8 x) { return bswap_64(x); } -s2 SwappingEndian::get(s2 x) { return bswap_16(x); } -s4 SwappingEndian::get(s4 x) { return bswap_32(x); } -s8 SwappingEndian::get(s8 x) { return bswap_64(x); } - -void SwappingEndian::set(u2& x, u2 y) { x = bswap_16(y); } -void SwappingEndian::set(u4& x, u4 y) { x = bswap_32(y); } -void SwappingEndian::set(u8& x, u8 y) { x = bswap_64(y); } -void SwappingEndian::set(s2& x, s2 y) { x = bswap_16(y); } -void SwappingEndian::set(s4& x, s4 y) { x = bswap_32(y); } -void SwappingEndian::set(s8& x, s8 y) { x = bswap_64(y); } - -SwappingEndian SwappingEndian::_swapping; - -Endian* Endian::get_handler(bool big_endian) { - // If requesting little endian on a little endian machine or - // big endian on a big endian machine use native handler - if (big_endian == is_big_endian()) { - return NativeEndian::get_native(); - } else { - // Use swapping handler. - return SwappingEndian::get_swapping(); - } -} - -Endian* Endian::get_native_handler() { - return NativeEndian::get_native(); -}
--- a/src/share/vm/utilities/endian.hpp Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,119 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - * - */ - -#ifndef SHARE_VM_UTILITIES_ENDIAN_HPP -#define SHARE_VM_UTILITIES_ENDIAN_HPP - -#include "utilities/globalDefinitions.hpp" - -// Selectable endian handling. Endian handlers are used when accessing values -// that are of unknown (until runtime) endian. The only requirement of the values -// accessed are that they are aligned to proper size boundaries (no misalignment.) -// To select an endian handler, one should call Endian::get_handler(big_endian); -// Where big_endian is true if big endian is required and false otherwise. The -// native endian handler can be fetched with Endian::get_native_handler(); -// To retrieve a value using the approprate endian, use one of the overloaded -// calls to get. To set a value, then use one of the overloaded set calls. -// Ex. -// s4 value; // Imported value; -// ... -// Endian* endian = Endian::get_handler(true); // Use big endian -// s4 corrected = endian->get(value); -// endian->set(value, 1); -// -class Endian { -public: - virtual u2 get(u2 x) = 0; - virtual u4 get(u4 x) = 0; - virtual u8 get(u8 x) = 0; - virtual s2 get(s2 x) = 0; - virtual s4 get(s4 x) = 0; - virtual s8 get(s8 x) = 0; - - virtual void set(u2& x, u2 y) = 0; - virtual void set(u4& x, u4 y) = 0; - virtual void set(u8& x, u8 y) = 0; - virtual void set(s2& x, s2 y) = 0; - virtual void set(s4& x, s4 y) = 0; - virtual void set(s8& x, s8 y) = 0; - - // Quick little endian test. - static bool is_little_endian() { u4 x = 1; return *(u1 *)&x != 0; } - - // Quick big endian test. - static bool is_big_endian() { return !is_little_endian(); } - - // Select an appropriate endian handler. - static Endian* get_handler(bool big_endian); - - // Return the native endian handler. - static Endian* get_native_handler(); -}; - -// Normal endian handling. -class NativeEndian : public Endian { -private: - static NativeEndian _native; - -public: - u2 get(u2 x); - u4 get(u4 x); - u8 get(u8 x); - s2 get(s2 x); - s4 get(s4 x); - s8 get(s8 x); - - void set(u2& x, u2 y); - void set(u4& x, u4 y); - void set(u8& x, u8 y); - void set(s2& x, s2 y); - void set(s4& x, s4 y); - void set(s8& x, s8 y); - - static Endian* get_native() { return &_native; } -}; - -// Swapping endian handling. -class SwappingEndian : public Endian { -private: - static SwappingEndian _swapping; - -public: - u2 get(u2 x); - u4 get(u4 x); - u8 get(u8 x); - s2 get(s2 x); - s4 get(s4 x); - s8 get(s8 x); - - void set(u2& x, u2 y); - void set(u4& x, u4 y); - void set(u8& x, u8 y); - void set(s2& x, s2 y); - void set(s4& x, s4 y); - void set(s8& x, s8 y); - - static Endian* get_swapping() { return &_swapping; } -}; -#endif // SHARE_VM_UTILITIES_ENDIAN_HPP
--- a/src/share/vm/utilities/globalDefinitions_gcc.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/globalDefinitions_gcc.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -161,7 +161,7 @@ //---------------------------------------------------------------------------------------------------- -// Constant for jlong (specifying an long long canstant is C++ compiler specific) +// Constant for jlong (specifying a long long constant is C++ compiler specific) // Build a 64bit integer constant #define CONST64(x) (x ## LL)
--- a/src/share/vm/utilities/globalDefinitions_sparcWorks.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/globalDefinitions_sparcWorks.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -178,7 +178,7 @@ //---------------------------------------------------------------------------------------------------- -// Constant for jlong (specifying an long long constant is C++ compiler specific) +// Constant for jlong (specifying a long long constant is C++ compiler specific) // Build a 64bit integer constant #define CONST64(x) (x ## LL)
--- a/src/share/vm/utilities/globalDefinitions_visCPP.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/globalDefinitions_visCPP.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -148,9 +148,9 @@ inline int g_isfinite(jdouble f) { return _finite(f); } //---------------------------------------------------------------------------------------------------- -// Constant for jlong (specifying an long long constant is C++ compiler specific) +// Constant for jlong (specifying a long long constant is C++ compiler specific) -// Build a 64bit integer constant on with Visual C++ +// Build a 64bit integer constant with Visual C++ #define CONST64(x) (x ## i64) #define UCONST64(x) (x ## ui64)
--- a/src/share/vm/utilities/globalDefinitions_xlc.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/globalDefinitions_xlc.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -108,7 +108,7 @@ //---------------------------------------------------------------------------------------------------- -// Constant for jlong (specifying an long long canstant is C++ compiler specific) +// Constant for jlong (specifying a long long constant is C++ compiler specific) // Build a 64bit integer constant #define CONST64(x) (x ## LL)
--- a/src/share/vm/utilities/stack.inline.hpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/stack.inline.hpp Tue Sep 29 18:47:52 2015 +0200 @@ -27,6 +27,17 @@ #include "utilities/stack.hpp" +// Stack is used by the GC code and in some hot paths a lot of the Stack +// code gets inlined. This is generally good, but when too much code has +// been inlined, no further inlining is allowed by GCC. Therefore we need +// to prevent parts of the slow path in Stack to be inlined to allow other +// code to be. +#if defined(TARGET_COMPILER_gcc) +#define NOINLINE __attribute__((noinline)) +#else +#define NOINLINE +#endif + template <MEMFLAGS F> StackBase<F>::StackBase(size_t segment_size, size_t max_cache_size, size_t max_size): _seg_size(segment_size), @@ -141,7 +152,7 @@ } template <class E, MEMFLAGS F> -void Stack<E, F>::push_segment() +NOINLINE void Stack<E, F>::push_segment() { assert(this->_cur_seg_size == this->_seg_size, "current segment is not full"); E* next; @@ -269,4 +280,6 @@ return _cur_seg + --_cur_seg_size; } +#undef NOINLINE + #endif // SHARE_VM_UTILITIES_STACK_INLINE_HPP
--- a/src/share/vm/utilities/vmError.cpp Tue Sep 29 16:51:31 2015 +0200 +++ b/src/share/vm/utilities/vmError.cpp Tue Sep 29 18:47:52 2015 +0200 @@ -231,7 +231,7 @@ if (signame) { jio_snprintf(buf, buflen, - "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" INTPTR_FORMAT, + "%s (0x%x) at pc=" PTR_FORMAT ", pid=%d, tid=" UINTX_FORMAT, signame, _id, _pc, os::current_process_id(), os::current_thread_id()); } else if (_filename != NULL && _lineno > 0) { @@ -239,7 +239,7 @@ char separator = os::file_separator()[0]; const char *p = strrchr(_filename, separator); int n = jio_snprintf(buf, buflen, - "Internal Error at %s:%d, pid=%d, tid=" INTPTR_FORMAT, + "Internal Error at %s:%d, pid=%d, tid=" UINTX_FORMAT, p ? p + 1 : _filename, _lineno, os::current_process_id(), os::current_thread_id()); if (n >= 0 && n < buflen && _message) { @@ -253,7 +253,7 @@ } } else { jio_snprintf(buf, buflen, - "Internal Error (0x%x), pid=%d, tid=" INTPTR_FORMAT, + "Internal Error (0x%x), pid=%d, tid=" UINTX_FORMAT, _id, os::current_process_id(), os::current_thread_id()); } @@ -486,7 +486,7 @@ // process id, thread id st->print(", pid=%d", os::current_process_id()); - st->print(", tid=" INTPTR_FORMAT, os::current_thread_id()); + st->print(", tid=" UINTX_FORMAT, os::current_thread_id()); st->cr(); STEP(80, "(printing error message)")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/TestMoveStoresOutOfLoopsStoreNoCtrl.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8134288 + * @summary Store nodes may not have a control if used to update profiling + * @run main/othervm -XX:-ProfileInterpreter -XX:-TieredCompilation -XX:-BackgroundCompilation TestMoveStoresOutOfLoopsStoreNoCtrl + * + */ + +public class TestMoveStoresOutOfLoopsStoreNoCtrl { + + static void test(boolean flag) { + for (int i = 0; i < 20000; i++) { + if (flag) { + int j = 0; + do { + j++; + } while(j < 10); + } + } + } + + static public void main(String[] args) { + test(false); + } + +}
--- a/test/compiler/arguments/CheckCICompilerCount.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/compiler/arguments/CheckCICompilerCount.java Tue Sep 29 18:47:52 2015 +0200 @@ -68,14 +68,14 @@ private static final String[][] NON_TIERED_EXPECTED_OUTPUTS = { { - "CICompilerCount=0 must be at least 1", + "CICompilerCount (0) must be at least 1", "Improperly specified VM option 'CICompilerCount=0'" }, { "intx CICompilerCount := 1 {product}" }, { - "CICompilerCount=0 must be at least 1", + "CICompilerCount (0) must be at least 1", "Improperly specified VM option 'CICompilerCount=0'" }, { @@ -123,14 +123,14 @@ private static final String[][] TIERED_EXPECTED_OUTPUTS = { { - "CICompilerCount=1 must be at least 2", + "CICompilerCount (1) must be at least 2", "Improperly specified VM option 'CICompilerCount=1'" }, { "intx CICompilerCount := 2 {product}" }, { - "CICompilerCount=1 must be at least 2", + "CICompilerCount (1) must be at least 2", "Improperly specified VM option 'CICompilerCount=1'" }, {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/arraycopy/TestArrayCopyOverflowInBoundChecks.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8134468 + * @summary test that checks whether an array load falls into the range of an arraycopy is incorrect on 32bits + * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestArrayCopyOverflowInBoundChecks + * + */ +public class TestArrayCopyOverflowInBoundChecks { + + static byte[] src_array = { 'a', 'b', 'c', 'd', 'e' }; + + static byte test(int copy_len) { + byte[] dst_array = new byte[10]; + System.arraycopy(src_array, 0, dst_array, 1, copy_len); + return dst_array[1]; + } + + static public void main(String[] args) { + for (int i = 0; i < 20000; i++) { + if (test(src_array.length - 1) != src_array[0]) { + throw new RuntimeException("Test failed"); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/arraycopy/TestEliminatedArrayCopyDeopt.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,204 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8130847 + * @summary Eliminated instance/array written to by an array copy variant must be correctly initialized when reallocated at a deopt + * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestEliminatedArrayCopyDeopt + * + */ + +// Test that if an ArrayCopy node is eliminated because it doesn't +// escape, then the correct field/array element values are captured so +// on a deoptimization, when the object/array is reallocated, it is +// correctly initialized + +public class TestEliminatedArrayCopyDeopt { + + static class A implements Cloneable { + int f0; + int f1; + int f2; + int f3; + int f4; + int f5; + int f6; + int f7; + int f8; + int f9; + int f10; + int f11; + int f12; + int f13; + int f14; + int f15; + + public Object clone() throws CloneNotSupportedException { + return super.clone(); + } + } + + // Clone + static boolean m1(A a, boolean flag) throws CloneNotSupportedException { + A c = (A)a.clone(); + if (flag) { + // never taken branch that causes the deoptimization + if (c.f0 != 0x42) { + return false; + } + } + return true; + } + + // Array clone + static int[] m2_src = null; + static boolean m2(boolean flag) throws CloneNotSupportedException { + int[] src = new int[10]; + m2_src = src; + for (int i = 0; i < src.length; i++) { + src[i] = 0x42+i; + } + int[] c = (int[])src.clone(); + if (flag) { + for (int i = 0; i < c.length; i++) { + if (c[i] != src[i]) { + return false; + } + } + } + return true; + } + + // Array copy + static boolean m3(int[] src, boolean flag) { + int[] dst = new int[10]; + System.arraycopy(src, 0, dst, 0, 10); + if (flag) { + for (int i = 0; i < dst.length; i++) { + if (dst[i] != src[i]) { + return false; + } + } + } + return true; + } + + // Array copy of subrange + static boolean m4(int[] src, boolean flag) { + int[] dst = new int[10]; + dst[0] = 0x42; + dst[1] = 0x42 - 1; + dst[2] = 0x42 - 2; + dst[8] = 0x42 - 8; + dst[9] = 0x42 - 9; + int src_off = 2; + int dst_off = 3; + int len = 5; + System.arraycopy(src, src_off, dst, dst_off, len); + if (flag) { + for (int i = 0; i < dst.length; i++) { + if (i >= dst_off && i < dst_off + len) { + if (dst[i] != src[i - dst_off + src_off]) { + return false; + } + } else { + if (dst[i] != 0x42-i) { + return false; + } + } + } + } + return true; + } + + // Array copy with Phi + static boolean m5(int[] src, boolean flag1, boolean flag2) { + int[] dst = new int[10]; + if (flag1) { + System.arraycopy(src, 0, dst, 0, 10); + } + if (flag2) { + for (int i = 0; i < dst.length; i++) { + if (dst[i] != src[i]) { + return false; + } + } + } + return true; + } + + static public void main(String[] args) throws Exception { + boolean success = true; + A a = new A(); + a.f0 = 0x42; + for (int i = 0; i < 20000; i++) { + m1(a, false); + } + if (!m1(a, true)) { + System.out.println("m1 failed"); + success = false; + } + + for (int i = 0; i < 20000; i++) { + m2(false); + } + if (!m2(true)) { + System.out.println("m2 failed"); + success = false; + } + + int[] src = new int[10]; + for (int i = 0; i < src.length; i++) { + src[i] = 0x42+i; + } + + for (int i = 0; i < 20000; i++) { + m3(src, false); + } + if (!m3(src, true)) { + System.out.println("m3 failed"); + success = false; + } + + for (int i = 0; i < 20000; i++) { + m4(src, false); + } + if (!m4(src, true)) { + System.out.println("m4 failed"); + success = false; + } + + for (int i = 0; i < 20000; i++) { + m5(src, i%2 == 0, false); + } + if (!m5(src, true, true)) { + System.out.println("m4 failed"); + success = false; + } + + if (!success) { + throw new RuntimeException("Test failed"); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/arraycopy/TestEliminatedArrayCopyPhi.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8134321 + * @summary Code that capture field values of eliminated allocation at a safepoint when there's an arraycopy behind a Phi is broken + * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement TestEliminatedArrayCopyPhi + * + */ + +public class TestEliminatedArrayCopyPhi { + + static int[] escaped; + + static void test(int[] src, boolean flag1, boolean flag2) { + int[] array = new int[10]; + if (flag1) { + System.arraycopy(src, 0, array, 0, src.length); + } else { + } + + if (flag2) { + // never taken + escaped = array; + } + } + + public static void main(String[] args) { + int[] src = new int[10]; + for (int i = 0; i < 20000; i++) { + test(src, (i % 2) == 0, false); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/escapeAnalysis/TestEABadMergeMem.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,86 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test + * @bug 8134031 + * @summary Bad rewiring of memory edges when we split unique types during EA + * @run main/othervm -XX:-BackgroundCompilation -XX:-UseOnStackReplacement -XX:CompileCommand=dontinline,TestEABadMergeMem::m_notinlined TestEABadMergeMem + * + */ + +public class TestEABadMergeMem { + + static class Box { + int i; + } + + static void m_notinlined() { + } + + static float dummy1; + static float dummy2; + + static int test(Box a, Box c, int i, int j, int k, boolean flag1, boolean flag2) { + Box b = new Box(); // non escaping + a.i = i; + b.i = j; + c.i = k; + + m_notinlined(); + + boolean flag3 = false; + if (flag1) { + for (int ii = 0; ii < 100; ii++) { + if (flag2) { + dummy1 = (float)ii; + } else { + dummy2 = (float)ii; + } + } + flag3 = true; + } + // Memory Phi here with projection of not inlined call as one edge, MergeMem as other + + if (flag3) { // will split through Phi during loopopts + int res = c.i + b.i; + m_notinlined(); // prevents split through phi during igvn + return res; + } else { + return 44 + 43; + } + } + + static public void main(String[] args) { + for (int i = 0; i < 20000; i++) { + // m(2); + Box a = new Box(); + Box c = new Box(); + int res = test(a, c, 42, 43, 44, (i%2) == 0, (i%3) == 0); + if (res != 44 + 43) { + throw new RuntimeException("Bad result " + res); + } + } + } + +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/floatingpoint/NaNTest.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ +/** + * @test + * @bug 8076373 + * @summary Verify if signaling NaNs are preserved. + * @run main NaNTest + */ +public class NaNTest { + static void testFloat() { + int originalValue = 0x7f800001; + int readBackValue = Float.floatToRawIntBits(Float.intBitsToFloat(originalValue)); + if (originalValue != readBackValue) { + String errorMessage = String.format("Original and read back float values mismatch\n0x%X 0x%X\n", + originalValue, + readBackValue); + throw new RuntimeException(errorMessage); + } else { + System.out.printf("Written and read back float values match\n0x%X 0x%X\n", + originalValue, + readBackValue); + } + } + + static void testDouble() { + long originalValue = 0xFFF0000000000001L; + long readBackValue = Double.doubleToRawLongBits(Double.longBitsToDouble(originalValue)); + if (originalValue != readBackValue) { + String errorMessage = String.format("Original and read back double values mismatch\n0x%X 0x%X\n", + originalValue, + readBackValue); + throw new RuntimeException(errorMessage); + } else { + System.out.printf("Written and read back double values match\n0x%X 0x%X\n", + originalValue, + readBackValue); + } + + } + + public static void main(String args[]) { + System.out.println("### NanTest started"); + + testFloat(); + testDouble(); + + System.out.println("### NanTest ended"); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/intrinsics/adler32/TestAdler32.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/** + * @test + * @bug 8132081 + * @summary C2 support for Adler32 on SPARC + * + * @run main/othervm/timeout=600 -Xbatch TestAdler32 -m + */ + +import java.nio.ByteBuffer; +import java.util.zip.Checksum; +import java.util.zip.Adler32; + +public class TestAdler32 { + public static void main(String[] args) { + int offset = Integer.getInteger("offset", 0); + int msgSize = Integer.getInteger("msgSize", 512); + boolean multi = false; + int iters = 20000; + int warmupIters = 20000; + + if (args.length > 0) { + if (args[0].equals("-m")) { + multi = true; + } else { + iters = Integer.valueOf(args[0]); + } + if (args.length > 1) { + warmupIters = Integer.valueOf(args[1]); + } + } + + if (multi) { + test_multi(warmupIters); + return; + } + + System.out.println(" offset = " + offset); + System.out.println("msgSize = " + msgSize + " bytes"); + System.out.println(" iters = " + iters); + + byte[] b = initializedBytes(msgSize, offset); + + Adler32 adler0 = new Adler32(); + Adler32 adler1 = new Adler32(); + Adler32 adler2 = new Adler32(); + + adler0.update(b, offset, msgSize); + + System.out.println("-------------------------------------------------------"); + + /* warm up */ + for (int i = 0; i < warmupIters; i++) { + adler1.reset(); + adler1.update(b, offset, msgSize); + } + + /* measure performance */ + long start = System.nanoTime(); + for (int i = 0; i < iters; i++) { + adler1.reset(); + adler1.update(b, offset, msgSize); + } + long end = System.nanoTime(); + double total = (double)(end - start)/1e9; // in seconds + double thruput = (double)msgSize*iters/1e6/total; // in MB/s + System.out.println("Adler32.update(byte[]) runtime = " + total + " seconds"); + System.out.println("Adler32.update(byte[]) throughput = " + thruput + " MB/s"); + + /* check correctness */ + for (int i = 0; i < iters; i++) { + adler1.reset(); + adler1.update(b, offset, msgSize); + if (!check(adler0, adler1)) break; + } + report("Adlers", adler0, adler1); + + System.out.println("-------------------------------------------------------"); + + ByteBuffer buf = ByteBuffer.allocateDirect(msgSize); + buf.put(b, offset, msgSize); + buf.flip(); + + /* warm up */ + for (int i = 0; i < warmupIters; i++) { + adler2.reset(); + adler2.update(buf); + buf.rewind(); + } + + /* measure performance */ + start = System.nanoTime(); + for (int i = 0; i < iters; i++) { + adler2.reset(); + adler2.update(buf); + buf.rewind(); + } + end = System.nanoTime(); + total = (double)(end - start)/1e9; // in seconds + thruput = (double)msgSize*iters/1e6/total; // in MB/s + System.out.println("Adler32.update(ByteBuffer) runtime = " + total + " seconds"); + System.out.println("Adler32.update(ByteBuffer) throughput = " + thruput + " MB/s"); + + /* check correctness */ + for (int i = 0; i < iters; i++) { + adler2.reset(); + adler2.update(buf); + buf.rewind(); + if (!check(adler0, adler2)) break; + } + report("Adlers", adler0, adler1); + + System.out.println("-------------------------------------------------------"); + } + + private static void report(String s, Checksum adler0, Checksum adler1) { + System.out.printf("%s: adler0 = %08x, adler1 = %08x\n", + s, adler0.getValue(), adler1.getValue()); + } + + private static boolean check(Checksum adler0, Checksum adler1) { + if (adler0.getValue() != adler1.getValue()) { + System.err.printf("ERROR: adler0 = %08x, adler1 = %08x\n", + adler0.getValue(), adler1.getValue()); + return false; + } + return true; + } + + private static byte[] initializedBytes(int M, int offset) { + byte[] bytes = new byte[M + offset]; + for (int i = 0; i < offset; i++) { + bytes[i] = (byte) i; + } + for (int i = offset; i < bytes.length; i++) { + bytes[i] = (byte) (i - offset); + } + return bytes; + } + + private static void test_multi(int iters) { + int len1 = 8; // the 8B/iteration loop + int len2 = 32; // the 32B/iteration loop + int len3 = 4096; // the 4KB/iteration loop + + byte[] b = initializedBytes(len3*16, 0); + int[] offsets = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 256, 512 }; + int[] sizes = { 0, 1, 2, 3, 4, 5, 6, 7, + len1, len1+1, len1+2, len1+3, len1+4, len1+5, len1+6, len1+7, + len1*2, len1*2+1, len1*2+3, len1*2+5, len1*2+7, + len2, len2+1, len2+3, len2+5, len2+7, + len2*2, len2*4, len2*8, len2*16, len2*32, len2*64, + len3, len3+1, len3+3, len3+5, len3+7, + len3*2, len3*4, len3*8, + len1+len2, len1+len2+1, len1+len2+3, len1+len2+5, len1+len2+7, + len1+len3, len1+len3+1, len1+len3+3, len1+len3+5, len1+len3+7, + len2+len3, len2+len3+1, len2+len3+3, len2+len3+5, len2+len3+7, + len1+len2+len3, len1+len2+len3+1, len1+len2+len3+3, + len1+len2+len3+5, len1+len2+len3+7, + (len1+len2+len3)*2, (len1+len2+len3)*2+1, (len1+len2+len3)*2+3, + (len1+len2+len3)*2+5, (len1+len2+len3)*2+7, + (len1+len2+len3)*3, (len1+len2+len3)*3-1, (len1+len2+len3)*3-3, + (len1+len2+len3)*3-5, (len1+len2+len3)*3-7 }; + Adler32[] adler0 = new Adler32[offsets.length*sizes.length]; + Adler32[] adler1 = new Adler32[offsets.length*sizes.length]; + int i, j, k; + + System.out.printf("testing %d cases ...\n", offsets.length*sizes.length); + + /* set the result from interpreter as reference */ + for (i = 0; i < offsets.length; i++) { + for (j = 0; j < sizes.length; j++) { + adler0[i*sizes.length + j] = new Adler32(); + adler1[i*sizes.length + j] = new Adler32(); + adler0[i*sizes.length + j].update(b, offsets[i], sizes[j]); + } + } + + /* warm up the JIT compiler and get result */ + for (k = 0; k < iters; k++) { + for (i = 0; i < offsets.length; i++) { + for (j = 0; j < sizes.length; j++) { + adler1[i*sizes.length + j].reset(); + adler1[i*sizes.length + j].update(b, offsets[i], sizes[j]); + } + } + } + + /* check correctness */ + for (i = 0; i < offsets.length; i++) { + for (j = 0; j < sizes.length; j++) { + if (!check(adler0[i*sizes.length + j], adler1[i*sizes.length + j])) { + System.out.printf("offsets[%d] = %d", i, offsets[i]); + System.out.printf("\tsizes[%d] = %d\n", j, sizes[j]); + } + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/loopopts/TestMoveStoresOutOfLoops.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,310 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 8080289 + * @summary Sink stores out of loops if possible + * @run main/othervm -XX:-UseOnStackReplacement -XX:-BackgroundCompilation -XX:+PrintCompilation -XX:CompileCommand=dontinline,TestMoveStoresOutOfLoops::test* TestMoveStoresOutOfLoops + * + */ + +import java.lang.reflect.*; +import java.util.*; +import java.util.function.*; + +public class TestMoveStoresOutOfLoops { + + private static long[] array = new long[10]; + private static long[] array2 = new long[10]; + private static boolean[] array3 = new boolean[1000]; + private static byte[] byte_array = new byte[10]; + + // Array store should be moved out of the loop, value stored + // should be 999, the loop should be eliminated + static void test_after_1(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = i; + } + } + + // Array store can't be moved out of loop because of following + // non loop invariant array access + static void test_after_2(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = i; + array2[i%10] = i; + } + } + + // Array store can't be moved out of loop because of following + // use + static void test_after_3(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = i; + if (array[0] == -1) { + break; + } + } + } + + // Array store can't be moved out of loop because of preceding + // use + static void test_after_4(int idx) { + for (int i = 0; i < 1000; i++) { + if (array[0] == -2) { + break; + } + array[idx] = i; + } + } + + // All array stores should be moved out of the loop, one after + // the other + static void test_after_5(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = i; + array[idx+1] = i; + array[idx+2] = i; + array[idx+3] = i; + array[idx+4] = i; + array[idx+5] = i; + } + } + + // Array store can be moved after the loop but needs to be + // cloned on both exit paths + static void test_after_6(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = i; + if (array3[i]) { + return; + } + } + } + + // Optimize out redundant stores + static void test_stores_1(int ignored) { + array[0] = 0; + array[1] = 1; + array[2] = 2; + array[0] = 0; + array[1] = 1; + array[2] = 2; + } + + static void test_stores_2(int idx) { + array[idx+0] = 0; + array[idx+1] = 1; + array[idx+2] = 2; + array[idx+0] = 0; + array[idx+1] = 1; + array[idx+2] = 2; + } + + static void test_stores_3(int idx) { + byte_array[idx+0] = 0; + byte_array[idx+1] = 1; + byte_array[idx+2] = 2; + byte_array[idx+0] = 0; + byte_array[idx+1] = 1; + byte_array[idx+2] = 2; + } + + // Array store can be moved out of the loop before the loop header + static void test_before_1(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = 999; + } + } + + // Array store can't be moved out of the loop before the loop + // header because there's more than one store on this slice + static void test_before_2(int idx) { + for (int i = 0; i < 1000; i++) { + array[idx] = 999; + array[i%2] = 0; + } + } + + // Array store can't be moved out of the loop before the loop + // header because of use before store + static int test_before_3(int idx) { + int res = 0; + for (int i = 0; i < 1000; i++) { + res += array[i%10]; + array[idx] = 999; + } + return res; + } + + // Array store can't be moved out of the loop before the loop + // header because of possible early exit + static void test_before_4(int idx) { + for (int i = 0; i < 1000; i++) { + if (idx / (i+1) > 0) { + return; + } + array[idx] = 999; + } + } + + // Array store can't be moved out of the loop before the loop + // header because it doesn't postdominate the loop head + static void test_before_5(int idx) { + for (int i = 0; i < 1000; i++) { + if (i % 2 == 0) { + array[idx] = 999; + } + } + } + + // Array store can be moved out of the loop before the loop header + static int test_before_6(int idx) { + int res = 0; + for (int i = 0; i < 1000; i++) { + if (i%2 == 1) { + res *= 2; + } else { + res++; + } + array[idx] = 999; + } + return res; + } + + final HashMap<String,Method> tests = new HashMap<>(); + { + for (Method m : this.getClass().getDeclaredMethods()) { + if (m.getName().matches("test_(before|after|stores)_[0-9]+")) { + assert(Modifier.isStatic(m.getModifiers())) : m; + tests.put(m.getName(), m); + } + } + } + + boolean success = true; + void doTest(String name, Runnable init, Function<String, Boolean> check) throws Exception { + Method m = tests.get(name); + for (int i = 0; i < 20000; i++) { + init.run(); + m.invoke(null, 0); + success = success && check.apply(name); + if (!success) { + break; + } + } + } + + static void array_init() { + array[0] = -1; + } + + static boolean array_check(String name) { + boolean success = true; + if (array[0] != 999) { + success = false; + System.out.println(name + " failed: array[0] = " + array[0]); + } + return success; + } + + static void array_init2() { + for (int i = 0; i < 6; i++) { + array[i] = -1; + } + } + + static boolean array_check2(String name) { + boolean success = true; + for (int i = 0; i < 6; i++) { + if (array[i] != 999) { + success = false; + System.out.println(name + " failed: array[" + i + "] = " + array[i]); + } + } + return success; + } + + static void array_init3() { + for (int i = 0; i < 3; i++) { + array[i] = -1; + } + } + + static boolean array_check3(String name) { + boolean success = true; + for (int i = 0; i < 3; i++) { + if (array[i] != i) { + success = false; + System.out.println(name + " failed: array[" + i + "] = " + array[i]); + } + } + return success; + } + + static void array_init4() { + for (int i = 0; i < 3; i++) { + byte_array[i] = -1; + } + } + + static boolean array_check4(String name) { + boolean success = true; + for (int i = 0; i < 3; i++) { + if (byte_array[i] != i) { + success = false; + System.out.println(name + " failed: byte_array[" + i + "] = " + byte_array[i]); + } + } + return success; + } + + static public void main(String[] args) throws Exception { + TestMoveStoresOutOfLoops test = new TestMoveStoresOutOfLoops(); + test.doTest("test_after_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_after_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_after_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_after_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_after_5", TestMoveStoresOutOfLoops::array_init2, TestMoveStoresOutOfLoops::array_check2); + test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + array3[999] = true; + test.doTest("test_after_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + + test.doTest("test_stores_1", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3); + test.doTest("test_stores_2", TestMoveStoresOutOfLoops::array_init3, TestMoveStoresOutOfLoops::array_check3); + test.doTest("test_stores_3", TestMoveStoresOutOfLoops::array_init4, TestMoveStoresOutOfLoops::array_check4); + + test.doTest("test_before_1", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_before_2", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_before_3", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_before_4", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_before_5", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + test.doTest("test_before_6", TestMoveStoresOutOfLoops::array_init, TestMoveStoresOutOfLoops::array_check); + + if (!test.success) { + throw new RuntimeException("Some tests failed"); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/compiler/regalloc/TestVectorRegAlloc.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +/** + * @test + * @bug 8131969 + * @summary assert in register allocation code when vector Phi for a loop is processed because code assumes all inputs already processed + * @run main/othervm -Xbatch TestVectorRegAlloc + * + */ + +public class TestVectorRegAlloc { + + static int test_helper_i; + static boolean test_helper() { + test_helper_i++; + return (test_helper_i & 7) != 0; + } + + static void test(double[] src, double[] dst, boolean flag) { + double j = 0.0; + while(test_helper()) { + for (int i = 0; i < src.length; i++) { + dst[i] = src[i] + j; + } + // Loop will be unswitched and ReplicateD of zero will be + // split through the Phi of outer loop + for (int i = 0; i < src.length; i++) { + double k; + if (flag) { + k = j; + } else { + k = 0; + } + dst[i] = src[i] + k; + } + j++; + } + } + + static public void main(String[] args) { + double[] src = new double[10]; + double[] dst = new double[10]; + for (int i = 0; i < 20000; i++) { + test(src, dst, (i % 2) == 0); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/GCTypes.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,115 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +import java.lang.management.GarbageCollectorMXBean; +import java.lang.management.ManagementFactory; +import java.util.Arrays; +import java.util.Objects; + +/** + * Helper class with enum representation of GC types. + */ +public final class GCTypes { + + private static <T extends GCType> T getCurrentGCType(Class<T> type) { + return ManagementFactory.getGarbageCollectorMXBeans().stream() + .map(bean -> getGCTypeByName(type, bean.getName())) + .filter(Objects::nonNull) + .findFirst() + .orElse(null); + } + + private static <T extends GCType> T getGCTypeByName(Class<T> type, String name) { + return Arrays.stream(type.getEnumConstants()) + .filter(e -> e.getGCName().equals(name)) + .findFirst() + .orElse(null); + } + + private static <T extends GCType> GarbageCollectorMXBean getGCBeanByType(Class<T> type) { + return ManagementFactory.getGarbageCollectorMXBeans().stream() + .filter(bean -> Arrays.stream(type.getEnumConstants()) + .filter(enumName -> enumName.getGCName().equals(bean.getName())) + .findFirst() + .isPresent() + ) + .findFirst() + .orElse(null); + } + + /** + * Helper interface used by GCTypes static methods + * to get gcTypeName field of *GCType classes. + */ + private interface GCType { + + String getGCName(); + } + + public static enum YoungGCType implements GCType { + DefNew("Copy"), + ParNew("ParNew"), + PSNew("PS Scavenge"), + G1("G1 Young Generation"); + + @Override + public String getGCName() { + return gcTypeName; + } + private final String gcTypeName; + + private YoungGCType(String name) { + gcTypeName = name; + } + + public static YoungGCType getYoungGCType() { + return GCTypes.getCurrentGCType(YoungGCType.class); + } + + public static GarbageCollectorMXBean getYoungGCBean() { + return GCTypes.getGCBeanByType(YoungGCType.class); + } + } + + public static enum OldGCType implements GCType { + Serial("MarkSweepCompact"), + CMS("ConcurrentMarkSweep"), + PSOld("PS MarkSweep"), + G1("G1 Old Generation"); + + private final String gcTypeName; + + private OldGCType(String name) { + gcTypeName = name; + } + + public static OldGCType getOldGCType() { + return GCTypes.getCurrentGCType(OldGCType.class); + } + + @Override + public String getGCName() { + return gcTypeName; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestMaxMinHeapFreeRatioFlags.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,299 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +/* + * @test TestMaxMinHeapFreeRatioFlags + * @key gc + * @summary Verify that heap size changes according to max and min heap free ratios. + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + * @build TestMaxMinHeapFreeRatioFlags + * @run driver/timeout=240 TestMaxMinHeapFreeRatioFlags + */ + +import java.util.LinkedList; +import java.util.Arrays; +import java.util.Collections; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import jdk.test.lib.HeapRegionUsageTool; +import sun.misc.Unsafe; + +public class TestMaxMinHeapFreeRatioFlags { + + public static final long M = 1024 * 1024; + public static final long MAX_HEAP_SIZE = 200 * M; + public static final long HEAP_SIZE = 10 * M; + public static final long MAX_NEW_SIZE = 20 * M; + public static final long NEW_SIZE = 5 * M; + + public static void main(String args[]) throws Exception { + LinkedList<String> options = new LinkedList<>( + Arrays.asList(Utils.getFilteredTestJavaOpts("-XX:[^ ]*HeapFreeRatio","-XX:\\+ExplicitGCInvokesConcurrent")) + ); + + negativeTest(20, false, 10, true, options); + negativeTest(100, true, 0, false, options); + negativeTest(101, false, 50, false, options); + negativeTest(49, true, 102, true, options); + negativeTest(-1, false, 50, false, options); + negativeTest(50, true, -1, true, options); + + positiveTest(10, false, 90, false, options); + positiveTest(10, true, 80, false, options); + positiveTest(20, false, 70, true, options); + positiveTest(25, true, 65, true, options); + positiveTest(40, false, 50, false, options); + } + + /** + * Verify that heap size will be changed to conform + * min and max heap free ratios. + * + * @param minRatio value of MinHeapFreeRatio option + * @param useXminf used Xminf option instead of MinHeapFreeRatio + * @param maxRatio value of MaxHeapFreeRatio option + * @param useXmaxf used Xmaxf option instead of MaxHeapFreeRatio + * @param options additional options for JVM + */ + public static void positiveTest(int minRatio, boolean useXminf, + int maxRatio, boolean useXmaxf, + LinkedList<String> options) throws Exception { + + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + (useXminf ? "-Xminf" + minRatio / 100.0 : "-XX:MinHeapFreeRatio=" + minRatio), + (useXmaxf ? "-Xmaxf" + maxRatio / 100.0 : "-XX:MaxHeapFreeRatio=" + maxRatio), + "-Xmx" + MAX_HEAP_SIZE, + "-Xms" + HEAP_SIZE, + "-XX:NewSize=" + NEW_SIZE, + "-XX:MaxNewSize=" + MAX_NEW_SIZE, + RatioVerifier.class.getName(), + Integer.toString(minRatio), + Integer.toString(maxRatio) + ); + + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + analyzer.shouldHaveExitValue(0); + } + + /** + * Verify that VM will fail to start with specified ratios. + * + * @param minRatio value of MinHeapFreeRatio option + * @param useXminf used Xminf option instead of MinHeapFreeRatio + * @param maxRatio value of MaxHeapFreeRatio option + * @param useXmaxf used Xmaxf option instead of MaxHeapFreeRatio + * @param options additional options for JVM + */ + public static void negativeTest(int minRatio, boolean useXminf, + int maxRatio, boolean useXmaxf, + LinkedList<String> options) throws Exception { + + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + (useXminf ? "-Xminf" + minRatio / 100.0 : "-XX:MinHeapFreeRatio=" + minRatio), + (useXmaxf ? "-Xmaxf" + maxRatio / 100.0 : "-XX:MaxHeapFreeRatio=" + maxRatio), + "-version" + ); + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + analyzer.shouldHaveExitValue(1); + analyzer.shouldContain("Error: Could not create the Java Virtual Machine."); + } + + /** + * RatioVerifier will be executed in the tested VM. + * It will check that real heap usage after collection lies between MinHeapFreeRatio and MaxHeapFreeRatio. + */ + public static class RatioVerifier { + + private static final Unsafe unsafe = Utils.getUnsafe(); + + // Size of byte array that will be allocated + public static final int CHUNK_SIZE = 1024; + // Length of byte array, that will be added to "garbage" list. + public static final int ARRAY_LENGTH = CHUNK_SIZE - Unsafe.ARRAY_BYTE_BASE_OFFSET; + // Amount of tries to force heap shrinking/expansion using GC + public static final int GC_TRIES = 10; + + // Value that will be added/substracted from expected min/max heap free ratio + // during memory allocation to make sure that specified limit will be exceeded. + public static final double OVERLOAD = 0.05; + // Acceptable heap free ratio limit exceedance: verification will fail if + // actual ratio is lower than expected min heap free ratio - VARIANCE or + // higher than expected max heap free ratio + VARIANCE. + public static final double VARIANCE = 0.025; + + public static LinkedList<Object> garbage = new LinkedList<>(); + + public static void main(String args[]) throws Exception { + if (args.length != 2) { + throw new IllegalArgumentException("Expected 2 args: <minRatio> <maxRatio>"); + } + if (GCTypes.OldGCType.getOldGCType() == GCTypes.OldGCType.PSOld) { + System.out.println("Test is not applicable to parallel GC"); + return; + } + + double minRatio = Integer.valueOf(args[0]) / 100.0; + double maxRatio = Integer.valueOf(args[1]) / 100.0; + + long maxHeapSize = getMax(); + + // commit 0.5 of total heap size to have enough space + // to both shink and expand + while (getCommitted() < maxHeapSize / 2) { + garbage.add(new byte[ARRAY_LENGTH]); + } + + forceGC(); + // Verify that current heap free ratio lies between specified limits + verifyRatio(minRatio, maxRatio); + + // Estimate how much memory we have to allocate to force expansion + long memoryToFill = (long) (getCommitted() * (1 - minRatio + OVERLOAD)) + - getUsed(); + + long previouslyCommitted = getCommitted(); + + while (memoryToFill > 0) { + garbage.add(new byte[CHUNK_SIZE]); + memoryToFill -= CHUNK_SIZE; + } + + forceGC(); + // Verify that after memory allocation heap free ratio is still conforming specified limits + verifyRatio(minRatio, maxRatio); + // Verify that heap was actually expanded + if (previouslyCommitted >= getCommitted()) { + throw new RuntimeException("Heap was not expanded."); + } + + // Estimate how much memory we have to free to force shrinking + long memoryToFree = getUsed() + - (long) (getCommitted() * (1 - maxRatio - OVERLOAD)); + + previouslyCommitted = getCommitted(); + + while (memoryToFree > 0 && garbage.size() > 0) { + garbage.remove(garbage.size() - 1); + memoryToFree -= CHUNK_SIZE; + } + + forceGC(); + // Verify that heap free ratio is still conforming specified limits + verifyRatio(minRatio, maxRatio); + // Verify that heap was actually shrinked + if (previouslyCommitted <= getCommitted()) { + throw new RuntimeException("Heap was not shrinked."); + } + + } + + public static void forceGC() { + for (int i = 0; i < GC_TRIES; i++) { + System.gc(); + try { + Thread.sleep(10); + } catch (InterruptedException ie) { + } + } + } + + /** + * Verify that heap free ratio is conforming specified limits. + * Actual heap free ratio may be very close to one of specified limits, + * but exceed for more then VARIANCE. + * Verification will also pass if actual ratio is not conforming limits, + * but it is not possible to shrink/expand heap. + */ + public static void verifyRatio(double minRatio, double maxRatio) { + double ratio = getHeapFreeRatio(); + System.out.println(minRatio + " " + ratio + " " + maxRatio); + if (minRatio - ratio > VARIANCE + && getCommitted() < getMax()) { + throw new RuntimeException("Current heap free ratio is lower than " + + "MinHeapFreeRatio (" + ratio + " vs " + minRatio + ")."); + } + if (ratio - maxRatio > VARIANCE + && getUsed() > getInit()) { + throw new RuntimeException("Current heap free ratio is higher than " + + "MaxHeapFreeRatio (" + ratio + " vs " + maxRatio + ")."); + } + } + + /* + * Obtain information about heap size. + * + * For G1 information summed up for all type of regions, + * because tested options affect overall heap sizing. + * + * For all other GCs return information only for old gen. + */ + public static long getMax() { + return HeapRegionUsageTool.getOldUsage().getMax(); + } + + public static long getInit() { + if (GCTypes.OldGCType.getOldGCType() == GCTypes.OldGCType.G1) { + return HeapRegionUsageTool.getEdenUsage().getInit() + + HeapRegionUsageTool.getSurvivorUsage().getInit() + + HeapRegionUsageTool.getOldUsage().getInit(); + } else { + return HeapRegionUsageTool.getOldUsage().getInit(); + } + } + + public static long getUsed() { + if (GCTypes.OldGCType.getOldGCType() == GCTypes.OldGCType.G1) { + return HeapRegionUsageTool.getEdenUsage().getUsed() + + HeapRegionUsageTool.getSurvivorUsage().getUsed() + + HeapRegionUsageTool.getOldUsage().getUsed(); + } else { + return HeapRegionUsageTool.getOldUsage().getUsed(); + } + } + + public static long getCommitted() { + if (GCTypes.OldGCType.getOldGCType() == GCTypes.OldGCType.G1) { + return HeapRegionUsageTool.getEdenUsage().getCommitted() + + HeapRegionUsageTool.getSurvivorUsage().getCommitted() + + HeapRegionUsageTool.getOldUsage().getCommitted(); + } else { + return HeapRegionUsageTool.getOldUsage().getCommitted(); + } + } + + public static long getFree() { + return getCommitted() - getUsed(); + } + + public static double getHeapFreeRatio() { + return getFree() / (double) getCommitted(); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestMinAndInitialSurvivorRatioFlags.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,206 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +/* + * @test TestMinAndInitialSurvivorRatioFlags + * @key gc + * @summary Verify that MinSurvivorRatio and InitialSurvivorRatio flags work + * @library /testlibrary /../../test/lib + * @modules java.base/sun.misc + * java.management + * @build TestMinAndInitialSurvivorRatioFlags + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * @run driver TestMinAndInitialSurvivorRatioFlags + */ + +import jdk.test.lib.AllocationHelper; +import java.lang.management.MemoryUsage; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import jdk.test.lib.HeapRegionUsageTool; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import sun.hotspot.WhiteBox; + +/* Test verifies that VM can start with any GC when MinSurvivorRatio and + * InitialSurvivorRatio flags passed and for Parallel GC it verifies that + * after start up survivor ratio equal to InitialSurvivorRatio value and + * that actual survivor ratio will never be less than MinSurvivorRatio. + */ +public class TestMinAndInitialSurvivorRatioFlags { + + public static final long M = 1024 * 1024; + public static final long HEAP_SIZE = 200 * M; + public static final long NEW_SIZE = 100 * M; + + public static void main(String args[]) throws Exception { + LinkedList<String> options = new LinkedList<>( + Arrays.asList(Utils.getFilteredTestJavaOpts("-XX:[^ ]*SurvivorRatio=[^ ]+")) + ); + + testSurvivorRatio(5, -1, -1, options, true); + testSurvivorRatio(10, -1, -1, options, true); + testSurvivorRatio(-1, 5, 3, options, true); + testSurvivorRatio(-1, 15, 3, options, true); + testSurvivorRatio(-1, 15, 3, options, false); + testSurvivorRatio(-1, 10, 10, options, true); + testSurvivorRatio(-1, 3, 15, options, true); + testSurvivorRatio(-1, 3, 15, options, false); + } + + /** + * Test that MinSurvivorRatio and InitialSurvivorRatio flags work. + * + * @param survivorRatio value for -XX:SurvivorRatio option, omitted if negative + * @param initRatio value for -XX:InitialSurvivorRatio option, omitted if negative + * @param minRatio value for -XX:MinSurvivorRatio option, omitted if negative + * @param options additional options for VM + * @param useAdaptiveSizePolicy turn on or off UseAdaptiveSizePolicy option + */ + public static void testSurvivorRatio(int survivorRatio, + int initRatio, + int minRatio, + LinkedList<String> options, + boolean useAdaptiveSizePolicy) throws Exception { + + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + "-Xbootclasspath/a:.", + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+WhiteBoxAPI", + "-XX:MaxNewSize=" + NEW_SIZE, "-XX:NewSize=" + NEW_SIZE, + "-Xmx" + HEAP_SIZE, "-Xms" + HEAP_SIZE, + (survivorRatio >= 0 ? "-XX:SurvivorRatio=" + survivorRatio : ""), + (initRatio >= 0 ? "-XX:InitialSurvivorRatio=" + initRatio : ""), + (minRatio >= 0 ? "-XX:MinSurvivorRatio=" + minRatio : ""), + (useAdaptiveSizePolicy ? "-XX:+UseAdaptiveSizePolicy" : "-XX:-UseAdaptiveSizePolicy"), + SurvivorRatioVerifier.class.getName(), + Integer.toString(survivorRatio), + Integer.toString(initRatio), + Integer.toString(minRatio), + Boolean.toString(useAdaptiveSizePolicy) + ); + vmOptions.removeIf((String p) -> p.isEmpty()); + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + analyzer.shouldHaveExitValue(0); + } + + /** + * Class that verifies survivor ratio. + * Will be executed in tested VM. Checks initial size of eden and survivor paces with alignment. + */ + public static class SurvivorRatioVerifier { + + public static WhiteBox wb = WhiteBox.getWhiteBox(); + + public static final int MAX_ITERATIONS = 10; + public static final int ARRAY_LENGTH = 10000; + public static final int CHUNK_SIZE = 10000; + + public static byte garbage[][] = new byte[ARRAY_LENGTH][]; + + public static void main(String args[]) throws Exception { + if (args.length != 4) { + throw new IllegalArgumentException("Expected 4 args: <survivorRatio> <initRatio> <minRatio> <useAdaptiveSizePolicy>"); + } + final int survivorRatio = Integer.valueOf(args[0]); + final int initRatio = Integer.valueOf(args[1]); + final int minRatio = Integer.valueOf(args[2]); + final boolean useAdaptiveSizePolicy = Boolean.valueOf(args[3]); + + // we stop testing only here to ensure that JVM will accept + // both MinSurvivorRatio and InitialSurvivorRatio regardles to GC + if (GCTypes.YoungGCType.getYoungGCType() != GCTypes.YoungGCType.PSNew) { + System.out.println("Test is only applicable to Parallel GC"); + return; + } + + // verify initial survivor ratio + verifySurvivorRatio(survivorRatio, initRatio, minRatio, useAdaptiveSizePolicy, true); + + // force GC + AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE, + () -> (verifySurvivorRatio(survivorRatio, initRatio, minRatio, useAdaptiveSizePolicy, false))); + allocator.allocateMemoryAndVerify(); + } + + /** + * Verify actual survivor ratio. + * + * @param survivorRatio value of SurvivorRatio option, omitted if negative + * @param initRatio value of InitialSurvivorRatio option, omitted if negative + * @param minRatio value of MinSurvivorRatio option, omitted if negative + * @param useAdaptiveSizePolicy value of UseAdaptiveSizePolicy option + * @param verifyInitialRatio true if we are going to verify initial ratio + */ + public static Void verifySurvivorRatio(int survivorRatio, + int initRatio, + int minRatio, + boolean useAdaptiveSizePolicy, + boolean verifyInitialRatio) { + + MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage(); + MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage(); + + long alignedNewSize = edenUsage.getMax() + 2 * survivorUsage.getMax(); + long generationAlignment = wb.psHeapGenerationAlignment(); + + if (survivorRatio >= 0) { + // -XX:SurvivorRatio was passed to JVM, actual ratio should be SurvivorRatio + 2 + long expectedSize = HeapRegionUsageTool.alignDown(alignedNewSize / (survivorRatio + 2), + generationAlignment); + + if (survivorUsage.getCommitted() != expectedSize) { + throw new RuntimeException("Expected survivor size is: " + expectedSize + + ", but observed size is: " + survivorUsage.getCommitted()); + } + } else if (verifyInitialRatio || !useAdaptiveSizePolicy) { + // In case of initial ratio verification or disabled adaptive size policy + // ratio should be equal to InitialSurvivorRatio value + long expectedSize = HeapRegionUsageTool.alignDown(alignedNewSize / initRatio, + generationAlignment); + if (survivorUsage.getCommitted() != expectedSize) { + throw new RuntimeException("Expected survivor size is: " + expectedSize + + ", but observed size is: " + survivorUsage.getCommitted()); + } + } else { + // In any other case actual survivor ratio should not be lower than MinSurvivorRatio + // or is should be equal to InitialSurvivorRatio + long expectedMinSize = HeapRegionUsageTool.alignDown(alignedNewSize / minRatio, + generationAlignment); + long expectedInitSize = HeapRegionUsageTool.alignDown(alignedNewSize / initRatio, + generationAlignment); + if (survivorUsage.getCommitted() != expectedInitSize + && survivorUsage.getCommitted() < expectedMinSize) { + throw new RuntimeException("Expected survivor size should be " + expectedMinSize + + " or should be greater then " + expectedMinSize + + ", but observer survivor size is " + survivorUsage.getCommitted()); + } + } + return null; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestNewRatioFlag.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,182 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +/* + * @test TestNewRatioFlag + * @key gc + * @bug 8025166 + * @summary Verify that heap devided among generations according to NewRatio + * @library /testlibrary /../../test/lib + * @modules java.base/sun.misc + * java.management + * @build TestNewRatioFlag + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * @run driver TestNewRatioFlag + */ + +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import jdk.test.lib.HeapRegionUsageTool; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import sun.hotspot.WhiteBox; + +public class TestNewRatioFlag { + + public static final long M = 1024 * 1024; + public static final long HEAP_SIZE = 100 * M; + + public static void main(String args[]) throws Exception { + LinkedList<String> options = new LinkedList<>( + Arrays.asList(Utils.getFilteredTestJavaOpts("(-XX:[^ ]*NewSize=[^ ]+)|(-Xm[ns][^ ]+)")) + ); + + testNewRatio(4, options); + testNewRatio(6, options); + testNewRatio(10, options); + testNewRatio(15, options); + testNewRatio(20, options); + } + + /** + * Verify that actual size of young gen conforms specified NewRatio + * + * @param ratio value of NewRatio option + * @param options additional options for VM + */ + public static void testNewRatio(int ratio, LinkedList<String> options) throws Exception { + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + "-Xbootclasspath/a:.", + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+WhiteBoxAPI", + "-XX:GCLockerEdenExpansionPercent=0", + "-Xmx" + HEAP_SIZE, + "-Xms" + HEAP_SIZE, + "-XX:NewRatio=" + ratio, + "-XX:-UseLargePages", + NewRatioVerifier.class.getName(), + Integer.toString(ratio) + ); + + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + analyzer.shouldHaveExitValue(0); + System.out.println(analyzer.getOutput()); + } + + public static class NewRatioVerifier { + + static WhiteBox wb = WhiteBox.getWhiteBox(); + + public static void main(String args[]) { + if (args.length != 1) { + throw new IllegalArgumentException("Expected 1 arg: <expectedRatio>"); + } + int expectedRatio = Integer.valueOf(args[0]); + switch (GCTypes.YoungGCType.getYoungGCType()) { + case DefNew: + case ParNew: + verifyDefNewNewRatio(expectedRatio); + break; + case PSNew: + verifyPSNewRatio(expectedRatio); + break; + case G1: + verifyG1NewRatio(expectedRatio); + break; + default: + throw new RuntimeException("Unexpected young GC type"); + } + } + + /** + * Verify NewSize for DefNew and ParNew collectors. + * + * Compare expected NewSize calculated according to sizing policies used by DefNew + * with NewSize value reported by MemoryPoolMXBeans. + */ + public static void verifyDefNewNewRatio(int expectedRatio) { + long initEden = HeapRegionUsageTool.getEdenUsage().getInit(); + long initSurv = HeapRegionUsageTool.getSurvivorUsage().getInit(); + long initOld = HeapRegionUsageTool.getOldUsage().getInit(); + + long newSize = initEden + 2 * initSurv; + + long expectedNewSize = HeapRegionUsageTool.alignDown(initOld / expectedRatio, + wb.getHeapSpaceAlignment()); + + if (expectedNewSize != newSize) { + throw new RuntimeException("Expected young gen size is: " + expectedNewSize + + ", but observed new size is: " + newSize); + } + } + + /** + * Verify NewSize for PS collector. + * Expected NewSize calculated according to alignment policies used by PS + * and then compared with actual NewSize obtained from MemoryPoolMXBeans. + */ + public static void verifyPSNewRatio(int expectedRatio) { + long initEden = HeapRegionUsageTool.getEdenUsage().getInit(); + long initSurv = HeapRegionUsageTool.getSurvivorUsage().getInit(); + long initOld = HeapRegionUsageTool.getOldUsage().getInit(); + + long newSize = initEden + 2 * initSurv; + + long alignedDownNewSize = HeapRegionUsageTool.alignDown(initOld / expectedRatio, + wb.getHeapSpaceAlignment()); + long expectedNewSize = HeapRegionUsageTool.alignUp(alignedDownNewSize, + wb.psVirtualSpaceAlignment()); + + if (expectedNewSize != newSize) { + throw new RuntimeException("Expected young gen size is: " + expectedNewSize + + ", but observed new size is: " + newSize); + } + } + + /** + * Verify NewSize for G1 GC. + * Amount of young regions calculated according to sizing policies used by G1 + * and then compared with actual number of young regions derived from + * values reported by MemoryPoolMXBeans and region size. + */ + public static void verifyG1NewRatio(int expectedRatio) { + long initEden = HeapRegionUsageTool.getEdenUsage().getInit(); + long initSurv = HeapRegionUsageTool.getSurvivorUsage().getInit(); + long maxOld = HeapRegionUsageTool.getOldUsage().getMax(); + + int regionSize = wb.g1RegionSize(); + int youngListLength = (int) ((initEden + initSurv) / regionSize); + int maxRegions = (int) (maxOld / regionSize); + int expectedYoungListLength = (int) (maxRegions / (double) (expectedRatio + 1)); + + if (youngListLength != expectedYoungListLength) { + throw new RuntimeException("Expected G1 young list length is: " + expectedYoungListLength + + ", but observed young list length is: " + youngListLength); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestNewSizeFlags.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,296 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestNewSizeFlags + * @key gc + * @bug 8025166 + * @summary Verify that young gen size conforms values specified by NewSize, MaxNewSize and Xmn options + * @library /testlibrary /../../test/lib + * @modules java.base/sun.misc + * java.management + * @build TestNewSizeFlags + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * @run driver/timeout=240 TestNewSizeFlags + */ + +import jdk.test.lib.AllocationHelper; +import java.io.IOException; +import java.lang.management.MemoryUsage; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import jdk.test.lib.HeapRegionUsageTool; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import sun.hotspot.WhiteBox; + +public class TestNewSizeFlags { + + public static final long M = 1024 * 1024; + + public static void main(String args[]) throws Exception { + LinkedList<String> options = new LinkedList<>( + Arrays.asList(Utils.getFilteredTestJavaOpts("(-Xm[nsx][^ ]+)|" + + "(-XX:(Max)?((New)|" + + "(Heap))((Size)|" + + "(Ratio))=[^ ]+)")) + ); + + // Test NewSize and MaxNewSize + testNewSizeFlags(20 * M, 10 * M, 30 * M, 40 * M, options, false); + testNewSizeFlags(10 * M, 20 * M, 30 * M, 40 * M, options, false); + testNewSizeFlags(-1, 20 * M, 30 * M, 40 * M, options, false); + testNewSizeFlags(10 * M, -1, 30 * M, 40 * M, options, false); + testNewSizeFlags(20 * M, 20 * M, 30 * M, 40 * M, options, false); + testNewSizeFlags(20 * M, 30 * M, 40 * M, 50 * M, options, false); + testNewSizeFlags(30 * M, 100 * M, 150 * M, 200 * M, options, false); + testNewSizeFlags(0, -1, 30 * M, 40 * M, options, false); + + // Test -Xmn + testXmnFlags(0, 30 * M, 40 * M, options, true); + testXmnFlags(20 * M, 30 * M, 40 * M, options, false); + testXmnFlags(50 * M, 70 * M, 100 * M, options, false); + } + + /** + * Verify that NewSize and MaxNewSize flags affect young gen size. + * + * @param newSize value of NewSize option, omitted if negative + * @param maxNewSize value of MaxNewSize option, omitted if negative + * @param heapSize value of HeapSize option + * @param maxHeapSize value of MaxHeapSize option + * @param options additional options for JVM + * @param failureExpected true if JVM should fail with passed heap size options + */ + public static void testNewSizeFlags(long newSize, long maxNewSize, + long heapSize, long maxHeapSize, + LinkedList<String> options, + boolean failureExpected) throws Exception { + testVMOptions(newSize, maxNewSize, + heapSize, maxHeapSize, + newSize, (maxNewSize >= 0 ? Math.max(maxNewSize, newSize) : maxNewSize), + options, failureExpected); + } + + /** + * Verify that -Xmn flag affect young gen size. + * + * @param mnValue value of -Xmn option + * @param heapSize value of HeapSize option + * @param maxHeapSize value of MaxHeapSize option + * @param options additional options for JVM + * @param failureExpected true if JVM should fail with passed heap size options + */ + public static void testXmnFlags(long mnValue, + long heapSize, long maxHeapSize, + LinkedList<String> options, + boolean failureExpected) throws Exception { + LinkedList<String> newOptions = new LinkedList<>(options); + newOptions.add("-Xmn" + mnValue); + testVMOptions(-1, -1, + heapSize, maxHeapSize, + mnValue, mnValue, + newOptions, failureExpected); + } + + /** + * Verify that NewSize and MaxNewSize flags affect young gen size. + * + * @param newSize value of NewSize option, omitted if negative + * @param maxNewSize value of MaxNewSize option, omitted if negative + * @param heapSize value of HeapSize option + * @param maxHeapSize value of MaxHeapSize option + * @param expectedNewSize expected initial young gen size + * @param expectedMaxNewSize expected max young gen size + * @param options additional options for JVM + * @param failureExpected true if JVM should fail with passed heap size options + */ + public static void testVMOptions(long newSize, long maxNewSize, + long heapSize, long maxHeapSize, + long expectedNewSize, long expectedMaxNewSize, + LinkedList<String> options, boolean failureExpected) throws Exception { + OutputAnalyzer analyzer = startVM(options, newSize, maxNewSize, heapSize, maxHeapSize, expectedNewSize, expectedMaxNewSize); + + if (failureExpected) { + analyzer.shouldHaveExitValue(1); + analyzer.shouldMatch("(Error occurred during initialization of VM)|" + + "(Error: Could not create the Java Virtual Machine.)"); + } else { + analyzer.shouldHaveExitValue(0); + } + } + + private static OutputAnalyzer startVM(LinkedList<String> options, + long newSize, long maxNewSize, + long heapSize, long maxHeapSize, + long expectedNewSize, long expectedMaxNewSize) throws Exception, IOException { + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + "-Xbootclasspath/a:.", + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+WhiteBoxAPI", + (newSize >= 0 ? "-XX:NewSize=" + newSize : ""), + (maxNewSize >= 0 ? "-XX:MaxNewSize=" + maxNewSize : ""), + "-Xmx" + maxHeapSize, + "-Xms" + heapSize, + "-XX:GCLockerEdenExpansionPercent=0", + "-XX:-UseLargePages", + NewSizeVerifier.class.getName(), + Long.toString(expectedNewSize), + Long.toString(expectedMaxNewSize) + ); + vmOptions.removeIf(String::isEmpty); + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + return analyzer; + } + + /** + * NewSizeVerifier checks that initial young gen size is equal to expected + * regardful to alignment and that young gen size will not be greater than + * expected max size. + * In order to verify that young gen size will not be greater then expected + * max size, NewSizeVerifier do some object allocation to force garbage + * collection and heap expansion. + */ + public static class NewSizeVerifier { + + static WhiteBox wb = WhiteBox.getWhiteBox(); + + public static final int ARRAY_LENGTH = 100; + public static final int CHUNK_SIZE = 1024; + public static final int MAX_ITERATIONS = 10; + public static byte garbage[][] = new byte[ARRAY_LENGTH][]; + + public static void main(String args[]) throws Exception { + if (args.length != 2) { + throw new IllegalArgumentException("Expected 2 args: <expectedNewSize> <expectedMaxNewSize>"); + } + final long newSize = Long.valueOf(args[0]); + final long maxNewSize = Long.valueOf(args[1]); + + // verify initial size + verifyNewSize(newSize, maxNewSize); + + // force GC and verify that size is still correct + AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE, () -> (verifyNewSize(newSize, maxNewSize))); + allocator.allocateMemoryAndVerifyNoOOME(); + } + + /** + * Verify that actual young gen size conforms NewSize and MaxNewSize values. + */ + public static Void verifyNewSize(long newSize, long maxNewSize) { + long alignedNewSize = alignNewSize(newSize); + long alignedMaxNewSize = alignNewSize(maxNewSize); + + MemoryUsage youngGenUsage = getYoungGenUsage(); + + if (newSize != -1) { + if (youngGenUsage.getInit() < alignedNewSize) { + throw new RuntimeException("initial new size < NewSize value: " + + youngGenUsage.getInit() + " < " + alignedNewSize); + } + + if (youngGenUsage.getCommitted() < alignedNewSize) { + throw new RuntimeException("actual new size < NewSize value: " + + youngGenUsage.getCommitted() + " < " + alignedNewSize); + } + + // for G1 max new size == committed new size + if (GCTypes.YoungGCType.getYoungGCType() != GCTypes.YoungGCType.G1 + && youngGenUsage.getMax() < alignedNewSize) { + throw new RuntimeException("max new size < NewSize value: " + + youngGenUsage.getMax() + " < " + alignedNewSize); + } + } + + if (maxNewSize != -1) { + if (youngGenUsage.getInit() > alignedMaxNewSize) { + throw new RuntimeException("initial new size > MaxNewSize value: " + + youngGenUsage.getInit() + " > " + alignedMaxNewSize); + } + + if (youngGenUsage.getCommitted() > alignedMaxNewSize) { + throw new RuntimeException("actual new size > MaxNewSize value: " + + youngGenUsage.getCommitted() + " > " + alignedMaxNewSize); + } + + if (GCTypes.YoungGCType.getYoungGCType() != GCTypes.YoungGCType.G1 + && youngGenUsage.getMax() != alignedMaxNewSize) { + throw new RuntimeException("max new size != MaxNewSize value: " + + youngGenUsage.getMax() + " != " + alignedMaxNewSize); + } + } + return null; + } + + /** + * Get young gen memory usage. + * + * For G1 it is EdenUsage + SurvivorUsage, + * for other GCs it is EdenUsage + 2 * SurvivorUsage. + * For G1 max value is just LONG_MAX. + * For all GCs used value is 0. + */ + private static MemoryUsage getYoungGenUsage() { + if (GCTypes.YoungGCType.getYoungGCType() == GCTypes.YoungGCType.G1) { + return new MemoryUsage(HeapRegionUsageTool.getEdenUsage().getInit() + + HeapRegionUsageTool.getSurvivorUsage().getInit(), + 0, + HeapRegionUsageTool.getEdenUsage().getCommitted() + + HeapRegionUsageTool.getSurvivorUsage().getCommitted(), + Long.MAX_VALUE); + } else { + return new MemoryUsage(HeapRegionUsageTool.getEdenUsage().getInit() + + HeapRegionUsageTool.getSurvivorUsage().getInit() * 2, + 0, + HeapRegionUsageTool.getEdenUsage().getCommitted() + + HeapRegionUsageTool.getSurvivorUsage().getCommitted() * 2, + HeapRegionUsageTool.getEdenUsage().getMax() + + HeapRegionUsageTool.getSurvivorUsage().getMax() * 2); + } + } + + /** + * Align value regardful to used young GC. + */ + public static long alignNewSize(long value) { + switch (GCTypes.YoungGCType.getYoungGCType()) { + case DefNew: + case ParNew: + return HeapRegionUsageTool.alignDown(value, wb.getHeapSpaceAlignment()); + case PSNew: + return HeapRegionUsageTool.alignUp(HeapRegionUsageTool.alignDown(value, + wb.getHeapSpaceAlignment()), + wb.psVirtualSpaceAlignment()); + case G1: + return HeapRegionUsageTool.alignUp(value, wb.g1RegionSize()); + default: + throw new RuntimeException("Unexpected young GC type"); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestSurvivorRatioFlag.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,182 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +/* + * @test TestSurvivorRatioFlag + * @key gc + * @summary Verify that actual survivor ratio is equal to specified SurvivorRatio value + * @library /testlibrary /../../test/lib + * @modules java.base/sun.misc + * java.management + * @build TestSurvivorRatioFlag + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * @run driver TestSurvivorRatioFlag + */ + +import jdk.test.lib.AllocationHelper; +import java.lang.management.MemoryUsage; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import jdk.test.lib.HeapRegionUsageTool; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import sun.hotspot.WhiteBox; + +public class TestSurvivorRatioFlag { + + public static final long M = 1024 * 1024; + public static final long HEAP_SIZE = 200 * M; + public static final long NEW_SIZE = 100 * M; + + public static void main(String args[]) throws Exception { + LinkedList<String> options = new LinkedList<>( + Arrays.asList(Utils.getFilteredTestJavaOpts("-XX:[^ ]*SurvivorRatio=[^ ]+")) + ); + + testSurvivorRatio(3, options); + testSurvivorRatio(6, options); + testSurvivorRatio(10, options); + testSurvivorRatio(15, options); + testSurvivorRatio(20, options); + } + + /** + * Verify that actual survivor ratio equal to specified. + * + * @param ratio survivor ratio that be verified + * @param options additional options to JVM + */ + public static void testSurvivorRatio(int ratio, LinkedList<String> options) throws Exception { + + LinkedList<String> vmOptions = new LinkedList<>(options); + + Collections.addAll(vmOptions, + "-Xbootclasspath/a:.", + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+WhiteBoxAPI", + "-XX:GCLockerEdenExpansionPercent=0", + "-XX:MaxNewSize=" + NEW_SIZE, + "-XX:NewSize=" + NEW_SIZE, + "-Xmx" + HEAP_SIZE, + "-Xms" + HEAP_SIZE, + "-XX:SurvivorRatio=" + ratio, + SurvivorRatioVerifier.class.getName(), + Integer.toString(ratio) + ); + + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + analyzer.shouldHaveExitValue(0); + } + + /** + * Class that verifies survivor ratio. + */ + public static class SurvivorRatioVerifier { + + static WhiteBox wb = WhiteBox.getWhiteBox(); + + public static final int MAX_ITERATIONS = 10; + public static final int ARRAY_LENGTH = 10000; + public static final int CHUNK_SIZE = 10000; + + public static void main(String args[]) throws Exception { + if (args.length != 1) { + throw new IllegalArgumentException("Expected 1 arg: <ratio>"); + } + final int ratio = Integer.valueOf(args[0]); + + AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE, () -> (verifySurvivorRatio(ratio))); + allocator.allocateMemoryAndVerify(); + } + + /** + * Verify that actual survivor ratio is equal to expected. + * Depending on selected young GC we verify that: + * - for DefNew and ParNew: eden_size / survivor_size is close to expectedRatio; + * - for PSNew: survivor_size equal to young_gen_size / expectedRatio; + * - for G1: survivor_regions <= young_list_length / expectedRatio. + */ + public static Void verifySurvivorRatio(int expectedRatio) { + GCTypes.YoungGCType type = GCTypes.YoungGCType.getYoungGCType(); + switch (type) { + case DefNew: + case ParNew: + verifyDefNewSurvivorRatio(expectedRatio); + break; + case PSNew: + verifyPSSurvivorRatio(expectedRatio); + break; + case G1: + verifyG1SurvivorRatio(expectedRatio); + break; + default: + throw new RuntimeException("Unexpected young GC type"); + } + return null; + } + + private static void verifyDefNewSurvivorRatio(int expectedRatio) { + MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage(); + MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage(); + + int actualRatio = (int) (edenUsage.getCommitted() / survivorUsage.getCommitted()); + if (Math.abs(actualRatio - expectedRatio) > 1) { + throw new RuntimeException("Expected survivor ratio is: " + expectedRatio + + ", but observed ratio is: " + actualRatio); + } + } + + private static void verifyPSSurvivorRatio(int expectedRatio) { + MemoryUsage edenUsage = HeapRegionUsageTool.getEdenUsage(); + MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage(); + + long youngGenSize = edenUsage.getMax() + 2 * survivorUsage.getMax(); + // for Paralle GC Min/InitialSurvivorRatio = SurvivorRatio + 2 + long expectedSize = HeapRegionUsageTool.alignDown(youngGenSize / (expectedRatio + 2), + wb.psHeapGenerationAlignment()); + + if (expectedSize != survivorUsage.getCommitted()) { + throw new RuntimeException("Expected survivor size is: " + expectedSize + + ", but observed size is: " + survivorUsage.getCommitted()); + } + } + + private static void verifyG1SurvivorRatio(int expectedRatio) { + MemoryUsage survivorUsage = HeapRegionUsageTool.getSurvivorUsage(); + + int regionSize = wb.g1RegionSize(); + int youngListLength = (int) Math.max(NEW_SIZE / regionSize, 1); + int expectedSurvivorRegions = (int) Math.ceil(youngListLength / (double) expectedRatio); + int observedSurvivorRegions = (int) (survivorUsage.getCommitted() / regionSize); + + if (expectedSurvivorRegions < observedSurvivorRegions) { + throw new RuntimeException("Expected amount of G1 survivor regions is " + + expectedSurvivorRegions + ", but observed " + + observedSurvivorRegions); + } + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/arguments/TestTargetSurvivorRatioFlag.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,319 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +/* + * @test TestTargetSurvivorRatioFlag + * @key gc + * @summary Verify that option TargetSurvivorRatio affects survivor space occupancy after minor GC. + * @library /testlibrary /../../test/lib + * @modules java.base/sun.misc + * java.management + * @build TestTargetSurvivorRatioFlag + * @run main ClassFileInstaller sun.hotspot.WhiteBox + * @run driver TestTargetSurvivorRatioFlag + */ + +import jdk.test.lib.AllocationHelper; +import java.lang.management.GarbageCollectorMXBean; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import jdk.test.lib.HeapRegionUsageTool; +import sun.misc.Unsafe; +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.ProcessTools; +import jdk.test.lib.Utils; +import sun.hotspot.WhiteBox; + +/* In order to test that TargetSurvivorRatio affects survivor space occupancy + * we setup fixed MaxTenuringThreshold and then verifying that if size of allocated + * objects is lower than (survivor_size * TargetSurvivorRatio / 100) then objects + * will stay in survivor space until MaxTenuringThreshold minor GC cycles. + * If more than (survivor_size * TargetSurvivorRatio / 100) objects were allocated, + * then we verify that after MaxTenuringThreshold minor GC cycles survivor space + * is almost empty. + */ +public class TestTargetSurvivorRatioFlag { + + public static final long M = 1024 * 1024; + + // VM option values + public static final long MAX_NEW_SIZE = 40 * M; + public static final int SURVIVOR_RATIO = 8; + public static final int MAX_TENURING_THRESHOLD = 15; + + // Value used to estimate amount of memory that should be allocated + // and placed in survivor space. + public static final double DELTA = 0.25; + + // Max variance of observed ratio + public static double VARIANCE = 1; + + // Messages used by debuggee + public static final String UNSUPPORTED_GC = "Unsupported GC"; + public static final String START_TEST = "Start test"; + public static final String END_TEST = "End test"; + + // Patterns used during log parsing + public static final String TENURING_DISTRIBUTION = "Desired survivor size"; + public static final String AGE_TABLE_ENTRY = "-[\\s]+age[\\s]+([0-9]+):[\\s]+([0-9]+)[\\s]+bytes,[\\s]+([0-9]+)[\\s]+total"; + public static final String MAX_SURVIVOR_SIZE = "Max survivor size: ([0-9]+)"; + + public static void main(String args[]) throws Exception { + + LinkedList<String> options = new LinkedList<>(Arrays.asList(Utils.getTestJavaOpts())); + + // Need to consider the effect of TargetPLABWastePct=1 for G1 GC + if (options.contains("-XX:+UseG1GC")) { + VARIANCE = 2; + } else { + VARIANCE = 1; + } + + negativeTest(-1, options); + negativeTest(101, options); + + positiveTest(20, options); + positiveTest(30, options); + positiveTest(55, options); + positiveTest(70, options); + } + + /** + * Verify that VM will fail to start with specified TargetSurvivorRatio + * + * @param ratio value of TargetSurvivorRatio + * @param options additional VM options + */ + public static void negativeTest(int ratio, LinkedList<String> options) throws Exception { + LinkedList<String> vmOptions = new LinkedList<>(options); + vmOptions.add("-XX:TargetSurvivorRatio=" + ratio); + vmOptions.add("-version"); + + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + + analyzer.shouldHaveExitValue(1); + analyzer.shouldContain("Error: Could not create the Java Virtual Machine."); + } + + /** + * Verify that actual survivor space usage ratio conforms specified TargetSurvivorRatio + * + * @param ratio value of TargetSurvivorRatio + * @param options additional VM options + */ + public static void positiveTest(int ratio, LinkedList<String> options) throws Exception { + LinkedList<String> vmOptions = new LinkedList<>(options); + Collections.addAll(vmOptions, + "-Xbootclasspath/a:.", + "-XX:+UnlockDiagnosticVMOptions", + "-XX:+WhiteBoxAPI", + "-XX:+UseAdaptiveSizePolicy", + "-XX:+PrintTenuringDistribution", + "-XX:MaxTenuringThreshold=" + MAX_TENURING_THRESHOLD, + "-XX:NewSize=" + MAX_NEW_SIZE, + "-XX:MaxNewSize=" + MAX_NEW_SIZE, + "-XX:InitialHeapSize=" + 2 * MAX_NEW_SIZE, + "-XX:MaxHeapSize=" + 2 * MAX_NEW_SIZE, + "-XX:SurvivorRatio=" + SURVIVOR_RATIO, + "-XX:TargetSurvivorRatio=" + ratio, + // For reducing variance of survivor size. + "-XX:TargetPLABWastePct=" + 1, + TargetSurvivorRatioVerifier.class.getName(), + Integer.toString(ratio) + ); + + ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(vmOptions.toArray(new String[vmOptions.size()])); + OutputAnalyzer analyzer = new OutputAnalyzer(procBuilder.start()); + + analyzer.shouldHaveExitValue(0); + + String output = analyzer.getOutput(); + + // Test avoids verification for parallel GC + if (!output.contains(UNSUPPORTED_GC)) { + // Two tests should be done - when actual ratio is lower than TargetSurvivorRatio + // and when it is higher. We chech that output contains results for exactly two tests. + List<Double> ratios = parseTestOutput(output); + + if (ratios.size() != 2) { + System.out.println(output); + throw new RuntimeException("Expected number of ratios extraced for output is 2," + + " but " + ratios.size() + " ratios were extracted"); + } + + // At the end of the first test survivor space usage ratio should lies between + // TargetSurvivorRatio and TargetSurvivorRatio - 2*DELTA + if (ratio < ratios.get(0) || ratio - ratios.get(0) > VARIANCE) { + System.out.println(output); + throw new RuntimeException("Survivor space usage ratio expected to be close to " + + ratio + ", but observed ratio is: " + ratios.get(0)); + } + + // After second test survivor space should be almost empty. + if (ratios.get(1) > VARIANCE) { + System.out.println(output); + throw new RuntimeException("Survivor space expected to be empty due to " + + "TargetSurvivorRatio overlimit, however observed " + + "survivor space usage ratio is: " + ratios.get(1)); + } + } else { + System.out.println("Selected GC does not support TargetSurvivorRatio option."); + } + } + + /** + * Parse output produced by TargetSurvivorRatioVerifier. + * + * @param output output obtained from TargetSurvivorRatioVerifier + * @return list of parsed test results, where each result is an actual + * survivor ratio after MaxTenuringThreshold minor GC cycles. + */ + public static List<Double> parseTestOutput(String output) { + List<Double> ratios = new LinkedList<Double>(); + String lines[] = output.split("[\n\r]"); + boolean testStarted = false; + long survivorSize = 0; + long survivorOccupancy = 0; + int gcCount = 0; + Pattern ageTableEntry = Pattern.compile(AGE_TABLE_ENTRY); + Pattern maxSurvivorSize = Pattern.compile(MAX_SURVIVOR_SIZE); + for (String line : lines) { + if (Pattern.matches(MAX_SURVIVOR_SIZE, line)) { + // We found estimated survivor space size + Matcher m = maxSurvivorSize.matcher(line); + m.find(); + survivorSize = Long.valueOf(m.group(1)); + } else if (line.contains(START_TEST) && !testStarted) { + // Start collecting test results + testStarted = true; + gcCount = 0; + } else if (testStarted) { + if (line.contains(TENURING_DISTRIBUTION)) { + // We found start of output emitted by -XX:+PrintTenuringDistribution + // If it is associated with "MaxTenuringThreshold" GC cycle, then it's + // time to report observed survivor usage ratio + gcCount++; + double survivorRatio = survivorOccupancy / (double) survivorSize; + if (gcCount == MAX_TENURING_THRESHOLD || gcCount == MAX_TENURING_THRESHOLD * 2) { + ratios.add(survivorRatio * 100.0); + testStarted = false; + } + survivorOccupancy = 0; + } else if (Pattern.matches(AGE_TABLE_ENTRY, line)) { + // Obtain survivor space usage from "total" age table log entry + Matcher m = ageTableEntry.matcher(line); + m.find(); + survivorOccupancy = Long.valueOf(m.group(3)); + } else if (line.contains(END_TEST)) { + // It is expected to find at least MaxTenuringThreshold GC events + // until test end + if (gcCount < MAX_TENURING_THRESHOLD) { + throw new RuntimeException("Observed " + gcCount + " GC events, " + + "while it is expected to see at least " + + MAX_TENURING_THRESHOLD); + } + testStarted = false; + } + } + } + return ratios; + } + + public static class TargetSurvivorRatioVerifier { + + static final WhiteBox wb = WhiteBox.getWhiteBox(); + static final Unsafe unsafe = Utils.getUnsafe(); + + // Desired size of memory allocated at once + public static final int CHUNK_SIZE = 1024; + // Length of byte[] array that will have occupy CHUNK_SIZE bytes in heap + public static final int ARRAY_LENGTH = CHUNK_SIZE - Unsafe.ARRAY_BYTE_BASE_OFFSET; + + public static void main(String args[]) throws Exception { + if (args.length != 1) { + throw new IllegalArgumentException("Expected 1 arg: <ratio>"); + } + if (GCTypes.YoungGCType.getYoungGCType() == GCTypes.YoungGCType.PSNew) { + System.out.println(UNSUPPORTED_GC); + return; + } + + int ratio = Integer.valueOf(args[0]); + long maxSurvivorSize = getMaxSurvivorSize(); + System.out.println("Max survivor size: " + maxSurvivorSize); + + allocateMemory(ratio - DELTA, maxSurvivorSize); + allocateMemory(ratio + DELTA, maxSurvivorSize); + } + + /** + * Allocate (<b>ratio</b> * <b>maxSize</b> / 100) bytes of objects + * and force at least "MaxTenuringThreshold" minor GCs. + * + * @param ratio ratio used to calculate how many objects should be allocated + * @param maxSize estimated max survivor space size + */ + public static void allocateMemory(double ratio, long maxSize) throws Exception { + GarbageCollectorMXBean youngGCBean = GCTypes.YoungGCType.getYoungGCBean(); + long garbageSize = (long) (maxSize * (ratio / 100.0)); + int arrayLength = (int) (garbageSize / CHUNK_SIZE); + AllocationHelper allocator = new AllocationHelper(1, arrayLength, ARRAY_LENGTH, null); + + System.out.println(START_TEST); + System.gc(); + final long initialGcId = youngGCBean.getCollectionCount(); + // allocate memory + allocator.allocateMemoryAndVerify(); + + // force minor GC + while (youngGCBean.getCollectionCount() <= initialGcId + MAX_TENURING_THRESHOLD * 2) { + byte b[] = new byte[ARRAY_LENGTH]; + } + + allocator.release(); + System.out.println(END_TEST); + } + + /** + * Estimate max survivor space size. + * + * For non-G1 GC returns value reported by MemoryPoolMXBean + * associated with survivor space. + * For G1 GC return max number of survivor regions * region size. + * Number if survivor regions estimated from MaxNewSize and SurvivorRatio. + */ + public static long getMaxSurvivorSize() { + if (GCTypes.YoungGCType.getYoungGCType() == GCTypes.YoungGCType.G1) { + int youngLength = (int) Math.max(MAX_NEW_SIZE / wb.g1RegionSize(), 1); + return (long) Math.ceil(youngLength / (double) SURVIVOR_RATIO) * wb.g1RegionSize(); + } else { + return HeapRegionUsageTool.getSurvivorUsage().getMax(); + } + } + } +}
--- a/test/gc/g1/TestHumongousShrinkHeap.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/gc/g1/TestHumongousShrinkHeap.java Tue Sep 29 18:47:52 2015 +0200 @@ -58,6 +58,10 @@ public static void main(String[] args) { + if (HUMON_COUNT == 0) { + System.out.println("Skipped. Heap is too small"); + return; + } System.out.format("Running with %s max heap size. " + "Will allocate humongous object of %s size %d times.%n", MemoryUsagePrinter.humanReadableByteCount(AVAILABLE_MEMORY, false),
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/g1/TestPLABSizeBounds.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestPLABSizeBounds + * @bug 8134857 + * @summary Regression test to ensure that G1 supports PLAB sizes of half a region size. + * @requires vm.gc=="G1" | vm.gc=="null" + * @key gc + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + */ + +import java.util.ArrayList; + +import jdk.test.lib.OutputAnalyzer; +import jdk.test.lib.Platform; +import jdk.test.lib.ProcessTools; + +public class TestPLABSizeBounds { + + public static final int M = 1024 * 1024; + + /** + * Starts the VM with the given region size and the given PLAB size arguments. The VM start should + * succeed if shouldSucceed is true, otherwise it should fail. + * + * @param regionSize The region size the VM should be started with in bytes. + * @param plabSize The young and old gen PLAB sizes the VM should be started with in machine words. + * @param shouldSucceed The expected result of the VM invocation. + */ + public static void runTest(int regionSize, int plabSize, boolean shouldSucceed) throws Exception { + ArrayList<String> testArguments = new ArrayList<String>(); + + testArguments.add("-XX:+UseG1GC"); + testArguments.add("-Xmx256M"); + testArguments.add("-XX:G1HeapRegionSize=" + regionSize); + testArguments.add("-XX:YoungPLABSize=" + plabSize); + testArguments.add("-XX:OldPLABSize=" + plabSize); + testArguments.add(GCTest.class.getName()); + + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(testArguments.toArray(new String[0])); + OutputAnalyzer output = new OutputAnalyzer(pb.start()); + + if (shouldSucceed) { + output.shouldHaveExitValue(0); + } else { + output.shouldHaveExitValue(1); + } + } + + public static void runRegionTest(int regionSize) throws Exception { + final int regionSizeInBytes = regionSize * M; + final int wordSize = Platform.is32bit() ? 4 : 8; + + runTest(regionSizeInBytes, (regionSizeInBytes / wordSize) / 2 - 1, true); + runTest(regionSizeInBytes, (regionSizeInBytes / wordSize) / 2, true); + runTest(regionSizeInBytes, (regionSizeInBytes / wordSize) / 2 + 1, false); + } + + public static void main(String[] args) throws Exception { + runRegionTest(1); + runRegionTest(2); + runRegionTest(4); + runRegionTest(8); + runRegionTest(16); + runRegionTest(32); + } + + static class GCTest { + public static void main(String [] args) { + System.out.println("Test completed."); + } + } +} +
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/g1/humongousObjects/Helpers.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +package gc.g1.humongousObjects; + +import sun.hotspot.WhiteBox; + +public class Helpers { + + // In case of 128 byte padding + private static final int MAX_PADDING_SIZE = 128; + + /** + * Detects amount of extra bytes required to allocate a byte array. + * Allocating a byte[n] array takes more then just n bytes in the heap. + * Extra bytes are required to store object reference and the length. + * This amount depends on bitness and other factors. + * + * @return byte[] memory overhead + */ + public static int detectByteArrayAllocationOverhead() { + + WhiteBox whiteBox = WhiteBox.getWhiteBox(); + + int zeroLengthByteArraySize = (int) whiteBox.getObjectSize(new byte[0]); + + // Since we do not know is there any padding in zeroLengthByteArraySize we cannot just take byte[0] size as overhead + for (int i = 1; i < MAX_PADDING_SIZE + 1; ++i) { + int realAllocationSize = (int) whiteBox.getObjectSize(new byte[i]); + if (realAllocationSize != zeroLengthByteArraySize) { + // It means we did not have any padding on previous step + return zeroLengthByteArraySize - (i - 1); + } + } + throw new Error("We cannot find byte[] memory overhead - should not reach here"); + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/g1/humongousObjects/TestHumongousThreshold.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,165 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +package gc.g1.humongousObjects; + +import jdk.test.lib.Asserts; +import sun.hotspot.WhiteBox; + +/** + * @test TestHumongousThreshold + * @summary Checks that objects larger than half a region are allocated as humongous + * @requires vm.gc=="G1" | vm.gc=="null" + * @library /testlibrary /../../test/lib + * @modules java.management + * @build sun.hotspot.WhiteBox + * gc.g1.humongousObjects.Helpers + * gc.g1.humongousObjects.TestHumongousThreshold + * @run driver ClassFileInstaller sun.hotspot.WhiteBox + * sun.hotspot.WhiteBox$WhiteBoxPermission + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=1M + * gc.g1.humongousObjects.TestHumongousThreshold + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=2M + * gc.g1.humongousObjects.TestHumongousThreshold + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=4M + * gc.g1.humongousObjects.TestHumongousThreshold + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=8M + * gc.g1.humongousObjects.TestHumongousThreshold + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=16M + * gc.g1.humongousObjects.TestHumongousThreshold + * + * @run main/othervm -XX:+UseG1GC -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. + * -XX:G1HeapRegionSize=32M + * gc.g1.humongousObjects.TestHumongousThreshold + * + */ + +public class TestHumongousThreshold { + private static final WhiteBox WHITE_BOX = WhiteBox.getWhiteBox(); + private static final int REGION_SIZE = WHITE_BOX.g1RegionSize(); + private static final int MAX_CONTINUOUS_SIZE_CHECK = 129; + private static final int NON_HUMONGOUS_DIVIDER = 10; + + /** + * The method allocates byte[] with specified size and checks that: + * 1. byte[] is allocated as we specified in expectedHumongous. + * 2. byte[] is allocated as humongous if its size is large than a half of region and non-humongous otherwise. + * It uses WB to obtain the size of created byte[]. Only objects larger than half of region are expected + * to be humongous. + * + * @param arraySize size of allocation + * @param expectedHumongous expected humongous/non-humongous allocation + * @return allocated byte array + */ + + private static byte[] allocateAndCheck(int arraySize, boolean expectedHumongous) { + byte[] storage = new byte[arraySize]; + long objectSize = WHITE_BOX.getObjectSize(storage); + boolean shouldBeHumongous = objectSize > (REGION_SIZE / 2); + + Asserts.assertEquals(expectedHumongous, shouldBeHumongous, "Despite we expected this object to be " + + (expectedHumongous ? "humongous" : "non-humongous") + " it appeared otherwise when we checked " + + "object size - likely test bug; Allocation size = " + arraySize + "; Object size = " + objectSize + + "; region size = " + REGION_SIZE); + + Asserts.assertEquals(WHITE_BOX.g1IsHumongous(storage), shouldBeHumongous, + "Object should be allocated as " + (shouldBeHumongous ? "humongous" + : "non-humongous") + " but it wasn't; Allocation size = " + arraySize + "; Object size = " + + objectSize + "; region size = " + REGION_SIZE); + return storage; + } + + public static void main(String[] args) { + int byteArrayMemoryOverhead = Helpers.detectByteArrayAllocationOverhead(); + + // Largest non-humongous byte[] + int maxByteArrayNonHumongousSize = (REGION_SIZE / 2) - byteArrayMemoryOverhead; + + // Increment for non-humongous testing + int nonHumongousStep = maxByteArrayNonHumongousSize / NON_HUMONGOUS_DIVIDER; + + // Maximum byte[] that takes one region + int maxByteArrayOneRegionSize = REGION_SIZE - byteArrayMemoryOverhead; + + // Sizes in regions + // i,e, 1.0f means one region, 1.5f means one and half region etc + float[] humongousFactors = {0.8f, 1.0f, 1.2f, 1.5f, 1.7f, 2.0f, 2.5f}; + + // Some diagnostic output + System.out.format("%s started%n", TestHumongousThreshold.class.getName()); + System.out.format("Actual G1 region size %d%n", REGION_SIZE); + System.out.format("byte[] memory overhead %d%n", byteArrayMemoryOverhead); + + // Non-humongous allocations + System.out.format("Doing non-humongous allocations%n"); + + // Testing allocations with byte[] with length from 0 to MAX_CONTINUOUS_SIZE_CHECK + System.out.format("Testing allocations with byte[] with length from 0 to %d%n", MAX_CONTINUOUS_SIZE_CHECK); + for (int i = 0; i < MAX_CONTINUOUS_SIZE_CHECK; ++i) { + allocateAndCheck(i, false); + } + + // Testing allocations with byte[] with length from 0 to nonHumongousStep * NON_HUMONGOUS_DIVIDER + System.out.format("Testing allocations with byte[] with length from 0 to %d with step %d%n", + nonHumongousStep * NON_HUMONGOUS_DIVIDER, nonHumongousStep); + for (int i = 0; i < NON_HUMONGOUS_DIVIDER; ++i) { + allocateAndCheck(i * nonHumongousStep, false); + } + + // Testing allocations with byte[] of maximum non-humongous length + System.out.format("Testing allocations with byte[] of maximum non-humongous length %d%n", + maxByteArrayNonHumongousSize); + allocateAndCheck(maxByteArrayNonHumongousSize, false); + + // Humongous allocations + System.out.format("Doing humongous allocations%n"); + // Testing with minimum humongous object + System.out.format("Testing with byte[] of minimum humongous object %d%n", maxByteArrayNonHumongousSize + 1); + allocateAndCheck(maxByteArrayNonHumongousSize + 1, true); + + // Testing allocations with byte[] with length from (maxByteArrayNonHumongousSize + 1) to + // (maxByteArrayNonHumongousSize + 1 + MAX_CONTINUOUS_SIZE_CHECK) + System.out.format("Testing allocations with byte[] with length from %d to %d%n", + maxByteArrayNonHumongousSize + 1, maxByteArrayNonHumongousSize + 1 + MAX_CONTINUOUS_SIZE_CHECK); + for (int i = 0; i < MAX_CONTINUOUS_SIZE_CHECK; ++i) { + allocateAndCheck(maxByteArrayNonHumongousSize + 1 + i, true); + } + + // Checking that large (more than a half of region size) objects are humongous + System.out.format("Checking that large (more than a half of region size) objects are humongous%n"); + for (float factor : humongousFactors) { + allocateAndCheck((int) (maxByteArrayOneRegionSize * factor), true); + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/gc/logging/TestPrintReferences.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test TestPrintReferences + * @bug 8133818 + * @summary Validate the reference processing logging + * @key gc + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + */ + +import jdk.test.lib.ProcessTools; +import jdk.test.lib.OutputAnalyzer; + +public class TestPrintReferences { + public static void main(String[] args) throws Exception { + ProcessBuilder pb_enabled = + ProcessTools.createJavaProcessBuilder("-XX:+PrintGCDetails", "-XX:+PrintReferenceGC", "-Xmx10M", GCTest.class.getName()); + OutputAnalyzer output = new OutputAnalyzer(pb_enabled.start()); + + output.shouldMatch( + "#[0-9]+: \\[SoftReference, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]" + + "#[0-9]+: \\[WeakReference, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]" + + "#[0-9]+: \\[FinalReference, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]" + + "#[0-9]+: \\[PhantomReference, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]" + + "#[0-9]+: \\[Cleaners, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]" + + "#[0-9]+: \\[JNI Weak Reference, [0-9]+ refs, [0-9]+\\.[0-9]+ secs\\]"); + + output.shouldHaveExitValue(0); + } + + static class GCTest { + public static void main(String [] args) { + System.gc(); + } + } +}
--- a/test/gc/survivorAlignment/TestPromotionFromSurvivorToTenuredAfterMinorGC.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/gc/survivorAlignment/TestPromotionFromSurvivorToTenuredAfterMinorGC.java Tue Sep 29 18:47:52 2015 +0200 @@ -28,7 +28,6 @@ * when their age exceeded tenuring threshold are not aligned to * SurvivorAlignmentInBytes value. * @library /testlibrary /../../test/lib - * @ignore 8130308 * @modules java.base/sun.misc * java.management * @build TestPromotionFromSurvivorToTenuredAfterMinorGC @@ -99,11 +98,18 @@ .getActualMemoryUsage(); test.allocate(); - for (int i = 0; i <= SurvivorAlignmentTestMain.MAX_TENURING_THRESHOLD; - i++) { + for (int i = 0; i <= SurvivorAlignmentTestMain.MAX_TENURING_THRESHOLD; i++) { SurvivorAlignmentTestMain.WHITE_BOX.youngGC(); } + // Sometimes we see that data unrelated to the test has been allocated during + // the loop. This data is included in the expectedMemoryUsage since we look + // through all threads to see what they allocated. If this data is still in + // the survivor area however, it should not be included in expectedMemoryUsage + // since the verification below only look at what's in tenured space. + expectedMemoryUsage -= SurvivorAlignmentTestMain.getAlignmentHelper( + SurvivorAlignmentTestMain.HeapSpace.SURVIVOR) + .getActualMemoryUsage(); test.verifyMemoryUsage(expectedMemoryUsage); } }
--- a/test/runtime/SharedArchiveFile/BasicJarBuilder.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/runtime/SharedArchiveFile/BasicJarBuilder.java Tue Sep 29 18:47:52 2015 +0200 @@ -35,14 +35,14 @@ import java.util.ArrayList; import sun.tools.jar.Main; +// Using JarBuilder requires that all to-be-jarred classes should be placed +// in the current working directory, aka "." public class BasicJarBuilder { private static final String classDir = System.getProperty("test.classes"); - public static void build(String jarName, String ...classNames) - throws Exception { - - createSimpleJar(classDir, classDir + File.separator + jarName + - ".jar", classNames); + public static void build(String jarName, String ...classNames) throws Exception { + createSimpleJar(".", classDir + File.separator + jarName + ".jar", + classNames); } private static void createSimpleJar(String jarclassDir, String jarName, @@ -71,7 +71,7 @@ } } - // helpers + // Get full path to the test jar public static String getTestJar(String jar) { File dir = new File(System.getProperty("test.classes", ".")); File jarFile = new File(dir, jar);
--- a/test/runtime/SharedArchiveFile/SharedStrings.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/runtime/SharedArchiveFile/SharedStrings.java Tue Sep 29 18:47:52 2015 +0200 @@ -32,12 +32,10 @@ * @library /testlibrary /../../test/lib * @modules java.base/sun.misc * java.management - * @ignore - 8133180 - * @build SharedStringsWb SharedStrings BasicJarBuilder + * @build SharedStringsWb SharedStrings BasicJarBuilder sun.hotspot.WhiteBox * @run main ClassFileInstaller sun.hotspot.WhiteBox * @run main SharedStrings */ - import jdk.test.lib.*; public class SharedStrings {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/runtime/SharedArchiveFile/SharedStringsRunAuto.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + */ + +/* + * @test SharedStringsAuto + * @summary Test -Xshare:auto with shared strings. + * Feature support: G1GC only, compressed oops/kptrs, 64-bit os, not on windows + * @requires (sun.arch.data.model != "32") & (os.family != "windows") + * @requires (vm.opt.UseCompressedOops == null) | (vm.opt.UseCompressedOops == true) + * @requires (vm.gc=="G1" | vm.gc=="null") + * @library /testlibrary + * @modules java.base/sun.misc + * java.management + * @run main SharedStringsRunAuto + */ + +import jdk.test.lib.*; +import java.io.File; + +public class SharedStringsRunAuto { + public static void main(String[] args) throws Exception { + // Dump + ProcessBuilder pb = ProcessTools.createJavaProcessBuilder( + "-XX:+UnlockDiagnosticVMOptions", + "-XX:SharedArchiveFile=./SharedStringsRunAuto.jsa", + "-XX:+UseCompressedOops", "-XX:+UseG1GC", + "-XX:+PrintSharedSpaces", + "-Xshare:dump"); + + new OutputAnalyzer(pb.start()) + .shouldContain("Loading classes to share") + .shouldContain("Shared string table stats") + .shouldHaveExitValue(0); + + // Run with -Xshare:auto + pb = ProcessTools.createJavaProcessBuilder( + "-XX:+UnlockDiagnosticVMOptions", + "-XX:SharedArchiveFile=./SharedStringsRunAuto.jsa", + "-XX:+UseCompressedOops", "-XX:+UseG1GC", + "-Xshare:auto", + "-version"); + + new OutputAnalyzer(pb.start()) + .shouldMatch("(java|openjdk) version") + .shouldHaveExitValue(0); + } +}
--- a/test/runtime/SharedArchiveFile/SharedStringsWb.java Tue Sep 29 16:51:31 2015 +0200 +++ b/test/runtime/SharedArchiveFile/SharedStringsWb.java Tue Sep 29 18:47:52 2015 +0200 @@ -34,8 +34,8 @@ return; } - // The string "java" is known to be interened and added to CDS archive - String s = "java"; + // The string below is known to be added to CDS archive + String s = "<init>"; String internedS = s.intern(); if (wb.isShared(internedS)) {
--- a/test/runtime/modules/ImageFile/ImageAttributeOffsetsTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,64 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Retrieves the array of offsets once with MemoryMapImage enabled once disabled. - * @test ImageAttributeOffsetsTest - * @summary Unit test for JVM_ImageAttributeOffsets() method - * @library /testlibrary /../../test/lib - * @build ImageAttributeOffsetsTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:+MemoryMapImage ImageAttributeOffsetsTest - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-MemoryMapImage ImageAttributeOffsetsTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageAttributeOffsetsTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - boolean passed = true; - // Get offsets - int[] array = wb.imageAttributeOffsets(id); - assertNotNull(array, "Could not retrieve offsets of array"); - - wb.imageCloseImage(id); - } -}
--- a/test/runtime/modules/ImageFile/ImageCloseTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,68 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test closing image opened multiple time. Test closing mutiple time an image. - * @test ImageCloseTest - * @summary Unit test for JVM_ImageClose() method - * @library /testlibrary /../../test/lib - * @build ImageCloseTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageCloseTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; - -public class ImageCloseTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = 0; - - // too many opens - for (int i = 0; i < 100; i++) { - id = wb.imageOpenImage(imageFile, bigEndian); - } - wb.imageCloseImage(id); - - // too many closes - id = wb.imageOpenImage(imageFile, bigEndian); - for (int i = 0; i < 100; i++) { - wb.imageCloseImage(id); - } - } -}
--- a/test/runtime/modules/ImageFile/ImageFileHeaderTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,126 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test that opening image containing wrong headers fails. - * @test ImageFileHeaderTest - * @library /testlibrary /../../test/lib - * @build ImageFileHeaderTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageFileHeaderTest - */ - -import java.nio.*; -import java.nio.file.Files; -import java.nio.file.Paths; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageFileHeaderTest { - - public static final int MAGIC = 0xCAFEDADA; - public static final short MAJOR = 0; - public static final short MINOR = 1; - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - public static ByteBuffer buf; - - public static void main(String... args) throws Exception { - - ByteOrder endian = getEndian(); - - // Try to read a non-existing file - assertFalse(wb.readImageFile("bogus")); - - // Incomplete header, only include the correct magic - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(MAGIC); - assertFalse(testImageFile("invalidheader.jimage")); - - // Build a complete header but reverse the endian - buf = ByteBuffer.allocate(100); - buf.order(endian == ByteOrder.LITTLE_ENDIAN ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN); - buf.putInt(MAGIC); - buf.putShort(MAJOR); - buf.putShort(MINOR); - assertFalse(testImageFile("wrongendian.jimage")); - - // Use the wrong magic - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(0xBEEFCACE); - buf.putShort(MAJOR); - buf.putShort(MINOR); - assertFalse(testImageFile("wrongmagic.jimage")); - - // Wrong major version (current + 1) - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(MAGIC); - buf.putShort((short)(MAJOR + 1)); - buf.putShort((short)MINOR); - assertFalse(testImageFile("wrongmajorversion.jimage")); - - // Wrong major version (negative) - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(MAGIC); - buf.putShort((short) -17); - buf.putShort((short)MINOR); - assertFalse(testImageFile("negativemajorversion.jimage")); - - // Wrong minor version (current + 1) - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(MAGIC); - buf.putShort((short)MAJOR); - buf.putShort((short)(MINOR + 1)); - assertFalse(testImageFile("wrongminorversion.jimage")); - - // Wrong minor version (negative) - buf = ByteBuffer.allocate(100); - buf.order(endian); - buf.putInt(MAGIC); - buf.putShort((short)MAJOR); - buf.putShort((short) -17); - assertFalse(testImageFile("negativeminorversion.jimage")); - } - - public static boolean testImageFile(String filename) throws Exception { - Files.write(Paths.get(filename), buf.array()); - System.out.println("Calling ReadImageFile on " + filename); - return wb.readImageFile(filename); - } - - public static ByteOrder getEndian() { - String endian = System.getProperty("sun.cpu.endian"); - if (endian.equalsIgnoreCase("little")) { - return ByteOrder.LITTLE_ENDIAN; - } else if (endian.equalsIgnoreCase("big")) { - return ByteOrder.BIG_ENDIAN; - } - throw new RuntimeException("Unexpected sun.cpu.endian value: " + endian); - } -}
--- a/test/runtime/modules/ImageFile/ImageFindAttributesTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,75 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Find the attributes of existing and invalid classes. - * @test ImageFindAttributesTest - * @summary Unit test for JVM_ImageFindAttributes() method - * @library /testlibrary /../../test/lib - * @build ImageFindAttributesTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageFindAttributesTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageFindAttributesTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - - // class resource - String className = "/java.base/java/lang/String.class"; - long[] longArr = wb.imageFindAttributes(id, className.getBytes()); - - assertNotNull(longArr, "Could not retrieve attributes of class " + className); - - // non-existent resource - String neClassName = "/java.base/java/lang/NonExistentClass.class"; - longArr = wb.imageFindAttributes(id, neClassName.getBytes()); - - assertNull(longArr, "Failed. Returned not null for non-existent " + neClassName); - - // garbage byte array - byte[] buf = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; - longArr = wb.imageFindAttributes(id, buf); - - assertNull(longArr, "Found attributes for garbage class"); - } -}
--- a/test/runtime/modules/ImageFile/ImageGetAttributesTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,128 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test getting all attributes, - * @test ImageGetAttributesTest - * @summary Unit test for JVM_ImageGetAttributes() method - * @library /testlibrary /../../test/lib - * @build LocationConstants ImageGetAttributesTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageGetAttributesTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageGetAttributesTest implements LocationConstants { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - testImageGetAttributes(imageFile); - } - - private static void testImageGetAttributes(String imageFile) { - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - try { - long stringsSize = wb.imageGetStringsSize(id); - assertNE(stringsSize, 0, "strings size is 0"); - - int[] array = wb.imageAttributeOffsets(id); - assertNotNull(array, "Could not retrieve offsets of array"); - - // Get non-null attributes - boolean attFound = false; - int[] idx = {-1, -1, -1}; - // first non-null attribute - for (int i = 0; i < array.length; i++) { - if (array[i] != 0) { - attFound = true; - idx[0] = i; - break; - } - } - - // middle non-null attribute - for (int i = array.length / 2; i < array.length; i++) { - if (array[i] != 0) { - attFound = true; - idx[1] = i; - break; - } - } - - // last non-null attribute - for (int i = array.length - 1; i >= 0; i--) { - if (array[i] != 0) { - attFound = true; - idx[2] = i; - break; - } - } - assertTrue(attFound, "Failed. No non-null offset attributes"); - // test cases above - for (int i = 0; i < 3; i++) { - if (idx[i] != -1) { - long[] attrs = wb.imageGetAttributes(id, (int) array[idx[i]]); - long module = attrs[LOCATION_ATTRIBUTE_MODULE]; - long parent = attrs[LOCATION_ATTRIBUTE_PARENT]; - long base = attrs[LOCATION_ATTRIBUTE_BASE]; - long ext = attrs[LOCATION_ATTRIBUTE_EXTENSION]; - - if ((module >= 0) && (module < stringsSize) - && (parent >= 0) && (parent < stringsSize) - && (base != 0) - && (ext >= 0) && (ext < stringsSize)) { - } else { - System.out.printf("Failed. Read attribute offset %d (position %d) but wrong offsets\n", - array[idx[i]], idx[i]); - System.out.printf(" offsets: module = %d parent = %d base = %d extention = %d\n", - module, parent, base, ext); - throw new RuntimeException("Read attribute offset error"); - } - } else { - System.out.printf("Failed. Could not read attribute offset %d (position %d)\n", - array[idx[i]], idx[i]); - throw new RuntimeException("Read attribute offset error"); - } - } - } finally { - wb.imageCloseImage(id); - } - } -}
--- a/test/runtime/modules/ImageFile/ImageGetDataAddressTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,71 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test accessing the data address of a jimage. This only makes sense when the - * entire jimage is mapped into memory. - * @test ImageGetDataAddressTest - * @summary Unit test for JVM_ImageGetDataAddress() method - * @library /testlibrary /../../test/lib - * @build ImageGetDataAddressTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:+MemoryMapImage ImageGetDataAddressTest + - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-MemoryMapImage ImageGetDataAddressTest - - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageGetDataAddressTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean isMMap = args[0].equals("+"); - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - - // get data for valid id - long dataAddr = wb.imageGetDataAddress(id); - assertFalse((dataAddr == 0) && isMMap, "Failed. Data address is " + dataAddr + " for valid id\n"); - - // get data for invalid id == 0 - dataAddr = wb.imageGetDataAddress(0); - assertTrue(dataAddr == 0, "Failed. Data address is " + dataAddr + " for zero id\n"); - - wb.imageCloseImage(id); - } -}
--- a/test/runtime/modules/ImageFile/ImageGetIndexAddressTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test the address of the jimage index. - * @test ImageGetIndexAddressTest - * @summary Unit test for JVM_ImageGetIndexAddress() method - * @library /testlibrary /../../test/lib - * @build ImageGetIndexAddressTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageGetIndexAddressTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageGetIndexAddressTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - - // get index for valid id - long indexAddr = wb.imageGetIndexAddress(id); - assertFalse(indexAddr == 0, "Failed. Index address is zero for valid id"); - - // get index for invalid id == 0 - indexAddr = wb.imageGetIndexAddress(0); - assertTrue(indexAddr == 0, "Failed. Index address is" + indexAddr + " for zero id\n"); - - wb.imageCloseImage(id); - } -}
--- a/test/runtime/modules/ImageFile/ImageGetStringBytesTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,79 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test that the string referenced by an attribute is retrieved. - * @test ImageGetStringBytesTest - * @summary Unit test for JVM_ImageGetStringBytes() method - * @library /testlibrary /../../test/lib - * @build LocationConstants ImageGetStringBytesTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageGetStringBytesTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageGetStringBytesTest implements LocationConstants { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - long id = wb.imageOpenImage(imageFile, bigEndian); - - String className = "/java.base/java/lang/String.class"; - long[] offsetArr = wb.imageFindAttributes(id, className.getBytes()); - - // Module - assertTrue(checkAttribute(id, offsetArr, LOCATION_ATTRIBUTE_MODULE, "Module")); - - // Parent - assertTrue(checkAttribute(id, offsetArr, LOCATION_ATTRIBUTE_PARENT, "Parent")); - - // Base - assertTrue(checkAttribute(id, offsetArr, LOCATION_ATTRIBUTE_BASE, "Base")); - - // Extension - assertTrue(checkAttribute(id, offsetArr, LOCATION_ATTRIBUTE_EXTENSION, "Extension")); - - wb.imageCloseImage(id); - } - - private static boolean checkAttribute(long id, long[] offsetArr, int attrId, String attrName) { - long offset = offsetArr[attrId]; - return wb.imageGetStringBytes(id, (int) offset) != null; - } -}
--- a/test/runtime/modules/ImageFile/ImageOpenTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,84 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test image opening/closing - * @test ImageOpenTest - * @summary Unit test for JVM_ImageOpen() method - * @library /testlibrary /../../test/lib - * @build ImageOpenTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI ImageOpenTest - */ - -import java.io.File; -import java.nio.ByteOrder; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageOpenTest { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String nonexistentImageFile = javaHome + "/lib/modules/nonexistent.jimage"; - String bootmodulesImageFile = javaHome + File.separator + "lib" + File.separator - + "modules" + File.separator + "bootmodules.jimage"; - - if (!(new File(bootmodulesImageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean bigEndian = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN; - - // open nonexistent image - long id = wb.imageOpenImage(nonexistentImageFile, bigEndian); - assertTrue(id == 0L, "Failed. Get id " + id + "instead of 0 on opening nonexistent file\n"); - wb.imageCloseImage(id); - - // open bootmodules image - id = wb.imageOpenImage(bootmodulesImageFile, bigEndian); - assertFalse(id == 0, "Failed. Get id 0 on opening bootmodules.jimage"); - wb.imageCloseImage(id); - - // non-native endian - id = wb.imageOpenImage(bootmodulesImageFile, !bigEndian); - assertFalse(id == 0, "Failed. Get id 0 on opening bootmodules.jimage with non-native endian"); - wb.imageCloseImage(id); - - // - // open several times - // - id = wb.imageOpenImage(bootmodulesImageFile, bigEndian); - long id1 = wb.imageOpenImage(bootmodulesImageFile, bigEndian); - long id2 = wb.imageOpenImage(bootmodulesImageFile, bigEndian); - assertTrue((id == id1) && (id == id2), "Failed. Open thee times with ids " + id + " " + id1 + " " + id1); - - wb.imageCloseImage(id); - wb.imageCloseImage(id1); - wb.imageCloseImage(id2); - } -}
--- a/test/runtime/modules/ImageFile/ImageReadTest.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,97 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -/* - * Test reading resource content. - * @test ImageReadTest - * @summary Unit test for JVM_ImageRead() method - * @library /testlibrary /../../test/lib - * @build LocationConstants ImageReadTest - * @run main ClassFileInstaller sun.hotspot.WhiteBox - * sun.hotspot.WhiteBox$WhiteBoxPermission - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:+MemoryMapImage ImageReadTest + - * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-MemoryMapImage ImageReadTest - - */ - -import java.io.File; -import java.nio.ByteBuffer; -import sun.hotspot.WhiteBox; -import static jdk.test.lib.Asserts.*; - -public class ImageReadTest implements LocationConstants { - - public static final WhiteBox wb = WhiteBox.getWhiteBox(); - - public static void main(String... args) throws Exception { - String javaHome = System.getProperty("java.home"); - String imageFile = javaHome + File.separator + "lib" - + File.separator + "modules" + File.separator - + "bootmodules.jimage"; - - if (!(new File(imageFile)).exists()) { - System.out.printf("Test skipped."); - return; - } - - boolean isMMap = args[0].equals("+"); - - long id = wb.imageOpenImage(imageFile, isMMap); - - final String mm = isMMap ? "-XX:+MemoryMapImage" : "-XX:-MemoryMapImage"; - final int magic = 0xCAFEBABE; - - String className = "/java.base/java/lang/String.class"; - long[] offsetArr = wb.imageFindAttributes(id, className.getBytes()); - long offset = offsetArr[LOCATION_ATTRIBUTE_OFFSET]; - long size = offsetArr[LOCATION_ATTRIBUTE_UNCOMPRESSED]; - - // positive: read - ByteBuffer buf = ByteBuffer.allocateDirect((int) size); - assertTrue(wb.imageRead(id, offset, buf, size), "Failed. Read operation returned false, should be true"); - int m = buf.getInt(); - assertTrue(m == magic, "Failed. Read operation returned true but wrong magic = " + magic); - - // positive: mmap - if (isMMap) { - long dataAddr = wb.imageGetDataAddress(id); - assertFalse(dataAddr == 0L, "Failed. Did not obtain data address on mmapped test"); - int data = wb.imageGetIntAtAddress(dataAddr, (int) offset, true); - assertTrue(data == magic, "Failed. MMap operation returned true but wrong magic = " + data); - } - - // negative: wrong offset - boolean success = wb.imageRead(id, -100, buf, size); - assertFalse(success, "Failed. Read operation (wrong offset): returned true"); - - // negative: too big offset - long filesize = new File(imageFile).length(); - success = wb.imageRead(id, filesize + 1, buf, size); - assertFalse(success, "Failed. Read operation (offset > file size) returned true"); - - // negative: negative size - success = wb.imageRead(id, offset, buf, -100); - assertFalse(success, "Failed. Read operation (negative size) returned true"); - - wb.imageCloseImage(id); - } -}
--- a/test/runtime/modules/ImageFile/LocationConstants.java Tue Sep 29 16:51:31 2015 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,36 +0,0 @@ -/* - * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -public interface LocationConstants { - // keep this in sync with enum in ImageLocation C++ class in the - // hotspot's C++ header file imageFile.hpp - public static final int LOCATION_ATTRIBUTE_END = 0; // End of attribute stream marker - public static final int LOCATION_ATTRIBUTE_MODULE = 1; // String table offset of module name - public static final int LOCATION_ATTRIBUTE_PARENT = 2; // String table offset of resource path parent - public static final int LOCATION_ATTRIBUTE_BASE = 3; // String table offset of resource path base - public static final int LOCATION_ATTRIBUTE_EXTENSION = 4; // String table offset of resource path extension - public static final int LOCATION_ATTRIBUTE_OFFSET = 5; // Container byte offset of resource - public static final int LOCATION_ATTRIBUTE_COMPRESSED = 6; // In image byte size of the compressed resource - public static final int LOCATION_ATTRIBUTE_UNCOMPRESSED = 7; // In memory byte size of the uncompressed resource - public static final int LOCATION_ATTRIBUTE_COUNT = 8; // Number of attribute kinds -}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/testlibrary/jdk/test/lib/AllocationHelper.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,116 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +package jdk.test.lib; + +import java.util.LinkedList; +import java.util.concurrent.Callable; + +/** + * Helper class which allocates memory. + * + * Typical usage: + * <pre> + * {@code + * AllocationHelper allocator = new AllocationHelper(MAX_ITERATIONS, ARRAY_LENGTH, CHUNK_SIZE, + * () -> (verifier())); + * // Allocate byte[CHUNK_SIZE] ARRAY_LENGTH times. Total allocated bytes will be CHUNK_SIZE * ARRAY_LENGTH + refs length. + * // Then invoke verifier and iterate MAX_ITERATIONS times. + * allocator.allocateMemoryAndVerify(); + * } + * </pre> + */ +public final class AllocationHelper { + + private final int arrayLength; + private final int maxIterations; + private final int chunkSize; + + // garbageStorage is used to store link to garbage to prevent optimization. + private static Object garbageStorage; + private byte garbage[][]; + private final Callable<?> verifierInstance; + + /** + * Create an AllocationHelper with specified iteration count, array length, chunk size and verifier. + * + * @param maxIterations + * @param arrayLength + * @param chunkSize + * @param verifier - Callable instance which will be invoked after all allocation cycle. Can be null; + */ + public AllocationHelper(int maxIterations, int arrayLength, int chunkSize, Callable<?> verifier) { + if ((arrayLength <= 0) || (maxIterations <= 0) || (chunkSize <= 0)) { + throw new IllegalArgumentException("maxIterations, arrayLength and chunkSize should be greater then 0."); + } + this.arrayLength = arrayLength; + this.maxIterations = maxIterations; + this.chunkSize = chunkSize; + verifierInstance = verifier; + garbage = new byte[this.arrayLength][]; + garbageStorage = garbage; + } + + private void allocateMemoryOneIteration() { + for (int j = 0; j < arrayLength; j++) { + garbage[j] = new byte[chunkSize]; + } + } + + /** + * Allocate memory and invoke Verifier during all iteration. + * + * @throws java.lang.Exception + */ + public void allocateMemoryAndVerify() throws Exception { + for (int i = 0; i < maxIterations; i++) { + allocateMemoryOneIteration(); + if (verifierInstance != null) { + verifierInstance.call(); + } + } + } + + /** + * The same as allocateMemoryAndVerify() but hides OOME + * + * @throws Exception + */ + public void allocateMemoryAndVerifyNoOOME() throws Exception { + try { + allocateMemoryAndVerify(); + } catch (OutOfMemoryError e) { + // exit on OOME + } + } + + /** + * Release link to allocated garbage to make it available for further GC + */ + public void release() { + if (garbage != null) { + garbage = null; + garbageStorage = null; + } + } +}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/test/testlibrary/jdk/test/lib/HeapRegionUsageTool.java Tue Sep 29 18:47:52 2015 +0200 @@ -0,0 +1,107 @@ +/* +* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. +* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. +* +* This code is free software; you can redistribute it and/or modify it +* under the terms of the GNU General Public License version 2 only, as +* published by the Free Software Foundation. +* +* This code is distributed in the hope that it will be useful, but WITHOUT +* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +* version 2 for more details (a copy is included in the LICENSE file that +* accompanied this code). +* +* You should have received a copy of the GNU General Public License version +* 2 along with this work; if not, write to the Free Software Foundation, +* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. +* +* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA +* or visit www.oracle.com if you need additional information or have any +* questions. +*/ + +package jdk.test.lib; + +import java.lang.management.ManagementFactory; +import java.lang.management.MemoryPoolMXBean; +import java.lang.management.MemoryUsage; + +/** + * Utility class used by tests to get heap region usage. + */ +public final class HeapRegionUsageTool { + + /** + * Get MemoryUsage from MemoryPoolMXBean which name matches passed string. + * + * @param name + * @return MemoryUsage + */ + private static MemoryUsage getUsage(String name){ + for (MemoryPoolMXBean pool : ManagementFactory.getMemoryPoolMXBeans()) { + if (pool.getName().matches(name)) { + return pool.getUsage(); + } + } + return null; + } + + /** + * Get MemoryUsage of Eden space. + * + * @return MemoryUsage + */ + public static MemoryUsage getEdenUsage() { + return getUsage(".*Eden.*"); + } + + /** + * Get MemoryUsage of Survivor space. + * + * @return MemoryUsage + */ + public static MemoryUsage getSurvivorUsage() { + return getUsage(".*Survivor.*"); + } + + /** + * Get memory usage of Tenured space + * + * @return MemoryUsage + */ + public static MemoryUsage getOldUsage() { + return getUsage(".*(Old|Tenured).*"); + } + + /** + * Get heap usage. + * + * @return MemoryUsage + */ + public static MemoryUsage getHeapUsage() { + return ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(); + } + + /** + * Helper function to align up. + * + * @param value + * @param alignment + * @return aligned value + */ + public static long alignUp(long value, long alignment) { + return (value + alignment - 1) & ~(alignment - 1); + } + + /** + * Helper function to align down. + * + * @param value + * @param alignment + * @return aligned value + */ + public static long alignDown(long value, long alignment) { + return value & ~(alignment - 1); + } +}