graal-compiler: src/os/linux/vm/os

comparison src/os/linux/vm/os_linux.cpp @ 6197:d2a62e0f25eb

6995781: Native Memory Tracking (Phase 1) 7151532: DCmd for hotspot native memory tracking Summary: Implementation of native memory tracking phase 1, which tracks VM native memory usage, and related DCmd Reviewed-by: acorn, coleenp, fparain

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	7432b9db36ff
children	65906dc96aa1

comparison

equal deleted inserted replaced

-:74533f63b116
+:d2a62e0f25eb
 //
 // Important note: if the location of libjvm.so changes this
 // code needs to be changed accordingly.
 // The next few definitions allow the code to be verbatim:
-#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n))
+#define malloc(n) (char*)NEW_C_HEAP_ARRAY(char, (n), mtInternal)
 #define getenv(n) ::getenv(n)
 /*
 * See ld(1):
 *      The linker uses the following search paths to locate required
 # define _CS_GNU_LIBPTHREAD_VERSION 3
 # endif
 size_t n = confstr(_CS_GNU_LIBC_VERSION, NULL, 0);
 if (n > 0) {
-char *str = (char *)malloc(n);
+char *str = (char *)malloc(n, mtInternal);
 confstr(_CS_GNU_LIBC_VERSION, str, n);
 os::Linux::set_glibc_version(str);
 } else {
 // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
 static char _gnu_libc_version[32];
 os::Linux::set_glibc_version(_gnu_libc_version);
 }
 n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
 if (n > 0) {
-char *str = (char *)malloc(n);
+char *str = (char *)malloc(n, mtInternal);
 confstr(_CS_GNU_LIBPTHREAD_VERSION, str, n);
 // Vanilla RH-9 (glibc 2.3.2) has a bug that confstr() always tells
 // us "NPTL-0.29" even we are running with LinuxThreads. Check if this
 // is the case. LinuxThreads has a hard limit on max number of threads.
 // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
 }
 }
 // release the storage
 for (int i = 0 ; i < n ; i++) {
 if (pelements[i] != NULL) {
-FREE_C_HEAP_ARRAY(char, pelements[i]);
+FREE_C_HEAP_ARRAY(char, pelements[i], mtInternal);
 }
 }
 if (pelements != NULL) {
-FREE_C_HEAP_ARRAY(char*, pelements);
+FREE_C_HEAP_ARRAY(char*, pelements, mtInternal);
 }
 } else {
 snprintf(buffer, buflen, "%s/lib%s.so", pname, fname);
 }
 }
 // NOTE: Linux kernel does not really reserve the pages for us.
 //       All it does is to check if there are enough free pages
 //       left at the time of mmap(). This could be a potential
 //       problem.
-bool os::commit_memory(char* addr, size_t size, bool exec) {
+bool os::pd_commit_memory(char* addr, size_t size, bool exec) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 uintptr_t res = (uintptr_t) ::mmap(addr, size, prot,
 MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0);
 if (res != (uintptr_t) MAP_FAILED) {
 if (UseNUMAInterleaving) {
 // Define MADV_HUGEPAGE here so we can build HotSpot on old systems.
 #ifndef MADV_HUGEPAGE
 #define MADV_HUGEPAGE 14
 #endif
-bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
+bool os::pd_commit_memory(char* addr, size_t size, size_t alignment_hint,
 bool exec) {
 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 uintptr_t res =
 (uintptr_t) ::mmap(addr, size, prot,
 return true;
 }
 return false;
 }
-void os::realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
+void os::pd_realign_memory(char *addr, size_t bytes, size_t alignment_hint) {
 if (UseHugeTLBFS && alignment_hint > (size_t)vm_page_size()) {
 // We don't check the return value: madvise(MADV_HUGEPAGE) may not
 // be supported or the memory may already be backed by huge pages.
 ::madvise(addr, bytes, MADV_HUGEPAGE);
 }
 }
-void os::free_memory(char *addr, size_t bytes, size_t alignment_hint) {
+void os::pd_free_memory(char *addr, size_t bytes, size_t alignment_hint) {
 // This method works by doing an mmap over an existing mmaping and effectively discarding
 // the existing pages. However it won't work for SHM-based large pages that cannot be
 // uncommitted at all. We don't do anything in this case to avoid creating a segment with
 // small pages on top of the SHM segment. This method always works for small pages, so we
 // allow that in any case.
 if (numa_available() != -1) {
 set_numa_all_nodes((unsigned long*)libnuma_dlsym(handle, "numa_all_nodes"));
 // Create a cpu -> node mapping
-_cpu_to_node = new (ResourceObj::C_HEAP) GrowableArray<int>(0, true);
+_cpu_to_node = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<int>(0, true);
 rebuild_cpu_to_node_map();
 return true;
 }
 }
 }
 cpu_to_node()->clear();
 cpu_to_node()->at_grow(cpu_num - 1);
 size_t node_num = numa_get_groups_num();
-unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size);
+unsigned long *cpu_map = NEW_C_HEAP_ARRAY(unsigned long, cpu_map_size, mtInternal);
 for (size_t i = 0; i < node_num; i++) {
 if (numa_node_to_cpus(i, cpu_map, cpu_map_size * sizeof(unsigned long)) != -1) {
 for (size_t j = 0; j < cpu_map_valid_size; j++) {
 if (cpu_map[j] != 0) {
 for (size_t k = 0; k < BitsPerCLong; k++) {
 }
 }
 }
 }
 }
-FREE_C_HEAP_ARRAY(unsigned long, cpu_map);
+FREE_C_HEAP_ARRAY(unsigned long, cpu_map, mtInternal);
 }
 int os::Linux::get_node_by_cpu(int cpu_id) {
 if (cpu_to_node() != NULL && cpu_id >= 0 && cpu_id < cpu_to_node()->length()) {
 return cpu_to_node()->at(cpu_id);
 os::Linux::numa_available_func_t os::Linux::_numa_available;
 os::Linux::numa_tonode_memory_func_t os::Linux::_numa_tonode_memory;
 os::Linux::numa_interleave_memory_func_t os::Linux::_numa_interleave_memory;
 unsigned long* os::Linux::_numa_all_nodes;
-bool os::uncommit_memory(char* addr, size_t size) {
+bool os::pd_uncommit_memory(char* addr, size_t size) {
 uintptr_t res = (uintptr_t) ::mmap(addr, size, PROT_NONE,
 MAP_PRIVATE|MAP_FIXED|MAP_NORESERVE|MAP_ANONYMOUS, -1, 0);
 return res  != (uintptr_t) MAP_FAILED;
 }
 // where we're going to put our guard pages, truncate the mapping at
 // that point by munmap()ping it.  This ensures that when we later
 // munmap() the guard pages we don't leave a hole in the stack
 // mapping. This only affects the main/initial thread, but guard
 // against future OS changes
-bool os::create_stack_guard_pages(char* addr, size_t size) {
+bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 uintptr_t stack_extent, stack_base;
 bool chk_bounds = NOT_DEBUG(os::Linux::is_initial_thread()) DEBUG_ONLY(true);
 if (chk_bounds && get_stack_bounds(&stack_extent, &stack_base)) {
 assert(os::Linux::is_initial_thread(),
 "growable stack in non-initial thread");
 //
 static int anon_munmap(char * addr, size_t size) {
 return ::munmap(addr, size) == 0;
 }
-char* os::reserve_memory(size_t bytes, char* requested_addr,
+char* os::pd_reserve_memory(size_t bytes, char* requested_addr,
 size_t alignment_hint) {
 return anon_mmap(requested_addr, bytes, (requested_addr != NULL));
 }
-bool os::release_memory(char* addr, size_t size) {
+bool os::pd_release_memory(char* addr, size_t size) {
 return anon_munmap(addr, size);
 }
 static address highest_vm_reserved_address() {
 return _highest_vm_reserved_address;
 }
 // Reserve memory at an arbitrary address, only if that area is
 // available (and not reserved for something else).
-char* os::attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
+char* os::pd_attempt_reserve_memory_at(size_t bytes, char* requested_addr) {
 const int max_tries = 10;
 char* base[max_tries];
 size_t size[max_tries];
 const size_t gap = 0x000000;
 // is expected to return 0 on failure and 1 on success to the jdk.
 return (ret < 0) ? 0 : 1;
 }
 // Map a block of memory.
-char* os::map_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_map_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 int prot;
 int flags = MAP_PRIVATE;
 return mapped_address;
 }
 // Remap a block of memory.
-char* os::remap_memory(int fd, const char* file_name, size_t file_offset,
+char* os::pd_remap_memory(int fd, const char* file_name, size_t file_offset,
 char *addr, size_t bytes, bool read_only,
 bool allow_exec) {
 // same as map_memory() on this OS
 return os::map_memory(fd, file_name, file_offset, addr, bytes, read_only,
 allow_exec);
 }
 // Unmap a block of memory.
-bool os::unmap_memory(char* addr, size_t bytes) {
+bool os::pd_unmap_memory(char* addr, size_t bytes) {
 return munmap(addr, bytes) == 0;
 }
 static jlong slow_thread_cpu_time(Thread *thread, bool user_sys_cpu_time);

Mercurial > hg > graal-compiler

comparison src/os/linux/vm/os_linux.cpp @ 6197:d2a62e0f25eb