--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/ci/ciMethod.java Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/ci/ciMethod.java Mon May 13 07:53:45 2013 +0200
@@ -97,8 +97,8 @@
holder.getName().asString() + " " +
OopUtilities.escapeString(method.getName().asString()) + " " +
method.getSignature().asString() + " " +
- method.getInvocationCounter() + " " +
- method.getBackedgeCounter() + " " +
+ method.getInvocationCount() + " " +
+ method.getBackedgeCount() + " " +
interpreterInvocationCount() + " " +
interpreterThrowoutCount() + " " +
instructionsSize());
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/Method.java Mon May 13 07:53:45 2013 +0200
@@ -24,15 +24,21 @@
package sun.jvm.hotspot.oops;
-import java.io.*;
-import java.util.*;
-import sun.jvm.hotspot.code.*;
-import sun.jvm.hotspot.debugger.*;
-import sun.jvm.hotspot.interpreter.*;
-import sun.jvm.hotspot.memory.*;
-import sun.jvm.hotspot.runtime.*;
-import sun.jvm.hotspot.types.*;
-import sun.jvm.hotspot.utilities.*;
+import java.io.PrintStream;
+import java.util.Observable;
+import java.util.Observer;
+
+import sun.jvm.hotspot.code.NMethod;
+import sun.jvm.hotspot.debugger.Address;
+import sun.jvm.hotspot.interpreter.OopMapCacheEntry;
+import sun.jvm.hotspot.runtime.SignatureConverter;
+import sun.jvm.hotspot.runtime.VM;
+import sun.jvm.hotspot.runtime.VMObjectFactory;
+import sun.jvm.hotspot.types.AddressField;
+import sun.jvm.hotspot.types.Type;
+import sun.jvm.hotspot.types.TypeDataBase;
+import sun.jvm.hotspot.types.WrongTypeException;
+import sun.jvm.hotspot.utilities.Assert;
// A Method represents a Java method
@@ -132,11 +138,13 @@
public long getAccessFlags() { return accessFlags.getValue(this); }
public long getCodeSize() { return getConstMethod().getCodeSize(); }
public long getVtableIndex() { return vtableIndex.getValue(this); }
- public long getInvocationCounter() {
- return getMethodCounters().getInvocationCounter();
+ public long getInvocationCount() {
+ MethodCounters mc = getMethodCounters();
+ return mc == null ? 0 : mc.getInvocationCounter();
}
- public long getBackedgeCounter() {
- return getMethodCounters().getBackedgeCounter();
+ public long getBackedgeCount() {
+ MethodCounters mc = getMethodCounters();
+ return mc == null ? 0 : mc.getBackedgeCounter();
}
// get associated compiled native method, if available, else return null.
@@ -349,8 +357,8 @@
holder.getName().asString() + " " +
OopUtilities.escapeString(getName().asString()) + " " +
getSignature().asString() + " " +
- getInvocationCounter() + " " +
- getBackedgeCounter() + " " +
+ getInvocationCount() + " " +
+ getBackedgeCount() + " " +
interpreterInvocationCount() + " " +
interpreterThrowoutCount() + " " +
code_size);
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/MethodData.java Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/oops/MethodData.java Mon May 13 07:53:45 2013 +0200
@@ -316,8 +316,8 @@
int iic = method.interpreterInvocationCount();
if (mileage < iic) mileage = iic;
- long ic = method.getInvocationCounter();
- long bc = method.getBackedgeCounter();
+ long ic = method.getInvocationCount();
+ long bc = method.getBackedgeCount();
long icval = ic >> 3;
if ((ic & 4) != 0) icval += CompileThreshold;
--- a/hotspot/src/share/vm/code/nmethod.cpp Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/src/share/vm/code/nmethod.cpp Mon May 13 07:53:45 2013 +0200
@@ -1794,6 +1794,19 @@
Metadata* md = r->metadata_value();
f(md);
}
+ } else if (iter.type() == relocInfo::virtual_call_type) {
+ // Check compiledIC holders associated with this nmethod
+ CompiledIC *ic = CompiledIC_at(iter.reloc());
+ if (ic->is_icholder_call()) {
+ CompiledICHolder* cichk = ic->cached_icholder();
+ f(cichk->holder_method());
+ f(cichk->holder_klass());
+ } else {
+ Metadata* ic_oop = ic->cached_metadata();
+ if (ic_oop != NULL) {
+ f(ic_oop);
+ }
+ }
}
}
}
@@ -1804,6 +1817,7 @@
Metadata* md = *p;
f(md);
}
+
// Call function Method*, not embedded in these other places.
if (_method != NULL) f(_method);
}
--- a/hotspot/src/share/vm/prims/jvmtiExport.cpp Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiExport.cpp Mon May 13 07:53:45 2013 +0200
@@ -619,6 +619,9 @@
// data has been changed by the new retransformable agent
// and it hasn't already been cached, cache it
*_cached_data_ptr = (unsigned char *)os::malloc(_curr_len, mtInternal);
+ if (*_cached_data_ptr == NULL) {
+ vm_exit_out_of_memory(_curr_len, OOM_MALLOC_ERROR, "unable to allocate cached copy of original class bytes");
+ }
memcpy(*_cached_data_ptr, _curr_data, _curr_len);
*_cached_length_ptr = _curr_len;
}
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Mon May 13 07:53:45 2013 +0200
@@ -3366,6 +3366,10 @@
}
#endif
+ // NULL out in scratch class to not delete twice. The class to be redefined
+ // always owns these bytes.
+ scratch_class->set_cached_class_file(NULL, 0);
+
// Replace inner_classes
Array<u2>* old_inner_classes = the_class->inner_classes();
the_class->set_inner_classes(scratch_class->inner_classes());
--- a/hotspot/src/share/vm/prims/methodHandles.cpp Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp Mon May 13 07:53:45 2013 +0200
@@ -193,19 +193,15 @@
flags |= IS_CONSTRUCTOR | (JVM_REF_invokeSpecial << REFERENCE_KIND_SHIFT);
} else if (mods.is_static()) {
flags |= IS_METHOD | (JVM_REF_invokeStatic << REFERENCE_KIND_SHIFT);
- // Get vindex from itable if method holder is an interface.
- if (m->method_holder()->is_interface()) {
- vmindex = klassItable::compute_itable_index(m);
- }
} else if (receiver_limit != mklass &&
!receiver_limit->is_subtype_of(mklass)) {
return NULL; // bad receiver limit
- } else if (receiver_limit->is_interface() &&
+ } else if (do_dispatch && receiver_limit->is_interface() &&
mklass->is_interface()) {
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
receiver_limit = mklass; // ignore passed-in limit; interfaces are interconvertible
vmindex = klassItable::compute_itable_index(m);
- } else if (mklass != receiver_limit && mklass->is_interface()) {
+ } else if (do_dispatch && mklass != receiver_limit && mklass->is_interface()) {
flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
// it is a miranda method, so m->vtable_index is not what we want
ResourceMark rm;
@@ -250,10 +246,25 @@
}
methodHandle m = info.resolved_method();
KlassHandle defc = info.resolved_klass();
- int vmindex = -1;
+ int vmindex = Method::invalid_vtable_index;
if (defc->is_interface() && m->method_holder()->is_interface()) {
- // LinkResolver does not report itable indexes! (fix this?)
- vmindex = klassItable::compute_itable_index(m());
+ // static interface methods do not reference vtable or itable
+ if (m->is_static()) {
+ vmindex = Method::nonvirtual_vtable_index;
+ }
+ // interface methods invoked via invokespecial also
+ // do not reference vtable or itable.
+ int ref_kind = ((java_lang_invoke_MemberName::flags(mname()) >>
+ REFERENCE_KIND_SHIFT) & REFERENCE_KIND_MASK);
+ if (ref_kind == JVM_REF_invokeSpecial) {
+ vmindex = Method::nonvirtual_vtable_index;
+ }
+ // If neither m is static nor ref_kind is invokespecial,
+ // set it to itable index.
+ if (vmindex == Method::invalid_vtable_index) {
+ // LinkResolver does not report itable indexes! (fix this?)
+ vmindex = klassItable::compute_itable_index(m());
+ }
} else if (m->can_be_statically_bound()) {
// LinkResolver reports vtable index even for final methods!
vmindex = Method::nonvirtual_vtable_index;
@@ -665,11 +676,9 @@
case IS_METHOD:
{
CallInfo result;
- bool do_dispatch = true; // default, neutral setting
{
assert(!HAS_PENDING_EXCEPTION, "");
if (ref_kind == JVM_REF_invokeStatic) {
- //do_dispatch = false; // no need, since statics are never dispatched
LinkResolver::resolve_static_call(result,
defc, name, type, KlassHandle(), false, false, THREAD);
} else if (ref_kind == JVM_REF_invokeInterface) {
@@ -680,7 +689,6 @@
LinkResolver::resolve_handle_call(result,
defc, name, type, KlassHandle(), THREAD);
} else if (ref_kind == JVM_REF_invokeSpecial) {
- do_dispatch = false; // force non-virtual linkage
LinkResolver::resolve_special_call(result,
defc, name, type, KlassHandle(), false, THREAD);
} else if (ref_kind == JVM_REF_invokeVirtual) {
--- a/hotspot/src/share/vm/runtime/arguments.cpp Fri May 10 11:27:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Mon May 13 07:53:45 2013 +0200
@@ -2100,6 +2100,26 @@
#endif
}
+ // Need to limit the extent of the padding to reasonable size.
+ // 8K is well beyond the reasonable HW cache line size, even with the
+ // aggressive prefetching, while still leaving the room for segregating
+ // among the distinct pages.
+ if (ContendedPaddingWidth < 0 || ContendedPaddingWidth > 8192) {
+ jio_fprintf(defaultStream::error_stream(),
+ "ContendedPaddingWidth=" INTX_FORMAT " must be the between %d and %d\n",
+ ContendedPaddingWidth, 0, 8192);
+ status = false;
+ }
+
+ // Need to enforce the padding not to break the existing field alignments.
+ // It is sufficient to check against the largest type size.
+ if ((ContendedPaddingWidth % BytesPerLong) != 0) {
+ jio_fprintf(defaultStream::error_stream(),
+ "ContendedPaddingWidth=" INTX_FORMAT " must be the multiple of %d\n",
+ ContendedPaddingWidth, BytesPerLong);
+ status = false;
+ }
+
return status;
}
@@ -3097,36 +3117,27 @@
}
void Arguments::set_shared_spaces_flags() {
- const bool must_share = DumpSharedSpaces || RequireSharedSpaces;
- const bool might_share = must_share || UseSharedSpaces;
-
- // CompressedOops cannot be used with CDS. The offsets of oopmaps and
- // static fields are incorrect in the archive. With some more clever
- // initialization, this restriction can probably be lifted.
- // ??? UseLargePages might be okay now
- const bool cannot_share = UseCompressedOops ||
- (UseLargePages && FLAG_IS_CMDLINE(UseLargePages));
- if (cannot_share) {
- if (must_share) {
- warning("disabling large pages %s"
- "because of %s", "" LP64_ONLY("and compressed oops "),
- DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on");
- FLAG_SET_CMDLINE(bool, UseLargePages, false);
- LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedOops, false));
- LP64_ONLY(FLAG_SET_CMDLINE(bool, UseCompressedKlassPointers, false));
- } else {
- // Prefer compressed oops and large pages to class data sharing
- if (UseSharedSpaces && Verbose) {
- warning("turning off use of shared archive because of large pages%s",
- "" LP64_ONLY(" and/or compressed oops"));
+#ifdef _LP64
+ const bool must_share = DumpSharedSpaces || RequireSharedSpaces;
+
+ // CompressedOops cannot be used with CDS. The offsets of oopmaps and
+ // static fields are incorrect in the archive. With some more clever
+ // initialization, this restriction can probably be lifted.
+ if (UseCompressedOops) {
+ if (must_share) {
+ warning("disabling compressed oops because of %s",
+ DumpSharedSpaces ? "-Xshare:dump" : "-Xshare:on");
+ FLAG_SET_CMDLINE(bool, UseCompressedOops, false);
+ FLAG_SET_CMDLINE(bool, UseCompressedKlassPointers, false);
+ } else {
+ // Prefer compressed oops to class data sharing
+ if (UseSharedSpaces && Verbose) {
+ warning("turning off use of shared archive because of compressed oops");
+ }
+ no_shared_spaces();
}
- no_shared_spaces();
}
- } else if (UseLargePages && might_share) {
- // Disable large pages to allow shared spaces. This is sub-optimal, since
- // there may not even be a shared archive to use.
- FLAG_SET_DEFAULT(UseLargePages, false);
- }
+#endif
if (DumpSharedSpaces) {
if (RequireSharedSpaces) {