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

comparison src/os/solaris/vm/os_solaris.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
 uint_t*         id_length) {
 bool result = false;
 // Find the number of processors in the processor set.
 if (pset_info(pset, NULL, id_length, NULL) == 0) {
 // Make up an array to hold their ids.
-*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
+*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 // Fill in the array with their processor ids.
 if (pset_info(pset, NULL, id_length, *id_array) == 0) {
 result = true;
 }
 }
 uint*           id_length) {
 const processorid_t MAX_PROCESSOR_ID = 100000 ;
 // Find the number of processors online.
 *id_length = sysconf(_SC_NPROCESSORS_ONLN);
 // Make up an array to hold their ids.
-*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length);
+*id_array = NEW_C_HEAP_ARRAY(processorid_t, *id_length, mtInternal);
 // Processors need not be numbered consecutively.
 long found = 0;
 processorid_t next = 0;
 while (found < *id_length && next < MAX_PROCESSOR_ID) {
 processor_info_t info;
 max_id = MAX2(max_id, id_array[m]);
 }
 // The next id, to limit loops.
 const processorid_t limit_id = max_id + 1;
 // Make up markers for available processors.
-bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id);
+bool* available_id = NEW_C_HEAP_ARRAY(bool, limit_id, mtInternal);
 for (uint c = 0; c < limit_id; c += 1) {
 available_id[c] = false;
 }
 for (uint a = 0; a < id_length; a += 1) {
 available_id[id_array[a]] = true;
 if (board * processors_per_board + 0 >= limit_id) {
 board = 0;
 }
 }
 if (available_id != NULL) {
-FREE_C_HEAP_ARRAY(bool, available_id);
+FREE_C_HEAP_ARRAY(bool, available_id, mtInternal);
 }
 return true;
 }
 void os::set_native_thread_name(const char *name) {
 } else {
 result = false;
 }
 }
 if (id_array != NULL) {
-FREE_C_HEAP_ARRAY(processorid_t, id_array);
+FREE_C_HEAP_ARRAY(processorid_t, id_array, mtInternal);
 }
 return result;
 }
 bool os::bind_to_processor(uint processor_id) {
 //
 // 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 free(p) FREE_C_HEAP_ARRAY(char, p)
+#define free(p) FREE_C_HEAP_ARRAY(char, p, mtInternal)
 #define getenv(n) ::getenv(n)
 #define EXTENSIONS_DIR  "/lib/ext"
 #define ENDORSED_DIR    "/lib/endorsed"
 #define COMMON_DIR      "/usr/jdk/packages"
 }
 }
 // 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);
 }
 }
 Maxlibjsigsigs = Maxsignum;
 // pending_signals has one int per signal
 // The additional signal is for SIGEXIT - exit signal to signal_thread
-pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1));
+pending_signals = (jint *)os::malloc(sizeof(jint) * (Sigexit+1), mtInternal);
 memset(pending_signals, 0, (sizeof(jint) * (Sigexit+1)));
 if (UseSignalChaining) {
 chainedsigactions = (struct sigaction *)malloc(sizeof(struct sigaction)
-* (Maxsignum + 1));
+* (Maxsignum + 1), mtInternal);
 memset(chainedsigactions, 0, (sizeof(struct sigaction) * (Maxsignum + 1)));
-preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1));
+preinstalled_sigs = (int *)os::malloc(sizeof(int) * (Maxsignum + 1), mtInternal);
 memset(preinstalled_sigs, 0, (sizeof(int) * (Maxsignum + 1)));
 }
-ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ));
+ourSigFlags = (int*)malloc(sizeof(int) * (Maxsignum + 1 ), mtInternal);
 memset(ourSigFlags, 0, sizeof(int) * (Maxsignum + 1));
 }
 void os::signal_init_pd() {
 int ret;
 int os::vm_allocation_granularity() {
 assert(page_size != -1, "must call os::init");
 return page_size;
 }
-bool os::commit_memory(char* addr, size_t bytes, bool exec) {
+bool os::pd_commit_memory(char* addr, size_t bytes, bool exec) {
 int prot = exec ? PROT_READ|PROT_WRITE|PROT_EXEC : PROT_READ|PROT_WRITE;
 size_t size = bytes;
 char *res = Solaris::mmap_chunk(addr, size, MAP_PRIVATE|MAP_FIXED, prot);
 if (res != NULL) {
 if (UseNUMAInterleaving) {
 return true;
 }
 return false;
 }
-bool os::commit_memory(char* addr, size_t bytes, size_t alignment_hint,
+bool os::pd_commit_memory(char* addr, size_t bytes, size_t alignment_hint,
 bool exec) {
 if (commit_memory(addr, bytes, exec)) {
 if (UseMPSS && alignment_hint > (size_t)vm_page_size()) {
 // If the large page size has been set and the VM
 // is using large pages, use the large page size
 }
 return false;
 }
 // Uncommit the pages in a specified region.
-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) {
 if (madvise(addr, bytes, MADV_FREE) < 0) {
 debug_only(warning("MADV_FREE failed."));
 return;
 }
 }
-bool os::create_stack_guard_pages(char* addr, size_t size) {
+bool os::pd_create_stack_guard_pages(char* addr, size_t size) {
 return os::commit_memory(addr, size);
 }
 bool os::remove_stack_guard_pages(char* addr, size_t size) {
 return os::uncommit_memory(addr, size);
 }
 // Change the page size in a given range.
-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) {
 assert((intptr_t)addr % alignment_hint == 0, "Address should be aligned.");
 assert((intptr_t)(addr + bytes) % alignment_hint == 0, "End should be aligned.");
 if (UseLargePages && UseMPSS) {
 Solaris::set_mpss_range(addr, bytes, alignment_hint);
 }
 p = addrs[addrs_count - 1] + page_size;
 }
 return end;
 }
-bool os::uncommit_memory(char* addr, size_t bytes) {
+bool os::pd_uncommit_memory(char* addr, size_t bytes) {
 size_t size = bytes;
 // Map uncommitted pages PROT_NONE so we fail early if we touch an
 // uncommitted page. Otherwise, the read/write might succeed if we
 // have enough swap space to back the physical page.
 return
 // uncommitted page. Otherwise, the read/write might succeed if we
 // have enough swap space to back the physical page.
 return mmap_chunk(addr, bytes, flags, PROT_NONE);
 }
-char* os::reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
+char* os::pd_reserve_memory(size_t bytes, char* requested_addr, size_t alignment_hint) {
 char* addr = Solaris::anon_mmap(requested_addr, bytes, alignment_hint, (requested_addr != NULL));
 guarantee(requested_addr == NULL || requested_addr == addr,
 "OS failed to return requested mmap address.");
 return addr;
 }
 // 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];
 // Solaris adds a gap between mmap'ed regions.  The size of the gap
 }
 return (i < max_tries) ? requested_addr : NULL;
 }
-bool os::release_memory(char* addr, size_t bytes) {
+bool os::pd_release_memory(char* addr, size_t bytes) {
 size_t size = bytes;
 return munmap(addr, size) == 0;
 }
 static bool solaris_mprotect(char* addr, size_t bytes, int prot) {
 return false;
 }
 lwpSize = 16*1024;
 for (;;) {
 ::lseek64 (lwpFile, 0, SEEK_SET);
-lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize);
+lwpArray = (prheader_t *)NEW_C_HEAP_ARRAY(char, lwpSize, mtInternal);
 if (::read(lwpFile, lwpArray, lwpSize) < 0) {
 if (ThreadPriorityVerbose) warning("Error reading /proc/self/lstatus\n");
 break;
 }
 if ((lwpArray->pr_nent * lwpArray->pr_entsize) <= lwpSize) {
 }
 if (aslwpcount == 0) isT2 = true;
 break;
 }
 lwpSize = lwpArray->pr_nent * lwpArray->pr_entsize;
-FREE_C_HEAP_ARRAY(char, lwpArray);  // retry.
+FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal);  // retry.
 }
-FREE_C_HEAP_ARRAY(char, lwpArray);
+FREE_C_HEAP_ARRAY(char, lwpArray, mtInternal);
 ::close (lwpFile);
 if (ThreadPriorityVerbose) {
 if (isT2) tty->print_cr("We are running with a T2 libthread\n");
 else tty->print_cr("We are not running with a T2 libthread\n");
 }
 if (UseNUMA) {
 if (!Solaris::liblgrp_init()) {
 UseNUMA = false;
 } else {
 size_t lgrp_limit = os::numa_get_groups_num();
-int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit);
+int *lgrp_ids = NEW_C_HEAP_ARRAY(int, lgrp_limit, mtInternal);
 size_t lgrp_num = os::numa_get_leaf_groups(lgrp_ids, lgrp_limit);
-FREE_C_HEAP_ARRAY(int, lgrp_ids);
+FREE_C_HEAP_ARRAY(int, lgrp_ids, mtInternal);
 if (lgrp_num < 2) {
 // There's only one locality group, disable NUMA.
 UseNUMA = false;
 }
 }
 *bytes = end - cur;
 return 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;
 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;
 }
 void os::pause() {
 char filename[MAX_PATH];

Mercurial > hg > graal-compiler

comparison src/os/solaris/vm/os_solaris.cpp @ 6197:d2a62e0f25eb