Merge
This commit is contained in:
Jon Masamitsu
commit
2ad3d66d79
hotspot
make
src
cpu/x86/vm
os/windows/vm
share
test
compiler
classUnloading
rtm/cli
runtime
@ -721,6 +721,19 @@ copy_debug_jdk::
|
||||
($(CD) $(JDK_IMAGE_DIR)/debug && $(TAR) -xf -) ; \
|
||||
fi
|
||||
|
||||
copy_optimized_jdk::
|
||||
$(RM) -r $(JDK_IMAGE_DIR)/optimized
|
||||
$(MKDIR) -p $(JDK_IMAGE_DIR)/optimized
|
||||
if [ -d $(JDK_IMPORT_PATH)/optimized ] ; then \
|
||||
($(CD) $(JDK_IMPORT_PATH)/optimized && \
|
||||
$(TAR) -cf - $(JDK_DIRS)) | \
|
||||
($(CD) $(JDK_IMAGE_DIR)/optimized && $(TAR) -xf -) ; \
|
||||
else \
|
||||
($(CD) $(JDK_IMPORT_PATH) && \
|
||||
$(TAR) -cf - $(JDK_DIRS)) | \
|
||||
($(CD) $(JDK_IMAGE_DIR)/optimized && $(TAR) -xf -) ; \
|
||||
fi
|
||||
|
||||
#
|
||||
# Check target
|
||||
#
|
||||
|
||||
@ -42,6 +42,9 @@ jprt_build_debugEmb:
|
||||
jprt_build_fastdebugEmb:
|
||||
$(MAKE) JAVASE_EMBEDDED=true MINIMIZE_RAM_USAGE=true jprt_build_fastdebug
|
||||
|
||||
jprt_build_optimizedEmb:
|
||||
$(MAKE) JAVASE_EMBEDDED=true MINIMIZE_RAM_USAGE=true jprt_build_optimized
|
||||
|
||||
jprt_build_productOpen:
|
||||
$(MAKE) OPENJDK=true jprt_build_product
|
||||
|
||||
@ -51,6 +54,9 @@ jprt_build_debugOpen:
|
||||
jprt_build_fastdebugOpen:
|
||||
$(MAKE) OPENJDK=true jprt_build_fastdebug
|
||||
|
||||
jprt_build_optimizedOpen:
|
||||
$(MAKE) OPENJDK=true jprt_build_optimized
|
||||
|
||||
jprt_build_product: all_product copy_product_jdk export_product_jdk
|
||||
( $(CD) $(JDK_IMAGE_DIR) && \
|
||||
$(ZIPEXE) $(ZIPFLAGS) -r $(JPRT_ARCHIVE_BUNDLE) . )
|
||||
@ -63,5 +69,9 @@ jprt_build_debug: all_debug copy_debug_jdk export_debug_jdk
|
||||
( $(CD) $(JDK_IMAGE_DIR)/debug && \
|
||||
$(ZIPEXE) $(ZIPFLAGS) -r $(JPRT_ARCHIVE_BUNDLE) . )
|
||||
|
||||
.PHONY: jprt_build_product jprt_build_fastdebug jprt_build_debug
|
||||
jprt_build_optimized: all_optimized copy_optimized_jdk export_optimized_jdk
|
||||
( $(CD) $(JDK_IMAGE_DIR)/optimized && \
|
||||
$(ZIPEXE) $(ZIPFLAGS) -r $(JPRT_ARCHIVE_BUNDLE) . )
|
||||
|
||||
.PHONY: jprt_build_product jprt_build_fastdebug jprt_build_debug jprt_build_optimized
|
||||
|
||||
|
||||
@ -93,13 +93,13 @@ 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|optimized}, \
|
||||
${jprt.my.solaris.sparcv9}-{product|fastdebug}, \
|
||||
${jprt.my.solaris.x64}-{product|fastdebug}, \
|
||||
${jprt.my.linux.i586}-{product|fastdebug}, \
|
||||
${jprt.my.linux.x64}-{product|fastdebug|optimized}, \
|
||||
${jprt.my.linux.x64}-{product|fastdebug}, \
|
||||
${jprt.my.macosx.x64}-{product|fastdebug}, \
|
||||
${jprt.my.windows.i586}-{product|fastdebug}, \
|
||||
${jprt.my.windows.x64}-{product|fastdebug|optimized}, \
|
||||
${jprt.my.windows.x64}-{product|fastdebug}, \
|
||||
${jprt.my.linux.armvh}-{product|fastdebug}
|
||||
|
||||
jprt.build.targets.open= \
|
||||
|
||||
@ -34,6 +34,9 @@ ALTSRC=$(WorkSpace)\src\closed
|
||||
CXX_FLAGS=$(CXX_FLAGS) /D "PRODUCT"
|
||||
!else
|
||||
CXX_FLAGS=$(CXX_FLAGS) /D "ASSERT"
|
||||
!if "$(BUILDARCH)" == "amd64"
|
||||
CXX_FLAGS=$(CXX_FLAGS) /homeparams
|
||||
!endif
|
||||
!endif
|
||||
|
||||
!if "$(Variant)" == "compiler1"
|
||||
|
||||
@ -604,6 +604,17 @@ void VM_Version::get_processor_features() {
|
||||
|
||||
#if INCLUDE_RTM_OPT
|
||||
if (UseRTMLocking) {
|
||||
if (is_intel_family_core()) {
|
||||
if ((_model == CPU_MODEL_HASWELL_E3) ||
|
||||
(_model == CPU_MODEL_HASWELL_E7 && _stepping < 3) ||
|
||||
(_model == CPU_MODEL_BROADWELL && _stepping < 4)) {
|
||||
if (!UnlockExperimentalVMOptions) {
|
||||
vm_exit_during_initialization("UseRTMLocking is only available as experimental option on this platform. It must be enabled via -XX:+UnlockExperimentalVMOptions flag.");
|
||||
} else {
|
||||
warning("UseRTMLocking is only available as experimental option on this platform.");
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!FLAG_IS_CMDLINE(UseRTMLocking)) {
|
||||
// RTM locking should be used only for applications with
|
||||
// high lock contention. For now we do not use it by default.
|
||||
|
||||
@ -276,7 +276,10 @@ protected:
|
||||
CPU_MODEL_WESTMERE_EX = 0x2f,
|
||||
CPU_MODEL_SANDYBRIDGE = 0x2a,
|
||||
CPU_MODEL_SANDYBRIDGE_EP = 0x2d,
|
||||
CPU_MODEL_IVYBRIDGE_EP = 0x3a
|
||||
CPU_MODEL_IVYBRIDGE_EP = 0x3a,
|
||||
CPU_MODEL_HASWELL_E3 = 0x3c,
|
||||
CPU_MODEL_HASWELL_E7 = 0x3f,
|
||||
CPU_MODEL_BROADWELL = 0x3d
|
||||
} cpuExtendedFamily;
|
||||
|
||||
// cpuid information block. All info derived from executing cpuid with
|
||||
|
||||
@ -135,11 +135,6 @@ BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID reserved) {
|
||||
if (ForceTimeHighResolution)
|
||||
timeEndPeriod(1L);
|
||||
|
||||
// Workaround for issue when a custom launcher doesn't call
|
||||
// DestroyJavaVM and NMT is trying to track memory when free is
|
||||
// called from a static destructor
|
||||
MemTracker::shutdown();
|
||||
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
@ -414,6 +409,8 @@ struct tm* os::localtime_pd(const time_t* clock, struct tm* res) {
|
||||
|
||||
LONG WINAPI topLevelExceptionFilter(struct _EXCEPTION_POINTERS* exceptionInfo);
|
||||
|
||||
extern jint volatile vm_getting_terminated;
|
||||
|
||||
// Thread start routine for all new Java threads
|
||||
static unsigned __stdcall java_start(Thread* thread) {
|
||||
// Try to randomize the cache line index of hot stack frames.
|
||||
@ -435,9 +432,17 @@ static unsigned __stdcall java_start(Thread* thread) {
|
||||
}
|
||||
}
|
||||
|
||||
// Diagnostic code to investigate JDK-6573254 (Part I)
|
||||
unsigned res = 90115; // non-java thread
|
||||
if (thread->is_Java_thread()) {
|
||||
JavaThread* java_thread = (JavaThread*)thread;
|
||||
res = java_lang_Thread::is_daemon(java_thread->threadObj())
|
||||
? 70115 // java daemon thread
|
||||
: 80115; // java non-daemon thread
|
||||
}
|
||||
|
||||
// Install a win32 structured exception handler around every thread created
|
||||
// by VM, so VM can genrate error dump when an exception occurred in non-
|
||||
// by VM, so VM can generate error dump when an exception occurred in non-
|
||||
// Java thread (e.g. VM thread).
|
||||
__try {
|
||||
thread->run();
|
||||
@ -453,6 +458,11 @@ static unsigned __stdcall java_start(Thread* thread) {
|
||||
Atomic::dec_ptr((intptr_t*)&os::win32::_os_thread_count);
|
||||
}
|
||||
|
||||
// Diagnostic code to investigate JDK-6573254 (Part II)
|
||||
if (OrderAccess::load_acquire(&vm_getting_terminated)) {
|
||||
return res;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -504,7 +504,7 @@ abstract class GenericDebugConfig extends BuildConfig {
|
||||
|
||||
super.init(includes, defines);
|
||||
|
||||
getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag()));
|
||||
getV("CompilerFlags").addAll(getCI().getDebugCompilerFlags(getOptFlag(), get("PlatformName")));
|
||||
getV("LinkerFlags").addAll(getCI().getDebugLinkerFlags());
|
||||
}
|
||||
}
|
||||
@ -619,7 +619,7 @@ class TieredProductConfig extends ProductConfig {
|
||||
abstract class CompilerInterface {
|
||||
abstract Vector getBaseCompilerFlags(Vector defines, Vector includes, String outDir);
|
||||
abstract Vector getBaseLinkerFlags(String outDir, String outDll, String platformName);
|
||||
abstract Vector getDebugCompilerFlags(String opt);
|
||||
abstract Vector getDebugCompilerFlags(String opt, String platformName);
|
||||
abstract Vector getDebugLinkerFlags();
|
||||
abstract void getAdditionalNonKernelLinkerFlags(Vector rv);
|
||||
abstract Vector getProductCompilerFlags();
|
||||
|
||||
@ -357,7 +357,7 @@ class CompilerInterfaceVC10 extends CompilerInterface {
|
||||
}
|
||||
|
||||
@Override
|
||||
Vector getDebugCompilerFlags(String opt) {
|
||||
Vector getDebugCompilerFlags(String opt, String platformName) {
|
||||
Vector rv = new Vector();
|
||||
|
||||
// Set /On option
|
||||
@ -369,6 +369,10 @@ class CompilerInterfaceVC10 extends CompilerInterface {
|
||||
addAttr(rv, "RuntimeLibrary", "MultiThreadedDLL");
|
||||
// Set /Oy- option
|
||||
addAttr(rv, "OmitFramePointers", "false");
|
||||
// Set /homeparams for x64 debug builds
|
||||
if(platformName.equals("x64")) {
|
||||
addAttr(rv, "AdditionalOptions", "/homeparams");
|
||||
}
|
||||
|
||||
return rv;
|
||||
}
|
||||
|
||||
@ -284,7 +284,7 @@ class CompilerInterfaceVC7 extends CompilerInterface {
|
||||
|
||||
}
|
||||
|
||||
Vector getDebugCompilerFlags(String opt) {
|
||||
Vector getDebugCompilerFlags(String opt, String platformName) {
|
||||
Vector rv = new Vector();
|
||||
|
||||
getDebugCompilerFlags_common(opt, rv);
|
||||
|
||||
@ -48,7 +48,7 @@ class CompilerInterfaceVC8 extends CompilerInterfaceVC7 {
|
||||
}
|
||||
|
||||
|
||||
Vector getDebugCompilerFlags(String opt) {
|
||||
Vector getDebugCompilerFlags(String opt, String platformName) {
|
||||
Vector rv = new Vector();
|
||||
|
||||
getDebugCompilerFlags_common(opt,rv);
|
||||
|
||||
@ -445,7 +445,7 @@ void FileMapInfo::write_bytes(const void* buffer, int nbytes) {
|
||||
// close and remove the file. See bug 6372906.
|
||||
close();
|
||||
remove(_full_path);
|
||||
fail_stop("Unable to write to shared archive file.", NULL);
|
||||
fail_stop("Unable to write to shared archive file.");
|
||||
}
|
||||
}
|
||||
_file_offset += nbytes;
|
||||
@ -463,7 +463,7 @@ void FileMapInfo::align_file_position() {
|
||||
// that the written file is the correct length.
|
||||
_file_offset -= 1;
|
||||
if (lseek(_fd, _file_offset, SEEK_SET) < 0) {
|
||||
fail_stop("Unable to seek.", NULL);
|
||||
fail_stop("Unable to seek.");
|
||||
}
|
||||
char zero = 0;
|
||||
write_bytes(&zero, 1);
|
||||
@ -534,7 +534,7 @@ ReservedSpace FileMapInfo::reserve_shared_memory() {
|
||||
// other reserved memory (like the code cache).
|
||||
ReservedSpace rs(size, os::vm_allocation_granularity(), false, requested_addr);
|
||||
if (!rs.is_reserved()) {
|
||||
fail_continue(err_msg("Unable to reserve shared space at required address " INTPTR_FORMAT, requested_addr));
|
||||
fail_continue("Unable to reserve shared space at required address " INTPTR_FORMAT, requested_addr);
|
||||
return rs;
|
||||
}
|
||||
// the reserved virtual memory is for mapping class data sharing archive
|
||||
@ -558,7 +558,7 @@ char* FileMapInfo::map_region(int i) {
|
||||
requested_addr, size, si->_read_only,
|
||||
si->_allow_exec);
|
||||
if (base == NULL || base != si->_base) {
|
||||
fail_continue(err_msg("Unable to map %s shared space at required address.", shared_region_name[i]));
|
||||
fail_continue("Unable to map %s shared space at required address.", shared_region_name[i]);
|
||||
return NULL;
|
||||
}
|
||||
#ifdef _WINDOWS
|
||||
@ -584,7 +584,7 @@ void FileMapInfo::unmap_region(int i) {
|
||||
|
||||
void FileMapInfo::assert_mark(bool check) {
|
||||
if (!check) {
|
||||
fail_stop("Mark mismatch while restoring from shared file.", NULL);
|
||||
fail_stop("Mark mismatch while restoring from shared file.");
|
||||
}
|
||||
}
|
||||
|
||||
@ -709,7 +709,7 @@ void FileMapInfo::print_shared_spaces() {
|
||||
void FileMapInfo::stop_sharing_and_unmap(const char* msg) {
|
||||
FileMapInfo *map_info = FileMapInfo::current_info();
|
||||
if (map_info) {
|
||||
map_info->fail_continue(msg);
|
||||
map_info->fail_continue("%s", msg);
|
||||
for (int i = 0; i < MetaspaceShared::n_regions; i++) {
|
||||
if (map_info->_header->_space[i]._base != NULL) {
|
||||
map_info->unmap_region(i);
|
||||
@ -717,6 +717,6 @@ void FileMapInfo::stop_sharing_and_unmap(const char* msg) {
|
||||
}
|
||||
}
|
||||
} else if (DumpSharedSpaces) {
|
||||
fail_stop(msg, NULL);
|
||||
fail_stop("%s", msg);
|
||||
}
|
||||
}
|
||||
|
||||
@ -190,8 +190,8 @@ public:
|
||||
bool remap_shared_readonly_as_readwrite();
|
||||
|
||||
// Errors.
|
||||
static void fail_stop(const char *msg, ...);
|
||||
static void fail_continue(const char *msg, ...);
|
||||
static void fail_stop(const char *msg, ...) ATTRIBUTE_PRINTF(1, 2);
|
||||
static void fail_continue(const char *msg, ...) ATTRIBUTE_PRINTF(1, 2);
|
||||
|
||||
// Return true if given address is in the mapped shared space.
|
||||
bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false);
|
||||
|
||||
@ -3126,6 +3126,8 @@ void Metaspace::global_initialize() {
|
||||
|
||||
if (DumpSharedSpaces) {
|
||||
#if INCLUDE_CDS
|
||||
MetaspaceShared::estimate_regions_size();
|
||||
|
||||
SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
|
||||
SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment);
|
||||
SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
|
||||
|
||||
@ -816,6 +816,7 @@ int MetaspaceShared::preload_and_dump(const char * class_list_path,
|
||||
//tty->print_cr("Preload failed: %s", class_name);
|
||||
}
|
||||
}
|
||||
fclose(file);
|
||||
} else {
|
||||
char errmsg[JVM_MAXPATHLEN];
|
||||
os::lasterror(errmsg, JVM_MAXPATHLEN);
|
||||
@ -1086,3 +1087,49 @@ bool MetaspaceShared::remap_shared_readonly_as_readwrite() {
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
int MetaspaceShared::count_class(const char* classlist_file) {
|
||||
if (classlist_file == NULL) {
|
||||
return 0;
|
||||
}
|
||||
char class_name[256];
|
||||
int class_count = 0;
|
||||
FILE* file = fopen(classlist_file, "r");
|
||||
if (file != NULL) {
|
||||
while ((fgets(class_name, sizeof class_name, file)) != NULL) {
|
||||
if (*class_name == '#') { // comment
|
||||
continue;
|
||||
}
|
||||
class_count++;
|
||||
}
|
||||
fclose(file);
|
||||
} else {
|
||||
char errmsg[JVM_MAXPATHLEN];
|
||||
os::lasterror(errmsg, JVM_MAXPATHLEN);
|
||||
tty->print_cr("Loading classlist failed: %s", errmsg);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return class_count;
|
||||
}
|
||||
|
||||
// the sizes are good for typical large applications that have a lot of shared
|
||||
// classes
|
||||
void MetaspaceShared::estimate_regions_size() {
|
||||
int class_count = count_class(SharedClassListFile);
|
||||
class_count += count_class(ExtraSharedClassListFile);
|
||||
|
||||
if (class_count > LargeThresholdClassCount) {
|
||||
if (class_count < HugeThresholdClassCount) {
|
||||
SET_ESTIMATED_SIZE(Large, ReadOnly);
|
||||
SET_ESTIMATED_SIZE(Large, ReadWrite);
|
||||
SET_ESTIMATED_SIZE(Large, MiscData);
|
||||
SET_ESTIMATED_SIZE(Large, MiscCode);
|
||||
} else {
|
||||
SET_ESTIMATED_SIZE(Huge, ReadOnly);
|
||||
SET_ESTIMATED_SIZE(Huge, ReadWrite);
|
||||
SET_ESTIMATED_SIZE(Huge, MiscData);
|
||||
SET_ESTIMATED_SIZE(Huge, MiscCode);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -30,6 +30,19 @@
|
||||
#include "utilities/exceptions.hpp"
|
||||
#include "utilities/macros.hpp"
|
||||
|
||||
#define LargeSharedArchiveSize (300*M)
|
||||
#define HugeSharedArchiveSize (800*M)
|
||||
#define ReadOnlyRegionPercentage 0.4
|
||||
#define ReadWriteRegionPercentage 0.55
|
||||
#define MiscDataRegionPercentage 0.03
|
||||
#define MiscCodeRegionPercentage 0.02
|
||||
#define LargeThresholdClassCount 5000
|
||||
#define HugeThresholdClassCount 40000
|
||||
|
||||
#define SET_ESTIMATED_SIZE(type, region) \
|
||||
Shared ##region## Size = FLAG_IS_DEFAULT(Shared ##region## Size) ? \
|
||||
(type ## SharedArchiveSize * region ## RegionPercentage) : Shared ## region ## Size
|
||||
|
||||
class FileMapInfo;
|
||||
|
||||
// Class Data Sharing Support
|
||||
@ -112,5 +125,8 @@ class MetaspaceShared : AllStatic {
|
||||
static void link_one_shared_class(Klass* obj, TRAPS);
|
||||
static void check_one_shared_class(Klass* obj);
|
||||
static void link_and_cleanup_shared_classes(TRAPS);
|
||||
|
||||
static int count_class(const char* classlist_file);
|
||||
static void estimate_regions_size() NOT_CDS_RETURN;
|
||||
};
|
||||
#endif // SHARE_VM_MEMORY_METASPACE_SHARED_HPP
|
||||
|
||||
@ -1708,8 +1708,8 @@ const TypeTuple *TypeTuple::LONG_CC_PAIR;
|
||||
// Make a TypeTuple from the range of a method signature
|
||||
const TypeTuple *TypeTuple::make_range(ciSignature* sig) {
|
||||
ciType* return_type = sig->return_type();
|
||||
uint total_fields = TypeFunc::Parms + return_type->size();
|
||||
const Type **field_array = fields(total_fields);
|
||||
uint arg_cnt = return_type->size();
|
||||
const Type **field_array = fields(arg_cnt);
|
||||
switch (return_type->basic_type()) {
|
||||
case T_LONG:
|
||||
field_array[TypeFunc::Parms] = TypeLong::LONG;
|
||||
@ -1734,26 +1734,26 @@ const TypeTuple *TypeTuple::make_range(ciSignature* sig) {
|
||||
default:
|
||||
ShouldNotReachHere();
|
||||
}
|
||||
return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons();
|
||||
return (TypeTuple*)(new TypeTuple(TypeFunc::Parms + arg_cnt, field_array))->hashcons();
|
||||
}
|
||||
|
||||
// Make a TypeTuple from the domain of a method signature
|
||||
const TypeTuple *TypeTuple::make_domain(ciInstanceKlass* recv, ciSignature* sig) {
|
||||
uint total_fields = TypeFunc::Parms + sig->size();
|
||||
uint arg_cnt = sig->size();
|
||||
|
||||
uint pos = TypeFunc::Parms;
|
||||
const Type **field_array;
|
||||
if (recv != NULL) {
|
||||
total_fields++;
|
||||
field_array = fields(total_fields);
|
||||
arg_cnt++;
|
||||
field_array = fields(arg_cnt);
|
||||
// Use get_const_type here because it respects UseUniqueSubclasses:
|
||||
field_array[pos++] = get_const_type(recv)->join_speculative(TypePtr::NOTNULL);
|
||||
} else {
|
||||
field_array = fields(total_fields);
|
||||
field_array = fields(arg_cnt);
|
||||
}
|
||||
|
||||
int i = 0;
|
||||
while (pos < total_fields) {
|
||||
while (pos < TypeFunc::Parms + arg_cnt) {
|
||||
ciType* type = sig->type_at(i);
|
||||
|
||||
switch (type->basic_type()) {
|
||||
@ -1780,7 +1780,8 @@ const TypeTuple *TypeTuple::make_domain(ciInstanceKlass* recv, ciSignature* sig)
|
||||
}
|
||||
i++;
|
||||
}
|
||||
return (TypeTuple*)(new TypeTuple(total_fields,field_array))->hashcons();
|
||||
|
||||
return (TypeTuple*)(new TypeTuple(TypeFunc::Parms + arg_cnt, field_array))->hashcons();
|
||||
}
|
||||
|
||||
const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) {
|
||||
@ -1789,6 +1790,7 @@ const TypeTuple *TypeTuple::make( uint cnt, const Type **fields ) {
|
||||
|
||||
//------------------------------fields-----------------------------------------
|
||||
// Subroutine call type with space allocated for argument types
|
||||
// Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
|
||||
const Type **TypeTuple::fields( uint arg_cnt ) {
|
||||
const Type **flds = (const Type **)(Compile::current()->type_arena()->Amalloc_4((TypeFunc::Parms+arg_cnt)*sizeof(Type*) ));
|
||||
flds[TypeFunc::Control ] = Type::CONTROL;
|
||||
|
||||
@ -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
|
||||
@ -635,6 +635,7 @@ public:
|
||||
static const TypeTuple *make_domain(ciInstanceKlass* recv, ciSignature *sig);
|
||||
|
||||
// Subroutine call type with space allocated for argument types
|
||||
// Memory for Control, I_O, Memory, FramePtr, and ReturnAdr is allocated implicitly
|
||||
static const Type **fields( uint arg_cnt );
|
||||
|
||||
virtual const Type *xmeet( const Type *t ) const;
|
||||
|
||||
@ -430,6 +430,8 @@ extern "C" {
|
||||
}
|
||||
}
|
||||
|
||||
jint volatile vm_getting_terminated = 0;
|
||||
|
||||
// Note: before_exit() can be executed only once, if more than one threads
|
||||
// are trying to shutdown the VM at the same time, only one thread
|
||||
// can run before_exit() and all other threads must wait.
|
||||
@ -460,6 +462,8 @@ void before_exit(JavaThread * thread) {
|
||||
}
|
||||
}
|
||||
|
||||
OrderAccess::release_store(&vm_getting_terminated, 1);
|
||||
|
||||
// The only difference between this and Win32's _onexit procs is that
|
||||
// this version is invoked before any threads get killed.
|
||||
ExitProc* current = exit_procs;
|
||||
|
||||
@ -171,8 +171,9 @@ class MallocMemorySnapshot : public ResourceObj {
|
||||
// Total malloc'd memory used by arenas
|
||||
size_t total_arena() const;
|
||||
|
||||
inline size_t thread_count() {
|
||||
return by_type(mtThreadStack)->malloc_count();
|
||||
inline size_t thread_count() const {
|
||||
MallocMemorySnapshot* s = const_cast<MallocMemorySnapshot*>(this);
|
||||
return s->by_type(mtThreadStack)->malloc_count();
|
||||
}
|
||||
|
||||
void reset();
|
||||
|
||||
@ -70,15 +70,13 @@ int compare_virtual_memory_site(const VirtualMemoryAllocationSite& s1,
|
||||
*/
|
||||
class MallocAllocationSiteWalker : public MallocSiteWalker {
|
||||
private:
|
||||
SortedLinkedList<MallocSite, compare_malloc_size, ResourceObj::ARENA>
|
||||
_malloc_sites;
|
||||
SortedLinkedList<MallocSite, compare_malloc_size> _malloc_sites;
|
||||
size_t _count;
|
||||
|
||||
// Entries in MallocSiteTable with size = 0 and count = 0,
|
||||
// when the malloc site is not longer there.
|
||||
public:
|
||||
MallocAllocationSiteWalker(Arena* arena) : _count(0), _malloc_sites(arena) {
|
||||
}
|
||||
MallocAllocationSiteWalker() : _count(0) { }
|
||||
|
||||
inline size_t count() const { return _count; }
|
||||
|
||||
@ -109,13 +107,12 @@ int compare_virtual_memory_base(const ReservedMemoryRegion& r1, const ReservedMe
|
||||
// Walk all virtual memory regions for baselining
|
||||
class VirtualMemoryAllocationWalker : public VirtualMemoryWalker {
|
||||
private:
|
||||
SortedLinkedList<ReservedMemoryRegion, compare_virtual_memory_base, ResourceObj::ARENA>
|
||||
SortedLinkedList<ReservedMemoryRegion, compare_virtual_memory_base>
|
||||
_virtual_memory_regions;
|
||||
size_t _count;
|
||||
|
||||
public:
|
||||
VirtualMemoryAllocationWalker(Arena* a) : _count(0), _virtual_memory_regions(a) {
|
||||
}
|
||||
VirtualMemoryAllocationWalker() : _count(0) { }
|
||||
|
||||
bool do_allocation_site(const ReservedMemoryRegion* rgn) {
|
||||
if (rgn->size() >= MemBaseline::SIZE_THRESHOLD) {
|
||||
@ -136,39 +133,30 @@ class VirtualMemoryAllocationWalker : public VirtualMemoryWalker {
|
||||
|
||||
|
||||
bool MemBaseline::baseline_summary() {
|
||||
assert(_malloc_memory_snapshot == NULL, "Malloc baseline not yet reset");
|
||||
assert(_virtual_memory_snapshot == NULL, "Virtual baseline not yet reset");
|
||||
|
||||
_malloc_memory_snapshot = new (arena()) MallocMemorySnapshot();
|
||||
_virtual_memory_snapshot = new (arena()) VirtualMemorySnapshot();
|
||||
if (_malloc_memory_snapshot == NULL || _virtual_memory_snapshot == NULL) {
|
||||
return false;
|
||||
}
|
||||
MallocMemorySummary::snapshot(_malloc_memory_snapshot);
|
||||
VirtualMemorySummary::snapshot(_virtual_memory_snapshot);
|
||||
MallocMemorySummary::snapshot(&_malloc_memory_snapshot);
|
||||
VirtualMemorySummary::snapshot(&_virtual_memory_snapshot);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool MemBaseline::baseline_allocation_sites() {
|
||||
assert(arena() != NULL, "Just check");
|
||||
// Malloc allocation sites
|
||||
MallocAllocationSiteWalker malloc_walker(arena());
|
||||
MallocAllocationSiteWalker malloc_walker;
|
||||
if (!MallocSiteTable::walk_malloc_site(&malloc_walker)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
_malloc_sites.set_head(malloc_walker.malloc_sites()->head());
|
||||
_malloc_sites.move(malloc_walker.malloc_sites());
|
||||
// The malloc sites are collected in size order
|
||||
_malloc_sites_order = by_size;
|
||||
|
||||
// Virtual memory allocation sites
|
||||
VirtualMemoryAllocationWalker virtual_memory_walker(arena());
|
||||
VirtualMemoryAllocationWalker virtual_memory_walker;
|
||||
if (!VirtualMemoryTracker::walk_virtual_memory(&virtual_memory_walker)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Virtual memory allocations are collected in call stack order
|
||||
_virtual_memory_allocations.set_head(virtual_memory_walker.virtual_memory_allocations()->head());
|
||||
_virtual_memory_allocations.move(virtual_memory_walker.virtual_memory_allocations());
|
||||
|
||||
if (!aggregate_virtual_memory_allocation_sites()) {
|
||||
return false;
|
||||
@ -180,11 +168,6 @@ bool MemBaseline::baseline_allocation_sites() {
|
||||
}
|
||||
|
||||
bool MemBaseline::baseline(bool summaryOnly) {
|
||||
if (arena() == NULL) {
|
||||
_arena = new (std::nothrow, mtNMT) Arena(mtNMT);
|
||||
if (arena() == NULL) return false;
|
||||
}
|
||||
|
||||
reset();
|
||||
|
||||
_class_count = InstanceKlass::number_of_instance_classes();
|
||||
@ -211,8 +194,7 @@ int compare_allocation_site(const VirtualMemoryAllocationSite& s1,
|
||||
}
|
||||
|
||||
bool MemBaseline::aggregate_virtual_memory_allocation_sites() {
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_allocation_site, ResourceObj::ARENA>
|
||||
allocation_sites(arena());
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_allocation_site> allocation_sites;
|
||||
|
||||
VirtualMemoryAllocationIterator itr = virtual_memory_allocations();
|
||||
const ReservedMemoryRegion* rgn;
|
||||
@ -230,12 +212,12 @@ bool MemBaseline::aggregate_virtual_memory_allocation_sites() {
|
||||
site->commit_memory(rgn->committed_size());
|
||||
}
|
||||
|
||||
_virtual_memory_sites.set_head(allocation_sites.head());
|
||||
_virtual_memory_sites.move(&allocation_sites);
|
||||
return true;
|
||||
}
|
||||
|
||||
MallocSiteIterator MemBaseline::malloc_sites(SortingOrder order) {
|
||||
assert(!_malloc_sites.is_empty(), "Detail baseline?");
|
||||
assert(!_malloc_sites.is_empty(), "Not detail baseline");
|
||||
switch(order) {
|
||||
case by_size:
|
||||
malloc_sites_to_size_order();
|
||||
@ -251,7 +233,7 @@ MallocSiteIterator MemBaseline::malloc_sites(SortingOrder order) {
|
||||
}
|
||||
|
||||
VirtualMemorySiteIterator MemBaseline::virtual_memory_sites(SortingOrder order) {
|
||||
assert(!_virtual_memory_sites.is_empty(), "Detail baseline?");
|
||||
assert(!_virtual_memory_sites.is_empty(), "Not detail baseline");
|
||||
switch(order) {
|
||||
case by_size:
|
||||
virtual_memory_sites_to_size_order();
|
||||
@ -270,8 +252,7 @@ VirtualMemorySiteIterator MemBaseline::virtual_memory_sites(SortingOrder order)
|
||||
// Sorting allocations sites in different orders
|
||||
void MemBaseline::malloc_sites_to_size_order() {
|
||||
if (_malloc_sites_order != by_size) {
|
||||
SortedLinkedList<MallocSite, compare_malloc_size, ResourceObj::ARENA>
|
||||
tmp(arena());
|
||||
SortedLinkedList<MallocSite, compare_malloc_size> tmp;
|
||||
|
||||
// Add malloc sites to sorted linked list to sort into size order
|
||||
tmp.move(&_malloc_sites);
|
||||
@ -283,8 +264,7 @@ void MemBaseline::malloc_sites_to_size_order() {
|
||||
|
||||
void MemBaseline::malloc_sites_to_allocation_site_order() {
|
||||
if (_malloc_sites_order != by_site) {
|
||||
SortedLinkedList<MallocSite, compare_malloc_site, ResourceObj::ARENA>
|
||||
tmp(arena());
|
||||
SortedLinkedList<MallocSite, compare_malloc_site> tmp;
|
||||
// Add malloc sites to sorted linked list to sort into site (address) order
|
||||
tmp.move(&_malloc_sites);
|
||||
_malloc_sites.set_head(tmp.head());
|
||||
@ -295,8 +275,7 @@ void MemBaseline::malloc_sites_to_allocation_site_order() {
|
||||
|
||||
void MemBaseline::virtual_memory_sites_to_size_order() {
|
||||
if (_virtual_memory_sites_order != by_size) {
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_size, ResourceObj::ARENA>
|
||||
tmp(arena());
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_size> tmp;
|
||||
|
||||
tmp.move(&_virtual_memory_sites);
|
||||
|
||||
@ -308,10 +287,9 @@ void MemBaseline::virtual_memory_sites_to_size_order() {
|
||||
|
||||
void MemBaseline::virtual_memory_sites_to_reservation_site_order() {
|
||||
if (_virtual_memory_sites_order != by_size) {
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_site, ResourceObj::ARENA>
|
||||
tmp(arena());
|
||||
SortedLinkedList<VirtualMemoryAllocationSite, compare_virtual_memory_site> tmp;
|
||||
|
||||
tmp.add(&_virtual_memory_sites);
|
||||
tmp.move(&_virtual_memory_sites);
|
||||
|
||||
_virtual_memory_sites.set_head(tmp.head());
|
||||
tmp.set_head(NULL);
|
||||
|
||||
@ -61,28 +61,22 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
};
|
||||
|
||||
private:
|
||||
// All baseline data is stored in this arena
|
||||
Arena* _arena;
|
||||
|
||||
// Summary information
|
||||
MallocMemorySnapshot* _malloc_memory_snapshot;
|
||||
VirtualMemorySnapshot* _virtual_memory_snapshot;
|
||||
MallocMemorySnapshot _malloc_memory_snapshot;
|
||||
VirtualMemorySnapshot _virtual_memory_snapshot;
|
||||
|
||||
size_t _class_count;
|
||||
|
||||
// Allocation sites information
|
||||
// Malloc allocation sites
|
||||
LinkedListImpl<MallocSite, ResourceObj::ARENA>
|
||||
_malloc_sites;
|
||||
LinkedListImpl<MallocSite> _malloc_sites;
|
||||
|
||||
// All virtual memory allocations
|
||||
LinkedListImpl<ReservedMemoryRegion, ResourceObj::ARENA>
|
||||
_virtual_memory_allocations;
|
||||
LinkedListImpl<ReservedMemoryRegion> _virtual_memory_allocations;
|
||||
|
||||
// Virtual memory allocations by allocation sites, always in by_address
|
||||
// order
|
||||
LinkedListImpl<VirtualMemoryAllocationSite, ResourceObj::ARENA>
|
||||
_virtual_memory_sites;
|
||||
LinkedListImpl<VirtualMemoryAllocationSite> _virtual_memory_sites;
|
||||
|
||||
SortingOrder _malloc_sites_order;
|
||||
SortingOrder _virtual_memory_sites_order;
|
||||
@ -93,30 +87,23 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
// create a memory baseline
|
||||
MemBaseline():
|
||||
_baseline_type(Not_baselined),
|
||||
_class_count(0),
|
||||
_arena(NULL),
|
||||
_malloc_memory_snapshot(NULL),
|
||||
_virtual_memory_snapshot(NULL),
|
||||
_malloc_sites(NULL) {
|
||||
_class_count(0) {
|
||||
}
|
||||
|
||||
~MemBaseline() {
|
||||
reset();
|
||||
if (_arena != NULL) {
|
||||
delete _arena;
|
||||
}
|
||||
}
|
||||
|
||||
bool baseline(bool summaryOnly = true);
|
||||
|
||||
BaselineType baseline_type() const { return _baseline_type; }
|
||||
|
||||
MallocMemorySnapshot* malloc_memory_snapshot() const {
|
||||
return _malloc_memory_snapshot;
|
||||
MallocMemorySnapshot* malloc_memory_snapshot() {
|
||||
return &_malloc_memory_snapshot;
|
||||
}
|
||||
|
||||
VirtualMemorySnapshot* virtual_memory_snapshot() const {
|
||||
return _virtual_memory_snapshot;
|
||||
VirtualMemorySnapshot* virtual_memory_snapshot() {
|
||||
return &_virtual_memory_snapshot;
|
||||
}
|
||||
|
||||
MallocSiteIterator malloc_sites(SortingOrder order);
|
||||
@ -133,10 +120,8 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
// memory
|
||||
size_t total_reserved_memory() const {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
assert(_virtual_memory_snapshot != NULL, "No virtual memory snapshot");
|
||||
assert(_malloc_memory_snapshot != NULL, "No malloc memory snapshot");
|
||||
size_t amount = _malloc_memory_snapshot->total() +
|
||||
_virtual_memory_snapshot->total_reserved();
|
||||
size_t amount = _malloc_memory_snapshot.total() +
|
||||
_virtual_memory_snapshot.total_reserved();
|
||||
return amount;
|
||||
}
|
||||
|
||||
@ -144,32 +129,30 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
// virtual memory
|
||||
size_t total_committed_memory() const {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
assert(_virtual_memory_snapshot != NULL,
|
||||
"Not a snapshot");
|
||||
size_t amount = _malloc_memory_snapshot->total() +
|
||||
_virtual_memory_snapshot->total_committed();
|
||||
size_t amount = _malloc_memory_snapshot.total() +
|
||||
_virtual_memory_snapshot.total_committed();
|
||||
return amount;
|
||||
}
|
||||
|
||||
size_t total_arena_memory() const {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
assert(_malloc_memory_snapshot != NULL, "Not yet baselined");
|
||||
return _malloc_memory_snapshot->total_arena();
|
||||
return _malloc_memory_snapshot.total_arena();
|
||||
}
|
||||
|
||||
size_t malloc_tracking_overhead() const {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
return _malloc_memory_snapshot->malloc_overhead()->size();
|
||||
MemBaseline* bl = const_cast<MemBaseline*>(this);
|
||||
return bl->_malloc_memory_snapshot.malloc_overhead()->size();
|
||||
}
|
||||
|
||||
const MallocMemory* malloc_memory(MEMFLAGS flag) const {
|
||||
assert(_malloc_memory_snapshot != NULL, "Not a snapshot");
|
||||
return _malloc_memory_snapshot->by_type(flag);
|
||||
MallocMemory* malloc_memory(MEMFLAGS flag) {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
return _malloc_memory_snapshot.by_type(flag);
|
||||
}
|
||||
|
||||
const VirtualMemory* virtual_memory(MEMFLAGS flag) const {
|
||||
assert(_virtual_memory_snapshot != NULL, "Not a snapshot");
|
||||
return _virtual_memory_snapshot->by_type(flag);
|
||||
VirtualMemory* virtual_memory(MEMFLAGS flag) {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
return _virtual_memory_snapshot.by_type(flag);
|
||||
}
|
||||
|
||||
|
||||
@ -180,24 +163,19 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
|
||||
size_t thread_count() const {
|
||||
assert(baseline_type() != Not_baselined, "Not yet baselined");
|
||||
assert(_malloc_memory_snapshot != NULL, "Baselined?");
|
||||
return _malloc_memory_snapshot->thread_count();
|
||||
return _malloc_memory_snapshot.thread_count();
|
||||
}
|
||||
|
||||
// reset the baseline for reuse
|
||||
void reset() {
|
||||
_baseline_type = Not_baselined;
|
||||
_malloc_memory_snapshot = NULL;
|
||||
_virtual_memory_snapshot = NULL;
|
||||
_malloc_memory_snapshot.reset();
|
||||
_virtual_memory_snapshot.reset();
|
||||
_class_count = 0;
|
||||
|
||||
_malloc_sites = NULL;
|
||||
_virtual_memory_sites = NULL;
|
||||
_virtual_memory_allocations = NULL;
|
||||
|
||||
if (_arena != NULL) {
|
||||
_arena->destruct_contents();
|
||||
}
|
||||
_malloc_sites.clear();
|
||||
_virtual_memory_sites.clear();
|
||||
_virtual_memory_allocations.clear();
|
||||
}
|
||||
|
||||
private:
|
||||
@ -210,8 +188,6 @@ class MemBaseline VALUE_OBJ_CLASS_SPEC {
|
||||
// Aggregate virtual memory allocation by allocation sites
|
||||
bool aggregate_virtual_memory_allocation_sites();
|
||||
|
||||
Arena* arena() { return _arena; }
|
||||
|
||||
// Sorting allocation sites in different orders
|
||||
// Sort allocation sites in size order
|
||||
void malloc_sites_to_size_order();
|
||||
|
||||
@ -35,7 +35,9 @@ import java.net.URLConnection;
|
||||
* @summary "Tests unloading of anonymous classes."
|
||||
* @library /testlibrary /testlibrary/whitebox
|
||||
* @compile TestAnonymousClassUnloading.java
|
||||
* @run main ClassFileInstaller TestAnonymousClassUnloading sun.hotspot.WhiteBox
|
||||
* @run main ClassFileInstaller TestAnonymousClassUnloading
|
||||
* sun.hotspot.WhiteBox
|
||||
* sun.hotspot.WhiteBox$WhiteBoxPermission
|
||||
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-BackgroundCompilation TestAnonymousClassUnloading
|
||||
*/
|
||||
public class TestAnonymousClassUnloading {
|
||||
|
||||
@ -36,7 +36,7 @@ import java.net.URLClassLoader;
|
||||
* @build WorkerClass
|
||||
* @run main ClassFileInstaller sun.hotspot.WhiteBox
|
||||
* sun.hotspot.WhiteBox$WhiteBoxPermission
|
||||
* @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-BackgroundCompilation -XX:-UseCompressedOops -XX:+UseParallelGC -XX:CompileOnly=TestMethodUnloading::doWork TestMethodUnloading
|
||||
* @run main/othervm -Xbootclasspath/a:. -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:-BackgroundCompilation -XX:-UseCompressedOops -XX:CompileOnly=TestMethodUnloading::doWork TestMethodUnloading
|
||||
*/
|
||||
public class TestMethodUnloading {
|
||||
private static final String workerClassName = "WorkerClass";
|
||||
|
||||
@ -54,16 +54,19 @@ public class TestPrintPreciseRTMLockingStatisticsOptionOnSupportedConfig
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM(optionName,
|
||||
TestPrintPreciseRTMLockingStatisticsBase.DEFAULT_VALUE,
|
||||
CommandLineOptionTest.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking");
|
||||
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM(optionName,
|
||||
TestPrintPreciseRTMLockingStatisticsBase.DEFAULT_VALUE,
|
||||
CommandLineOptionTest.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:-UseRTMLocking", prepareOptionValue("true"));
|
||||
|
||||
// verify that option could be turned on
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
|
||||
CommandLineOptionTest.UNLOCK_DIAGNOSTIC_VM_OPTIONS,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking", prepareOptionValue("true"));
|
||||
}
|
||||
|
||||
|
||||
@ -63,13 +63,16 @@ public class TestUseRTMDeoptOptionOnSupportedConfig
|
||||
// verify default value
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
|
||||
TestUseRTMDeoptOptionOnSupportedConfig.DEFAULT_VALUE,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking");
|
||||
// verify that option is off when UseRTMLocking is off
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
|
||||
"false", "-XX:-UseRTMLocking", "-XX:+UseRTMDeopt");
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt", "false",
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:-UseRTMLocking", "-XX:+UseRTMDeopt");
|
||||
// verify that option could be turned on
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt",
|
||||
"true", "-XX:+UseRTMLocking", "-XX:+UseRTMDeopt");
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMDeopt", "true",
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking", "-XX:+UseRTMDeopt");
|
||||
}
|
||||
|
||||
public static void main(String args[]) throws Throwable {
|
||||
|
||||
@ -59,24 +59,31 @@ public class TestUseRTMLockingOptionOnSupportedConfig
|
||||
new String[]{
|
||||
RTMGenericCommandLineOptionTest.RTM_INSTR_ERROR,
|
||||
unrecongnizedOption
|
||||
}, ExitCode.OK, "-XX:+UseRTMLocking"
|
||||
}, ExitCode.OK,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking"
|
||||
);
|
||||
|
||||
CommandLineOptionTest.verifySameJVMStartup(null,
|
||||
new String[]{
|
||||
RTMGenericCommandLineOptionTest.RTM_INSTR_ERROR,
|
||||
unrecongnizedOption
|
||||
}, ExitCode.OK, "-XX:-UseRTMLocking"
|
||||
}, ExitCode.OK,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:-UseRTMLocking"
|
||||
);
|
||||
// verify that UseRTMLocking is of by default
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
|
||||
TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE);
|
||||
TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS);
|
||||
// verify that we can change UseRTMLocking value
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
|
||||
TestUseRTMLockingOptionOnSupportedConfig.DEFAULT_VALUE,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:-UseRTMLocking");
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseRTMLocking",
|
||||
"true", "-XX:+UseRTMLocking");
|
||||
"true", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking");
|
||||
}
|
||||
|
||||
public static void main(String args[]) throws Throwable {
|
||||
|
||||
@ -54,18 +54,22 @@ public class TestUseRTMLockingOptionWithBiasedLocking
|
||||
// verify that we will not get a warning
|
||||
CommandLineOptionTest.verifySameJVMStartup(null,
|
||||
new String[] { warningMessage }, ExitCode.OK,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking", "-XX:-UseBiasedLocking");
|
||||
// verify that we will get a warning
|
||||
CommandLineOptionTest.verifySameJVMStartup(
|
||||
new String[] { warningMessage }, null, ExitCode.OK,
|
||||
CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
|
||||
// verify that UseBiasedLocking is false when we use rtm locking
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseBiasedLocking",
|
||||
"false", "-XX:+UseRTMLocking");
|
||||
"false", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking");
|
||||
// verify that we can't turn on biased locking when
|
||||
// using rtm locking
|
||||
CommandLineOptionTest.verifyOptionValueForSameVM("UseBiasedLocking",
|
||||
"false", "-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
|
||||
"false", CommandLineOptionTest.UNLOCK_EXPERIMENTAL_VM_OPTIONS,
|
||||
"-XX:+UseRTMLocking", "-XX:+UseBiasedLocking");
|
||||
}
|
||||
|
||||
public static void main(String args[]) throws Throwable {
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
* @bug 8024927
|
||||
* @summary Testing address of compressed class pointer space as best as possible.
|
||||
* @library /testlibrary
|
||||
* @ignore 8055164
|
||||
*/
|
||||
|
||||
import com.oracle.java.testlibrary.*;
|
||||
@ -89,7 +88,6 @@ public class CompressedClassPointers {
|
||||
"-version");
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("HeapBaseMinAddress must be at least");
|
||||
output.shouldContain("HotSpot");
|
||||
output.shouldHaveExitValue(0);
|
||||
}
|
||||
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
* @key nmt
|
||||
* @summary Empty argument to NMT should result in an informative error message
|
||||
* @library /testlibrary
|
||||
* @ignore 8055051
|
||||
*/
|
||||
|
||||
import com.oracle.java.testlibrary.*;
|
||||
|
||||
@ -62,21 +62,18 @@ public class JcmdDetailDiff {
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=256KB +256KB, committed=0KB)");
|
||||
output.shouldContain("WB_NMTReserveMemory");
|
||||
|
||||
wb.NMTCommitMemory(addr, commitSize);
|
||||
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "detail.diff", "scale=KB"});
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=256KB +256KB, committed=128KB +128KB)");
|
||||
output.shouldContain("WB_NMTReserveMemory");
|
||||
|
||||
wb.NMTUncommitMemory(addr, commitSize);
|
||||
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "detail.diff", "scale=KB"});
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=256KB +256KB, committed=0KB)");
|
||||
output.shouldContain("WB_NMTReserveMemory");
|
||||
|
||||
wb.NMTReleaseMemory(addr, reserveSize);
|
||||
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "detail.diff", "scale=KB"});
|
||||
|
||||
@ -22,10 +22,9 @@
|
||||
*/
|
||||
|
||||
/*
|
||||
* @key stress
|
||||
* @test
|
||||
* @summary Test corner case that overflows malloc site hashtable bucket
|
||||
* @key nmt jcmd
|
||||
* @key nmt jcmd stress
|
||||
* @library /testlibrary /testlibrary/whitebox
|
||||
* @ignore - This test is disabled since it will stress NMT and timeout during normal testing
|
||||
* @build MallocSiteHashOverflow
|
||||
|
||||
@ -22,10 +22,9 @@
|
||||
*/
|
||||
|
||||
/*
|
||||
* @key stress
|
||||
* @test
|
||||
* @summary Stress test for malloc tracking
|
||||
* @key nmt jcmd
|
||||
* @key nmt jcmd stress
|
||||
* @library /testlibrary /testlibrary/whitebox
|
||||
* @build MallocStressTest
|
||||
* @ignore - This test is disabled since it will stress NMT and timeout during normal testing
|
||||
|
||||
@ -34,14 +34,15 @@ public class NMTWithCDS {
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
ProcessBuilder pb;
|
||||
pb = ProcessTools.createJavaProcessBuilder("-XX:SharedArchiveFile=./sample.jsa", "-Xshare:dump");
|
||||
pb = ProcessTools.createJavaProcessBuilder(
|
||||
"-XX:+UnlockDiagnosticVMOptions", "-XX:SharedArchiveFile=./sample.jsa", "-Xshare:dump");
|
||||
OutputAnalyzer output = new OutputAnalyzer(pb.start());
|
||||
try {
|
||||
output.shouldContain("Loading classes to share");
|
||||
output.shouldHaveExitValue(0);
|
||||
|
||||
pb = ProcessTools.createJavaProcessBuilder(
|
||||
"-XX:NativeMemoryTracking=detail", "-XX:SharedArchiveFile=./sample.jsa", "-Xshare:on", "-version");
|
||||
"-XX:+UnlockDiagnosticVMOptions", "-XX:NativeMemoryTracking=detail", "-XX:SharedArchiveFile=./sample.jsa", "-Xshare:on", "-version");
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("sharing");
|
||||
output.shouldHaveExitValue(0);
|
||||
|
||||
@ -26,7 +26,6 @@
|
||||
* @summary Test reserve/commit/uncommit/release of virtual memory and that we track it correctly
|
||||
* @key nmt jcmd
|
||||
* @library /testlibrary /testlibrary/whitebox
|
||||
* @ignore
|
||||
* @build VirtualAllocCommitUncommitRecommit
|
||||
* @run main ClassFileInstaller sun.hotspot.WhiteBox
|
||||
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail VirtualAllocCommitUncommitRecommit
|
||||
@ -43,8 +42,8 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
|
||||
public static void main(String args[]) throws Exception {
|
||||
OutputAnalyzer output;
|
||||
long commitSize = 4 * 1024; // 4KB
|
||||
long reserveSize = 1024 * 1024; // 1024KB
|
||||
long commitSize = 128 * 1024; // 128KB
|
||||
long reserveSize = 4 * 1024 * 1024; // 4096KB
|
||||
long addr;
|
||||
|
||||
String pid = Integer.toString(ProcessTools.getProcessId());
|
||||
@ -63,11 +62,11 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
"VM.native_memory", "detail" });
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=0KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=0KB)");
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
long addrA = addr;
|
||||
@ -84,24 +83,24 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
wb.NMTCommitMemory(addrD, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=16KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=512KB)");
|
||||
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
// uncommit BC
|
||||
wb.NMTUncommitMemory(addrB, commitSize);
|
||||
wb.NMTUncommitMemory(addrC, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=8KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=256KB)");
|
||||
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
// commit EF
|
||||
@ -109,22 +108,22 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
wb.NMTCommitMemory(addrF, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=16KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=512KB)");
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
// uncommit A
|
||||
wb.NMTUncommitMemory(addrA, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=12KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=384KB)");
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
// commit ABC
|
||||
@ -133,11 +132,11 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
wb.NMTCommitMemory(addrC, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=24KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=768KB)");
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
// uncommit ABCDEF
|
||||
@ -149,11 +148,11 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
wb.NMTUncommitMemory(addrF, commitSize);
|
||||
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldContain("Test (reserved=1024KB, committed=0KB)");
|
||||
output.shouldContain("Test (reserved=4096KB, committed=0KB)");
|
||||
if (has_nmt_detail) {
|
||||
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize)
|
||||
+ "\\] reserved 1024KB for Test");
|
||||
+ "\\] reserved 4096KB for Test");
|
||||
}
|
||||
|
||||
// release
|
||||
@ -161,6 +160,6 @@ public class VirtualAllocCommitUncommitRecommit {
|
||||
output = new OutputAnalyzer(pb.start());
|
||||
output.shouldNotContain("Test (reserved=");
|
||||
output.shouldNotMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*"
|
||||
+ Long.toHexString(addr + reserveSize) + "\\] reserved");
|
||||
+ Long.toHexString(addr + reserveSize) + "\\] reserved 4096KB for Test");
|
||||
}
|
||||
}
|
||||
|
||||
@ -31,15 +31,14 @@
|
||||
## @bug 8022301
|
||||
## @bug 8025519
|
||||
## @summary sigaction(sig) results in process hang/timed-out if sig is much greater than SIGRTMAX
|
||||
## @ignore 8041727
|
||||
## @run shell/timeout=60 Test8017498.sh
|
||||
##
|
||||
|
||||
if [ "${TESTSRC}" = "" ]
|
||||
then
|
||||
TESTSRC=${PWD}
|
||||
if [ -z "${TESTSRC}" ]; then
|
||||
TESTSRC="${PWD}"
|
||||
echo "TESTSRC not set. Using "${TESTSRC}" as default"
|
||||
fi
|
||||
|
||||
echo "TESTSRC=${TESTSRC}"
|
||||
## Adding common setup Variables for running shell tests.
|
||||
. ${TESTSRC}/../../test_env.sh
|
||||
@ -52,13 +51,13 @@ case "$OS" in
|
||||
Linux)
|
||||
echo "Testing on Linux"
|
||||
gcc_cmd=`which gcc`
|
||||
if [ "x$gcc_cmd" == "x" ]; then
|
||||
if [ -z "$gcc_cmd" ]; then
|
||||
echo "WARNING: gcc not found. Cannot execute test." 2>&1
|
||||
exit 0;
|
||||
fi
|
||||
MY_LD_PRELOAD=${TESTJAVA}${FS}jre${FS}lib${FS}${VM_CPU}${FS}libjsig.so
|
||||
if [ "$VM_BITS" == "32" ] && [ "$VM_CPU" != "arm" ] && [ "$VM_CPU" != "ppc" ]; then
|
||||
EXTRA_CFLAG=-m32
|
||||
if [ "$VM_BITS" = "32" ] && [ "$VM_CPU" != "arm" ] && [ "$VM_CPU" != "ppc" ]; then
|
||||
EXTRA_CFLAG=-m32
|
||||
fi
|
||||
echo MY_LD_PRELOAD = ${MY_LD_PRELOAD}
|
||||
;;
|
||||
@ -70,7 +69,7 @@ esac
|
||||
|
||||
THIS_DIR=.
|
||||
|
||||
cp ${TESTSRC}${FS}*.java ${THIS_DIR}
|
||||
cp "${TESTSRC}${FS}"*.java "${THIS_DIR}"
|
||||
${COMPILEJAVA}${FS}bin${FS}javac *.java
|
||||
|
||||
$gcc_cmd -DLINUX -fPIC -shared \
|
||||
@ -80,16 +79,19 @@ $gcc_cmd -DLINUX -fPIC -shared \
|
||||
-I${COMPILEJAVA}${FS}include${FS}linux \
|
||||
${TESTSRC}${FS}TestJNI.c
|
||||
|
||||
if [ $? -ne 0 ] ; then
|
||||
echo "Compile failed, Ignoring failed compilation and forcing the test to pass"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# run the java test in the background
|
||||
cmd="LD_PRELOAD=$MY_LD_PRELOAD \
|
||||
${TESTJAVA}${FS}bin${FS}java \
|
||||
-Djava.library.path=. -server TestJNI 100"
|
||||
echo "$cmd > test.out 2>&1"
|
||||
eval $cmd > test.out 2>&1
|
||||
echo "$cmd > test.out"
|
||||
eval $cmd > test.out
|
||||
|
||||
grep "old handler" test.out > ${NULL}
|
||||
if [ $? = 0 ]
|
||||
then
|
||||
if grep "old handler" test.out > ${NULL}; then
|
||||
echo "Test Passed"
|
||||
exit 0
|
||||
fi
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user