graal-compiler: src/share/vm/runtime/os.cpp comparison

comparison src/share/vm/runtime/os.cpp @ 6948:e522a00b91aa

Merge with http://hg.openjdk.java.net/hsx/hsx25/hotspot/ after NPG - C++ build works

author	Doug Simon <doug.simon@oracle.com>
date	Mon, 12 Nov 2012 23:14:12 +0100
parents	957c266d8bc5 716c64bda5ba
children	2cb439954abf

comparison

equal deleted inserted replaced

-:ae13cc658b80
+:e522a00b91aa
 /*
-* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1997, 2012, 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.
 assert(false, "Should not happen");
 return OS_ERR;
 }
 }
+// The mapping from OS priority back to Java priority may be inexact because
+// Java priorities can map M:1 with native priorities. If you want the definite
+// Java priority then use JavaThread::java_priority()
 OSReturn os::get_priority(const Thread* const thread, ThreadPriority& priority) {
 int p;
 int os_prio;
 OSReturn ret = get_native_priority(thread, &os_prio);
 if (ret != OS_OK) return ret;
-for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] > os_prio; p--) ;
+if (java_to_os_priority[MaxPriority] > java_to_os_priority[MinPriority]) {
+for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] > os_prio; p--) ;
+} else {
+// niceness values are in reverse order
+for (p = MaxPriority; p > MinPriority && java_to_os_priority[p] < os_prio; p--) ;
+}
 priority = (ThreadPriority)p;
 return OS_OK;
 }
 break;
 }
 default: {
 // Dispatch the signal to java
 HandleMark hm(THREAD);
-klassOop k = SystemDictionary::resolve_or_null(vmSymbols::sun_misc_Signal(), THREAD);
+Klass* k = SystemDictionary::resolve_or_null(vmSymbols::sun_misc_Signal(), THREAD);
 KlassHandle klass (THREAD, k);
 if (klass.not_null()) {
 JavaValue result(T_VOID);
 JavaCallArguments args;
 args.push_int(sig);
 // trigger additional out-of-memory conditions
 if (tty != NULL) {
 char klass_name[256];
 char tmp_sig_name[16];
 const char* sig_name = "UNKNOWN";
-instanceKlass::cast(PENDING_EXCEPTION->klass())->
+InstanceKlass::cast(PENDING_EXCEPTION->klass())->
 name()->as_klass_external_name(klass_name, 256);
 if (os::exception_name(sig, tmp_sig_name, 16) != NULL)
 sig_name = tmp_sig_name;
 warning("Exception %s occurred dispatching signal %s to handler"
 "- the VM may need to be forcibly terminated",
 void os::signal_init() {
 if (!ReduceSignalUsage) {
 // Setup JavaThread for processing signals
 EXCEPTION_MARK;
-klassOop k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
+Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK);
 instanceKlassHandle klass (THREAD, k);
 instanceHandle thread_oop = klass->allocate_instance_handle(CHECK);
 const char thread_name[] = "Signal Dispatcher";
 Handle string = java_lang_String::create_from_str(thread_name, CHECK);
 }
 debug_only(if (paranoid) verify_block(memblock));
 if (PrintMalloc && tty != NULL) tty->print_cr("os::malloc " SIZE_FORMAT " bytes --> " PTR_FORMAT, size, memblock);
 // we do not track MallocCushion memory
-if (MemTracker::is_on()) {
 MemTracker::record_malloc((address)memblock, size, memflags, caller == 0 ? CALLER_PC : caller);
-}
 return memblock;
 }
 void* os::realloc(void *memblock, size_t size, MEMFLAGS memflags, address caller) {
 #ifndef ASSERT
 NOT_PRODUCT(inc_stat_counter(&num_mallocs, 1));
 NOT_PRODUCT(inc_stat_counter(&alloc_bytes, size));
 void* ptr = ::realloc(memblock, size);
-if (ptr != NULL && MemTracker::is_on()) {
+if (ptr != NULL) {
 MemTracker::record_realloc((address)memblock, (address)ptr, size, memflags,
 caller == 0 ? CALLER_PC : caller);
 }
 return ptr;
 #else
 addr, (int)(addr - nm->entry_point()), nm);
 if (verbose) {
 st->print(" for ");
 nm->method()->print_value_on(st);
 }
+st->cr();
 nm->print_nmethod(verbose);
 return;
 }
 st->print_cr(INTPTR_FORMAT " is at code_begin+%d in ", addr, (int)(addr - b->code_begin()));
 b->print_on(st);
 } else if (p == NULL && ((oopDesc*)addr)->is_oop()) {
 p = (HeapWord*) addr;
 print = true;
 }
 if (print) {
-st->print_cr(INTPTR_FORMAT " is an oop", addr);
+if (p == (HeapWord*) addr) {
+st->print_cr(INTPTR_FORMAT " is an oop", addr);
+} else {
+st->print_cr(INTPTR_FORMAT " is pointing into object: " INTPTR_FORMAT, addr, p);
+}
 oop(p)->print_on(st);
-if (p != (HeapWord*)x && oop(p)->is_constMethod() &&
-constMethodOop(p)->contains(addr)) {
-Thread *thread = Thread::current();
-HandleMark hm(thread);
-methodHandle mh (thread, constMethodOop(p)->method());
-if (!mh->is_native()) {
-st->print_cr("bci_from(%p) = %d; print_codes():",
-addr, mh->bci_from(address(x)));
-mh->print_codes_on(st);
-}
-}
 return;
 }
 } else {
 if (Universe::heap()->is_in_reserved(addr)) {
 st->print_cr(INTPTR_FORMAT " is an unallocated location "
 if (verbose) thread->print_on(st);
 return;
 }
 }
+#ifndef PRODUCT
+// Check if in metaspace.
+if (ClassLoaderDataGraph::contains((address)addr)) {
+// Use addr->print() from the debugger instead (not here)
+st->print_cr(INTPTR_FORMAT
+" is pointing into metadata", addr);
+return;
+}
+#endif
 // Try an OS specific find
 if (os::find(addr, st)) {
 return;
 }
 }
 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
-if (result != NULL && MemTracker::is_on()) {
+if (result != NULL) {
 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
 }
 return result;
 }
 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
 char* result = pd_attempt_reserve_memory_at(bytes, addr);
-if (result != NULL && MemTracker::is_on()) {
+if (result != NULL) {
 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
 }
 return result;
 }
 pd_split_reserved_memory(base, size, split, realloc);
 }
 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
 bool res = pd_commit_memory(addr, bytes, executable);
-if (res && MemTracker::is_on()) {
+if (res) {
 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
 }
 return res;
 }
 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
 bool executable) {
 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
-if (res && MemTracker::is_on()) {
+if (res) {
 MemTracker::record_virtual_memory_commit((address)addr, size, CALLER_PC);
 }
 return res;
 }
 char* os::map_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 char* result = pd_map_memory(fd, file_name, file_offset, addr, bytes, read_only, allow_exec);
-if (result != NULL && MemTracker::is_on()) {
+if (result != NULL) {
 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
+MemTracker::record_virtual_memory_commit((address)result, bytes, CALLER_PC);
 }
 return result;
 }
 char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
 }
 bool os::unmap_memory(char *addr, size_t bytes) {
 bool result = pd_unmap_memory(addr, bytes);
 if (result) {
+MemTracker::record_virtual_memory_uncommit((address)addr, bytes);
 MemTracker::record_virtual_memory_release((address)addr, bytes);
 }
 return result;
 }

Mercurial > hg > graal-compiler

comparison src/share/vm/runtime/os.cpp @ 6948:e522a00b91aa