--- a/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
b2287cac7813c70ed7f679d9a46fe774bd4005f8 jdk9-b30
9d0e6639a4d71b63507dd94b1a028e963b27e798 jdk9-b31
1b1ec4291abc0ba6da7bf79b754f08dd759a4a0c jdk9-b32
+f0c5e4b732da823bdaa4184133675f384e7cd68d jdk9-b33
+9618201c5df28a460631577fad1f61e96f775c34 jdk9-b34
--- a/.hgtags-top-repo Thu Oct 09 12:36:23 2014 -0700
+++ b/.hgtags-top-repo Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
36e9bc875325813ac9c44ac0c617a463091fa9f5 jdk9-b30
69a84c16d9c28e0e3d504b9c8766c24bafcd58f6 jdk9-b31
7e3512dae8e020d44399c0f1c579ff1fe3090ed6 jdk9-b32
+e4ba01b726e263953ae129be37c94de6ed145b1d jdk9-b33
+087b23f35631e68e950496a36fce8ccca612966a jdk9-b34
--- a/common/autoconf/bootcycle-spec.gmk.in Thu Oct 09 12:36:23 2014 -0700
+++ b/common/autoconf/bootcycle-spec.gmk.in Fri Oct 10 02:24:41 2014 -0700
@@ -48,6 +48,13 @@
# Use a different Boot JDK
OLD_BOOT_JDK:=$(BOOT_JDK)
BOOT_JDK:=@BUILD_OUTPUT@/images/j2sdk-image
-BOOT_RTJAR:=@BUILD_OUTPUT@/images/j2sdk-image/jre/lib/rt.jar
+BOOT_RTJAR:=$(BOOT_JDK)/jre/lib/rt.jar
-SJAVAC_SERVER_JAVA:=$(subst $(OLD_BOOT_JDK),$(BOOT_JDK),$(SJAVAC_SERVER_JAVA))
+JAVA_CMD:=$(BOOT_JDK)/bin/java
+JAVAC_CMD:=$(BOOT_JDK)/bin/javac
+JAVAH_CMD:=$(BOOT_JDK)/bin/javah
+JAR_CMD:=$(BOOT_JDK)/bin/jar
+NATIVE2ASCII_CMD:=$(BOOT_JDK)/bin/native2ascii
+JARSIGNER_CMD:=$(BOOT_JDK)/bin/jarsigner
+SJAVAC_SERVER_JAVA_CMD:=$(JAVA_CMD)
+
--- a/common/autoconf/build-performance.m4 Thu Oct 09 12:36:23 2014 -0700
+++ b/common/autoconf/build-performance.m4 Fri Oct 10 02:24:41 2014 -0700
@@ -296,7 +296,7 @@
AC_SUBST(SJAVAC_SERVER_JAVA)
if test "$MEMORY_SIZE" -gt "3000"; then
- ADD_JVM_ARG_IF_OK([-d64],SJAVAC_SERVER_JAVA,[$SJAVAC_SERVER_JAVA])
+ ADD_JVM_ARG_IF_OK([-d64],SJAVAC_SERVER_JAVA_FLAGS,[$SJAVAC_SERVER_JAVA])
if test "$JVM_ARG_OK" = true; then
JVM_64BIT=true
JVM_ARG_OK=false
@@ -320,7 +320,8 @@
if test "$MX_VALUE" -lt "512"; then
MX_VALUE=512
fi
- ADD_JVM_ARG_IF_OK([-Xms${MS_VALUE}M -Xmx${MX_VALUE}M],SJAVAC_SERVER_JAVA,[$SJAVAC_SERVER_JAVA])
+ ADD_JVM_ARG_IF_OK([-Xms${MS_VALUE}M -Xmx${MX_VALUE}M],SJAVAC_SERVER_JAVA_FLAGS,[$SJAVAC_SERVER_JAVA])
+ AC_SUBST(SJAVAC_SERVER_JAVA_FLAGS)
AC_ARG_ENABLE([sjavac], [AS_HELP_STRING([--enable-sjavac],
[use sjavac to do fast incremental compiles @<:@disabled@:>@])],
--- a/common/autoconf/generated-configure.sh Thu Oct 09 12:36:23 2014 -0700
+++ b/common/autoconf/generated-configure.sh Fri Oct 10 02:24:41 2014 -0700
@@ -633,6 +633,7 @@
USE_PRECOMPILED_HEADER
SJAVAC_SERVER_DIR
ENABLE_SJAVAC
+SJAVAC_SERVER_JAVA_FLAGS
SJAVAC_SERVER_JAVA
JAVA_TOOL_FLAGS_SMALL
JAVA_FLAGS_SMALL
@@ -4327,7 +4328,7 @@
#CUSTOM_AUTOCONF_INCLUDE
# Do not change or remove the following line, it is needed for consistency checks:
-DATE_WHEN_GENERATED=1410791401
+DATE_WHEN_GENERATED=1412599039
###############################################################################
#
@@ -50472,7 +50473,7 @@
FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
- SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -d64"
+ SJAVAC_SERVER_JAVA_FLAGS="$SJAVAC_SERVER_JAVA_FLAGS -d64"
JVM_ARG_OK=true
else
$ECHO "Arg failed:" >&5
@@ -50510,7 +50511,7 @@
FOUND_WARN=`$ECHO "$OUTPUT" | grep -i warn`
FOUND_VERSION=`$ECHO $OUTPUT | grep " version \""`
if test "x$FOUND_VERSION" != x && test "x$FOUND_WARN" = x; then
- SJAVAC_SERVER_JAVA="$SJAVAC_SERVER_JAVA -Xms${MS_VALUE}M -Xmx${MX_VALUE}M"
+ SJAVAC_SERVER_JAVA_FLAGS="$SJAVAC_SERVER_JAVA_FLAGS -Xms${MS_VALUE}M -Xmx${MX_VALUE}M"
JVM_ARG_OK=true
else
$ECHO "Arg failed:" >&5
@@ -50519,6 +50520,7 @@
fi
+
# Check whether --enable-sjavac was given.
if test "${enable_sjavac+set}" = set; then :
enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
--- a/common/autoconf/spec.gmk.in Thu Oct 09 12:36:23 2014 -0700
+++ b/common/autoconf/spec.gmk.in Fri Oct 10 02:24:41 2014 -0700
@@ -256,7 +256,8 @@
BUILD_HOTSPOT=@BUILD_HOTSPOT@
-# The boot jdk to use
+# The boot jdk to use. These are overridden in bootcycle-spec.gmk. Make sure to keep
+# them in sync.
BOOT_JDK:=@BOOT_JDK@
BOOT_RTJAR:=@BOOT_RTJAR@
BOOT_TOOLSJAR=$(BOOT_JDK)/lib/tools.jar
@@ -453,23 +454,35 @@
JAVA_FLAGS_BIG:=@JAVA_FLAGS_BIG@
JAVA_FLAGS_SMALL:=@JAVA_FLAGS_SMALL@
JAVA_TOOL_FLAGS_SMALL:=@JAVA_TOOL_FLAGS_SMALL@
+SJAVAC_SERVER_JAVA_FLAGS:=@SJAVAC_SERVER_JAVA_FLAGS@
-JAVA=@FIXPATH@ @JAVA@ $(JAVA_FLAGS_BIG) $(JAVA_FLAGS)
-JAVA_SMALL=@FIXPATH@ @JAVA@ $(JAVA_FLAGS_SMALL) $(JAVA_FLAGS)
+# The *_CMD variables are defined separately to be easily overridden in bootcycle-spec.gmk
+# for bootcycle-images build. Make sure to keep them in sync. Do not use the *_CMD
+# versions of the variables directly.
+JAVA_CMD:=@JAVA@
+JAVAC_CMD:=@JAVAC@
+JAVAH_CMD:=@JAVAH@
+JAR_CMD:=@JAR@
+NATIVE2ASCII_CMD:=@NATIVE2ASCII@
+JARSIGNER_CMD:=@JARSIGNER@
+SJAVAC_SERVER_JAVA_CMD:=@SJAVAC_SERVER_JAVA@
+# These variables are meant to be used. They are defined with = instead of := to make
+# it possible to override only the *_CMD variables.
+JAVA=@FIXPATH@ $(JAVA_CMD) $(JAVA_FLAGS_BIG) $(JAVA_FLAGS)
+JAVA_SMALL=@FIXPATH@ $(JAVA_CMD) $(JAVA_FLAGS_SMALL) $(JAVA_FLAGS)
+JAVAC=@FIXPATH@ $(JAVAC_CMD)
+JAVAH=@FIXPATH@ $(JAVAH_CMD)
+JAR=@FIXPATH@ $(JAR_CMD)
+NATIVE2ASCII=@FIXPATH@ $(NATIVE2ASCII_CMD) $(JAVA_TOOL_FLAGS_SMALL)
+JARSIGNER=@FIXPATH@ $(JARSIGNER_CMD)
+# A specific java binary with specific options can be used to run
+# the long running background sjavac servers and other long running tasks.
+SJAVAC_SERVER_JAVA=@FIXPATH@ $(SJAVAC_SERVER_JAVA_CMD) $(SJAVAC_SERVER_JAVA_FLAGS)
-JAVAC:=@FIXPATH@ @JAVAC@
# Hotspot sets this variable before reading the SPEC when compiling sa-jdi.jar. Avoid
# overriding that value by using ?=.
JAVAC_FLAGS?=@JAVAC_FLAGS@
-JAVAH:=@FIXPATH@ @JAVAH@
-
-JAR:=@FIXPATH@ @JAR@
-
-NATIVE2ASCII:=@FIXPATH@ @NATIVE2ASCII@ $(JAVA_TOOL_FLAGS_SMALL)
-
-JARSIGNER:=@FIXPATH@ @JARSIGNER@
-
# You run the new javac using the boot jdk with $(BOOT_JDK)/bin/java $(NEW_JAVAC) ...
INTERIM_LANGTOOLS_JAR := $(LANGTOOLS_OUTPUTDIR)/dist/interim_langtools.jar
INTERIM_LANGTOOLS_ARGS := "-Xbootclasspath/p:$(INTERIM_LANGTOOLS_JAR)" -cp $(INTERIM_LANGTOOLS_JAR)
@@ -486,10 +499,6 @@
RC_FLAGS:=@RC_FLAGS@
endif
-# A specific java binary with specific options can be used to run
-# the long running background sjavac servers and other long running tasks.
-SJAVAC_SERVER_JAVA:=@FIXPATH@ @SJAVAC_SERVER_JAVA@
-
# Tools adhering to a minimal and common standard of posix compliance.
AWK:=@AWK@
BASENAME:=@BASENAME@
--- a/corba/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/corba/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
98967ae6ae53ebf15615e07cd5a6b1ae04dfd84c jdk9-b30
c432b80aadd0cb2b2361b02add4d671957d4cec9 jdk9-b31
b5b139354630edb2d06190bf31653acbdcea63a8 jdk9-b32
+cfdac5887952c2dd73c73a1d8d9aa880d0539bbf jdk9-b33
+24a0bad5910f775bb4002d1dacf8b3af87c63cd8 jdk9-b34
--- a/corba/make/CompileCorba.gmk Thu Oct 09 12:36:23 2014 -0700
+++ b/corba/make/CompileCorba.gmk Fri Oct 10 02:24:41 2014 -0700
@@ -51,13 +51,11 @@
JAR := $(INTERIM_CORBA_JAR)))
################################################################################
-# Copy idl files straight to jdk/lib. Not sure if this is the right way to do
-# it, but we are moving away from the one repo at a time build. Perhaps we should
-# scrap the 'jdk' prefix to bin, lib etc?
-$(JDK_OUTPUTDIR)/lib/%: $(CORBA_TOPDIR)/src/java.corba/share/classes/com/sun/tools/corba/se/idl/%
+# Copy idl files straight to jdk/include.
+$(JDK_OUTPUTDIR)/include/%: $(CORBA_TOPDIR)/src/java.corba/share/classes/com/sun/tools/corba/se/idl/%
$(install-file)
-IDL_TARGET_FILES := $(JDK_OUTPUTDIR)/lib/orb.idl $(JDK_OUTPUTDIR)/lib/ir.idl
+IDL_TARGET_FILES := $(JDK_OUTPUTDIR)/include/orb.idl $(JDK_OUTPUTDIR)/include/ir.idl
################################################################################
--- a/hotspot/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -435,3 +435,5 @@
5c722dffbc0f34eb8d903dca7b261e52248fa17e jdk9-b30
9f7d155d28e519f3e4645dc21cf185c25f3176ed jdk9-b31
af46576a8d7cb4003028b8ee8bf408cfe227315b jdk9-b32
+9b3f5e4f33725f7c1d9b8e523133fe8383a54d9f jdk9-b33
+821164b0131a47ca065697c7d27d8f215e608c8d jdk9-b34
--- a/hotspot/agent/src/os/win32/windbg/sawindbg.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/agent/src/os/win32/windbg/sawindbg.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -318,12 +318,18 @@
path = (jstring) env->GetStaticObjectField(clazz, imagePath_ID);
CHECK_EXCEPTION_(false);
+ if (path == NULL) {
+ THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get imagePath field ID!", false);
+ }
buf = env->GetStringUTFChars(path, &isCopy);
CHECK_EXCEPTION_(false);
AutoJavaString imagePath(env, path, buf);
path = (jstring) env->GetStaticObjectField(clazz, symbolPath_ID);
CHECK_EXCEPTION_(false);
+ if (path == NULL) {
+ THROW_NEW_DEBUGGER_EXCEPTION_("Windbg Error: not able to get symbolPath field ID!", false);
+ }
buf = env->GetStringUTFChars(path, &isCopy);
CHECK_EXCEPTION_(false);
AutoJavaString symbolPath(env, path, buf);
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/code/CodeCache.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/code/CodeCache.java Fri Oct 10 02:24:41 2014 -0700
@@ -32,12 +32,10 @@
import sun.jvm.hotspot.utilities.*;
public class CodeCache {
- private static AddressField heapField;
- private static AddressField scavengeRootNMethodsField;
+ private static GrowableArray<CodeHeap> heapArray;
+ private static AddressField scavengeRootNMethodsField;
private static VirtualConstructor virtualConstructor;
- private CodeHeap heap;
-
static {
VM.registerVMInitializedObserver(new Observer() {
public void update(Observable o, Object data) {
@@ -49,7 +47,10 @@
private static synchronized void initialize(TypeDataBase db) {
Type type = db.lookupType("CodeCache");
- heapField = type.getAddressField("_heap");
+ // Get array of CodeHeaps
+ AddressField heapsField = type.getAddressField("_heaps");
+ heapArray = GrowableArray.create(heapsField.getValue(), new StaticBaseConstructor<CodeHeap>(CodeHeap.class));
+
scavengeRootNMethodsField = type.getAddressField("_scavenge_root_nmethods");
virtualConstructor = new VirtualConstructor(db);
@@ -67,16 +68,17 @@
}
}
- public CodeCache() {
- heap = (CodeHeap) VMObjectFactory.newObject(CodeHeap.class, heapField.getValue());
- }
-
public NMethod scavengeRootMethods() {
return (NMethod) VMObjectFactory.newObject(NMethod.class, scavengeRootNMethodsField.getValue());
}
public boolean contains(Address p) {
- return getHeap().contains(p);
+ for (int i = 0; i < heapArray.length(); ++i) {
+ if (heapArray.at(i).contains(p)) {
+ return true;
+ }
+ }
+ return false;
}
/** When VM.getVM().isDebugging() returns true, this behaves like
@@ -97,14 +99,24 @@
public CodeBlob findBlobUnsafe(Address start) {
CodeBlob result = null;
+ CodeHeap containing_heap = null;
+ for (int i = 0; i < heapArray.length(); ++i) {
+ if (heapArray.at(i).contains(start)) {
+ containing_heap = heapArray.at(i);
+ break;
+ }
+ }
+ if (containing_heap == null) {
+ return null;
+ }
try {
- result = (CodeBlob) virtualConstructor.instantiateWrapperFor(getHeap().findStart(start));
+ result = (CodeBlob) virtualConstructor.instantiateWrapperFor(containing_heap.findStart(start));
}
catch (WrongTypeException wte) {
Address cbAddr = null;
try {
- cbAddr = getHeap().findStart(start);
+ cbAddr = containing_heap.findStart(start);
}
catch (Exception findEx) {
findEx.printStackTrace();
@@ -167,31 +179,32 @@
}
public void iterate(CodeCacheVisitor visitor) {
- CodeHeap heap = getHeap();
- Address ptr = heap.begin();
- Address end = heap.end();
-
- visitor.prologue(ptr, end);
+ visitor.prologue(lowBound(), highBound());
CodeBlob lastBlob = null;
- while (ptr != null && ptr.lessThan(end)) {
- try {
- // Use findStart to get a pointer inside blob other findBlob asserts
- CodeBlob blob = findBlobUnsafe(heap.findStart(ptr));
- if (blob != null) {
- visitor.visit(blob);
- if (blob == lastBlob) {
- throw new InternalError("saw same blob twice");
+
+ for (int i = 0; i < heapArray.length(); ++i) {
+ CodeHeap current_heap = heapArray.at(i);
+ Address ptr = current_heap.begin();
+ while (ptr != null && ptr.lessThan(current_heap.end())) {
+ try {
+ // Use findStart to get a pointer inside blob other findBlob asserts
+ CodeBlob blob = findBlobUnsafe(current_heap.findStart(ptr));
+ if (blob != null) {
+ visitor.visit(blob);
+ if (blob == lastBlob) {
+ throw new InternalError("saw same blob twice");
+ }
+ lastBlob = blob;
}
- lastBlob = blob;
+ } catch (RuntimeException e) {
+ e.printStackTrace();
}
- } catch (RuntimeException e) {
- e.printStackTrace();
+ Address next = current_heap.nextBlock(ptr);
+ if (next != null && next.lessThan(ptr)) {
+ throw new InternalError("pointer moved backwards");
+ }
+ ptr = next;
}
- Address next = heap.nextBlock(ptr);
- if (next != null && next.lessThan(ptr)) {
- throw new InternalError("pointer moved backwards");
- }
- ptr = next;
}
visitor.epilogue();
}
@@ -200,7 +213,23 @@
// Internals only below this point
//
- private CodeHeap getHeap() {
- return heap;
+ private Address lowBound() {
+ Address low = heapArray.at(0).begin();
+ for (int i = 1; i < heapArray.length(); ++i) {
+ if (heapArray.at(i).begin().lessThan(low)) {
+ low = heapArray.at(i).begin();
+ }
+ }
+ return low;
+ }
+
+ private Address highBound() {
+ Address high = heapArray.at(0).end();
+ for (int i = 1; i < heapArray.length(); ++i) {
+ if (heapArray.at(i).end().greaterThan(high)) {
+ high = heapArray.at(i).end();
+ }
+ }
+ return high;
}
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1Allocator.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,40 @@
+package sun.jvm.hotspot.gc_implementation.g1;
+
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.runtime.VMObject;
+import sun.jvm.hotspot.types.CIntegerField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+
+public class G1Allocator extends VMObject {
+
+ //size_t _summary_bytes_used;
+ static private CIntegerField summaryBytesUsedField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ static private synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("G1Allocator");
+
+ summaryBytesUsedField = type.getCIntegerField("_summary_bytes_used");
+ }
+
+ public long getSummaryBytes() {
+ return summaryBytesUsedField.getValue(addr);
+ }
+
+ public G1Allocator(Address addr) {
+ super(addr);
+
+ }
+}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1CollectedHeap.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1CollectedHeap.java Fri Oct 10 02:24:41 2014 -0700
@@ -36,7 +36,6 @@
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.runtime.VMObjectFactory;
import sun.jvm.hotspot.types.AddressField;
-import sun.jvm.hotspot.types.CIntegerField;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
@@ -47,8 +46,8 @@
static private long hrmFieldOffset;
// MemRegion _g1_reserved;
static private long g1ReservedFieldOffset;
- // size_t _summary_bytes_used;
- static private CIntegerField summaryBytesUsedField;
+ // G1Allocator* _allocator
+ static private AddressField g1Allocator;
// G1MonitoringSupport* _g1mm;
static private AddressField g1mmField;
// HeapRegionSet _old_set;
@@ -68,7 +67,7 @@
Type type = db.lookupType("G1CollectedHeap");
hrmFieldOffset = type.getField("_hrm").getOffset();
- summaryBytesUsedField = type.getCIntegerField("_summary_bytes_used");
+ g1Allocator = type.getAddressField("_allocator");
g1mmField = type.getAddressField("_g1mm");
oldSetFieldOffset = type.getField("_old_set").getOffset();
humongousSetFieldOffset = type.getField("_humongous_set").getOffset();
@@ -79,7 +78,7 @@
}
public long used() {
- return summaryBytesUsedField.getValue(addr);
+ return allocator().getSummaryBytes();
}
public long n_regions() {
@@ -97,6 +96,11 @@
return (G1MonitoringSupport) VMObjectFactory.newObject(G1MonitoringSupport.class, g1mmAddr);
}
+ public G1Allocator allocator() {
+ Address g1AllocatorAddr = g1Allocator.getValue(addr);
+ return (G1Allocator) VMObjectFactory.newObject(G1Allocator.class, g1AllocatorAddr);
+ }
+
public HeapRegionSetBase oldSet() {
Address oldSetAddr = addr.addOffsetTo(oldSetFieldOffset);
return (HeapRegionSetBase) VMObjectFactory.newObject(HeapRegionSetBase.class,
--- a/hotspot/make/bsd/makefiles/vm.make Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/bsd/makefiles/vm.make Fri Oct 10 02:24:41 2014 -0700
@@ -234,10 +234,10 @@
vm_version.o: $(filter-out vm_version.o,$(JVM_OBJ_FILES))
-mapfile : $(MAPFILE) vm.def
+mapfile : $(MAPFILE) vm.def mapfile_ext
rm -f $@
awk '{ if ($$0 ~ "INSERT VTABLE SYMBOLS HERE") \
- { system ("cat vm.def"); } \
+ { system ("cat mapfile_ext"); system ("cat vm.def"); } \
else \
{ print $$0 } \
}' > $@ < $(MAPFILE)
@@ -249,6 +249,13 @@
vm.def: $(Res_Files) $(Obj_Files)
sh $(GAMMADIR)/make/bsd/makefiles/build_vm_def.sh *.o > $@
+mapfile_ext:
+ rm -f $@
+ touch $@
+ if [ -f $(HS_ALT_MAKE)/bsd/makefiles/mapfile-ext ]; then \
+ cat $(HS_ALT_MAKE)/bsd/makefiles/mapfile-ext > $@; \
+ fi
+
STATIC_CXX = false
ifeq ($(LINK_INTO),AOUT)
@@ -265,6 +272,8 @@
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/.
LFLAGS_VM += -Xlinker -rpath -Xlinker @loader_path/..
LFLAGS_VM += -Xlinker -install_name -Xlinker @rpath/$(@F)
+ else
+ LFLAGS_VM += -Wl,-z,defs
endif
# JVM is statically linked with libgcc[_s] and libstdc++; this is needed to
--- a/hotspot/make/excludeSrc.make Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/excludeSrc.make Fri Oct 10 02:24:41 2014 -0700
@@ -21,6 +21,9 @@
# questions.
#
#
+
+include $(GAMMADIR)/make/altsrc.make
+
ifeq ($(INCLUDE_JVMTI), false)
CXXFLAGS += -DINCLUDE_JVMTI=0
CFLAGS += -DINCLUDE_JVMTI=0
@@ -78,12 +81,12 @@
CXXFLAGS += -DINCLUDE_ALL_GCS=0
CFLAGS += -DINCLUDE_ALL_GCS=0
- gc_impl := $(GAMMADIR)/src/share/vm/gc_implementation
- gc_exclude := \
- $(notdir $(wildcard $(gc_impl)/concurrentMarkSweep/*.cpp)) \
- $(notdir $(wildcard $(gc_impl)/g1/*.cpp)) \
- $(notdir $(wildcard $(gc_impl)/parallelScavenge/*.cpp)) \
- $(notdir $(wildcard $(gc_impl)/parNew/*.cpp))
+ gc_impl := $(HS_COMMON_SRC)/share/vm/gc_implementation
+ gc_impl_alt := $(HS_ALT_SRC)/share/vm/gc_implementation
+ gc_subdirs := concurrentMarkSweep g1 parallelScavenge parNew
+ gc_exclude := $(foreach gc,$(gc_subdirs), \
+ $(notdir $(wildcard $(gc_impl)/$(gc)/*.cpp)) \
+ $(notdir $(wildcard $(gc_impl_alt)/$(gc)/*.cpp)))
Src_Files_EXCLUDE += $(gc_exclude)
# Exclude everything in $(gc_impl)/shared except the files listed
--- a/hotspot/make/jprt.properties Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,388 +0,0 @@
-#
-# Copyright (c) 2006, 2013, 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.
-#
-#
-
-# Properties for jprt
-
-# All build result bundles are full jdks.
-jprt.need.sibling.build=false
-
-# At submit time, the release supplied will be in jprt.submit.release
-# and will be one of the official release names defined in jprt.
-# jprt supports property value expansion using ${property.name} syntax.
-
-# This tells jprt what default release we want to build
-
-jprt.hotspot.default.release=jdk9
-
-jprt.tools.default.release=${jprt.submit.option.release?${jprt.submit.option.release}:${jprt.hotspot.default.release}}
-
-# Disable syncing the source after builds and tests are done.
-
-jprt.sync.push=false
-
-# Note: we want both embedded releases and regular releases to build and test
-# all platforms so that regressions are not introduced (eg. change to
-# common code by SE breaks PPC/ARM; change to common code by SE-E breaks
-# sparc etc.
-
-# Define the Solaris platforms we want for the various releases
-jprt.my.solaris.sparcv9.jdk9=solaris_sparcv9_5.11
-jprt.my.solaris.sparcv9=${jprt.my.solaris.sparcv9.${jprt.tools.default.release}}
-
-jprt.my.solaris.x64.jdk9=solaris_x64_5.11
-jprt.my.solaris.x64=${jprt.my.solaris.x64.${jprt.tools.default.release}}
-
-jprt.my.linux.i586.jdk9=linux_i586_2.6
-jprt.my.linux.i586=${jprt.my.linux.i586.${jprt.tools.default.release}}
-
-jprt.my.linux.x64.jdk9=linux_x64_2.6
-jprt.my.linux.x64=${jprt.my.linux.x64.${jprt.tools.default.release}}
-
-jprt.my.linux.ppc.jdk9=linux_ppc_2.6
-jprt.my.linux.ppc=${jprt.my.linux.ppc.${jprt.tools.default.release}}
-
-jprt.my.linux.ppcv2.jdk9=linux_ppcv2_2.6
-jprt.my.linux.ppcv2=${jprt.my.linux.ppcv2.${jprt.tools.default.release}}
-
-jprt.my.linux.armvfpsflt.jdk9=linux_armvfpsflt_2.6
-jprt.my.linux.armvfpsflt=${jprt.my.linux.armvfpsflt.${jprt.tools.default.release}}
-
-jprt.my.linux.armvfphflt.jdk9=linux_armvfphflt_2.6
-jprt.my.linux.armvfphflt=${jprt.my.linux.armvfphflt.${jprt.tools.default.release}}
-
-# The ARM GP vfp-sflt build is not currently supported
-#jprt.my.linux.armvs.jdk9=linux_armvs_2.6
-#jprt.my.linux.armvs=${jprt.my.linux.armvs.${jprt.tools.default.release}}
-
-jprt.my.linux.armvh.jdk9=linux_armvh_2.6
-jprt.my.linux.armvh=${jprt.my.linux.armvh.${jprt.tools.default.release}}
-
-jprt.my.linux.armsflt.jdk9=linux_armsflt_2.6
-jprt.my.linux.armsflt=${jprt.my.linux.armsflt.${jprt.tools.default.release}}
-
-jprt.my.macosx.x64.jdk9=macosx_x64_10.7
-jprt.my.macosx.x64=${jprt.my.macosx.x64.${jprt.tools.default.release}}
-
-jprt.my.windows.i586.jdk9=windows_i586_6.1
-jprt.my.windows.i586=${jprt.my.windows.i586.${jprt.tools.default.release}}
-
-jprt.my.windows.x64.jdk9=windows_x64_6.1
-jprt.my.windows.x64=${jprt.my.windows.x64.${jprt.tools.default.release}}
-
-# Standard list of jprt build targets for this source tree
-
-jprt.build.targets.standard= \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}, \
- ${jprt.my.solaris.x64}-{product|fastdebug}, \
- ${jprt.my.linux.i586}-{product|fastdebug}, \
- ${jprt.my.linux.x64}-{product|fastdebug}, \
- ${jprt.my.macosx.x64}-{product|fastdebug}, \
- ${jprt.my.windows.i586}-{product|fastdebug}, \
- ${jprt.my.windows.x64}-{product|fastdebug}, \
- ${jprt.my.linux.armvh}-{product|fastdebug}
-
-jprt.build.targets.open= \
- ${jprt.my.solaris.x64}-{debugOpen}, \
- ${jprt.my.linux.x64}-{productOpen}
-
-jprt.build.targets.embedded= \
- ${jprt.my.linux.i586}-{productEmb|fastdebugEmb}, \
- ${jprt.my.linux.ppc}-{productEmb|fastdebugEmb}, \
- ${jprt.my.linux.ppcv2}-{productEmb|fastdebugEmb}, \
- ${jprt.my.linux.armvfpsflt}-{productEmb|fastdebugEmb}, \
- ${jprt.my.linux.armvfphflt}-{productEmb|fastdebugEmb}, \
- ${jprt.my.linux.armsflt}-{productEmb|fastdebugEmb}
-
-jprt.build.targets.all=${jprt.build.targets.standard}, \
- ${jprt.build.targets.embedded}, ${jprt.build.targets.open}
-
-jprt.build.targets.jdk9=${jprt.build.targets.all}
-jprt.build.targets=${jprt.build.targets.${jprt.tools.default.release}}
-
-# Subset lists of test targets for this source tree
-
-jprt.my.solaris.sparcv9.test.targets= \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jvm98, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-scimark, \
- ${jprt.my.solaris.sparcv9}-product-c2-runThese8, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_SerialGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_ParallelGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_ParNewGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_CMS, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_G1, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCBasher_ParOldGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_SerialGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_ParallelGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_ParNewGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-GCOld_ParOldGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_SerialGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_ParallelGC, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_CMS, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_G1, \
- ${jprt.my.solaris.sparcv9}-{product|fastdebug}-c2-jbb_ParOldGC
-
-jprt.my.solaris.x64.test.targets= \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-jvm98, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-scimark, \
- ${jprt.my.solaris.x64}-product-c2-runThese8, \
- ${jprt.my.solaris.x64}-product-c2-runThese8_Xcomp_lang, \
- ${jprt.my.solaris.x64}-product-c2-runThese8_Xcomp_vm, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_SerialGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_ParallelGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_ParNewGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_CMS, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_G1, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCBasher_ParOldGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_SerialGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_ParallelGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_ParNewGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_ParOldGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-jbb_SerialGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-jbb_ParallelGC, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.solaris.x64}-{product|fastdebug}-c2-GCOld_ParOldGC
-
-jprt.my.linux.i586.test.targets = \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-jvm98, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-scimark, \
- ${jprt.my.linux.i586}-product-c1-runThese8_Xcomp_lang, \
- ${jprt.my.linux.i586}-product-c1-runThese8_Xcomp_vm, \
- ${jprt.my.linux.i586}-fastdebug-c1-runThese8_Xshare, \
- ${jprt.my.linux.i586}-fastdebug-c2-runThese8_Xcomp_lang, \
- ${jprt.my.linux.i586}-fastdebug-c2-runThese8_Xcomp_vm, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_SerialGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParallelGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParNewGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_CMS, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_G1, \
- ${jprt.my.linux.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParOldGC, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_SerialGC, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_ParallelGC, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_ParNewGC, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_CMS, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_G1, \
- ${jprt.my.linux.i586}-product-{c1|c2}-GCOld_ParOldGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c1-jbb_SerialGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c1-jbb_ParallelGC, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c1-jbb_CMS, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c1-jbb_G1, \
- ${jprt.my.linux.i586}-{product|fastdebug}-c1-jbb_ParOldGC
-
-jprt.my.linux.x64.test.targets = \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jvm98, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-scimark, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_SerialGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_ParallelGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_ParNewGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_CMS, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_G1, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCBasher_ParOldGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_SerialGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_ParallelGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_ParNewGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-GCOld_ParOldGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jbb_ParallelGC, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jbb_G1, \
- ${jprt.my.linux.x64}-{product|fastdebug}-c2-jbb_ParOldGC
-
-jprt.my.macosx.x64.test.targets = \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jvm98, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-scimark, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_SerialGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_ParallelGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_ParNewGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_CMS, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_G1, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCBasher_ParOldGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_SerialGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_ParallelGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_ParNewGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-GCOld_ParOldGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jbb_ParallelGC, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jbb_G1, \
- ${jprt.my.macosx.x64}-{product|fastdebug}-c2-jbb_ParOldGC
-
-jprt.my.windows.i586.test.targets = \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-jvm98, \
- ${jprt.my.windows.i586}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-scimark, \
- ${jprt.my.windows.i586}-product-{c1|c2}-runThese8, \
- ${jprt.my.windows.i586}-product-{c1|c2}-runThese8_Xcomp_lang, \
- ${jprt.my.windows.i586}-product-{c1|c2}-runThese8_Xcomp_vm, \
- ${jprt.my.windows.i586}-fastdebug-c1-runThese8_Xshare, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_SerialGC, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParallelGC, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParNewGC, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_CMS, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_G1, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-GCBasher_ParOldGC, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_SerialGC, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_ParallelGC, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_ParNewGC, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_CMS, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_G1, \
- ${jprt.my.windows.i586}-product-{c1|c2}-GCOld_ParOldGC, \
- ${jprt.my.windows.i586}-{product|fastdebug}-{c1|c2}-jbb_default, \
- ${jprt.my.windows.i586}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.windows.i586}-product-{c1|c2}-jbb_ParallelGC, \
- ${jprt.my.windows.i586}-product-{c1|c2}-jbb_CMS, \
- ${jprt.my.windows.i586}-product-{c1|c2}-jbb_G1, \
- ${jprt.my.windows.i586}-product-{c1|c2}-jbb_ParOldGC
-
-jprt.my.windows.x64.test.targets = \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-jvm98, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-jvm98_nontiered, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-scimark, \
- ${jprt.my.windows.x64}-product-c2-runThese8, \
- ${jprt.my.windows.x64}-product-c2-runThese8_Xcomp_lang, \
- ${jprt.my.windows.x64}-product-c2-runThese8_Xcomp_vm, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_SerialGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_ParallelGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_ParNewGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_CMS, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_G1, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCBasher_ParOldGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_SerialGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_ParallelGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_ParNewGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_CMS, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_G1, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-GCOld_ParOldGC, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-jbb_default, \
- ${jprt.my.windows.x64}-{product|fastdebug}-c2-jbb_default_nontiered, \
- ${jprt.my.windows.x64}-product-c2-jbb_CMS, \
- ${jprt.my.windows.x64}-product-c2-jbb_ParallelGC, \
- ${jprt.my.windows.x64}-product-c2-jbb_G1, \
- ${jprt.my.windows.x64}-product-c2-jbb_ParOldGC
-
-# Some basic "smoke" tests for OpenJDK builds
-jprt.test.targets.open = \
- ${jprt.my.solaris.x64}-{productOpen|fastdebugOpen}-c2-jvm98, \
- ${jprt.my.linux.x64}-{productOpen|fastdebugOpen}-c2-jvm98
-
-# Testing for actual embedded builds is different to standard
-jprt.my.linux.i586.test.targets.embedded = \
- linux_i586_2.6-product-c1-scimark
-
-# The complete list of test targets for jprt
-# Note: no PPC or ARM tests at this stage
-
-jprt.test.targets.standard = \
- ${jprt.my.linux.i586.test.targets.embedded}, \
- ${jprt.my.solaris.sparcv9.test.targets}, \
- ${jprt.my.solaris.x64.test.targets}, \
- ${jprt.my.linux.i586.test.targets}, \
- ${jprt.my.linux.x64.test.targets}, \
- ${jprt.my.macosx.x64.test.targets}, \
- ${jprt.my.windows.i586.test.targets}, \
- ${jprt.my.windows.x64.test.targets}, \
- ${jprt.test.targets.open}
-
-jprt.test.targets.embedded= \
- ${jprt.my.linux.i586.test.targets.embedded}, \
- ${jprt.my.solaris.sparcv9.test.targets}, \
- ${jprt.my.solaris.x64.test.targets}, \
- ${jprt.my.linux.x64.test.targets}, \
- ${jprt.my.windows.i586.test.targets}, \
- ${jprt.my.windows.x64.test.targets}
-
-jprt.test.targets.jdk9=${jprt.test.targets.standard}
-jprt.test.targets=${jprt.test.targets.${jprt.tools.default.release}}
-
-# The default test/Makefile targets that should be run
-
-#jprt.make.rule.test.targets=*-product-*-packtest
-
-jprt.make.rule.test.targets.standard.client = \
- ${jprt.my.linux.i586}-*-c1-clienttest, \
- ${jprt.my.windows.i586}-*-c1-clienttest
-
-jprt.make.rule.test.targets.standard.server = \
- ${jprt.my.solaris.sparcv9}-*-c2-servertest, \
- ${jprt.my.solaris.x64}-*-c2-servertest, \
- ${jprt.my.linux.i586}-*-c2-servertest, \
- ${jprt.my.linux.x64}-*-c2-servertest, \
- ${jprt.my.macosx.x64}-*-c2-servertest, \
- ${jprt.my.windows.i586}-*-c2-servertest, \
- ${jprt.my.windows.x64}-*-c2-servertest
-
-jprt.make.rule.test.targets.standard.internalvmtests = \
- ${jprt.my.solaris.sparcv9}-fastdebug-c2-internalvmtests, \
- ${jprt.my.solaris.x64}-fastdebug-c2-internalvmtests, \
- ${jprt.my.linux.i586}-fastdebug-c2-internalvmtests, \
- ${jprt.my.linux.x64}-fastdebug-c2-internalvmtests, \
- ${jprt.my.macosx.x64}-fastdebug-c2-internalvmtests, \
- ${jprt.my.windows.i586}-fastdebug-c2-internalvmtests, \
- ${jprt.my.windows.x64}-fastdebug-c2-internalvmtests
-
-jprt.make.rule.test.targets.standard.reg.group = \
- ${jprt.my.solaris.sparcv9}-fastdebug-c2-GROUP, \
- ${jprt.my.solaris.x64}-fastdebug-c2-GROUP, \
- ${jprt.my.linux.i586}-fastdebug-c2-GROUP, \
- ${jprt.my.linux.x64}-fastdebug-c2-GROUP, \
- ${jprt.my.macosx.x64}-fastdebug-c2-GROUP, \
- ${jprt.my.windows.i586}-fastdebug-c2-GROUP, \
- ${jprt.my.windows.x64}-fastdebug-c2-GROUP, \
- ${jprt.my.linux.i586}-fastdebug-c1-GROUP, \
- ${jprt.my.windows.i586}-fastdebug-c1-GROUP
-
-jprt.make.rule.test.targets.standard = \
- ${jprt.make.rule.test.targets.standard.client}, \
- ${jprt.make.rule.test.targets.standard.server}, \
- ${jprt.make.rule.test.targets.standard.internalvmtests}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_wbapitest}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_compiler}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_gc}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_runtime}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_runtime_closed}, \
- ${jprt.make.rule.test.targets.standard.reg.group:GROUP=hotspot_serviceability}
-
-jprt.make.rule.test.targets.embedded = \
- ${jprt.make.rule.test.targets.standard.client}
-
-jprt.make.rule.test.targets.jdk9=${jprt.make.rule.test.targets.standard}
-jprt.make.rule.test.targets=${jprt.make.rule.test.targets.${jprt.tools.default.release}}
-
-# 7155453: Work-around to prevent popups on OSX from blocking test completion
-# but the work-around is added to all platforms to be consistent
-jprt.jbb.options=-Djava.awt.headless=true
--- a/hotspot/make/linux/makefiles/vm.make Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/linux/makefiles/vm.make Fri Oct 10 02:24:41 2014 -0700
@@ -227,10 +227,10 @@
vm_version.o: $(filter-out vm_version.o,$(JVM_OBJ_FILES))
-mapfile : $(MAPFILE) vm.def
+mapfile : $(MAPFILE) vm.def mapfile_ext
rm -f $@
awk '{ if ($$0 ~ "INSERT VTABLE SYMBOLS HERE") \
- { system ("cat vm.def"); } \
+ { system ("cat mapfile_ext"); system ("cat vm.def"); } \
else \
{ print $$0 } \
}' > $@ < $(MAPFILE)
@@ -242,6 +242,13 @@
vm.def: $(Res_Files) $(Obj_Files)
sh $(GAMMADIR)/make/linux/makefiles/build_vm_def.sh *.o > $@
+mapfile_ext:
+ rm -f $@
+ touch $@
+ if [ -f $(HS_ALT_MAKE)/linux/makefiles/mapfile-ext ]; then \
+ cat $(HS_ALT_MAKE)/linux/makefiles/mapfile-ext > $@; \
+ fi
+
ifeq ($(JVM_VARIANT_ZEROSHARK), true)
STATIC_CXX = false
else
@@ -261,6 +268,7 @@
LIBJVM_MAPFILE$(LDNOMAP) = mapfile_reorder
LFLAGS_VM$(LDNOMAP) += $(MAPFLAG:FILENAME=$(LIBJVM_MAPFILE))
LFLAGS_VM += $(SONAMEFLAG:SONAME=$(LIBJVM))
+ LFLAGS_VM += -Wl,-z,defs
# JVM is statically linked with libgcc[_s] and libstdc++; this is needed to
# get around library dependency and compatibility issues. Must use gcc not
--- a/hotspot/make/solaris/makefiles/buildtree.make Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/solaris/makefiles/buildtree.make Fri Oct 10 02:24:41 2014 -0700
@@ -258,6 +258,8 @@
echo && echo "ZIP_DEBUGINFO_FILES = $(ZIP_DEBUGINFO_FILES)"; \
[ -n "$(ZIPEXE)" ] && \
echo && echo "ZIPEXE = $(ZIPEXE)"; \
+ [ -n "$(HS_ALT_MAKE)" ] && \
+ echo && echo "HS_ALT_MAKE = $(HS_ALT_MAKE)"; \
[ -n "$(HOTSPOT_EXTRA_SYSDEFS)" ] && \
echo && \
echo "HOTSPOT_EXTRA_SYSDEFS\$$(HOTSPOT_EXTRA_SYSDEFS) = $(HOTSPOT_EXTRA_SYSDEFS)" && \
--- a/hotspot/make/solaris/makefiles/mapfile-vers-COMPILER1 Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/solaris/makefiles/mapfile-vers-COMPILER1 Fri Oct 10 02:24:41 2014 -0700
@@ -29,7 +29,7 @@
SUNWprivate_1.1 {
global:
# Dtrace support
- __1cJCodeCacheF_heap_;
+ __1cJCodeCacheG_heaps_;
__1cIUniverseO_collectedHeap_;
__1cGMethodG__vtbl_;
__1cHnmethodG__vtbl_;
--- a/hotspot/make/solaris/makefiles/mapfile-vers-COMPILER2 Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/solaris/makefiles/mapfile-vers-COMPILER2 Fri Oct 10 02:24:41 2014 -0700
@@ -29,7 +29,7 @@
SUNWprivate_1.1 {
global:
# Dtrace support
- __1cJCodeCacheF_heap_;
+ __1cJCodeCacheG_heaps_;
__1cIUniverseO_collectedHeap_;
__1cGMethodG__vtbl_;
__1cHnmethodG__vtbl_;
--- a/hotspot/make/solaris/makefiles/mapfile-vers-TIERED Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/solaris/makefiles/mapfile-vers-TIERED Fri Oct 10 02:24:41 2014 -0700
@@ -29,7 +29,7 @@
SUNWprivate_1.1 {
global:
# Dtrace support
- __1cJCodeCacheF_heap_;
+ __1cJCodeCacheG_heaps_;
__1cIUniverseO_collectedHeap_;
__1cGMethodG__vtbl_;
__1cHnmethodG__vtbl_;
--- a/hotspot/make/solaris/makefiles/vm.make Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/make/solaris/makefiles/vm.make Fri Oct 10 02:24:41 2014 -0700
@@ -130,7 +130,7 @@
# Not sure what the 'designed for' comment is referring too above.
# The order may not be too significant anymore, but I have placed this
# older libm before libCrun, just to make sure it's found and used first.
-LIBS += -lsocket -lsched -ldl $(LIBM) -lCrun -lthread -ldoor -lc -ldemangle
+LIBS += -lsocket -lsched -ldl $(LIBM) -lCrun -lthread -ldoor -lc -ldemangle -lnsl
else
ifeq ($(COMPILER_REV_NUMERIC), 502)
# SC6.1 has it's own libm.so: specifying anything else provokes a name conflict.
@@ -249,11 +249,12 @@
vm_version.o: $(filter-out vm_version.o,$(JVM_OBJ_FILES))
-mapfile : $(MAPFILE) $(MAPFILE_DTRACE_OPT) vm.def
+mapfile : $(MAPFILE) $(MAPFILE_DTRACE_OPT) vm.def mapfile_ext
rm -f $@
cat $(MAPFILE) $(MAPFILE_DTRACE_OPT) \
| $(NAWK) '{ \
if ($$0 ~ "INSERT VTABLE SYMBOLS HERE") { \
+ system ("cat mapfile_ext"); \
system ("cat vm.def"); \
} else { \
print $$0; \
@@ -267,6 +268,13 @@
vm.def: $(Obj_Files)
sh $(GAMMADIR)/make/solaris/makefiles/build_vm_def.sh *.o > $@
+mapfile_ext:
+ rm -f $@
+ touch $@
+ if [ -f $(HS_ALT_MAKE)/solaris/makefiles/mapfile-ext ]; then \
+ cat $(HS_ALT_MAKE)/solaris/makefiles/mapfile-ext > $@; \
+ fi
+
ifeq ($(LINK_INTO),AOUT)
LIBJVM.o =
LIBJVM_MAPFILE =
@@ -276,6 +284,7 @@
LIBJVM_MAPFILE$(LDNOMAP) = mapfile_extended
LFLAGS_VM$(LDNOMAP) += $(MAPFLAG:FILENAME=$(LIBJVM_MAPFILE))
LFLAGS_VM += $(SONAMEFLAG:SONAME=$(LIBJVM))
+ LFLAGS_VM += -Wl,-z,defs
ifndef USE_GCC
LIBS_VM = $(LIBS)
else
--- a/hotspot/src/cpu/ppc/vm/c2_globals_ppc.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/ppc/vm/c2_globals_ppc.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -79,6 +79,9 @@
define_pd_global(intx, InitialCodeCacheSize, 2048*K); // Integral multiple of CodeCacheExpansionSize
define_pd_global(intx, ReservedCodeCacheSize, 256*M);
+define_pd_global(intx, NonProfiledCodeHeapSize, 125*M);
+define_pd_global(intx, ProfiledCodeHeapSize, 126*M);
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(intx, CodeCacheExpansionSize, 64*K);
// Ergonomics related flags
--- a/hotspot/src/cpu/ppc/vm/frame_ppc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/ppc/vm/frame_ppc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -308,3 +308,10 @@
// unused... but returns fp() to minimize changes introduced by 7087445
return fp();
}
+
+#ifndef PRODUCT
+// This is a generic constructor which is only used by pns() in debug.cpp.
+frame::frame(void* sp, void* fp, void* pc) : _sp((intptr_t*)sp), _unextended_sp((intptr_t*)sp) {
+ find_codeblob_and_set_pc_and_deopt_state((address)pc); // also sets _fp and adjusts _unextended_sp
+}
+#endif
--- a/hotspot/src/cpu/sparc/vm/c1_globals_sparc.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_globals_sparc.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -47,6 +47,9 @@
define_pd_global(intx, FreqInlineSize, 325 );
define_pd_global(bool, ResizeTLAB, true );
define_pd_global(intx, ReservedCodeCacheSize, 32*M );
+define_pd_global(intx, NonProfiledCodeHeapSize, 13*M );
+define_pd_global(intx, ProfiledCodeHeapSize, 14*M );
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(intx, CodeCacheExpansionSize, 32*K );
define_pd_global(uintx, CodeCacheMinBlockLength, 1);
define_pd_global(uintx, CodeCacheMinimumUseSpace, 400*K);
--- a/hotspot/src/cpu/sparc/vm/c2_globals_sparc.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/c2_globals_sparc.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -74,6 +74,9 @@
// InitialCodeCacheSize derived from specjbb2000 run.
define_pd_global(intx, InitialCodeCacheSize, 2048*K); // Integral multiple of CodeCacheExpansionSize
define_pd_global(intx, ReservedCodeCacheSize, 48*M);
+define_pd_global(intx, NonProfiledCodeHeapSize, 21*M);
+define_pd_global(intx, ProfiledCodeHeapSize, 22*M);
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(intx, CodeCacheExpansionSize, 64*K);
// Ergonomics related flags
@@ -82,6 +85,9 @@
// InitialCodeCacheSize derived from specjbb2000 run.
define_pd_global(intx, InitialCodeCacheSize, 1536*K); // Integral multiple of CodeCacheExpansionSize
define_pd_global(intx, ReservedCodeCacheSize, 32*M);
+define_pd_global(intx, NonProfiledCodeHeapSize, 13*M);
+define_pd_global(intx, ProfiledCodeHeapSize, 14*M);
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(intx, CodeCacheExpansionSize, 32*K);
// Ergonomics related flags
define_pd_global(uint64_t,MaxRAM, 4ULL*G);
--- a/hotspot/src/cpu/sparc/vm/frame_sparc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/frame_sparc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -343,7 +343,7 @@
// constructors
// Construct an unpatchable, deficient frame
-frame::frame(intptr_t* sp, unpatchable_t, address pc, CodeBlob* cb) {
+void frame::init(intptr_t* sp, address pc, CodeBlob* cb) {
#ifdef _LP64
assert( (((intptr_t)sp & (wordSize-1)) == 0), "frame constructor passed an invalid sp");
#endif
@@ -365,6 +365,10 @@
#endif // ASSERT
}
+frame::frame(intptr_t* sp, unpatchable_t, address pc, CodeBlob* cb) {
+ init(sp, pc, cb);
+}
+
frame::frame(intptr_t* sp, intptr_t* younger_sp, bool younger_frame_is_interpreted) :
_sp(sp),
_younger_sp(younger_sp),
@@ -419,6 +423,13 @@
}
}
+#ifndef PRODUCT
+// This is a generic constructor which is only used by pns() in debug.cpp.
+frame::frame(void* sp, void* fp, void* pc) {
+ init((intptr_t*)sp, (address)pc, NULL);
+}
+#endif
+
bool frame::is_interpreted_frame() const {
return Interpreter::contains(pc());
}
--- a/hotspot/src/cpu/sparc/vm/frame_sparc.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/frame_sparc.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -163,6 +163,8 @@
enum unpatchable_t { unpatchable };
frame(intptr_t* sp, unpatchable_t, address pc = NULL, CodeBlob* cb = NULL);
+ void init(intptr_t* sp, address pc, CodeBlob* cb);
+
// Walk from sp outward looking for old_sp, and return old_sp's predecessor
// (i.e. return the sp from the frame where old_sp is the fp).
// Register windows are assumed to be flushed for the stack in question.
--- a/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/sharedRuntime_sparc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1128,51 +1128,82 @@
// Hoist any int/ptr/long's in the first 6 to int regs.
// Hoist any flt/dbl's in the first 16 dbl regs.
int j = 0; // Count of actual args, not HALVES
- for( int i=0; i<total_args_passed; i++, j++ ) {
- switch( sig_bt[i] ) {
+ VMRegPair param_array_reg; // location of the argument in the parameter array
+ for (int i = 0; i < total_args_passed; i++, j++) {
+ param_array_reg.set_bad();
+ switch (sig_bt[i]) {
case T_BOOLEAN:
case T_BYTE:
case T_CHAR:
case T_INT:
case T_SHORT:
- regs[i].set1( int_stk_helper( j ) ); break;
+ regs[i].set1(int_stk_helper(j));
+ break;
case T_LONG:
- assert( sig_bt[i+1] == T_VOID, "expecting half" );
+ assert(sig_bt[i+1] == T_VOID, "expecting half");
case T_ADDRESS: // raw pointers, like current thread, for VM calls
case T_ARRAY:
case T_OBJECT:
case T_METADATA:
- regs[i].set2( int_stk_helper( j ) );
+ regs[i].set2(int_stk_helper(j));
break;
case T_FLOAT:
- if ( j < 16 ) {
- // V9ism: floats go in ODD registers
- regs[i].set1(as_FloatRegister(1 + (j<<1))->as_VMReg());
- } else {
- // V9ism: floats go in ODD stack slot
- regs[i].set1(VMRegImpl::stack2reg(1 + (j<<1)));
+ // Per SPARC Compliance Definition 2.4.1, page 3P-12 available here
+ // http://www.sparc.org/wp-content/uploads/2014/01/SCD.2.4.1.pdf.gz
+ //
+ // "When a callee prototype exists, and does not indicate variable arguments,
+ // floating-point values assigned to locations %sp+BIAS+128 through %sp+BIAS+248
+ // will be promoted to floating-point registers"
+ //
+ // By "promoted" it means that the argument is located in two places, an unused
+ // spill slot in the "parameter array" (starts at %sp+BIAS+128), and a live
+ // float register. In most cases, there are 6 or fewer arguments of any type,
+ // and the standard parameter array slots (%sp+BIAS+128 to %sp+BIAS+176 exclusive)
+ // serve as shadow slots. Per the spec floating point registers %d6 to %d16
+ // require slots beyond that (up to %sp+BIAS+248).
+ //
+ {
+ // V9ism: floats go in ODD registers and stack slots
+ int float_index = 1 + (j << 1);
+ param_array_reg.set1(VMRegImpl::stack2reg(float_index));
+ if (j < 16) {
+ regs[i].set1(as_FloatRegister(float_index)->as_VMReg());
+ } else {
+ regs[i] = param_array_reg;
+ }
}
break;
case T_DOUBLE:
- assert( sig_bt[i+1] == T_VOID, "expecting half" );
- if ( j < 16 ) {
- // V9ism: doubles go in EVEN/ODD regs
- regs[i].set2(as_FloatRegister(j<<1)->as_VMReg());
- } else {
- // V9ism: doubles go in EVEN/ODD stack slots
- regs[i].set2(VMRegImpl::stack2reg(j<<1));
+ {
+ assert(sig_bt[i + 1] == T_VOID, "expecting half");
+ // V9ism: doubles go in EVEN/ODD regs and stack slots
+ int double_index = (j << 1);
+ param_array_reg.set2(VMRegImpl::stack2reg(double_index));
+ if (j < 16) {
+ regs[i].set2(as_FloatRegister(double_index)->as_VMReg());
+ } else {
+ // V9ism: doubles go in EVEN/ODD stack slots
+ regs[i] = param_array_reg;
+ }
}
break;
- case T_VOID: regs[i].set_bad(); j--; break; // Do not count HALVES
+ case T_VOID:
+ regs[i].set_bad();
+ j--;
+ break; // Do not count HALVES
default:
ShouldNotReachHere();
}
- if (regs[i].first()->is_stack()) {
- int off = regs[i].first()->reg2stack();
+ // Keep track of the deepest parameter array slot.
+ if (!param_array_reg.first()->is_valid()) {
+ param_array_reg = regs[i];
+ }
+ if (param_array_reg.first()->is_stack()) {
+ int off = param_array_reg.first()->reg2stack();
if (off > max_stack_slots) max_stack_slots = off;
}
- if (regs[i].second()->is_stack()) {
- int off = regs[i].second()->reg2stack();
+ if (param_array_reg.second()->is_stack()) {
+ int off = param_array_reg.second()->reg2stack();
if (off > max_stack_slots) max_stack_slots = off;
}
}
@@ -1180,8 +1211,8 @@
#else // _LP64
// V8 convention: first 6 things in O-regs, rest on stack.
// Alignment is willy-nilly.
- for( int i=0; i<total_args_passed; i++ ) {
- switch( sig_bt[i] ) {
+ for (int i = 0; i < total_args_passed; i++) {
+ switch (sig_bt[i]) {
case T_ADDRESS: // raw pointers, like current thread, for VM calls
case T_ARRAY:
case T_BOOLEAN:
@@ -1192,23 +1223,23 @@
case T_OBJECT:
case T_METADATA:
case T_SHORT:
- regs[i].set1( int_stk_helper( i ) );
+ regs[i].set1(int_stk_helper(i));
break;
case T_DOUBLE:
case T_LONG:
- assert( sig_bt[i+1] == T_VOID, "expecting half" );
- regs[i].set_pair( int_stk_helper( i+1 ), int_stk_helper( i ) );
+ assert(sig_bt[i + 1] == T_VOID, "expecting half");
+ regs[i].set_pair(int_stk_helper(i + 1), int_stk_helper(i));
break;
case T_VOID: regs[i].set_bad(); break;
default:
ShouldNotReachHere();
}
if (regs[i].first()->is_stack()) {
- int off = regs[i].first()->reg2stack();
+ int off = regs[i].first()->reg2stack();
if (off > max_stack_slots) max_stack_slots = off;
}
if (regs[i].second()->is_stack()) {
- int off = regs[i].second()->reg2stack();
+ int off = regs[i].second()->reg2stack();
if (off > max_stack_slots) max_stack_slots = off;
}
}
@@ -1357,11 +1388,10 @@
const Register rOop = src.first()->as_Register();
const Register rHandle = L5;
int oop_slot = rOop->input_number() * VMRegImpl::slots_per_word + oop_handle_offset;
- int offset = oop_slot*VMRegImpl::stack_slot_size;
- Label skip;
+ int offset = oop_slot * VMRegImpl::stack_slot_size;
__ st_ptr(rOop, SP, offset + STACK_BIAS);
if (is_receiver) {
- *receiver_offset = oop_slot * VMRegImpl::stack_slot_size;
+ *receiver_offset = offset;
}
map->set_oop(VMRegImpl::stack2reg(oop_slot));
__ add(SP, offset + STACK_BIAS, rHandle);
--- a/hotspot/src/cpu/sparc/vm/sparc.ad Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/sparc/vm/sparc.ad Fri Oct 10 02:24:41 2014 -0700
@@ -1989,7 +1989,7 @@
// to implement the UseStrictFP mode.
const bool Matcher::strict_fp_requires_explicit_rounding = false;
-// Are floats conerted to double when stored to stack during deoptimization?
+// Are floats converted to double when stored to stack during deoptimization?
// Sparc does not handle callee-save floats.
bool Matcher::float_in_double() { return false; }
@@ -3218,7 +3218,7 @@
// are owned by the CALLEE. Holes should not be nessecary in the
// incoming area, as the Java calling convention is completely under
// the control of the AD file. Doubles can be sorted and packed to
-// avoid holes. Holes in the outgoing arguments may be nessecary for
+// avoid holes. Holes in the outgoing arguments may be necessary for
// varargs C calling conventions.
// Note 3: Region 0-3 is even aligned, with pad2 as needed. Region 3-5 is
// even aligned with pad0 as needed.
@@ -3284,7 +3284,7 @@
%}
// Body of function which returns an OptoRegs array locating
- // arguments either in registers or in stack slots for callin
+ // arguments either in registers or in stack slots for calling
// C.
c_calling_convention %{
// This is obviously always outgoing
--- a/hotspot/src/cpu/x86/vm/c1_globals_x86.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/x86/vm/c1_globals_x86.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -47,6 +47,9 @@
define_pd_global(intx, NewSizeThreadIncrease, 4*K );
define_pd_global(intx, InitialCodeCacheSize, 160*K);
define_pd_global(intx, ReservedCodeCacheSize, 32*M );
+define_pd_global(intx, NonProfiledCodeHeapSize, 13*M );
+define_pd_global(intx, ProfiledCodeHeapSize, 14*M );
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(bool, ProfileInterpreter, false);
define_pd_global(intx, CodeCacheExpansionSize, 32*K );
define_pd_global(uintx, CodeCacheMinBlockLength, 1);
--- a/hotspot/src/cpu/x86/vm/c2_globals_x86.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/x86/vm/c2_globals_x86.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -84,6 +84,9 @@
define_pd_global(bool, OptoBundling, false);
define_pd_global(intx, ReservedCodeCacheSize, 48*M);
+define_pd_global(intx, NonProfiledCodeHeapSize, 21*M);
+define_pd_global(intx, ProfiledCodeHeapSize, 22*M);
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(uintx, CodeCacheMinBlockLength, 4);
define_pd_global(uintx, CodeCacheMinimumUseSpace, 400*K);
--- a/hotspot/src/cpu/x86/vm/frame_x86.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/x86/vm/frame_x86.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -715,3 +715,10 @@
assert(! is_compiled_frame(), "unknown compiled frame size");
return fp();
}
+
+#ifndef PRODUCT
+// This is a generic constructor which is only used by pns() in debug.cpp.
+frame::frame(void* sp, void* fp, void* pc) {
+ init((intptr_t*)sp, (intptr_t*)fp, (address)pc);
+}
+#endif
--- a/hotspot/src/cpu/x86/vm/frame_x86.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/x86/vm/frame_x86.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -187,6 +187,8 @@
frame(intptr_t* sp, intptr_t* fp);
+ void init(intptr_t* sp, intptr_t* fp, address pc);
+
// accessors for the instance variables
// Note: not necessarily the real 'frame pointer' (see real_fp)
intptr_t* fp() const { return _fp; }
--- a/hotspot/src/cpu/x86/vm/frame_x86.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/x86/vm/frame_x86.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -41,7 +41,7 @@
_deopt_state = unknown;
}
-inline frame::frame(intptr_t* sp, intptr_t* fp, address pc) {
+inline void frame::init(intptr_t* sp, intptr_t* fp, address pc) {
_sp = sp;
_unextended_sp = sp;
_fp = fp;
@@ -59,6 +59,10 @@
}
}
+inline frame::frame(intptr_t* sp, intptr_t* fp, address pc) {
+ init(sp, fp, pc);
+}
+
inline frame::frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc) {
_sp = sp;
_unextended_sp = unextended_sp;
--- a/hotspot/src/cpu/zero/vm/frame_zero.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/zero/vm/frame_zero.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -438,3 +438,10 @@
// unused... but returns fp() to minimize changes introduced by 7087445
return fp();
}
+
+#ifndef PRODUCT
+// This is a generic constructor which is only used by pns() in debug.cpp.
+frame::frame(void* sp, void* fp, void* pc) {
+ Unimplemented();
+}
+#endif
--- a/hotspot/src/cpu/zero/vm/shark_globals_zero.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/cpu/zero/vm/shark_globals_zero.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -53,6 +53,9 @@
define_pd_global(intx, NewSizeThreadIncrease, 4*K );
define_pd_global(intx, InitialCodeCacheSize, 160*K);
define_pd_global(intx, ReservedCodeCacheSize, 32*M );
+define_pd_global(intx, NonProfiledCodeHeapSize, 13*M );
+define_pd_global(intx, ProfiledCodeHeapSize, 14*M );
+define_pd_global(intx, NonNMethodCodeHeapSize, 5*M );
define_pd_global(bool, ProfileInterpreter, false);
define_pd_global(intx, CodeCacheExpansionSize, 32*K );
define_pd_global(uintx, CodeCacheMinBlockLength, 1 );
--- a/hotspot/src/os/bsd/dtrace/generateJvmOffsets.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/bsd/dtrace/generateJvmOffsets.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -67,7 +67,7 @@
* we link this program with -z nodefs .
*
* But for 'debug1' and 'fastdebug1' we still have to provide
- * a particular workaround for the following symbols bellow.
+ * a particular workaround for the following symbols below.
* It will be good to find out a generic way in the future.
*/
@@ -87,21 +87,24 @@
#endif /* ASSERT */
#endif /* COMPILER1 */
-#define GEN_OFFS(Type,Name) \
+#define GEN_OFFS_NAME(Type,Name,OutputType) \
switch(gen_variant) { \
case GEN_OFFSET: \
- printf("#define OFFSET_%-33s %ld\n", \
- #Type #Name, offset_of(Type, Name)); \
+ printf("#define OFFSET_%-33s %ld\n", \
+ #OutputType #Name, offset_of(Type, Name)); \
break; \
case GEN_INDEX: \
printf("#define IDX_OFFSET_%-33s %d\n", \
- #Type #Name, index++); \
+ #OutputType #Name, index++); \
break; \
case GEN_TABLE: \
- printf("\tOFFSET_%s,\n", #Type #Name); \
+ printf("\tOFFSET_%s,\n", #OutputType #Name); \
break; \
}
+#define GEN_OFFS(Type,Name) \
+ GEN_OFFS_NAME(Type,Name,Type)
+
#define GEN_SIZE(Type) \
switch(gen_variant) { \
case GEN_OFFSET: \
@@ -246,6 +249,11 @@
GEN_OFFS(VirtualSpace, _high);
printf("\n");
+ /* We need to use different names here because of the template parameter */
+ GEN_OFFS_NAME(GrowableArray<CodeHeap*>, _data, GrowableArray_CodeHeap);
+ GEN_OFFS_NAME(GrowableArray<CodeHeap*>, _len, GrowableArray_CodeHeap);
+ printf("\n");
+
GEN_OFFS(CodeBlob, _name);
GEN_OFFS(CodeBlob, _header_size);
GEN_OFFS(CodeBlob, _content_offset);
--- a/hotspot/src/os/bsd/dtrace/jhelper.d Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/bsd/dtrace/jhelper.d Fri Oct 10 02:24:41 2014 -0700
@@ -43,7 +43,9 @@
extern pointer __JvmOffsets;
-extern pointer __1cJCodeCacheF_heap_;
+/* GrowableArray<CodeHeaps*>* */
+extern pointer __1cJCodeCacheG_heaps_;
+
extern pointer __1cIUniverseO_collectedHeap_;
extern pointer __1cHnmethodG__vtbl_;
@@ -95,8 +97,8 @@
/!init_done && !this->done/
{
MARK_LINE;
- init_done = 1;
+ copyin_offset(POINTER_SIZE);
copyin_offset(COMPILER);
copyin_offset(OFFSET_CollectedHeap_reserved);
copyin_offset(OFFSET_MemRegion_start);
@@ -122,6 +124,9 @@
copyin_offset(OFFSET_CodeHeap_segmap);
copyin_offset(OFFSET_CodeHeap_log2_segment_size);
+ copyin_offset(OFFSET_GrowableArray_CodeHeap_data);
+ copyin_offset(OFFSET_GrowableArray_CodeHeap_len);
+
copyin_offset(OFFSET_VirtualSpace_low);
copyin_offset(OFFSET_VirtualSpace_high);
@@ -152,26 +157,14 @@
#error "Don't know architecture"
#endif
- this->CodeCache_heap_address = copyin_ptr(&``__1cJCodeCacheF_heap_);
-
- /* Reading volatile values */
- this->CodeCache_low = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
-
- this->CodeCache_high = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+ /* Read address of GrowableArray<CodeHeaps*> */
+ this->code_heaps_address = copyin_ptr(&``__1cJCodeCacheG_heaps_);
+ /* Read address of _data array field in GrowableArray */
+ this->code_heaps_array_address = copyin_ptr(this->code_heaps_address + OFFSET_GrowableArray_CodeHeap_data);
+ this->number_of_heaps = copyin_uint32(this->code_heaps_address + OFFSET_GrowableArray_CodeHeap_len);
- this->CodeCache_segmap_low = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_low);
-
- this->CodeCache_segmap_high = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_high);
-
- this->CodeHeap_log2_segment_size = copyin_uint32(
- this->CodeCache_heap_address + OFFSET_CodeHeap_log2_segment_size);
-
- this->Method_vtbl = (pointer) &``__1cNMethodG__vtbl_;
-
+ this->Method_vtbl = (pointer) &``__1cGMethodG__vtbl_;
+
/*
* Get Java heap bounds
*/
@@ -187,21 +180,152 @@
this->heap_end = this->heap_start + this->heap_size;
}
+/*
+ * IMPORTANT: At the moment the ustack helper supports up to 5 code heaps in
+ * the code cache. If more code heaps are added the following probes have to
+ * be extended. This is done by simply adding a probe to get the heap bounds
+ * and another probe to set the code heap address of the newly created heap.
+ */
+
+/*
+ * ----- BEGIN: Get bounds of code heaps -----
+ */
dtrace:helper:ustack:
-/!this->done &&
-this->CodeCache_low <= this->pc && this->pc < this->CodeCache_high/
+/init_done < 1 && this->number_of_heaps >= 1 && !this->done/
+{
+ MARK_LINE;
+ /* CodeHeap 1 */
+ init_done = 1;
+ this->code_heap1_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap1_low = copyin_ptr(this->code_heap1_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap1_high = copyin_ptr(this->code_heap1_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 2 && this->number_of_heaps >= 2 && !this->done/
+{
+ MARK_LINE;
+ /* CodeHeap 2 */
+ init_done = 2;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap2_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap2_low = copyin_ptr(this->code_heap2_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap2_high = copyin_ptr(this->code_heap2_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 3 && this->number_of_heaps >= 3 && !this->done/
+{
+ /* CodeHeap 3 */
+ init_done = 3;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap3_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap3_low = copyin_ptr(this->code_heap3_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap3_high = copyin_ptr(this->code_heap3_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 4 && this->number_of_heaps >= 4 && !this->done/
+{
+ /* CodeHeap 4 */
+ init_done = 4;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap4_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap4_low = copyin_ptr(this->code_heap4_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap4_high = copyin_ptr(this->code_heap4_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 5 && this->number_of_heaps >= 5 && !this->done/
+{
+ /* CodeHeap 5 */
+ init_done = 5;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap5_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap5_low = copyin_ptr(this->code_heap5_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap5_high = copyin_ptr(this->code_heap5_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+/*
+ * ----- END: Get bounds of code heaps -----
+ */
+
+/*
+ * ----- BEGIN: Get address of the code heap pc points to -----
+ */
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 1 && this->code_heap1_low <= this->pc && this->pc < this->code_heap1_high/
{
MARK_LINE;
this->codecache = 1;
+ this->code_heap_address = this->code_heap1_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 2 && this->code_heap2_low <= this->pc && this->pc < this->code_heap2_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap2_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 3 && this->code_heap3_low <= this->pc && this->pc < this->code_heap3_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap3_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 4 && this->code_heap4_low <= this->pc && this->pc < this->code_heap4_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap4_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 5 && this->code_heap5_low <= this->pc && this->pc < this->code_heap5_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap5_address;
+}
+/*
+ * ----- END: Get address of the code heap pc points to -----
+ */
+
+dtrace:helper:ustack:
+/!this->done && this->codecache/
+{
+ MARK_LINE;
+ /*
+ * Get code heap configuration
+ */
+ this->code_heap_low = copyin_ptr(this->code_heap_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap_segmap_low = copyin_ptr(this->code_heap_address +
+ OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_low);
+ this->code_heap_log2_segment_size = copyin_uint32(
+ this->code_heap_address + OFFSET_CodeHeap_log2_segment_size);
/*
- * Find start.
+ * Find start
*/
- this->segment = (this->pc - this->CodeCache_low) >>
- this->CodeHeap_log2_segment_size;
- this->block = this->CodeCache_segmap_low;
+ this->segment = (this->pc - this->code_heap_low) >>
+ this->code_heap_log2_segment_size;
+ this->block = this->code_heap_segmap_low;
this->tag = copyin_uchar(this->block + this->segment);
- "second";
}
dtrace:helper:ustack:
@@ -256,8 +380,8 @@
/!this->done && this->codecache/
{
MARK_LINE;
- this->block = this->CodeCache_low +
- (this->segment << this->CodeHeap_log2_segment_size);
+ this->block = this->code_heap_low +
+ (this->segment << this->code_heap_log2_segment_size);
this->used = copyin_uint32(this->block + OFFSET_HeapBlockHeader_used);
}
--- a/hotspot/src/os/bsd/dtrace/libjvm_db.c Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/bsd/dtrace/libjvm_db.c Fri Oct 10 02:24:41 2014 -0700
@@ -150,16 +150,18 @@
uint64_t Use_Compressed_Oops_address;
uint64_t Universe_narrow_oop_base_address;
uint64_t Universe_narrow_oop_shift_address;
- uint64_t CodeCache_heap_address;
+ uint64_t CodeCache_heaps_address;
/* Volatiles */
uint8_t Use_Compressed_Oops;
uint64_t Universe_narrow_oop_base;
uint32_t Universe_narrow_oop_shift;
- uint64_t CodeCache_low;
- uint64_t CodeCache_high;
- uint64_t CodeCache_segmap_low;
- uint64_t CodeCache_segmap_high;
+ // Code cache heaps
+ int32_t Number_of_heaps;
+ uint64_t* Heap_low;
+ uint64_t* Heap_high;
+ uint64_t* Heap_segmap_low;
+ uint64_t* Heap_segmap_high;
int32_t SIZE_CodeCache_log2_segment;
@@ -278,8 +280,9 @@
}
if (vmp->typeName[0] == 'C' && strcmp("CodeCache", vmp->typeName) == 0) {
- if (strcmp("_heap", vmp->fieldName) == 0) {
- err = read_pointer(J, vmp->address, &J->CodeCache_heap_address);
+ /* Read _heaps field of type GrowableArray<CodeHeaps*>* */
+ if (strcmp("_heaps", vmp->fieldName) == 0) {
+ err = read_pointer(J, vmp->address, &J->CodeCache_heaps_address);
}
} else if (vmp->typeName[0] == 'U' && strcmp("Universe", vmp->typeName) == 0) {
if (strcmp("_narrow_oop._base", vmp->fieldName) == 0) {
@@ -318,7 +321,9 @@
}
static int read_volatiles(jvm_agent_t* J) {
- uint64_t ptr;
+ int i;
+ uint64_t array_data;
+ uint64_t code_heap_address;
int err;
err = find_symbol(J, "UseCompressedOops", &J->Use_Compressed_Oops_address);
@@ -334,20 +339,43 @@
err = ps_pread(J->P, J->Universe_narrow_oop_shift_address, &J->Universe_narrow_oop_shift, sizeof(uint32_t));
CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_memory +
- OFFSET_VirtualSpace_low, &J->CodeCache_low);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_memory +
- OFFSET_VirtualSpace_high, &J->CodeCache_high);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_segmap +
- OFFSET_VirtualSpace_low, &J->CodeCache_segmap_low);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_segmap +
- OFFSET_VirtualSpace_high, &J->CodeCache_segmap_high);
- CHECK_FAIL(err);
+ /* CodeCache_heaps_address points to GrowableArray<CodeHeaps*>, read _data field
+ pointing to the first entry of type CodeCache* in the array */
+ err = read_pointer(J, J->CodeCache_heaps_address + OFFSET_GrowableArray_CodeHeap_data, &array_data);
+ /* Read _len field containing the number of code heaps */
+ err = ps_pread(J->P, J->CodeCache_heaps_address + OFFSET_GrowableArray_CodeHeap_len,
+ &J->Number_of_heaps, sizeof(J->Number_of_heaps));
+
+ /* Allocate memory for heap configurations */
+ J->Heap_low = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_high = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_segmap_low = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_segmap_high = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+
+ /* Read code heap configurations */
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ /* Read address of heap */
+ err = read_pointer(J, array_data, &code_heap_address);
+ CHECK_FAIL(err);
- err = ps_pread(J->P, J->CodeCache_heap_address + OFFSET_CodeHeap_log2_segment_size,
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_memory +
+ OFFSET_VirtualSpace_low, &J->Heap_low[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_memory +
+ OFFSET_VirtualSpace_high, &J->Heap_high[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_segmap +
+ OFFSET_VirtualSpace_low, &J->Heap_segmap_low[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_segmap +
+ OFFSET_VirtualSpace_high, &J->Heap_segmap_high[i]);
+ CHECK_FAIL(err);
+
+ /* Increment pointer to next entry */
+ array_data = array_data + POINTER_SIZE;
+ }
+
+ err = ps_pread(J->P, code_heap_address + OFFSET_CodeHeap_log2_segment_size,
&J->SIZE_CodeCache_log2_segment, sizeof(J->SIZE_CodeCache_log2_segment));
CHECK_FAIL(err);
@@ -357,46 +385,57 @@
return err;
}
-
-static int codecache_contains(jvm_agent_t* J, uint64_t ptr) {
- /* make sure the code cache is up to date */
- return (J->CodeCache_low <= ptr && ptr < J->CodeCache_high);
+static int codeheap_contains(int heap_num, jvm_agent_t* J, uint64_t ptr) {
+ return (J->Heap_low[heap_num] <= ptr && ptr < J->Heap_high[heap_num]);
}
-static uint64_t segment_for(jvm_agent_t* J, uint64_t p) {
- return (p - J->CodeCache_low) >> J->SIZE_CodeCache_log2_segment;
+static int codecache_contains(jvm_agent_t* J, uint64_t ptr) {
+ int i;
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ if (codeheap_contains(i, J, ptr)) {
+ return 1;
+ }
+ }
+ return 0;
}
-static uint64_t block_at(jvm_agent_t* J, int i) {
- return J->CodeCache_low + (i << J->SIZE_CodeCache_log2_segment);
+static uint64_t segment_for(int heap_num, jvm_agent_t* J, uint64_t p) {
+ return (p - J->Heap_low[heap_num]) >> J->SIZE_CodeCache_log2_segment;
+}
+
+static uint64_t block_at(int heap_num, jvm_agent_t* J, int i) {
+ return J->Heap_low[heap_num] + (i << J->SIZE_CodeCache_log2_segment);
}
static int find_start(jvm_agent_t* J, uint64_t ptr, uint64_t *startp) {
int err;
+ int i;
- *startp = 0;
- if (J->CodeCache_low <= ptr && ptr < J->CodeCache_high) {
- int32_t used;
- uint64_t segment = segment_for(J, ptr);
- uint64_t block = J->CodeCache_segmap_low;
- uint8_t tag;
- err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
- CHECK_FAIL(err);
- if (tag == 0xff)
- return PS_OK;
- while (tag > 0) {
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ *startp = 0;
+ if (codeheap_contains(i, J, ptr)) {
+ int32_t used;
+ uint64_t segment = segment_for(i, J, ptr);
+ uint64_t block = J->Heap_segmap_low[i];
+ uint8_t tag;
err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
CHECK_FAIL(err);
- segment -= tag;
+ if (tag == 0xff)
+ return PS_OK;
+ while (tag > 0) {
+ err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
+ CHECK_FAIL(err);
+ segment -= tag;
+ }
+ block = block_at(i, J, segment);
+ err = ps_pread(J->P, block + OFFSET_HeapBlockHeader_used, &used, sizeof(used));
+ CHECK_FAIL(err);
+ if (used) {
+ *startp = block + SIZE_HeapBlockHeader;
+ }
}
- block = block_at(J, segment);
- err = ps_pread(J->P, block + OFFSET_HeapBlockHeader_used, &used, sizeof(used));
- CHECK_FAIL(err);
- if (used) {
- *startp = block + SIZE_HeapBlockHeader;
- }
+ return PS_OK;
}
- return PS_OK;
fail:
return -1;
--- a/hotspot/src/os/solaris/dtrace/generateJvmOffsets.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/solaris/dtrace/generateJvmOffsets.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -82,21 +82,24 @@
#endif /* ASSERT */
#endif /* COMPILER1 */
-#define GEN_OFFS(Type,Name) \
+#define GEN_OFFS_NAME(Type,Name,OutputType) \
switch(gen_variant) { \
case GEN_OFFSET: \
printf("#define OFFSET_%-33s %d\n", \
- #Type #Name, offset_of(Type, Name)); \
+ #OutputType #Name, offset_of(Type, Name)); \
break; \
case GEN_INDEX: \
printf("#define IDX_OFFSET_%-33s %d\n", \
- #Type #Name, index++); \
+ #OutputType #Name, index++); \
break; \
case GEN_TABLE: \
- printf("\tOFFSET_%s,\n", #Type #Name); \
+ printf("\tOFFSET_%s,\n", #OutputType #Name); \
break; \
}
+#define GEN_OFFS(Type,Name) \
+ GEN_OFFS_NAME(Type,Name,Type)
+
#define GEN_SIZE(Type) \
switch(gen_variant) { \
case GEN_OFFSET: \
@@ -241,6 +244,11 @@
GEN_OFFS(VirtualSpace, _high);
printf("\n");
+ /* We need to use different names here because of the template parameter */
+ GEN_OFFS_NAME(GrowableArray<CodeHeap*>, _data, GrowableArray_CodeHeap);
+ GEN_OFFS_NAME(GrowableArray<CodeHeap*>, _len, GrowableArray_CodeHeap);
+ printf("\n");
+
GEN_OFFS(CodeBlob, _name);
GEN_OFFS(CodeBlob, _header_size);
GEN_OFFS(CodeBlob, _content_offset);
--- a/hotspot/src/os/solaris/dtrace/jhelper.d Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/solaris/dtrace/jhelper.d Fri Oct 10 02:24:41 2014 -0700
@@ -43,7 +43,9 @@
extern pointer __JvmOffsets;
-extern pointer __1cJCodeCacheF_heap_;
+/* GrowableArray<CodeHeaps*>* */
+extern pointer __1cJCodeCacheG_heaps_;
+
extern pointer __1cIUniverseO_collectedHeap_;
extern pointer __1cHnmethodG__vtbl_;
@@ -95,8 +97,8 @@
/!init_done && !this->done/
{
MARK_LINE;
- init_done = 1;
-
+
+ copyin_offset(POINTER_SIZE);
copyin_offset(COMPILER);
copyin_offset(OFFSET_CollectedHeap_reserved);
copyin_offset(OFFSET_MemRegion_start);
@@ -122,6 +124,9 @@
copyin_offset(OFFSET_CodeHeap_segmap);
copyin_offset(OFFSET_CodeHeap_log2_segment_size);
+ copyin_offset(OFFSET_GrowableArray_CodeHeap_data);
+ copyin_offset(OFFSET_GrowableArray_CodeHeap_len);
+
copyin_offset(OFFSET_VirtualSpace_low);
copyin_offset(OFFSET_VirtualSpace_high);
@@ -152,24 +157,13 @@
#error "Don't know architecture"
#endif
- this->CodeCache_heap_address = copyin_ptr(&``__1cJCodeCacheF_heap_);
-
- this->CodeCache_low = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
-
- this->CodeCache_high = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+ /* Read address of GrowableArray<CodeHeaps*> */
+ this->code_heaps_address = copyin_ptr(&``__1cJCodeCacheG_heaps_);
+ /* Read address of _data array field in GrowableArray */
+ this->code_heaps_array_address = copyin_ptr(this->code_heaps_address + OFFSET_GrowableArray_CodeHeap_data);
+ this->number_of_heaps = copyin_uint32(this->code_heaps_address + OFFSET_GrowableArray_CodeHeap_len);
- this->CodeCache_segmap_low = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_low);
-
- this->CodeCache_segmap_high = copyin_ptr(this->CodeCache_heap_address +
- OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_high);
-
- this->CodeHeap_log2_segment_size = copyin_uint32(
- this->CodeCache_heap_address + OFFSET_CodeHeap_log2_segment_size);
-
- this->Method_vtbl = (pointer) &``__1cGMethodG__vtbl_;
+ this->Method_vtbl = (pointer) &``__1cGMethodG__vtbl_;
/*
* Get Java heap bounds
@@ -186,21 +180,152 @@
this->heap_end = this->heap_start + this->heap_size;
}
+/*
+ * IMPORTANT: At the moment the ustack helper supports up to 5 code heaps in
+ * the code cache. If more code heaps are added the following probes have to
+ * be extended. This is done by simply adding a probe to get the heap bounds
+ * and another probe to set the code heap address of the newly created heap.
+ */
+
+/*
+ * ----- BEGIN: Get bounds of code heaps -----
+ */
dtrace:helper:ustack:
-/!this->done &&
-this->CodeCache_low <= this->pc && this->pc < this->CodeCache_high/
+/init_done < 1 && this->number_of_heaps >= 1 && !this->done/
+{
+ MARK_LINE;
+ /* CodeHeap 1 */
+ init_done = 1;
+ this->code_heap1_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap1_low = copyin_ptr(this->code_heap1_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap1_high = copyin_ptr(this->code_heap1_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 2 && this->number_of_heaps >= 2 && !this->done/
+{
+ MARK_LINE;
+ /* CodeHeap 2 */
+ init_done = 2;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap2_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap2_low = copyin_ptr(this->code_heap2_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap2_high = copyin_ptr(this->code_heap2_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 3 && this->number_of_heaps >= 3 && !this->done/
+{
+ /* CodeHeap 3 */
+ init_done = 3;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap3_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap3_low = copyin_ptr(this->code_heap3_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap3_high = copyin_ptr(this->code_heap3_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 4 && this->number_of_heaps >= 4 && !this->done/
+{
+ /* CodeHeap 4 */
+ init_done = 4;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap4_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap4_low = copyin_ptr(this->code_heap4_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap4_high = copyin_ptr(this->code_heap4_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+
+dtrace:helper:ustack:
+/init_done < 5 && this->number_of_heaps >= 5 && !this->done/
+{
+ /* CodeHeap 5 */
+ init_done = 5;
+ this->code_heaps_array_address = this->code_heaps_array_address + POINTER_SIZE;
+ this->code_heap5_address = copyin_ptr(this->code_heaps_array_address);
+ this->code_heap5_low = copyin_ptr(this->code_heap5_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap5_high = copyin_ptr(this->code_heap5_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_high);
+}
+/*
+ * ----- END: Get bounds of code heaps -----
+ */
+
+/*
+ * ----- BEGIN: Get address of the code heap pc points to -----
+ */
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 1 && this->code_heap1_low <= this->pc && this->pc < this->code_heap1_high/
{
MARK_LINE;
this->codecache = 1;
+ this->code_heap_address = this->code_heap1_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 2 && this->code_heap2_low <= this->pc && this->pc < this->code_heap2_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap2_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 3 && this->code_heap3_low <= this->pc && this->pc < this->code_heap3_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap3_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 4 && this->code_heap4_low <= this->pc && this->pc < this->code_heap4_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap4_address;
+}
+
+dtrace:helper:ustack:
+/!this->done && this->number_of_heaps >= 5 && this->code_heap5_low <= this->pc && this->pc < this->code_heap5_high/
+{
+ MARK_LINE;
+ this->codecache = 1;
+ this->code_heap_address = this->code_heap5_address;
+}
+/*
+ * ----- END: Get address of the code heap pc points to -----
+ */
+
+dtrace:helper:ustack:
+/!this->done && this->codecache/
+{
+ MARK_LINE;
+ /*
+ * Get code heap configuration
+ */
+ this->code_heap_low = copyin_ptr(this->code_heap_address +
+ OFFSET_CodeHeap_memory + OFFSET_VirtualSpace_low);
+ this->code_heap_segmap_low = copyin_ptr(this->code_heap_address +
+ OFFSET_CodeHeap_segmap + OFFSET_VirtualSpace_low);
+ this->code_heap_log2_segment_size = copyin_uint32(
+ this->code_heap_address + OFFSET_CodeHeap_log2_segment_size);
/*
- * Find start.
+ * Find start
*/
- this->segment = (this->pc - this->CodeCache_low) >>
- this->CodeHeap_log2_segment_size;
- this->block = this->CodeCache_segmap_low;
+ this->segment = (this->pc - this->code_heap_low) >>
+ this->code_heap_log2_segment_size;
+ this->block = this->code_heap_segmap_low;
this->tag = copyin_uchar(this->block + this->segment);
- "second";
}
dtrace:helper:ustack:
@@ -255,8 +380,8 @@
/!this->done && this->codecache/
{
MARK_LINE;
- this->block = this->CodeCache_low +
- (this->segment << this->CodeHeap_log2_segment_size);
+ this->block = this->code_heap_low +
+ (this->segment << this->code_heap_log2_segment_size);
this->used = copyin_uint32(this->block + OFFSET_HeapBlockHeader_used);
}
--- a/hotspot/src/os/solaris/dtrace/libjvm_db.c Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/solaris/dtrace/libjvm_db.c Fri Oct 10 02:24:41 2014 -0700
@@ -150,16 +150,18 @@
uint64_t Use_Compressed_Oops_address;
uint64_t Universe_narrow_oop_base_address;
uint64_t Universe_narrow_oop_shift_address;
- uint64_t CodeCache_heap_address;
+ uint64_t CodeCache_heaps_address;
/* Volatiles */
uint8_t Use_Compressed_Oops;
uint64_t Universe_narrow_oop_base;
uint32_t Universe_narrow_oop_shift;
- uint64_t CodeCache_low;
- uint64_t CodeCache_high;
- uint64_t CodeCache_segmap_low;
- uint64_t CodeCache_segmap_high;
+ // Code cache heaps
+ int32_t Number_of_heaps;
+ uint64_t* Heap_low;
+ uint64_t* Heap_high;
+ uint64_t* Heap_segmap_low;
+ uint64_t* Heap_segmap_high;
int32_t SIZE_CodeCache_log2_segment;
@@ -278,8 +280,9 @@
}
if (vmp->typeName[0] == 'C' && strcmp("CodeCache", vmp->typeName) == 0) {
- if (strcmp("_heap", vmp->fieldName) == 0) {
- err = read_pointer(J, vmp->address, &J->CodeCache_heap_address);
+ /* Read _heaps field of type GrowableArray<CodeHeaps*>* */
+ if (strcmp("_heaps", vmp->fieldName) == 0) {
+ err = read_pointer(J, vmp->address, &J->CodeCache_heaps_address);
}
} else if (vmp->typeName[0] == 'U' && strcmp("Universe", vmp->typeName) == 0) {
if (strcmp("_narrow_oop._base", vmp->fieldName) == 0) {
@@ -318,7 +321,9 @@
}
static int read_volatiles(jvm_agent_t* J) {
- uint64_t ptr;
+ int i;
+ uint64_t array_data;
+ uint64_t code_heap_address;
int err;
err = find_symbol(J, "UseCompressedOops", &J->Use_Compressed_Oops_address);
@@ -334,20 +339,43 @@
err = ps_pread(J->P, J->Universe_narrow_oop_shift_address, &J->Universe_narrow_oop_shift, sizeof(uint32_t));
CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_memory +
- OFFSET_VirtualSpace_low, &J->CodeCache_low);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_memory +
- OFFSET_VirtualSpace_high, &J->CodeCache_high);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_segmap +
- OFFSET_VirtualSpace_low, &J->CodeCache_segmap_low);
- CHECK_FAIL(err);
- err = read_pointer(J, J->CodeCache_heap_address + OFFSET_CodeHeap_segmap +
- OFFSET_VirtualSpace_high, &J->CodeCache_segmap_high);
- CHECK_FAIL(err);
+ /* CodeCache_heaps_address points to GrowableArray<CodeHeaps*>, read _data field
+ pointing to the first entry of type CodeCache* in the array */
+ err = read_pointer(J, J->CodeCache_heaps_address + OFFSET_GrowableArray_CodeHeap_data, &array_data);
+ /* Read _len field containing the number of code heaps */
+ err = ps_pread(J->P, J->CodeCache_heaps_address + OFFSET_GrowableArray_CodeHeap_len,
+ &J->Number_of_heaps, sizeof(J->Number_of_heaps));
+
+ /* Allocate memory for heap configurations */
+ J->Heap_low = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_high = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_segmap_low = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+ J->Heap_segmap_high = (jvm_agent_t*)calloc(J->Number_of_heaps, sizeof(uint64_t));
+
+ /* Read code heap configurations */
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ /* Read address of heap */
+ err = read_pointer(J, array_data, &code_heap_address);
+ CHECK_FAIL(err);
- err = ps_pread(J->P, J->CodeCache_heap_address + OFFSET_CodeHeap_log2_segment_size,
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_memory +
+ OFFSET_VirtualSpace_low, &J->Heap_low[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_memory +
+ OFFSET_VirtualSpace_high, &J->Heap_high[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_segmap +
+ OFFSET_VirtualSpace_low, &J->Heap_segmap_low[i]);
+ CHECK_FAIL(err);
+ err = read_pointer(J, code_heap_address + OFFSET_CodeHeap_segmap +
+ OFFSET_VirtualSpace_high, &J->Heap_segmap_high[i]);
+ CHECK_FAIL(err);
+
+ /* Increment pointer to next entry */
+ array_data = array_data + POINTER_SIZE;
+ }
+
+ err = ps_pread(J->P, code_heap_address + OFFSET_CodeHeap_log2_segment_size,
&J->SIZE_CodeCache_log2_segment, sizeof(J->SIZE_CodeCache_log2_segment));
CHECK_FAIL(err);
@@ -357,46 +385,57 @@
return err;
}
-
-static int codecache_contains(jvm_agent_t* J, uint64_t ptr) {
- /* make sure the code cache is up to date */
- return (J->CodeCache_low <= ptr && ptr < J->CodeCache_high);
+static int codeheap_contains(int heap_num, jvm_agent_t* J, uint64_t ptr) {
+ return (J->Heap_low[heap_num] <= ptr && ptr < J->Heap_high[heap_num]);
}
-static uint64_t segment_for(jvm_agent_t* J, uint64_t p) {
- return (p - J->CodeCache_low) >> J->SIZE_CodeCache_log2_segment;
+static int codecache_contains(jvm_agent_t* J, uint64_t ptr) {
+ int i;
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ if (codeheap_contains(i, J, ptr)) {
+ return 1;
+ }
+ }
+ return 0;
}
-static uint64_t block_at(jvm_agent_t* J, int i) {
- return J->CodeCache_low + (i << J->SIZE_CodeCache_log2_segment);
+static uint64_t segment_for(int heap_num, jvm_agent_t* J, uint64_t p) {
+ return (p - J->Heap_low[heap_num]) >> J->SIZE_CodeCache_log2_segment;
+}
+
+static uint64_t block_at(int heap_num, jvm_agent_t* J, int i) {
+ return J->Heap_low[heap_num] + (i << J->SIZE_CodeCache_log2_segment);
}
static int find_start(jvm_agent_t* J, uint64_t ptr, uint64_t *startp) {
int err;
+ int i;
- *startp = 0;
- if (J->CodeCache_low <= ptr && ptr < J->CodeCache_high) {
- int32_t used;
- uint64_t segment = segment_for(J, ptr);
- uint64_t block = J->CodeCache_segmap_low;
- uint8_t tag;
- err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
- CHECK_FAIL(err);
- if (tag == 0xff)
- return PS_OK;
- while (tag > 0) {
+ for (i = 0; i < J->Number_of_heaps; ++i) {
+ *startp = 0;
+ if (codeheap_contains(i, J, ptr)) {
+ int32_t used;
+ uint64_t segment = segment_for(i, J, ptr);
+ uint64_t block = J->Heap_segmap_low[i];
+ uint8_t tag;
err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
CHECK_FAIL(err);
- segment -= tag;
+ if (tag == 0xff)
+ return PS_OK;
+ while (tag > 0) {
+ err = ps_pread(J->P, block + segment, &tag, sizeof(tag));
+ CHECK_FAIL(err);
+ segment -= tag;
+ }
+ block = block_at(i, J, segment);
+ err = ps_pread(J->P, block + OFFSET_HeapBlockHeader_used, &used, sizeof(used));
+ CHECK_FAIL(err);
+ if (used) {
+ *startp = block + SIZE_HeapBlockHeader;
+ }
}
- block = block_at(J, segment);
- err = ps_pread(J->P, block + OFFSET_HeapBlockHeader_used, &used, sizeof(used));
- CHECK_FAIL(err);
- if (used) {
- *startp = block + SIZE_HeapBlockHeader;
- }
+ return PS_OK;
}
- return PS_OK;
fail:
return -1;
--- a/hotspot/src/os/solaris/vm/os_solaris.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os/solaris/vm/os_solaris.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -3129,8 +3129,7 @@
return true;
}
-char* os::reserve_memory_special(size_t size, size_t alignment, char* addr,
- bool exec) {
+char* os::reserve_memory_special(size_t size, size_t alignment, char* addr, bool exec) {
fatal("os::reserve_memory_special should not be called on Solaris.");
return NULL;
}
--- a/hotspot/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/os_cpu/solaris_sparc/vm/os_solaris_sparc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -265,7 +265,7 @@
CAST_FROM_FN_PTR(address, os::current_frame));
if (os::is_first_C_frame(&myframe)) {
// stack is not walkable
- return frame(NULL, NULL, NULL);
+ return frame(NULL, NULL, false);
} else {
return os::get_sender_for_C_frame(&myframe);
}
--- a/hotspot/src/share/vm/adlc/archDesc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/adlc/archDesc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
//
-// Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+// Copyright (c) 1997, 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
@@ -969,23 +969,22 @@
void ArchDesc::initBaseOpTypes() {
// Create OperandForm and assign type for each opcode.
for (int i = 1; i < _last_machine_leaf; ++i) {
- char *ident = (char *)NodeClassNames[i];
+ char *ident = (char *)NodeClassNames[i];
constructOperand(ident, true);
}
// Create InstructForm and assign type for each ideal instruction.
- for ( int j = _last_machine_leaf+1; j < _last_opcode; ++j) {
- char *ident = (char *)NodeClassNames[j];
- if(!strcmp(ident, "ConI") || !strcmp(ident, "ConP") ||
- !strcmp(ident, "ConN") || !strcmp(ident, "ConNKlass") ||
- !strcmp(ident, "ConF") || !strcmp(ident, "ConD") ||
- !strcmp(ident, "ConL") || !strcmp(ident, "Con" ) ||
- !strcmp(ident, "Bool") ) {
+ for (int j = _last_machine_leaf+1; j < _last_opcode; ++j) {
+ char *ident = (char *)NodeClassNames[j];
+ if (!strcmp(ident, "ConI") || !strcmp(ident, "ConP") ||
+ !strcmp(ident, "ConN") || !strcmp(ident, "ConNKlass") ||
+ !strcmp(ident, "ConF") || !strcmp(ident, "ConD") ||
+ !strcmp(ident, "ConL") || !strcmp(ident, "Con" ) ||
+ !strcmp(ident, "Bool")) {
constructOperand(ident, true);
- }
- else {
- InstructForm *insForm = new InstructForm(ident, true);
- // insForm->_opcode = nextUserOpType(ident);
- _globalNames.Insert(ident,insForm);
+ } else {
+ InstructForm *insForm = new InstructForm(ident, true);
+ // insForm->_opcode = nextUserOpType(ident);
+ _globalNames.Insert(ident, insForm);
addForm(insForm);
}
}
@@ -1038,6 +1037,9 @@
ident = "TEMP";
eForm = new Effect(ident);
_globalNames.Insert(ident, eForm);
+ ident = "TEMP_DEF";
+ eForm = new Effect(ident);
+ _globalNames.Insert(ident, eForm);
ident = "CALL";
eForm = new Effect(ident);
_globalNames.Insert(ident, eForm);
@@ -1050,8 +1052,8 @@
const char *idealName = NodeClassNames[idealIndex];
_idealIndex.Insert((void*) idealName, (void*) (intptr_t) idealIndex);
}
- for ( idealIndex = _last_machine_leaf+1;
- idealIndex < _last_opcode; ++idealIndex) {
+ for (idealIndex = _last_machine_leaf+1;
+ idealIndex < _last_opcode; ++idealIndex) {
const char *idealName = NodeClassNames[idealIndex];
_idealIndex.Insert((void*) idealName, (void*) (intptr_t) idealIndex);
}
--- a/hotspot/src/share/vm/adlc/formssel.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/adlc/formssel.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1816,15 +1816,16 @@
//------------------------------Effect-----------------------------------------
static int effect_lookup(const char *name) {
- if(!strcmp(name, "USE")) return Component::USE;
- if(!strcmp(name, "DEF")) return Component::DEF;
- if(!strcmp(name, "USE_DEF")) return Component::USE_DEF;
- if(!strcmp(name, "KILL")) return Component::KILL;
- if(!strcmp(name, "USE_KILL")) return Component::USE_KILL;
- if(!strcmp(name, "TEMP")) return Component::TEMP;
- if(!strcmp(name, "INVALID")) return Component::INVALID;
- if(!strcmp(name, "CALL")) return Component::CALL;
- assert( false,"Invalid effect name specified\n");
+ if (!strcmp(name, "USE")) return Component::USE;
+ if (!strcmp(name, "DEF")) return Component::DEF;
+ if (!strcmp(name, "USE_DEF")) return Component::USE_DEF;
+ if (!strcmp(name, "KILL")) return Component::KILL;
+ if (!strcmp(name, "USE_KILL")) return Component::USE_KILL;
+ if (!strcmp(name, "TEMP")) return Component::TEMP;
+ if (!strcmp(name, "TEMP_DEF")) return Component::TEMP_DEF;
+ if (!strcmp(name, "INVALID")) return Component::INVALID;
+ if (!strcmp(name, "CALL")) return Component::CALL;
+ assert(false,"Invalid effect name specified\n");
return Component::INVALID;
}
@@ -1836,6 +1837,7 @@
case Component::USE_KILL: return "USE_KILL"; break;
case Component::KILL: return "KILL"; break;
case Component::TEMP: return "TEMP"; break;
+ case Component::TEMP_DEF: return "TEMP_DEF"; break;
case Component::DEF: return "DEF"; break;
case Component::CALL: return "CALL"; break;
default: assert(false, "unknown effect");
--- a/hotspot/src/share/vm/adlc/formssel.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/adlc/formssel.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+ * 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
@@ -910,13 +910,16 @@
public:
// Implementation depends upon working bit intersection and union.
enum use_def_enum {
- INVALID = 0x0,
- USE = 0x1,
- DEF = 0x2, USE_DEF = 0x3,
- KILL = 0x4, USE_KILL = 0x5,
+ INVALID = 0x0,
+ USE = 0x1,
+ DEF = 0x2,
+ USE_DEF = USE | DEF,
+ KILL = 0x4,
+ USE_KILL = USE | KILL,
SYNTHETIC = 0x8,
- TEMP = USE | SYNTHETIC,
- CALL = 0x10
+ TEMP = USE | SYNTHETIC,
+ TEMP_DEF = TEMP | DEF,
+ CALL = 0x10
};
};
--- a/hotspot/src/share/vm/adlc/output_c.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/adlc/output_c.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1715,13 +1715,14 @@
bool declared_def = false;
bool declared_kill = false;
- while( (comp = node->_components.iter()) != NULL ) {
+ while ((comp = node->_components.iter()) != NULL) {
// Lookup register class associated with operand type
- Form *form = (Form*)_globalNames[comp->_type];
- assert( form, "component type must be a defined form");
- OperandForm *op = form->is_operand();
-
- if (comp->is(Component::TEMP)) {
+ Form *form = (Form*)_globalNames[comp->_type];
+ assert(form, "component type must be a defined form");
+ OperandForm *op = form->is_operand();
+
+ if (comp->is(Component::TEMP) ||
+ comp->is(Component::TEMP_DEF)) {
fprintf(fp, " // TEMP %s\n", comp->_name);
if (!declared_def) {
// Define the variable "def" to hold new MachProjNodes
@@ -1750,7 +1751,7 @@
declared_kill = true;
}
- assert( op, "Support additional KILLS for base operands");
+ assert(op, "Support additional KILLS for base operands");
const char *regmask = reg_mask(*op);
const char *ideal_type = op->ideal_type(_globalNames, _register);
--- a/hotspot/src/share/vm/c1/c1_Canonicalizer.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_Canonicalizer.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -327,7 +327,7 @@
if (t2->is_constant()) {
switch (t2->tag()) {
case intTag : if (t2->as_IntConstant()->value() == 0) set_canonical(x->x()); return;
- case longTag : if (t2->as_IntConstant()->value() == 0) set_canonical(x->x()); return;
+ case longTag : if (t2->as_LongConstant()->value() == (jlong)0) set_canonical(x->x()); return;
default : ShouldNotReachHere();
}
}
@@ -808,28 +808,41 @@
static bool match_index_and_scale(Instruction* instr,
Instruction** index,
- int* log2_scale,
- Instruction** instr_to_unpin) {
- *instr_to_unpin = NULL;
-
- // Skip conversion ops
+ int* log2_scale) {
+ // Skip conversion ops. This works only on 32bit because of the implicit l2i that the
+ // unsafe performs.
+#ifndef _LP64
Convert* convert = instr->as_Convert();
- if (convert != NULL) {
+ if (convert != NULL && convert->op() == Bytecodes::_i2l) {
+ assert(convert->value()->type() == intType, "invalid input type");
instr = convert->value();
}
+#endif
ShiftOp* shift = instr->as_ShiftOp();
if (shift != NULL) {
- if (shift->is_pinned()) {
- *instr_to_unpin = shift;
+ if (shift->op() == Bytecodes::_lshl) {
+ assert(shift->x()->type() == longType, "invalid input type");
+ } else {
+#ifndef _LP64
+ if (shift->op() == Bytecodes::_ishl) {
+ assert(shift->x()->type() == intType, "invalid input type");
+ } else {
+ return false;
+ }
+#else
+ return false;
+#endif
}
+
+
// Constant shift value?
Constant* con = shift->y()->as_Constant();
if (con == NULL) return false;
// Well-known type and value?
IntConstant* val = con->type()->as_IntConstant();
- if (val == NULL) return false;
- if (shift->x()->type() != intType) return false;
+ assert(val != NULL, "Should be an int constant");
+
*index = shift->x();
int tmp_scale = val->value();
if (tmp_scale >= 0 && tmp_scale < 4) {
@@ -842,31 +855,42 @@
ArithmeticOp* arith = instr->as_ArithmeticOp();
if (arith != NULL) {
- if (arith->is_pinned()) {
- *instr_to_unpin = arith;
+ // See if either arg is a known constant
+ Constant* con = arith->x()->as_Constant();
+ if (con != NULL) {
+ *index = arith->y();
+ } else {
+ con = arith->y()->as_Constant();
+ if (con == NULL) return false;
+ *index = arith->x();
}
+ long const_value;
// Check for integer multiply
- if (arith->op() == Bytecodes::_imul) {
- // See if either arg is a known constant
- Constant* con = arith->x()->as_Constant();
- if (con != NULL) {
- *index = arith->y();
+ if (arith->op() == Bytecodes::_lmul) {
+ assert((*index)->type() == longType, "invalid input type");
+ LongConstant* val = con->type()->as_LongConstant();
+ assert(val != NULL, "expecting a long constant");
+ const_value = val->value();
+ } else {
+#ifndef _LP64
+ if (arith->op() == Bytecodes::_imul) {
+ assert((*index)->type() == intType, "invalid input type");
+ IntConstant* val = con->type()->as_IntConstant();
+ assert(val != NULL, "expecting an int constant");
+ const_value = val->value();
} else {
- con = arith->y()->as_Constant();
- if (con == NULL) return false;
- *index = arith->x();
+ return false;
}
- if ((*index)->type() != intType) return false;
- // Well-known type and value?
- IntConstant* val = con->type()->as_IntConstant();
- if (val == NULL) return false;
- switch (val->value()) {
- case 1: *log2_scale = 0; return true;
- case 2: *log2_scale = 1; return true;
- case 4: *log2_scale = 2; return true;
- case 8: *log2_scale = 3; return true;
- default: return false;
- }
+#else
+ return false;
+#endif
+ }
+ switch (const_value) {
+ case 1: *log2_scale = 0; return true;
+ case 2: *log2_scale = 1; return true;
+ case 4: *log2_scale = 2; return true;
+ case 8: *log2_scale = 3; return true;
+ default: return false;
}
}
@@ -879,29 +903,37 @@
Instruction** base,
Instruction** index,
int* log2_scale) {
- Instruction* instr_to_unpin = NULL;
ArithmeticOp* root = x->base()->as_ArithmeticOp();
if (root == NULL) return false;
// Limit ourselves to addition for now
if (root->op() != Bytecodes::_ladd) return false;
+
+ bool match_found = false;
// Try to find shift or scale op
- if (match_index_and_scale(root->y(), index, log2_scale, &instr_to_unpin)) {
+ if (match_index_and_scale(root->y(), index, log2_scale)) {
*base = root->x();
- } else if (match_index_and_scale(root->x(), index, log2_scale, &instr_to_unpin)) {
+ match_found = true;
+ } else if (match_index_and_scale(root->x(), index, log2_scale)) {
*base = root->y();
- } else if (root->y()->as_Convert() != NULL) {
+ match_found = true;
+ } else if (NOT_LP64(root->y()->as_Convert() != NULL) LP64_ONLY(false)) {
+ // Skipping i2l works only on 32bit because of the implicit l2i that the unsafe performs.
+ // 64bit needs a real sign-extending conversion.
Convert* convert = root->y()->as_Convert();
- if (convert->op() == Bytecodes::_i2l && convert->value()->type() == intType) {
+ if (convert->op() == Bytecodes::_i2l) {
+ assert(convert->value()->type() == intType, "should be an int");
// pick base and index, setting scale at 1
*base = root->x();
*index = convert->value();
*log2_scale = 0;
- } else {
- return false;
+ match_found = true;
}
- } else {
- // doesn't match any expected sequences
- return false;
+ }
+ // The default solution
+ if (!match_found) {
+ *base = root->x();
+ *index = root->y();
+ *log2_scale = 0;
}
// If the value is pinned then it will be always be computed so
--- a/hotspot/src/share/vm/c1/c1_Compilation.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_Compilation.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -38,17 +38,18 @@
typedef enum {
_t_compile,
- _t_setup,
- _t_buildIR,
- _t_optimize_blocks,
- _t_optimize_null_checks,
- _t_rangeCheckElimination,
- _t_emit_lir,
- _t_linearScan,
- _t_lirGeneration,
- _t_lir_schedule,
- _t_codeemit,
- _t_codeinstall,
+ _t_setup,
+ _t_buildIR,
+ _t_hir_parse,
+ _t_gvn,
+ _t_optimize_blocks,
+ _t_optimize_null_checks,
+ _t_rangeCheckElimination,
+ _t_emit_lir,
+ _t_linearScan,
+ _t_lirGeneration,
+ _t_codeemit,
+ _t_codeinstall,
max_phase_timers
} TimerName;
@@ -56,13 +57,14 @@
"compile",
"setup",
"buildIR",
+ "parse_hir",
+ "gvn",
"optimize_blocks",
"optimize_null_checks",
"rangeCheckElimination",
"emit_lir",
"linearScan",
"lirGeneration",
- "lir_schedule",
"codeemit",
"codeinstall"
};
@@ -144,7 +146,10 @@
log->stamp();
log->end_head();
}
- _hir = new IR(this, method(), osr_bci());
+ {
+ PhaseTraceTime timeit(_t_hir_parse);
+ _hir = new IR(this, method(), osr_bci());
+ }
if (log) log->done("parse");
if (!_hir->is_valid()) {
bailout("invalid parsing");
@@ -189,6 +194,7 @@
if (UseGlobalValueNumbering) {
// No resource mark here! LoopInvariantCodeMotion can allocate ValueStack objects.
+ PhaseTraceTime timeit(_t_gvn);
int instructions = Instruction::number_of_instructions();
GlobalValueNumbering gvn(_hir);
assert(instructions == Instruction::number_of_instructions(),
@@ -419,8 +425,12 @@
void Compilation::compile_method() {
- // setup compilation
- initialize();
+ {
+ PhaseTraceTime timeit(_t_setup);
+
+ // setup compilation
+ initialize();
+ }
if (!method()->can_be_compiled()) {
// Prevent race condition 6328518.
@@ -615,24 +625,54 @@
}
void Compilation::print_timers() {
- // tty->print_cr(" Native methods : %6.3f s, Average : %2.3f", CompileBroker::_t_native_compilation.seconds(), CompileBroker::_t_native_compilation.seconds() / CompileBroker::_total_native_compile_count);
- float total = timers[_t_setup].seconds() + timers[_t_buildIR].seconds() + timers[_t_emit_lir].seconds() + timers[_t_lir_schedule].seconds() + timers[_t_codeemit].seconds() + timers[_t_codeinstall].seconds();
+ tty->print_cr(" C1 Compile Time: %7.3f s", timers[_t_compile].seconds());
+ tty->print_cr(" Setup time: %7.3f s", timers[_t_setup].seconds());
+
+ {
+ tty->print_cr(" Build HIR: %7.3f s", timers[_t_buildIR].seconds());
+ tty->print_cr(" Parse: %7.3f s", timers[_t_hir_parse].seconds());
+ tty->print_cr(" Optimize blocks: %7.3f s", timers[_t_optimize_blocks].seconds());
+ tty->print_cr(" GVN: %7.3f s", timers[_t_gvn].seconds());
+ tty->print_cr(" Null checks elim: %7.3f s", timers[_t_optimize_null_checks].seconds());
+ tty->print_cr(" Range checks elim: %7.3f s", timers[_t_rangeCheckElimination].seconds());
+ double other = timers[_t_buildIR].seconds() -
+ (timers[_t_hir_parse].seconds() +
+ timers[_t_optimize_blocks].seconds() +
+ timers[_t_gvn].seconds() +
+ timers[_t_optimize_null_checks].seconds() +
+ timers[_t_rangeCheckElimination].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
+ }
- tty->print_cr(" Detailed C1 Timings");
- tty->print_cr(" Setup time: %6.3f s (%4.1f%%)", timers[_t_setup].seconds(), (timers[_t_setup].seconds() / total) * 100.0);
- tty->print_cr(" Build IR: %6.3f s (%4.1f%%)", timers[_t_buildIR].seconds(), (timers[_t_buildIR].seconds() / total) * 100.0);
- float t_optimizeIR = timers[_t_optimize_blocks].seconds() + timers[_t_optimize_null_checks].seconds();
- tty->print_cr(" Optimize: %6.3f s (%4.1f%%)", t_optimizeIR, (t_optimizeIR / total) * 100.0);
- tty->print_cr(" RCE: %6.3f s (%4.1f%%)", timers[_t_rangeCheckElimination].seconds(), (timers[_t_rangeCheckElimination].seconds() / total) * 100.0);
- tty->print_cr(" Emit LIR: %6.3f s (%4.1f%%)", timers[_t_emit_lir].seconds(), (timers[_t_emit_lir].seconds() / total) * 100.0);
- tty->print_cr(" LIR Gen: %6.3f s (%4.1f%%)", timers[_t_lirGeneration].seconds(), (timers[_t_lirGeneration].seconds() / total) * 100.0);
- tty->print_cr(" Linear Scan: %6.3f s (%4.1f%%)", timers[_t_linearScan].seconds(), (timers[_t_linearScan].seconds() / total) * 100.0);
- NOT_PRODUCT(LinearScan::print_timers(timers[_t_linearScan].seconds()));
- tty->print_cr(" LIR Schedule: %6.3f s (%4.1f%%)", timers[_t_lir_schedule].seconds(), (timers[_t_lir_schedule].seconds() / total) * 100.0);
- tty->print_cr(" Code Emission: %6.3f s (%4.1f%%)", timers[_t_codeemit].seconds(), (timers[_t_codeemit].seconds() / total) * 100.0);
- tty->print_cr(" Code Installation: %6.3f s (%4.1f%%)", timers[_t_codeinstall].seconds(), (timers[_t_codeinstall].seconds() / total) * 100.0);
- tty->print_cr(" Instruction Nodes: %6d nodes", totalInstructionNodes);
+ {
+ tty->print_cr(" Emit LIR: %7.3f s", timers[_t_emit_lir].seconds());
+ tty->print_cr(" LIR Gen: %7.3f s", timers[_t_lirGeneration].seconds());
+ tty->print_cr(" Linear Scan: %7.3f s", timers[_t_linearScan].seconds());
+ NOT_PRODUCT(LinearScan::print_timers(timers[_t_linearScan].seconds()));
+
+ double other = timers[_t_emit_lir].seconds() -
+ (timers[_t_lirGeneration].seconds() +
+ timers[_t_linearScan].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
+ }
+
+ tty->print_cr(" Code Emission: %7.3f s", timers[_t_codeemit].seconds());
+ tty->print_cr(" Code Installation: %7.3f s", timers[_t_codeinstall].seconds());
+
+ double other = timers[_t_compile].seconds() -
+ (timers[_t_setup].seconds() +
+ timers[_t_buildIR].seconds() +
+ timers[_t_emit_lir].seconds() +
+ timers[_t_codeemit].seconds() +
+ timers[_t_codeinstall].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
NOT_PRODUCT(LinearScan::print_statistics());
}
--- a/hotspot/src/share/vm/c1/c1_Compiler.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_Compiler.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -76,6 +76,11 @@
}
}
+int Compiler::code_buffer_size() {
+ assert(SegmentedCodeCache, "Should be only used with a segmented code cache");
+ return Compilation::desired_max_code_buffer_size() + Compilation::desired_max_constant_size();
+}
+
BufferBlob* Compiler::init_buffer_blob() {
// Allocate buffer blob once at startup since allocation for each
// compilation seems to be too expensive (at least on Intel win32).
--- a/hotspot/src/share/vm/c1/c1_Compiler.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_Compiler.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -54,6 +54,9 @@
// Print compilation timers and statistics
virtual void print_timers();
+
+ // Size of the code buffer
+ static int code_buffer_size();
};
#endif // SHARE_VM_C1_C1_COMPILER_HPP
--- a/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_LIRGenerator.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -2045,6 +2045,8 @@
}
}
+// Here UnsafeGetRaw may have x->base() and x->index() be int or long
+// on both 64 and 32 bits. Expecting x->base() to be always long on 64bit.
void LIRGenerator::do_UnsafeGetRaw(UnsafeGetRaw* x) {
LIRItem base(x->base(), this);
LIRItem idx(this);
@@ -2059,50 +2061,73 @@
int log2_scale = 0;
if (x->has_index()) {
- assert(x->index()->type()->tag() == intTag, "should not find non-int index");
log2_scale = x->log2_scale();
}
assert(!x->has_index() || idx.value() == x->index(), "should match");
LIR_Opr base_op = base.result();
+ LIR_Opr index_op = idx.result();
#ifndef _LP64
if (x->base()->type()->tag() == longTag) {
base_op = new_register(T_INT);
__ convert(Bytecodes::_l2i, base.result(), base_op);
- } else {
- assert(x->base()->type()->tag() == intTag, "must be");
+ }
+ if (x->has_index()) {
+ if (x->index()->type()->tag() == longTag) {
+ LIR_Opr long_index_op = index_op;
+ if (x->index()->type()->is_constant()) {
+ long_index_op = new_register(T_LONG);
+ __ move(index_op, long_index_op);
+ }
+ index_op = new_register(T_INT);
+ __ convert(Bytecodes::_l2i, long_index_op, index_op);
+ } else {
+ assert(x->index()->type()->tag() == intTag, "must be");
+ }
}
+ // At this point base and index should be all ints.
+ assert(base_op->type() == T_INT && !base_op->is_constant(), "base should be an non-constant int");
+ assert(!x->has_index() || index_op->type() == T_INT, "index should be an int");
+#else
+ if (x->has_index()) {
+ if (x->index()->type()->tag() == intTag) {
+ if (!x->index()->type()->is_constant()) {
+ index_op = new_register(T_LONG);
+ __ convert(Bytecodes::_i2l, idx.result(), index_op);
+ }
+ } else {
+ assert(x->index()->type()->tag() == longTag, "must be");
+ if (x->index()->type()->is_constant()) {
+ index_op = new_register(T_LONG);
+ __ move(idx.result(), index_op);
+ }
+ }
+ }
+ // At this point base is a long non-constant
+ // Index is a long register or a int constant.
+ // We allow the constant to stay an int because that would allow us a more compact encoding by
+ // embedding an immediate offset in the address expression. If we have a long constant, we have to
+ // move it into a register first.
+ assert(base_op->type() == T_LONG && !base_op->is_constant(), "base must be a long non-constant");
+ assert(!x->has_index() || (index_op->type() == T_INT && index_op->is_constant()) ||
+ (index_op->type() == T_LONG && !index_op->is_constant()), "unexpected index type");
#endif
BasicType dst_type = x->basic_type();
- LIR_Opr index_op = idx.result();
LIR_Address* addr;
if (index_op->is_constant()) {
assert(log2_scale == 0, "must not have a scale");
+ assert(index_op->type() == T_INT, "only int constants supported");
addr = new LIR_Address(base_op, index_op->as_jint(), dst_type);
} else {
#ifdef X86
-#ifdef _LP64
- if (!index_op->is_illegal() && index_op->type() == T_INT) {
- LIR_Opr tmp = new_pointer_register();
- __ convert(Bytecodes::_i2l, index_op, tmp);
- index_op = tmp;
- }
-#endif
addr = new LIR_Address(base_op, index_op, LIR_Address::Scale(log2_scale), 0, dst_type);
#elif defined(ARM)
addr = generate_address(base_op, index_op, log2_scale, 0, dst_type);
#else
if (index_op->is_illegal() || log2_scale == 0) {
-#ifdef _LP64
- if (!index_op->is_illegal() && index_op->type() == T_INT) {
- LIR_Opr tmp = new_pointer_register();
- __ convert(Bytecodes::_i2l, index_op, tmp);
- index_op = tmp;
- }
-#endif
addr = new LIR_Address(base_op, index_op, dst_type);
} else {
LIR_Opr tmp = new_pointer_register();
@@ -2129,7 +2154,6 @@
BasicType type = x->basic_type();
if (x->has_index()) {
- assert(x->index()->type()->tag() == intTag, "should not find non-int index");
log2_scale = x->log2_scale();
}
@@ -2152,38 +2176,39 @@
set_no_result(x);
LIR_Opr base_op = base.result();
+ LIR_Opr index_op = idx.result();
+
#ifndef _LP64
if (x->base()->type()->tag() == longTag) {
base_op = new_register(T_INT);
__ convert(Bytecodes::_l2i, base.result(), base_op);
- } else {
- assert(x->base()->type()->tag() == intTag, "must be");
+ }
+ if (x->has_index()) {
+ if (x->index()->type()->tag() == longTag) {
+ index_op = new_register(T_INT);
+ __ convert(Bytecodes::_l2i, idx.result(), index_op);
+ }
}
+ // At this point base and index should be all ints and not constants
+ assert(base_op->type() == T_INT && !base_op->is_constant(), "base should be an non-constant int");
+ assert(!x->has_index() || (index_op->type() == T_INT && !index_op->is_constant()), "index should be an non-constant int");
+#else
+ if (x->has_index()) {
+ if (x->index()->type()->tag() == intTag) {
+ index_op = new_register(T_LONG);
+ __ convert(Bytecodes::_i2l, idx.result(), index_op);
+ }
+ }
+ // At this point base and index are long and non-constant
+ assert(base_op->type() == T_LONG && !base_op->is_constant(), "base must be a non-constant long");
+ assert(!x->has_index() || (index_op->type() == T_LONG && !index_op->is_constant()), "index must be a non-constant long");
#endif
- LIR_Opr index_op = idx.result();
if (log2_scale != 0) {
// temporary fix (platform dependent code without shift on Intel would be better)
- index_op = new_pointer_register();
-#ifdef _LP64
- if(idx.result()->type() == T_INT) {
- __ convert(Bytecodes::_i2l, idx.result(), index_op);
- } else {
-#endif
- // TODO: ARM also allows embedded shift in the address
- __ move(idx.result(), index_op);
-#ifdef _LP64
- }
-#endif
+ // TODO: ARM also allows embedded shift in the address
__ shift_left(index_op, log2_scale, index_op);
}
-#ifdef _LP64
- else if(!index_op->is_illegal() && index_op->type() == T_INT) {
- LIR_Opr tmp = new_pointer_register();
- __ convert(Bytecodes::_i2l, index_op, tmp);
- index_op = tmp;
- }
-#endif
LIR_Address* addr = new LIR_Address(base_op, index_op, x->basic_type());
__ move(value.result(), addr);
--- a/hotspot/src/share/vm/c1/c1_globals.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/c1/c1_globals.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -287,9 +287,6 @@
develop(bool, InstallMethods, true, \
"Install methods at the end of successful compilations") \
\
- product(intx, CompilationRepeat, 0, \
- "Number of times to recompile method before returning result") \
- \
develop(intx, NMethodSizeLimit, (64*K)*wordSize, \
"Maximum size of a compiled method.") \
\
--- a/hotspot/src/share/vm/ci/ciEnv.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/ci/ciEnv.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -34,6 +34,7 @@
#include "ci/ciUtilities.hpp"
#include "classfile/systemDictionary.hpp"
#include "classfile/vmSymbols.hpp"
+#include "code/codeCache.hpp"
#include "code/scopeDesc.hpp"
#include "compiler/compileBroker.hpp"
#include "compiler/compileLog.hpp"
@@ -579,7 +580,12 @@
oop obj = cpool->resolved_references()->obj_at(cache_index);
if (obj != NULL) {
ciObject* ciobj = get_object(obj);
- return ciConstant(T_OBJECT, ciobj);
+ if (ciobj->is_array()) {
+ return ciConstant(T_ARRAY, ciobj);
+ } else {
+ assert(ciobj->is_instance(), "should be an instance");
+ return ciConstant(T_OBJECT, ciobj);
+ }
}
index = cpool->object_to_cp_index(cache_index);
}
@@ -606,8 +612,12 @@
}
}
ciObject* constant = get_object(string);
- assert (constant->is_instance(), "must be an instance, or not? ");
- return ciConstant(T_OBJECT, constant);
+ if (constant->is_array()) {
+ return ciConstant(T_ARRAY, constant);
+ } else {
+ assert (constant->is_instance(), "must be an instance, or not? ");
+ return ciConstant(T_OBJECT, constant);
+ }
} else if (tag.is_klass() || tag.is_unresolved_klass()) {
// 4881222: allow ldc to take a class type
ciKlass* klass = get_klass_by_index_impl(cpool, index, ignore_will_link, accessor);
@@ -1085,7 +1095,7 @@
} else {
// The CodeCache is full. Print out warning and disable compilation.
record_failure("code cache is full");
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeCache::get_code_blob_type(comp_level));
}
}
--- a/hotspot/src/share/vm/ci/ciTypeFlow.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/ci/ciTypeFlow.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -730,7 +730,7 @@
if (obj->is_null_object()) {
push_null();
} else {
- assert(obj->is_instance(), "must be java_mirror of klass");
+ assert(obj->is_instance() || obj->is_array(), "must be java_mirror of klass");
push_object(obj->klass());
}
} else {
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -636,6 +636,7 @@
}
// set the classLoader field in the java_lang_Class instance
+ assert(class_loader() == k->class_loader(), "should be same");
set_class_loader(mirror(), class_loader());
// Setup indirection from klass->mirror last
--- a/hotspot/src/share/vm/classfile/symbolTable.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/classfile/symbolTable.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -496,77 +496,65 @@
void SymbolTable::print_histogram() {
MutexLocker ml(SymbolTable_lock);
const int results_length = 100;
- int results[results_length];
+ int counts[results_length];
+ int sizes[results_length];
int i,j;
// initialize results to zero
for (j = 0; j < results_length; j++) {
- results[j] = 0;
+ counts[j] = 0;
+ sizes[j] = 0;
}
- int total = 0;
- int max_symbols = 0;
- int out_of_range = 0;
- int memory_total = 0;
- int count = 0;
+ int total_size = 0;
+ int total_count = 0;
+ int total_length = 0;
+ int max_length = 0;
+ int out_of_range_count = 0;
+ int out_of_range_size = 0;
for (i = 0; i < the_table()->table_size(); i++) {
HashtableEntry<Symbol*, mtSymbol>* p = the_table()->bucket(i);
for ( ; p != NULL; p = p->next()) {
- memory_total += p->literal()->size();
- count++;
- int counter = p->literal()->utf8_length();
- total += counter;
- if (counter < results_length) {
- results[counter]++;
+ int size = p->literal()->size();
+ int len = p->literal()->utf8_length();
+ if (len < results_length) {
+ counts[len]++;
+ sizes[len] += size;
} else {
- out_of_range++;
+ out_of_range_count++;
+ out_of_range_size += size;
}
- max_symbols = MAX2(max_symbols, counter);
+ total_count++;
+ total_size += size;
+ total_length += len;
+ max_length = MAX2(max_length, len);
}
}
- tty->print_cr("Symbol Table:");
- tty->print_cr("Total number of symbols %5d", count);
- tty->print_cr("Total size in memory %5dK",
- (memory_total*HeapWordSize)/1024);
- tty->print_cr("Total counted %5d", _symbols_counted);
- tty->print_cr("Total removed %5d", _symbols_removed);
+ tty->print_cr("Symbol Table Histogram:");
+ tty->print_cr(" Total number of symbols %7d", total_count);
+ tty->print_cr(" Total size in memory %7dK",
+ (total_size*HeapWordSize)/1024);
+ tty->print_cr(" Total counted %7d", _symbols_counted);
+ tty->print_cr(" Total removed %7d", _symbols_removed);
if (_symbols_counted > 0) {
- tty->print_cr("Percent removed %3.2f",
+ tty->print_cr(" Percent removed %3.2f",
((float)_symbols_removed/(float)_symbols_counted)* 100);
}
- tty->print_cr("Reference counts %5d", Symbol::_total_count);
- tty->print_cr("Symbol arena size %5d used %5d",
- arena()->size_in_bytes(), arena()->used());
- tty->print_cr("Histogram of symbol length:");
- tty->print_cr("%8s %5d", "Total ", total);
- tty->print_cr("%8s %5d", "Maximum", max_symbols);
- tty->print_cr("%8s %3.2f", "Average",
- ((float) total / (float) the_table()->table_size()));
- tty->print_cr("%s", "Histogram:");
- tty->print_cr(" %s %29s", "Length", "Number chains that length");
+ tty->print_cr(" Reference counts %7d", Symbol::_total_count);
+ tty->print_cr(" Symbol arena used %7dK", arena()->used()/1024);
+ tty->print_cr(" Symbol arena size %7dK", arena()->size_in_bytes()/1024);
+ tty->print_cr(" Total symbol length %7d", total_length);
+ tty->print_cr(" Maximum symbol length %7d", max_length);
+ tty->print_cr(" Average symbol length %7.2f", ((float) total_length / (float) total_count));
+ tty->print_cr(" Symbol length histogram:");
+ tty->print_cr(" %6s %10s %10s", "Length", "#Symbols", "Size");
for (i = 0; i < results_length; i++) {
- if (results[i] > 0) {
- tty->print_cr("%6d %10d", i, results[i]);
+ if (counts[i] > 0) {
+ tty->print_cr(" %6d %10d %10dK", i, counts[i], (sizes[i]*HeapWordSize)/1024);
}
}
- if (Verbose) {
- int line_length = 70;
- tty->print_cr("%s %30s", " Length", "Number chains that length");
- for (i = 0; i < results_length; i++) {
- if (results[i] > 0) {
- tty->print("%4d", i);
- for (j = 0; (j < results[i]) && (j < line_length); j++) {
- tty->print("%1s", "*");
- }
- if (j == line_length) {
- tty->print("%1s", "+");
- }
- tty->cr();
- }
- }
- }
- tty->print_cr(" %s %d: %d\n", "Number chains longer than",
- results_length, out_of_range);
+ tty->print_cr(" >=%6d %10d %10dK\n", results_length,
+ out_of_range_count, (out_of_range_size*HeapWordSize)/1024);
}
void SymbolTable::print() {
--- a/hotspot/src/share/vm/classfile/systemDictionary.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -2273,12 +2273,14 @@
spe = NULL;
// Must create lots of stuff here, but outside of the SystemDictionary lock.
m = Method::make_method_handle_intrinsic(iid, signature, CHECK_(empty));
- CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_highest_tier,
- methodHandle(), CompileThreshold, "MH", CHECK_(empty));
- // Check if we need to have compiled code but we don't.
- if (!Arguments::is_interpreter_only() && !m->has_compiled_code()) {
- THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
- "out of space in CodeCache for method handle intrinsic", empty);
+ if (!Arguments::is_interpreter_only()) {
+ // Generate a compiled form of the MH intrinsic.
+ AdapterHandlerLibrary::create_native_wrapper(m);
+ // Check if have the compiled code.
+ if (!m->has_compiled_code()) {
+ THROW_MSG_(vmSymbols::java_lang_VirtualMachineError(),
+ "out of space in CodeCache for method handle intrinsic", empty);
+ }
}
// Now grab the lock. We might have to throw away the new method,
// if a racing thread has managed to install one at the same time.
--- a/hotspot/src/share/vm/classfile/verifier.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/classfile/verifier.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1694,8 +1694,6 @@
constantPoolHandle cp (THREAD, _method->constants());
for(int i = 0; i < exlength; i++) {
- //reacquire the table in case a GC happened
- ExceptionTable exhandlers(_method());
u2 start_pc = exhandlers.start_pc(i);
u2 end_pc = exhandlers.end_pc(i);
u2 handler_pc = exhandlers.handler_pc(i);
@@ -1803,8 +1801,6 @@
ExceptionTable exhandlers(_method());
int exlength = exhandlers.length();
for(int i = 0; i < exlength; i++) {
- //reacquire the table in case a GC happened
- ExceptionTable exhandlers(_method());
u2 start_pc = exhandlers.start_pc(i);
u2 end_pc = exhandlers.end_pc(i);
u2 handler_pc = exhandlers.handler_pc(i);
--- a/hotspot/src/share/vm/classfile/verifier.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/classfile/verifier.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -406,13 +406,20 @@
}
// Keep a list of temporary symbols created during verification because
- // their reference counts need to be decrememented when the verifier object
+ // their reference counts need to be decremented when the verifier object
// goes out of scope. Since these symbols escape the scope in which they're
// created, we can't use a TempNewSymbol.
- Symbol* create_temporary_symbol(
- const Symbol* s, int begin, int end, TRAPS);
+ Symbol* create_temporary_symbol(const Symbol* s, int begin, int end, TRAPS);
Symbol* create_temporary_symbol(const char *s, int length, TRAPS);
+ Symbol* create_temporary_symbol(Symbol* s) {
+ // This version just updates the reference count and saves the symbol to be
+ // dereferenced later.
+ s->increment_refcount();
+ _symbols->push(s);
+ return s;
+ }
+
TypeOrigin ref_ctx(const char* str, TRAPS);
};
@@ -425,10 +432,8 @@
case T_ARRAY:
{
Symbol* name = sig_type->as_symbol(CHECK_0);
- // Create another symbol to save as signature stream unreferences
- // this symbol.
- Symbol* name_copy =
- create_temporary_symbol(name, 0, name->utf8_length(), CHECK_0);
+ // Create another symbol to save as signature stream unreferences this symbol.
+ Symbol* name_copy = create_temporary_symbol(name);
assert(name_copy == name, "symbols don't match");
*inference_type =
VerificationType::reference_type(name_copy);
--- a/hotspot/src/share/vm/code/codeBlob.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/codeBlob.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -229,14 +229,11 @@
return blob;
}
-
void* BufferBlob::operator new(size_t s, unsigned size, bool is_critical) throw() {
- void* p = CodeCache::allocate(size, is_critical);
- return p;
+ return CodeCache::allocate(size, CodeBlobType::NonNMethod, is_critical);
}
-
-void BufferBlob::free( BufferBlob *blob ) {
+void BufferBlob::free(BufferBlob *blob) {
ThreadInVMfromUnknown __tiv; // get to VM state in case we block on CodeCache_lock
blob->flush();
{
@@ -299,7 +296,6 @@
return blob;
}
-
//----------------------------------------------------------------------------------------------------
// Implementation of RuntimeStub
@@ -340,14 +336,14 @@
void* RuntimeStub::operator new(size_t s, unsigned size) throw() {
- void* p = CodeCache::allocate(size, true);
+ void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod, true);
if (!p) fatal("Initial size of CodeCache is too small");
return p;
}
// operator new shared by all singletons:
void* SingletonBlob::operator new(size_t s, unsigned size) throw() {
- void* p = CodeCache::allocate(size, true);
+ void* p = CodeCache::allocate(size, CodeBlobType::NonNMethod, true);
if (!p) fatal("Initial size of CodeCache is too small");
return p;
}
--- a/hotspot/src/share/vm/code/codeBlob.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/codeBlob.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -30,6 +30,18 @@
#include "runtime/frame.hpp"
#include "runtime/handles.hpp"
+// CodeBlob Types
+// Used in the CodeCache to assign CodeBlobs to different CodeHeaps
+struct CodeBlobType {
+ enum {
+ MethodNonProfiled = 0, // Execution level 1 and 4 (non-profiled) nmethods (including native nmethods)
+ MethodProfiled = 1, // Execution level 2 and 3 (profiled) nmethods
+ NonNMethod = 2, // Non-nmethods like Buffers, Adapters and Runtime Stubs
+ All = 3, // All types (No code cache segmentation)
+ NumTypes = 4 // Number of CodeBlobTypes
+ };
+};
+
// CodeBlob - superclass for all entries in the CodeCache.
//
// Suptypes are:
@@ -385,9 +397,6 @@
return (pc == unpack_pc || (pc + frame::pc_return_offset) == unpack_pc);
}
-
-
-
// GC for args
void preserve_callee_argument_oops(frame fr, const RegisterMap *reg_map, OopClosure* f) { /* Nothing to do */ }
--- a/hotspot/src/share/vm/code/codeCache.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/codeCache.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -44,12 +44,21 @@
#include "runtime/icache.hpp"
#include "runtime/java.hpp"
#include "runtime/mutexLocker.hpp"
+#include "runtime/compilationPolicy.hpp"
#include "services/memoryService.hpp"
#include "trace/tracing.hpp"
#include "utilities/xmlstream.hpp"
+#ifdef COMPILER1
+#include "c1/c1_Compilation.hpp"
+#include "c1/c1_Compiler.hpp"
+#endif
+#ifdef COMPILER2
+#include "opto/c2compiler.hpp"
+#include "opto/compile.hpp"
+#include "opto/node.hpp"
+#endif
// Helper class for printing in CodeCache
-
class CodeBlob_sizes {
private:
int count;
@@ -115,64 +124,216 @@
}
};
-// CodeCache implementation
+// Iterate over all CodeHeaps
+#define FOR_ALL_HEAPS(heap) for (GrowableArrayIterator<CodeHeap*> heap = _heaps->begin(); heap != _heaps->end(); ++heap)
+// Iterate over all CodeBlobs (cb) on the given CodeHeap
+#define FOR_ALL_BLOBS(cb, heap) for (CodeBlob* cb = first_blob(heap); cb != NULL; cb = next_blob(heap, cb))
-CodeHeap * CodeCache::_heap = new CodeHeap();
+address CodeCache::_low_bound = 0;
+address CodeCache::_high_bound = 0;
int CodeCache::_number_of_blobs = 0;
int CodeCache::_number_of_adapters = 0;
int CodeCache::_number_of_nmethods = 0;
int CodeCache::_number_of_nmethods_with_dependencies = 0;
bool CodeCache::_needs_cache_clean = false;
nmethod* CodeCache::_scavenge_root_nmethods = NULL;
-
int CodeCache::_codemem_full_count = 0;
-CodeBlob* CodeCache::first() {
- assert_locked_or_safepoint(CodeCache_lock);
- return (CodeBlob*)_heap->first();
-}
+// Initialize array of CodeHeaps
+GrowableArray<CodeHeap*>* CodeCache::_heaps = new(ResourceObj::C_HEAP, mtCode) GrowableArray<CodeHeap*> (CodeBlobType::All, true);
+
+void CodeCache::initialize_heaps() {
+ // Determine size of compiler buffers
+ size_t code_buffers_size = 0;
+#ifdef COMPILER1
+ // C1 temporary code buffers (see Compiler::init_buffer_blob())
+ const int c1_count = CompilationPolicy::policy()->compiler_count(CompLevel_simple);
+ code_buffers_size += c1_count * Compiler::code_buffer_size();
+#endif
+#ifdef COMPILER2
+ // C2 scratch buffers (see Compile::init_scratch_buffer_blob())
+ const int c2_count = CompilationPolicy::policy()->compiler_count(CompLevel_full_optimization);
+ // Initial size of constant table (this may be increased if a compiled method needs more space)
+ code_buffers_size += c2_count * C2Compiler::initial_code_buffer_size();
+#endif
+ // Calculate default CodeHeap sizes if not set by user
+ if (!FLAG_IS_CMDLINE(NonNMethodCodeHeapSize) && !FLAG_IS_CMDLINE(ProfiledCodeHeapSize)
+ && !FLAG_IS_CMDLINE(NonProfiledCodeHeapSize)) {
+ // Increase default NonNMethodCodeHeapSize to account for compiler buffers
+ FLAG_SET_ERGO(uintx, NonNMethodCodeHeapSize, NonNMethodCodeHeapSize + code_buffers_size);
+
+ // Check if we have enough space for the non-nmethod code heap
+ if (ReservedCodeCacheSize > NonNMethodCodeHeapSize) {
+ // Use the default value for NonNMethodCodeHeapSize and one half of the
+ // remaining size for non-profiled methods and one half for profiled methods
+ size_t remaining_size = ReservedCodeCacheSize - NonNMethodCodeHeapSize;
+ size_t profiled_size = remaining_size / 2;
+ size_t non_profiled_size = remaining_size - profiled_size;
+ FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, profiled_size);
+ FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, non_profiled_size);
+ } else {
+ // Use all space for the non-nmethod heap and set other heaps to minimal size
+ FLAG_SET_ERGO(uintx, NonNMethodCodeHeapSize, ReservedCodeCacheSize - os::vm_page_size() * 2);
+ FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, os::vm_page_size());
+ FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, os::vm_page_size());
+ }
+ }
-CodeBlob* CodeCache::next(CodeBlob* cb) {
- assert_locked_or_safepoint(CodeCache_lock);
- return (CodeBlob*)_heap->next(cb);
-}
+ // We do not need the profiled CodeHeap, use all space for the non-profiled CodeHeap
+ if(!heap_available(CodeBlobType::MethodProfiled)) {
+ FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, NonProfiledCodeHeapSize + ProfiledCodeHeapSize);
+ FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, 0);
+ }
+ // We do not need the non-profiled CodeHeap, use all space for the non-nmethod CodeHeap
+ if(!heap_available(CodeBlobType::MethodNonProfiled)) {
+ FLAG_SET_ERGO(uintx, NonNMethodCodeHeapSize, NonNMethodCodeHeapSize + NonProfiledCodeHeapSize);
+ FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, 0);
+ }
+
+ // Make sure we have enough space for VM internal code
+ uint min_code_cache_size = (CodeCacheMinimumUseSpace DEBUG_ONLY(* 3)) + CodeCacheMinimumFreeSpace;
+ if (NonNMethodCodeHeapSize < (min_code_cache_size + code_buffers_size)) {
+ vm_exit_during_initialization("Not enough space in non-nmethod code heap to run VM.");
+ }
+ guarantee(NonProfiledCodeHeapSize + ProfiledCodeHeapSize + NonNMethodCodeHeapSize <= ReservedCodeCacheSize, "Size check");
+
+ // Align reserved sizes of CodeHeaps
+ size_t non_method_size = ReservedCodeSpace::allocation_align_size_up(NonNMethodCodeHeapSize);
+ size_t profiled_size = ReservedCodeSpace::allocation_align_size_up(ProfiledCodeHeapSize);
+ size_t non_profiled_size = ReservedCodeSpace::allocation_align_size_up(NonProfiledCodeHeapSize);
+ // Compute initial sizes of CodeHeaps
+ size_t init_non_method_size = MIN2(InitialCodeCacheSize, non_method_size);
+ size_t init_profiled_size = MIN2(InitialCodeCacheSize, profiled_size);
+ size_t init_non_profiled_size = MIN2(InitialCodeCacheSize, non_profiled_size);
-CodeBlob* CodeCache::alive(CodeBlob *cb) {
- assert_locked_or_safepoint(CodeCache_lock);
- while (cb != NULL && !cb->is_alive()) cb = next(cb);
- return cb;
+ // Reserve one continuous chunk of memory for CodeHeaps and split it into
+ // parts for the individual heaps. The memory layout looks like this:
+ // ---------- high -----------
+ // Non-profiled nmethods
+ // Profiled nmethods
+ // Non-nmethods
+ // ---------- low ------------
+ ReservedCodeSpace rs = reserve_heap_memory(non_profiled_size + profiled_size + non_method_size);
+ ReservedSpace non_method_space = rs.first_part(non_method_size);
+ ReservedSpace rest = rs.last_part(non_method_size);
+ ReservedSpace profiled_space = rest.first_part(profiled_size);
+ ReservedSpace non_profiled_space = rest.last_part(profiled_size);
+
+ // Non-nmethods (stubs, adapters, ...)
+ add_heap(non_method_space, "CodeHeap 'non-nmethods'", init_non_method_size, CodeBlobType::NonNMethod);
+ // Tier 2 and tier 3 (profiled) methods
+ add_heap(profiled_space, "CodeHeap 'profiled nmethods'", init_profiled_size, CodeBlobType::MethodProfiled);
+ // Tier 1 and tier 4 (non-profiled) methods and native methods
+ add_heap(non_profiled_space, "CodeHeap 'non-profiled nmethods'", init_non_profiled_size, CodeBlobType::MethodNonProfiled);
}
+ReservedCodeSpace CodeCache::reserve_heap_memory(size_t size) {
+ // Determine alignment
+ const size_t page_size = os::can_execute_large_page_memory() ?
+ MIN2(os::page_size_for_region(InitialCodeCacheSize, 8),
+ os::page_size_for_region(size, 8)) :
+ os::vm_page_size();
+ const size_t granularity = os::vm_allocation_granularity();
+ const size_t r_align = MAX2(page_size, granularity);
+ const size_t r_size = align_size_up(size, r_align);
+ const size_t rs_align = page_size == (size_t) os::vm_page_size() ? 0 :
+ MAX2(page_size, granularity);
-nmethod* CodeCache::alive_nmethod(CodeBlob* cb) {
- assert_locked_or_safepoint(CodeCache_lock);
- while (cb != NULL && (!cb->is_alive() || !cb->is_nmethod())) cb = next(cb);
- return (nmethod*)cb;
+ ReservedCodeSpace rs(r_size, rs_align, rs_align > 0);
+
+ // Initialize bounds
+ _low_bound = (address)rs.base();
+ _high_bound = _low_bound + rs.size();
+
+ return rs;
+}
+
+bool CodeCache::heap_available(int code_blob_type) {
+ if (!SegmentedCodeCache) {
+ // No segmentation: use a single code heap
+ return (code_blob_type == CodeBlobType::All);
+ } else if ((Arguments::mode() == Arguments::_int) ||
+ (TieredStopAtLevel == CompLevel_none)) {
+ // Interpreter only: we don't need any method code heaps
+ return (code_blob_type == CodeBlobType::NonNMethod);
+ } else if (TieredCompilation && (TieredStopAtLevel > CompLevel_simple)) {
+ // Tiered compilation: use all code heaps
+ return (code_blob_type < CodeBlobType::All);
+ } else {
+ // No TieredCompilation: we only need the non-nmethod and non-profiled code heap
+ return (code_blob_type == CodeBlobType::NonNMethod) ||
+ (code_blob_type == CodeBlobType::MethodNonProfiled);
+ }
}
-nmethod* CodeCache::first_nmethod() {
- assert_locked_or_safepoint(CodeCache_lock);
- CodeBlob* cb = first();
- while (cb != NULL && !cb->is_nmethod()) {
- cb = next(cb);
+void CodeCache::add_heap(ReservedSpace rs, const char* name, size_t size_initial, int code_blob_type) {
+ // Check if heap is needed
+ if (!heap_available(code_blob_type)) {
+ return;
}
- return (nmethod*)cb;
+
+ // Create CodeHeap
+ CodeHeap* heap = new CodeHeap(name, code_blob_type);
+ _heaps->append(heap);
+
+ // Reserve Space
+ size_initial = round_to(size_initial, os::vm_page_size());
+
+ if (!heap->reserve(rs, size_initial, CodeCacheSegmentSize)) {
+ vm_exit_during_initialization("Could not reserve enough space for code cache");
+ }
+
+ // Register the CodeHeap
+ MemoryService::add_code_heap_memory_pool(heap, name);
+}
+
+CodeHeap* CodeCache::get_code_heap(CodeBlob* cb) {
+ assert(cb != NULL, "CodeBlob is null");
+ FOR_ALL_HEAPS(heap) {
+ if ((*heap)->contains(cb)) {
+ return *heap;
+ }
+ }
+ ShouldNotReachHere();
+ return NULL;
}
-nmethod* CodeCache::next_nmethod (CodeBlob* cb) {
+CodeHeap* CodeCache::get_code_heap(int code_blob_type) {
+ FOR_ALL_HEAPS(heap) {
+ if ((*heap)->accepts(code_blob_type)) {
+ return *heap;
+ }
+ }
+ return NULL;
+}
+
+CodeBlob* CodeCache::first_blob(CodeHeap* heap) {
assert_locked_or_safepoint(CodeCache_lock);
- cb = next(cb);
- while (cb != NULL && !cb->is_nmethod()) {
- cb = next(cb);
- }
- return (nmethod*)cb;
+ assert(heap != NULL, "heap is null");
+ return (CodeBlob*)heap->first();
}
-static size_t maxCodeCacheUsed = 0;
+CodeBlob* CodeCache::first_blob(int code_blob_type) {
+ if (heap_available(code_blob_type)) {
+ return first_blob(get_code_heap(code_blob_type));
+ } else {
+ return NULL;
+ }
+}
-CodeBlob* CodeCache::allocate(int size, bool is_critical) {
+CodeBlob* CodeCache::next_blob(CodeHeap* heap, CodeBlob* cb) {
+ assert_locked_or_safepoint(CodeCache_lock);
+ assert(heap != NULL, "heap is null");
+ return (CodeBlob*)heap->next(cb);
+}
+
+CodeBlob* CodeCache::next_blob(CodeBlob* cb) {
+ return next_blob(get_code_heap(cb), cb);
+}
+
+CodeBlob* CodeCache::allocate(int size, int code_blob_type, bool is_critical) {
// Do not seize the CodeCache lock here--if the caller has not
// already done so, we are going to lose bigtime, since the code
// cache will contain a garbage CodeBlob until the caller can
@@ -184,22 +345,34 @@
return NULL;
}
CodeBlob* cb = NULL;
+
+ // Get CodeHeap for the given CodeBlobType
+ CodeHeap* heap = get_code_heap(code_blob_type);
+ assert(heap != NULL, "heap is null");
+
while (true) {
- cb = (CodeBlob*)_heap->allocate(size, is_critical);
+ cb = (CodeBlob*)heap->allocate(size, is_critical);
if (cb != NULL) break;
- if (!_heap->expand_by(CodeCacheExpansionSize)) {
+ if (!heap->expand_by(CodeCacheExpansionSize)) {
// Expansion failed
+ if (SegmentedCodeCache && (code_blob_type == CodeBlobType::NonNMethod)) {
+ // Fallback solution: Store non-nmethod code in the non-profiled code heap
+ return allocate(size, CodeBlobType::MethodNonProfiled, is_critical);
+ }
return NULL;
}
if (PrintCodeCacheExtension) {
ResourceMark rm;
- tty->print_cr("code cache extended to [" INTPTR_FORMAT ", " INTPTR_FORMAT "] (" SSIZE_FORMAT " bytes)",
- (intptr_t)_heap->low_boundary(), (intptr_t)_heap->high(),
- (address)_heap->high() - (address)_heap->low_boundary());
+ if (SegmentedCodeCache) {
+ tty->print("%s", heap->name());
+ } else {
+ tty->print("CodeCache");
+ }
+ tty->print_cr(" extended to [" INTPTR_FORMAT ", " INTPTR_FORMAT "] (" SSIZE_FORMAT " bytes)",
+ (intptr_t)heap->low_boundary(), (intptr_t)heap->high(),
+ (address)heap->high() - (address)heap->low_boundary());
}
}
- maxCodeCacheUsed = MAX2(maxCodeCacheUsed, ((address)_heap->high_boundary() -
- (address)_heap->low_boundary()) - unallocated_capacity());
print_trace("allocation", cb, size);
_number_of_blobs++;
return cb;
@@ -220,12 +393,12 @@
}
_number_of_blobs--;
- _heap->deallocate(cb);
+ // Get heap for given CodeBlob and deallocate
+ get_code_heap(cb)->deallocate(cb);
assert(_number_of_blobs >= 0, "sanity check");
}
-
void CodeCache::commit(CodeBlob* cb) {
// this is called by nmethod::nmethod, which must already own CodeCache_lock
assert_locked_or_safepoint(CodeCache_lock);
@@ -243,89 +416,102 @@
ICache::invalidate_range(cb->content_begin(), cb->content_size());
}
-
-// Iteration over CodeBlobs
-
-#define FOR_ALL_BLOBS(var) for (CodeBlob *var = first() ; var != NULL; var = next(var) )
-#define FOR_ALL_ALIVE_BLOBS(var) for (CodeBlob *var = alive(first()); var != NULL; var = alive(next(var)))
-#define FOR_ALL_ALIVE_NMETHODS(var) for (nmethod *var = alive_nmethod(first()); var != NULL; var = alive_nmethod(next(var)))
-#define FOR_ALL_NMETHODS(var) for (nmethod *var = first_nmethod(); var != NULL; var = next_nmethod(var))
-
-
bool CodeCache::contains(void *p) {
// It should be ok to call contains without holding a lock
- return _heap->contains(p);
+ FOR_ALL_HEAPS(heap) {
+ if ((*heap)->contains(p)) {
+ return true;
+ }
+ }
+ return false;
}
-
-// This method is safe to call without holding the CodeCache_lock, as long as a dead codeblob is not
-// looked up (i.e., one that has been marked for deletion). It only dependes on the _segmap to contain
+// This method is safe to call without holding the CodeCache_lock, as long as a dead CodeBlob is not
+// looked up (i.e., one that has been marked for deletion). It only depends on the _segmap to contain
// valid indices, which it will always do, as long as the CodeBlob is not in the process of being recycled.
CodeBlob* CodeCache::find_blob(void* start) {
CodeBlob* result = find_blob_unsafe(start);
- if (result == NULL) return NULL;
// We could potentially look up non_entrant methods
- guarantee(!result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method");
+ guarantee(result == NULL || !result->is_zombie() || result->is_locked_by_vm() || is_error_reported(), "unsafe access to zombie method");
return result;
}
+// Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know
+// what you are doing)
+CodeBlob* CodeCache::find_blob_unsafe(void* start) {
+ // NMT can walk the stack before code cache is created
+ if (_heaps == NULL || _heaps->is_empty()) return NULL;
+
+ FOR_ALL_HEAPS(heap) {
+ CodeBlob* result = (CodeBlob*) (*heap)->find_start(start);
+ if (result != NULL && result->blob_contains((address)start)) {
+ return result;
+ }
+ }
+ return NULL;
+}
+
nmethod* CodeCache::find_nmethod(void* start) {
- CodeBlob *cb = find_blob(start);
- assert(cb == NULL || cb->is_nmethod(), "did not find an nmethod");
+ CodeBlob* cb = find_blob(start);
+ assert(cb->is_nmethod(), "did not find an nmethod");
return (nmethod*)cb;
}
-
void CodeCache::blobs_do(void f(CodeBlob* nm)) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_BLOBS(p) {
- f(p);
+ FOR_ALL_HEAPS(heap) {
+ FOR_ALL_BLOBS(cb, *heap) {
+ f(cb);
+ }
}
}
-
void CodeCache::nmethods_do(void f(nmethod* nm)) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_BLOBS(nm) {
- if (nm->is_nmethod()) f((nmethod*)nm);
+ NMethodIterator iter;
+ while(iter.next()) {
+ f(iter.method());
}
}
void CodeCache::alive_nmethods_do(void f(nmethod* nm)) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_NMETHODS(nm) {
- f(nm);
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ f(iter.method());
}
}
int CodeCache::alignment_unit() {
- return (int)_heap->alignment_unit();
+ return (int)_heaps->first()->alignment_unit();
}
-
int CodeCache::alignment_offset() {
- return (int)_heap->alignment_offset();
+ return (int)_heaps->first()->alignment_offset();
}
-
-// Mark nmethods for unloading if they contain otherwise unreachable
-// oops.
+// Mark nmethods for unloading if they contain otherwise unreachable oops.
void CodeCache::do_unloading(BoolObjectClosure* is_alive, bool unloading_occurred) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_NMETHODS(nm) {
- nm->do_unloading(is_alive, unloading_occurred);
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ iter.method()->do_unloading(is_alive, unloading_occurred);
}
}
void CodeCache::blobs_do(CodeBlobClosure* f) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_BLOBS(cb) {
- f->do_code_blob(cb);
+ FOR_ALL_HEAPS(heap) {
+ FOR_ALL_BLOBS(cb, *heap) {
+ if (cb->is_alive()) {
+ f->do_code_blob(cb);
#ifdef ASSERT
- if (cb->is_nmethod())
- ((nmethod*)cb)->verify_scavenge_root_oops();
+ if (cb->is_nmethod())
+ ((nmethod*)cb)->verify_scavenge_root_oops();
#endif //ASSERT
+ }
+ }
}
}
@@ -453,44 +639,39 @@
// Temporarily mark nmethods that are claimed to be on the non-perm list.
void CodeCache::mark_scavenge_root_nmethods() {
- FOR_ALL_ALIVE_BLOBS(cb) {
- if (cb->is_nmethod()) {
- nmethod *nm = (nmethod*)cb;
- assert(nm->scavenge_root_not_marked(), "clean state");
- if (nm->on_scavenge_root_list())
- nm->set_scavenge_root_marked();
- }
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
+ assert(nm->scavenge_root_not_marked(), "clean state");
+ if (nm->on_scavenge_root_list())
+ nm->set_scavenge_root_marked();
}
}
// If the closure is given, run it on the unlisted nmethods.
// Also make sure that the effects of mark_scavenge_root_nmethods is gone.
void CodeCache::verify_perm_nmethods(CodeBlobClosure* f_or_null) {
- FOR_ALL_ALIVE_BLOBS(cb) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
bool call_f = (f_or_null != NULL);
- if (cb->is_nmethod()) {
- nmethod *nm = (nmethod*)cb;
- assert(nm->scavenge_root_not_marked(), "must be already processed");
- if (nm->on_scavenge_root_list())
- call_f = false; // don't show this one to the client
- nm->verify_scavenge_root_oops();
- } else {
- call_f = false; // not an nmethod
- }
- if (call_f) f_or_null->do_code_blob(cb);
+ assert(nm->scavenge_root_not_marked(), "must be already processed");
+ if (nm->on_scavenge_root_list())
+ call_f = false; // don't show this one to the client
+ nm->verify_scavenge_root_oops();
+ if (call_f) f_or_null->do_code_blob(nm);
}
}
#endif //PRODUCT
void CodeCache::verify_clean_inline_caches() {
#ifdef ASSERT
- FOR_ALL_ALIVE_BLOBS(cb) {
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
- assert(!nm->is_unloaded(), "Tautology");
- nm->verify_clean_inline_caches();
- nm->verify();
- }
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
+ assert(!nm->is_unloaded(), "Tautology");
+ nm->verify_clean_inline_caches();
+ nm->verify();
}
#endif
}
@@ -499,10 +680,12 @@
#ifdef ASSERT
// make sure that we aren't leaking icholders
int count = 0;
- FOR_ALL_BLOBS(cb) {
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
- count += nm->verify_icholder_relocations();
+ FOR_ALL_HEAPS(heap) {
+ FOR_ALL_BLOBS(cb, *heap) {
+ if (cb->is_nmethod()) {
+ nmethod* nm = (nmethod*)cb;
+ count += nm->verify_icholder_relocations();
+ }
}
}
@@ -516,16 +699,15 @@
void CodeCache::gc_epilogue() {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_BLOBS(cb) {
- if (cb->is_nmethod()) {
- nmethod *nm = (nmethod*)cb;
- assert(!nm->is_unloaded(), "Tautology");
- if (needs_cache_clean()) {
- nm->cleanup_inline_caches();
- }
- DEBUG_ONLY(nm->verify());
- DEBUG_ONLY(nm->verify_oop_relocations());
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
+ assert(!nm->is_unloaded(), "Tautology");
+ if (needs_cache_clean()) {
+ nm->cleanup_inline_caches();
}
+ DEBUG_ONLY(nm->verify());
+ DEBUG_ONLY(nm->verify_oop_relocations());
}
set_needs_cache_clean(false);
prune_scavenge_root_nmethods();
@@ -536,37 +718,94 @@
void CodeCache::verify_oops() {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
VerifyOopClosure voc;
- FOR_ALL_ALIVE_BLOBS(cb) {
- if (cb->is_nmethod()) {
- nmethod *nm = (nmethod*)cb;
- nm->oops_do(&voc);
- nm->verify_oop_relocations();
- }
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
+ nm->oops_do(&voc);
+ nm->verify_oop_relocations();
}
}
+size_t CodeCache::capacity() {
+ size_t cap = 0;
+ FOR_ALL_HEAPS(heap) {
+ cap += (*heap)->capacity();
+ }
+ return cap;
+}
-address CodeCache::first_address() {
- assert_locked_or_safepoint(CodeCache_lock);
- return (address)_heap->low_boundary();
+size_t CodeCache::unallocated_capacity(int code_blob_type) {
+ CodeHeap* heap = get_code_heap(code_blob_type);
+ return (heap != NULL) ? heap->unallocated_capacity() : 0;
}
+size_t CodeCache::unallocated_capacity() {
+ size_t unallocated_cap = 0;
+ FOR_ALL_HEAPS(heap) {
+ unallocated_cap += (*heap)->unallocated_capacity();
+ }
+ return unallocated_cap;
+}
-address CodeCache::last_address() {
- assert_locked_or_safepoint(CodeCache_lock);
- return (address)_heap->high();
+size_t CodeCache::max_capacity() {
+ size_t max_cap = 0;
+ FOR_ALL_HEAPS(heap) {
+ max_cap += (*heap)->max_capacity();
+ }
+ return max_cap;
}
/**
- * Returns the reverse free ratio. E.g., if 25% (1/4) of the code cache
+ * Returns true if a CodeHeap is full and sets code_blob_type accordingly.
+ */
+bool CodeCache::is_full(int* code_blob_type) {
+ FOR_ALL_HEAPS(heap) {
+ if ((*heap)->unallocated_capacity() < CodeCacheMinimumFreeSpace) {
+ *code_blob_type = (*heap)->code_blob_type();
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * Returns the reverse free ratio. E.g., if 25% (1/4) of the code heap
* is free, reverse_free_ratio() returns 4.
*/
-double CodeCache::reverse_free_ratio() {
- double unallocated_capacity = (double)(CodeCache::unallocated_capacity() - CodeCacheMinimumFreeSpace);
- double max_capacity = (double)CodeCache::max_capacity();
+double CodeCache::reverse_free_ratio(int code_blob_type) {
+ CodeHeap* heap = get_code_heap(code_blob_type);
+ if (heap == NULL) {
+ return 0;
+ }
+ double unallocated_capacity = (double)(heap->unallocated_capacity() - CodeCacheMinimumFreeSpace);
+ double max_capacity = (double)heap->max_capacity();
return max_capacity / unallocated_capacity;
}
+size_t CodeCache::bytes_allocated_in_freelists() {
+ size_t allocated_bytes = 0;
+ FOR_ALL_HEAPS(heap) {
+ allocated_bytes += (*heap)->allocated_in_freelist();
+ }
+ return allocated_bytes;
+}
+
+int CodeCache::allocated_segments() {
+ int number_of_segments = 0;
+ FOR_ALL_HEAPS(heap) {
+ number_of_segments += (*heap)->allocated_segments();
+ }
+ return number_of_segments;
+}
+
+size_t CodeCache::freelists_length() {
+ size_t length = 0;
+ FOR_ALL_HEAPS(heap) {
+ length += (*heap)->freelist_length();
+ }
+ return length;
+}
+
void icache_init();
void CodeCache::initialize() {
@@ -579,14 +818,16 @@
// the code cache to the page size. In particular, Solaris is moving to a larger
// default page size.
CodeCacheExpansionSize = round_to(CodeCacheExpansionSize, os::vm_page_size());
- InitialCodeCacheSize = round_to(InitialCodeCacheSize, os::vm_page_size());
- ReservedCodeCacheSize = round_to(ReservedCodeCacheSize, os::vm_page_size());
- if (!_heap->reserve(ReservedCodeCacheSize, InitialCodeCacheSize, CodeCacheSegmentSize)) {
- vm_exit_during_initialization("Could not reserve enough space for code cache");
+
+ if (SegmentedCodeCache) {
+ // Use multiple code heaps
+ initialize_heaps();
+ } else {
+ // Use a single code heap
+ ReservedCodeSpace rs = reserve_heap_memory(ReservedCodeCacheSize);
+ add_heap(rs, "CodeCache", InitialCodeCacheSize, CodeBlobType::All);
}
- MemoryService::add_code_heap_memory_pool(_heap);
-
// Initialize ICache flush mechanism
// This service is needed for os::register_code_area
icache_init();
@@ -594,10 +835,9 @@
// Give OS a chance to register generated code area.
// This is used on Windows 64 bit platforms to register
// Structured Exception Handlers for our generated code.
- os::register_code_area(_heap->low_boundary(), _heap->high_boundary());
+ os::register_code_area((char*)low_bound(), (char*)high_bound());
}
-
void codeCache_init() {
CodeCache::initialize();
}
@@ -610,8 +850,9 @@
void CodeCache::clear_inline_caches() {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_NMETHODS(nm) {
- nm->clear_inline_caches();
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ iter.method()->clear_inline_caches();
}
}
@@ -666,7 +907,9 @@
}
}
- FOR_ALL_ALIVE_NMETHODS(nm) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
if (nm->is_marked_for_deoptimization()) {
// ...Already marked in the previous pass; don't count it again.
} else if (nm->is_evol_dependent_on(dependee())) {
@@ -687,19 +930,22 @@
// Deoptimize all methods
void CodeCache::mark_all_nmethods_for_deoptimization() {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
- FOR_ALL_ALIVE_NMETHODS(nm) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
if (!nm->method()->is_method_handle_intrinsic()) {
nm->mark_for_deoptimization();
}
}
}
-
int CodeCache::mark_for_deoptimization(Method* dependee) {
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
int number_of_marked_CodeBlobs = 0;
- FOR_ALL_ALIVE_NMETHODS(nm) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
if (nm->is_dependent_on_method(dependee)) {
ResourceMark rm;
nm->mark_for_deoptimization();
@@ -712,7 +958,9 @@
void CodeCache::make_marked_nmethods_zombies() {
assert(SafepointSynchronize::is_at_safepoint(), "must be at a safepoint");
- FOR_ALL_ALIVE_NMETHODS(nm) {
+ 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
@@ -733,7 +981,9 @@
void CodeCache::make_marked_nmethods_not_entrant() {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_ALIVE_NMETHODS(nm) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
if (nm->is_marked_for_deoptimization()) {
nm->make_not_entrant();
}
@@ -741,23 +991,56 @@
}
void CodeCache::verify() {
- _heap->verify();
- FOR_ALL_ALIVE_BLOBS(p) {
- p->verify();
+ assert_locked_or_safepoint(CodeCache_lock);
+ FOR_ALL_HEAPS(heap) {
+ (*heap)->verify();
+ FOR_ALL_BLOBS(cb, *heap) {
+ if (cb->is_alive()) {
+ cb->verify();
+ }
+ }
}
}
-void CodeCache::report_codemem_full() {
+// A CodeHeap is full. Print out warning and report event.
+void CodeCache::report_codemem_full(int code_blob_type, bool print) {
+ // Get nmethod heap for the given CodeBlobType and build CodeCacheFull event
+ CodeHeap* heap = get_code_heap(code_blob_type);
+ assert(heap != NULL, "heap is null");
+
+ if (!heap->was_full() || print) {
+ // Not yet reported for this heap, report
+ heap->report_full();
+ if (SegmentedCodeCache) {
+ warning("%s is full. Compiler has been disabled.", CodeCache::get_code_heap_name(code_blob_type));
+ warning("Try increasing the code heap size using -XX:%s=",
+ (code_blob_type == CodeBlobType::MethodNonProfiled) ? "NonProfiledCodeHeapSize" : "ProfiledCodeHeapSize");
+ } else {
+ warning("CodeCache is full. Compiler has been disabled.");
+ warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
+ }
+ ResourceMark rm;
+ stringStream s;
+ // Dump code cache into a buffer before locking the tty,
+ {
+ MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+ print_summary(&s);
+ }
+ ttyLocker ttyl;
+ tty->print("%s", s.as_string());
+ }
+
_codemem_full_count++;
EventCodeCacheFull event;
if (event.should_commit()) {
- event.set_startAddress((u8)low_bound());
- event.set_commitedTopAddress((u8)high());
- event.set_reservedTopAddress((u8)high_bound());
+ event.set_codeBlobType((u1)code_blob_type);
+ event.set_startAddress((u8)heap->low_boundary());
+ event.set_commitedTopAddress((u8)heap->high());
+ event.set_reservedTopAddress((u8)heap->high_boundary());
event.set_entryCount(nof_blobs());
event.set_methodCount(nof_nmethods());
event.set_adaptorCount(nof_adapters());
- event.set_unallocatedCapacity(unallocated_capacity()/K);
+ event.set_unallocatedCapacity(heap->unallocated_capacity()/K);
event.set_fullCount(_codemem_full_count);
event.commit();
}
@@ -765,15 +1048,17 @@
void CodeCache::print_memory_overhead() {
size_t wasted_bytes = 0;
- CodeBlob *cb;
- for (cb = first(); cb != NULL; cb = next(cb)) {
- HeapBlock* heap_block = ((HeapBlock*)cb) - 1;
- wasted_bytes += heap_block->length() * CodeCacheSegmentSize - cb->size();
+ FOR_ALL_HEAPS(heap) {
+ CodeHeap* curr_heap = *heap;
+ for (CodeBlob* cb = (CodeBlob*)curr_heap->first(); cb != NULL; cb = (CodeBlob*)curr_heap->next(cb)) {
+ HeapBlock* heap_block = ((HeapBlock*)cb) - 1;
+ wasted_bytes += heap_block->length() * CodeCacheSegmentSize - cb->size();
+ }
}
// Print bytes that are allocated in the freelist
ttyLocker ttl;
- tty->print_cr("Number of elements in freelist: " SSIZE_FORMAT, freelist_length());
- tty->print_cr("Allocated in freelist: " SSIZE_FORMAT "kB", bytes_allocated_in_freelist()/K);
+ tty->print_cr("Number of elements in freelist: " SSIZE_FORMAT, freelists_length());
+ tty->print_cr("Allocated in freelist: " SSIZE_FORMAT "kB", bytes_allocated_in_freelists()/K);
tty->print_cr("Unused bytes in CodeBlobs: " SSIZE_FORMAT "kB", (wasted_bytes/K));
tty->print_cr("Segment map size: " SSIZE_FORMAT "kB", allocated_segments()/K); // 1 byte per segment
}
@@ -808,43 +1093,48 @@
int max_nm_size = 0;
ResourceMark rm;
- CodeBlob *cb;
- for (cb = first(); cb != NULL; cb = next(cb)) {
- total++;
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
+ int i = 0;
+ FOR_ALL_HEAPS(heap) {
+ if (SegmentedCodeCache && Verbose) {
+ tty->print_cr("-- %s --", (*heap)->name());
+ }
+ FOR_ALL_BLOBS(cb, *heap) {
+ total++;
+ if (cb->is_nmethod()) {
+ nmethod* nm = (nmethod*)cb;
- if (Verbose && nm->method() != NULL) {
- ResourceMark rm;
- char *method_name = nm->method()->name_and_sig_as_C_string();
- tty->print("%s", method_name);
- if(nm->is_alive()) { tty->print_cr(" alive"); }
- if(nm->is_not_entrant()) { tty->print_cr(" not-entrant"); }
- if(nm->is_zombie()) { tty->print_cr(" zombie"); }
- }
+ if (Verbose && nm->method() != NULL) {
+ ResourceMark rm;
+ char *method_name = nm->method()->name_and_sig_as_C_string();
+ tty->print("%s", method_name);
+ if(nm->is_alive()) { tty->print_cr(" alive"); }
+ if(nm->is_not_entrant()) { tty->print_cr(" not-entrant"); }
+ if(nm->is_zombie()) { tty->print_cr(" zombie"); }
+ }
- nmethodCount++;
+ nmethodCount++;
- if(nm->is_alive()) { nmethodAlive++; }
- if(nm->is_not_entrant()) { nmethodNotEntrant++; }
- if(nm->is_zombie()) { nmethodZombie++; }
- if(nm->is_unloaded()) { nmethodUnloaded++; }
- if(nm->method() != NULL && nm->is_native_method()) { nmethodNative++; }
+ if(nm->is_alive()) { nmethodAlive++; }
+ if(nm->is_not_entrant()) { nmethodNotEntrant++; }
+ if(nm->is_zombie()) { nmethodZombie++; }
+ if(nm->is_unloaded()) { nmethodUnloaded++; }
+ if(nm->method() != NULL && nm->is_native_method()) { nmethodNative++; }
- if(nm->method() != NULL && nm->is_java_method()) {
- nmethodJava++;
- max_nm_size = MAX2(max_nm_size, nm->size());
+ if(nm->method() != NULL && nm->is_java_method()) {
+ nmethodJava++;
+ max_nm_size = MAX2(max_nm_size, nm->size());
+ }
+ } else if (cb->is_runtime_stub()) {
+ runtimeStubCount++;
+ } else if (cb->is_deoptimization_stub()) {
+ deoptimizationStubCount++;
+ } else if (cb->is_uncommon_trap_stub()) {
+ uncommonTrapStubCount++;
+ } else if (cb->is_adapter_blob()) {
+ adapterCount++;
+ } else if (cb->is_buffer_blob()) {
+ bufferBlobCount++;
}
- } else if (cb->is_runtime_stub()) {
- runtimeStubCount++;
- } else if (cb->is_deoptimization_stub()) {
- deoptimizationStubCount++;
- } else if (cb->is_uncommon_trap_stub()) {
- uncommonTrapStubCount++;
- } else if (cb->is_adapter_blob()) {
- adapterCount++;
- } else if (cb->is_buffer_blob()) {
- bufferBlobCount++;
}
}
@@ -853,12 +1143,11 @@
int *buckets = NEW_C_HEAP_ARRAY(int, bucketLimit, mtCode);
memset(buckets, 0, sizeof(int) * bucketLimit);
- for (cb = first(); cb != NULL; cb = next(cb)) {
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
- if(nm->is_java_method()) {
- buckets[nm->size() / bucketSize]++;
- }
+ NMethodIterator iter;
+ while(iter.next()) {
+ nmethod* nm = iter.method();
+ if(nm->method() != NULL && nm->is_java_method()) {
+ buckets[nm->size() / bucketSize]++;
}
}
@@ -902,11 +1191,13 @@
CodeBlob_sizes live;
CodeBlob_sizes dead;
- FOR_ALL_BLOBS(p) {
- if (!p->is_alive()) {
- dead.add(p);
- } else {
- live.add(p);
+ FOR_ALL_HEAPS(heap) {
+ FOR_ALL_BLOBS(cb, *heap) {
+ if (!cb->is_alive()) {
+ dead.add(cb);
+ } else {
+ live.add(cb);
+ }
}
}
@@ -920,21 +1211,22 @@
dead.print("dead");
}
-
if (WizardMode) {
// print the oop_map usage
int code_size = 0;
int number_of_blobs = 0;
int number_of_oop_maps = 0;
int map_size = 0;
- FOR_ALL_BLOBS(p) {
- if (p->is_alive()) {
- number_of_blobs++;
- code_size += p->code_size();
- OopMapSet* set = p->oop_maps();
- if (set != NULL) {
- number_of_oop_maps += set->size();
- map_size += set->heap_size();
+ FOR_ALL_HEAPS(heap) {
+ FOR_ALL_BLOBS(cb, *heap) {
+ if (cb->is_alive()) {
+ number_of_blobs++;
+ code_size += cb->code_size();
+ OopMapSet* set = cb->oop_maps();
+ if (set != NULL) {
+ number_of_oop_maps += set->size();
+ map_size += set->heap_size();
+ }
}
}
}
@@ -949,20 +1241,31 @@
}
void CodeCache::print_summary(outputStream* st, bool detailed) {
- size_t total = (_heap->high_boundary() - _heap->low_boundary());
- st->print_cr("CodeCache: size=" SIZE_FORMAT "Kb used=" SIZE_FORMAT
- "Kb max_used=" SIZE_FORMAT "Kb free=" SIZE_FORMAT "Kb",
- total/K, (total - unallocated_capacity())/K,
- maxCodeCacheUsed/K, unallocated_capacity()/K);
+ FOR_ALL_HEAPS(heap_iterator) {
+ CodeHeap* heap = (*heap_iterator);
+ size_t total = (heap->high_boundary() - heap->low_boundary());
+ if (SegmentedCodeCache) {
+ st->print("%s:", heap->name());
+ } else {
+ st->print("CodeCache:");
+ }
+ st->print_cr(" size=" SIZE_FORMAT "Kb used=" SIZE_FORMAT
+ "Kb max_used=" SIZE_FORMAT "Kb free=" SIZE_FORMAT "Kb",
+ total/K, (total - heap->unallocated_capacity())/K,
+ heap->max_allocated_capacity()/K, heap->unallocated_capacity()/K);
+
+ if (detailed) {
+ st->print_cr(" bounds [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT "]",
+ p2i(heap->low_boundary()),
+ p2i(heap->high()),
+ p2i(heap->high_boundary()));
+ }
+ }
if (detailed) {
- st->print_cr(" bounds [" INTPTR_FORMAT ", " INTPTR_FORMAT ", " INTPTR_FORMAT "]",
- p2i(_heap->low_boundary()),
- p2i(_heap->high()),
- p2i(_heap->high_boundary()));
st->print_cr(" total_blobs=" UINT32_FORMAT " nmethods=" UINT32_FORMAT
- " adapters=" UINT32_FORMAT,
- nof_blobs(), nof_nmethods(), nof_adapters());
+ " adapters=" UINT32_FORMAT,
+ nof_blobs(), nof_nmethods(), nof_adapters());
st->print_cr(" compilation: %s", CompileBroker::should_compile_new_jobs() ?
"enabled" : Arguments::mode() == Arguments::_int ?
"disabled (interpreter mode)" :
@@ -973,12 +1276,14 @@
void CodeCache::print_codelist(outputStream* st) {
assert_locked_or_safepoint(CodeCache_lock);
- FOR_ALL_NMETHODS(p) {
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* nm = iter.method();
ResourceMark rm;
- char *method_name = p->method()->name_and_sig_as_C_string();
+ char *method_name = nm->method()->name_and_sig_as_C_string();
st->print_cr("%d %d %s ["INTPTR_FORMAT", "INTPTR_FORMAT" - "INTPTR_FORMAT"]",
- p->compile_id(), p->comp_level(), method_name, (intptr_t)p->header_begin(),
- (intptr_t)p->code_begin(), (intptr_t)p->code_end());
+ nm->compile_id(), nm->comp_level(), method_name, (intptr_t)nm->header_begin(),
+ (intptr_t)nm->code_begin(), (intptr_t)nm->code_end());
}
}
@@ -995,4 +1300,3 @@
nof_blobs(), nof_nmethods(), nof_adapters(),
unallocated_capacity());
}
-
--- a/hotspot/src/share/vm/code/codeCache.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/codeCache.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -26,105 +26,117 @@
#define SHARE_VM_CODE_CODECACHE_HPP
#include "code/codeBlob.hpp"
+#include "code/nmethod.hpp"
#include "memory/allocation.hpp"
#include "memory/heap.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/oopsHierarchy.hpp"
+#include "runtime/mutexLocker.hpp"
// The CodeCache implements the code cache for various pieces of generated
// code, e.g., compiled java methods, runtime stubs, transition frames, etc.
// The entries in the CodeCache are all CodeBlob's.
-// Implementation:
-// - Each CodeBlob occupies one chunk of memory.
-// - Like the offset table in oldspace the zone has at table for
-// locating a method given a addess of an instruction.
+// -- Implementation --
+// The CodeCache consists of one or more CodeHeaps, each of which contains
+// CodeBlobs of a specific CodeBlobType. Currently heaps for the following
+// types are available:
+// - Non-nmethods: Non-nmethods like Buffers, Adapters and Runtime Stubs
+// - Profiled nmethods: nmethods that are profiled, i.e., those
+// executed at level 2 or 3
+// - Non-Profiled nmethods: nmethods that are not profiled, i.e., those
+// executed at level 1 or 4 and native methods
+// - All: Used for code of all types if code cache segmentation is disabled.
+//
+// In the rare case of the non-nmethod code heap getting full, non-nmethod code
+// will be stored in the non-profiled code heap as a fallback solution.
+//
+// Depending on the availability of compilers and TieredCompilation there
+// may be fewer heaps. The size of the code heaps depends on the values of
+// ReservedCodeCacheSize, NonProfiledCodeHeapSize and ProfiledCodeHeapSize
+// (see CodeCache::heap_available(..) and CodeCache::initialize_heaps(..)
+// for details).
+//
+// Code cache segmentation is controlled by the flag SegmentedCodeCache.
+// If turned off, all code types are stored in a single code heap. By default
+// code cache segmentation is turned on if TieredCompilation is enabled and
+// ReservedCodeCacheSize >= 240 MB.
+//
+// All methods of the CodeCache accepting a CodeBlobType only apply to
+// CodeBlobs of the given type. For example, iteration over the
+// CodeBlobs of a specific type can be done by using CodeCache::first_blob(..)
+// and CodeCache::next_blob(..) and providing the corresponding CodeBlobType.
+//
+// IMPORTANT: If you add new CodeHeaps to the code cache or change the
+// existing ones, make sure to adapt the dtrace scripts (jhelper.d) for
+// Solaris and BSD.
class OopClosure;
class DepChange;
class CodeCache : AllStatic {
friend class VMStructs;
+ friend class NMethodIterator;
private:
- // CodeHeap is malloc()'ed at startup and never deleted during shutdown,
- // so that the generated assembly code is always there when it's needed.
- // This may cause memory leak, but is necessary, for now. See 4423824,
- // 4422213 or 4436291 for details.
- static CodeHeap * _heap;
- static int _number_of_blobs;
- static int _number_of_adapters;
- static int _number_of_nmethods;
- static int _number_of_nmethods_with_dependencies;
- static bool _needs_cache_clean;
- static nmethod* _scavenge_root_nmethods; // linked via nm->scavenge_root_link()
+ // CodeHeaps of the cache
+ static GrowableArray<CodeHeap*>* _heaps;
+
+ static address _low_bound; // Lower bound of CodeHeap addresses
+ static address _high_bound; // Upper bound of CodeHeap addresses
+ static int _number_of_blobs; // Total number of CodeBlobs in the cache
+ static int _number_of_adapters; // Total number of Adapters in the cache
+ static int _number_of_nmethods; // Total number of nmethods in the cache
+ static int _number_of_nmethods_with_dependencies; // Total number of nmethods with dependencies
+ static bool _needs_cache_clean; // True if inline caches of the nmethods needs to be flushed
+ static nmethod* _scavenge_root_nmethods; // linked via nm->scavenge_root_link()
+ static int _codemem_full_count; // Number of times a CodeHeap in the cache was full
static void mark_scavenge_root_nmethods() PRODUCT_RETURN;
static void verify_perm_nmethods(CodeBlobClosure* f_or_null) PRODUCT_RETURN;
- static int _codemem_full_count;
- static size_t bytes_allocated_in_freelist() { return _heap->allocated_in_freelist(); }
- static int allocated_segments() { return _heap->allocated_segments(); }
- static size_t freelist_length() { return _heap->freelist_length(); }
+ // CodeHeap management
+ static void initialize_heaps(); // Initializes the CodeHeaps
+ // Creates a new heap with the given name and size, containing CodeBlobs of the given type
+ static void add_heap(ReservedSpace rs, const char* name, size_t size_initial, int code_blob_type);
+ static CodeHeap* get_code_heap(CodeBlob* cb); // Returns the CodeHeap for the given CodeBlob
+ static CodeHeap* get_code_heap(int code_blob_type); // Returns the CodeHeap for the given CodeBlobType
+ static bool heap_available(int code_blob_type); // Returns true if an own CodeHeap for the given CodeBlobType is available
+ static ReservedCodeSpace reserve_heap_memory(size_t size); // Reserves one continuous chunk of memory for the CodeHeaps
+
+ // Iteration
+ static CodeBlob* first_blob(CodeHeap* heap); // Returns the first CodeBlob on the given CodeHeap
+ static CodeBlob* first_blob(int code_blob_type); // Returns the first CodeBlob of the given type
+ static CodeBlob* next_blob(CodeHeap* heap, CodeBlob* cb); // Returns the first alive CodeBlob on the given CodeHeap
+ static CodeBlob* next_blob(CodeBlob* cb); // Returns the next CodeBlob of the given type succeeding the given CodeBlob
+
+ static size_t bytes_allocated_in_freelists();
+ static int allocated_segments();
+ static size_t freelists_length();
public:
-
// Initialization
static void initialize();
- static void report_codemem_full();
-
// Allocation/administration
- static CodeBlob* allocate(int size, bool is_critical = false); // allocates a new CodeBlob
- static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled
- static int alignment_unit(); // guaranteed alignment of all CodeBlobs
- static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
- static void free(CodeBlob* cb); // frees a CodeBlob
- static bool contains(void *p); // returns whether p is included
- static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs
- static void blobs_do(CodeBlobClosure* f); // iterates over all CodeBlobs
- static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods
- static void alive_nmethods_do(void f(nmethod* nm)); // iterates over all alive nmethods
+ static CodeBlob* allocate(int size, int code_blob_type, bool is_critical = false); // allocates a new CodeBlob
+ static void commit(CodeBlob* cb); // called when the allocated CodeBlob has been filled
+ static int alignment_unit(); // guaranteed alignment of all CodeBlobs
+ static int alignment_offset(); // guaranteed offset of first CodeBlob byte within alignment unit (i.e., allocation header)
+ static void free(CodeBlob* cb); // frees a CodeBlob
+ static bool contains(void *p); // returns whether p is included
+ static void blobs_do(void f(CodeBlob* cb)); // iterates over all CodeBlobs
+ static void blobs_do(CodeBlobClosure* f); // iterates over all CodeBlobs
+ static void nmethods_do(void f(nmethod* nm)); // iterates over all nmethods
+ static void alive_nmethods_do(void f(nmethod* nm)); // iterates over all alive nmethods
// Lookup
- static CodeBlob* find_blob(void* start);
- static nmethod* find_nmethod(void* start);
-
- // Lookup that does not fail if you lookup a zombie method (if you call this, be sure to know
- // what you are doing)
- static CodeBlob* find_blob_unsafe(void* start) {
- // NMT can walk the stack before code cache is created
- if (_heap == NULL) return NULL;
+ static CodeBlob* find_blob(void* start); // Returns the CodeBlob containing the given address
+ static CodeBlob* find_blob_unsafe(void* start); // Same as find_blob but does not fail if looking up a zombie method
+ static nmethod* find_nmethod(void* start); // Returns the nmethod containing the given address
- CodeBlob* result = (CodeBlob*)_heap->find_start(start);
- // this assert is too strong because the heap code will return the
- // heapblock containing start. That block can often be larger than
- // the codeBlob itself. If you look up an address that is within
- // the heapblock but not in the codeBlob you will assert.
- //
- // Most things will not lookup such bad addresses. However
- // AsyncGetCallTrace can see intermediate frames and get that kind
- // of invalid address and so can a developer using hsfind.
- //
- // The more correct answer is to return NULL if blob_contains() returns
- // false.
- // assert(result == NULL || result->blob_contains((address)start), "found wrong CodeBlob");
-
- if (result != NULL && !result->blob_contains((address)start)) {
- result = NULL;
- }
- return result;
- }
-
- // Iteration
- static CodeBlob* first();
- static CodeBlob* next (CodeBlob* cb);
- static CodeBlob* alive(CodeBlob *cb);
- static nmethod* alive_nmethod(CodeBlob *cb);
- static nmethod* first_nmethod();
- static nmethod* next_nmethod (CodeBlob* cb);
- static int nof_blobs() { return _number_of_blobs; }
- static int nof_adapters() { return _number_of_adapters; }
- static int nof_nmethods() { return _number_of_nmethods; }
+ static int nof_blobs() { return _number_of_blobs; } // Returns the total number of CodeBlobs in the cache
+ static int nof_adapters() { return _number_of_adapters; } // Returns the total number of Adapters in the cache
+ static int nof_nmethods() { return _number_of_nmethods; } // Returns the total number of nmethods in the cache
// GC support
static void gc_epilogue();
@@ -137,7 +149,7 @@
static void asserted_non_scavengable_nmethods_do(CodeBlobClosure* f = NULL) PRODUCT_RETURN;
static void scavenge_root_nmethods_do(CodeBlobClosure* f);
- static nmethod* scavenge_root_nmethods() { return _scavenge_root_nmethods; }
+ static nmethod* scavenge_root_nmethods() { return _scavenge_root_nmethods; }
static void set_scavenge_root_nmethods(nmethod* nm) { _scavenge_root_nmethods = nm; }
static void add_scavenge_root_nmethod(nmethod* nm);
static void drop_scavenge_root_nmethod(nmethod* nm);
@@ -151,27 +163,45 @@
static void print_trace(const char* event, CodeBlob* cb, int size = 0) PRODUCT_RETURN;
static void print_summary(outputStream* st, bool detailed = true); // Prints a summary of the code cache usage
static void log_state(outputStream* st);
+ static const char* get_code_heap_name(int code_blob_type) { return (heap_available(code_blob_type) ? get_code_heap(code_blob_type)->name() : "Unused"); }
+ static void report_codemem_full(int code_blob_type, bool print);
// Dcmd (Diagnostic commands)
static void print_codelist(outputStream* st);
static void print_layout(outputStream* st);
// The full limits of the codeCache
- static address low_bound() { return (address) _heap->low_boundary(); }
- static address high_bound() { return (address) _heap->high_boundary(); }
- static address high() { return (address) _heap->high(); }
+ static address low_bound() { return _low_bound; }
+ static address high_bound() { return _high_bound; }
// Profiling
- static address first_address(); // first address used for CodeBlobs
- static address last_address(); // last address used for CodeBlobs
- static size_t capacity() { return _heap->capacity(); }
- static size_t max_capacity() { return _heap->max_capacity(); }
- static size_t unallocated_capacity() { return _heap->unallocated_capacity(); }
- static double reverse_free_ratio();
+ static size_t capacity();
+ static size_t unallocated_capacity(int code_blob_type);
+ static size_t unallocated_capacity();
+ static size_t max_capacity();
+
+ static bool is_full(int* code_blob_type);
+ static double reverse_free_ratio(int code_blob_type);
+
+ static bool needs_cache_clean() { return _needs_cache_clean; }
+ static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; }
+ static void clear_inline_caches(); // clear all inline caches
- static bool needs_cache_clean() { return _needs_cache_clean; }
- static void set_needs_cache_clean(bool v) { _needs_cache_clean = v; }
- static void clear_inline_caches(); // clear all inline caches
+ // Returns the CodeBlobType for nmethods of the given compilation level
+ static int get_code_blob_type(int comp_level) {
+ if (comp_level == CompLevel_none ||
+ comp_level == CompLevel_simple ||
+ comp_level == CompLevel_full_optimization) {
+ // Non profiled methods
+ return CodeBlobType::MethodNonProfiled;
+ } else if (comp_level == CompLevel_limited_profile ||
+ comp_level == CompLevel_full_profile) {
+ // Profiled methods
+ return CodeBlobType::MethodProfiled;
+ }
+ ShouldNotReachHere();
+ return 0;
+ }
static void verify_clean_inline_caches();
static void verify_icholder_relocations();
@@ -187,10 +217,87 @@
static void make_marked_nmethods_zombies();
static void make_marked_nmethods_not_entrant();
- // tells how many nmethods have dependencies
+ // tells how many nmethods have dependencies
static int number_of_nmethods_with_dependencies();
static int get_codemem_full_count() { return _codemem_full_count; }
};
+
+// Iterator to iterate over nmethods in the CodeCache.
+class NMethodIterator : public StackObj {
+ private:
+ CodeBlob* _code_blob; // Current CodeBlob
+ int _code_blob_type; // Refers to current CodeHeap
+
+ public:
+ NMethodIterator() {
+ initialize(NULL); // Set to NULL, initialized by first call to next()
+ }
+
+ NMethodIterator(nmethod* nm) {
+ initialize(nm);
+ }
+
+ // Advance iterator to next nmethod
+ bool next() {
+ assert_locked_or_safepoint(CodeCache_lock);
+ assert(_code_blob_type < CodeBlobType::NumTypes, "end reached");
+
+ bool result = next_nmethod();
+ while (!result && (_code_blob_type < CodeBlobType::MethodProfiled)) {
+ // Advance to next code heap if segmented code cache
+ _code_blob_type++;
+ result = next_nmethod();
+ }
+ return result;
+ }
+
+ // Advance iterator to next alive nmethod
+ bool next_alive() {
+ bool result = next();
+ while(result && !_code_blob->is_alive()) {
+ result = next();
+ }
+ return result;
+ }
+
+ bool end() const { return _code_blob == NULL; }
+ nmethod* method() const { return (nmethod*)_code_blob; }
+
+private:
+ // Initialize iterator to given nmethod
+ void initialize(nmethod* nm) {
+ _code_blob = (CodeBlob*)nm;
+ if (!SegmentedCodeCache) {
+ // Iterate over all CodeBlobs
+ _code_blob_type = CodeBlobType::All;
+ } else if (nm != NULL) {
+ _code_blob_type = CodeCache::get_code_blob_type(nm->comp_level());
+ } else {
+ // Only iterate over method code heaps, starting with non-profiled
+ _code_blob_type = CodeBlobType::MethodNonProfiled;
+ }
+ }
+
+ // Advance iterator to the next nmethod in the current code heap
+ bool next_nmethod() {
+ // Get first method CodeBlob
+ if (_code_blob == NULL) {
+ _code_blob = CodeCache::first_blob(_code_blob_type);
+ if (_code_blob == NULL) {
+ return false;
+ } else if (_code_blob->is_nmethod()) {
+ return true;
+ }
+ }
+ // Search for next method CodeBlob
+ _code_blob = CodeCache::next_blob(_code_blob);
+ while (_code_blob != NULL && !_code_blob->is_nmethod()) {
+ _code_blob = CodeCache::next_blob(_code_blob);
+ }
+ return _code_blob != NULL;
+ }
+};
+
#endif // SHARE_VM_CODE_CODECACHE_HPP
--- a/hotspot/src/share/vm/code/compiledIC.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/compiledIC.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -155,6 +155,14 @@
return _ic_call->destination();
}
+// Clears the IC stub if the compiled IC is in transition state
+void CompiledIC::clear_ic_stub() {
+ if (is_in_transition_state()) {
+ ICStub* stub = ICStub_from_destination_address(stub_address());
+ stub->clear();
+ }
+}
+
//-----------------------------------------------------------------------------
// High-level access to an inline cache. Guaranteed to be MT-safe.
@@ -333,10 +341,7 @@
if (safe_transition) {
// Kill any leftover stub we might have too
- if (is_in_transition_state()) {
- ICStub* old_stub = ICStub_from_destination_address(stub_address());
- old_stub->clear();
- }
+ clear_ic_stub();
if (is_optimized()) {
set_ic_destination(entry);
} else {
--- a/hotspot/src/share/vm/code/compiledIC.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/compiledIC.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -216,6 +216,7 @@
//
void set_to_clean(); // Can only be called during a safepoint operation
void set_to_monomorphic(CompiledICInfo& info);
+ void clear_ic_stub();
// Returns true if successful and false otherwise. The call can fail if memory
// allocation in the code cache fails.
--- a/hotspot/src/share/vm/code/dependencies.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/dependencies.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -567,12 +567,16 @@
what = "object ";
}
tty->print(" %s = %s", what, (put_star? "*": ""));
- if (arg.is_klass())
+ if (arg.is_klass()) {
tty->print("%s", ((Klass*)arg.metadata_value())->external_name());
- else if (arg.is_method())
+ } else if (arg.is_method()) {
((Method*)arg.metadata_value())->print_value();
- else
+ } else if (arg.is_oop()) {
+ arg.oop_value()->print_value_on(tty);
+ } else {
ShouldNotReachHere(); // Provide impl for this type.
+ }
+
tty->cr();
}
if (witness != NULL) {
@@ -609,7 +613,11 @@
int nargs = argument_count();
GrowableArray<DepArgument>* args = new GrowableArray<DepArgument>(nargs);
for (int j = 0; j < nargs; j++) {
- args->push(argument(j));
+ if (type() == call_site_target_value) {
+ args->push(argument_oop(j));
+ } else {
+ args->push(argument(j));
+ }
}
int argslen = args->length();
Dependencies::print_dependency(type(), args, witness);
--- a/hotspot/src/share/vm/code/nmethod.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/nmethod.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -500,7 +500,7 @@
CodeOffsets offsets;
offsets.set_value(CodeOffsets::Verified_Entry, vep_offset);
offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);
- nm = new (native_nmethod_size) nmethod(method(), native_nmethod_size,
+ nm = new (native_nmethod_size, CompLevel_none) nmethod(method(), native_nmethod_size,
compile_id, &offsets,
code_buffer, frame_size,
basic_lock_owner_sp_offset,
@@ -538,7 +538,7 @@
offsets.set_value(CodeOffsets::Dtrace_trap, trap_offset);
offsets.set_value(CodeOffsets::Frame_Complete, frame_complete);
- nm = new (nmethod_size) nmethod(method(), nmethod_size,
+ nm = new (nmethod_size, CompLevel_none) nmethod(method(), nmethod_size,
&offsets, code_buffer, frame_size);
NOT_PRODUCT(if (nm != NULL) nmethod_stats.note_nmethod(nm));
@@ -586,7 +586,7 @@
+ round_to(nul_chk_table->size_in_bytes(), oopSize)
+ round_to(debug_info->data_size() , oopSize);
- nm = new (nmethod_size)
+ nm = new (nmethod_size, comp_level)
nmethod(method(), nmethod_size, compile_id, entry_bci, offsets,
orig_pc_offset, debug_info, dependencies, code_buffer, frame_size,
oop_maps,
@@ -803,9 +803,11 @@
}
#endif // def HAVE_DTRACE_H
-void* nmethod::operator new(size_t size, int nmethod_size) throw() {
- // Not critical, may return null if there is too little continuous memory
- return CodeCache::allocate(nmethod_size);
+void* nmethod::operator new(size_t size, int nmethod_size, int comp_level) throw () {
+ // With a SegmentedCodeCache, nmethods are allocated on separate heaps and therefore do not share memory
+ // with critical CodeBlobs. We define the allocation as critical to make sure all code heap memory is used.
+ bool is_critical = SegmentedCodeCache;
+ return CodeCache::allocate(nmethod_size, CodeCache::get_code_blob_type(comp_level), is_critical);
}
nmethod::nmethod(
@@ -1128,6 +1130,18 @@
}
}
+// Clear ICStubs of all compiled ICs
+void nmethod::clear_ic_stubs() {
+ assert_locked_or_safepoint(CompiledIC_lock);
+ RelocIterator iter(this);
+ while(iter.next()) {
+ if (iter.type() == relocInfo::virtual_call_type) {
+ CompiledIC* ic = CompiledIC_at(&iter);
+ ic->clear_ic_stub();
+ }
+ }
+}
+
void nmethod::cleanup_inline_caches() {
@@ -1530,7 +1544,7 @@
Events::log(JavaThread::current(), "flushing nmethod " INTPTR_FORMAT, this);
if (PrintMethodFlushing) {
tty->print_cr("*flushing nmethod %3d/" INTPTR_FORMAT ". Live blobs:" UINT32_FORMAT "/Free CodeCache:" SIZE_FORMAT "Kb",
- _compile_id, this, CodeCache::nof_blobs(), CodeCache::unallocated_capacity()/1024);
+ _compile_id, this, CodeCache::nof_blobs(), CodeCache::unallocated_capacity(CodeCache::get_code_blob_type(_comp_level))/1024);
}
// We need to deallocate any ExceptionCache data.
@@ -1557,7 +1571,6 @@
CodeCache::free(this);
}
-
//
// Notify all classes this nmethod is dependent on that it is no
// longer dependent. This should only be called in two situations.
@@ -2418,15 +2431,18 @@
// Turn off dependency tracing while actually testing dependencies.
NOT_PRODUCT( FlagSetting fs(TraceDependencies, false) );
- typedef ResourceHashtable<DependencySignature, int, &DependencySignature::hash,
- &DependencySignature::equals, 11027> DepTable;
-
- DepTable* table = new DepTable();
+ typedef ResourceHashtable<DependencySignature, int, &DependencySignature::hash,
+ &DependencySignature::equals, 11027> DepTable;
+
+ DepTable* table = new DepTable();
// Iterate over live nmethods and check dependencies of all nmethods that are not
// marked for deoptimization. A particular dependency is only checked once.
- for(nmethod* nm = CodeCache::alive_nmethod(CodeCache::first()); nm != NULL; nm = CodeCache::alive_nmethod(CodeCache::next(nm))) {
- if (!nm->is_marked_for_deoptimization()) {
+ NMethodIterator iter;
+ while(iter.next()) {
+ nmethod* nm = iter.method();
+ // Only notify for live nmethods
+ if (nm->is_alive() && !nm->is_marked_for_deoptimization()) {
for (Dependencies::DepStream deps(nm); deps.next(); ) {
// Construct abstraction of a dependency.
DependencySignature* current_sig = new DependencySignature(deps);
--- a/hotspot/src/share/vm/code/nmethod.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/nmethod.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -288,7 +288,7 @@
int comp_level);
// helper methods
- void* operator new(size_t size, int nmethod_size) throw();
+ void* operator new(size_t size, int nmethod_size, int comp_level) throw();
const char* reloc_string_for(u_char* begin, u_char* end);
// Returns true if this thread changed the state of the nmethod or
@@ -577,6 +577,7 @@
// Inline cache support
void clear_inline_caches();
+ void clear_ic_stubs();
void cleanup_inline_caches();
bool inlinecache_check_contains(address addr) const {
return (addr >= code_begin() && addr < verified_entry_point());
--- a/hotspot/src/share/vm/code/vtableStubs.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/code/vtableStubs.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -63,7 +63,7 @@
// If changing the name, update the other file accordingly.
BufferBlob* blob = BufferBlob::create("vtable chunks", bytes);
if (blob == NULL) {
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return NULL;
}
_chunk = blob->content_begin();
--- a/hotspot/src/share/vm/compiler/compileBroker.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/compiler/compileBroker.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -137,6 +137,8 @@
elapsedTimer CompileBroker::_t_total_compilation;
elapsedTimer CompileBroker::_t_osr_compilation;
elapsedTimer CompileBroker::_t_standard_compilation;
+elapsedTimer CompileBroker::_t_invalidated_compilation;
+elapsedTimer CompileBroker::_t_bailedout_compilation;
int CompileBroker::_total_bailout_count = 0;
int CompileBroker::_total_invalidated_count = 0;
@@ -783,18 +785,22 @@
void CompileBroker::print_compile_queues(outputStream* st) {
- _c1_compile_queue->print(st);
- _c2_compile_queue->print(st);
+ MutexLocker locker(MethodCompileQueue_lock);
+ if (_c1_compile_queue != NULL) {
+ _c1_compile_queue->print(st);
+ }
+ if (_c2_compile_queue != NULL) {
+ _c2_compile_queue->print(st);
+ }
}
-
void CompileQueue::print(outputStream* st) {
- assert_locked_or_safepoint(lock());
+ assert(lock()->owned_by_self(), "must own lock");
st->print_cr("Contents of %s", name());
st->print_cr("----------------------------");
CompileTask* task = _first;
if (task == NULL) {
- st->print_cr("Empty");;
+ st->print_cr("Empty");
} else {
while (task != NULL) {
task->print_compilation(st, NULL, true, true);
@@ -1206,6 +1212,12 @@
return;
}
+ if (TieredCompilation) {
+ // Tiered policy requires MethodCounters to exist before adding a method to
+ // the queue. Create if we don't have them yet.
+ method->get_method_counters(thread);
+ }
+
// Outputs from the following MutexLocker block:
CompileTask* task = NULL;
bool blocking = false;
@@ -1747,9 +1759,11 @@
// We need this HandleMark to avoid leaking VM handles.
HandleMark hm(thread);
- if (CodeCache::unallocated_capacity() < CodeCacheMinimumFreeSpace) {
- // the code cache is really full
- handle_full_code_cache();
+ // Check if the CodeCache is full
+ int code_blob_type = 0;
+ if (CodeCache::is_full(&code_blob_type)) {
+ // The CodeHeap for code_blob_type is really full
+ handle_full_code_cache(code_blob_type);
}
CompileTask* task = queue->get();
@@ -1777,22 +1791,6 @@
if (method()->number_of_breakpoints() == 0) {
// Compile the method.
if ((UseCompiler || AlwaysCompileLoopMethods) && CompileBroker::should_compile_new_jobs()) {
-#ifdef COMPILER1
- // Allow repeating compilations for the purpose of benchmarking
- // compile speed. This is not useful for customers.
- if (CompilationRepeat != 0) {
- int compile_count = CompilationRepeat;
- while (compile_count > 0) {
- invoke_compiler_on_method(task);
- nmethod* nm = method->code();
- if (nm != NULL) {
- nm->make_zombie();
- method->clear_code();
- }
- compile_count--;
- }
- }
-#endif /* COMPILER1 */
invoke_compiler_on_method(task);
} else {
// After compilation is disabled, remove remaining methods from queue
@@ -2079,7 +2077,7 @@
* The CodeCache is full. Print out warning and disable compilation
* or try code cache cleaning so compilation can continue later.
*/
-void CompileBroker::handle_full_code_cache() {
+void CompileBroker::handle_full_code_cache(int code_blob_type) {
UseInterpreter = true;
if (UseCompiler || AlwaysCompileLoopMethods ) {
if (xtty != NULL) {
@@ -2096,8 +2094,6 @@
xtty->end_elem();
}
- CodeCache::report_codemem_full();
-
#ifndef PRODUCT
if (CompileTheWorld || ExitOnFullCodeCache) {
codecache_print(/* detailed= */ true);
@@ -2119,12 +2115,7 @@
disable_compilation_forever();
}
- // Print warning only once
- if (should_print_compiler_warning()) {
- warning("CodeCache is full. Compiler has been disabled.");
- warning("Try increasing the code cache size using -XX:ReservedCodeCacheSize=");
- codecache_print(/* detailed= */ true);
- }
+ CodeCache::report_codemem_full(code_blob_type, should_print_compiler_warning());
}
}
@@ -2247,6 +2238,11 @@
// _perf variables are production performance counters which are
// updated regardless of the setting of the CITime and CITimeEach flags
//
+
+ // account all time, including bailouts and failures in this counter;
+ // C1 and C2 counters are counting both successful and unsuccessful compiles
+ _t_total_compilation.add(time);
+
if (!success) {
_total_bailout_count++;
if (UsePerfData) {
@@ -2254,6 +2250,7 @@
_perf_last_failed_type->set_value(counters->compile_type());
_perf_total_bailout_count->inc();
}
+ _t_bailedout_compilation.add(time);
} else if (code == NULL) {
if (UsePerfData) {
_perf_last_invalidated_method->set_value(counters->current_method());
@@ -2261,14 +2258,13 @@
_perf_total_invalidated_count->inc();
}
_total_invalidated_count++;
+ _t_invalidated_compilation.add(time);
} else {
// Compilation succeeded
// update compilation ticks - used by the implementation of
// java.lang.management.CompilationMBean
_perf_total_compilation->inc(time.ticks());
-
- _t_total_compilation.add(time);
_peak_compilation_time = time.milliseconds() > _peak_compilation_time ? time.milliseconds() : _peak_compilation_time;
if (CITime) {
@@ -2336,37 +2332,47 @@
void CompileBroker::print_times() {
tty->cr();
- tty->print_cr("Accumulated compiler times (for compiled methods only)");
- tty->print_cr("------------------------------------------------");
+ tty->print_cr("Accumulated compiler times");
+ tty->print_cr("----------------------------------------------------------");
//0000000000111111111122222222223333333333444444444455555555556666666666
//0123456789012345678901234567890123456789012345678901234567890123456789
- tty->print_cr(" Total compilation time : %6.3f s", CompileBroker::_t_total_compilation.seconds());
- tty->print_cr(" Standard compilation : %6.3f s, Average : %2.3f",
+ tty->print_cr(" Total compilation time : %7.3f s", CompileBroker::_t_total_compilation.seconds());
+ tty->print_cr(" Standard compilation : %7.3f s, Average : %2.3f s",
CompileBroker::_t_standard_compilation.seconds(),
CompileBroker::_t_standard_compilation.seconds() / CompileBroker::_total_standard_compile_count);
- tty->print_cr(" On stack replacement : %6.3f s, Average : %2.3f", CompileBroker::_t_osr_compilation.seconds(), CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count);
+ tty->print_cr(" Bailed out compilation : %7.3f s, Average : %2.3f s",
+ CompileBroker::_t_bailedout_compilation.seconds(),
+ CompileBroker::_t_bailedout_compilation.seconds() / CompileBroker::_total_bailout_count);
+ tty->print_cr(" On stack replacement : %7.3f s, Average : %2.3f s",
+ CompileBroker::_t_osr_compilation.seconds(),
+ CompileBroker::_t_osr_compilation.seconds() / CompileBroker::_total_osr_compile_count);
+ tty->print_cr(" Invalidated : %7.3f s, Average : %2.3f s",
+ CompileBroker::_t_invalidated_compilation.seconds(),
+ CompileBroker::_t_invalidated_compilation.seconds() / CompileBroker::_total_invalidated_count);
AbstractCompiler *comp = compiler(CompLevel_simple);
if (comp != NULL) {
+ tty->cr();
comp->print_timers();
}
comp = compiler(CompLevel_full_optimization);
if (comp != NULL) {
+ tty->cr();
comp->print_timers();
}
tty->cr();
- tty->print_cr(" Total compiled methods : %6d methods", CompileBroker::_total_compile_count);
- tty->print_cr(" Standard compilation : %6d methods", CompileBroker::_total_standard_compile_count);
- tty->print_cr(" On stack replacement : %6d methods", CompileBroker::_total_osr_compile_count);
+ tty->print_cr(" Total compiled methods : %8d methods", CompileBroker::_total_compile_count);
+ tty->print_cr(" Standard compilation : %8d methods", CompileBroker::_total_standard_compile_count);
+ tty->print_cr(" On stack replacement : %8d methods", CompileBroker::_total_osr_compile_count);
int tcb = CompileBroker::_sum_osr_bytes_compiled + CompileBroker::_sum_standard_bytes_compiled;
- tty->print_cr(" Total compiled bytecodes : %6d bytes", tcb);
- tty->print_cr(" Standard compilation : %6d bytes", CompileBroker::_sum_standard_bytes_compiled);
- tty->print_cr(" On stack replacement : %6d bytes", CompileBroker::_sum_osr_bytes_compiled);
+ tty->print_cr(" Total compiled bytecodes : %8d bytes", tcb);
+ tty->print_cr(" Standard compilation : %8d bytes", CompileBroker::_sum_standard_bytes_compiled);
+ tty->print_cr(" On stack replacement : %8d bytes", CompileBroker::_sum_osr_bytes_compiled);
int bps = (int)(tcb / CompileBroker::_t_total_compilation.seconds());
- tty->print_cr(" Average compilation speed: %6d bytes/s", bps);
+ tty->print_cr(" Average compilation speed : %8d bytes/s", bps);
tty->cr();
- tty->print_cr(" nmethod code size : %6d bytes", CompileBroker::_sum_nmethod_code_size);
- tty->print_cr(" nmethod total size : %6d bytes", CompileBroker::_sum_nmethod_size);
+ tty->print_cr(" nmethod code size : %8d bytes", CompileBroker::_sum_nmethod_code_size);
+ tty->print_cr(" nmethod total size : %8d bytes", CompileBroker::_sum_nmethod_size);
}
// Debugging output for failure
--- a/hotspot/src/share/vm/compiler/compileBroker.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/compiler/compileBroker.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -322,6 +322,8 @@
static elapsedTimer _t_total_compilation;
static elapsedTimer _t_osr_compilation;
static elapsedTimer _t_standard_compilation;
+ static elapsedTimer _t_invalidated_compilation;
+ static elapsedTimer _t_bailedout_compilation;
static int _total_compile_count;
static int _total_bailout_count;
@@ -434,7 +436,7 @@
static bool is_compilation_disabled_forever() {
return _should_compile_new_jobs == shutdown_compilaton;
}
- static void handle_full_code_cache();
+ static void handle_full_code_cache(int code_blob_type);
// Ensures that warning is only printed once.
static bool should_print_compiler_warning() {
jint old = Atomic::cmpxchg(1, &_print_compilation_warning, 0);
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/concurrentMarkSweepGeneration.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -4167,7 +4167,7 @@
// been published), so we do not need to check for
// uninitialized objects before pushing here.
void Par_ConcMarkingClosure::do_oop(oop obj) {
- assert(obj->is_oop_or_null(true), "expected an oop or NULL");
+ assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
@@ -7226,7 +7226,7 @@
// isMarked() query is "safe".
bool ScanMarkedObjectsAgainClosure::do_object_bm(oop p, MemRegion mr) {
// Ignore mark word because we are running concurrent with mutators
- assert(p->is_oop_or_null(true), "expected an oop or null");
+ assert(p->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(p)));
HeapWord* addr = (HeapWord*)p;
assert(_span.contains(addr), "we are scanning the CMS generation");
bool is_obj_array = false;
@@ -7666,7 +7666,7 @@
}
void PushAndMarkVerifyClosure::do_oop(oop obj) {
- assert(obj->is_oop_or_null(), "expected an oop or NULL");
+ assert(obj->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
if (_span.contains(addr) && !_verification_bm->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@@ -7764,7 +7764,7 @@
void PushOrMarkClosure::do_oop(oop obj) {
// Ignore mark word because we are running concurrent with mutators.
- assert(obj->is_oop_or_null(true), "expected an oop or NULL");
+ assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
if (_span.contains(addr) && !_bitMap->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@@ -7802,7 +7802,7 @@
void Par_PushOrMarkClosure::do_oop(oop obj) {
// Ignore mark word because we are running concurrent with mutators.
- assert(obj->is_oop_or_null(true), "expected an oop or NULL");
+ assert(obj->is_oop_or_null(true), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
if (_whole_span.contains(addr) && !_bit_map->isMarked(addr)) {
// Oop lies in _span and isn't yet grey or black
@@ -7879,7 +7879,7 @@
// path and may be at the end of the global overflow list (so
// the mark word may be NULL).
assert(obj->is_oop_or_null(true /* ignore mark word */),
- "expected an oop or NULL");
+ err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
@@ -7959,7 +7959,7 @@
// the debugger, is_oop_or_null(false) may subsequently start
// to hold.
assert(obj->is_oop_or_null(true),
- "expected an oop or NULL");
+ err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
HeapWord* addr = (HeapWord*)obj;
// Check if oop points into the CMS generation
// and is not marked
--- a/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/concurrentMarkSweep/promotionInfo.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -73,7 +73,7 @@
} else {
res = (PromotedObject*)(_next & next_mask);
}
- assert(oop(res)->is_oop_or_null(true /* ignore mark word */), "Not an oop?");
+ assert(oop(res)->is_oop_or_null(true /* ignore mark word */), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(oop(res))));
return res;
}
inline void setNext(PromotedObject* x) {
--- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -107,7 +107,7 @@
HeapRegion *curr = regions_at(index++);
guarantee(curr != NULL, "Regions in _regions array cannot be NULL");
guarantee(!curr->is_young(), "should not be young!");
- guarantee(!curr->isHumongous(), "should not be humongous!");
+ guarantee(!curr->is_humongous(), "should not be humongous!");
if (prev != NULL) {
guarantee(order_regions(prev, curr) != 1,
err_msg("GC eff prev: %1.4f GC eff curr: %1.4f",
@@ -149,7 +149,7 @@
void CollectionSetChooser::add_region(HeapRegion* hr) {
- assert(!hr->isHumongous(),
+ assert(!hr->is_humongous(),
"Humongous regions shouldn't be added to the collection set");
assert(!hr->is_young(), "should not be young!");
_regions.append(hr);
--- a/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/collectionSetChooser.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -109,7 +109,7 @@
bool should_add(HeapRegion* hr) {
assert(hr->is_marked(), "pre-condition");
assert(!hr->is_young(), "should never consider young regions");
- return !hr->isHumongous() &&
+ return !hr->is_humongous() &&
hr->live_bytes() < _region_live_threshold_bytes;
}
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentG1Refine.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -128,9 +128,7 @@
}
uint ConcurrentG1Refine::thread_num() {
- uint n_threads = (G1ConcRefinementThreads > 0) ? G1ConcRefinementThreads
- : ParallelGCThreads;
- return MAX2<uint>(n_threads, 1);
+ return G1ConcRefinementThreads;
}
void ConcurrentG1Refine::print_worker_threads_on(outputStream* st) const {
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -910,7 +910,7 @@
class NoteStartOfMarkHRClosure: public HeapRegionClosure {
public:
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
r->note_start_of_marking();
}
return false;
@@ -1288,6 +1288,22 @@
print_stats();
}
+// Helper class to get rid of some boilerplate code.
+class G1CMTraceTime : public GCTraceTime {
+ static bool doit_and_prepend(bool doit) {
+ if (doit) {
+ gclog_or_tty->put(' ');
+ }
+ return doit;
+ }
+
+ public:
+ G1CMTraceTime(const char* title, bool doit)
+ : GCTraceTime(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm(),
+ G1CollectedHeap::heap()->concurrent_mark()->concurrent_gc_id()) {
+ }
+};
+
void ConcurrentMark::checkpointRootsFinal(bool clear_all_soft_refs) {
// world is stopped at this checkpoint
assert(SafepointSynchronize::is_at_safepoint(),
@@ -1341,9 +1357,13 @@
// marking due to overflowing the global mark stack.
reset_marking_state();
} else {
- // Aggregate the per-task counting data that we have accumulated
- // while marking.
- aggregate_count_data();
+ {
+ G1CMTraceTime trace("GC aggregate-data", G1Log::finer());
+
+ // Aggregate the per-task counting data that we have accumulated
+ // while marking.
+ aggregate_count_data();
+ }
SATBMarkQueueSet& satb_mq_set = JavaThread::satb_mark_queue_set();
// We're done with marking.
@@ -1398,10 +1418,10 @@
// to 1 the bits on the region bitmap that correspond to its
// associated "continues humongous" regions.
void set_bit_for_region(HeapRegion* hr) {
- assert(!hr->continuesHumongous(), "should have filtered those out");
+ assert(!hr->is_continues_humongous(), "should have filtered those out");
BitMap::idx_t index = (BitMap::idx_t) hr->hrm_index();
- if (!hr->startsHumongous()) {
+ if (!hr->is_starts_humongous()) {
// Normal (non-humongous) case: just set the bit.
_region_bm->par_at_put(index, true);
} else {
@@ -1434,7 +1454,7 @@
bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
// We will ignore these here and process them when their
// associated "starts humongous" region is processed (see
// set_bit_for_heap_region()). Note that we cannot rely on their
@@ -1556,7 +1576,7 @@
int failures() const { return _failures; }
bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
// We will ignore these here and process them when their
// associated "starts humongous" region is processed (see
// set_bit_for_heap_region()). Note that we cannot rely on their
@@ -1731,7 +1751,7 @@
bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
// We will ignore these here and process them when their
// associated "starts humongous" region is processed (see
// set_bit_for_heap_region()). Note that we cannot rely on their
@@ -1861,7 +1881,7 @@
const HeapRegionSetCount& humongous_regions_removed() { return _humongous_regions_removed; }
bool doHeapRegion(HeapRegion *hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
return false;
}
// We use a claim value of zero here because all regions
@@ -1875,8 +1895,8 @@
if (hr->used() > 0 && hr->max_live_bytes() == 0 && !hr->is_young()) {
_freed_bytes += hr->used();
hr->set_containing_set(NULL);
- if (hr->isHumongous()) {
- assert(hr->startsHumongous(), "we should only see starts humongous");
+ if (hr->is_humongous()) {
+ assert(hr->is_starts_humongous(), "we should only see starts humongous");
_humongous_regions_removed.increment(1u, hr->capacity());
_g1->free_humongous_region(hr, _local_cleanup_list, true);
} else {
@@ -2466,22 +2486,6 @@
G1CollectedHeap::heap()->parallel_cleaning(is_alive, true, true, purged_classes);
}
-// Helper class to get rid of some boilerplate code.
-class G1RemarkGCTraceTime : public GCTraceTime {
- static bool doit_and_prepend(bool doit) {
- if (doit) {
- gclog_or_tty->put(' ');
- }
- return doit;
- }
-
- public:
- G1RemarkGCTraceTime(const char* title, bool doit)
- : GCTraceTime(title, doit_and_prepend(doit), false, G1CollectedHeap::heap()->gc_timer_cm(),
- G1CollectedHeap::heap()->concurrent_mark()->concurrent_gc_id()) {
- }
-};
-
void ConcurrentMark::weakRefsWork(bool clear_all_soft_refs) {
if (has_overflown()) {
// Skip processing the discovered references if we have
@@ -2504,10 +2508,7 @@
// Inner scope to exclude the cleaning of the string and symbol
// tables from the displayed time.
{
- if (G1Log::finer()) {
- gclog_or_tty->put(' ');
- }
- GCTraceTime t("GC ref-proc", G1Log::finer(), false, g1h->gc_timer_cm(), concurrent_gc_id());
+ G1CMTraceTime t("GC ref-proc", G1Log::finer());
ReferenceProcessor* rp = g1h->ref_processor_cm();
@@ -2598,24 +2599,24 @@
// Unload Klasses, String, Symbols, Code Cache, etc.
{
- G1RemarkGCTraceTime trace("Unloading", G1Log::finer());
+ G1CMTraceTime trace("Unloading", G1Log::finer());
if (ClassUnloadingWithConcurrentMark) {
bool purged_classes;
{
- G1RemarkGCTraceTime trace("System Dictionary Unloading", G1Log::finest());
+ G1CMTraceTime trace("System Dictionary Unloading", G1Log::finest());
purged_classes = SystemDictionary::do_unloading(&g1_is_alive);
}
{
- G1RemarkGCTraceTime trace("Parallel Unloading", G1Log::finest());
+ G1CMTraceTime trace("Parallel Unloading", G1Log::finest());
weakRefsWorkParallelPart(&g1_is_alive, purged_classes);
}
}
if (G1StringDedup::is_enabled()) {
- G1RemarkGCTraceTime trace("String Deduplication Unlink", G1Log::finest());
+ G1CMTraceTime trace("String Deduplication Unlink", G1Log::finest());
G1StringDedup::unlink(&g1_is_alive);
}
}
@@ -2719,7 +2720,7 @@
HandleMark hm;
G1CollectedHeap* g1h = G1CollectedHeap::heap();
- G1RemarkGCTraceTime trace("Finalize Marking", G1Log::finer());
+ G1CMTraceTime trace("Finalize Marking", G1Log::finer());
g1h->ensure_parsability(false);
@@ -3191,7 +3192,7 @@
_cm_card_bm(cm_card_bm), _max_worker_id(max_worker_id) { }
bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
// We will ignore these here and process them when their
// associated "starts humongous" region is processed.
// Note that we cannot rely on their associated
@@ -3334,6 +3335,7 @@
} else {
g1_par_agg_task.work(0);
}
+ _g1h->allocation_context_stats().update_at_remark();
}
// Clear the per-worker arrays used to store the per-region counting data
@@ -3562,7 +3564,7 @@
void CMTask::setup_for_region(HeapRegion* hr) {
assert(hr != NULL,
"claim_region() should have filtered out NULL regions");
- assert(!hr->continuesHumongous(),
+ assert(!hr->is_continues_humongous(),
"claim_region() should have filtered out continues humongous regions");
if (_cm->verbose_low()) {
@@ -4287,7 +4289,7 @@
HR_FORMAT_PARAMS(_curr_region));
}
- assert(!_curr_region->isHumongous() || mr.start() == _curr_region->bottom(),
+ assert(!_curr_region->is_humongous() || mr.start() == _curr_region->bottom(),
"humongous regions should go around loop once only");
// Some special cases:
@@ -4301,7 +4303,7 @@
if (mr.is_empty()) {
giveup_current_region();
regular_clock_call();
- } else if (_curr_region->isHumongous() && mr.start() == _curr_region->bottom()) {
+ } else if (_curr_region->is_humongous() && mr.start() == _curr_region->bottom()) {
if (_nextMarkBitMap->isMarked(mr.start())) {
// The object is marked - apply the closure
BitMap::idx_t offset = _nextMarkBitMap->heapWordToOffset(mr.start());
@@ -4748,7 +4750,7 @@
size_t remset_bytes = r->rem_set()->mem_size();
size_t strong_code_roots_bytes = r->rem_set()->strong_code_roots_mem_size();
- if (r->startsHumongous()) {
+ if (r->is_starts_humongous()) {
assert(_hum_used_bytes == 0 && _hum_capacity_bytes == 0 &&
_hum_prev_live_bytes == 0 && _hum_next_live_bytes == 0,
"they should have been zeroed after the last time we used them");
@@ -4760,7 +4762,7 @@
get_hum_bytes(&used_bytes, &capacity_bytes,
&prev_live_bytes, &next_live_bytes);
end = bottom + HeapRegion::GrainWords;
- } else if (r->continuesHumongous()) {
+ } else if (r->is_continues_humongous()) {
get_hum_bytes(&used_bytes, &capacity_bytes,
&prev_live_bytes, &next_live_bytes);
assert(end == bottom + HeapRegion::GrainWords, "invariant");
--- a/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/concurrentMark.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -88,7 +88,7 @@
size_t region_size_bytes = mr.byte_size();
uint index = hr->hrm_index();
- assert(!hr->continuesHumongous(), "should not be HC region");
+ assert(!hr->is_continues_humongous(), "should not be HC region");
assert(hr == g1h->heap_region_containing(start), "sanity");
assert(hr == g1h->heap_region_containing(mr.last()), "sanity");
assert(marked_bytes_array != NULL, "pre-condition");
@@ -277,7 +277,7 @@
++_refs_reached;
HeapWord* objAddr = (HeapWord*) obj;
- assert(obj->is_oop_or_null(true /* ignore mark word */), "Error");
+ assert(obj->is_oop_or_null(true /* ignore mark word */), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(obj)));
if (_g1h->is_in_g1_reserved(objAddr)) {
assert(obj != NULL, "null check is implicit");
if (!_nextMarkBitMap->isMarked(objAddr)) {
@@ -366,7 +366,7 @@
assert(hr != NULL, "sanity");
// Given that we're looking for a region that contains an object
// header it's impossible to get back a HC region.
- assert(!hr->continuesHumongous(), "sanity");
+ assert(!hr->is_continues_humongous(), "sanity");
// We cannot assert that word_size == obj->size() given that obj
// might not be in a consistent state (another thread might be in
--- a/hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -129,8 +129,7 @@
// Note that we first perform the allocation and then we store the
// region in _alloc_region. This is the reason why an active region
// can never be empty.
- _alloc_region = new_alloc_region;
- _count += 1;
+ update_alloc_region(new_alloc_region);
trace("region allocation successful");
return result;
} else {
@@ -172,6 +171,19 @@
trace("set");
}
+void G1AllocRegion::update_alloc_region(HeapRegion* alloc_region) {
+ trace("update");
+ // We explicitly check that the region is not empty to make sure we
+ // maintain the "the alloc region cannot be empty" invariant.
+ assert(alloc_region != NULL && !alloc_region->is_empty(),
+ ar_ext_msg(this, "pre-condition"));
+
+ _alloc_region = alloc_region;
+ _alloc_region->set_allocation_context(allocation_context());
+ _count += 1;
+ trace("updated");
+}
+
HeapRegion* G1AllocRegion::release() {
trace("releasing");
HeapRegion* alloc_region = _alloc_region;
@@ -225,5 +237,70 @@
G1AllocRegion::G1AllocRegion(const char* name,
bool bot_updates)
: _name(name), _bot_updates(bot_updates),
- _alloc_region(NULL), _count(0), _used_bytes_before(0) { }
+ _alloc_region(NULL), _count(0), _used_bytes_before(0),
+ _allocation_context(AllocationContext::system()) { }
+
+
+HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size,
+ bool force) {
+ return _g1h->new_mutator_alloc_region(word_size, force);
+}
+
+void MutatorAllocRegion::retire_region(HeapRegion* alloc_region,
+ size_t allocated_bytes) {
+ _g1h->retire_mutator_alloc_region(alloc_region, allocated_bytes);
+}
+
+HeapRegion* SurvivorGCAllocRegion::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(), GCAllocForSurvived);
+}
+
+void SurvivorGCAllocRegion::retire_region(HeapRegion* alloc_region,
+ size_t allocated_bytes) {
+ _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes,
+ GCAllocForSurvived);
+}
+
+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(), GCAllocForTenured);
+}
+void OldGCAllocRegion::retire_region(HeapRegion* alloc_region,
+ size_t allocated_bytes) {
+ _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes,
+ GCAllocForTenured);
+}
+
+HeapRegion* OldGCAllocRegion::release() {
+ HeapRegion* cur = get();
+ if (cur != NULL) {
+ // Determine how far we are from the next card boundary. If it is smaller than
+ // the minimum object size we can allocate into, expand into the next card.
+ HeapWord* top = cur->top();
+ HeapWord* aligned_top = (HeapWord*)align_ptr_up(top, G1BlockOffsetSharedArray::N_bytes);
+
+ size_t to_allocate_words = pointer_delta(aligned_top, top, HeapWordSize);
+
+ if (to_allocate_words != 0) {
+ // We are not at a card boundary. Fill up, possibly into the next, taking the
+ // end of the region and the minimum object size into account.
+ to_allocate_words = MIN2(pointer_delta(cur->end(), cur->top(), HeapWordSize),
+ MAX2(to_allocate_words, G1CollectedHeap::min_fill_size()));
+
+ // Skip allocation if there is not enough space to allocate even the smallest
+ // possible object. In this case this region will not be retained, so the
+ // original problem cannot occur.
+ if (to_allocate_words >= G1CollectedHeap::min_fill_size()) {
+ HeapWord* dummy = attempt_allocation(to_allocate_words, true /* bot_updates */);
+ CollectedHeap::fill_with_object(dummy, to_allocate_words);
+ }
+ }
+ }
+ return G1AllocRegion::release();
+}
+
+
--- a/hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1AllocRegion.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -57,6 +57,9 @@
// correct use of init() and release()).
HeapRegion* volatile _alloc_region;
+ // Allocation context associated with this alloc region.
+ AllocationContext_t _allocation_context;
+
// It keeps track of the distinct number of regions that are used
// for allocation in the active interval of this object, i.e.,
// between a call to init() and a call to release(). The count
@@ -110,6 +113,10 @@
// else can allocate out of it.
void retire(bool fill_up);
+ // After a region is allocated by alloc_new_region, this
+ // method is used to set it as the active alloc_region
+ void update_alloc_region(HeapRegion* alloc_region);
+
// Allocate a new active region and use it to perform a word_size
// allocation. The force parameter will be passed on to
// G1CollectedHeap::allocate_new_alloc_region() and tells it to try
@@ -137,6 +144,9 @@
return (hr == _dummy_region) ? NULL : hr;
}
+ void set_allocation_context(AllocationContext_t context) { _allocation_context = context; }
+ AllocationContext_t allocation_context() { return _allocation_context; }
+
uint count() { return _count; }
// The following two are the building blocks for the allocation method.
@@ -182,6 +192,40 @@
#endif // G1_ALLOC_REGION_TRACING
};
+class MutatorAllocRegion : 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);
+public:
+ MutatorAllocRegion()
+ : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
+};
+
+class SurvivorGCAllocRegion : 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);
+public:
+ SurvivorGCAllocRegion()
+ : G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { }
+};
+
+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);
+public:
+ OldGCAllocRegion()
+ : G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { }
+
+ // This specialization of release() makes sure that the last card that has
+ // been allocated into has been completely filled by a dummy object. This
+ // avoids races when remembered set scanning wants to update the BOT of the
+ // last card in the retained old gc alloc region, and allocation threads
+ // allocating into that card at the same time.
+ virtual HeapRegion* release();
+};
+
class ar_ext_msg : public err_msg {
public:
ar_ext_msg(G1AllocRegion* alloc_region, const char *message) : err_msg("%s", "") {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1AllocationContext.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,52 @@
+/*
+ * 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_GC_IMPLEMENTATION_G1_G1ALLOCATIONCONTEXT_HPP
+#define SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCATIONCONTEXT_HPP
+
+#include "memory/allocation.hpp"
+
+typedef unsigned char AllocationContext_t;
+
+class AllocationContext : AllStatic {
+public:
+ // Currently used context
+ static AllocationContext_t current() {
+ return 0;
+ }
+ // System wide default context
+ static AllocationContext_t system() {
+ return 0;
+ }
+};
+
+class AllocationContextStats: public StackObj {
+public:
+ inline void clear() { }
+ inline void update(bool full_gc) { }
+ inline void update_at_remark() { }
+ inline bool available() { return false; }
+};
+
+#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCATIONCONTEXT_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1Allocator.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,155 @@
+/*
+ * 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc_implementation/g1/g1Allocator.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.hpp"
+#include "gc_implementation/g1/g1CollectorPolicy.hpp"
+#include "gc_implementation/g1/heapRegion.inline.hpp"
+#include "gc_implementation/g1/heapRegionSet.inline.hpp"
+
+void G1DefaultAllocator::init_mutator_alloc_region() {
+ assert(_mutator_alloc_region.get() == NULL, "pre-condition");
+ _mutator_alloc_region.init();
+}
+
+void G1DefaultAllocator::release_mutator_alloc_region() {
+ _mutator_alloc_region.release();
+ assert(_mutator_alloc_region.get() == NULL, "post-condition");
+}
+
+void G1Allocator::reuse_retained_old_region(EvacuationInfo& evacuation_info,
+ OldGCAllocRegion* old,
+ HeapRegion** retained_old) {
+ HeapRegion* retained_region = *retained_old;
+ *retained_old = NULL;
+
+ // We will discard the current GC alloc region if:
+ // a) it's in the collection set (it can happen!),
+ // b) it's already full (no point in using it),
+ // c) it's empty (this means that it was emptied during
+ // a cleanup and it should be on the free list now), or
+ // d) it's humongous (this means that it was emptied
+ // during a cleanup and was added to the free list, but
+ // has been subsequently used to allocate a humongous
+ // object that may be less than the region size).
+ if (retained_region != NULL &&
+ !retained_region->in_collection_set() &&
+ !(retained_region->top() == retained_region->end()) &&
+ !retained_region->is_empty() &&
+ !retained_region->is_humongous()) {
+ retained_region->record_top_and_timestamp();
+ // The retained region was added to the old region set when it was
+ // retired. We have to remove it now, since we don't allow regions
+ // we allocate to in the region sets. We'll re-add it later, when
+ // it's retired again.
+ _g1h->_old_set.remove(retained_region);
+ bool during_im = _g1h->g1_policy()->during_initial_mark_pause();
+ retained_region->note_start_of_copying(during_im);
+ old->set(retained_region);
+ _g1h->_hr_printer.reuse(retained_region);
+ evacuation_info.set_alloc_regions_used_before(retained_region->used());
+ }
+}
+
+void G1DefaultAllocator::init_gc_alloc_regions(EvacuationInfo& evacuation_info) {
+ assert_at_safepoint(true /* should_be_vm_thread */);
+
+ _survivor_gc_alloc_region.init();
+ _old_gc_alloc_region.init();
+ reuse_retained_old_region(evacuation_info,
+ &_old_gc_alloc_region,
+ &_retained_old_gc_alloc_region);
+}
+
+void G1DefaultAllocator::release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info) {
+ AllocationContext_t context = AllocationContext::current();
+ evacuation_info.set_allocation_regions(survivor_gc_alloc_region(context)->count() +
+ old_gc_alloc_region(context)->count());
+ survivor_gc_alloc_region(context)->release();
+ // If we have an old GC alloc region to release, we'll save it in
+ // _retained_old_gc_alloc_region. If we don't
+ // _retained_old_gc_alloc_region will become NULL. This is what we
+ // want either way so no reason to check explicitly for either
+ // condition.
+ _retained_old_gc_alloc_region = old_gc_alloc_region(context)->release();
+
+ if (ResizePLAB) {
+ _g1h->_survivor_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
+ _g1h->_old_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
+ }
+}
+
+void G1DefaultAllocator::abandon_gc_alloc_regions() {
+ assert(survivor_gc_alloc_region(AllocationContext::current())->get() == NULL, "pre-condition");
+ assert(old_gc_alloc_region(AllocationContext::current())->get() == NULL, "pre-condition");
+ _retained_old_gc_alloc_region = NULL;
+}
+
+G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) :
+ ParGCAllocBuffer(gclab_word_size), _retired(true) { }
+
+HeapWord* G1ParGCAllocator::allocate_slow(GCAllocPurpose purpose, size_t word_sz, AllocationContext_t context) {
+ HeapWord* obj = NULL;
+ size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
+ if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
+ G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose, context);
+ add_to_alloc_buffer_waste(alloc_buf->words_remaining());
+ alloc_buf->retire(false /* end_of_gc */, false /* retain */);
+
+ HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size, context);
+ if (buf == NULL) {
+ return NULL; // Let caller handle allocation failure.
+ }
+ // Otherwise.
+ alloc_buf->set_word_size(gclab_word_size);
+ alloc_buf->set_buf(buf);
+
+ obj = alloc_buf->allocate(word_sz);
+ assert(obj != NULL, "buffer was definitely big enough...");
+ } else {
+ obj = _g1h->par_allocate_during_gc(purpose, word_sz, context);
+ }
+ return obj;
+}
+
+G1DefaultParGCAllocator::G1DefaultParGCAllocator(G1CollectedHeap* g1h) :
+ G1ParGCAllocator(g1h),
+ _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)),
+ _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)) {
+
+ _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer;
+ _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer;
+
+}
+
+void G1DefaultParGCAllocator::retire_alloc_buffers() {
+ for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
+ size_t waste = _alloc_buffers[ap]->words_remaining();
+ add_to_alloc_buffer_waste(waste);
+ _alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
+ true /* end_of_gc */,
+ false /* retain */);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1Allocator.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,242 @@
+/*
+ * 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_GC_IMPLEMENTATION_G1_G1ALLOCATOR_HPP
+#define SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCATOR_HPP
+
+#include "gc_implementation/g1/g1AllocationContext.hpp"
+#include "gc_implementation/g1/g1AllocRegion.hpp"
+#include "gc_implementation/shared/parGCAllocBuffer.hpp"
+
+enum GCAllocPurpose {
+ GCAllocForTenured,
+ GCAllocForSurvived,
+ GCAllocPurposeCount
+};
+
+// Base class for G1 allocators.
+class G1Allocator : public CHeapObj<mtGC> {
+ friend class VMStructs;
+protected:
+ G1CollectedHeap* _g1h;
+
+ // Outside of GC pauses, the number of bytes used in all regions other
+ // than the current allocation region.
+ size_t _summary_bytes_used;
+
+public:
+ G1Allocator(G1CollectedHeap* heap) :
+ _g1h(heap), _summary_bytes_used(0) { }
+
+ static G1Allocator* create_allocator(G1CollectedHeap* g1h);
+
+ 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 release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info) = 0;
+ virtual void abandon_gc_alloc_regions() = 0;
+
+ virtual MutatorAllocRegion* mutator_alloc_region(AllocationContext_t context) = 0;
+ virtual SurvivorGCAllocRegion* survivor_gc_alloc_region(AllocationContext_t context) = 0;
+ virtual OldGCAllocRegion* old_gc_alloc_region(AllocationContext_t context) = 0;
+ virtual size_t used() = 0;
+ virtual bool is_retained_old_region(HeapRegion* hr) = 0;
+
+ void reuse_retained_old_region(EvacuationInfo& evacuation_info,
+ OldGCAllocRegion* old,
+ HeapRegion** retained);
+
+ size_t used_unlocked() const {
+ return _summary_bytes_used;
+ }
+
+ void increase_used(size_t bytes) {
+ _summary_bytes_used += bytes;
+ }
+
+ void decrease_used(size_t bytes) {
+ assert(_summary_bytes_used >= bytes,
+ err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" should be >= bytes: "SIZE_FORMAT,
+ _summary_bytes_used, bytes));
+ _summary_bytes_used -= bytes;
+ }
+
+ void set_used(size_t bytes) {
+ _summary_bytes_used = bytes;
+ }
+
+ virtual HeapRegion* new_heap_region(uint hrs_index,
+ G1BlockOffsetSharedArray* sharedOffsetArray,
+ MemRegion mr) {
+ return new HeapRegion(hrs_index, sharedOffsetArray, mr);
+ }
+};
+
+// The default allocator for G1.
+class G1DefaultAllocator : public G1Allocator {
+protected:
+ // Alloc region used to satisfy mutator allocation requests.
+ MutatorAllocRegion _mutator_alloc_region;
+
+ // Alloc region used to satisfy allocation requests by the GC for
+ // survivor objects.
+ SurvivorGCAllocRegion _survivor_gc_alloc_region;
+
+ // Alloc region used to satisfy allocation requests by the GC for
+ // old objects.
+ OldGCAllocRegion _old_gc_alloc_region;
+
+ HeapRegion* _retained_old_gc_alloc_region;
+public:
+ G1DefaultAllocator(G1CollectedHeap* heap) : G1Allocator(heap), _retained_old_gc_alloc_region(NULL) { }
+
+ virtual void init_mutator_alloc_region();
+ virtual void release_mutator_alloc_region();
+
+ virtual void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
+ virtual void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
+ virtual void abandon_gc_alloc_regions();
+
+ virtual bool is_retained_old_region(HeapRegion* hr) {
+ return _retained_old_gc_alloc_region == hr;
+ }
+
+ virtual MutatorAllocRegion* mutator_alloc_region(AllocationContext_t context) {
+ return &_mutator_alloc_region;
+ }
+
+ virtual SurvivorGCAllocRegion* survivor_gc_alloc_region(AllocationContext_t context) {
+ return &_survivor_gc_alloc_region;
+ }
+
+ virtual OldGCAllocRegion* old_gc_alloc_region(AllocationContext_t context) {
+ return &_old_gc_alloc_region;
+ }
+
+ virtual size_t used() {
+ assert(Heap_lock->owner() != NULL,
+ "Should be owned on this thread's behalf.");
+ size_t result = _summary_bytes_used;
+
+ // Read only once in case it is set to NULL concurrently
+ HeapRegion* hr = mutator_alloc_region(AllocationContext::current())->get();
+ if (hr != NULL) {
+ result += hr->used();
+ }
+ return result;
+ }
+};
+
+class G1ParGCAllocBuffer: public ParGCAllocBuffer {
+private:
+ bool _retired;
+
+public:
+ G1ParGCAllocBuffer(size_t gclab_word_size);
+ virtual ~G1ParGCAllocBuffer() {
+ guarantee(_retired, "Allocation buffer has not been retired");
+ }
+
+ virtual void set_buf(HeapWord* buf) {
+ ParGCAllocBuffer::set_buf(buf);
+ _retired = false;
+ }
+
+ virtual void retire(bool end_of_gc, bool retain) {
+ if (_retired) {
+ return;
+ }
+ ParGCAllocBuffer::retire(end_of_gc, retain);
+ _retired = true;
+ }
+};
+
+class G1ParGCAllocator : public CHeapObj<mtGC> {
+ friend class G1ParScanThreadState;
+protected:
+ G1CollectedHeap* _g1h;
+
+ size_t _alloc_buffer_waste;
+ size_t _undo_waste;
+
+ void add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
+ void add_to_undo_waste(size_t waste) { _undo_waste += waste; }
+
+ HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz, AllocationContext_t context);
+
+ virtual void retire_alloc_buffers() = 0;
+ virtual G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose, AllocationContext_t context) = 0;
+
+public:
+ G1ParGCAllocator(G1CollectedHeap* g1h) :
+ _g1h(g1h), _alloc_buffer_waste(0), _undo_waste(0) {
+ }
+
+ static G1ParGCAllocator* create_allocator(G1CollectedHeap* g1h);
+
+ size_t alloc_buffer_waste() { return _alloc_buffer_waste; }
+ size_t undo_waste() {return _undo_waste; }
+
+ HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz, AllocationContext_t context) {
+ HeapWord* obj = NULL;
+ if (purpose == GCAllocForSurvived) {
+ obj = alloc_buffer(purpose, context)->allocate_aligned(word_sz, SurvivorAlignmentInBytes);
+ } else {
+ obj = alloc_buffer(purpose, context)->allocate(word_sz);
+ }
+ if (obj != NULL) {
+ return obj;
+ }
+ return allocate_slow(purpose, word_sz, context);
+ }
+
+ void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz, AllocationContext_t context) {
+ if (alloc_buffer(purpose, context)->contains(obj)) {
+ assert(alloc_buffer(purpose, context)->contains(obj + word_sz - 1),
+ "should contain whole object");
+ alloc_buffer(purpose, context)->undo_allocation(obj, word_sz);
+ } else {
+ CollectedHeap::fill_with_object(obj, word_sz);
+ add_to_undo_waste(word_sz);
+ }
+ }
+};
+
+class G1DefaultParGCAllocator : public G1ParGCAllocator {
+ G1ParGCAllocBuffer _surviving_alloc_buffer;
+ G1ParGCAllocBuffer _tenured_alloc_buffer;
+ G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
+
+public:
+ G1DefaultParGCAllocator(G1CollectedHeap* g1h);
+
+ virtual G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose, AllocationContext_t context) {
+ return _alloc_buffers[purpose];
+ }
+
+ virtual void retire_alloc_buffers() ;
+};
+
+#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1ALLOCATOR_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1Allocator_ext.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,35 @@
+/*
+ * 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc_implementation/g1/g1Allocator.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.hpp"
+
+G1Allocator* G1Allocator::create_allocator(G1CollectedHeap* g1h) {
+ return new G1DefaultAllocator(g1h);
+}
+
+G1ParGCAllocator* G1ParGCAllocator::create_allocator(G1CollectedHeap* g1h) {
+ return new G1DefaultParGCAllocator(g1h);
+}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -469,7 +469,7 @@
// can move in an incremental collection.
bool G1CollectedHeap::is_scavengable(const void* p) {
HeapRegion* hr = heap_region_containing(p);
- return !hr->isHumongous();
+ return !hr->is_humongous();
}
void G1CollectedHeap::check_ct_logs_at_safepoint() {
@@ -560,7 +560,7 @@
}
HeapRegion* G1CollectedHeap::new_region(size_t word_size, bool is_old, bool do_expand) {
- assert(!isHumongous(word_size) || word_size <= HeapRegion::GrainWords,
+ assert(!is_humongous(word_size) || word_size <= HeapRegion::GrainWords,
"the only time we use this to allocate a humongous region is "
"when we are allocating a single humongous region");
@@ -615,9 +615,10 @@
HeapWord*
G1CollectedHeap::humongous_obj_allocate_initialize_regions(uint first,
uint num_regions,
- size_t word_size) {
+ size_t word_size,
+ AllocationContext_t context) {
assert(first != G1_NO_HRM_INDEX, "pre-condition");
- assert(isHumongous(word_size), "word_size should be humongous");
+ assert(is_humongous(word_size), "word_size should be humongous");
assert(num_regions * HeapRegion::GrainWords >= word_size, "pre-condition");
// Index of last region in the series + 1.
@@ -666,14 +667,15 @@
// will also update the BOT covering all the regions to reflect
// that there is a single object that starts at the bottom of the
// first region.
- first_hr->set_startsHumongous(new_top, new_end);
-
+ first_hr->set_starts_humongous(new_top, new_end);
+ first_hr->set_allocation_context(context);
// Then, if there are any, we will set up the "continues
// humongous" regions.
HeapRegion* hr = NULL;
for (uint i = first + 1; i < last; ++i) {
hr = region_at(i);
- hr->set_continuesHumongous(first_hr);
+ hr->set_continues_humongous(first_hr);
+ hr->set_allocation_context(context);
}
// If we have "continues humongous" regions (hr != NULL), then the
// end of the last one should match new_end.
@@ -711,7 +713,7 @@
// G1. For example, the code that looks for a consecutive number
// of empty regions will consider them empty and try to
// re-allocate them. We can extend is_empty() to also include
- // !continuesHumongous(), but it is easier to just update the top
+ // !is_continues_humongous(), but it is easier to just update the top
// fields here. The way we set top for all regions (i.e., top ==
// end for all regions but the last one, top == new_top for the
// last one) is actually used when we will free up the humongous
@@ -740,7 +742,7 @@
check_bitmaps("Humongous Region Allocation", first_hr);
assert(first_hr->used() == word_size * HeapWordSize, "invariant");
- _summary_bytes_used += first_hr->used();
+ _allocator->increase_used(first_hr->used());
_humongous_set.add(first_hr);
return new_obj;
@@ -749,7 +751,7 @@
// If could fit into free regions w/o expansion, try.
// Otherwise, if can expand, do so.
// Otherwise, if using ex regions might help, try with ex given back.
-HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size) {
+HeapWord* G1CollectedHeap::humongous_obj_allocate(size_t word_size, AllocationContext_t context) {
assert_heap_locked_or_at_safepoint(true /* should_be_vm_thread */);
verify_region_sets_optional();
@@ -818,7 +820,8 @@
HeapWord* result = NULL;
if (first != G1_NO_HRM_INDEX) {
- result = humongous_obj_allocate_initialize_regions(first, obj_regions, word_size);
+ result = humongous_obj_allocate_initialize_regions(first, obj_regions,
+ word_size, context);
assert(result != NULL, "it should always return a valid result");
// A successful humongous object allocation changes the used space
@@ -834,7 +837,7 @@
HeapWord* G1CollectedHeap::allocate_new_tlab(size_t word_size) {
assert_heap_not_locked_and_not_at_safepoint();
- assert(!isHumongous(word_size), "we do not allow humongous TLABs");
+ assert(!is_humongous(word_size), "we do not allow humongous TLABs");
unsigned int dummy_gc_count_before;
int dummy_gclocker_retry_count = 0;
@@ -851,7 +854,7 @@
unsigned int gc_count_before;
HeapWord* result = NULL;
- if (!isHumongous(word_size)) {
+ if (!is_humongous(word_size)) {
result = attempt_allocation(word_size, &gc_count_before, &gclocker_retry_count);
} else {
result = attempt_allocation_humongous(word_size, &gc_count_before, &gclocker_retry_count);
@@ -862,6 +865,8 @@
// Create the garbage collection operation...
VM_G1CollectForAllocation op(gc_count_before, word_size);
+ op.set_allocation_context(AllocationContext::current());
+
// ...and get the VM thread to execute it.
VMThread::execute(&op);
@@ -870,7 +875,7 @@
// if it is NULL. If the allocation attempt failed immediately
// after a Full GC, it's unlikely we'll be able to allocate now.
HeapWord* result = op.result();
- if (result != NULL && !isHumongous(word_size)) {
+ if (result != NULL && !is_humongous(word_size)) {
// Allocations that take place on VM operations do not do any
// card dirtying and we have to do it here. We only have to do
// this for non-humongous allocations, though.
@@ -897,12 +902,13 @@
}
HeapWord* G1CollectedHeap::attempt_allocation_slow(size_t word_size,
- unsigned int *gc_count_before_ret,
- int* gclocker_retry_count_ret) {
+ AllocationContext_t context,
+ unsigned int *gc_count_before_ret,
+ int* gclocker_retry_count_ret) {
// Make sure you read the note in attempt_allocation_humongous().
assert_heap_not_locked_and_not_at_safepoint();
- assert(!isHumongous(word_size), "attempt_allocation_slow() should not "
+ assert(!is_humongous(word_size), "attempt_allocation_slow() should not "
"be called for humongous allocation requests");
// We should only get here after the first-level allocation attempt
@@ -919,23 +925,22 @@
{
MutexLockerEx x(Heap_lock);
-
- result = _mutator_alloc_region.attempt_allocation_locked(word_size,
- false /* bot_updates */);
+ result = _allocator->mutator_alloc_region(context)->attempt_allocation_locked(word_size,
+ false /* bot_updates */);
if (result != NULL) {
return result;
}
// If we reach here, attempt_allocation_locked() above failed to
// allocate a new region. So the mutator alloc region should be NULL.
- assert(_mutator_alloc_region.get() == NULL, "only way to get here");
+ assert(_allocator->mutator_alloc_region(context)->get() == NULL, "only way to get here");
if (GC_locker::is_active_and_needs_gc()) {
if (g1_policy()->can_expand_young_list()) {
// No need for an ergo verbose message here,
// can_expand_young_list() does this when it returns true.
- result = _mutator_alloc_region.attempt_allocation_force(word_size,
- false /* bot_updates */);
+ result = _allocator->mutator_alloc_region(context)->attempt_allocation_force(word_size,
+ false /* bot_updates */);
if (result != NULL) {
return result;
}
@@ -995,8 +1000,8 @@
// first attempt (without holding the Heap_lock) here and the
// follow-on attempt will be at the start of the next loop
// iteration (after taking the Heap_lock).
- result = _mutator_alloc_region.attempt_allocation(word_size,
- false /* bot_updates */);
+ result = _allocator->mutator_alloc_region(context)->attempt_allocation(word_size,
+ false /* bot_updates */);
if (result != NULL) {
return result;
}
@@ -1014,8 +1019,8 @@
}
HeapWord* G1CollectedHeap::attempt_allocation_humongous(size_t word_size,
- unsigned int * gc_count_before_ret,
- int* gclocker_retry_count_ret) {
+ unsigned int * gc_count_before_ret,
+ int* gclocker_retry_count_ret) {
// The structure of this method has a lot of similarities to
// attempt_allocation_slow(). The reason these two were not merged
// into a single one is that such a method would require several "if
@@ -1028,7 +1033,7 @@
// much as possible.
assert_heap_not_locked_and_not_at_safepoint();
- assert(isHumongous(word_size), "attempt_allocation_humongous() "
+ assert(is_humongous(word_size), "attempt_allocation_humongous() "
"should only be called for humongous allocations");
// Humongous objects can exhaust the heap quickly, so we should check if we
@@ -1056,7 +1061,7 @@
// Given that humongous objects are not allocated in young
// regions, we'll first try to do the allocation without doing a
// collection hoping that there's enough space in the heap.
- result = humongous_obj_allocate(word_size);
+ result = humongous_obj_allocate(word_size, AllocationContext::current());
if (result != NULL) {
return result;
}
@@ -1132,17 +1137,18 @@
}
HeapWord* G1CollectedHeap::attempt_allocation_at_safepoint(size_t word_size,
- bool expect_null_mutator_alloc_region) {
+ AllocationContext_t context,
+ bool expect_null_mutator_alloc_region) {
assert_at_safepoint(true /* should_be_vm_thread */);
- assert(_mutator_alloc_region.get() == NULL ||
+ assert(_allocator->mutator_alloc_region(context)->get() == NULL ||
!expect_null_mutator_alloc_region,
"the current alloc region was unexpectedly found to be non-NULL");
- if (!isHumongous(word_size)) {
- return _mutator_alloc_region.attempt_allocation_locked(word_size,
+ if (!is_humongous(word_size)) {
+ return _allocator->mutator_alloc_region(context)->attempt_allocation_locked(word_size,
false /* bot_updates */);
} else {
- HeapWord* result = humongous_obj_allocate(word_size);
+ HeapWord* result = humongous_obj_allocate(word_size, context);
if (result != NULL && g1_policy()->need_to_start_conc_mark("STW humongous allocation")) {
g1_policy()->set_initiate_conc_mark_if_possible();
}
@@ -1162,7 +1168,7 @@
bool doHeapRegion(HeapRegion* r) {
HeapRegionRemSet* hrrs = r->rem_set();
- if (r->continuesHumongous()) {
+ if (r->is_continues_humongous()) {
// We'll assert that the strong code root list and RSet is empty
assert(hrrs->strong_code_roots_list_length() == 0, "sanity");
assert(hrrs->occupied() == 0, "RSet should be empty");
@@ -1199,7 +1205,7 @@
{ }
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
_cl.set_from(r);
r->oop_iterate(&_cl);
}
@@ -1231,14 +1237,14 @@
assert(!hr->is_young(), "not expecting to find young regions");
if (hr->is_free()) {
// We only generate output for non-empty regions.
- } else if (hr->startsHumongous()) {
+ } else if (hr->is_starts_humongous()) {
if (hr->region_num() == 1) {
// single humongous region
_hr_printer->post_compaction(hr, G1HRPrinter::SingleHumongous);
} else {
_hr_printer->post_compaction(hr, G1HRPrinter::StartsHumongous);
}
- } else if (hr->continuesHumongous()) {
+ } else if (hr->is_continues_humongous()) {
_hr_printer->post_compaction(hr, G1HRPrinter::ContinuesHumongous);
} else if (hr->is_old()) {
_hr_printer->post_compaction(hr, G1HRPrinter::Old);
@@ -1342,8 +1348,8 @@
concurrent_mark()->abort();
// Make sure we'll choose a new allocation region afterwards.
- release_mutator_alloc_region();
- abandon_gc_alloc_regions();
+ _allocator->release_mutator_alloc_region();
+ _allocator->abandon_gc_alloc_regions();
g1_rem_set()->cleanupHRRS();
// We should call this after we retire any currently active alloc
@@ -1515,7 +1521,7 @@
clear_cset_fast_test();
- init_mutator_alloc_region();
+ _allocator->init_mutator_alloc_region();
double end = os::elapsedTime();
g1_policy()->record_full_collection_end();
@@ -1651,6 +1657,7 @@
HeapWord*
G1CollectedHeap::satisfy_failed_allocation(size_t word_size,
+ AllocationContext_t context,
bool* succeeded) {
assert_at_safepoint(true /* should_be_vm_thread */);
@@ -1658,7 +1665,8 @@
// Let's attempt the allocation first.
HeapWord* result =
attempt_allocation_at_safepoint(word_size,
- false /* expect_null_mutator_alloc_region */);
+ context,
+ false /* expect_null_mutator_alloc_region */);
if (result != NULL) {
assert(*succeeded, "sanity");
return result;
@@ -1668,7 +1676,7 @@
// incremental pauses. Therefore, at least for now, we'll favor
// expansion over collection. (This might change in the future if we can
// do something smarter than full collection to satisfy a failed alloc.)
- result = expand_and_allocate(word_size);
+ result = expand_and_allocate(word_size, context);
if (result != NULL) {
assert(*succeeded, "sanity");
return result;
@@ -1685,7 +1693,8 @@
// Retry the allocation
result = attempt_allocation_at_safepoint(word_size,
- true /* expect_null_mutator_alloc_region */);
+ context,
+ true /* expect_null_mutator_alloc_region */);
if (result != NULL) {
assert(*succeeded, "sanity");
return result;
@@ -1702,7 +1711,8 @@
// Retry the allocation once more
result = attempt_allocation_at_safepoint(word_size,
- true /* expect_null_mutator_alloc_region */);
+ context,
+ true /* expect_null_mutator_alloc_region */);
if (result != NULL) {
assert(*succeeded, "sanity");
return result;
@@ -1724,7 +1734,7 @@
// successful, perform the allocation and return the address of the
// allocated block, or else "NULL".
-HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size) {
+HeapWord* G1CollectedHeap::expand_and_allocate(size_t word_size, AllocationContext_t context) {
assert_at_safepoint(true /* should_be_vm_thread */);
verify_region_sets_optional();
@@ -1739,7 +1749,8 @@
_hrm.verify_optional();
verify_region_sets_optional();
return attempt_allocation_at_safepoint(word_size,
- false /* expect_null_mutator_alloc_region */);
+ context,
+ false /* expect_null_mutator_alloc_region */);
}
return NULL;
}
@@ -1816,7 +1827,7 @@
// We should only reach here at the end of a Full GC which means we
// should not not be holding to any GC alloc regions. The method
// below will make sure of that and do any remaining clean up.
- abandon_gc_alloc_regions();
+ _allocator->abandon_gc_alloc_regions();
// Instead of tearing down / rebuilding the free lists here, we
// could instead use the remove_all_pending() method on free_list to
@@ -1849,7 +1860,7 @@
_bot_shared(NULL),
_evac_failure_scan_stack(NULL),
_mark_in_progress(false),
- _cg1r(NULL), _summary_bytes_used(0),
+ _cg1r(NULL),
_g1mm(NULL),
_refine_cte_cl(NULL),
_full_collection(false),
@@ -1861,7 +1872,6 @@
_free_regions_coming(false),
_young_list(new YoungList(this)),
_gc_time_stamp(0),
- _retained_old_gc_alloc_region(NULL),
_survivor_plab_stats(YoungPLABSize, PLABWeight),
_old_plab_stats(OldPLABSize, PLABWeight),
_expand_heap_after_alloc_failure(true),
@@ -1884,6 +1894,7 @@
vm_exit_during_initialization("Failed necessary allocation.");
}
+ _allocator = G1Allocator::create_allocator(_g1h);
_humongous_object_threshold_in_words = HeapRegion::GrainWords / 2;
int n_queues = MAX2((int)ParallelGCThreads, 1);
@@ -1960,15 +1971,10 @@
ReservedSpace heap_rs = Universe::reserve_heap(max_byte_size,
heap_alignment);
- // It is important to do this in a way such that concurrent readers can't
- // temporarily think something is in the heap. (I've actually seen this
- // happen in asserts: DLD.)
- _reserved.set_word_size(0);
- _reserved.set_start((HeapWord*)heap_rs.base());
- _reserved.set_end((HeapWord*)(heap_rs.base() + heap_rs.size()));
+ initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
// Create the gen rem set (and barrier set) for the entire reserved region.
- _rem_set = collector_policy()->create_rem_set(_reserved, 2);
+ _rem_set = collector_policy()->create_rem_set(reserved_region(), 2);
set_barrier_set(rem_set()->bs());
if (!barrier_set()->is_a(BarrierSet::G1SATBCTLogging)) {
vm_exit_during_initialization("G1 requires a G1SATBLoggingCardTableModRefBS");
@@ -2052,7 +2058,7 @@
FreeRegionList::set_unrealistically_long_length(max_regions() + 1);
- _bot_shared = new G1BlockOffsetSharedArray(_reserved, bot_storage);
+ _bot_shared = new G1BlockOffsetSharedArray(reserved_region(), bot_storage);
_g1h = this;
@@ -2127,7 +2133,7 @@
dummy_region->set_top(dummy_region->end());
G1AllocRegion::setup(this, dummy_region);
- init_mutator_alloc_region();
+ _allocator->init_mutator_alloc_region();
// Do create of the monitoring and management support so that
// values in the heap have been properly initialized.
@@ -2237,14 +2243,14 @@
}
void G1CollectedHeap::reset_gc_time_stamps(HeapRegion* hr) {
- assert(!hr->continuesHumongous(), "pre-condition");
+ assert(!hr->is_continues_humongous(), "pre-condition");
hr->reset_gc_time_stamp();
- if (hr->startsHumongous()) {
+ if (hr->is_starts_humongous()) {
uint first_index = hr->hrm_index() + 1;
uint last_index = hr->last_hc_index();
for (uint i = first_index; i < last_index; i += 1) {
HeapRegion* chr = region_at(i);
- assert(chr->continuesHumongous(), "sanity");
+ assert(chr->is_continues_humongous(), "sanity");
chr->reset_gc_time_stamp();
}
}
@@ -2301,21 +2307,12 @@
// Computes the sum of the storage used by the various regions.
-
size_t G1CollectedHeap::used() const {
- assert(Heap_lock->owner() != NULL,
- "Should be owned on this thread's behalf.");
- size_t result = _summary_bytes_used;
- // Read only once in case it is set to NULL concurrently
- HeapRegion* hr = _mutator_alloc_region.get();
- if (hr != NULL)
- result += hr->used();
- return result;
+ return _allocator->used();
}
size_t G1CollectedHeap::used_unlocked() const {
- size_t result = _summary_bytes_used;
- return result;
+ return _allocator->used_unlocked();
}
class SumUsedClosure: public HeapRegionClosure {
@@ -2323,7 +2320,7 @@
public:
SumUsedClosure() : _used(0) {}
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
_used += r->used();
}
return false;
@@ -2355,11 +2352,12 @@
// Let's fill up most of the region
size_t word_size = HeapRegion::GrainWords - 1024;
// And as a result the region we'll allocate will be humongous.
- guarantee(isHumongous(word_size), "sanity");
+ guarantee(is_humongous(word_size), "sanity");
for (uintx i = 0; i < G1DummyRegionsPerGC; ++i) {
// Let's use the existing mechanism for the allocation
- HeapWord* dummy_obj = humongous_obj_allocate(word_size);
+ HeapWord* dummy_obj = humongous_obj_allocate(word_size,
+ AllocationContext::system());
if (dummy_obj != NULL) {
MemRegion mr(dummy_obj, word_size);
CollectedHeap::fill_with_object(mr);
@@ -2510,6 +2508,7 @@
true, /* should_initiate_conc_mark */
g1_policy()->max_pause_time_ms(),
cause);
+ op.set_allocation_context(AllocationContext::current());
VMThread::execute(&op);
if (!op.pause_succeeded()) {
@@ -2581,7 +2580,7 @@
public:
IterateOopClosureRegionClosure(ExtendedOopClosure* cl) : _cl(cl) {}
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
r->oop_iterate(_cl);
}
return false;
@@ -2600,7 +2599,7 @@
public:
IterateObjectClosureRegionClosure(ObjectClosure* cl) : _cl(cl) {}
bool doHeapRegion(HeapRegion* r) {
- if (! r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
r->object_iterate(_cl);
}
return false;
@@ -2682,11 +2681,11 @@
r->claim_value(), _claim_value);
++_failures;
}
- if (!r->isHumongous()) {
+ if (!r->is_humongous()) {
_sh_region = NULL;
- } else if (r->startsHumongous()) {
+ } else if (r->is_starts_humongous()) {
_sh_region = r;
- } else if (r->continuesHumongous()) {
+ } else if (r->is_continues_humongous()) {
if (r->humongous_start_region() != _sh_region) {
gclog_or_tty->print_cr("Region " HR_FORMAT ", "
"HS = "PTR_FORMAT", should be "PTR_FORMAT,
@@ -2720,7 +2719,7 @@
bool doHeapRegion(HeapRegion* hr) {
assert(hr->in_collection_set(), "how?");
- assert(!hr->isHumongous(), "H-region in CSet");
+ assert(!hr->is_humongous(), "H-region in CSet");
if (hr->claim_value() != _claim_value) {
gclog_or_tty->print_cr("CSet Region " HR_FORMAT ", "
"claim value = %d, should be %d",
@@ -2859,7 +2858,7 @@
HeapRegion* G1CollectedHeap::next_compaction_region(const HeapRegion* from) const {
HeapRegion* result = _hrm.next_region_in_heap(from);
- while (result != NULL && result->isHumongous()) {
+ while (result != NULL && result->is_humongous()) {
result = _hrm.next_region_in_heap(result);
}
return result;
@@ -2910,7 +2909,7 @@
// since we can't allow tlabs to grow big enough to accommodate
// humongous objects.
- HeapRegion* hr = _mutator_alloc_region.get();
+ HeapRegion* hr = _allocator->mutator_alloc_region(AllocationContext::current())->get();
size_t max_tlab = max_tlab_size() * wordSize;
if (hr == NULL) {
return max_tlab;
@@ -3219,7 +3218,7 @@
}
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
bool failures = false;
r->verify(_vo, &failures);
if (failures) {
@@ -3597,7 +3596,7 @@
}
}
-void G1CollectedHeap::gc_epilogue(bool full /* Ignored */) {
+void G1CollectedHeap::gc_epilogue(bool full) {
if (G1SummarizeRSetStats &&
(G1SummarizeRSetStatsPeriod > 0) &&
@@ -3614,6 +3613,7 @@
// always_do_update_barrier = true;
resize_all_tlabs();
+ allocation_context_stats().update(full);
// We have just completed a GC. Update the soft reference
// policy with the new heap occupancy
@@ -3631,6 +3631,8 @@
false, /* should_initiate_conc_mark */
g1_policy()->max_pause_time_ms(),
gc_cause);
+
+ op.set_allocation_context(AllocationContext::current());
VMThread::execute(&op);
HeapWord* result = op.result();
@@ -3676,7 +3678,7 @@
bool G1CollectedHeap::humongous_region_is_always_live(uint index) {
HeapRegion* region = region_at(index);
- assert(region->startsHumongous(), "Must start a humongous object");
+ assert(region->is_starts_humongous(), "Must start a humongous object");
return oop(region->bottom())->is_objArray() || !region->rem_set()->is_empty();
}
@@ -3689,7 +3691,7 @@
}
virtual bool doHeapRegion(HeapRegion* r) {
- if (!r->startsHumongous()) {
+ if (!r->is_starts_humongous()) {
return false;
}
G1CollectedHeap* g1h = G1CollectedHeap::heap();
@@ -3961,7 +3963,7 @@
// Forget the current alloc region (we might even choose it to be part
// of the collection set!).
- release_mutator_alloc_region();
+ _allocator->release_mutator_alloc_region();
// We should call this after we retire the mutator alloc
// region(s) so that all the ALLOC / RETIRE events are generated
@@ -4044,7 +4046,7 @@
setup_surviving_young_words();
// Initialize the GC alloc regions.
- init_gc_alloc_regions(evacuation_info);
+ _allocator->init_gc_alloc_regions(evacuation_info);
// Actually do the work...
evacuate_collection_set(evacuation_info);
@@ -4093,7 +4095,7 @@
_young_list->reset_auxilary_lists();
if (evacuation_failed()) {
- _summary_bytes_used = recalculate_used();
+ _allocator->set_used(recalculate_used());
uint n_queues = MAX2((int)ParallelGCThreads, 1);
for (uint i = 0; i < n_queues; i++) {
if (_evacuation_failed_info_array[i].has_failed()) {
@@ -4103,7 +4105,7 @@
} else {
// The "used" of the the collection set have already been subtracted
// when they were freed. Add in the bytes evacuated.
- _summary_bytes_used += g1_policy()->bytes_copied_during_gc();
+ _allocator->increase_used(g1_policy()->bytes_copied_during_gc());
}
if (g1_policy()->during_initial_mark_pause()) {
@@ -4125,7 +4127,7 @@
g1_policy()->print_collection_set(g1_policy()->inc_cset_head(), gclog_or_tty);
#endif // YOUNG_LIST_VERBOSE
- init_mutator_alloc_region();
+ _allocator->init_mutator_alloc_region();
{
size_t expand_bytes = g1_policy()->expansion_amount();
@@ -4270,80 +4272,6 @@
return MIN2(_humongous_object_threshold_in_words, gclab_word_size);
}
-void G1CollectedHeap::init_mutator_alloc_region() {
- assert(_mutator_alloc_region.get() == NULL, "pre-condition");
- _mutator_alloc_region.init();
-}
-
-void G1CollectedHeap::release_mutator_alloc_region() {
- _mutator_alloc_region.release();
- assert(_mutator_alloc_region.get() == NULL, "post-condition");
-}
-
-void G1CollectedHeap::use_retained_old_gc_alloc_region(EvacuationInfo& evacuation_info) {
- HeapRegion* retained_region = _retained_old_gc_alloc_region;
- _retained_old_gc_alloc_region = NULL;
-
- // We will discard the current GC alloc region if:
- // a) it's in the collection set (it can happen!),
- // b) it's already full (no point in using it),
- // c) it's empty (this means that it was emptied during
- // a cleanup and it should be on the free list now), or
- // d) it's humongous (this means that it was emptied
- // during a cleanup and was added to the free list, but
- // has been subsequently used to allocate a humongous
- // object that may be less than the region size).
- if (retained_region != NULL &&
- !retained_region->in_collection_set() &&
- !(retained_region->top() == retained_region->end()) &&
- !retained_region->is_empty() &&
- !retained_region->isHumongous()) {
- retained_region->record_top_and_timestamp();
- // The retained region was added to the old region set when it was
- // retired. We have to remove it now, since we don't allow regions
- // we allocate to in the region sets. We'll re-add it later, when
- // it's retired again.
- _old_set.remove(retained_region);
- bool during_im = g1_policy()->during_initial_mark_pause();
- retained_region->note_start_of_copying(during_im);
- _old_gc_alloc_region.set(retained_region);
- _hr_printer.reuse(retained_region);
- evacuation_info.set_alloc_regions_used_before(retained_region->used());
- }
-}
-
-void G1CollectedHeap::init_gc_alloc_regions(EvacuationInfo& evacuation_info) {
- assert_at_safepoint(true /* should_be_vm_thread */);
-
- _survivor_gc_alloc_region.init();
- _old_gc_alloc_region.init();
-
- use_retained_old_gc_alloc_region(evacuation_info);
-}
-
-void G1CollectedHeap::release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info) {
- evacuation_info.set_allocation_regions(_survivor_gc_alloc_region.count() +
- _old_gc_alloc_region.count());
- _survivor_gc_alloc_region.release();
- // If we have an old GC alloc region to release, we'll save it in
- // _retained_old_gc_alloc_region. If we don't
- // _retained_old_gc_alloc_region will become NULL. This is what we
- // want either way so no reason to check explicitly for either
- // condition.
- _retained_old_gc_alloc_region = _old_gc_alloc_region.release();
-
- if (ResizePLAB) {
- _survivor_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
- _old_plab_stats.adjust_desired_plab_sz(no_of_gc_workers);
- }
-}
-
-void G1CollectedHeap::abandon_gc_alloc_regions() {
- assert(_survivor_gc_alloc_region.get() == NULL, "pre-condition");
- assert(_old_gc_alloc_region.get() == NULL, "pre-condition");
- _retained_old_gc_alloc_region = NULL;
-}
-
void G1CollectedHeap::init_for_evac_failure(OopsInHeapRegionClosure* cl) {
_drain_in_progress = false;
set_evac_failure_closure(cl);
@@ -4484,25 +4412,26 @@
}
HeapWord* G1CollectedHeap::par_allocate_during_gc(GCAllocPurpose purpose,
- size_t word_size) {
+ size_t word_size,
+ AllocationContext_t context) {
if (purpose == GCAllocForSurvived) {
- HeapWord* result = survivor_attempt_allocation(word_size);
+ HeapWord* result = survivor_attempt_allocation(word_size, context);
if (result != NULL) {
return result;
} else {
// Let's try to allocate in the old gen in case we can fit the
// object there.
- return old_attempt_allocation(word_size);
+ return old_attempt_allocation(word_size, context);
}
} else {
assert(purpose == GCAllocForTenured, "sanity");
- HeapWord* result = old_attempt_allocation(word_size);
+ HeapWord* result = old_attempt_allocation(word_size, context);
if (result != NULL) {
return result;
} else {
// Let's try to allocate in the survivors in case we can fit the
// object there.
- return survivor_attempt_allocation(word_size);
+ return survivor_attempt_allocation(word_size, context);
}
}
@@ -4511,9 +4440,6 @@
return NULL;
}
-G1ParGCAllocBuffer::G1ParGCAllocBuffer(size_t gclab_word_size) :
- ParGCAllocBuffer(gclab_word_size), _retired(true) { }
-
void G1ParCopyHelper::mark_object(oop obj) {
assert(!_g1->heap_region_containing(obj)->in_collection_set(), "should not mark objects in the CSet");
@@ -5087,7 +5013,11 @@
_num_entered_barrier(0)
{
nmethod::increase_unloading_clock();
- _first_nmethod = CodeCache::alive_nmethod(CodeCache::first());
+ // Get first alive nmethod
+ NMethodIterator iter = NMethodIterator();
+ if(iter.next_alive()) {
+ _first_nmethod = iter.method();
+ }
_claimed_nmethod = (volatile nmethod*)_first_nmethod;
}
@@ -5130,27 +5060,26 @@
void claim_nmethods(nmethod** claimed_nmethods, int *num_claimed_nmethods) {
nmethod* first;
- nmethod* last;
+ NMethodIterator last;
do {
*num_claimed_nmethods = 0;
- first = last = (nmethod*)_claimed_nmethod;
+ first = (nmethod*)_claimed_nmethod;
+ last = NMethodIterator(first);
if (first != NULL) {
+
for (int i = 0; i < MaxClaimNmethods; i++) {
- last = CodeCache::alive_nmethod(CodeCache::next(last));
-
- if (last == NULL) {
+ if (!last.next_alive()) {
break;
}
-
- claimed_nmethods[i] = last;
+ claimed_nmethods[i] = last.method();
(*num_claimed_nmethods)++;
}
}
- } while ((nmethod*)Atomic::cmpxchg_ptr(last, &_claimed_nmethod, first) != first);
+ } while ((nmethod*)Atomic::cmpxchg_ptr(last.method(), &_claimed_nmethod, first) != first);
}
nmethod* claim_postponed_nmethod() {
@@ -6008,7 +5937,7 @@
}
}
- release_gc_alloc_regions(n_workers, evacuation_info);
+ _allocator->release_gc_alloc_regions(n_workers, evacuation_info);
g1_rem_set()->cleanup_after_oops_into_collection_set_do();
// Reset and re-enable the hot card cache.
@@ -6075,7 +6004,7 @@
void G1CollectedHeap::free_humongous_region(HeapRegion* hr,
FreeRegionList* free_list,
bool par) {
- assert(hr->startsHumongous(), "this is only for starts humongous regions");
+ assert(hr->is_starts_humongous(), "this is only for starts humongous regions");
assert(free_list != NULL, "pre-condition");
size_t hr_capacity = hr->capacity();
@@ -6088,7 +6017,7 @@
uint i = hr->hrm_index() + 1;
while (i < last_index) {
HeapRegion* curr_hr = region_at(i);
- assert(curr_hr->continuesHumongous(), "invariant");
+ assert(curr_hr->is_continues_humongous(), "invariant");
curr_hr->clear_humongous();
free_region(curr_hr, free_list, par);
i += 1;
@@ -6114,10 +6043,7 @@
}
void G1CollectedHeap::decrement_summary_bytes(size_t bytes) {
- assert(_summary_bytes_used >= bytes,
- err_msg("invariant: _summary_bytes_used: "SIZE_FORMAT" should be >= bytes: "SIZE_FORMAT,
- _summary_bytes_used, bytes));
- _summary_bytes_used -= bytes;
+ _allocator->decrease_used(bytes);
}
class G1ParCleanupCTTask : public AbstractGangTask {
@@ -6259,7 +6185,7 @@
bool failures() { return _failures; }
virtual bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) return false;
+ if (hr->is_continues_humongous()) return false;
bool result = _g1h->verify_bitmaps(_caller, hr);
if (!result) {
@@ -6438,7 +6364,7 @@
}
virtual bool doHeapRegion(HeapRegion* r) {
- if (!r->startsHumongous()) {
+ if (!r->is_starts_humongous()) {
return false;
}
@@ -6484,7 +6410,7 @@
if (G1TraceReclaimDeadHumongousObjectsAtYoungGC) {
gclog_or_tty->print_cr("Live humongous %d region %d with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d live-other %d obj array %d",
- r->isHumongous(),
+ r->is_humongous(),
region_idx,
r->rem_set()->occupied(),
r->rem_set()->strong_code_roots_list_length(),
@@ -6503,7 +6429,7 @@
if (G1TraceReclaimDeadHumongousObjectsAtYoungGC) {
gclog_or_tty->print_cr("Reclaim humongous region %d start "PTR_FORMAT" region %d length "UINT32_FORMAT" with remset "SIZE_FORMAT" code roots "SIZE_FORMAT" is marked %d live-other %d obj array %d",
- r->isHumongous(),
+ r->is_humongous(),
r->bottom(),
region_idx,
r->region_num(),
@@ -6693,7 +6619,7 @@
// We ignore young regions, we'll empty the young list afterwards.
// We ignore humongous regions, we're not tearing down the
// humongous regions set.
- assert(r->is_free() || r->is_young() || r->isHumongous(),
+ assert(r->is_free() || r->is_young() || r->is_humongous(),
"it cannot be another type");
}
return false;
@@ -6738,18 +6664,19 @@
}
bool doHeapRegion(HeapRegion* r) {
- if (r->continuesHumongous()) {
+ if (r->is_continues_humongous()) {
return false;
}
if (r->is_empty()) {
// Add free regions to the free list
r->set_free();
+ r->set_allocation_context(AllocationContext::system());
_hrm->insert_into_free_list(r);
} else if (!_free_list_only) {
assert(!r->is_young(), "we should not come across young regions");
- if (r->isHumongous()) {
+ if (r->is_humongous()) {
// We ignore humongous regions, we left the humongous set unchanged
} else {
// Objects that were compacted would have ended up on regions
@@ -6781,12 +6708,12 @@
heap_region_iterate(&cl);
if (!free_list_only) {
- _summary_bytes_used = cl.total_used();
- }
- assert(_summary_bytes_used == recalculate_used(),
- err_msg("inconsistent _summary_bytes_used, "
+ _allocator->set_used(cl.total_used());
+ }
+ assert(_allocator->used_unlocked() == recalculate_used(),
+ err_msg("inconsistent _allocator->used_unlocked(), "
"value: "SIZE_FORMAT" recalculated: "SIZE_FORMAT,
- _summary_bytes_used, recalculate_used()));
+ _allocator->used_unlocked(), recalculate_used()));
}
void G1CollectedHeap::set_refine_cte_cl_concurrency(bool concurrent) {
@@ -6826,7 +6753,7 @@
assert(alloc_region->is_eden(), "all mutator alloc regions should be eden");
g1_policy()->add_region_to_incremental_cset_lhs(alloc_region);
- _summary_bytes_used += allocated_bytes;
+ _allocator->increase_used(allocated_bytes);
_hr_printer.retire(alloc_region);
// We update the eden sizes here, when the region is retired,
// instead of when it's allocated, since this is the point that its
@@ -6834,11 +6761,6 @@
g1mm()->update_eden_size();
}
-HeapRegion* MutatorAllocRegion::allocate_new_region(size_t word_size,
- bool force) {
- return _g1h->new_mutator_alloc_region(word_size, force);
-}
-
void G1CollectedHeap::set_par_threads() {
// Don't change the number of workers. Use the value previously set
// in the workgroup.
@@ -6855,11 +6777,6 @@
set_par_threads(n_workers);
}
-void MutatorAllocRegion::retire_region(HeapRegion* alloc_region,
- size_t allocated_bytes) {
- _g1h->retire_mutator_alloc_region(alloc_region, allocated_bytes);
-}
-
// Methods for the GC alloc regions
HeapRegion* G1CollectedHeap::new_gc_alloc_region(size_t word_size,
@@ -6910,58 +6827,6 @@
_hr_printer.retire(alloc_region);
}
-HeapRegion* SurvivorGCAllocRegion::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(), GCAllocForSurvived);
-}
-
-void SurvivorGCAllocRegion::retire_region(HeapRegion* alloc_region,
- size_t allocated_bytes) {
- _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes,
- GCAllocForSurvived);
-}
-
-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(), GCAllocForTenured);
-}
-
-void OldGCAllocRegion::retire_region(HeapRegion* alloc_region,
- size_t allocated_bytes) {
- _g1h->retire_gc_alloc_region(alloc_region, allocated_bytes,
- GCAllocForTenured);
-}
-
-HeapRegion* OldGCAllocRegion::release() {
- HeapRegion* cur = get();
- if (cur != NULL) {
- // Determine how far we are from the next card boundary. If it is smaller than
- // the minimum object size we can allocate into, expand into the next card.
- HeapWord* top = cur->top();
- HeapWord* aligned_top = (HeapWord*)align_ptr_up(top, G1BlockOffsetSharedArray::N_bytes);
-
- size_t to_allocate_words = pointer_delta(aligned_top, top, HeapWordSize);
-
- if (to_allocate_words != 0) {
- // We are not at a card boundary. Fill up, possibly into the next, taking the
- // end of the region and the minimum object size into account.
- to_allocate_words = MIN2(pointer_delta(cur->end(), cur->top(), HeapWordSize),
- MAX2(to_allocate_words, G1CollectedHeap::min_fill_size()));
-
- // Skip allocation if there is not enough space to allocate even the smallest
- // possible object. In this case this region will not be retained, so the
- // original problem cannot occur.
- if (to_allocate_words >= G1CollectedHeap::min_fill_size()) {
- HeapWord* dummy = attempt_allocation(to_allocate_words, true /* bot_updates */);
- CollectedHeap::fill_with_object(dummy, to_allocate_words);
- }
- }
- }
- return G1AllocRegion::release();
-}
-
// Heap region set verification
class VerifyRegionListsClosure : public HeapRegionClosure {
@@ -6982,13 +6847,13 @@
_old_count(), _humongous_count(), _free_count(){ }
bool doHeapRegion(HeapRegion* hr) {
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
return false;
}
if (hr->is_young()) {
// TODO
- } else if (hr->startsHumongous()) {
+ } else if (hr->is_starts_humongous()) {
assert(hr->containing_set() == _humongous_set, err_msg("Heap region %u is starts humongous but not in humongous set.", hr->hrm_index()));
_humongous_count.increment(1u, hr->capacity());
} else if (hr->is_empty()) {
@@ -7069,7 +6934,7 @@
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
HeapRegion* hr = _g1h->heap_region_containing(obj);
- assert(!hr->continuesHumongous(),
+ assert(!hr->is_continues_humongous(),
err_msg("trying to add code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT
" starting at "HR_FORMAT,
_nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
@@ -7096,7 +6961,7 @@
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
HeapRegion* hr = _g1h->heap_region_containing(obj);
- assert(!hr->continuesHumongous(),
+ assert(!hr->is_continues_humongous(),
err_msg("trying to remove code root "PTR_FORMAT" in continuation of humongous region "HR_FORMAT
" starting at "HR_FORMAT,
_nm, HR_FORMAT_PARAMS(hr), HR_FORMAT_PARAMS(hr->humongous_start_region())));
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,8 @@
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
#define SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
+#include "gc_implementation/g1/g1AllocationContext.hpp"
+#include "gc_implementation/g1/g1Allocator.hpp"
#include "gc_implementation/g1/concurrentMark.hpp"
#include "gc_implementation/g1/evacuationInfo.hpp"
#include "gc_implementation/g1/g1AllocRegion.hpp"
@@ -80,12 +82,6 @@
typedef int RegionIdx_t; // needs to hold [ 0..max_regions() )
typedef int CardIdx_t; // needs to hold [ 0..CardsPerRegion )
-enum GCAllocPurpose {
- GCAllocForTenured,
- GCAllocForSurvived,
- GCAllocPurposeCount
-};
-
class YoungList : public CHeapObj<mtGC> {
private:
G1CollectedHeap* _g1h;
@@ -158,40 +154,6 @@
void print();
};
-class MutatorAllocRegion : 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);
-public:
- MutatorAllocRegion()
- : G1AllocRegion("Mutator Alloc Region", false /* bot_updates */) { }
-};
-
-class SurvivorGCAllocRegion : 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);
-public:
- SurvivorGCAllocRegion()
- : G1AllocRegion("Survivor GC Alloc Region", false /* bot_updates */) { }
-};
-
-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);
-public:
- OldGCAllocRegion()
- : G1AllocRegion("Old GC Alloc Region", true /* bot_updates */) { }
-
- // This specialization of release() makes sure that the last card that has been
- // allocated into has been completely filled by a dummy object.
- // This avoids races when remembered set scanning wants to update the BOT of the
- // last card in the retained old gc alloc region, and allocation threads
- // allocating into that card at the same time.
- virtual HeapRegion* release();
-};
-
// The G1 STW is alive closure.
// An instance is embedded into the G1CH and used as the
// (optional) _is_alive_non_header closure in the STW
@@ -222,6 +184,9 @@
friend class MutatorAllocRegion;
friend class SurvivorGCAllocRegion;
friend class OldGCAllocRegion;
+ friend class G1Allocator;
+ friend class G1DefaultAllocator;
+ friend class G1ResManAllocator;
// Closures used in implementation.
template <G1Barrier barrier, G1Mark do_mark_object>
@@ -232,6 +197,8 @@
friend class G1ParScanClosureSuper;
friend class G1ParEvacuateFollowersClosure;
friend class G1ParTask;
+ friend class G1ParGCAllocator;
+ friend class G1DefaultParGCAllocator;
friend class G1FreeGarbageRegionClosure;
friend class RefineCardTableEntryClosure;
friend class G1PrepareCompactClosure;
@@ -293,44 +260,18 @@
// The sequence of all heap regions in the heap.
HeapRegionManager _hrm;
- // Alloc region used to satisfy mutator allocation requests.
- MutatorAllocRegion _mutator_alloc_region;
+ // Class that handles the different kinds of allocations.
+ G1Allocator* _allocator;
- // Alloc region used to satisfy allocation requests by the GC for
- // survivor objects.
- SurvivorGCAllocRegion _survivor_gc_alloc_region;
+ // Statistics for each allocation context
+ AllocationContextStats _allocation_context_stats;
// PLAB sizing policy for survivors.
PLABStats _survivor_plab_stats;
- // Alloc region used to satisfy allocation requests by the GC for
- // old objects.
- OldGCAllocRegion _old_gc_alloc_region;
-
// PLAB sizing policy for tenured objects.
PLABStats _old_plab_stats;
- PLABStats* stats_for_purpose(GCAllocPurpose purpose) {
- PLABStats* stats = NULL;
-
- switch (purpose) {
- case GCAllocForSurvived:
- stats = &_survivor_plab_stats;
- break;
- case GCAllocForTenured:
- stats = &_old_plab_stats;
- break;
- default:
- assert(false, "unrecognized GCAllocPurpose");
- }
-
- return stats;
- }
-
- // The last old region we allocated to during the last GC.
- // Typically, it is not full so we should re-use it during the next GC.
- HeapRegion* _retained_old_gc_alloc_region;
-
// It specifies whether we should attempt to expand the heap after a
// region allocation failure. If heap expansion fails we set this to
// false so that we don't re-attempt the heap expansion (it's likely
@@ -348,9 +289,6 @@
// It initializes the GC alloc regions at the start of a GC.
void init_gc_alloc_regions(EvacuationInfo& evacuation_info);
- // Setup the retained old gc alloc region as the currrent old gc alloc region.
- void use_retained_old_gc_alloc_region(EvacuationInfo& evacuation_info);
-
// It releases the GC alloc regions at the end of a GC.
void release_gc_alloc_regions(uint no_of_gc_workers, EvacuationInfo& evacuation_info);
@@ -361,13 +299,6 @@
// Helper for monitoring and management support.
G1MonitoringSupport* _g1mm;
- // Determines PLAB size for a particular allocation purpose.
- size_t desired_plab_sz(GCAllocPurpose purpose);
-
- // Outside of GC pauses, the number of bytes used in all regions other
- // than the current allocation region.
- size_t _summary_bytes_used;
-
// Records whether the region at the given index is kept live by roots or
// references from the young generation.
class HumongousIsLiveBiasedMappedArray : public G1BiasedMappedArray<bool> {
@@ -526,11 +457,12 @@
// humongous region.
HeapWord* humongous_obj_allocate_initialize_regions(uint first,
uint num_regions,
- size_t word_size);
+ size_t word_size,
+ AllocationContext_t context);
// Attempt to allocate a humongous object of the given size. Return
// NULL if unsuccessful.
- HeapWord* humongous_obj_allocate(size_t word_size);
+ HeapWord* humongous_obj_allocate(size_t word_size, AllocationContext_t context);
// The following two methods, allocate_new_tlab() and
// mem_allocate(), are the two main entry points from the runtime
@@ -586,6 +518,7 @@
// retry the allocation attempt, potentially scheduling a GC
// pause. This should only be used for non-humongous allocations.
HeapWord* attempt_allocation_slow(size_t word_size,
+ AllocationContext_t context,
unsigned int* gc_count_before_ret,
int* gclocker_retry_count_ret);
@@ -600,7 +533,8 @@
// specifies whether the mutator alloc region is expected to be NULL
// or not.
HeapWord* attempt_allocation_at_safepoint(size_t word_size,
- bool expect_null_mutator_alloc_region);
+ AllocationContext_t context,
+ bool expect_null_mutator_alloc_region);
// It dirties the cards that cover the block so that so that the post
// write barrier never queues anything when updating objects on this
@@ -612,7 +546,9 @@
// allocation region, either by picking one or expanding the
// heap, and then allocate a block of the given size. The block
// may not be a humongous - it must fit into a single heap region.
- HeapWord* par_allocate_during_gc(GCAllocPurpose purpose, size_t word_size);
+ HeapWord* par_allocate_during_gc(GCAllocPurpose purpose,
+ size_t word_size,
+ AllocationContext_t context);
HeapWord* allocate_during_gc_slow(GCAllocPurpose purpose,
HeapRegion* alloc_region,
@@ -624,10 +560,12 @@
void par_allocate_remaining_space(HeapRegion* r);
// 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 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 word_size,
+ AllocationContext_t context);
// These methods are the "callbacks" from the G1AllocRegion class.
@@ -666,13 +604,15 @@
// Callback from VM_G1CollectForAllocation operation.
// This function does everything necessary/possible to satisfy a
// failed allocation request (including collection, expansion, etc.)
- HeapWord* satisfy_failed_allocation(size_t word_size, bool* succeeded);
+ HeapWord* satisfy_failed_allocation(size_t word_size,
+ AllocationContext_t context,
+ bool* succeeded);
// Attempting to expand the heap sufficiently
// to support an allocation of the given "word_size". If
// successful, perform the allocation and return the address of the
// allocated block, or else "NULL".
- HeapWord* expand_and_allocate(size_t word_size);
+ HeapWord* expand_and_allocate(size_t word_size, AllocationContext_t context);
// Process any reference objects discovered during
// an incremental evacuation pause.
@@ -684,6 +624,10 @@
public:
+ G1Allocator* allocator() {
+ return _allocator;
+ }
+
G1MonitoringSupport* g1mm() {
assert(_g1mm != NULL, "should have been initialized");
return _g1mm;
@@ -695,6 +639,29 @@
// (Rounds up to a HeapRegion boundary.)
bool expand(size_t expand_bytes);
+ // Returns the PLAB statistics given a purpose.
+ PLABStats* stats_for_purpose(GCAllocPurpose purpose) {
+ PLABStats* stats = NULL;
+
+ switch (purpose) {
+ case GCAllocForSurvived:
+ stats = &_survivor_plab_stats;
+ break;
+ case GCAllocForTenured:
+ stats = &_old_plab_stats;
+ break;
+ default:
+ assert(false, "unrecognized GCAllocPurpose");
+ }
+
+ return stats;
+ }
+
+ // Determines PLAB size for a particular allocation purpose.
+ size_t desired_plab_sz(GCAllocPurpose purpose);
+
+ inline AllocationContextStats& allocation_context_stats();
+
// Do anything common to GC's.
virtual void gc_prologue(bool full);
virtual void gc_epilogue(bool full);
@@ -1272,7 +1239,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 hr == _retained_old_gc_alloc_region;
+ return _allocator->is_retained_old_region(hr);
}
// Perform a collection of the heap; intended for use in implementing
@@ -1283,6 +1250,11 @@
// The same as above but assume that the caller holds the Heap_lock.
void collect_locked(GCCause::Cause cause);
+ virtual void copy_allocation_context_stats(const jint* contexts,
+ jlong* totals,
+ jbyte* accuracy,
+ jint len);
+
// True iff an evacuation has failed in the most-recent collection.
bool evacuation_failed() { return _evacuation_failed; }
@@ -1540,7 +1512,7 @@
virtual inline bool can_elide_initializing_store_barrier(oop new_obj);
// Returns "true" iff the given word_size is "very large".
- static bool isHumongous(size_t word_size) {
+ static bool is_humongous(size_t word_size) {
// Note this has to be strictly greater-than as the TLABs
// are capped at the humongous threshold and we want to
// ensure that we don't try to allocate a TLAB as
@@ -1747,28 +1719,4 @@
size_t _max_heap_capacity;
};
-class G1ParGCAllocBuffer: public ParGCAllocBuffer {
-private:
- bool _retired;
-
-public:
- G1ParGCAllocBuffer(size_t gclab_word_size);
- virtual ~G1ParGCAllocBuffer() {
- guarantee(_retired, "Allocation buffer has not been retired");
- }
-
- virtual void set_buf(HeapWord* buf) {
- ParGCAllocBuffer::set_buf(buf);
- _retired = false;
- }
-
- virtual void retire(bool end_of_gc, bool retain) {
- if (_retired) {
- return;
- }
- ParGCAllocBuffer::retire(end_of_gc, retain);
- _retired = true;
- }
-};
-
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1COLLECTEDHEAP_HPP
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -37,14 +37,18 @@
// Inline functions for G1CollectedHeap
+inline AllocationContextStats& G1CollectedHeap::allocation_context_stats() {
+ return _allocation_context_stats;
+}
+
// Return the region with the given index. It assumes the index is valid.
inline HeapRegion* G1CollectedHeap::region_at(uint index) const { return _hrm.at(index); }
inline uint G1CollectedHeap::addr_to_region(HeapWord* addr) const {
assert(is_in_reserved(addr),
err_msg("Cannot calculate region index for address "PTR_FORMAT" that is outside of the heap ["PTR_FORMAT", "PTR_FORMAT")",
- p2i(addr), p2i(_reserved.start()), p2i(_reserved.end())));
- return (uint)(pointer_delta(addr, _reserved.start(), sizeof(uint8_t)) >> HeapRegion::LogOfHRGrainBytes);
+ p2i(addr), p2i(reserved_region().start()), p2i(reserved_region().end())));
+ return (uint)(pointer_delta(addr, reserved_region().start(), sizeof(uint8_t)) >> HeapRegion::LogOfHRGrainBytes);
}
inline HeapWord* G1CollectedHeap::bottom_addr_for_region(uint index) const {
@@ -63,7 +67,7 @@
template <class T>
inline HeapRegion* G1CollectedHeap::heap_region_containing(const T addr) const {
HeapRegion* hr = heap_region_containing_raw(addr);
- if (hr->continuesHumongous()) {
+ if (hr->is_continues_humongous()) {
return hr->humongous_start_region();
}
return hr;
@@ -95,13 +99,15 @@
unsigned int* gc_count_before_ret,
int* gclocker_retry_count_ret) {
assert_heap_not_locked_and_not_at_safepoint();
- assert(!isHumongous(word_size), "attempt_allocation() should not "
+ assert(!is_humongous(word_size), "attempt_allocation() should not "
"be called for humongous allocation requests");
- HeapWord* result = _mutator_alloc_region.attempt_allocation(word_size,
- false /* bot_updates */);
+ AllocationContext_t context = AllocationContext::current();
+ HeapWord* result = _allocator->mutator_alloc_region(context)->attempt_allocation(word_size,
+ false /* bot_updates */);
if (result == NULL) {
result = attempt_allocation_slow(word_size,
+ context,
gc_count_before_ret,
gclocker_retry_count_ret);
}
@@ -112,17 +118,17 @@
return result;
}
-inline HeapWord* G1CollectedHeap::survivor_attempt_allocation(size_t
- word_size) {
- assert(!isHumongous(word_size),
+inline HeapWord* G1CollectedHeap::survivor_attempt_allocation(size_t word_size,
+ AllocationContext_t context) {
+ assert(!is_humongous(word_size),
"we should not be seeing humongous-size allocations in this path");
- HeapWord* result = _survivor_gc_alloc_region.attempt_allocation(word_size,
- false /* bot_updates */);
+ HeapWord* result = _allocator->survivor_gc_alloc_region(context)->attempt_allocation(word_size,
+ false /* bot_updates */);
if (result == NULL) {
MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag);
- result = _survivor_gc_alloc_region.attempt_allocation_locked(word_size,
- false /* bot_updates */);
+ result = _allocator->survivor_gc_alloc_region(context)->attempt_allocation_locked(word_size,
+ false /* bot_updates */);
}
if (result != NULL) {
dirty_young_block(result, word_size);
@@ -130,16 +136,17 @@
return result;
}
-inline HeapWord* G1CollectedHeap::old_attempt_allocation(size_t word_size) {
- assert(!isHumongous(word_size),
+inline HeapWord* G1CollectedHeap::old_attempt_allocation(size_t word_size,
+ AllocationContext_t context) {
+ assert(!is_humongous(word_size),
"we should not be seeing humongous-size allocations in this path");
- HeapWord* result = _old_gc_alloc_region.attempt_allocation(word_size,
- true /* bot_updates */);
+ HeapWord* result = _allocator->old_gc_alloc_region(context)->attempt_allocation(word_size,
+ true /* bot_updates */);
if (result == NULL) {
MutexLockerEx x(FreeList_lock, Mutex::_no_safepoint_check_flag);
- result = _old_gc_alloc_region.attempt_allocation_locked(word_size,
- true /* bot_updates */);
+ result = _allocator->old_gc_alloc_region(context)->attempt_allocation_locked(word_size,
+ true /* bot_updates */);
}
return result;
}
@@ -159,7 +166,7 @@
assert(word_size > 0, "pre-condition");
assert(containing_hr->is_in(start), "it should contain start");
assert(containing_hr->is_young(), "it should be young");
- assert(!containing_hr->isHumongous(), "it should not be humongous");
+ assert(!containing_hr->is_humongous(), "it should not be humongous");
HeapWord* end = start + word_size;
assert(containing_hr->is_in(end - 1), "it should also contain end - 1");
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap_ext.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,32 @@
+/*
+ * 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "gc_implementation/g1/g1CollectedHeap.hpp"
+
+void G1CollectedHeap::copy_allocation_context_stats(const jint* contexts,
+ jlong* totals,
+ jbyte* accuracy,
+ jint len) {
+}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1EvacFailure.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -192,7 +192,7 @@
bool during_initial_mark = _g1h->g1_policy()->during_initial_mark_pause();
bool during_conc_mark = _g1h->mark_in_progress();
- assert(!hr->isHumongous(), "sanity");
+ assert(!hr->is_humongous(), "sanity");
assert(hr->in_collection_set(), "bad CS");
if (hr->claimHeapRegion(HeapRegion::ParEvacFailureClaimValue)) {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1HotCardCache.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1HotCardCache.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -43,9 +43,7 @@
_hot_cache_idx = 0;
// For refining the cards in the hot cache in parallel
- uint n_workers = (ParallelGCThreads > 0 ?
- _g1h->workers()->total_workers() : 1);
- _hot_cache_par_chunk_size = MAX2(1, _hot_cache_size / (int)n_workers);
+ _hot_cache_par_chunk_size = (ParallelGCThreads > 0 ? ClaimChunkSize : _hot_cache_size);
_hot_cache_par_claimed_idx = 0;
_card_counts.initialize(card_counts_storage);
--- a/hotspot/src/share/vm/gc_implementation/g1/g1HotCardCache.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1HotCardCache.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -70,6 +70,9 @@
G1CardCounts _card_counts;
+ // The number of cached cards a thread claims when flushing the cache
+ static const int ClaimChunkSize = 32;
+
bool default_use_cache() const {
return (G1ConcRSLogCacheSize > 0);
}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -193,76 +193,6 @@
gc_tracer()->report_object_count_after_gc(&GenMarkSweep::is_alive);
}
-class G1PrepareCompactClosure: public HeapRegionClosure {
- G1CollectedHeap* _g1h;
- ModRefBarrierSet* _mrbs;
- CompactPoint _cp;
- HeapRegionSetCount _humongous_regions_removed;
-
- bool is_cp_initialized() const {
- return _cp.space != NULL;
- }
-
- void prepare_for_compaction(HeapRegion* hr, HeapWord* end) {
- // If this is the first live region that we came across which we can compact,
- // initialize the CompactPoint.
- if (!is_cp_initialized()) {
- _cp.space = hr;
- _cp.threshold = hr->initialize_threshold();
- }
- hr->prepare_for_compaction(&_cp);
- // Also clear the part of the card table that will be unused after
- // compaction.
- _mrbs->clear(MemRegion(hr->compaction_top(), end));
- }
-
- void free_humongous_region(HeapRegion* hr) {
- HeapWord* end = hr->end();
- FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep");
-
- assert(hr->startsHumongous(),
- "Only the start of a humongous region should be freed.");
-
- hr->set_containing_set(NULL);
- _humongous_regions_removed.increment(1u, hr->capacity());
-
- _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */);
- prepare_for_compaction(hr, end);
- dummy_free_list.remove_all();
- }
-
-public:
- G1PrepareCompactClosure()
- : _g1h(G1CollectedHeap::heap()),
- _mrbs(_g1h->g1_barrier_set()),
- _cp(NULL),
- _humongous_regions_removed() { }
-
- void update_sets() {
- // We'll recalculate total used bytes and recreate the free list
- // at the end of the GC, so no point in updating those values here.
- HeapRegionSetCount empty_set;
- _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed);
- }
-
- bool doHeapRegion(HeapRegion* hr) {
- if (hr->isHumongous()) {
- if (hr->startsHumongous()) {
- oop obj = oop(hr->bottom());
- if (obj->is_gc_marked()) {
- obj->forward_to(obj);
- } else {
- free_humongous_region(hr);
- }
- } else {
- assert(hr->continuesHumongous(), "Invalid humongous.");
- }
- } else {
- prepare_for_compaction(hr, hr->end());
- }
- return false;
- }
-};
void G1MarkSweep::mark_sweep_phase2() {
// Now all live objects are marked, compute the new object addresses.
@@ -271,21 +201,17 @@
// phase2, phase3 and phase4, but the ValidateMarkSweep live oops
// tracking expects us to do so. See comment under phase4.
- G1CollectedHeap* g1h = G1CollectedHeap::heap();
-
GCTraceTime tm("phase 2", G1Log::fine() && Verbose, true, gc_timer(), gc_tracer()->gc_id());
GenMarkSweep::trace("2");
- G1PrepareCompactClosure blk;
- g1h->heap_region_iterate(&blk);
- blk.update_sets();
+ prepare_compaction();
}
class G1AdjustPointersClosure: public HeapRegionClosure {
public:
bool doHeapRegion(HeapRegion* r) {
- if (r->isHumongous()) {
- if (r->startsHumongous()) {
+ if (r->is_humongous()) {
+ if (r->is_starts_humongous()) {
// We must adjust the pointers on the single H object.
oop obj = oop(r->bottom());
// point all the oops to the new location
@@ -340,8 +266,8 @@
G1SpaceCompactClosure() {}
bool doHeapRegion(HeapRegion* hr) {
- if (hr->isHumongous()) {
- if (hr->startsHumongous()) {
+ if (hr->is_humongous()) {
+ if (hr->is_starts_humongous()) {
oop obj = oop(hr->bottom());
if (obj->is_gc_marked()) {
obj->init_mark();
@@ -373,3 +299,68 @@
g1h->heap_region_iterate(&blk);
}
+
+void G1MarkSweep::prepare_compaction_work(G1PrepareCompactClosure* blk) {
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ g1h->heap_region_iterate(blk);
+ blk->update_sets();
+}
+
+void G1PrepareCompactClosure::free_humongous_region(HeapRegion* hr) {
+ HeapWord* end = hr->end();
+ FreeRegionList dummy_free_list("Dummy Free List for G1MarkSweep");
+
+ assert(hr->is_starts_humongous(),
+ "Only the start of a humongous region should be freed.");
+
+ hr->set_containing_set(NULL);
+ _humongous_regions_removed.increment(1u, hr->capacity());
+
+ _g1h->free_humongous_region(hr, &dummy_free_list, false /* par */);
+ prepare_for_compaction(hr, end);
+ dummy_free_list.remove_all();
+}
+
+void G1PrepareCompactClosure::prepare_for_compaction(HeapRegion* hr, HeapWord* end) {
+ // If this is the first live region that we came across which we can compact,
+ // initialize the CompactPoint.
+ if (!is_cp_initialized()) {
+ _cp.space = hr;
+ _cp.threshold = hr->initialize_threshold();
+ }
+ prepare_for_compaction_work(&_cp, hr, end);
+}
+
+void G1PrepareCompactClosure::prepare_for_compaction_work(CompactPoint* cp,
+ HeapRegion* hr,
+ HeapWord* end) {
+ hr->prepare_for_compaction(cp);
+ // Also clear the part of the card table that will be unused after
+ // compaction.
+ _mrbs->clear(MemRegion(hr->compaction_top(), end));
+}
+
+void G1PrepareCompactClosure::update_sets() {
+ // We'll recalculate total used bytes and recreate the free list
+ // at the end of the GC, so no point in updating those values here.
+ HeapRegionSetCount empty_set;
+ _g1h->remove_from_old_sets(empty_set, _humongous_regions_removed);
+}
+
+bool G1PrepareCompactClosure::doHeapRegion(HeapRegion* hr) {
+ if (hr->is_humongous()) {
+ if (hr->is_starts_humongous()) {
+ oop obj = oop(hr->bottom());
+ if (obj->is_gc_marked()) {
+ obj->forward_to(obj);
+ } else {
+ free_humongous_region(hr);
+ }
+ } else {
+ assert(hr->is_continues_humongous(), "Invalid humongous.");
+ }
+ } else {
+ prepare_for_compaction(hr, hr->end());
+ }
+ return false;
+}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -43,7 +43,7 @@
// compaction.
//
// Class unloading will only occur when a full gc is invoked.
-
+class G1PrepareCompactClosure;
class G1MarkSweep : AllStatic {
friend class VM_G1MarkSweep;
@@ -70,6 +70,30 @@
static void mark_sweep_phase4();
static void allocate_stacks();
+ static void prepare_compaction();
+ static void prepare_compaction_work(G1PrepareCompactClosure* blk);
+};
+
+class G1PrepareCompactClosure : public HeapRegionClosure {
+ protected:
+ G1CollectedHeap* _g1h;
+ ModRefBarrierSet* _mrbs;
+ CompactPoint _cp;
+ HeapRegionSetCount _humongous_regions_removed;
+
+ virtual void prepare_for_compaction(HeapRegion* hr, HeapWord* end);
+ void prepare_for_compaction_work(CompactPoint* cp, HeapRegion* hr, HeapWord* end);
+ void free_humongous_region(HeapRegion* hr);
+ bool is_cp_initialized() const { return _cp.space != NULL; }
+
+ public:
+ G1PrepareCompactClosure() :
+ _g1h(G1CollectedHeap::heap()),
+ _mrbs(_g1h->g1_barrier_set()),
+ _humongous_regions_removed() { }
+
+ void update_sets();
+ bool doHeapRegion(HeapRegion* hr);
};
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_G1MARKSWEEP_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1MarkSweep_ext.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2001, 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 "gc_implementation/g1/g1MarkSweep.hpp"
+
+void G1MarkSweep::prepare_compaction() {
+ G1PrepareCompactClosure blk;
+ G1MarkSweep::prepare_compaction_work(&blk);
+}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -38,11 +38,8 @@
_g1_rem(g1h->g1_rem_set()),
_hash_seed(17), _queue_num(queue_num),
_term_attempts(0),
- _surviving_alloc_buffer(g1h->desired_plab_sz(GCAllocForSurvived)),
- _tenured_alloc_buffer(g1h->desired_plab_sz(GCAllocForTenured)),
_age_table(false), _scanner(g1h, rp),
- _strong_roots_time(0), _term_time(0),
- _alloc_buffer_waste(0), _undo_waste(0) {
+ _strong_roots_time(0), _term_time(0) {
_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
@@ -60,14 +57,14 @@
_surviving_young_words = _surviving_young_words_base + PADDING_ELEM_NUM;
memset(_surviving_young_words, 0, (size_t) real_length * sizeof(size_t));
- _alloc_buffers[GCAllocForSurvived] = &_surviving_alloc_buffer;
- _alloc_buffers[GCAllocForTenured] = &_tenured_alloc_buffer;
+ _g1_par_allocator = G1ParGCAllocator::create_allocator(_g1h);
_start = os::elapsedTime();
}
G1ParScanThreadState::~G1ParScanThreadState() {
- retire_alloc_buffers();
+ _g1_par_allocator->retire_alloc_buffers();
+ delete _g1_par_allocator;
FREE_C_HEAP_ARRAY(size_t, _surviving_young_words_base, mtGC);
}
@@ -90,14 +87,16 @@
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;
+ const size_t alloc_buffer_waste = _g1_par_allocator->alloc_buffer_waste();
+ const size_t undo_waste = _g1_par_allocator->undo_waste();
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),
i, 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);
+ (alloc_buffer_waste + undo_waste) * HeapWordSize / K,
+ alloc_buffer_waste * HeapWordSize / K,
+ undo_waste * HeapWordSize / K);
}
#ifdef ASSERT
@@ -164,12 +163,13 @@
: m->age();
GCAllocPurpose alloc_purpose = g1p->evacuation_destination(from_region, age,
word_sz);
- HeapWord* obj_ptr = allocate(alloc_purpose, word_sz);
+ AllocationContext_t context = from_region->allocation_context();
+ HeapWord* obj_ptr = _g1_par_allocator->allocate(alloc_purpose, word_sz, context);
#ifndef PRODUCT
// Should this evacuation fail?
if (_g1h->evacuation_should_fail()) {
if (obj_ptr != NULL) {
- undo_allocation(alloc_purpose, obj_ptr, word_sz);
+ _g1_par_allocator->undo_allocation(alloc_purpose, obj_ptr, word_sz, context);
obj_ptr = NULL;
}
}
@@ -246,66 +246,8 @@
obj->oop_iterate_backwards(&_scanner);
}
} else {
- undo_allocation(alloc_purpose, obj_ptr, word_sz);
+ _g1_par_allocator->undo_allocation(alloc_purpose, obj_ptr, word_sz, context);
obj = forward_ptr;
}
return obj;
}
-
-HeapWord* G1ParScanThreadState::allocate_slow(GCAllocPurpose purpose, size_t word_sz) {
- HeapWord* obj = NULL;
- size_t gclab_word_size = _g1h->desired_plab_sz(purpose);
- if (word_sz * 100 < gclab_word_size * ParallelGCBufferWastePct) {
- G1ParGCAllocBuffer* alloc_buf = alloc_buffer(purpose);
- add_to_alloc_buffer_waste(alloc_buf->words_remaining());
- alloc_buf->retire(false /* end_of_gc */, false /* retain */);
-
- HeapWord* buf = _g1h->par_allocate_during_gc(purpose, gclab_word_size);
- if (buf == NULL) {
- return NULL; // Let caller handle allocation failure.
- }
- // Otherwise.
- alloc_buf->set_word_size(gclab_word_size);
- alloc_buf->set_buf(buf);
-
- obj = alloc_buf->allocate(word_sz);
- assert(obj != NULL, "buffer was definitely big enough...");
- } else {
- obj = _g1h->par_allocate_during_gc(purpose, word_sz);
- }
- return obj;
-}
-
-void G1ParScanThreadState::undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz) {
- if (alloc_buffer(purpose)->contains(obj)) {
- assert(alloc_buffer(purpose)->contains(obj + word_sz - 1),
- "should contain whole object");
- alloc_buffer(purpose)->undo_allocation(obj, word_sz);
- } else {
- CollectedHeap::fill_with_object(obj, word_sz);
- add_to_undo_waste(word_sz);
- }
-}
-
-HeapWord* G1ParScanThreadState::allocate(GCAllocPurpose purpose, size_t word_sz) {
- HeapWord* obj = NULL;
- if (purpose == GCAllocForSurvived) {
- obj = alloc_buffer(GCAllocForSurvived)->allocate_aligned(word_sz, SurvivorAlignmentInBytes);
- } else {
- obj = alloc_buffer(GCAllocForTenured)->allocate(word_sz);
- }
- if (obj != NULL) {
- return obj;
- }
- return allocate_slow(purpose, word_sz);
-}
-
-void G1ParScanThreadState::retire_alloc_buffers() {
- for (int ap = 0; ap < GCAllocPurposeCount; ++ap) {
- size_t waste = _alloc_buffers[ap]->words_remaining();
- add_to_alloc_buffer_waste(waste);
- _alloc_buffers[ap]->flush_stats_and_retire(_g1h->stats_for_purpose((GCAllocPurpose)ap),
- true /* end_of_gc */,
- false /* retain */);
- }
-}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1ParScanThreadState.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -46,9 +46,8 @@
G1SATBCardTableModRefBS* _ct_bs;
G1RemSet* _g1_rem;
- G1ParGCAllocBuffer _surviving_alloc_buffer;
- G1ParGCAllocBuffer _tenured_alloc_buffer;
- G1ParGCAllocBuffer* _alloc_buffers[GCAllocPurposeCount];
+ G1ParGCAllocator* _g1_par_allocator;
+
ageTable _age_table;
G1ParScanClosure _scanner;
@@ -78,7 +77,6 @@
#define PADDING_ELEM_NUM (DEFAULT_CACHE_LINE_SIZE / sizeof(size_t))
void add_to_alloc_buffer_waste(size_t waste) { _alloc_buffer_waste += waste; }
-
void add_to_undo_waste(size_t waste) { _undo_waste += waste; }
DirtyCardQueue& dirty_card_queue() { return _dcq; }
@@ -90,13 +88,6 @@
ageTable* age_table() { return &_age_table; }
- G1ParGCAllocBuffer* alloc_buffer(GCAllocPurpose purpose) {
- return _alloc_buffers[purpose];
- }
-
- size_t alloc_buffer_waste() const { return _alloc_buffer_waste; }
- size_t undo_waste() const { return _undo_waste; }
-
#ifdef ASSERT
bool queue_is_empty() const { return _refs->is_empty(); }
@@ -110,7 +101,7 @@
_refs->push(ref);
}
- template <class T> void update_rs(HeapRegion* from, T* p, int tid) {
+ template <class T> void update_rs(HeapRegion* from, T* p, uint tid) {
// If the new value of the field points to the same region or
// is the to-space, we don't need to include it in the Rset updates.
if (!from->is_in_reserved(oopDesc::load_decode_heap_oop(p)) && !from->is_survivor()) {
@@ -121,12 +112,6 @@
}
}
}
- private:
-
- inline HeapWord* allocate(GCAllocPurpose purpose, size_t word_sz);
- inline HeapWord* allocate_slow(GCAllocPurpose purpose, size_t word_sz);
- inline void undo_allocation(GCAllocPurpose purpose, HeapWord* obj, size_t word_sz);
-
public:
void set_evac_failure_closure(OopsInHeapRegionClosure* evac_failure_cl) {
@@ -172,8 +157,6 @@
}
private:
- void retire_alloc_buffers();
-
#define G1_PARTIAL_ARRAY_MASK 0x2
inline bool has_partial_array_mask(oop* ref) const {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -413,7 +413,7 @@
_ctbs(_g1h->g1_barrier_set()) {}
bool doHeapRegion(HeapRegion* r) {
- if (!r->continuesHumongous()) {
+ if (!r->is_continues_humongous()) {
r->rem_set()->scrub(_ctbs, _region_bm, _card_bm);
}
return false;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -119,7 +119,7 @@
// Record, if necessary, the fact that *p (where "p" is in region "from",
// which is required to be non-NULL) has changed to a new non-NULL value.
template <class T> void write_ref(HeapRegion* from, T* p);
- template <class T> void par_write_ref(HeapRegion* from, T* p, int tid);
+ template <class T> void par_write_ref(HeapRegion* from, T* p, uint tid);
// Requires "region_bm" and "card_bm" to be bitmaps with 1 bit per region
// or card, respectively, such that a region or card with a corresponding
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSet.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -44,7 +44,7 @@
}
template <class T>
-inline void G1RemSet::par_write_ref(HeapRegion* from, T* p, int tid) {
+inline void G1RemSet::par_write_ref(HeapRegion* from, T* p, uint tid) {
oop obj = oopDesc::load_decode_heap_oop(p);
if (obj == NULL) {
return;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1RemSetSummary.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -263,7 +263,7 @@
current = &_free;
} else if (r->is_young()) {
current = &_young;
- } else if (r->isHumongous()) {
+ } else if (r->is_humongous()) {
current = &_humonguous;
} else if (r->is_old()) {
current = &_old;
--- a/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1_globals.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -262,12 +262,12 @@
"Percentage (0-100) of the heap size to use as default " \
" maximum young gen size.") \
\
- experimental(uintx, G1MixedGCLiveThresholdPercent, 65, \
+ experimental(uintx, G1MixedGCLiveThresholdPercent, 85, \
"Threshold for regions to be considered for inclusion in the " \
"collection set of mixed GCs. " \
"Regions with live bytes exceeding this will not be collected.") \
\
- product(uintx, G1HeapWastePercent, 10, \
+ product(uintx, G1HeapWastePercent, 5, \
"Amount of space, expressed as a percentage of the heap size, " \
"that G1 is willing not to collect to avoid expensive GCs.") \
\
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -28,6 +28,7 @@
#include "gc_implementation/g1/g1CollectedHeap.inline.hpp"
#include "gc_implementation/g1/g1OopClosures.inline.hpp"
#include "gc_implementation/g1/heapRegion.inline.hpp"
+#include "gc_implementation/g1/heapRegionBounds.inline.hpp"
#include "gc_implementation/g1/heapRegionRemSet.hpp"
#include "gc_implementation/g1/heapRegionManager.inline.hpp"
#include "gc_implementation/shared/liveRange.hpp"
@@ -138,32 +139,16 @@
}
}
-// Minimum region size; we won't go lower than that.
-// We might want to decrease this in the future, to deal with small
-// heaps a bit more efficiently.
-#define MIN_REGION_SIZE ( 1024 * 1024 )
-
-// Maximum region size; we don't go higher than that. There's a good
-// reason for having an upper bound. We don't want regions to get too
-// large, otherwise cleanup's effectiveness would decrease as there
-// will be fewer opportunities to find totally empty regions after
-// marking.
-#define MAX_REGION_SIZE ( 32 * 1024 * 1024 )
-
-// The automatic region size calculation will try to have around this
-// many regions in the heap (based on the min heap size).
-#define TARGET_REGION_NUMBER 2048
-
size_t HeapRegion::max_region_size() {
- return (size_t)MAX_REGION_SIZE;
+ return HeapRegionBounds::max_size();
}
void HeapRegion::setup_heap_region_size(size_t initial_heap_size, size_t max_heap_size) {
uintx region_size = G1HeapRegionSize;
if (FLAG_IS_DEFAULT(G1HeapRegionSize)) {
size_t average_heap_size = (initial_heap_size + max_heap_size) / 2;
- region_size = MAX2(average_heap_size / TARGET_REGION_NUMBER,
- (uintx) MIN_REGION_SIZE);
+ region_size = MAX2(average_heap_size / HeapRegionBounds::target_number(),
+ (uintx) HeapRegionBounds::min_size());
}
int region_size_log = log2_long((jlong) region_size);
@@ -173,10 +158,10 @@
region_size = ((uintx)1 << region_size_log);
// Now make sure that we don't go over or under our limits.
- if (region_size < MIN_REGION_SIZE) {
- region_size = MIN_REGION_SIZE;
- } else if (region_size > MAX_REGION_SIZE) {
- region_size = MAX_REGION_SIZE;
+ if (region_size < HeapRegionBounds::min_size()) {
+ region_size = HeapRegionBounds::min_size();
+ } else if (region_size > HeapRegionBounds::max_size()) {
+ region_size = HeapRegionBounds::max_size();
}
// And recalculate the log.
@@ -213,11 +198,12 @@
void HeapRegion::hr_clear(bool par, bool clear_space, bool locked) {
assert(_humongous_start_region == NULL,
"we should have already filtered out humongous regions");
- assert(_end == _orig_end,
+ assert(_end == orig_end(),
"we should have already filtered out humongous regions");
_in_collection_set = false;
+ set_allocation_context(AllocationContext::system());
set_young_index_in_cset(-1);
uninstall_surv_rate_group();
set_free();
@@ -264,9 +250,9 @@
_gc_efficiency = (double) reclaimable_bytes() / region_elapsed_time_ms;
}
-void HeapRegion::set_startsHumongous(HeapWord* new_top, HeapWord* new_end) {
- assert(!isHumongous(), "sanity / pre-condition");
- assert(end() == _orig_end,
+void HeapRegion::set_starts_humongous(HeapWord* new_top, HeapWord* new_end) {
+ assert(!is_humongous(), "sanity / pre-condition");
+ assert(end() == orig_end(),
"Should be normal before the humongous object allocation");
assert(top() == bottom(), "should be empty");
assert(bottom() <= new_top && new_top <= new_end, "pre-condition");
@@ -278,30 +264,30 @@
_offsets.set_for_starts_humongous(new_top);
}
-void HeapRegion::set_continuesHumongous(HeapRegion* first_hr) {
- assert(!isHumongous(), "sanity / pre-condition");
- assert(end() == _orig_end,
+void HeapRegion::set_continues_humongous(HeapRegion* first_hr) {
+ assert(!is_humongous(), "sanity / pre-condition");
+ assert(end() == orig_end(),
"Should be normal before the humongous object allocation");
assert(top() == bottom(), "should be empty");
- assert(first_hr->startsHumongous(), "pre-condition");
+ assert(first_hr->is_starts_humongous(), "pre-condition");
_type.set_continues_humongous();
_humongous_start_region = first_hr;
}
void HeapRegion::clear_humongous() {
- assert(isHumongous(), "pre-condition");
+ assert(is_humongous(), "pre-condition");
- if (startsHumongous()) {
+ if (is_starts_humongous()) {
assert(top() <= end(), "pre-condition");
- set_end(_orig_end);
+ set_end(orig_end());
if (top() > end()) {
// at least one "continues humongous" region after it
set_top(end());
}
} else {
// continues humongous
- assert(end() == _orig_end, "sanity");
+ assert(end() == orig_end(), "sanity");
}
assert(capacity() == HeapRegion::GrainBytes, "pre-condition");
@@ -324,9 +310,10 @@
MemRegion mr) :
G1OffsetTableContigSpace(sharedOffsetArray, mr),
_hrm_index(hrm_index),
+ _allocation_context(AllocationContext::system()),
_humongous_start_region(NULL),
_in_collection_set(false),
- _next_in_special_set(NULL), _orig_end(NULL),
+ _next_in_special_set(NULL),
_claimed(InitialClaimValue), _evacuation_failed(false),
_prev_marked_bytes(0), _next_marked_bytes(0), _gc_efficiency(0.0),
_next_young_region(NULL),
@@ -349,10 +336,14 @@
G1OffsetTableContigSpace::initialize(mr, clear_space, mangle_space);
- _orig_end = mr.end();
hr_clear(false /*par*/, false /*clear_space*/);
set_top(bottom());
record_top_and_timestamp();
+
+ assert(mr.end() == orig_end(),
+ err_msg("Given region end address " PTR_FORMAT " should match exactly "
+ "bottom plus one region size, i.e. " PTR_FORMAT,
+ p2i(mr.end()), p2i(orig_end())));
}
CompactibleSpace* HeapRegion::next_compaction_space() const {
@@ -663,7 +654,7 @@
return;
}
- if (continuesHumongous()) {
+ if (is_continues_humongous()) {
if (strong_code_roots_length > 0) {
gclog_or_tty->print_cr("region "HR_FORMAT" is a continuation of a humongous "
"region but has "SIZE_FORMAT" code root entries",
@@ -683,6 +674,8 @@
void HeapRegion::print() const { print_on(gclog_or_tty); }
void HeapRegion::print_on(outputStream* st) const {
+ st->print("AC%4u", allocation_context());
+
st->print(" %2s", get_short_type_str());
if (in_collection_set())
st->print(" CS");
@@ -788,7 +781,7 @@
HeapRegion* to = _g1h->heap_region_containing(obj);
if (from != NULL && to != NULL &&
from != to &&
- !to->isHumongous()) {
+ !to->is_humongous()) {
jbyte cv_obj = *_bs->byte_for_const(_containing_obj);
jbyte cv_field = *_bs->byte_for_const(p);
const jbyte dirty = CardTableModRefBS::dirty_card_val();
@@ -842,19 +835,19 @@
HeapWord* p = bottom();
HeapWord* prev_p = NULL;
VerifyLiveClosure vl_cl(g1, vo);
- bool is_humongous = isHumongous();
+ bool is_region_humongous = is_humongous();
size_t object_num = 0;
while (p < top()) {
oop obj = oop(p);
size_t obj_size = block_size(p);
object_num += 1;
- if (is_humongous != g1->isHumongous(obj_size) &&
+ if (is_region_humongous != g1->is_humongous(obj_size) &&
!g1->is_obj_dead(obj, this)) { // Dead objects may have bigger block_size since they span several objects.
gclog_or_tty->print_cr("obj "PTR_FORMAT" is of %shumongous size ("
SIZE_FORMAT" words) in a %shumongous region",
- p, g1->isHumongous(obj_size) ? "" : "non-",
- obj_size, is_humongous ? "" : "non-");
+ p, g1->is_humongous(obj_size) ? "" : "non-",
+ obj_size, is_region_humongous ? "" : "non-");
*failures = true;
return;
}
@@ -963,7 +956,7 @@
}
}
- if (is_humongous && object_num > 1) {
+ if (is_region_humongous && object_num > 1) {
gclog_or_tty->print_cr("region ["PTR_FORMAT","PTR_FORMAT"] is humongous "
"but has "SIZE_FORMAT", objects",
bottom(), end(), object_num);
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegion.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,7 @@
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP
#define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGION_HPP
+#include "gc_implementation/g1/g1AllocationContext.hpp"
#include "gc_implementation/g1/g1BlockOffsetTable.hpp"
#include "gc_implementation/g1/g1_specialized_oop_closures.hpp"
#include "gc_implementation/g1/heapRegionType.hpp"
@@ -222,13 +223,12 @@
// The index of this region in the heap region sequence.
uint _hrm_index;
+ AllocationContext_t _allocation_context;
+
HeapRegionType _type;
// For a humongous region, region in which it starts.
HeapRegion* _humongous_start_region;
- // For the start region of a humongous sequence, it's original end().
- HeapWord* _orig_end;
-
// True iff the region is in current collection_set.
bool _in_collection_set;
@@ -417,9 +417,9 @@
bool is_eden() const { return _type.is_eden(); }
bool is_survivor() const { return _type.is_survivor(); }
- bool isHumongous() const { return _type.is_humongous(); }
- bool startsHumongous() const { return _type.is_starts_humongous(); }
- bool continuesHumongous() const { return _type.is_continues_humongous(); }
+ bool is_humongous() const { return _type.is_humongous(); }
+ bool is_starts_humongous() const { return _type.is_starts_humongous(); }
+ bool is_continues_humongous() const { return _type.is_continues_humongous(); }
bool is_old() const { return _type.is_old(); }
@@ -431,10 +431,10 @@
// Return the number of distinct regions that are covered by this region:
// 1 if the region is not humongous, >= 1 if the region is humongous.
uint region_num() const {
- if (!isHumongous()) {
+ if (!is_humongous()) {
return 1U;
} else {
- assert(startsHumongous(), "doesn't make sense on HC regions");
+ assert(is_starts_humongous(), "doesn't make sense on HC regions");
assert(capacity() % HeapRegion::GrainBytes == 0, "sanity");
return (uint) (capacity() >> HeapRegion::LogOfHRGrainBytes);
}
@@ -443,7 +443,7 @@
// Return the index + 1 of the last HC regions that's associated
// with this HS region.
uint last_hc_index() const {
- assert(startsHumongous(), "don't call this otherwise");
+ assert(is_starts_humongous(), "don't call this otherwise");
return hrm_index() + region_num();
}
@@ -452,7 +452,7 @@
// their _end set up to be the end of the last continues region of the
// corresponding humongous object.
bool is_in_reserved_raw(const void* p) const {
- return _bottom <= p && p < _orig_end;
+ return _bottom <= p && p < orig_end();
}
// Makes the current region be a "starts humongous" region, i.e.,
@@ -478,12 +478,12 @@
// humongous regions can be calculated by just looking at the
// "starts humongous" regions and by ignoring the "continues
// humongous" regions.
- void set_startsHumongous(HeapWord* new_top, HeapWord* new_end);
+ void set_starts_humongous(HeapWord* new_top, HeapWord* new_end);
// Makes the current region be a "continues humongous'
// region. first_hr is the "start humongous" region of the series
// which this region will be part of.
- void set_continuesHumongous(HeapRegion* first_hr);
+ void set_continues_humongous(HeapRegion* first_hr);
// Unsets the humongous-related fields on the region.
void clear_humongous();
@@ -513,6 +513,14 @@
_next_in_special_set = r;
}
+ void set_allocation_context(AllocationContext_t context) {
+ _allocation_context = context;
+ }
+
+ AllocationContext_t allocation_context() const {
+ return _allocation_context;
+ }
+
// Methods used by the HeapRegionSetBase class and subclasses.
// Getter and setter for the next and prev fields used to link regions into
@@ -556,7 +564,8 @@
void set_next_dirty_cards_region(HeapRegion* hr) { _next_dirty_cards_region = hr; }
bool is_on_dirty_cards_region_list() const { return get_next_dirty_cards_region() != NULL; }
- HeapWord* orig_end() const { return _orig_end; }
+ // For the start region of a humongous sequence, it's original end().
+ HeapWord* orig_end() const { return _bottom + GrainWords; }
// Reset HR stuff to default values.
void hr_clear(bool par, bool clear_space, bool locked = false);
@@ -603,7 +612,7 @@
bool is_marked() { return _prev_top_at_mark_start != bottom(); }
void reset_during_compaction() {
- assert(isHumongous() && startsHumongous(),
+ assert(is_starts_humongous(),
"should only be called for starts humongous regions");
zero_marked_bytes();
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionBounds.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,52 @@
+/*
+ * 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_GC_IMPLEMENTATION_G1_HEAPREGIONBOUNDS_HPP
+#define SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONBOUNDS_HPP
+
+class HeapRegionBounds : public AllStatic {
+private:
+ // Minimum region size; we won't go lower than that.
+ // We might want to decrease this in the future, to deal with small
+ // heaps a bit more efficiently.
+ static const size_t MIN_REGION_SIZE = 1024 * 1024;
+
+ // Maximum region size; we don't go higher than that. There's a good
+ // reason for having an upper bound. We don't want regions to get too
+ // large, otherwise cleanup's effectiveness would decrease as there
+ // will be fewer opportunities to find totally empty regions after
+ // marking.
+ static const size_t MAX_REGION_SIZE = 32 * 1024 * 1024;
+
+ // The automatic region size calculation will try to have around this
+ // many regions in the heap (based on the min heap size).
+ static const size_t TARGET_REGION_NUMBER = 2048;
+
+public:
+ static inline size_t min_size();
+ static inline size_t max_size();
+ static inline size_t target_number();
+};
+
+#endif // SHARE_VM_GC_IMPLEMENTATION_G1_HEAPREGIONBOUNDS_HPP
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionBounds.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,37 @@
+/*
+ * 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.
+ *
+ */
+
+#include "gc_implementation/g1/heapRegionBounds.hpp"
+
+size_t HeapRegionBounds::min_size() {
+ return MIN_REGION_SIZE;
+}
+
+size_t HeapRegionBounds::max_size() {
+ return MAX_REGION_SIZE;
+}
+
+size_t HeapRegionBounds::target_number() {
+ return TARGET_REGION_NUMBER;
+}
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionManager.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -66,10 +66,11 @@
#endif
HeapRegion* HeapRegionManager::new_heap_region(uint hrm_index) {
- HeapWord* bottom = G1CollectedHeap::heap()->bottom_addr_for_region(hrm_index);
+ G1CollectedHeap* g1h = G1CollectedHeap::heap();
+ HeapWord* bottom = g1h->bottom_addr_for_region(hrm_index);
MemRegion mr(bottom, bottom + HeapRegion::GrainWords);
assert(reserved().contains(mr), "invariant");
- return new HeapRegion(hrm_index, G1CollectedHeap::heap()->bot_shared(), mr);
+ return g1h->allocator()->new_heap_region(hrm_index, g1h->bot_shared(), mr);
}
void HeapRegionManager::commit_regions(uint index, size_t num_regions) {
@@ -281,7 +282,7 @@
// We'll ignore "continues humongous" regions (we'll process them
// when we come across their corresponding "start humongous"
// region) and regions already claimed.
- if (r->claim_value() == claim_value || r->continuesHumongous()) {
+ if (r->claim_value() == claim_value || r->is_continues_humongous()) {
continue;
}
// OK, try to claim it
@@ -289,7 +290,7 @@
continue;
}
// Success!
- if (r->startsHumongous()) {
+ if (r->is_starts_humongous()) {
// If the region is "starts humongous" we'll iterate over its
// "continues humongous" first; in fact we'll do them
// first. The order is important. In one case, calling the
@@ -301,7 +302,7 @@
for (uint ch_index = index + 1; ch_index < index + r->region_num(); ch_index++) {
HeapRegion* chr = _regions.get_by_index(ch_index);
- assert(chr->continuesHumongous(), "Must be humongous region");
+ assert(chr->is_continues_humongous(), "Must be humongous region");
assert(chr->humongous_start_region() == r,
err_msg("Must work on humongous continuation of the original start region "
PTR_FORMAT ", but is " PTR_FORMAT, p2i(r), p2i(chr)));
@@ -311,7 +312,7 @@
bool claim_result = chr->claimHeapRegion(claim_value);
// We should always be able to claim it; no one else should
// be trying to claim this region.
- guarantee(claim_result, "We should always be able to claim the continuesHumongous part of the humongous object");
+ guarantee(claim_result, "We should always be able to claim the is_continues_humongous part of the humongous object");
bool res2 = blk->doHeapRegion(chr);
if (res2) {
@@ -322,7 +323,7 @@
// does something with "continues humongous" regions
// clears them). We might have to weaken it in the future,
// but let's leave these two asserts here for extra safety.
- assert(chr->continuesHumongous(), "should still be the case");
+ assert(chr->is_continues_humongous(), "should still be the case");
assert(chr->humongous_start_region() == r, "sanity");
}
}
@@ -424,7 +425,7 @@
// this method may be called, we have only completed allocation of the regions,
// but not put into a region set.
prev_committed = true;
- if (hr->startsHumongous()) {
+ if (hr->is_starts_humongous()) {
prev_end = hr->orig_end();
} else {
prev_end = hr->end();
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -419,7 +419,7 @@
FromCardCache::print();
}
-void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, int tid) {
+void OtherRegionsTable::add_reference(OopOrNarrowOopStar from, uint tid) {
uint cur_hrm_ind = hr()->hrm_index();
if (G1TraceHeapRegionRememberedSet) {
@@ -435,10 +435,10 @@
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr("Table for [" PTR_FORMAT "...): card %d (cache = %d)",
hr()->bottom(), from_card,
- FromCardCache::at((uint)tid, cur_hrm_ind));
+ FromCardCache::at(tid, cur_hrm_ind));
}
- if (FromCardCache::contains_or_replace((uint)tid, cur_hrm_ind, from_card)) {
+ if (FromCardCache::contains_or_replace(tid, cur_hrm_ind, from_card)) {
if (G1TraceHeapRegionRememberedSet) {
gclog_or_tty->print_cr(" from-card cache hit.");
}
@@ -493,7 +493,7 @@
return;
} else {
if (G1TraceHeapRegionRememberedSet) {
- gclog_or_tty->print_cr(" [tid %d] sparse table entry "
+ gclog_or_tty->print_cr(" [tid %u] sparse table entry "
"overflow(f: %d, t: %u)",
tid, from_hrm_ind, cur_hrm_ind);
}
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionRemSet.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -179,7 +179,7 @@
// For now. Could "expand" some tables in the future, so that this made
// sense.
- void add_reference(OopOrNarrowOopStar from, int tid);
+ void add_reference(OopOrNarrowOopStar from, uint tid);
// Removes any entries shown by the given bitmaps to contain only dead
// objects.
@@ -301,7 +301,7 @@
}
// Used in the parallel case.
- void add_reference(OopOrNarrowOopStar from, int tid) {
+ void add_reference(OopOrNarrowOopStar from, uint tid) {
_other_regions.add_reference(from, tid);
}
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionSet.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -41,7 +41,7 @@
void HeapRegionSetBase::verify_region(HeapRegion* hr) {
assert(hr->containing_set() == this, err_msg("Inconsistent containing set for %u", hr->hrm_index()));
assert(!hr->is_young(), err_msg("Adding young region %u", hr->hrm_index())); // currently we don't use these sets for young regions
- assert(hr->isHumongous() == regions_humongous(), err_msg("Wrong humongous state for region %u and set %s", hr->hrm_index(), name()));
+ assert(hr->is_humongous() == regions_humongous(), err_msg("Wrong humongous state for region %u and set %s", hr->hrm_index(), name()));
assert(hr->is_free() == regions_free(), err_msg("Wrong free state for region %u and set %s", hr->hrm_index(), name()));
assert(!hr->is_free() || hr->is_empty(), err_msg("Free region %u is not empty for set %s", hr->hrm_index(), name()));
assert(!hr->is_empty() || hr->is_free(), err_msg("Empty region %u is not free for set %s", hr->hrm_index(), name()));
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -30,8 +30,8 @@
case FreeTag:
case EdenTag:
case SurvTag:
- case HumStartsTag:
- case HumContTag:
+ case StartsHumongousTag:
+ case ContinuesHumongousTag:
case OldTag:
return true;
}
@@ -41,12 +41,12 @@
const char* HeapRegionType::get_str() const {
hrt_assert_is_valid(_tag);
switch (_tag) {
- case FreeTag: return "FREE";
- case EdenTag: return "EDEN";
- case SurvTag: return "SURV";
- case HumStartsTag: return "HUMS";
- case HumContTag: return "HUMC";
- case OldTag: return "OLD";
+ case FreeTag: return "FREE";
+ case EdenTag: return "EDEN";
+ case SurvTag: return "SURV";
+ case StartsHumongousTag: return "HUMS";
+ case ContinuesHumongousTag: return "HUMC";
+ case OldTag: return "OLD";
}
ShouldNotReachHere();
// keep some compilers happy
@@ -56,12 +56,12 @@
const char* HeapRegionType::get_short_str() const {
hrt_assert_is_valid(_tag);
switch (_tag) {
- case FreeTag: return "F";
- case EdenTag: return "E";
- case SurvTag: return "S";
- case HumStartsTag: return "HS";
- case HumContTag: return "HC";
- case OldTag: return "O";
+ case FreeTag: return "F";
+ case EdenTag: return "E";
+ case SurvTag: return "S";
+ case StartsHumongousTag: return "HS";
+ case ContinuesHumongousTag: return "HC";
+ case OldTag: return "O";
}
ShouldNotReachHere();
// keep some compilers happy
--- a/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/heapRegionType.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -49,22 +49,22 @@
// 0001 1 [ 3] Survivor
//
// 0010 0 Humongous Mask
- // 0010 0 [ 4] Humongous Starts
- // 0010 1 [ 5] Humongous Continues
+ // 0010 0 [ 4] Starts Humongous
+ // 0010 1 [ 5] Continues Humongous
//
// 01000 [ 8] Old
typedef enum {
- FreeTag = 0,
+ FreeTag = 0,
- YoungMask = 2,
- EdenTag = YoungMask,
- SurvTag = YoungMask + 1,
+ YoungMask = 2,
+ EdenTag = YoungMask,
+ SurvTag = YoungMask + 1,
- HumMask = 4,
- HumStartsTag = HumMask,
- HumContTag = HumMask + 1,
+ HumongousMask = 4,
+ StartsHumongousTag = HumongousMask,
+ ContinuesHumongousTag = HumongousMask + 1,
- OldTag = 8
+ OldTag = 8
} Tag;
volatile Tag _tag;
@@ -104,9 +104,9 @@
bool is_eden() const { return get() == EdenTag; }
bool is_survivor() const { return get() == SurvTag; }
- bool is_humongous() const { return (get() & HumMask) != 0; }
- bool is_starts_humongous() const { return get() == HumStartsTag; }
- bool is_continues_humongous() const { return get() == HumContTag; }
+ bool is_humongous() const { return (get() & HumongousMask) != 0; }
+ bool is_starts_humongous() const { return get() == StartsHumongousTag; }
+ bool is_continues_humongous() const { return get() == ContinuesHumongousTag; }
bool is_old() const { return get() == OldTag; }
@@ -118,8 +118,8 @@
void set_eden_pre_gc() { set_from(EdenTag, SurvTag); }
void set_survivor() { set_from(SurvTag, FreeTag); }
- void set_starts_humongous() { set_from(HumStartsTag, FreeTag); }
- void set_continues_humongous() { set_from(HumContTag, FreeTag); }
+ void set_starts_humongous() { set_from(StartsHumongousTag, FreeTag); }
+ void set_continues_humongous() { set_from(ContinuesHumongousTag, FreeTag); }
void set_old() { set(OldTag); }
--- a/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/vmStructs_g1.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -45,11 +45,13 @@
nonstatic_field(HeapRegionManager, _regions, G1HeapRegionTable) \
nonstatic_field(HeapRegionManager, _num_committed, uint) \
\
+ nonstatic_field(G1Allocator, _summary_bytes_used, size_t) \
+ \
nonstatic_field(G1CollectedHeap, _hrm, HeapRegionManager) \
- nonstatic_field(G1CollectedHeap, _summary_bytes_used, size_t) \
nonstatic_field(G1CollectedHeap, _g1mm, G1MonitoringSupport*) \
nonstatic_field(G1CollectedHeap, _old_set, HeapRegionSetBase) \
nonstatic_field(G1CollectedHeap, _humongous_set, HeapRegionSetBase) \
+ nonstatic_field(G1CollectedHeap, _allocator, G1Allocator*) \
\
nonstatic_field(G1MonitoringSupport, _eden_committed, size_t) \
nonstatic_field(G1MonitoringSupport, _eden_used, size_t) \
@@ -72,14 +74,16 @@
\
declare_type(G1OffsetTableContigSpace, CompactibleSpace) \
declare_type(HeapRegion, G1OffsetTableContigSpace) \
- declare_toplevel_type(HeapRegionManager) \
+ declare_toplevel_type(HeapRegionManager) \
declare_toplevel_type(HeapRegionSetBase) \
declare_toplevel_type(HeapRegionSetCount) \
declare_toplevel_type(G1MonitoringSupport) \
+ declare_toplevel_type(G1Allocator) \
\
declare_toplevel_type(G1CollectedHeap*) \
declare_toplevel_type(HeapRegion*) \
declare_toplevel_type(G1MonitoringSupport*) \
+ declare_toplevel_type(G1Allocator*) \
#endif // SHARE_VM_GC_IMPLEMENTATION_G1_VMSTRUCTS_G1_HPP
--- a/hotspot/src/share/vm/gc_implementation/g1/vm_operations_g1.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/vm_operations_g1.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -45,7 +45,8 @@
void VM_G1CollectForAllocation::doit() {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
GCCauseSetter x(g1h, _gc_cause);
- _result = g1h->satisfy_failed_allocation(_word_size, &_pause_succeeded);
+
+ _result = g1h->satisfy_failed_allocation(_word_size, allocation_context(), &_pause_succeeded);
assert(_result == NULL || _pause_succeeded,
"if we get back a result, the pause should have succeeded");
}
@@ -99,7 +100,7 @@
if (_word_size > 0) {
// An allocation has been requested. So, try to do that first.
- _result = g1h->attempt_allocation_at_safepoint(_word_size,
+ _result = g1h->attempt_allocation_at_safepoint(_word_size, allocation_context(),
false /* expect_null_cur_alloc_region */);
if (_result != NULL) {
// If we can successfully allocate before we actually do the
@@ -152,7 +153,7 @@
g1h->do_collection_pause_at_safepoint(_target_pause_time_ms);
if (_pause_succeeded && _word_size > 0) {
// An allocation had been requested.
- _result = g1h->attempt_allocation_at_safepoint(_word_size,
+ _result = g1h->attempt_allocation_at_safepoint(_word_size, allocation_context(),
true /* expect_null_cur_alloc_region */);
} else {
assert(_result == NULL, "invariant");
--- a/hotspot/src/share/vm/gc_implementation/g1/vm_operations_g1.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/vm_operations_g1.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,7 @@
#ifndef SHARE_VM_GC_IMPLEMENTATION_G1_VM_OPERATIONS_G1_HPP
#define SHARE_VM_GC_IMPLEMENTATION_G1_VM_OPERATIONS_G1_HPP
+#include "gc_implementation/g1/g1AllocationContext.hpp"
#include "gc_implementation/shared/vmGCOperations.hpp"
// VM_operations for the G1 collector.
@@ -40,6 +41,7 @@
size_t _word_size;
HeapWord* _result;
bool _pause_succeeded;
+ AllocationContext_t _allocation_context;
public:
VM_G1OperationWithAllocRequest(unsigned int gc_count_before,
@@ -49,6 +51,8 @@
_word_size(word_size), _result(NULL), _pause_succeeded(false) { }
HeapWord* result() { return _result; }
bool pause_succeeded() { return _pause_succeeded; }
+ void set_allocation_context(AllocationContext_t context) { _allocation_context = context; }
+ AllocationContext_t allocation_context() { return _allocation_context; }
};
class VM_G1CollectFull: public VM_GC_Operation {
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/cardTableExtension.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -288,7 +288,7 @@
while (p < to) {
Prefetch::write(p, interval);
oop m = oop(p);
- assert(m->is_oop_or_null(), "check for header");
+ assert(m->is_oop_or_null(), err_msg("Expected an oop or NULL for header field at " PTR_FORMAT, p2i(m)));
m->push_contents(pm);
p += m->size();
}
@@ -296,7 +296,7 @@
} else {
while (p < to) {
oop m = oop(p);
- assert(m->is_oop_or_null(), "check for header");
+ assert(m->is_oop_or_null(), err_msg("Expected an oop or NULL for header field at " PTR_FORMAT, p2i(m)));
m->push_contents(pm);
p += m->size();
}
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/parallelScavengeHeap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -74,10 +74,9 @@
return JNI_ENOMEM;
}
- _reserved = MemRegion((HeapWord*)heap_rs.base(),
- (HeapWord*)(heap_rs.base() + heap_rs.size()));
+ initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
- CardTableExtension* const barrier_set = new CardTableExtension(_reserved, 3);
+ CardTableExtension* const barrier_set = new CardTableExtension(reserved_region(), 3);
barrier_set->initialize();
_barrier_set = barrier_set;
oopDesc::set_bs(_barrier_set);
--- a/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_implementation/parallelScavenge/psParallelCompact.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -2882,7 +2882,7 @@
start_array->allocate_block(addr);
}
oop(addr)->update_contents(cm);
- assert(oop(addr)->is_oop_or_null(), "should be an oop now");
+ assert(oop(addr)->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(oop(addr))));
}
}
}
@@ -3366,7 +3366,7 @@
oop moved_oop = (oop) destination();
moved_oop->update_contents(compaction_manager());
- assert(moved_oop->is_oop_or_null(), "Object should be whole at this point");
+ assert(moved_oop->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(moved_oop)));
update_state(words);
assert(destination() == (HeapWord*)moved_oop + moved_oop->size(), "sanity");
--- a/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -582,6 +582,14 @@
}
}
+void CollectedHeap::initialize_reserved_region(HeapWord *start, HeapWord *end) {
+ // It is important to do this in a way such that concurrent readers can't
+ // temporarily think something is in the heap. (Seen this happen in asserts.)
+ _reserved.set_word_size(0);
+ _reserved.set_start(start);
+ _reserved.set_end(end);
+}
+
/////////////// Unit tests ///////////////
#ifndef PRODUCT
--- a/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -85,6 +85,7 @@
friend class VMStructs;
friend class IsGCActiveMark; // Block structured external access to _is_gc_active
+ private:
#ifdef ASSERT
static int _fire_out_of_memory_count;
#endif
@@ -97,8 +98,9 @@
// Used in support of ReduceInitialCardMarks; only consulted if COMPILER2 is being used
bool _defer_initial_card_mark;
+ MemRegion _reserved;
+
protected:
- MemRegion _reserved;
BarrierSet* _barrier_set;
bool _is_gc_active;
uint _n_par_threads;
@@ -211,6 +213,7 @@
// Stop any onging concurrent work and prepare for exit.
virtual void stop() {}
+ void initialize_reserved_region(HeapWord *start, HeapWord *end);
MemRegion reserved_region() const { return _reserved; }
address base() const { return (address)reserved_region().start(); }
@@ -637,6 +640,15 @@
// actual number may be germane.
static bool use_parallel_gc_threads() { return ParallelGCThreads > 0; }
+ // Copy the current allocation context statistics for the specified contexts.
+ // For each context in contexts, set the corresponding entries in the totals
+ // and accuracy arrays to the current values held by the statistics. Each
+ // array should be of length len.
+ virtual void copy_allocation_context_stats(const jint* contexts,
+ jlong* totals,
+ jbyte* accuracy,
+ jint len) { }
+
/////////////// Unit tests ///////////////
NOT_PRODUCT(static void test_is_in();)
--- a/hotspot/src/share/vm/gc_interface/gcCause.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_interface/gcCause.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -54,6 +54,9 @@
case _wb_young_gc:
return "WhiteBox Initiated Young GC";
+ case _update_allocation_context_stats:
+ return "Update Allocation Context Stats";
+
case _no_gc:
return "No GC";
--- a/hotspot/src/share/vm/gc_interface/gcCause.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/gc_interface/gcCause.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -47,6 +47,7 @@
_heap_inspection,
_heap_dump,
_wb_young_gc,
+ _update_allocation_context_stats,
/* implementation independent, but reserved for GC use */
_no_gc,
--- a/hotspot/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/interpreter/bytecodeInterpreter.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -35,7 +35,7 @@
#ifdef ASSERT
#define VERIFY_OOP(o_) \
if (VerifyOops) { \
- assert((oop(o_))->is_oop_or_null(), "Not an oop!"); \
+ assert((oop(o_))->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(oop(o_)))); \
StubRoutines::_verify_oop_count++; \
}
#else
--- a/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/interpreter/interpreterRuntime.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1077,7 +1077,7 @@
address SignatureHandlerLibrary::set_handler_blob() {
BufferBlob* handler_blob = BufferBlob::create("native signature handlers", blob_size);
if (handler_blob == NULL) {
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return NULL;
}
address handler = handler_blob->code_begin();
--- a/hotspot/src/share/vm/memory/allocation.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/allocation.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -693,14 +693,16 @@
// compilers and they should be upwards compatible with C++11/14. Therefore
// PLEASE BE CAREFUL if you change the signature of the following operators!
+static void * zero = (void *) 0;
+
void* operator new(size_t size) /* throw(std::bad_alloc) */ {
fatal("Should not call global operator new");
- return 0;
+ return zero;
}
void* operator new [](size_t size) /* throw(std::bad_alloc) */ {
fatal("Should not call global operator new[]");
- return 0;
+ return zero;
}
void* operator new(size_t size, const std::nothrow_t& nothrow_constant) throw() {
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -817,7 +817,11 @@
assert(!Heap_lock->owned_by_self(), "Should not be holding the Heap_lock");
do {
- MetaWord* result = NULL;
+ MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+ if (result != NULL) {
+ return result;
+ }
+
if (GC_locker::is_active_and_needs_gc()) {
// If the GC_locker is active, just expand and allocate.
// If that does not succeed, wait if this thread is not
--- a/hotspot/src/share/vm/memory/genCollectedHeap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/genCollectedHeap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -123,17 +123,9 @@
return JNI_ENOMEM;
}
- _reserved = MemRegion((HeapWord*)heap_rs.base(),
- (HeapWord*)(heap_rs.base() + heap_rs.size()));
+ initialize_reserved_region((HeapWord*)heap_rs.base(), (HeapWord*)(heap_rs.base() + heap_rs.size()));
- // It is important to do this in a way such that concurrent readers can't
- // temporarily think something is in the heap. (Seen this happen in asserts.)
- _reserved.set_word_size(0);
- _reserved.set_start((HeapWord*)heap_rs.base());
- size_t actual_heap_size = heap_rs.size();
- _reserved.set_end((HeapWord*)(heap_rs.base() + actual_heap_size));
-
- _rem_set = collector_policy()->create_rem_set(_reserved, n_covered_regions);
+ _rem_set = collector_policy()->create_rem_set(reserved_region(), n_covered_regions);
set_barrier_set(rem_set()->bs());
_gch = this;
--- a/hotspot/src/share/vm/memory/heap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/heap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -35,7 +35,9 @@
// Implementation of Heap
-CodeHeap::CodeHeap() {
+CodeHeap::CodeHeap(const char* name, const int code_blob_type)
+ : _code_blob_type(code_blob_type) {
+ _name = name;
_number_of_committed_segments = 0;
_number_of_reserved_segments = 0;
_segment_size = 0;
@@ -44,6 +46,8 @@
_freelist = NULL;
_freelist_segments = 0;
_freelist_length = 0;
+ _max_allocated_capacity = 0;
+ _was_full = false;
}
@@ -88,9 +92,8 @@
}
-bool CodeHeap::reserve(size_t reserved_size, size_t committed_size,
- size_t segment_size) {
- assert(reserved_size >= committed_size, "reserved < committed");
+bool CodeHeap::reserve(ReservedSpace rs, size_t committed_size, size_t segment_size) {
+ assert(rs.size() >= committed_size, "reserved < committed");
assert(segment_size >= sizeof(FreeBlock), "segment size is too small");
assert(is_power_of_2(segment_size), "segment_size must be a power of 2");
@@ -102,18 +105,13 @@
if (os::can_execute_large_page_memory()) {
const size_t min_pages = 8;
page_size = MIN2(os::page_size_for_region(committed_size, min_pages),
- os::page_size_for_region(reserved_size, min_pages));
+ os::page_size_for_region(rs.size(), min_pages));
}
const size_t granularity = os::vm_allocation_granularity();
- const size_t r_align = MAX2(page_size, granularity);
- const size_t r_size = align_size_up(reserved_size, r_align);
const size_t c_size = align_size_up(committed_size, page_size);
- const size_t rs_align = page_size == (size_t) os::vm_page_size() ? 0 :
- MAX2(page_size, granularity);
- ReservedCodeSpace rs(r_size, rs_align, rs_align > 0);
- os::trace_page_sizes("code heap", committed_size, reserved_size, page_size,
+ os::trace_page_sizes(_name, committed_size, rs.size(), page_size,
rs.base(), rs.size());
if (!_memory.initialize(rs, c_size)) {
return false;
@@ -186,6 +184,7 @@
assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check");
assert(!block->free(), "must be marked free");
DEBUG_ONLY(memset((void*)block->allocated_space(), badCodeHeapNewVal, instance_size));
+ _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity());
return block->allocated_space();
}
@@ -207,6 +206,7 @@
b->initialize(number_of_segments);
_next_segment += number_of_segments;
DEBUG_ONLY(memset((void *)b->allocated_space(), badCodeHeapNewVal, instance_size));
+ _max_allocated_capacity = MAX2(_max_allocated_capacity, allocated_capacity());
return b->allocated_space();
} else {
return NULL;
--- a/hotspot/src/share/vm/memory/heap.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/heap.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,7 @@
#ifndef SHARE_VM_MEMORY_HEAP_HPP
#define SHARE_VM_MEMORY_HEAP_HPP
+#include "code/codeBlob.hpp"
#include "memory/allocation.hpp"
#include "runtime/virtualspace.hpp"
@@ -93,6 +94,11 @@
FreeBlock* _freelist;
size_t _freelist_segments; // No. of segments in freelist
int _freelist_length;
+ size_t _max_allocated_capacity; // Peak capacity that was allocated during lifetime of the heap
+
+ const char* _name; // Name of the CodeHeap
+ const int _code_blob_type; // CodeBlobType it contains
+ bool _was_full; // True if the code heap was full
enum { free_sentinel = 0xFF };
@@ -127,10 +133,10 @@
void clear(); // clears all heap contents
public:
- CodeHeap();
+ CodeHeap(const char* name, const int code_blob_type);
// Heap extents
- bool reserve(size_t reserved_size, size_t committed_size, size_t segment_size);
+ bool reserve(ReservedSpace rs, size_t committed_size, size_t segment_size);
bool expand_by(size_t size); // expands committed memory by size
// Memory allocation
@@ -161,8 +167,19 @@
size_t max_capacity() const;
int allocated_segments() const;
size_t allocated_capacity() const;
+ size_t max_allocated_capacity() const { return _max_allocated_capacity; }
size_t unallocated_capacity() const { return max_capacity() - allocated_capacity(); }
+ // Returns true if the CodeHeap contains CodeBlobs of the given type
+ bool accepts(int code_blob_type) const { return (_code_blob_type == CodeBlobType::All) ||
+ (_code_blob_type == code_blob_type); }
+ int code_blob_type() const { return _code_blob_type; }
+
+ // Debugging / Profiling
+ const char* name() const { return _name; }
+ bool was_full() { return _was_full; }
+ void report_full() { _was_full = true; }
+
private:
size_t heap_unallocated_capacity() const;
--- a/hotspot/src/share/vm/memory/metaspace.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1415,10 +1415,31 @@
return value;
}
-size_t MetaspaceGC::inc_capacity_until_GC(size_t v) {
+bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC) {
assert_is_size_aligned(v, Metaspace::commit_alignment());
- return (size_t)Atomic::add_ptr(v, &_capacity_until_GC);
+ size_t capacity_until_GC = (size_t) _capacity_until_GC;
+ size_t new_value = capacity_until_GC + v;
+
+ if (new_value < capacity_until_GC) {
+ // The addition wrapped around, set new_value to aligned max value.
+ new_value = align_size_down(max_uintx, Metaspace::commit_alignment());
+ }
+
+ intptr_t expected = (intptr_t) capacity_until_GC;
+ intptr_t actual = Atomic::cmpxchg_ptr((intptr_t) new_value, &_capacity_until_GC, expected);
+
+ if (expected != actual) {
+ return false;
+ }
+
+ if (new_cap_until_GC != NULL) {
+ *new_cap_until_GC = new_value;
+ }
+ if (old_cap_until_GC != NULL) {
+ *old_cap_until_GC = capacity_until_GC;
+ }
+ return true;
}
size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
@@ -1518,7 +1539,10 @@
expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
// Don't expand unless it's significant
if (expand_bytes >= MinMetaspaceExpansion) {
- size_t new_capacity_until_GC = MetaspaceGC::inc_capacity_until_GC(expand_bytes);
+ size_t new_capacity_until_GC = 0;
+ bool succeeded = MetaspaceGC::inc_capacity_until_GC(expand_bytes, &new_capacity_until_GC);
+ assert(succeeded, "Should always succesfully increment HWM when at safepoint");
+
Metaspace::tracer()->report_gc_threshold(capacity_until_GC,
new_capacity_until_GC,
MetaspaceGCThresholdUpdater::ComputeNewSize);
@@ -3321,19 +3345,29 @@
size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
assert(delta_bytes > 0, "Must be");
- size_t after_inc = MetaspaceGC::inc_capacity_until_GC(delta_bytes);
-
- // capacity_until_GC might be updated concurrently, must calculate previous value.
- size_t before_inc = after_inc - delta_bytes;
-
- tracer()->report_gc_threshold(before_inc, after_inc,
- MetaspaceGCThresholdUpdater::ExpandAndAllocate);
- if (PrintGCDetails && Verbose) {
- gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
- " to " SIZE_FORMAT, before_inc, after_inc);
+ size_t before = 0;
+ size_t after = 0;
+ MetaWord* res;
+ bool incremented;
+
+ // Each thread increments the HWM at most once. Even if the thread fails to increment
+ // the HWM, an allocation is still attempted. This is because another thread must then
+ // have incremented the HWM and therefore the allocation might still succeed.
+ do {
+ incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before);
+ res = allocate(word_size, mdtype);
+ } while (!incremented && res == NULL);
+
+ if (incremented) {
+ tracer()->report_gc_threshold(before, after,
+ MetaspaceGCThresholdUpdater::ExpandAndAllocate);
+ if (PrintGCDetails && Verbose) {
+ gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
+ " to " SIZE_FORMAT, before, after);
+ }
}
- return allocate(word_size, mdtype);
+ return res;
}
// Space allocated in the Metaspace. This may
--- a/hotspot/src/share/vm/memory/metaspace.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -87,6 +87,7 @@
friend class VM_CollectForMetadataAllocation;
friend class MetaspaceGC;
friend class MetaspaceAux;
+ friend class CollectorPolicy;
public:
enum MetadataType {
@@ -144,6 +145,8 @@
// allocate(ClassLoaderData*, size_t, bool, MetadataType, TRAPS)
MetaWord* allocate(size_t word_size, MetadataType mdtype);
+ MetaWord* expand_and_allocate(size_t size, MetadataType mdtype);
+
// Virtual Space lists for both classes and other metadata
static VirtualSpaceList* _space_list;
static VirtualSpaceList* _class_space_list;
@@ -234,9 +237,6 @@
bool read_only, MetaspaceObj::Type type, TRAPS);
void deallocate(MetaWord* ptr, size_t byte_size, bool is_class);
- MetaWord* expand_and_allocate(size_t size,
- MetadataType mdtype);
-
static bool contains(const void* ptr);
void dump(outputStream* const out) const;
@@ -407,7 +407,9 @@
static void post_initialize();
static size_t capacity_until_GC();
- static size_t inc_capacity_until_GC(size_t v);
+ static bool inc_capacity_until_GC(size_t v,
+ size_t* new_cap_until_GC = NULL,
+ size_t* old_cap_until_GC = NULL);
static size_t dec_capacity_until_GC(size_t v);
static bool should_concurrent_collect() { return _should_concurrent_collect; }
--- a/hotspot/src/share/vm/memory/referenceProcessor.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/referenceProcessor.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -473,7 +473,7 @@
_discovered_addr = java_lang_ref_Reference::discovered_addr(_ref);
oop discovered = java_lang_ref_Reference::discovered(_ref);
assert(_discovered_addr && discovered->is_oop_or_null(),
- "discovered field is bad");
+ err_msg("Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered)));
_next = discovered;
_referent_addr = java_lang_ref_Reference::referent_addr(_ref);
_referent = java_lang_ref_Reference::referent(_ref);
@@ -482,7 +482,9 @@
assert(allow_null_referent ?
_referent->is_oop_or_null()
: _referent->is_oop(),
- "bad referent");
+ err_msg("Expected an oop%s for referent field at " PTR_FORMAT,
+ (allow_null_referent ? " or NULL" : ""),
+ p2i(_referent)));
}
void DiscoveredListIterator::remove() {
@@ -630,7 +632,7 @@
oop next = java_lang_ref_Reference::next(iter.obj());
if ((iter.referent() == NULL || iter.is_referent_alive() ||
next != NULL)) {
- assert(next->is_oop_or_null(), "bad next field");
+ assert(next->is_oop_or_null(), err_msg("Expected an oop or NULL for next field at " PTR_FORMAT, p2i(next)));
// Remove Reference object from list
iter.remove();
// Trace the cohorts
@@ -979,7 +981,7 @@
while (iter.has_next()) {
iter.load_ptrs(DEBUG_ONLY(true /* allow_null_referent */));
oop next = java_lang_ref_Reference::next(iter.obj());
- assert(next->is_oop_or_null(), "bad next field");
+ assert(next->is_oop_or_null(), err_msg("Expected an oop or NULL for next field at " PTR_FORMAT, p2i(next)));
// If referent has been cleared or Reference is not active,
// drop it.
if (iter.referent() == NULL || next != NULL) {
@@ -1172,7 +1174,7 @@
HeapWord* const discovered_addr = java_lang_ref_Reference::discovered_addr(obj);
const oop discovered = java_lang_ref_Reference::discovered(obj);
- assert(discovered->is_oop_or_null(), "bad discovered field");
+ assert(discovered->is_oop_or_null(), err_msg("Expected an oop or NULL for discovered field at " PTR_FORMAT, p2i(discovered)));
if (discovered != NULL) {
// The reference has already been discovered...
if (TraceReferenceGC) {
--- a/hotspot/src/share/vm/memory/space.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/space.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -331,11 +331,10 @@
CompactibleSpace* space;
HeapWord* threshold;
- CompactPoint(Generation* _gen) :
- gen(_gen), space(NULL), threshold(0) {}
+ CompactPoint(Generation* g = NULL) :
+ gen(g), space(NULL), threshold(0) {}
};
-
// A space that supports compaction operations. This is usually, but not
// necessarily, a space that is normally contiguous. But, for example, a
// free-list-based space whose normal collection is a mark-sweep without
--- a/hotspot/src/share/vm/memory/universe.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/universe.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -127,6 +127,8 @@
oop Universe::_arithmetic_exception_instance = NULL;
oop Universe::_virtual_machine_error_instance = NULL;
oop Universe::_vm_exception = NULL;
+oop Universe::_allocation_context_notification_obj = NULL;
+
Method* Universe::_throw_illegal_access_error = NULL;
Array<int>* Universe::_the_empty_int_array = NULL;
Array<u2>* Universe::_the_empty_short_array = NULL;
@@ -196,6 +198,7 @@
f->do_oop((oop*)&_main_thread_group);
f->do_oop((oop*)&_system_thread_group);
f->do_oop((oop*)&_vm_exception);
+ f->do_oop((oop*)&_allocation_context_notification_obj);
debug_only(f->do_oop((oop*)&_fullgc_alot_dummy_array);)
}
--- a/hotspot/src/share/vm/memory/universe.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/universe.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -178,6 +178,8 @@
// the vm thread.
static oop _vm_exception;
+ static oop _allocation_context_notification_obj;
+
// The particular choice of collected heap.
static CollectedHeap* _collectedHeap;
@@ -307,6 +309,10 @@
static oop arithmetic_exception_instance() { return _arithmetic_exception_instance; }
static oop virtual_machine_error_instance() { return _virtual_machine_error_instance; }
static oop vm_exception() { return _vm_exception; }
+
+ static inline oop allocation_context_notification_obj();
+ static inline void set_allocation_context_notification_obj(oop obj);
+
static Method* throw_illegal_access_error() { return _throw_illegal_access_error; }
static Array<int>* the_empty_int_array() { return _the_empty_int_array; }
--- a/hotspot/src/share/vm/memory/universe.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/memory/universe.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -41,4 +41,12 @@
return type == T_DOUBLE || type == T_LONG;
}
+inline oop Universe::allocation_context_notification_obj() {
+ return _allocation_context_notification_obj;
+}
+
+inline void Universe::set_allocation_context_notification_obj(oop obj) {
+ _allocation_context_notification_obj = obj;
+}
+
#endif // SHARE_VM_MEMORY_UNIVERSE_INLINE_HPP
--- a/hotspot/src/share/vm/oops/arrayKlass.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/oops/arrayKlass.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -92,7 +92,7 @@
ResourceMark rm(THREAD);
k->initialize_supers(super_klass(), CHECK);
k->vtable()->initialize_vtable(false, CHECK);
- java_lang_Class::create_mirror(k, Handle(NULL), Handle(NULL), CHECK);
+ java_lang_Class::create_mirror(k, Handle(THREAD, k->class_loader()), Handle(NULL), CHECK);
}
GrowableArray<Klass*>* ArrayKlass::compute_secondary_supers(int num_extra_slots) {
--- a/hotspot/src/share/vm/oops/method.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/oops/method.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -93,7 +93,7 @@
set_hidden(false);
set_dont_inline(false);
set_method_data(NULL);
- set_method_counters(NULL);
+ clear_method_counters();
set_vtable_index(Method::garbage_vtable_index);
// Fix and bury in Method*
@@ -117,7 +117,7 @@
MetadataFactory::free_metadata(loader_data, method_data());
set_method_data(NULL);
MetadataFactory::free_metadata(loader_data, method_counters());
- set_method_counters(NULL);
+ clear_method_counters();
// The nmethod will be gone when we get here.
if (code() != NULL) _code = NULL;
}
@@ -395,9 +395,7 @@
methodHandle mh(m);
ClassLoaderData* loader_data = mh->method_holder()->class_loader_data();
MethodCounters* counters = MethodCounters::allocate(loader_data, CHECK_NULL);
- if (mh->method_counters() == NULL) {
- mh->set_method_counters(counters);
- } else {
+ if (!mh->init_method_counters(counters)) {
MetadataFactory::free_metadata(loader_data, counters);
}
return mh->method_counters();
@@ -859,7 +857,7 @@
assert(!DumpSharedSpaces || _method_data == NULL, "unexpected method data?");
set_method_data(NULL);
- set_method_counters(NULL);
+ clear_method_counters();
}
// Called when the method_holder is getting linked. Setup entrypoints so the method
--- a/hotspot/src/share/vm/oops/method.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/oops/method.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -333,11 +333,13 @@
return _method_counters;
}
- void set_method_counters(MethodCounters* counters) {
- // The store into method must be released. On platforms without
- // total store order (TSO) the reference may become visible before
- // the initialization of data otherwise.
- OrderAccess::release_store_ptr((volatile void *)&_method_counters, counters);
+ void clear_method_counters() {
+ _method_counters = NULL;
+ }
+
+ bool init_method_counters(MethodCounters* counters) {
+ // Try to install a pointer to MethodCounters, return true on success.
+ return Atomic::cmpxchg_ptr(counters, (volatile void*)&_method_counters, NULL) == NULL;
}
#ifdef TIERED
--- a/hotspot/src/share/vm/opto/buildOopMap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/buildOopMap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -555,7 +555,7 @@
// Collect GC mask info - where are all the OOPs?
void Compile::BuildOopMaps() {
- NOT_PRODUCT( TracePhase t3("bldOopMaps", &_t_buildOopMaps, TimeCompiler); )
+ TracePhase tp("bldOopMaps", &timers[_t_buildOopMaps]);
// Can't resource-mark because I need to leave all those OopMaps around,
// or else I need to resource-mark some arena other than the default.
// ResourceMark rm; // Reclaim all OopFlows when done
--- a/hotspot/src/share/vm/opto/c2_globals.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/c2_globals.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -590,9 +590,6 @@
product(intx, TypeProfileMajorReceiverPercent, 90, \
"% of major receiver type to all profiled receivers") \
\
- notproduct(bool, TimeCompiler2, false, \
- "detailed time the compiler (requires +TimeCompiler)") \
- \
diagnostic(bool, PrintIntrinsics, false, \
"prints attempted and successful inlining of intrinsics") \
\
--- a/hotspot/src/share/vm/opto/c2compiler.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/c2compiler.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -24,7 +24,9 @@
#include "precompiled.hpp"
#include "opto/c2compiler.hpp"
+#include "opto/compile.hpp"
#include "opto/optoreg.hpp"
+#include "opto/output.hpp"
#include "opto/runtime.hpp"
// register information defined by ADLC
@@ -145,5 +147,10 @@
void C2Compiler::print_timers() {
- // do nothing
+ Compile::print_timers();
}
+
+int C2Compiler::initial_code_buffer_size() {
+ assert(SegmentedCodeCache, "Should be only used with a segmented code cache");
+ return Compile::MAX_inst_size + Compile::MAX_locs_size + initial_const_capacity;
+}
--- a/hotspot/src/share/vm/opto/c2compiler.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/c2compiler.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -50,6 +50,9 @@
// Print compilation timers and statistics
void print_timers();
+
+ // Initial size of the code buffer (may be increased at runtime)
+ static int initial_code_buffer_size();
};
#endif // SHARE_VM_OPTO_C2COMPILER_HPP
--- a/hotspot/src/share/vm/opto/callGenerator.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/callGenerator.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -879,7 +879,7 @@
call_does_dispatch, vtable_index); // out-parameters
// We lack profiling at this call but type speculation may
// provide us with a type
- speculative_receiver_type = receiver_type->speculative_type();
+ speculative_receiver_type = (receiver_type != NULL) ? receiver_type->speculative_type() : NULL;
}
CallGenerator* cg = C->call_generator(target, vtable_index, call_does_dispatch, jvms, true, PROB_ALWAYS, speculative_receiver_type, true, true);
assert(cg == NULL || !cg->is_late_inline() || cg->is_mh_late_inline(), "no late inline here");
--- a/hotspot/src/share/vm/opto/chaitin.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/chaitin.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -209,7 +209,7 @@
, _trace_spilling(TraceSpilling || C->method_has_option("TraceSpilling"))
#endif
{
- NOT_PRODUCT( Compile::TracePhase t3("ctorChaitin", &_t_ctorChaitin, TimeCompiler); )
+ Compile::TracePhase tp("ctorChaitin", &timers[_t_ctorChaitin]);
_high_frequency_lrg = MIN2(double(OPTO_LRG_HIGH_FREQ), _cfg.get_outer_loop_frequency());
@@ -295,6 +295,8 @@
// Renumber the live ranges to compact them. Makes the IFG smaller.
void PhaseChaitin::compact() {
+ Compile::TracePhase tp("chaitinCompact", &timers[_t_chaitinCompact]);
+
// Current the _uf_map contains a series of short chains which are headed
// by a self-cycle. All the chains run from big numbers to little numbers.
// The Find() call chases the chains & shortens them for the next Find call.
@@ -369,7 +371,7 @@
#endif
{
- NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+ Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
_live = NULL; // Mark live as being not available
rm.reset_to_mark(); // Reclaim working storage
IndexSet::reset_memory(C, &live_arena);
@@ -386,7 +388,7 @@
// at all the GC points, and "stretches" the live range of any base pointer
// to the GC point.
if (stretch_base_pointer_live_ranges(&live_arena)) {
- NOT_PRODUCT(Compile::TracePhase t3("computeLive (sbplr)", &_t_computeLive, TimeCompiler);)
+ Compile::TracePhase tp("computeLive (sbplr)", &timers[_t_computeLive]);
// Since some live range stretched, I need to recompute live
_live = NULL;
rm.reset_to_mark(); // Reclaim working storage
@@ -399,17 +401,19 @@
// Create the interference graph using virtual copies
build_ifg_virtual(); // Include stack slots this time
+ // The IFG is/was triangular. I am 'squaring it up' so Union can run
+ // faster. Union requires a 'for all' operation which is slow on the
+ // triangular adjacency matrix (quick reminder: the IFG is 'sparse' -
+ // meaning I can visit all the Nodes neighbors less than a Node in time
+ // O(# of neighbors), but I have to visit all the Nodes greater than a
+ // given Node and search them for an instance, i.e., time O(#MaxLRG)).
+ _ifg->SquareUp();
+
// Aggressive (but pessimistic) copy coalescing.
// This pass works on virtual copies. Any virtual copies which are not
// coalesced get manifested as actual copies
{
- // The IFG is/was triangular. I am 'squaring it up' so Union can run
- // faster. Union requires a 'for all' operation which is slow on the
- // triangular adjacency matrix (quick reminder: the IFG is 'sparse' -
- // meaning I can visit all the Nodes neighbors less than a Node in time
- // O(# of neighbors), but I have to visit all the Nodes greater than a
- // given Node and search them for an instance, i.e., time O(#MaxLRG)).
- _ifg->SquareUp();
+ Compile::TracePhase tp("chaitinCoalesce1", &timers[_t_chaitinCoalesce1]);
PhaseAggressiveCoalesce coalesce(*this);
coalesce.coalesce_driver();
@@ -424,7 +428,7 @@
// After aggressive coalesce, attempt a first cut at coloring.
// To color, we need the IFG and for that we need LIVE.
{
- NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+ Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
_live = NULL;
rm.reset_to_mark(); // Reclaim working storage
IndexSet::reset_memory(C, &live_arena);
@@ -462,7 +466,7 @@
compact(); // Compact LRGs; return new lower max lrg
{
- NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+ Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
_live = NULL;
rm.reset_to_mark(); // Reclaim working storage
IndexSet::reset_memory(C, &live_arena);
@@ -476,6 +480,7 @@
_ifg->Compute_Effective_Degree();
// Only do conservative coalescing if requested
if (OptoCoalesce) {
+ Compile::TracePhase tp("chaitinCoalesce2", &timers[_t_chaitinCoalesce2]);
// Conservative (and pessimistic) copy coalescing of those spills
PhaseConservativeCoalesce coalesce(*this);
// If max live ranges greater than cutoff, don't color the stack.
@@ -531,7 +536,7 @@
// Nuke the live-ness and interference graph and LiveRanGe info
{
- NOT_PRODUCT( Compile::TracePhase t3("computeLive", &_t_computeLive, TimeCompiler); )
+ Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);
_live = NULL;
rm.reset_to_mark(); // Reclaim working storage
IndexSet::reset_memory(C, &live_arena);
@@ -549,6 +554,7 @@
// Only do conservative coalescing if requested
if (OptoCoalesce) {
+ Compile::TracePhase tp("chaitinCoalesce3", &timers[_t_chaitinCoalesce3]);
// Conservative (and pessimistic) copy coalescing
PhaseConservativeCoalesce coalesce(*this);
// Check for few live ranges determines how aggressive coalesce is.
@@ -1054,6 +1060,7 @@
// Compute cost/area ratio, in case we spill. Build the lo-degree list.
void PhaseChaitin::cache_lrg_info( ) {
+ Compile::TracePhase tp("chaitinCacheLRG", &timers[_t_chaitinCacheLRG]);
for (uint i = 1; i < _lrg_map.max_lrg_id(); i++) {
LRG &lrg = lrgs(i);
@@ -1137,6 +1144,7 @@
// Simplify the IFG by removing LRGs of low degree.
void PhaseChaitin::Simplify( ) {
+ Compile::TracePhase tp("chaitinSimplify", &timers[_t_chaitinSimplify]);
while( 1 ) { // Repeat till simplified it all
// May want to explore simplifying lo_degree before _lo_stk_degree.
@@ -1384,6 +1392,8 @@
// everything going back is guaranteed a color. Select that color. If some
// hi-degree LRG cannot get a color then we record that we must spill.
uint PhaseChaitin::Select( ) {
+ Compile::TracePhase tp("chaitinSelect", &timers[_t_chaitinSelect]);
+
uint spill_reg = LRG::SPILL_REG;
_max_reg = OptoReg::Name(0); // Past max register used
while( _simplified ) {
@@ -1577,7 +1587,7 @@
// This function does only cisc spill work.
if( !UseCISCSpill ) return;
- NOT_PRODUCT( Compile::TracePhase t3("fixupSpills", &_t_fixupSpills, TimeCompiler); )
+ Compile::TracePhase tp("fixupSpills", &timers[_t_fixupSpills]);
// Grab the Frame Pointer
Node *fp = _cfg.get_root_block()->head()->in(1)->in(TypeFunc::FramePtr);
--- a/hotspot/src/share/vm/opto/compile.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/compile.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -535,7 +535,7 @@
if (scratch_buffer_blob() == NULL) {
// Let CompilerBroker disable further compilations.
record_failure("Not enough space for scratch buffer in CodeCache");
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return;
}
}
@@ -667,16 +667,18 @@
C = this;
CompileWrapper cw(this);
-#ifndef PRODUCT
- if (TimeCompiler2) {
+
+ if (CITimeVerbose) {
tty->print(" ");
target->holder()->name()->print();
tty->print(".");
target->print_short_name();
tty->print(" ");
}
- TraceTime t1("Total compilation time", &_t_totalCompilation, TimeCompiler, TimeCompiler2);
- TraceTime t2(NULL, &_t_methodCompilation, TimeCompiler, false);
+ TraceTime t1("Total compilation time", &_t_totalCompilation, CITime, CITimeVerbose);
+ TraceTime t2(NULL, &_t_methodCompilation, CITime, false);
+
+#ifndef PRODUCT
bool print_opto_assembly = PrintOptoAssembly || _method->has_option("PrintOptoAssembly");
if (!print_opto_assembly) {
bool print_assembly = (PrintAssembly || _method->should_print_assembly());
@@ -726,7 +728,7 @@
print_inlining_init();
{ // Scope for timing the parser
- TracePhase t3("parse", &_t_parser, true);
+ TracePhase tp("parse", &timers[_t_parser]);
// Put top into the hash table ASAP.
initial_gvn()->transform_no_reclaim(top());
@@ -888,8 +890,8 @@
record_method_not_compilable("+OptoNoExecute"); // Flag as failed
return;
}
- TracePhase t2("install_code", &_t_registerMethod, TimeCompiler);
#endif
+ TracePhase tp("install_code", &timers[_t_registerMethod]);
if (is_osr_compilation()) {
_code_offsets.set_value(CodeOffsets::Verified_Entry, 0);
@@ -977,9 +979,10 @@
_interpreter_frame_size(0) {
C = this;
+ TraceTime t1(NULL, &_t_totalCompilation, CITime, false);
+ TraceTime t2(NULL, &_t_stubCompilation, CITime, false);
+
#ifndef PRODUCT
- TraceTime t1(NULL, &_t_totalCompilation, TimeCompiler, false);
- TraceTime t2(NULL, &_t_stubCompilation, TimeCompiler, false);
set_print_assembly(PrintFrameConverterAssembly);
set_parsed_irreducible_loop(false);
#endif
@@ -1949,30 +1952,38 @@
for_igvn()->clear();
gvn->replace_with(&igvn);
- int i = 0;
-
- for (; i <_late_inlines.length() && !inlining_progress(); i++) {
- CallGenerator* cg = _late_inlines.at(i);
- _late_inlines_pos = i+1;
- cg->do_late_inline();
- if (failing()) return;
+ {
+ TracePhase tp("incrementalInline_inline", &timers[_t_incrInline_inline]);
+ int i = 0;
+ for (; i <_late_inlines.length() && !inlining_progress(); i++) {
+ CallGenerator* cg = _late_inlines.at(i);
+ _late_inlines_pos = i+1;
+ cg->do_late_inline();
+ if (failing()) return;
+ }
+ int j = 0;
+ for (; i < _late_inlines.length(); i++, j++) {
+ _late_inlines.at_put(j, _late_inlines.at(i));
+ }
+ _late_inlines.trunc_to(j);
}
- int j = 0;
- for (; i < _late_inlines.length(); i++, j++) {
- _late_inlines.at_put(j, _late_inlines.at(i));
- }
- _late_inlines.trunc_to(j);
{
+ TracePhase tp("incrementalInline_pru", &timers[_t_incrInline_pru]);
ResourceMark rm;
PhaseRemoveUseless pru(gvn, for_igvn());
}
- igvn = PhaseIterGVN(gvn);
+ {
+ TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
+ igvn = PhaseIterGVN(gvn);
+ }
}
// Perform incremental inlining until bound on number of live nodes is reached
void Compile::inline_incrementally(PhaseIterGVN& igvn) {
+ TracePhase tp("incrementalInline", &timers[_t_incrInline]);
+
PhaseGVN* gvn = initial_gvn();
set_inlining_incrementally(true);
@@ -1983,6 +1994,7 @@
if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) {
+ TracePhase tp("incrementalInline_ideal", &timers[_t_incrInline_ideal]);
// PhaseIdealLoop is expensive so we only try it once we are
// out of live nodes and we only try it again if the previous
// helped got the number of nodes down significantly
@@ -2001,7 +2013,10 @@
if (failing()) return;
- igvn.optimize();
+ {
+ TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
+ igvn.optimize();
+ }
if (failing()) return;
}
@@ -2018,13 +2033,16 @@
if (failing()) return;
{
+ TracePhase tp("incrementalInline_pru", &timers[_t_incrInline_pru]);
ResourceMark rm;
PhaseRemoveUseless pru(initial_gvn(), for_igvn());
}
- igvn = PhaseIterGVN(gvn);
-
- igvn.optimize();
+ {
+ TracePhase tp("incrementalInline_igvn", &timers[_t_incrInline_igvn]);
+ igvn = PhaseIterGVN(gvn);
+ igvn.optimize();
+ }
}
set_inlining_incrementally(false);
@@ -2034,7 +2052,7 @@
//------------------------------Optimize---------------------------------------
// Given a graph, optimize it.
void Compile::Optimize() {
- TracePhase t1("optimizer", &_t_optimizer, true);
+ TracePhase tp("optimizer", &timers[_t_optimizer]);
#ifndef PRODUCT
if (env()->break_at_compile()) {
@@ -2060,7 +2078,7 @@
_modified_nodes = new (comp_arena()) Unique_Node_List(comp_arena());
#endif
{
- NOT_PRODUCT( TracePhase t2("iterGVN", &_t_iterGVN, TimeCompiler); )
+ TracePhase tp("iterGVN", &timers[_t_iterGVN]);
igvn.optimize();
}
@@ -2068,17 +2086,13 @@
if (failing()) return;
- {
- NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); )
- inline_incrementally(igvn);
- }
+ inline_incrementally(igvn);
print_method(PHASE_INCREMENTAL_INLINE, 2);
if (failing()) return;
if (eliminate_boxing()) {
- NOT_PRODUCT( TracePhase t2("incrementalInline", &_t_incrInline, TimeCompiler); )
// Inline valueOf() methods now.
inline_boxing_calls(igvn);
@@ -2105,7 +2119,7 @@
if (_do_escape_analysis && ConnectionGraph::has_candidates(this)) {
if (has_loops()) {
// Cleanup graph (remove dead nodes).
- TracePhase t2("idealLoop", &_t_idealLoop, true);
+ TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false, true );
if (major_progress()) print_method(PHASE_PHASEIDEAL_BEFORE_EA, 2);
if (failing()) return;
@@ -2121,7 +2135,7 @@
if (failing()) return;
if (congraph() != NULL && macro_count() > 0) {
- NOT_PRODUCT( TracePhase t2("macroEliminate", &_t_macroEliminate, TimeCompiler); )
+ TracePhase tp("macroEliminate", &timers[_t_macroEliminate]);
PhaseMacroExpand mexp(igvn);
mexp.eliminate_macro_nodes();
igvn.set_delay_transform(false);
@@ -2140,7 +2154,7 @@
loop_opts_cnt = num_loop_opts();
if((loop_opts_cnt > 0) && (has_loops() || has_split_ifs())) {
{
- TracePhase t2("idealLoop", &_t_idealLoop, true);
+ TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, true );
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP1, 2);
@@ -2148,7 +2162,7 @@
}
// Loop opts pass if partial peeling occurred in previous pass
if(PartialPeelLoop && major_progress() && (loop_opts_cnt > 0)) {
- TracePhase t3("idealLoop", &_t_idealLoop, true);
+ TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false );
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP2, 2);
@@ -2156,14 +2170,14 @@
}
// Loop opts pass for loop-unrolling before CCP
if(major_progress() && (loop_opts_cnt > 0)) {
- TracePhase t4("idealLoop", &_t_idealLoop, true);
+ TracePhase tp("idealLoop", &timers[_t_idealLoop]);
PhaseIdealLoop ideal_loop( igvn, false );
loop_opts_cnt--;
if (major_progress()) print_method(PHASE_PHASEIDEALLOOP3, 2);
}
if (!failing()) {
// Verify that last round of loop opts produced a valid graph
- NOT_PRODUCT( TracePhase t2("idealLoopVerify", &_t_idealLoopVerify, TimeCompiler); )
+ TracePhase tp("idealLoopVerify", &timers[_t_idealLoopVerify]);
PhaseIdealLoop::verify(igvn);
}
}
@@ -2173,7 +2187,7 @@
PhaseCCP ccp( &igvn );
assert( true, "Break here to ccp.dump_nodes_and_types(_root,999,1)");
{
- TracePhase t2("ccp", &_t_ccp, true);
+ TracePhase tp("ccp", &timers[_t_ccp]);
ccp.do_transform();
}
print_method(PHASE_CPP1, 2);
@@ -2182,7 +2196,7 @@
// Iterative Global Value Numbering, including ideal transforms
{
- NOT_PRODUCT( TracePhase t2("iterGVN2", &_t_iterGVN2, TimeCompiler); )
+ TracePhase tp("iterGVN2", &timers[_t_iterGVN2]);
igvn = ccp;
igvn.optimize();
}
@@ -2196,7 +2210,7 @@
if(loop_opts_cnt > 0) {
debug_only( int cnt = 0; );
while(major_progress() && (loop_opts_cnt > 0)) {
- TracePhase t2("idealLoop", &_t_idealLoop, true);
+ TracePhase tp("idealLoop", &timers[_t_idealLoop]);
assert( cnt++ < 40, "infinite cycle in loop optimization" );
PhaseIdealLoop ideal_loop( igvn, true);
loop_opts_cnt--;
@@ -2208,12 +2222,12 @@
{
// Verify that all previous optimizations produced a valid graph
// at least to this point, even if no loop optimizations were done.
- NOT_PRODUCT( TracePhase t2("idealLoopVerify", &_t_idealLoopVerify, TimeCompiler); )
+ TracePhase tp("idealLoopVerify", &timers[_t_idealLoopVerify]);
PhaseIdealLoop::verify(igvn);
}
{
- NOT_PRODUCT( TracePhase t2("macroExpand", &_t_macroExpand, TimeCompiler); )
+ TracePhase tp("macroExpand", &timers[_t_macroExpand]);
PhaseMacroExpand mex(igvn);
if (mex.expand_macro_nodes()) {
assert(failing(), "must bail out w/ explicit message");
@@ -2227,7 +2241,7 @@
process_print_inlining();
// A method with only infinite loops has no edges entering loops from root
{
- NOT_PRODUCT( TracePhase t2("graphReshape", &_t_graphReshaping, TimeCompiler); )
+ TracePhase tp("graphReshape", &timers[_t_graphReshaping]);
if (final_graph_reshaping()) {
assert(failing(), "must bail out w/ explicit message");
return;
@@ -2258,7 +2272,7 @@
Matcher matcher;
_matcher = &matcher;
{
- TracePhase t2("matcher", &_t_matcher, true);
+ TracePhase tp("matcher", &timers[_t_matcher]);
matcher.match();
}
// In debug mode can dump m._nodes.dump() for mapping of ideal to machine
@@ -2275,7 +2289,7 @@
PhaseCFG cfg(node_arena(), root(), matcher);
_cfg = &cfg;
{
- NOT_PRODUCT( TracePhase t2("scheduler", &_t_scheduler, TimeCompiler); )
+ TracePhase tp("scheduler", &timers[_t_scheduler]);
bool success = cfg.do_global_code_motion();
if (!success) {
return;
@@ -2289,7 +2303,7 @@
PhaseChaitin regalloc(unique(), cfg, matcher);
_regalloc = ®alloc;
{
- TracePhase t2("regalloc", &_t_registerAllocation, true);
+ TracePhase tp("regalloc", &timers[_t_registerAllocation]);
// Perform register allocation. After Chaitin, use-def chains are
// no longer accurate (at spill code) and so must be ignored.
// Node->LRG->reg mappings are still accurate.
@@ -2306,7 +2320,7 @@
// are not adding any new instructions. If any basic block is empty, we
// can now safely remove it.
{
- NOT_PRODUCT( TracePhase t2("blockOrdering", &_t_blockOrdering, TimeCompiler); )
+ TracePhase tp("blockOrdering", &timers[_t_blockOrdering]);
cfg.remove_empty_blocks();
if (do_freq_based_layout()) {
PhaseBlockLayout layout(cfg);
@@ -2318,22 +2332,20 @@
// Apply peephole optimizations
if( OptoPeephole ) {
- NOT_PRODUCT( TracePhase t2("peephole", &_t_peephole, TimeCompiler); )
+ TracePhase tp("peephole", &timers[_t_peephole]);
PhasePeephole peep( _regalloc, cfg);
peep.do_transform();
}
// Do late expand if CPU requires this.
if (Matcher::require_postalloc_expand) {
- NOT_PRODUCT(TracePhase t2c("postalloc_expand", &_t_postalloc_expand, true));
+ TracePhase tp("postalloc_expand", &timers[_t_postalloc_expand]);
cfg.postalloc_expand(_regalloc);
}
// Convert Nodes to instruction bits in a buffer
{
- // %%%% workspace merge brought two timers together for one job
- TracePhase t2a("output", &_t_output, true);
- NOT_PRODUCT( TraceTime t2b(NULL, &_t_codeGeneration, TimeCompiler, false); )
+ TraceTime tp("output", &timers[_t_output], CITime);
Output();
}
@@ -3538,11 +3550,11 @@
_root = NULL; // flush the graph, too
}
-Compile::TracePhase::TracePhase(const char* name, elapsedTimer* accumulator, bool dolog)
- : TraceTime(NULL, accumulator, false NOT_PRODUCT( || TimeCompiler ), false),
- _phase_name(name), _dolog(dolog)
+Compile::TracePhase::TracePhase(const char* name, elapsedTimer* accumulator)
+ : TraceTime(name, accumulator, CITime, CITimeVerbose),
+ _phase_name(name), _dolog(CITimeVerbose)
{
- if (dolog) {
+ if (_dolog) {
C = Compile::current();
_log = C->log();
} else {
--- a/hotspot/src/share/vm/opto/compile.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/compile.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -97,10 +97,10 @@
AliasIdxRaw = 3 // hard-wired index for TypeRawPtr::BOTTOM
};
- // Variant of TraceTime(NULL, &_t_accumulator, TimeCompiler);
- // Integrated with logging. If logging is turned on, and dolog is true,
+ // Variant of TraceTime(NULL, &_t_accumulator, CITime);
+ // Integrated with logging. If logging is turned on, and CITimeVerbose is true,
// then brackets are put into the log, with time stamps and node counts.
- // (The time collection itself is always conditionalized on TimeCompiler.)
+ // (The time collection itself is always conditionalized on CITime.)
class TracePhase : public TraceTime {
private:
Compile* C;
@@ -108,7 +108,7 @@
const char* _phase_name;
bool _dolog;
public:
- TracePhase(const char* name, elapsedTimer* accumulator, bool dolog);
+ TracePhase(const char* name, elapsedTimer* accumulator);
~TracePhase();
};
--- a/hotspot/src/share/vm/opto/escape.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/escape.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -82,7 +82,7 @@
}
void ConnectionGraph::do_analysis(Compile *C, PhaseIterGVN *igvn) {
- Compile::TracePhase t2("escapeAnalysis", &Phase::_t_escapeAnalysis, true);
+ Compile::TracePhase tp("escapeAnalysis", &Phase::timers[Phase::_t_escapeAnalysis]);
ResourceMark rm;
// Add ConP#NULL and ConN#NULL nodes before ConnectionGraph construction
@@ -117,7 +117,7 @@
GrowableArray<FieldNode*> oop_fields_worklist;
DEBUG_ONLY( GrowableArray<Node*> addp_worklist; )
- { Compile::TracePhase t3("connectionGraph", &Phase::_t_connectionGraph, true);
+ { Compile::TracePhase tp("connectionGraph", &Phase::timers[Phase::_t_connectionGraph]);
// 1. Populate Connection Graph (CG) with PointsTo nodes.
ideal_nodes.map(C->live_nodes(), NULL); // preallocate space
@@ -2839,6 +2839,13 @@
continue;
}
}
+
+ const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
+ if (t == NULL)
+ continue; // not a TypeOopPtr
+ if (!t->klass_is_exact())
+ continue; // not an unique type
+
if (alloc->is_Allocate()) {
// Set the scalar_replaceable flag for allocation
// so it could be eliminated.
@@ -2857,10 +2864,7 @@
// - not determined to be ineligible by escape analysis
set_map(alloc, n);
set_map(n, alloc);
- const TypeOopPtr *t = igvn->type(n)->isa_oopptr();
- if (t == NULL)
- continue; // not a TypeOopPtr
- const TypeOopPtr* tinst = t->cast_to_exactness(true)->is_oopptr()->cast_to_instance_id(ni);
+ const TypeOopPtr* tinst = t->cast_to_instance_id(ni);
igvn->hash_delete(n);
igvn->set_type(n, tinst);
n->raise_bottom_type(tinst);
--- a/hotspot/src/share/vm/opto/ifg.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/ifg.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -306,6 +306,7 @@
// at this point can end up in bad places). Copies I re-insert later I have
// more opportunity to insert them in low-frequency locations.
void PhaseChaitin::build_ifg_virtual( ) {
+ Compile::TracePhase tp("buildIFG_virt", &timers[_t_buildIFGvirtual]);
// For all blocks (in any order) do...
for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
@@ -739,7 +740,7 @@
* low to high register pressure transition within the block (if any).
*/
uint PhaseChaitin::build_ifg_physical( ResourceArea *a ) {
- NOT_PRODUCT(Compile::TracePhase t3("buildIFG", &_t_buildIFGphysical, TimeCompiler);)
+ Compile::TracePhase tp("buildIFG", &timers[_t_buildIFGphysical]);
uint must_spill = 0;
for (uint i = 0; i < _cfg.number_of_blocks(); i++) {
--- a/hotspot/src/share/vm/opto/output.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/output.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -1166,7 +1166,7 @@
// Have we run out of code space?
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return NULL;
}
// Configure the code buffer.
@@ -1491,7 +1491,7 @@
cb->insts()->maybe_expand_to_ensure_remaining(MAX_inst_size);
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return;
}
@@ -1648,7 +1648,7 @@
// One last check for failed CodeBuffer::expand:
if ((cb->blob() == NULL) || (!CompileBroker::should_compile_new_jobs())) {
C->record_failure("CodeCache is full");
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return;
}
@@ -1887,7 +1887,7 @@
if (max_vector_size() > 8)
return;
- NOT_PRODUCT( TracePhase t2("isched", &_t_instrSched, TimeCompiler); )
+ TracePhase tp("isched", &timers[_t_instrSched]);
// Create a data structure for all the scheduling information
Scheduling scheduling(Thread::current()->resource_area(), *this);
--- a/hotspot/src/share/vm/opto/parse1.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/parse1.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -528,7 +528,7 @@
methods_parsed++;
#ifndef PRODUCT
// add method size here to guarantee that inlined methods are added too
- if (TimeCompiler)
+ if (CITime)
_total_bytes_compiled += method()->code_size();
show_parse_info();
--- a/hotspot/src/share/vm/opto/phase.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/phase.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -30,56 +30,14 @@
#include "opto/node.hpp"
#include "opto/phase.hpp"
-#ifndef PRODUCT
int Phase::_total_bytes_compiled = 0;
elapsedTimer Phase::_t_totalCompilation;
elapsedTimer Phase::_t_methodCompilation;
elapsedTimer Phase::_t_stubCompilation;
-#endif
-// The next timers used for LogCompilation
-elapsedTimer Phase::_t_parser;
-elapsedTimer Phase::_t_optimizer;
-elapsedTimer Phase::_t_escapeAnalysis;
-elapsedTimer Phase::_t_connectionGraph;
-elapsedTimer Phase::_t_idealLoop;
-elapsedTimer Phase::_t_ccp;
-elapsedTimer Phase::_t_matcher;
-elapsedTimer Phase::_t_registerAllocation;
-elapsedTimer Phase::_t_output;
-
-#ifndef PRODUCT
-elapsedTimer Phase::_t_graphReshaping;
-elapsedTimer Phase::_t_scheduler;
-elapsedTimer Phase::_t_blockOrdering;
-elapsedTimer Phase::_t_macroEliminate;
-elapsedTimer Phase::_t_macroExpand;
-elapsedTimer Phase::_t_peephole;
-elapsedTimer Phase::_t_postalloc_expand;
-elapsedTimer Phase::_t_codeGeneration;
-elapsedTimer Phase::_t_registerMethod;
-elapsedTimer Phase::_t_temporaryTimer1;
-elapsedTimer Phase::_t_temporaryTimer2;
-elapsedTimer Phase::_t_idealLoopVerify;
-
-// Subtimers for _t_optimizer
-elapsedTimer Phase::_t_iterGVN;
-elapsedTimer Phase::_t_iterGVN2;
-elapsedTimer Phase::_t_incrInline;
-
-// Subtimers for _t_registerAllocation
-elapsedTimer Phase::_t_ctorChaitin;
-elapsedTimer Phase::_t_buildIFGphysical;
-elapsedTimer Phase::_t_computeLive;
-elapsedTimer Phase::_t_regAllocSplit;
-elapsedTimer Phase::_t_postAllocCopyRemoval;
-elapsedTimer Phase::_t_fixupSpills;
-
-// Subtimers for _t_output
-elapsedTimer Phase::_t_instrSched;
-elapsedTimer Phase::_t_buildOopMaps;
-#endif
+// The counters to use for LogCompilation
+elapsedTimer Phase::timers[max_phase_timers];
//------------------------------Phase------------------------------------------
Phase::Phase( PhaseNumber pnum ) : _pnum(pnum), C( pnum == Compiler ? NULL : Compile::current()) {
@@ -89,93 +47,132 @@
CompileBroker::maybe_block();
}
-#ifndef PRODUCT
-static const double minimum_reported_time = 0.0001; // seconds
-static const double expected_method_compile_coverage = 0.97; // %
-static const double minimum_meaningful_method_compile = 2.00; // seconds
+void Phase::print_timers() {
+ tty->print_cr (" C2 Compile Time: %7.3f s", Phase::_t_totalCompilation.seconds());
+ tty->print_cr (" Parse: %7.3f s", timers[_t_parser].seconds());
-void Phase::print_timers() {
- tty->print_cr ("Accumulated compiler times:");
- tty->print_cr ("---------------------------");
- tty->print_cr (" Total compilation: %3.3f sec.", Phase::_t_totalCompilation.seconds());
- tty->print (" method compilation : %3.3f sec", Phase::_t_methodCompilation.seconds());
- tty->print ("/%d bytes",_total_bytes_compiled);
- tty->print_cr (" (%3.0f bytes per sec) ", Phase::_total_bytes_compiled / Phase::_t_methodCompilation.seconds());
- tty->print_cr (" stub compilation : %3.3f sec.", Phase::_t_stubCompilation.seconds());
- tty->print_cr (" Phases:");
- tty->print_cr (" parse : %3.3f sec", Phase::_t_parser.seconds());
- tty->print_cr (" optimizer : %3.3f sec", Phase::_t_optimizer.seconds());
- if( Verbose || WizardMode ) {
+ {
+ tty->print_cr (" Optimize: %7.3f s", timers[_t_optimizer].seconds());
if (DoEscapeAnalysis) {
// EA is part of Optimizer.
- tty->print_cr (" escape analysis: %3.3f sec", Phase::_t_escapeAnalysis.seconds());
- tty->print_cr (" connection graph: %3.3f sec", Phase::_t_connectionGraph.seconds());
- tty->print_cr (" macroEliminate : %3.3f sec", Phase::_t_macroEliminate.seconds());
+ tty->print_cr (" Escape Analysis: %7.3f s", timers[_t_escapeAnalysis].seconds());
+ tty->print_cr (" Conn Graph: %7.3f s", timers[_t_connectionGraph].seconds());
+ tty->print_cr (" Macro Eliminate: %7.3f s", timers[_t_macroEliminate].seconds());
}
- tty->print_cr (" iterGVN : %3.3f sec", Phase::_t_iterGVN.seconds());
- tty->print_cr (" incrInline : %3.3f sec", Phase::_t_incrInline.seconds());
- tty->print_cr (" idealLoop : %3.3f sec", Phase::_t_idealLoop.seconds());
- tty->print_cr (" idealLoopVerify: %3.3f sec", Phase::_t_idealLoopVerify.seconds());
- tty->print_cr (" ccp : %3.3f sec", Phase::_t_ccp.seconds());
- tty->print_cr (" iterGVN2 : %3.3f sec", Phase::_t_iterGVN2.seconds());
- tty->print_cr (" macroExpand : %3.3f sec", Phase::_t_macroExpand.seconds());
- tty->print_cr (" graphReshape : %3.3f sec", Phase::_t_graphReshaping.seconds());
- double optimizer_subtotal = Phase::_t_iterGVN.seconds() + Phase::_t_iterGVN2.seconds() +
- Phase::_t_escapeAnalysis.seconds() + Phase::_t_macroEliminate.seconds() +
- Phase::_t_idealLoop.seconds() + Phase::_t_ccp.seconds() +
- Phase::_t_macroExpand.seconds() + Phase::_t_graphReshaping.seconds();
- double percent_of_optimizer = ((optimizer_subtotal == 0.0) ? 0.0 : (optimizer_subtotal / Phase::_t_optimizer.seconds() * 100.0));
- tty->print_cr (" subtotal : %3.3f sec, %3.2f %%", optimizer_subtotal, percent_of_optimizer);
- }
- tty->print_cr (" matcher : %3.3f sec", Phase::_t_matcher.seconds());
- tty->print_cr (" scheduler : %3.3f sec", Phase::_t_scheduler.seconds());
- tty->print_cr (" regalloc : %3.3f sec", Phase::_t_registerAllocation.seconds());
- if( Verbose || WizardMode ) {
- tty->print_cr (" ctorChaitin : %3.3f sec", Phase::_t_ctorChaitin.seconds());
- tty->print_cr (" buildIFG : %3.3f sec", Phase::_t_buildIFGphysical.seconds());
- tty->print_cr (" computeLive : %3.3f sec", Phase::_t_computeLive.seconds());
- tty->print_cr (" regAllocSplit : %3.3f sec", Phase::_t_regAllocSplit.seconds());
- tty->print_cr (" postAllocCopyRemoval: %3.3f sec", Phase::_t_postAllocCopyRemoval.seconds());
- tty->print_cr (" fixupSpills : %3.3f sec", Phase::_t_fixupSpills.seconds());
- double regalloc_subtotal = Phase::_t_ctorChaitin.seconds() +
- Phase::_t_buildIFGphysical.seconds() + Phase::_t_computeLive.seconds() +
- Phase::_t_regAllocSplit.seconds() + Phase::_t_fixupSpills.seconds() +
- Phase::_t_postAllocCopyRemoval.seconds();
- double percent_of_regalloc = ((regalloc_subtotal == 0.0) ? 0.0 : (regalloc_subtotal / Phase::_t_registerAllocation.seconds() * 100.0));
- tty->print_cr (" subtotal : %3.3f sec, %3.2f %%", regalloc_subtotal, percent_of_regalloc);
+ tty->print_cr (" GVN 1: %7.3f s", timers[_t_iterGVN].seconds());
+
+ {
+ tty->print_cr (" Incremental Inline: %7.3f s", timers[_t_incrInline].seconds());
+ tty->print_cr (" IdealLoop: %7.3f s", timers[_t_incrInline_ideal].seconds());
+ tty->print_cr (" IGVN: %7.3f s", timers[_t_incrInline_igvn].seconds());
+ tty->print_cr (" Inline: %7.3f s", timers[_t_incrInline_inline].seconds());
+ tty->print_cr (" Prune Useless: %7.3f s", timers[_t_incrInline_pru].seconds());
+
+ double other = timers[_t_incrInline].seconds() -
+ (timers[_t_incrInline_ideal].seconds() +
+ timers[_t_incrInline_igvn].seconds() +
+ timers[_t_incrInline_inline].seconds() +
+ timers[_t_incrInline_pru].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
+ }
+ tty->print_cr (" IdealLoop: %7.3f s", timers[_t_idealLoop].seconds());
+ tty->print_cr (" IdealLoop Verify: %7.3f s", timers[_t_idealLoopVerify].seconds());
+ tty->print_cr (" Cond Const Prop: %7.3f s", timers[_t_ccp].seconds());
+ tty->print_cr (" GVN 2: %7.3f s", timers[_t_iterGVN2].seconds());
+ tty->print_cr (" Macro Expand: %7.3f s", timers[_t_macroExpand].seconds());
+ tty->print_cr (" Graph Reshape: %7.3f s", timers[_t_graphReshaping].seconds());
+
+ double other = timers[_t_optimizer].seconds() -
+ (timers[_t_escapeAnalysis].seconds() +
+ timers[_t_iterGVN].seconds() +
+ timers[_t_incrInline].seconds() +
+ timers[_t_idealLoop].seconds() +
+ timers[_t_idealLoopVerify].seconds() +
+ timers[_t_ccp].seconds() +
+ timers[_t_iterGVN2].seconds() +
+ timers[_t_macroExpand].seconds() +
+ timers[_t_graphReshaping].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
}
- tty->print_cr (" blockOrdering : %3.3f sec", Phase::_t_blockOrdering.seconds());
- tty->print_cr (" peephole : %3.3f sec", Phase::_t_peephole.seconds());
- if (Matcher::require_postalloc_expand) {
- tty->print_cr (" postalloc_expand: %3.3f sec", Phase::_t_postalloc_expand.seconds());
- }
- tty->print_cr (" codeGen : %3.3f sec", Phase::_t_codeGeneration.seconds());
- tty->print_cr (" install_code : %3.3f sec", Phase::_t_registerMethod.seconds());
- tty->print_cr (" -------------- : ----------");
- double phase_subtotal = Phase::_t_parser.seconds() +
- Phase::_t_optimizer.seconds() + Phase::_t_graphReshaping.seconds() +
- Phase::_t_matcher.seconds() + Phase::_t_scheduler.seconds() +
- Phase::_t_registerAllocation.seconds() + Phase::_t_blockOrdering.seconds() +
- Phase::_t_codeGeneration.seconds() + Phase::_t_registerMethod.seconds();
- double percent_of_method_compile = ((phase_subtotal == 0.0) ? 0.0 : phase_subtotal / Phase::_t_methodCompilation.seconds()) * 100.0;
- // counters inside Compile::CodeGen include time for adapters and stubs
- // so phase-total can be greater than 100%
- tty->print_cr (" total : %3.3f sec, %3.2f %%", phase_subtotal, percent_of_method_compile);
+
+ tty->print_cr (" Matcher: %7.3f s", timers[_t_matcher].seconds());
+ tty->print_cr (" Scheduler: %7.3f s", timers[_t_scheduler].seconds());
+
+ {
+ tty->print_cr (" Regalloc: %7.3f s", timers[_t_registerAllocation].seconds());
+ tty->print_cr (" Ctor Chaitin: %7.3f s", timers[_t_ctorChaitin].seconds());
+ tty->print_cr (" Build IFG (virt): %7.3f s", timers[_t_buildIFGvirtual].seconds());
+ tty->print_cr (" Build IFG (phys): %7.3f s", timers[_t_buildIFGphysical].seconds());
+ tty->print_cr (" Compute Liveness: %7.3f s", timers[_t_computeLive].seconds());
+ tty->print_cr (" Regalloc Split: %7.3f s", timers[_t_regAllocSplit].seconds());
+ tty->print_cr (" Postalloc Copy Rem: %7.3f s", timers[_t_postAllocCopyRemoval].seconds());
+ tty->print_cr (" Fixup Spills: %7.3f s", timers[_t_fixupSpills].seconds());
+ tty->print_cr (" Compact: %7.3f s", timers[_t_chaitinCompact].seconds());
+ tty->print_cr (" Coalesce 1: %7.3f s", timers[_t_chaitinCoalesce1].seconds());
+ tty->print_cr (" Coalesce 2: %7.3f s", timers[_t_chaitinCoalesce2].seconds());
+ tty->print_cr (" Coalesce 3: %7.3f s", timers[_t_chaitinCoalesce3].seconds());
+ tty->print_cr (" Cache LRG: %7.3f s", timers[_t_chaitinCacheLRG].seconds());
+ tty->print_cr (" Simplify: %7.3f s", timers[_t_chaitinSimplify].seconds());
+ tty->print_cr (" Select: %7.3f s", timers[_t_chaitinSelect].seconds());
+
+ double other = timers[_t_registerAllocation].seconds() -
+ (timers[_t_ctorChaitin].seconds() +
+ timers[_t_buildIFGvirtual].seconds() +
+ timers[_t_buildIFGphysical].seconds() +
+ timers[_t_computeLive].seconds() +
+ timers[_t_regAllocSplit].seconds() +
+ timers[_t_postAllocCopyRemoval].seconds() +
+ timers[_t_fixupSpills].seconds() +
+ timers[_t_chaitinCompact].seconds() +
+ timers[_t_chaitinCoalesce1].seconds() +
+ timers[_t_chaitinCoalesce2].seconds() +
+ timers[_t_chaitinCoalesce3].seconds() +
+ timers[_t_chaitinCacheLRG].seconds() +
+ timers[_t_chaitinSimplify].seconds() +
+ timers[_t_chaitinSelect].seconds());
- assert( percent_of_method_compile > expected_method_compile_coverage ||
- phase_subtotal < minimum_meaningful_method_compile,
- "Must account for method compilation");
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
+ }
+ tty->print_cr (" Block Ordering: %7.3f s", timers[_t_blockOrdering].seconds());
+ tty->print_cr (" Peephole: %7.3f s", timers[_t_peephole].seconds());
+ if (Matcher::require_postalloc_expand) {
+ tty->print_cr (" Postalloc Expand: %7.3f s", timers[_t_postalloc_expand].seconds());
+ }
+ tty->print_cr (" Code Emission: %7.3f s", timers[_t_output].seconds());
+ tty->print_cr (" Insn Scheduling: %7.3f s", timers[_t_instrSched].seconds());
+ tty->print_cr (" Build OOP maps: %7.3f s", timers[_t_buildOopMaps].seconds());
+ tty->print_cr (" Code Installation: %7.3f s", timers[_t_registerMethod].seconds());
- if( Phase::_t_temporaryTimer1.seconds() > minimum_reported_time ) {
+ if( timers[_t_temporaryTimer1].seconds() > 0 ) {
tty->cr();
- tty->print_cr (" temporaryTimer1: %3.3f sec", Phase::_t_temporaryTimer1.seconds());
+ tty->print_cr (" Temp Timer 1: %7.3f s", timers[_t_temporaryTimer1].seconds());
}
- if( Phase::_t_temporaryTimer2.seconds() > minimum_reported_time ) {
+ if( timers[_t_temporaryTimer2].seconds() > 0 ) {
tty->cr();
- tty->print_cr (" temporaryTimer2: %3.3f sec", Phase::_t_temporaryTimer2.seconds());
+ tty->print_cr (" Temp Timer 2: %7.3f s", timers[_t_temporaryTimer2].seconds());
}
- tty->print_cr (" output : %3.3f sec", Phase::_t_output.seconds());
- tty->print_cr (" isched : %3.3f sec", Phase::_t_instrSched.seconds());
- tty->print_cr (" bldOopMaps : %3.3f sec", Phase::_t_buildOopMaps.seconds());
+
+ double other = Phase::_t_totalCompilation.seconds() -
+ (timers[_t_parser].seconds() +
+ timers[_t_optimizer].seconds() +
+ timers[_t_matcher].seconds() +
+ timers[_t_scheduler].seconds() +
+ timers[_t_registerAllocation].seconds() +
+ timers[_t_blockOrdering].seconds() +
+ timers[_t_peephole].seconds() +
+ timers[_t_postalloc_expand].seconds() +
+ timers[_t_output].seconds() +
+ timers[_t_registerMethod].seconds() +
+ timers[_t_temporaryTimer1].seconds() +
+ timers[_t_temporaryTimer2].seconds());
+ if (other > 0) {
+ tty->print_cr(" Other: %7.3f s", other);
+ }
+
}
-#endif
--- a/hotspot/src/share/vm/opto/phase.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/phase.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -60,63 +60,65 @@
Peephole, // Apply peephole optimizations
last_phase
};
+
+ enum PhaseTraceId {
+ _t_parser,
+ _t_optimizer,
+ _t_escapeAnalysis,
+ _t_connectionGraph,
+ _t_macroEliminate,
+ _t_iterGVN,
+ _t_incrInline,
+ _t_incrInline_ideal,
+ _t_incrInline_igvn,
+ _t_incrInline_pru,
+ _t_incrInline_inline,
+ _t_idealLoop,
+ _t_idealLoopVerify,
+ _t_ccp,
+ _t_iterGVN2,
+ _t_macroExpand,
+ _t_graphReshaping,
+ _t_matcher,
+ _t_scheduler,
+ _t_registerAllocation,
+ _t_ctorChaitin,
+ _t_buildIFGvirtual,
+ _t_buildIFGphysical,
+ _t_computeLive,
+ _t_regAllocSplit,
+ _t_postAllocCopyRemoval,
+ _t_fixupSpills,
+ _t_chaitinCompact,
+ _t_chaitinCoalesce1,
+ _t_chaitinCoalesce2,
+ _t_chaitinCoalesce3,
+ _t_chaitinCacheLRG,
+ _t_chaitinSimplify,
+ _t_chaitinSelect,
+ _t_blockOrdering,
+ _t_peephole,
+ _t_postalloc_expand,
+ _t_output,
+ _t_instrSched,
+ _t_buildOopMaps,
+ _t_registerMethod,
+ _t_temporaryTimer1,
+ _t_temporaryTimer2,
+ max_phase_timers
+ };
+
+ static elapsedTimer timers[max_phase_timers];
+
protected:
enum PhaseNumber _pnum; // Phase number (for stat gathering)
-#ifndef PRODUCT
static int _total_bytes_compiled;
// accumulated timers
static elapsedTimer _t_totalCompilation;
static elapsedTimer _t_methodCompilation;
static elapsedTimer _t_stubCompilation;
-#endif
-
-// The next timers used for LogCompilation
- static elapsedTimer _t_parser;
- static elapsedTimer _t_optimizer;
-public:
- // ConnectionGraph can't be Phase since it is used after EA done.
- static elapsedTimer _t_escapeAnalysis;
- static elapsedTimer _t_connectionGraph;
-protected:
- static elapsedTimer _t_idealLoop;
- static elapsedTimer _t_ccp;
- static elapsedTimer _t_matcher;
- static elapsedTimer _t_registerAllocation;
- static elapsedTimer _t_output;
-
-#ifndef PRODUCT
- static elapsedTimer _t_graphReshaping;
- static elapsedTimer _t_scheduler;
- static elapsedTimer _t_blockOrdering;
- static elapsedTimer _t_macroEliminate;
- static elapsedTimer _t_macroExpand;
- static elapsedTimer _t_peephole;
- static elapsedTimer _t_postalloc_expand;
- static elapsedTimer _t_codeGeneration;
- static elapsedTimer _t_registerMethod;
- static elapsedTimer _t_temporaryTimer1;
- static elapsedTimer _t_temporaryTimer2;
- static elapsedTimer _t_idealLoopVerify;
-
-// Subtimers for _t_optimizer
- static elapsedTimer _t_iterGVN;
- static elapsedTimer _t_iterGVN2;
- static elapsedTimer _t_incrInline;
-
-// Subtimers for _t_registerAllocation
- static elapsedTimer _t_ctorChaitin;
- static elapsedTimer _t_buildIFGphysical;
- static elapsedTimer _t_computeLive;
- static elapsedTimer _t_regAllocSplit;
- static elapsedTimer _t_postAllocCopyRemoval;
- static elapsedTimer _t_fixupSpills;
-
-// Subtimers for _t_output
- static elapsedTimer _t_instrSched;
- static elapsedTimer _t_buildOopMaps;
-#endif
// Generate a subtyping check. Takes as input the subtype and supertype.
// Returns 2 values: sets the default control() to the true path and
@@ -131,9 +133,7 @@
Compile * C;
Phase( PhaseNumber pnum );
-#ifndef PRODUCT
static void print_timers();
-#endif
};
#endif // SHARE_VM_OPTO_PHASE_HPP
--- a/hotspot/src/share/vm/opto/postaloc.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/postaloc.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -403,7 +403,7 @@
// When we see a use from a reg-reg Copy, we will attempt to use the copy's
// source directly and make the copy go dead.
void PhaseChaitin::post_allocate_copy_removal() {
- NOT_PRODUCT( Compile::TracePhase t3("postAllocCopyRemoval", &_t_postAllocCopyRemoval, TimeCompiler); )
+ Compile::TracePhase tp("postAllocCopyRemoval", &timers[_t_postAllocCopyRemoval]);
ResourceMark rm;
// Need a mapping from basic block Node_Lists. We need a Node_List to
--- a/hotspot/src/share/vm/opto/reg_split.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/opto/reg_split.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -468,7 +468,7 @@
// Else, hoist LRG back up to register only (ie - split is also DEF)
// We will compute a new maxlrg as we go
uint PhaseChaitin::Split(uint maxlrg, ResourceArea* split_arena) {
- NOT_PRODUCT( Compile::TracePhase t3("regAllocSplit", &_t_regAllocSplit, TimeCompiler); )
+ Compile::TracePhase tp("regAllocSplit", &timers[_t_regAllocSplit]);
// Free thread local resources used by this method on exit.
ResourceMark rm(split_arena);
--- a/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiCodeBlobEvents.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -228,19 +228,17 @@
// created nmethod will notify normally and nmethods which are freed
// can be safely skipped.
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
- nmethod* current = CodeCache::first_nmethod();
- while (current != NULL) {
- // Only notify for live nmethods
- if (current->is_alive()) {
- // Lock the nmethod so it can't be freed
- nmethodLocker nml(current);
+ // Iterate over non-profiled and profiled nmethods
+ NMethodIterator iter;
+ while(iter.next_alive()) {
+ nmethod* current = iter.method();
+ // Lock the nmethod so it can't be freed
+ nmethodLocker nml(current);
- // Don't hold the lock over the notify or jmethodID creation
- MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
- current->get_and_cache_jmethod_id();
- JvmtiExport::post_compiled_method_load(current);
- }
- current = CodeCache::next_nmethod(current);
+ // Don't hold the lock over the notify or jmethodID creation
+ MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
+ current->get_and_cache_jmethod_id();
+ JvmtiExport::post_compiled_method_load(current);
}
return JVMTI_ERROR_NONE;
}
--- a/hotspot/src/share/vm/prims/whitebox.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -257,7 +257,7 @@
G1CollectedHeap* g1 = G1CollectedHeap::heap();
oop result = JNIHandles::resolve(obj);
const HeapRegion* hr = g1->heap_region_containing(result);
- return hr->isHumongous();
+ return hr->is_humongous();
WB_END
WB_ENTRY(jlong, WB_G1NumFreeRegions(JNIEnv* env, jobject o))
@@ -713,6 +713,12 @@
WB_ENTRY(void, WB_FullGC(JNIEnv* env, jobject o))
Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(true);
Universe::heap()->collect(GCCause::_last_ditch_collection);
+#if INCLUDE_ALL_GCS
+ if (UseG1GC) {
+ // Needs to be cleared explicitly for G1
+ Universe::heap()->collector_policy()->set_should_clear_all_soft_refs(false);
+ }
+#endif // INCLUDE_ALL_GCS
WB_END
WB_ENTRY(void, WB_YoungGC(JNIEnv* env, jobject o))
@@ -814,6 +820,33 @@
MetadataFactory::free_array(cld, (Array<u1>*)(uintptr_t)addr);
WB_END
+WB_ENTRY(jlong, WB_IncMetaspaceCapacityUntilGC(JNIEnv* env, jobject wb, jlong inc))
+ if (inc < 0) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
+ err_msg("WB_IncMetaspaceCapacityUntilGC: inc is negative: " JLONG_FORMAT, inc));
+ }
+
+ jlong max_size_t = (jlong) ((size_t) -1);
+ if (inc > max_size_t) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
+ err_msg("WB_IncMetaspaceCapacityUntilGC: inc does not fit in size_t: " JLONG_FORMAT, inc));
+ }
+
+ size_t new_cap_until_GC = 0;
+ size_t aligned_inc = align_size_down((size_t) inc, Metaspace::commit_alignment());
+ bool success = MetaspaceGC::inc_capacity_until_GC(aligned_inc, &new_cap_until_GC);
+ if (!success) {
+ THROW_MSG_0(vmSymbols::java_lang_IllegalStateException(),
+ "WB_IncMetaspaceCapacityUntilGC: could not increase capacity until GC "
+ "due to contention with another thread");
+ }
+ return (jlong) new_cap_until_GC;
+WB_END
+
+WB_ENTRY(jlong, WB_MetaspaceCapacityUntilGC(JNIEnv* env, jobject wb))
+ return (jlong) MetaspaceGC::capacity_until_GC();
+WB_END
+
//Some convenience methods to deal with objects from java
int WhiteBox::offset_for_field(const char* field_name, oop object,
Symbol* signature_symbol) {
@@ -864,6 +897,36 @@
return ret;
}
+void WhiteBox::register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread, JNINativeMethod* method_array, int method_count) {
+ ResourceMark rm;
+ ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
+
+ // one by one registration natives for exception catching
+ jclass no_such_method_error_klass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
+ CHECK_JNI_EXCEPTION(env);
+ for (int i = 0, n = method_count; i < n; ++i) {
+ // Skip dummy entries
+ if (method_array[i].fnPtr == NULL) continue;
+ if (env->RegisterNatives(wbclass, &method_array[i], 1) != 0) {
+ jthrowable throwable_obj = env->ExceptionOccurred();
+ if (throwable_obj != NULL) {
+ env->ExceptionClear();
+ if (env->IsInstanceOf(throwable_obj, no_such_method_error_klass)) {
+ // NoSuchMethodError is thrown when a method can't be found or a method is not native.
+ // Ignoring the exception since it is not preventing use of other WhiteBox methods.
+ tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s",
+ method_array[i].name, method_array[i].signature);
+ }
+ } else {
+ // Registration failed unexpectedly.
+ tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered",
+ method_array[i].name, method_array[i].signature);
+ env->UnregisterNatives(wbclass);
+ break;
+ }
+ }
+ }
+}
#define CC (char*)
@@ -955,6 +1018,8 @@
CC"(Ljava/lang/ClassLoader;J)J", (void*)&WB_AllocateMetaspace },
{CC"freeMetaspace",
CC"(Ljava/lang/ClassLoader;JJ)V", (void*)&WB_FreeMetaspace },
+ {CC"incMetaspaceCapacityUntilGC", CC"(J)J", (void*)&WB_IncMetaspaceCapacityUntilGC },
+ {CC"metaspaceCapacityUntilGC", CC"()J", (void*)&WB_MetaspaceCapacityUntilGC },
{CC"getCPUFeatures", CC"()Ljava/lang/String;", (void*)&WB_GetCPUFeatures },
{CC"getNMethod", CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
(void*)&WB_GetNMethod },
@@ -971,35 +1036,9 @@
instanceKlassHandle ikh = instanceKlassHandle(JNIHandles::resolve(wbclass)->klass());
Handle loader(ikh->class_loader());
if (loader.is_null()) {
- ResourceMark rm;
- ThreadToNativeFromVM ttnfv(thread); // can't be in VM when we call JNI
- bool result = true;
- // one by one registration natives for exception catching
- jclass exceptionKlass = env->FindClass(vmSymbols::java_lang_NoSuchMethodError()->as_C_string());
- CHECK_JNI_EXCEPTION(env);
- for (int i = 0, n = sizeof(methods) / sizeof(methods[0]); i < n; ++i) {
- if (env->RegisterNatives(wbclass, methods + i, 1) != 0) {
- result = false;
- jthrowable throwable_obj = env->ExceptionOccurred();
- if (throwable_obj != NULL) {
- env->ExceptionClear();
- if (env->IsInstanceOf(throwable_obj, exceptionKlass)) {
- // j.l.NoSuchMethodError is thrown when a method can't be found or a method is not native
- // ignoring the exception
- tty->print_cr("Warning: 'NoSuchMethodError' on register of sun.hotspot.WhiteBox::%s%s", methods[i].name, methods[i].signature);
- }
- } else {
- // register is failed w/o exception or w/ unexpected exception
- tty->print_cr("Warning: unexpected error on register of sun.hotspot.WhiteBox::%s%s. All methods will be unregistered", methods[i].name, methods[i].signature);
- env->UnregisterNatives(wbclass);
- break;
- }
- }
- }
-
- if (result) {
- WhiteBox::set_used();
- }
+ WhiteBox::register_methods(env, wbclass, thread, methods, sizeof(methods) / sizeof(methods[0]));
+ WhiteBox::register_extended(env, wbclass, thread);
+ WhiteBox::set_used();
}
}
}
--- a/hotspot/src/share/vm/prims/whitebox.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/prims/whitebox.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -29,6 +29,8 @@
#include "memory/allocation.hpp"
#include "oops/oopsHierarchy.hpp"
+#include "oops/symbol.hpp"
+#include "runtime/interfaceSupport.hpp"
// Entry macro to transition from JNI to VM state.
@@ -64,6 +66,9 @@
static bool lookup_bool(const char* field_name, oop object);
static int array_bytes_to_length(size_t bytes);
+ static void register_methods(JNIEnv* env, jclass wbclass, JavaThread* thread,
+ JNINativeMethod* method_array, int method_count);
+ static void register_extended(JNIEnv* env, jclass wbclass, JavaThread* thread);
};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/prims/whitebox_ext.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2012, 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 "prims/whitebox.hpp"
+
+void WhiteBox::register_extended(JNIEnv* env, jclass wbclass, JavaThread* thread) { }
--- a/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/advancedThresholdPolicy.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -215,7 +215,7 @@
// The main intention is to keep enough free space for C2 compiled code
// to achieve peak performance if the code cache is under stress.
if ((TieredStopAtLevel == CompLevel_full_optimization) && (level != CompLevel_full_optimization)) {
- double current_reverse_free_ratio = CodeCache::reverse_free_ratio();
+ double current_reverse_free_ratio = CodeCache::reverse_free_ratio(CodeCache::get_code_blob_type(level));
if (current_reverse_free_ratio > _increase_threshold_at_ratio) {
k *= exp(current_reverse_free_ratio - _increase_threshold_at_ratio);
}
--- a/hotspot/src/share/vm/runtime/arguments.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -36,6 +36,7 @@
#include "oops/oop.inline.hpp"
#include "prims/jvmtiExport.hpp"
#include "runtime/arguments.hpp"
+#include "runtime/arguments_ext.hpp"
#include "runtime/globals_extension.hpp"
#include "runtime/java.hpp"
#include "runtime/os.hpp"
@@ -88,6 +89,8 @@
bool Arguments::_has_profile = false;
size_t Arguments::_conservative_max_heap_alignment = 0;
uintx 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;
@@ -1143,7 +1146,29 @@
}
// Increase the code cache size - tiered compiles a lot more.
if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
- FLAG_SET_DEFAULT(ReservedCodeCacheSize, ReservedCodeCacheSize * 5);
+ FLAG_SET_ERGO(uintx, ReservedCodeCacheSize, ReservedCodeCacheSize * 5);
+ }
+ // Enable SegmentedCodeCache if TieredCompilation is enabled and ReservedCodeCacheSize >= 240M
+ if (FLAG_IS_DEFAULT(SegmentedCodeCache) && ReservedCodeCacheSize >= 240*M) {
+ FLAG_SET_ERGO(bool, SegmentedCodeCache, true);
+
+ if (FLAG_IS_DEFAULT(ReservedCodeCacheSize)) {
+ // Multiply sizes by 5 but fix NonNMethodCodeHeapSize (distribute among non-profiled and profiled code heap)
+ if (FLAG_IS_DEFAULT(ProfiledCodeHeapSize)) {
+ FLAG_SET_ERGO(uintx, ProfiledCodeHeapSize, ProfiledCodeHeapSize * 5 + NonNMethodCodeHeapSize * 2);
+ }
+ if (FLAG_IS_DEFAULT(NonProfiledCodeHeapSize)) {
+ FLAG_SET_ERGO(uintx, NonProfiledCodeHeapSize, NonProfiledCodeHeapSize * 5 + NonNMethodCodeHeapSize * 2);
+ }
+ // Check consistency of code heap sizes
+ if ((NonNMethodCodeHeapSize + NonProfiledCodeHeapSize + ProfiledCodeHeapSize) != ReservedCodeCacheSize) {
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid code heap sizes: NonNMethodCodeHeapSize(%dK) + ProfiledCodeHeapSize(%dK) + NonProfiledCodeHeapSize(%dK) = %dK. Must be equal to ReservedCodeCacheSize = %uK.\n",
+ NonNMethodCodeHeapSize/K, ProfiledCodeHeapSize/K, NonProfiledCodeHeapSize/K,
+ (NonNMethodCodeHeapSize + ProfiledCodeHeapSize + NonProfiledCodeHeapSize)/K, ReservedCodeCacheSize/K);
+ vm_exit(1);
+ }
+ }
}
if (!UseInterpreter) { // -Xcomp
Tier3InvokeNotifyFreqLog = 0;
@@ -1561,24 +1586,25 @@
CollectorPolicy::compute_heap_alignment());
}
-void Arguments::set_ergonomics_flags() {
-
+void Arguments::select_gc_ergonomically() {
if (os::is_server_class_machine()) {
- // If no other collector is requested explicitly,
- // let the VM select the collector based on
- // machine class and automatic selection policy.
- if (!UseSerialGC &&
- !UseConcMarkSweepGC &&
- !UseG1GC &&
- !UseParNewGC &&
- FLAG_IS_DEFAULT(UseParallelGC)) {
- if (should_auto_select_low_pause_collector()) {
- FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
- } else {
- FLAG_SET_ERGO(bool, UseParallelGC, true);
- }
+ if (should_auto_select_low_pause_collector()) {
+ FLAG_SET_ERGO(bool, UseConcMarkSweepGC, true);
+ } else {
+ FLAG_SET_ERGO(bool, UseParallelGC, true);
}
}
+}
+
+void Arguments::select_gc() {
+ if (!gc_selected()) {
+ ArgumentsExt::select_gc_ergonomically();
+ }
+}
+
+void Arguments::set_ergonomics_flags() {
+ select_gc();
+
#ifdef COMPILER2
// Shared spaces work fine with other GCs but causes bytecode rewriting
// to be disabled, which hurts interpreter performance and decreases
@@ -1630,9 +1656,11 @@
// 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;
}
}
@@ -1664,13 +1692,18 @@
#ifdef COMPILER1
FastTLABRefill = false;
#endif
- FLAG_SET_DEFAULT(ParallelGCThreads,
- Abstract_VM_Version::parallel_worker_threads());
+ FLAG_SET_DEFAULT(ParallelGCThreads, Abstract_VM_Version::parallel_worker_threads());
if (ParallelGCThreads == 0) {
- FLAG_SET_DEFAULT(ParallelGCThreads,
- Abstract_VM_Version::parallel_worker_threads());
+ assert(!FLAG_IS_DEFAULT(ParallelGCThreads), "The default value for ParallelGCThreads should not be 0.");
+ vm_exit_during_initialization("The flag -XX:+UseG1GC can not be combined with -XX:ParallelGCThreads=0", NULL);
}
+#if INCLUDE_ALL_GCS
+ if (G1ConcRefinementThreads == 0) {
+ FLAG_SET_DEFAULT(G1ConcRefinementThreads, ParallelGCThreads);
+ }
+#endif
+
// MarkStackSize will be set (if it hasn't been set by the user)
// when concurrent marking is initialized.
// Its value will be based upon the number of parallel marking threads.
@@ -1696,6 +1729,46 @@
}
}
+#if !INCLUDE_ALL_GCS
+#ifdef ASSERT
+static bool verify_serial_gc_flags() {
+ return (UseSerialGC &&
+ !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC ||
+ UseParallelGC || UseParallelOldGC));
+}
+#endif // ASSERT
+#endif // INCLUDE_ALL_GCS
+
+void Arguments::set_gc_specific_flags() {
+#if INCLUDE_ALL_GCS
+ // Set per-collector flags
+ if (UseParallelGC || UseParallelOldGC) {
+ set_parallel_gc_flags();
+ } else if (UseConcMarkSweepGC) { // Should be done before ParNew check below
+ set_cms_and_parnew_gc_flags();
+ } else if (UseParNewGC) { // Skipped if CMS is set above
+ set_parnew_gc_flags();
+ } else if (UseG1GC) {
+ set_g1_gc_flags();
+ }
+ check_deprecated_gcs();
+ check_deprecated_gc_flags();
+ if (AssumeMP && !UseSerialGC) {
+ if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
+ warning("If the number of processors is expected to increase from one, then"
+ " you should configure the number of parallel GC threads appropriately"
+ " using -XX:ParallelGCThreads=N");
+ }
+ }
+ if (MinHeapFreeRatio == 100) {
+ // Keeping the heap 100% free is hard ;-) so limit it to 99%.
+ FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
+ }
+#else // INCLUDE_ALL_GCS
+ assert(verify_serial_gc_flags(), "SerialGC unset");
+#endif // INCLUDE_ALL_GCS
+}
+
julong Arguments::limit_by_allocatable_memory(julong limit) {
julong max_allocatable;
julong result = limit;
@@ -1937,16 +2010,6 @@
return false;
}
-#if !INCLUDE_ALL_GCS
-#ifdef ASSERT
-static bool verify_serial_gc_flags() {
- return (UseSerialGC &&
- !(UseParNewGC || (UseConcMarkSweepGC || CMSIncrementalMode) || UseG1GC ||
- UseParallelGC || UseParallelOldGC));
-}
-#endif // ASSERT
-#endif // INCLUDE_ALL_GCS
-
// check if do gclog rotation
// +UseGCLogFileRotation is a must,
// no gc log rotation when log file not supplied or
@@ -2025,6 +2088,8 @@
MaxHeapFreeRatio);
return false;
}
+ // This does not set the flag itself, but stores the value in a safe place for later usage.
+ _min_heap_free_ratio = min_heap_free_ratio;
return true;
}
@@ -2039,11 +2104,13 @@
MinHeapFreeRatio);
return false;
}
+ // This does not set the flag itself, but stores the value in a safe place for later usage.
+ _max_heap_free_ratio = max_heap_free_ratio;
return true;
}
// Check consistency of GC selection
-bool Arguments::check_gc_consistency() {
+bool Arguments::check_gc_consistency_user() {
check_gclog_consistency();
bool status = true;
// Ensure that the user has not selected conflicting sets
@@ -2202,7 +2269,7 @@
FLAG_SET_DEFAULT(UseGCOverheadLimit, false);
}
- status = status && check_gc_consistency();
+ status = status && ArgumentsExt::check_gc_consistency_user();
status = status && check_stack_pages();
if (CMSIncrementalMode) {
@@ -2442,6 +2509,18 @@
"Invalid ReservedCodeCacheSize=%dM. Must be at most %uM.\n", ReservedCodeCacheSize/M,
(2*G)/M);
status = false;
+ } else if (NonNMethodCodeHeapSize < min_code_cache_size){
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid NonNMethodCodeHeapSize=%dK. Must be at least %uK.\n", NonNMethodCodeHeapSize/K,
+ min_code_cache_size/K);
+ status = false;
+ } else if ((!FLAG_IS_DEFAULT(NonNMethodCodeHeapSize) || !FLAG_IS_DEFAULT(ProfiledCodeHeapSize) || !FLAG_IS_DEFAULT(NonProfiledCodeHeapSize))
+ && (NonNMethodCodeHeapSize + NonProfiledCodeHeapSize + ProfiledCodeHeapSize) != ReservedCodeCacheSize) {
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid code heap sizes: NonNMethodCodeHeapSize(%dK) + ProfiledCodeHeapSize(%dK) + NonProfiledCodeHeapSize(%dK) = %dK. Must be equal to ReservedCodeCacheSize = %uK.\n",
+ NonNMethodCodeHeapSize/K, ProfiledCodeHeapSize/K, NonProfiledCodeHeapSize/K,
+ (NonNMethodCodeHeapSize + ProfiledCodeHeapSize + NonProfiledCodeHeapSize)/K, ReservedCodeCacheSize/K);
+ status = false;
}
status &= verify_interval(NmethodSweepFraction, 1, ReservedCodeCacheSize/K, "NmethodSweepFraction");
@@ -2459,8 +2538,6 @@
warning("The VM option CICompilerCountPerCPU overrides CICompilerCount.");
}
- status &= check_vm_args_consistency_ext();
-
return status;
}
@@ -2868,8 +2945,41 @@
return JNI_EINVAL;
}
FLAG_SET_CMDLINE(uintx, ReservedCodeCacheSize, (uintx)long_ReservedCodeCacheSize);
+ // -XX:NonNMethodCodeHeapSize=
+ } else if (match_option(option, "-XX:NonNMethodCodeHeapSize=", &tail)) {
+ julong long_NonNMethodCodeHeapSize = 0;
+
+ ArgsRange errcode = parse_memory_size(tail, &long_NonNMethodCodeHeapSize, 1);
+ if (errcode != arg_in_range) {
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid maximum non-nmethod code heap size: %s.\n", option->optionString);
+ return JNI_EINVAL;
+ }
+ FLAG_SET_CMDLINE(uintx, NonNMethodCodeHeapSize, (uintx)long_NonNMethodCodeHeapSize);
+ // -XX:ProfiledCodeHeapSize=
+ } else if (match_option(option, "-XX:ProfiledCodeHeapSize=", &tail)) {
+ julong long_ProfiledCodeHeapSize = 0;
+
+ ArgsRange errcode = parse_memory_size(tail, &long_ProfiledCodeHeapSize, 1);
+ if (errcode != arg_in_range) {
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid maximum profiled code heap size: %s.\n", option->optionString);
+ return JNI_EINVAL;
+ }
+ FLAG_SET_CMDLINE(uintx, ProfiledCodeHeapSize, (uintx)long_ProfiledCodeHeapSize);
+ // -XX:NonProfiledCodeHeapSizee=
+ } else if (match_option(option, "-XX:NonProfiledCodeHeapSize=", &tail)) {
+ julong long_NonProfiledCodeHeapSize = 0;
+
+ ArgsRange errcode = parse_memory_size(tail, &long_NonProfiledCodeHeapSize, 1);
+ if (errcode != arg_in_range) {
+ jio_fprintf(defaultStream::error_stream(),
+ "Invalid maximum non-profiled code heap size: %s.\n", option->optionString);
+ return JNI_EINVAL;
+ }
+ FLAG_SET_CMDLINE(uintx, NonProfiledCodeHeapSize, (uintx)long_NonProfiledCodeHeapSize);
//-XX:IncreaseFirstTierCompileThresholdAt=
- } else if (match_option(option, "-XX:IncreaseFirstTierCompileThresholdAt=", &tail)) {
+ } else if (match_option(option, "-XX:IncreaseFirstTierCompileThresholdAt=", &tail)) {
uintx uint_IncreaseFirstTierCompileThresholdAt = 0;
if (!parse_uintx(tail, &uint_IncreaseFirstTierCompileThresholdAt, 0) || uint_IncreaseFirstTierCompileThresholdAt > 99) {
jio_fprintf(defaultStream::error_stream(),
@@ -3443,7 +3553,7 @@
}
}
- if (!check_vm_args_consistency()) {
+ if (!ArgumentsExt::check_vm_args_consistency()) {
return JNI_ERR;
}
@@ -3799,7 +3909,7 @@
set_shared_spaces_flags();
// Check the GC selections again.
- if (!check_gc_consistency()) {
+ if (!ArgumentsExt::check_gc_consistency_ergo()) {
return JNI_EINVAL;
}
@@ -3821,33 +3931,7 @@
// Set heap size based on available physical memory
set_heap_size();
-#if INCLUDE_ALL_GCS
- // Set per-collector flags
- if (UseParallelGC || UseParallelOldGC) {
- set_parallel_gc_flags();
- } else if (UseConcMarkSweepGC) { // Should be done before ParNew check below
- set_cms_and_parnew_gc_flags();
- } else if (UseParNewGC) { // Skipped if CMS is set above
- set_parnew_gc_flags();
- } else if (UseG1GC) {
- set_g1_gc_flags();
- }
- check_deprecated_gcs();
- check_deprecated_gc_flags();
- if (AssumeMP && !UseSerialGC) {
- if (FLAG_IS_DEFAULT(ParallelGCThreads) && ParallelGCThreads == 1) {
- warning("If the number of processors is expected to increase from one, then"
- " you should configure the number of parallel GC threads appropriately"
- " using -XX:ParallelGCThreads=N");
- }
- }
- if (MinHeapFreeRatio == 100) {
- // Keeping the heap 100% free is hard ;-) so limit it to 99%.
- FLAG_SET_ERGO(uintx, MinHeapFreeRatio, 99);
- }
-#else // INCLUDE_ALL_GCS
- assert(verify_serial_gc_flags(), "SerialGC unset");
-#endif // INCLUDE_ALL_GCS
+ set_gc_specific_flags();
// Initialize Metaspace flags and alignments
Metaspace::ergo_initialize();
--- a/hotspot/src/share/vm/runtime/arguments.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -285,7 +285,11 @@
// Value of the conservative maximum heap alignment needed
static size_t _conservative_max_heap_alignment;
- static uintx _min_heap_size;
+ 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;
@@ -336,8 +340,10 @@
static void set_conservative_max_heap_alignment();
static void set_use_compressed_oops();
static void set_use_compressed_klass_ptrs();
+ static void select_gc();
static void set_ergonomics_flags();
static void set_shared_spaces_flags();
+ static void set_gc_specific_flags();
// limits the given memory size by the maximum amount of memory this process is
// currently allowed to allocate or reserve.
static julong limit_by_allocatable_memory(julong size);
@@ -449,6 +455,9 @@
// Adjusts the arguments after the OS have adjusted the arguments
static jint adjust_after_os();
+ static inline bool gc_selected(); // whether a gc has been selected
+ static void select_gc_ergonomically();
+
// Verifies that the given value will fit as a MinHeapFreeRatio. If not, an error
// message is returned in the provided buffer.
static bool verify_MinHeapFreeRatio(FormatBuffer<80>& err_msg, uintx min_heap_free_ratio);
@@ -458,12 +467,12 @@
static bool verify_MaxHeapFreeRatio(FormatBuffer<80>& err_msg, uintx max_heap_free_ratio);
// Check for consistency in the selection of the garbage collector.
- static bool check_gc_consistency();
+ static bool check_gc_consistency_user(); // Check user-selected gc
+ static inline bool check_gc_consistency_ergo(); // Check ergonomic-selected gc
static void check_deprecated_gcs();
static void check_deprecated_gc_flags();
// Check consistency or otherwise of VM argument settings
static bool check_vm_args_consistency();
- static bool check_vm_args_consistency_ext();
// Check stack pages settings
static bool check_stack_pages();
// Used by os_solaris
@@ -516,6 +525,10 @@
static uintx min_heap_size() { return _min_heap_size; }
static void set_min_heap_size(uintx 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(); }
@@ -598,4 +611,13 @@
static bool copy_expand_pid(const char* src, size_t srclen, char* buf, size_t buflen);
};
+bool Arguments::gc_selected() {
+ return UseConcMarkSweepGC || UseG1GC || UseParallelGC || UseParallelOldGC ||
+ UseParNewGC || UseSerialGC;
+}
+
+bool Arguments::check_gc_consistency_ergo() {
+ return check_gc_consistency_user();
+}
+
#endif // SHARE_VM_RUNTIME_ARGUMENTS_HPP
--- a/hotspot/src/share/vm/runtime/arguments_ext.cpp Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,30 +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.
- *
- */
-
-#include "precompiled.hpp"
-#include "runtime/arguments.hpp"
-
-bool Arguments::check_vm_args_consistency_ext() {
- return true;
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/runtime/arguments_ext.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,55 @@
+/*
+ * 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_RUNTIME_ARGUMENTS_EXT_HPP
+#define SHARE_VM_RUNTIME_ARGUMENTS_EXT_HPP
+
+#include "memory/allocation.hpp"
+#include "runtime/arguments.hpp"
+
+class ArgumentsExt: AllStatic {
+public:
+ static inline void select_gc_ergonomically();
+ static inline bool check_gc_consistency_user();
+ static inline bool check_gc_consistency_ergo();
+ static inline bool check_vm_args_consistency();
+};
+
+void ArgumentsExt::select_gc_ergonomically() {
+ Arguments::select_gc_ergonomically();
+}
+
+bool ArgumentsExt::check_gc_consistency_user() {
+ return Arguments::check_gc_consistency_user();
+}
+
+bool ArgumentsExt::check_gc_consistency_ergo() {
+ return Arguments::check_gc_consistency_ergo();
+}
+
+bool ArgumentsExt::check_vm_args_consistency() {
+ return Arguments::check_vm_args_consistency();
+}
+
+#endif // SHARE_VM_RUNTIME_ARGUMENTS_EXT_HPP
--- a/hotspot/src/share/vm/runtime/fprofiler.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/fprofiler.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -165,7 +165,7 @@
for (int index = 0; index < s; index++) {
counters[index] = 0;
}
- base = CodeCache::first_address();
+ base = CodeCache::low_bound();
}
void PCRecorder::record(address pc) {
--- a/hotspot/src/share/vm/runtime/frame.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/frame.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -68,6 +68,15 @@
// Constructors
frame();
+#ifndef PRODUCT
+ // This is a generic constructor which is only used by pns() in debug.cpp.
+ // pns (i.e. print native stack) uses this constructor to create a starting
+ // frame for stack walking. The implementation of this constructor is platform
+ // dependent (i.e. SPARC doesn't need an 'fp' argument an will ignore it) but
+ // we want to keep the signature generic because pns() is shared code.
+ frame(void* sp, void* fp, void* pc);
+#endif
+
// Accessors
// pc: Returns the pc at which this frame will continue normally.
--- a/hotspot/src/share/vm/runtime/globals.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -186,6 +186,10 @@
define_pd_global(intx, InlineUnsafeOps, true);
define_pd_global(intx, InitialCodeCacheSize, 160*K);
define_pd_global(intx, ReservedCodeCacheSize, 32*M);
+define_pd_global(intx, NonProfiledCodeHeapSize, 0);
+define_pd_global(intx, ProfiledCodeHeapSize, 0);
+define_pd_global(intx, NonNMethodCodeHeapSize, 32*M);
+
define_pd_global(intx, CodeCacheExpansionSize, 32*K);
define_pd_global(intx, CodeCacheMinBlockLength, 1);
define_pd_global(intx, CodeCacheMinimumUseSpace, 200*K);
@@ -2483,6 +2487,9 @@
product(bool, CITime, false, \
"collect timing information for compilation") \
\
+ develop(bool, CITimeVerbose, false, \
+ "be more verbose in compilation timings") \
+ \
develop(bool, CITimeEach, false, \
"display timing information after each successful compilation") \
\
@@ -2570,9 +2577,6 @@
product(bool, UseTypeProfile, true, \
"Check interpreter profile for historically monomorphic calls") \
\
- notproduct(bool, TimeCompiler, false, \
- "Time the compiler") \
- \
diagnostic(bool, PrintInlining, false, \
"Print inlining optimizations") \
\
@@ -3354,9 +3358,21 @@
develop_pd(uintx, CodeCacheMinimumUseSpace, \
"Minimum code cache size (in bytes) required to start VM.") \
\
+ product(bool, SegmentedCodeCache, false, \
+ "Use a segmented code cache") \
+ \
product_pd(uintx, ReservedCodeCacheSize, \
"Reserved code cache size (in bytes) - maximum code cache size") \
\
+ product_pd(uintx, NonProfiledCodeHeapSize, \
+ "Size of code heap with non-profiled methods (in bytes)") \
+ \
+ product_pd(uintx, ProfiledCodeHeapSize, \
+ "Size of code heap with profiled methods (in bytes)") \
+ \
+ product_pd(uintx, NonNMethodCodeHeapSize, \
+ "Size of code heap with non-nmethods (in bytes)") \
+ \
product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
"When less than X space left, we stop compiling") \
\
--- a/hotspot/src/share/vm/runtime/init.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/init.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -49,6 +49,7 @@
void management_init();
void bytecodes_init();
void classLoader_init();
+void compilationPolicy_init();
void codeCache_init();
void VM_Version_init();
void os_init_globals(); // depends on VM_Version_init, before universe_init
@@ -68,7 +69,6 @@
void vtableStubs_init();
void InlineCacheBuffer_init();
void compilerOracle_init();
-void compilationPolicy_init();
void compileBroker_init();
// Initialization after compiler initialization
@@ -97,6 +97,7 @@
management_init();
bytecodes_init();
classLoader_init();
+ compilationPolicy_init();
codeCache_init();
VM_Version_init();
os_init_globals();
@@ -123,7 +124,6 @@
vtableStubs_init();
InlineCacheBuffer_init();
compilerOracle_init();
- compilationPolicy_init();
compileBroker_init();
VMRegImpl::set_regName();
--- a/hotspot/src/share/vm/runtime/java.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/java.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -272,9 +272,6 @@
print_method_profiling_data();
- if (TimeCompiler) {
- COMPILER2_PRESENT(Compile::print_timers();)
- }
if (TimeCompilationPolicy) {
CompilationPolicy::policy()->print_time();
}
--- a/hotspot/src/share/vm/runtime/serviceThread.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/serviceThread.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -29,6 +29,7 @@
#include "runtime/mutexLocker.hpp"
#include "runtime/os.hpp"
#include "prims/jvmtiImpl.hpp"
+#include "services/allocationContextService.hpp"
#include "services/gcNotifier.hpp"
#include "services/diagnosticArgument.hpp"
#include "services/diagnosticFramework.hpp"
@@ -86,6 +87,7 @@
bool has_jvmti_events = false;
bool has_gc_notification_event = false;
bool has_dcmd_notification_event = false;
+ bool acs_notify = false;
JvmtiDeferredEvent jvmti_event;
{
// Need state transition ThreadBlockInVM so that this thread
@@ -102,7 +104,8 @@
while (!(sensors_changed = LowMemoryDetector::has_pending_requests()) &&
!(has_jvmti_events = JvmtiDeferredEventQueue::has_events()) &&
!(has_gc_notification_event = GCNotifier::has_event()) &&
- !(has_dcmd_notification_event = DCmdFactory::has_pending_jmx_notification())) {
+ !(has_dcmd_notification_event = DCmdFactory::has_pending_jmx_notification()) &&
+ !(acs_notify = AllocationContextService::should_notify())) {
// wait until one of the sensors has pending requests, or there is a
// pending JVMTI event or JMX GC notification to post
Service_lock->wait(Mutex::_no_safepoint_check_flag);
@@ -128,6 +131,10 @@
if(has_dcmd_notification_event) {
DCmdFactory::send_notification(CHECK);
}
+
+ if (acs_notify) {
+ AllocationContextService::notify(CHECK);
+ }
}
}
--- a/hotspot/src/share/vm/runtime/sharedRuntime.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/sharedRuntime.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -2422,7 +2422,7 @@
// Ought to log this but compile log is only per compile thread
// and we're some non descript Java thread.
MutexUnlocker mu(AdapterHandlerLibrary_lock);
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::NonNMethod);
return NULL; // Out of CodeCache space
}
entry->relocate(new_adapter->content_begin());
@@ -2596,7 +2596,7 @@
nm->post_compiled_method_load_event();
} else {
// CodeCache is full, disable compilation
- CompileBroker::handle_full_code_cache();
+ CompileBroker::handle_full_code_cache(CodeBlobType::MethodNonProfiled);
}
}
--- a/hotspot/src/share/vm/runtime/sweeper.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/sweeper.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -131,7 +131,7 @@
#define SWEEP(nm)
#endif
-nmethod* NMethodSweeper::_current = NULL; // Current nmethod
+NMethodIterator NMethodSweeper::_current; // Current nmethod
long NMethodSweeper::_traversals = 0; // Stack scan count, also sweep ID.
long NMethodSweeper::_total_nof_code_cache_sweeps = 0; // Total number of full sweeps of the code cache
long NMethodSweeper::_time_counter = 0; // Virtual time used to periodically invoke sweeper
@@ -150,26 +150,24 @@
// 3) zombie -> marked_for_reclamation
int NMethodSweeper::_hotness_counter_reset_val = 0;
-long NMethodSweeper::_total_nof_methods_reclaimed = 0; // Accumulated nof methods flushed
-long NMethodSweeper::_total_nof_c2_methods_reclaimed = 0; // Accumulated nof methods flushed
-size_t NMethodSweeper::_total_flushed_size = 0; // Total number of bytes flushed from the code cache
-Tickspan NMethodSweeper::_total_time_sweeping; // Accumulated time sweeping
-Tickspan NMethodSweeper::_total_time_this_sweep; // Total time this sweep
-Tickspan NMethodSweeper::_peak_sweep_time; // Peak time for a full sweep
-Tickspan NMethodSweeper::_peak_sweep_fraction_time; // Peak time sweeping one fraction
-
+long NMethodSweeper::_total_nof_methods_reclaimed = 0; // Accumulated nof methods flushed
+long NMethodSweeper::_total_nof_c2_methods_reclaimed = 0; // Accumulated nof methods flushed
+size_t NMethodSweeper::_total_flushed_size = 0; // Total number of bytes flushed from the code cache
+Tickspan NMethodSweeper::_total_time_sweeping; // Accumulated time sweeping
+Tickspan NMethodSweeper::_total_time_this_sweep; // Total time this sweep
+Tickspan NMethodSweeper::_peak_sweep_time; // Peak time for a full sweep
+Tickspan NMethodSweeper::_peak_sweep_fraction_time; // Peak time sweeping one fraction
class MarkActivationClosure: public CodeBlobClosure {
public:
virtual void do_code_blob(CodeBlob* cb) {
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
- nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
- // If we see an activation belonging to a non_entrant nmethod, we mark it.
- if (nm->is_not_entrant()) {
- nm->mark_as_seen_on_stack();
- }
+ assert(cb->is_nmethod(), "CodeBlob should be nmethod");
+ nmethod* nm = (nmethod*)cb;
+ nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
+ // If we see an activation belonging to a non_entrant nmethod, we mark it.
+ if (nm->is_not_entrant()) {
+ nm->mark_as_seen_on_stack();
}
}
};
@@ -178,10 +176,9 @@
class SetHotnessClosure: public CodeBlobClosure {
public:
virtual void do_code_blob(CodeBlob* cb) {
- if (cb->is_nmethod()) {
- nmethod* nm = (nmethod*)cb;
- nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
- }
+ assert(cb->is_nmethod(), "CodeBlob should be nmethod");
+ nmethod* nm = (nmethod*)cb;
+ nm->set_hotness_counter(NMethodSweeper::hotness_counter_reset_val());
}
};
static SetHotnessClosure set_hotness_closure;
@@ -194,7 +191,7 @@
return _hotness_counter_reset_val;
}
bool NMethodSweeper::sweep_in_progress() {
- return (_current != NULL);
+ return !_current.end();
}
// Scans the stacks of all Java threads and marks activations of not-entrant methods.
@@ -212,11 +209,13 @@
_time_counter++;
// Check for restart
- assert(CodeCache::find_blob_unsafe(_current) == _current, "Sweeper nmethod cached state invalid");
+ assert(CodeCache::find_blob_unsafe(_current.method()) == _current.method(), "Sweeper nmethod cached state invalid");
if (!sweep_in_progress()) {
_seen = 0;
_sweep_fractions_left = NmethodSweepFraction;
- _current = CodeCache::first_nmethod();
+ _current = NMethodIterator();
+ // Initialize to first nmethod
+ _current.next();
_traversals += 1;
_total_time_this_sweep = Tickspan();
@@ -271,7 +270,9 @@
// an unsigned type would cause an underflow (wait_until_next_sweep becomes a large positive
// value) that disables the intended periodic sweeps.
const int max_wait_time = ReservedCodeCacheSize / (16 * M);
- double wait_until_next_sweep = max_wait_time - time_since_last_sweep - CodeCache::reverse_free_ratio();
+ double wait_until_next_sweep = max_wait_time - time_since_last_sweep -
+ MAX2(CodeCache::reverse_free_ratio(CodeBlobType::MethodProfiled),
+ CodeCache::reverse_free_ratio(CodeBlobType::MethodNonProfiled));
assert(wait_until_next_sweep <= (double)max_wait_time, "Calculation of code cache sweeper interval is incorrect");
if ((wait_until_next_sweep <= 0.0) || !CompileBroker::should_compile_new_jobs()) {
@@ -353,7 +354,7 @@
MutexLockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
// The last invocation iterates until there are no more nmethods
- for (int i = 0; (i < todo || _sweep_fractions_left == 1) && _current != NULL; i++) {
+ while ((swept_count < todo || _sweep_fractions_left == 1) && !_current.end()) {
swept_count++;
if (SafepointSynchronize::is_synchronizing()) { // Safepoint request
if (PrintMethodFlushing && Verbose) {
@@ -369,19 +370,19 @@
// Since we will give up the CodeCache_lock, always skip ahead
// to the next nmethod. Other blobs can be deleted by other
// threads but nmethods are only reclaimed by the sweeper.
- nmethod* next = CodeCache::next_nmethod(_current);
+ nmethod* nm = _current.method();
+ _current.next();
// Now ready to process nmethod and give up CodeCache_lock
{
MutexUnlockerEx mu(CodeCache_lock, Mutex::_no_safepoint_check_flag);
- freed_memory += process_nmethod(_current);
+ freed_memory += process_nmethod(nm);
}
_seen++;
- _current = next;
}
}
- assert(_sweep_fractions_left > 1 || _current == NULL, "must have scanned the whole cache");
+ assert(_sweep_fractions_left > 1 || _current.end(), "must have scanned the whole cache");
const Ticks sweep_end_counter = Ticks::now();
const Tickspan sweep_time = sweep_end_counter - sweep_start_counter;
@@ -542,6 +543,10 @@
if (PrintMethodFlushing && Verbose) {
tty->print_cr("### Nmethod %3d/" PTR_FORMAT " (not entrant) being made zombie", nm->compile_id(), nm);
}
+ // 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();
// Code cache state change is tracked in make_zombie()
nm->make_zombie();
_zombified_count++;
@@ -594,7 +599,8 @@
// ReservedCodeCacheSize
int reset_val = hotness_counter_reset_val();
int time_since_reset = reset_val - nm->hotness_counter();
- double threshold = -reset_val + (CodeCache::reverse_free_ratio() * NmethodSweepActivity);
+ int code_blob_type = (CodeCache::get_code_blob_type(nm->comp_level()));
+ double threshold = -reset_val + (CodeCache::reverse_free_ratio(code_blob_type) * NmethodSweepActivity);
// The less free space in the code cache we have - the bigger reverse_free_ratio() is.
// I.e., 'threshold' increases with lower available space in the code cache and a higher
// NmethodSweepActivity. If the current hotness counter - which decreases from its initial
@@ -614,12 +620,7 @@
// The stack-scanning low-cost detection may not see the method was used (which can happen for
// flat profiles). Check the age counter for possible data.
if (UseCodeAging && make_not_entrant && (nm->is_compiled_by_c2() || nm->is_compiled_by_c1())) {
- MethodCounters* mc = nm->method()->method_counters();
- if (mc == NULL) {
- // Sometimes we can get here without MethodCounters. For example if we run with -Xcomp.
- // Try to allocate them.
- mc = nm->method()->get_method_counters(Thread::current());
- }
+ MethodCounters* mc = nm->method()->get_method_counters(Thread::current());
if (mc != NULL) {
// Snapshot the value as it's changed concurrently
int age = mc->nmethod_age();
--- a/hotspot/src/share/vm/runtime/sweeper.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/sweeper.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -54,33 +54,33 @@
// is full.
class NMethodSweeper : public AllStatic {
- static long _traversals; // Stack scan count, also sweep ID.
- static long _total_nof_code_cache_sweeps; // Total number of full sweeps of the code cache
- static long _time_counter; // Virtual time used to periodically invoke sweeper
- static long _last_sweep; // Value of _time_counter when the last sweep happened
- static nmethod* _current; // Current nmethod
- static int _seen; // Nof. nmethod we have currently processed in current pass of CodeCache
- static int _flushed_count; // Nof. nmethods flushed in current sweep
- static int _zombified_count; // Nof. nmethods made zombie in current sweep
- static int _marked_for_reclamation_count; // Nof. nmethods marked for reclaim in current sweep
+ static long _traversals; // Stack scan count, also sweep ID.
+ static long _total_nof_code_cache_sweeps; // Total number of full sweeps of the code cache
+ static long _time_counter; // Virtual time used to periodically invoke sweeper
+ static long _last_sweep; // Value of _time_counter when the last sweep happened
+ static NMethodIterator _current; // Current nmethod
+ static int _seen; // Nof. nmethod we have currently processed in current pass of CodeCache
+ static int _flushed_count; // Nof. nmethods flushed in current sweep
+ static int _zombified_count; // Nof. nmethods made zombie in current sweep
+ static int _marked_for_reclamation_count; // Nof. nmethods marked for reclaim in current sweep
- static volatile int _sweep_fractions_left; // Nof. invocations left until we are completed with this pass
- static volatile int _sweep_started; // Flag to control conc sweeper
- static volatile bool _should_sweep; // Indicates if we should invoke the sweeper
- static volatile int _bytes_changed; // Counts the total nmethod size if the nmethod changed from:
- // 1) alive -> not_entrant
- // 2) not_entrant -> zombie
- // 3) zombie -> marked_for_reclamation
+ static volatile int _sweep_fractions_left; // Nof. invocations left until we are completed with this pass
+ static volatile int _sweep_started; // Flag to control conc sweeper
+ static volatile bool _should_sweep; // Indicates if we should invoke the sweeper
+ static volatile int _bytes_changed; // Counts the total nmethod size if the nmethod changed from:
+ // 1) alive -> not_entrant
+ // 2) not_entrant -> zombie
+ // 3) zombie -> marked_for_reclamation
// Stat counters
static long _total_nof_methods_reclaimed; // Accumulated nof methods flushed
static long _total_nof_c2_methods_reclaimed; // Accumulated nof C2-compiled methods flushed
static size_t _total_flushed_size; // Total size of flushed methods
static int _hotness_counter_reset_val;
- static Tickspan _total_time_sweeping; // Accumulated time sweeping
- static Tickspan _total_time_this_sweep; // Total time this sweep
- static Tickspan _peak_sweep_time; // Peak time for a full sweep
- static Tickspan _peak_sweep_fraction_time; // Peak time sweeping one fraction
+ static Tickspan _total_time_sweeping; // Accumulated time sweeping
+ static Tickspan _total_time_this_sweep; // Total time this sweep
+ static Tickspan _peak_sweep_time; // Peak time for a full sweep
+ static Tickspan _peak_sweep_fraction_time; // Peak time sweeping one fraction
static int process_nmethod(nmethod *nm);
static void release_nmethod(nmethod* nm);
@@ -98,7 +98,7 @@
#ifdef ASSERT
- static bool is_sweeping(nmethod* which) { return _current == which; }
+ static bool is_sweeping(nmethod* which) { return _current.method() == which; }
// Keep track of sweeper activity in the ring buffer
static void record_sweep(nmethod* nm, int line);
static void report_events(int id, address entry);
--- a/hotspot/src/share/vm/runtime/thread.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/thread.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -826,6 +826,7 @@
st->print("os_prio=%d ", os_prio);
}
st->print("tid=" INTPTR_FORMAT " ", this);
+ ext().print_on(st);
osthread()->print_on(st);
}
debug_only(if (WizardMode) print_owned_locks_on(st);)
@@ -2964,6 +2965,8 @@
// Push the Java priority down to the native thread; needs Threads_lock
Thread::set_priority(this, prio);
+ prepare_ext();
+
// Add the new thread to the Threads list and set it in motion.
// We must have threads lock in order to call Threads::add.
// It is crucial that we do not block before the thread is
@@ -3795,6 +3798,24 @@
}
}
+JavaThread* Threads::find_java_thread_from_java_tid(jlong java_tid) {
+ assert(Threads_lock->owned_by_self(), "Must hold Threads_lock");
+
+ JavaThread* java_thread = NULL;
+ // Sequential search for now. Need to do better optimization later.
+ for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
+ oop tobj = thread->threadObj();
+ if (!thread->is_exiting() &&
+ tobj != NULL &&
+ java_tid == java_lang_Thread::thread_id(tobj)) {
+ java_thread = thread;
+ break;
+ }
+ }
+ return java_thread;
+}
+
+
// Last thread running calls java.lang.Shutdown.shutdown()
void JavaThread::invoke_shutdown_hooks() {
HandleMark hm(this);
--- a/hotspot/src/share/vm/runtime/thread.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/thread.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -40,6 +40,7 @@
#include "runtime/safepoint.hpp"
#include "runtime/stubRoutines.hpp"
#include "runtime/threadLocalStorage.hpp"
+#include "runtime/thread_ext.hpp"
#include "runtime/unhandledOops.hpp"
#include "utilities/macros.hpp"
@@ -256,6 +257,8 @@
TRACE_DATA _trace_data; // Thread-local data for tracing
+ ThreadExt _ext;
+
int _vm_operation_started_count; // VM_Operation support
int _vm_operation_completed_count; // VM_Operation support
@@ -409,6 +412,9 @@
TRACE_DATA* trace_data() { return &_trace_data; }
+ const ThreadExt& ext() const { return _ext; }
+ ThreadExt& ext() { return _ext; }
+
// VM operation support
int vm_operation_ticket() { return ++_vm_operation_started_count; }
int vm_operation_completed_count() { return _vm_operation_completed_count; }
@@ -978,6 +984,7 @@
// not specified, use the priority of the thread object. Threads_lock
// must be held while this function is called.
void prepare(jobject jni_thread, ThreadPriority prio=NoPriority);
+ void prepare_ext();
void set_saved_exception_pc(address pc) { _saved_exception_pc = pc; }
address saved_exception_pc() { return _saved_exception_pc; }
@@ -1910,6 +1917,8 @@
// Deoptimizes all frames tied to marked nmethods
static void deoptimized_wrt_marked_nmethods();
+ static JavaThread* find_java_thread_from_java_tid(jlong java_tid);
+
};
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/runtime/thread_ext.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,31 @@
+/*
+ * 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.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "runtime/thread.hpp"
+#include "runtime/thread_ext.hpp"
+
+void JavaThread::prepare_ext() {
+}
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/runtime/thread_ext.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,35 @@
+/*
+ * 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_RUNTIME_THREAD_EXT_HPP
+#define SHARE_VM_RUNTIME_THREAD_EXT_HPP
+
+#include "memory/allocation.hpp"
+
+class ThreadExt VALUE_OBJ_CLASS_SPEC {
+public:
+ void print_on(outputStream* st) const {};
+};
+
+#endif // SHARE_VM_RUNTIME_THREAD_EXT_HPP
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -765,8 +765,8 @@
/* CodeCache (NOTE: incomplete) */ \
/********************************/ \
\
- static_field(CodeCache, _heap, CodeHeap*) \
- static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \
+ static_field(CodeCache, _heaps, GrowableArray<CodeHeap*>*) \
+ static_field(CodeCache, _scavenge_root_nmethods, nmethod*) \
\
/*******************************/ \
/* CodeHeap (NOTE: incomplete) */ \
--- a/hotspot/src/share/vm/runtime/vm_operations.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/runtime/vm_operations.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -68,6 +68,7 @@
template(G1CollectFull) \
template(G1CollectForAllocation) \
template(G1IncCollectionPause) \
+ template(DestroyAllocationContext) \
template(EnableBiasedLocking) \
template(RevokeBias) \
template(BulkRevokeBias) \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/src/share/vm/services/allocationContextService.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,39 @@
+/*
+ * 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_SERVICES_ALLOCATION_CONTEXT_SERVICE_HPP
+#define SHARE_VM_SERVICES_ALLOCATION_CONTEXT_SERVICE_HPP
+
+#include "utilities/exceptions.hpp"
+
+class AllocationContextService: public AllStatic {
+public:
+ static inline bool should_notify();
+ static inline void notify(TRAPS);
+};
+
+bool AllocationContextService::should_notify() { return false; }
+void AllocationContextService::notify(TRAPS) { }
+
+#endif // SHARE_VM_SERVICES_ALLOCATION_CONTEXT_SERVICE_HPP
--- a/hotspot/src/share/vm/services/diagnosticCommand.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/diagnosticCommand.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -427,7 +427,7 @@
return "Compiler.codelist";
}
static const char* description() {
- return "Print all compiled methods in code cache.";
+ return "Print all compiled methods in code cache that are alive";
}
static const char* impact() {
return "Medium";
--- a/hotspot/src/share/vm/services/heapDumper.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/heapDumper.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -722,7 +722,7 @@
// reflection and sun.misc.Unsafe classes may have a reference to a
// Klass* so filter it out.
- assert(o->is_oop_or_null(), "should always be an oop");
+ assert(o->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(o)));
writer->write_objectID(o);
break;
}
--- a/hotspot/src/share/vm/services/mallocTracker.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/mallocTracker.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -140,11 +140,6 @@
return NULL;
}
- // Check malloc size, size has to <= MAX_MALLOC_SIZE. This is only possible on 32-bit
- // systems, when malloc size >= 1GB, but is is safe to assume it won't happen.
- if (size > MAX_MALLOC_SIZE) {
- fatal("Should not use malloc for big memory block, use virtual memory instead");
- }
// Uses placement global new operator to initialize malloc header
switch(level) {
case NMT_off:
@@ -154,10 +149,12 @@
break;
}
case NMT_summary: {
+ assert(size <= MAX_MALLOC_SIZE, "malloc size overrun for NMT");
header = ::new (malloc_base) MallocHeader(size, flags);
break;
}
case NMT_detail: {
+ assert(size <= MAX_MALLOC_SIZE, "malloc size overrun for NMT");
header = ::new (malloc_base) MallocHeader(size, flags, stack);
break;
}
--- a/hotspot/src/share/vm/services/management.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/management.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -392,23 +392,6 @@
return (instanceOop) element();
}
-// Helper functions
-static JavaThread* find_java_thread_from_id(jlong thread_id) {
- assert(Threads_lock->owned_by_self(), "Must hold Threads_lock");
-
- JavaThread* java_thread = NULL;
- // Sequential search for now. Need to do better optimization later.
- for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {
- oop tobj = thread->threadObj();
- if (!thread->is_exiting() &&
- tobj != NULL &&
- thread_id == java_lang_Thread::thread_id(tobj)) {
- java_thread = thread;
- break;
- }
- }
- return java_thread;
-}
static GCMemoryManager* get_gc_memory_manager_from_jobject(jobject mgr, TRAPS) {
if (mgr == NULL) {
@@ -445,6 +428,8 @@
return MemoryService::get_memory_pool(ph);
}
+#endif // INCLUDE_MANAGEMENT
+
static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {
int num_threads = ids_ah->length();
@@ -460,6 +445,8 @@
}
}
+#if INCLUDE_MANAGEMENT
+
static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {
// check if the element of infoArray is of type ThreadInfo class
Klass* threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);
@@ -823,45 +810,6 @@
return prev;
JVM_END
-// Gets an array containing the amount of memory allocated on the Java
-// heap for a set of threads (in bytes). Each element of the array is
-// the amount of memory allocated for the thread ID specified in the
-// corresponding entry in the given array of thread IDs; or -1 if the
-// thread does not exist or has terminated.
-JVM_ENTRY(void, jmm_GetThreadAllocatedMemory(JNIEnv *env, jlongArray ids,
- jlongArray sizeArray))
- // Check if threads is null
- if (ids == NULL || sizeArray == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
-
- ResourceMark rm(THREAD);
- typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
- typeArrayHandle ids_ah(THREAD, ta);
-
- typeArrayOop sa = typeArrayOop(JNIHandles::resolve_non_null(sizeArray));
- typeArrayHandle sizeArray_h(THREAD, sa);
-
- // validate the thread id array
- validate_thread_id_array(ids_ah, CHECK);
-
- // sizeArray must be of the same length as the given array of thread IDs
- int num_threads = ids_ah->length();
- if (num_threads != sizeArray_h->length()) {
- THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
- "The length of the given long array does not match the length of "
- "the given array of thread IDs");
- }
-
- MutexLockerEx ml(Threads_lock);
- for (int i = 0; i < num_threads; i++) {
- JavaThread* java_thread = find_java_thread_from_id(ids_ah->long_at(i));
- if (java_thread != NULL) {
- sizeArray_h->long_at_put(i, java_thread->cooked_allocated_bytes());
- }
- }
-JVM_END
-
// Returns a java/lang/management/MemoryUsage object representing
// the memory usage for the heap or non-heap memory.
JVM_ENTRY(jobject, jmm_GetMemoryUsage(JNIEnv* env, jboolean heap))
@@ -1167,7 +1115,7 @@
MutexLockerEx ml(Threads_lock);
for (int i = 0; i < num_threads; i++) {
jlong tid = ids_ah->long_at(i);
- JavaThread* jt = find_java_thread_from_id(tid);
+ JavaThread* jt = Threads::find_java_thread_from_java_tid(tid);
oop thread_obj = (jt != NULL ? jt->threadObj() : (oop)NULL);
instanceHandle threadObj_h(THREAD, (instanceOop) thread_obj);
thread_handle_array->append(threadObj_h);
@@ -1244,7 +1192,7 @@
MutexLockerEx ml(Threads_lock);
for (int i = 0; i < num_threads; i++) {
jlong tid = ids_ah->long_at(i);
- JavaThread* jt = find_java_thread_from_id(tid);
+ JavaThread* jt = Threads::find_java_thread_from_java_tid(tid);
ThreadSnapshot* ts;
if (jt == NULL) {
// if the thread does not exist or now it is terminated,
@@ -1488,7 +1436,7 @@
}
} else {
// reset contention statistics for a given thread
- JavaThread* java_thread = find_java_thread_from_id(tid);
+ JavaThread* java_thread = Threads::find_java_thread_from_java_tid(tid);
if (java_thread == NULL) {
return false;
}
@@ -1557,7 +1505,7 @@
return os::current_thread_cpu_time();
} else {
MutexLockerEx ml(Threads_lock);
- java_thread = find_java_thread_from_id(thread_id);
+ java_thread = Threads::find_java_thread_from_java_tid(thread_id);
if (java_thread != NULL) {
return os::thread_cpu_time((Thread*) java_thread);
}
@@ -1565,78 +1513,6 @@
return -1;
JVM_END
-// Returns the CPU time consumed by a given thread (in nanoseconds).
-// If thread_id == 0, CPU time for the current thread is returned.
-// If user_sys_cpu_time = true, user level and system CPU time of
-// a given thread is returned; otherwise, only user level CPU time
-// is returned.
-JVM_ENTRY(jlong, jmm_GetThreadCpuTimeWithKind(JNIEnv *env, jlong thread_id, jboolean user_sys_cpu_time))
- if (!os::is_thread_cpu_time_supported()) {
- return -1;
- }
-
- if (thread_id < 0) {
- THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
- "Invalid thread ID", -1);
- }
-
- JavaThread* java_thread = NULL;
- if (thread_id == 0) {
- // current thread
- return os::current_thread_cpu_time(user_sys_cpu_time != 0);
- } else {
- MutexLockerEx ml(Threads_lock);
- java_thread = find_java_thread_from_id(thread_id);
- if (java_thread != NULL) {
- return os::thread_cpu_time((Thread*) java_thread, user_sys_cpu_time != 0);
- }
- }
- return -1;
-JVM_END
-
-// Gets an array containing the CPU times consumed by a set of threads
-// (in nanoseconds). Each element of the array is the CPU time for the
-// thread ID specified in the corresponding entry in the given array
-// of thread IDs; or -1 if the thread does not exist or has terminated.
-// If user_sys_cpu_time = true, the sum of user level and system CPU time
-// for the given thread is returned; otherwise, only user level CPU time
-// is returned.
-JVM_ENTRY(void, jmm_GetThreadCpuTimesWithKind(JNIEnv *env, jlongArray ids,
- jlongArray timeArray,
- jboolean user_sys_cpu_time))
- // Check if threads is null
- if (ids == NULL || timeArray == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
-
- ResourceMark rm(THREAD);
- typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
- typeArrayHandle ids_ah(THREAD, ta);
-
- typeArrayOop tia = typeArrayOop(JNIHandles::resolve_non_null(timeArray));
- typeArrayHandle timeArray_h(THREAD, tia);
-
- // validate the thread id array
- validate_thread_id_array(ids_ah, CHECK);
-
- // timeArray must be of the same length as the given array of thread IDs
- int num_threads = ids_ah->length();
- if (num_threads != timeArray_h->length()) {
- THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
- "The length of the given long array does not match the length of "
- "the given array of thread IDs");
- }
-
- MutexLockerEx ml(Threads_lock);
- for (int i = 0; i < num_threads; i++) {
- JavaThread* java_thread = find_java_thread_from_id(ids_ah->long_at(i));
- if (java_thread != NULL) {
- timeArray_h->long_at_put(i, os::thread_cpu_time((Thread*)java_thread,
- user_sys_cpu_time != 0));
- }
- }
-JVM_END
-
// Returns a String array of all VM global flag names
JVM_ENTRY(jobjectArray, jmm_GetVMGlobalNames(JNIEnv *env))
// last flag entry is always NULL, so subtract 1
@@ -2331,7 +2207,122 @@
return (jlong)(((double)ticks / (double)os::elapsed_frequency())
* (double)1000.0);
}
+#endif // INCLUDE_MANAGEMENT
+// Gets an array containing the amount of memory allocated on the Java
+// heap for a set of threads (in bytes). Each element of the array is
+// the amount of memory allocated for the thread ID specified in the
+// corresponding entry in the given array of thread IDs; or -1 if the
+// thread does not exist or has terminated.
+JVM_ENTRY(void, jmm_GetThreadAllocatedMemory(JNIEnv *env, jlongArray ids,
+ jlongArray sizeArray))
+ // Check if threads is null
+ if (ids == NULL || sizeArray == NULL) {
+ THROW(vmSymbols::java_lang_NullPointerException());
+ }
+
+ ResourceMark rm(THREAD);
+ typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
+ typeArrayHandle ids_ah(THREAD, ta);
+
+ typeArrayOop sa = typeArrayOop(JNIHandles::resolve_non_null(sizeArray));
+ typeArrayHandle sizeArray_h(THREAD, sa);
+
+ // validate the thread id array
+ validate_thread_id_array(ids_ah, CHECK);
+
+ // sizeArray must be of the same length as the given array of thread IDs
+ int num_threads = ids_ah->length();
+ if (num_threads != sizeArray_h->length()) {
+ THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+ "The length of the given long array does not match the length of "
+ "the given array of thread IDs");
+ }
+
+ MutexLockerEx ml(Threads_lock);
+ for (int i = 0; i < num_threads; i++) {
+ JavaThread* java_thread = Threads::find_java_thread_from_java_tid(ids_ah->long_at(i));
+ if (java_thread != NULL) {
+ sizeArray_h->long_at_put(i, java_thread->cooked_allocated_bytes());
+ }
+ }
+JVM_END
+
+// Returns the CPU time consumed by a given thread (in nanoseconds).
+// If thread_id == 0, CPU time for the current thread is returned.
+// If user_sys_cpu_time = true, user level and system CPU time of
+// a given thread is returned; otherwise, only user level CPU time
+// is returned.
+JVM_ENTRY(jlong, jmm_GetThreadCpuTimeWithKind(JNIEnv *env, jlong thread_id, jboolean user_sys_cpu_time))
+ if (!os::is_thread_cpu_time_supported()) {
+ return -1;
+ }
+
+ if (thread_id < 0) {
+ THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
+ "Invalid thread ID", -1);
+ }
+
+ JavaThread* java_thread = NULL;
+ if (thread_id == 0) {
+ // current thread
+ return os::current_thread_cpu_time(user_sys_cpu_time != 0);
+ } else {
+ MutexLockerEx ml(Threads_lock);
+ java_thread = Threads::find_java_thread_from_java_tid(thread_id);
+ if (java_thread != NULL) {
+ return os::thread_cpu_time((Thread*) java_thread, user_sys_cpu_time != 0);
+ }
+ }
+ return -1;
+JVM_END
+
+// Gets an array containing the CPU times consumed by a set of threads
+// (in nanoseconds). Each element of the array is the CPU time for the
+// thread ID specified in the corresponding entry in the given array
+// of thread IDs; or -1 if the thread does not exist or has terminated.
+// If user_sys_cpu_time = true, the sum of user level and system CPU time
+// for the given thread is returned; otherwise, only user level CPU time
+// is returned.
+JVM_ENTRY(void, jmm_GetThreadCpuTimesWithKind(JNIEnv *env, jlongArray ids,
+ jlongArray timeArray,
+ jboolean user_sys_cpu_time))
+ // Check if threads is null
+ if (ids == NULL || timeArray == NULL) {
+ THROW(vmSymbols::java_lang_NullPointerException());
+ }
+
+ ResourceMark rm(THREAD);
+ typeArrayOop ta = typeArrayOop(JNIHandles::resolve_non_null(ids));
+ typeArrayHandle ids_ah(THREAD, ta);
+
+ typeArrayOop tia = typeArrayOop(JNIHandles::resolve_non_null(timeArray));
+ typeArrayHandle timeArray_h(THREAD, tia);
+
+ // validate the thread id array
+ validate_thread_id_array(ids_ah, CHECK);
+
+ // timeArray must be of the same length as the given array of thread IDs
+ int num_threads = ids_ah->length();
+ if (num_threads != timeArray_h->length()) {
+ THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
+ "The length of the given long array does not match the length of "
+ "the given array of thread IDs");
+ }
+
+ MutexLockerEx ml(Threads_lock);
+ for (int i = 0; i < num_threads; i++) {
+ JavaThread* java_thread = Threads::find_java_thread_from_java_tid(ids_ah->long_at(i));
+ if (java_thread != NULL) {
+ timeArray_h->long_at_put(i, os::thread_cpu_time((Thread*)java_thread,
+ user_sys_cpu_time != 0));
+ }
+ }
+JVM_END
+
+
+
+#if INCLUDE_MANAGEMENT
const struct jmmInterface_1_ jmm_interface = {
NULL,
NULL,
--- a/hotspot/src/share/vm/services/memoryService.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/memoryService.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -63,7 +63,9 @@
GCMemoryManager* MemoryService::_minor_gc_manager = NULL;
GCMemoryManager* MemoryService::_major_gc_manager = NULL;
-MemoryPool* MemoryService::_code_heap_pool = NULL;
+MemoryManager* MemoryService::_code_cache_manager = NULL;
+GrowableArray<MemoryPool*>* MemoryService::_code_heap_pools =
+ new (ResourceObj::C_HEAP, mtInternal) GrowableArray<MemoryPool*>(init_code_heap_pools_size, true);
MemoryPool* MemoryService::_metaspace_pool = NULL;
MemoryPool* MemoryService::_compressed_class_pool = NULL;
@@ -388,15 +390,21 @@
}
#endif // INCLUDE_ALL_GCS
-void MemoryService::add_code_heap_memory_pool(CodeHeap* heap) {
- _code_heap_pool = new CodeHeapPool(heap,
- "Code Cache",
- true /* support_usage_threshold */);
- MemoryManager* mgr = MemoryManager::get_code_cache_memory_manager();
- mgr->add_pool(_code_heap_pool);
+void MemoryService::add_code_heap_memory_pool(CodeHeap* heap, const char* name) {
+ // Create new memory pool for this heap
+ MemoryPool* code_heap_pool = new CodeHeapPool(heap, name, true /* support_usage_threshold */);
+
+ // Append to lists
+ _code_heap_pools->append(code_heap_pool);
+ _pools_list->append(code_heap_pool);
- _pools_list->append(_code_heap_pool);
- _managers_list->append(mgr);
+ if (_code_cache_manager == NULL) {
+ // Create CodeCache memory manager
+ _code_cache_manager = MemoryManager::get_code_cache_memory_manager();
+ _managers_list->append(_code_cache_manager);
+ }
+
+ _code_cache_manager->add_pool(code_heap_pool);
}
void MemoryService::add_metaspace_memory_pools() {
--- a/hotspot/src/share/vm/services/memoryService.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/services/memoryService.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -53,7 +53,8 @@
private:
enum {
init_pools_list_size = 10,
- init_managers_list_size = 5
+ init_managers_list_size = 5,
+ init_code_heap_pools_size = 9
};
// index for minor and major generations
@@ -70,8 +71,9 @@
static GCMemoryManager* _major_gc_manager;
static GCMemoryManager* _minor_gc_manager;
- // Code heap memory pool
- static MemoryPool* _code_heap_pool;
+ // memory manager and code heap pools for the CodeCache
+ static MemoryManager* _code_cache_manager;
+ static GrowableArray<MemoryPool*>* _code_heap_pools;
static MemoryPool* _metaspace_pool;
static MemoryPool* _compressed_class_pool;
@@ -123,7 +125,7 @@
public:
static void set_universe_heap(CollectedHeap* heap);
- static void add_code_heap_memory_pool(CodeHeap* heap);
+ static void add_code_heap_memory_pool(CodeHeap* heap, const char* name);
static void add_metaspace_memory_pools();
static MemoryPool* get_memory_pool(instanceHandle pool);
@@ -146,7 +148,10 @@
static void track_memory_usage();
static void track_code_cache_memory_usage() {
- track_memory_pool_usage(_code_heap_pool);
+ // Track memory pool usage of all CodeCache memory pools
+ for (int i = 0; i < _code_heap_pools->length(); ++i) {
+ track_memory_pool_usage(_code_heap_pools->at(i));
+ }
}
static void track_metaspace_memory_usage() {
track_memory_pool_usage(_metaspace_pool);
--- a/hotspot/src/share/vm/trace/trace.xml Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/trace/trace.xml Fri Oct 10 02:24:41 2014 -0700
@@ -394,6 +394,7 @@
<event id="CodeCacheFull" path="vm/code_cache/full" label="Code Cache Full"
has_thread="true" is_requestable="false" is_constant="false" is_instant="true">
+ <value type="CODEBLOBTYPE" field="codeBlobType" label="Code Heap"/>
<value type="ADDRESS" field="startAddress" label="Start Address"/>
<value type="ADDRESS" field="commitedTopAddress" label="Commited Top"/>
<value type="ADDRESS" field="reservedTopAddress" label="Reserved Top"/>
--- a/hotspot/src/share/vm/trace/tracetypes.xml Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/trace/tracetypes.xml Fri Oct 10 02:24:41 2014 -0700
@@ -170,6 +170,11 @@
type="U1" jvm_type="FLAGVALUEORIGIN">
<value type="UTF8" field="origin" label="origin" />
</content_type>
+
+ <content_type id="CodeBlobType" hr_name="Code Blob Type"
+ type="U1" jvm_type="CODEBLOBTYPE">
+ <value type="UTF8" field="type" label="type" />
+ </content_type>
</content_types>
@@ -371,6 +376,10 @@
<!-- FLAGVALUEORIGIN -->
<primary_type symbol="FLAGVALUEORIGIN" datatype="U1"
contenttype="FLAGVALUEORIGIN" type="u1" sizeop="sizeof(u1)" />
+
+ <!-- CODEBLOBTYPE -->
+ <primary_type symbol="CODEBLOBTYPE" datatype="U1"
+ contenttype="CODEBLOBTYPE" type="u1" sizeop="sizeof(u1)" />
</primary_types>
</types>
--- a/hotspot/src/share/vm/utilities/bitMap.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -342,9 +342,9 @@
bm_word_t* other_map = other.map();
idx_t size = size_in_words();
for (idx_t index = 0; index < size; index++) {
- idx_t temp = map(index) | other_map[index];
- changed = changed || (temp != map(index));
- map()[index] = temp;
+ idx_t temp = dest_map[index] | other_map[index];
+ changed = changed || (temp != dest_map[index]);
+ dest_map[index] = temp;
}
return changed;
}
@@ -407,10 +407,10 @@
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
- if (*word != (bm_word_t) AllBits) return false;
+ if (*word != ~(bm_word_t)0) return false;
word++;
}
- return rest == 0 || (*word | ~right_n_bits((int)rest)) == (bm_word_t) AllBits;
+ return rest == 0 || (*word | ~right_n_bits((int)rest)) == ~(bm_word_t)0;
}
@@ -418,10 +418,10 @@
bm_word_t* word = map();
idx_t rest = size();
for (; rest >= (idx_t) BitsPerWord; rest -= BitsPerWord) {
- if (*word != (bm_word_t) NoBits) return false;
+ if (*word != 0) return false;
word++;
}
- return rest == 0 || (*word & right_n_bits((int)rest)) == (bm_word_t) NoBits;
+ return rest == 0 || (*word & right_n_bits((int)rest)) == 0;
}
void BitMap::clear_large() {
@@ -441,7 +441,7 @@
offset < rightOffset && index < endIndex;
offset = (++index) << LogBitsPerWord) {
idx_t rest = map(index) >> (offset & (BitsPerWord - 1));
- for (; offset < rightOffset && rest != (bm_word_t)NoBits; offset++) {
+ for (; offset < rightOffset && rest != 0; offset++) {
if (rest & 1) {
if (!blk->do_bit(offset)) return false;
// resample at each closure application
@@ -468,7 +468,7 @@
(intptr_t) NULL_WORD);
if (res != NULL_WORD) {
guarantee( _pop_count_table == (void*) res, "invariant" );
- FREE_C_HEAP_ARRAY(bm_word_t, table, mtInternal);
+ FREE_C_HEAP_ARRAY(idx_t, table, mtInternal);
}
}
}
--- a/hotspot/src/share/vm/utilities/bitMap.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -80,7 +80,7 @@
// Set a word to a specified value or to all ones; clear a word.
void set_word (idx_t word, bm_word_t val) { _map[word] = val; }
- void set_word (idx_t word) { set_word(word, ~(uintptr_t)0); }
+ void set_word (idx_t word) { set_word(word, ~(bm_word_t)0); }
void clear_word(idx_t word) { _map[word] = 0; }
// Utilities for ranges of bits. Ranges are half-open [beg, end).
--- a/hotspot/src/share/vm/utilities/bitMap.inline.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/bitMap.inline.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -130,7 +130,7 @@
inline void BitMap::set_range_of_words(idx_t beg, idx_t end) {
bm_word_t* map = _map;
- for (idx_t i = beg; i < end; ++i) map[i] = ~(uintptr_t)0;
+ for (idx_t i = beg; i < end; ++i) map[i] = ~(bm_word_t)0;
}
@@ -172,8 +172,8 @@
// check bits including and to the _left_ of offset's position
idx_t pos = bit_in_word(res_offset);
- idx_t res = map(index) >> pos;
- if (res != (uintptr_t)NoBits) {
+ bm_word_t res = map(index) >> pos;
+ if (res != 0) {
// find the position of the 1-bit
for (; !(res & 1); res_offset++) {
res = res >> 1;
@@ -207,7 +207,7 @@
// skip over all word length 0-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)NoBits) {
+ if (res != 0) {
// found a 1, return the offset
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
@@ -235,9 +235,9 @@
// check bits including and to the _left_ of offset's position
idx_t pos = res_offset & (BitsPerWord - 1);
- idx_t res = (map(index) >> pos) | left_n_bits((int)pos);
+ bm_word_t res = (map(index) >> pos) | left_n_bits((int)pos);
- if (res != (uintptr_t)AllBits) {
+ if (res != ~(bm_word_t)0) {
// find the position of the 0-bit
for (; res & 1; res_offset++) {
res = res >> 1;
@@ -248,7 +248,7 @@
// skip over all word length 1-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)AllBits) {
+ if (res != ~(bm_word_t)0) {
// found a 0, return the offset
for (res_offset = index << LogBitsPerWord; res & 1;
res_offset++) {
@@ -277,8 +277,8 @@
idx_t res_offset = l_offset;
// check bits including and to the _left_ of offset's position
- idx_t res = map(index) >> bit_in_word(res_offset);
- if (res != (uintptr_t)NoBits) {
+ bm_word_t res = map(index) >> bit_in_word(res_offset);
+ if (res != 0) {
// find the position of the 1-bit
for (; !(res & 1); res_offset++) {
res = res >> 1;
@@ -290,7 +290,7 @@
// skip over all word length 0-bit runs
for (index++; index < r_index; index++) {
res = map(index);
- if (res != (uintptr_t)NoBits) {
+ if (res != 0) {
// found a 1, return the offset
for (res_offset = bit_index(index); !(res & 1); res_offset++) {
res = res >> 1;
@@ -321,11 +321,11 @@
}
inline void BitMap::set_large_range_of_words(idx_t beg, idx_t end) {
- memset(_map + beg, ~(unsigned char)0, (end - beg) * sizeof(uintptr_t));
+ memset(_map + beg, ~(unsigned char)0, (end - beg) * sizeof(bm_word_t));
}
inline void BitMap::clear_large_range_of_words(idx_t beg, idx_t end) {
- memset(_map + beg, 0, (end - beg) * sizeof(uintptr_t));
+ memset(_map + beg, 0, (end - beg) * sizeof(bm_word_t));
}
inline BitMap::idx_t BitMap::word_index_round_up(idx_t bit) const {
--- a/hotspot/src/share/vm/utilities/debug.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/debug.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -653,6 +653,13 @@
tty->print_cr(" pm(int pc) - print Method* given compiled PC");
tty->print_cr(" findm(intptr_t pc) - finds Method*");
tty->print_cr(" find(intptr_t x) - finds & prints nmethod/stub/bytecode/oop based on pointer into it");
+ tty->print_cr(" pns(void* sp, void* fp, void* pc) - print native (i.e. mixed) stack trace. E.g.");
+ tty->print_cr(" pns($sp, $rbp, $pc) on Linux/amd64 and Solaris/amd64 or");
+ tty->print_cr(" pns($sp, $ebp, $pc) on Linux/x86 or");
+ tty->print_cr(" pns($sp, 0, $pc) on Linux/ppc64 or");
+ tty->print_cr(" pns($sp + 0x7ff, 0, $pc) on Solaris/SPARC");
+ tty->print_cr(" - in gdb do 'set overload-resolution off' before calling pns()");
+ tty->print_cr(" - in dbx do 'frame 1' before calling pns()");
tty->print_cr("misc.");
tty->print_cr(" flush() - flushes the log file");
@@ -665,3 +672,56 @@
}
#endif // !PRODUCT
+
+void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size) {
+
+ // see if it's a valid frame
+ if (fr.pc()) {
+ st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
+
+ int count = 0;
+ while (count++ < StackPrintLimit) {
+ fr.print_on_error(st, buf, buf_size);
+ st->cr();
+ // Compiled code may use EBP register on x86 so it looks like
+ // non-walkable C frame. Use frame.sender() for java frames.
+ if (t && t->is_Java_thread()) {
+ // Catch very first native frame by using stack address.
+ // For JavaThread stack_base and stack_size should be set.
+ if (!t->on_local_stack((address)(fr.real_fp() + 1))) {
+ break;
+ }
+ if (fr.is_java_frame() || fr.is_native_frame() || fr.is_runtime_frame()) {
+ RegisterMap map((JavaThread*)t, false); // No update
+ fr = fr.sender(&map);
+ } else {
+ fr = os::get_sender_for_C_frame(&fr);
+ }
+ } else {
+ // is_first_C_frame() does only simple checks for frame pointer,
+ // it will pass if java compiled code has a pointer in EBP.
+ if (os::is_first_C_frame(&fr)) break;
+ fr = os::get_sender_for_C_frame(&fr);
+ }
+ }
+
+ if (count > StackPrintLimit) {
+ st->print_cr("...<more frames>...");
+ }
+
+ st->cr();
+ }
+}
+
+#ifndef PRODUCT
+
+extern "C" void pns(void* sp, void* fp, void* pc) { // print native stack
+ Command c("pns");
+ static char buf[O_BUFLEN];
+ Thread* t = ThreadLocalStorage::get_thread_slow();
+ // Call generic frame constructor (certain arguments may be ignored)
+ frame fr(sp, fp, pc);
+ print_native_stack(tty, fr, t, buf, sizeof(buf));
+}
+
+#endif // !PRODUCT
--- a/hotspot/src/share/vm/utilities/debug.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/debug.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -263,4 +263,7 @@
void pd_ps(frame f);
void pd_obfuscate_location(char *buf, size_t buflen);
+class outputStream;
+void print_native_stack(outputStream* st, frame fr, Thread* t, char* buf, int buf_size);
+
#endif // SHARE_VM_UTILITIES_DEBUG_HPP
--- a/hotspot/src/share/vm/utilities/taskqueue.hpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/taskqueue.hpp Fri Oct 10 02:24:41 2014 -0700
@@ -331,7 +331,7 @@
// index, &_elems[index], _elems[index]);
E* t = (E*)&_elems[index]; // cast away volatility
oop* p = (oop*)t;
- assert((*t)->is_oop_or_null(), "Not an oop or null");
+ assert((*t)->is_oop_or_null(), err_msg("Expected an oop or NULL at " PTR_FORMAT, p2i(*t)));
f->do_oop(p);
}
// tty->print_cr("END OopTaskQueue::oops_do");
--- a/hotspot/src/share/vm/utilities/vmError.cpp Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/src/share/vm/utilities/vmError.cpp Fri Oct 10 02:24:41 2014 -0700
@@ -577,7 +577,7 @@
STEP(120, "(printing native stack)" )
- if (_verbose) {
+ if (_verbose) {
if (os::platform_print_native_stack(st, _context, buf, sizeof(buf))) {
// We have printed the native stack in platform-specific code
// Windows/x64 needs special handling.
@@ -585,43 +585,7 @@
frame fr = _context ? os::fetch_frame_from_context(_context)
: os::current_frame();
- // see if it's a valid frame
- if (fr.pc()) {
- st->print_cr("Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)");
-
-
- int count = 0;
- while (count++ < StackPrintLimit) {
- fr.print_on_error(st, buf, sizeof(buf));
- st->cr();
- // Compiled code may use EBP register on x86 so it looks like
- // non-walkable C frame. Use frame.sender() for java frames.
- if (_thread && _thread->is_Java_thread()) {
- // Catch very first native frame by using stack address.
- // For JavaThread stack_base and stack_size should be set.
- if (!_thread->on_local_stack((address)(fr.sender_sp() + 1))) {
- break;
- }
- if (fr.is_java_frame()) {
- RegisterMap map((JavaThread*)_thread, false); // No update
- fr = fr.sender(&map);
- } else {
- fr = os::get_sender_for_C_frame(&fr);
- }
- } else {
- // is_first_C_frame() does only simple checks for frame pointer,
- // it will pass if java compiled code has a pointer in EBP.
- if (os::is_first_C_frame(&fr)) break;
- fr = os::get_sender_for_C_frame(&fr);
- }
- }
-
- if (count > StackPrintLimit) {
- st->print_cr("...<more frames>...");
- }
-
- st->cr();
- }
+ print_native_stack(st, fr, _thread, buf, sizeof(buf));
}
}
--- a/hotspot/test/Makefile Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/Makefile Fri Oct 10 02:24:41 2014 -0700
@@ -259,8 +259,8 @@
EXTRA_JTREG_OPTIONS += -concurrency:$(CONCURRENCY)
endif
-# Default JTREG to run (win32 script works for everybody)
-JTREG = $(JT_HOME)/win32/bin/jtreg
+# Default JTREG to run
+JTREG = $(JT_HOME)/bin/jtreg
# Only run automatic tests
JTREG_BASIC_OPTIONS += -a
@@ -321,6 +321,17 @@
################################################################
+# minimaltest (make sure various basic java minimal options work)
+
+hotspot_minimaltest minimaltest: prep $(PRODUCT_HOME)
+ $(PRODUCT_HOME)/bin/java $(JAVA_OPTIONS) -version
+ $(PRODUCT_HOME)/bin/java $(JAVA_OPTIONS) -help
+ $(PRODUCT_HOME)/bin/java $(JAVA_OPTIONS) -X
+
+PHONY_LIST += hotspot_minimaltest minimaltest
+
+################################################################
+
# servertest (make sure various basic java server options work)
hotspot_servertest servertest: prep $(PRODUCT_HOME)
--- a/hotspot/test/TEST.groups Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/TEST.groups Fri Oct 10 02:24:41 2014 -0700
@@ -61,7 +61,6 @@
# can be resolved in some cases by using tools from the compile-jdk.
#
needs_jdk = \
- gc/TestG1ZeroPGCTJcmdThreadPrint.java \
gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java \
gc/metaspace/TestMetaspacePerfCounters.java \
gc/metaspace/TestPerfCountersAndMemoryPools.java \
@@ -134,6 +133,13 @@
gc/metaspace/TestMetaspaceMemoryPool.java \
gc/arguments/TestDynMinHeapFreeRatio.java \
gc/arguments/TestDynMaxHeapFreeRatio.java \
+ gc/g1/TestShrinkAuxiliaryData00.java \
+ gc/g1/TestShrinkAuxiliaryData05.java \
+ gc/g1/TestShrinkAuxiliaryData10.java \
+ gc/g1/TestShrinkAuxiliaryData15.java \
+ gc/g1/TestShrinkAuxiliaryData20.java \
+ gc/g1/TestShrinkAuxiliaryData25.java \
+ gc/g1/TestShrinkAuxiliaryData30.java \
runtime/InternalApi/ThreadCpuTimesDeadlock.java \
serviceability/threads/TestFalseDeadLock.java \
@@ -198,7 +204,6 @@
compact1_minimal = \
serviceability/ \
compiler/ \
- testlibrary/ \
testlibrary_tests/ \
sanity/ \
runtime/ \
@@ -214,14 +219,13 @@
#
needs_g1gc = \
compiler/regalloc/C1ObjectSpillInLogicOp.java \
- gc/8000311/Test8000311.java \
- gc/TestG1ZeroPGCTJcmdThreadPrint.java \
gc/TestSystemGC.java \
gc/arguments/TestAlignmentToUseLargePages.java \
gc/arguments/TestG1HeapRegionSize.java \
gc/arguments/TestG1HeapSizeFlags.java \
gc/arguments/TestMaxHeapSizeTools.java \
gc/arguments/TestMaxNewSize.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/class_unloading/TestG1ClassUnloadingHWM.java \
gc/g1/ \
@@ -249,6 +253,7 @@
gc/arguments/TestAlignmentToUseLargePages.java \
gc/arguments/TestMaxNewSize.java \
gc/arguments/TestMinInitialErgonomics.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/metaspace/TestMetaspacePerfCounters.java \
gc/parallelScavenge/ \
@@ -263,6 +268,7 @@
gc/arguments/TestAlignmentToUseLargePages.java \
gc/arguments/TestCMSHeapSizeFlags.java \
gc/arguments/TestMaxNewSize.java \
+ gc/arguments/TestParallelGCThreads.java \
gc/arguments/TestUseCompressedOopsErgo.java \
gc/class_unloading/TestCMSClassUnloadingEnabledHWM.java \
gc/concurrentMarkSweep/ \
@@ -323,8 +329,244 @@
hotspot_wbapitest = \
sanity/
-hotspot_compiler = \
- sanity/ExecuteInternalVMTests.java
+hotspot_compiler_1 = \
+ compiler/5057225/Test5057225.java \
+ compiler/5091921/Test5091921.java \
+ compiler/5091921/Test6186134.java \
+ compiler/5091921/Test6196102.java \
+ compiler/5091921/Test6357214.java \
+ compiler/5091921/Test6559156.java \
+ compiler/5091921/Test6753639.java \
+ compiler/5091921/Test6935022.java \
+ compiler/5091921/Test6959129.java \
+ compiler/5091921/Test6985295.java \
+ compiler/5091921/Test6992759.java \
+ compiler/5091921/Test7005594.java \
+ compiler/5091921/Test7020614.java \
+ compiler/6378821/Test6378821.java \
+ compiler/6431242/Test.java \
+ compiler/6443505/Test6443505.java \
+ compiler/6478991/NullCheckTest.java \
+ compiler/6539464/Test.java \
+ compiler/6579789/Test6579789.java \
+ compiler/6636138/ \
+ compiler/6646019/Test.java \
+ compiler/6659207/Test.java \
+ compiler/6661247/Test.java \
+ compiler/6663621/IVTest.java \
+ compiler/6689060/Test.java \
+ compiler/6695810/Test.java \
+ compiler/6700047/Test6700047.java \
+ compiler/6711100/Test.java \
+ compiler/6724218/Test.java \
+ compiler/6732154/Test6732154.java \
+ compiler/6758234/Test6758234.java \
+ compiler/6769124/ \
+ compiler/6772683/InterruptedTest.java \
+ compiler/6778657/Test.java \
+ compiler/6795161/Test.java \
+ compiler/6795362/Test6795362.java \
+ compiler/6795465/Test6795465.java \
+ compiler/6796786/Test6796786.java \
+ compiler/6799693/Test.java \
+ compiler/6805724/Test6805724.java \
+ compiler/6814842/Test6814842.java \
+ compiler/6823453/Test.java \
+ compiler/6833129/Test.java \
+ compiler/6837011/Test6837011.java \
+ compiler/6843752/Test.java \
+ compiler/6849574/Test.java \
+ compiler/6855164/Test.java \
+ compiler/6855215/Test6855215.java \
+ compiler/6857159/Test6857159.java \
+ compiler/6860469/Test.java \
+ compiler/6863155/Test6863155.java \
+ compiler/6863420/Test.java \
+ compiler/6865265/StackOverflowBug.java \
+ compiler/6879902/Test6879902.java \
+ compiler/6880034/Test6880034.java \
+ compiler/6891750/Test6891750.java \
+ compiler/6892265/Test.java \
+ compiler/6894807/IsInstanceTest.java \
+ compiler/6901572/Test.java \
+ compiler/6909839/Test6909839.java \
+ compiler/6910484/Test.java \
+ compiler/6910605/Test.java \
+ compiler/6910618/Test.java \
+ compiler/6916644/Test6916644.java \
+ compiler/6921969/TestMultiplyLongHiZero.java \
+ compiler/6930043/Test6930043.java \
+ compiler/6932496/Test6932496.java \
+ compiler/6956668/Test6956668.java \
+ compiler/6968348/Test6968348.java \
+ compiler/6973329/Test.java
+
+hotspot_compiler_2 = \
+ compiler/6982370/Test6982370.java \
+ compiler/7009231/Test7009231.java \
+ compiler/7009359/Test7009359.java \
+ compiler/7017746/Test.java \
+ compiler/7024475/Test7024475.java \
+ compiler/7041100/Test7041100.java \
+ compiler/7044738/Test7044738.java \
+ compiler/7046096/Test7046096.java \
+ compiler/7048332/Test7048332.java \
+ compiler/7068051/Test7068051.java \
+ compiler/7082949/Test7082949.java \
+ compiler/7088020/Test7088020.java \
+ compiler/7090976/Test7090976.java \
+ compiler/7103261/Test7103261.java \
+ compiler/7110586/Test7110586.java \
+ compiler/7119644/ \
+ compiler/7141637/SpreadNullArg.java \
+ compiler/7169782/Test7169782.java \
+ compiler/7174363/Test7174363.java \
+ compiler/7179138/ \
+ compiler/7190310/ \
+ compiler/7192963/ \
+ compiler/7200264/TestIntVect.java \
+ compiler/8000805/Test8000805.java \
+ compiler/8002069/Test8002069.java \
+ compiler/8004741/Test8004741.java \
+ compiler/8005033/Test8005033.java \
+ compiler/8005419/Test8005419.java \
+ compiler/8005956/PolynomialRoot.java \
+ compiler/8007294/Test8007294.java
+
+hotspot_compiler_3 = \
+ compiler/8007722/Test8007722.java \
+ compiler/8009761/Test8009761.java \
+ compiler/8010927/Test8010927.java \
+ compiler/8011706/Test8011706.java \
+ compiler/8011771/Test8011771.java \
+ compiler/8011901/Test8011901.java \
+ compiler/arraycopy/TestMissingControl.java \
+ compiler/ciReplay/TestVM_no_comp_level.sh \
+ compiler/classUnloading/anonymousClass/TestAnonymousClassUnloading.java \
+ compiler/codecache/CheckUpperLimit.java \
+ compiler/codegen/ \
+ compiler/cpuflags/RestoreMXCSR.java \
+ compiler/EscapeAnalysis/ \
+ compiler/exceptions/TestRecursiveReplacedException.java \
+ compiler/floatingpoint/ModNaN.java \
+ compiler/gcbarriers/G1CrashTest.java \
+ compiler/inlining/ \
+ compiler/IntegerArithmetic/TestIntegerComparison.java \
+ compiler/intrinsics/bmi/TestAndnI.java \
+ compiler/intrinsics/bmi/TestAndnI.java \
+ compiler/intrinsics/bmi/TestAndnL.java \
+ compiler/intrinsics/bmi/TestBlsiI.java \
+ compiler/intrinsics/bmi/TestBlsiL.java \
+ compiler/intrinsics/bmi/TestBlsmskI.java \
+ compiler/intrinsics/bmi/TestBlsmskL.java \
+ compiler/intrinsics/bmi/TestBlsrI.java \
+ compiler/intrinsics/bmi/TestBlsrL.java \
+ compiler/intrinsics/bmi/TestLzcntI.java \
+ compiler/intrinsics/bmi/TestLzcntL.java \
+ compiler/intrinsics/bmi/TestTzcntI.java \
+ compiler/intrinsics/bmi/TestTzcntL.java \
+ compiler/intrinsics/clone/TestObjectClone.java \
+ compiler/intrinsics/hashcode/TestHashCode.java \
+ compiler/intrinsics/mathexact/CompareTest.java \
+ compiler/intrinsics/mathexact/GVNTest.java \
+ compiler/intrinsics/mathexact/NegExactILoadTest.java \
+ compiler/intrinsics/mathexact/NegExactILoopDependentTest.java \
+ compiler/intrinsics/mathexact/NegExactINonConstantTest.java \
+ compiler/intrinsics/mathexact/SubExactICondTest.java \
+ compiler/intrinsics/mathexact/SubExactILoadTest.java \
+ compiler/intrinsics/mathexact/SubExactILoopDependentTest.java \
+ compiler/intrinsics/stringequals/TestStringEqualsBadLength.java \
+ compiler/intrinsics/unsafe/UnsafeGetAddressTest.java \
+ compiler/jsr292/ConcurrentClassLoadingTest.java \
+ compiler/jsr292/CreatesInterfaceDotEqualsCallInfo.java \
+ compiler/jsr292/CreatesInterfaceDotEqualsCallInfo.java \
+ compiler/loopopts/TestLogSum.java \
+ compiler/macronodes/TestEliminateAllocationPhi.java \
+ compiler/membars/TestMemBarAcquire.java \
+ compiler/osr/TestOSRWithNonEmptyStack.java \
+ compiler/profiling/TestMethodHandleInvokesIntrinsic.java \
+ compiler/profiling/TestSpecTrapClassUnloading.java \
+ compiler/profiling/TestUnexpectedProfilingMismatch.java \
+ compiler/regalloc/C1ObjectSpillInLogicOp.java \
+ compiler/startup/NumCompilerThreadsCheck.java \
+ compiler/startup/SmallCodeCacheStartup.java \
+ compiler/types/TestSpeculationFailedHigherEqual.java \
+ compiler/types/TypeSpeculation.java \
+ compiler/uncommontrap/StackOverflowGuardPagesOff.java \
+ compiler/uncommontrap/TestStackBangMonitorOwned.java \
+ compiler/uncommontrap/TestStackBangRbp.java \
+ compiler/unsafe/GetUnsafeObjectG1PreBarrier.java
+
+
+hotspot_compiler_closed = \
+ closed/compiler/4292742/Test.java \
+ closed/compiler/4474154/Test4474154.java \
+ closed/compiler/4482613/Test4482613.java \
+ closed/compiler/4490177/tctest.java \
+ closed/compiler/4495990/Application.java \
+ closed/compiler/4522874/Test4522874.sh \
+ closed/compiler/4629512/Test4629512.java \
+ closed/compiler/4647299/Looper.java \
+ closed/compiler/4655758/TestClass.java \
+ closed/compiler/4671453/LongCompTest.java \
+ closed/compiler/4671460/CharArrTest.java \
+ closed/compiler/4709105/StringTest2.java \
+ closed/compiler/4732721/Bug.java \
+ closed/compiler/4750681/ReadTest.java \
+ closed/compiler/4787943/LongCrash.java \
+ closed/compiler/4819903/Base64Test.java \
+ closed/compiler/4903383/Test.java \
+ closed/compiler/4906393/Test.java \
+ closed/compiler/4907999/Uidtest.java \
+ closed/compiler/4917709/Tester.java \
+ closed/compiler/4957832/Test.java \
+ closed/compiler/4965430/LoopTest.java \
+ closed/compiler/4979449/T4979449.java \
+ closed/compiler/5031274/Test.java \
+ closed/compiler/5043395/T5043395.java \
+ closed/compiler/5049410/Test.java \
+ closed/compiler/5098422/Test.java \
+ closed/compiler/6173783/Test.java \
+ closed/compiler/6272923/Test6272923.sh \
+ closed/compiler/6290963/Test.java \
+ closed/compiler/6305546/Test.java \
+ closed/compiler/6309806/Test.java \
+ closed/compiler/6311859/Test.java \
+ closed/compiler/6321689/Test.java \
+ closed/compiler/6326935/Test.java \
+ closed/compiler/6367889/Test.java \
+ closed/compiler/6371167/Test.java \
+ closed/compiler/6389127/Test.java \
+ closed/compiler/6397650/Test.java \
+ closed/compiler/6414932/Test.java \
+ closed/compiler/6421619/Test_6421619.java \
+ closed/compiler/6427750/UnsafeVolatile.java \
+ closed/compiler/6431243/Test.java \
+ closed/compiler/6433572/TestSyncJSR.java \
+ closed/compiler/6433840/clinit.java \
+ closed/compiler/6457854/Test.java \
+ closed/compiler/6476804/Test.java \
+ closed/compiler/6512111/CorruptFinalLong.java \
+ closed/compiler/6551887/Test.java \
+ closed/compiler/6571539/Test.java \
+ closed/compiler/6587132/Test.java \
+ closed/compiler/6588045/Test.java \
+ closed/compiler/6588598/etype.java \
+ closed/compiler/6661918/Test6661918.java \
+ closed/compiler/6707044/Test.java \
+ closed/compiler/6730716/Test.java \
+ closed/compiler/6772368/Test6772368.sh \
+ closed/compiler/6897150/Test6897150.java \
+ closed/compiler/6931567/Test6931567.java \
+ closed/compiler/7196857/Test7196857.java \
+ closed/compiler/8009699/Test8009699.java \
+ closed/compiler/8009699/Test8009699B.java \
+ closed/compiler/8014811/Test8014811.java \
+ closed/compiler/8029507/InvokePrivate.java \
+ closed/compiler/callingConvention/Arg9Double.java \
+ closed/compiler/deoptimization/DeoptArithmetic.java \
+ closed/compiler/deoptimization/TestDoubleLocals.java \
+ closed/compiler/deoptimization/TestDoubleMerge.java
hotspot_gc = \
sanity/ExecuteInternalVMTests.java
@@ -343,16 +585,20 @@
-runtime/SharedArchiveFile/CdsSameObjectAlignment.java \
-runtime/SharedArchiveFile/DefaultUseWithClient.java \
-runtime/Thread/CancellableThreadTest.java \
- -runtime/runtime/7158988/FieldMonitor.java
+ -runtime/7158988/FieldMonitor.java
hotspot_runtime_closed = \
sanity/ExecuteInternalVMTests.java
hotspot_serviceability = \
- sanity/ExecuteInternalVMTests.java
+ sanity/ExecuteInternalVMTests.java \
+ serviceability/dcmd/compiler
hotspot_all = \
- :hotspot_compiler \
+ :hotspot_compiler_1 \
+ :hotspot_compiler_2 \
+ :hotspot_compiler_3 \
+ :hotspot_compiler_closed \
:hotspot_gc \
:hotspot_runtime \
:hotspot_serviceability
--- a/hotspot/test/compiler/IntegerArithmetic/TestIntegerComparison.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/IntegerArithmetic/TestIntegerComparison.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,7 +25,7 @@
* @test TestIntegerComparison
* @bug 8043284 8042786
* @summary "Tests optimizations of signed and unsigned integer comparison."
- * @run main/othervm -server -Xcomp -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:CompileOnly=TestIntegerComparison::testSigned,TestIntegerComparison::testUnsigned TestIntegerComparison
+ * @run main/othervm -Xcomp -XX:CompileOnly=TestIntegerComparison::testSigned,TestIntegerComparison::testUnsigned TestIntegerComparison
*/
public class TestIntegerComparison {
/**
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/codecache/CheckSegmentedCodeCache.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,132 @@
+/*
+ * 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.
+ */
+
+import com.oracle.java.testlibrary.*;
+
+/*
+ * @test CheckSegmentedCodeCache
+ * @bug 8015774
+ * @summary "Checks VM options related to the segmented code cache"
+ * @library /testlibrary
+ * @run main/othervm CheckSegmentedCodeCache
+ */
+public class CheckSegmentedCodeCache {
+ // Code heap names
+ private static final String NON_METHOD = "CodeHeap 'non-nmethods'";
+ private static final String PROFILED = "CodeHeap 'profiled nmethods'";
+ private static final String NON_PROFILED = "CodeHeap 'non-profiled nmethods'";
+
+ private static void verifySegmentedCodeCache(ProcessBuilder pb, boolean enabled) throws Exception {
+ OutputAnalyzer out = new OutputAnalyzer(pb.start());
+ if (enabled) {
+ try {
+ // Non-nmethod code heap should be always available with the segmented code cache
+ out.shouldContain(NON_METHOD);
+ } catch (RuntimeException e) {
+ // TieredCompilation is disabled in a client VM
+ out.shouldContain("TieredCompilation is disabled in this release.");
+ }
+ } else {
+ out.shouldNotContain(NON_METHOD);
+ }
+ out.shouldHaveExitValue(0);
+ }
+
+ private static void verifyCodeHeapNotExists(ProcessBuilder pb, String... heapNames) throws Exception {
+ OutputAnalyzer out = new OutputAnalyzer(pb.start());
+ for (String name : heapNames) {
+ out.shouldNotContain(name);
+ }
+ }
+
+ private static void failsWith(ProcessBuilder pb, String message) throws Exception {
+ OutputAnalyzer out = new OutputAnalyzer(pb.start());
+ out.shouldContain(message);
+ out.shouldHaveExitValue(1);
+ }
+
+ /**
+ * Check the result of segmented code cache related VM options.
+ */
+ public static void main(String[] args) throws Exception {
+ ProcessBuilder pb;
+
+ // Disabled with ReservedCodeCacheSize < 240MB
+ pb = ProcessTools.createJavaProcessBuilder("-XX:ReservedCodeCacheSize=239m",
+ "-XX:+PrintCodeCache", "-version");
+ verifySegmentedCodeCache(pb, false);
+
+ // Disabled without TieredCompilation
+ pb = ProcessTools.createJavaProcessBuilder("-XX:-TieredCompilation",
+ "-XX:+PrintCodeCache", "-version");
+ verifySegmentedCodeCache(pb, false);
+
+ // Enabled with TieredCompilation and ReservedCodeCacheSize >= 240MB
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+TieredCompilation",
+ "-XX:ReservedCodeCacheSize=240m",
+ "-XX:+PrintCodeCache", "-version");
+ verifySegmentedCodeCache(pb, true);
+
+ // Always enabled if SegmentedCodeCache is set
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-XX:-TieredCompilation",
+ "-XX:ReservedCodeCacheSize=239m",
+ "-XX:+PrintCodeCache", "-version");
+ verifySegmentedCodeCache(pb, true);
+
+ // The profiled and non-profiled code heaps should not be available in
+ // interpreter-only mode
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-Xint",
+ "-XX:+PrintCodeCache", "-version");
+ verifyCodeHeapNotExists(pb, PROFILED, NON_PROFILED);
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-XX:TieredStopAtLevel=0",
+ "-XX:+PrintCodeCache", "-version");
+ verifyCodeHeapNotExists(pb, PROFILED, NON_PROFILED);
+
+ // If we stop compilation at CompLevel_simple
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-XX:TieredStopAtLevel=1",
+ "-XX:+PrintCodeCache", "-version");
+ verifyCodeHeapNotExists(pb, PROFILED);
+
+ // Fails with too small non-nmethod code heap size
+ pb = ProcessTools.createJavaProcessBuilder("-XX:NonNMethodCodeHeapSize=100K");
+ failsWith(pb, "Invalid NonNMethodCodeHeapSize");
+
+ // Fails if code heap sizes do not add up
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-XX:ReservedCodeCacheSize=10M",
+ "-XX:NonNMethodCodeHeapSize=5M",
+ "-XX:ProfiledCodeHeapSize=5M",
+ "-XX:NonProfiledCodeHeapSize=5M");
+ failsWith(pb, "Invalid code heap sizes");
+
+ // Fails if not enough space for VM internal code
+ pb = ProcessTools.createJavaProcessBuilder("-XX:+SegmentedCodeCache",
+ "-XX:ReservedCodeCacheSize=1700K",
+ "-XX:InitialCodeCacheSize=100K");
+ failsWith(pb, "Not enough space in non-nmethod code heap to run VM");
+ }
+}
--- a/hotspot/test/compiler/codegen/LoadWithMask.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/codegen/LoadWithMask.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,7 +25,7 @@
* @test
* @bug 8032207
* @summary Invalid node sizing for loadUS2L_immI16 and loadI2L_immI
- * @run main/othervm -server -Xbatch -XX:-TieredCompilation -XX:CompileCommand=compileonly,LoadWithMask.foo LoadWithMask
+ * @run main/othervm -Xbatch -XX:CompileCommand=compileonly,LoadWithMask.foo LoadWithMask
*
*/
public class LoadWithMask {
--- a/hotspot/test/compiler/codegen/LoadWithMask2.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/codegen/LoadWithMask2.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,7 +25,7 @@
* @test
* @bug 8031743
* @summary loadI2L_immI broken for negative memory values
- * @run main/othervm -server -Xbatch -XX:-TieredCompilation -XX:CompileCommand=compileonly,*.foo* LoadWithMask2
+ * @run main/othervm -Xbatch -XX:CompileCommand=compileonly,*.foo* LoadWithMask2
*
*/
public class LoadWithMask2 {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/intrinsics/multiplytolen/TestMultiplyToLenReturnProfile.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,52 @@
+/*
+ * 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.
+ *
+ */
+
+/**
+ * @test
+ * @bug 8057758
+ * @summary MultiplyToLen sets its return type to have a bottom offset which confuses code generation
+ * @run main/othervm -XX:-TieredCompilation -XX:-BackgroundCompilation -XX:-UseOnStackReplacement -XX:TypeProfileLevel=222 TestMultiplyToLenReturnProfile
+ *
+ */
+
+
+import java.math.*;
+
+public class TestMultiplyToLenReturnProfile {
+
+ static BigInteger m(BigInteger i1, BigInteger i2) {
+ BigInteger res = BigInteger.valueOf(0);
+ for (int i = 0; i < 100; i++) {
+ res.add(i1.multiply(i2));
+ }
+ return res;
+ }
+
+ static public void main(String[] args) {
+ BigInteger v = BigInteger.valueOf(Integer.MAX_VALUE).pow(2);
+ for (int i = 0; i < 20000; i++) {
+ m(v, v.add(BigInteger.valueOf(1)));
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/jsr292/NullConstantReceiver.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8059556
+ * @run main/othervm -Xbatch NullConstantReceiver
+ */
+
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+
+public class NullConstantReceiver {
+ static final MethodHandle target;
+ static {
+ try {
+ target = MethodHandles.lookup().findVirtual(NullConstantReceiver.class, "test", MethodType.methodType(void.class));
+ } catch (ReflectiveOperationException e) {
+ throw new Error(e);
+ }
+ }
+
+ public void test() {}
+
+ static void run() throws Throwable {
+ target.invokeExact((NullConstantReceiver) null);
+ }
+
+ public static void main(String[] args) throws Throwable {
+ for (int i = 0; i<15000; i++) {
+ try {
+ run();
+ } catch (NullPointerException e) {
+ // expected
+ continue;
+ }
+ throw new AssertionError("NPE wasn't thrown");
+ }
+ System.out.println("TEST PASSED");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/jsr292/VMAnonymousClasses.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,125 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test
+ * @bug 8058828
+ * @run main/bootclasspath -Xbatch VMAnonymousClasses
+ */
+
+import jdk.internal.org.objectweb.asm.ClassWriter;
+import jdk.internal.org.objectweb.asm.MethodVisitor;
+import jdk.internal.org.objectweb.asm.Opcodes;
+import sun.misc.Unsafe;
+
+import java.lang.invoke.ConstantCallSite;
+import java.lang.invoke.MethodHandle;
+import java.lang.invoke.MethodHandles;
+import java.lang.invoke.MethodType;
+import java.lang.invoke.MutableCallSite;
+import java.lang.invoke.VolatileCallSite;
+
+public class VMAnonymousClasses {
+ static final String TEST_METHOD_NAME = "constant";
+
+ static final Unsafe UNSAFE = Unsafe.getUnsafe();
+
+ static int getConstantPoolSize(byte[] classFile) {
+ // The first few bytes:
+ // u4 magic;
+ // u2 minor_version;
+ // u2 major_version;
+ // u2 constant_pool_count;
+ return ((classFile[8] & 0xFF) << 8) | (classFile[9] & 0xFF);
+ }
+
+ static void test(Object value) throws ReflectiveOperationException {
+ System.out.printf("Test: %s", value != null ? value.getClass() : "null");
+
+ ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
+ cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, "Test", null, "java/lang/Object", null);
+
+ MethodVisitor mv = cw.visitMethod(Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC, TEST_METHOD_NAME, "()Ljava/lang/Object;", null, null);
+
+ String placeholder = "CONSTANT";
+ int index = cw.newConst(placeholder);
+ mv.visitLdcInsn(placeholder);
+ mv.visitInsn(Opcodes.ARETURN);
+
+ mv.visitMaxs(0, 0);
+ mv.visitEnd();
+
+ byte[] classFile = cw.toByteArray();
+
+ Object[] cpPatches = new Object[getConstantPoolSize(classFile)];
+ cpPatches[index] = value;
+
+ Class<?> test = UNSAFE.defineAnonymousClass(VMAnonymousClasses.class, classFile, cpPatches);
+
+ Object expectedResult = (value != null) ? value : placeholder;
+ for (int i = 0; i<15000; i++) {
+ Object result = test.getMethod(TEST_METHOD_NAME).invoke(null);
+ if (result != expectedResult) {
+ throw new AssertionError(String.format("Wrong value returned: %s != %s", value, result));
+ }
+ }
+ System.out.println(" PASSED");
+ }
+
+ public static void main(String[] args) throws ReflectiveOperationException {
+ // Objects
+ test(new Object());
+ test("TEST");
+ test(new VMAnonymousClasses());
+ test(null);
+
+ // Class
+ test(String.class);
+
+ // Arrays
+ test(new boolean[0]);
+ test(new byte[0]);
+ test(new char[0]);
+ test(new short[0]);
+ test(new int[0]);
+ test(new long[0]);
+ test(new float[0]);
+ test(new double[0]);
+ test(new Object[0]);
+
+ // Multi-dimensional arrays
+ test(new byte[0][0]);
+ test(new Object[0][0]);
+
+ // MethodHandle-related
+ MethodType mt = MethodType.methodType(void.class, String[].class);
+ MethodHandle mh = MethodHandles.lookup().findStatic(VMAnonymousClasses.class, "main", mt);
+ test(mt);
+ test(mh);
+ test(new ConstantCallSite(mh));
+ test(new MutableCallSite(MethodType.methodType(void.class)));
+ test(new VolatileCallSite(MethodType.methodType(void.class)));
+
+ System.out.println("TEST PASSED");
+ }
+}
--- a/hotspot/test/compiler/stable/TestStableBoolean.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableBoolean.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableBoolean$DefaultStaticValue
* java/lang/invoke/TestStableBoolean$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableBoolean
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableBoolean
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableBoolean
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableBoolean
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableBoolean
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableBoolean
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableByte.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableByte.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableByte$DefaultStaticValue
* java/lang/invoke/TestStableByte$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableByte
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableByte
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableByte
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableByte
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableByte
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableByte
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableChar.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableChar.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableChar$DefaultStaticValue
* java/lang/invoke/TestStableChar$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableChar
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableChar
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableChar
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableChar
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableChar
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableChar
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableDouble.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableDouble.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableDouble$DefaultStaticValue
* java/lang/invoke/TestStableDouble$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableDouble
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableDouble
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableDouble
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableDouble
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableDouble
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableDouble
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableFloat.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableFloat.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableFloat$DefaultStaticValue
* java/lang/invoke/TestStableFloat$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableFloat
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableFloat
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableFloat
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableFloat
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableFloat
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableFloat
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableInt.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableInt.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableInt$DefaultStaticValue
* java/lang/invoke/TestStableInt$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableInt
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableInt
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableInt
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableInt
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableInt
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableInt
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableLong.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableLong.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableLong$DefaultStaticValue
* java/lang/invoke/TestStableLong$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableLong
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableLong
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableLong
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableLong
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableLong
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableLong
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableObject.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableObject.java Fri Oct 10 02:24:41 2014 -0700
@@ -54,44 +54,32 @@
* java/lang/invoke/TestStableObject$DefaultStaticValue
* java/lang/invoke/TestStableObject$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableObject
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableObject
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableObject
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableObject
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableObject
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableObject
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/stable/TestStableShort.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/stable/TestStableShort.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,44 +53,32 @@
* java/lang/invoke/TestStableShort$DefaultStaticValue
* java/lang/invoke/TestStableShort$ObjectArrayLowerDim2
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableShort
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:-TieredCompilation
+ * -XX:-TieredCompilation
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableShort
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:+FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableShort
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
+ * @run main/othervm -Xbootclasspath/a:.
* -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -server -XX:+TieredCompilation -XX:TieredStopAtLevel=1
+ * -XX:+TieredCompilation -XX:TieredStopAtLevel=1
* -XX:-FoldStableValues
* -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
* java.lang.invoke.TestStableShort
*
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:+FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableShort
- * @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions
- * -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xcomp
- * -client -XX:-TieredCompilation
- * -XX:-FoldStableValues
- * -XX:CompileOnly=::get,::get1,::get2,::get3,::get4
- * java.lang.invoke.TestStableShort
*/
package java.lang.invoke;
--- a/hotspot/test/compiler/uncommontrap/UncommonTrapStackBang.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/compiler/uncommontrap/UncommonTrapStackBang.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 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
@@ -27,9 +27,7 @@
* @bug 8026775
* @summary Uncommon trap blob did not bang all the stack shadow pages
*
- * @run main/othervm -server -XX:+IgnoreUnrecognizedVMOptions -XX:+TieredCompilation UncommonTrapStackBang
- * @run main/othervm -server -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation UncommonTrapStackBang
- *
+ * @run main/othervm UncommonTrapStackBang
*
* Note: This test does not reproduce the problem with absolute
* certainty. Empirically the bug reproduces on Windows some 80+% of
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/compiler/unsafe/UnsafeRaw.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,140 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8058744
+ * @summary Invalid pattern-matching of address computations in raw unsafe
+ * @library /testlibrary
+ * @run main/othervm -Xbatch UnsafeRaw
+ */
+
+import com.oracle.java.testlibrary.Utils;
+import java.util.Random;
+
+public class UnsafeRaw {
+ public static class Tests {
+ public static int int_index(sun.misc.Unsafe unsafe, long base, int index) throws Exception {
+ return unsafe.getInt(base + (index << 2));
+ }
+ public static int long_index(sun.misc.Unsafe unsafe, long base, long index) throws Exception {
+ return unsafe.getInt(base + (index << 2));
+ }
+ public static int int_index_back_ashift(sun.misc.Unsafe unsafe, long base, int index) throws Exception {
+ return unsafe.getInt(base + (index >> 2));
+ }
+ public static int int_index_back_lshift(sun.misc.Unsafe unsafe, long base, int index) throws Exception {
+ return unsafe.getInt(base + (index >>> 2));
+ }
+ public static int long_index_back_ashift(sun.misc.Unsafe unsafe, long base, long index) throws Exception {
+ return unsafe.getInt(base + (index >> 2));
+ }
+ public static int long_index_back_lshift(sun.misc.Unsafe unsafe, long base, long index) throws Exception {
+ return unsafe.getInt(base + (index >>> 2));
+ }
+ public static int int_const_12345678_index(sun.misc.Unsafe unsafe, long base) throws Exception {
+ int idx4 = 0x12345678;
+ return unsafe.getInt(base + idx4);
+ }
+ public static int long_const_1234567890abcdef_index(sun.misc.Unsafe unsafe, long base) throws Exception {
+ long idx5 = 0x1234567890abcdefL;
+ return unsafe.getInt(base + idx5);
+ }
+ public static int int_index_mul(sun.misc.Unsafe unsafe, long base, int index) throws Exception {
+ return unsafe.getInt(base + (index * 4));
+ }
+ public static int long_index_mul(sun.misc.Unsafe unsafe, long base, long index) throws Exception {
+ return unsafe.getInt(base + (index * 4));
+ }
+ public static int int_index_mul_scale_16(sun.misc.Unsafe unsafe, long base, int index) throws Exception {
+ return unsafe.getInt(base + (index * 16));
+ }
+ public static int long_index_mul_scale_16(sun.misc.Unsafe unsafe, long base, long index) throws Exception {
+ return unsafe.getInt(base + (index * 16));
+ }
+ }
+
+ public static void main(String[] args) throws Exception {
+ sun.misc.Unsafe unsafe = Utils.getUnsafe();
+ final int array_size = 128;
+ final int element_size = 4;
+ final int magic = 0x12345678;
+
+ Random rnd = new Random();
+
+ long array = unsafe.allocateMemory(array_size * element_size); // 128 ints
+ long addr = array + array_size * element_size / 2; // something in the middle to work with
+ unsafe.putInt(addr, magic);
+ for (int j = 0; j < 100000; j++) {
+ if (Tests.int_index(unsafe, addr, 0) != magic) throw new Exception();
+ if (Tests.long_index(unsafe, addr, 0) != magic) throw new Exception();
+ if (Tests.int_index_mul(unsafe, addr, 0) != magic) throw new Exception();
+ if (Tests.long_index_mul(unsafe, addr, 0) != magic) throw new Exception();
+ {
+ long idx1 = rnd.nextLong();
+ long addr1 = addr - (idx1 << 2);
+ if (Tests.long_index(unsafe, addr1, idx1) != magic) throw new Exception();
+ }
+ {
+ long idx2 = rnd.nextLong();
+ long addr2 = addr - (idx2 >> 2);
+ if (Tests.long_index_back_ashift(unsafe, addr2, idx2) != magic) throw new Exception();
+ }
+ {
+ long idx3 = rnd.nextLong();
+ long addr3 = addr - (idx3 >>> 2);
+ if (Tests.long_index_back_lshift(unsafe, addr3, idx3) != magic) throw new Exception();
+ }
+ {
+ long idx4 = 0x12345678;
+ long addr4 = addr - idx4;
+ if (Tests.int_const_12345678_index(unsafe, addr4) != magic) throw new Exception();
+ }
+ {
+ long idx5 = 0x1234567890abcdefL;
+ long addr5 = addr - idx5;
+ if (Tests.long_const_1234567890abcdef_index(unsafe, addr5) != magic) throw new Exception();
+ }
+ {
+ int idx6 = rnd.nextInt();
+ long addr6 = addr - (idx6 >> 2);
+ if (Tests.int_index_back_ashift(unsafe, addr6, idx6) != magic) throw new Exception();
+ }
+ {
+ int idx7 = rnd.nextInt();
+ long addr7 = addr - (idx7 >>> 2);
+ if (Tests.int_index_back_lshift(unsafe, addr7, idx7) != magic) throw new Exception();
+ }
+ {
+ int idx8 = rnd.nextInt();
+ long addr8 = addr - (idx8 * 16);
+ if (Tests.int_index_mul_scale_16(unsafe, addr8, idx8) != magic) throw new Exception();
+ }
+ {
+ long idx9 = rnd.nextLong();
+ long addr9 = addr - (idx9 * 16);
+ if (Tests.long_index_mul_scale_16(unsafe, addr9, idx9) != magic) throw new Exception();
+ }
+ }
+ }
+}
--- a/hotspot/test/gc/8000311/Test8000311.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,42 +0,0 @@
-/*
- * Copyright (c) 2013, 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 Test8000311
- * @key gc
- * @bug 8000311
- * @summary G1: ParallelGCThreads==0 broken
- * @run main/othervm -XX:+UseG1GC -XX:ParallelGCThreads=0 -XX:+ResizePLAB -XX:+ExplicitGCInvokesConcurrent Test8000311
- * @author filipp.zhinkin@oracle.com
- */
-
-import java.util.*;
-
-public class Test8000311 {
- public static void main(String args[]) {
- for(int i = 0; i<100; i++) {
- byte[] garbage = new byte[1000];
- System.gc();
- }
- }
-}
--- a/hotspot/test/gc/TestG1ZeroPGCTJcmdThreadPrint.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,54 +0,0 @@
-/*
- * Copyright (c) 2013, 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 TestG1ZeroPGCTJcmdThreadPrint
- * @key gc
- * @bug 8005875
- * @summary Use jcmd to generate a thread dump of a Java program being run with PGCT=0 to verify 8005875
- * @library /testlibrary
- * @run main/othervm -XX:+UseG1GC -XX:ParallelGCThreads=0 -XX:+IgnoreUnrecognizedVMOptions TestG1ZeroPGCTJcmdThreadPrint
- */
-
-import com.oracle.java.testlibrary.*;
-
-public class TestG1ZeroPGCTJcmdThreadPrint {
- public static void main(String args[]) throws Exception {
-
- // Grab the pid from the current java process
- String pid = Integer.toString(ProcessTools.getProcessId());
-
- // Create a ProcessBuilder
- ProcessBuilder pb = new ProcessBuilder();
-
- // Run jcmd <pid> Thread.print
- pb.command(JDKToolFinder.getJDKTool("jcmd"), pid, "Thread.print");
-
- OutputAnalyzer output = new OutputAnalyzer(pb.start());
-
- // There shouldn't be a work gang for concurrent marking.
- output.shouldNotContain("G1 Parallel Marking Threads");
-
- // Make sure we didn't crash
- output.shouldHaveExitValue(0);
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/arguments/TestG1ConcRefinementThreads.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,97 @@
+/*
+* 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.
+*/
+
+/*
+ * @test TestG1ConcRefinementThreads
+ * @key gc
+ * @bug 8047976
+ * @summary Tests argument processing for G1ConcRefinementThreads
+ * @library /testlibrary
+ */
+
+import com.oracle.java.testlibrary.*;
+import java.util.*;
+import java.util.regex.*;
+
+public class TestG1ConcRefinementThreads {
+
+ static final int AUTO_SELECT_THREADS_COUNT = 0;
+ static final int PASSED_THREADS_COUNT = 11;
+
+ public static void main(String args[]) throws Exception {
+ // default case
+ runG1ConcRefinementThreadsTest(
+ new String[]{}, // automatically selected
+ AUTO_SELECT_THREADS_COUNT /* use default setting */);
+
+ // zero setting case
+ runG1ConcRefinementThreadsTest(
+ new String[]{"-XX:G1ConcRefinementThreads=0"}, // automatically selected
+ AUTO_SELECT_THREADS_COUNT /* set to zero */);
+
+ // non-zero sestting case
+ runG1ConcRefinementThreadsTest(
+ new String[]{"-XX:G1ConcRefinementThreads="+Integer.toString(PASSED_THREADS_COUNT)},
+ PASSED_THREADS_COUNT);
+ }
+
+ private static void runG1ConcRefinementThreadsTest(String[] passedOpts,
+ int expectedValue) throws Exception {
+ List<String> vmOpts = new ArrayList<>();
+ if (passedOpts.length > 0) {
+ Collections.addAll(vmOpts, passedOpts);
+ }
+ Collections.addAll(vmOpts, "-XX:+UseG1GC", "-XX:+PrintFlagsFinal", "-version");
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(vmOpts.toArray(new String[vmOpts.size()]));
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+
+ output.shouldHaveExitValue(0);
+ String stdout = output.getStdout();
+ checkG1ConcRefinementThreadsConsistency(stdout, expectedValue);
+ }
+
+ private static void checkG1ConcRefinementThreadsConsistency(String output, int expectedValue) {
+ int actualValue = getIntValue("G1ConcRefinementThreads", output);
+
+ if (expectedValue == 0) {
+ // If expectedValue is automatically selected, set it same as ParallelGCThreads.
+ expectedValue = getIntValue("ParallelGCThreads", output);
+ }
+
+ if (expectedValue != actualValue) {
+ throw new RuntimeException(
+ "Actual G1ConcRefinementThreads(" + Integer.toString(actualValue)
+ + ") is not equal to expected value(" + Integer.toString(expectedValue) + ")");
+ }
+ }
+
+ public static int getIntValue(String flag, String where) {
+ Matcher m = Pattern.compile(flag + "\\s+:?=\\s+\\d+").matcher(where);
+ if (!m.find()) {
+ throw new RuntimeException("Could not find value for flag " + flag + " in output string");
+ }
+ String match = m.group();
+ return Integer.parseInt(match.substring(match.lastIndexOf(" ") + 1, match.length()));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/arguments/TestParallelGCThreads.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,64 @@
+/*
+* 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.
+*/
+
+/*
+ * @test TestParallelGCThreads
+ * @key gc
+ * @bug 8059527
+ * @summary Tests argument processing for ParallelGCThreads
+ * @library /testlibrary
+ * @run driver TestParallelGCThreads
+ */
+
+import com.oracle.java.testlibrary.*;
+
+public class TestParallelGCThreads {
+
+ public static void main(String args[]) throws Exception {
+
+ // For each parallel collector (G1, Parallel, ParNew/CMS)
+ for (String gc : new String[] {"G1", "Parallel", "ConcMarkSweep"}) {
+
+ // Make sure the VM does not allow ParallelGCThreads set to 0
+ String[] flags = new String[] {"-XX:+Use" + gc + "GC", "-XX:ParallelGCThreads=0", "-XX:+PrintFlagsFinal", "-version"};
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flags);
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(1);
+
+ // Do some basic testing to ensure the flag updates the count
+ for (long i = 1; i <= 3; i++) {
+ flags = new String[] {"-XX:+Use" + gc + "GC", "-XX:ParallelGCThreads=" + i, "-XX:+PrintFlagsFinal", "-version"};
+ long count = getParallelGCThreadCount(flags);
+ Asserts.assertEQ(count, i, "Specifying ParallelGCThreads=" + i + " for " + gc + "GC does not set the thread count properly!");
+ }
+ }
+ }
+
+ public static long getParallelGCThreadCount(String flags[]) throws Exception {
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(flags);
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+ String stdout = output.getStdout();
+ return FlagsValue.getFlagLongValue("ParallelGCThreads", stdout);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,286 @@
+/*
+ * 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.
+ */
+
+import static com.oracle.java.testlibrary.Asserts.assertLessThanOrEqual;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.ProcessTools;
+import com.oracle.java.testlibrary.Utils;
+import java.io.IOException;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryUsage;
+import java.text.DecimalFormat;
+import java.text.DecimalFormatSymbols;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import sun.misc.Unsafe;
+
+public class TestShrinkAuxiliaryData {
+
+ private final static String[] initialOpts = new String[]{
+ "-XX:MinHeapFreeRatio=10",
+ "-XX:MaxHeapFreeRatio=11",
+ "-XX:+UseG1GC",
+ "-XX:G1HeapRegionSize=1m",
+ "-XX:+PrintGCDetails"
+ };
+
+ private final int RSetCacheSize;
+
+ protected TestShrinkAuxiliaryData(int RSetCacheSize) {
+ this.RSetCacheSize = RSetCacheSize;
+ }
+
+ protected void test() throws Exception {
+ ArrayList<String> vmOpts = new ArrayList();
+ Collections.addAll(vmOpts, initialOpts);
+
+ int maxCacheSize = Math.max(0, Math.min(31, getMaxCacheSize()));
+ if (maxCacheSize < RSetCacheSize) {
+ System.out.format("Skiping test for %d cache size due max cache size %d",
+ RSetCacheSize, maxCacheSize
+ );
+ return;
+ }
+
+ printTestInfo(maxCacheSize);
+
+ vmOpts.add("-XX:G1ConcRSLogCacheSize=" + RSetCacheSize);
+
+ vmOpts.addAll(Arrays.asList(Utils.getFilteredTestJavaOpts(
+ ShrinkAuxiliaryDataTest.prohibitedVmOptions)));
+
+ // for 32 bits ObjectAlignmentInBytes is not a option
+ if (Platform.is32bit()) {
+ ArrayList<String> vmOptsWithoutAlign = new ArrayList(vmOpts);
+ vmOptsWithoutAlign.add(ShrinkAuxiliaryDataTest.class.getName());
+ performTest(vmOptsWithoutAlign);
+ return;
+ }
+
+ for (int alignment = 3; alignment <= 8; alignment++) {
+ ArrayList<String> vmOptsWithAlign = new ArrayList(vmOpts);
+ vmOptsWithAlign.add("-XX:ObjectAlignmentInBytes="
+ + (int) Math.pow(2, alignment));
+ vmOptsWithAlign.add(ShrinkAuxiliaryDataTest.class.getName());
+
+ performTest(vmOptsWithAlign);
+ }
+ }
+
+ private void performTest(List<String> opts) throws Exception {
+ ProcessBuilder pb
+ = ProcessTools.createJavaProcessBuilder(
+ opts.toArray(new String[opts.size()])
+ );
+
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+ }
+
+ private void printTestInfo(int maxCacheSize) {
+
+ DecimalFormat grouped = new DecimalFormat("000,000");
+ DecimalFormatSymbols formatSymbols = grouped.getDecimalFormatSymbols();
+ formatSymbols.setGroupingSeparator(' ');
+ grouped.setDecimalFormatSymbols(formatSymbols);
+
+ System.out.format("Test will use %s bytes of memory of %s available%n"
+ + "Available memory is %s with %d bytes pointer size - can save %s pointers%n"
+ + "Max cache size: 2^%d = %s elements%n",
+ grouped.format(ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
+ grouped.format(Runtime.getRuntime().freeMemory()),
+ grouped.format(Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest()),
+ Unsafe.ADDRESS_SIZE,
+ grouped.format((Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest())
+ / Unsafe.ADDRESS_SIZE),
+ maxCacheSize,
+ grouped.format((int) Math.pow(2, maxCacheSize))
+ );
+ }
+
+ /**
+ * Detects maximum possible size of G1ConcRSLogCacheSize available for
+ * current process based on maximum available process memory size
+ *
+ * @return power of two
+ */
+ private static int getMaxCacheSize() {
+ long availableMemory = Runtime.getRuntime().freeMemory()
+ - ShrinkAuxiliaryDataTest.getMemoryUsedByTest() - 1l;
+ if (availableMemory <= 0) {
+ return 0;
+ }
+ long availablePointersCount = availableMemory / Unsafe.ADDRESS_SIZE;
+ return (63 - (int) Long.numberOfLeadingZeros(availablePointersCount));
+ }
+
+ static class ShrinkAuxiliaryDataTest {
+
+ public static void main(String[] args) throws IOException {
+ int iterateCount = DEFAULT_ITERATION_COUNT;
+
+ if (args.length > 0) {
+ try {
+ iterateCount = Integer.parseInt(args[0]);
+ } catch (NumberFormatException e) {
+ //num_iterate remains default
+ }
+ }
+
+ new ShrinkAuxiliaryDataTest().test(iterateCount);
+ }
+
+ class GarbageObject {
+
+ private final List<byte[]> payload = new ArrayList();
+ private final List<GarbageObject> ref = new LinkedList();
+
+ public GarbageObject(int size) {
+ payload.add(new byte[size]);
+ }
+
+ public void addRef(GarbageObject g) {
+ ref.add(g);
+ }
+
+ public void mutate() {
+ if (!payload.isEmpty() && payload.get(0).length > 0) {
+ payload.get(0)[0] = (byte) (Math.random() * Byte.MAX_VALUE);
+ }
+ }
+ }
+
+ private final List<GarbageObject> garbage = new ArrayList();
+
+ public void test(int num_iterate) throws IOException {
+
+ allocate();
+ link();
+ mutate();
+ deallocate();
+
+ MemoryUsage muBeforeHeap
+ = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+ MemoryUsage muBeforeNonHeap
+ = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
+
+ for (int i = 0; i < num_iterate; i++) {
+ allocate();
+ link();
+ mutate();
+ deallocate();
+ }
+
+ System.gc();
+ MemoryUsage muAfterHeap
+ = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage();
+ MemoryUsage muAfterNonHeap
+ = ManagementFactory.getMemoryMXBean().getNonHeapMemoryUsage();
+
+ assertLessThanOrEqual(muAfterHeap.getCommitted(), muBeforeHeap.getCommitted(),
+ String.format("heap decommit failed - after > before: %d > %d",
+ muAfterHeap.getCommitted(), muBeforeHeap.getCommitted()
+ )
+ );
+
+ if (muAfterHeap.getCommitted() < muBeforeHeap.getCommitted()) {
+ assertLessThanOrEqual(muAfterNonHeap.getCommitted(), muBeforeNonHeap.getCommitted(),
+ String.format("non-heap decommit failed - after > before: %d > %d",
+ muAfterNonHeap.getCommitted(), muBeforeNonHeap.getCommitted()
+ )
+ );
+ }
+ }
+
+ private void allocate() {
+ for (int r = 0; r < REGIONS_TO_ALLOCATE; r++) {
+ for (int i = 0; i < NUM_OBJECTS_PER_REGION; i++) {
+ GarbageObject g = new GarbageObject(REGION_SIZE
+ / NUM_OBJECTS_PER_REGION);
+ garbage.add(g);
+ }
+ }
+ }
+
+ /**
+ * Iterate through all allocated objects, and link to objects in another
+ * regions
+ */
+ private void link() {
+ for (int ig = 0; ig < garbage.size(); ig++) {
+ int regionNumber = ig / NUM_OBJECTS_PER_REGION;
+
+ for (int i = 0; i < NUM_LINKS; i++) {
+ int regionToLink;
+ do {
+ regionToLink = (int) (Math.random()
+ * REGIONS_TO_ALLOCATE);
+ } while (regionToLink == regionNumber);
+
+ // get random garbage object from random region
+ garbage.get(ig).addRef(garbage.get(regionToLink
+ * NUM_OBJECTS_PER_REGION + (int) (Math.random()
+ * NUM_OBJECTS_PER_REGION)));
+ }
+ }
+ }
+
+ private void mutate() {
+ for (int ig = 0; ig < garbage.size(); ig++) {
+ garbage.get(ig).mutate();
+ }
+ }
+
+ private void deallocate() {
+ garbage.clear();
+ System.gc();
+ }
+
+ static long getMemoryUsedByTest() {
+ return REGIONS_TO_ALLOCATE * REGION_SIZE;
+ }
+
+ private static final int REGION_SIZE = 1024 * 1024;
+ private static final int DEFAULT_ITERATION_COUNT = 1; // iterate main scenario
+ private static final int REGIONS_TO_ALLOCATE = 5;
+ private static final int NUM_OBJECTS_PER_REGION = 10;
+ private static final int NUM_LINKS = 20; // how many links create for each object
+
+ private static final String[] prohibitedVmOptions = {
+ // remove this when @requires option will be on duty
+ "-XX:\\+UseParallelGC",
+ "-XX:\\+UseSerialGC",
+ "-XX:\\+UseConcMarkSweepGC",
+ "-XX:\\+UseParallelOldGC",
+ "-XX:\\+UseParNewGC",
+ "-Xconcgc",
+ "-Xincgc"
+ };
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData00.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData00
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData00
+ * @run driver/timeout=720 TestShrinkAuxiliaryData00
+ */
+public class TestShrinkAuxiliaryData00 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(0).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData05.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData05
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData05
+ * @run driver/timeout=720 TestShrinkAuxiliaryData05
+ */
+public class TestShrinkAuxiliaryData05 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(5).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData10.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData10
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData10
+ * @run driver/timeout=720 TestShrinkAuxiliaryData10
+ */
+public class TestShrinkAuxiliaryData10 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(10).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData15.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData15
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData15
+ * @run driver/timeout=720 TestShrinkAuxiliaryData15
+ */
+public class TestShrinkAuxiliaryData15 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(15).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData20.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData20
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData20
+ * @run driver/timeout=720 TestShrinkAuxiliaryData20
+ */
+public class TestShrinkAuxiliaryData20 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(20).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData25.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData25
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData25
+ * @run driver/timeout=720 TestShrinkAuxiliaryData25
+ */
+public class TestShrinkAuxiliaryData25 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(25).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/g1/TestShrinkAuxiliaryData30.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,38 @@
+/*
+ * 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.
+ */
+
+/**
+ * @test TestShrinkAuxiliaryData30
+ * @bug 8038423
+ * @summary Checks that decommitment occurs for JVM with different
+ * G1ConcRSLogCacheSize and ObjectAlignmentInBytes options values
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestShrinkAuxiliaryData TestShrinkAuxiliaryData30
+ * @run driver/timeout=720 TestShrinkAuxiliaryData30
+ */
+public class TestShrinkAuxiliaryData30 {
+
+ public static void main(String[] args) throws Exception {
+ new TestShrinkAuxiliaryData(30).test();
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/gc/metaspace/TestCapacityUntilGCWrapAround.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,59 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @key gc
+ * @bug 8049831
+ * @library /testlibrary /testlibrary/whitebox
+ * @build TestCapacityUntilGCWrapAround
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI TestCapacityUntilGCWrapAround
+ */
+
+import sun.hotspot.WhiteBox;
+
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.Platform;
+
+public class TestCapacityUntilGCWrapAround {
+ private static long MB = 1024 * 1024;
+ private static long GB = 1024 * MB;
+ private static long MAX_UINT = 4 * GB - 1; // On 32-bit platforms
+
+ public static void main(String[] args) {
+ if (Platform.is32bit()) {
+ WhiteBox wb = WhiteBox.getWhiteBox();
+
+ long before = wb.metaspaceCapacityUntilGC();
+ // Now force possible overflow of capacity_until_GC.
+ long after = wb.incMetaspaceCapacityUntilGC(MAX_UINT);
+
+ Asserts.assertGTE(after, before,
+ "Increasing with MAX_UINT should not cause wrap around: " + after + " < " + before);
+ Asserts.assertLTE(after, MAX_UINT,
+ "Increasing with MAX_UINT should not cause value larger than MAX_UINT:" + after);
+ }
+ }
+}
--- a/hotspot/test/runtime/CompressedOops/UseCompressedOops.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/runtime/CompressedOops/UseCompressedOops.java Fri Oct 10 02:24:41 2014 -0700
@@ -52,18 +52,17 @@
.shouldContain("Compressed Oops mode")
.shouldHaveExitValue(0);
- // Larger than 4gb heap should result in zero based with shift 3
- testCompressedOops("-XX:+UseCompressedOops", "-Xmx5g")
- .shouldContain("Zero based")
- .shouldContain("Oop shift amount: 3")
- .shouldHaveExitValue(0);
+ // Skip the following three test cases if we're on OSX or Solaris.
+ //
+ // OSX doesn't seem to care about HeapBaseMinAddress and Solaris
+ // puts the heap way up, forcing different behaviour.
+ if (!Platform.isOSX() && !Platform.isSolaris()) {
+ // Larger than 4gb heap should result in zero based with shift 3
+ testCompressedOops("-XX:+UseCompressedOops", "-Xmx5g")
+ .shouldContain("Zero based")
+ .shouldContain("Oop shift amount: 3")
+ .shouldHaveExitValue(0);
- // Skip the following three test cases if we're on OSX or Solaris Sparc.
- //
- // OSX doesn't seem to care about HeapBaseMinAddress and Solaris Sparc
- // puts the heap way up, forcing different behaviour.
-
- if (!Platform.isOSX() && !(Platform.isSolaris() && Platform.isSparc())) {
// Small heap above 4gb should result in zero based with shift 3
testCompressedOops("-XX:+UseCompressedOops", "-Xmx32m", "-XX:HeapBaseMinAddress=4g")
.shouldContain("Zero based")
@@ -83,6 +82,12 @@
.shouldContain("Non-zero based")
.shouldContain("Oop shift amount: 4")
.shouldHaveExitValue(0);
+
+ // 32gb heap with object alignment set to 16 bytes should result in zero based with shift 4
+ testCompressedOops("-XX:+UseCompressedOops", "-Xmx32g", "-XX:ObjectAlignmentInBytes=16")
+ .shouldContain("Zero based")
+ .shouldContain("Oop shift amount: 4")
+ .shouldHaveExitValue(0);
}
// Explicitly enabling compressed oops with 32gb heap should result a warning
@@ -106,12 +111,6 @@
.shouldContain("Max heap size too large for Compressed Oops")
.shouldHaveExitValue(0);
- // 32gb heap with object alignment set to 16 bytes should result in zero based with shift 4
- testCompressedOops("-XX:+UseCompressedOops", "-Xmx32g", "-XX:ObjectAlignmentInBytes=16")
- .shouldContain("Zero based")
- .shouldContain("Oop shift amount: 4")
- .shouldHaveExitValue(0);
-
} else {
// Compressed oops should only apply to 64bit platforms
testCompressedOops("-XX:+UseCompressedOops", "-Xmx32m")
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/LoadClass/ShowClassLoader.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,45 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @key regression
+ * @bug 8058927
+ * @summary Make sure array class has the right class loader
+ * @run main ShowClassLoader
+ */
+
+public class ShowClassLoader {
+
+ public static void main(String[] args) {
+ Object[] oa = new Object[0];
+ ShowClassLoader[] sa = new ShowClassLoader[0];
+
+ System.out.println("Classloader for Object[] is " + oa.getClass().getClassLoader());
+ System.out.println("Classloader for SCL[] is " + sa.getClass().getClassLoader() );
+
+ if (sa.getClass().getClassLoader() == null) {
+ throw new RuntimeException("Wrong class loader");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/NMT/UnsafeMallocLimit2.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,54 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8058818
+ * @library /testlibrary
+ * @build UnsafeMallocLimit2
+ * @run main/othervm -Xmx32m -XX:NativeMemoryTracking=off UnsafeMallocLimit2
+ */
+
+import com.oracle.java.testlibrary.*;
+import sun.misc.Unsafe;
+
+public class UnsafeMallocLimit2 {
+
+ public static void main(String args[]) throws Exception {
+ if (Platform.is32bit()) {
+ Unsafe unsafe = Utils.getUnsafe();
+ try {
+ // Allocate greater than MALLOC_MAX and likely won't fail to allocate,
+ // so it hits the NMT code that asserted.
+ // Test that this doesn't cause an assertion with NMT off.
+ // The option above overrides if all the tests are run with NMT on.
+ unsafe.allocateMemory(0x40000000);
+ System.out.println("Allocation succeeded");
+ } catch (OutOfMemoryError e) {
+ System.out.println("Allocation failed");
+ }
+ } else {
+ System.out.println("Test only valid on 32-bit platforms");
+ }
+ }
+}
--- a/hotspot/test/serviceability/dcmd/CodeCacheTest.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,139 +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.
- */
-
-/*
- * @test CodeCacheTest
- * @bug 8054889
- * @build DcmdUtil CodeCacheTest
- * @run main CodeCacheTest
- * @summary Test of diagnostic command Compiler.codecache
- */
-
-import java.io.BufferedReader;
-import java.io.StringReader;
-import java.lang.reflect.Method;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-public class CodeCacheTest {
-
- /**
- * This test calls Jcmd (diagnostic command tool) Compiler.codecache and then parses the output,
- * making sure that all number look ok
- *
- *
- * Expected output:
- *
- * CodeCache: size=245760Kb used=4680Kb max_used=4680Kb free=241079Kb
- * bounds [0x00007f5bd9000000, 0x00007f5bd94a0000, 0x00007f5be8000000]
- * total_blobs=575 nmethods=69 adapters=423
- * compilation: enabled
- */
-
- static Pattern line1 = Pattern.compile("CodeCache: size=(\\p{Digit}*)Kb used=(\\p{Digit}*)Kb max_used=(\\p{Digit}*)Kb free=(\\p{Digit}*)Kb");
- static Pattern line2 = Pattern.compile(" bounds \\[0x(\\p{XDigit}*), 0x(\\p{XDigit}*), 0x(\\p{XDigit}*)\\]");
- static Pattern line3 = Pattern.compile(" total_blobs=(\\p{Digit}*) nmethods=(\\p{Digit}*) adapters=(\\p{Digit}*)");
- static Pattern line4 = Pattern.compile(" compilation: (\\w*)");
-
- public static void main(String arg[]) throws Exception {
-
- // Get output from dcmd (diagnostic command)
- String result = DcmdUtil.executeDcmd("Compiler.codecache");
- BufferedReader r = new BufferedReader(new StringReader(result));
-
- // Validate first line
- String line;
- line = r.readLine();
- Matcher m = line1.matcher(line);
- if (m.matches()) {
- for(int i = 1; i <= 4; i++) {
- int val = Integer.parseInt(m.group(i));
- if (val < 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- }
- } else {
- throw new Exception("Regexp 1 failed");
- }
-
- // Validate second line
- line = r.readLine();
- m = line2.matcher(line);
- if (m.matches()) {
- long start = Long.parseLong(m.group(1), 16);
- if (start < 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- long mark = Long.parseLong(m.group(2), 16);
- if (mark < 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- long top = Long.parseLong(m.group(3), 16);
- if (top < 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- if (start > mark) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- if (mark > top) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- } else {
- throw new Exception("Regexp 2 failed line: " + line);
- }
-
- // Validate third line
- line = r.readLine();
- m = line3.matcher(line);
- if (m.matches()) {
- int blobs = Integer.parseInt(m.group(1));
- if (blobs <= 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- int nmethods = Integer.parseInt(m.group(2));
- if (nmethods <= 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- int adapters = Integer.parseInt(m.group(3));
- if (adapters <= 0) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- if (blobs < (nmethods + adapters)) {
- throw new Exception("Failed parsing dcmd codecache output");
- }
- } else {
- throw new Exception("Regexp 3 failed");
- }
-
- // Validate fourth line
- line = r.readLine();
- m = line4.matcher(line);
- if (m.matches()) {
- if (!m.group(1).equals("enabled")) {
- throw new Exception("Invalid message: '" + m.group(1) + "'");
- }
- } else {
- throw new Exception("Regexp 4 failed");
- }
- }
-}
--- a/hotspot/test/serviceability/dcmd/CodelistTest.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,97 +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.
- */
-
-/*
- * @test CodelistTest
- * @bug 8054889
- * @build DcmdUtil MethodIdentifierParser CodelistTest
- * @run main CodelistTest
- * @summary Test of diagnostic command Compiler.codelist
- */
-
-import java.io.BufferedReader;
-import java.io.StringReader;
-import java.lang.reflect.Method;
-
-public class CodelistTest {
-
- /**
- * This test calls Jcmd (diagnostic command tool) Compiler.codelist and then parses the output,
- * making sure that the first methods in the list is valid by reflection.
- *
- * Output example:
- *
- * 6 0 java.lang.System.arraycopy(Ljava/lang/Object;ILjava/lang/Object;II)V [0x00007f7b49200910, 0x00007f7b49200aa0 - 0x00007f7b49200d30]
- * 2 3 java.lang.String.indexOf(II)I [0x00007f7b49200d90, 0x00007f7b49200f60 - 0x00007f7b49201490]
- * 7 3 java.lang.Math.min(II)I [0x00007f7b4922f010, 0x00007f7b4922f180 - 0x00007f7b4922f338]
- * 8 3 java.lang.String.equals(Ljava/lang/Object;)Z [0x00007f7b4922fb10, 0x00007f7b4922fd40 - 0x00007f7b49230698]
- * 9 3 java.lang.AbstractStringBuilder.ensureCapacityInternal(I)V [0x00007f7b49232010, 0x00007f7b492321a0 - 0x00007f7b49232510]
- * 10 1 java.lang.Object.<init>()V [0x00007f7b49233e90, 0x00007f7b49233fe0 - 0x00007f7b49234118]
- *
- */
-
- public static void main(String arg[]) throws Exception {
- int ok = 0;
- int fail = 0;
-
- // Get output from dcmd (diagnostic command)
- String result = DcmdUtil.executeDcmd("Compiler.codelist");
- BufferedReader r = new BufferedReader(new StringReader(result));
-
- // Grab a method name from the output
- String line;
- int count = 0;
-
- while((line = r.readLine()) != null) {
- count++;
-
- String[] parts = line.split(" ");
- // int compileID = Integer.parseInt(parts[0]);
- // int compileLevel = Integer.parseInt(parts[1]);
- String methodPrintedInLogFormat = parts[2];
-
- // skip inits and clinits - they can not be reflected
- if (methodPrintedInLogFormat.contains("<init>")) {
- continue;
- }
- if (methodPrintedInLogFormat.contains("<clinit>")) {
- continue;
- }
-
- MethodIdentifierParser mf = new MethodIdentifierParser(methodPrintedInLogFormat);
- Method m;
- try {
- m = mf.getMethod();
- } catch (NoSuchMethodException e) {
- m = null;
- }
- if (m == null) {
- throw new Exception("Test failed");
- }
- if (count > 10) {
- // Testing 10 entries is enough. Lets not waste time.
- break;
- }
- }
- }
-}
--- a/hotspot/test/serviceability/dcmd/CompilerQueueTest.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,108 +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.
- */
-
-/*
- * @test CompilerQueueTest
- * @bug 8054889
- * @build DcmdUtil CompilerQueueTest
- * @run main CompilerQueueTest
- * @summary Test of diagnostic command Compiler.queue
- */
-
-import java.io.BufferedReader;
-import java.io.StringReader;
-
-public class CompilerQueueTest {
-
- /**
- * This test calls Jcmd (diagnostic command tool) Compiler.queue and
- * then parses the output, making sure that the output look ok.
- *
- *
- * Output example:
- *
- * Contents of C1 compile queue
- * ----------------------------
- * 73 3 java.lang.AbstractStringBuilder::append (50 bytes)
- * 74 1 java.util.TreeMap::size (5 bytes)
- * 75 3 java.lang.StringBuilder::append (8 bytes)
- * 83 3 java.util.TreeMap$ValueIterator::next (8 bytes)
- * 84 1 javax.management.MBeanFeatureInfo::getName (5 bytes)
- * ----------------------------
- * Contents of C2 compile queue
- * ----------------------------
- * Empty
- * ----------------------------
- *
- **/
-
- public static void main(String arg[]) throws Exception {
-
- // Get output from dcmd (diagnostic command)
- String result = DcmdUtil.executeDcmd("Compiler.queue");
- BufferedReader r = new BufferedReader(new StringReader(result));
-
- String line;
- match(r.readLine(), "Contents of C1 compile queue");
- match(r.readLine(), "----------------------------");
- String str = r.readLine();
- if (!str.equals("Empty")) {
- while (str.charAt(0) != '-') {
- validateMethodLine(str);
- str = r.readLine();
- }
- } else {
- str = r.readLine();
- }
-
- match(str, "----------------------------");
- match(r.readLine(), "Contents of C2 compile queue");
- match(r.readLine(), "----------------------------");
- str = r.readLine();
- if (!str.equals("Empty")) {
- while (str.charAt(0) != '-') {
- validateMethodLine(str);
- str = r.readLine();
- }
- } else {
- str = r.readLine();
- }
- match(str, "----------------------------");
- }
-
- private static void validateMethodLine(String str) throws Exception {
- String name = str.substring(19);
- int sep = name.indexOf("::");
- try {
- Class.forName(name.substring(0, sep));
- } catch (ClassNotFoundException e) {
- throw new Exception("Failed parsing dcmd queue");
- }
- }
-
- public static void match(String line, String str) throws Exception {
- if (!line.equals(str)) {
- throw new Exception("String equals: " + line + ", " + str);
- }
- }
-}
--- a/hotspot/test/serviceability/dcmd/MethodIdentifierParser.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,196 +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.
- */
-
-import java.lang.reflect.Method;
-import java.util.ArrayList;
-
-public class MethodIdentifierParser {
-
- private String logString;
- private String className;
- private String methodName;
- private String methodDescriptor;
-
- /**
- * This is a utility class for parsing the log entries for a method. It supplies
- * a few select methods for reflecting the class and method from that information.
- *
- * Example log entries:
- * "java.util.TreeMap.successor(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;"
- */
-
- public MethodIdentifierParser(String logString) {
- this.logString = logString;
-
- int i = logString.lastIndexOf("."); // find start of method name
- className = logString.substring(0, i); // classname is everything before
- int i2 = logString.indexOf("("); // Signature starts with an '('
- methodName = logString.substring(i+1, i2);
- methodDescriptor = logString.substring(i2, logString.length());
-
- // Add sanity check for extracted fields
- }
-
- public Method getMethod() throws NoSuchMethodException, SecurityException, ClassNotFoundException, Exception {
- try {
- return Class.forName(className).getDeclaredMethod(methodName, getParamenterDescriptorArray());
- } catch (UnexpectedTokenException e) {
- throw new Exception("Parse failed");
- }
- }
-
- public Class<?>[] getParamenterDescriptorArray() throws ClassNotFoundException, UnexpectedTokenException {
- ParameterDecriptorIterator s = new ParameterDecriptorIterator(methodDescriptor);
- Class<?> paramType;
- ArrayList<Class<?>> list = new ArrayList<Class<?>>();
- while ((paramType = s.nextParamType()) != null) {
- list.add(paramType);
- }
- if (list.size() > 0) {
- return list.toArray(new Class<?>[list.size()]);
- } else {
- return null;
- }
- }
-
- class ParameterDecriptorIterator {
-
- // This class uses charAt() indexing for startMark and i
- // That is when i points to the last char it can be retrieved with
- // charAt(i). Including the last char for a subString requires
- // substring(startMark, i+1);
-
- private String methodDescriptor;
- private int startMark;
-
- public ParameterDecriptorIterator(String signature) {
- this.methodDescriptor = signature;
- this.startMark = 0;
- if (signature.charAt(0) == '(') {
- this.startMark = 1;
- }
- }
-
- public Class<?> nextParamType() throws UnexpectedTokenException {
- int i = startMark;
- while (methodDescriptor.length() > i) {
- switch (methodDescriptor.charAt(i)) {
- case 'C':
- case 'B':
- case 'I':
- case 'J':
- case 'Z':
- case 'F':
- case 'D':
- case 'S':
- // Primitive class case, but we may have gotten here with [ as first token
- break;
- case 'L':
- // Internal class name suffixed by ';'
- while (methodDescriptor.charAt(i) != ';') {
- i++;
- }
- break;
- case '[':
- i++; // arrays -> do another pass
- continue;
- case ')':
- return null; // end found
- case 'V':
- case ';':
- default:
- throw new UnexpectedTokenException(methodDescriptor, i);
- }
- break;
- }
- if (i == startMark) {
- // Single char -> primitive class case
- startMark++; // Update for next iteration
- switch (methodDescriptor.charAt(i)) {
- case 'C':
- return char.class;
- case 'B':
- return byte.class;
- case 'I':
- return int.class;
- case 'J':
- return long.class;
- case 'F':
- return float.class;
- case 'D':
- return double.class;
- case 'S':
- return short.class;
- case 'Z':
- return boolean.class;
- default:
- throw new UnexpectedTokenException(methodDescriptor, i);
- }
- } else {
- // Multi char case
- String nextParam;
- if (methodDescriptor.charAt(startMark) == 'L') {
- // When reflecting a class the leading 'L' and trailing';' must be removed.
- // (When reflecting an array of classes, they must remain...)
- nextParam = methodDescriptor.substring(startMark+1, i);
- } else {
- // Any kind of array - simple case, use whole descriptor when reflecting.
- nextParam = methodDescriptor.substring(startMark, i+1);
- }
- startMark = ++i; // Update for next iteration
- try {
- // The parameter descriptor uses JVM internal class identifier with '/' as
- // package separator, but Class.forName expects '.'.
- nextParam = nextParam.replace('/', '.');
- return Class.forName(nextParam);
- } catch (ClassNotFoundException e) {
- System.out.println("Class not Found: " + nextParam);
- return null;
- }
- }
- }
- }
-
- class UnexpectedTokenException extends Exception {
- String descriptor;
- int i;
- public UnexpectedTokenException(String descriptor, int i) {
- this.descriptor = descriptor;
- this.i = i;
- }
-
- @Override
- public String toString() {
- return "Unexpected token at: " + i + " in signature: " + descriptor;
- }
-
- private static final long serialVersionUID = 1L;
- }
-
- public void debugPrint() {
- System.out.println("mlf in: " + logString);
- System.out.println("mlf class: " + className);
- System.out.println("mlf method: " + methodName);
- System.out.println("mlf methodDescriptor: " + methodDescriptor);
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/dcmd/compiler/CodeCacheTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,176 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test CodeCacheTest
+ * @bug 8054889
+ * @library ..
+ * @build DcmdUtil CodeCacheTest
+ * @run main/othervm -XX:+SegmentedCodeCache CodeCacheTest
+ * @run main/othervm -XX:-SegmentedCodeCache CodeCacheTest
+ * @run main/othervm -Xint -XX:+SegmentedCodeCache CodeCacheTest
+ * @summary Test of diagnostic command Compiler.codecache
+ */
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+import java.lang.reflect.Method;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class CodeCacheTest {
+
+ /**
+ * This test calls Jcmd (diagnostic command tool) Compiler.codecache and then parses the output,
+ * making sure that all numbers look ok
+ *
+ *
+ * Expected output without code cache segmentation:
+ *
+ * CodeCache: size=245760Kb used=4680Kb max_used=4680Kb free=241079Kb
+ * bounds [0x00007f5bd9000000, 0x00007f5bd94a0000, 0x00007f5be8000000]
+ * total_blobs=575 nmethods=69 adapters=423
+ * compilation: enabled
+ *
+ * Expected output with code cache segmentation (number of segments may change):
+ *
+ * CodeHeap 'non-nmethods': size=5696Kb used=2236Kb max_used=2238Kb free=3459Kb
+ * bounds [0x00007fa0f0ffe000, 0x00007fa0f126e000, 0x00007fa0f158e000]
+ * CodeHeap 'profiled nmethods': size=120036Kb used=8Kb max_used=8Kb free=120027Kb
+ * bounds [0x00007fa0f158e000, 0x00007fa0f17fe000, 0x00007fa0f8ac7000]
+ * CodeHeap 'non-profiled nmethods': size=120036Kb used=2Kb max_used=2Kb free=120034Kb
+ * bounds [0x00007fa0f8ac7000, 0x00007fa0f8d37000, 0x00007fa100000000]
+ * total_blobs=486 nmethods=8 adapters=399
+ * compilation: enabled
+ */
+
+ static Pattern line1 = Pattern.compile("(CodeCache|CodeHeap.*): size=(\\p{Digit}*)Kb used=(\\p{Digit}*)Kb max_used=(\\p{Digit}*)Kb free=(\\p{Digit}*)Kb");
+ static Pattern line2 = Pattern.compile(" bounds \\[0x(\\p{XDigit}*), 0x(\\p{XDigit}*), 0x(\\p{XDigit}*)\\]");
+ static Pattern line3 = Pattern.compile(" total_blobs=(\\p{Digit}*) nmethods=(\\p{Digit}*) adapters=(\\p{Digit}*)");
+ static Pattern line4 = Pattern.compile(" compilation: (.*)");
+
+ private static boolean getFlagBool(String flag, String where) {
+ Matcher m = Pattern.compile(flag + "\\s+:?= (true|false)").matcher(where);
+ if (!m.find()) {
+ throw new RuntimeException("Could not find value for flag " + flag + " in output string");
+ }
+ return m.group(1).equals("true");
+ }
+
+ private static int getFlagInt(String flag, String where) {
+ Matcher m = Pattern.compile(flag + "\\s+:?=\\s+\\d+").matcher(where);
+ if (!m.find()) {
+ throw new RuntimeException("Could not find value for flag " + flag + " in output string");
+ }
+ String match = m.group();
+ return Integer.parseInt(match.substring(match.lastIndexOf(" ") + 1, match.length()));
+ }
+
+ public static void main(String arg[]) throws Exception {
+ // Get number of code cache segments
+ int segmentsCount = 0;
+ String flags = DcmdUtil.executeDcmd("VM.flags", "-all");
+ if (!getFlagBool("SegmentedCodeCache", flags) || !getFlagBool("UseCompiler", flags)) {
+ // No segmentation
+ segmentsCount = 1;
+ } else if (getFlagBool("TieredCompilation", flags) && getFlagInt("TieredStopAtLevel", flags) > 1) {
+ // Tiered compilation: use all segments
+ segmentsCount = 3;
+ } else {
+ // No TieredCompilation: only non-nmethod and non-profiled segment
+ segmentsCount = 2;
+ }
+
+ // Get output from dcmd (diagnostic command)
+ String result = DcmdUtil.executeDcmd("Compiler.codecache");
+ BufferedReader r = new BufferedReader(new StringReader(result));
+
+ // Validate code cache segments
+ String line;
+ Matcher m;
+ for (int s = 0; s < segmentsCount; ++s) {
+ // Validate first line
+ line = r.readLine();
+ m = line1.matcher(line);
+ if (m.matches()) {
+ for (int i = 2; i <= 5; i++) {
+ int val = Integer.parseInt(m.group(i));
+ if (val < 0) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ }
+ } else {
+ throw new Exception("Regexp 1 failed");
+ }
+
+ // Validate second line
+ line = r.readLine();
+ m = line2.matcher(line);
+ if (m.matches()) {
+ String start = m.group(1);
+ String mark = m.group(2);
+ String top = m.group(3);
+
+ // Lexical compare of hex numbers to check that they look sane.
+ if (start.compareTo(mark) > 1) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ if (mark.compareTo(top) > 1) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ } else {
+ throw new Exception("Regexp 2 failed line: " + line);
+ }
+ }
+
+ // Validate third line
+ line = r.readLine();
+ m = line3.matcher(line);
+ if (m.matches()) {
+ int blobs = Integer.parseInt(m.group(1));
+ if (blobs <= 0) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ int nmethods = Integer.parseInt(m.group(2));
+ if (nmethods < 0) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ int adapters = Integer.parseInt(m.group(3));
+ if (adapters <= 0) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ if (blobs < (nmethods + adapters)) {
+ throw new Exception("Failed parsing dcmd codecache output");
+ }
+ } else {
+ throw new Exception("Regexp 3 failed");
+ }
+
+ // Validate fourth line
+ line = r.readLine();
+ m = line4.matcher(line);
+ if (!m.matches()) {
+ throw new Exception("Regexp 4 failed");
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/dcmd/compiler/CodelistTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,101 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test CodelistTest
+ * @bug 8054889
+ * @library ..
+ * @build DcmdUtil MethodIdentifierParser CodelistTest
+ * @run main CodelistTest
+ * @summary Test of diagnostic command Compiler.codelist
+ */
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+import java.lang.reflect.Method;
+
+public class CodelistTest {
+
+ /**
+ * This test calls Jcmd (diagnostic command tool) Compiler.codelist and then parses the output,
+ * making sure that the first methods in the list is valid by reflection.
+ *
+ * Output example:
+ *
+ * 6 0 java.lang.System.arraycopy(Ljava/lang/Object;ILjava/lang/Object;II)V [0x00007f7b49200910, 0x00007f7b49200aa0 - 0x00007f7b49200d30]
+ * 2 3 java.lang.String.indexOf(II)I [0x00007f7b49200d90, 0x00007f7b49200f60 - 0x00007f7b49201490]
+ * 7 3 java.lang.Math.min(II)I [0x00007f7b4922f010, 0x00007f7b4922f180 - 0x00007f7b4922f338]
+ * 8 3 java.lang.String.equals(Ljava/lang/Object;)Z [0x00007f7b4922fb10, 0x00007f7b4922fd40 - 0x00007f7b49230698]
+ * 9 3 java.lang.AbstractStringBuilder.ensureCapacityInternal(I)V [0x00007f7b49232010, 0x00007f7b492321a0 - 0x00007f7b49232510]
+ * 10 1 java.lang.Object.<init>()V [0x00007f7b49233e90, 0x00007f7b49233fe0 - 0x00007f7b49234118]
+ *
+ */
+
+ public static void main(String arg[]) throws Exception {
+ int ok = 0;
+ int fail = 0;
+
+ // Get output from dcmd (diagnostic command)
+ String result = DcmdUtil.executeDcmd("Compiler.codelist");
+ BufferedReader r = new BufferedReader(new StringReader(result));
+
+ // Grab a method name from the output
+ String line;
+ int count = 0;
+
+ while((line = r.readLine()) != null) {
+ count++;
+
+ String[] parts = line.split(" ");
+ // int compileID = Integer.parseInt(parts[0]);
+ // int compileLevel = Integer.parseInt(parts[1]);
+ String methodPrintedInLogFormat = parts[2];
+
+ // skip inits, clinits and methodHandles - they can not be reflected
+ if (methodPrintedInLogFormat.contains("<init>")) {
+ continue;
+ }
+ if (methodPrintedInLogFormat.contains("<clinit>")) {
+ continue;
+ }
+ if (methodPrintedInLogFormat.contains("MethodHandle")) {
+ continue;
+ }
+
+ MethodIdentifierParser mf = new MethodIdentifierParser(methodPrintedInLogFormat);
+ Method m;
+ try {
+ m = mf.getMethod();
+ } catch (NoSuchMethodException e) {
+ m = null;
+ }
+ if (m == null) {
+ throw new Exception("Test failed on: " + methodPrintedInLogFormat);
+ }
+ if (count > 10) {
+ // Testing 10 entries is enough. Lets not waste time.
+ break;
+ }
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/dcmd/compiler/CompilerQueueTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,107 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test CompilerQueueTest
+ * @bug 8054889
+ * @library ..
+ * @build DcmdUtil CompilerQueueTest
+ * @run main CompilerQueueTest
+ * @run main/othervm -Xint CompilerQueueTest
+ * @summary Test of diagnostic command Compiler.queue
+ */
+
+import java.io.BufferedReader;
+import java.io.StringReader;
+
+public class CompilerQueueTest {
+
+ /**
+ * This test calls Jcmd (diagnostic command tool) Compiler.queue and
+ * then parses the output, making sure that the output look ok.
+ *
+ *
+ * Output example:
+ *
+ * Contents of C1 compile queue
+ * ----------------------------
+ * 73 3 java.lang.AbstractStringBuilder::append (50 bytes)
+ * 74 1 java.util.TreeMap::size (5 bytes)
+ * 75 3 java.lang.StringBuilder::append (8 bytes)
+ * 83 3 java.util.TreeMap$ValueIterator::next (8 bytes)
+ * 84 1 javax.management.MBeanFeatureInfo::getName (5 bytes)
+ * ----------------------------
+ * Contents of C2 compile queue
+ * ----------------------------
+ * Empty
+ * ----------------------------
+ *
+ **/
+
+ public static void main(String arg[]) throws Exception {
+
+ // Get output from dcmd (diagnostic command)
+ String result = DcmdUtil.executeDcmd("Compiler.queue");
+ BufferedReader r = new BufferedReader(new StringReader(result));
+
+ String str = r.readLine();
+
+ while (str != null) {
+ if (str.startsWith("Contents of C")) {
+ match(r.readLine(), "----------------------------");
+ str = r.readLine();
+ if (!str.equals("Empty")) {
+ while (str.charAt(0) != '-') {
+ validateMethodLine(str);
+ str = r.readLine();
+ }
+ } else {
+ str = r.readLine();
+ }
+ match(str,"----------------------------");
+ str = r.readLine();
+ } else {
+ throw new Exception("Failed parsing dcmd queue, line: " + str);
+ }
+ }
+ }
+
+ private static void validateMethodLine(String str) throws Exception {
+ String name = str.substring(19);
+ int sep = name.indexOf("::");
+ if (sep == -1) {
+ throw new Exception("Failed dcmd queue, didn't find separator :: in: " + name);
+ }
+ try {
+ Class.forName(name.substring(0, sep));
+ } catch (ClassNotFoundException e) {
+ throw new Exception("Failed dcmd queue, Class for name: " + str);
+ }
+ }
+
+ public static void match(String line, String str) throws Exception {
+ if (!line.equals(str)) {
+ throw new Exception("String equals: " + line + ", " + str);
+ }
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/dcmd/compiler/MethodIdentifierParser.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,196 @@
+/*
+ * 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.
+ */
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class MethodIdentifierParser {
+
+ private String logString;
+ private String className;
+ private String methodName;
+ private String methodDescriptor;
+
+ /**
+ * This is a utility class for parsing the log entries for a method. It supplies
+ * a few select methods for reflecting the class and method from that information.
+ *
+ * Example log entries:
+ * "java.util.TreeMap.successor(Ljava/util/TreeMap$Entry;)Ljava/util/TreeMap$Entry;"
+ */
+
+ public MethodIdentifierParser(String logString) {
+ this.logString = logString;
+
+ int i = logString.lastIndexOf("."); // find start of method name
+ className = logString.substring(0, i); // classname is everything before
+ int i2 = logString.indexOf("("); // Signature starts with an '('
+ methodName = logString.substring(i+1, i2);
+ methodDescriptor = logString.substring(i2, logString.length());
+
+ // Add sanity check for extracted fields
+ }
+
+ public Method getMethod() throws NoSuchMethodException, SecurityException, ClassNotFoundException, Exception {
+ try {
+ return Class.forName(className).getDeclaredMethod(methodName, getParamenterDescriptorArray());
+ } catch (UnexpectedTokenException e) {
+ throw new Exception("Parse failed");
+ }
+ }
+
+ public Class<?>[] getParamenterDescriptorArray() throws ClassNotFoundException, UnexpectedTokenException {
+ ParameterDecriptorIterator s = new ParameterDecriptorIterator(methodDescriptor);
+ Class<?> paramType;
+ ArrayList<Class<?>> list = new ArrayList<Class<?>>();
+ while ((paramType = s.nextParamType()) != null) {
+ list.add(paramType);
+ }
+ if (list.size() > 0) {
+ return list.toArray(new Class<?>[list.size()]);
+ } else {
+ return null;
+ }
+ }
+
+ class ParameterDecriptorIterator {
+
+ // This class uses charAt() indexing for startMark and i
+ // That is when i points to the last char it can be retrieved with
+ // charAt(i). Including the last char for a subString requires
+ // substring(startMark, i+1);
+
+ private String methodDescriptor;
+ private int startMark;
+
+ public ParameterDecriptorIterator(String signature) {
+ this.methodDescriptor = signature;
+ this.startMark = 0;
+ if (signature.charAt(0) == '(') {
+ this.startMark = 1;
+ }
+ }
+
+ public Class<?> nextParamType() throws UnexpectedTokenException {
+ int i = startMark;
+ while (methodDescriptor.length() > i) {
+ switch (methodDescriptor.charAt(i)) {
+ case 'C':
+ case 'B':
+ case 'I':
+ case 'J':
+ case 'Z':
+ case 'F':
+ case 'D':
+ case 'S':
+ // Primitive class case, but we may have gotten here with [ as first token
+ break;
+ case 'L':
+ // Internal class name suffixed by ';'
+ while (methodDescriptor.charAt(i) != ';') {
+ i++;
+ }
+ break;
+ case '[':
+ i++; // arrays -> do another pass
+ continue;
+ case ')':
+ return null; // end found
+ case 'V':
+ case ';':
+ default:
+ throw new UnexpectedTokenException(methodDescriptor, i);
+ }
+ break;
+ }
+ if (i == startMark) {
+ // Single char -> primitive class case
+ startMark++; // Update for next iteration
+ switch (methodDescriptor.charAt(i)) {
+ case 'C':
+ return char.class;
+ case 'B':
+ return byte.class;
+ case 'I':
+ return int.class;
+ case 'J':
+ return long.class;
+ case 'F':
+ return float.class;
+ case 'D':
+ return double.class;
+ case 'S':
+ return short.class;
+ case 'Z':
+ return boolean.class;
+ default:
+ throw new UnexpectedTokenException(methodDescriptor, i);
+ }
+ } else {
+ // Multi char case
+ String nextParam;
+ if (methodDescriptor.charAt(startMark) == 'L') {
+ // When reflecting a class the leading 'L' and trailing';' must be removed.
+ // (When reflecting an array of classes, they must remain...)
+ nextParam = methodDescriptor.substring(startMark+1, i);
+ } else {
+ // Any kind of array - simple case, use whole descriptor when reflecting.
+ nextParam = methodDescriptor.substring(startMark, i+1);
+ }
+ startMark = ++i; // Update for next iteration
+ try {
+ // The parameter descriptor uses JVM internal class identifier with '/' as
+ // package separator, but Class.forName expects '.'.
+ nextParam = nextParam.replace('/', '.');
+ return Class.forName(nextParam);
+ } catch (ClassNotFoundException e) {
+ System.out.println("Class not Found: " + nextParam);
+ return null;
+ }
+ }
+ }
+ }
+
+ class UnexpectedTokenException extends Exception {
+ String descriptor;
+ int i;
+ public UnexpectedTokenException(String descriptor, int i) {
+ this.descriptor = descriptor;
+ this.i = i;
+ }
+
+ @Override
+ public String toString() {
+ return "Unexpected token at: " + i + " in signature: " + descriptor;
+ }
+
+ private static final long serialVersionUID = 1L;
+ }
+
+ public void debugPrint() {
+ System.out.println("mlf in: " + logString);
+ System.out.println("mlf class: " + className);
+ System.out.println("mlf method: " + methodName);
+ System.out.println("mlf methodDescriptor: " + methodDescriptor);
+ }
+}
--- a/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Thu Oct 09 12:36:23 2014 -0700
+++ b/hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java Fri Oct 10 02:24:41 2014 -0700
@@ -30,6 +30,7 @@
import java.util.function.Function;
import java.util.stream.Stream;
import java.security.BasicPermission;
+
import sun.hotspot.parser.DiagnosticCommand;
public class WhiteBox {
@@ -151,6 +152,8 @@
public native void readReservedMemory();
public native long allocateMetaspace(ClassLoader classLoader, long size);
public native void freeMetaspace(ClassLoader classLoader, long addr, long size);
+ public native long incMetaspaceCapacityUntilGC(long increment);
+ public native long metaspaceCapacityUntilGC();
// force Young GC
public native void youngGC();
@@ -168,6 +171,12 @@
// CPU features
public native String getCPUFeatures();
+ // Native extensions
+ public native long getHeapUsageForContext(int context);
+ public native long getHeapRegionCountForContext(int context);
+ public native int getContextForObject(Object obj);
+ public native void printRegionInfo(int context);
+
// VM flags
public native void setBooleanVMFlag(String name, boolean value);
public native void setIntxVMFlag(String name, long value);
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/Bar.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,5 @@
+public class Bar {
+ private static void staticMethod() { }
+ public void method() { }
+ protected Bar() { }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/ClassesDirTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+
+/*
+ * @test
+ * @bug 8012447
+ * @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
+ * @build ClassFileInstaller sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main ClassesDirTest prepare
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld classes
+ * @run main ClassesDirTest check ctw.log
+ * @summary testing of CompileTheWorld :: classes in directory
+ * @author igor.ignatyev@oracle.com
+ */
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+public class ClassesDirTest extends CtwTest {
+ private static final String[] SHOULD_CONTAIN
+ = {"# dir: classes", "Done (2 classes, 6 methods, "};
+
+ private ClassesDirTest() {
+ super(SHOULD_CONTAIN);
+ }
+
+ public static void main(String[] args) throws Exception {
+ new ClassesDirTest().run(args);
+ }
+
+ protected void prepare() throws Exception {
+ String path = "classes";
+ Files.createDirectory(Paths.get(path));
+ Files.move(Paths.get("Foo.class"), Paths.get(path, "Foo.class"),
+ StandardCopyOption.REPLACE_EXISTING);
+ Files.move(Paths.get("Bar.class"), Paths.get(path, "Bar.class"),
+ StandardCopyOption.REPLACE_EXISTING);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/ClassesListTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+
+/*
+ * @test
+ * @bug 8012447
+ * @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
+ * @build ClassFileInstaller sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main ClassesListTest prepare
+ * @run main/othervm/timeout=600 -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld classes.lst
+ * @run main ClassesListTest check ctw.log
+ * @summary testing of CompileTheWorld :: list of classes in file
+ * @author igor.ignatyev@oracle.com
+ */
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+public class ClassesListTest extends CtwTest {
+ private static final String[] SHOULD_CONTAIN
+ = {"# list: classes.lst", "Done (4 classes, "};
+
+ private ClassesListTest() {
+ super(SHOULD_CONTAIN);
+ }
+
+ public static void main(String[] args) throws Exception {
+ new ClassesListTest().run(args);
+ }
+
+ protected void prepare() throws Exception {
+ String path = "classes.lst";
+ Files.copy(Paths.get(System.getProperty("test.src"), path),
+ Paths.get(path), StandardCopyOption.REPLACE_EXISTING);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/CtwTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2013, 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.util.List;
+import java.util.Collections;
+import java.util.ArrayList;
+
+import java.io.File;
+import java.io.Writer;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.BufferedReader;
+
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+import java.nio.charset.Charset;
+
+import com.oracle.java.testlibrary.JDKToolFinder;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+
+public abstract class CtwTest {
+ protected final String[] shouldContain;
+ protected CtwTest(String[] shouldContain) {
+ this.shouldContain = shouldContain;
+ }
+
+ public void run(String[] args) throws Exception {
+ if (args.length == 0) {
+ throw new Error("args is empty");
+ }
+ switch (args[0]) {
+ case "prepare":
+ prepare();
+ break;
+ case "check":
+ check(args);
+ break;
+ default:
+ throw new Error("unregonized action -- " + args[0]);
+ }
+ }
+
+ protected void prepare() throws Exception { }
+
+ protected void check(String[] args) throws Exception {
+ if (args.length < 2) {
+ throw new Error("logfile isn't specified");
+ }
+ String logfile = args[1];
+ try (BufferedReader r = Files.newBufferedReader(Paths.get(logfile),
+ Charset.defaultCharset())) {
+ OutputAnalyzer output = readOutput(r);
+ for (String test : shouldContain) {
+ output.shouldContain(test);
+ }
+ }
+ }
+
+ private static OutputAnalyzer readOutput(BufferedReader reader)
+ throws IOException {
+ StringBuilder builder = new StringBuilder();
+ String eol = String.format("%n");
+ String line;
+
+ while ((line = reader.readLine()) != null) {
+ builder.append(line);
+ builder.append(eol);
+ }
+ return new OutputAnalyzer(builder.toString(), "");
+ }
+
+ protected void dump(OutputAnalyzer output, String name) {
+ try (Writer w = new FileWriter(name + ".out")) {
+ String s = output.getStdout();
+ w.write(s, s.length(), 0);
+ } catch (IOException io) {
+ io.printStackTrace();
+ }
+ try (Writer w = new FileWriter(name + ".err")) {
+ String s = output.getStderr();
+ w.write(s, s.length(), 0);
+ } catch (IOException io) {
+ io.printStackTrace();
+ }
+ }
+
+ protected ProcessBuilder createJarProcessBuilder(String... command)
+ throws Exception {
+ String javapath = JDKToolFinder.getJDKTool("jar");
+
+ ArrayList<String> args = new ArrayList<>();
+ args.add(javapath);
+ Collections.addAll(args, command);
+
+ return new ProcessBuilder(args.toArray(new String[args.size()]));
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/Foo.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,5 @@
+public class Foo {
+ private static void staticMethod() { }
+ public void method() { }
+ protected Foo() { }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/JarDirTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+
+/*
+ * @test
+ * @bug 8012447
+ * @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
+ * @build ClassFileInstaller com.oracle.java.testlibrary.* sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main JarDirTest prepare
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld jars/*
+ * @run main JarDirTest check ctw.log
+ * @summary testing of CompileTheWorld :: jars in directory
+ * @author igor.ignatyev@oracle.com
+ */
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import com.oracle.java.testlibrary.OutputAnalyzer;
+
+public class JarDirTest extends CtwTest {
+ private static final String[] SHOULD_CONTAIN
+ = {"# jar_in_dir: jars",
+ "# jar: jars" + File.separator +"foo.jar",
+ "# jar: jars" + File.separator +"bar.jar",
+ "Done (4 classes, 12 methods, "};
+
+ private JarDirTest() {
+ super(SHOULD_CONTAIN);
+ }
+
+ public static void main(String[] args) throws Exception {
+ new JarDirTest().run(args);
+ }
+
+ protected void prepare() throws Exception {
+ String path = "jars";
+ Files.createDirectory(Paths.get(path));
+
+ ProcessBuilder pb = createJarProcessBuilder("cf", "jars/foo.jar",
+ "Foo.class", "Bar.class");
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ dump(output, "ctw-foo.jar");
+ output.shouldHaveExitValue(0);
+
+ pb = createJarProcessBuilder("cf", "jars/bar.jar", "Foo.class",
+ "Bar.class");
+ output = new OutputAnalyzer(pb.start());
+ dump(output, "ctw-bar.jar");
+ output.shouldHaveExitValue(0);
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/JarsTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2013, 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.
+ */
+
+/*
+ * @test
+ * @bug 8012447
+ * @library /testlibrary /testlibrary/whitebox /testlibrary/ctw/src
+ * @build ClassFileInstaller com.oracle.java.testlibrary.* sun.hotspot.tools.ctw.CompileTheWorld sun.hotspot.WhiteBox Foo Bar
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox Foo Bar
+ * sun.hotspot.WhiteBox$WhiteBoxPermission
+ * @run main JarsTest prepare
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Dsun.hotspot.tools.ctw.logfile=ctw.log sun.hotspot.tools.ctw.CompileTheWorld foo.jar bar.jar
+ * @run main JarsTest check ctw.log
+ * @summary testing of CompileTheWorld :: jars
+ * @author igor.ignatyev@oracle.com
+ */
+
+import com.oracle.java.testlibrary.OutputAnalyzer;
+
+public class JarsTest extends CtwTest {
+ private static final String[] SHOULD_CONTAIN
+ = {"# jar: foo.jar", "# jar: bar.jar",
+ "Done (4 classes, 12 methods, "};
+
+ private JarsTest() {
+ super(SHOULD_CONTAIN);
+ }
+
+ public static void main(String[] args) throws Exception {
+ new JarsTest().run(args);
+ }
+
+ protected void prepare() throws Exception {
+ ProcessBuilder pb = createJarProcessBuilder("cf", "foo.jar",
+ "Foo.class", "Bar.class");
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ dump(output, "ctw-foo.jar");
+ output.shouldHaveExitValue(0);
+
+ pb = createJarProcessBuilder("cf", "bar.jar", "Foo.class", "Bar.class");
+ output = new OutputAnalyzer(pb.start());
+ dump(output, "ctw-bar.jar");
+ output.shouldHaveExitValue(0);
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/testlibrary_tests/ctw/classes.lst Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,4 @@
+java.lang.String
+java.lang.Object
+Foo
+Bar
--- a/jaxp/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/jaxp/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
d181d4002214e4914d5525bd5ee13369311c765c jdk9-b30
292317ebc7dbaca6b3965f0bc7b38a2cee733b7a jdk9-b31
b940ca3d2c7e8a279ca850706b89c2ad3a841e82 jdk9-b32
+46b360454dadbb329d42c59bb8192daeb9d59875 jdk9-b33
+6b343b9b7a7008f5f699a2d99881163cab7a2986 jdk9-b34
--- a/jaxws/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/jaxws/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -278,3 +278,5 @@
e58d3ea638c3824f01547596b2a98aa5f77c4a5c jdk9-b30
7af228ae847f3c02aaafb7b01cdbb3bdc2e89e77 jdk9-b31
838a2f693e51b869e7bc26a20afffdde1300394e jdk9-b32
+77a45995dd3b6e57805475ae3111ac6f7db7749e jdk9-b33
+28ea43d925f1e5250976097a2977dd3e66e11f0b jdk9-b34
--- a/jdk/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
8d24fb4493f13d380a2adf62d444e1e5a4451f37 jdk9-b30
71e99dae28f9791287b88d46e16a266b564f22be jdk9-b31
8bdf7083b5bd02aa330ba622895e586dd3378d37 jdk9-b32
+60fe681c30bc3821545a2506d4d3c2e04073f67c jdk9-b33
+21568031434d7a9dbb0cc6516cc3183d349c2253 jdk9-b34
--- a/jdk/src/java.base/share/classes/java/nio/X-Buffer.java.template Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/X-Buffer.java.template Fri Oct 10 02:24:41 2014 -0700
@@ -384,7 +384,7 @@
* and vice versa. The new buffer's capacity and limit will be
* <tt>array.length</tt>, its position will be zero, and its mark will be
* undefined. Its {@link #array backing array} will be the
- * given array, and its {@link #arrayOffset array offset>} will
+ * given array, and its {@link #arrayOffset array offset} will
* be zero. </p>
*
* @param array
--- a/jdk/src/java.base/share/classes/java/nio/file/FileStore.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/file/FileStore.java Fri Oct 10 02:24:41 2014 -0700
@@ -208,7 +208,7 @@
* @param attribute
* the attribute to read
- * @return the attribute value; {@code null} may be a valid valid for some
+ * @return the attribute value; {@code null} may be a valid for some
* attributes
*
* @throws UnsupportedOperationException
--- a/jdk/src/java.base/share/classes/java/nio/file/Files.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/file/Files.java Fri Oct 10 02:24:41 2014 -0700
@@ -1480,7 +1480,7 @@
* <li>It is <i>transitive</i>: for three {@code Paths}
* {@code f}, {@code g}, and {@code h}, if {@code isSameFile(f,g)} returns
* {@code true} and {@code isSameFile(g,h)} returns {@code true}, then
- * {@code isSameFile(f,h)} will return return {@code true}.
+ * {@code isSameFile(f,h)} will return {@code true}.
* </ul>
*
* @param path
@@ -2818,7 +2818,7 @@
/**
* Opens or creates a file for writing, returning a {@code BufferedWriter}
* that may be used to write text to the file in an efficient manner.
- * The {@code options} parameter specifies how the the file is created or
+ * The {@code options} parameter specifies how the file is created or
* opened. If no options are present then this method works as if the {@link
* StandardOpenOption#CREATE CREATE}, {@link
* StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
@@ -3307,7 +3307,7 @@
* line.separator}. Characters are encoded into bytes using the specified
* charset.
*
- * <p> The {@code options} parameter specifies how the the file is created
+ * <p> The {@code options} parameter specifies how the file is created
* or opened. If no options are present then this method works as if the
* {@link StandardOpenOption#CREATE CREATE}, {@link
* StandardOpenOption#TRUNCATE_EXISTING TRUNCATE_EXISTING}, and {@link
--- a/jdk/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/file/SecureDirectoryStream.java Fri Oct 10 02:24:41 2014 -0700
@@ -115,7 +115,7 @@
* channel.
*
* @param path
- * the path of the file to open open or create
+ * the path of the file to open or create
* @param options
* options specifying how the file is opened
* @param attrs
--- a/jdk/src/java.base/share/classes/java/nio/file/TempFileHelper.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/file/TempFileHelper.java Fri Oct 10 02:24:41 2014 -0700
@@ -74,7 +74,7 @@
}
/**
- * Creates a file or directory in in the given given directory (or in the
+ * Creates a file or directory in the given directory (or in the
* temporary directory if dir is {@code null}).
*/
private static Path create(Path dir,
@@ -149,7 +149,7 @@
}
/**
- * Creates a temporary file in the given directory, or in in the
+ * Creates a temporary file in the given directory, or in the
* temporary directory if dir is {@code null}.
*/
static Path createTempFile(Path dir,
@@ -162,7 +162,7 @@
}
/**
- * Creates a temporary directory in the given directory, or in in the
+ * Creates a temporary directory in the given directory, or in the
* temporary directory if dir is {@code null}.
*/
static Path createTempDirectory(Path dir,
--- a/jdk/src/java.base/share/classes/java/nio/file/attribute/package-info.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/nio/file/attribute/package-info.java Fri Oct 10 02:24:41 2014 -0700
@@ -51,7 +51,7 @@
* <p> An attribute view provides a read-only or updatable view of the non-opaque
* values, or <em>metadata</em>, associated with objects in a file system.
* The {@link java.nio.file.attribute.FileAttributeView} interface is
- * extended by several other interfaces that that views to specific sets of file
+ * extended by several other interfaces that views to specific sets of file
* attributes. {@code FileAttributeViews} are selected by invoking the {@link
* java.nio.file.Files#getFileAttributeView} method with a
* <em>type-token</em> to identify the required view. Views can also be identified
--- a/jdk/src/java.base/share/classes/java/security/Key.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/Key.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -63,7 +63,7 @@
* </pre>
*
* For more information, see
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280:
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280:
* Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a>.
*
* <LI>A Format
--- a/jdk/src/java.base/share/classes/java/security/cert/CRLReason.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/CRLReason.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 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
@@ -27,8 +27,8 @@
/**
* The CRLReason enumeration specifies the reason that a certificate
- * is revoked, as defined in <a href="http://www.ietf.org/rfc/rfc3280.txt">
- * RFC 3280: Internet X.509 Public Key Infrastructure Certificate and CRL
+ * is revoked, as defined in <a href="http://tools.ietf.org/html/rfc5280">
+ * RFC 5280: Internet X.509 Public Key Infrastructure Certificate and CRL
* Profile</a>.
*
* @author Sean Mullan
--- a/jdk/src/java.base/share/classes/java/security/cert/PKIXReason.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/PKIXReason.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 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
@@ -28,7 +28,7 @@
/**
* The {@code PKIXReason} enumerates the potential PKIX-specific reasons
* that an X.509 certification path may be invalid according to the PKIX
- * (RFC 3280) standard. These reasons are in addition to those of the
+ * (RFC 5280) standard. These reasons are in addition to those of the
* {@code CertPathValidatorException.BasicReason} enumeration.
*
* @since 1.7
--- a/jdk/src/java.base/share/classes/java/security/cert/TrustAnchor.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/TrustAnchor.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 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
@@ -78,7 +78,7 @@
* The name constraints are specified as a byte array. This byte array
* should contain the DER encoded form of the name constraints, as they
* would appear in the NameConstraints structure defined in
- * <a href="http://www.ietf.org/rfc/rfc3280">RFC 3280</a>
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280</a>
* and X.509. The ASN.1 definition of this structure appears below.
*
* <pre>{@code
@@ -140,7 +140,7 @@
* <p>
* The name constraints are specified as a byte array. This byte array
* contains the DER encoded form of the name constraints, as they
- * would appear in the NameConstraints structure defined in RFC 3280
+ * would appear in the NameConstraints structure defined in RFC 5280
* and X.509. The ASN.1 notation for this structure is supplied in the
* documentation for
* {@link #TrustAnchor(X509Certificate, byte[])
@@ -179,7 +179,7 @@
* <p>
* The name constraints are specified as a byte array. This byte array
* contains the DER encoded form of the name constraints, as they
- * would appear in the NameConstraints structure defined in RFC 3280
+ * would appear in the NameConstraints structure defined in RFC 5280
* and X.509. The ASN.1 notation for this structure is supplied in the
* documentation for
* {@link #TrustAnchor(X509Certificate, byte[])
@@ -294,7 +294,7 @@
* <p>
* The name constraints are returned as a byte array. This byte array
* contains the DER encoded form of the name constraints, as they
- * would appear in the NameConstraints structure defined in RFC 3280
+ * would appear in the NameConstraints structure defined in RFC 5280
* and X.509. The ASN.1 notation for this structure is supplied in the
* documentation for
* {@link #TrustAnchor(X509Certificate, byte[])
--- a/jdk/src/java.base/share/classes/java/security/cert/X509CRL.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/X509CRL.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -69,7 +69,7 @@
* </pre>
* <p>
* More information can be found in
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280: Internet X.509
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280: Internet X.509
* Public Key Infrastructure Certificate and CRL Profile</a>.
* <p>
* The ASN.1 definition of {@code tbsCertList} is:
--- a/jdk/src/java.base/share/classes/java/security/cert/X509CRLSelector.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/X509CRLSelector.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -52,7 +52,7 @@
* {@link CertStore#getCRLs CertStore.getCRLs} or some similar
* method.
* <p>
- * Please refer to <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280:
+ * Please refer to <a href="http://tools.ietf.org/html/rfc5280">RFC 5280:
* Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a>
* for definitions of the X.509 CRL fields and extensions mentioned below.
* <p>
--- a/jdk/src/java.base/share/classes/java/security/cert/X509CertSelector.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/X509CertSelector.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -65,7 +65,7 @@
* number. Other unique combinations include the issuer, subject,
* subjectKeyIdentifier and/or the subjectPublicKey criteria.
* <p>
- * Please refer to <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280:
+ * Please refer to <a href="http://tools.ietf.org/html/rfc5280">RFC 5280:
* Internet X.509 Public Key Infrastructure Certificate and CRL Profile</a> for
* definitions of the X.509 certificate extensions mentioned below.
* <p>
@@ -728,7 +728,7 @@
* The name is provided in string format.
* <a href="http://www.ietf.org/rfc/rfc822.txt">RFC 822</a>, DNS, and URI
* names use the well-established string formats for those types (subject to
- * the restrictions included in RFC 3280). IPv4 address names are
+ * the restrictions included in RFC 5280). IPv4 address names are
* supplied using dotted quad notation. OID address names are represented
* as a series of nonnegative integers separated by periods. And
* directory names (distinguished names) are supplied in RFC 2253 format.
@@ -746,7 +746,7 @@
* String form of some distinguished names.
*
* @param type the name type (0-8, as specified in
- * RFC 3280, section 4.2.1.7)
+ * RFC 5280, section 4.2.1.6)
* @param name the name in string form (not {@code null})
* @throws IOException if a parsing error occurs
*/
@@ -770,7 +770,7 @@
* <p>
* The name is provided as a byte array. This byte array should contain
* the DER encoded name, as it would appear in the GeneralName structure
- * defined in RFC 3280 and X.509. The encoded byte array should only contain
+ * defined in RFC 5280 and X.509. The encoded byte array should only contain
* the encoded value of the name, and should not include the tag associated
* with the name in the GeneralName structure. The ASN.1 definition of this
* structure appears below.
@@ -806,7 +806,7 @@
* must contain the specified subjectAlternativeName.
*
* @param type the name type (0-8, as specified in
- * RFC 3280, section 4.2.1.7)
+ * RFC 5280, section 4.2.1.6)
* @param name the name in string or byte array form
* @throws IOException if a parsing error occurs
*/
@@ -995,7 +995,7 @@
* <p>
* The name constraints are specified as a byte array. This byte array
* should contain the DER encoded form of the name constraints, as they
- * would appear in the NameConstraints structure defined in RFC 3280
+ * would appear in the NameConstraints structure defined in RFC 5280
* and X.509. The ASN.1 definition of this structure appears below.
*
* <pre>{@code
@@ -1197,7 +1197,7 @@
* <p>
* The name is provided in string format. RFC 822, DNS, and URI names
* use the well-established string formats for those types (subject to
- * the restrictions included in RFC 3280). IPv4 address names are
+ * the restrictions included in RFC 5280). IPv4 address names are
* supplied using dotted quad notation. OID address names are represented
* as a series of nonnegative integers separated by periods. And
* directory names (distinguished names) are supplied in RFC 2253 format.
@@ -1214,7 +1214,7 @@
* String form of some distinguished names.
*
* @param type the name type (0-8, as specified in
- * RFC 3280, section 4.2.1.7)
+ * RFC 5280, section 4.2.1.6)
* @param name the name in string form
* @throws IOException if a parsing error occurs
*/
@@ -1234,7 +1234,7 @@
* <p>
* The name is provided as a byte array. This byte array should contain
* the DER encoded name, as it would appear in the GeneralName structure
- * defined in RFC 3280 and X.509. The ASN.1 definition of this structure
+ * defined in RFC 5280 and X.509. The ASN.1 definition of this structure
* appears in the documentation for
* {@link #addSubjectAlternativeName(int type, byte [] name)
* addSubjectAlternativeName(int type, byte [] name)}.
@@ -1243,7 +1243,7 @@
* subsequent modifications.
*
* @param type the name type (0-8, as specified in
- * RFC 3280, section 4.2.1.7)
+ * RFC 5280, section 4.2.1.6)
* @param name a byte array containing the name in ASN.1 DER encoded form
* @throws IOException if a parsing error occurs
*/
@@ -1258,7 +1258,7 @@
* the specified pathToName.
*
* @param type the name type (0-8, as specified in
- * RFC 3280, section 4.2.1.7)
+ * RFC 5280, section 4.2.1.6)
* @param name the name in string or byte array form
* @throws IOException if an encoding error occurs (incorrect form for DN)
*/
@@ -1715,7 +1715,7 @@
* <p>
* The name constraints are returned as a byte array. This byte array
* contains the DER encoded form of the name constraints, as they
- * would appear in the NameConstraints structure defined in RFC 3280
+ * would appear in the NameConstraints structure defined in RFC 5280
* and X.509. The ASN.1 notation for this structure is supplied in the
* documentation for
* {@link #setNameConstraints(byte [] bytes) setNameConstraints(byte [] bytes)}.
--- a/jdk/src/java.base/share/classes/java/security/cert/X509Certificate.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/security/cert/X509Certificate.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -63,7 +63,7 @@
* CA such as a "root" CA.
* <p>
* More information can be found in
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280: Internet X.509
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280: Internet X.509
* Public Key Infrastructure Certificate and CRL Profile</a>.
* <p>
* The ASN.1 definition of {@code tbsCertificate} is:
@@ -408,7 +408,7 @@
* Gets the {@code issuerUniqueID} value from the certificate.
* The issuer unique identifier is present in the certificate
* to handle the possibility of reuse of issuer names over time.
- * RFC 3280 recommends that names not be reused and that
+ * RFC 5280 recommends that names not be reused and that
* conforming certificates not make use of unique identifiers.
* Applications conforming to that profile should be capable of
* parsing unique identifiers and making comparisons.
@@ -459,7 +459,7 @@
* encipherOnly (7),
* decipherOnly (8) }
* </pre>
- * RFC 3280 recommends that when used, this be marked
+ * RFC 5280 recommends that when used, this be marked
* as a critical extension.
*
* @return the KeyUsage extension of this certificate, represented as
@@ -572,7 +572,7 @@
* <a href="http://www.ietf.org/rfc/rfc822.txt">RFC 822</a>, DNS, and URI
* names are returned as {@code String}s,
* using the well-established string formats for those types (subject to
- * the restrictions included in RFC 3280). IPv4 address names are
+ * the restrictions included in RFC 5280). IPv4 address names are
* returned using dotted quad notation. IPv6 address names are returned
* in the form "a1:a2:...:a8", where a1-a8 are hexadecimal values
* representing the eight 16-bit pieces of the address. OID names are
--- a/jdk/src/java.base/share/classes/java/util/jar/Pack200.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/java/util/jar/Pack200.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -93,8 +93,7 @@
* The deployment applications can use "Accept-Encoding=pack200-gzip". This
* indicates to the server that the client application desires a version of
* the file encoded with Pack200 and further compressed with gzip. Please
- * refer to <a href="{@docRoot}/../technotes/guides/deployment/deployment-guide/pack200.html">Java Deployment Guide</a> for more details and
- * techniques.
+ * refer to the Java Deployment Guide for techniques and details.
* <p>
* Unless otherwise noted, passing a <tt>null</tt> argument to a constructor or
* method in this class will cause a {@link NullPointerException} to be thrown.
--- a/jdk/src/java.base/share/classes/javax/security/auth/x500/X500Principal.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/javax/security/auth/x500/X500Principal.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -41,13 +41,13 @@
* of the distinguished name, or by using the ASN.1 DER encoded byte
* representation of the distinguished name. The current specification
* for the string representation of a distinguished name is defined in
- * <a href="http://www.ietf.org/rfc/rfc2253.txt">RFC 2253: Lightweight
+ * <a href="http://tools.ietf.org/html/rfc2253">RFC 2253: Lightweight
* Directory Access Protocol (v3): UTF-8 String Representation of
* Distinguished Names</a>. This class, however, accepts string formats from
- * both RFC 2253 and <a href="http://www.ietf.org/rfc/rfc1779.txt">RFC 1779:
+ * both RFC 2253 and <a href="http://tools.ietf.org/html/rfc1779">RFC 1779:
* A String Representation of Distinguished Names</a>, and also recognizes
* attribute type keywords whose OIDs (Object Identifiers) are defined in
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280: Internet X.509
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280: Internet X.509
* Public Key Infrastructure Certificate and CRL Profile</a>.
*
* <p> The string representation for this {@code X500Principal}
@@ -108,7 +108,7 @@
* (and listed in {@link #getName(String format) getName(String format)}),
* as well as the T, DNQ or DNQUALIFIER, SURNAME, GIVENNAME, INITIALS,
* GENERATION, EMAILADDRESS, and SERIALNUMBER keywords whose Object
- * Identifiers (OIDs) are defined in RFC 3280 and its successor.
+ * Identifiers (OIDs) are defined in RFC 5280.
* Any other attribute type must be specified as an OID.
*
* <p>This implementation enforces a more restrictive OID syntax than
@@ -456,7 +456,7 @@
* (obtained via the {@code getName(X500Principal.CANONICAL)} method)
* of this object and <i>o</i> are equal.
*
- * <p> This implementation is compliant with the requirements of RFC 3280.
+ * <p> This implementation is compliant with the requirements of RFC 5280.
*
* @param o Object to be compared for equality with this
* {@code X500Principal}
--- a/jdk/src/java.base/share/classes/javax/security/auth/x500/package-info.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/javax/security/auth/x500/package-info.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -31,15 +31,15 @@
* <h2>Package Specification</h2>
*
* <ul>
- * <li><a href="http://www.ietf.org/rfc/rfc1779.txt">
+ * <li><a href="http://tools.ietf.org/html/rfc1779">
* RFC 1779: A String Representation of Distinguished Names</a></li>
- * <li><a href="http://www.ietf.org/rfc/rfc2253.txt">
+ * <li><a href="http://tools.ietf.org/html/rfc2253">
* RFC 2253: Lightweight Directory Access Protocol (v3):
* UTF-8 String Representation of Distinguished Names</a></li>
- * <li><a href="http://www.ietf.org/rfc/rfc3280.txt">
- * RFC 3280: Internet X.509 Public Key Infrastructure
+ * <li><a href="http://tools.ietf.org/html/rfc5280">
+ * RFC 5280: Internet X.509 Public Key Infrastructure
* Certificate and Certificate Revocation List (CRL) Profile</a></li>
- * <li><a href="http://www.ietf.org/rfc/rfc4512.txt">
+ * <li><a href="http://tools.ietf.org/html/rfc4512">
* RFC 4512: Lightweight Directory Access Protocol (LDAP):
* Directory Information Models</a></li>
* </ul>
--- a/jdk/src/java.base/share/classes/sun/security/provider/SunEntries.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/SunEntries.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -64,7 +64,7 @@
* and CRLs. Aliases for X.509 are X509.
*
* - PKIX is the certification path validation algorithm described
- * in RFC 3280. The ValidationAlgorithm attribute notes the
+ * in RFC 5280. The ValidationAlgorithm attribute notes the
* specification that this provider implements.
*
* - LDAP is the CertStore type for LDAP repositories. The
@@ -250,7 +250,7 @@
map.put("CertPathBuilder.PKIX",
"sun.security.provider.certpath.SunCertPathBuilder");
map.put("CertPathBuilder.PKIX ValidationAlgorithm",
- "RFC3280");
+ "RFC5280");
/*
* CertPathValidator
@@ -258,7 +258,7 @@
map.put("CertPathValidator.PKIX",
"sun.security.provider.certpath.PKIXCertPathValidator");
map.put("CertPathValidator.PKIX ValidationAlgorithm",
- "RFC3280");
+ "RFC5280");
/*
* CertStores
--- a/jdk/src/java.base/share/classes/sun/security/provider/certpath/DistributionPointFetcher.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/certpath/DistributionPointFetcher.java Fri Oct 10 02:24:41 2014 -0700
@@ -434,7 +434,7 @@
}
if (indirectCRL) {
if (pointCrlIssuers.size() != 1) {
- // RFC 3280: there must be only 1 CRL issuer
+ // RFC 5280: there must be only 1 CRL issuer
// name when relativeName is present
if (debug != null) {
debug.println("must only be one CRL " +
--- a/jdk/src/java.base/share/classes/sun/security/provider/certpath/PolicyChecker.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/certpath/PolicyChecker.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -578,7 +578,7 @@
}
/**
- * Rewrite leaf nodes at the end of validation as described in RFC 3280
+ * Rewrite leaf nodes at the end of validation as described in RFC 5280
* section 6.1.5: Step (g)(iii). Leaf nodes with anyPolicy are replaced
* by nodes explicitly representing initial policies not already
* represented by leaf nodes.
--- a/jdk/src/java.base/share/classes/sun/security/provider/certpath/PolicyNodeImpl.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/certpath/PolicyNodeImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -56,7 +56,7 @@
private PolicyNodeImpl mParent;
private HashSet<PolicyNodeImpl> mChildren;
- // the 4 fields specified by RFC 3280
+ // the 4 fields specified by RFC 5280
private String mValidPolicy;
private HashSet<PolicyQualifierInfo> mQualifierSet;
private boolean mCriticalityIndicator;
--- a/jdk/src/java.base/share/classes/sun/security/provider/certpath/RevocationChecker.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/certpath/RevocationChecker.java Fri Oct 10 02:24:41 2014 -0700
@@ -472,9 +472,9 @@
" ---checking revocation status ...");
}
- // reject circular dependencies - RFC 3280 is not explicit on how
- // to handle this, so we feel it is safest to reject them until
- // the issue is resolved in the PKIX WG.
+ // Reject circular dependencies - RFC 5280 is not explicit on how
+ // to handle this, but does suggest that they can be a security
+ // risk and can create unresolvable dependencies
if (stackedCerts != null && stackedCerts.contains(cert)) {
if (debug != null) {
debug.println("RevocationChecker.checkCRLs()" +
@@ -628,7 +628,7 @@
/*
* Abort CRL validation and throw exception if there are any
* unrecognized critical CRL entry extensions (see section
- * 5.3 of RFC 3280).
+ * 5.3 of RFC 5280).
*/
Set<String> unresCritExts = entry.getCriticalExtensionOIDs();
if (unresCritExts != null && !unresCritExts.isEmpty()) {
@@ -880,9 +880,9 @@
" ---checking " + msg + "...");
}
- // reject circular dependencies - RFC 3280 is not explicit on how
- // to handle this, so we feel it is safest to reject them until
- // the issue is resolved in the PKIX WG.
+ // Reject circular dependencies - RFC 5280 is not explicit on how
+ // to handle this, but does suggest that they can be a security
+ // risk and can create unresolvable dependencies
if ((stackedCerts != null) && stackedCerts.contains(cert)) {
if (debug != null) {
debug.println(
--- a/jdk/src/java.base/share/classes/sun/security/provider/certpath/SunCertPathBuilder.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/provider/certpath/SunCertPathBuilder.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -53,7 +53,7 @@
* <p> If successful, it returns a certification path which has successfully
* satisfied all the constraints and requirements specified in the
* PKIXBuilderParameters object and has been validated according to the PKIX
- * path validation algorithm defined in RFC 3280.
+ * path validation algorithm defined in RFC 5280.
*
* <p> This implementation uses a depth-first search approach to finding
* certification paths. If it comes to a point in which it cannot find
--- a/jdk/src/java.base/share/classes/sun/security/util/DerInputBuffer.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/util/DerInputBuffer.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -285,7 +285,7 @@
* YYMMDDhhmmss-hhmm
* UTC Time is broken in storing only two digits of year.
* If YY < 50, we assume 20YY;
- * if YY >= 50, we assume 19YY, as per RFC 3280.
+ * if YY >= 50, we assume 19YY, as per RFC 5280.
*
* Generalized time has a four-digit year and allows any
* precision specified in ISO 8601. However, for our purposes,
--- a/jdk/src/java.base/share/classes/sun/security/util/DerOutputStream.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/util/DerOutputStream.java Fri Oct 10 02:24:41 2014 -0700
@@ -461,7 +461,7 @@
* Marshals a DER UTC time/date value.
*
* <P>YYMMDDhhmmss{Z|+hhmm|-hhmm} ... emits only using Zulu time
- * and with seconds (even if seconds=0) as per RFC 3280.
+ * and with seconds (even if seconds=0) as per RFC 5280.
*/
public void putUTCTime(Date d) throws IOException {
putTime(d, DerValue.tag_UtcTime);
@@ -471,7 +471,7 @@
* Marshals a DER Generalized Time/date value.
*
* <P>YYYYMMDDhhmmss{Z|+hhmm|-hhmm} ... emits only using Zulu time
- * and with seconds (even if seconds=0) as per RFC 3280.
+ * and with seconds (even if seconds=0) as per RFC 5280.
*/
public void putGeneralizedTime(Date d) throws IOException {
putTime(d, DerValue.tag_GeneralizedTime);
--- a/jdk/src/java.base/share/classes/sun/security/util/DerValue.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/util/DerValue.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -45,8 +45,8 @@
* (such as PKCS #10 certificate requests, and some kinds of PKCS #7 data).
*
* A note with respect to T61/Teletex strings: From RFC 1617, section 4.1.3
- * and RFC 3280, section 4.1.2.4., we assume that this kind of string will
- * contain ISO-8859-1 characters only.
+ * and RFC 5280, section 8, we assume that this kind of string will contain
+ * ISO-8859-1 characters only.
*
*
* @author David Brownell
--- a/jdk/src/java.base/share/classes/sun/security/x509/AuthorityInfoAccessExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/AuthorityInfoAccessExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2004, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2004, 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
@@ -43,7 +43,7 @@
* certificate that identifies the specific OCSP Responder to use when
* performing on-line validation of that certificate.
* <p>
- * This extension is defined in <a href="http://www.ietf.org/rfc/rfc3280.txt">
+ * This extension is defined in <a href="http://tools.ietf.org/html/rfc5280">
* Internet X.509 PKI Certificate and Certificate Revocation List
* (CRL) Profile</a>. The profile permits
* the extension to be included in end-entity or CA certificates,
--- a/jdk/src/java.base/share/classes/sun/security/x509/CertificateIssuerExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/CertificateIssuerExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -44,7 +44,7 @@
* <p>
* If used by conforming CRL issuers, this extension is always
* critical. If an implementation ignored this extension it could not
- * correctly attribute CRL entries to certificates. PKIX (RFC 3280)
+ * correctly attribute CRL entries to certificates. PKIX (RFC 5280)
* RECOMMENDS that implementations recognize this extension.
* <p>
* The ASN.1 definition for this is:
--- a/jdk/src/java.base/share/classes/sun/security/x509/DeltaCRLIndicatorExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/DeltaCRLIndicatorExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -45,7 +45,7 @@
*
* <p>
* The extension is defined in Section 5.2.4 of
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">Internet X.509 PKI Certific
+ * <a href="http://tools.ietf.org/html/rfc5280">Internet X.509 PKI Certific
ate and Certificate Revocation List (CRL) Profile</a>.
*
* <p>
--- a/jdk/src/java.base/share/classes/sun/security/x509/ExtendedKeyUsageExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/ExtendedKeyUsageExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 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
@@ -94,7 +94,7 @@
public static final String NAME = "ExtendedKeyUsage";
public static final String USAGES = "usages";
- // OID defined in RFC 3280 Sections 4.2.1.13
+ // OID defined in RFC 5280 Sections 4.2.1.12
// more from http://www.alvestrand.no/objectid/1.3.6.1.5.5.7.3.html
private static final Map <ObjectIdentifier, String> map =
new HashMap <ObjectIdentifier, String> ();
--- a/jdk/src/java.base/share/classes/sun/security/x509/FreshestCRLExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/FreshestCRLExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -42,7 +42,7 @@
*
* <p>
* The extension is defined in Section 5.2.6 of
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">Internet X.509 PKI Certific
+ * <a href="http://tools.ietf.org/html/rfc5280">Internet X.509 PKI Certific
ate and Certificate Revocation List (CRL) Profile</a>.
*
* <p>
--- a/jdk/src/java.base/share/classes/sun/security/x509/InvalidityDateExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/InvalidityDateExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 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
@@ -33,7 +33,7 @@
import sun.security.util.*;
/**
- * From RFC 3280:
+ * From RFC 5280:
* <p>
* The invalidity date is a non-critical CRL entry extension that
* provides the date on which it is known or suspected that the private
--- a/jdk/src/java.base/share/classes/sun/security/x509/IssuingDistributionPointExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/IssuingDistributionPointExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -46,7 +46,7 @@
*
* <p>
* The extension is defined in Section 5.2.5 of
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">Internet X.509 PKI Certific
+ * <a href="http://tools.ietf.org/html/rfc5280">Internet X.509 PKI Certific
ate and Certificate Revocation List (CRL) Profile</a>.
*
* <p>
--- a/jdk/src/java.base/share/classes/sun/security/x509/RDN.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/RDN.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2002, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2002, 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
@@ -341,7 +341,7 @@
/*
* Returns a printable form of this RDN, using RFC 1779 style catenation
* of attribute/value assertions, and emitting attribute type keywords
- * from RFCs 1779, 2253, and 3280.
+ * from RFCs 1779, 2253, and 5280.
*/
public String toString() {
if (assertion.length == 1) {
--- a/jdk/src/java.base/share/classes/sun/security/x509/README Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/README Fri Oct 10 02:24:41 2014 -0700
@@ -34,7 +34,7 @@
Protocol (LDAP) that many organizations are expecting will help
address online certificate distribution over the Internet.
- RFC 3280, which describes the Internet X.509 Public Key
+ RFC 5280, which describes the Internet X.509 Public Key
Infrastructure Certificate and CRL Profile.
RSA DSI has a bunch of "Public Key Cryptography Standards" (PKCS) which
--- a/jdk/src/java.base/share/classes/sun/security/x509/SubjectInfoAccessExtension.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/SubjectInfoAccessExtension.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 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
@@ -47,7 +47,7 @@
* included in end entity or CA certificates. Conforming CAs MUST mark
* this extension as non-critical.
* <p>
- * This extension is defined in <a href="http://www.ietf.org/rfc/rfc3280.txt">
+ * This extension is defined in <a href="http://tools.ietf.org/html/rfc5280">
* Internet X.509 PKI Certificate and Certificate Revocation List
* (CRL) Profile</a>. The profile permits
* the extension to be included in end-entity or CA certificates,
--- a/jdk/src/java.base/share/classes/sun/security/x509/URIName.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/URIName.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -35,15 +35,15 @@
* This class implements the URIName as required by the GeneralNames
* ASN.1 object.
* <p>
- * [RFC3280] When the subjectAltName extension contains a URI, the name MUST be
+ * [RFC5280] When the subjectAltName extension contains a URI, the name MUST be
* stored in the uniformResourceIdentifier (an IA5String). The name MUST
* be a non-relative URL, and MUST follow the URL syntax and encoding
- * rules specified in [RFC 1738]. The name must include both a scheme
+ * rules specified in [RFC 3986]. The name must include both a scheme
* (e.g., "http" or "ftp") and a scheme-specific-part. The scheme-
* specific-part must include a fully qualified domain name or IP
* address as the host.
* <p>
- * As specified in [RFC 1738], the scheme name is not case-sensitive
+ * As specified in [RFC 3986], the scheme name is not case-sensitive
* (e.g., "http" is equivalent to "HTTP"). The host part is also not
* case-sensitive, but other components of the scheme-specific-part may
* be case-sensitive. When comparing URIs, conforming implementations
@@ -113,7 +113,7 @@
}
host = uri.getHost();
- // RFC 3280 says that the host should be non-null, but we allow it to
+ // RFC 5280 says that the host should be non-null, but we allow it to
// be null because some widely deployed certificates contain CDP
// extensions with URIs that have no hostname (see bugs 4802236 and
// 5107944).
@@ -148,7 +148,7 @@
/**
* Create the URIName object with the specified name constraint. URI
* name constraints syntax is different than SubjectAltNames, etc. See
- * 4.2.1.11 of RFC 3280.
+ * 4.2.1.10 of RFC 5280.
*
* @param value the URI name constraint
* @throws IOException if name is not a proper URI name constraint
@@ -300,7 +300,7 @@
* These results are used in checking NameConstraints during
* certification path verification.
* <p>
- * RFC3280: For URIs, the constraint applies to the host part of the name.
+ * RFC5280: For URIs, the constraint applies to the host part of the name.
* The constraint may specify a host or a domain. Examples would be
* "foo.bar.com"; and ".xyz.com". When the the constraint begins with
* a period, it may be expanded with one or more subdomains. That is,
--- a/jdk/src/java.base/share/classes/sun/security/x509/X500Name.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/X500Name.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1996, 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
@@ -605,7 +605,7 @@
* Returns a string form of the X.500 distinguished name.
* The format of the string is from RFC 1779. The returned string
* may contain non-standardised keywords for more readability
- * (keywords from RFCs 1779, 2253, and 3280).
+ * (keywords from RFCs 1779, 2253, and 5280).
*/
public String toString() {
if (dn == null) {
@@ -866,7 +866,7 @@
* O="Sue, Grabbit and Runn" or
* O=Sue\, Grabbit and Runn
*
- * This method can parse RFC 1779, 2253 or 4514 DNs and non-standard 3280
+ * This method can parse RFC 1779, 2253 or 4514 DNs and non-standard 5280
* keywords. Additional keywords can be specified in the keyword/OID map.
*/
private void parseDN(String input, Map<String, String> keywordMap)
@@ -1122,7 +1122,7 @@
/*
* Selected OIDs from X.520
- * Includes all those specified in RFC 3280 as MUST or SHOULD
+ * Includes all those specified in RFC 5280 as MUST or SHOULD
* be recognized
*/
private static final int commonName_data[] = { 2, 5, 4, 3 };
@@ -1220,7 +1220,7 @@
ipAddress_oid = intern(ObjectIdentifier.newInternal(ipAddress_data));
/*
- * Domain component OID from RFC 1274, RFC 2247, RFC 3280
+ * Domain component OID from RFC 1274, RFC 2247, RFC 5280
*/
/*
--- a/jdk/src/java.base/share/classes/sun/security/x509/X509CRLImpl.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/X509CRLImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -63,7 +63,7 @@
* signature BIT STRING }
* </pre>
* More information can be found in
- * <a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280: Internet X.509
+ * <a href="http://tools.ietf.org/html/rfc5280">RFC 5280: Internet X.509
* Public Key Infrastructure Certificate and CRL Profile</a>.
* <p>
* The ASN.1 definition of <code>tbsCertList</code> is:
--- a/jdk/src/java.base/share/classes/sun/security/x509/X509CertInfo.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/classes/sun/security/x509/X509CertInfo.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 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
@@ -708,7 +708,7 @@
}
/*
- * Verify if X.509 V3 Certificate is compliant with RFC 3280.
+ * Verify if X.509 V3 Certificate is compliant with RFC 5280.
*/
private void verifyCert(X500Name subject,
CertificateExtensions extensions)
--- a/jdk/src/java.base/share/conf/security/java.security Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.base/share/conf/security/java.security Fri Oct 10 02:24:41 2014 -0700
@@ -345,7 +345,7 @@
# By default, the location of the OCSP responder is determined implicitly
# from the certificate being validated. This property explicitly specifies
# the location of the OCSP responder. The property is used when the
-# Authority Information Access extension (defined in RFC 3280) is absent
+# Authority Information Access extension (defined in RFC 5280) is absent
# from the certificate or when it requires overriding.
#
# Example,
--- a/jdk/src/java.logging/share/classes/java/util/logging/Logger.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.logging/share/classes/java/util/logging/Logger.java Fri Oct 10 02:24:41 2014 -0700
@@ -1376,8 +1376,12 @@
return;
}
if (!isLoggable(Level.FINER)) return;
- for (int i = 0; i < params.length; i++) {
- msg = msg + " {" + i + "}";
+ if (params.length > 0) {
+ final StringBuilder b = new StringBuilder(msg);
+ for (int i = 0; i < params.length; i++) {
+ b.append(' ').append('{').append(i).append('}');
+ }
+ msg = b.toString();
}
logp(Level.FINER, sourceClass, sourceMethod, msg, params);
}
--- a/jdk/src/java.sql.rowset/share/classes/javax/sql/rowset/WebRowSet.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/java.sql.rowset/share/classes/javax/sql/rowset/WebRowSet.java Fri Oct 10 02:24:41 2014 -0700
@@ -56,7 +56,7 @@
* organization. The SQL/XML definition is available at the following URI:
* <ul>
* <li>
- * <a href="http://standards.iso.org/iso/9075/2002/12/sqlxml">http://standards.iso.org/iso/9075/2002/12/sqlxml</a>
+ * <a href="http://standards.iso.org/iso/9075/2002/12/sqlxml.xsd">http://standards.iso.org/iso/9075/2002/12/sqlxml.xsd</a>
* </li>
* </ul>
* The schema definition describes the internal data of a {@code RowSet} object
--- a/jdk/src/jdk.attach/windows/native/libattach/VirtualMachineImpl.c Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/jdk.attach/windows/native/libattach/VirtualMachineImpl.c Fri Oct 10 02:24:41 2014 -0700
@@ -92,6 +92,10 @@
* Code copied to target process
*/
#pragma check_stack (off)
+/* Switch off all runtime checks (checks caused by /RTC<x>). They cause the
+ * generated code to contain relative jumps to check functions which make
+ * the code position dependent. */
+#pragma runtime_checks ("scu", off)
DWORD WINAPI jvm_attach_thread_func(DataBlock *pData)
{
HINSTANCE h;
@@ -122,7 +126,7 @@
void jvm_attach_thread_func_end (void) {
}
#pragma check_stack
-
+#pragma runtime_checks ("scu", restore)
/*
* Class: sun_tools_attach_VirtualMachineImpl
--- a/jdk/src/jdk.dev/share/classes/sun/security/tools/jarsigner/TimestampedSigner.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/src/jdk.dev/share/classes/sun/security/tools/jarsigner/TimestampedSigner.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 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
@@ -140,7 +140,7 @@
/**
* Examine the certificate for a Subject Information Access extension
- * (<a href="http://www.ietf.org/rfc/rfc3280.txt">RFC 3280</a>).
+ * (<a href="http://tools.ietf.org/html/rfc5280">RFC 5280</a>).
* The extension's <tt>accessMethod</tt> field should contain the object
* identifier defined for timestamping: 1.3.6.1.5.5.7.48.3 and its
* <tt>accessLocation</tt> field should contain an HTTP or HTTPS URL.
--- a/jdk/test/TEST.groups Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/TEST.groups Fri Oct 10 02:24:41 2014 -0700
@@ -365,7 +365,6 @@
java/util/zip/3GBZipFiles.sh \
jdk/lambda/FDTest.java \
jdk/lambda/separate/Compiler.java \
- sun/management/jdp/JdpTest.sh \
sun/management/jmxremote/bootstrap/JvmstatCountersTest.java \
sun/management/jmxremote/bootstrap/LocalManagementTest.java \
sun/management/jmxremote/bootstrap/CustomLauncherTest.java \
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/util/logging/Logger/entering/LoggerEnteringWithParams.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,173 @@
+
+/*
+ * 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.
+ */
+
+import java.io.ByteArrayOutputStream;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.logging.Handler;
+import java.util.logging.Level;
+import java.util.logging.LogRecord;
+import java.util.logging.Logger;
+import java.util.logging.SimpleFormatter;
+import java.util.logging.StreamHandler;
+
+/**
+ * @test
+ * @bug 8028788
+ * @summary tests that the message format string is correctly constructed
+ * by Logger.entering
+ * @run main/othervm LoggerEnteringWithParams
+ * @author daniel fuchs
+ */
+public class LoggerEnteringWithParams {
+
+ final static Object[] data = {
+ "one", "two", "three", "four", "five", "six", "seven", "eight"
+ };
+
+ static final class TestHandler extends Handler {
+ final List<LogRecord> events = new CopyOnWriteArrayList<>();
+ final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ final StreamHandler wrapped = new StreamHandler(bytes, new SimpleFormatter());
+
+ @Override
+ public void publish(LogRecord record) {
+ events.add(record);
+ wrapped.publish(record);
+ wrapped.flush();
+ }
+ @Override
+ public void flush() {
+ wrapped.flush();
+ }
+ @Override
+ public void close() throws SecurityException {
+ wrapped.close();
+ }
+
+ @Override
+ public synchronized void setLevel(Level newLevel) throws SecurityException {
+ super.setLevel(newLevel);
+ wrapped.setLevel(newLevel);
+ }
+
+ public void reset() {
+ bytes.reset();
+ events.clear();
+ }
+
+ }
+
+ public static void main(String[] args) {
+ Logger logger = Logger.getLogger("some.logger");
+ TestHandler handler = new TestHandler();
+ logger.setUseParentHandlers(false);
+ handler.setLevel(Level.ALL);
+ logger.setLevel(Level.FINEST);
+ logger.addHandler(handler);
+
+ // Auto-detect the line termination used by SimpleFormatter - (CR vs CRLF)
+ logger.entering("test", "test");
+ final String test = handler.bytes.toString();
+ System.out.println(test);
+ final String lineEnd = test.substring(test.indexOf("ENTRY")+"ENTRY".length());
+ System.out.print("Line termination is " + lineEnd.length() + " char(s) long:");
+ for (int i=0; i<lineEnd.length(); i++) {
+ System.out.print(" code="+(int)lineEnd.charAt(i));
+ }
+ System.out.println();
+ handler.reset();
+
+ for (int i=0 ; i<=data.length; i++) {
+ final StringBuilder b = new StringBuilder("ENTRY");
+ final StringBuilder f = new StringBuilder("ENTRY");
+ final Object[] params = new Object[i];
+ for (int k=0; k<i; k++) {
+ params[k] = data[k];
+ b.append(' ').append(String.valueOf(params[k]));
+ f.append(" {").append(String.valueOf(k)).append('}');
+ }
+
+ final String expected = b.toString();
+ final String format = f.toString();
+ final String className = "class"+i;
+ final String methodName = "method"+i;
+
+ logger.entering(className, methodName, params);
+ final String logged = handler.bytes.toString();
+ System.out.println("got:\n" + logged);
+
+ if (!logged.contains(className)) {
+ throw new RuntimeException("Marker for " + className
+ + " not found."
+ + "\n\tgot: <<\n" + logged + "\t >>");
+ }
+ if (!logged.contains(methodName)) {
+ throw new RuntimeException("Marker for " + methodName
+ + " not found."
+ + "\n\tgot: <<\n" + logged + "\t >>");
+ }
+ if (!logged.contains(expected)) {
+ throw new RuntimeException("Marker for parameters[size="
+ + i + "] not found"
+ + "\n\tgot: <<\n" + logged + "\t >>");
+ }
+ if (!logged.contains(expected+lineEnd)) {
+ throw new RuntimeException("Marker for parameters[size="
+ + i + "] has extra characters"
+ + "\n\tgot: <<\n" + logged + "\t >>");
+ }
+
+ LogRecord record = handler.events.remove(0);
+ if (!handler.events.isEmpty()) {
+ throw new RuntimeException("Handler has more log records: "
+ + handler.events.toString());
+ }
+ if (!className.equals(record.getSourceClassName())) {
+ throw new RuntimeException("Unexpected class name in LogRecord."
+ + "\n\texpected: " + className
+ + "\n\tgot: " + record.getSourceClassName());
+ }
+ if (!methodName.equals(record.getSourceMethodName())) {
+ throw new RuntimeException("Unexpected method name in LogRecord."
+ + "\n\texpected: " + methodName
+ + "\n\tgot: " + record.getSourceMethodName());
+ }
+ if (!format.equals(record.getMessage())) {
+ throw new RuntimeException("Unexpected message format in LogRecord."
+ + "\n\texpected: " + format
+ + "\n\tgot: " + record.getMessage());
+ }
+ if (!Arrays.deepEquals(params, record.getParameters())) {
+ throw new RuntimeException("Unexpected parameter array in LogRecord."
+ + "\n\texpected: " + Arrays.toString(params)
+ + "\n\tgot: " + Arrays.toString(record.getParameters()));
+ }
+
+ handler.reset();
+ }
+ }
+
+}
--- a/jdk/test/javax/sql/testng/TEST.properties Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/javax/sql/testng/TEST.properties Fri Oct 10 02:24:41 2014 -0700
@@ -1,2 +1,3 @@
# JDBC unit tests uses TestNG
-TestNG.dirs= .
\ No newline at end of file
+TestNG.dirs= .
+othervm.dirs= .
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/jars/badFactory/META-INF/services/javax.sql.rowset.RowSetFactory Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1 @@
+invalid.RowSetFactoryImpl
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/jars/goodFactory/META-INF/services/javax.sql.rowset.RowSetFactory Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1 @@
+util.StubRowSetFactory
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/test/rowset/RowSetFactoryTests.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,119 @@
+/*
+ * 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.
+ */
+package test.rowset;
+
+import java.sql.SQLException;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+import static org.testng.Assert.*;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import util.BaseTest;
+
+public class RowSetFactoryTests extends BaseTest {
+
+ // RowSet implementations that we are testing for
+ private final String DEFAULT_CACHEDROWSET_CLASSNAME = "com.sun.rowset.CachedRowSetImpl";
+ private final String DEFAULT_FILTEREDROWSET_CLASSNAME = "com.sun.rowset.FileteredRowSetImpl";
+ private final String DEFAULT_JDBCROWSET_CLASSNAME = "com.sun.rowset.JdbcRowSetImpl";
+ private final String DEFAULT_JOINROWSET_CLASSNAME = "com.sun.rowset.JoinRowSetImpl";
+ private final String DEFAULT_WEBROWSET_CLASSNAME = "com.sun.rowset.WebRowSetImpl";
+ private final String STUB_FACTORY_CLASSNAME = "util.StubRowSetFactory";
+ private final String STUB_CACHEDROWSET_CLASSNAME = "util.StubCachedRowSetImpl";
+ private final String STUB_FILTEREDROWSET_CLASSNAME = "util.StubFilteredRowSetImpl";
+ private final String STUB_JDBCROWSET_CLASSNAME = "util.StubJdbcRowSetImpl";
+ private final String STUB_JOINROWSET_CLASSNAME = "util.StubJoinRowSetImpl";
+ private final String STUB_WEBROWSET_CLASSNAME = "util.StubWebRowSetImpl";
+
+
+ /*
+ * Validate that the RowSetFactory returned by RowSetProvider.newFactory()
+ * returns the correct RowSet implementations
+ */
+ @Test(dataProvider = "RowSetValues", enabled = true)
+ public void test(RowSetFactory rsf, String impl) throws SQLException {
+ validateRowSetImpl(rsf, impl);
+ }
+
+ /*
+ * Utility Method to validate the RowsetFactory returns the correct
+ * RowSet implementation
+ */
+ private void validateRowSetImpl(RowSetFactory rsf, String implName)
+ throws SQLException {
+ assertNotNull(rsf, "RowSetFactory should not be null");
+ switch (implName) {
+ case DEFAULT_CACHEDROWSET_CLASSNAME:
+ assertTrue(rsf.createCachedRowSet() instanceof com.sun.rowset.CachedRowSetImpl);
+ break;
+ case DEFAULT_FILTEREDROWSET_CLASSNAME:
+ assertTrue(rsf.createFilteredRowSet() instanceof com.sun.rowset.FilteredRowSetImpl);
+ break;
+ case DEFAULT_JDBCROWSET_CLASSNAME:
+ assertTrue(rsf.createJdbcRowSet() instanceof com.sun.rowset.JdbcRowSetImpl);
+ break;
+ case DEFAULT_JOINROWSET_CLASSNAME:
+ assertTrue(rsf.createJoinRowSet() instanceof com.sun.rowset.JoinRowSetImpl);
+ break;
+ case DEFAULT_WEBROWSET_CLASSNAME:
+ assertTrue(rsf.createWebRowSet() instanceof com.sun.rowset.WebRowSetImpl);
+ break;
+ case STUB_CACHEDROWSET_CLASSNAME:
+ assertTrue(rsf.createCachedRowSet() instanceof util.StubCachedRowSetImpl);
+ break;
+ case STUB_FILTEREDROWSET_CLASSNAME:
+ assertTrue(rsf.createFilteredRowSet() instanceof util.StubFilteredRowSetImpl);
+ break;
+ case STUB_JDBCROWSET_CLASSNAME:
+ assertTrue(rsf.createJdbcRowSet() instanceof util.StubJdbcRowSetImpl);
+ break;
+ case STUB_WEBROWSET_CLASSNAME:
+ assertTrue(rsf.createWebRowSet() instanceof util.StubWebRowSetImpl);
+ break;
+ }
+
+ }
+
+ /*
+ * DataProvider used to provide the RowSetFactory and the RowSet
+ * implementation that should be returned
+ */
+ @DataProvider(name = "RowSetValues")
+ private Object[][] RowSetValues() throws SQLException {
+ RowSetFactory rsf = RowSetProvider.newFactory();
+ RowSetFactory rsf1 = RowSetProvider.newFactory(STUB_FACTORY_CLASSNAME, null);
+ return new Object[][]{
+ {rsf, DEFAULT_CACHEDROWSET_CLASSNAME},
+ {rsf, DEFAULT_FILTEREDROWSET_CLASSNAME},
+ {rsf, DEFAULT_JDBCROWSET_CLASSNAME},
+ {rsf, DEFAULT_JOINROWSET_CLASSNAME},
+ {rsf, DEFAULT_WEBROWSET_CLASSNAME},
+ {rsf1, STUB_CACHEDROWSET_CLASSNAME},
+ {rsf1, STUB_FILTEREDROWSET_CLASSNAME},
+ {rsf1, STUB_JDBCROWSET_CLASSNAME},
+ {rsf1, STUB_JOINROWSET_CLASSNAME},
+ {rsf1, STUB_WEBROWSET_CLASSNAME}
+
+ };
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/test/rowset/RowSetProviderTests.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,189 @@
+/*
+ * 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.
+ */
+package test.rowset;
+
+import com.sun.rowset.RowSetFactoryImpl;
+import java.io.File;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.sql.SQLException;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.RowSetProvider;
+import static org.testng.Assert.*;
+import org.testng.annotations.AfterClass;
+import org.testng.annotations.AfterMethod;
+import org.testng.annotations.BeforeClass;
+import org.testng.annotations.DataProvider;
+import org.testng.annotations.Test;
+import util.BaseTest;
+import util.StubRowSetFactory;
+
+public class RowSetProviderTests extends BaseTest {
+
+ // Default RowSetFactory Implementation
+ private final String DEFFAULT_FACTORY_CLASSNAME = "com.sun.rowset.RowSetFactoryImpl";
+ // Stub RowSetFactory Implementation
+ private final String STUB_FACTORY_CLASSNAME = "util.StubRowSetFactory";
+ // Indicator that the factory implementation does not need to be checked
+ private final String NO_VALADATE_IMPL = "";
+ // Original System property value for javax.sql.rowset.RowSetFactory
+ private static String origFactoryProperty;
+ // Original ClassLoader
+ private static ClassLoader cl;
+ // Path to the location of the jar files used by the ServiceLoader API
+ private static String jarPath;
+
+ /*
+ * Save off the original property value for javax.sql.rowset.RowSetFactory,
+ * original classloader and define the path to the jars directory
+ */
+ @BeforeClass
+ public static void setUpClass() throws Exception {
+ origFactoryProperty = System.getProperty("javax.sql.rowset.RowSetFactory");
+ cl = Thread.currentThread().getContextClassLoader();
+ jarPath = System.getProperty("test.src", ".") + File.separatorChar
+ + "jars" + File.separatorChar;
+ }
+
+ /*
+ * Install the original javax.sql.rowset.RowSetFactory property value
+ */
+ @AfterClass
+ public static void tearDownClass() throws Exception {
+ if (origFactoryProperty != null) {
+ System.setProperty("javax.sql.rowset.RowSetFactory",
+ origFactoryProperty);
+ }
+ }
+
+ /*
+ * Clear the javax.sql.rowset.RowSetFactory property value and
+ * reset the classloader to its original value
+ */
+ @AfterMethod
+ public void tearDownMethod() throws Exception {
+ System.clearProperty("javax.sql.rowset.RowSetFactory");
+ Thread.currentThread().setContextClassLoader(cl);
+ }
+
+ /*
+ * Validate that the correct RowSetFactory is returned by newFactory().
+ */
+ @Test(dataProvider = "RowSetFactoryValues")
+ public void test(RowSetFactory rsf, String impl) throws SQLException {
+ validateProvider(rsf, impl);
+ }
+
+ /*
+ * Validate that the default RowSetFactory is returned by newFactory()
+ * when specified by the javax.sql.rowset.RowSetFactory property.
+ */
+ @Test
+ public void test01() throws SQLException {
+ System.setProperty("javax.sql.rowset.RowSetFactory",
+ DEFFAULT_FACTORY_CLASSNAME);
+ validateProvider(RowSetProvider.newFactory(), DEFFAULT_FACTORY_CLASSNAME);
+ }
+
+ /*
+ * Validate that the correct RowSetFactory is returned by newFactory()
+ * when specified by the javax.sql.rowset.RowSetFactory property.
+ */
+ @Test(enabled = true)
+ public void test02() throws SQLException {
+ System.setProperty("javax.sql.rowset.RowSetFactory", STUB_FACTORY_CLASSNAME);
+ validateProvider(RowSetProvider.newFactory(), STUB_FACTORY_CLASSNAME);
+ }
+
+ /*
+ * Validate that a SQLException is thrown by newFactory()
+ * when specified RowSetFactory specified by the
+ * javax.sql.rowset.RowSetFactory property is not valid.
+ */
+ @Test(expectedExceptions = SQLException.class)
+ public void test03() throws SQLException {
+ System.setProperty("javax.sql.rowset.RowSetFactory",
+ "invalid.RowSetFactoryImpl");
+ RowSetFactory rsf = RowSetProvider.newFactory();
+ }
+
+ /*
+ * Validate that the correct RowSetFactory is returned by newFactory()
+ * when specified by the ServiceLoader API.
+ */
+ @Test
+ public void test04() throws Exception {
+ File f = new File(jarPath + "goodFactory");
+ URLClassLoader loader = new URLClassLoader(new URL[]{
+ new URL(f.toURI().toString())}, getClass().getClassLoader());
+ Thread.currentThread().setContextClassLoader(loader);
+ validateProvider(RowSetProvider.newFactory(), STUB_FACTORY_CLASSNAME);
+ }
+
+ /*
+ * Validate that a SQLException is thrown by newFactory() if the default
+ * RowSetFactory specified by the ServiceLoader API is not valid
+ */
+ @Test(expectedExceptions = SQLException.class)
+ public void test05() throws Exception {
+ File f = new File(jarPath + "badFactory");
+ URLClassLoader loader = new URLClassLoader(new URL[]{
+ new URL(f.toURI().toString())}, getClass().getClassLoader());
+ Thread.currentThread().setContextClassLoader(loader);
+ RowSetProvider.newFactory();
+ }
+
+ /*
+ * Utility Method to validate that the RowsetFactory returned from
+ * RowSetProvider.newFactory() is correct
+ */
+ private void validateProvider(RowSetFactory rsf, String implName) {
+ assertNotNull(rsf, "RowSetFactory should not be null");
+ switch (implName) {
+ case DEFFAULT_FACTORY_CLASSNAME:
+ assertTrue(rsf instanceof RowSetFactoryImpl);
+ break;
+ case STUB_FACTORY_CLASSNAME:
+ assertTrue(rsf instanceof StubRowSetFactory);
+ break;
+ default:
+ }
+ }
+
+ /*
+ * DataProvider used to provide a RowSetFactory and the expected
+ * RowSetFactory implementation that should be returned
+ */
+ @DataProvider(name = "RowSetFactoryValues")
+ private Object[][] RowSetFactoryValues() throws SQLException {
+ RowSetFactory rsf = RowSetProvider.newFactory();
+ RowSetFactory rsf1 = RowSetProvider.newFactory(STUB_FACTORY_CLASSNAME, null);
+ RowSetFactory rsf2 = RowSetProvider.newFactory(DEFFAULT_FACTORY_CLASSNAME, null);
+ return new Object[][]{
+ {rsf, NO_VALADATE_IMPL},
+ {rsf, DEFFAULT_FACTORY_CLASSNAME},
+ {rsf1, STUB_FACTORY_CLASSNAME},
+ {rsf2, DEFFAULT_FACTORY_CLASSNAME}
+ };
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubCachedRowSetImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1848 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+import javax.sql.RowSetMetaData;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.RowSetWarning;
+import javax.sql.rowset.spi.SyncProvider;
+import javax.sql.rowset.spi.SyncProviderException;
+
+public class StubCachedRowSetImpl implements CachedRowSet {
+
+ public StubCachedRowSetImpl() {
+ }
+
+ @Override
+ public void populate(ResultSet data) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute(Connection conn) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges() throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges(Connection con) throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void restoreOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void release() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoDelete() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoInsert() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoUpdate() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(int idx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SyncProvider getSyncProvider() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSyncProvider(String provider) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int size() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMetaData(RowSetMetaData md) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getTableName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTableName(String tabName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getKeyColumns() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setKeyColumns(int[] keys) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSet createShared() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopy() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopySchema() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopyNoConstraints() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSetWarning getRowSetWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getShowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShowDeleted(boolean b) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback(Savepoint s) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet rs, int startRow) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPageSize(int size) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getPageSize() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean nextPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previousPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUrl() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUrl(String url) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getDataSourceName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDataSourceName(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUsername() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUsername(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getPassword() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPassword(String password) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getTransactionIsolation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCommand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCommand(String cmd) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setReadOnly(boolean value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxFieldSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxFieldSize(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxRows() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxRows(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getEscapeProcessing() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setEscapeProcessing(boolean enable) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getQueryTimeout() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setQueryTimeout(int seconds) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setType(int type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setConcurrency(int concurrency) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(String parameterName, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(int parameterIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(String parameterName, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(int parameterIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(String parameterName, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(int parameterIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(String parameterName, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(int parameterIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(String parameterName, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(int parameterIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(String parameterName, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(int parameterIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(String parameterName, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(int parameterIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(String parameterName, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(String parameterName, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRef(int i, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int i, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int i, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setArray(int i, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearParameters() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void removeRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(String parameterName, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setURL(int parameterIndex, URL x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean next() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void close() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean wasNull() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSetMetaData getMetaData() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int findColumn(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isBeforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isAfterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void beforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void afterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean first() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean last() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean absolute(int row) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean relative(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previous() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchDirection(int direction) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchSize(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getConcurrency() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowUpdated() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowInserted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(int columnIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(String columnLabel, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void insertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void refreshRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToInsertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToCurrentRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Statement getStatement() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String[] columnNames) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getMatchColumnIndexes() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getMatchColumnNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubFilteredRowSetImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1892 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+import javax.sql.RowSetMetaData;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.FilteredRowSet;
+import javax.sql.rowset.Predicate;
+import javax.sql.rowset.RowSetWarning;
+import javax.sql.rowset.spi.SyncProvider;
+import javax.sql.rowset.spi.SyncProviderException;
+
+public class StubFilteredRowSetImpl implements FilteredRowSet {
+
+ public StubFilteredRowSetImpl() {
+ }
+
+ @Override
+ public void setFilter(Predicate p) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Predicate getFilter() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void readXml(Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void readXml(InputStream iStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet data) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute(Connection conn) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges() throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges(Connection con) throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void restoreOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void release() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoDelete() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoInsert() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoUpdate() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(int idx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SyncProvider getSyncProvider() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSyncProvider(String provider) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int size() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMetaData(RowSetMetaData md) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getTableName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTableName(String tabName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getKeyColumns() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setKeyColumns(int[] keys) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSet createShared() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopy() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopySchema() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopyNoConstraints() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSetWarning getRowSetWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getShowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShowDeleted(boolean b) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback(Savepoint s) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet rs, int startRow) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPageSize(int size) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getPageSize() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean nextPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previousPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUrl() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUrl(String url) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getDataSourceName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDataSourceName(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUsername() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUsername(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getPassword() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPassword(String password) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getTransactionIsolation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCommand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCommand(String cmd) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setReadOnly(boolean value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxFieldSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxFieldSize(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxRows() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxRows(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getEscapeProcessing() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setEscapeProcessing(boolean enable) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getQueryTimeout() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setQueryTimeout(int seconds) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setType(int type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setConcurrency(int concurrency) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(String parameterName, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(int parameterIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(String parameterName, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(int parameterIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(String parameterName, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(int parameterIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(String parameterName, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(int parameterIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(String parameterName, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(int parameterIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(String parameterName, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(int parameterIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(String parameterName, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(int parameterIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(String parameterName, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(String parameterName, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRef(int i, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int i, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int i, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setArray(int i, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearParameters() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void removeRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(String parameterName, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setURL(int parameterIndex, URL x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean next() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void close() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean wasNull() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSetMetaData getMetaData() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int findColumn(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isBeforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isAfterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void beforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void afterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean first() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean last() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean absolute(int row) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean relative(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previous() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchDirection(int direction) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchSize(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getConcurrency() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowUpdated() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowInserted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(int columnIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(String columnLabel, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void insertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void refreshRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToInsertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToCurrentRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Statement getStatement() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String[] columnNames) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getMatchColumnIndexes() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getMatchColumnNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubJdbcRowSetImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1672 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Map;
+import javax.sql.RowSetListener;
+import javax.sql.rowset.JdbcRowSet;
+import javax.sql.rowset.RowSetWarning;
+
+public class StubJdbcRowSetImpl implements JdbcRowSet {
+
+ @Override
+ public boolean getShowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShowDeleted(boolean b) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSetWarning getRowSetWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getAutoCommit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAutoCommit(boolean autoCommit) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback(Savepoint s) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUrl() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUrl(String url) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getDataSourceName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDataSourceName(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUsername() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUsername(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getPassword() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPassword(String password) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getTransactionIsolation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCommand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCommand(String cmd) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setReadOnly(boolean value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxFieldSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxFieldSize(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxRows() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxRows(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getEscapeProcessing() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setEscapeProcessing(boolean enable) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getQueryTimeout() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setQueryTimeout(int seconds) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setType(int type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setConcurrency(int concurrency) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(String parameterName, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(int parameterIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(String parameterName, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(int parameterIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(String parameterName, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(int parameterIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(String parameterName, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(int parameterIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(String parameterName, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(int parameterIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(String parameterName, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(int parameterIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(String parameterName, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(int parameterIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(String parameterName, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(String parameterName, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRef(int i, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int i, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int i, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setArray(int i, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearParameters() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void removeRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(String parameterName, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setURL(int parameterIndex, URL x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean next() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void close() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean wasNull() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSetMetaData getMetaData() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int findColumn(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isBeforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isAfterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void beforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void afterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean first() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean last() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean absolute(int row) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean relative(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previous() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchDirection(int direction) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchSize(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getConcurrency() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowUpdated() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowInserted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(int columnIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(String columnLabel, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void insertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void refreshRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToInsertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToCurrentRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Statement getStatement() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String[] columnNames) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getMatchColumnIndexes() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getMatchColumnNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubJoinRowSetImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1962 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+import javax.sql.RowSetMetaData;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.JoinRowSet;
+import javax.sql.rowset.Joinable;
+import javax.sql.rowset.RowSetWarning;
+import javax.sql.rowset.spi.SyncProvider;
+import javax.sql.rowset.spi.SyncProviderException;
+
+class StubJoinRowSetImpl implements JoinRowSet {
+
+ public StubJoinRowSetImpl() {
+ }
+
+ @Override
+ public void addRowSet(Joinable rowset) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSet(RowSet rowset, int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSet(RowSet rowset, String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSet(RowSet[] rowset, int[] columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSet(RowSet[] rowset, String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> getRowSets() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getRowSetNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet toCachedRowSet() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean supportsCrossJoin() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean supportsInnerJoin() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean supportsLeftOuterJoin() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean supportsRightOuterJoin() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean supportsFullJoin() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setJoinType(int joinType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getWhereClause() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getJoinType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void readXml(Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void readXml(InputStream iStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet data) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute(Connection conn) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges() throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges(Connection con) throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void restoreOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void release() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoDelete() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoInsert() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoUpdate() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(int idx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SyncProvider getSyncProvider() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSyncProvider(String provider) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int size() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMetaData(RowSetMetaData md) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getTableName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTableName(String tabName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getKeyColumns() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setKeyColumns(int[] keys) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSet createShared() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopy() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopySchema() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopyNoConstraints() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSetWarning getRowSetWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getShowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShowDeleted(boolean b) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback(Savepoint s) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet rs, int startRow) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPageSize(int size) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getPageSize() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean nextPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previousPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUrl() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUrl(String url) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getDataSourceName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDataSourceName(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUsername() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUsername(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getPassword() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPassword(String password) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getTransactionIsolation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCommand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCommand(String cmd) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setReadOnly(boolean value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxFieldSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxFieldSize(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxRows() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxRows(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getEscapeProcessing() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setEscapeProcessing(boolean enable) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getQueryTimeout() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setQueryTimeout(int seconds) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setType(int type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setConcurrency(int concurrency) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(String parameterName, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(int parameterIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(String parameterName, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(int parameterIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(String parameterName, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(int parameterIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(String parameterName, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(int parameterIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(String parameterName, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(int parameterIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(String parameterName, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(int parameterIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(String parameterName, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(int parameterIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(String parameterName, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(String parameterName, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRef(int i, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int i, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int i, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setArray(int i, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearParameters() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void removeRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(String parameterName, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setURL(int parameterIndex, URL x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean next() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void close() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean wasNull() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSetMetaData getMetaData() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int findColumn(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isBeforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isAfterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void beforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void afterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean first() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean last() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean absolute(int row) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean relative(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previous() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchDirection(int direction) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchSize(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getConcurrency() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowUpdated() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowInserted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(int columnIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(String columnLabel, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void insertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void refreshRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToInsertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToCurrentRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Statement getStatement() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String[] columnNames) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getMatchColumnIndexes() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getMatchColumnNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubRowSetFactory.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,60 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.sql.SQLException;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.FilteredRowSet;
+import javax.sql.rowset.JdbcRowSet;
+import javax.sql.rowset.JoinRowSet;
+import javax.sql.rowset.RowSetFactory;
+import javax.sql.rowset.WebRowSet;
+
+public class StubRowSetFactory implements RowSetFactory {
+
+ @Override
+ public CachedRowSet createCachedRowSet() throws SQLException {
+ return new StubCachedRowSetImpl();
+ }
+
+ @Override
+ public FilteredRowSet createFilteredRowSet() throws SQLException {
+ return new StubFilteredRowSetImpl();
+ }
+
+ @Override
+ public JdbcRowSet createJdbcRowSet() throws SQLException {
+ return new StubJdbcRowSetImpl();
+ }
+
+ @Override
+ public JoinRowSet createJoinRowSet() throws SQLException {
+ return new StubJoinRowSetImpl();
+ }
+
+ @Override
+ public WebRowSet createWebRowSet() throws SQLException {
+ return new StubWebRowSetImpl();
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/sql/testng/util/StubWebRowSetImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,1879 @@
+/*
+ * 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.
+ */
+package util;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.NClob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.RowId;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.SQLXML;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+import javax.sql.RowSetMetaData;
+import javax.sql.rowset.CachedRowSet;
+import javax.sql.rowset.RowSetWarning;
+import javax.sql.rowset.WebRowSet;
+import javax.sql.rowset.spi.SyncProvider;
+import javax.sql.rowset.spi.SyncProviderException;
+
+public class StubWebRowSetImpl implements WebRowSet {
+
+ @Override
+ public void readXml(Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void readXml(InputStream iStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(ResultSet rs, OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(Writer writer) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void writeXml(OutputStream oStream) throws SQLException, IOException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet data) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute(Connection conn) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges() throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void acceptChanges(Connection con) throws SyncProviderException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void restoreOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void release() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoDelete() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoInsert() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void undoUpdate() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(int idx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean columnUpdated(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(int column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Collection<?> toCollection(String column) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SyncProvider getSyncProvider() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSyncProvider(String provider) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int size() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMetaData(RowSetMetaData md) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginal() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSet getOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setOriginalRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getTableName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTableName(String tabName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getKeyColumns() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setKeyColumns(int[] keys) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSet createShared() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopy() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopySchema() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public CachedRowSet createCopyNoConstraints() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowSetWarning getRowSetWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getShowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShowDeleted(boolean b) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void commit() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rollback(Savepoint s) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void rowSetPopulated(RowSetEvent event, int numRows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void populate(ResultSet rs, int startRow) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPageSize(int size) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getPageSize() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean nextPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previousPage() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUrl() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUrl(String url) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getDataSourceName() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDataSourceName(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getUsername() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setUsername(String name) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getPassword() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setPassword(String password) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getTransactionIsolation() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTransactionIsolation(int level) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Map<String, Class<?>> getTypeMap() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCommand() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCommand(String cmd) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isReadOnly() {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setReadOnly(boolean value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxFieldSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxFieldSize(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getMaxRows() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMaxRows(int max) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getEscapeProcessing() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setEscapeProcessing(boolean enable) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getQueryTimeout() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setQueryTimeout(int seconds) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setType(int type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setConcurrency(int concurrency) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int parameterIndex, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(int paramIndex, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNull(String parameterName, int sqlType, String typeName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(int parameterIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBoolean(String parameterName, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(int parameterIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setByte(String parameterName, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(int parameterIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setShort(String parameterName, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(int parameterIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setInt(String parameterName, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(int parameterIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setLong(String parameterName, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(int parameterIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFloat(String parameterName, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(int parameterIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDouble(String parameterName, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(int parameterIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBigDecimal(String parameterName, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(int parameterIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setString(String parameterName, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(int parameterIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBytes(String parameterName, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setAsciiStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(int parameterIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBinaryStream(String parameterName, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setCharacterStream(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x, int targetSqlType) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(String parameterName, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setObject(int parameterIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRef(int i, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int i, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(int parameterIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setBlob(String parameterName, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int i, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setArray(int i, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(int parameterIndex, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setDate(String parameterName, Date x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(int parameterIndex, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTime(String parameterName, Time x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setTimestamp(String parameterName, Timestamp x, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearParameters() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void execute() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void addRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void removeRowSetListener(RowSetListener listener) {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(int parameterIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setSQLXML(String parameterName, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(int parameterIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setRowId(String parameterName, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(int parameterIndex, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNString(String parameterName, String value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(int parameterIndex, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNCharacterStream(String parameterName, Reader value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(String parameterName, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, NClob value) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setNClob(int parameterIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setURL(int parameterIndex, URL x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean next() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void close() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean wasNull() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean getBoolean(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte getByte(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public short getShort(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getInt(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public long getLong(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public float getFloat(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public double getDouble(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel, int scale) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public byte[] getBytes(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getAsciiStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getUnicodeStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public InputStream getBinaryStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLWarning getWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void clearWarnings() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getCursorName() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public ResultSetMetaData getMetaData() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int findColumn(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public BigDecimal getBigDecimal(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isBeforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isAfterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void beforeFirst() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void afterLast() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean first() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean last() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean absolute(int row) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean relative(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean previous() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchDirection(int direction) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchDirection() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setFetchSize(int rows) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getFetchSize() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getType() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getConcurrency() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowUpdated() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowInserted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean rowDeleted() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(int columnIndex, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(int columnIndex, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(int columnIndex, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(int columnIndex, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(int columnIndex, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(int columnIndex, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(int columnIndex, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(int columnIndex, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(int columnIndex, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(int columnIndex, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNull(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBoolean(String columnLabel, boolean x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateByte(String columnLabel, byte x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateShort(String columnLabel, short x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateInt(String columnLabel, int x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateLong(String columnLabel, long x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateFloat(String columnLabel, float x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDouble(String columnLabel, double x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBigDecimal(String columnLabel, BigDecimal x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateString(String columnLabel, String x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBytes(String columnLabel, byte[] x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateDate(String columnLabel, Date x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTime(String columnLabel, Time x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateTimestamp(String columnLabel, Timestamp x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, int length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x, int scaleOrLength) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateObject(String columnLabel, Object x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void insertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void deleteRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void refreshRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void cancelRowUpdates() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToInsertRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void moveToCurrentRow() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Statement getStatement() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Object getObject(String columnLabel, Map<String, Class<?>> map) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Ref getRef(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Blob getBlob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Clob getClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Array getArray(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Date getDate(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Time getTime(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Timestamp getTimestamp(String columnLabel, Calendar cal) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public URL getURL(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(int columnIndex, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRef(String columnLabel, Ref x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, Blob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Clob x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(int columnIndex, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateArray(String columnLabel, Array x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public RowId getRowId(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(int columnIndex, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateRowId(String columnLabel, RowId x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int getHoldability() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isClosed() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(int columnIndex, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNString(String columnLabel, String nString) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, NClob nClob) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public NClob getNClob(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public SQLXML getSQLXML(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(int columnIndex, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateSQLXML(String columnLabel, SQLXML xmlObject) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String getNString(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(int columnIndex) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public Reader getNCharacterStream(String columnLabel) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader, long length) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(int columnIndex, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(int columnIndex, Reader x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateAsciiStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBinaryStream(String columnLabel, InputStream x) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateCharacterStream(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(int columnIndex, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateBlob(String columnLabel, InputStream inputStream) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(int columnIndex, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void updateNClob(String columnLabel, Reader reader) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(int columnIndex, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T getObject(String columnLabel, Class<T> type) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public <T> T unwrap(Class<T> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public boolean isWrapperFor(Class<?> iface) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void setMatchColumn(String[] columnNames) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public int[] getMatchColumnIndexes() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public String[] getMatchColumnNames() throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int columnIdx) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(int[] columnIdxes) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+ @Override
+ public void unsetMatchColumn(String[] columnName) throws SQLException {
+ throw new UnsupportedOperationException("Not supported yet.");
+ }
+
+}
--- a/jdk/test/sun/management/jdp/JdpClient.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,190 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, 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.io.IOException;
-import java.net.Inet6Address;
-import java.net.InetAddress;
-import java.net.InetSocketAddress;
-import java.net.NetworkInterface;
-import java.net.ProtocolFamily;
-import java.net.StandardProtocolFamily;
-import java.net.StandardSocketOptions;
-import java.nio.ByteBuffer;
-import java.nio.channels.DatagramChannel;
-import java.nio.channels.SelectionKey;
-import java.nio.channels.Selector;
-import java.util.Collections;
-import java.util.Enumeration;
-import java.util.Map;
-
-import sun.management.jdp.JdpException;
-import sun.management.jdp.JdpJmxPacket;
-import sun.management.jdp.JdpPacketReader;
-
-public class JdpClient {
-
- private static class PacketListener implements Runnable {
-
- private static final int BUFFER_LENGTH = 4096;
- private final DatagramChannel channel;
- private static int maxPacketCount = 1;
- private static int maxEmptyPacketCount = 10;
-
- private void get(Map<?, ?> map, String key)
- throws JdpException {
-
- if (map.get(key) == null) {
- throw new JdpException("Test failed, packet field " + key + " missed");
- }
- }
-
- private void checkFieldPresence(JdpJmxPacket p)
- throws IOException, JdpException {
-
- byte[] b = p.getPacketData();
-
- JdpPacketReader reader = new JdpPacketReader(b);
- Map<String, String> pMap = reader.getDiscoveryDataAsMap();
-
- get(pMap, JdpJmxPacket.UUID_KEY);
- get(pMap, JdpJmxPacket.MAIN_CLASS_KEY);
- get(pMap, JdpJmxPacket.JMX_SERVICE_URL_KEY);
- // get(pMap, JdpJmxPacket.INSTANCE_NAME_KEY);
- get(pMap, JdpJmxPacket.PROCESS_ID_KEY);
- get(pMap, JdpJmxPacket.BROADCAST_INTERVAL_KEY);
- get(pMap, JdpJmxPacket.RMI_HOSTNAME_KEY);
- }
-
-
- PacketListener(DatagramChannel channel) {
- this.channel = channel;
- }
-
- @java.lang.Override
- public void run() {
- try {
- Selector sel;
- sel = Selector.open();
- channel.configureBlocking(false);
- channel.register(sel, SelectionKey.OP_READ);
- ByteBuffer buf = ByteBuffer.allocate(1024);
-
- int count = 1;
- int emptyPacketsCount = 1;
-
- try {
- while (true) {
-
- // Use tcpdump -U -w - -s 1400 -c 2 -vv port 7095
- // to verify that correct packet being sent
- sel.selectedKeys().clear();
- buf.rewind();
-
- sel.select(10 * 1000);
- channel.receive(buf);
-
- if (buf.position() == 0) {
- if (JdpDoSomething.getVerbose()) {
- System.err.println("Empty packet received");
- }
- if (++emptyPacketsCount > maxEmptyPacketCount) {
- throw new RuntimeException("Test failed, maxEmptyPacketCount reached");
- }
-
- continue;
- }
-
- buf.flip();
- byte[] dgramData = new byte[buf.remaining()];
- buf.get(dgramData);
- try {
- JdpJmxPacket packet = new JdpJmxPacket(dgramData);
- JdpDoSomething.printJdpPacket(packet);
- checkFieldPresence(packet);
- if (++count > maxPacketCount) {
- break;
- }
- } catch (JdpException e) {
- e.printStackTrace();
- throw new RuntimeException("Test failed");
- }
-
- }
-
- System.out.println("OK: Test passed");
-
- } finally {
- sel.close();
- channel.close();
- }
- } catch (IOException e) {
- e.printStackTrace();
- throw new RuntimeException("Test failed");
- }
- }
- }
-
- public static void main(String[] args) {
- try {
- String discoveryPort = System.getProperty("com.sun.management.jdp.port");
- String discoveryAddress = System.getProperty("com.sun.management.jdp.address");
- if (discoveryAddress == null || discoveryPort == null) {
- System.out.println("Test failed. address and port must be specified");
- return;
- }
-
- int port = Integer.parseInt(discoveryPort);
- InetAddress address = InetAddress.getByName(discoveryAddress);
-
-
- ProtocolFamily family = (address instanceof Inet6Address)
- ? StandardProtocolFamily.INET6 : StandardProtocolFamily.INET;
-
- DatagramChannel channel;
-
- channel = DatagramChannel.open(family);
- channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
- channel.bind(new InetSocketAddress(port));
-
- Enumeration<NetworkInterface> nets = NetworkInterface.getNetworkInterfaces();
- for (NetworkInterface interf : Collections.list(nets)) {
- if (interf.supportsMulticast()) {
- try {
- channel.join(address, interf);
- } catch (IOException e) {
- // Skip not configured interfaces
- }
- }
- }
-
- PacketListener listener = new PacketListener(channel);
- new Thread(listener, "Jdp Client").start();
-
- } catch (RuntimeException e) {
- System.out.println("Test failed.");
- } catch (Exception e) {
- e.printStackTrace();
- System.out.println("Test failed. unexpected error " + e);
- }
- }
-}
--- a/jdk/test/sun/management/jdp/JdpDefaultsTest.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/management/jdp/JdpDefaultsTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,9 @@
* A JVM with JDP on should send multicast JDP packets regularly.
*
* @author Alex Schenkman
+ */
+
+/*
* @test JdpDefaultsTest
* @summary Assert that we can read JDP packets from a multicast socket connection, on default IP and port.
* @library /lib/testlibrary
--- a/jdk/test/sun/management/jdp/JdpDoSomething.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,106 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, 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.io.File;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.util.Objects;
-
-import sun.management.jdp.JdpJmxPacket;
-import sun.management.jdp.JdpException;
-
-public class JdpDoSomething {
-
- private static final String lockFileName = "JdpDoSomething.lck";
- private static final boolean verbose = false;
-
- public static boolean getVerbose() {
- return verbose;
- }
-
- public static void printJdpPacket(JdpJmxPacket p) {
- if (getVerbose()) {
- try {
- RandomAccessFile f = new RandomAccessFile("out.dmp", "rw");
- f.write(p.getPacketData());
- f.close();
- } catch (IOException e) {
- System.out.println("Can't write a dump file: " + e);
- }
-
- System.out.println("Id: " + p.getId());
- System.out.println("Jmx: " + p.getJmxServiceUrl());
- System.out.println("Main: " + p.getMainClass());
- System.out.println("InstanceName: " + p.getInstanceName());
- System.out.println("ProccessId: " + p.getProcessId());
- System.out.println("BroadcastInterval: " + p.getBroadcastInterval());
- System.out.println("Rmi Hostname: " + p.getRmiHostname());
-
- System.out.flush();
- }
- }
-
- public static void compaireJdpPacketEx(JdpJmxPacket p1, JdpJmxPacket p2)
- throws JdpException {
-
- if (!Objects.equals(p1, p1)) {
- throw new JdpException("Packet mismatch error");
- }
-
- if (!Objects.equals(p1.getMainClass(), p2.getMainClass())) {
- throw new JdpException("Packet mismatch error (main class)");
- }
-
- if (!Objects.equals(p1.getInstanceName(), p2.getInstanceName())) {
- throw new JdpException("Packet mismatch error (instance name)");
- }
- }
-
- public static void doSomething() {
- try {
- File lockFile = new File(lockFileName);
- lockFile.createNewFile();
-
- while (lockFile.exists()) {
- long datetime = lockFile.lastModified();
- long epoch = System.currentTimeMillis() / 1000;
-
- // Don't allow test app to run more than an hour
- if (epoch - datetime > 3600) {
- System.err.println("Lock is too old. Aborting");
- return;
- }
- Thread.sleep(1);
- }
-
- } catch (Throwable e) {
- System.err.println("Something bad happens:" + e);
- }
- }
-
- public static void main(String args[]) throws Exception {
- System.err.println("main enter");
- doSomething();
- System.err.println("main exit");
- }
-}
--- a/jdk/test/sun/management/jdp/JdpOffTest.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/management/jdp/JdpOffTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,6 +26,9 @@
* com.sun.management.jmxremote.autodiscovery=false should be respected.
*
* @author Alex Schenkman
+ */
+
+/*
* @test JdpOffTest.java
* @summary Assert that no JDP packets are sent to the default address and port.
* @library /lib/testlibrary
--- a/jdk/test/sun/management/jdp/JdpSpecificAddressTest.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/management/jdp/JdpSpecificAddressTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,9 @@
* A JVM with JDP on should send multicast JDP packets regularly.
*
* @author Alex Schenkman
+ */
+
+/*
* @test JdpSpecificAddressTest
* @summary Assert that we can read JDP packets from a multicast socket connection, on specific IP and port.
* @library /lib/testlibrary
--- a/jdk/test/sun/management/jdp/JdpTest.sh Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,358 +0,0 @@
-#!/bin/sh -x
-
-# Copyright (c) 2011, 2013, 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 7169888
-# @compile -XDignore.symbol.file JdpUnitTest.java JdpClient.java JdpDoSomething.java
-# @run shell JdpTest.sh --jtreg --no-compile
-# @summary No word Failed expected in the test output
-
-_verbose=no
-_jtreg=no
-_compile=yes
-
-# temporary disable jcmd related tests
-# _testsuite="01,02,03,04,05"
-_testsuite="01"
-
-_pwd=`pwd`
-
-_testclasses=".classes"
-_testsrc="${_pwd}"
-_lockFileName="JdpDoSomething.lck"
-
-_logname=".classes/output.txt"
-_last_pid=""
-
-_ip="224.0.23.178"
-_port="7095"
-_jmxport="4545"
-
-_do_compile(){
- # If the test run without JTReg, we have to compile it by our self
- # Under JTReg see @compile statement above
- # sun.* packages is not included to symbol file lib/ct.sym so we have
- # to ignore it
-
- if [ ! -d ${_testclasses} ]
- then
- mkdir -p ${_testclasses}
- fi
-
- rm -f ${_testclasses}/*.class
-
- # Compile testcase
- ${COMPILEJAVA}/bin/javac -XDignore.symbol.file -d ${_testclasses} \
- JdpUnitTest.java \
- JdpDoSomething.java \
- JdpClient.java
-
-
- if [ ! -f ${_testclasses}/JdpDoSomething.class -o ! -f ${_testclasses}/JdpClient.class -o ! -f ${_testclasses}/JdpUnitTest.class ]
- then
- echo "ERROR: Can't compile"
- exit 255
- fi
-}
-
-
-_app_start(){
-
- testappname=$1
- shift
-
- ${TESTJAVA}/bin/java -server $* -cp ${_testclasses} ${testappname} >> ${_logname} 2>&1 &
- _last_pid=$!
-
-# wait until VM is actually starts.
-# please note, if vm doesn't start for some reason
-# jtreg kills the test by timeout. Don't file a bug.
- cnt=1
- while true
- do
- npid=`_get_pid`
- if [ "${npid}" != "" ]
- then
- break
- fi
- if [ "${cnt}" = "10" ]
- then
- echo "ERROR: Test app not started. Please check machine resources before filing a bug."
- if [ "${_jtreg}" = "yes" ]
- then
- exit 255
- fi
- break
- fi
- cnt=`expr $cnt + 1`
- sleep 1
- done
-}
-
-_get_pid(){
- ${TESTJAVA}/bin/jps | sed -n "/Jdp/s/ .*//p"
-}
-
-_app_stop(){
- rm ${_lockFileName}
-
-# wait until VM is actually shuts down
- while true
- do
- npid=`_get_pid`
- if [ "${npid}" = "" ]
- then
- break
- fi
- sleep 1
- done
-}
-
-_testme(){
- ${TESTJAVA}/bin/java \
- -cp ${_testclasses} \
- $* \
- -Dcom.sun.management.jdp.port=${_port} \
- -Dcom.sun.management.jdp.address=${_ip} \
- JdpClient
-}
-
-
-_jcmd(){
- ${TESTJAVA}/bin/jcmd JdpDoSomething $* > /dev/null 2>/dev/null
-}
-
-
-_echo(){
- echo "$*"
- echo "$*" >> ${_logname}
-}
-
-# ============= TESTS ======================================
-
-test_01(){
-
- _echo "**** Test one ****"
-
- _app_start JdpUnitTest \
- -Dcom.sun.management.jdp.port=${_port} \
- -Dcom.sun.management.jdp.address=${_ip} \
- -Dcom.sun.management.jdp.name=testme \
- -Djava.rmi.server.hostname=localhost \
- -Dcom.sun.management.jdp.pause=5
-
- res=`_testme`
-
- case "${res}" in
- OK*)
- _echo "Passed"
- ;;
- *)
- _echo "Failed!"
- ;;
- esac
-
- _app_stop
-}
-
-test_02(){
-
- _echo "**** Test two ****"
-
- _app_start JdpDoSomething \
- -Dcom.sun.management.jdp.port=${_port} \
- -Dcom.sun.management.jdp.address=${_ip} \
- -Dcom.sun.management.jdp.pause=5 \
- -Dcom.sun.management.jdp.name=testme \
- -Djava.rmi.server.hostname=localhost \
- -Dcom.sun.management.jmxremote.port=${_jmxport} \
- -Dcom.sun.management.jmxremote.authenticate=false \
- -Dcom.sun.management.jmxremote.ssl=false
-
- res=`_testme`
-
- case "${res}" in
- OK*)
- _echo "Passed"
- ;;
- *)
- _echo "Failed!"
- ;;
- esac
-
- _app_stop
-}
-
-test_03(){
-
- _echo "**** Test three ****"
-
- _app_start JdpDoSomething
-
- _jcmd ManagementAgent.start\
- jdp.port=${_port} \
- jdp.address=${_ip} \
- jdp.pause=5 \
- jdp.name=jcmdtest \
- jmxremote.port=${_jmxport} \
- jmxremote.authenticate=false \
- jmxremote.ssl=false
-
- res=`_testme`
-
- case "${res}" in
- OK*)
- _echo "Passed"
- ;;
- *)
- _echo "Failed!"
- ;;
- esac
-
- _app_stop
-}
-
-test_04(){
-
- _echo "**** Test four ****"
-
- _app_start JdpDoSomething \
- -Dcom.sun.management.jmxremote.autodiscovery=true \
- -Dcom.sun.management.jdp.name=testme \
- -Djava.rmi.server.hostname=localhost \
- -Dcom.sun.management.jmxremote.port=${_jmxport} \
- -Dcom.sun.management.jmxremote.authenticate=false \
- -Dcom.sun.management.jmxremote.ssl=false
-
- res=`_testme`
-
- case "${res}" in
- OK*)
- _echo "Passed"
- ;;
- *)
- _echo "Failed!"
- ;;
- esac
-
- _app_stop
-}
-
-test_05(){
-
- _echo "**** Test five ****"
-
- _app_start JdpDoSomething
-
- _jcmd ManagementAgent.start\
- jmxremote.autodiscovery=true \
- jmxremote.port=${_jmxport} \
- jmxremote.authenticate=false \
- jmxremote.ssl=false
-
-
- res=`_testme`
-
- case "${res}" in
- OK*)
- _echo "Passed"
- ;;
- *)
- _echo "Failed!"
- ;;
- esac
-
- _app_stop
-}
-
-
-# ============= MAIN =======================================
-
-if [ "x${TESTJAVA}" = "x" ]
-then
- echo "TESTJAVA env have to be set"
- exit
-fi
-
-# COMPILEJAVA variable is set when we test jre
-if [ "x${COMPILEJAVA}" = "x" ]
-then
- COMPILEJAVA="${TESTJAVA}"
-fi
-
-
-#------------------------------------------------------------------------------
-# reading parameters
-
-for parm in "$@"
-do
- case $parm in
- --verbose) _verbose=yes ;;
- --jtreg) _jtreg=yes ;;
- --no-compile) _compile=no ;;
- --testsuite=*) _testsuite=`_echo $parm | sed "s,^--.*=\(.*\),\1,"` ;;
- *)
- echo "Undefined parameter $parm. Try --help for help"
- exit
- ;;
- esac
-done
-
-if [ "${_compile}" = "yes" ]
-then
- _do_compile
-fi
-
-if [ "${_jtreg}" = "yes" ]
-then
- _testclasses=${TESTCLASSES}
- _testsrc=${TESTSRC}
- _logname="output.txt"
-fi
-
-# Make sure _tesclasses is absolute path
-tt=`echo ${_testclasses} | sed -e 's,/,,'`
-if [ "${tt}" = "${_testclasses}" ]
-then
- _testclasses="${_pwd}/${_testclasses}"
-fi
-
-_policyname="${_testclasses}/policy"
-
-rm -f ${_logname}
-rm -f ${_policyname}
-
-if [ -f ${_testsrc}/policy.tpl ]
-then
-
-cat ${_testsrc}/policy.tpl | \
- sed -e "s,@_TESTCLASSES@,${_testclasses},g" -e "s,@TESTJAVA@,${TESTJAVA},g" \
- > ${_policyname}
-
-fi
-
-# Local mode tests
-for i in `echo ${_testsuite} | sed -e "s/,/ /g"`
-do
- test_${i}
-done
--- a/jdk/test/sun/management/jdp/JdpUnitTest.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,96 +0,0 @@
-/*
- * Copyright (c) 2012, 2013, 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.io.IOException;
-import java.net.InetAddress;
-import java.util.UUID;
-
-import sun.management.jdp.JdpController;
-import sun.management.jdp.JdpPacket;
-import sun.management.jdp.JdpJmxPacket;
-import sun.management.jdp.JdpException;
-
-public class JdpUnitTest {
-
-
- static byte[] russian_name = {(byte) 0xd0, (byte) 0xbf, (byte) 0xd1, (byte) 0x80, (byte) 0xd0, (byte) 0xbe, (byte) 0xd0, (byte) 0xb2,
- (byte) 0xd0, (byte) 0xb5, (byte) 0xd1, (byte) 0x80, (byte) 0xd0, (byte) 0xba, (byte) 0xd0, (byte) 0xb0,
- (byte) 0x20, (byte) 0xd1, (byte) 0x81, (byte) 0xd0, (byte) 0xb2, (byte) 0xd1, (byte) 0x8f, (byte) 0xd0,
- (byte) 0xb7, (byte) 0xd0, (byte) 0xb8, (byte) 0x0a};
-
- /**
- * This test tests that complete packet is build correctly
- */
- public static void PacketBuilderTest()
- throws IOException, JdpException {
-
- /* Complete packet test */
- {
- JdpJmxPacket p1 = new JdpJmxPacket(UUID.randomUUID(), "fake://unit-test");
- p1.setMainClass("FakeUnitTest");
- p1.setInstanceName(new String(russian_name, "UTF-8"));
- byte[] b = p1.getPacketData();
-
- JdpJmxPacket p2 = new JdpJmxPacket(b);
- JdpDoSomething.printJdpPacket(p1);
- JdpDoSomething.compaireJdpPacketEx(p1, p2);
- }
-
- /*Missed field packet test*/
- {
- JdpJmxPacket p1 = new JdpJmxPacket(UUID.randomUUID(), "fake://unit-test");
- p1.setMainClass("FakeUnitTest");
- p1.setInstanceName(null);
- byte[] b = p1.getPacketData();
-
- JdpJmxPacket p2 = new JdpJmxPacket(b);
- JdpDoSomething.printJdpPacket(p1);
- JdpDoSomething.compaireJdpPacketEx(p1, p2);
- }
-
- System.out.println("OK: Test passed");
-
- }
-
- public static void startFakeDiscoveryService()
- throws IOException, JdpException {
-
- String discoveryPort = System.getProperty("com.sun.management.jdp.port");
- String discoveryAddress = System.getProperty("com.sun.management.jdp.address");
- InetAddress address = InetAddress.getByName(discoveryAddress);
- int port = Integer.parseInt(discoveryPort);
- JdpController.startDiscoveryService(address, port, "FakeDiscovery", "fake://unit-test");
- }
-
- public static void main(String[] args) {
- try {
- PacketBuilderTest();
- startFakeDiscoveryService();
- JdpDoSomething.doSomething();
-
- } catch (Throwable e) {
- e.printStackTrace();
- System.out.println("Test failed. unexpected error " + e);
- }
- }
-}
--- a/jdk/test/sun/management/jdp/README Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/management/jdp/README Fri Oct 10 02:24:41 2014 -0700
@@ -1,32 +1,4 @@
-The following test were contributed by dmitry.samersoff@oracle.com and will be ported in the near future:
-JdpClient.java
-JdpDoSomething.java
-JdpTest.sh
-JdpUnitTest.java
-
-
-JdpTest.sh:
--------------------------------------
-test_01 - basic test, check if JDP packet assembler and other
- parts of JDP is not broken
-
-test_02 - test if JDP starts with custom parameters. (disabled)
-
-test_03 - test if jcmd is able to start jdp with
- custom parameters (disabled)
-
-test_04 - test if JDP starts with default parameters (disabled)
-
-test_05 - test if jcmd is able to start jdp with default
- parameters (disabled)
-
-Only test_01 is enabled at the moment.
-
-JdpUnitTest.java: contains unit tests used under development.
-
-
-==========================================================================
-The other Java-based tests in this folder are contributed by alex.schenkman@oracle.com
+The tests in this folder are contributed by alex.schenkman@oracle.com
There are three Jdp test cases in this folder:
1) Jdp is turned off.
--- a/jdk/test/sun/reflect/CallerSensitive/CallerSensitiveFinder.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/reflect/CallerSensitive/CallerSensitiveFinder.java Fri Oct 10 02:24:41 2014 -0700
@@ -47,7 +47,7 @@
* @summary Verify if CallerSensitive methods are annotated with
* sun.reflect.CallerSensitive annotation
* @build CallerSensitiveFinder
- * @run main/othervm/timeout=900 -mx600m CallerSensitiveFinder
+ * @run main/othervm/timeout=900 CallerSensitiveFinder
*/
public class CallerSensitiveFinder {
private static int numThreads = 3;
--- a/jdk/test/sun/security/pkcs11/PKCS11Test.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/security/pkcs11/PKCS11Test.java Fri Oct 10 02:24:41 2014 -0700
@@ -189,6 +189,8 @@
if (osName.startsWith("Win")) {
osName = "Windows";
NSPR_PREFIX = "lib";
+ } else if (osName.equals("Mac OS X")) {
+ osName = "MacOSX";
}
String osid = osName + "-"
+ props.getProperty("os.arch") + "-" + props.getProperty("sun.arch.data.model");
@@ -507,6 +509,8 @@
PKCS11_BASE + "/nss/lib/windows-i586/".replace('/', SEP)});
osMap.put("Windows-amd64-64", new String[]{
PKCS11_BASE + "/nss/lib/windows-amd64/".replace('/', SEP)});
+ osMap.put("MacOSX-x86_64-64", new String[]{
+ PKCS11_BASE + "/nss/lib/macosx-x86_64/"});
}
private final static char[] hexDigits = "0123456789abcdef".toCharArray();
--- a/jdk/test/sun/security/pkcs11/Secmod/TrustAnchors.java Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/security/pkcs11/Secmod/TrustAnchors.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -23,7 +23,7 @@
/**
* @test
- * @bug 6298106 6275523 6420252
+ * @bug 6298106 6275523 6420252 8059627
* @summary make sure we can access the NSS trust anchor module
* @author Andreas Sterbenz
* @library ..
@@ -43,10 +43,12 @@
return;
}
- if (System.getProperty("os.name").toLowerCase().startsWith("win")) {
- // our secmod.db file says nssckbi.*so*, so NSS does not find the
- // *DLL* on windows.
- System.out.println("Test currently does not work on Windows, skipping");
+ // our secmod.db file says nssckbi.*so*, so NSS does not find the
+ // *DLL* on Windows nor the *DYLIB* on Mac OSX.
+ String osName = System.getProperty("os.name").toLowerCase();
+ if (osName.startsWith("win") || osName.startsWith("mac")) {
+ System.out.println("Test currently does not work on " + osName +
+ ", skipping");
return;
}
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libfreebl3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libnspr4.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libnss3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libnssckbi.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libnssdbm3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libnssutil3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libplc4.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libplds4.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libsoftokn3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libsqlite3.dylib has changed
Binary file jdk/test/sun/security/pkcs11/nss/lib/macosx-x86_64/libssl3.dylib has changed
--- a/jdk/test/sun/security/tools/keytool/ListKeychainStore.sh Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/security/tools/keytool/ListKeychainStore.sh Fri Oct 10 02:24:41 2014 -0700
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2012, 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
@@ -22,7 +22,7 @@
#
# @test
-# @bug 7133495
+# @bug 7133495 8041740
# @summary [macosx] KeyChain KeyStore implementation retrieves only one private key entry
if [ "${TESTJAVA}" = "" ] ; then
@@ -49,8 +49,10 @@
KEYTOOL="${TESTJAVA}/bin/keytool ${TESTTOOLVMOPTS} -storetype KeychainStore -keystore NONE -storepass $PWD"
TEMPORARY_P12="$TESTCLASSES/7133495.p12"
TEMPORARY_KC="$TESTCLASSES/7133495.keychain"
+TEMPORARY_LIST="$TESTCLASSES/7133495.tmp"
CLEANUP_P12="rm -f $TEMPORARY_P12"
CLEANUP_KC="security delete-keychain $TEMPORARY_KC"
+CLEANUP_LIST="rm -f $TEMPORARY_LIST"
# Count the number of private key entries in the Keychain keystores
@@ -115,6 +117,15 @@
fi
echo "Imported keypairs from PKCS12 keystore into the keychain"
+# Adjust the keychain search order
+
+echo "\"$TEMPORARY_KC\"" > $TEMPORARY_LIST
+security list-keychains >> $TEMPORARY_LIST
+security list-keychains -s `xargs < ${TEMPORARY_LIST}`
+`$CLEANUP_LIST`
+echo "Temporary keychain search order:"
+security list-keychains
+
# Recount the number of private key entries in the Keychain keystores
COUNT=`$KEYTOOL -list | grep PrivateKeyEntry | wc -l`
--- a/jdk/test/sun/security/tools/keytool/autotest.sh Thu Oct 09 12:36:23 2014 -0700
+++ b/jdk/test/sun/security/tools/keytool/autotest.sh Fri Oct 10 02:24:41 2014 -0700
@@ -85,9 +85,7 @@
fi
;;
Darwin )
- LIBNAME=`find_one \
- "/Applications/Firefox.app/Contents/MacOS/libsoftokn3.dylib" \
- "/Applications/Thunderbird.app//Contents/MacOS/libsoftokn3.dylib"`
+ LIBNAME="$TESTSRC/../../pkcs11/nss/lib/macosx-x86_64/libsoftokn3.dylib"
;;
* )
echo "Will not run test on: ${OS}"
@@ -102,10 +100,6 @@
echo "Using NSS lib at $LIBNAME"
-if [ $OS = Darwin ]; then
- export DYLD_LIBRARY_PATH=`dirname $LIBNAME`
-fi
-
${COMPILEJAVA}${FS}bin${FS}javac ${TESTJAVACOPTS} ${TESTTOOLVMOPTS} -d . -XDignore.symbol.file \
${TESTSRC}${FS}KeyToolTest.java || exit 10
--- a/langtools/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -275,3 +275,5 @@
ef5427c13e1e741c457a2ed868e3b6d6bf717754 jdk9-b30
0046d55383a9d873ffbc7253d7c5e28ab98c5bea jdk9-b31
ad99965443d19a59e810ae67b0b742bb9722f5ed jdk9-b32
+e891e0c4edc5174a4da6d19dc2d59697b79f1916 jdk9-b33
+e18407fcede818b30709913784cb6b904030531d jdk9-b34
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Attr.java Fri Oct 10 02:24:41 2014 -0700
@@ -3159,14 +3159,6 @@
result = checkId(tree, env1.enclClass.sym.type, sym, env, resultInfo);
}
- /** Report dependencies.
- * @param from The enclosing class sym
- * @param to The found identifier that the class depends on.
- */
- public void reportDependence(Symbol from, Symbol to) {
- // Override if you want to collect the reported dependencies.
- }
-
public void visitSelect(JCFieldAccess tree) {
// Determine the expected kind of the qualifier expression.
int skind = 0;
@@ -3299,10 +3291,6 @@
env.info.selectSuper = selectSuperPrev;
result = checkId(tree, site, sym, env, resultInfo);
-
- if ((tree.sym.kind & TYP) != 0) {
- reportDependence(env.enclClass.sym, tree.sym);
- }
}
//where
/** Determine symbol referenced by a Select expression,
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/LambdaToMethod.java Fri Oct 10 02:24:41 2014 -0700
@@ -825,6 +825,10 @@
if (rcvr == null) return null;
JCExpression rcvrExpr = make.Ident(rcvr);
Type rcvrType = tree.sym.enclClass().type;
+ if (rcvrType == syms.arrayClass.type) {
+ // Map the receiver type to the actually type, not just "array"
+ rcvrType = tree.getQualifierExpression().type;
+ }
if (!rcvr.type.tsym.isSubClass(rcvrType.tsym, types)) {
rcvrExpr = make.TypeCast(make.Type(rcvrType), rcvrExpr).setType(rcvrType);
}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/comp/Resolve.java Fri Oct 10 02:24:41 2014 -0700
@@ -2083,9 +2083,6 @@
if ((kind & TYP) != 0) {
sym = findType(env, name);
- if (sym.kind==TYP) {
- reportDependence(env.enclClass.sym, sym);
- }
if (sym.exists()) return sym;
else if (sym.kind < bestSoFar.kind) bestSoFar = sym;
}
@@ -2094,14 +2091,6 @@
else return bestSoFar;
}
- /** Report dependencies.
- * @param from The enclosing class sym
- * @param to The found identifier that the class depends on.
- */
- public void reportDependence(Symbol from, Symbol to) {
- // Override if you want to collect the reported dependencies.
- }
-
/** Find an identifier in a package which matches a specified kind set.
* @param env The current environment.
* @param name The identifier's name.
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/main/JavaCompiler.java Fri Oct 10 02:24:41 2014 -0700
@@ -1228,12 +1228,6 @@
attr.postAttr(env.tree);
}
compileStates.put(env, CompileState.ATTR);
- if (rootClasses != null && rootClasses.contains(env.enclClass)) {
- // This was a class that was explicitly supplied for compilation.
- // If we want to capture the public api of this class,
- // then now is a good time to do it.
- reportPublicApi(env.enclClass.sym);
- }
}
finally {
log.useSource(prev);
@@ -1242,14 +1236,6 @@
return env;
}
- /** Report the public api of a class that was supplied explicitly for compilation,
- * for example on the command line to javac.
- * @param sym The symbol of the class.
- */
- public void reportPublicApi(ClassSymbol sym) {
- // Override to collect the reported public api.
- }
-
/**
* Perform dataflow checks on attributed parse trees.
* These include checks for definite assignment and unreachable statements.
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/javac/parser/JavacParser.java Fri Oct 10 02:24:41 2014 -0700
@@ -2271,9 +2271,11 @@
}
/*
- * This method parses a statement treating it as a block, relaxing the
- * JLS restrictions, allows us to parse more faulty code, doing so
- * enables us to provide better and accurate diagnostics to the user.
+ * Parse a Statement (JLS 14.5). As an enhancement to improve error recovery,
+ * this method will also recognize variable and class declarations (which are
+ * not legal for a Statement) by delegating the parsing to BlockStatement (JLS 14.2).
+ * If any illegal declarations are found, they will be wrapped in an erroneous tree,
+ * and an error will be produced by this method.
*/
JCStatement parseStatementAsBlock() {
int pos = token.pos;
@@ -2302,6 +2304,8 @@
}
}
+ /**This method parses a statement appearing inside a block.
+ */
List<JCStatement> blockStatement() {
//todo: skip to anchor on error(?)
int pos = token.pos;
@@ -2311,7 +2315,8 @@
case LBRACE: case IF: case FOR: case WHILE: case DO: case TRY:
case SWITCH: case SYNCHRONIZED: case RETURN: case THROW: case BREAK:
case CONTINUE: case SEMI: case ELSE: case FINALLY: case CATCH:
- return List.of(parseStatement());
+ case ASSERT:
+ return List.of(parseSimpleStatement());
case MONKEYS_AT:
case FINAL: {
Comment dc = token.comment(CommentStyle.JAVADOC);
@@ -2343,14 +2348,12 @@
error(token.pos, "local.enum");
dc = token.comment(CommentStyle.JAVADOC);
return List.of(classOrInterfaceOrEnumDeclaration(modifiersOpt(), dc));
- case ASSERT:
- return List.of(parseStatement());
default:
Token prevToken = token;
JCExpression t = term(EXPR | TYPE);
if (token.kind == COLON && t.hasTag(IDENT)) {
nextToken();
- JCStatement stat = parseStatement();
+ JCStatement stat = parseStatementAsBlock();
return List.<JCStatement>of(F.at(pos).Labelled(prevToken.name(), stat));
} else if ((lastmode & TYPE) != 0 && LAX_IDENTIFIER.accepts(token.kind)) {
pos = token.pos;
@@ -2389,10 +2392,8 @@
* | CONTINUE [Ident] ";"
* | ASSERT Expression [ ":" Expression ] ";"
* | ";"
- * | ExpressionStatement
- * | Ident ":" Statement
*/
- public JCStatement parseStatement() {
+ JCStatement parseSimpleStatement() {
int pos = token.pos;
switch (token.kind) {
case LBRACE:
@@ -2542,24 +2543,17 @@
JCAssert t = toP(F.at(pos).Assert(assertion, message));
return t;
}
- case ENUM:
default:
- Token prevToken = token;
- JCExpression expr = parseExpression();
- if (token.kind == COLON && expr.hasTag(IDENT)) {
- nextToken();
- JCStatement stat = parseStatement();
- return F.at(pos).Labelled(prevToken.name(), stat);
- } else {
- // This Exec is an "ExpressionStatement"; it subsumes the terminating semicolon
- expr = checkExprStat(expr);
- accept(SEMI);
- JCExpressionStatement stat = toP(F.at(pos).Exec(expr));
- return stat;
- }
+ Assert.error();
+ return null;
}
}
+ @Override
+ public JCStatement parseStatement() {
+ return parseStatementAsBlock();
+ }
+
private JCStatement doRecover(int startPos, ErrorRecoveryAction action, String key) {
int errPos = S.errPos();
JCTree stm = action.doRecover(this);
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/Util.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/Util.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,6 +26,8 @@
package com.sun.tools.sjavac;
import java.io.File;
+import java.io.PrintWriter;
+import java.io.StringWriter;
import java.nio.file.Path;
import java.util.Arrays;
import java.util.HashSet;
@@ -173,6 +175,20 @@
return null;
}
+ public static <E> Set<E> union(Set<? extends E> s1,
+ Set<? extends E> s2) {
+ Set<E> union = new HashSet<>();
+ union.addAll(s1);
+ union.addAll(s2);
+ return union;
+ }
+
+ public static String getStackTrace(Throwable t) {
+ StringWriter sw = new StringWriter();
+ t.printStackTrace(new PrintWriter(sw));
+ return sw.toString();
+ }
+
// TODO: Remove when refactoring from java.io.File to java.nio.file.Path.
public static File pathToFile(Path path) {
return path == null ? null : path.toFile();
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/client/SjavacClient.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/client/SjavacClient.java Fri Oct 10 02:24:41 2014 -0700
@@ -172,7 +172,7 @@
} catch (IOException | ClassNotFoundException ex) {
Log.error("Exception caught: " + ex);
result = new CompilationResult(CompilationResult.ERROR_FATAL);
- result.stderr = ex.getMessage();
+ result.stderr = Util.getStackTrace(ex);
}
return result;
}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/AttrWithDeps.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,68 +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. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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 com.sun.tools.sjavac.comp;
-
-import com.sun.tools.javac.comp.Attr;
-import com.sun.tools.javac.util.Context;
-import com.sun.tools.javac.code.Symbol;
-
-/** Subclass to Attr that overrides reportDepedence.
- *
- * <p><b>This is NOT part of any supported API.
- * If you write code that depends on this, you do so at your own risk.
- * This code and its internal interfaces are subject to change or
- * deletion without notice.</b>
- */
-public class AttrWithDeps extends Attr {
-
- /** The dependency database
- */
- protected Dependencies deps;
-
- protected AttrWithDeps(Context context) {
- super(context);
- deps = Dependencies.instance(context);
- }
-
- public static void preRegister(Context context) {
- context.put(attrKey, new Context.Factory<Attr>() {
- public Attr make(Context c) {
- Attr instance = new AttrWithDeps(c);
- c.put(Attr.class, instance);
- return instance;
- }
- });
- }
-
- /** Collect dependencies in the enclosing class
- * @param from The enclosing class sym
- * @param to The enclosing classes references this sym.
- * */
- @Override
- public void reportDependence(Symbol from, Symbol to) {
- // Capture dependencies between the packages.
- deps.collect(from.packge().fullname, to.packge().fullname);
- }
-}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/JavaCompilerWithDeps.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,107 +0,0 @@
-/*
- * Copyright (c) 2012, 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. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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 com.sun.tools.sjavac.comp;
-
-import java.util.StringTokenizer;
-
-import com.sun.tools.javac.main.JavaCompiler;
-import com.sun.tools.javac.util.Context;
-import com.sun.tools.javac.code.Symbol.ClassSymbol;
-
-/** Subclass to Resolve that overrides collect.
- *
- * <p><b>This is NOT part of any supported API.
- * If you write code that depends on this, you do so at your own risk.
- * This code and its internal interfaces are subject to change or
- * deletion without notice.</b>
- */
-public class JavaCompilerWithDeps extends JavaCompiler {
-
- /** The dependency database
- */
- protected Dependencies deps;
- protected SjavacErrorHandler errorHandler;
-
- public JavaCompilerWithDeps(Context context, SjavacErrorHandler eh) {
- super(context);
- deps = Dependencies.instance(context);
- errorHandler = eh;
- needRootClasses = true;
- }
-
- public static void preRegister(Context context, final SjavacErrorHandler eh) {
- context.put(compilerKey, new Context.Factory<JavaCompiler>() {
- public JavaCompiler make(Context c) {
- JavaCompiler instance = new JavaCompilerWithDeps(c, eh);
- c.put(JavaCompiler.class, instance);
- return instance;
- }
- });
- }
-
- /** Collect the public apis of classes supplied explicitly for compilation.
- * @param sym The class to visit.
- */
- @Override
- public void reportPublicApi(ClassSymbol sym) {
- // The next test will catch when source files are located in the wrong directory!
- // This ought to be moved into javac as a new warning, or perhaps as part
- // of the auxiliary class warning.
-
- // For example if sun.swing.BeanInfoUtils
- // is in fact stored in: /mybuild/jdk/gensrc/javax/swing/beaninfo/BeanInfoUtils.java
-
- // We do not need to test that BeanInfoUtils is stored in a file named BeanInfoUtils
- // since this is checked earlier.
- if (sym.sourcefile != null) {
- // Rewrite sun.swing.BeanInfoUtils into /sun/swing/
- StringBuilder pathb = new StringBuilder();
- StringTokenizer qn = new StringTokenizer(sym.packge().toString(), ".");
- boolean first = true;
- while (qn.hasMoreTokens()) {
- String o = qn.nextToken();
- pathb.append("/");
- pathb.append(o);
- first = false;
- }
- pathb.append("/");
- String path = pathb.toString();
-
- // Now cut the uri to be: file:///mybuild/jdk/gensrc/javax/swing/beaninfo/
- String p = sym.sourcefile.toUri().getPath();
- // Do not use File.separatorChar here, a URI always uses slashes /.
- int i = p.lastIndexOf("/");
- String pp = p.substring(0,i+1);
-
- // Now check if the truncated uri ends with the path. (It does not == failure!)
- if (path.length() > 0 && !path.equals("/unnamed package/") && !pp.endsWith(path)) {
- errorHandler.logError("Error: The source file "+sym.sourcefile.getName()+
- " is located in the wrong package directory, because it contains the class "+
- sym.getQualifiedName());
- }
- }
- deps.visitPubapi(sym);
- }
-}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/PathAndPackageVerifier.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,147 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp;
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import javax.tools.JavaFileObject;
+
+import com.sun.source.tree.CompilationUnitTree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCIdent;
+import com.sun.tools.javac.util.DefinedBy;
+import com.sun.tools.javac.util.DefinedBy.Api;
+import com.sun.tools.javac.util.Name;
+
+public class PathAndPackageVerifier implements TaskListener {
+
+ // Stores the set of compilation units whose source file path does not
+ // match the package declaration.
+ Set<CompilationUnitTree> misplacedCompilationUnits = new HashSet<>();
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void started(TaskEvent e) {
+ }
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void finished(TaskEvent e) {
+ if (e.getKind() != TaskEvent.Kind.ANALYZE)
+ return;
+
+ CompilationUnitTree cu = e.getCompilationUnit();
+ if (cu == null)
+ return;
+
+ JavaFileObject jfo = cu.getSourceFile();
+ if (jfo == null)
+ return; // No source file -> package doesn't matter
+
+ JCTree pkg = (JCTree) cu.getPackageName();
+ if (pkg == null)
+ return; // Default package. See JDK-8048144.
+
+ Path dir = Paths.get(jfo.toUri()).normalize().getParent();
+ if (!checkPathAndPackage(dir, pkg))
+ misplacedCompilationUnits.add(cu);
+ }
+
+ /* Returns true if dir matches pkgName.
+ *
+ * Examples:
+ * (a/b/c, a.b.c) gives true
+ * (i/j/k, i.x.k) gives false
+ *
+ * Currently (x/a/b/c, a.b.c) also gives true. See JDK-8059598.
+ */
+ private boolean checkPathAndPackage(Path dir, JCTree pkgName) {
+ Iterator<String> pathIter = new ParentIterator(dir);
+ Iterator<String> pkgIter = new EnclosingPkgIterator(pkgName);
+ while (pathIter.hasNext() && pkgIter.hasNext()) {
+ if (!pathIter.next().equals(pkgIter.next()))
+ return false;
+ }
+ return !pkgIter.hasNext(); /*&& !pathIter.hasNext() See JDK-8059598 */
+ }
+
+ public Set<CompilationUnitTree> getMisplacedCompilationUnits() {
+ return misplacedCompilationUnits;
+ }
+
+ /* Iterates over the names of the parents of the given path:
+ * Example: dir1/dir2/dir3 results in dir3 -> dir2 -> dir1
+ */
+ private static class ParentIterator implements Iterator<String> {
+ Path next;
+ ParentIterator(Path initial) {
+ next = initial;
+ }
+ @Override
+ public boolean hasNext() {
+ return next != null;
+ }
+ @Override
+ public String next() {
+ String tmp = next.getFileName().toString();
+ next = next.getParent();
+ return tmp;
+ }
+ }
+
+ /* Iterates over the names of the enclosing packages:
+ * Example: pkg1.pkg2.pkg3 results in pkg3 -> pkg2 -> pkg1
+ */
+ private static class EnclosingPkgIterator implements Iterator<String> {
+ JCTree next;
+ EnclosingPkgIterator(JCTree initial) {
+ next = initial;
+ }
+ @Override
+ public boolean hasNext() {
+ return next != null;
+ }
+ @Override
+ public String next() {
+ Name name;
+ if (next instanceof JCIdent) {
+ name = ((JCIdent) next).name;
+ next = null;
+ } else {
+ JCFieldAccess fa = (JCFieldAccess) next;
+ name = fa.name;
+ next = fa.selected;
+ }
+ return name.toString();
+ }
+ }
+}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/ResolveWithDeps.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,67 +0,0 @@
-/*
- * Copyright (c) 2012, 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. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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 com.sun.tools.sjavac.comp;
-
-import com.sun.tools.javac.comp.Resolve;
-import com.sun.tools.javac.util.Context;
-import com.sun.tools.javac.code.Symbol;
-
-/** Subclass to Resolve that overrides collect.
- *
- * <p><b>This is NOT part of any supported API.
- * If you write code that depends on this, you do so at your own risk.
- * This code and its internal interfaces are subject to change or
- * deletion without notice.</b>
- */
-public class ResolveWithDeps extends Resolve {
-
- /** The dependency database
- */
- protected Dependencies deps;
-
- protected ResolveWithDeps(Context context) {
- super(context);
- deps = Dependencies.instance(context);
- }
-
- public static void preRegister(Context context) {
- context.put(resolveKey, new Context.Factory<Resolve>() {
- public Resolve make(Context c) {
- Resolve instance = new ResolveWithDeps(c);
- c.put(Resolve.class, instance);
- return instance;
- }
- });
- }
- /** Collect dependencies in the enclosing class
- * @param from The enclosing class sym
- * @param to The enclosing classes references this sym.
- * */
- @Override
- public void reportDependence(Symbol from, Symbol to) {
- // Capture dependencies between the packages.
- deps.collect(from.packge().fullname, to.packge().fullname);
- }
-}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/SjavacErrorHandler.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +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. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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 com.sun.tools.sjavac.comp;
-
-/**
- * <p><b>This is NOT part of any supported API.
- * If you write code that depends on this, you do so at your own risk.
- * This code and its internal interfaces are subject to change or
- * deletion without notice.</b>
- */
-public interface SjavacErrorHandler {
- void logError(String msg);
-}
--- a/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/SjavacImpl.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/SjavacImpl.java Fri Oct 10 02:24:41 2014 -0700
@@ -28,20 +28,25 @@
import java.io.PrintWriter;
import java.io.StringWriter;
import java.net.URI;
+import java.nio.file.Paths;
import java.util.Arrays;
import java.util.List;
import java.util.Set;
-import java.util.concurrent.atomic.AtomicBoolean;
-import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
+import com.sun.source.tree.CompilationUnitTree;
import com.sun.tools.javac.api.JavacTaskImpl;
import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.ListBuffer;
import com.sun.tools.javac.util.Options;
+import com.sun.tools.sjavac.Util;
+import com.sun.tools.sjavac.comp.dependencies.DependencyCollector;
+import com.sun.tools.sjavac.comp.dependencies.PublicApiCollector;
import com.sun.tools.sjavac.server.CompilationResult;
import com.sun.tools.sjavac.server.Sjavac;
import com.sun.tools.sjavac.server.SysInfo;
@@ -70,20 +75,10 @@
List<File> explicitSources,
Set<URI> sourcesToCompile,
Set<URI> visibleSources) {
- final AtomicBoolean forcedExit = new AtomicBoolean();
-
JavacTool compiler = JavacTool.create();
StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
SmartFileManager smartFileManager = new SmartFileManager(fileManager);
Context context = new Context();
- ResolveWithDeps.preRegister(context);
- AttrWithDeps.preRegister(context);
- JavaCompilerWithDeps.preRegister(context, new SjavacErrorHandler() {
- @Override
- public void logError(String msg) {
- forcedExit.set(true);
- }
- });
// Now setup the actual compilation....
CompilationResult compilationResult = new CompilationResult(0);
@@ -101,13 +96,16 @@
for (JavaFileObject i : fileManager.getJavaFileObjectsFromFiles(sourcesToCompileFiles)) {
compilationUnits.append(i);
}
- forcedExit.set(false);
+
// Create a new logger.
StringWriter stdoutLog = new StringWriter();
StringWriter stderrLog = new StringWriter();
PrintWriter stdout = new PrintWriter(stdoutLog);
PrintWriter stderr = new PrintWriter(stderrLog);
com.sun.tools.javac.main.Main.Result rc = com.sun.tools.javac.main.Main.Result.OK;
+ DependencyCollector depsCollector = new DependencyCollector();
+ PublicApiCollector pubApiCollector = new PublicApiCollector();
+ PathAndPackageVerifier papVerifier = new PathAndPackageVerifier();
try {
if (compilationUnits.size() > 0) {
smartFileManager.setVisibleSources(visibleSources);
@@ -115,32 +113,51 @@
smartFileManager.setLog(stdout);
// Do the compilation!
- CompilationTask task = compiler.getTask(stderr,
- smartFileManager,
- null,
- Arrays.asList(args),
- null,
- compilationUnits,
- context);
+ JavacTaskImpl task =
+ (JavacTaskImpl) compiler.getTask(stderr,
+ smartFileManager,
+ null,
+ Arrays.asList(args),
+ null,
+ compilationUnits,
+ context);
smartFileManager.setSymbolFileEnabled(!Options.instance(context).isSet("ignore.symbol.file"));
- rc = ((JavacTaskImpl) task).doCall();
+ task.addTaskListener(depsCollector);
+ task.addTaskListener(pubApiCollector);
+ task.addTaskListener(papVerifier);
+ rc = task.doCall();
smartFileManager.flush();
}
} catch (Exception e) {
- stderrLog.append(e.getMessage());
- forcedExit.set(true);
+ stderrLog.append(Util.getStackTrace(e));
+ rc = com.sun.tools.javac.main.Main.Result.ERROR;
}
compilationResult.packageArtifacts = smartFileManager.getPackageArtifacts();
Dependencies deps = Dependencies.instance(context);
+ for (PackageSymbol from : depsCollector.getSourcePackages()) {
+ for (PackageSymbol to : depsCollector.getDependenciesForPkg(from))
+ deps.collect(from.fullname, to.fullname);
+ }
+
+ for (ClassSymbol cs : pubApiCollector.getClassSymbols())
+ deps.visitPubapi(cs);
+
+ if (papVerifier.getMisplacedCompilationUnits().size() > 0) {
+ for (CompilationUnitTree cu : papVerifier.getMisplacedCompilationUnits()) {
+ System.err.println("Misplaced compilation unit.");
+ System.err.println(" Directory: " + Paths.get(cu.getSourceFile().toUri()).getParent());
+ System.err.println(" Package: " + cu.getPackageName());
+ }
+ rc = com.sun.tools.javac.main.Main.Result.ERROR;
+ }
+
compilationResult.packageDependencies = deps.getDependencies();
compilationResult.packagePubapis = deps.getPubapis();
-
compilationResult.stdout = stdoutLog.toString();
compilationResult.stderr = stderrLog.toString();
-
- compilationResult.returnCode = rc.exitCode == 0 && forcedExit.get() ? -1 : rc.exitCode;
+ compilationResult.returnCode = rc.exitCode;
return compilationResult;
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/Dependency.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,33 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.Set;
+
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+
+interface Dependency {
+ Set<PackageSymbol> getPackages();
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/DependencyCollector.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,76 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.DefinedBy;
+import com.sun.tools.javac.util.DefinedBy.Api;
+import com.sun.tools.sjavac.Util;
+
+public class DependencyCollector implements TaskListener {
+
+ Map<PackageSymbol, Set<PackageSymbol>> collectedDependencies = new HashMap<>();
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void started(TaskEvent e) {
+ }
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void finished(TaskEvent e) {
+ if (e.getKind() == TaskEvent.Kind.ANALYZE) {
+ JCCompilationUnit cu = (JCCompilationUnit) e.getCompilationUnit();
+ PackageSymbol thisPkg = cu.packge;
+ if (thisPkg == null) {
+ // Compilation unit in default package. See JDK-8048144.
+ return;
+ }
+ DependencyScanner ds = new DependencyScanner();
+ cu.accept(ds);
+ Set<PackageSymbol> pkgDeps = ds.getResult()
+ .stream()
+ .flatMap(dep -> dep.getPackages().stream())
+ .collect(Collectors.toSet());
+ collectedDependencies.merge(thisPkg, pkgDeps, Util::union);
+ }
+ }
+
+ public Set<PackageSymbol> getSourcePackages() {
+ return collectedDependencies.keySet();
+ }
+
+ public Set<PackageSymbol> getDependenciesForPkg(PackageSymbol ps) {
+ return collectedDependencies.get(ps);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/DependencyScanner.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,84 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.TypeTag;
+import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
+import com.sun.tools.javac.tree.JCTree.JCIdent;
+import com.sun.tools.javac.tree.TreeScanner;
+
+class DependencyScanner extends TreeScanner {
+
+ public final Set<Dependency> dependencies = new HashSet<>();
+
+ private boolean isValidDependency(Type t) {
+ if (t == null || t.isPrimitiveOrVoid() || t.isErroneous())
+ return false;
+ TypeTag tag = t.getTag();
+ return tag != TypeTag.PACKAGE
+ && tag != TypeTag.METHOD
+ && tag != TypeTag.ARRAY
+ && tag != TypeTag.TYPEVAR;
+ }
+
+ @Override
+ public void visitIdent(JCIdent tree) {
+ if (isValidDependency(tree.type))
+ dependencies.add(new TypeAndSupertypesDependency(tree.type.tsym));
+ super.visitIdent(tree);
+ }
+
+ @Override
+ public void visitSelect(JCFieldAccess tree) {
+ if (tree.getIdentifier().contentEquals("*")) {
+ Symbol sym = tree.selected instanceof JCIdent ? ((JCIdent) tree.selected).sym
+ : ((JCFieldAccess) tree.selected).sym;
+ if (sym instanceof ClassSymbol) {
+ ClassSymbol clsSym = (ClassSymbol) sym;
+ dependencies.add(new TypeAndSupertypesDependency(clsSym.type.tsym));
+ } else {
+ dependencies.add(new PackageDependency((PackageSymbol) sym));
+ }
+ } else if (tree.type != null && tree.type.hasTag(TypeTag.METHOD)) { // Method call? Depend on the result (even though we never access it elsewhere)
+ Type retType = tree.type.getReturnType();
+ if (isValidDependency(retType))
+ dependencies.add(new TypeAndSupertypesDependency(retType.tsym));
+ } else if (isValidDependency(tree.type)) {
+ dependencies.add(new TypeAndSupertypesDependency(tree.type.tsym));
+ }
+ super.visitSelect(tree);
+ }
+
+ public Set<Dependency> getResult() {
+ return dependencies;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/PackageDependency.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,41 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.Collections;
+import java.util.Set;
+
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+
+public class PackageDependency implements Dependency {
+ PackageSymbol ps;
+ public PackageDependency(PackageSymbol ps) {
+ this.ps = ps;
+ }
+ @Override
+ public Set<PackageSymbol> getPackages() {
+ return Collections.singleton(ps);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/PublicApiCollector.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,61 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.sun.source.tree.Tree;
+import com.sun.source.util.TaskEvent;
+import com.sun.source.util.TaskListener;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.util.DefinedBy;
+import com.sun.tools.javac.util.DefinedBy.Api;
+
+public class PublicApiCollector implements TaskListener {
+
+ final Set<ClassSymbol> classSymbols = new HashSet<>();
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void started(TaskEvent e) {
+ }
+
+ @Override
+ @DefinedBy(Api.COMPILER_TREE)
+ public void finished(TaskEvent e) {
+ if (e.getKind() == TaskEvent.Kind.ANALYZE) {
+ for (Tree t : e.getCompilationUnit().getTypeDecls()) {
+ if (t instanceof JCClassDecl) // Can also be a JCSkip
+ classSymbols.add(((JCClassDecl) t).sym);
+ }
+ }
+ }
+
+ public Set<ClassSymbol> getClassSymbols() {
+ return classSymbols;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/src/jdk.compiler/share/classes/com/sun/tools/sjavac/comp/dependencies/TypeAndSupertypesDependency.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,74 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 com.sun.tools.sjavac.comp.dependencies;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Objects;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.javac.code.Symbol.TypeSymbol;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Type;
+
+
+public class TypeAndSupertypesDependency implements Dependency {
+
+ protected TypeSymbol type;
+
+ public TypeAndSupertypesDependency(TypeSymbol type) {
+ this.type = Objects.requireNonNull(type);
+ }
+
+ private Set<TypeSymbol> allSupertypes(TypeSymbol t) {
+ if (t == null)
+ return Collections.emptySet();
+ Set<TypeSymbol> result = new HashSet<>();
+ result.add(t);
+ if (t instanceof ClassSymbol) {
+ ClassSymbol cs = (ClassSymbol) t;
+ result.addAll(allSupertypes(cs.getSuperclass().tsym));
+ for (Type it : cs.getInterfaces())
+ result.addAll(allSupertypes(it.tsym));
+ }
+ return result;
+ }
+
+ @Override
+ public Set<PackageSymbol> getPackages() {
+ if (type.kind == Kinds.ERR)
+ return Collections.emptySet();
+ if (type instanceof ClassSymbol) {
+ return allSupertypes(type).stream()
+ .map(TypeSymbol::packge)
+ .collect(Collectors.toSet());
+ }
+ throw new AssertionError("Could not get package name for " + type);
+ }
+}
+
--- a/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/ClassUseWriter.java Fri Oct 10 02:24:41 2014 -0700
@@ -333,7 +333,7 @@
HtmlTree ul = new HtmlTree(HtmlTag.UL);
ul.addStyle(HtmlStyle.blockList);
for (PackageDoc pkg : pkgSet) {
- Content li = HtmlTree.LI(HtmlStyle.blockList, getMarkerAnchor(pkg.name()));
+ Content li = HtmlTree.LI(HtmlStyle.blockList, getMarkerAnchor(getPackageAnchorName(pkg)));
Content link = getResource("doclet.ClassUse_Uses.of.0.in.1",
getLink(new LinkInfoImpl(configuration, LinkInfoImpl.Kind.CLASS_USE_HEADER,
classdoc)),
@@ -355,7 +355,7 @@
*/
protected void addPackageUse(PackageDoc pkg, Content contentTree) throws IOException {
Content tdFirst = HtmlTree.TD(HtmlStyle.colFirst,
- getHyperLink(pkg.name(), new StringContent(utils.getPackageName(pkg))));
+ getHyperLink(getPackageAnchorName(pkg), new StringContent(utils.getPackageName(pkg))));
contentTree.addContent(tdFirst);
HtmlTree tdLast = new HtmlTree(HtmlTag.TD);
tdLast.addStyle(HtmlStyle.colLast);
--- a/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/HtmlDocletWriter.java Fri Oct 10 02:24:41 2014 -0700
@@ -992,6 +992,16 @@
}
/**
+ * Given a package, return the name to be used in HTML anchor tag.
+ * @param packageDoc the package.
+ * @return the name to be used in HTML anchor tag.
+ */
+ public String getPackageAnchorName(PackageDoc packageDoc) {
+ return packageDoc == null || packageDoc.name().length() == 0 ?
+ SectionName.UNNAMED_PACKAGE_ANCHOR.getName() : packageDoc.name();
+ }
+
+ /**
* Return the link to the given package.
*
* @param pkg the package to link to.
--- a/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/PackageUseWriter.java Fri Oct 10 02:24:41 2014 -0700
@@ -207,7 +207,7 @@
} else {
tr.addStyle(HtmlStyle.rowColor);
}
- addClassRow(itc.next(), packageName, tr);
+ addClassRow(itc.next(), usingPackage, tr);
tbody.addContent(tr);
}
table.addContent(tbody);
@@ -220,15 +220,15 @@
* Add a row for the class that uses the given package.
*
* @param usedClass the class that uses the given package
- * @param packageName the name of the package to which the class belongs
+ * @param pkg the package to which the class belongs
* @param contentTree the content tree to which the row will be added
*/
- protected void addClassRow(ClassDoc usedClass, String packageName,
+ protected void addClassRow(ClassDoc usedClass, PackageDoc pkg,
Content contentTree) {
DocPath dp = pathString(usedClass,
DocPaths.CLASS_USE.resolve(DocPath.forName(usedClass)));
Content td = HtmlTree.TD(HtmlStyle.colOne,
- getHyperLink(dp.fragment(packageName), new StringContent(usedClass.name())));
+ getHyperLink(dp.fragment(getPackageAnchorName(pkg)), new StringContent(usedClass.name())));
addIndexComment(usedClass, td);
contentTree.addContent(td);
}
--- a/langtools/test/com/sun/javadoc/testPackageDeprecation/TestPackageDeprecation.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/com/sun/javadoc/testPackageDeprecation/TestPackageDeprecation.java Fri Oct 10 02:24:41 2014 -0700
@@ -23,7 +23,7 @@
/*
* @test
- * @bug 6492694 8026567
+ * @bug 6492694 8026567 8048351
* @summary Test package deprecation.
* @author bpatel
* @library ../lib/
@@ -70,6 +70,8 @@
"pkg1");
checkOutput("allclasses-frame.html", false,
"FooDepr");
+ checkOutput("class-use/C2.ModalExclusionType.html", true,
+ "<td class=\"colFirst\"><a href=\"#unnamed.package\"><Unnamed></a></td>");
checkFiles(false,
"pkg1/package-summary.html",
--- a/langtools/test/com/sun/javadoc/testUseOption/TestUseOption.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/com/sun/javadoc/testUseOption/TestUseOption.java Fri Oct 10 02:24:41 2014 -0700
@@ -23,7 +23,7 @@
/*
* @test
- * @bug 4496290 4985072 7006178 7068595 8016328 8050031
+ * @bug 4496290 4985072 7006178 7068595 8016328 8050031 8048351
* @summary A simple test to ensure class-use files are correct.
* @author jamieh
* @library ../lib
@@ -134,9 +134,12 @@
"Uses of <a href=\"../UsedInC.html\" title=\"class in <Unnamed>\">"
+ "UsedInC</a> in <a href=\"../package-summary.html\"><Unnamed></a>"
);
+ checkOutput("class-use/UsedInC.html", true,
+ "<li class=\"blockList\"><a name=\"unnamed.package\">"
+ );
checkOutput("package-use.html", true,
"<td class=\"colOne\">"
- + "<a href=\"class-use/UsedInC.html#%3CUnnamed%3E\">UsedInC</a> </td>"
+ + "<a href=\"class-use/UsedInC.html#unnamed.package\">UsedInC</a> </td>"
);
}
--- a/langtools/test/tools/javac/LabeledDeclaration.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/LabeledDeclaration.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,6 +1,6 @@
/*
* @test /nodynamiccopyright/
- * @bug 4039843
+ * @bug 4039843 8057652
* @summary The compiler should not allow labeled declarations.
* @author turnidge
*
--- a/langtools/test/tools/javac/LabeledDeclaration.out Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/LabeledDeclaration.out Fri Oct 10 02:24:41 2014 -0700
@@ -1,3 +1,2 @@
-LabeledDeclaration.java:12:14: compiler.err.dot.class.expected
-LabeledDeclaration.java:12:10: compiler.err.not.stmt
-2 errors
+LabeledDeclaration.java:12:14: compiler.err.variable.not.allowed
+1 error
--- a/langtools/test/tools/javac/T6306967.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/T6306967.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,32 +1,9 @@
/*
- * Copyright (c) 2006, 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
+ * @test /nodynamiccopyright/
* @bug 6306967
* @summary Variable x is used before initialized
* @author Wei Tao
- * @compile/fail T6306967.java
+ * @compile/fail/ref=T6306967.out -XDrawDiagnostics T6306967.java
*/
public class T6306967 {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/T6306967.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,2 @@
+T6306967.java:18:28: compiler.err.var.might.not.have.been.initialized: x
+1 error
--- a/langtools/test/tools/javac/T6379327.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/T6379327.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,32 +1,9 @@
/*
- * Copyright (c) 2006, 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
+ * @test /nodynamiccopyright/
* @bug 6379327
* @summary Erroneous catch block not detected with anonymous class declaration
* @author Peter Jones, Wei Tao
- * @compile/fail T6379327.java
+ * @compile/fail/ref=T6379327.out -XDrawDiagnostics T6379327.java
*/
import java.security.*;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/T6379327.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,2 @@
+T6379327.java:19:11: compiler.err.except.never.thrown.in.try: java.lang.ClassNotFoundException
+1 error
--- a/langtools/test/tools/javac/T6407257.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/T6407257.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,32 +1,9 @@
/*
- * Copyright (c) 2006, 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
+ * @test /nodynamiccopyright/
* @bug 6407257
* @summary javac locks up when encountering cyclic inheritance
* @author Peter von der Ah\u00e9
- * @compile/fail T6407257.java
+ * @compile/fail/ref=T6407257.out -XDrawDiagnostics T6407257.java
*/
class T6407257a extends T6407257a {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/T6407257.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,2 @@
+T6407257.java:9:1: compiler.err.cyclic.inheritance: T6407257a
+1 error
--- a/langtools/test/tools/javac/T6663588.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/T6663588.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,32 +1,9 @@
/*
- * Copyright (c) 2008, 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
+ * @test /nodynamiccopyright/
* @bug 6663588
* @summary Compiler goes into infinite loop for Cyclic Inheritance test case
* @author Maurizio Cimadamore
- * @compile/fail T6663588.java
+ * @compile/fail/ref=T6663588.out -XDrawDiagnostics T6663588.java
*/
public class T6663588<T extends T6663588.Inner> extends T6663588 {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/T6663588.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,2 @@
+T6663588.java:9:8: compiler.err.cyclic.inheritance: T6663588
+1 error
--- a/langtools/test/tools/javac/UncaughtOverflow.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/UncaughtOverflow.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,36 +1,14 @@
/*
- * Copyright (c) 1997, 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 4035346
+ * @test /nodynamiccopyright/
+ * @bug 4035346 4097402
* @summary Compiler used to allow this initialization, despite the overflow.
* @author turnidge
*
- * @compile/fail UncaughtOverflow.java
+ * @compile/fail/ref=UncaughtOverflow.out -XDrawDiagnostics UncaughtOverflow.java
*/
public
class UncaughtOverflow {
- int i = 100000000000;
+ int i1 = 100000000000;
+ int i2 = -2147483649;
}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/UncaughtOverflow.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,3 @@
+UncaughtOverflow.java:12:14: compiler.err.int.number.too.large: 100000000000
+UncaughtOverflow.java:13:15: compiler.err.int.number.too.large: -2147483649
+2 errors
--- a/langtools/test/tools/javac/UncaughtOverflow2.java Thu Oct 09 12:36:23 2014 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 1998, 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 4097402
- * @summary Compiler used to allow this initialization, despite the overflow.
- * @author turnidge
- *
- * @compile/fail UncaughtOverflow2.java
- */
-
-public
-class UncaughtOverflow2 {
- int i = -2147483649;
-}
--- a/langtools/test/tools/javac/UseEnum.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/UseEnum.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,40 +1,16 @@
/*
- * Copyright (c) 2004, 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
+ * @test /nodynamiccopyright/
* @bug 5013488
* @summary Compiler AssertionError: com.sun.tools.javac.util.Bits.incl(Bits.java:73)
*
- * @compile/fail UseEnum.java
+ * @compile/fail/ref=UseEnum.out -XDrawDiagnostics UseEnum.java
*/
import static java.lang.System.out;
class UseEnum {
-
+ enum Animal {cat, dog, bird, fish};
public static void main(String args[]) {
- enum Animal {cat, dog, bird, fish};
Animal pet;
pet = Animal.cat;
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/UseEnum.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,2 @@
+UseEnum.java:19:29: compiler.err.cant.resolve.location: kindname.variable, beast, , , (compiler.misc.location: kindname.class, UseEnum, null)
+1 error
--- a/langtools/test/tools/javac/VoidArray.java Thu Oct 09 12:36:23 2014 -0700
+++ b/langtools/test/tools/javac/VoidArray.java Fri Oct 10 02:24:41 2014 -0700
@@ -1,33 +1,10 @@
/*
- * Copyright (c) 1997, 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
+ * @test /nodynamiccopyright/
* @bug 4034979
* @summary The compiler should never allow void[] to appear as a type
* in a program.
*
- * @compile/fail VoidArray.java
+ * @compile/fail/ref=VoidArray.out -XDrawDiagnostics VoidArray.java
*/
public
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/VoidArray.out Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,7 @@
+VoidArray.java:12:9: compiler.err.expected: token.identifier
+VoidArray.java:12:13: compiler.err.expected: token.identifier
+VoidArray.java:14:9: compiler.err.expected: token.identifier
+VoidArray.java:14:12: compiler.err.invalid.meth.decl.ret.type.req
+VoidArray.java:14:24: compiler.err.expected: token.identifier
+VoidArray.java:14:28: compiler.err.expected3: ',', ')', '['
+6 errors
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/javac/lambda/MethodReferenceArrayClone.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,67 @@
+/*
+ * 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.
+ */
+
+/*
+ * @test
+ * @bug 8056051
+ * @summary int[]::clone causes "java.lang.NoClassDefFoundError: Array"
+ * @run main MethodReferenceArrayClone
+ */
+
+import java.util.Arrays;
+import java.util.function.Function;
+import java.util.function.Supplier;
+
+public class MethodReferenceArrayClone {
+ public static void main(String[] args) {
+ int[] intArgs = new int[] {1, 2, 3, 4, 5};
+ checkInt("int[]::clone", int[]::clone, intArgs);
+ checkInt("a -> a.clone()", a -> a.clone(), intArgs);
+ checkInt("intArgs::clone", intArgs::clone, intArgs);
+
+ String[] stringArgs = new String[] {"hi", "de", "ho"};
+ checkString("String[]::clone", String[]::clone, stringArgs);
+ checkString("a -> a.clone()", a -> a.clone(), stringArgs);
+ checkString("args::clone", stringArgs::clone, stringArgs);
+ }
+
+ private static void checkInt(String label, Supplier<int[]> s, int[] expected) {
+ if (!Arrays.equals(s.get(), expected)) {
+ throw new RuntimeException("Unexpected value " + label + ": " + Arrays.toString(s.get()));
+ }
+ }
+
+ private static void checkInt(String label, Function<int[], int[]> f, int[] a) {
+ checkInt(label, () -> f.apply(a), a);
+ }
+
+ private static void checkString(String label, Supplier<String[]> s, String[] expected) {
+ if (!Arrays.equals(s.get(), expected)) {
+ throw new RuntimeException("Unexpected value " + label + ": " + Arrays.toString(s.get()));
+ }
+ }
+
+ private static void checkString(String label, Function<String[], String[]> f, String[] a) {
+ checkString(label, () -> f.apply(a), a);
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/DependencyCollection.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,130 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 8056258 8048609
+ * @summary Ensures that the DependencyCollector covers various cases.
+ * @library /tools/lib
+ * @build Wrapper ToolBox
+ * @run main Wrapper DependencyCollection
+ */
+
+import java.io.PrintWriter;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+import com.sun.tools.javac.api.JavacTaskImpl;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.sjavac.comp.SmartFileManager;
+import com.sun.tools.sjavac.comp.dependencies.DependencyCollector;
+
+public class DependencyCollection {
+
+ public static void main(String[] args) {
+ Path src = Paths.get(ToolBox.testSrc, "test-input", "src");
+
+ JavaCompiler javac = ToolProvider.getSystemJavaCompiler();
+ StandardJavaFileManager fileManager = javac.getStandardFileManager(null, null, null);
+ SmartFileManager smartFileManager = new SmartFileManager(fileManager);
+ smartFileManager.setSymbolFileEnabled(false);
+ Iterable<? extends JavaFileObject> fileObjects =
+ fileManager.getJavaFileObjectsFromFiles(Arrays.asList(src.resolve("pkg/Test.java").toFile()));
+ JavacTaskImpl task = (JavacTaskImpl) javac.getTask(new PrintWriter(System.out),
+ smartFileManager,
+ null,
+ Arrays.asList("-d", "classes",
+ "-sourcepath", src.toAbsolutePath().toString()),
+ null,
+ fileObjects);
+ DependencyCollector depsCollector = new DependencyCollector();
+ task.addTaskListener(depsCollector);
+ task.doCall();
+
+ // Find pkg symbol
+ PackageSymbol pkg = findPkgSymbolWithName(depsCollector.getSourcePackages(), "pkg");
+ Set<PackageSymbol> foundDependencies = depsCollector.getDependenciesForPkg(pkg);
+
+ // Print dependencies
+ System.out.println("Found dependencies:");
+ foundDependencies.stream()
+ .sorted(Comparator.comparing(DependencyCollection::extractNumber))
+ .forEach(p -> System.out.println(" " + p));
+
+ // Check result
+ Set<Integer> found = foundDependencies.stream()
+ .map(DependencyCollection::extractNumber)
+ .collect(Collectors.toSet());
+ found.remove(-1); // Dependencies with no number (java.lang etc)
+ Set<Integer> expected = new HashSet<>();
+ for (int i = 2; i <= 30; i++) {
+ if (i == 15) continue; // Case 15 correspond to the type of a throw-away return value.
+ expected.add(i);
+ }
+
+ Set<Integer> missing = new HashSet<>(expected);
+ missing.removeAll(found);
+ if (missing.size() > 0) {
+ System.out.println("Missing dependencies:");
+ missing.forEach(i -> System.out.println(" Dependency " + i));
+ }
+
+ Set<Integer> unexpected = new HashSet<>(found);
+ unexpected.removeAll(expected);
+ if (unexpected.size() > 0) {
+ System.out.println("Unexpected dependencies found:");
+ unexpected.forEach(i -> System.out.println(" Dependency " + i));
+ }
+
+ if (missing.size() > 0 || unexpected.size() > 0)
+ throw new AssertionError("Missing and/or unexpected dependencies found.");
+ }
+
+ private static PackageSymbol findPkgSymbolWithName(Set<PackageSymbol> syms, String name) {
+ for (PackageSymbol ps : syms)
+ if (ps.fullname.toString().equals("pkg"))
+ return ps;
+ throw new AssertionError("Could not find package named \"pkg\".");
+ }
+
+ public static int extractNumber(PackageSymbol p) {
+ Matcher m = Pattern.compile("\\d+").matcher(p.fullname.toString());
+ if (!m.find())
+ return -1;
+ return Integer.parseInt(m.group());
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/IncCompInheritance.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,70 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 8056258
+ * @summary Analysis of public API does not take super classes into account
+ * @library /tools/lib
+ * @build Wrapper ToolBox
+ * @run main Wrapper IncCompInheritance
+ */
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class IncCompInheritance extends SjavacBase {
+ public static void main(String... args) throws Exception {
+
+ Path root = Paths.get(IncCompInheritance.class.getSimpleName() + "Test");
+ Path src = root.resolve("src");
+ Path classes = root.resolve("classes");
+
+ // Prep source files: A <- B <- C
+ String a = "package pkga; public class A { public void m() {} }";
+ String b = "package pkgb; public class B extends pkga.A {}";
+ String c = "package pkgc; public class C extends pkgb.B {{ new pkgb.B().m(); }}";
+ toolbox.writeFile(src.resolve("pkga/A.java"), a);
+ toolbox.writeFile(src.resolve("pkgb/B.java"), b);
+ toolbox.writeFile(src.resolve("pkgc/C.java"), c);
+
+ // Initial compile (should succeed)
+ String server = "--server:portfile=testserver,background=false";
+ int rc1 = compile(server, "-d", classes, src);
+ if (rc1 != 0)
+ throw new AssertionError("Compilation failed unexpectedly");
+
+ // Remove method A.m
+ String aModified = "package pkga; public class A { }";
+ toolbox.writeFile(src.resolve("pkga/A.java"), aModified);
+
+ // Incremental compile (C should now be recompiled even though it
+ // depends on A only through inheritance via B).
+ // Since A.m is removed, this should fail.
+ int rc2 = compile(server, "-d", classes, src);
+ if (rc2 == 0)
+ throw new AssertionError("Compilation succeeded unexpectedly");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/PackagePathMismatch.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,54 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 8059349
+ * @summary This test makes sure file paths matches package declarations
+ * @library /tools/lib
+ * @build Wrapper ToolBox
+ * @run main Wrapper PackagePathMismatch
+ */
+
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class PackagePathMismatch extends SjavacBase {
+ public static void main(String... args) throws Exception {
+
+ Path root = Paths.get(PackagePathMismatch.class.getSimpleName() + "Test");
+ Path src = root.resolve("src");
+ Path classes = root.resolve("classes");
+
+ toolbox.writeFile(src.resolve("a/x/c/Test.java"),
+ "package a.b.c; class Test { }");
+
+ // Compile should fail since package a.b.c does not match path a/x/c.
+ String server = "--server:portfile=testserver,background=false";
+ int rc1 = compile(server, "-d", classes, src);
+ if (rc1 == 0)
+ throw new AssertionError("Compilation succeeded unexpectedly");
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/SjavacBase.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,50 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.reflect.Method;
+import java.util.Arrays;
+
+public class SjavacBase {
+
+ protected final static ToolBox toolbox = new ToolBox();
+
+ /**
+ * Utility method for invoking sjavac. Method accepts Objects as arguments
+ * (which are turned into Strings through Object::toString) to allow clients
+ * to pass for instance Path objects.
+ */
+ public static int compile(Object... args) throws ReflectiveOperationException {
+ // Use reflection to avoid a compile-time dependency on sjavac Main
+ System.err.println("compile: " + Arrays.toString(args));
+ Class<?> c = Class.forName("com.sun.tools.sjavac.Main");
+ Method m = c.getDeclaredMethod("go", String[].class);
+ String[] strArgs = new String[args.length];
+ for (int i = 0; i < args.length; i++)
+ strArgs[i] = args[i].toString();
+ int rc = (Integer) m.invoke(null, (Object) strArgs);
+ return rc;
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/nondependency/pkg26/Cls26.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 nondependency.pkg26;
+
+public class Cls26 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg/Test.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,74 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+// Use fully qualified names to avoid accidentally capturing dependencies in import statements.
+
+package pkg;
+
+import pkg2.*; // pkg2 as a whole
+import pkg3.Cls3; // pkg3.Cls3
+import pkg25.Cls25; // pkg25.Cls25
+import nondependency.pkg26.Cls26; // pkg26.Cls26 (but not nondependency)
+import pkg28.Cls28.Inner28; // pkg29.Cls28, pkg29.Cls28.Inner28
+import static pkg29.Cls29.Inner29; // pkg29.Cls29, pkg29.Cls29.Inner29
+import static pkg30.Cls30.*; // pkg30.Cls30 as a whole
+
+@pkg5.Anno5 // pkg5.Anno5
+public class Test<S extends pkg23.Cls23> // pkg23.Cls23
+ extends pkg4.Cls4/*extends pkg11.Cls11*/<pkg6.Cls6/*extends pkg12.Cls12*/> // pkg4.Cls4, pkg11.Cls11, pkg6.Cls6, pkg12.Cls12
+ implements pkg7.Cls7, pkg8.Cls8<pkg9.Cls9> { // pkg7.Cls7, pkg8.Cls8, pkg9.Cls9
+
+ pkg27.Cls27 cls27[][][] = new pkg27.Cls27[0][0][0]; // pkg27.Cls27
+
+ pkg2.Cls2 cls2;
+ pkg19.Cls19 f19; // pkg19.Cls19
+
+ public static void main(String[] args) { // java.lang.String
+ pkg10.Cls10 o = new pkg10.Cls10(); // pkg10.Cls10
+
+ o.getCls13().getCls14().getCls15(); // pkg13.Cls13, pkg14.Cls14, pkg15.Cls15
+ pkg23.Cls23.f24 = null; // pkg23.Cls23, pkg24.Cls24
+ }
+
+ static pkg16.Cls16 m1(pkg17.Cls17 o) { // pkg16.Cls16, pkg17.Cls17
+ return null;
+ }
+
+ public <T extends pkg18.Cls18> void m2() { // pkg18.Cls18
+ }
+
+ public <T> T m3() {
+ T t;
+ t = null;
+ return t;
+ }
+
+ @pkg20.Anno20(pkg21.Cls21.class) // pkg20.Anno20, pkg21.Cls21
+ private void m3(@pkg22.Anno22 String s) { // pkg22.Anno22
+ Runnable r = () -> { System.out.println("hello"); };
+ }
+
+ private void m4() throws Cls25 { // pkg25.Cls25
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg10/Cls10.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,30 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg10;
+public class Cls10 {
+ public pkg13.Cls13 getCls13() {
+ return null;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg11/Cls11.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg11; public class Cls11 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg12/Cls12.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg12; public class Cls12 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg13/Cls13.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,30 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg13;
+public class Cls13 {
+ public pkg14.Cls14 getCls14() {
+ return null;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg14/Cls14.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,30 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg14;
+public class Cls14 {
+ public int[] getCls15() {
+ return null;
+ }
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg15/Cls15.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg15; public class Cls15 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg16/Cls16.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg16; public class Cls16 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg17/Cls17.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg17; public class Cls17 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg18/Cls18.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg18; public class Cls18 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg19/Cls19.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg19; public class Cls19 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg2/Cls2.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg2; public class Cls2 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg20/Anno20.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg20;
+public @interface Anno20 {
+ Class<?> value();
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg21/Cls21.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg21; public class Cls21 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg22/Anno22.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg22;
+public @interface Anno22 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg23/Cls23.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg23;
+public class Cls23 {
+ public static pkg24.Cls24 f24;
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg24/Cls24.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg24; public class Cls24 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg25/Cls25.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg25;
+
+public class Cls25 extends Throwable {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg27/Cls27.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,26 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg27;
+public class Cls27 {}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg28/Cls28.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg28;
+public class Cls28 {
+ public static class Inner28 {}
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg29/Cls29.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg29;
+public class Cls29 {
+ public static class Inner29 {}
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg3/Cls3.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg3; public class Cls3 { }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg30/Cls30.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,28 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg30;
+
+public class Cls30 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg4/Cls4.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg4;
+public class Cls4<T> extends pkg11.Cls11 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg5/Anno5.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg5;
+public @interface Anno5 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg6/Cls6.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg6;
+public class Cls6 extends pkg12.Cls12 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg7/Cls7.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg7;
+public interface Cls7 {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg8/Cls8.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,27 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg8;
+public interface Cls8<T> {
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/langtools/test/tools/sjavac/test-input/src/pkg9/Cls9.java Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,25 @@
+/*
+ * 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 pkg9; public class Cls9 { }
--- a/make/jprt.properties Thu Oct 09 12:36:23 2014 -0700
+++ b/make/jprt.properties Fri Oct 10 02:24:41 2014 -0700
@@ -483,7 +483,10 @@
${my.make.rule.test.targets.hotspot.servertests}, \
${my.make.rule.test.targets.hotspot.internalvmtests}, \
${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_wbapitest}, \
- ${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_compiler}, \
+ ${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_compiler_1}, \
+ ${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_compiler_2}, \
+ ${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_compiler_3}, \
+ ${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_compiler_closed}, \
${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_gc}, \
${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_runtime}, \
${my.make.rule.test.targets.hotspot.reg.group:GROUP=hotspot_runtime_closed}, \
--- a/modules.xml Thu Oct 09 12:36:23 2014 -0700
+++ b/modules.xml Fri Oct 10 02:24:41 2014 -0700
@@ -1603,6 +1603,9 @@
<depend>jdk.rmic</depend>
<depend>jdk.xml.bind</depend>
<depend>jdk.xml.ws</depend>
+ <export>
+ <name>com.sun.jarsigner</name>
+ </export>
</module>
<module>
<name>jdk.hotspot.agent</name>
--- a/nashorn/.hgtags Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/.hgtags Fri Oct 10 02:24:41 2014 -0700
@@ -266,3 +266,5 @@
072dbed6c5d968a6b9e156c36cd8838b4ff86ea1 jdk9-b30
77efdecfa2a5c28672b7c7dcc2d1b52dcb90d493 jdk9-b31
62ba20541b948fb98a7036d9f01baa54e95fb6fa jdk9-b32
+b374d8910e7f8de2b7ecacee9ae4cad88f23feab jdk9-b33
+4ece2dad8c37f520f1ccc1cf84870f362c8eb9d6 jdk9-b34
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/nashorn/bin/fixwhitespace.sh Fri Oct 10 02:24:41 2014 -0700
@@ -0,0 +1,37 @@
+#!/bin/bash
+#
+# Copyright (c) 2010, 2013, 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.
+#
+
+fix() {
+ #convert tabs to spaces
+ find . -name $1 -exec sed -i "" 's/ / /g' {} \;
+ #remove trailing whitespace
+ find . -name $1 -exec sed -i "" 's/[ ]*$//' \{} \;
+}
+
+if [ ! -z $1 ]; then
+ fix $1;
+else
+ fix "*.java"
+ fix "*.js"
+fi
--- a/nashorn/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/MethodGenerator.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/MethodGenerator.java Fri Oct 10 02:24:41 2014 -0700
@@ -85,6 +85,7 @@
import jdk.internal.org.objectweb.asm.Handle;
import jdk.internal.org.objectweb.asm.MethodVisitor;
import jdk.internal.org.objectweb.asm.Type;
+import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic;
/**
* Base class for all method generating classes.
@@ -97,7 +98,7 @@
private final Type returnType;
private final Type[] argumentTypes;
- static final Type EMPTY_LINK_LOGIC_TYPE = Type.getType("Ljdk/nashorn/internal/objects/annotations/SpecializedFunction$LinkLogic$Empty;");
+ static final Type EMPTY_LINK_LOGIC_TYPE = Type.getType(LinkLogic.getEmptyLinkLogicClass());
MethodGenerator(final MethodVisitor mv, final int access, final String name, final String descriptor) {
super(Main.ASM_VERSION, mv);
--- a/nashorn/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/ScriptClassInfo.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/buildtools/nasgen/src/jdk/nashorn/internal/tools/nasgen/ScriptClassInfo.java Fri Oct 10 02:24:41 2014 -0700
@@ -38,6 +38,7 @@
import jdk.nashorn.internal.objects.annotations.ScriptClass;
import jdk.nashorn.internal.objects.annotations.Setter;
import jdk.nashorn.internal.objects.annotations.SpecializedFunction;
+import jdk.nashorn.internal.objects.annotations.SpecializedFunction.LinkLogic;
import jdk.nashorn.internal.objects.annotations.Where;
import jdk.nashorn.internal.tools.nasgen.MemberInfo.Kind;
@@ -55,8 +56,8 @@
static final String SETTER_ANNO_DESC = Type.getDescriptor(Setter.class);
static final String PROPERTY_ANNO_DESC = Type.getDescriptor(Property.class);
static final String WHERE_ENUM_DESC = Type.getDescriptor(Where.class);
+ static final String LINK_LOGIC_DESC = Type.getDescriptor(LinkLogic.class);
static final String SPECIALIZED_FUNCTION = Type.getDescriptor(SpecializedFunction.class);
- static final String LINK_LOGIC_DESC = "Ljdk/nashorn/internal/objects/annotations/SpecializedFunction$LinkLogic;";
static final Map<String, Kind> annotations = new HashMap<>();
--- a/nashorn/make/BuildNashorn.gmk Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/make/BuildNashorn.gmk Fri Oct 10 02:24:41 2014 -0700
@@ -29,6 +29,7 @@
-include $(SPEC)
include MakeBase.gmk
include JavaCompilation.gmk
+include SetupJavaCompilers.gmk
JDK_CLASSES := $(subst $(SPACE),$(PATH_SEP),$(strip $(addprefix $(JDK_OUTPUTDIR)/modules/, \
java.base java.logging java.scripting)))
@@ -63,10 +64,10 @@
# Build nasgen
$(eval $(call SetupJavaCompilation,BUILD_NASGEN, \
- SETUP := GENERATE_NEWBYTECODE_DEBUG, \
+ SETUP := GENERATE_OLDBYTECODE, \
SRC := $(NASGEN_SRC) $(ASM_SRC), \
BIN := $(NASHORN_OUTPUTDIR)/nasgen_classes, \
- ADD_JAVAC_FLAGS := -cp $(NASHORN_OUTPUTDIR)/nashorn_classes))
+ ADD_JAVAC_FLAGS := -bootclasspath "$(BOOT_RTJAR)$(PATH_SEP)$(NASHORN_OUTPUTDIR)/nashorn_classes"))
# Nasgen needs nashorn classes
$(BUILD_NASGEN): $(BUILD_NASHORN)
--- a/nashorn/make/build.xml Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/make/build.xml Fri Oct 10 02:24:41 2014 -0700
@@ -78,7 +78,7 @@
<istrue value="${jfr}"/>
</condition>
</target>
-
+
<target name="init" depends="init-conditions, init-cc">
<!-- extends jvm args -->
<property name="run.test.jvmargs" value="${run.test.jvmargs.main} ${run.test.cc.jvmargs} ${jfr.options}"/>
@@ -420,6 +420,7 @@
<propertyref prefix="test-sys-prop-no-security."/>
<mapper from="test-sys-prop-no-security.*" to="*" type="glob"/>
</propertyset>
+ <sysproperty key="optimistic.override" value="${optimistic}"/>
<classpath>
<pathelement path="${run.test.classpath}"/>
</classpath>
@@ -431,7 +432,7 @@
<delete dir="${build.dir}/nashorn_code_cache"/>
<property name="debug.test.jvmargs" value=""/>
<testng outputdir="${build.test.results.dir}" classfilesetref="test.classes"
- verbose="${testng.verbose}" haltonfailure="true" useDefaultListeners="false" listeners="${testng.listeners}" workingDir="${basedir}">
+ verbose="${testng.verbose}" haltonfailure="true" useDefaultListeners="false" listeners="${testng.listeners}" workingDir="${basedir}">
<jvmarg line="${ext.class.path}"/>
<jvmarg line="${run.test.jvmargs} -Xmx${run.test.xmx} ${run.test.jvmsecurityargs} -Dbuild.dir=${build.dir}"/>
<jvmarg line="${debug.test.jvmargs}"/>
@@ -442,6 +443,7 @@
<propertyref prefix="test-sys-prop."/>
<mapper from="test-sys-prop.*" to="*" type="glob"/>
</propertyset>
+ <sysproperty key="optimistic.override" value="${optimistic}"/>
<sysproperty key="test.js.excludes.file" value="${exclude.list}"/>
<classpath>
<pathelement path="${run.test.classpath}"/>
@@ -449,7 +451,27 @@
</testng>
</target>
- <target name="test" depends="jar, -test-classes-all,-test-classes-single, check-testng, check-external-tests, compile-test, generate-policy-file, -test-security, -test-nosecurity" if="testng.available"/>
+ <target name="test" depends="test-pessimistic, test-optimistic"/>
+
+ <target name="test-optimistic" depends="jar, -test-classes-all,-test-classes-single, check-testng, check-external-tests, compile-test, generate-policy-file" if="testng.available">
+ <echo message="Running test suite in OPTIMISTIC mode..."/>
+ <antcall target="-test-nosecurity" inheritRefs="true">
+ <param name="optimistic" value="true"/>
+ </antcall>
+ <antcall target="-test-security" inheritRefs="true">
+ <param name="optimistic" value="true"/>
+ </antcall>
+ </target>
+
+ <target name="test-pessimistic" depends="jar, -test-classes-all,-test-classes-single, check-testng, check-external-tests, compile-test, generate-policy-file" if="testng.available">
+ <echo message="Running test suite in PESSIMISTIC mode..."/>
+ <antcall target="-test-nosecurity" inheritRefs="true">
+ <param name="optimistic" value="false"/>
+ </antcall>
+ <antcall target="-test-security" inheritRefs="true">
+ <param name="optimistic" value="false"/>
+ </antcall>
+ </target>
<target name="check-jemmy.jfx.testng" unless="jemmy.jfx.testng.available">
<echo message="WARNING: Jemmy or JavaFX or TestNG not available, will not run tests. Please copy testng.jar, JemmyCore.jar, JemmyFX.jar, JemmyAWTInput.jar under test${file.separator}lib directory. And make sure you have jfxrt.jar in ${java.home}${file.separator}lib${file.separator}ext dir."/>
--- a/nashorn/make/project.properties Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/make/project.properties Fri Oct 10 02:24:41 2014 -0700
@@ -286,7 +286,8 @@
# turn on assertions for tests
run.test.jvmargs.main=${run.test.jvmargs.common} -ea
-# extra jvmargs that might be useful for debugging
+# Extra jvmargs that might be useful for debugging
+# and performance improvements/monitoring
#
# -XX:+UnlockDiagnosticVMOptions
#
@@ -304,9 +305,25 @@
#
# print all compiled nmethods with oopmaps and lots of other info
# -XX:+PrintNMethods
+#
+# activate the generic "UseNewCode" flag to test whatever functionality
+# lies behind it. This is the preferred way to test a, yet flagless,
+# feature in HotSpot - for example, the uncommon trap placement fix
+# was hidden behind this flag before it became the default
+#
+# -XX:+UnlockDiagnosticVMOptions -XX:+UseNewCode
+#
+# Crank up the type profile level to 222, which has some warmup
+# penalties, but produces much better code for JavaScript, where better
+# and more intrusive type profiling is required to get rid of
+# a large amount of unnecessary guard code, that could not otherwise
+# be eliminated
+#
+# -XX:TypeProfileLevel=222
+#
# Use best known performance options for octane
-run.test.jvmargs.octane.main=${run.test.jvmargs.common} -XX:+UnlockDiagnosticVMOptions -XX:+UseNewCode -XX:TypeProfileLevel=222
+run.test.jvmargs.octane.main=${run.test.jvmargs.common} -XX:TypeProfileLevel=222
# Security manager args - make sure that we run with the nashorn.policy that the build creates
run.test.jvmsecurityargs=-Xverify:all -Djava.security.manager -Djava.security.policy=${build.dir}/nashorn.policy
--- a/nashorn/samples/BufferArray.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/samples/BufferArray.java Fri Oct 10 02:24:41 2014 -0700
@@ -29,8 +29,8 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
+import java.nio.DoubleBuffer;
import jdk.nashorn.api.scripting.AbstractJSObject;
-import java.nio.DoubleBuffer;
/**
* Simple class demonstrating pluggable script object
@@ -112,6 +112,8 @@
return true;
}
};
+ default:
+ break;
}
return null;
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/ApplySpecialization.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/ApplySpecialization.java Fri Oct 10 02:24:41 2014 -0700
@@ -27,7 +27,6 @@
import static jdk.nashorn.internal.codegen.CompilerConstants.ARGUMENTS_VAR;
import static jdk.nashorn.internal.codegen.CompilerConstants.EXPLODED_ARGUMENT_PREFIX;
-
import java.lang.invoke.MethodType;
import java.util.ArrayDeque;
import java.util.ArrayList;
@@ -35,7 +34,6 @@
import java.util.HashSet;
import java.util.List;
import java.util.Set;
-
import jdk.nashorn.internal.ir.AccessNode;
import jdk.nashorn.internal.ir.CallNode;
import jdk.nashorn.internal.ir.Expression;
@@ -131,7 +129,7 @@
@SuppressWarnings("serial")
final UnsupportedOperationException uoe = new UnsupportedOperationException() {
@Override
- public Throwable fillInStackTrace() {
+ public synchronized Throwable fillInStackTrace() {
return null;
}
};
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/CodeGenerator.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/CodeGenerator.java Fri Oct 10 02:24:41 2014 -0700
@@ -104,6 +104,7 @@
import jdk.nashorn.internal.ir.IndexNode;
import jdk.nashorn.internal.ir.JoinPredecessor;
import jdk.nashorn.internal.ir.JoinPredecessorExpression;
+import jdk.nashorn.internal.ir.JumpStatement;
import jdk.nashorn.internal.ir.LabelNode;
import jdk.nashorn.internal.ir.LexicalContext;
import jdk.nashorn.internal.ir.LexicalContextNode;
@@ -1204,17 +1205,21 @@
@Override
public boolean enterBreakNode(final BreakNode breakNode) {
+ return enterJumpStatement(breakNode);
+ }
+
+ private boolean enterJumpStatement(final JumpStatement jump) {
if(!method.isReachable()) {
return false;
}
- enterStatement(breakNode);
-
- method.beforeJoinPoint(breakNode);
- final BreakableNode breakFrom = lc.getBreakable(breakNode.getLabelName());
- popScopesUntil(breakFrom);
- final Label breakLabel = breakFrom.getBreakLabel();
- breakLabel.markAsBreakTarget();
- method.splitAwareGoto(lc, breakLabel, breakFrom);
+ enterStatement(jump);
+
+ method.beforeJoinPoint(jump);
+ final BreakableNode target = jump.getTarget(lc);
+ popScopesUntil(target);
+ final Label targetLabel = jump.getTargetLabel(target);
+ targetLabel.markAsBreakTarget();
+ method.splitAwareGoto(lc, targetLabel, target);
return false;
}
@@ -1517,19 +1522,7 @@
@Override
public boolean enterContinueNode(final ContinueNode continueNode) {
- if(!method.isReachable()) {
- return false;
- }
- enterStatement(continueNode);
- method.beforeJoinPoint(continueNode);
-
- final LoopNode continueTo = lc.getContinueTo(continueNode.getLabelName());
- popScopesUntil(continueTo);
- final Label continueLabel = continueTo.getContinueLabel();
- continueLabel.markAsBreakTarget();
- method.splitAwareGoto(lc, continueLabel, continueTo);
-
- return false;
+ return enterJumpStatement(continueNode);
}
@Override
@@ -2807,6 +2800,7 @@
final boolean hasReturn = method.hasReturn();
final SplitMethodEmitter splitMethod = ((SplitMethodEmitter)method);
final List<Label> targets = splitMethod.getExternalTargets();
+ final boolean hasControlFlow = hasReturn || !targets.isEmpty();
final List<BreakableNode> targetNodes = splitMethod.getExternalTargetNodes();
final Type returnType = lc.getCurrentFunction().getReturnType();
@@ -2814,6 +2808,9 @@
// Wrap up this method.
if(method.isReachable()) {
+ if (hasControlFlow) {
+ method.setSplitState(-1);
+ }
method.loadCompilerConstant(RETURN, returnType);
method._return(returnType);
}
@@ -2831,17 +2828,16 @@
throw e;
}
+ //no external jump targets or return in switch node
+ if (!hasControlFlow) {
+ return splitNode;
+ }
+
// Handle return from split method if there was one.
final MethodEmitter caller = method;
final int targetCount = targets.size();
- //no external jump targets or return in switch node
- if (!hasReturn && targets.isEmpty()) {
- return splitNode;
- }
-
- caller.loadCompilerConstant(SCOPE);
- caller.checkcast(Scope.class);
+ caller.loadScope();
caller.invoke(Scope.GET_SPLIT_STATE);
final Label breakLabel = new Label("no_split_state");
@@ -2873,19 +2869,16 @@
caller.loadCompilerConstant(RETURN, returnType);
caller._return(returnType);
} else {
- // Clear split state.
- caller.loadCompilerConstant(SCOPE);
- caller.checkcast(Scope.class);
- caller.load(-1);
- caller.invoke(Scope.SET_SPLIT_STATE);
final BreakableNode targetNode = targetNodes.get(i - 1);
final Label label = targets.get(i - 1);
- final JoinPredecessor jumpOrigin = splitNode.getJumpOrigin(label);
- if(jumpOrigin != null) {
- method.beforeJoinPoint(jumpOrigin);
+ if (!lc.isExternalTarget(splitNode, targetNode)) {
+ final JoinPredecessor jumpOrigin = splitNode.getJumpOrigin(label);
+ if(jumpOrigin != null) {
+ method.beforeJoinPoint(jumpOrigin);
+ }
+ popScopesUntil(targetNode);
}
- popScopesUntil(targetNode);
- caller.splitAwareGoto(lc, targets.get(i - 1), targetNode);
+ caller.splitAwareGoto(lc, label, targetNode);
}
}
caller.label(breakLabel);
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/CompilationPhase.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/CompilationPhase.java Fri Oct 10 02:24:41 2014 -0700
@@ -38,7 +38,6 @@
import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SPLIT;
import static jdk.nashorn.internal.ir.FunctionNode.CompilationState.SYMBOLS_ASSIGNED;
import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
-
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.EnumSet;
@@ -48,7 +47,6 @@
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
-
import jdk.nashorn.internal.AssertsEnabled;
import jdk.nashorn.internal.codegen.Compiler.CompilationPhases;
import jdk.nashorn.internal.ir.FunctionNode;
@@ -627,7 +625,7 @@
/**
* Start a compilation phase
- * @param compiler
+ * @param compiler the compiler to use
* @param functionNode function to compile
* @return function node
*/
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Compiler.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Compiler.java Fri Oct 10 02:24:41 2014 -0700
@@ -32,7 +32,6 @@
import static jdk.nashorn.internal.codegen.CompilerConstants.THIS;
import static jdk.nashorn.internal.codegen.CompilerConstants.VARARGS;
import static jdk.nashorn.internal.runtime.logging.DebugLogger.quote;
-
import java.io.File;
import java.lang.invoke.MethodType;
import java.util.Arrays;
@@ -154,6 +153,13 @@
private RecompilableScriptFunctionData compiledFunction;
/**
+ * Most compile unit names are longer than the default StringBuilder buffer,
+ * worth startup performance when massive class generation is going on to increase
+ * this
+ */
+ private static final int COMPILE_UNIT_NAME_BUFFER_SIZE = 32;
+
+ /**
* Compilation phases that a compilation goes through
*/
public static class CompilationPhases implements Iterable<CompilationPhase> {
@@ -452,12 +458,16 @@
@Override
public DebugLogger initLogger(final Context ctxt) {
+ final boolean optimisticTypes = env._optimistic_types;
+ final boolean lazyCompilation = env._lazy_compilation;
+
return ctxt.getLogger(this.getClass(), new Consumer<DebugLogger>() {
@Override
public void accept(final DebugLogger newLogger) {
- if (!Compiler.this.getScriptEnvironment()._lazy_compilation) {
+ if (!lazyCompilation) {
newLogger.warning("WARNING: Running with lazy compilation switched off. This is not a default setting.");
}
+ newLogger.warning("Optimistic types are ", optimisticTypes ? "ENABLED." : "DISABLED.");
}
});
}
@@ -535,9 +545,10 @@
* @throws CompilationException if error occurs during compilation
*/
public FunctionNode compile(final FunctionNode functionNode, final CompilationPhases phases) throws CompilationException {
-
- log.finest("Starting compile job for ", DebugLogger.quote(functionNode.getName()), " phases=", quote(phases.getDesc()));
- log.indent();
+ if (log.isEnabled()) {
+ log.info(">> Starting compile job for ", DebugLogger.quote(functionNode.getName()), " phases=", quote(phases.getDesc()));
+ log.indent();
+ }
final String name = DebugLogger.quote(functionNode.getName());
@@ -554,7 +565,7 @@
long time = 0L;
for (final CompilationPhase phase : phases) {
- log.fine(phase, " starting for ", quote(name));
+ log.fine(phase, " starting for ", name);
try {
newFunctionNode = phase.apply(this, phases, newFunctionNode);
@@ -582,8 +593,11 @@
log.unindent();
if (info) {
- final StringBuilder sb = new StringBuilder();
- sb.append("Compile job for ").append(newFunctionNode.getSource()).append(':').append(quote(newFunctionNode.getName())).append(" finished");
+ final StringBuilder sb = new StringBuilder("<< Finished compile job for ");
+ sb.append(newFunctionNode.getSource()).
+ append(':').
+ append(quote(newFunctionNode.getName()));
+
if (time > 0L && timeLogger != null) {
assert env.isTimingEnabled();
sb.append(" in ").append(time).append(" ms");
@@ -631,7 +645,8 @@
}
String nextCompileUnitName() {
- final StringBuilder sb = new StringBuilder(firstCompileUnitName);
+ final StringBuilder sb = new StringBuilder(COMPILE_UNIT_NAME_BUFFER_SIZE);
+ sb.append(firstCompileUnitName);
final int cuid = nextCompileUnitId.getAndIncrement();
if (cuid > 0) {
sb.append("$cu").append(cuid);
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Label.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Label.java Fri Oct 10 02:24:41 2014 -0700
@@ -590,8 +590,13 @@
return label.getOffset() > other.label.getOffset();
}
+ private String str;
+
@Override
public String toString() {
- return name + '_' + id;
+ if (str == null) {
+ str = name + '_' + id;
+ }
+ return str;
}
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/LocalVariableTypesCalculator.java Fri Oct 10 02:24:41 2014 -0700
@@ -464,21 +464,20 @@
@Override
public boolean enterBreakNode(final BreakNode breakNode) {
- if(!reachable) {
- return false;
- }
-
- final BreakableNode target = lc.getBreakable(breakNode.getLabelName());
- return splitAwareJumpToLabel(breakNode, target, target.getBreakLabel());
+ return enterJumpStatement(breakNode);
}
@Override
public boolean enterContinueNode(final ContinueNode continueNode) {
+ return enterJumpStatement(continueNode);
+ }
+
+ private boolean enterJumpStatement(final JumpStatement jump) {
if(!reachable) {
return false;
}
- final LoopNode target = lc.getContinueTo(continueNode.getLabelName());
- return splitAwareJumpToLabel(continueNode, target, target.getContinueLabel());
+ final BreakableNode target = jump.getTarget(lc);
+ return splitAwareJumpToLabel(jump, target, jump.getTargetLabel(target));
}
private boolean splitAwareJumpToLabel(final JumpStatement jumpStatement, final BreakableNode target, final Label targetLabel) {
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/Lower.java Fri Oct 10 02:24:41 2014 -0700
@@ -52,6 +52,7 @@
import jdk.nashorn.internal.ir.FunctionNode.CompilationState;
import jdk.nashorn.internal.ir.IdentNode;
import jdk.nashorn.internal.ir.IfNode;
+import jdk.nashorn.internal.ir.JumpStatement;
import jdk.nashorn.internal.ir.LabelNode;
import jdk.nashorn.internal.ir.LexicalContext;
import jdk.nashorn.internal.ir.LiteralNode;
@@ -382,12 +383,16 @@
@Override
public Node leaveBreakNode(final BreakNode breakNode) {
- return copy(breakNode, (Node)Lower.this.lc.getBreakable(breakNode.getLabelName()));
+ return leaveJumpStatement(breakNode);
}
@Override
public Node leaveContinueNode(final ContinueNode continueNode) {
- return copy(continueNode, Lower.this.lc.getContinueTo(continueNode.getLabelName()));
+ return leaveJumpStatement(continueNode);
+ }
+
+ private Node leaveJumpStatement(final JumpStatement jump) {
+ return copy(jump, (Node)jump.getTarget(Lower.this.lc));
}
@Override
@@ -627,7 +632,7 @@
@Override
public Node leaveContinueNode(final ContinueNode node) {
// all inner loops have been popped.
- if (lex.contains(lex.getContinueTo(node.getLabelName()))) {
+ if (lex.contains(node.getTarget(lex))) {
escapes.add(node);
}
return node;
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/MethodEmitter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/MethodEmitter.java Fri Oct 10 02:24:41 2014 -0700
@@ -103,6 +103,7 @@
import jdk.nashorn.internal.runtime.Debug;
import jdk.nashorn.internal.runtime.JSType;
import jdk.nashorn.internal.runtime.RewriteException;
+import jdk.nashorn.internal.runtime.Scope;
import jdk.nashorn.internal.runtime.ScriptObject;
import jdk.nashorn.internal.runtime.ScriptRuntime;
import jdk.nashorn.internal.runtime.UnwarrantedOptimismException;
@@ -1046,6 +1047,14 @@
return load(getCompilerConstantSymbol(cc), type != null ? type : getCompilerConstantType(cc));
}
+ MethodEmitter loadScope() {
+ return loadCompilerConstant(SCOPE).checkcast(Scope.class);
+ }
+
+ MethodEmitter setSplitState(final int state) {
+ return loadScope().load(state).invoke(Scope.SET_SPLIT_STATE);
+ }
+
void storeCompilerConstant(final CompilerConstants cc) {
storeCompilerConstant(cc, null);
}
@@ -2134,6 +2143,8 @@
load("Function");
invoke(ScriptRuntime.INVALIDATE_RESERVED_BUILTIN_NAME);
break;
+ default:
+ break;
}
return this;
}
@@ -2574,12 +2585,55 @@
*
* @param args debug information to print
*/
+ @SuppressWarnings("unused")
private void debug(final Object... args) {
if (debug) {
debug(30, args);
}
}
+ private void debug(final String arg) {
+ if (debug) {
+ debug(30, arg);
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1 });
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1, final Object arg2) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1, arg2 });
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1, final Object arg2, final Object arg3) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1, arg2, arg3 });
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1, final Object arg2, final Object arg3, final Object arg4) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1, arg2, arg3, arg4 });
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1, final Object arg2, final Object arg3, final Object arg4, final Object arg5) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1, arg2, arg3, arg4, arg5 });
+ }
+ }
+
+ private void debug(final Object arg0, final Object arg1, final Object arg2, final Object arg3, final Object arg4, final Object arg5, final Object arg6) {
+ if (debug) {
+ debug(30, new Object[] { arg0, arg1, arg2, arg3, arg4, arg5, arg6 });
+ }
+ }
+
/**
* Debug function that outputs generated bytecode and stack contents
* for a label - indentation is currently the only thing that differs
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/OptimisticTypesPersistence.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/OptimisticTypesPersistence.java Fri Oct 10 02:24:41 2014 -0700
@@ -443,7 +443,7 @@
// does not increase filesDeleted
}
files[i] = null; // gc eligible
- };
+ }
}
private static Path[] getAllRegularFilesInLastModifiedOrder() throws IOException {
@@ -454,7 +454,7 @@
@Override
public boolean test(final Path path) {
return !Files.isDirectory(path);
- };
+ }
})
.map(new Function<Path, PathAndTime>() {
@Override
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/SplitMethodEmitter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/SplitMethodEmitter.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,8 +25,6 @@
package jdk.nashorn.internal.codegen;
-import static jdk.nashorn.internal.codegen.CompilerConstants.SCOPE;
-
import java.util.ArrayList;
import java.util.List;
import jdk.internal.org.objectweb.asm.MethodVisitor;
@@ -34,7 +32,6 @@
import jdk.nashorn.internal.ir.BreakableNode;
import jdk.nashorn.internal.ir.LexicalContext;
import jdk.nashorn.internal.ir.SplitNode;
-import jdk.nashorn.internal.runtime.Scope;
/**
* Emitter used for splitting methods. Needs to keep track of if there are jump targets
@@ -65,15 +62,13 @@
assert splitNode != null;
final int index = findExternalTarget(lc, label, targetNode);
if (index >= 0) {
- loadCompilerConstant(SCOPE);
- checkcast(Scope.class);
- load(index + 1);
- invoke(Scope.SET_SPLIT_STATE);
- loadUndefined(Type.OBJECT);
- _return(functionNode.getReturnType());
- return;
+ setSplitState(index + 1); // 0 is ordinary return
+ final Type retType = functionNode.getReturnType();
+ loadUndefined(retType);
+ _return(retType);
+ } else {
+ super.splitAwareGoto(lc, label, targetNode);
}
- super.splitAwareGoto(lc, label, targetNode);
}
private int findExternalTarget(final LexicalContext lc, final Label label, final BreakableNode targetNode) {
@@ -94,11 +89,7 @@
@Override
MethodEmitter registerReturn() {
setHasReturn();
- loadCompilerConstant(SCOPE);
- checkcast(Scope.class);
- load(0);
- invoke(Scope.SET_SPLIT_STATE);
- return this;
+ return setSplitState(0);
}
final List<Label> getExternalTargets() {
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/types/Type.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/codegen/types/Type.java Fri Oct 10 02:24:41 2014 -0700
@@ -47,7 +47,6 @@
import static jdk.internal.org.objectweb.asm.Opcodes.T_INT;
import static jdk.internal.org.objectweb.asm.Opcodes.T_LONG;
import static jdk.nashorn.internal.codegen.CompilerConstants.staticCallNoLookup;
-
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
@@ -55,8 +54,10 @@
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
+import java.util.Collections;
import java.util.Map;
import java.util.TreeMap;
+import java.util.WeakHashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import jdk.internal.org.objectweb.asm.Handle;
@@ -104,6 +105,16 @@
/** The class for this type */
private final Class<?> clazz;
+ /**
+ * Cache for internal types - this is a query that requires complex stringbuilding inside
+ * ASM and it saves startup time to cache the type mappings
+ */
+ private static final Map<Class<?>, jdk.internal.org.objectweb.asm.Type> INTERNAL_TYPE_CACHE =
+ Collections.synchronizedMap(new WeakHashMap<Class<?>, jdk.internal.org.objectweb.asm.Type>());
+
+ /** Internal ASM type for this Type - computed once at construction */
+ private final jdk.internal.org.objectweb.asm.Type internalType;
+
/** Weights are used to decide which types are "wider" than other types */
protected static final int MIN_WEIGHT = -1;
@@ -122,12 +133,13 @@
* @param slots how many bytecode slots the type takes up
*/
Type(final String name, final Class<?> clazz, final int weight, final int slots) {
- this.name = name;
- this.clazz = clazz;
- this.descriptor = jdk.internal.org.objectweb.asm.Type.getDescriptor(clazz);
- this.weight = weight;
+ this.name = name;
+ this.clazz = clazz;
+ this.descriptor = jdk.internal.org.objectweb.asm.Type.getDescriptor(clazz);
+ this.weight = weight;
assert weight >= MIN_WEIGHT && weight <= MAX_WEIGHT : "illegal type weight: " + weight;
- this.slots = slots;
+ this.slots = slots;
+ this.internalType = getInternalType(clazz);
}
/**
@@ -299,7 +311,7 @@
*
* @param typeMap the type map
* @param output data output
- * @throws IOException
+ * @throws IOException if write cannot be completed
*/
public static void writeTypeMap(final Map<Integer, Type> typeMap, final DataOutput output) throws IOException {
if (typeMap == null) {
@@ -329,7 +341,7 @@
*
* @param input data input
* @return type map
- * @throws IOException
+ * @throws IOException if read cannot be completed
*/
public static Map<Integer, Type> readTypeMap(final DataInput input) throws IOException {
final int size = input.readInt();
@@ -357,11 +369,22 @@
}
private jdk.internal.org.objectweb.asm.Type getInternalType() {
- return jdk.internal.org.objectweb.asm.Type.getType(getTypeClass());
+ return internalType;
+ }
+
+ private static jdk.internal.org.objectweb.asm.Type lookupInternalType(final Class<?> type) {
+ final Map<Class<?>, jdk.internal.org.objectweb.asm.Type> cache = INTERNAL_TYPE_CACHE;
+ jdk.internal.org.objectweb.asm.Type itype = cache.get(type);
+ if (itype != null) {
+ return itype;
+ }
+ itype = jdk.internal.org.objectweb.asm.Type.getType(type);
+ cache.put(type, itype);
+ return itype;
}
private static jdk.internal.org.objectweb.asm.Type getInternalType(final Class<?> type) {
- return jdk.internal.org.objectweb.asm.Type.getType(type);
+ return lookupInternalType(type);
}
static void invokestatic(final MethodVisitor method, final Call call) {
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/BreakNode.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/BreakNode.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,7 @@
package jdk.nashorn.internal.ir;
+import jdk.nashorn.internal.codegen.Label;
import jdk.nashorn.internal.ir.annotations.Immutable;
import jdk.nashorn.internal.ir.visitor.NodeVisitor;
@@ -68,4 +69,14 @@
String getStatementName() {
return "break";
}
+
+ @Override
+ public BreakableNode getTarget(final LexicalContext lc) {
+ return lc.getBreakable(getLabelName());
+ }
+
+ @Override
+ public Label getTargetLabel(final BreakableNode target) {
+ return target.getBreakLabel();
+ }
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/ContinueNode.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/ContinueNode.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,7 @@
package jdk.nashorn.internal.ir;
+import jdk.nashorn.internal.codegen.Label;
import jdk.nashorn.internal.ir.annotations.Immutable;
import jdk.nashorn.internal.ir.visitor.NodeVisitor;
@@ -67,5 +68,16 @@
String getStatementName() {
return "continue";
}
+
+
+ @Override
+ public BreakableNode getTarget(final LexicalContext lc) {
+ return lc.getContinueTo(getLabelName());
+ }
+
+ @Override
+ public Label getTargetLabel(final BreakableNode target) {
+ return ((LoopNode)target).getContinueLabel();
+ }
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/JumpStatement.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/ir/JumpStatement.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,8 @@
package jdk.nashorn.internal.ir;
+import jdk.nashorn.internal.codegen.Label;
+
/**
* Common base class for jump statements (e.g. {@code break} and {@code continue}).
*/
@@ -82,6 +84,24 @@
abstract String getStatementName();
+ /**
+ * Finds the target for this jump statement in a lexical context.
+ * @param lc the lexical context
+ * @return the target, or null if not found
+ */
+ public abstract BreakableNode getTarget(final LexicalContext lc);
+
+ /**
+ * Returns the label corresponding to this kind of jump statement (either a break or continue label) in the target.
+ * @param target the target. Note that it need not be the target of this jump statement, as the method can retrieve
+ * a label on any passed target as long as the target has a label of the requisite kind. Of course, it is advisable
+ * to invoke the method on a jump statement that targets the breakable.
+ * @return the label of the target corresponding to the kind of jump statement.
+ * @throws ClassCastException if invoked on the kind of breakable node that this jump statement is not prepared to
+ * handle.
+ */
+ public abstract Label getTargetLabel(final BreakableNode target);
+
@Override
public JumpStatement setLocalVariableConversion(final LexicalContext lc, final LocalVariableConversion conversion) {
if(this.conversion == conversion) {
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/Global.java Fri Oct 10 02:24:41 2014 -0700
@@ -561,6 +561,7 @@
*
* @param engine ScriptEngine to initialize
*/
+ @SuppressWarnings("hiding")
public void initBuiltinObjects(final ScriptEngine engine) {
if (this.builtinObject != null) {
// already initialized, just return
@@ -905,10 +906,12 @@
}
switch (nameStr) {
- case "context":
- return sctxt;
- case "engine":
- return global.engine;
+ case "context":
+ return sctxt;
+ case "engine":
+ return global.engine;
+ default:
+ break;
}
if (self == UNDEFINED) {
@@ -1715,6 +1718,7 @@
return func;
}
+ @SuppressWarnings("hiding")
private void init(final ScriptEngine engine) {
assert Context.getGlobal() == this : "this global is not set as current";
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeArray.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeArray.java Fri Oct 10 02:24:41 2014 -0700
@@ -1835,7 +1835,7 @@
return false;
}
- private ContinuousArrayData getContinuousNonEmptyArrayData(final Object self) {
+ private static ContinuousArrayData getContinuousNonEmptyArrayData(final Object self) {
final ContinuousArrayData data = getContinuousArrayData(self);
if (data != null) {
return data.length() == 0 ? null : data;
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeDebug.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/NativeDebug.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,7 +26,6 @@
package jdk.nashorn.internal.objects;
import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
-
import java.io.PrintWriter;
import java.util.LinkedList;
import java.util.Objects;
@@ -262,8 +261,8 @@
/**
* Set the event queue capacity
- * @param self
- * @param newCapacity
+ * @param self an event queue
+ * @param newCapacity new capacity
*/
@Function(attributes = Attribute.NOT_ENUMERABLE, where = Where.CONSTRUCTOR)
public static void setEventQueueCapacity(final Object self, final Object newCapacity) {
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/annotations/SpecializedFunction.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/objects/annotations/SpecializedFunction.java Fri Oct 10 02:24:41 2014 -0700
@@ -77,7 +77,7 @@
public boolean isEmpty() {
return true;
}
- };
+ }
/**
* Get the class representing the empty link logic
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/AbstractParser.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/parser/AbstractParser.java Fri Oct 10 02:24:41 2014 -0700
@@ -30,7 +30,6 @@
import static jdk.nashorn.internal.parser.TokenType.EOF;
import static jdk.nashorn.internal.parser.TokenType.EOL;
import static jdk.nashorn.internal.parser.TokenType.IDENT;
-
import java.util.HashMap;
import java.util.Map;
import jdk.nashorn.internal.ir.IdentNode;
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CodeInstaller.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CodeInstaller.java Fri Oct 10 02:24:41 2014 -0700
@@ -100,4 +100,21 @@
* @return compiled script data
*/
public StoredScript loadScript(Source source, String functionKey);
+
+ /**
+ * Returns a new code installer that shares most of the functionality of this code installer, but uses a
+ * new, independent class loader.
+ * @return a new code installer with a new independent class loader.
+ */
+ public CodeInstaller<T> withNewLoader();
+
+ /**
+ * Returns true if this code installer is compatible with the other code installer. Compatibility is expected to be
+ * an equivalence relation, and installers are supposed to be compatible with those they create using
+ * {@link #withNewLoader()}.
+ * @param other the other code installer tested for compatibility with this code installer.
+ * @return true if this code installer is compatible with the other code installer.
+ */
+ public boolean isCompatibleWith(CodeInstaller<T> other);
+
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CodeStore.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CodeStore.java Fri Oct 10 02:24:41 2014 -0700
@@ -210,7 +210,7 @@
/**
* Constructor
*
- * @throws IOException
+ * @throws IOException if there are read/write problems with the cache and cache directory
*/
public DirectoryCodeStore() throws IOException {
this(Options.getStringProperty("nashorn.persistent.code.cache", "nashorn_code_cache"), false, DEFAULT_MIN_SIZE);
@@ -222,7 +222,7 @@
* @param path directory to store code in
* @param readOnly is this a read only code store
* @param minSize minimum file size for caching scripts
- * @throws IOException
+ * @throws IOException if there are read/write problems with the cache and cache directory
*/
public DirectoryCodeStore(final String path, final boolean readOnly, final int minSize) throws IOException {
this.dir = checkDirectory(path, readOnly);
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CompiledFunction.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/CompiledFunction.java Fri Oct 10 02:24:41 2014 -0700
@@ -110,9 +110,8 @@
*/
this.invoker = MH.insertArguments(invoker, invoker.type().parameterCount() - 1, UnwarrantedOptimismException.FIRST_PROGRAM_POINT);
throw new AssertionError("Optimistic (UnwarrantedOptimismException throwing) builtin functions are currently not in use");
- } else {
- this.invoker = invoker;
}
+ this.invoker = invoker;
this.constructor = constructor;
this.flags = flags;
this.callSiteType = callSiteType;
@@ -510,8 +509,8 @@
return ((ArrayType)paramTypes[paramTypes.length - 1]).getElementType();
}
- boolean matchesCallSite(final MethodType callSiteType, final boolean pickVarArg) {
- if (callSiteType.equals(this.callSiteType)) {
+ boolean matchesCallSite(final MethodType other, final boolean pickVarArg) {
+ if (other.equals(this.callSiteType)) {
return true;
}
final MethodType type = type();
@@ -521,7 +520,7 @@
return pickVarArg;
}
- final int csParamCount = getParamCount(callSiteType);
+ final int csParamCount = getParamCount(other);
final boolean csIsVarArg = csParamCount == Integer.MAX_VALUE;
final int thisThisIndex = needsCallee() ? 1 : 0; // Index of "this" parameter in this function's type
@@ -530,7 +529,7 @@
// We must match all incoming parameters, except "this". Starting from 1 to skip "this".
for(int i = 1; i < minParams; ++i) {
final Type fnType = Type.typeFor(type.parameterType(i + thisThisIndex));
- final Type csType = csIsVarArg ? Type.OBJECT : Type.typeFor(callSiteType.parameterType(i + 1));
+ final Type csType = csIsVarArg ? Type.OBJECT : Type.typeFor(other.parameterType(i + 1));
if(!fnType.isEquivalentTo(csType)) {
return false;
}
@@ -752,9 +751,9 @@
return sb.toString();
}
- private void logRecompile(final String reason, final FunctionNode fn, final MethodType callSiteType, final Map<Integer, Type> ipp) {
+ private void logRecompile(final String reason, final FunctionNode fn, final MethodType type, final Map<Integer, Type> ipp) {
if (log.isEnabled()) {
- log.info(reason, DebugLogger.quote(fn.getName()), " signature: ", callSiteType, " ", toStringInvalidations(ipp));
+ log.info(reason, DebugLogger.quote(fn.getName()), " signature: ", type, " ", toStringInvalidations(ipp));
}
}
@@ -815,8 +814,6 @@
compiler.persistClassInfo(cacheKey, normalFn);
}
- FunctionNode fn2 = effectiveOptInfo.reparse();
- fn2 = compiler.compile(fn2, CompilationPhases.COMPILE_UPTO_BYTECODE);
log.info("Done.");
final boolean canBeDeoptimized = normalFn.canBeDeoptimized();
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Context.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Context.java Fri Oct 10 02:24:41 2014 -0700
@@ -33,7 +33,6 @@
import static jdk.nashorn.internal.runtime.ECMAErrors.typeError;
import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
import static jdk.nashorn.internal.runtime.Source.sourceFor;
-
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
@@ -64,9 +63,7 @@
import java.util.function.Consumer;
import java.util.function.Supplier;
import java.util.logging.Level;
-
import javax.script.ScriptEngine;
-
import jdk.internal.org.objectweb.asm.ClassReader;
import jdk.internal.org.objectweb.asm.util.CheckClassAdapter;
import jdk.nashorn.api.scripting.ClassFilter;
@@ -161,7 +158,7 @@
}
/**
- * Return the context for this installer
+ * Return the script environment for this installer
* @return ScriptEnvironment
*/
@Override
@@ -225,6 +222,20 @@
}
return null;
}
+
+ @Override
+ public CodeInstaller<ScriptEnvironment> withNewLoader() {
+ return new ContextCodeInstaller(context, context.createNewLoader(), codeSource);
+ }
+
+ @Override
+ public boolean isCompatibleWith(final CodeInstaller<ScriptEnvironment> other) {
+ if (other instanceof ContextCodeInstaller) {
+ final ContextCodeInstaller cci = (ContextCodeInstaller)other;
+ return cci.context == context && cci.codeSource == codeSource;
+ }
+ return false;
+ }
}
/** Is Context global debug mode enabled ? */
@@ -1126,6 +1137,9 @@
StoredScript storedScript = null;
FunctionNode functionNode = null;
+ // We only use the code store here if optimistic types are disabled. With optimistic types,
+ // code is stored per function in RecompilableScriptFunctionData.
+ // TODO: This should really be triggered by lazy compilation, not optimistic types.
final boolean useCodeStore = env._persistent_cache && !env._parse_only && !env._optimistic_types;
final String cacheKey = useCodeStore ? CodeStore.getCacheKey(0, null) : null;
@@ -1212,7 +1226,7 @@
final String mainClassName = storedScript.getMainClassName();
final byte[] mainClassBytes = classBytes.get(mainClassName);
final Class<?> mainClass = installer.install(mainClassName, mainClassBytes);
- final Map<Integer, FunctionInitializer> initialzers = storedScript.getInitializers();
+ final Map<Integer, FunctionInitializer> initializers = storedScript.getInitializers();
installedClasses.put(mainClassName, mainClass);
@@ -1232,8 +1246,8 @@
if (constant instanceof RecompilableScriptFunctionData) {
final RecompilableScriptFunctionData data = (RecompilableScriptFunctionData) constant;
data.initTransients(source, installer);
- if (initialzers != null) {
- final FunctionInitializer initializer = initialzers.get(data.getFunctionNodeId());
+ final FunctionInitializer initializer = initializers.get(data.getFunctionNodeId());
+ if (initializer != null) {
initializer.setCode(installedClasses.get(initializer.getClassName()));
data.initializeCode(initializer);
}
@@ -1390,7 +1404,7 @@
* logic to e.g. multiple switchpoint classes.
*/
public static final class BuiltinSwitchPoint extends SwitchPoint {
-
+ //empty
}
/**
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Debug.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/Debug.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,7 +26,6 @@
package jdk.nashorn.internal.runtime;
import static jdk.nashorn.internal.parser.TokenType.EOF;
-
import jdk.nashorn.internal.parser.Lexer;
import jdk.nashorn.internal.parser.Token;
import jdk.nashorn.internal.parser.TokenStream;
@@ -42,12 +41,12 @@
/**
* Return the topmost JavaScript frame in a stack trace
- * @param e
+ * @param t throwable that contains the stack trace
* @return line describing the topmost JavaScript frame
*/
- public static String firstJSFrame(final Throwable e) {
- for (final StackTraceElement ste : e.getStackTrace()) {
- if(ECMAErrors.isScriptFrame(ste)) {
+ public static String firstJSFrame(final Throwable t) {
+ for (final StackTraceElement ste : t.getStackTrace()) {
+ if (ECMAErrors.isScriptFrame(ste)) {
return ste.toString();
}
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/RecompilableScriptFunctionData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/RecompilableScriptFunctionData.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,6 +26,7 @@
package jdk.nashorn.internal.runtime;
import static jdk.nashorn.internal.lookup.Lookup.MH;
+
import java.io.IOException;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
@@ -268,7 +269,7 @@
if (this.source == null && this.installer == null) {
this.source = src;
this.installer = inst;
- } else if (this.source != src || this.installer != inst) {
+ } else if (this.source != src || !this.installer.isCompatibleWith(inst)) {
// Existing values must be same as those passed as parameters
throw new IllegalArgumentException();
}
@@ -407,6 +408,17 @@
return getCompiler(fn, actualCallSiteType, newLocals(runtimeScope), null, null);
}
+ /**
+ * Returns a code installer for installing new code. If we're using either optimistic typing or loader-per-compile,
+ * then asks for a code installer with a new class loader; otherwise just uses the current installer. We use
+ * a new class loader with optimistic typing so that deoptimized code can get reclaimed by GC.
+ * @return a code installer for installing new code.
+ */
+ private CodeInstaller<ScriptEnvironment> getInstallerForNewCode() {
+ final ScriptEnvironment env = installer.getOwner();
+ return env._optimistic_types || env._loader_per_compile ? installer.withNewLoader() : installer;
+ }
+
Compiler getCompiler(final FunctionNode functionNode, final MethodType actualCallSiteType,
final ScriptObject runtimeScope, final Map<Integer, Type> invalidatedProgramPoints,
final int[] continuationEntryPoints) {
@@ -417,7 +429,7 @@
return new Compiler(
context,
context.getEnv(),
- installer,
+ getInstallerForNewCode(),
functionNode.getSource(), // source
context.getErrorManager(),
isStrict() | functionNode.isStrict(), // is strict
@@ -463,11 +475,12 @@
final TypeMap typeMap = typeMap(actualCallSiteType);
final Type[] paramTypes = typeMap == null ? null : typeMap.getParameterTypes(functionNodeId);
cacheKey = CodeStore.getCacheKey(functionNodeId, paramTypes);
- final StoredScript script = installer.loadScript(source, cacheKey);
+ final CodeInstaller<ScriptEnvironment> newInstaller = getInstallerForNewCode();
+ final StoredScript script = newInstaller.loadScript(source, cacheKey);
if (script != null) {
Compiler.updateCompilationId(script.getCompilationId());
- return install(script);
+ return installStoredScript(script, newInstaller);
}
}
@@ -481,15 +494,7 @@
return new FunctionInitializer(compiledFn, compiler.getInvalidatedProgramPoints());
}
-
- /**
- * Install this script using the given {@code installer}.
- *
- * @param script the compiled script
- * @return the function initializer
- */
- private FunctionInitializer install(final StoredScript script) {
-
+ private static Map<String, Class<?>> installStoredScriptClasses(final StoredScript script, final CodeInstaller<ScriptEnvironment> installer) {
final Map<String, Class<?>> installedClasses = new HashMap<>();
final Map<String, byte[]> classBytes = script.getClassBytes();
final String mainClassName = script.getMainClassName();
@@ -501,14 +506,25 @@
for (final Map.Entry<String, byte[]> entry : classBytes.entrySet()) {
final String className = entry.getKey();
- final byte[] code = entry.getValue();
+ final byte[] bytecode = entry.getValue();
if (className.equals(mainClassName)) {
continue;
}
- installedClasses.put(className, installer.install(className, code));
+ installedClasses.put(className, installer.install(className, bytecode));
}
+ return installedClasses;
+ }
+
+ /**
+ * Install this script using the given {@code installer}.
+ *
+ * @param script the compiled script
+ * @return the function initializer
+ */
+ private FunctionInitializer installStoredScript(final StoredScript script, final CodeInstaller<ScriptEnvironment> newInstaller) {
+ final Map<String, Class<?>> installedClasses = installStoredScriptClasses(script, newInstaller);
final Map<Integer, FunctionInitializer> initializers = script.getInitializers();
assert initializers != null;
@@ -523,7 +539,7 @@
}
}
- installer.initialize(installedClasses.values(), source, constants);
+ newInstaller.initialize(installedClasses.values(), source, constants);
initializer.setCode(installedClasses.get(initializer.getClassName()));
return initializer;
}
@@ -588,9 +604,11 @@
return lookupCodeMethod(fn.getCompileUnit().getCode(), type);
}
- MethodHandle lookupCodeMethod(final Class<?> code, final MethodType targetType) {
- log.info("Looking up ", DebugLogger.quote(name), " type=", targetType);
- return MH.findStatic(LOOKUP, code, functionName, targetType);
+ MethodHandle lookupCodeMethod(final Class<?> codeClass, final MethodType targetType) {
+ if (log.isEnabled()) {
+ log.info("Looking up ", DebugLogger.quote(name), " type=", targetType);
+ }
+ return MH.findStatic(LOOKUP, codeClass, functionName, targetType);
}
/**
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptFunction.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptFunction.java Fri Oct 10 02:24:41 2014 -0700
@@ -501,7 +501,7 @@
* @param linkLogicClass linkLogicClass, or null if no link logic exists
* @return link logic instance, or null if one could not be constructed for this receiver
*/
- private LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
+ private static LinkLogic getLinkLogic(final Object self, final Class<? extends LinkLogic> linkLogicClass) {
if (linkLogicClass == null) {
return LinkLogic.EMPTY_INSTANCE; //always OK to link this, specialization but without special linking logic
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptObject.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/ScriptObject.java Fri Oct 10 02:24:41 2014 -0700
@@ -935,10 +935,10 @@
* creating setters that probably aren't used. Inject directly into the spill pool
* the defaults for "arguments" and "caller"
*
- * @param key
- * @param propertyFlags
- * @param getter
- * @param setter
+ * @param key property key
+ * @param propertyFlags flags
+ * @param getter getter for {@link UserAccessorProperty}, null if not present or N/A
+ * @param setter setter for {@link UserAccessorProperty}, null if not present or N/A
*/
protected final void initUserAccessors(final String key, final int propertyFlags, final ScriptFunction getter, final ScriptFunction setter) {
final int slot = spillLength;
@@ -1749,8 +1749,8 @@
*/
public Object put(final Object key, final Object value, final boolean strict) {
final Object oldValue = get(key);
- final int flags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
- set(key, value, flags);
+ final int scriptObjectFlags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
+ set(key, value, scriptObjectFlags);
return oldValue;
}
@@ -1763,9 +1763,9 @@
* @param strict strict mode or not
*/
public void putAll(final Map<?, ?> otherMap, final boolean strict) {
- final int flags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
+ final int scriptObjectFlags = strict ? NashornCallSiteDescriptor.CALLSITE_STRICT : 0;
for (final Map.Entry<?, ?> entry : otherMap.entrySet()) {
- set(entry.getKey(), entry.getValue(), flags);
+ set(entry.getKey(), entry.getValue(), scriptObjectFlags);
}
}
@@ -2046,7 +2046,7 @@
// Marks a property as declared and sets its value. Used as slow path for block-scoped LET and CONST
@SuppressWarnings("unused")
private void declareAndSet(final String key, final Object value) {
- final PropertyMap map = getMap();
+ final PropertyMap oldMap = getMap();
final FindProperty find = findProperty(key, false);
assert find != null;
@@ -2054,7 +2054,7 @@
assert property != null;
assert property.needsDeclaration();
- final PropertyMap newMap = map.replaceProperty(property, property.removeFlags(Property.NEEDS_DECLARATION));
+ final PropertyMap newMap = oldMap.replaceProperty(property, property.removeFlags(Property.NEEDS_DECLARATION));
setMap(newMap);
set(key, value, 0);
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -536,7 +536,7 @@
final Class<?> widest = widestType(items);
ArrayData newData = convert(widest);
- long pos = newData.length();
+ long pos = newData.length;
for (final Object item : items) {
newData = newData.ensure(pos); //avoid sparse array
newData.set((int)pos++, item, strict);
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ArrayFilter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ArrayFilter.java Fri Oct 10 02:24:41 2014 -0700
@@ -39,7 +39,7 @@
protected ArrayData underlying;
ArrayFilter(final ArrayData underlying) {
- super(underlying.length());
+ super(underlying.length);
this.underlying = underlying;
}
@@ -70,13 +70,13 @@
@Override
public void shiftLeft(final int by) {
underlying.shiftLeft(by);
- setLength(underlying.length());
+ setLength(underlying.length);
}
@Override
public ArrayData shiftRight(final int by) {
underlying = underlying.shiftRight(by);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -84,7 +84,7 @@
@Override
public ArrayData ensure(final long safeIndex) {
underlying = underlying.ensure(safeIndex);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -92,7 +92,7 @@
@Override
public ArrayData shrink(final long newLength) {
underlying = underlying.shrink(newLength);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -100,7 +100,7 @@
@Override
public ArrayData set(final int index, final Object value, final boolean strict) {
underlying = underlying.set(index, value, strict);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -108,7 +108,7 @@
@Override
public ArrayData set(final int index, final int value, final boolean strict) {
underlying = underlying.set(index, value, strict);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -116,7 +116,7 @@
@Override
public ArrayData set(final int index, final long value, final boolean strict) {
underlying = underlying.set(index, value, strict);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -124,7 +124,7 @@
@Override
public ArrayData set(final int index, final double value, final boolean strict) {
underlying = underlying.set(index, value, strict);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@@ -189,28 +189,28 @@
@Override
public ArrayData delete(final int index) {
underlying = underlying.delete(index);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@Override
public ArrayData delete(final long from, final long to) {
underlying = underlying.delete(from, to);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@Override
public ArrayData convert(final Class<?> type) {
underlying = underlying.convert(type);
- setLength(underlying.length());
+ setLength(underlying.length);
return this;
}
@Override
public Object pop() {
final Object value = underlying.pop();
- setLength(underlying.length());
+ setLength(underlying.length);
return value;
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ContinuousArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ContinuousArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -76,11 +76,11 @@
* array without reallocating, or if we are overwriting an already
* allocated element
*
- * @param index
+ * @param index index to check
* @return true if we don't need to do any array reallocation to fit an element at index
*/
public final boolean hasRoomFor(final int index) {
- return has(index) || (index == length() && ensure(index) == this);
+ return has(index) || (index == length && ensure(index) == this);
}
/**
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/DeletedArrayFilter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/DeletedArrayFilter.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,7 +26,6 @@
package jdk.nashorn.internal.runtime.arrays;
import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
-
import java.lang.reflect.Array;
import jdk.nashorn.internal.runtime.BitVector;
@@ -40,7 +39,7 @@
DeletedArrayFilter(final ArrayData underlying) {
super(underlying);
- this.deleted = new BitVector(underlying.length());
+ this.deleted = new BitVector(underlying.length);
}
@Override
@@ -80,25 +79,25 @@
@Override
public void shiftLeft(final int by) {
super.shiftLeft(by);
- deleted.shiftLeft(by, length());
+ deleted.shiftLeft(by, length);
}
@Override
public ArrayData shiftRight(final int by) {
super.shiftRight(by);
- deleted.shiftRight(by, length());
+ deleted.shiftRight(by, length);
return this;
}
@Override
public ArrayData ensure(final long safeIndex) {
- if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length()) {
+ if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length) {
return new SparseArrayData(this, safeIndex + 1);
}
super.ensure(safeIndex);
- deleted.resize(length());
+ deleted.resize(length);
return this;
}
@@ -106,7 +105,7 @@
@Override
public ArrayData shrink(final long newLength) {
super.shrink(newLength);
- deleted.resize(length());
+ deleted.resize(length);
return this;
}
@@ -147,7 +146,7 @@
@Override
public ArrayData delete(final int index) {
final long longIndex = ArrayIndex.toLongIndex(index);
- assert longIndex >= 0 && longIndex < length();
+ assert longIndex >= 0 && longIndex < length;
deleted.set(longIndex);
underlying.setEmpty(index);
return this;
@@ -155,7 +154,7 @@
@Override
public ArrayData delete(final long fromIndex, final long toIndex) {
- assert fromIndex >= 0 && fromIndex <= toIndex && toIndex < length();
+ assert fromIndex >= 0 && fromIndex <= toIndex && toIndex < length;
deleted.setRange(fromIndex, toIndex + 1);
underlying.setEmpty(fromIndex, toIndex);
return this;
@@ -163,7 +162,7 @@
@Override
public Object pop() {
- final long index = length() - 1;
+ final long index = length - 1;
if (super.has((int)index)) {
final boolean isDeleted = deleted.isSet(index);
@@ -180,7 +179,7 @@
final ArrayData newArray = underlying.slice(from, to);
final DeletedArrayFilter newFilter = new DeletedArrayFilter(newArray);
newFilter.getDeleted().copy(deleted);
- newFilter.getDeleted().shiftLeft(from, newFilter.length());
+ newFilter.getDeleted().shiftLeft(from, newFilter.length);
return newFilter;
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/DeletedRangeArrayFilter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/DeletedRangeArrayFilter.java Fri Oct 10 02:24:41 2014 -0700
@@ -45,7 +45,7 @@
if(hi < SparseArrayData.MAX_DENSE_LENGTH || underlying instanceof SparseArrayData) {
return underlying;
}
- return new SparseArrayData(underlying, underlying.length());
+ return new SparseArrayData(underlying, underlying.length);
}
private boolean isEmpty() {
@@ -93,7 +93,7 @@
@Override
public ArrayData ensure(final long safeIndex) {
- if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length()) {
+ if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length) {
return new SparseArrayData(this, safeIndex + 1);
}
@@ -110,8 +110,9 @@
@Override
public ArrayData shiftRight(final int by) {
super.shiftRight(by);
- lo = Math.min(length(), lo + by);
- hi = Math.min(length() - 1, hi + by);
+ final long len = length;
+ lo = Math.min(len, lo + by);
+ hi = Math.min(len - 1, hi + by);
return isEmpty() ? getUnderlying() : this;
}
@@ -237,7 +238,7 @@
@Override
public Object pop() {
- final int index = (int)(length() - 1);
+ final int index = (int)length - 1;
if (super.has(index)) {
final boolean isDeleted = isDeleted(index);
final Object value = super.pop();
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/IntArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/IntArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -105,13 +105,13 @@
@Override
public ArrayData copy() {
- return new IntArrayData(array.clone(), (int) length());
+ return new IntArrayData(array.clone(), (int)length);
}
@Override
public Object asArrayOfType(final Class<?> componentType) {
if (componentType == int.class) {
- return array.length == length() ? array.clone() : Arrays.copyOf(array, (int) length());
+ return array.length == length ? array.clone() : Arrays.copyOf(array, (int)length);
}
return super.asArrayOfType(componentType);
}
@@ -183,7 +183,7 @@
@Override
public ArrayData shiftRight(final int by) {
- final ArrayData newData = ensure(by + length() - 1);
+ final ArrayData newData = ensure(by + length - 1);
if (newData != this) {
newData.shiftRight(by);
return newData;
@@ -229,7 +229,7 @@
@Override
public ArrayData set(final int index, final int value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -238,7 +238,7 @@
public ArrayData set(final int index, final long value, final boolean strict) {
if (JSType.isRepresentableAsInt(value)) {
array[index] = JSType.toInt32(value);
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -249,7 +249,7 @@
public ArrayData set(final int index, final double value, final boolean strict) {
if (JSType.isRepresentableAsInt(value)) {
array[index] = (int)(long)value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -298,7 +298,7 @@
@Override
public boolean has(final int index) {
- return 0 <= index && index < length();
+ return 0 <= index && index < length;
}
@Override
@@ -313,11 +313,11 @@
@Override
public Object pop() {
- if (length() == 0) {
+ if (length == 0) {
return ScriptRuntime.UNDEFINED;
}
- final int newLength = (int) length() - 1;
+ final int newLength = (int)length - 1;
final int elem = array[newLength];
array[newLength] = 0;
setLength(newLength);
@@ -327,7 +327,7 @@
@Override
public ArrayData slice(final long from, final long to) {
- final long start = from < 0 ? from + length() : from;
+ final long start = from < 0 ? from + length : from;
final long newLength = to - start;
return new IntArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength);
@@ -335,18 +335,18 @@
@Override
public final ArrayData push(final boolean strict, final int item) {
- final long length = length();
- final ArrayData newData = ensure(length);
+ final long len = length;
+ final ArrayData newData = ensure(len);
if (newData == this) {
- array[(int)length] = item;
+ array[(int)len] = item;
return this;
}
- return newData.set((int)length, item, strict);
+ return newData.set((int)len, item, strict);
}
@Override
public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException {
- final long oldLength = length();
+ final long oldLength = length;
final long newLength = oldLength - removed + added;
if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) {
throw new UnsupportedOperationException();
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/LongArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/LongArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -62,12 +62,12 @@
@Override
public ArrayData copy() {
- return new LongArrayData(array.clone(), (int)length());
+ return new LongArrayData(array.clone(), (int)length);
}
@Override
public Object[] asObjectArray() {
- return toObjectArray(array, (int)length());
+ return toObjectArray(array, (int)length);
}
private static Object[] toObjectArray(final long[] array, final int length) {
@@ -84,7 +84,7 @@
@Override
public Object asArrayOfType(final Class<?> componentType) {
if (componentType == long.class) {
- return array.length == length() ? array.clone() : Arrays.copyOf(array, (int)length());
+ return array.length == length ? array.clone() : Arrays.copyOf(array, (int)length);
}
return super.asArrayOfType(componentType);
}
@@ -105,11 +105,11 @@
if (type == Integer.class || type == Long.class) {
return this;
}
- final int length = (int) length();
+ final int len = (int)length;
if (type == Double.class) {
- return new NumberArrayData(LongArrayData.toDoubleArray(array, length), length);
+ return new NumberArrayData(LongArrayData.toDoubleArray(array, len), len);
}
- return new ObjectArrayData(LongArrayData.toObjectArray(array, length), length);
+ return new ObjectArrayData(LongArrayData.toObjectArray(array, len), len);
}
@Override
@@ -119,7 +119,7 @@
@Override
public ArrayData shiftRight(final int by) {
- final ArrayData newData = ensure(by + length() - 1);
+ final ArrayData newData = ensure(by + length - 1);
if (newData != this) {
newData.shiftRight(by);
return newData;
@@ -165,14 +165,14 @@
@Override
public ArrayData set(final int index, final int value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final long value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -180,7 +180,7 @@
public ArrayData set(final int index, final double value, final boolean strict) {
if (JSType.isRepresentableAsLong(value)) {
array[index] = (long)value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
return convert(Double.class).set(index, value, strict);
@@ -256,7 +256,7 @@
@Override
public boolean has(final int index) {
- return 0 <= index && index < length();
+ return 0 <= index && index < length;
}
@Override
@@ -271,11 +271,11 @@
@Override
public Object pop() {
- if (length() == 0) {
+ if (length == 0) {
return ScriptRuntime.UNDEFINED;
}
- final int newLength = (int) (length() - 1);
+ final int newLength = (int)length - 1;
final long elem = array[newLength];
array[newLength] = 0;
setLength(newLength);
@@ -285,25 +285,25 @@
@Override
public ArrayData slice(final long from, final long to) {
- final long start = from < 0 ? from + length() : from;
+ final long start = from < 0 ? from + length : from;
final long newLength = to - start;
return new LongArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength);
}
@Override
public final ArrayData push(final boolean strict, final long item) {
- final long length = length();
- final ArrayData newData = ensure(length);
+ final long len = length;
+ final ArrayData newData = ensure(len);
if (newData == this) {
- array[(int)length] = item;
+ array[(int)len] = item;
return this;
}
- return newData.set((int)length, item, strict);
+ return newData.set((int)len, item, strict);
}
@Override
public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException {
- final long oldLength = length();
+ final long oldLength = length;
final long newLength = oldLength - removed + added;
if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) {
throw new UnsupportedOperationException();
@@ -353,7 +353,6 @@
final long elem = array[newLength];
array[newLength] = 0;
return elem;
- //return array[(int)--length];
}
@Override
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/NoTypeArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/NoTypeArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -58,19 +58,19 @@
@Override
public ArrayData convert(final Class<?> type) {
- final long length = length();
+ final long len = length;
final ArrayData arrayData;
if (type == Long.class) {
- arrayData = new LongArrayData(new long[ArrayData.nextSize((int)length)], (int)length);
+ arrayData = new LongArrayData(new long[ArrayData.nextSize((int)len)], (int)len);
} else if (type == Double.class) {
- arrayData = new NumberArrayData(new double[ArrayData.nextSize((int)length)], (int)length);
+ arrayData = new NumberArrayData(new double[ArrayData.nextSize((int)len)], (int)len);
} else if (type == Integer.class) {
- arrayData = new IntArrayData(new int[ArrayData.nextSize((int)length)], (int)length);
+ arrayData = new IntArrayData(new int[ArrayData.nextSize((int)len)], (int)len);
} else {
assert !type.isPrimitive();
- arrayData = new ObjectArrayData(new Object[ArrayData.nextSize((int)length)], (int)length);
+ arrayData = new ObjectArrayData(new Object[ArrayData.nextSize((int)len)], (int)len);
}
- return length == 0 ? arrayData : new DeletedRangeArrayFilter(arrayData, 0, length - 1);
+ return length == 0 ? arrayData : new DeletedRangeArrayFilter(arrayData, 0, len - 1);
}
@Override
@@ -90,11 +90,11 @@
}
// Don't trample the shared EMPTY_ARRAY.
- if (length() == 0) {
- return new NoTypeArrayData(Math.max(safeIndex + 1, length()));
+ if (length == 0) {
+ return new NoTypeArrayData(Math.max(safeIndex + 1, length));
}
- setLength(Math.max(safeIndex + 1, length()));
+ setLength(Math.max(safeIndex + 1, length));
return this;
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/NumberArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/NumberArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -61,12 +61,12 @@
@Override
public ArrayData copy() {
- return new NumberArrayData(array.clone(), (int) length());
+ return new NumberArrayData(array.clone(), (int)length);
}
@Override
public Object[] asObjectArray() {
- return toObjectArray(array, (int) length());
+ return toObjectArray(array, (int)length);
}
private static Object[] toObjectArray(final double[] array, final int length) {
@@ -82,7 +82,7 @@
@Override
public Object asArrayOfType(final Class<?> componentType) {
if(componentType == double.class) {
- return array.length == length() ? array.clone() : Arrays.copyOf(array, (int) length());
+ return array.length == length ? array.clone() : Arrays.copyOf(array, (int)length);
}
return super.asArrayOfType(componentType);
}
@@ -90,8 +90,8 @@
@Override
public ArrayData convert(final Class<?> type) {
if (type != Double.class && type != Integer.class && type != Long.class) {
- final int length = (int) length();
- return new ObjectArrayData(NumberArrayData.toObjectArray(array, length), length);
+ final int len = (int)length;
+ return new ObjectArrayData(NumberArrayData.toObjectArray(array, len), len);
}
return this;
}
@@ -103,7 +103,7 @@
@Override
public ArrayData shiftRight(final int by) {
- final ArrayData newData = ensure(by + length() - 1);
+ final ArrayData newData = ensure(by + length - 1);
if (newData != this) {
newData.shiftRight(by);
return newData;
@@ -148,21 +148,21 @@
@Override
public ArrayData set(final int index, final int value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final long value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final double value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -231,7 +231,7 @@
@Override
public boolean has(final int index) {
- return 0 <= index && index < length();
+ return 0 <= index && index < length;
}
@Override
@@ -246,11 +246,11 @@
@Override
public Object pop() {
- if (length() == 0) {
+ if (length == 0) {
return UNDEFINED;
}
- final int newLength = (int) (length() - 1);
+ final int newLength = (int)length - 1;
final double elem = array[newLength];
array[newLength] = 0;
setLength(newLength);
@@ -259,25 +259,25 @@
@Override
public ArrayData slice(final long from, final long to) {
- final long start = from < 0 ? from + length() : from;
+ final long start = from < 0 ? from + length : from;
final long newLength = to - start;
return new NumberArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength);
}
@Override
public final ArrayData push(final boolean strict, final double item) {
- final long length = length();
- final ArrayData newData = ensure(length);
+ final long len = length;
+ final ArrayData newData = ensure(len);
if (newData == this) {
- array[(int)length] = item;
+ array[(int)len] = item;
return this;
}
- return newData.set((int)length, item, strict);
+ return newData.set((int)len, item, strict);
}
@Override
public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException {
- final long oldLength = length();
+ final long oldLength = length;
final long newLength = oldLength - removed + added;
if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) {
throw new UnsupportedOperationException();
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ObjectArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/ObjectArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -67,14 +67,14 @@
@Override
public Object[] asObjectArray() {
- return array.length == length() ? array.clone() : asObjectArrayCopy();
+ return array.length == length ? array.clone() : asObjectArrayCopy();
}
private Object[] asObjectArrayCopy() {
- final long l = length();
- assert l <= Integer.MAX_VALUE;
- final Object[] copy = new Object[(int)l];
- System.arraycopy(array, 0, copy, 0, (int)l);
+ final long len = length;
+ assert len <= Integer.MAX_VALUE;
+ final Object[] copy = new Object[(int)len];
+ System.arraycopy(array, 0, copy, 0, (int)len);
return copy;
}
@@ -90,7 +90,7 @@
@Override
public ArrayData shiftRight(final int by) {
- final ArrayData newData = ensure(by + length() - 1);
+ final ArrayData newData = ensure(by + length - 1);
if (newData != this) {
newData.shiftRight(by);
return newData;
@@ -122,28 +122,28 @@
@Override
public ArrayData set(final int index, final Object value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final int value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final long value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@Override
public ArrayData set(final int index, final double value, final boolean strict) {
array[index] = value;
- setLength(Math.max(index + 1, length()));
+ setLength(Math.max(index + 1, length));
return this;
}
@@ -220,7 +220,7 @@
@Override
public boolean has(final int index) {
- return 0 <= index && index < length();
+ return 0 <= index && index < length;
}
@Override
@@ -273,11 +273,11 @@
@Override
public Object pop() {
- if (length() == 0) {
+ if (length == 0) {
return ScriptRuntime.UNDEFINED;
}
- final int newLength = (int) (length() - 1);
+ final int newLength = (int)length - 1;
final Object elem = array[newLength];
setEmpty(newLength);
setLength(newLength);
@@ -286,25 +286,25 @@
@Override
public ArrayData slice(final long from, final long to) {
- final long start = from < 0 ? from + length() : from;
+ final long start = from < 0 ? from + length : from;
final long newLength = to - start;
return new ObjectArrayData(Arrays.copyOfRange(array, (int)from, (int)to), (int)newLength);
}
@Override
public ArrayData push(final boolean strict, final Object item) {
- final long length = length();
- final ArrayData newData = ensure(length);
+ final long len = length;
+ final ArrayData newData = ensure(len);
if (newData == this) {
- array[(int)length] = item;
+ array[(int)len] = item;
return this;
}
- return newData.set((int)length, item, strict);
+ return newData.set((int)len, item, strict);
}
@Override
public ArrayData fastSplice(final int start, final int removed, final int added) throws UnsupportedOperationException {
- final long oldLength = length();
+ final long oldLength = length;
final long newLength = oldLength - removed + added;
if (newLength > SparseArrayData.MAX_DENSE_LENGTH && newLength > array.length) {
throw new UnsupportedOperationException();
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/SparseArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/SparseArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -53,28 +53,28 @@
SparseArrayData(final ArrayData underlying, final long length, final TreeMap<Long, Object> sparseMap) {
super(length);
- assert underlying.length() <= length;
+ assert underlying.length <= length;
this.underlying = underlying;
- this.maxDenseLength = Math.max(MAX_DENSE_LENGTH, underlying.length());
+ this.maxDenseLength = Math.max(MAX_DENSE_LENGTH, underlying.length);
this.sparseMap = sparseMap;
}
@Override
public ArrayData copy() {
- return new SparseArrayData(underlying.copy(), length(), new TreeMap<>(sparseMap));
+ return new SparseArrayData(underlying.copy(), length, new TreeMap<>(sparseMap));
}
@Override
public Object[] asObjectArray() {
- final int length = (int) Math.min(length(), Integer.MAX_VALUE);
- final int underlyingLength = (int) Math.min(length, underlying.length());
- final Object[] objArray = new Object[length];
+ final int len = (int)Math.min(length, Integer.MAX_VALUE);
+ final int underlyingLength = (int)Math.min(len, underlying.length);
+ final Object[] objArray = new Object[len];
for (int i = 0; i < underlyingLength; i++) {
objArray[i] = underlying.getObject(i);
}
- Arrays.fill(objArray, underlyingLength, length, ScriptRuntime.UNDEFINED);
+ Arrays.fill(objArray, underlyingLength, len, ScriptRuntime.UNDEFINED);
for (final Map.Entry<Long, Object> entry : sparseMap.entrySet()) {
final long key = entry.getKey();
@@ -104,14 +104,14 @@
}
sparseMap = newSparseMap;
- setLength(Math.max(length() - by, 0));
+ setLength(Math.max(length - by, 0));
}
@Override
public ArrayData shiftRight(final int by) {
final TreeMap<Long, Object> newSparseMap = new TreeMap<>();
- if (underlying.length() + by > maxDenseLength) {
- for (long i = maxDenseLength - by; i < underlying.length(); i++) {
+ if (underlying.length + by > maxDenseLength) {
+ for (long i = maxDenseLength - by; i < underlying.length; i++) {
if (underlying.has((int) i)) {
newSparseMap.put(Long.valueOf(i + by), underlying.getObject((int) i));
}
@@ -127,23 +127,23 @@
}
sparseMap = newSparseMap;
- setLength(length() + by);
+ setLength(length + by);
return this;
}
@Override
public ArrayData ensure(final long safeIndex) {
- if (safeIndex < maxDenseLength && underlying.length() <= safeIndex) {
+ if (safeIndex < maxDenseLength && underlying.length <= safeIndex) {
underlying = underlying.ensure(safeIndex);
}
- setLength(Math.max(safeIndex + 1, length()));
+ setLength(Math.max(safeIndex + 1, length));
return this;
}
@Override
public ArrayData shrink(final long newLength) {
- if (newLength < underlying.length()) {
+ if (newLength < underlying.length) {
underlying = underlying.shrink(newLength);
underlying.setLength(newLength);
sparseMap.clear();
@@ -160,11 +160,11 @@
if (index >= 0 && index < maxDenseLength) {
ensure(index);
underlying = underlying.set(index, value, strict);
- setLength(Math.max(underlying.length(), length()));
+ setLength(Math.max(underlying.length, length));
} else {
final Long longIndex = indexToKey(index);
sparseMap.put(longIndex, value);
- setLength(Math.max(longIndex + 1, length()));
+ setLength(Math.max(longIndex + 1, length));
}
return this;
@@ -175,11 +175,11 @@
if (index >= 0 && index < maxDenseLength) {
ensure(index);
underlying = underlying.set(index, value, strict);
- setLength(Math.max(underlying.length(), length()));
+ setLength(Math.max(underlying.length, length));
} else {
final Long longIndex = indexToKey(index);
sparseMap.put(longIndex, value);
- setLength(Math.max(longIndex + 1, length()));
+ setLength(Math.max(longIndex + 1, length));
}
return this;
}
@@ -189,11 +189,11 @@
if (index >= 0 && index < maxDenseLength) {
ensure(index);
underlying = underlying.set(index, value, strict);
- setLength(Math.max(underlying.length(), length()));
+ setLength(Math.max(underlying.length, length));
} else {
final Long longIndex = indexToKey(index);
sparseMap.put(longIndex, value);
- setLength(Math.max(longIndex + 1, length()));
+ setLength(Math.max(longIndex + 1, length));
}
return this;
}
@@ -203,11 +203,11 @@
if (index >= 0 && index < maxDenseLength) {
ensure(index);
underlying = underlying.set(index, value, strict);
- setLength(Math.max(underlying.length(), length()));
+ setLength(Math.max(underlying.length, length));
} else {
final Long longIndex = indexToKey(index);
sparseMap.put(longIndex, value);
- setLength(Math.max(longIndex + 1, length()));
+ setLength(Math.max(longIndex + 1, length));
}
return this;
}
@@ -294,7 +294,7 @@
@Override
public boolean has(final int index) {
if (index >= 0 && index < maxDenseLength) {
- return index < underlying.length() && underlying.has(index);
+ return index < underlying.length && underlying.has(index);
}
return sparseMap.containsKey(indexToKey(index));
@@ -303,7 +303,7 @@
@Override
public ArrayData delete(final int index) {
if (index >= 0 && index < maxDenseLength) {
- if (index < underlying.length()) {
+ if (index < underlying.length) {
underlying = underlying.delete(index);
}
} else {
@@ -315,8 +315,8 @@
@Override
public ArrayData delete(final long fromIndex, final long toIndex) {
- if (fromIndex < maxDenseLength && fromIndex < underlying.length()) {
- underlying = underlying.delete(fromIndex, Math.min(toIndex, underlying.length() - 1));
+ if (fromIndex < maxDenseLength && fromIndex < underlying.length) {
+ underlying = underlying.delete(fromIndex, Math.min(toIndex, underlying.length - 1));
}
if (toIndex >= maxDenseLength) {
sparseMap.subMap(fromIndex, true, toIndex, true).clear();
@@ -336,30 +336,30 @@
@Override
public Object pop() {
- if (length() == 0) {
+ if (length == 0) {
return ScriptRuntime.UNDEFINED;
}
- if (length() == underlying.length()) {
+ if (length == underlying.length) {
final Object result = underlying.pop();
- setLength(underlying.length());
+ setLength(underlying.length);
return result;
}
- setLength(length() - 1);
- final Long key = Long.valueOf(length());
+ setLength(length - 1);
+ final Long key = Long.valueOf(length);
return sparseMap.containsKey(key) ? sparseMap.remove(key) : ScriptRuntime.UNDEFINED;
}
@Override
public ArrayData slice(final long from, final long to) {
- assert to <= length();
- final long start = from < 0 ? (from + length()) : from;
+ assert to <= length;
+ final long start = from < 0 ? (from + length) : from;
final long newLength = to - start;
if (start >= 0 && to <= maxDenseLength) {
- if (newLength <= underlying.length()) {
+ if (newLength <= underlying.length) {
return underlying.slice(from, to);
}
- return underlying.slice(from, to).ensure(newLength - 1).delete(underlying.length(), newLength);
+ return underlying.slice(from, to).ensure(newLength - 1).delete(underlying.length, newLength);
}
ArrayData sliced = EMPTY_ARRAY;
@@ -369,13 +369,13 @@
sliced = sliced.set((int)(i - start), getObject((int)i), false);
}
}
- assert sliced.length() == newLength;
+ assert sliced.length == newLength;
return sliced;
}
@Override
public long nextIndex(final long index) {
- if (index < underlying.length() - 1) {
+ if (index < underlying.length - 1) {
return underlying.nextIndex(index);
}
@@ -383,6 +383,6 @@
if (nextKey != null) {
return nextKey;
}
- return length();
+ return length;
}
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/TypedArrayData.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/TypedArrayData.java Fri Oct 10 02:24:41 2014 -0700
@@ -54,11 +54,11 @@
}
/**
- * Length in elements. Accessed from {@code ArrayBufferView}
+ * Length in number of elements. Accessed from {@code ArrayBufferView}
* @return element length
*/
public final int getElementLength() {
- return (int)length();
+ return (int)length;
}
/**
@@ -119,7 +119,7 @@
@Override
public final boolean has(final int index) {
- return 0 <= index && index < length();
+ return 0 <= index && index < length;
}
@Override
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/UndefinedArrayFilter.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/arrays/UndefinedArrayFilter.java Fri Oct 10 02:24:41 2014 -0700
@@ -26,7 +26,6 @@
package jdk.nashorn.internal.runtime.arrays;
import static jdk.nashorn.internal.runtime.ScriptRuntime.UNDEFINED;
-
import java.lang.reflect.Array;
import jdk.nashorn.internal.runtime.BitVector;
import jdk.nashorn.internal.runtime.UnwarrantedOptimismException;
@@ -41,7 +40,7 @@
UndefinedArrayFilter(final ArrayData underlying) {
super(underlying);
- this.undefined = new BitVector(underlying.length());
+ this.undefined = new BitVector(underlying.length);
}
@Override
@@ -81,25 +80,25 @@
@Override
public void shiftLeft(final int by) {
super.shiftLeft(by);
- undefined.shiftLeft(by, length());
+ undefined.shiftLeft(by, length);
}
@Override
public ArrayData shiftRight(final int by) {
super.shiftRight(by);
- undefined.shiftRight(by, length());
+ undefined.shiftRight(by, length);
return this;
}
@Override
public ArrayData ensure(final long safeIndex) {
- if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length()) {
+ if (safeIndex >= SparseArrayData.MAX_DENSE_LENGTH && safeIndex >= length) {
return new SparseArrayData(this, safeIndex + 1);
}
super.ensure(safeIndex);
- undefined.resize(length());
+ undefined.resize(length);
return this;
}
@@ -107,7 +106,7 @@
@Override
public ArrayData shrink(final long newLength) {
super.shrink(newLength);
- undefined.resize(length());
+ undefined.resize(length);
return this;
}
@@ -217,7 +216,7 @@
@Override
public Object pop() {
- final long index = length() - 1;
+ final long index = length - 1;
if (super.has((int)index)) {
final boolean isUndefined = undefined.isSet(index);
@@ -234,7 +233,7 @@
final ArrayData newArray = underlying.slice(from, to);
final UndefinedArrayFilter newFilter = new UndefinedArrayFilter(newArray);
newFilter.getUndefined().copy(undefined);
- newFilter.getUndefined().shiftLeft(from, newFilter.length());
+ newFilter.getUndefined().shiftLeft(from, newFilter.length);
return newFilter;
}
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/regexp/RegExpFactory.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/regexp/RegExpFactory.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,6 +25,9 @@
package jdk.nashorn.internal.runtime.regexp;
+import java.util.Collections;
+import java.util.Set;
+import java.util.WeakHashMap;
import jdk.nashorn.internal.runtime.ParserException;
import jdk.nashorn.internal.runtime.options.Options;
@@ -39,6 +42,15 @@
private final static String JDK = "jdk";
private final static String JONI = "joni";
+ /** Weak cache of already validated regexps - when reparsing, we don't, for example
+ * need to recompile (reverify) all regexps that have previously been parsed by this
+ * RegExpFactory in a previous compilation. This saves significant time in e.g. avatar
+ * startup */
+ private static final Set<String> VALID_CACHE_SET =
+ Collections.newSetFromMap(
+ Collections.synchronizedMap(
+ new WeakHashMap<String, Boolean>()));
+
static {
final String impl = Options.getStringProperty("nashorn.regexp.impl", JONI);
switch (impl) {
@@ -88,7 +100,9 @@
*/
// @SuppressWarnings({"unused"})
public static void validate(final String pattern, final String flags) throws ParserException {
- instance.compile(pattern, flags);
+ if (VALID_CACHE_SET.add(pattern + flags)) {
+ instance.compile(pattern, flags);
+ }
}
/**
--- a/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/resources/Options.properties Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/src/jdk.scripting.nashorn/share/classes/jdk/nashorn/internal/runtime/resources/Options.properties Fri Oct 10 02:24:41 2014 -0700
@@ -203,9 +203,9 @@
nashorn.option.optimistic.types = { \
name="--optimistic-types", \
- is_undocumented=true, \
- desc="Use optimistic type assumptions with deoptimizing recompilation.", \
- default=true \
+ short_name="-ot", \
+ desc="Use optimistic type assumptions with deoptimizing recompilation. This makes the compiler try, for any program symbol whose type cannot be proven at compile time, to type it as narrow and primitive as possible. If the runtime encounters an error because symbol type is too narrow, a wider method will be generated until steady stage is reached. While this produces as optimal Java Bytecode as possible, erroneous type guesses will lead to longer warmup. Optimistic typing is currently enabled by default, but can be disabled for faster startup performance.", \
+ default=true \
}
nashorn.option.loader.per.compile = { \
--- a/nashorn/test/script/basic/octane-payload.js Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/test/script/basic/octane-payload.js Fri Oct 10 02:24:41 2014 -0700
@@ -40,7 +40,7 @@
{name:"gbemu", files:["gbemu-part1.js", "gbemu-part2.js"], suite:"GameboyBenchmark"},
{name:"mandreel", files:["mandreel.js"], suite:"MandreelBenchmark"},
{name:"navier-stokes", files:["navier-stokes.js"], suite:"NavierStokes"},
- {name:"pdfjs", files:["pdfjs.js"], suite:"PdfJS"},
+ {name:"pdfjs", files:["pdfjs.js"], suite:"PdfJS", cleanUpIteration: function() { canvas_logs = []; }},
{name:"raytrace", files:["raytrace.js"], suite:"RayTrace"},
{name:"regexp", files:["regexp.js"], suite:"RegExpSuite"},
{name:"richards", files:["richards.js"], suite:"Richards"},
--- a/nashorn/test/script/basic/run-octane.js Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/test/script/basic/run-octane.js Fri Oct 10 02:24:41 2014 -0700
@@ -24,8 +24,8 @@
/**
* @subtest
*/
-var payload = __DIR__ + "octane-payload.js";
-load(payload);
+var dir = typeof(__DIR__) == 'undefined' ? "test/script/basic/" : __DIR__;
+load(dir + "octane-payload.js");
var runtime = undefined;
var verbose = false;
@@ -43,27 +43,27 @@
function load_bench(arg) {
for (var idx = 0; idx < arg.files.length; idx++) {
- var f = arg.files[idx];
- var file = f.split('/');
- var file_name = path + file[file.length - 1];
+ var f = arg.files[idx];
+ var file = f.split('/');
+ var file_name = path + file[file.length - 1];
- var compile_and_return = should_compile_only(file_name);
- if (compile_and_return) {
- if (typeof compile_only === 'undefined') { //for a run, skip compile onlies, don't even compile them
- return true;
+ var compile_and_return = should_compile_only(file_name);
+ if (compile_and_return) {
+ if (typeof compile_only === 'undefined') { //for a run, skip compile onlies, don't even compile them
+ return true;
+ }
}
- }
- print_verbose(arg, "loading '" + arg.name + "' [" + f + "]... " + file_name);
- load(file_name);
+ print_verbose(arg, "loading '" + arg.name + "' [" + f + "]... " + file_name);
+ load(file_name);
}
if (typeof arg.before !== 'undefined') {
- arg.before();
+ arg.before();
}
if (compile_and_return) {
- print_always(arg, "Compiled OK");
+ print_always(arg, "Compiled OK");
}
return !compile_and_return;
@@ -73,16 +73,16 @@
function run_one_benchmark(arg, iters) {
if (!load_bench(arg)) {
- return;
+ return;
}
var success = true;
var current_name;
if (iters == undefined) {
- iters = numberOfIterations;
+ iters = numberOfIterations;
} else {
- numberOfIterations = iters;
+ numberOfIterations = iters;
}
var benchmarks = eval(arg.suite + ".benchmarks");
@@ -91,64 +91,69 @@
var mean_score = 0;
try {
- for (var x = 0; x < benchmarks.length ; x++) {
- //do warmup run
- //reset random number generator needed as of octane 9 before each run
- BenchmarkSuite.ResetRNG();
- benchmarks[x].Setup();
- }
- BenchmarkSuite.ResetRNG();
- print_verbose(arg, "running '" + arg.name + "' for " + iters + " iterations of no less than " + min_time + " seconds");
-
- var scores = [];
-
- var min_time_ms = min_time * 1000;
- var len = benchmarks.length;
-
- for (var it = 0; it < iters + 1; it++) {
- //every iteration must take a minimum of 10 secs
- var ops = 0;
- var elapsed = 0;
- var start = new Date;
- do {
- for (var i = 0; i < len; i++) {
- benchmarks[i].run();
- //important - no timing here like elapsed = new Date() - start, as in the
- //original harness. This will make timing very non-deterministic.
- //NOTHING else must live in this loop
+ for (var x = 0; x < benchmarks.length ; x++) {
+ //do warmup run
+ //reset random number generator needed as of octane 9 before each run
+ BenchmarkSuite.ResetRNG();
+ benchmarks[x].Setup();
}
- ops += len;
- elapsed = new Date - start;
- } while (elapsed < min_time * 1000);
+ BenchmarkSuite.ResetRNG();
+ print_verbose(arg, "running '" + arg.name + "' for " + iters + " iterations of no less than " + min_time + " seconds");
+
+ var scores = [];
+
+ var min_time_ms = min_time * 1000;
+ var len = benchmarks.length;
- var score = ops / elapsed * 1000 * 60;
- scores.push(score);
- var name = it == 0 ? "warmup" : "iteration " + it;
- print_verbose(arg, name + " finished " + score.toFixed(0) + " ops/minute");
- }
-
- for (var x = 0; x < benchmarks.length ; x++) {
- benchmarks[x].TearDown();
- }
+ for (var it = 0; it < iters + 1; it++) {
+ //every iteration must take a minimum of 10 secs
+ var ops = 0;
+ var elapsed = 0;
+ var start = new Date;
+ do {
+ for (var i = 0; i < len; i++) {
+ benchmarks[i].run();
+ //important - no timing here like elapsed = new Date() - start, as in the
+ //original harness. This will make timing very non-deterministic.
+ //NOTHING else must live in this loop
+ }
+ ops += len;
+ elapsed = new Date - start;
+ } while (elapsed < min_time * 1000);
- for (var x = 1; x < iters + 1 ; x++) {
- mean_score += scores[x];
- min_score = Math.min(min_score, scores[x]);
- max_score = Math.max(max_score, scores[x]);
- }
- mean_score /= iters;
+ var score = ops / elapsed * 1000 * 60;
+ scores.push(score);
+ var name = it == 0 ? "warmup" : "iteration " + it;
+ print_verbose(arg, name + " finished " + score.toFixed(0) + " ops/minute");
+
+ // optional per-iteration cleanup hook
+ if (typeof arg.cleanUpIteration == "function") {
+ arg.cleanUpIteration();
+ }
+ }
+
+ for (var x = 0; x < benchmarks.length ; x++) {
+ benchmarks[x].TearDown();
+ }
+
+ for (var x = 1; x < iters + 1 ; x++) {
+ mean_score += scores[x];
+ min_score = Math.min(min_score, scores[x]);
+ max_score = Math.max(max_score, scores[x]);
+ }
+ mean_score /= iters;
} catch (e) {
- print_always(arg, "*** Aborted and setting score to zero. Reason: " + e);
- if (is_this_nashorn() && e instanceof java.lang.Throwable) {
- e.printStackTrace();
- }
- mean_score = min_score = max_score = 0;
- scores = [0];
+ print_always(arg, "*** Aborted and setting score to zero. Reason: " + e);
+ if (is_this_nashorn() && e instanceof java.lang.Throwable) {
+ e.printStackTrace();
+ }
+ mean_score = min_score = max_score = 0;
+ scores = [0];
}
var res = mean_score.toFixed(0);
if (verbose) {
- res += " ops/minute (" + min_score.toFixed(0) + "-" + max_score.toFixed(0) + "), warmup=" + scores[0].toFixed(0);
+ res += " ops/minute (" + min_score.toFixed(0) + "-" + max_score.toFixed(0) + "), warmup=" + scores[0].toFixed(0);
}
print_always(arg, res);
}
@@ -163,13 +168,13 @@
function print_verbose(arg, x) {
if (verbose) {
- print_always(arg, x)
+ print_always(arg, x)
}
}
function run_suite(tests, iters) {
for (var idx = 0; idx < tests.length; idx++) {
- run_one_benchmark(tests[idx], iters);
+ run_one_benchmark(tests[idx], iters);
}
}
@@ -184,13 +189,13 @@
var new_args = [];
for (i in args) {
if (args[i].toString().indexOf(' ') != -1) {
- args[i] = args[i].replace(/\/$/, '');
- var s = args[i].split(' ');
- for (j in s) {
- new_args.push(s[j]);
- }
+ args[i] = args[i].replace(/\/$/, '');
+ var s = args[i].split(' ');
+ for (j in s) {
+ new_args.push(s[j]);
+ }
} else {
- new_args.push(args[i]);
+ new_args.push(args[i]);
}
}
@@ -205,46 +210,46 @@
for (var i = 0; i < args.length; i++) {
arg = args[i];
if (arg == "--iterations") {
- iters = +args[++i];
- if (isNaN(iters)) {
- throw "'--iterations' must be followed by integer";
- }
+ iters = +args[++i];
+ if (isNaN(iters)) {
+ throw "'--iterations' must be followed by integer";
+ }
} else if (arg == "--runtime") {
- runtime = args[++i];
+ runtime = args[++i];
} else if (arg == "--verbose") {
- verbose = true;
+ verbose = true;
} else if (arg == "--min-time") {
- min_time = +args[++i];
- if (isNaN(iters)) {
- throw "'--min-time' must be followed by integer";
- }
+ min_time = +args[++i];
+ if (isNaN(iters)) {
+ throw "'--min-time' must be followed by integer";
+ }
} else if (arg == "") {
- continue; //skip
+ continue; //skip
} else {
- var found = false;
- for (j in tests) {
- if (tests[j].name === arg) {
- tests_found.push(tests[j]);
- found = true;
- break;
+ var found = false;
+ for (j in tests) {
+ if (tests[j].name === arg) {
+ tests_found.push(tests[j]);
+ found = true;
+ break;
+ }
}
- }
- if (!found) {
- var str = "unknown test name: '" + arg + "' -- valid names are: ";
- for (j in tests) {
- if (j != 0) {
- str += ", ";
+ if (!found) {
+ var str = "unknown test name: '" + arg + "' -- valid names are: ";
+ for (j in tests) {
+ if (j != 0) {
+ str += ", ";
+ }
+ str += "'" + tests[j].name + "'";
+ }
+ throw str;
}
- str += "'" + tests[j].name + "'";
- }
- throw str;
- }
}
}
if (tests_found.length == 0) {
for (i in tests) {
- tests_found.push(tests[i]);
+ tests_found.push(tests[i]);
}
}
@@ -255,21 +260,21 @@
if (is_this_nashorn()) {
try {
- read = readFully;
+ read = readFully;
} catch (e) {
- print("ABORTING: Cannot find 'readFully'. You must have scripting enabled to use this test harness. (-scripting)");
- throw e;
+ print("ABORTING: Cannot find 'readFully'. You must have scripting enabled to use this test harness. (-scripting)");
+ throw e;
}
}
// run tests in alphabetical order by name
tests_found.sort(function(a, b) {
if (a.name < b.name) {
- return -1;
+ return -1;
} else if (a.name > b.name) {
- return 1;
+ return 1;
} else {
- return 0;
+ return 0;
}
});
--- a/nashorn/test/src/jdk/nashorn/internal/runtime/ClassFilterTest.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/test/src/jdk/nashorn/internal/runtime/ClassFilterTest.java Fri Oct 10 02:24:41 2014 -0700
@@ -25,10 +25,10 @@
package jdk.nashorn.internal.runtime;
-
import jdk.nashorn.api.scripting.ClassFilter;
import jdk.nashorn.api.scripting.NashornScriptEngineFactory;
import jdk.nashorn.api.scripting.URLReader;
+import jdk.nashorn.internal.test.framework.TestFinder;
import org.testng.annotations.Test;
import javax.script.ScriptEngine;
@@ -126,9 +126,9 @@
private void persistentCacheTestImpl() {
NashornScriptEngineFactory factory = new NashornScriptEngineFactory();
ScriptEngine engine = factory.getScriptEngine(
- new String[]{"--persistent-code-cache"},
- getClass().getClassLoader(),
- getClassFilter()
+ TestFinder.addExplicitOptimisticTypes(new String[]{"--persistent-code-cache", "--optimistic-types=true"}),
+ getClass().getClassLoader(),
+ getClassFilter()
);
String testScript = "var a = Java.type('java.lang.String');" + generateCodeForPersistentStore();
try {
@@ -137,7 +137,7 @@
fail(exc.getMessage());
}
ScriptEngine engineSafe = factory.getScriptEngine(
- new String[]{"--persistent-code-cache"},
+ TestFinder.addExplicitOptimisticTypes(new String[]{"--persistent-code-cache", "--optimistic-types=true"}),
getClass().getClassLoader(),
new ClassFilter() {
@Override
@@ -151,7 +151,7 @@
fail("ClassNotFoundException should have been thrown");
} catch (final Exception exc) {
if (!(exc.getCause() instanceof ClassNotFoundException)) {
- fail("ClassNotFoundException expected");
+ fail("ClassNotFoundException expected, got " + exc.getClass());
}
}
}
--- a/nashorn/test/src/jdk/nashorn/internal/test/framework/ScriptRunnable.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/test/src/jdk/nashorn/internal/test/framework/ScriptRunnable.java Fri Oct 10 02:24:41 2014 -0700
@@ -179,7 +179,7 @@
for (final String str : forkJVMOptions) {
if(!str.isEmpty()) {
cmd.add(str);
- }
+ }
}
cmd.add(Shell.class.getName());
// now add the rest of the "in process" runtime arguments
--- a/nashorn/test/src/jdk/nashorn/internal/test/framework/TestFinder.java Thu Oct 09 12:36:23 2014 -0700
+++ b/nashorn/test/src/jdk/nashorn/internal/test/framework/TestFinder.java Fri Oct 10 02:24:41 2014 -0700
@@ -56,6 +56,7 @@
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
@@ -75,7 +76,7 @@
* Utility class to find/parse script test files and to create 'test' instances.
* Actual 'test' object type is decided by clients of this class.
*/
-final class TestFinder {
+public final class TestFinder {
private TestFinder() {}
interface TestFactory<T> {
@@ -215,6 +216,8 @@
final List<String> scriptArguments = new ArrayList<>();
boolean inComment = false;
+ boolean explicitOptimistic = false;
+
try (Scanner scanner = new Scanner(testFile)) {
while (scanner.hasNext()) {
// TODO: Scan for /ref=file qualifiers, etc, to determine run
@@ -287,7 +290,11 @@
scriptArguments.add(scanner.next());
break;
case "@option":
- engineOptions.add(scanner.next());
+ final String next = scanner.next();
+ engineOptions.add(next);
+ if (next.startsWith("--optimistic-types")) {
+ explicitOptimistic = true;
+ }
break;
case "@fork":
fork = true;
@@ -336,12 +343,61 @@
testOptions.put(OPTIONS_FORK, "true");
}
+ //if there are explicit optimistic type settings, use those - do not override
+ //the test might only work with optimistic types on or off.
+ if (!explicitOptimistic) {
+ addExplicitOptimisticTypes(engineOptions);
+ }
+
tests.add(factory.createTest(framework, testFile.toFile(), engineOptions, testOptions, scriptArguments));
} else if (!isNotTest) {
orphans.add(name);
}
}
+ //the reverse of the default setting for optimistic types, if enabled, false, otherwise true
+ //thus, true for 8u40, false for 9
+ private static final boolean OPTIMISTIC_OVERRIDE = false;
+
+ /**
+ * Check if there is an optimistic override, that disables the default
+ * false optimistic types and sets them to true, for testing purposes
+ *
+ * @return true if optimistic type override has been set by test suite
+ */
+ public static boolean hasOptimisticOverride() {
+ return Boolean.valueOf(OPTIMISTIC_OVERRIDE).toString().equals(System.getProperty("optimistic.override"));
+ }
+
+ /**
+ * Add an optimistic-types=true option to an argument list if this
+ * is set to override the default false. Add an optimistic-types=true
+ * options to an argument list if this is set to override the default
+ * true
+ *
+ * @args new argument list array
+ */
+ public static String[] addExplicitOptimisticTypes(String[] args) {
+ if (hasOptimisticOverride()) {
+ final List<String> newList = new ArrayList<>(Arrays.asList(args));
+ newList.add("--optimistic-types=" + Boolean.valueOf(OPTIMISTIC_OVERRIDE));
+ return newList.toArray(new String[0]);
+ }
+ return args;
+ }
+
+ /**
+ * Add an optimistic-types=true option to an argument list if this
+ * is set to override the default false
+ *
+ * @args argument list
+ */
+ public static void addExplicitOptimisticTypes(List<String> args) {
+ if (hasOptimisticOverride()) {
+ args.add("--optimistic-types=" + Boolean.valueOf(OPTIMISTIC_OVERRIDE));
+ }
+ }
+
private static boolean strictModeEnabled() {
return Boolean.getBoolean(TEST_JS_ENABLE_STRICT_MODE);
}