stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Alejandro Murillo 2013-04-11 16:35:19 -07:00
commit 8a2ec195f6
48 changed files with 679 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
hotspot/.hgtags
View File

@ -331,3 +331,4 @@ e3a41fc0234895eba4f272b984f7dacff495f8eb hs25-b24
af788b85010ebabbc1e8f52c6766e08c7a95cf99 jdk8-b84
a947f40fb536e5b9e0aa210cf26abb430f80887a hs25-b26
42fe530cd478744a4d12a0cbf803f0fc804bab1a jdk8-b85
09b0d3e9ba6cdf7da07d4010d2d1df14596f6864 hs25-b27

2
hotspot/make/hotspot_version
View File

@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2013
HS_MAJOR_VER=25
HS_MINOR_VER=0
HS_BUILD_NUMBER=26
HS_BUILD_NUMBER=27
JDK_MAJOR_VER=1
JDK_MINOR_VER=8

12
hotspot/make/linux/makefiles/gcc.make
View File

@ -126,14 +126,12 @@ endif
# Compiler warnings are treated as errors
WARNINGS_ARE_ERRORS = -Werror
# Except for a few acceptable ones
WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef -Wunused-function
# Since GCC 4.3, -Wconversion has changed its meanings to warn these implicit
# conversions which might affect the values. To avoid that, we need to turn
# it off explicitly.
ifneq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 3 \) \))" "0"
WARNING_FLAGS = -Wpointer-arith -Wsign-compare -Wundef
else
WARNING_FLAGS = -Wpointer-arith -Wconversion -Wsign-compare -Wundef
# conversions which might affect the values. Only enable it in earlier versions.
ifeq "$(shell expr \( $(CC_VER_MAJOR) \> 4 \) \| \( \( $(CC_VER_MAJOR) = 4 \) \& \( $(CC_VER_MINOR) \>= 3 \) \))" "0"
WARNING_FLAGS += -Wconversion
endif
CFLAGS_WARN/DEFAULT = $(WARNINGS_ARE_ERRORS) $(WARNING_FLAGS)

8
hotspot/src/cpu/x86/vm/assembler_x86.cpp
View File

@ -214,14 +214,6 @@ static int encode(Register r) {
return enc;
}
static int encode(XMMRegister r) {
int enc = r->encoding();
if (enc >= 8) {
enc -= 8;
}
return enc;
}
void Assembler::emit_arith_b(int op1, int op2, Register dst, int imm8) {
assert(dst->has_byte_register(), "must have byte register");
assert(isByte(op1) && isByte(op2), "wrong opcode");

5
hotspot/src/cpu/x86/vm/methodHandles_x86.cpp
View File

@ -41,11 +41,6 @@
#define BIND(label) bind(label); BLOCK_COMMENT(#label ":")
// Workaround for C++ overloading nastiness on '0' for RegisterOrConstant.
static RegisterOrConstant constant(int value) {
return RegisterOrConstant(value);
}
void MethodHandles::load_klass_from_Class(MacroAssembler* _masm, Register klass_reg) {
if (VerifyMethodHandles)
verify_klass(_masm, klass_reg, SystemDictionary::WK_KLASS_ENUM_NAME(java_lang_Class),

11
hotspot/src/cpu/x86/vm/x86_64.ad
View File

@ -1693,17 +1693,6 @@ const RegMask Matcher::method_handle_invoke_SP_save_mask() {
return PTR_RBP_REG_mask();
}
static Address build_address(int b, int i, int s, int d) {
Register index = as_Register(i);
Address::ScaleFactor scale = (Address::ScaleFactor)s;
if (index == rsp) {
index = noreg;
scale = Address::no_scale;
}
Address addr(as_Register(b), index, scale, d);
return addr;
}
%}
//----------ENCODING BLOCK-----------------------------------------------------

22
hotspot/src/os/bsd/vm/os_bsd.cpp
View File

@ -152,7 +152,6 @@ sigset_t SR_sigset;
// utility functions
static int SR_initialize();
static int SR_finalize();
julong os::available_memory() {
return Bsd::available_memory();
@ -1200,6 +1199,9 @@ bool os::dll_build_name(char* buffer, size_t buflen,
} else if (strchr(pname, *os::path_separator()) != NULL) {
int n;
char** pelements = split_path(pname, &n);
if (pelements == NULL) {
return false;
}
for (int i = 0 ; i < n ; i++) {
// Really shouldn't be NULL, but check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
@ -2766,10 +2768,6 @@ static int SR_initialize() {
return 0;
}
static int SR_finalize() {
return 0;
}
// returns true on success and false on error - really an error is fatal
// but this seems the normal response to library errors
@ -3578,16 +3576,6 @@ int os::Bsd::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mutex,
////////////////////////////////////////////////////////////////////////////////
// debug support
static address same_page(address x, address y) {
int page_bits = -os::vm_page_size();
if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
return x;
else if (x > y)
return (address)(intptr_t(y) | ~page_bits) + 1;
else
return (address)(intptr_t(y) & page_bits);
}
bool os::find(address addr, outputStream* st) {
Dl_info dlinfo;
memset(&dlinfo, 0, sizeof(dlinfo));
@ -3611,8 +3599,8 @@ bool os::find(address addr, outputStream* st) {
if (Verbose) {
// decode some bytes around the PC
address begin = same_page(addr-40, addr);
address end = same_page(addr+40, addr);
address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size());
address end = clamp_address_in_page(addr+40, addr, os::vm_page_size());
address lowest = (address) dlinfo.dli_sname;
if (!lowest) lowest = (address) dlinfo.dli_fbase;
if (begin < lowest) begin = lowest;

17
hotspot/src/os/bsd/vm/perfMemory_bsd.cpp
View File

@ -672,15 +672,15 @@ static int open_sharedmem_file(const char* filename, int oflags, TRAPS) {
RESTARTABLE(::open(filename, oflags), result);
if (result == OS_ERR) {
if (errno == ENOENT) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found", OS_ERR);
}
else if (errno == EACCES) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied", OS_ERR);
}
else {
THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));
THROW_MSG_(vmSymbols::java_io_IOException(), strerror(errno), OS_ERR);
}
}
@ -828,7 +828,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
char* mapAddress;
int result;
int fd;
size_t size;
size_t size = 0;
const char* luser = NULL;
int mmap_prot;
@ -899,9 +899,12 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
if (*sizep == 0) {
size = sharedmem_filesize(fd, CHECK);
assert(size != 0, "unexpected size");
} else {
size = *sizep;
}
assert(size > 0, "unexpected size <= 0");
mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
// attempt to close the file - restart if it gets interrupted,

22
hotspot/src/os/linux/vm/os_linux.cpp
View File

@ -176,7 +176,6 @@ class MemNotifyThread: public Thread {
// utility functions
static int SR_initialize();
static int SR_finalize();
julong os::available_memory() {
return Linux::available_memory();
@ -1633,6 +1632,9 @@ bool os::dll_build_name(char* buffer, size_t buflen,
} else if (strchr(pname, *os::path_separator()) != NULL) {
int n;
char** pelements = split_path(pname, &n);
if (pelements == NULL) {
return false;
}
for (int i = 0 ; i < n ; i++) {
// Really shouldn't be NULL, but check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
@ -3655,10 +3657,6 @@ static int SR_initialize() {
return 0;
}
static int SR_finalize() {
return 0;
}
// returns true on success and false on error - really an error is fatal
// but this seems the normal response to library errors
@ -4500,16 +4498,6 @@ int os::Linux::safe_cond_timedwait(pthread_cond_t *_cond, pthread_mutex_t *_mute
////////////////////////////////////////////////////////////////////////////////
// debug support
static address same_page(address x, address y) {
int page_bits = -os::vm_page_size();
if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
return x;
else if (x > y)
return (address)(intptr_t(y) | ~page_bits) + 1;
else
return (address)(intptr_t(y) & page_bits);
}
bool os::find(address addr, outputStream* st) {
Dl_info dlinfo;
memset(&dlinfo, 0, sizeof(dlinfo));
@ -4533,8 +4521,8 @@ bool os::find(address addr, outputStream* st) {
if (Verbose) {
// decode some bytes around the PC
address begin = same_page(addr-40, addr);
address end = same_page(addr+40, addr);
address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size());
address end = clamp_address_in_page(addr+40, addr, os::vm_page_size());
address lowest = (address) dlinfo.dli_sname;
if (!lowest) lowest = (address) dlinfo.dli_fbase;
if (begin < lowest) begin = lowest;

17
hotspot/src/os/linux/vm/perfMemory_linux.cpp
View File

@ -672,15 +672,15 @@ static int open_sharedmem_file(const char* filename, int oflags, TRAPS) {
RESTARTABLE(::open(filename, oflags), result);
if (result == OS_ERR) {
if (errno == ENOENT) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found", OS_ERR);
}
else if (errno == EACCES) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied", OS_ERR);
}
else {
THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));
THROW_MSG_(vmSymbols::java_io_IOException(), strerror(errno), OS_ERR);
}
}
@ -828,7 +828,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
char* mapAddress;
int result;
int fd;
size_t size;
size_t size = 0;
const char* luser = NULL;
int mmap_prot;
@ -899,9 +899,12 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
if (*sizep == 0) {
size = sharedmem_filesize(fd, CHECK);
assert(size != 0, "unexpected size");
} else {
size = *sizep;
}
assert(size > 0, "unexpected size <= 0");
mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
// attempt to close the file - restart if it gets interrupted,

17
hotspot/src/os/solaris/vm/os_solaris.cpp
View File

@ -1885,6 +1885,9 @@ bool os::dll_build_name(char* buffer, size_t buflen,
} else if (strchr(pname, *os::path_separator()) != NULL) {
int n;
char** pelements = split_path(pname, &n);
if (pelements == NULL) {
return false;
}
for (int i = 0 ; i < n ; i++) {
// really shouldn't be NULL but what the heck, check can't hurt
if (pelements[i] == NULL || strlen(pelements[i]) == 0) {
@ -5787,16 +5790,6 @@ int os::loadavg(double loadavg[], int nelem) {
//---------------------------------------------------------------------------------
static address same_page(address x, address y) {
intptr_t page_bits = -os::vm_page_size();
if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits))
return x;
else if (x > y)
return (address)(intptr_t(y) | ~page_bits) + 1;
else
return (address)(intptr_t(y) & page_bits);
}
bool os::find(address addr, outputStream* st) {
Dl_info dlinfo;
memset(&dlinfo, 0, sizeof(dlinfo));
@ -5822,8 +5815,8 @@ bool os::find(address addr, outputStream* st) {
if (Verbose) {
// decode some bytes around the PC
address begin = same_page(addr-40, addr);
address end = same_page(addr+40, addr);
address begin = clamp_address_in_page(addr-40, addr, os::vm_page_size());
address end = clamp_address_in_page(addr+40, addr, os::vm_page_size());
address lowest = (address) dlinfo.dli_sname;
if (!lowest) lowest = (address) dlinfo.dli_fbase;
if (begin < lowest) begin = lowest;

17
hotspot/src/os/solaris/vm/perfMemory_solaris.cpp
View File

@ -687,15 +687,15 @@ static int open_sharedmem_file(const char* filename, int oflags, TRAPS) {
RESTARTABLE(::open(filename, oflags), result);
if (result == OS_ERR) {
if (errno == ENOENT) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Process not found", OS_ERR);
}
else if (errno == EACCES) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied");
THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),
"Permission denied", OS_ERR);
}
else {
THROW_MSG_0(vmSymbols::java_io_IOException(), strerror(errno));
THROW_MSG_(vmSymbols::java_io_IOException(), strerror(errno), OS_ERR);
}
}
@ -843,7 +843,7 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
char* mapAddress;
int result;
int fd;
size_t size;
size_t size = 0;
const char* luser = NULL;
int mmap_prot;
@ -914,9 +914,12 @@ static void mmap_attach_shared(const char* user, int vmid, PerfMemory::PerfMemor
if (*sizep == 0) {
size = sharedmem_filesize(fd, CHECK);
assert(size != 0, "unexpected size");
} else {
size = *sizep;
}
assert(size > 0, "unexpected size <= 0");
mapAddress = (char*)::mmap((char*)0, size, mmap_prot, MAP_SHARED, fd, 0);
// attempt to close the file - restart if it gets interrupted,

3
hotspot/src/os/windows/vm/os_windows.cpp
View File

@ -1182,6 +1182,9 @@ bool os::dll_build_name(char *buffer, size_t buflen,
} else if (strchr(pname, *os::path_separator()) != NULL) {
int n;
char** pelements = split_path(pname, &n);
if (pelements == NULL) {
return false;
}
for (int i = 0 ; i < n ; i++) {
char* path = pelements[i];
// Really shouldn't be NULL, but check can't hurt

7
hotspot/src/os/windows/vm/perfMemory_windows.cpp
View File

@ -1581,7 +1581,7 @@ static void open_file_mapping(const char* user, int vmid,
ResourceMark rm;
void *mapAddress = 0;
size_t size;
size_t size = 0;
HANDLE fmh;
DWORD ofm_access;
DWORD mv_access;
@ -1652,9 +1652,12 @@ static void open_file_mapping(const char* user, int vmid,
if (*sizep == 0) {
size = sharedmem_filesize(rfilename, CHECK);
assert(size != 0, "unexpected size");
} else {
size = *sizep;
}
assert(size > 0, "unexpected size <= 0");
// Open the file mapping object with the given name
fmh = open_sharedmem_object(robjectname, ofm_access, CHECK);

4
hotspot/src/share/tools/launcher/wildcard.c
View File

@ -368,8 +368,10 @@ wildcardFileList(const char *wildcard)
const char *basename;
FileList fl = FileList_new(16);
WildcardIterator it = WildcardIterator_for(wildcard);
if (it == NULL)
if (it == NULL) {
FileList_free(fl);
return NULL;
}
while ((basename = WildcardIterator_next(it)) != NULL)
if (isJarFileName(basename))
FileList_add(fl, wildcardConcat(wildcard, basename));

19
hotspot/src/share/vm/c1/c1_LIRGenerator.cpp
View File

@ -711,25 +711,6 @@ static ciArrayKlass* as_array_klass(ciType* type) {
}
}
static Value maxvalue(IfOp* ifop) {
switch (ifop->cond()) {
case If::eql: return NULL;
case If::neq: return NULL;
case If::lss: // x < y ? x : y
case If::leq: // x <= y ? x : y
if (ifop->x() == ifop->tval() &&
ifop->y() == ifop->fval()) return ifop->y();
return NULL;
case If::gtr: // x > y ? y : x
case If::geq: // x >= y ? y : x
if (ifop->x() == ifop->tval() &&
ifop->y() == ifop->fval()) return ifop->y();
return NULL;
}
}
static ciType* phi_declared_type(Phi* phi) {
ciType* t = phi->operand_at(0)->declared_type();
if (t == NULL) {

6
hotspot/src/share/vm/classfile/verifier.cpp
View File

@ -63,6 +63,7 @@
#define NOFAILOVER_MAJOR_VERSION 51
#define NONZERO_PADDING_BYTES_IN_SWITCH_MAJOR_VERSION 51
#define STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION 52
// Access to external entry for VerifyClassCodes - old byte code verifier
@ -2320,6 +2321,11 @@ void ClassVerifier::verify_invoke_instructions(
types = (1 << JVM_CONSTANT_InterfaceMethodref) |
(1 << JVM_CONSTANT_Methodref);
break;
case Bytecodes::_invokestatic:
types = (_klass->major_version() < STATIC_METHOD_IN_INTERFACE_MAJOR_VERSION) ?
(1 << JVM_CONSTANT_Methodref) :
((1 << JVM_CONSTANT_InterfaceMethodref) | (1 << JVM_CONSTANT_Methodref));
break;
default:
types = 1 << JVM_CONSTANT_Methodref;
}

22
hotspot/src/share/vm/compiler/compileLog.cpp
View File

@ -60,28 +60,6 @@ CompileLog::~CompileLog() {
}
// Advance kind up to a null or space, return this tail.
// Make sure kind is null-terminated, not space-terminated.
// Use the buffer if necessary.
static const char* split_attrs(const char* &kind, char* buffer) {
const char* attrs = strchr(kind, ' ');
// Tease apart the first word from the rest:
if (attrs == NULL) {
return ""; // no attrs, no split
} else if (kind == buffer) {
((char*) attrs)[-1] = 0;
return attrs;
} else {
// park it in the buffer, so we can put a null on the end
assert(!(kind >= buffer && kind < buffer+100), "not obviously in buffer");
int klen = attrs - kind;
strncpy(buffer, kind, klen);
buffer[klen] = 0;
kind = buffer; // return by reference
return attrs;
}
}
// see_tag, pop_tag: Override the default do-nothing methods on xmlStream.
// These methods provide a hook for managing the the extra context markup.
void CompileLog::see_tag(const char* tag, bool push) {

7
hotspot/src/share/vm/compiler/compilerOracle.cpp
View File

@ -237,13 +237,6 @@ static const char * command_names[] = {
"help"
};
static const char * command_name(OracleCommand command) {
if (command < OracleFirstCommand || command >= OracleCommandCount) {
return "unknown command";
}
return command_names[command];
}
class MethodMatcher;
static MethodMatcher* lists[OracleCommandCount] = { 0, };

12
hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp
View File

@ -1359,18 +1359,6 @@ void G1CollectorPolicy::print_yg_surv_rate_info() const {
#endif // PRODUCT
}
#ifndef PRODUCT
// for debugging, bit of a hack...
static char*
region_num_to_mbs(int length) {
static char buffer[64];
double bytes = (double) (length * HeapRegion::GrainBytes);
double mbs = bytes / (double) (1024 * 1024);
sprintf(buffer, "%7.2lfMB", mbs);
return buffer;
}
#endif // PRODUCT
uint G1CollectorPolicy::max_regions(int purpose) {
switch (purpose) {
case GCAllocForSurvived:

9
hotspot/src/share/vm/gc_implementation/g1/ptrQueue.cpp
View File

@ -53,15 +53,6 @@ void PtrQueue::flush() {
}
static int byte_index_to_index(int ind) {
assert((ind % oopSize) == 0, "Invariant.");
return ind / oopSize;
}
static int index_to_byte_index(int byte_ind) {
return byte_ind * oopSize;
}
void PtrQueue::enqueue_known_active(void* ptr) {
assert(0 <= _index && _index <= _sz, "Invariant.");
assert(_index == 0 || _buf != NULL, "invariant");

5
hotspot/src/share/vm/interpreter/interpreterRuntime.cpp
View File

@ -557,11 +557,6 @@ IRT_END
// be shared by method invocation and synchronized blocks.
//%note synchronization_3
static void trace_locking(Handle& h_locking_obj, bool is_locking) {
ObjectSynchronizer::trace_locking(h_locking_obj, false, true, is_locking);
}
//%note monitor_1
IRT_ENTRY_NO_ASYNC(void, InterpreterRuntime::monitorenter(JavaThread* thread, BasicObjectLock* elem))
#ifdef ASSERT

7
hotspot/src/share/vm/memory/heap.cpp
View File

@ -79,13 +79,6 @@ static size_t align_to_page_size(size_t size) {
}
static size_t align_to_allocation_size(size_t size) {
const size_t alignment = (size_t)os::vm_allocation_granularity();
assert(is_power_of_2(alignment), "no kidding ???");
return (size + alignment - 1) & ~(alignment - 1);
}
void CodeHeap::on_code_mapping(char* base, size_t size) {
#ifdef LINUX
extern void linux_wrap_code(char* base, size_t size);

4
hotspot/src/share/vm/memory/universe.cpp
View File

@ -1326,6 +1326,8 @@ static uintptr_t _verify_oop_data[2] = {0, (uintptr_t)-1};
static uintptr_t _verify_klass_data[2] = {0, (uintptr_t)-1};
#ifndef PRODUCT
static void calculate_verify_data(uintptr_t verify_data[2],
HeapWord* low_boundary,
HeapWord* high_boundary) {
@ -1360,9 +1362,7 @@ static void calculate_verify_data(uintptr_t verify_data[2],
verify_data[1] = bits;
}
// Oop verification (see MacroAssembler::verify_oop)
#ifndef PRODUCT
uintptr_t Universe::verify_oop_mask() {
MemRegion m = heap()->reserved_region();

12
hotspot/src/share/vm/oops/constantPool.cpp
View File

@ -1378,12 +1378,13 @@ const char* ConstantPool::printable_name_at(int which) {
// JVMTI GetConstantPool support
// For temporary use until code is stable.
#define DBG(code)
// For debugging of constant pool
const bool debug_cpool = false;
static const char* WARN_MSG = "Must not be such entry!";
#define DBG(code) do { if (debug_cpool) { (code); } } while(0)
static void print_cpool_bytes(jint cnt, u1 *bytes) {
const char* WARN_MSG = "Must not be such entry!";
jint size = 0;
u2 idx1, idx2;
@ -1669,8 +1670,7 @@ int ConstantPool::copy_cpool_bytes(int cpool_size,
idx1 = tbl->symbol_to_value(sym);
assert(idx1 != 0, "Have not found a hashtable entry");
Bytes::put_Java_u2((address) (bytes+1), idx1);
DBG(char *str = sym->as_utf8());
DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, str));
DBG(printf("JVM_CONSTANT_String: idx=#%03hd, %s", idx1, sym->as_utf8()));
break;
}
case JVM_CONSTANT_Fieldref:
@ -1745,6 +1745,8 @@ int ConstantPool::copy_cpool_bytes(int cpool_size,
return (int)(bytes - start_bytes);
} /* end copy_cpool_bytes */
#undef DBG
void ConstantPool::set_on_stack(const bool value) {
if (value) {

2
hotspot/src/share/vm/oops/instanceKlass.cpp
View File

@ -3157,7 +3157,7 @@ void InstanceKlass::verify_on(outputStream* st) {
Array<int>* method_ordering = this->method_ordering();
int length = method_ordering->length();
if (JvmtiExport::can_maintain_original_method_order() ||
(UseSharedSpaces && length != 0)) {
((UseSharedSpaces || DumpSharedSpaces) && length != 0)) {
guarantee(length == methods()->length(), "invalid method ordering length");
jlong sum = 0;
for (int j = 0; j < length; j++) {

20
hotspot/src/share/vm/opto/block.cpp
View File

@ -1028,26 +1028,6 @@ void UnionFind::Union( uint idx1, uint idx2 ) {
}
#ifndef PRODUCT
static void edge_dump(GrowableArray<CFGEdge *> *edges) {
tty->print_cr("---- Edges ----");
for (int i = 0; i < edges->length(); i++) {
CFGEdge *e = edges->at(i);
if (e != NULL) {
edges->at(i)->dump();
}
}
}
static void trace_dump(Trace *traces[], int count) {
tty->print_cr("---- Traces ----");
for (int i = 0; i < count; i++) {
Trace *tr = traces[i];
if (tr != NULL) {
tr->dump();
}
}
}
void Trace::dump( ) const {
tty->print_cr("Trace (freq %f)", first_block()->_freq);
for (Block *b = first_block(); b != NULL; b = next(b)) {

2
hotspot/src/share/vm/opto/compile.cpp
View File

@ -2326,12 +2326,14 @@ struct Final_Reshape_Counts : public StackObj {
int get_inner_loop_count() const { return _inner_loop_count; }
};
#ifdef ASSERT
static bool oop_offset_is_sane(const TypeInstPtr* tp) {
ciInstanceKlass *k = tp->klass()->as_instance_klass();
// Make sure the offset goes inside the instance layout.
return k->contains_field_offset(tp->offset());
// Note that OffsetBot and OffsetTop are very negative.
}
#endif
// Eliminate trivially redundant StoreCMs and accumulate their
// precedence edges.

23
hotspot/src/share/vm/opto/connode.cpp
View File

@ -465,29 +465,6 @@ Node *CheckCastPPNode::Identity( PhaseTransform *phase ) {
return (phase->type(in(1)) == phase->type(this)) ? in(1) : this;
}
// Determine whether "n" is a node which can cause an alias of one of its inputs. Node types
// which can create aliases are: CheckCastPP, Phi, and any store (if there is also a load from
// the location.)
// Note: this checks for aliases created in this compilation, not ones which may
// be potentially created at call sites.
static bool can_cause_alias(Node *n, PhaseTransform *phase) {
bool possible_alias = false;
if (n->is_Store()) {
possible_alias = !n->as_Store()->value_never_loaded(phase);
} else {
int opc = n->Opcode();
possible_alias = n->is_Phi() ||
opc == Op_CheckCastPP ||
opc == Op_StorePConditional ||
opc == Op_CompareAndSwapP ||
opc == Op_CompareAndSwapN ||
opc == Op_GetAndSetP ||
opc == Op_GetAndSetN;
}
return possible_alias;
}
//------------------------------Value------------------------------------------
// Take 'join' of input and cast-up type, unless working with an Interface
const Type *CheckCastPPNode::Value( PhaseTransform *phase ) const {

10
hotspot/src/share/vm/opto/subnode.cpp
View File

@ -1078,16 +1078,6 @@ uint BoolNode::cmp( const Node &n ) const {
return (_test._test == b->_test._test);
}
//------------------------------clone_cmp--------------------------------------
// Clone a compare/bool tree
static Node *clone_cmp( Node *cmp, Node *cmp1, Node *cmp2, PhaseGVN *gvn, BoolTest::mask test ) {
Node *ncmp = cmp->clone();
ncmp->set_req(1,cmp1);
ncmp->set_req(2,cmp2);
ncmp = gvn->transform( ncmp );
return new (gvn->C) BoolNode( ncmp, test );
}
//-------------------------------make_predicate--------------------------------
Node* BoolNode::make_predicate(Node* test_value, PhaseGVN* phase) {
if (test_value->is_Con()) return test_value;

27
hotspot/src/share/vm/prims/jni.cpp
View File

@ -1289,32 +1289,6 @@ enum JNICallType {
JNI_NONVIRTUAL
};
static methodHandle jni_resolve_interface_call(Handle recv, methodHandle method, TRAPS) {
assert(!method.is_null() , "method should not be null");
KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
KlassHandle spec_klass (THREAD, method->method_holder());
Symbol* name = method->name();
Symbol* signature = method->signature();
CallInfo info;
LinkResolver::resolve_interface_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
return info.selected_method();
}
static methodHandle jni_resolve_virtual_call(Handle recv, methodHandle method, TRAPS) {
assert(!method.is_null() , "method should not be null");
KlassHandle recv_klass; // Default to NULL (use of ?: can confuse gcc)
if (recv.not_null()) recv_klass = KlassHandle(THREAD, recv->klass());
KlassHandle spec_klass (THREAD, method->method_holder());
Symbol* name = method->name();
Symbol* signature = method->signature();
CallInfo info;
LinkResolver::resolve_virtual_call(info, recv, recv_klass, spec_klass, name, signature, KlassHandle(), false, true, CHECK_(methodHandle()));
return info.selected_method();
}
static void jni_invoke_static(JNIEnv *env, JavaValue* result, jobject receiver, JNICallType call_type, jmethodID method_id, JNI_ArgumentPusher *args, TRAPS) {
@ -5053,6 +5027,7 @@ _JNI_IMPORT_OR_EXPORT_ jint JNICALL JNI_GetDefaultJavaVMInitArgs(void *args_) {
void execute_internal_vm_tests() {
if (ExecuteInternalVMTests) {
tty->print_cr("Running internal VM tests");
run_unit_test(GlobalDefinitions::test_globals());
run_unit_test(arrayOopDesc::test_max_array_length());
run_unit_test(CollectedHeap::test_is_in());
run_unit_test(QuickSort::test_quick_sort());

2
hotspot/src/share/vm/prims/jniCheck.hpp
View File

@ -33,7 +33,7 @@ extern "C" {
// within IN_VM macro), one to be called when in NATIVE state.
// When in VM state:
static void ReportJNIFatalError(JavaThread* thr, const char *msg) {
static inline void ReportJNIFatalError(JavaThread* thr, const char *msg) {
tty->print_cr("FATAL ERROR in native method: %s", msg);
thr->print_stack();
os::abort(true);

65
hotspot/src/share/vm/prims/whitebox.cpp
View File

@ -118,45 +118,46 @@ WB_END
#endif // INCLUDE_ALL_GCS
#ifdef INCLUDE_NMT
// Keep track of the 3 allocations in NMTAllocTest so we can free them later
// on and verify that they're not visible anymore
static void* nmtMtTest1 = NULL, *nmtMtTest2 = NULL, *nmtMtTest3 = NULL;
// Alloc memory using the test memory type so that we can use that to see if
// NMT picks it up correctly
WB_ENTRY(jboolean, WB_NMTAllocTest(JNIEnv* env))
void *mem;
WB_ENTRY(jlong, WB_NMTMalloc(JNIEnv* env, jobject o, jlong size))
jlong addr = 0;
if (!MemTracker::is_on() || MemTracker::shutdown_in_progress()) {
return false;
if (MemTracker::is_on() && !MemTracker::shutdown_in_progress()) {
addr = (jlong)(uintptr_t)os::malloc(size, mtTest);
}
// Allocate 2 * 128k + 256k + 1024k and free the 1024k one to make sure we track
// everything correctly. Total should be 512k held alive.
nmtMtTest1 = os::malloc(128 * 1024, mtTest);
mem = os::malloc(1024 * 1024, mtTest);
nmtMtTest2 = os::malloc(256 * 1024, mtTest);
os::free(mem, mtTest);
nmtMtTest3 = os::malloc(128 * 1024, mtTest);
return true;
return addr;
WB_END
// Free the memory allocated by NMTAllocTest
WB_ENTRY(jboolean, WB_NMTFreeTestMemory(JNIEnv* env))
WB_ENTRY(void, WB_NMTFree(JNIEnv* env, jobject o, jlong mem))
os::free((void*)(uintptr_t)mem, mtTest);
WB_END
if (nmtMtTest1 == NULL || nmtMtTest2 == NULL || nmtMtTest3 == NULL) {
return false;
WB_ENTRY(jlong, WB_NMTReserveMemory(JNIEnv* env, jobject o, jlong size))
jlong addr = 0;
if (MemTracker::is_on() && !MemTracker::shutdown_in_progress()) {
addr = (jlong)(uintptr_t)os::reserve_memory(size);
MemTracker::record_virtual_memory_type((address)addr, mtTest);
}
os::free(nmtMtTest1, mtTest);
nmtMtTest1 = NULL;
os::free(nmtMtTest2, mtTest);
nmtMtTest2 = NULL;
os::free(nmtMtTest3, mtTest);
nmtMtTest3 = NULL;
return addr;
WB_END
return true;
WB_ENTRY(void, WB_NMTCommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::commit_memory((char *)(uintptr_t)addr, size);
MemTracker::record_virtual_memory_type((address)(uintptr_t)addr, mtTest);
WB_END
WB_ENTRY(void, WB_NMTUncommitMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::uncommit_memory((char *)(uintptr_t)addr, size);
WB_END
WB_ENTRY(void, WB_NMTReleaseMemory(JNIEnv* env, jobject o, jlong addr, jlong size))
os::release_memory((char *)(uintptr_t)addr, size);
WB_END
// Block until the current generation of NMT data to be merged, used to reliably test the NMT feature
@ -340,9 +341,13 @@ static JNINativeMethod methods[] = {
{CC"g1RegionSize", CC"()I", (void*)&WB_G1RegionSize },
#endif // INCLUDE_ALL_GCS
#ifdef INCLUDE_NMT
{CC"NMTAllocTest", CC"()Z", (void*)&WB_NMTAllocTest },
{CC"NMTFreeTestMemory", CC"()Z", (void*)&WB_NMTFreeTestMemory },
{CC"NMTWaitForDataMerge",CC"()Z", (void*)&WB_NMTWaitForDataMerge},
{CC"NMTMalloc", CC"(J)J", (void*)&WB_NMTMalloc },
{CC"NMTFree", CC"(J)V", (void*)&WB_NMTFree },
{CC"NMTReserveMemory", CC"(J)J", (void*)&WB_NMTReserveMemory },
{CC"NMTCommitMemory", CC"(JJ)V", (void*)&WB_NMTCommitMemory },
{CC"NMTUncommitMemory", CC"(JJ)V", (void*)&WB_NMTUncommitMemory },
{CC"NMTReleaseMemory", CC"(JJ)V", (void*)&WB_NMTReleaseMemory },
{CC"NMTWaitForDataMerge", CC"()Z", (void*)&WB_NMTWaitForDataMerge},
#endif // INCLUDE_NMT
{CC"deoptimizeAll", CC"()V", (void*)&WB_DeoptimizeAll },
{CC"deoptimizeMethod", CC"(Ljava/lang/reflect/Method;)I",

6
hotspot/src/share/vm/runtime/arguments.cpp
View File

@ -1754,11 +1754,15 @@ bool Arguments::verify_percentage(uintx value, const char* name) {
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,
@ -3092,6 +3096,7 @@ do { \
} \
} while(0)
#if !INCLUDE_ALL_GCS
static void force_serial_gc() {
FLAG_SET_DEFAULT(UseSerialGC, true);
FLAG_SET_DEFAULT(CMSIncrementalMode, false); // special CMS suboption
@ -3101,6 +3106,7 @@ static void force_serial_gc() {
UNSUPPORTED_GC_OPTION(UseConcMarkSweepGC);
UNSUPPORTED_GC_OPTION(UseParNewGC);
}
#endif // INCLUDE_ALL_GCS
// Parse entry point called from JNI_CreateJavaVM

4
hotspot/src/share/vm/runtime/safepoint.cpp
View File

@ -735,6 +735,9 @@ void SafepointSynchronize::block(JavaThread *thread) {
// Exception handlers
#ifndef PRODUCT
#ifdef SPARC
#ifdef _LP64
#define PTR_PAD ""
#else
@ -755,7 +758,6 @@ static void print_longs(jlong oldptr, jlong newptr, bool wasoop) {
newptr, is_oop?"oop":" ", (wasoop && !is_oop) ? "STALE" : ((wasoop==false&&is_oop==false&&oldptr !=newptr)?"STOMP":" "));
}
#ifdef SPARC
static void print_me(intptr_t *new_sp, intptr_t *old_sp, bool *was_oops) {
#ifdef _LP64
tty->print_cr("--------+------address-----+------before-----------+-------after----------+");

7
hotspot/src/share/vm/runtime/synchronizer.cpp
View File

@ -449,8 +449,6 @@ void ObjectSynchronizer::notifyall(Handle obj, TRAPS) {
// and explicit fences (barriers) to control for architectural reordering performed
// by the CPU(s) or platform.
static int MBFence (int x) { OrderAccess::fence(); return x; }
struct SharedGlobals {
// These are highly shared mostly-read variables.
// To avoid false-sharing they need to be the sole occupants of a $ line.
@ -1639,11 +1637,6 @@ void ObjectSynchronizer::release_monitors_owned_by_thread(TRAPS) {
#ifndef PRODUCT
void ObjectSynchronizer::trace_locking(Handle locking_obj, bool is_compiled,
bool is_method, bool is_locking) {
// Don't know what to do here
}
// Verify all monitors in the monitor cache, the verification is weak.
void ObjectSynchronizer::verify() {
ObjectMonitor* block = gBlockList;

1
hotspot/src/share/vm/runtime/synchronizer.hpp
View File

@ -121,7 +121,6 @@ class ObjectSynchronizer : AllStatic {
static void oops_do(OopClosure* f);
// debugging
static void trace_locking(Handle obj, bool is_compiled, bool is_method, bool is_locking) PRODUCT_RETURN;
static void verify() PRODUCT_RETURN;
static int verify_objmon_isinpool(ObjectMonitor *addr) PRODUCT_RETURN0;

14
hotspot/src/share/vm/services/memTracker.cpp
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
* 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
@ -127,12 +127,15 @@ void MemTracker::start() {
assert(_state == NMT_bootstrapping_multi_thread, "wrong state");
_snapshot = new (std::nothrow)MemSnapshot();
if (_snapshot != NULL && !_snapshot->out_of_memory()) {
if (start_worker()) {
if (_snapshot != NULL) {
if (!_snapshot->out_of_memory() && start_worker()) {
_state = NMT_started;
NMT_track_callsite = (_tracking_level == NMT_detail && can_walk_stack());
return;
}
delete _snapshot;
_snapshot = NULL;
}
// fail to start native memory tracking, shut it down
@ -544,7 +547,10 @@ bool MemTracker::start_worker() {
assert(_worker_thread == NULL, "Just Check");
_worker_thread = new (std::nothrow) MemTrackWorker();
if (_worker_thread == NULL || _worker_thread->has_error()) {
shutdown(NMT_initialization);
if (_worker_thread != NULL) {
delete _worker_thread;
_worker_thread = NULL;
}
return false;
}
_worker_thread->start();

12
hotspot/src/share/vm/utilities/debug.cpp
View File

@ -608,18 +608,6 @@ extern "C" nmethod* findnm(intptr_t addr) {
return CodeCache::find_nmethod((address)addr);
}
static address same_page(address x, address y) {
intptr_t page_bits = -os::vm_page_size();
if ((intptr_t(x) & page_bits) == (intptr_t(y) & page_bits)) {
return x;
} else if (x > y) {
return (address)(intptr_t(y) | ~page_bits) + 1;
} else {
return (address)(intptr_t(y) & page_bits);
}
}
// Another interface that isn't ambiguous in dbx.
// Can we someday rename the other find to hsfind?
extern "C" void hsfind(intptr_t x) {

30
hotspot/src/share/vm/utilities/globalDefinitions.cpp
View File

@ -355,3 +355,33 @@ size_t lcm(size_t a, size_t b) {
return size_t(result);
}
#ifndef PRODUCT
void GlobalDefinitions::test_globals() {
intptr_t page_sizes[] = { os::vm_page_size(), 4096, 8192, 65536, 2*1024*1024 };
const int num_page_sizes = sizeof(page_sizes) / sizeof(page_sizes[0]);
for (int i = 0; i < num_page_sizes; i++) {
intptr_t page_size = page_sizes[i];
address a_page = (address)(10*page_size);
// Check that address within page is returned as is
assert(clamp_address_in_page(a_page, a_page, page_size) == a_page, "incorrect");
assert(clamp_address_in_page(a_page + 128, a_page, page_size) == a_page + 128, "incorrect");
assert(clamp_address_in_page(a_page + page_size - 1, a_page, page_size) == a_page + page_size - 1, "incorrect");
// Check that address above page returns start of next page
assert(clamp_address_in_page(a_page + page_size, a_page, page_size) == a_page + page_size, "incorrect");
assert(clamp_address_in_page(a_page + page_size + 1, a_page, page_size) == a_page + page_size, "incorrect");
assert(clamp_address_in_page(a_page + page_size*5 + 1, a_page, page_size) == a_page + page_size, "incorrect");
// Check that address below page returns start of page
assert(clamp_address_in_page(a_page - 1, a_page, page_size) == a_page, "incorrect");
assert(clamp_address_in_page(a_page - 2*page_size - 1, a_page, page_size) == a_page, "incorrect");
assert(clamp_address_in_page(a_page - 5*page_size - 1, a_page, page_size) == a_page, "incorrect");
}
}
#endif // PRODUCT

29
hotspot/src/share/vm/utilities/globalDefinitions.hpp
View File

@ -419,6 +419,24 @@ inline intptr_t align_object_offset(intptr_t offset) {
return align_size_up(offset, HeapWordsPerLong);
}
// Clamp an address to be within a specific page
// 1. If addr is on the page it is returned as is
// 2. If addr is above the page_address the start of the *next* page will be returned
// 3. Otherwise, if addr is below the page_address the start of the page will be returned
inline address clamp_address_in_page(address addr, address page_address, intptr_t page_size) {
if (align_size_down(intptr_t(addr), page_size) == align_size_down(intptr_t(page_address), page_size)) {
// address is in the specified page, just return it as is
return addr;
} else if (addr > page_address) {
// address is above specified page, return start of next page
return (address)align_size_down(intptr_t(page_address), page_size) + page_size;
} else {
// address is below specified page, return start of page
return (address)align_size_down(intptr_t(page_address), page_size);
}
}
// The expected size in bytes of a cache line, used to pad data structures.
#define DEFAULT_CACHE_LINE_SIZE 64
@ -1296,4 +1314,15 @@ static inline void* dereference_vptr(void* addr) {
return *(void**)addr;
}
#ifndef PRODUCT
// For unit testing only
class GlobalDefinitions {
public:
static void test_globals();
};
#endif // PRODUCT
#endif // SHARE_VM_UTILITIES_GLOBALDEFINITIONS_HPP

25
hotspot/test/runtime/NMT/AllocTestType.java → hotspot/test/runtime/NMT/MallocTestType.java
View File

@ -26,30 +26,33 @@
* @summary Test consistency of NMT by leaking a few select allocations of the Test type and then verify visibility with jcmd
* @key nmt jcmd
* @library /testlibrary /testlibrary/whitebox
* @build AllocTestType
* @build MallocTestType
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail AllocTestType
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail MallocTestType
*/
import com.oracle.java.testlibrary.*;
import sun.hotspot.WhiteBox;
public class AllocTestType {
public class MallocTestType {
public static void main(String args[]) throws Exception {
OutputAnalyzer output;
WhiteBox wb = WhiteBox.getWhiteBox();
// Grab my own PID
String pid = Integer.toString(ProcessTools.getProcessId());
ProcessBuilder pb = new ProcessBuilder();
// Use WB API to alloc with the mtTest type
if (!WhiteBox.getWhiteBox().NMTAllocTest()) {
throw new Exception("Call to WB API NMTAllocTest() failed");
}
// Use WB API to alloc and free with the mtTest type
long memAlloc3 = wb.NMTMalloc(128 * 1024);
long memAlloc2 = wb.NMTMalloc(256 * 1024);
wb.NMTFree(memAlloc3);
long memAlloc1 = wb.NMTMalloc(512 * 1024);
wb.NMTFree(memAlloc2);
// Use WB API to ensure that all data has been merged before we continue
if (!WhiteBox.getWhiteBox().NMTWaitForDataMerge()) {
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
@ -59,12 +62,10 @@ public class AllocTestType {
output.shouldContain("Test (reserved=512KB, committed=512KB)");
// Free the memory allocated by NMTAllocTest
if (!WhiteBox.getWhiteBox().NMTFreeTestMemory()) {
throw new Exception("Call to WB API NMTFreeTestMemory() failed");
}
wb.NMTFree(memAlloc1);
// Use WB API to ensure that all data has been merged before we continue
if (!WhiteBox.getWhiteBox().NMTWaitForDataMerge()) {
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
output = new OutputAnalyzer(pb.start());

91
hotspot/test/runtime/NMT/ThreadedMallocTestType.java Normal file
View File

@ -0,0 +1,91 @@
/*
* 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
* @key nmt jcmd
* @library /testlibrary /testlibrary/whitebox
* @build ThreadedMallocTestType
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail ThreadedMallocTestType
*/
import com.oracle.java.testlibrary.*;
import sun.hotspot.WhiteBox;
public class ThreadedMallocTestType {
public static long memAlloc1;
public static long memAlloc2;
public static long memAlloc3;
public static void main(String args[]) throws Exception {
OutputAnalyzer output;
final WhiteBox wb = WhiteBox.getWhiteBox();
// Grab my own PID
String pid = Integer.toString(ProcessTools.getProcessId());
ProcessBuilder pb = new ProcessBuilder();
Thread allocThread = new Thread() {
public void run() {
// Alloc memory using the WB api
memAlloc1 = wb.NMTMalloc(128 * 1024);
memAlloc2 = wb.NMTMalloc(256 * 1024);
memAlloc3 = wb.NMTMalloc(512 * 1024);
}
};
allocThread.start();
allocThread.join();
// Use WB API to ensure that all data has been merged before we continue
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
// Run 'jcmd <pid> VM.native_memory summary'
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "summary"});
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=896KB, committed=896KB)");
Thread freeThread = new Thread() {
public void run() {
// Free the memory allocated by NMTMalloc
wb.NMTFree(memAlloc1);
wb.NMTFree(memAlloc2);
wb.NMTFree(memAlloc3);
}
};
freeThread.start();
freeThread.join();
// Use WB API to ensure that all data has been merged before we continue
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Test (reserved=");
}
}

112
hotspot/test/runtime/NMT/ThreadedVirtualAllocTestType.java Normal file
View File

@ -0,0 +1,112 @@
/*
* 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
* @key nmt jcmd
* @library /testlibrary /testlibrary/whitebox
* @build ThreadedVirtualAllocTestType
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail ThreadedVirtualAllocTestType
*/
import com.oracle.java.testlibrary.*;
import sun.hotspot.WhiteBox;
public class ThreadedVirtualAllocTestType {
public static long addr;
public static final WhiteBox wb = WhiteBox.getWhiteBox();
public static final long commitSize = 128 * 1024;
public static final long reserveSize = 512 * 1024;
public static void main(String args[]) throws Exception {
OutputAnalyzer output;
String pid = Integer.toString(ProcessTools.getProcessId());
ProcessBuilder pb = new ProcessBuilder();
Thread reserveThread = new Thread() {
public void run() {
addr = wb.NMTReserveMemory(reserveSize);
}
};
reserveThread.start();
reserveThread.join();
mergeData();
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "detail"});
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=512KB, committed=0KB)");
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + reserveSize) + "\\] reserved 512KB for Test");
Thread commitThread = new Thread() {
public void run() {
wb.NMTCommitMemory(addr, commitSize);
}
};
commitThread.start();
commitThread.join();
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=512KB, committed=128KB)");
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + commitSize) + "\\] committed 128KB");
Thread uncommitThread = new Thread() {
public void run() {
wb.NMTUncommitMemory(addr, commitSize);
}
};
uncommitThread.start();
uncommitThread.join();
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=512KB, committed=0KB)");
output.shouldNotMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + commitSize) + "\\] committed");
Thread releaseThread = new Thread() {
public void run() {
wb.NMTReleaseMemory(addr, reserveSize);
}
};
releaseThread.start();
releaseThread.join();
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Test (reserved=");
output.shouldNotContain("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + reserveSize) + "\\] reserved");
}
public static void mergeData() throws Exception {
// Use WB API to ensure that all data has been merged before we continue
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
}
}

88
hotspot/test/runtime/NMT/VirtualAllocTestType.java Normal file
View File

@ -0,0 +1,88 @@
/*
* 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
* @summary Test Reserve/Commit/Uncommit/Release of virtual memory and that we track it correctly
* @key nmt jcmd
* @library /testlibrary /testlibrary/whitebox
* @build VirtualAllocTestType
* @run main ClassFileInstaller sun.hotspot.WhiteBox
* @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -XX:NativeMemoryTracking=detail VirtualAllocTestType
*/
import com.oracle.java.testlibrary.*;
import sun.hotspot.WhiteBox;
public class VirtualAllocTestType {
public static WhiteBox wb = WhiteBox.getWhiteBox();
public static void main(String args[]) throws Exception {
OutputAnalyzer output;
long commitSize = 128 * 1024;
long reserveSize = 256 * 1024;
long addr;
String pid = Integer.toString(ProcessTools.getProcessId());
ProcessBuilder pb = new ProcessBuilder();
addr = wb.NMTReserveMemory(reserveSize);
mergeData();
pb.command(new String[] { JDKToolFinder.getJDKTool("jcmd"), pid, "VM.native_memory", "detail"});
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=256KB, committed=0KB)");
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + reserveSize) + "\\] reserved 256KB for Test");
wb.NMTCommitMemory(addr, commitSize);
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=256KB, committed=128KB)");
output.shouldMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + commitSize) + "\\] committed 128KB");
wb.NMTUncommitMemory(addr, commitSize);
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldContain("Test (reserved=256KB, committed=0KB)");
output.shouldNotMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + commitSize) + "\\] committed");
wb.NMTReleaseMemory(addr, reserveSize);
mergeData();
output = new OutputAnalyzer(pb.start());
output.shouldNotContain("Test (reserved=");
output.shouldNotMatch("\\[0x[0]*" + Long.toHexString(addr) + " - 0x[0]*" + Long.toHexString(addr + reserveSize) + "\\] reserved");
}
public static void mergeData() throws Exception {
// Use WB API to ensure that all data has been merged before we continue
if (!wb.NMTWaitForDataMerge()) {
throw new Exception("Call to WB API NMTWaitForDataMerge() failed");
}
}
}

74
hotspot/test/testlibrary/OutputAnalyzerTest.java
View File

@ -36,6 +36,11 @@ public class OutputAnalyzerTest {
String stdout = "aaaaaa";
String stderr = "bbbbbb";
// Regexps used for testing pattern matching of the test input
String stdoutPattern = "[a]";
String stderrPattern = "[b]";
String nonExistingPattern = "[c]";
OutputAnalyzer output = new OutputAnalyzer(stdout, stderr);
if (!stdout.equals(output.getStdout())) {
@ -99,10 +104,73 @@ public class OutputAnalyzerTest {
}
try {
output.stderrShouldNotContain(stderr);
throw new Exception("shouldContain() failed to throw exception");
output.stderrShouldNotContain(stderr);
throw new Exception("shouldContain() failed to throw exception");
} catch (RuntimeException e) {
// expected
// expected
}
// Should match
try {
output.shouldMatch(stdoutPattern);
output.stdoutShouldMatch(stdoutPattern);
output.shouldMatch(stderrPattern);
output.stderrShouldMatch(stderrPattern);
} catch (RuntimeException e) {
throw new Exception("shouldMatch() failed", e);
}
try {
output.shouldMatch(nonExistingPattern);
throw new Exception("shouldMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
try {
output.stdoutShouldMatch(stderrPattern);
throw new Exception(
"stdoutShouldMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
try {
output.stderrShouldMatch(stdoutPattern);
throw new Exception(
"stderrShouldMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
// Should not match
try {
output.shouldNotMatch(nonExistingPattern);
output.stdoutShouldNotMatch(nonExistingPattern);
output.stderrShouldNotMatch(nonExistingPattern);
} catch (RuntimeException e) {
throw new Exception("shouldNotMatch() failed", e);
}
try {
output.shouldNotMatch(stdoutPattern);
throw new Exception("shouldNotMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
try {
output.stdoutShouldNotMatch(stdoutPattern);
throw new Exception("shouldNotMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
try {
output.stderrShouldNotMatch(stderrPattern);
throw new Exception("shouldNotMatch() failed to throw exception");
} catch (RuntimeException e) {
// expected
}
}
}

105
hotspot/test/testlibrary/com/oracle/java/testlibrary/OutputAnalyzer.java
View File

@ -24,6 +24,8 @@
package com.oracle.java.testlibrary;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public final class OutputAnalyzer {
@ -141,6 +143,103 @@ public final class OutputAnalyzer {
}
}
/**
* Verify that the stdout and stderr contents of output buffer matches
* the pattern
*
* @param pattern
* @throws RuntimeException If the pattern was not found
*/
public void shouldMatch(String pattern) {
Matcher stdoutMatcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stdout);
Matcher stderrMatcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stderr);
if (!stdoutMatcher.find() && !stderrMatcher.find()) {
throw new RuntimeException("'" + pattern
+ "' missing from stdout/stderr: [" + stdout + stderr
+ "]\n");
}
}
/**
* Verify that the stdout contents of output buffer matches the
* pattern
*
* @param pattern
* @throws RuntimeException If the pattern was not found
*/
public void stdoutShouldMatch(String pattern) {
Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stdout);
if (!matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' missing from stdout: [" + stdout + "]\n");
}
}
/**
* Verify that the stderr contents of output buffer matches the
* pattern
*
* @param pattern
* @throws RuntimeException If the pattern was not found
*/
public void stderrShouldMatch(String pattern) {
Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stderr);
if (!matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' missing from stderr: [" + stderr + "]\n");
}
}
/**
* Verify that the stdout and stderr contents of output buffer does not
* match the pattern
*
* @param pattern
* @throws RuntimeException If the pattern was found
*/
public void shouldNotMatch(String pattern) {
Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stdout);
if (matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' found in stdout: [" + stdout + "]\n");
}
matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stderr);
if (matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' found in stderr: [" + stderr + "]\n");
}
}
/**
* Verify that the stdout contents of output buffer does not match the
* pattern
*
* @param pattern
* @throws RuntimeException If the pattern was found
*/
public void stdoutShouldNotMatch(String pattern) {
Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stdout);
if (matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' found in stdout: [" + stdout + "]\n");
}
}
/**
* Verify that the stderr contents of output buffer does not match the
* pattern
*
* @param pattern
* @throws RuntimeException If the pattern was found
*/
public void stderrShouldNotMatch(String pattern) {
Matcher matcher = Pattern.compile(pattern, Pattern.MULTILINE).matcher(stderr);
if (matcher.find()) {
throw new RuntimeException("'" + pattern
+ "' found in stderr: [" + stderr + "]\n");
}
}
/**
* Verifiy the exit value of the process
*
@ -148,9 +247,9 @@ public final class OutputAnalyzer {
* @throws RuntimeException If the exit value from the process did not match the expected value
*/
public void shouldHaveExitValue(int expectedExitValue) {
if (getExitValue() != expectedExitValue) {
throw new RuntimeException("Exit value " + getExitValue() + " , expected to get " + expectedExitValue);
}
if (getExitValue() != expectedExitValue) {
throw new RuntimeException("Exit value " + getExitValue() + " , expected to get " + expectedExitValue);
}
}
/**

8
hotspot/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java
View File

@ -80,8 +80,12 @@ public class WhiteBox {
public native Object[] parseCommandLine(String commandline, DiagnosticCommand[] args);
// NMT
public native boolean NMTAllocTest();
public native boolean NMTFreeTestMemory();
public native long NMTMalloc(long size);
public native void NMTFree(long mem);
public native long NMTReserveMemory(long size);
public native void NMTCommitMemory(long addr, long size);
public native void NMTUncommitMemory(long addr, long size);
public native void NMTReleaseMemory(long addr, long size);
public native boolean NMTWaitForDataMerge();
// Compiler