--- a/hotspot/agent/src/os/bsd/ps_core.c Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/os/bsd/ps_core.c Fri Oct 11 13:00:40 2013 -0700
@@ -44,6 +44,7 @@
// close all file descriptors
static void close_files(struct ps_prochandle* ph) {
lib_info* lib = NULL;
+
// close core file descriptor
if (ph->core->core_fd >= 0)
close(ph->core->core_fd);
@@ -149,8 +150,7 @@
// Return the map_info for the given virtual address. We keep a sorted
// array of pointers in ph->map_array, so we can binary search.
-static map_info* core_lookup(struct ps_prochandle *ph, uintptr_t addr)
-{
+static map_info* core_lookup(struct ps_prochandle *ph, uintptr_t addr) {
int mid, lo = 0, hi = ph->core->num_maps - 1;
map_info *mp;
@@ -230,9 +230,9 @@
size_t _used; // for setting space top on read
// 4991491 NOTICE These are C++ bool's in filemap.hpp and must match up with
- // the C type matching the C++ bool type on any given platform. For
- // Hotspot on BSD we assume the corresponding C type is char but
- // licensees on BSD versions may need to adjust the type of these fields.
+ // the C type matching the C++ bool type on any given platform.
+ // We assume the corresponding C type is char but licensees
+ // may need to adjust the type of these fields.
char _read_only; // read only space?
char _allow_exec; // executable code in space?
@@ -286,10 +286,12 @@
#define USE_SHARED_SPACES_SYM "_UseSharedSpaces"
// mangled name of Arguments::SharedArchivePath
#define SHARED_ARCHIVE_PATH_SYM "_ZN9Arguments17SharedArchivePathE"
+#define LIBJVM_NAME "/libjvm.dylib"
#else
#define USE_SHARED_SPACES_SYM "UseSharedSpaces"
// mangled name of Arguments::SharedArchivePath
#define SHARED_ARCHIVE_PATH_SYM "__ZN9Arguments17SharedArchivePathE"
+#define LIBJVM_NAME "/libjvm.so"
#endif // __APPLE_
static bool init_classsharing_workaround(struct ps_prochandle* ph) {
@@ -300,12 +302,7 @@
// we are iterating over shared objects from the core dump. look for
// libjvm.so.
const char *jvm_name = 0;
-#ifdef __APPLE__
- if ((jvm_name = strstr(lib->name, "/libjvm.dylib")) != 0)
-#else
- if ((jvm_name = strstr(lib->name, "/libjvm.so")) != 0)
-#endif // __APPLE__
- {
+ if ((jvm_name = strstr(lib->name, LIBJVM_NAME)) != 0) {
char classes_jsa[PATH_MAX];
struct FileMapHeader header;
int fd = -1;
@@ -399,8 +396,8 @@
}
}
return true;
- }
- lib = lib->next;
+ }
+ lib = lib->next;
}
return true;
}
@@ -432,8 +429,8 @@
// allocate map_array
map_info** array;
if ( (array = (map_info**) malloc(sizeof(map_info*) * num_maps)) == NULL) {
- print_debug("can't allocate memory for map array\n");
- return false;
+ print_debug("can't allocate memory for map array\n");
+ return false;
}
// add maps to array
@@ -450,7 +447,7 @@
ph->core->map_array = array;
// sort the map_info array by base virtual address.
qsort(ph->core->map_array, ph->core->num_maps, sizeof (map_info*),
- core_cmp_mapping);
+ core_cmp_mapping);
// print map
if (is_debug()) {
@@ -458,7 +455,7 @@
print_debug("---- sorted virtual address map ----\n");
for (j = 0; j < ph->core->num_maps; j++) {
print_debug("base = 0x%lx\tsize = %d\n", ph->core->map_array[j]->vaddr,
- ph->core->map_array[j]->memsz);
+ ph->core->map_array[j]->memsz);
}
}
@@ -1091,9 +1088,9 @@
notep->n_type, notep->n_descsz);
if (notep->n_type == NT_PRSTATUS) {
- if (core_handle_prstatus(ph, descdata, notep->n_descsz) != true) {
- return false;
- }
+ if (core_handle_prstatus(ph, descdata, notep->n_descsz) != true) {
+ return false;
+ }
}
p = descdata + ROUNDUP(notep->n_descsz, 4);
}
@@ -1121,7 +1118,7 @@
* contains a set of saved /proc structures), and PT_LOAD (which
* represents a memory mapping from the process's address space).
*
- * Difference b/w Solaris PT_NOTE and BSD PT_NOTE:
+ * Difference b/w Solaris PT_NOTE and Linux/BSD PT_NOTE:
*
* In Solaris there are two PT_NOTE segments the first PT_NOTE (if present)
* contains /proc structs in the pre-2.6 unstructured /proc format. the last
@@ -1167,32 +1164,61 @@
// read segments of a shared object
static bool read_lib_segments(struct ps_prochandle* ph, int lib_fd, ELF_EHDR* lib_ehdr, uintptr_t lib_base) {
- int i = 0;
- ELF_PHDR* phbuf;
- ELF_PHDR* lib_php = NULL;
+ int i = 0;
+ ELF_PHDR* phbuf;
+ ELF_PHDR* lib_php = NULL;
+
+ int page_size=sysconf(_SC_PAGE_SIZE);
- if ((phbuf = read_program_header_table(lib_fd, lib_ehdr)) == NULL)
- return false;
+ if ((phbuf = read_program_header_table(lib_fd, lib_ehdr)) == NULL) {
+ return false;
+ }
+
+ // we want to process only PT_LOAD segments that are not writable.
+ // i.e., text segments. The read/write/exec (data) segments would
+ // have been already added from core file segments.
+ for (lib_php = phbuf, i = 0; i < lib_ehdr->e_phnum; i++) {
+ if ((lib_php->p_type == PT_LOAD) && !(lib_php->p_flags & PF_W) && (lib_php->p_filesz != 0)) {
+
+ uintptr_t target_vaddr = lib_php->p_vaddr + lib_base;
+ map_info *existing_map = core_lookup(ph, target_vaddr);
- // we want to process only PT_LOAD segments that are not writable.
- // i.e., text segments. The read/write/exec (data) segments would
- // have been already added from core file segments.
- for (lib_php = phbuf, i = 0; i < lib_ehdr->e_phnum; i++) {
- if ((lib_php->p_type == PT_LOAD) && !(lib_php->p_flags & PF_W) && (lib_php->p_filesz != 0)) {
- if (add_map_info(ph, lib_fd, lib_php->p_offset, lib_php->p_vaddr + lib_base, lib_php->p_filesz) == NULL)
- goto err;
+ if (existing_map == NULL){
+ if (add_map_info(ph, lib_fd, lib_php->p_offset,
+ target_vaddr, lib_php->p_filesz) == NULL) {
+ goto err;
+ }
+ } else {
+ if ((existing_map->memsz != page_size) &&
+ (existing_map->fd != lib_fd) &&
+ (existing_map->memsz != lib_php->p_filesz)){
+
+ print_debug("address conflict @ 0x%lx (size = %ld, flags = %d\n)",
+ target_vaddr, lib_php->p_filesz, lib_php->p_flags);
+ goto err;
+ }
+
+ /* replace PT_LOAD segment with library segment */
+ print_debug("overwrote with new address mapping (memsz %ld -> %ld)\n",
+ existing_map->memsz, lib_php->p_filesz);
+
+ existing_map->fd = lib_fd;
+ existing_map->offset = lib_php->p_offset;
+ existing_map->memsz = lib_php->p_filesz;
}
- lib_php++;
- }
+ }
+
+ lib_php++;
+ }
- free(phbuf);
- return true;
+ free(phbuf);
+ return true;
err:
- free(phbuf);
- return false;
+ free(phbuf);
+ return false;
}
-// process segments from interpreter (ld-elf.so.1)
+// process segments from interpreter (ld.so or ld-linux.so or ld-elf.so)
static bool read_interp_segments(struct ps_prochandle* ph) {
ELF_EHDR interp_ehdr;
@@ -1303,32 +1329,34 @@
debug_base = dyn.d_un.d_ptr;
// at debug_base we have struct r_debug. This has first link map in r_map field
if (ps_pread(ph, (psaddr_t) debug_base + FIRST_LINK_MAP_OFFSET,
- &first_link_map_addr, sizeof(uintptr_t)) != PS_OK) {
+ &first_link_map_addr, sizeof(uintptr_t)) != PS_OK) {
print_debug("can't read first link map address\n");
return false;
}
// read ld_base address from struct r_debug
- // XXX: There is no r_ldbase member on BSD
- /*
+#if 0 // There is no r_ldbase member on BSD
if (ps_pread(ph, (psaddr_t) debug_base + LD_BASE_OFFSET, &ld_base_addr,
sizeof(uintptr_t)) != PS_OK) {
print_debug("can't read ld base address\n");
return false;
}
ph->core->ld_base_addr = ld_base_addr;
- */
+#else
ph->core->ld_base_addr = 0;
+#endif
print_debug("interpreter base address is 0x%lx\n", ld_base_addr);
- // now read segments from interp (i.e ld-elf.so.1)
- if (read_interp_segments(ph) != true)
+ // now read segments from interp (i.e ld.so or ld-linux.so or ld-elf.so)
+ if (read_interp_segments(ph) != true) {
return false;
+ }
// after adding interpreter (ld.so) mappings sort again
- if (sort_map_array(ph) != true)
+ if (sort_map_array(ph) != true) {
return false;
+ }
print_debug("first link map is at 0x%lx\n", first_link_map_addr);
@@ -1380,8 +1408,9 @@
add_lib_info_fd(ph, lib_name, lib_fd, lib_base);
// Map info is added for the library (lib_name) so
// we need to re-sort it before calling the p_pdread.
- if (sort_map_array(ph) != true)
+ if (sort_map_array(ph) != true) {
return false;
+ }
} else {
print_debug("can't read ELF header for shared object %s\n", lib_name);
close(lib_fd);
@@ -1392,7 +1421,7 @@
// read next link_map address
if (ps_pread(ph, (psaddr_t) link_map_addr + LINK_MAP_NEXT_OFFSET,
- &link_map_addr, sizeof(uintptr_t)) != PS_OK) {
+ &link_map_addr, sizeof(uintptr_t)) != PS_OK) {
print_debug("can't read next link in link_map\n");
return false;
}
@@ -1408,7 +1437,7 @@
struct ps_prochandle* ph = (struct ps_prochandle*) calloc(1, sizeof(struct ps_prochandle));
if (ph == NULL) {
- print_debug("cant allocate ps_prochandle\n");
+ print_debug("can't allocate ps_prochandle\n");
return NULL;
}
@@ -1444,38 +1473,45 @@
}
if (read_elf_header(ph->core->exec_fd, &exec_ehdr) != true || exec_ehdr.e_type != ET_EXEC) {
- print_debug("executable file is not a valid ELF ET_EXEC file\n");
- goto err;
+ print_debug("executable file is not a valid ELF ET_EXEC file\n");
+ goto err;
}
// process core file segments
- if (read_core_segments(ph, &core_ehdr) != true)
- goto err;
+ if (read_core_segments(ph, &core_ehdr) != true) {
+ goto err;
+ }
// process exec file segments
- if (read_exec_segments(ph, &exec_ehdr) != true)
- goto err;
+ if (read_exec_segments(ph, &exec_ehdr) != true) {
+ goto err;
+ }
// exec file is also treated like a shared object for symbol search
if (add_lib_info_fd(ph, exec_file, ph->core->exec_fd,
- (uintptr_t)0 + find_base_address(ph->core->exec_fd, &exec_ehdr)) == NULL)
- goto err;
+ (uintptr_t)0 + find_base_address(ph->core->exec_fd, &exec_ehdr)) == NULL) {
+ goto err;
+ }
// allocate and sort maps into map_array, we need to do this
// here because read_shared_lib_info needs to read from debuggee
// address space
- if (sort_map_array(ph) != true)
+ if (sort_map_array(ph) != true) {
goto err;
+ }
- if (read_shared_lib_info(ph) != true)
+ if (read_shared_lib_info(ph) != true) {
goto err;
+ }
// sort again because we have added more mappings from shared objects
- if (sort_map_array(ph) != true)
+ if (sort_map_array(ph) != true) {
goto err;
+ }
- if (init_classsharing_workaround(ph) != true)
+ if (init_classsharing_workaround(ph) != true) {
goto err;
+ }
print_debug("Leave Pgrab_core\n");
return ph;
--- a/hotspot/agent/src/os/linux/ps_core.c Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/os/linux/ps_core.c Fri Oct 11 13:00:40 2013 -0700
@@ -41,155 +41,158 @@
// ps_prochandle cleanup helper functions
// close all file descriptors
-static void close_elf_files(struct ps_prochandle* ph) {
- lib_info* lib = NULL;
+static void close_files(struct ps_prochandle* ph) {
+ lib_info* lib = NULL;
- // close core file descriptor
- if (ph->core->core_fd >= 0)
- close(ph->core->core_fd);
+ // close core file descriptor
+ if (ph->core->core_fd >= 0)
+ close(ph->core->core_fd);
- // close exec file descriptor
- if (ph->core->exec_fd >= 0)
- close(ph->core->exec_fd);
+ // close exec file descriptor
+ if (ph->core->exec_fd >= 0)
+ close(ph->core->exec_fd);
- // close interp file descriptor
- if (ph->core->interp_fd >= 0)
- close(ph->core->interp_fd);
+ // close interp file descriptor
+ if (ph->core->interp_fd >= 0)
+ close(ph->core->interp_fd);
- // close class share archive file
- if (ph->core->classes_jsa_fd >= 0)
- close(ph->core->classes_jsa_fd);
+ // close class share archive file
+ if (ph->core->classes_jsa_fd >= 0)
+ close(ph->core->classes_jsa_fd);
- // close all library file descriptors
- lib = ph->libs;
- while (lib) {
- int fd = lib->fd;
- if (fd >= 0 && fd != ph->core->exec_fd) close(fd);
- lib = lib->next;
- }
+ // close all library file descriptors
+ lib = ph->libs;
+ while (lib) {
+ int fd = lib->fd;
+ if (fd >= 0 && fd != ph->core->exec_fd) {
+ close(fd);
+ }
+ lib = lib->next;
+ }
}
// clean all map_info stuff
static void destroy_map_info(struct ps_prochandle* ph) {
map_info* map = ph->core->maps;
while (map) {
- map_info* next = map->next;
- free(map);
- map = next;
+ map_info* next = map->next;
+ free(map);
+ map = next;
}
if (ph->core->map_array) {
- free(ph->core->map_array);
+ free(ph->core->map_array);
}
// Part of the class sharing workaround
map = ph->core->class_share_maps;
while (map) {
- map_info* next = map->next;
- free(map);
- map = next;
+ map_info* next = map->next;
+ free(map);
+ map = next;
}
}
// ps_prochandle operations
static void core_release(struct ps_prochandle* ph) {
- if (ph->core) {
- close_elf_files(ph);
- destroy_map_info(ph);
- free(ph->core);
- }
+ if (ph->core) {
+ close_files(ph);
+ destroy_map_info(ph);
+ free(ph->core);
+ }
}
static map_info* allocate_init_map(int fd, off_t offset, uintptr_t vaddr, size_t memsz) {
- map_info* map;
- if ( (map = (map_info*) calloc(1, sizeof(map_info))) == NULL) {
- print_debug("can't allocate memory for map_info\n");
- return NULL;
- }
+ map_info* map;
+ if ( (map = (map_info*) calloc(1, sizeof(map_info))) == NULL) {
+ print_debug("can't allocate memory for map_info\n");
+ return NULL;
+ }
- // initialize map
- map->fd = fd;
- map->offset = offset;
- map->vaddr = vaddr;
- map->memsz = memsz;
- return map;
+ // initialize map
+ map->fd = fd;
+ map->offset = offset;
+ map->vaddr = vaddr;
+ map->memsz = memsz;
+ return map;
}
// add map info with given fd, offset, vaddr and memsz
static map_info* add_map_info(struct ps_prochandle* ph, int fd, off_t offset,
uintptr_t vaddr, size_t memsz) {
- map_info* map;
- if ((map = allocate_init_map(fd, offset, vaddr, memsz)) == NULL) {
- return NULL;
- }
+ map_info* map;
+ if ((map = allocate_init_map(fd, offset, vaddr, memsz)) == NULL) {
+ return NULL;
+ }
- // add this to map list
- map->next = ph->core->maps;
- ph->core->maps = map;
- ph->core->num_maps++;
+ // add this to map list
+ map->next = ph->core->maps;
+ ph->core->maps = map;
+ ph->core->num_maps++;
- return map;
+ return map;
}
// Part of the class sharing workaround
-static void add_class_share_map_info(struct ps_prochandle* ph, off_t offset,
+static map_info* add_class_share_map_info(struct ps_prochandle* ph, off_t offset,
uintptr_t vaddr, size_t memsz) {
- map_info* map;
- if ((map = allocate_init_map(ph->core->classes_jsa_fd,
- offset, vaddr, memsz)) == NULL) {
- return;
- }
+ map_info* map;
+ if ((map = allocate_init_map(ph->core->classes_jsa_fd,
+ offset, vaddr, memsz)) == NULL) {
+ return NULL;
+ }
- map->next = ph->core->class_share_maps;
- ph->core->class_share_maps = map;
+ map->next = ph->core->class_share_maps;
+ ph->core->class_share_maps = map;
+ return map;
}
// Return the map_info for the given virtual address. We keep a sorted
// array of pointers in ph->map_array, so we can binary search.
-static map_info* core_lookup(struct ps_prochandle *ph, uintptr_t addr)
-{
- int mid, lo = 0, hi = ph->core->num_maps - 1;
- map_info *mp;
+static map_info* core_lookup(struct ps_prochandle *ph, uintptr_t addr) {
+ int mid, lo = 0, hi = ph->core->num_maps - 1;
+ map_info *mp;
- while (hi - lo > 1) {
- mid = (lo + hi) / 2;
- if (addr >= ph->core->map_array[mid]->vaddr)
- lo = mid;
- else
- hi = mid;
- }
+ while (hi - lo > 1) {
+ mid = (lo + hi) / 2;
+ if (addr >= ph->core->map_array[mid]->vaddr) {
+ lo = mid;
+ } else {
+ hi = mid;
+ }
+ }
- if (addr < ph->core->map_array[hi]->vaddr)
- mp = ph->core->map_array[lo];
- else
- mp = ph->core->map_array[hi];
+ if (addr < ph->core->map_array[hi]->vaddr) {
+ mp = ph->core->map_array[lo];
+ } else {
+ mp = ph->core->map_array[hi];
+ }
- if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz)
- return (mp);
+ if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz) {
+ return (mp);
+ }
- // Part of the class sharing workaround
- // Unfortunately, we have no way of detecting -Xshare state.
- // Check out the share maps atlast, if we don't find anywhere.
- // This is done this way so to avoid reading share pages
- // ahead of other normal maps. For eg. with -Xshare:off we don't
- // want to prefer class sharing data to data from core.
- mp = ph->core->class_share_maps;
- if (mp) {
- print_debug("can't locate map_info at 0x%lx, trying class share maps\n",
- addr);
- }
- while (mp) {
- if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz) {
- print_debug("located map_info at 0x%lx from class share maps\n",
- addr);
- return (mp);
- }
- mp = mp->next;
- }
+ // Part of the class sharing workaround
+ // Unfortunately, we have no way of detecting -Xshare state.
+ // Check out the share maps atlast, if we don't find anywhere.
+ // This is done this way so to avoid reading share pages
+ // ahead of other normal maps. For eg. with -Xshare:off we don't
+ // want to prefer class sharing data to data from core.
+ mp = ph->core->class_share_maps;
+ if (mp) {
+ print_debug("can't locate map_info at 0x%lx, trying class share maps\n", addr);
+ }
+ while (mp) {
+ if (addr >= mp->vaddr && addr < mp->vaddr + mp->memsz) {
+ print_debug("located map_info at 0x%lx from class share maps\n", addr);
+ return (mp);
+ }
+ mp = mp->next;
+ }
- print_debug("can't locate map_info at 0x%lx\n", addr);
- return (NULL);
+ print_debug("can't locate map_info at 0x%lx\n", addr);
+ return (NULL);
}
//---------------------------------------------------------------
@@ -226,9 +229,9 @@
size_t _used; // for setting space top on read
// 4991491 NOTICE These are C++ bool's in filemap.hpp and must match up with
- // the C type matching the C++ bool type on any given platform. For
- // Hotspot on Linux we assume the corresponding C type is char but
- // licensees on Linux versions may need to adjust the type of these fields.
+ // the C type matching the C++ bool type on any given platform.
+ // We assume the corresponding C type is char but licensees
+ // may need to adjust the type of these fields.
char _read_only; // read only space?
char _allow_exec; // executable code in space?
@@ -238,154 +241,159 @@
};
static bool read_jboolean(struct ps_prochandle* ph, uintptr_t addr, jboolean* pvalue) {
- jboolean i;
- if (ps_pdread(ph, (psaddr_t) addr, &i, sizeof(i)) == PS_OK) {
- *pvalue = i;
- return true;
- } else {
- return false;
- }
+ jboolean i;
+ if (ps_pdread(ph, (psaddr_t) addr, &i, sizeof(i)) == PS_OK) {
+ *pvalue = i;
+ return true;
+ } else {
+ return false;
+ }
}
static bool read_pointer(struct ps_prochandle* ph, uintptr_t addr, uintptr_t* pvalue) {
- uintptr_t uip;
- if (ps_pdread(ph, (psaddr_t) addr, &uip, sizeof(uip)) == PS_OK) {
- *pvalue = uip;
- return true;
- } else {
- return false;
- }
+ uintptr_t uip;
+ if (ps_pdread(ph, (psaddr_t) addr, (char *)&uip, sizeof(uip)) == PS_OK) {
+ *pvalue = uip;
+ return true;
+ } else {
+ return false;
+ }
}
// used to read strings from debuggee
static bool read_string(struct ps_prochandle* ph, uintptr_t addr, char* buf, size_t size) {
- size_t i = 0;
- char c = ' ';
+ size_t i = 0;
+ char c = ' ';
- while (c != '\0') {
- if (ps_pdread(ph, (psaddr_t) addr, &c, sizeof(char)) != PS_OK)
- return false;
- if (i < size - 1)
- buf[i] = c;
- else // smaller buffer
- return false;
- i++; addr++;
- }
+ while (c != '\0') {
+ if (ps_pdread(ph, (psaddr_t) addr, &c, sizeof(char)) != PS_OK) {
+ return false;
+ }
+ if (i < size - 1) {
+ buf[i] = c;
+ } else {
+ // smaller buffer
+ return false;
+ }
+ i++; addr++;
+ }
- buf[i] = '\0';
- return true;
+ buf[i] = '\0';
+ return true;
}
#define USE_SHARED_SPACES_SYM "UseSharedSpaces"
// mangled name of Arguments::SharedArchivePath
#define SHARED_ARCHIVE_PATH_SYM "_ZN9Arguments17SharedArchivePathE"
+#define LIBJVM_NAME "/libjvm.so"
static bool init_classsharing_workaround(struct ps_prochandle* ph) {
- lib_info* lib = ph->libs;
- while (lib != NULL) {
- // we are iterating over shared objects from the core dump. look for
- // libjvm.so.
- const char *jvm_name = 0;
- if ((jvm_name = strstr(lib->name, "/libjvm.so")) != 0) {
- char classes_jsa[PATH_MAX];
- struct FileMapHeader header;
- size_t n = 0;
- int fd = -1, m = 0;
- uintptr_t base = 0, useSharedSpacesAddr = 0;
- uintptr_t sharedArchivePathAddrAddr = 0, sharedArchivePathAddr = 0;
- jboolean useSharedSpaces = 0;
- map_info* mi = 0;
+ lib_info* lib = ph->libs;
+ while (lib != NULL) {
+ // we are iterating over shared objects from the core dump. look for
+ // libjvm.so.
+ const char *jvm_name = 0;
+ if ((jvm_name = strstr(lib->name, LIBJVM_NAME)) != 0) {
+ char classes_jsa[PATH_MAX];
+ struct FileMapHeader header;
+ int fd = -1;
+ int m = 0;
+ size_t n = 0;
+ uintptr_t base = 0, useSharedSpacesAddr = 0;
+ uintptr_t sharedArchivePathAddrAddr = 0, sharedArchivePathAddr = 0;
+ jboolean useSharedSpaces = 0;
+ map_info* mi = 0;
- memset(classes_jsa, 0, sizeof(classes_jsa));
- jvm_name = lib->name;
- useSharedSpacesAddr = lookup_symbol(ph, jvm_name, USE_SHARED_SPACES_SYM);
- if (useSharedSpacesAddr == 0) {
- print_debug("can't lookup 'UseSharedSpaces' flag\n");
- return false;
- }
+ memset(classes_jsa, 0, sizeof(classes_jsa));
+ jvm_name = lib->name;
+ useSharedSpacesAddr = lookup_symbol(ph, jvm_name, USE_SHARED_SPACES_SYM);
+ if (useSharedSpacesAddr == 0) {
+ print_debug("can't lookup 'UseSharedSpaces' flag\n");
+ return false;
+ }
- // Hotspot vm types are not exported to build this library. So
- // using equivalent type jboolean to read the value of
- // UseSharedSpaces which is same as hotspot type "bool".
- if (read_jboolean(ph, useSharedSpacesAddr, &useSharedSpaces) != true) {
- print_debug("can't read the value of 'UseSharedSpaces' flag\n");
- return false;
- }
+ // Hotspot vm types are not exported to build this library. So
+ // using equivalent type jboolean to read the value of
+ // UseSharedSpaces which is same as hotspot type "bool".
+ if (read_jboolean(ph, useSharedSpacesAddr, &useSharedSpaces) != true) {
+ print_debug("can't read the value of 'UseSharedSpaces' flag\n");
+ return false;
+ }
- if ((int)useSharedSpaces == 0) {
- print_debug("UseSharedSpaces is false, assuming -Xshare:off!\n");
- return true;
- }
+ if ((int)useSharedSpaces == 0) {
+ print_debug("UseSharedSpaces is false, assuming -Xshare:off!\n");
+ return true;
+ }
- sharedArchivePathAddrAddr = lookup_symbol(ph, jvm_name, SHARED_ARCHIVE_PATH_SYM);
- if (sharedArchivePathAddrAddr == 0) {
- print_debug("can't lookup shared archive path symbol\n");
- return false;
- }
+ sharedArchivePathAddrAddr = lookup_symbol(ph, jvm_name, SHARED_ARCHIVE_PATH_SYM);
+ if (sharedArchivePathAddrAddr == 0) {
+ print_debug("can't lookup shared archive path symbol\n");
+ return false;
+ }
- if (read_pointer(ph, sharedArchivePathAddrAddr, &sharedArchivePathAddr) != true) {
- print_debug("can't read shared archive path pointer\n");
- return false;
- }
+ if (read_pointer(ph, sharedArchivePathAddrAddr, &sharedArchivePathAddr) != true) {
+ print_debug("can't read shared archive path pointer\n");
+ return false;
+ }
- if (read_string(ph, sharedArchivePathAddr, classes_jsa, sizeof(classes_jsa)) != true) {
- print_debug("can't read shared archive path value\n");
- return false;
- }
+ if (read_string(ph, sharedArchivePathAddr, classes_jsa, sizeof(classes_jsa)) != true) {
+ print_debug("can't read shared archive path value\n");
+ return false;
+ }
- print_debug("looking for %s\n", classes_jsa);
- // open the class sharing archive file
- fd = pathmap_open(classes_jsa);
- if (fd < 0) {
- print_debug("can't open %s!\n", classes_jsa);
- ph->core->classes_jsa_fd = -1;
- return false;
- } else {
- print_debug("opened %s\n", classes_jsa);
- }
+ print_debug("looking for %s\n", classes_jsa);
+ // open the class sharing archive file
+ fd = pathmap_open(classes_jsa);
+ if (fd < 0) {
+ print_debug("can't open %s!\n", classes_jsa);
+ ph->core->classes_jsa_fd = -1;
+ return false;
+ } else {
+ print_debug("opened %s\n", classes_jsa);
+ }
- // read FileMapHeader from the file
- memset(&header, 0, sizeof(struct FileMapHeader));
- if ((n = read(fd, &header, sizeof(struct FileMapHeader)))
- != sizeof(struct FileMapHeader)) {
- print_debug("can't read shared archive file map header from %s\n", classes_jsa);
- close(fd);
- return false;
- }
+ // read FileMapHeader from the file
+ memset(&header, 0, sizeof(struct FileMapHeader));
+ if ((n = read(fd, &header, sizeof(struct FileMapHeader)))
+ != sizeof(struct FileMapHeader)) {
+ print_debug("can't read shared archive file map header from %s\n", classes_jsa);
+ close(fd);
+ return false;
+ }
- // check file magic
- if (header._magic != 0xf00baba2) {
- print_debug("%s has bad shared archive file magic number 0x%x, expecing 0xf00baba2\n",
- classes_jsa, header._magic);
- close(fd);
- return false;
- }
+ // check file magic
+ if (header._magic != 0xf00baba2) {
+ print_debug("%s has bad shared archive file magic number 0x%x, expecing 0xf00baba2\n",
+ classes_jsa, header._magic);
+ close(fd);
+ return false;
+ }
- // check version
- if (header._version != CURRENT_ARCHIVE_VERSION) {
- print_debug("%s has wrong shared archive file version %d, expecting %d\n",
- classes_jsa, header._version, CURRENT_ARCHIVE_VERSION);
- close(fd);
- return false;
- }
+ // check version
+ if (header._version != CURRENT_ARCHIVE_VERSION) {
+ print_debug("%s has wrong shared archive file version %d, expecting %d\n",
+ classes_jsa, header._version, CURRENT_ARCHIVE_VERSION);
+ close(fd);
+ return false;
+ }
- ph->core->classes_jsa_fd = fd;
- // add read-only maps from classes.jsa to the list of maps
- for (m = 0; m < NUM_SHARED_MAPS; m++) {
- if (header._space[m]._read_only) {
- base = (uintptr_t) header._space[m]._base;
- // no need to worry about the fractional pages at-the-end.
- // possible fractional pages are handled by core_read_data.
- add_class_share_map_info(ph, (off_t) header._space[m]._file_offset,
- base, (size_t) header._space[m]._used);
- print_debug("added a share archive map at 0x%lx\n", base);
- }
- }
- return true;
+ ph->core->classes_jsa_fd = fd;
+ // add read-only maps from classes.jsa to the list of maps
+ for (m = 0; m < NUM_SHARED_MAPS; m++) {
+ if (header._space[m]._read_only) {
+ base = (uintptr_t) header._space[m]._base;
+ // no need to worry about the fractional pages at-the-end.
+ // possible fractional pages are handled by core_read_data.
+ add_class_share_map_info(ph, (off_t) header._space[m]._file_offset,
+ base, (size_t) header._space[m]._used);
+ print_debug("added a share archive map at 0x%lx\n", base);
+ }
}
- lib = lib->next;
+ return true;
}
- return true;
+ lib = lib->next;
+ }
+ return true;
}
@@ -396,54 +404,58 @@
// callback for sorting the array of map_info pointers.
static int core_cmp_mapping(const void *lhsp, const void *rhsp)
{
- const map_info *lhs = *((const map_info **)lhsp);
- const map_info *rhs = *((const map_info **)rhsp);
+ const map_info *lhs = *((const map_info **)lhsp);
+ const map_info *rhs = *((const map_info **)rhsp);
- if (lhs->vaddr == rhs->vaddr)
- return (0);
+ if (lhs->vaddr == rhs->vaddr) {
+ return (0);
+ }
- return (lhs->vaddr < rhs->vaddr ? -1 : 1);
+ return (lhs->vaddr < rhs->vaddr ? -1 : 1);
}
// we sort map_info by starting virtual address so that we can do
// binary search to read from an address.
static bool sort_map_array(struct ps_prochandle* ph) {
- size_t num_maps = ph->core->num_maps;
- map_info* map = ph->core->maps;
- int i = 0;
+ size_t num_maps = ph->core->num_maps;
+ map_info* map = ph->core->maps;
+ int i = 0;
- // allocate map_array
- map_info** array;
- if ( (array = (map_info**) malloc(sizeof(map_info*) * num_maps)) == NULL) {
- print_debug("can't allocate memory for map array\n");
- return false;
- }
+ // allocate map_array
+ map_info** array;
+ if ( (array = (map_info**) malloc(sizeof(map_info*) * num_maps)) == NULL) {
+ print_debug("can't allocate memory for map array\n");
+ return false;
+ }
- // add maps to array
- while (map) {
- array[i] = map;
- i++;
- map = map->next;
- }
+ // add maps to array
+ while (map) {
+ array[i] = map;
+ i++;
+ map = map->next;
+ }
- // sort is called twice. If this is second time, clear map array
- if (ph->core->map_array) free(ph->core->map_array);
- ph->core->map_array = array;
- // sort the map_info array by base virtual address.
- qsort(ph->core->map_array, ph->core->num_maps, sizeof (map_info*),
- core_cmp_mapping);
+ // sort is called twice. If this is second time, clear map array
+ if (ph->core->map_array) {
+ free(ph->core->map_array);
+ }
+
+ ph->core->map_array = array;
+ // sort the map_info array by base virtual address.
+ qsort(ph->core->map_array, ph->core->num_maps, sizeof (map_info*),
+ core_cmp_mapping);
- // print map
- if (is_debug()) {
- int j = 0;
- print_debug("---- sorted virtual address map ----\n");
- for (j = 0; j < ph->core->num_maps; j++) {
- print_debug("base = 0x%lx\tsize = %zu\n", ph->core->map_array[j]->vaddr,
- ph->core->map_array[j]->memsz);
- }
- }
+ // print map
+ if (is_debug()) {
+ int j = 0;
+ print_debug("---- sorted virtual address map ----\n");
+ for (j = 0; j < ph->core->num_maps; j++) {
+ print_debug("base = 0x%lx\tsize = %zu\n", ph->core->map_array[j]->vaddr,
+ ph->core->map_array[j]->memsz);
+ }
+ }
- return true;
+ return true;
}
#ifndef MIN
@@ -460,16 +472,18 @@
off_t off;
int fd;
- if (mp == NULL)
+ if (mp == NULL) {
break; /* No mapping for this address */
+ }
fd = mp->fd;
mapoff = addr - mp->vaddr;
len = MIN(resid, mp->memsz - mapoff);
off = mp->offset + mapoff;
- if ((len = pread(fd, buf, len, off)) <= 0)
+ if ((len = pread(fd, buf, len, off)) <= 0) {
break;
+ }
resid -= len;
addr += len;
@@ -625,8 +639,9 @@
notep->n_type, notep->n_descsz);
if (notep->n_type == NT_PRSTATUS) {
- if (core_handle_prstatus(ph, descdata, notep->n_descsz) != true)
- return false;
+ if (core_handle_prstatus(ph, descdata, notep->n_descsz) != true) {
+ return false;
+ }
}
p = descdata + ROUNDUP(notep->n_descsz, 4);
}
@@ -654,7 +669,7 @@
* contains a set of saved /proc structures), and PT_LOAD (which
* represents a memory mapping from the process's address space).
*
- * Difference b/w Solaris PT_NOTE and Linux PT_NOTE:
+ * Difference b/w Solaris PT_NOTE and Linux/BSD PT_NOTE:
*
* In Solaris there are two PT_NOTE segments the first PT_NOTE (if present)
* contains /proc structs in the pre-2.6 unstructured /proc format. the last
@@ -674,7 +689,9 @@
for (core_php = phbuf, i = 0; i < core_ehdr->e_phnum; i++) {
switch (core_php->p_type) {
case PT_NOTE:
- if (core_handle_note(ph, core_php) != true) goto err;
+ if (core_handle_note(ph, core_php) != true) {
+ goto err;
+ }
break;
case PT_LOAD: {
@@ -832,60 +849,62 @@
// read shared library info from runtime linker's data structures.
// This work is done by librtlb_db in Solaris
static bool read_shared_lib_info(struct ps_prochandle* ph) {
- uintptr_t addr = ph->core->dynamic_addr;
- uintptr_t debug_base;
- uintptr_t first_link_map_addr;
- uintptr_t ld_base_addr;
- uintptr_t link_map_addr;
- uintptr_t lib_base_diff;
- uintptr_t lib_base;
- uintptr_t lib_name_addr;
- char lib_name[BUF_SIZE];
- ELF_DYN dyn;
- ELF_EHDR elf_ehdr;
- int lib_fd;
+ uintptr_t addr = ph->core->dynamic_addr;
+ uintptr_t debug_base;
+ uintptr_t first_link_map_addr;
+ uintptr_t ld_base_addr;
+ uintptr_t link_map_addr;
+ uintptr_t lib_base_diff;
+ uintptr_t lib_base;
+ uintptr_t lib_name_addr;
+ char lib_name[BUF_SIZE];
+ ELF_DYN dyn;
+ ELF_EHDR elf_ehdr;
+ int lib_fd;
- // _DYNAMIC has information of the form
- // [tag] [data] [tag] [data] .....
- // Both tag and data are pointer sized.
- // We look for dynamic info with DT_DEBUG. This has shared object info.
- // refer to struct r_debug in link.h
+ // _DYNAMIC has information of the form
+ // [tag] [data] [tag] [data] .....
+ // Both tag and data are pointer sized.
+ // We look for dynamic info with DT_DEBUG. This has shared object info.
+ // refer to struct r_debug in link.h
+
+ dyn.d_tag = DT_NULL;
+ while (dyn.d_tag != DT_DEBUG) {
+ if (ps_pdread(ph, (psaddr_t) addr, &dyn, sizeof(ELF_DYN)) != PS_OK) {
+ print_debug("can't read debug info from _DYNAMIC\n");
+ return false;
+ }
+ addr += sizeof(ELF_DYN);
+ }
- dyn.d_tag = DT_NULL;
- while (dyn.d_tag != DT_DEBUG) {
- if (ps_pdread(ph, (psaddr_t) addr, &dyn, sizeof(ELF_DYN)) != PS_OK) {
- print_debug("can't read debug info from _DYNAMIC\n");
- return false;
- }
- addr += sizeof(ELF_DYN);
- }
-
- // we have got Dyn entry with DT_DEBUG
- debug_base = dyn.d_un.d_ptr;
- // at debug_base we have struct r_debug. This has first link map in r_map field
- if (ps_pdread(ph, (psaddr_t) debug_base + FIRST_LINK_MAP_OFFSET,
+ // we have got Dyn entry with DT_DEBUG
+ debug_base = dyn.d_un.d_ptr;
+ // at debug_base we have struct r_debug. This has first link map in r_map field
+ if (ps_pdread(ph, (psaddr_t) debug_base + FIRST_LINK_MAP_OFFSET,
&first_link_map_addr, sizeof(uintptr_t)) != PS_OK) {
- print_debug("can't read first link map address\n");
- return false;
- }
+ print_debug("can't read first link map address\n");
+ return false;
+ }
- // read ld_base address from struct r_debug
- if (ps_pdread(ph, (psaddr_t) debug_base + LD_BASE_OFFSET, &ld_base_addr,
+ // read ld_base address from struct r_debug
+ if (ps_pdread(ph, (psaddr_t) debug_base + LD_BASE_OFFSET, &ld_base_addr,
sizeof(uintptr_t)) != PS_OK) {
- print_debug("can't read ld base address\n");
- return false;
- }
- ph->core->ld_base_addr = ld_base_addr;
+ print_debug("can't read ld base address\n");
+ return false;
+ }
+ ph->core->ld_base_addr = ld_base_addr;
+
+ print_debug("interpreter base address is 0x%lx\n", ld_base_addr);
- print_debug("interpreter base address is 0x%lx\n", ld_base_addr);
-
- // now read segments from interp (i.e ld.so or ld-linux.so)
- if (read_interp_segments(ph) != true)
+ // now read segments from interp (i.e ld.so or ld-linux.so or ld-elf.so)
+ if (read_interp_segments(ph) != true) {
return false;
+ }
- // after adding interpreter (ld.so) mappings sort again
- if (sort_map_array(ph) != true)
- return false;
+ // after adding interpreter (ld.so) mappings sort again
+ if (sort_map_array(ph) != true) {
+ return false;
+ }
print_debug("first link map is at 0x%lx\n", first_link_map_addr);
@@ -950,95 +969,102 @@
}
}
- // read next link_map address
- if (ps_pdread(ph, (psaddr_t) link_map_addr + LINK_MAP_NEXT_OFFSET,
- &link_map_addr, sizeof(uintptr_t)) != PS_OK) {
- print_debug("can't read next link in link_map\n");
- return false;
- }
- }
+ // read next link_map address
+ if (ps_pdread(ph, (psaddr_t) link_map_addr + LINK_MAP_NEXT_OFFSET,
+ &link_map_addr, sizeof(uintptr_t)) != PS_OK) {
+ print_debug("can't read next link in link_map\n");
+ return false;
+ }
+ }
- return true;
+ return true;
}
// the one and only one exposed stuff from this file
struct ps_prochandle* Pgrab_core(const char* exec_file, const char* core_file) {
- ELF_EHDR core_ehdr;
- ELF_EHDR exec_ehdr;
- ELF_EHDR lib_ehdr;
+ ELF_EHDR core_ehdr;
+ ELF_EHDR exec_ehdr;
+ ELF_EHDR lib_ehdr;
- struct ps_prochandle* ph = (struct ps_prochandle*) calloc(1, sizeof(struct ps_prochandle));
- if (ph == NULL) {
- print_debug("can't allocate ps_prochandle\n");
- return NULL;
- }
+ struct ps_prochandle* ph = (struct ps_prochandle*) calloc(1, sizeof(struct ps_prochandle));
+ if (ph == NULL) {
+ print_debug("can't allocate ps_prochandle\n");
+ return NULL;
+ }
- if ((ph->core = (struct core_data*) calloc(1, sizeof(struct core_data))) == NULL) {
- free(ph);
- print_debug("can't allocate ps_prochandle\n");
- return NULL;
- }
+ if ((ph->core = (struct core_data*) calloc(1, sizeof(struct core_data))) == NULL) {
+ free(ph);
+ print_debug("can't allocate ps_prochandle\n");
+ return NULL;
+ }
- // initialize ph
- ph->ops = &core_ops;
- ph->core->core_fd = -1;
- ph->core->exec_fd = -1;
- ph->core->interp_fd = -1;
+ // initialize ph
+ ph->ops = &core_ops;
+ ph->core->core_fd = -1;
+ ph->core->exec_fd = -1;
+ ph->core->interp_fd = -1;
- // open the core file
- if ((ph->core->core_fd = open(core_file, O_RDONLY)) < 0) {
- print_debug("can't open core file\n");
- goto err;
- }
+ // open the core file
+ if ((ph->core->core_fd = open(core_file, O_RDONLY)) < 0) {
+ print_debug("can't open core file\n");
+ goto err;
+ }
- // read core file ELF header
- if (read_elf_header(ph->core->core_fd, &core_ehdr) != true || core_ehdr.e_type != ET_CORE) {
- print_debug("core file is not a valid ELF ET_CORE file\n");
- goto err;
- }
+ // read core file ELF header
+ if (read_elf_header(ph->core->core_fd, &core_ehdr) != true || core_ehdr.e_type != ET_CORE) {
+ print_debug("core file is not a valid ELF ET_CORE file\n");
+ goto err;
+ }
+
+ if ((ph->core->exec_fd = open(exec_file, O_RDONLY)) < 0) {
+ print_debug("can't open executable file\n");
+ goto err;
+ }
- if ((ph->core->exec_fd = open(exec_file, O_RDONLY)) < 0) {
- print_debug("can't open executable file\n");
- goto err;
- }
+ if (read_elf_header(ph->core->exec_fd, &exec_ehdr) != true || exec_ehdr.e_type != ET_EXEC) {
+ print_debug("executable file is not a valid ELF ET_EXEC file\n");
+ goto err;
+ }
+
+ // process core file segments
+ if (read_core_segments(ph, &core_ehdr) != true) {
+ goto err;
+ }
- if (read_elf_header(ph->core->exec_fd, &exec_ehdr) != true || exec_ehdr.e_type != ET_EXEC) {
- print_debug("executable file is not a valid ELF ET_EXEC file\n");
- goto err;
- }
+ // process exec file segments
+ if (read_exec_segments(ph, &exec_ehdr) != true) {
+ goto err;
+ }
- // process core file segments
- if (read_core_segments(ph, &core_ehdr) != true)
- goto err;
-
- // process exec file segments
- if (read_exec_segments(ph, &exec_ehdr) != true)
- goto err;
+ // exec file is also treated like a shared object for symbol search
+ if (add_lib_info_fd(ph, exec_file, ph->core->exec_fd,
+ (uintptr_t)0 + find_base_address(ph->core->exec_fd, &exec_ehdr)) == NULL) {
+ goto err;
+ }
- // exec file is also treated like a shared object for symbol search
- if (add_lib_info_fd(ph, exec_file, ph->core->exec_fd,
- (uintptr_t)0 + find_base_address(ph->core->exec_fd, &exec_ehdr)) == NULL)
- goto err;
+ // allocate and sort maps into map_array, we need to do this
+ // here because read_shared_lib_info needs to read from debuggee
+ // address space
+ if (sort_map_array(ph) != true) {
+ goto err;
+ }
- // allocate and sort maps into map_array, we need to do this
- // here because read_shared_lib_info needs to read from debuggee
- // address space
- if (sort_map_array(ph) != true)
- goto err;
+ if (read_shared_lib_info(ph) != true) {
+ goto err;
+ }
- if (read_shared_lib_info(ph) != true)
- goto err;
+ // sort again because we have added more mappings from shared objects
+ if (sort_map_array(ph) != true) {
+ goto err;
+ }
- // sort again because we have added more mappings from shared objects
- if (sort_map_array(ph) != true)
- goto err;
+ if (init_classsharing_workaround(ph) != true) {
+ goto err;
+ }
- if (init_classsharing_workaround(ph) != true)
- goto err;
-
- return ph;
+ return ph;
err:
- Prelease(ph);
- return NULL;
+ Prelease(ph);
+ return NULL;
}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/asm/Disassembler.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/asm/Disassembler.java Fri Oct 11 13:00:40 2013 -0700
@@ -67,6 +67,13 @@
String libname = "hsdis";
String arch = System.getProperty("os.arch");
if (os.lastIndexOf("Windows", 0) != -1) {
+ if (arch.equals("x86")) {
+ libname += "-i386";
+ } else if (arch.equals("amd64")) {
+ libname += "-amd64";
+ } else {
+ libname += "-" + arch;
+ }
path.append(sep + "bin" + sep);
libname += ".dll";
} else if (os.lastIndexOf("SunOS", 0) != -1) {
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/ProtectionDomainCacheEntry.java Fri Oct 11 13:00:40 2013 -0700
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2001, 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.
+ *
+ */
+
+package sun.jvm.hotspot.memory;
+
+import java.util.*;
+import sun.jvm.hotspot.debugger.*;
+import sun.jvm.hotspot.oops.*;
+import sun.jvm.hotspot.runtime.*;
+import sun.jvm.hotspot.types.*;
+
+public class ProtectionDomainCacheEntry extends VMObject {
+ private static sun.jvm.hotspot.types.OopField protectionDomainField;
+
+ static {
+ VM.registerVMInitializedObserver(new Observer() {
+ public void update(Observable o, Object data) {
+ initialize(VM.getVM().getTypeDataBase());
+ }
+ });
+ }
+
+ private static synchronized void initialize(TypeDataBase db) {
+ Type type = db.lookupType("ProtectionDomainCacheEntry");
+ protectionDomainField = type.getOopField("_literal");
+ }
+
+ public ProtectionDomainCacheEntry(Address addr) {
+ super(addr);
+ }
+
+ public Oop protectionDomain() {
+ return VM.getVM().getObjectHeap().newOop(protectionDomainField.getValue(addr));
+ }
+}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/ProtectionDomainEntry.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/ProtectionDomainEntry.java Fri Oct 11 13:00:40 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 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
@@ -32,7 +32,7 @@
public class ProtectionDomainEntry extends VMObject {
private static AddressField nextField;
- private static sun.jvm.hotspot.types.OopField protectionDomainField;
+ private static AddressField pdCacheField;
static {
VM.registerVMInitializedObserver(new Observer() {
@@ -46,7 +46,7 @@
Type type = db.lookupType("ProtectionDomainEntry");
nextField = type.getAddressField("_next");
- protectionDomainField = type.getOopField("_protection_domain");
+ pdCacheField = type.getAddressField("_pd_cache");
}
public ProtectionDomainEntry(Address addr) {
@@ -54,10 +54,12 @@
}
public ProtectionDomainEntry next() {
- return (ProtectionDomainEntry) VMObjectFactory.newObject(ProtectionDomainEntry.class, addr);
+ return (ProtectionDomainEntry) VMObjectFactory.newObject(ProtectionDomainEntry.class, nextField.getValue(addr));
}
public Oop protectionDomain() {
- return VM.getVM().getObjectHeap().newOop(protectionDomainField.getValue(addr));
+ ProtectionDomainCacheEntry pd_cache = (ProtectionDomainCacheEntry)
+ VMObjectFactory.newObject(ProtectionDomainCacheEntry.class, pdCacheField.getValue(addr));
+ return pd_cache.protectionDomain();
}
}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/SymbolTable.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/memory/SymbolTable.java Fri Oct 11 13:00:40 2013 -0700
@@ -44,12 +44,10 @@
private static synchronized void initialize(TypeDataBase db) {
Type type = db.lookupType("SymbolTable");
theTableField = type.getAddressField("_the_table");
- symbolTableSize = db.lookupIntConstant("SymbolTable::symbol_table_size").intValue();
}
// Fields
private static AddressField theTableField;
- private static int symbolTableSize;
// Accessors
public static SymbolTable getTheTable() {
@@ -57,10 +55,6 @@
return (SymbolTable) VMObjectFactory.newObject(SymbolTable.class, tmp);
}
- public static int getSymbolTableSize() {
- return symbolTableSize;
- }
-
public SymbolTable(Address addr) {
super(addr);
}
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/AbstractHeapGraphWriter.java Fri Oct 11 13:00:40 2013 -0700
@@ -59,6 +59,7 @@
public boolean doObj(Oop oop) {
try {
+ writeHeapRecordPrologue();
if (oop instanceof TypeArray) {
writePrimitiveArray((TypeArray)oop);
} else if (oop instanceof ObjArray) {
@@ -97,6 +98,7 @@
// not-a-Java-visible oop
writeInternalObject(oop);
}
+ writeHeapRecordEpilogue();
} catch (IOException exp) {
throw new RuntimeException(exp);
}
@@ -416,6 +418,12 @@
protected void writeHeapFooter() throws IOException {
}
+ protected void writeHeapRecordPrologue() throws IOException {
+ }
+
+ protected void writeHeapRecordEpilogue() throws IOException {
+ }
+
// HeapVisitor, OopVisitor methods can't throw any non-runtime
// exception. But, derived class write methods (which are called
// from visitor callbacks) may throw IOException. Hence, we throw
--- a/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/agent/src/share/classes/sun/jvm/hotspot/utilities/HeapHprofBinWriter.java Fri Oct 11 13:00:40 2013 -0700
@@ -44,7 +44,7 @@
* WARNING: This format is still under development, and is subject to
* change without notice.
*
- * header "JAVA PROFILE 1.0.1" (0-terminated)
+ * header "JAVA PROFILE 1.0.1" or "JAVA PROFILE 1.0.2" (0-terminated)
* u4 size of identifiers. Identifiers are used to represent
* UTF8 strings, objects, stack traces, etc. They usually
* have the same size as host pointers. For example, on
@@ -292,11 +292,34 @@
* 0x00000002: cpu sampling on/off
* u2 stack trace depth
*
+ *
+ * When the header is "JAVA PROFILE 1.0.2" a heap dump can optionally
+ * be generated as a sequence of heap dump segments. This sequence is
+ * terminated by an end record. The additional tags allowed by format
+ * "JAVA PROFILE 1.0.2" are:
+ *
+ * HPROF_HEAP_DUMP_SEGMENT denote a heap dump segment
+ *
+ * [heap dump sub-records]*
+ * The same sub-record types allowed by HPROF_HEAP_DUMP
+ *
+ * HPROF_HEAP_DUMP_END denotes the end of a heap dump
+ *
*/
public class HeapHprofBinWriter extends AbstractHeapGraphWriter {
+
+ // The heap size threshold used to determine if segmented format
+ // ("JAVA PROFILE 1.0.2") should be used.
+ private static final long HPROF_SEGMENTED_HEAP_DUMP_THRESHOLD = 2L * 0x40000000;
+
+ // The approximate size of a heap segment. Used to calculate when to create
+ // a new segment.
+ private static final long HPROF_SEGMENTED_HEAP_DUMP_SEGMENT_SIZE = 1L * 0x40000000;
+
// hprof binary file header
- private static final String HPROF_HEADER = "JAVA PROFILE 1.0.1";
+ private static final String HPROF_HEADER_1_0_1 = "JAVA PROFILE 1.0.1";
+ private static final String HPROF_HEADER_1_0_2 = "JAVA PROFILE 1.0.2";
// constants in enum HprofTag
private static final int HPROF_UTF8 = 0x01;
@@ -312,6 +335,10 @@
private static final int HPROF_CPU_SAMPLES = 0x0D;
private static final int HPROF_CONTROL_SETTINGS = 0x0E;
+ // 1.0.2 record types
+ private static final int HPROF_HEAP_DUMP_SEGMENT = 0x1C;
+ private static final int HPROF_HEAP_DUMP_END = 0x2C;
+
// Heap dump constants
// constants in enum HprofGcTag
private static final int HPROF_GC_ROOT_UNKNOWN = 0xFF;
@@ -352,11 +379,9 @@
private static final int JVM_SIGNATURE_ARRAY = '[';
private static final int JVM_SIGNATURE_CLASS = 'L';
-
public synchronized void write(String fileName) throws IOException {
// open file stream and create buffered data output stream
- FileOutputStream fos = new FileOutputStream(fileName);
- FileChannel chn = fos.getChannel();
+ fos = new FileOutputStream(fileName);
out = new DataOutputStream(new BufferedOutputStream(fos));
VM vm = VM.getVM();
@@ -385,6 +410,9 @@
FLOAT_SIZE = objectHeap.getFloatSize();
DOUBLE_SIZE = objectHeap.getDoubleSize();
+ // Check weather we should dump the heap as segments
+ useSegmentedHeapDump = vm.getUniverse().heap().used() > HPROF_SEGMENTED_HEAP_DUMP_THRESHOLD;
+
// hprof bin format header
writeFileHeader();
@@ -394,38 +422,87 @@
// hprof UTF-8 symbols section
writeSymbols();
+
// HPROF_LOAD_CLASS records for all classes
writeClasses();
- // write heap data now
- out.writeByte((byte)HPROF_HEAP_DUMP);
- out.writeInt(0); // relative timestamp
-
- // remember position of dump length, we will fixup
- // length later - hprof format requires length.
- out.flush();
- long dumpStart = chn.position();
-
- // write dummy length of 0 and we'll fix it later.
- out.writeInt(0);
-
// write CLASS_DUMP records
writeClassDumpRecords();
// this will write heap data into the buffer stream
super.write();
+ // flush buffer stream.
+ out.flush();
+
+ // Fill in final length
+ fillInHeapRecordLength();
+
+ if (useSegmentedHeapDump) {
+ // Write heap segment-end record
+ out.writeByte((byte) HPROF_HEAP_DUMP_END);
+ out.writeInt(0);
+ out.writeInt(0);
+ }
+
// flush buffer stream and throw it.
out.flush();
out = null;
+ // close the file stream
+ fos.close();
+ }
+
+ @Override
+ protected void writeHeapRecordPrologue() throws IOException {
+ if (currentSegmentStart == 0) {
+ // write heap data header, depending on heap size use segmented heap
+ // format
+ out.writeByte((byte) (useSegmentedHeapDump ? HPROF_HEAP_DUMP_SEGMENT
+ : HPROF_HEAP_DUMP));
+ out.writeInt(0);
+
+ // remember position of dump length, we will fixup
+ // length later - hprof format requires length.
+ out.flush();
+ currentSegmentStart = fos.getChannel().position();
+
+ // write dummy length of 0 and we'll fix it later.
+ out.writeInt(0);
+ }
+ }
+
+ @Override
+ protected void writeHeapRecordEpilogue() throws IOException {
+ if (useSegmentedHeapDump) {
+ out.flush();
+ if ((fos.getChannel().position() - currentSegmentStart - 4) >= HPROF_SEGMENTED_HEAP_DUMP_SEGMENT_SIZE) {
+ fillInHeapRecordLength();
+ currentSegmentStart = 0;
+ }
+ }
+ }
+
+ private void fillInHeapRecordLength() throws IOException {
+
// now get current position to calculate length
- long dumpEnd = chn.position();
+ long dumpEnd = fos.getChannel().position();
+
// calculate length of heap data
- int dumpLen = (int) (dumpEnd - dumpStart - 4);
+ long dumpLenLong = (dumpEnd - currentSegmentStart - 4L);
+
+ // Check length boundary, overflow could happen but is _very_ unlikely
+ if(dumpLenLong >= (4L * 0x40000000)){
+ throw new RuntimeException("Heap segment size overflow.");
+ }
+
+ // Save the current position
+ long currentPosition = fos.getChannel().position();
// seek the position to write length
- chn.position(dumpStart);
+ fos.getChannel().position(currentSegmentStart);
+
+ int dumpLen = (int) dumpLenLong;
// write length as integer
fos.write((dumpLen >>> 24) & 0xFF);
@@ -433,8 +510,8 @@
fos.write((dumpLen >>> 8) & 0xFF);
fos.write((dumpLen >>> 0) & 0xFF);
- // close the file stream
- fos.close();
+ //Reset to previous current position
+ fos.getChannel().position(currentPosition);
}
private void writeClassDumpRecords() throws IOException {
@@ -443,7 +520,9 @@
sysDict.allClassesDo(new SystemDictionary.ClassVisitor() {
public void visit(Klass k) {
try {
+ writeHeapRecordPrologue();
writeClassDumpRecord(k);
+ writeHeapRecordEpilogue();
} catch (IOException e) {
throw new RuntimeException(e);
}
@@ -884,7 +963,12 @@
// writes hprof binary file header
private void writeFileHeader() throws IOException {
// version string
- out.writeBytes(HPROF_HEADER);
+ if(useSegmentedHeapDump) {
+ out.writeBytes(HPROF_HEADER_1_0_2);
+ }
+ else {
+ out.writeBytes(HPROF_HEADER_1_0_1);
+ }
out.writeByte((byte)'\0');
// write identifier size. we use pointers as identifiers.
@@ -976,6 +1060,7 @@
private static final int EMPTY_FRAME_DEPTH = -1;
private DataOutputStream out;
+ private FileOutputStream fos;
private Debugger dbg;
private ObjectHeap objectHeap;
private SymbolTable symTbl;
@@ -983,6 +1068,10 @@
// oopSize of the debuggee
private int OBJ_ID_SIZE;
+ // Added for hprof file format 1.0.2 support
+ private boolean useSegmentedHeapDump;
+ private long currentSegmentStart;
+
private long BOOLEAN_BASE_OFFSET;
private long BYTE_BASE_OFFSET;
private long CHAR_BASE_OFFSET;
@@ -1005,6 +1094,7 @@
private static class ClassData {
int instSize;
List fields;
+
ClassData(int instSize, List fields) {
this.instSize = instSize;
this.fields = fields;
--- a/hotspot/make/hotspot_version Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/make/hotspot_version Fri Oct 11 13:00:40 2013 -0700
@@ -35,7 +35,7 @@
HS_MAJOR_VER=25
HS_MINOR_VER=0
-HS_BUILD_NUMBER=53
+HS_BUILD_NUMBER=54
JDK_MAJOR_VER=1
JDK_MINOR_VER=8
--- a/hotspot/make/windows/makefiles/compile.make Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/make/windows/makefiles/compile.make Fri Oct 11 13:00:40 2013 -0700
@@ -44,6 +44,7 @@
# /GS Inserts security stack checks in some functions (VS2005 default)
# /Oi Use intrinsics (in /O2)
# /Od Disable all optimizations
+# /MP Use multiple cores for compilation
#
# NOTE: Normally following any of the above with a '-' will turn off that flag
#
@@ -206,6 +207,7 @@
DEBUG_OPT_OPTION = /Od
GX_OPTION = /EHsc
LD_FLAGS = /manifest $(LD_FLAGS)
+MP_FLAG = /MP
# Manifest Tool - used in VS2005 and later to adjust manifests stored
# as resources inside build artifacts.
!if "x$(MT)" == "x"
@@ -219,6 +221,7 @@
DEBUG_OPT_OPTION = /Od
GX_OPTION = /EHsc
LD_FLAGS = /manifest $(LD_FLAGS)
+MP_FLAG = /MP
# Manifest Tool - used in VS2005 and later to adjust manifests stored
# as resources inside build artifacts.
!if "x$(MT)" == "x"
@@ -235,6 +238,7 @@
DEBUG_OPT_OPTION = /Od
GX_OPTION = /EHsc
LD_FLAGS = /manifest $(LD_FLAGS)
+MP_FLAG = /MP
# Manifest Tool - used in VS2005 and later to adjust manifests stored
# as resources inside build artifacts.
!if "x$(MT)" == "x"
@@ -245,6 +249,8 @@
!endif
!endif
+CXX_FLAGS = $(CXX_FLAGS) $(MP_FLAG)
+
# If NO_OPTIMIZATIONS is defined in the environment, turn everything off
!ifdef NO_OPTIMIZATIONS
PRODUCT_OPT_OPTION = $(DEBUG_OPT_OPTION)
--- a/hotspot/make/windows/makefiles/fastdebug.make Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/make/windows/makefiles/fastdebug.make Fri Oct 11 13:00:40 2013 -0700
@@ -38,7 +38,7 @@
!include ../local.make
!include compile.make
-CXX_FLAGS=$(CXX_FLAGS) $(FASTDEBUG_OPT_OPTION) /D "CHECK_UNHANDLED_OOPS"
+CXX_FLAGS=$(CXX_FLAGS) $(FASTDEBUG_OPT_OPTION)
!include $(WorkSpace)/make/windows/makefiles/vm.make
!include local.make
--- a/hotspot/make/windows/makefiles/sa.make Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/make/windows/makefiles/sa.make Fri Oct 11 13:00:40 2013 -0700
@@ -102,28 +102,33 @@
!if "$(MT)" != ""
SA_LD_FLAGS = -manifest $(SA_LD_FLAGS)
!endif
-SASRCFILE = $(AGENT_DIR)/src/os/win32/windbg/sawindbg.cpp
+
+SASRCFILES = $(AGENT_DIR)/src/os/win32/windbg/sawindbg.cpp \
+ $(AGENT_DIR)/src/share/native/sadis.c
+
SA_LFLAGS = $(SA_LD_FLAGS) -nologo -subsystem:console -machine:$(MACHINE)
!if "$(ENABLE_FULL_DEBUG_SYMBOLS)" == "1"
SA_LFLAGS = $(SA_LFLAGS) -map -debug
!endif
+SA_CFLAGS = $(SA_CFLAGS) $(MP_FLAG)
+
# Note that we do not keep sawindbj.obj around as it would then
# get included in the dumpbin command in build_vm_def.sh
# In VS2005 or VS2008 the link command creates a .manifest file that we want
# to insert into the linked artifact so we do not need to track it separately.
# Use ";#2" for .dll and ";#1" for .exe in the MT command below:
-$(SAWINDBG): $(SASRCFILE)
+$(SAWINDBG): $(SASRCFILES)
set INCLUDE=$(SA_INCLUDE)$(INCLUDE)
$(CXX) @<<
-I"$(BootStrapDir)/include" -I"$(BootStrapDir)/include/win32"
-I"$(GENERATED)" $(SA_CFLAGS)
- $(SASRCFILE)
+ $(SASRCFILES)
-out:$*.obj
<<
set LIB=$(SA_LIB)$(LIB)
- $(LD) -out:$@ -DLL $*.obj dbgeng.lib $(SA_LFLAGS)
+ $(LD) -out:$@ -DLL sawindbg.obj sadis.obj dbgeng.lib $(SA_LFLAGS)
!if "$(MT)" != ""
$(MT) -manifest $(@F).manifest -outputresource:$(@F);#2
!endif
--- a/hotspot/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_Runtime1_sparc.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -37,6 +37,9 @@
#include "runtime/vframeArray.hpp"
#include "utilities/macros.hpp"
#include "vmreg_sparc.inline.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
+#endif
// Implementation of StubAssembler
@@ -912,7 +915,7 @@
Register tmp2 = G3_scratch;
jbyte* byte_map_base = ((CardTableModRefBS*)bs)->byte_map_base;
- Label not_already_dirty, restart, refill;
+ Label not_already_dirty, restart, refill, young_card;
#ifdef _LP64
__ srlx(addr, CardTableModRefBS::card_shift, addr);
@@ -924,9 +927,15 @@
__ set(rs, cardtable); // cardtable := <card table base>
__ ldub(addr, cardtable, tmp); // tmp := [addr + cardtable]
+ __ cmp_and_br_short(tmp, G1SATBCardTableModRefBS::g1_young_card_val(), Assembler::equal, Assembler::pt, young_card);
+
+ __ membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+ __ ldub(addr, cardtable, tmp); // tmp := [addr + cardtable]
+
assert(CardTableModRefBS::dirty_card_val() == 0, "otherwise check this code");
__ cmp_and_br_short(tmp, G0, Assembler::notEqual, Assembler::pt, not_already_dirty);
+ __ bind(young_card);
// We didn't take the branch, so we're already dirty: return.
// Use return-from-leaf
__ retl();
--- a/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/cpu/sparc/vm/macroAssembler_sparc.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -3752,7 +3752,7 @@
#define __ masm.
address start = __ pc();
- Label not_already_dirty, restart, refill;
+ Label not_already_dirty, restart, refill, young_card;
#ifdef _LP64
__ srlx(O0, CardTableModRefBS::card_shift, O0);
@@ -3763,9 +3763,15 @@
__ set(addrlit, O1); // O1 := <card table base>
__ ldub(O0, O1, O2); // O2 := [O0 + O1]
+ __ cmp_and_br_short(O2, G1SATBCardTableModRefBS::g1_young_card_val(), Assembler::equal, Assembler::pt, young_card);
+
+ __ membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+ __ ldub(O0, O1, O2); // O2 := [O0 + O1]
+
assert(CardTableModRefBS::dirty_card_val() == 0, "otherwise check this code");
__ cmp_and_br_short(O2, G0, Assembler::notEqual, Assembler::pt, not_already_dirty);
+ __ bind(young_card);
// We didn't take the branch, so we're already dirty: return.
// Use return-from-leaf
__ retl();
--- a/hotspot/src/cpu/x86/vm/c1_Runtime1_x86.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/c1_Runtime1_x86.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -38,6 +38,9 @@
#include "runtime/vframeArray.hpp"
#include "utilities/macros.hpp"
#include "vmreg_x86.inline.hpp"
+#if INCLUDE_ALL_GCS
+#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
+#endif
// Implementation of StubAssembler
@@ -1753,13 +1756,17 @@
__ leal(card_addr, __ as_Address(ArrayAddress(cardtable, index)));
#endif
- __ cmpb(Address(card_addr, 0), 0);
+ __ cmpb(Address(card_addr, 0), (int)G1SATBCardTableModRefBS::g1_young_card_val());
+ __ jcc(Assembler::equal, done);
+
+ __ membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+ __ cmpb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
__ jcc(Assembler::equal, done);
// storing region crossing non-NULL, card is clean.
// dirty card and log.
- __ movb(Address(card_addr, 0), 0);
+ __ movb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
__ cmpl(queue_index, 0);
__ jcc(Assembler::equal, runtime);
--- a/hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/cpu/x86/vm/macroAssembler_x86.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -3389,13 +3389,18 @@
const Register card_addr = tmp;
lea(card_addr, as_Address(ArrayAddress(cardtable, index)));
#endif
- cmpb(Address(card_addr, 0), 0);
+ cmpb(Address(card_addr, 0), (int)G1SATBCardTableModRefBS::g1_young_card_val());
jcc(Assembler::equal, done);
+ membar(Assembler::Membar_mask_bits(Assembler::StoreLoad));
+ cmpb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
+ jcc(Assembler::equal, done);
+
+
// storing a region crossing, non-NULL oop, card is clean.
// dirty card and log.
- movb(Address(card_addr, 0), 0);
+ movb(Address(card_addr, 0), (int)CardTableModRefBS::dirty_card_val());
cmpl(queue_index, 0);
jcc(Assembler::equal, runtime);
--- a/hotspot/src/os/bsd/vm/osThread_bsd.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/os/bsd/vm/osThread_bsd.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -42,7 +42,7 @@
#ifdef __APPLE__
typedef thread_t thread_id_t;
#else
- typedef pthread_t thread_id_t;
+ typedef pid_t thread_id_t;
#endif
// _pthread_id is the pthread id, which is used by library calls
--- a/hotspot/src/os/bsd/vm/os_bsd.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -100,6 +100,7 @@
# include <stdint.h>
# include <inttypes.h>
# include <sys/ioctl.h>
+# include <sys/syscall.h>
#if defined(__FreeBSD__) || defined(__NetBSD__)
# include <elf.h>
@@ -152,6 +153,7 @@
// utility functions
static int SR_initialize();
+static void unpackTime(timespec* absTime, bool isAbsolute, jlong time);
julong os::available_memory() {
return Bsd::available_memory();
@@ -247,7 +249,17 @@
* since it returns a 64 bit value)
*/
mib[0] = CTL_HW;
+
+#if defined (HW_MEMSIZE) // Apple
mib[1] = HW_MEMSIZE;
+#elif defined(HW_PHYSMEM) // Most of BSD
+ mib[1] = HW_PHYSMEM;
+#elif defined(HW_REALMEM) // Old FreeBSD
+ mib[1] = HW_REALMEM;
+#else
+ #error No ways to get physmem
+#endif
+
len = sizeof(mem_val);
if (sysctl(mib, 2, &mem_val, &len, NULL, 0) != -1) {
assert(len == sizeof(mem_val), "unexpected data size");
@@ -679,18 +691,12 @@
return NULL;
}
+ osthread->set_thread_id(os::Bsd::gettid());
+
#ifdef __APPLE__
- // thread_id is mach thread on macos, which pthreads graciously caches and provides for us
- mach_port_t thread_id = ::pthread_mach_thread_np(::pthread_self());
- guarantee(thread_id != 0, "thread id missing from pthreads");
- osthread->set_thread_id(thread_id);
-
- uint64_t unique_thread_id = locate_unique_thread_id(thread_id);
+ uint64_t unique_thread_id = locate_unique_thread_id(osthread->thread_id());
guarantee(unique_thread_id != 0, "unique thread id was not found");
osthread->set_unique_thread_id(unique_thread_id);
-#else
- // thread_id is pthread_id on BSD
- osthread->set_thread_id(::pthread_self());
#endif
// initialize signal mask for this thread
os::Bsd::hotspot_sigmask(thread);
@@ -847,18 +853,13 @@
return false;
}
+ osthread->set_thread_id(os::Bsd::gettid());
+
// Store pthread info into the OSThread
#ifdef __APPLE__
- // thread_id is mach thread on macos, which pthreads graciously caches and provides for us
- mach_port_t thread_id = ::pthread_mach_thread_np(::pthread_self());
- guarantee(thread_id != 0, "just checking");
- osthread->set_thread_id(thread_id);
-
- uint64_t unique_thread_id = locate_unique_thread_id(thread_id);
+ uint64_t unique_thread_id = locate_unique_thread_id(osthread->thread_id());
guarantee(unique_thread_id != 0, "just checking");
osthread->set_unique_thread_id(unique_thread_id);
-#else
- osthread->set_thread_id(::pthread_self());
#endif
osthread->set_pthread_id(::pthread_self());
@@ -1125,6 +1126,30 @@
return n;
}
+// Information of current thread in variety of formats
+pid_t os::Bsd::gettid() {
+ int retval = -1;
+
+#ifdef __APPLE__ //XNU kernel
+ // despite the fact mach port is actually not a thread id use it
+ // instead of syscall(SYS_thread_selfid) as it certainly fits to u4
+ retval = ::pthread_mach_thread_np(::pthread_self());
+ guarantee(retval != 0, "just checking");
+ return retval;
+
+#elif __FreeBSD__
+ retval = syscall(SYS_thr_self);
+#elif __OpenBSD__
+ retval = syscall(SYS_getthrid);
+#elif __NetBSD__
+ retval = (pid_t) syscall(SYS__lwp_self);
+#endif
+
+ if (retval == -1) {
+ return getpid();
+ }
+}
+
intx os::current_thread_id() {
#ifdef __APPLE__
return (intx)::pthread_mach_thread_np(::pthread_self());
@@ -1132,6 +1157,7 @@
return (intx)::pthread_self();
#endif
}
+
int os::current_process_id() {
// Under the old bsd thread library, bsd gives each thread
@@ -1904,7 +1930,7 @@
bool timedwait(unsigned int sec, int nsec);
private:
jlong currenttime() const;
- semaphore_t _semaphore;
+ os_semaphore_t _semaphore;
};
Semaphore::Semaphore() : _semaphore(0) {
@@ -1972,7 +1998,7 @@
bool Semaphore::timedwait(unsigned int sec, int nsec) {
struct timespec ts;
- jlong endtime = unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
+ unpackTime(&ts, false, (sec * NANOSECS_PER_SEC) + nsec);
while (1) {
int result = sem_timedwait(&_semaphore, &ts);
--- a/hotspot/src/os/bsd/vm/os_bsd.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -84,6 +84,7 @@
static void hotspot_sigmask(Thread* thread);
static bool is_initial_thread(void);
+ static pid_t gettid();
static int page_size(void) { return _page_size; }
static void set_page_size(int val) { _page_size = val; }
--- a/hotspot/src/os/linux/vm/globals_linux.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/os/linux/vm/globals_linux.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -53,7 +53,7 @@
// Defines Linux-specific default values. The flags are available on all
// platforms, but they may have different default values on other platforms.
//
-define_pd_global(bool, UseLargePages, true);
+define_pd_global(bool, UseLargePages, false);
define_pd_global(bool, UseLargePagesIndividualAllocation, false);
define_pd_global(bool, UseOSErrorReporting, false);
define_pd_global(bool, UseThreadPriorities, true) ;
--- a/hotspot/src/os/linux/vm/os_linux.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -3361,13 +3361,15 @@
if (FLAG_IS_DEFAULT(UseHugeTLBFS) &&
FLAG_IS_DEFAULT(UseSHM) &&
FLAG_IS_DEFAULT(UseTransparentHugePages)) {
- // If UseLargePages is specified on the command line try all methods,
- // if it's default, then try only UseTransparentHugePages.
- if (FLAG_IS_DEFAULT(UseLargePages)) {
- UseTransparentHugePages = true;
- } else {
- UseHugeTLBFS = UseTransparentHugePages = UseSHM = true;
- }
+
+ // The type of large pages has not been specified by the user.
+
+ // Try UseHugeTLBFS and then UseSHM.
+ UseHugeTLBFS = UseSHM = true;
+
+ // Don't try UseTransparentHugePages since there are known
+ // performance issues with it turned on. This might change in the future.
+ UseTransparentHugePages = false;
}
if (UseTransparentHugePages) {
@@ -3393,9 +3395,19 @@
}
void os::large_page_init() {
- if (!UseLargePages) {
+ if (!UseLargePages &&
+ !UseTransparentHugePages &&
+ !UseHugeTLBFS &&
+ !UseSHM) {
+ // Not using large pages.
+ return;
+ }
+
+ if (!FLAG_IS_DEFAULT(UseLargePages) && !UseLargePages) {
+ // The user explicitly turned off large pages.
+ // Ignore the rest of the large pages flags.
+ UseTransparentHugePages = false;
UseHugeTLBFS = false;
- UseTransparentHugePages = false;
UseSHM = false;
return;
}
--- a/hotspot/src/share/vm/classfile/classFileParser.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/classFileParser.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -4080,8 +4080,7 @@
// Generate any default methods - default methods are interface methods
// that have a default implementation. This is new with Lambda project.
- if (has_default_methods && !access_flags.is_interface() &&
- local_interfaces->length() > 0) {
+ if (has_default_methods && !access_flags.is_interface() ) {
DefaultMethods::generate_default_methods(
this_klass(), &all_mirandas, CHECK_(nullHandle));
}
--- a/hotspot/src/share/vm/classfile/defaultMethods.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/defaultMethods.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -345,7 +345,6 @@
}
Symbol* generate_no_defaults_message(TRAPS) const;
- Symbol* generate_abstract_method_message(Method* method, TRAPS) const;
Symbol* generate_conflicts_message(GrowableArray<Method*>* methods, TRAPS) const;
public:
@@ -404,20 +403,19 @@
_exception_message = generate_no_defaults_message(CHECK);
_exception_name = vmSymbols::java_lang_AbstractMethodError();
} else if (qualified_methods.length() == 1) {
+ // leave abstract methods alone, they will be found via normal search path
Method* method = qualified_methods.at(0);
- if (method->is_abstract()) {
- _exception_message = generate_abstract_method_message(method, CHECK);
- _exception_name = vmSymbols::java_lang_AbstractMethodError();
- } else {
+ if (!method->is_abstract()) {
_selected_target = qualified_methods.at(0);
}
} else {
_exception_message = generate_conflicts_message(&qualified_methods,CHECK);
_exception_name = vmSymbols::java_lang_IncompatibleClassChangeError();
+ if (TraceDefaultMethods) {
+ _exception_message->print_value_on(tty);
+ tty->print_cr("");
+ }
}
-
- assert((has_target() ^ throws_exception()) == 1,
- "One and only one must be true");
}
bool contains_signature(Symbol* query) {
@@ -475,20 +473,6 @@
return SymbolTable::new_symbol("No qualifying defaults found", CHECK_NULL);
}
-Symbol* MethodFamily::generate_abstract_method_message(Method* method, TRAPS) const {
- Symbol* klass = method->klass_name();
- Symbol* name = method->name();
- Symbol* sig = method->signature();
- stringStream ss;
- ss.print("Method ");
- ss.write((const char*)klass->bytes(), klass->utf8_length());
- ss.print(".");
- ss.write((const char*)name->bytes(), name->utf8_length());
- ss.write((const char*)sig->bytes(), sig->utf8_length());
- ss.print(" is abstract");
- return SymbolTable::new_symbol(ss.base(), (int)ss.size(), CHECK_NULL);
-}
-
Symbol* MethodFamily::generate_conflicts_message(GrowableArray<Method*>* methods, TRAPS) const {
stringStream ss;
ss.print("Conflicting default methods:");
@@ -595,6 +579,18 @@
#endif // ndef PRODUCT
};
+static bool already_in_vtable_slots(GrowableArray<EmptyVtableSlot*>* slots, Method* m) {
+ bool found = false;
+ for (int j = 0; j < slots->length(); ++j) {
+ if (slots->at(j)->name() == m->name() &&
+ slots->at(j)->signature() == m->signature() ) {
+ found = true;
+ break;
+ }
+ }
+ return found;
+}
+
static GrowableArray<EmptyVtableSlot*>* find_empty_vtable_slots(
InstanceKlass* klass, GrowableArray<Method*>* mirandas, TRAPS) {
@@ -604,8 +600,10 @@
// All miranda methods are obvious candidates
for (int i = 0; i < mirandas->length(); ++i) {
- EmptyVtableSlot* slot = new EmptyVtableSlot(mirandas->at(i));
- slots->append(slot);
+ Method* m = mirandas->at(i);
+ if (!already_in_vtable_slots(slots, m)) {
+ slots->append(new EmptyVtableSlot(m));
+ }
}
// Also any overpasses in our superclasses, that we haven't implemented.
@@ -621,7 +619,26 @@
// unless we have a real implementation of it in the current class.
Method* impl = klass->lookup_method(m->name(), m->signature());
if (impl == NULL || impl->is_overpass()) {
- slots->append(new EmptyVtableSlot(m));
+ if (!already_in_vtable_slots(slots, m)) {
+ slots->append(new EmptyVtableSlot(m));
+ }
+ }
+ }
+ }
+
+ // also any default methods in our superclasses
+ if (super->default_methods() != NULL) {
+ for (int i = 0; i < super->default_methods()->length(); ++i) {
+ Method* m = super->default_methods()->at(i);
+ // m is a method that would have been a miranda if not for the
+ // default method processing that occurred on behalf of our superclass,
+ // so it's a method we want to re-examine in this new context. That is,
+ // unless we have a real implementation of it in the current class.
+ Method* impl = klass->lookup_method(m->name(), m->signature());
+ if (impl == NULL || impl->is_overpass()) {
+ if (!already_in_vtable_slots(slots, m)) {
+ slots->append(new EmptyVtableSlot(m));
+ }
}
}
}
@@ -679,7 +696,7 @@
// private interface methods are not candidates for default methods
// invokespecial to private interface methods doesn't use default method logic
// future: take access controls into account for superclass methods
- if (m != NULL && (!iklass->is_interface() || m->is_public())) {
+ if (m != NULL && !m->is_static() && (!iklass->is_interface() || m->is_public())) {
if (_family == NULL) {
_family = new StatefulMethodFamily();
}
@@ -700,7 +717,7 @@
-static void create_overpasses(
+static void create_defaults_and_exceptions(
GrowableArray<EmptyVtableSlot*>* slots, InstanceKlass* klass, TRAPS);
static void generate_erased_defaults(
@@ -721,6 +738,8 @@
static void merge_in_new_methods(InstanceKlass* klass,
GrowableArray<Method*>* new_methods, TRAPS);
+static void create_default_methods( InstanceKlass* klass,
+ GrowableArray<Method*>* new_methods, TRAPS);
// This is the guts of the default methods implementation. This is called just
// after the classfile has been parsed if some ancestor has default methods.
@@ -782,7 +801,7 @@
}
#endif // ndef PRODUCT
- create_overpasses(empty_slots, klass, CHECK);
+ create_defaults_and_exceptions(empty_slots, klass, CHECK);
#ifndef PRODUCT
if (TraceDefaultMethods) {
@@ -791,66 +810,6 @@
#endif // ndef PRODUCT
}
-
-
-#ifdef ASSERT
-// Return true is broad type is a covariant return of narrow type
-static bool covariant_return_type(BasicType narrow, BasicType broad) {
- if (narrow == broad) {
- return true;
- }
- if (broad == T_OBJECT) {
- return true;
- }
- return false;
-}
-#endif
-
-static int assemble_redirect(
- BytecodeConstantPool* cp, BytecodeBuffer* buffer,
- Symbol* incoming, Method* target, TRAPS) {
-
- BytecodeAssembler assem(buffer, cp);
-
- SignatureStream in(incoming, true);
- SignatureStream out(target->signature(), true);
- u2 parameter_count = 0;
-
- assem.aload(parameter_count++); // load 'this'
-
- while (!in.at_return_type()) {
- assert(!out.at_return_type(), "Parameter counts do not match");
- BasicType bt = in.type();
- assert(out.type() == bt, "Parameter types are not compatible");
- assem.load(bt, parameter_count);
- if (in.is_object() && in.as_symbol(THREAD) != out.as_symbol(THREAD)) {
- assem.checkcast(out.as_symbol(THREAD));
- } else if (bt == T_LONG || bt == T_DOUBLE) {
- ++parameter_count; // longs and doubles use two slots
- }
- ++parameter_count;
- in.next();
- out.next();
- }
- assert(out.at_return_type(), "Parameter counts do not match");
- assert(covariant_return_type(out.type(), in.type()), "Return types are not compatible");
-
- if (parameter_count == 1 && (in.type() == T_LONG || in.type() == T_DOUBLE)) {
- ++parameter_count; // need room for return value
- }
- if (target->method_holder()->is_interface()) {
- assem.invokespecial(target);
- } else {
- assem.invokevirtual(target);
- }
-
- if (in.is_object() && in.as_symbol(THREAD) != out.as_symbol(THREAD)) {
- assem.checkcast(in.as_symbol(THREAD));
- }
- assem._return(in.type());
- return parameter_count;
-}
-
static int assemble_method_error(
BytecodeConstantPool* cp, BytecodeBuffer* buffer, Symbol* errorName, Symbol* message, TRAPS) {
@@ -924,18 +883,18 @@
}
}
-// A "bridge" is a method created by javac to bridge the gap between
-// an implementation and a generically-compatible, but different, signature.
-// Bridges have actual bytecode implementation in classfiles.
-// An "overpass", on the other hand, performs the same function as a bridge
-// but does not occur in a classfile; the VM creates overpass itself,
-// when it needs a path to get from a call site to an default method, and
-// a bridge doesn't exist.
-static void create_overpasses(
+// Create default_methods list for the current class.
+// With the VM only processing erased signatures, the VM only
+// creates an overpass in a conflict case or a case with no candidates.
+// This allows virtual methods to override the overpass, but ensures
+// that a local method search will find the exception rather than an abstract
+// or default method that is not a valid candidate.
+static void create_defaults_and_exceptions(
GrowableArray<EmptyVtableSlot*>* slots,
InstanceKlass* klass, TRAPS) {
GrowableArray<Method*> overpasses;
+ GrowableArray<Method*> defaults;
BytecodeConstantPool bpool(klass->constants());
for (int i = 0; i < slots->length(); ++i) {
@@ -943,7 +902,6 @@
if (slot->is_bound()) {
MethodFamily* method = slot->get_binding();
- int max_stack = 0;
BytecodeBuffer buffer;
#ifndef PRODUCT
@@ -953,26 +911,27 @@
tty->print_cr("");
if (method->has_target()) {
method->print_selected(tty, 1);
- } else {
+ } else if (method->throws_exception()) {
method->print_exception(tty, 1);
}
}
#endif // ndef PRODUCT
+
if (method->has_target()) {
Method* selected = method->get_selected_target();
if (selected->method_holder()->is_interface()) {
- max_stack = assemble_redirect(
- &bpool, &buffer, slot->signature(), selected, CHECK);
+ defaults.push(selected);
}
} else if (method->throws_exception()) {
- max_stack = assemble_method_error(&bpool, &buffer, method->get_exception_name(), method->get_exception_message(), CHECK);
- }
- if (max_stack != 0) {
+ int max_stack = assemble_method_error(&bpool, &buffer,
+ method->get_exception_name(), method->get_exception_message(), CHECK);
AccessFlags flags = accessFlags_from(
JVM_ACC_PUBLIC | JVM_ACC_SYNTHETIC | JVM_ACC_BRIDGE);
- Method* m = new_method(&bpool, &buffer, slot->name(), slot->signature(),
+ Method* m = new_method(&bpool, &buffer, slot->name(), slot->signature(),
flags, max_stack, slot->size_of_parameters(),
ConstMethod::OVERPASS, CHECK);
+ // We push to the methods list:
+ // overpass methods which are exception throwing methods
if (m != NULL) {
overpasses.push(m);
}
@@ -983,11 +942,31 @@
#ifndef PRODUCT
if (TraceDefaultMethods) {
tty->print_cr("Created %d overpass methods", overpasses.length());
+ tty->print_cr("Created %d default methods", defaults.length());
}
#endif // ndef PRODUCT
- switchover_constant_pool(&bpool, klass, &overpasses, CHECK);
- merge_in_new_methods(klass, &overpasses, CHECK);
+ if (overpasses.length() > 0) {
+ switchover_constant_pool(&bpool, klass, &overpasses, CHECK);
+ merge_in_new_methods(klass, &overpasses, CHECK);
+ }
+ if (defaults.length() > 0) {
+ create_default_methods(klass, &defaults, CHECK);
+ }
+}
+
+static void create_default_methods( InstanceKlass* klass,
+ GrowableArray<Method*>* new_methods, TRAPS) {
+
+ int new_size = new_methods->length();
+ Array<Method*>* total_default_methods = MetadataFactory::new_array<Method*>(
+ klass->class_loader_data(), new_size, NULL, CHECK);
+ for (int index = 0; index < new_size; index++ ) {
+ total_default_methods->at_put(index, new_methods->at(index));
+ }
+ Method::sort_methods(total_default_methods, false, false);
+
+ klass->set_default_methods(total_default_methods);
}
static void sort_methods(GrowableArray<Method*>* methods) {
--- a/hotspot/src/share/vm/classfile/dictionary.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/dictionary.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2003, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 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
@@ -25,6 +25,7 @@
#include "precompiled.hpp"
#include "classfile/dictionary.hpp"
#include "classfile/systemDictionary.hpp"
+#include "memory/iterator.hpp"
#include "oops/oop.inline.hpp"
#include "prims/jvmtiRedefineClassesTrace.hpp"
#include "utilities/hashtable.inline.hpp"
@@ -38,17 +39,21 @@
: TwoOopHashtable<Klass*, mtClass>(table_size, sizeof(DictionaryEntry)) {
_current_class_index = 0;
_current_class_entry = NULL;
+ _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
};
-
Dictionary::Dictionary(int table_size, HashtableBucket<mtClass>* t,
int number_of_entries)
: TwoOopHashtable<Klass*, mtClass>(table_size, sizeof(DictionaryEntry), t, number_of_entries) {
_current_class_index = 0;
_current_class_entry = NULL;
+ _pd_cache_table = new ProtectionDomainCacheTable(defaultProtectionDomainCacheSize);
};
+ProtectionDomainCacheEntry* Dictionary::cache_get(oop protection_domain) {
+ return _pd_cache_table->get(protection_domain);
+}
DictionaryEntry* Dictionary::new_entry(unsigned int hash, Klass* klass,
ClassLoaderData* loader_data) {
@@ -105,11 +110,12 @@
}
-void DictionaryEntry::add_protection_domain(oop protection_domain) {
+void DictionaryEntry::add_protection_domain(Dictionary* dict, oop protection_domain) {
assert_locked_or_safepoint(SystemDictionary_lock);
if (!contains_protection_domain(protection_domain)) {
+ ProtectionDomainCacheEntry* entry = dict->cache_get(protection_domain);
ProtectionDomainEntry* new_head =
- new ProtectionDomainEntry(protection_domain, _pd_set);
+ new ProtectionDomainEntry(entry, _pd_set);
// Warning: Preserve store ordering. The SystemDictionary is read
// without locks. The new ProtectionDomainEntry must be
// complete before other threads can be allowed to see it
@@ -193,7 +199,10 @@
void Dictionary::always_strong_oops_do(OopClosure* blk) {
- // Follow all system classes and temporary placeholders in dictionary
+ // Follow all system classes and temporary placeholders in dictionary; only
+ // protection domain oops contain references into the heap. In a first
+ // pass over the system dictionary determine which need to be treated as
+ // strongly reachable and mark them as such.
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry *probe = bucket(index);
probe != NULL;
@@ -201,10 +210,13 @@
Klass* e = probe->klass();
ClassLoaderData* loader_data = probe->loader_data();
if (is_strongly_reachable(loader_data, e)) {
- probe->protection_domain_set_oops_do(blk);
+ probe->set_strongly_reachable();
}
}
}
+ // Then iterate over the protection domain cache to apply the closure on the
+ // previously marked ones.
+ _pd_cache_table->always_strong_oops_do(blk);
}
@@ -266,18 +278,12 @@
}
}
-
void Dictionary::oops_do(OopClosure* f) {
- for (int index = 0; index < table_size(); index++) {
- for (DictionaryEntry* probe = bucket(index);
- probe != NULL;
- probe = probe->next()) {
- probe->protection_domain_set_oops_do(f);
- }
- }
+ // Only the protection domain oops contain references into the heap. Iterate
+ // over all of them.
+ _pd_cache_table->oops_do(f);
}
-
void Dictionary::methods_do(void f(Method*)) {
for (int index = 0; index < table_size(); index++) {
for (DictionaryEntry* probe = bucket(index);
@@ -292,6 +298,11 @@
}
}
+void Dictionary::unlink(BoolObjectClosure* is_alive) {
+ // Only the protection domain cache table may contain references to the heap
+ // that need to be unlinked.
+ _pd_cache_table->unlink(is_alive);
+}
Klass* Dictionary::try_get_next_class() {
while (true) {
@@ -306,7 +317,6 @@
// never reached
}
-
// Add a loaded class to the system dictionary.
// Readers of the SystemDictionary aren't always locked, so _buckets
// is volatile. The store of the next field in the constructor is
@@ -396,7 +406,7 @@
assert(protection_domain() != NULL,
"real protection domain should be present");
- entry->add_protection_domain(protection_domain());
+ entry->add_protection_domain(this, protection_domain());
assert(entry->contains_protection_domain(protection_domain()),
"now protection domain should be present");
@@ -446,6 +456,146 @@
}
}
+ProtectionDomainCacheTable::ProtectionDomainCacheTable(int table_size)
+ : Hashtable<oop, mtClass>(table_size, sizeof(ProtectionDomainCacheEntry))
+{
+}
+
+void ProtectionDomainCacheTable::unlink(BoolObjectClosure* is_alive) {
+ assert(SafepointSynchronize::is_at_safepoint(), "must be");
+ for (int i = 0; i < table_size(); ++i) {
+ ProtectionDomainCacheEntry** p = bucket_addr(i);
+ ProtectionDomainCacheEntry* entry = bucket(i);
+ while (entry != NULL) {
+ if (is_alive->do_object_b(entry->literal())) {
+ p = entry->next_addr();
+ } else {
+ *p = entry->next();
+ free_entry(entry);
+ }
+ entry = *p;
+ }
+ }
+}
+
+void ProtectionDomainCacheTable::oops_do(OopClosure* f) {
+ for (int index = 0; index < table_size(); index++) {
+ for (ProtectionDomainCacheEntry* probe = bucket(index);
+ probe != NULL;
+ probe = probe->next()) {
+ probe->oops_do(f);
+ }
+ }
+}
+
+uint ProtectionDomainCacheTable::bucket_size() {
+ return sizeof(ProtectionDomainCacheEntry);
+}
+
+#ifndef PRODUCT
+void ProtectionDomainCacheTable::print() {
+ tty->print_cr("Protection domain cache table (table_size=%d, classes=%d)",
+ table_size(), number_of_entries());
+ for (int index = 0; index < table_size(); index++) {
+ for (ProtectionDomainCacheEntry* probe = bucket(index);
+ probe != NULL;
+ probe = probe->next()) {
+ probe->print();
+ }
+ }
+}
+
+void ProtectionDomainCacheEntry::print() {
+ tty->print_cr("entry "PTR_FORMAT" value "PTR_FORMAT" strongly_reachable %d next "PTR_FORMAT,
+ this, (void*)literal(), _strongly_reachable, next());
+}
+#endif
+
+void ProtectionDomainCacheTable::verify() {
+ int element_count = 0;
+ for (int index = 0; index < table_size(); index++) {
+ for (ProtectionDomainCacheEntry* probe = bucket(index);
+ probe != NULL;
+ probe = probe->next()) {
+ probe->verify();
+ element_count++;
+ }
+ }
+ guarantee(number_of_entries() == element_count,
+ "Verify of protection domain cache table failed");
+ debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
+}
+
+void ProtectionDomainCacheEntry::verify() {
+ guarantee(literal()->is_oop(), "must be an oop");
+}
+
+void ProtectionDomainCacheTable::always_strong_oops_do(OopClosure* f) {
+ // the caller marked the protection domain cache entries that we need to apply
+ // the closure on. Only process them.
+ for (int index = 0; index < table_size(); index++) {
+ for (ProtectionDomainCacheEntry* probe = bucket(index);
+ probe != NULL;
+ probe = probe->next()) {
+ if (probe->is_strongly_reachable()) {
+ probe->reset_strongly_reachable();
+ probe->oops_do(f);
+ }
+ }
+ }
+}
+
+ProtectionDomainCacheEntry* ProtectionDomainCacheTable::get(oop protection_domain) {
+ unsigned int hash = compute_hash(protection_domain);
+ int index = hash_to_index(hash);
+
+ ProtectionDomainCacheEntry* entry = find_entry(index, protection_domain);
+ if (entry == NULL) {
+ entry = add_entry(index, hash, protection_domain);
+ }
+ return entry;
+}
+
+ProtectionDomainCacheEntry* ProtectionDomainCacheTable::find_entry(int index, oop protection_domain) {
+ for (ProtectionDomainCacheEntry* e = bucket(index); e != NULL; e = e->next()) {
+ if (e->protection_domain() == protection_domain) {
+ return e;
+ }
+ }
+
+ return NULL;
+}
+
+ProtectionDomainCacheEntry* ProtectionDomainCacheTable::add_entry(int index, unsigned int hash, oop protection_domain) {
+ assert_locked_or_safepoint(SystemDictionary_lock);
+ assert(index == index_for(protection_domain), "incorrect index?");
+ assert(find_entry(index, protection_domain) == NULL, "no double entry");
+
+ ProtectionDomainCacheEntry* p = new_entry(hash, protection_domain);
+ Hashtable<oop, mtClass>::add_entry(index, p);
+ return p;
+}
+
+void ProtectionDomainCacheTable::free(ProtectionDomainCacheEntry* to_delete) {
+ unsigned int hash = compute_hash(to_delete->protection_domain());
+ int index = hash_to_index(hash);
+
+ ProtectionDomainCacheEntry** p = bucket_addr(index);
+ ProtectionDomainCacheEntry* entry = bucket(index);
+ while (true) {
+ assert(entry != NULL, "sanity");
+
+ if (entry == to_delete) {
+ *p = entry->next();
+ Hashtable<oop, mtClass>::free_entry(entry);
+ break;
+ } else {
+ p = entry->next_addr();
+ entry = *p;
+ }
+ }
+}
+
SymbolPropertyTable::SymbolPropertyTable(int table_size)
: Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry))
{
@@ -532,11 +682,13 @@
tty->cr();
}
}
+ tty->cr();
+ _pd_cache_table->print();
+ tty->cr();
}
#endif
-
void Dictionary::verify() {
guarantee(number_of_entries() >= 0, "Verify of system dictionary failed");
@@ -563,5 +715,7 @@
guarantee(number_of_entries() == element_count,
"Verify of system dictionary failed");
debug_only(verify_lookup_length((double)number_of_entries() / table_size()));
+
+ _pd_cache_table->verify();
}
--- a/hotspot/src/share/vm/classfile/dictionary.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/dictionary.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -27,11 +27,14 @@
#include "classfile/systemDictionary.hpp"
#include "oops/instanceKlass.hpp"
-#include "oops/oop.hpp"
+#include "oops/oop.inline.hpp"
#include "utilities/hashtable.hpp"
class DictionaryEntry;
class PSPromotionManager;
+class ProtectionDomainCacheTable;
+class ProtectionDomainCacheEntry;
+class BoolObjectClosure;
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// The data structure for the system dictionary (and the shared system
@@ -45,6 +48,8 @@
// pointer to the current hash table entry.
static DictionaryEntry* _current_class_entry;
+ ProtectionDomainCacheTable* _pd_cache_table;
+
DictionaryEntry* get_entry(int index, unsigned int hash,
Symbol* name, ClassLoaderData* loader_data);
@@ -93,6 +98,7 @@
void methods_do(void f(Method*));
+ void unlink(BoolObjectClosure* is_alive);
// Classes loaded by the bootstrap loader are always strongly reachable.
// If we're not doing class unloading, all classes are strongly reachable.
@@ -118,6 +124,7 @@
// Sharing support
void reorder_dictionary();
+ ProtectionDomainCacheEntry* cache_get(oop protection_domain);
#ifndef PRODUCT
void print();
@@ -126,21 +133,112 @@
};
// The following classes can be in dictionary.cpp, but we need these
-// to be in header file so that SA's vmStructs can access.
+// to be in header file so that SA's vmStructs can access them.
+class ProtectionDomainCacheEntry : public HashtableEntry<oop, mtClass> {
+ friend class VMStructs;
+ private:
+ // Flag indicating whether this protection domain entry is strongly reachable.
+ // Used during iterating over the system dictionary to remember oops that need
+ // to be updated.
+ bool _strongly_reachable;
+ public:
+ oop protection_domain() { return literal(); }
+
+ void init() {
+ _strongly_reachable = false;
+ }
+
+ ProtectionDomainCacheEntry* next() {
+ return (ProtectionDomainCacheEntry*)HashtableEntry<oop, mtClass>::next();
+ }
+
+ ProtectionDomainCacheEntry** next_addr() {
+ return (ProtectionDomainCacheEntry**)HashtableEntry<oop, mtClass>::next_addr();
+ }
+
+ void oops_do(OopClosure* f) {
+ f->do_oop(literal_addr());
+ }
+
+ void set_strongly_reachable() { _strongly_reachable = true; }
+ bool is_strongly_reachable() { return _strongly_reachable; }
+ void reset_strongly_reachable() { _strongly_reachable = false; }
+
+ void print() PRODUCT_RETURN;
+ void verify();
+};
+
+// The ProtectionDomainCacheTable contains all protection domain oops. The system
+// dictionary entries reference its entries instead of having references to oops
+// directly.
+// This is used to speed up system dictionary iteration: the oops in the
+// protection domain are the only ones referring the Java heap. So when there is
+// need to update these, instead of going over every entry of the system dictionary,
+// we only need to iterate over this set.
+// The amount of different protection domains used is typically magnitudes smaller
+// than the number of system dictionary entries (loaded classes).
+class ProtectionDomainCacheTable : public Hashtable<oop, mtClass> {
+ friend class VMStructs;
+private:
+ ProtectionDomainCacheEntry* bucket(int i) {
+ return (ProtectionDomainCacheEntry*) Hashtable<oop, mtClass>::bucket(i);
+ }
+
+ // The following method is not MT-safe and must be done under lock.
+ ProtectionDomainCacheEntry** bucket_addr(int i) {
+ return (ProtectionDomainCacheEntry**) Hashtable<oop, mtClass>::bucket_addr(i);
+ }
+
+ ProtectionDomainCacheEntry* new_entry(unsigned int hash, oop protection_domain) {
+ ProtectionDomainCacheEntry* entry = (ProtectionDomainCacheEntry*) Hashtable<oop, mtClass>::new_entry(hash, protection_domain);
+ entry->init();
+ return entry;
+ }
+
+ static unsigned int compute_hash(oop protection_domain) {
+ return (unsigned int)(protection_domain->identity_hash());
+ }
+
+ int index_for(oop protection_domain) {
+ return hash_to_index(compute_hash(protection_domain));
+ }
+
+ ProtectionDomainCacheEntry* add_entry(int index, unsigned int hash, oop protection_domain);
+ ProtectionDomainCacheEntry* find_entry(int index, oop protection_domain);
+
+public:
+
+ ProtectionDomainCacheTable(int table_size);
+
+ ProtectionDomainCacheEntry* get(oop protection_domain);
+ void free(ProtectionDomainCacheEntry* entry);
+
+ void unlink(BoolObjectClosure* cl);
+
+ // GC support
+ void oops_do(OopClosure* f);
+ void always_strong_oops_do(OopClosure* f);
+
+ static uint bucket_size();
+
+ void print() PRODUCT_RETURN;
+ void verify();
+};
+
class ProtectionDomainEntry :public CHeapObj<mtClass> {
friend class VMStructs;
public:
ProtectionDomainEntry* _next;
- oop _protection_domain;
+ ProtectionDomainCacheEntry* _pd_cache;
- ProtectionDomainEntry(oop protection_domain, ProtectionDomainEntry* next) {
- _protection_domain = protection_domain;
- _next = next;
+ ProtectionDomainEntry(ProtectionDomainCacheEntry* pd_cache, ProtectionDomainEntry* next) {
+ _pd_cache = pd_cache;
+ _next = next;
}
ProtectionDomainEntry* next() { return _next; }
- oop protection_domain() { return _protection_domain; }
+ oop protection_domain() { return _pd_cache->protection_domain(); }
};
// An entry in the system dictionary, this describes a class as
@@ -151,6 +249,24 @@
private:
// Contains the set of approved protection domains that can access
// this system dictionary entry.
+ //
+ // This protection domain set is a set of tuples:
+ //
+ // (InstanceKlass C, initiating class loader ICL, Protection Domain PD)
+ //
+ // [Note that C.protection_domain(), which is stored in the java.lang.Class
+ // mirror of C, is NOT the same as PD]
+ //
+ // If such an entry (C, ICL, PD) exists in the table, it means that
+ // it is okay for a class Foo to reference C, where
+ //
+ // Foo.protection_domain() == PD, and
+ // Foo's defining class loader == ICL
+ //
+ // The usage of the PD set can be seen in SystemDictionary::validate_protection_domain()
+ // It is essentially a cache to avoid repeated Java up-calls to
+ // ClassLoader.checkPackageAccess().
+ //
ProtectionDomainEntry* _pd_set;
ClassLoaderData* _loader_data;
@@ -158,7 +274,7 @@
// Tells whether a protection is in the approved set.
bool contains_protection_domain(oop protection_domain) const;
// Adds a protection domain to the approved set.
- void add_protection_domain(oop protection_domain);
+ void add_protection_domain(Dictionary* dict, oop protection_domain);
Klass* klass() const { return (Klass*)literal(); }
Klass** klass_addr() { return (Klass**)literal_addr(); }
@@ -189,12 +305,11 @@
: contains_protection_domain(protection_domain());
}
-
- void protection_domain_set_oops_do(OopClosure* f) {
+ void set_strongly_reachable() {
for (ProtectionDomainEntry* current = _pd_set;
current != NULL;
current = current->_next) {
- f->do_oop(&(current->_protection_domain));
+ current->_pd_cache->set_strongly_reachable();
}
}
@@ -202,7 +317,7 @@
for (ProtectionDomainEntry* current = _pd_set;
current != NULL;
current = current->_next) {
- current->_protection_domain->verify();
+ current->_pd_cache->protection_domain()->verify();
}
}
--- a/hotspot/src/share/vm/classfile/javaClasses.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/javaClasses.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1376,8 +1376,15 @@
const char* klass_name = holder->external_name();
int buf_len = (int)strlen(klass_name);
- // pushing to the stack trace added one.
+ // The method id may point to an obsolete method, can't get more stack information
Method* method = holder->method_with_idnum(method_id);
+ if (method == NULL) {
+ char* buf = NEW_RESOURCE_ARRAY(char, buf_len + 64);
+ // This is what the java code prints in this case - added Redefined
+ sprintf(buf, "\tat %s.null (Redefined)", klass_name);
+ return buf;
+ }
+
char* method_name = method->name()->as_C_string();
buf_len += (int)strlen(method_name);
@@ -1773,7 +1780,8 @@
return element;
}
-oop java_lang_StackTraceElement::create(Handle mirror, int method_id, int version, int bci, TRAPS) {
+oop java_lang_StackTraceElement::create(Handle mirror, int method_id,
+ int version, int bci, TRAPS) {
// Allocate java.lang.StackTraceElement instance
Klass* k = SystemDictionary::StackTraceElement_klass();
assert(k != NULL, "must be loaded in 1.4+");
@@ -1790,8 +1798,16 @@
oop classname = StringTable::intern((char*) str, CHECK_0);
java_lang_StackTraceElement::set_declaringClass(element(), classname);
+ Method* method = holder->method_with_idnum(method_id);
+ // Method on stack may be obsolete because it was redefined so cannot be
+ // found by idnum.
+ if (method == NULL) {
+ // leave name and fileName null
+ java_lang_StackTraceElement::set_lineNumber(element(), -1);
+ return element();
+ }
+
// Fill in method name
- Method* method = holder->method_with_idnum(method_id);
oop methodname = StringTable::intern(method->name(), CHECK_0);
java_lang_StackTraceElement::set_methodName(element(), methodname);
--- a/hotspot/src/share/vm/classfile/symbolTable.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/symbolTable.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -107,18 +107,13 @@
add(loader_data, cp, names_count, name, lengths, cp_indices, hashValues, THREAD);
}
- // Table size
- enum {
- symbol_table_size = 20011
- };
-
Symbol* lookup(int index, const char* name, int len, unsigned int hash);
SymbolTable()
- : Hashtable<Symbol*, mtSymbol>(symbol_table_size, sizeof (HashtableEntry<Symbol*, mtSymbol>)) {}
+ : Hashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>)) {}
SymbolTable(HashtableBucket<mtSymbol>* t, int number_of_entries)
- : Hashtable<Symbol*, mtSymbol>(symbol_table_size, sizeof (HashtableEntry<Symbol*, mtSymbol>), t,
+ : Hashtable<Symbol*, mtSymbol>(SymbolTableSize, sizeof (HashtableEntry<Symbol*, mtSymbol>), t,
number_of_entries) {}
// Arena for permanent symbols (null class loader) that are never unloaded
@@ -136,6 +131,9 @@
// The symbol table
static SymbolTable* the_table() { return _the_table; }
+ // Size of one bucket in the string table. Used when checking for rollover.
+ static uint bucket_size() { return sizeof(HashtableBucket<mtSymbol>); }
+
static void create_table() {
assert(_the_table == NULL, "One symbol table allowed.");
_the_table = new SymbolTable();
@@ -145,8 +143,11 @@
static void create_table(HashtableBucket<mtSymbol>* t, int length,
int number_of_entries) {
assert(_the_table == NULL, "One symbol table allowed.");
- assert(length == symbol_table_size * sizeof(HashtableBucket<mtSymbol>),
- "bad shared symbol size.");
+
+ // If CDS archive used a different symbol table size, use that size instead
+ // which is better than giving an error.
+ SymbolTableSize = length/bucket_size();
+
_the_table = new SymbolTable(t, number_of_entries);
// if CDS give symbol table a default arena size since most symbols
// are already allocated in the shared misc section.
--- a/hotspot/src/share/vm/classfile/systemDictionary.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/systemDictionary.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1697,6 +1697,24 @@
return newsize;
}
+#ifdef ASSERT
+class VerifySDReachableAndLiveClosure : public OopClosure {
+private:
+ BoolObjectClosure* _is_alive;
+
+ template <class T> void do_oop_work(T* p) {
+ oop obj = oopDesc::load_decode_heap_oop(p);
+ guarantee(_is_alive->do_object_b(obj), "Oop in system dictionary must be live");
+ }
+
+public:
+ VerifySDReachableAndLiveClosure(BoolObjectClosure* is_alive) : OopClosure(), _is_alive(is_alive) { }
+
+ virtual void do_oop(oop* p) { do_oop_work(p); }
+ virtual void do_oop(narrowOop* p) { do_oop_work(p); }
+};
+#endif
+
// Assumes classes in the SystemDictionary are only unloaded at a safepoint
// Note: anonymous classes are not in the SD.
bool SystemDictionary::do_unloading(BoolObjectClosure* is_alive) {
@@ -1707,7 +1725,15 @@
unloading_occurred = dictionary()->do_unloading();
constraints()->purge_loader_constraints();
resolution_errors()->purge_resolution_errors();
-}
+ }
+ // Oops referenced by the system dictionary may get unreachable independently
+ // of the class loader (eg. cached protection domain oops). So we need to
+ // explicitly unlink them here instead of in Dictionary::do_unloading.
+ dictionary()->unlink(is_alive);
+#ifdef ASSERT
+ VerifySDReachableAndLiveClosure cl(is_alive);
+ dictionary()->oops_do(&cl);
+#endif
return unloading_occurred;
}
--- a/hotspot/src/share/vm/classfile/verifier.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/classfile/verifier.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -2442,10 +2442,16 @@
bool subtype = ref_class_type.is_assignable_from(
current_type(), this, CHECK_VERIFY(this));
if (!subtype) {
- verify_error(ErrorContext::bad_code(bci),
- "Bad invokespecial instruction: "
- "current class isn't assignable to reference class.");
- return;
+ if (current_class()->is_anonymous()) {
+ subtype = ref_class_type.is_assignable_from(VerificationType::reference_type(
+ current_class()->host_klass()->name()), this, CHECK_VERIFY(this));
+ }
+ if (!subtype) {
+ verify_error(ErrorContext::bad_code(bci),
+ "Bad invokespecial instruction: "
+ "current class isn't assignable to reference class.");
+ return;
+ }
}
}
// Match method descriptor with operand stack
@@ -2461,7 +2467,28 @@
} else { // other methods
// Ensures that target class is assignable to method class.
if (opcode == Bytecodes::_invokespecial) {
- current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
+ if (!current_class()->is_anonymous()) {
+ current_frame->pop_stack(current_type(), CHECK_VERIFY(this));
+ } else {
+ // anonymous class invokespecial calls: either the
+ // operand stack/objectref is a subtype of the current class OR
+ // the objectref is a subtype of the host_klass of the current class
+ // to allow an anonymous class to reference methods in the host_klass
+ VerificationType top = current_frame->pop_stack(CHECK_VERIFY(this));
+ bool subtype = current_type().is_assignable_from(top, this, CHECK_VERIFY(this));
+ if (!subtype) {
+ VerificationType hosttype =
+ VerificationType::reference_type(current_class()->host_klass()->name());
+ subtype = hosttype.is_assignable_from(top, this, CHECK_VERIFY(this));
+ }
+ if (!subtype) {
+ verify_error( ErrorContext::bad_type(current_frame->offset(),
+ current_frame->stack_top_ctx(),
+ TypeOrigin::implicit(top)),
+ "Bad type on operand stack");
+ return;
+ }
+ }
} else if (opcode == Bytecodes::_invokevirtual) {
VerificationType stack_object_type =
current_frame->pop_stack(ref_class_type, CHECK_VERIFY(this));
--- a/hotspot/src/share/vm/code/dependencies.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/code/dependencies.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2005, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 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
@@ -812,8 +812,8 @@
Klass* k = ctxk;
Method* lm = k->lookup_method(m->name(), m->signature());
if (lm == NULL && k->oop_is_instance()) {
- // It might be an abstract interface method, devoid of mirandas.
- lm = ((InstanceKlass*)k)->lookup_method_in_all_interfaces(m->name(),
+ // It might be an interface method
+ lm = ((InstanceKlass*)k)->lookup_method_in_ordered_interfaces(m->name(),
m->signature());
}
if (lm == m)
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -6035,7 +6035,11 @@
// is dirty.
G1SATBCardTableModRefBS* ct_bs = g1_barrier_set();
MemRegion mr(hr->bottom(), hr->pre_dummy_top());
- ct_bs->verify_dirty_region(mr);
+ if (hr->is_young()) {
+ ct_bs->verify_g1_young_region(mr);
+ } else {
+ ct_bs->verify_dirty_region(mr);
+ }
}
void G1CollectedHeap::verify_dirty_young_list(HeapRegion* head) {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectedHeap.inline.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -29,6 +29,7 @@
#include "gc_implementation/g1/g1CollectedHeap.hpp"
#include "gc_implementation/g1/g1AllocRegion.inline.hpp"
#include "gc_implementation/g1/g1CollectorPolicy.hpp"
+#include "gc_implementation/g1/g1SATBCardTableModRefBS.hpp"
#include "gc_implementation/g1/heapRegionSeq.inline.hpp"
#include "utilities/taskqueue.hpp"
@@ -134,7 +135,7 @@
assert(containing_hr->is_in(end - 1), "it should also contain end - 1");
MemRegion mr(start, end);
- g1_barrier_set()->dirty(mr);
+ g1_barrier_set()->g1_mark_as_young(mr);
}
inline RefToScanQueue* G1CollectedHeap::task_queue(int i) const {
--- a/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1CollectorPolicy.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -319,10 +319,10 @@
}
void G1CollectorPolicy::initialize_flags() {
- set_min_alignment(HeapRegion::GrainBytes);
+ _min_alignment = HeapRegion::GrainBytes;
size_t card_table_alignment = GenRemSet::max_alignment_constraint(rem_set_name());
size_t page_size = UseLargePages ? os::large_page_size() : os::vm_page_size();
- set_max_alignment(MAX3(card_table_alignment, min_alignment(), page_size));
+ _max_alignment = MAX3(card_table_alignment, _min_alignment, page_size);
if (SurvivorRatio < 1) {
vm_exit_during_initialization("Invalid survivor ratio specified");
}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -70,6 +70,12 @@
if ((val & (clean_card_mask_val() | deferred_card_val())) == deferred_card_val()) {
return false;
}
+
+ if (val == g1_young_gen) {
+ // the card is for a young gen region. We don't need to keep track of all pointers into young
+ return false;
+ }
+
// Cached bit can be installed either on a clean card or on a claimed card.
jbyte new_val = val;
if (val == clean_card_val()) {
@@ -85,6 +91,19 @@
return true;
}
+void G1SATBCardTableModRefBS::g1_mark_as_young(const MemRegion& mr) {
+ jbyte *const first = byte_for(mr.start());
+ jbyte *const last = byte_after(mr.last());
+
+ memset(first, g1_young_gen, last - first);
+}
+
+#ifndef PRODUCT
+void G1SATBCardTableModRefBS::verify_g1_young_region(MemRegion mr) {
+ verify_region(mr, g1_young_gen, true);
+}
+#endif
+
G1SATBCardTableLoggingModRefBS::
G1SATBCardTableLoggingModRefBS(MemRegion whole_heap,
int max_covered_regions) :
@@ -97,7 +116,11 @@
void
G1SATBCardTableLoggingModRefBS::write_ref_field_work(void* field,
oop new_val) {
- jbyte* byte = byte_for(field);
+ volatile jbyte* byte = byte_for(field);
+ if (*byte == g1_young_gen) {
+ return;
+ }
+ OrderAccess::storeload();
if (*byte != dirty_card) {
*byte = dirty_card;
Thread* thr = Thread::current();
@@ -129,7 +152,7 @@
void
G1SATBCardTableLoggingModRefBS::invalidate(MemRegion mr, bool whole_heap) {
- jbyte* byte = byte_for(mr.start());
+ volatile jbyte* byte = byte_for(mr.start());
jbyte* last_byte = byte_for(mr.last());
Thread* thr = Thread::current();
if (whole_heap) {
@@ -138,25 +161,35 @@
byte++;
}
} else {
- // Enqueue if necessary.
- if (thr->is_Java_thread()) {
- JavaThread* jt = (JavaThread*)thr;
- while (byte <= last_byte) {
- if (*byte != dirty_card) {
- *byte = dirty_card;
- jt->dirty_card_queue().enqueue(byte);
+ // skip all consecutive young cards
+ for (; byte <= last_byte && *byte == g1_young_gen; byte++);
+
+ if (byte <= last_byte) {
+ OrderAccess::storeload();
+ // Enqueue if necessary.
+ if (thr->is_Java_thread()) {
+ JavaThread* jt = (JavaThread*)thr;
+ for (; byte <= last_byte; byte++) {
+ if (*byte == g1_young_gen) {
+ continue;
+ }
+ if (*byte != dirty_card) {
+ *byte = dirty_card;
+ jt->dirty_card_queue().enqueue(byte);
+ }
}
- byte++;
- }
- } else {
- MutexLockerEx x(Shared_DirtyCardQ_lock,
- Mutex::_no_safepoint_check_flag);
- while (byte <= last_byte) {
- if (*byte != dirty_card) {
- *byte = dirty_card;
- _dcqs.shared_dirty_card_queue()->enqueue(byte);
+ } else {
+ MutexLockerEx x(Shared_DirtyCardQ_lock,
+ Mutex::_no_safepoint_check_flag);
+ for (; byte <= last_byte; byte++) {
+ if (*byte == g1_young_gen) {
+ continue;
+ }
+ if (*byte != dirty_card) {
+ *byte = dirty_card;
+ _dcqs.shared_dirty_card_queue()->enqueue(byte);
+ }
}
- byte++;
}
}
}
--- a/hotspot/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/g1SATBCardTableModRefBS.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -38,7 +38,14 @@
// snapshot-at-the-beginning marking.
class G1SATBCardTableModRefBS: public CardTableModRefBSForCTRS {
+protected:
+ enum G1CardValues {
+ g1_young_gen = CT_MR_BS_last_reserved << 1
+ };
+
public:
+ static int g1_young_card_val() { return g1_young_gen; }
+
// Add "pre_val" to a set of objects that may have been disconnected from the
// pre-marking object graph.
static void enqueue(oop pre_val);
@@ -118,6 +125,9 @@
_byte_map[card_index] = val;
}
+ void verify_g1_young_region(MemRegion mr) PRODUCT_RETURN;
+ void g1_mark_as_young(const MemRegion& mr);
+
bool mark_card_deferred(size_t card_index);
bool is_card_deferred(size_t card_index) {
--- a/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/g1/ptrQueue.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -80,6 +80,10 @@
void reset() { if (_buf != NULL) _index = _sz; }
+ void enqueue(volatile void* ptr) {
+ enqueue((void*)(ptr));
+ }
+
// Enqueues the given "obj".
void enqueue(void* ptr) {
if (!_active) return;
--- a/hotspot/src/share/vm/gc_implementation/shared/vmGCOperations.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_implementation/shared/vmGCOperations.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -214,9 +214,6 @@
: VM_GC_Operation(gc_count_before, gc_cause, full_gc_count_before, true),
_loader_data(loader_data), _size(size), _mdtype(mdtype), _result(NULL) {
}
- ~VM_CollectForMetadataAllocation() {
- MetaspaceGC::set_expand_after_GC(false);
- }
virtual VMOp_Type type() const { return VMOp_CollectForMetadataAllocation; }
virtual void doit();
MetaWord* result() const { return _result; }
--- a/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -202,12 +202,6 @@
ShouldNotReachHere(); // Unexpected use of this function
}
}
-MetaWord* CollectedHeap::satisfy_failed_metadata_allocation(
- ClassLoaderData* loader_data,
- size_t size, Metaspace::MetadataType mdtype) {
- return collector_policy()->satisfy_failed_metadata_allocation(loader_data, size, mdtype);
-}
-
void CollectedHeap::pre_initialize() {
// Used for ReduceInitialCardMarks (when COMPILER2 is used);
--- a/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/gc_interface/collectedHeap.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -475,11 +475,6 @@
// the context of the vm thread.
virtual void collect_as_vm_thread(GCCause::Cause cause);
- // Callback from VM_CollectForMetadataAllocation operation.
- MetaWord* satisfy_failed_metadata_allocation(ClassLoaderData* loader_data,
- size_t size,
- Metaspace::MetadataType mdtype);
-
// Returns the barrier set for this heap
BarrierSet* barrier_set() { return _barrier_set; }
--- a/hotspot/src/share/vm/interpreter/linkResolver.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/interpreter/linkResolver.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1,4 +1,5 @@
/*
+ * Copyright (c) 1997, 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
@@ -221,8 +222,17 @@
//
// According to JVM spec. $5.4.3c & $5.4.3d
+// Look up method in klasses, including static methods
+// Then look up local default methods
void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
Method* result_oop = klass->uncached_lookup_method(name, signature);
+ if (result_oop == NULL) {
+ Array<Method*>* default_methods = InstanceKlass::cast(klass())->default_methods();
+ if (default_methods != NULL) {
+ result_oop = InstanceKlass::find_method(default_methods, name, signature);
+ }
+ }
+
if (EnableInvokeDynamic && result_oop != NULL) {
vmIntrinsics::ID iid = result_oop->intrinsic_id();
if (MethodHandles::is_signature_polymorphic(iid)) {
@@ -234,6 +244,7 @@
}
// returns first instance method
+// Looks up method in classes, then looks up local default methods
void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
Method* result_oop = klass->uncached_lookup_method(name, signature);
result = methodHandle(THREAD, result_oop);
@@ -241,13 +252,38 @@
klass = KlassHandle(THREAD, result->method_holder()->super());
result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature));
}
+
+ if (result.is_null()) {
+ Array<Method*>* default_methods = InstanceKlass::cast(klass())->default_methods();
+ if (default_methods != NULL) {
+ result = methodHandle(InstanceKlass::find_method(default_methods, name, signature));
+ assert(result.is_null() || !result->is_static(), "static defaults not allowed");
+ }
+ }
}
+int LinkResolver::vtable_index_of_interface_method(KlassHandle klass,
+ methodHandle resolved_method, TRAPS) {
-int LinkResolver::vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
- ResourceMark rm(THREAD);
- klassVtable *vt = InstanceKlass::cast(klass())->vtable();
- return vt->index_of_miranda(name, signature);
+ int vtable_index = Method::invalid_vtable_index;
+ Symbol* name = resolved_method->name();
+ Symbol* signature = resolved_method->signature();
+
+ // First check in default method array
+ if (!resolved_method->is_abstract() &&
+ (InstanceKlass::cast(klass())->default_methods() != NULL)) {
+ int index = InstanceKlass::find_method_index(InstanceKlass::cast(klass())->default_methods(), name, signature);
+ if (index >= 0 ) {
+ vtable_index = InstanceKlass::cast(klass())->default_vtable_indices()->at(index);
+ }
+ }
+ if (vtable_index == Method::invalid_vtable_index) {
+ // get vtable_index for miranda methods
+ ResourceMark rm(THREAD);
+ klassVtable *vt = InstanceKlass::cast(klass())->vtable();
+ vtable_index = vt->index_of_miranda(name, signature);
+ }
+ return vtable_index;
}
void LinkResolver::lookup_method_in_interfaces(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
@@ -625,6 +661,12 @@
resolved_method->method_holder()->internal_name()
);
resolved_method->access_flags().print_on(tty);
+ if (resolved_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (resolved_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->cr();
}
}
@@ -853,6 +895,7 @@
resolved_method->signature()));
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
+
if (TraceItables && Verbose) {
ResourceMark rm(THREAD);
tty->print("invokespecial resolved method: caller-class:%s, compile-time-class:%s, method:%s, method_holder:%s, access_flags: ",
@@ -864,8 +907,7 @@
resolved_method->method_holder()->internal_name()
);
resolved_method->access_flags().print_on(tty);
- if (resolved_method->method_holder()->is_interface() &&
- !resolved_method->is_abstract()) {
+ if (resolved_method->is_default_method()) {
tty->print("default");
}
if (resolved_method->is_overpass()) {
@@ -945,10 +987,12 @@
sel_method->method_holder()->internal_name()
);
sel_method->access_flags().print_on(tty);
- if (sel_method->method_holder()->is_interface() &&
- !sel_method->is_abstract()) {
+ if (sel_method->is_default_method()) {
tty->print("default");
}
+ if (sel_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->cr();
}
@@ -996,26 +1040,25 @@
THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
}
- if (PrintVtables && Verbose) {
- ResourceMark rm(THREAD);
- tty->print("invokevirtual resolved method: caller-class:%s, compile-time-class:%s, method:%s, method_holder:%s, access_flags: ",
- (current_klass.is_null() ? "<NULL>" : current_klass->internal_name()),
- (resolved_klass.is_null() ? "<NULL>" : resolved_klass->internal_name()),
- Method::name_and_sig_as_C_string(resolved_klass(),
- resolved_method->name(),
- resolved_method->signature()),
- resolved_method->method_holder()->internal_name()
- );
- resolved_method->access_flags().print_on(tty);
- if (resolved_method->method_holder()->is_interface() &&
- !resolved_method->is_abstract()) {
- tty->print("default");
- }
- if (resolved_method->is_overpass()) {
- tty->print("overpass");
- }
- tty->cr();
- }
+ if (PrintVtables && Verbose) {
+ ResourceMark rm(THREAD);
+ tty->print("invokevirtual resolved method: caller-class:%s, compile-time-class:%s, method:%s, method_holder:%s, access_flags: ",
+ (current_klass.is_null() ? "<NULL>" : current_klass->internal_name()),
+ (resolved_klass.is_null() ? "<NULL>" : resolved_klass->internal_name()),
+ Method::name_and_sig_as_C_string(resolved_klass(),
+ resolved_method->name(),
+ resolved_method->signature()),
+ resolved_method->method_holder()->internal_name()
+ );
+ resolved_method->access_flags().print_on(tty);
+ if (resolved_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (resolved_method->is_overpass()) {
+ tty->print("overpass");
+ }
+ tty->cr();
+ }
}
// throws runtime exceptions
@@ -1045,10 +1088,8 @@
// do lookup based on receiver klass using the vtable index
if (resolved_method->method_holder()->is_interface()) { // miranda method
- vtable_index = vtable_index_of_miranda_method(resolved_klass,
- resolved_method->name(),
- resolved_method->signature(), CHECK);
-
+ vtable_index = vtable_index_of_interface_method(resolved_klass,
+ resolved_method, CHECK);
assert(vtable_index >= 0 , "we should have valid vtable index at this point");
InstanceKlass* inst = InstanceKlass::cast(recv_klass());
@@ -1104,11 +1145,10 @@
vtable_index
);
selected_method->access_flags().print_on(tty);
- if (selected_method->method_holder()->is_interface() &&
- !selected_method->is_abstract()) {
+ if (selected_method->is_default_method()) {
tty->print("default");
}
- if (resolved_method->is_overpass()) {
+ if (selected_method->is_overpass()) {
tty->print("overpass");
}
tty->cr();
@@ -1191,7 +1231,6 @@
sel_method->name(),
sel_method->signature()));
}
-
// check if abstract
if (check_null_and_abstract && sel_method->is_abstract()) {
ResourceMark rm(THREAD);
@@ -1220,11 +1259,10 @@
sel_method->method_holder()->internal_name()
);
sel_method->access_flags().print_on(tty);
- if (sel_method->method_holder()->is_interface() &&
- !sel_method->is_abstract()) {
+ if (sel_method->is_default_method()) {
tty->print("default");
}
- if (resolved_method->is_overpass()) {
+ if (sel_method->is_overpass()) {
tty->print("overpass");
}
tty->cr();
--- a/hotspot/src/share/vm/interpreter/linkResolver.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/interpreter/linkResolver.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -130,8 +130,7 @@
static void lookup_polymorphic_method (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature,
KlassHandle current_klass, Handle *appendix_result_or_null, Handle *method_type_result, TRAPS);
- static int vtable_index_of_miranda_method(KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
-
+ static int vtable_index_of_interface_method(KlassHandle klass, methodHandle resolved_method, TRAPS);
static void resolve_klass (KlassHandle& result, constantPoolHandle pool, int index, TRAPS);
static void resolve_pool (KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS);
--- a/hotspot/src/share/vm/memory/collectorPolicy.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -47,85 +47,53 @@
// CollectorPolicy methods.
-// Align down. If the aligning result in 0, return 'alignment'.
-static size_t restricted_align_down(size_t size, size_t alignment) {
- return MAX2(alignment, align_size_down_(size, alignment));
-}
-
void CollectorPolicy::initialize_flags() {
- assert(max_alignment() >= min_alignment(),
- err_msg("max_alignment: " SIZE_FORMAT " less than min_alignment: " SIZE_FORMAT,
- max_alignment(), min_alignment()));
- assert(max_alignment() % min_alignment() == 0,
- err_msg("max_alignment: " SIZE_FORMAT " not aligned by min_alignment: " SIZE_FORMAT,
- max_alignment(), min_alignment()));
+ assert(_max_alignment >= _min_alignment,
+ err_msg("max_alignment: " SIZE_FORMAT " less than min_alignment: " SIZE_FORMAT,
+ _max_alignment, _min_alignment));
+ assert(_max_alignment % _min_alignment == 0,
+ err_msg("max_alignment: " SIZE_FORMAT " not aligned by min_alignment: " SIZE_FORMAT,
+ _max_alignment, _min_alignment));
if (MaxHeapSize < InitialHeapSize) {
vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
}
- // Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
- // override if MaxMetaspaceSize was set on the command line or not.
- // This information is needed later to conform to the specification of the
- // java.lang.management.MemoryUsage API.
- //
- // Ideally, we would be able to set the default value of MaxMetaspaceSize in
- // globals.hpp to the aligned value, but this is not possible, since the
- // alignment depends on other flags being parsed.
- MaxMetaspaceSize = restricted_align_down(MaxMetaspaceSize, max_alignment());
-
- if (MetaspaceSize > MaxMetaspaceSize) {
- MetaspaceSize = MaxMetaspaceSize;
- }
-
- MetaspaceSize = restricted_align_down(MetaspaceSize, min_alignment());
-
- assert(MetaspaceSize <= MaxMetaspaceSize, "Must be");
-
- MinMetaspaceExpansion = restricted_align_down(MinMetaspaceExpansion, min_alignment());
- MaxMetaspaceExpansion = restricted_align_down(MaxMetaspaceExpansion, min_alignment());
-
- MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, min_alignment());
-
- assert(MetaspaceSize % min_alignment() == 0, "metapace alignment");
- assert(MaxMetaspaceSize % max_alignment() == 0, "maximum metaspace alignment");
- if (MetaspaceSize < 256*K) {
- vm_exit_during_initialization("Too small initial Metaspace size");
- }
+ MinHeapDeltaBytes = align_size_up(MinHeapDeltaBytes, _min_alignment);
}
void CollectorPolicy::initialize_size_info() {
// User inputs from -mx and ms must be aligned
- set_min_heap_byte_size(align_size_up(Arguments::min_heap_size(), min_alignment()));
- set_initial_heap_byte_size(align_size_up(InitialHeapSize, min_alignment()));
- set_max_heap_byte_size(align_size_up(MaxHeapSize, max_alignment()));
+ _min_heap_byte_size = align_size_up(Arguments::min_heap_size(), _min_alignment);
+ _initial_heap_byte_size = align_size_up(InitialHeapSize, _min_alignment);
+ _max_heap_byte_size = align_size_up(MaxHeapSize, _max_alignment);
// Check heap parameter properties
- if (initial_heap_byte_size() < M) {
+ if (_initial_heap_byte_size < M) {
vm_exit_during_initialization("Too small initial heap");
}
// Check heap parameter properties
- if (min_heap_byte_size() < M) {
+ if (_min_heap_byte_size < M) {
vm_exit_during_initialization("Too small minimum heap");
}
- if (initial_heap_byte_size() <= NewSize) {
+ if (_initial_heap_byte_size <= NewSize) {
// make sure there is at least some room in old space
vm_exit_during_initialization("Too small initial heap for new size specified");
}
- if (max_heap_byte_size() < min_heap_byte_size()) {
+ if (_max_heap_byte_size < _min_heap_byte_size) {
vm_exit_during_initialization("Incompatible minimum and maximum heap sizes specified");
}
- if (initial_heap_byte_size() < min_heap_byte_size()) {
+ if (_initial_heap_byte_size < _min_heap_byte_size) {
vm_exit_during_initialization("Incompatible minimum and initial heap sizes specified");
}
- if (max_heap_byte_size() < initial_heap_byte_size()) {
+ if (_max_heap_byte_size < _initial_heap_byte_size) {
vm_exit_during_initialization("Incompatible initial and maximum heap sizes specified");
}
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Minimum heap " SIZE_FORMAT " Initial heap "
SIZE_FORMAT " Maximum heap " SIZE_FORMAT,
- min_heap_byte_size(), initial_heap_byte_size(), max_heap_byte_size());
+ _min_heap_byte_size, _initial_heap_byte_size, _max_heap_byte_size);
}
}
@@ -180,15 +148,15 @@
size_t GenCollectorPolicy::scale_by_NewRatio_aligned(size_t base_size) {
size_t x = base_size / (NewRatio+1);
- size_t new_gen_size = x > min_alignment() ?
- align_size_down(x, min_alignment()) :
- min_alignment();
+ size_t new_gen_size = x > _min_alignment ?
+ align_size_down(x, _min_alignment) :
+ _min_alignment;
return new_gen_size;
}
size_t GenCollectorPolicy::bound_minus_alignment(size_t desired_size,
size_t maximum_size) {
- size_t alignment = min_alignment();
+ size_t alignment = _min_alignment;
size_t max_minus = maximum_size - alignment;
return desired_size < max_minus ? desired_size : max_minus;
}
@@ -207,8 +175,8 @@
void GenCollectorPolicy::initialize_flags() {
// All sizes must be multiples of the generation granularity.
- set_min_alignment((uintx) Generation::GenGrain);
- set_max_alignment(compute_max_alignment());
+ _min_alignment = (uintx) Generation::GenGrain;
+ _max_alignment = compute_max_alignment();
CollectorPolicy::initialize_flags();
@@ -218,26 +186,26 @@
if (NewSize > MaxNewSize) {
MaxNewSize = NewSize;
}
- NewSize = align_size_down(NewSize, min_alignment());
- MaxNewSize = align_size_down(MaxNewSize, min_alignment());
+ NewSize = align_size_down(NewSize, _min_alignment);
+ MaxNewSize = align_size_down(MaxNewSize, _min_alignment);
// Check validity of heap flags
- assert(NewSize % min_alignment() == 0, "eden space alignment");
- assert(MaxNewSize % min_alignment() == 0, "survivor space alignment");
+ assert(NewSize % _min_alignment == 0, "eden space alignment");
+ assert(MaxNewSize % _min_alignment == 0, "survivor space alignment");
- if (NewSize < 3*min_alignment()) {
+ if (NewSize < 3 * _min_alignment) {
// make sure there room for eden and two survivor spaces
vm_exit_during_initialization("Too small new size specified");
}
if (SurvivorRatio < 1 || NewRatio < 1) {
- vm_exit_during_initialization("Invalid heap ratio specified");
+ vm_exit_during_initialization("Invalid young gen ratio specified");
}
}
void TwoGenerationCollectorPolicy::initialize_flags() {
GenCollectorPolicy::initialize_flags();
- OldSize = align_size_down(OldSize, min_alignment());
+ OldSize = align_size_down(OldSize, _min_alignment);
if (FLAG_IS_CMDLINE(OldSize) && FLAG_IS_DEFAULT(NewSize)) {
// NewRatio will be used later to set the young generation size so we use
@@ -246,11 +214,11 @@
assert(NewRatio > 0, "NewRatio should have been set up earlier");
size_t calculated_heapsize = (OldSize / NewRatio) * (NewRatio + 1);
- calculated_heapsize = align_size_up(calculated_heapsize, max_alignment());
+ calculated_heapsize = align_size_up(calculated_heapsize, _max_alignment);
MaxHeapSize = calculated_heapsize;
InitialHeapSize = calculated_heapsize;
}
- MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
+ MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
// adjust max heap size if necessary
if (NewSize + OldSize > MaxHeapSize) {
@@ -260,18 +228,18 @@
uintx calculated_size = NewSize + OldSize;
double shrink_factor = (double) MaxHeapSize / calculated_size;
// align
- NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment());
+ NewSize = align_size_down((uintx) (NewSize * shrink_factor), _min_alignment);
// OldSize is already aligned because above we aligned MaxHeapSize to
- // max_alignment(), and we just made sure that NewSize is aligned to
- // min_alignment(). In initialize_flags() we verified that max_alignment()
- // is a multiple of min_alignment().
+ // _max_alignment, and we just made sure that NewSize is aligned to
+ // _min_alignment. In initialize_flags() we verified that _max_alignment
+ // is a multiple of _min_alignment.
OldSize = MaxHeapSize - NewSize;
} else {
MaxHeapSize = NewSize + OldSize;
}
}
// need to do this again
- MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
+ MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
// adjust max heap size if necessary
if (NewSize + OldSize > MaxHeapSize) {
@@ -281,24 +249,24 @@
uintx calculated_size = NewSize + OldSize;
double shrink_factor = (double) MaxHeapSize / calculated_size;
// align
- NewSize = align_size_down((uintx) (NewSize * shrink_factor), min_alignment());
+ NewSize = align_size_down((uintx) (NewSize * shrink_factor), _min_alignment);
// OldSize is already aligned because above we aligned MaxHeapSize to
- // max_alignment(), and we just made sure that NewSize is aligned to
- // min_alignment(). In initialize_flags() we verified that max_alignment()
- // is a multiple of min_alignment().
+ // _max_alignment, and we just made sure that NewSize is aligned to
+ // _min_alignment. In initialize_flags() we verified that _max_alignment
+ // is a multiple of _min_alignment.
OldSize = MaxHeapSize - NewSize;
} else {
MaxHeapSize = NewSize + OldSize;
}
}
// need to do this again
- MaxHeapSize = align_size_up(MaxHeapSize, max_alignment());
+ MaxHeapSize = align_size_up(MaxHeapSize, _max_alignment);
always_do_update_barrier = UseConcMarkSweepGC;
// Check validity of heap flags
- assert(OldSize % min_alignment() == 0, "old space alignment");
- assert(MaxHeapSize % max_alignment() == 0, "maximum heap alignment");
+ assert(OldSize % _min_alignment == 0, "old space alignment");
+ assert(MaxHeapSize % _max_alignment == 0, "maximum heap alignment");
}
// Values set on the command line win over any ergonomically
@@ -313,7 +281,7 @@
void GenCollectorPolicy::initialize_size_info() {
CollectorPolicy::initialize_size_info();
- // min_alignment() is used for alignment within a generation.
+ // _min_alignment is used for alignment within a generation.
// There is additional alignment done down stream for some
// collectors that sometimes causes unwanted rounding up of
// generations sizes.
@@ -322,18 +290,18 @@
size_t max_new_size = 0;
if (FLAG_IS_CMDLINE(MaxNewSize) || FLAG_IS_ERGO(MaxNewSize)) {
- if (MaxNewSize < min_alignment()) {
- max_new_size = min_alignment();
+ if (MaxNewSize < _min_alignment) {
+ max_new_size = _min_alignment;
}
- if (MaxNewSize >= max_heap_byte_size()) {
- max_new_size = align_size_down(max_heap_byte_size() - min_alignment(),
- min_alignment());
+ if (MaxNewSize >= _max_heap_byte_size) {
+ max_new_size = align_size_down(_max_heap_byte_size - _min_alignment,
+ _min_alignment);
warning("MaxNewSize (" SIZE_FORMAT "k) is equal to or "
"greater than the entire heap (" SIZE_FORMAT "k). A "
"new generation size of " SIZE_FORMAT "k will be used.",
- MaxNewSize/K, max_heap_byte_size()/K, max_new_size/K);
+ MaxNewSize/K, _max_heap_byte_size/K, max_new_size/K);
} else {
- max_new_size = align_size_down(MaxNewSize, min_alignment());
+ max_new_size = align_size_down(MaxNewSize, _min_alignment);
}
// The case for FLAG_IS_ERGO(MaxNewSize) could be treated
@@ -351,7 +319,7 @@
// just accept those choices. The choices currently made are
// not always "wise".
} else {
- max_new_size = scale_by_NewRatio_aligned(max_heap_byte_size());
+ max_new_size = scale_by_NewRatio_aligned(_max_heap_byte_size);
// Bound the maximum size by NewSize below (since it historically
// would have been NewSize and because the NewRatio calculation could
// yield a size that is too small) and bound it by MaxNewSize above.
@@ -364,13 +332,13 @@
// Given the maximum gen0 size, determine the initial and
// minimum gen0 sizes.
- if (max_heap_byte_size() == min_heap_byte_size()) {
+ if (_max_heap_byte_size == _min_heap_byte_size) {
// The maximum and minimum heap sizes are the same so
// the generations minimum and initial must be the
// same as its maximum.
- set_min_gen0_size(max_new_size);
- set_initial_gen0_size(max_new_size);
- set_max_gen0_size(max_new_size);
+ _min_gen0_size = max_new_size;
+ _initial_gen0_size = max_new_size;
+ _max_gen0_size = max_new_size;
} else {
size_t desired_new_size = 0;
if (!FLAG_IS_DEFAULT(NewSize)) {
@@ -391,43 +359,37 @@
// Use the default NewSize as the floor for these values. If
// NewRatio is overly large, the resulting sizes can be too
// small.
- _min_gen0_size = MAX2(scale_by_NewRatio_aligned(min_heap_byte_size()),
- NewSize);
+ _min_gen0_size = MAX2(scale_by_NewRatio_aligned(_min_heap_byte_size), NewSize);
desired_new_size =
- MAX2(scale_by_NewRatio_aligned(initial_heap_byte_size()),
- NewSize);
+ MAX2(scale_by_NewRatio_aligned(_initial_heap_byte_size), NewSize);
}
assert(_min_gen0_size > 0, "Sanity check");
- set_initial_gen0_size(desired_new_size);
- set_max_gen0_size(max_new_size);
+ _initial_gen0_size = desired_new_size;
+ _max_gen0_size = max_new_size;
// At this point the desirable initial and minimum sizes have been
// determined without regard to the maximum sizes.
// Bound the sizes by the corresponding overall heap sizes.
- set_min_gen0_size(
- bound_minus_alignment(_min_gen0_size, min_heap_byte_size()));
- set_initial_gen0_size(
- bound_minus_alignment(_initial_gen0_size, initial_heap_byte_size()));
- set_max_gen0_size(
- bound_minus_alignment(_max_gen0_size, max_heap_byte_size()));
+ _min_gen0_size = bound_minus_alignment(_min_gen0_size, _min_heap_byte_size);
+ _initial_gen0_size = bound_minus_alignment(_initial_gen0_size, _initial_heap_byte_size);
+ _max_gen0_size = bound_minus_alignment(_max_gen0_size, _max_heap_byte_size);
// At this point all three sizes have been checked against the
// maximum sizes but have not been checked for consistency
// among the three.
// Final check min <= initial <= max
- set_min_gen0_size(MIN2(_min_gen0_size, _max_gen0_size));
- set_initial_gen0_size(
- MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size));
- set_min_gen0_size(MIN2(_min_gen0_size, _initial_gen0_size));
+ _min_gen0_size = MIN2(_min_gen0_size, _max_gen0_size);
+ _initial_gen0_size = MAX2(MIN2(_initial_gen0_size, _max_gen0_size), _min_gen0_size);
+ _min_gen0_size = MIN2(_min_gen0_size, _initial_gen0_size);
}
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("1: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
- min_gen0_size(), initial_gen0_size(), max_gen0_size());
+ _min_gen0_size, _initial_gen0_size, _max_gen0_size);
}
}
@@ -447,19 +409,17 @@
if ((*gen1_size_ptr + *gen0_size_ptr) > heap_size) {
if ((heap_size < (*gen0_size_ptr + min_gen1_size)) &&
- (heap_size >= min_gen1_size + min_alignment())) {
+ (heap_size >= min_gen1_size + _min_alignment)) {
// Adjust gen0 down to accommodate min_gen1_size
*gen0_size_ptr = heap_size - min_gen1_size;
*gen0_size_ptr =
- MAX2((uintx)align_size_down(*gen0_size_ptr, min_alignment()),
- min_alignment());
+ MAX2((uintx)align_size_down(*gen0_size_ptr, _min_alignment), _min_alignment);
assert(*gen0_size_ptr > 0, "Min gen0 is too large");
result = true;
} else {
*gen1_size_ptr = heap_size - *gen0_size_ptr;
*gen1_size_ptr =
- MAX2((uintx)align_size_down(*gen1_size_ptr, min_alignment()),
- min_alignment());
+ MAX2((uintx)align_size_down(*gen1_size_ptr, _min_alignment), _min_alignment);
}
}
return result;
@@ -480,10 +440,9 @@
// The maximum gen1 size can be determined from the maximum gen0
// and maximum heap size since no explicit flags exits
// for setting the gen1 maximum.
- _max_gen1_size = max_heap_byte_size() - _max_gen0_size;
+ _max_gen1_size = _max_heap_byte_size - _max_gen0_size;
_max_gen1_size =
- MAX2((uintx)align_size_down(_max_gen1_size, min_alignment()),
- min_alignment());
+ MAX2((uintx)align_size_down(_max_gen1_size, _min_alignment), _min_alignment);
// If no explicit command line flag has been set for the
// gen1 size, use what is left for gen1.
if (FLAG_IS_DEFAULT(OldSize) || FLAG_IS_ERGO(OldSize)) {
@@ -492,70 +451,66 @@
// with the overall heap size). In either case make
// the minimum, maximum and initial sizes consistent
// with the gen0 sizes and the overall heap sizes.
- assert(min_heap_byte_size() > _min_gen0_size,
+ assert(_min_heap_byte_size > _min_gen0_size,
"gen0 has an unexpected minimum size");
- set_min_gen1_size(min_heap_byte_size() - min_gen0_size());
- set_min_gen1_size(
- MAX2((uintx)align_size_down(_min_gen1_size, min_alignment()),
- min_alignment()));
- set_initial_gen1_size(initial_heap_byte_size() - initial_gen0_size());
- set_initial_gen1_size(
- MAX2((uintx)align_size_down(_initial_gen1_size, min_alignment()),
- min_alignment()));
-
+ _min_gen1_size = _min_heap_byte_size - _min_gen0_size;
+ _min_gen1_size =
+ MAX2((uintx)align_size_down(_min_gen1_size, _min_alignment), _min_alignment);
+ _initial_gen1_size = _initial_heap_byte_size - _initial_gen0_size;
+ _initial_gen1_size =
+ MAX2((uintx)align_size_down(_initial_gen1_size, _min_alignment), _min_alignment);
} else {
// It's been explicitly set on the command line. Use the
// OldSize and then determine the consequences.
- set_min_gen1_size(OldSize);
- set_initial_gen1_size(OldSize);
+ _min_gen1_size = OldSize;
+ _initial_gen1_size = OldSize;
// If the user has explicitly set an OldSize that is inconsistent
// with other command line flags, issue a warning.
// The generation minimums and the overall heap mimimum should
// be within one heap alignment.
- if ((_min_gen1_size + _min_gen0_size + min_alignment()) <
- min_heap_byte_size()) {
+ if ((_min_gen1_size + _min_gen0_size + _min_alignment) < _min_heap_byte_size) {
warning("Inconsistency between minimum heap size and minimum "
- "generation sizes: using minimum heap = " SIZE_FORMAT,
- min_heap_byte_size());
+ "generation sizes: using minimum heap = " SIZE_FORMAT,
+ _min_heap_byte_size);
}
if ((OldSize > _max_gen1_size)) {
warning("Inconsistency between maximum heap size and maximum "
- "generation sizes: using maximum heap = " SIZE_FORMAT
- " -XX:OldSize flag is being ignored",
- max_heap_byte_size());
+ "generation sizes: using maximum heap = " SIZE_FORMAT
+ " -XX:OldSize flag is being ignored",
+ _max_heap_byte_size);
}
// If there is an inconsistency between the OldSize and the minimum and/or
// initial size of gen0, since OldSize was explicitly set, OldSize wins.
if (adjust_gen0_sizes(&_min_gen0_size, &_min_gen1_size,
- min_heap_byte_size(), OldSize)) {
+ _min_heap_byte_size, OldSize)) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("2: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
- min_gen0_size(), initial_gen0_size(), max_gen0_size());
+ _min_gen0_size, _initial_gen0_size, _max_gen0_size);
}
}
// Initial size
if (adjust_gen0_sizes(&_initial_gen0_size, &_initial_gen1_size,
- initial_heap_byte_size(), OldSize)) {
+ _initial_heap_byte_size, OldSize)) {
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("3: Minimum gen0 " SIZE_FORMAT " Initial gen0 "
SIZE_FORMAT " Maximum gen0 " SIZE_FORMAT,
- min_gen0_size(), initial_gen0_size(), max_gen0_size());
+ _min_gen0_size, _initial_gen0_size, _max_gen0_size);
}
}
}
// Enforce the maximum gen1 size.
- set_min_gen1_size(MIN2(_min_gen1_size, _max_gen1_size));
+ _min_gen1_size = MIN2(_min_gen1_size, _max_gen1_size);
// Check that min gen1 <= initial gen1 <= max gen1
- set_initial_gen1_size(MAX2(_initial_gen1_size, _min_gen1_size));
- set_initial_gen1_size(MIN2(_initial_gen1_size, _max_gen1_size));
+ _initial_gen1_size = MAX2(_initial_gen1_size, _min_gen1_size);
+ _initial_gen1_size = MIN2(_initial_gen1_size, _max_gen1_size);
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Minimum gen1 " SIZE_FORMAT " Initial gen1 "
SIZE_FORMAT " Maximum gen1 " SIZE_FORMAT,
- min_gen1_size(), initial_gen1_size(), max_gen1_size());
+ _min_gen1_size, _initial_gen1_size, _max_gen1_size);
}
}
--- a/hotspot/src/share/vm/memory/collectorPolicy.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/collectorPolicy.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -101,17 +101,12 @@
// Return maximum heap alignment that may be imposed by the policy
static size_t compute_max_alignment();
- void set_min_alignment(size_t align) { _min_alignment = align; }
size_t min_alignment() { return _min_alignment; }
- void set_max_alignment(size_t align) { _max_alignment = align; }
size_t max_alignment() { return _max_alignment; }
size_t initial_heap_byte_size() { return _initial_heap_byte_size; }
- void set_initial_heap_byte_size(size_t v) { _initial_heap_byte_size = v; }
size_t max_heap_byte_size() { return _max_heap_byte_size; }
- void set_max_heap_byte_size(size_t v) { _max_heap_byte_size = v; }
size_t min_heap_byte_size() { return _min_heap_byte_size; }
- void set_min_heap_byte_size(size_t v) { _min_heap_byte_size = v; }
enum Name {
CollectorPolicyKind,
@@ -248,12 +243,9 @@
public:
// Accessors
- size_t min_gen0_size() { return _min_gen0_size; }
- void set_min_gen0_size(size_t v) { _min_gen0_size = v; }
+ size_t min_gen0_size() { return _min_gen0_size; }
size_t initial_gen0_size() { return _initial_gen0_size; }
- void set_initial_gen0_size(size_t v) { _initial_gen0_size = v; }
- size_t max_gen0_size() { return _max_gen0_size; }
- void set_max_gen0_size(size_t v) { _max_gen0_size = v; }
+ size_t max_gen0_size() { return _max_gen0_size; }
virtual int number_of_generations() = 0;
@@ -302,12 +294,9 @@
public:
// Accessors
- size_t min_gen1_size() { return _min_gen1_size; }
- void set_min_gen1_size(size_t v) { _min_gen1_size = v; }
+ size_t min_gen1_size() { return _min_gen1_size; }
size_t initial_gen1_size() { return _initial_gen1_size; }
- void set_initial_gen1_size(size_t v) { _initial_gen1_size = v; }
- size_t max_gen1_size() { return _max_gen1_size; }
- void set_max_gen1_size(size_t v) { _max_gen1_size = v; }
+ size_t max_gen1_size() { return _max_gen1_size; }
// Inherited methods
TwoGenerationCollectorPolicy* as_two_generation_policy() { return this; }
--- a/hotspot/src/share/vm/memory/filemap.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/filemap.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -26,6 +26,7 @@
#define SHARE_VM_MEMORY_FILEMAP_HPP
#include "memory/metaspaceShared.hpp"
+#include "memory/metaspace.hpp"
// Layout of the file:
// header: dump of archive instance plus versioning info, datestamp, etc.
--- a/hotspot/src/share/vm/memory/heapInspection.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/heapInspection.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -73,6 +73,10 @@
"Number of bytes used by the InstanceKlass::methods() array") \
f(method_ordering_bytes, IK_method_ordering, \
"Number of bytes used by the InstanceKlass::method_ordering() array") \
+ f(default_methods_array_bytes, IK_default_methods, \
+ "Number of bytes used by the InstanceKlass::default_methods() array") \
+ f(default_vtable_indices_bytes, IK_default_vtable_indices, \
+ "Number of bytes used by the InstanceKlass::default_vtable_indices() array") \
f(local_interfaces_bytes, IK_local_interfaces, \
"Number of bytes used by the InstanceKlass::local_interfaces() array") \
f(transitive_interfaces_bytes, IK_transitive_interfaces, \
--- a/hotspot/src/share/vm/memory/metaspace.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -29,17 +29,21 @@
#include "memory/collectorPolicy.hpp"
#include "memory/filemap.hpp"
#include "memory/freeList.hpp"
+#include "memory/gcLocker.hpp"
#include "memory/metablock.hpp"
#include "memory/metachunk.hpp"
#include "memory/metaspace.hpp"
#include "memory/metaspaceShared.hpp"
#include "memory/resourceArea.hpp"
#include "memory/universe.hpp"
+#include "runtime/atomic.inline.hpp"
#include "runtime/globals.hpp"
+#include "runtime/init.hpp"
#include "runtime/java.hpp"
#include "runtime/mutex.hpp"
#include "runtime/orderAccess.hpp"
#include "services/memTracker.hpp"
+#include "services/memoryService.hpp"
#include "utilities/copy.hpp"
#include "utilities/debug.hpp"
@@ -84,13 +88,7 @@
return (ChunkIndex) (i+1);
}
-// Originally _capacity_until_GC was set to MetaspaceSize here but
-// the default MetaspaceSize before argument processing was being
-// used which was not the desired value. See the code
-// in should_expand() to see how the initialization is handled
-// now.
-size_t MetaspaceGC::_capacity_until_GC = 0;
-bool MetaspaceGC::_expand_after_GC = false;
+volatile intptr_t MetaspaceGC::_capacity_until_GC = 0;
uint MetaspaceGC::_shrink_factor = 0;
bool MetaspaceGC::_should_concurrent_collect = false;
@@ -293,9 +291,10 @@
MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; }
- size_t expanded_words() const { return _virtual_space.committed_size() / BytesPerWord; }
size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
+ bool is_pre_committed() const { return _virtual_space.special(); }
+
// address of next available space in _virtual_space;
// Accessors
VirtualSpaceNode* next() { return _next; }
@@ -337,7 +336,7 @@
// Expands/shrinks the committed space in a virtual space. Delegates
// to Virtualspace
- bool expand_by(size_t words, bool pre_touch = false);
+ bool expand_by(size_t min_words, size_t preferred_words);
// In preparation for deleting this node, remove all the chunks
// in the node from any freelist.
@@ -351,29 +350,64 @@
void print_on(outputStream* st) const;
};
+#define assert_is_ptr_aligned(ptr, alignment) \
+ assert(is_ptr_aligned(ptr, alignment), \
+ err_msg(PTR_FORMAT " is not aligned to " \
+ SIZE_FORMAT, ptr, alignment))
+
+#define assert_is_size_aligned(size, alignment) \
+ assert(is_size_aligned(size, alignment), \
+ err_msg(SIZE_FORMAT " is not aligned to " \
+ SIZE_FORMAT, size, alignment))
+
+
+// Decide if large pages should be committed when the memory is reserved.
+static bool should_commit_large_pages_when_reserving(size_t bytes) {
+ if (UseLargePages && UseLargePagesInMetaspace && !os::can_commit_large_page_memory()) {
+ size_t words = bytes / BytesPerWord;
+ bool is_class = false; // We never reserve large pages for the class space.
+ if (MetaspaceGC::can_expand(words, is_class) &&
+ MetaspaceGC::allowed_expansion() >= words) {
+ return true;
+ }
+ }
+
+ return false;
+}
+
// byte_size is the size of the associated virtualspace.
-VirtualSpaceNode::VirtualSpaceNode(size_t byte_size) : _top(NULL), _next(NULL), _rs(), _container_count(0) {
- // align up to vm allocation granularity
- byte_size = align_size_up(byte_size, os::vm_allocation_granularity());
+VirtualSpaceNode::VirtualSpaceNode(size_t bytes) : _top(NULL), _next(NULL), _rs(), _container_count(0) {
+ assert_is_size_aligned(bytes, Metaspace::reserve_alignment());
// This allocates memory with mmap. For DumpSharedspaces, try to reserve
// configurable address, generally at the top of the Java heap so other
// memory addresses don't conflict.
if (DumpSharedSpaces) {
- char* shared_base = (char*)SharedBaseAddress;
- _rs = ReservedSpace(byte_size, 0, false, shared_base, 0);
+ bool large_pages = false; // No large pages when dumping the CDS archive.
+ char* shared_base = (char*)align_ptr_up((char*)SharedBaseAddress, Metaspace::reserve_alignment());
+
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages, shared_base, 0);
if (_rs.is_reserved()) {
assert(shared_base == 0 || _rs.base() == shared_base, "should match");
} else {
// Get a mmap region anywhere if the SharedBaseAddress fails.
- _rs = ReservedSpace(byte_size);
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
}
MetaspaceShared::set_shared_rs(&_rs);
} else {
- _rs = ReservedSpace(byte_size);
+ bool large_pages = should_commit_large_pages_when_reserving(bytes);
+
+ _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
}
- MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
+ if (_rs.is_reserved()) {
+ assert(_rs.base() != NULL, "Catch if we get a NULL address");
+ assert(_rs.size() != 0, "Catch if we get a 0 size");
+ assert_is_ptr_aligned(_rs.base(), Metaspace::reserve_alignment());
+ assert_is_size_aligned(_rs.size(), Metaspace::reserve_alignment());
+
+ MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
+ }
}
void VirtualSpaceNode::purge(ChunkManager* chunk_manager) {
@@ -410,8 +444,6 @@
#endif
// List of VirtualSpaces for metadata allocation.
-// It has a _next link for singly linked list and a MemRegion
-// for total space in the VirtualSpace.
class VirtualSpaceList : public CHeapObj<mtClass> {
friend class VirtualSpaceNode;
@@ -419,16 +451,13 @@
VirtualSpaceSize = 256 * K
};
- // Global list of virtual spaces
// Head of the list
VirtualSpaceNode* _virtual_space_list;
// virtual space currently being used for allocations
VirtualSpaceNode* _current_virtual_space;
- // Can this virtual list allocate >1 spaces? Also, used to determine
- // whether to allocate unlimited small chunks in this virtual space
+ // Is this VirtualSpaceList used for the compressed class space
bool _is_class;
- bool can_grow() const { return !is_class() || !UseCompressedClassPointers; }
// Sum of reserved and committed memory in the virtual spaces
size_t _reserved_words;
@@ -453,7 +482,7 @@
// Get another virtual space and add it to the list. This
// is typically prompted by a failed attempt to allocate a chunk
// and is typically followed by the allocation of a chunk.
- bool grow_vs(size_t vs_word_size);
+ bool create_new_virtual_space(size_t vs_word_size);
public:
VirtualSpaceList(size_t word_size);
@@ -465,12 +494,12 @@
size_t grow_chunks_by_words,
size_t medium_chunk_bunch);
- bool expand_by(VirtualSpaceNode* node, size_t word_size, bool pre_touch = false);
-
- // Get the first chunk for a Metaspace. Used for
- // special cases such as the boot class loader, reflection
- // class loader and anonymous class loader.
- Metachunk* get_initialization_chunk(size_t word_size, size_t chunk_bunch);
+ bool expand_node_by(VirtualSpaceNode* node,
+ size_t min_words,
+ size_t preferred_words);
+
+ bool expand_by(size_t min_words,
+ size_t preferred_words);
VirtualSpaceNode* current_virtual_space() {
return _current_virtual_space;
@@ -478,8 +507,7 @@
bool is_class() const { return _is_class; }
- // Allocate the first virtualspace.
- void initialize(size_t word_size);
+ bool initialization_succeeded() { return _virtual_space_list != NULL; }
size_t reserved_words() { return _reserved_words; }
size_t reserved_bytes() { return reserved_words() * BytesPerWord; }
@@ -708,6 +736,9 @@
// and allocates from that chunk.
MetaWord* grow_and_allocate(size_t word_size);
+ // Notify memory usage to MemoryService.
+ void track_metaspace_memory_usage();
+
// debugging support.
void dump(outputStream* const out) const;
@@ -869,6 +900,12 @@
MetaWord* chunk_limit = top();
assert(chunk_limit != NULL, "Not safe to call this method");
+ // The virtual spaces are always expanded by the
+ // commit granularity to enforce the following condition.
+ // Without this the is_available check will not work correctly.
+ assert(_virtual_space.committed_size() == _virtual_space.actual_committed_size(),
+ "The committed memory doesn't match the expanded memory.");
+
if (!is_available(chunk_word_size)) {
if (TraceMetadataChunkAllocation) {
gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available %d words ", chunk_word_size);
@@ -888,14 +925,21 @@
// Expand the virtual space (commit more of the reserved space)
-bool VirtualSpaceNode::expand_by(size_t words, bool pre_touch) {
- size_t bytes = words * BytesPerWord;
- bool result = virtual_space()->expand_by(bytes, pre_touch);
- if (TraceMetavirtualspaceAllocation && !result) {
- gclog_or_tty->print_cr("VirtualSpaceNode::expand_by() failed "
- "for byte size " SIZE_FORMAT, bytes);
- virtual_space()->print_on(gclog_or_tty);
+bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
+ size_t min_bytes = min_words * BytesPerWord;
+ size_t preferred_bytes = preferred_words * BytesPerWord;
+
+ size_t uncommitted = virtual_space()->reserved_size() - virtual_space()->actual_committed_size();
+
+ if (uncommitted < min_bytes) {
+ return false;
}
+
+ size_t commit = MIN2(preferred_bytes, uncommitted);
+ bool result = virtual_space()->expand_by(commit, false);
+
+ assert(result, "Failed to commit memory");
+
return result;
}
@@ -914,12 +958,23 @@
return false;
}
- // An allocation out of this Virtualspace that is larger
- // than an initial commit size can waste that initial committed
- // space.
- size_t committed_byte_size = 0;
- bool result = virtual_space()->initialize(_rs, committed_byte_size);
+ // These are necessary restriction to make sure that the virtual space always
+ // grows in steps of Metaspace::commit_alignment(). If both base and size are
+ // aligned only the middle alignment of the VirtualSpace is used.
+ assert_is_ptr_aligned(_rs.base(), Metaspace::commit_alignment());
+ assert_is_size_aligned(_rs.size(), Metaspace::commit_alignment());
+
+ // ReservedSpaces marked as special will have the entire memory
+ // pre-committed. Setting a committed size will make sure that
+ // committed_size and actual_committed_size agrees.
+ size_t pre_committed_size = _rs.special() ? _rs.size() : 0;
+
+ bool result = virtual_space()->initialize_with_granularity(_rs, pre_committed_size,
+ Metaspace::commit_alignment());
if (result) {
+ assert(virtual_space()->committed_size() == virtual_space()->actual_committed_size(),
+ "Checking that the pre-committed memory was registered by the VirtualSpace");
+
set_top((MetaWord*)virtual_space()->low());
set_reserved(MemRegion((HeapWord*)_rs.base(),
(HeapWord*)(_rs.base() + _rs.size())));
@@ -976,13 +1031,23 @@
_reserved_words = _reserved_words - v;
}
+#define assert_committed_below_limit() \
+ assert(MetaspaceAux::committed_bytes() <= MaxMetaspaceSize, \
+ err_msg("Too much committed memory. Committed: " SIZE_FORMAT \
+ " limit (MaxMetaspaceSize): " SIZE_FORMAT, \
+ MetaspaceAux::committed_bytes(), MaxMetaspaceSize));
+
void VirtualSpaceList::inc_committed_words(size_t v) {
assert_lock_strong(SpaceManager::expand_lock());
_committed_words = _committed_words + v;
+
+ assert_committed_below_limit();
}
void VirtualSpaceList::dec_committed_words(size_t v) {
assert_lock_strong(SpaceManager::expand_lock());
_committed_words = _committed_words - v;
+
+ assert_committed_below_limit();
}
void VirtualSpaceList::inc_virtual_space_count() {
@@ -1025,8 +1090,8 @@
if (vsl->container_count() == 0 && vsl != current_virtual_space()) {
// Unlink it from the list
if (prev_vsl == vsl) {
- // This is the case of the current note being the first note.
- assert(vsl == virtual_space_list(), "Expected to be the first note");
+ // This is the case of the current node being the first node.
+ assert(vsl == virtual_space_list(), "Expected to be the first node");
set_virtual_space_list(vsl->next());
} else {
prev_vsl->set_next(vsl->next());
@@ -1054,7 +1119,7 @@
#endif
}
-VirtualSpaceList::VirtualSpaceList(size_t word_size ) :
+VirtualSpaceList::VirtualSpaceList(size_t word_size) :
_is_class(false),
_virtual_space_list(NULL),
_current_virtual_space(NULL),
@@ -1063,9 +1128,7 @@
_virtual_space_count(0) {
MutexLockerEx cl(SpaceManager::expand_lock(),
Mutex::_no_safepoint_check_flag);
- bool initialization_succeeded = grow_vs(word_size);
- assert(initialization_succeeded,
- " VirtualSpaceList initialization should not fail");
+ create_new_virtual_space(word_size);
}
VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
@@ -1079,8 +1142,9 @@
Mutex::_no_safepoint_check_flag);
VirtualSpaceNode* class_entry = new VirtualSpaceNode(rs);
bool succeeded = class_entry->initialize();
- assert(succeeded, " VirtualSpaceList initialization should not fail");
- link_vs(class_entry);
+ if (succeeded) {
+ link_vs(class_entry);
+ }
}
size_t VirtualSpaceList::free_bytes() {
@@ -1088,14 +1152,24 @@
}
// Allocate another meta virtual space and add it to the list.
-bool VirtualSpaceList::grow_vs(size_t vs_word_size) {
+bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
assert_lock_strong(SpaceManager::expand_lock());
- if (vs_word_size == 0) {
+
+ if (is_class()) {
+ assert(false, "We currently don't support more than one VirtualSpace for"
+ " the compressed class space. The initialization of the"
+ " CCS uses another code path and should not hit this path.");
return false;
}
+
+ if (vs_word_size == 0) {
+ assert(false, "vs_word_size should always be at least _reserve_alignment large.");
+ return false;
+ }
+
// Reserve the space
size_t vs_byte_size = vs_word_size * BytesPerWord;
- assert(vs_byte_size % os::vm_allocation_granularity() == 0, "Not aligned");
+ assert_is_size_aligned(vs_byte_size, Metaspace::reserve_alignment());
// Allocate the meta virtual space and initialize it.
VirtualSpaceNode* new_entry = new VirtualSpaceNode(vs_byte_size);
@@ -1103,7 +1177,8 @@
delete new_entry;
return false;
} else {
- assert(new_entry->reserved_words() == vs_word_size, "Must be");
+ assert(new_entry->reserved_words() == vs_word_size,
+ "Reserved memory size differs from requested memory size");
// ensure lock-free iteration sees fully initialized node
OrderAccess::storestore();
link_vs(new_entry);
@@ -1130,20 +1205,67 @@
}
}
-bool VirtualSpaceList::expand_by(VirtualSpaceNode* node, size_t word_size, bool pre_touch) {
+bool VirtualSpaceList::expand_node_by(VirtualSpaceNode* node,
+ size_t min_words,
+ size_t preferred_words) {
size_t before = node->committed_words();
- bool result = node->expand_by(word_size, pre_touch);
+ bool result = node->expand_by(min_words, preferred_words);
size_t after = node->committed_words();
// after and before can be the same if the memory was pre-committed.
- assert(after >= before, "Must be");
+ assert(after >= before, "Inconsistency");
inc_committed_words(after - before);
return result;
}
+bool VirtualSpaceList::expand_by(size_t min_words, size_t preferred_words) {
+ assert_is_size_aligned(min_words, Metaspace::commit_alignment_words());
+ assert_is_size_aligned(preferred_words, Metaspace::commit_alignment_words());
+ assert(min_words <= preferred_words, "Invalid arguments");
+
+ if (!MetaspaceGC::can_expand(min_words, this->is_class())) {
+ return false;
+ }
+
+ size_t allowed_expansion_words = MetaspaceGC::allowed_expansion();
+ if (allowed_expansion_words < min_words) {
+ return false;
+ }
+
+ size_t max_expansion_words = MIN2(preferred_words, allowed_expansion_words);
+
+ // Commit more memory from the the current virtual space.
+ bool vs_expanded = expand_node_by(current_virtual_space(),
+ min_words,
+ max_expansion_words);
+ if (vs_expanded) {
+ return true;
+ }
+
+ // Get another virtual space.
+ size_t grow_vs_words = MAX2((size_t)VirtualSpaceSize, preferred_words);
+ grow_vs_words = align_size_up(grow_vs_words, Metaspace::reserve_alignment_words());
+
+ if (create_new_virtual_space(grow_vs_words)) {
+ if (current_virtual_space()->is_pre_committed()) {
+ // The memory was pre-committed, so we are done here.
+ assert(min_words <= current_virtual_space()->committed_words(),
+ "The new VirtualSpace was pre-committed, so it"
+ "should be large enough to fit the alloc request.");
+ return true;
+ }
+
+ return expand_node_by(current_virtual_space(),
+ min_words,
+ max_expansion_words);
+ }
+
+ return false;
+}
+
Metachunk* VirtualSpaceList::get_new_chunk(size_t word_size,
size_t grow_chunks_by_words,
size_t medium_chunk_bunch) {
@@ -1151,63 +1273,27 @@
// Allocate a chunk out of the current virtual space.
Metachunk* next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- if (next == NULL) {
- // Not enough room in current virtual space. Try to commit
- // more space.
- size_t expand_vs_by_words = MAX2(medium_chunk_bunch,
- grow_chunks_by_words);
- size_t page_size_words = os::vm_page_size() / BytesPerWord;
- size_t aligned_expand_vs_by_words = align_size_up(expand_vs_by_words,
- page_size_words);
- bool vs_expanded =
- expand_by(current_virtual_space(), aligned_expand_vs_by_words);
- if (!vs_expanded) {
- // Should the capacity of the metaspaces be expanded for
- // this allocation? If it's the virtual space for classes and is
- // being used for CompressedHeaders, don't allocate a new virtualspace.
- if (can_grow() && MetaspaceGC::should_expand(this, word_size)) {
- // Get another virtual space.
- size_t allocation_aligned_expand_words =
- align_size_up(aligned_expand_vs_by_words, os::vm_allocation_granularity() / BytesPerWord);
- size_t grow_vs_words =
- MAX2((size_t)VirtualSpaceSize, allocation_aligned_expand_words);
- if (grow_vs(grow_vs_words)) {
- // Got it. It's on the list now. Get a chunk from it.
- assert(current_virtual_space()->expanded_words() == 0,
- "New virtual space nodes should not have expanded");
-
- size_t grow_chunks_by_words_aligned = align_size_up(grow_chunks_by_words,
- page_size_words);
- // We probably want to expand by aligned_expand_vs_by_words here.
- expand_by(current_virtual_space(), grow_chunks_by_words_aligned);
- next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- }
- } else {
- // Allocation will fail and induce a GC
- if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr("VirtualSpaceList::get_new_chunk():"
- " Fail instead of expand the metaspace");
- }
- }
- } else {
- // The virtual space expanded, get a new chunk
- next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
- assert(next != NULL, "Just expanded, should succeed");
- }
+ if (next != NULL) {
+ return next;
}
- assert(next == NULL || (next->next() == NULL && next->prev() == NULL),
- "New chunk is still on some list");
- return next;
-}
-
-Metachunk* VirtualSpaceList::get_initialization_chunk(size_t chunk_word_size,
- size_t chunk_bunch) {
- // Get a chunk from the chunk freelist
- Metachunk* new_chunk = get_new_chunk(chunk_word_size,
- chunk_word_size,
- chunk_bunch);
- return new_chunk;
+ // The expand amount is currently only determined by the requested sizes
+ // and not how much committed memory is left in the current virtual space.
+
+ size_t min_word_size = align_size_up(grow_chunks_by_words, Metaspace::commit_alignment_words());
+ size_t preferred_word_size = align_size_up(medium_chunk_bunch, Metaspace::commit_alignment_words());
+ if (min_word_size >= preferred_word_size) {
+ // Can happen when humongous chunks are allocated.
+ preferred_word_size = min_word_size;
+ }
+
+ bool expanded = expand_by(min_word_size, preferred_word_size);
+ if (expanded) {
+ next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
+ assert(next != NULL, "The allocation was expected to succeed after the expansion");
+ }
+
+ return next;
}
void VirtualSpaceList::print_on(outputStream* st) const {
@@ -1256,96 +1342,96 @@
// Calculate the amount to increase the high water mark (HWM).
// Increase by a minimum amount (MinMetaspaceExpansion) so that
// another expansion is not requested too soon. If that is not
-// enough to satisfy the allocation (i.e. big enough for a word_size
-// allocation), increase by MaxMetaspaceExpansion. If that is still
-// not enough, expand by the size of the allocation (word_size) plus
-// some.
-size_t MetaspaceGC::delta_capacity_until_GC(size_t word_size) {
- size_t before_inc = MetaspaceGC::capacity_until_GC();
- size_t min_delta_words = MinMetaspaceExpansion / BytesPerWord;
- size_t max_delta_words = MaxMetaspaceExpansion / BytesPerWord;
- size_t page_size_words = os::vm_page_size() / BytesPerWord;
- size_t size_delta_words = align_size_up(word_size, page_size_words);
- size_t delta_words = MAX2(size_delta_words, min_delta_words);
- if (delta_words > min_delta_words) {
+// enough to satisfy the allocation, increase by MaxMetaspaceExpansion.
+// If that is still not enough, expand by the size of the allocation
+// plus some.
+size_t MetaspaceGC::delta_capacity_until_GC(size_t bytes) {
+ size_t min_delta = MinMetaspaceExpansion;
+ size_t max_delta = MaxMetaspaceExpansion;
+ size_t delta = align_size_up(bytes, Metaspace::commit_alignment());
+
+ if (delta <= min_delta) {
+ delta = min_delta;
+ } else if (delta <= max_delta) {
// Don't want to hit the high water mark on the next
// allocation so make the delta greater than just enough
// for this allocation.
- delta_words = MAX2(delta_words, max_delta_words);
- if (delta_words > max_delta_words) {
- // This allocation is large but the next ones are probably not
- // so increase by the minimum.
- delta_words = delta_words + min_delta_words;
- }
+ delta = max_delta;
+ } else {
+ // This allocation is large but the next ones are probably not
+ // so increase by the minimum.
+ delta = delta + min_delta;
}
- return delta_words;
+
+ assert_is_size_aligned(delta, Metaspace::commit_alignment());
+
+ return delta;
+}
+
+size_t MetaspaceGC::capacity_until_GC() {
+ size_t value = (size_t)OrderAccess::load_ptr_acquire(&_capacity_until_GC);
+ assert(value >= MetaspaceSize, "Not initialied properly?");
+ return value;
}
-bool MetaspaceGC::should_expand(VirtualSpaceList* vsl, size_t word_size) {
-
- // If the user wants a limit, impose one.
- // The reason for someone using this flag is to limit reserved space. So
- // for non-class virtual space, compare against virtual spaces that are reserved.
- // For class virtual space, we only compare against the committed space, not
- // reserved space, because this is a larger space prereserved for compressed
- // class pointers.
- if (!FLAG_IS_DEFAULT(MaxMetaspaceSize)) {
- size_t nonclass_allocated = MetaspaceAux::reserved_bytes(Metaspace::NonClassType);
- size_t class_allocated = MetaspaceAux::allocated_capacity_bytes(Metaspace::ClassType);
- size_t real_allocated = nonclass_allocated + class_allocated;
- if (real_allocated >= MaxMetaspaceSize) {
+size_t MetaspaceGC::inc_capacity_until_GC(size_t v) {
+ assert_is_size_aligned(v, Metaspace::commit_alignment());
+
+ return (size_t)Atomic::add_ptr(v, &_capacity_until_GC);
+}
+
+size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
+ assert_is_size_aligned(v, Metaspace::commit_alignment());
+
+ return (size_t)Atomic::add_ptr(-(intptr_t)v, &_capacity_until_GC);
+}
+
+bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
+ // Check if the compressed class space is full.
+ if (is_class && Metaspace::using_class_space()) {
+ size_t class_committed = MetaspaceAux::committed_bytes(Metaspace::ClassType);
+ if (class_committed + word_size * BytesPerWord > CompressedClassSpaceSize) {
return false;
}
}
- // Class virtual space should always be expanded. Call GC for the other
- // metadata virtual space.
- if (Metaspace::using_class_space() &&
- (vsl == Metaspace::class_space_list())) return true;
-
- // If this is part of an allocation after a GC, expand
- // unconditionally.
- if (MetaspaceGC::expand_after_GC()) {
- return true;
+ // Check if the user has imposed a limit on the metaspace memory.
+ size_t committed_bytes = MetaspaceAux::committed_bytes();
+ if (committed_bytes + word_size * BytesPerWord > MaxMetaspaceSize) {
+ return false;
}
-
- // If the capacity is below the minimum capacity, allow the
- // expansion. Also set the high-water-mark (capacity_until_GC)
- // to that minimum capacity so that a GC will not be induced
- // until that minimum capacity is exceeded.
- size_t committed_capacity_bytes = MetaspaceAux::allocated_capacity_bytes();
- size_t metaspace_size_bytes = MetaspaceSize;
- if (committed_capacity_bytes < metaspace_size_bytes ||
- capacity_until_GC() == 0) {
- set_capacity_until_GC(metaspace_size_bytes);
- return true;
- } else {
- if (committed_capacity_bytes < capacity_until_GC()) {
- return true;
- } else {
- if (TraceMetadataChunkAllocation && Verbose) {
- gclog_or_tty->print_cr(" allocation request size " SIZE_FORMAT
- " capacity_until_GC " SIZE_FORMAT
- " allocated_capacity_bytes " SIZE_FORMAT,
- word_size,
- capacity_until_GC(),
- MetaspaceAux::allocated_capacity_bytes());
- }
- return false;
- }
+ return true;
+}
+
+size_t MetaspaceGC::allowed_expansion() {
+ size_t committed_bytes = MetaspaceAux::committed_bytes();
+
+ size_t left_until_max = MaxMetaspaceSize - committed_bytes;
+
+ // Always grant expansion if we are initiating the JVM,
+ // or if the GC_locker is preventing GCs.
+ if (!is_init_completed() || GC_locker::is_active_and_needs_gc()) {
+ return left_until_max / BytesPerWord;
}
+
+ size_t capacity_until_gc = capacity_until_GC();
+
+ if (capacity_until_gc <= committed_bytes) {
+ return 0;
+ }
+
+ size_t left_until_GC = capacity_until_gc - committed_bytes;
+ size_t left_to_commit = MIN2(left_until_GC, left_until_max);
+
+ return left_to_commit / BytesPerWord;
}
-
-
void MetaspaceGC::compute_new_size() {
assert(_shrink_factor <= 100, "invalid shrink factor");
uint current_shrink_factor = _shrink_factor;
_shrink_factor = 0;
- // Until a faster way of calculating the "used" quantity is implemented,
- // use "capacity".
const size_t used_after_gc = MetaspaceAux::allocated_capacity_bytes();
const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC();
@@ -1377,9 +1463,10 @@
// If we have less capacity below the metaspace HWM, then
// increment the HWM.
size_t expand_bytes = minimum_desired_capacity - capacity_until_GC;
+ expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
// Don't expand unless it's significant
if (expand_bytes >= MinMetaspaceExpansion) {
- MetaspaceGC::set_capacity_until_GC(capacity_until_GC + expand_bytes);
+ MetaspaceGC::inc_capacity_until_GC(expand_bytes);
}
if (PrintGCDetails && Verbose) {
size_t new_capacity_until_GC = capacity_until_GC;
@@ -1436,6 +1523,9 @@
// on the third call, and 100% by the fourth call. But if we recompute
// size without shrinking, it goes back to 0%.
shrink_bytes = shrink_bytes / 100 * current_shrink_factor;
+
+ shrink_bytes = align_size_down(shrink_bytes, Metaspace::commit_alignment());
+
assert(shrink_bytes <= max_shrink_bytes,
err_msg("invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT,
shrink_bytes, max_shrink_bytes));
@@ -1467,7 +1557,7 @@
// Don't shrink unless it's significant
if (shrink_bytes >= MinMetaspaceExpansion &&
((capacity_until_GC - shrink_bytes) >= MetaspaceSize)) {
- MetaspaceGC::set_capacity_until_GC(capacity_until_GC - shrink_bytes);
+ MetaspaceGC::dec_capacity_until_GC(shrink_bytes);
}
}
@@ -1700,7 +1790,6 @@
assert(free_list != NULL, "Sanity check");
chunk = free_list->head();
- debug_only(Metachunk* debug_head = chunk;)
if (chunk == NULL) {
return NULL;
@@ -1709,9 +1798,6 @@
// Remove the chunk as the head of the list.
free_list->remove_chunk(chunk);
- // Chunk is being removed from the chunks free list.
- dec_free_chunks_total(chunk->capacity_word_size());
-
if (TraceMetadataChunkAllocation && Verbose) {
gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list "
PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
@@ -1722,21 +1808,22 @@
word_size,
FreeBlockDictionary<Metachunk>::atLeast);
- if (chunk != NULL) {
- if (TraceMetadataHumongousAllocation) {
- size_t waste = chunk->word_size() - word_size;
- gclog_or_tty->print_cr("Free list allocate humongous chunk size "
- SIZE_FORMAT " for requested size " SIZE_FORMAT
- " waste " SIZE_FORMAT,
- chunk->word_size(), word_size, waste);
- }
- // Chunk is being removed from the chunks free list.
- dec_free_chunks_total(chunk->capacity_word_size());
- } else {
+ if (chunk == NULL) {
return NULL;
}
+
+ if (TraceMetadataHumongousAllocation) {
+ size_t waste = chunk->word_size() - word_size;
+ gclog_or_tty->print_cr("Free list allocate humongous chunk size "
+ SIZE_FORMAT " for requested size " SIZE_FORMAT
+ " waste " SIZE_FORMAT,
+ chunk->word_size(), word_size, waste);
+ }
}
+ // Chunk is being removed from the chunks free list.
+ dec_free_chunks_total(chunk->capacity_word_size());
+
// Remove it from the links to this freelist
chunk->set_next(NULL);
chunk->set_prev(NULL);
@@ -1977,6 +2064,15 @@
return chunk_word_size;
}
+void SpaceManager::track_metaspace_memory_usage() {
+ if (is_init_completed()) {
+ if (is_class()) {
+ MemoryService::track_compressed_class_memory_usage();
+ }
+ MemoryService::track_metaspace_memory_usage();
+ }
+}
+
MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
assert(vs_list()->current_virtual_space() != NULL,
"Should have been set");
@@ -2002,15 +2098,24 @@
size_t grow_chunks_by_words = calc_chunk_size(word_size);
Metachunk* next = get_new_chunk(word_size, grow_chunks_by_words);
+ if (next != NULL) {
+ Metadebug::deallocate_chunk_a_lot(this, grow_chunks_by_words);
+ }
+
+ MetaWord* mem = NULL;
+
// If a chunk was available, add it to the in-use chunk list
// and do an allocation from it.
if (next != NULL) {
- Metadebug::deallocate_chunk_a_lot(this, grow_chunks_by_words);
// Add to this manager's list of chunks in use.
add_chunk(next, false);
- return next->allocate(word_size);
+ mem = next->allocate(word_size);
}
- return NULL;
+
+ // Track metaspace memory usage statistic.
+ track_metaspace_memory_usage();
+
+ return mem;
}
void SpaceManager::print_on(outputStream* st) const {
@@ -2366,6 +2471,7 @@
inc_used_metrics(word_size);
return current_chunk()->allocate(word_size); // caller handles null result
}
+
if (current_chunk() != NULL) {
result = current_chunk()->allocate(word_size);
}
@@ -2373,7 +2479,8 @@
if (result == NULL) {
result = grow_and_allocate(word_size);
}
- if (result != 0) {
+
+ if (result != NULL) {
inc_used_metrics(word_size);
assert(result != (MetaWord*) chunks_in_use(MediumIndex),
"Head of the list is being allocated");
@@ -2639,24 +2746,26 @@
void MetaspaceAux::print_on(outputStream* out) {
Metaspace::MetadataType nct = Metaspace::NonClassType;
- out->print_cr(" Metaspace total "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
- allocated_capacity_bytes()/K, allocated_used_bytes()/K, reserved_bytes()/K);
-
- out->print_cr(" data space "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
- allocated_capacity_bytes(nct)/K,
- allocated_used_bytes(nct)/K,
- reserved_bytes(nct)/K);
+ out->print_cr(" Metaspace "
+ "used " SIZE_FORMAT "K, "
+ "capacity " SIZE_FORMAT "K, "
+ "committed " SIZE_FORMAT "K, "
+ "reserved " SIZE_FORMAT "K",
+ allocated_used_bytes()/K,
+ allocated_capacity_bytes()/K,
+ committed_bytes()/K,
+ reserved_bytes()/K);
+
if (Metaspace::using_class_space()) {
Metaspace::MetadataType ct = Metaspace::ClassType;
out->print_cr(" class space "
- SIZE_FORMAT "K, used " SIZE_FORMAT "K,"
- " reserved " SIZE_FORMAT "K",
+ "used " SIZE_FORMAT "K, "
+ "capacity " SIZE_FORMAT "K, "
+ "committed " SIZE_FORMAT "K, "
+ "reserved " SIZE_FORMAT "K",
+ allocated_used_bytes(ct)/K,
allocated_capacity_bytes(ct)/K,
- allocated_used_bytes(ct)/K,
+ committed_bytes(ct)/K,
reserved_bytes(ct)/K);
}
}
@@ -2808,6 +2917,9 @@
size_t Metaspace::_first_chunk_word_size = 0;
size_t Metaspace::_first_class_chunk_word_size = 0;
+size_t Metaspace::_commit_alignment = 0;
+size_t Metaspace::_reserve_alignment = 0;
+
Metaspace::Metaspace(Mutex* lock, MetaspaceType type) {
initialize(lock, type);
}
@@ -2869,21 +2981,30 @@
assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
assert(class_metaspace_size() < KlassEncodingMetaspaceMax,
"Metaspace size is too big");
+ assert_is_ptr_aligned(requested_addr, _reserve_alignment);
+ assert_is_ptr_aligned(cds_base, _reserve_alignment);
+ assert_is_size_aligned(class_metaspace_size(), _reserve_alignment);
+
+ // Don't use large pages for the class space.
+ bool large_pages = false;
ReservedSpace metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(),
- false, requested_addr, 0);
+ _reserve_alignment,
+ large_pages,
+ requested_addr, 0);
if (!metaspace_rs.is_reserved()) {
if (UseSharedSpaces) {
+ size_t increment = align_size_up(1*G, _reserve_alignment);
+
// Keep trying to allocate the metaspace, increasing the requested_addr
// by 1GB each time, until we reach an address that will no longer allow
// use of CDS with compressed klass pointers.
char *addr = requested_addr;
- while (!metaspace_rs.is_reserved() && (addr + 1*G > addr) &&
- can_use_cds_with_metaspace_addr(addr + 1*G, cds_base)) {
- addr = addr + 1*G;
+ while (!metaspace_rs.is_reserved() && (addr + increment > addr) &&
+ can_use_cds_with_metaspace_addr(addr + increment, cds_base)) {
+ addr = addr + increment;
metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(), false, addr, 0);
+ _reserve_alignment, large_pages, addr, 0);
}
}
@@ -2894,7 +3015,7 @@
// So, UseCompressedClassPointers cannot be turned off at this point.
if (!metaspace_rs.is_reserved()) {
metaspace_rs = ReservedSpace(class_metaspace_size(),
- os::vm_allocation_granularity(), false);
+ _reserve_alignment, large_pages);
if (!metaspace_rs.is_reserved()) {
vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
class_metaspace_size()));
@@ -2933,34 +3054,96 @@
assert(using_class_space(), "Must be using class space");
_class_space_list = new VirtualSpaceList(rs);
_chunk_manager_class = new ChunkManager(SpecializedChunk, ClassSmallChunk, ClassMediumChunk);
+
+ if (!_class_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Failed to setup compressed class space virtual space list.");
+ }
}
#endif
+// Align down. If the aligning result in 0, return 'alignment'.
+static size_t restricted_align_down(size_t size, size_t alignment) {
+ return MAX2(alignment, align_size_down_(size, alignment));
+}
+
+void Metaspace::ergo_initialize() {
+ if (DumpSharedSpaces) {
+ // Using large pages when dumping the shared archive is currently not implemented.
+ FLAG_SET_ERGO(bool, UseLargePagesInMetaspace, false);
+ }
+
+ size_t page_size = os::vm_page_size();
+ if (UseLargePages && UseLargePagesInMetaspace) {
+ page_size = os::large_page_size();
+ }
+
+ _commit_alignment = page_size;
+ _reserve_alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity());
+
+ // Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
+ // override if MaxMetaspaceSize was set on the command line or not.
+ // This information is needed later to conform to the specification of the
+ // java.lang.management.MemoryUsage API.
+ //
+ // Ideally, we would be able to set the default value of MaxMetaspaceSize in
+ // globals.hpp to the aligned value, but this is not possible, since the
+ // alignment depends on other flags being parsed.
+ MaxMetaspaceSize = restricted_align_down(MaxMetaspaceSize, _reserve_alignment);
+
+ if (MetaspaceSize > MaxMetaspaceSize) {
+ MetaspaceSize = MaxMetaspaceSize;
+ }
+
+ MetaspaceSize = restricted_align_down(MetaspaceSize, _commit_alignment);
+
+ assert(MetaspaceSize <= MaxMetaspaceSize, "MetaspaceSize should be limited by MaxMetaspaceSize");
+
+ if (MetaspaceSize < 256*K) {
+ vm_exit_during_initialization("Too small initial Metaspace size");
+ }
+
+ MinMetaspaceExpansion = restricted_align_down(MinMetaspaceExpansion, _commit_alignment);
+ MaxMetaspaceExpansion = restricted_align_down(MaxMetaspaceExpansion, _commit_alignment);
+
+ CompressedClassSpaceSize = restricted_align_down(CompressedClassSpaceSize, _reserve_alignment);
+ set_class_metaspace_size(CompressedClassSpaceSize);
+}
+
void Metaspace::global_initialize() {
// Initialize the alignment for shared spaces.
int max_alignment = os::vm_page_size();
size_t cds_total = 0;
- set_class_metaspace_size(align_size_up(CompressedClassSpaceSize,
- os::vm_allocation_granularity()));
-
MetaspaceShared::set_max_alignment(max_alignment);
if (DumpSharedSpaces) {
- SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
+ SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment);
- SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
- SharedMiscCodeSize = align_size_up(SharedMiscCodeSize, max_alignment);
+ SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
+ SharedMiscCodeSize = align_size_up(SharedMiscCodeSize, max_alignment);
// Initialize with the sum of the shared space sizes. The read-only
// and read write metaspace chunks will be allocated out of this and the
// remainder is the misc code and data chunks.
cds_total = FileMapInfo::shared_spaces_size();
+ cds_total = align_size_up(cds_total, _reserve_alignment);
_space_list = new VirtualSpaceList(cds_total/wordSize);
_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
+ if (!_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Unable to dump shared archive.", NULL);
+ }
+
#ifdef _LP64
+ if (cds_total + class_metaspace_size() > (uint64_t)max_juint) {
+ vm_exit_during_initialization("Unable to dump shared archive.",
+ err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
+ SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
+ "klass limit: " SIZE_FORMAT, cds_total, class_metaspace_size(),
+ cds_total + class_metaspace_size(), (size_t)max_juint));
+ }
+
// Set the compressed klass pointer base so that decoding of these pointers works
// properly when creating the shared archive.
assert(UseCompressedOops && UseCompressedClassPointers,
@@ -2971,9 +3154,6 @@
_space_list->current_virtual_space()->bottom());
}
- // Set the shift to zero.
- assert(class_metaspace_size() < (uint64_t)(max_juint) - cds_total,
- "CDS region is too large");
Universe::set_narrow_klass_shift(0);
#endif
@@ -2992,12 +3172,12 @@
// Map in spaces now also
if (mapinfo->initialize() && MetaspaceShared::map_shared_spaces(mapinfo)) {
FileMapInfo::set_current_info(mapinfo);
+ cds_total = FileMapInfo::shared_spaces_size();
+ cds_address = (address)mapinfo->region_base(0);
} else {
assert(!mapinfo->is_open() && !UseSharedSpaces,
"archive file not closed or shared spaces not disabled.");
}
- cds_total = FileMapInfo::shared_spaces_size();
- cds_address = (address)mapinfo->region_base(0);
}
#ifdef _LP64
@@ -3005,7 +3185,9 @@
// above the heap and above the CDS area (if it exists).
if (using_class_space()) {
if (UseSharedSpaces) {
- allocate_metaspace_compressed_klass_ptrs((char *)(cds_address + cds_total), cds_address);
+ char* cds_end = (char*)(cds_address + cds_total);
+ cds_end = (char *)align_ptr_up(cds_end, _reserve_alignment);
+ allocate_metaspace_compressed_klass_ptrs(cds_end, cds_address);
} else {
allocate_metaspace_compressed_klass_ptrs((char *)CompressedKlassPointersBase, 0);
}
@@ -3023,11 +3205,19 @@
_first_class_chunk_word_size = align_word_size_up(_first_class_chunk_word_size);
// Arbitrarily set the initial virtual space to a multiple
// of the boot class loader size.
- size_t word_size = VIRTUALSPACEMULTIPLIER * first_chunk_word_size();
+ size_t word_size = VIRTUALSPACEMULTIPLIER * _first_chunk_word_size;
+ word_size = align_size_up(word_size, Metaspace::reserve_alignment_words());
+
// Initialize the list of virtual spaces.
_space_list = new VirtualSpaceList(word_size);
_chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
+
+ if (!_space_list->initialization_succeeded()) {
+ vm_exit_during_initialization("Unable to setup metadata virtual space list.", NULL);
+ }
}
+
+ MetaspaceGC::initialize();
}
Metachunk* Metaspace::get_initialization_chunk(MetadataType mdtype,
@@ -3039,7 +3229,7 @@
return chunk;
}
- return get_space_list(mdtype)->get_initialization_chunk(chunk_word_size, chunk_bunch);
+ return get_space_list(mdtype)->get_new_chunk(chunk_word_size, chunk_word_size, chunk_bunch);
}
void Metaspace::initialize(Mutex* lock, MetaspaceType type) {
@@ -3112,19 +3302,18 @@
}
MetaWord* Metaspace::expand_and_allocate(size_t word_size, MetadataType mdtype) {
- MetaWord* result;
- MetaspaceGC::set_expand_after_GC(true);
- size_t before_inc = MetaspaceGC::capacity_until_GC();
- size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size) * BytesPerWord;
- MetaspaceGC::inc_capacity_until_GC(delta_bytes);
+ size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
+ assert(delta_bytes > 0, "Must be");
+
+ size_t after_inc = MetaspaceGC::inc_capacity_until_GC(delta_bytes);
+ size_t before_inc = after_inc - delta_bytes;
+
if (PrintGCDetails && Verbose) {
gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
- " to " SIZE_FORMAT, before_inc, MetaspaceGC::capacity_until_GC());
+ " to " SIZE_FORMAT, before_inc, after_inc);
}
- result = allocate(word_size, mdtype);
-
- return result;
+ return allocate(word_size, mdtype);
}
// Space allocated in the Metaspace. This may
@@ -3206,6 +3395,7 @@
}
}
+
Metablock* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
bool read_only, MetaspaceObj::Type type, TRAPS) {
if (HAS_PENDING_EXCEPTION) {
@@ -3213,20 +3403,16 @@
return NULL; // caller does a CHECK_NULL too
}
- MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
-
- // SSS: Should we align the allocations and make sure the sizes are aligned.
- MetaWord* result = NULL;
-
assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
"ClassLoaderData::the_null_class_loader_data() should have been used.");
+
// Allocate in metaspaces without taking out a lock, because it deadlocks
// with the SymbolTable_lock. Dumping is single threaded for now. We'll have
// to revisit this for application class data sharing.
if (DumpSharedSpaces) {
assert(type > MetaspaceObj::UnknownType && type < MetaspaceObj::_number_of_types, "sanity");
Metaspace* space = read_only ? loader_data->ro_metaspace() : loader_data->rw_metaspace();
- result = space->allocate(word_size, NonClassType);
+ MetaWord* result = space->allocate(word_size, NonClassType);
if (result == NULL) {
report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
} else {
@@ -3235,40 +3421,62 @@
return Metablock::initialize(result, word_size);
}
- result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+ MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
+
+ // Try to allocate metadata.
+ MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
+
+ if (result == NULL) {
+ // Allocation failed.
+ if (is_init_completed()) {
+ // Only start a GC if the bootstrapping has completed.
+
+ // Try to clean out some memory and retry.
+ result = Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
+ loader_data, word_size, mdtype);
+ }
+ }
if (result == NULL) {
- // Try to clean out some memory and retry.
- result =
- Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
- loader_data, word_size, mdtype);
-
- // If result is still null, we are out of memory.
- if (result == NULL) {
- if (Verbose && TraceMetadataChunkAllocation) {
- gclog_or_tty->print_cr("Metaspace allocation failed for size "
- SIZE_FORMAT, word_size);
- if (loader_data->metaspace_or_null() != NULL) loader_data->dump(gclog_or_tty);
- MetaspaceAux::dump(gclog_or_tty);
- }
- // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
- const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
- "Metadata space";
- report_java_out_of_memory(space_string);
-
- if (JvmtiExport::should_post_resource_exhausted()) {
- JvmtiExport::post_resource_exhausted(
- JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
- space_string);
- }
- if (is_class_space_allocation(mdtype)) {
- THROW_OOP_0(Universe::out_of_memory_error_class_metaspace());
- } else {
- THROW_OOP_0(Universe::out_of_memory_error_metaspace());
- }
+ report_metadata_oome(loader_data, word_size, mdtype, THREAD);
+ // Will not reach here.
+ return NULL;
+ }
+
+ return Metablock::initialize(result, word_size);
+}
+
+void Metaspace::report_metadata_oome(ClassLoaderData* loader_data, size_t word_size, MetadataType mdtype, TRAPS) {
+ // If result is still null, we are out of memory.
+ if (Verbose && TraceMetadataChunkAllocation) {
+ gclog_or_tty->print_cr("Metaspace allocation failed for size "
+ SIZE_FORMAT, word_size);
+ if (loader_data->metaspace_or_null() != NULL) {
+ loader_data->dump(gclog_or_tty);
}
+ MetaspaceAux::dump(gclog_or_tty);
}
- return Metablock::initialize(result, word_size);
+
+ // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
+ const char* space_string = is_class_space_allocation(mdtype) ? "Compressed class space" :
+ "Metadata space";
+ report_java_out_of_memory(space_string);
+
+ if (JvmtiExport::should_post_resource_exhausted()) {
+ JvmtiExport::post_resource_exhausted(
+ JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
+ space_string);
+ }
+
+ if (!is_init_completed()) {
+ vm_exit_during_initialization("OutOfMemoryError", space_string);
+ }
+
+ if (is_class_space_allocation(mdtype)) {
+ THROW_OOP(Universe::out_of_memory_error_class_metaspace());
+ } else {
+ THROW_OOP(Universe::out_of_memory_error_metaspace());
+ }
}
void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
--- a/hotspot/src/share/vm/memory/metaspace.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/memory/metaspace.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -87,9 +87,10 @@
friend class MetaspaceAux;
public:
- enum MetadataType {ClassType = 0,
- NonClassType = ClassType + 1,
- MetadataTypeCount = ClassType + 2
+ enum MetadataType {
+ ClassType,
+ NonClassType,
+ MetadataTypeCount
};
enum MetaspaceType {
StandardMetaspaceType,
@@ -103,6 +104,9 @@
private:
void initialize(Mutex* lock, MetaspaceType type);
+ // Get the first chunk for a Metaspace. Used for
+ // special cases such as the boot class loader, reflection
+ // class loader and anonymous class loader.
Metachunk* get_initialization_chunk(MetadataType mdtype,
size_t chunk_word_size,
size_t chunk_bunch);
@@ -123,6 +127,9 @@
static size_t _first_chunk_word_size;
static size_t _first_class_chunk_word_size;
+ static size_t _commit_alignment;
+ static size_t _reserve_alignment;
+
SpaceManager* _vsm;
SpaceManager* vsm() const { return _vsm; }
@@ -191,12 +198,17 @@
Metaspace(Mutex* lock, MetaspaceType type);
~Metaspace();
- // Initialize globals for Metaspace
+ static void ergo_initialize();
static void global_initialize();
static size_t first_chunk_word_size() { return _first_chunk_word_size; }
static size_t first_class_chunk_word_size() { return _first_class_chunk_word_size; }
+ static size_t reserve_alignment() { return _reserve_alignment; }
+ static size_t reserve_alignment_words() { return _reserve_alignment / BytesPerWord; }
+ static size_t commit_alignment() { return _commit_alignment; }
+ static size_t commit_alignment_words() { return _commit_alignment / BytesPerWord; }
+
char* bottom() const;
size_t used_words_slow(MetadataType mdtype) const;
size_t free_words_slow(MetadataType mdtype) const;
@@ -219,6 +231,9 @@
static void purge(MetadataType mdtype);
static void purge();
+ static void report_metadata_oome(ClassLoaderData* loader_data, size_t word_size,
+ MetadataType mdtype, TRAPS);
+
void print_on(outputStream* st) const;
// Debugging support
void verify();
@@ -352,17 +367,10 @@
class MetaspaceGC : AllStatic {
- // The current high-water-mark for inducing a GC. When
- // the capacity of all space in the virtual lists reaches this value,
- // a GC is induced and the value is increased. This should be changed
- // to the space actually used for allocations to avoid affects of
- // fragmentation losses to partially used chunks. Size is in words.
- static size_t _capacity_until_GC;
-
- // After a GC is done any allocation that fails should try to expand
- // the capacity of the Metaspaces. This flag is set during attempts
- // to allocate in the VMGCOperation that does the GC.
- static bool _expand_after_GC;
+ // The current high-water-mark for inducing a GC.
+ // When committed memory of all metaspaces reaches this value,
+ // a GC is induced and the value is increased. Size is in bytes.
+ static volatile intptr_t _capacity_until_GC;
// For a CMS collection, signal that a concurrent collection should
// be started.
@@ -370,20 +378,16 @@
static uint _shrink_factor;
- static void set_capacity_until_GC(size_t v) { _capacity_until_GC = v; }
-
static size_t shrink_factor() { return _shrink_factor; }
void set_shrink_factor(uint v) { _shrink_factor = v; }
public:
- static size_t capacity_until_GC() { return _capacity_until_GC; }
- static void inc_capacity_until_GC(size_t v) { _capacity_until_GC += v; }
- static void dec_capacity_until_GC(size_t v) {
- _capacity_until_GC = _capacity_until_GC > v ? _capacity_until_GC - v : 0;
- }
- static bool expand_after_GC() { return _expand_after_GC; }
- static void set_expand_after_GC(bool v) { _expand_after_GC = v; }
+ static void initialize() { _capacity_until_GC = MetaspaceSize; }
+
+ static size_t capacity_until_GC();
+ static size_t inc_capacity_until_GC(size_t v);
+ static size_t dec_capacity_until_GC(size_t v);
static bool should_concurrent_collect() { return _should_concurrent_collect; }
static void set_should_concurrent_collect(bool v) {
@@ -391,11 +395,14 @@
}
// The amount to increase the high-water-mark (_capacity_until_GC)
- static size_t delta_capacity_until_GC(size_t word_size);
+ static size_t delta_capacity_until_GC(size_t bytes);
- // It is expected that this will be called when the current capacity
- // has been used and a GC should be considered.
- static bool should_expand(VirtualSpaceList* vsl, size_t word_size);
+ // Tells if we have can expand metaspace without hitting set limits.
+ static bool can_expand(size_t words, bool is_class);
+
+ // Returns amount that we can expand without hitting a GC,
+ // measured in words.
+ static size_t allowed_expansion();
// Calculate the new high-water mark at which to induce
// a GC.
--- a/hotspot/src/share/vm/oops/instanceKlass.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/instanceKlass.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -238,6 +238,13 @@
}
}
+// create a new array of vtable_indices for default methods
+Array<int>* InstanceKlass::create_new_default_vtable_indices(int len, TRAPS) {
+ Array<int>* vtable_indices = MetadataFactory::new_array<int>(class_loader_data(), len, CHECK_NULL);
+ assert(default_vtable_indices() == NULL, "only create once");
+ set_default_vtable_indices(vtable_indices);
+ return vtable_indices;
+}
InstanceKlass::InstanceKlass(int vtable_len,
int itable_len,
@@ -263,6 +270,8 @@
set_array_klasses(NULL);
set_methods(NULL);
set_method_ordering(NULL);
+ set_default_methods(NULL);
+ set_default_vtable_indices(NULL);
set_local_interfaces(NULL);
set_transitive_interfaces(NULL);
init_implementor();
@@ -376,6 +385,21 @@
}
set_method_ordering(NULL);
+ // default methods can be empty
+ if (default_methods() != NULL &&
+ default_methods() != Universe::the_empty_method_array()) {
+ MetadataFactory::free_array<Method*>(loader_data, default_methods());
+ }
+ // Do NOT deallocate the default methods, they are owned by superinterfaces.
+ set_default_methods(NULL);
+
+ // default methods vtable indices can be empty
+ if (default_vtable_indices() != NULL) {
+ MetadataFactory::free_array<int>(loader_data, default_vtable_indices());
+ }
+ set_default_vtable_indices(NULL);
+
+
// This array is in Klass, but remove it with the InstanceKlass since
// this place would be the only caller and it can share memory with transitive
// interfaces.
@@ -456,14 +480,14 @@
return java_lang_Class::signers(java_mirror());
}
-volatile oop InstanceKlass::init_lock() const {
+oop InstanceKlass::init_lock() const {
// return the init lock from the mirror
return java_lang_Class::init_lock(java_mirror());
}
void InstanceKlass::eager_initialize_impl(instanceKlassHandle this_oop) {
EXCEPTION_MARK;
- volatile oop init_lock = this_oop->init_lock();
+ oop init_lock = this_oop->init_lock();
ObjectLocker ol(init_lock, THREAD);
// abort if someone beat us to the initialization
@@ -608,7 +632,7 @@
// verification & rewriting
{
- volatile oop init_lock = this_oop->init_lock();
+ oop init_lock = this_oop->init_lock();
ObjectLocker ol(init_lock, THREAD);
// rewritten will have been set if loader constraint error found
// on an earlier link attempt
@@ -731,7 +755,7 @@
// refer to the JVM book page 47 for description of steps
// Step 1
{
- volatile oop init_lock = this_oop->init_lock();
+ oop init_lock = this_oop->init_lock();
ObjectLocker ol(init_lock, THREAD);
Thread *self = THREAD; // it's passed the current thread
@@ -879,7 +903,7 @@
}
void InstanceKlass::set_initialization_state_and_notify_impl(instanceKlassHandle this_oop, ClassState state, TRAPS) {
- volatile oop init_lock = this_oop->init_lock();
+ oop init_lock = this_oop->init_lock();
ObjectLocker ol(init_lock, THREAD);
this_oop->set_init_state(state);
ol.notify_all(CHECK);
@@ -1354,32 +1378,44 @@
return -1;
}
+// find_method looks up the name/signature in the local methods array
Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
return InstanceKlass::find_method(methods(), name, signature);
}
+// find_method looks up the name/signature in the local methods array
Method* InstanceKlass::find_method(
Array<Method*>* methods, Symbol* name, Symbol* signature) {
+ int hit = find_method_index(methods, name, signature);
+ return hit >= 0 ? methods->at(hit): NULL;
+}
+
+// Used directly for default_methods to find the index into the
+// default_vtable_indices, and indirectly by find_method
+// find_method_index looks in the local methods array to return the index
+// of the matching name/signature
+int InstanceKlass::find_method_index(
+ Array<Method*>* methods, Symbol* name, Symbol* signature) {
int hit = binary_search(methods, name);
if (hit != -1) {
Method* m = methods->at(hit);
// Do linear search to find matching signature. First, quick check
// for common case
- if (m->signature() == signature) return m;
+ if (m->signature() == signature) return hit;
// search downwards through overloaded methods
int i;
for (i = hit - 1; i >= 0; --i) {
Method* m = methods->at(i);
assert(m->is_method(), "must be method");
if (m->name() != name) break;
- if (m->signature() == signature) return m;
+ if (m->signature() == signature) return i;
}
// search upwards
for (i = hit + 1; i < methods->length(); ++i) {
Method* m = methods->at(i);
assert(m->is_method(), "must be method");
if (m->name() != name) break;
- if (m->signature() == signature) return m;
+ if (m->signature() == signature) return i;
}
// not found
#ifdef ASSERT
@@ -1387,9 +1423,8 @@
assert(index == -1, err_msg("binary search should have found entry %d", index));
#endif
}
- return NULL;
+ return -1;
}
-
int InstanceKlass::find_method_by_name(Symbol* name, int* end) {
return find_method_by_name(methods(), name, end);
}
@@ -1408,6 +1443,7 @@
return -1;
}
+// lookup_method searches both the local methods array and all superclasses methods arrays
Method* InstanceKlass::uncached_lookup_method(Symbol* name, Symbol* signature) const {
Klass* klass = const_cast<InstanceKlass*>(this);
while (klass != NULL) {
@@ -1418,6 +1454,21 @@
return NULL;
}
+// lookup a method in the default methods list then in all transitive interfaces
+// Do NOT return private or static methods
+Method* InstanceKlass::lookup_method_in_ordered_interfaces(Symbol* name,
+ Symbol* signature) const {
+ Method* m = NULL;
+ if (default_methods() != NULL) {
+ m = find_method(default_methods(), name, signature);
+ }
+ // Look up interfaces
+ if (m == NULL) {
+ m = lookup_method_in_all_interfaces(name, signature);
+ }
+ return m;
+}
+
// lookup a method in all the interfaces that this class implements
// Do NOT return private or static methods, new in JDK8 which are not externally visible
// They should only be found in the initial InterfaceMethodRef
@@ -2548,6 +2599,42 @@
return m;
}
+
+#if INCLUDE_JVMTI
+// update default_methods for redefineclasses for methods that are
+// not yet in the vtable due to concurrent subclass define and superinterface
+// redefinition
+// Note: those in the vtable, should have been updated via adjust_method_entries
+void InstanceKlass::adjust_default_methods(Method** old_methods, Method** new_methods,
+ int methods_length, bool* trace_name_printed) {
+ // search the default_methods for uses of either obsolete or EMCP methods
+ if (default_methods() != NULL) {
+ for (int j = 0; j < methods_length; j++) {
+ Method* old_method = old_methods[j];
+ Method* new_method = new_methods[j];
+
+ for (int index = 0; index < default_methods()->length(); index ++) {
+ if (default_methods()->at(index) == old_method) {
+ default_methods()->at_put(index, new_method);
+ if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
+ if (!(*trace_name_printed)) {
+ // RC_TRACE_MESG macro has an embedded ResourceMark
+ RC_TRACE_MESG(("adjust: klassname=%s default methods from name=%s",
+ external_name(),
+ old_method->method_holder()->external_name()));
+ *trace_name_printed = true;
+ }
+ RC_TRACE(0x00100000, ("default method update: %s(%s) ",
+ new_method->name()->as_C_string(),
+ new_method->signature()->as_C_string()));
+ }
+ }
+ }
+ }
+ }
+}
+#endif // INCLUDE_JVMTI
+
// On-stack replacement stuff
void InstanceKlass::add_osr_nmethod(nmethod* n) {
// only one compilation can be active
@@ -2742,11 +2829,21 @@
st->print(BULLET"methods: "); methods()->print_value_on(st); st->cr();
if (Verbose || WizardMode) {
Array<Method*>* method_array = methods();
- for(int i = 0; i < method_array->length(); i++) {
+ for (int i = 0; i < method_array->length(); i++) {
st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
}
}
- st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr();
+ st->print(BULLET"method ordering: "); method_ordering()->print_value_on(st); st->cr();
+ st->print(BULLET"default_methods: "); default_methods()->print_value_on(st); st->cr();
+ if (Verbose && default_methods() != NULL) {
+ Array<Method*>* method_array = default_methods();
+ for (int i = 0; i < method_array->length(); i++) {
+ st->print("%d : ", i); method_array->at(i)->print_value(); st->cr();
+ }
+ }
+ if (default_vtable_indices() != NULL) {
+ st->print(BULLET"default vtable indices: "); default_vtable_indices()->print_value_on(st); st->cr();
+ }
st->print(BULLET"local interfaces: "); local_interfaces()->print_value_on(st); st->cr();
st->print(BULLET"trans. interfaces: "); transitive_interfaces()->print_value_on(st); st->cr();
st->print(BULLET"constants: "); constants()->print_value_on(st); st->cr();
@@ -3099,6 +3196,19 @@
}
}
+ // Verify default methods
+ if (default_methods() != NULL) {
+ Array<Method*>* methods = this->default_methods();
+ for (int j = 0; j < methods->length(); j++) {
+ guarantee(methods->at(j)->is_method(), "non-method in methods array");
+ }
+ for (int j = 0; j < methods->length() - 1; j++) {
+ Method* m1 = methods->at(j);
+ Method* m2 = methods->at(j + 1);
+ guarantee(m1->name()->fast_compare(m2->name()) <= 0, "methods not sorted correctly");
+ }
+ }
+
// Verify JNI static field identifiers
if (jni_ids() != NULL) {
jni_ids()->verify(this);
--- a/hotspot/src/share/vm/oops/instanceKlass.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/instanceKlass.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -269,12 +269,18 @@
// Method array.
Array<Method*>* _methods;
+ // Default Method Array, concrete methods inherited from interfaces
+ Array<Method*>* _default_methods;
// Interface (Klass*s) this class declares locally to implement.
Array<Klass*>* _local_interfaces;
// Interface (Klass*s) this class implements transitively.
Array<Klass*>* _transitive_interfaces;
// Int array containing the original order of method in the class file (for JVMTI).
Array<int>* _method_ordering;
+ // Int array containing the vtable_indices for default_methods
+ // offset matches _default_methods offset
+ Array<int>* _default_vtable_indices;
+
// Instance and static variable information, starts with 6-tuples of shorts
// [access, name index, sig index, initval index, low_offset, high_offset]
// for all fields, followed by the generic signature data at the end of
@@ -356,6 +362,15 @@
void set_method_ordering(Array<int>* m) { _method_ordering = m; }
void copy_method_ordering(intArray* m, TRAPS);
+ // default_methods
+ Array<Method*>* default_methods() const { return _default_methods; }
+ void set_default_methods(Array<Method*>* a) { _default_methods = a; }
+
+ // default method vtable_indices
+ Array<int>* default_vtable_indices() const { return _default_vtable_indices; }
+ void set_default_vtable_indices(Array<int>* v) { _default_vtable_indices = v; }
+ Array<int>* create_new_default_vtable_indices(int len, TRAPS);
+
// interfaces
Array<Klass*>* local_interfaces() const { return _local_interfaces; }
void set_local_interfaces(Array<Klass*>* a) {
@@ -501,12 +516,18 @@
Method* find_method(Symbol* name, Symbol* signature) const;
static Method* find_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
+ // find a local method index in default_methods (returns -1 if not found)
+ static int find_method_index(Array<Method*>* methods, Symbol* name, Symbol* signature);
+
// lookup operation (returns NULL if not found)
Method* uncached_lookup_method(Symbol* name, Symbol* signature) const;
// lookup a method in all the interfaces that this class implements
// (returns NULL if not found)
Method* lookup_method_in_all_interfaces(Symbol* name, Symbol* signature) const;
+ // lookup a method in local defaults then in all interfaces
+ // (returns NULL if not found)
+ Method* lookup_method_in_ordered_interfaces(Symbol* name, Symbol* signature) const;
// Find method indices by name. If a method with the specified name is
// found the index to the first method is returned, and 'end' is filled in
@@ -910,6 +931,11 @@
klassItable* itable() const; // return new klassItable wrapper
Method* method_at_itable(Klass* holder, int index, TRAPS);
+#if INCLUDE_JVMTI
+ void adjust_default_methods(Method** old_methods, Method** new_methods,
+ int methods_length, bool* trace_name_printed);
+#endif // INCLUDE_JVMTI
+
// Garbage collection
void oop_follow_contents(oop obj);
int oop_adjust_pointers(oop obj);
@@ -995,7 +1021,7 @@
// Must be one per class and it has to be a VM internal object so java code
// cannot lock it (like the mirror).
// It has to be an object not a Mutex because it's held through java calls.
- volatile oop init_lock() const;
+ oop init_lock() const;
private:
// Static methods that are used to implement member methods where an exposed this pointer
--- a/hotspot/src/share/vm/oops/klassVtable.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/klassVtable.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -83,7 +83,7 @@
GrowableArray<Method*> new_mirandas(20);
// compute the number of mirandas methods that must be added to the end
- get_mirandas(&new_mirandas, all_mirandas, super, methods, local_interfaces);
+ get_mirandas(&new_mirandas, all_mirandas, super, methods, NULL, local_interfaces);
*num_new_mirandas = new_mirandas.length();
vtable_length += *num_new_mirandas * vtableEntry::size();
@@ -186,7 +186,7 @@
assert(methods->at(i)->is_method(), "must be a Method*");
methodHandle mh(THREAD, methods->at(i));
- bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, checkconstraints, CHECK);
+ bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, -1, checkconstraints, CHECK);
if (needs_new_entry) {
put_method_at(mh(), initialized);
@@ -195,7 +195,35 @@
}
}
- // add miranda methods to end of vtable.
+ // update vtable with default_methods
+ Array<Method*>* default_methods = ik()->default_methods();
+ if (default_methods != NULL) {
+ len = default_methods->length();
+ if (len > 0) {
+ Array<int>* def_vtable_indices = NULL;
+ if ((def_vtable_indices = ik()->default_vtable_indices()) == NULL) {
+ def_vtable_indices = ik()->create_new_default_vtable_indices(len, CHECK);
+ } else {
+ assert(def_vtable_indices->length() == len, "reinit vtable len?");
+ }
+ for (int i = 0; i < len; i++) {
+ HandleMark hm(THREAD);
+ assert(default_methods->at(i)->is_method(), "must be a Method*");
+ methodHandle mh(THREAD, default_methods->at(i));
+
+ bool needs_new_entry = update_inherited_vtable(ik(), mh, super_vtable_len, i, checkconstraints, CHECK);
+
+ // needs new entry
+ if (needs_new_entry) {
+ put_method_at(mh(), initialized);
+ def_vtable_indices->at_put(i, initialized); //set vtable index
+ initialized++;
+ }
+ }
+ }
+ }
+
+ // add miranda methods; it will also return the updated initialized
initialized = fill_in_mirandas(initialized);
// In class hierarchies where the accessibility is not increasing (i.e., going from private ->
@@ -230,14 +258,19 @@
#ifndef PRODUCT
if (PrintVtables && Verbose) {
ResourceMark rm(THREAD);
+ char* sig = target_method()->name_and_sig_as_C_string();
tty->print("transitive overriding superclass %s with %s::%s index %d, original flags: ",
supersuperklass->internal_name(),
- _klass->internal_name(), (target_method() != NULL) ?
- target_method()->name()->as_C_string() : "<NULL>", vtable_index);
+ _klass->internal_name(), sig, vtable_index);
super_method->access_flags().print_on(tty);
+ if (super_method->is_default_method()) {
+ tty->print("default");
+ }
tty->print("overriders flags: ");
target_method->access_flags().print_on(tty);
- tty->cr();
+ if (target_method->is_default_method()) {
+ tty->print("default");
+ }
}
#endif /*PRODUCT*/
break; // return found superk
@@ -258,16 +291,31 @@
// OR return true if a new vtable entry is required.
// Only called for InstanceKlass's, i.e. not for arrays
// If that changed, could not use _klass as handle for klass
-bool klassVtable::update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len,
- bool checkconstraints, TRAPS) {
+bool klassVtable::update_inherited_vtable(InstanceKlass* klass, methodHandle target_method,
+ int super_vtable_len, int default_index,
+ bool checkconstraints, TRAPS) {
ResourceMark rm;
bool allocate_new = true;
assert(klass->oop_is_instance(), "must be InstanceKlass");
- assert(klass == target_method()->method_holder(), "caller resp.");
- // Initialize the method's vtable index to "nonvirtual".
- // If we allocate a vtable entry, we will update it to a non-negative number.
- target_method()->set_vtable_index(Method::nonvirtual_vtable_index);
+ Array<int>* def_vtable_indices = NULL;
+ bool is_default = false;
+ // default methods are concrete methods in superinterfaces which are added to the vtable
+ // with their real method_holder
+ // Since vtable and itable indices share the same storage, don't touch
+ // the default method's real vtable/itable index
+ // default_vtable_indices stores the vtable value relative to this inheritor
+ if (default_index >= 0 ) {
+ is_default = true;
+ def_vtable_indices = klass->default_vtable_indices();
+ assert(def_vtable_indices != NULL, "def vtable alloc?");
+ assert(default_index <= def_vtable_indices->length(), "def vtable len?");
+ } else {
+ assert(klass == target_method()->method_holder(), "caller resp.");
+ // Initialize the method's vtable index to "nonvirtual".
+ // If we allocate a vtable entry, we will update it to a non-negative number.
+ target_method()->set_vtable_index(Method::nonvirtual_vtable_index);
+ }
// Static and <init> methods are never in
if (target_method()->is_static() || target_method()->name() == vmSymbols::object_initializer_name()) {
@@ -284,6 +332,8 @@
// An interface never allocates new vtable slots, only inherits old ones.
// This method will either be assigned its own itable index later,
// or be assigned an inherited vtable index in the loop below.
+ // default methods store their vtable indices in the inheritors default_vtable_indices
+ assert (default_index == -1, "interfaces don't store resolved default methods");
target_method()->set_vtable_index(Method::pending_itable_index);
}
@@ -307,8 +357,15 @@
Symbol* name = target_method()->name();
Symbol* signature = target_method()->signature();
- Handle target_loader(THREAD, _klass()->class_loader());
- Symbol* target_classname = _klass->name();
+
+ KlassHandle target_klass(THREAD, target_method()->method_holder());
+ if (target_klass == NULL) {
+ target_klass = _klass;
+ }
+
+ Handle target_loader(THREAD, target_klass->class_loader());
+
+ Symbol* target_classname = target_klass->name();
for(int i = 0; i < super_vtable_len; i++) {
Method* super_method = method_at(i);
// Check if method name matches
@@ -317,10 +374,14 @@
// get super_klass for method_holder for the found method
InstanceKlass* super_klass = super_method->method_holder();
- if ((super_klass->is_override(super_method, target_loader, target_classname, THREAD)) ||
- ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
- && ((super_klass = find_transitive_override(super_klass, target_method, i, target_loader,
- target_classname, THREAD)) != (InstanceKlass*)NULL))) {
+ if (is_default
+ || ((super_klass->is_override(super_method, target_loader, target_classname, THREAD))
+ || ((klass->major_version() >= VTABLE_TRANSITIVE_OVERRIDE_VERSION)
+ && ((super_klass = find_transitive_override(super_klass,
+ target_method, i, target_loader,
+ target_classname, THREAD))
+ != (InstanceKlass*)NULL))))
+ {
// overriding, so no new entry
allocate_new = false;
@@ -347,7 +408,7 @@
"%s used in the signature";
char* sig = target_method()->name_and_sig_as_C_string();
const char* loader1 = SystemDictionary::loader_name(target_loader());
- char* current = _klass->name()->as_C_string();
+ char* current = target_klass->name()->as_C_string();
const char* loader2 = SystemDictionary::loader_name(super_loader());
char* failed_type_name = failed_type_symbol->as_C_string();
size_t buflen = strlen(msg) + strlen(sig) + strlen(loader1) +
@@ -360,16 +421,39 @@
}
}
- put_method_at(target_method(), i);
- target_method()->set_vtable_index(i);
+ put_method_at(target_method(), i);
+ if (!is_default) {
+ target_method()->set_vtable_index(i);
+ } else {
+ if (def_vtable_indices != NULL) {
+ def_vtable_indices->at_put(default_index, i);
+ }
+ assert(super_method->is_default_method() || super_method->is_overpass()
+ || super_method->is_abstract(), "default override error");
+ }
+
+
#ifndef PRODUCT
if (PrintVtables && Verbose) {
+ ResourceMark rm(THREAD);
+ char* sig = target_method()->name_and_sig_as_C_string();
tty->print("overriding with %s::%s index %d, original flags: ",
- _klass->internal_name(), (target_method() != NULL) ?
- target_method()->name()->as_C_string() : "<NULL>", i);
+ target_klass->internal_name(), sig, i);
super_method->access_flags().print_on(tty);
+ if (super_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (super_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->print("overriders flags: ");
target_method->access_flags().print_on(tty);
+ if (target_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (target_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->cr();
}
#endif /*PRODUCT*/
@@ -378,12 +462,25 @@
// but not override another. Once we override one, not need new
#ifndef PRODUCT
if (PrintVtables && Verbose) {
+ ResourceMark rm(THREAD);
+ char* sig = target_method()->name_and_sig_as_C_string();
tty->print("NOT overriding with %s::%s index %d, original flags: ",
- _klass->internal_name(), (target_method() != NULL) ?
- target_method()->name()->as_C_string() : "<NULL>", i);
+ target_klass->internal_name(), sig,i);
super_method->access_flags().print_on(tty);
+ if (super_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (super_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->print("overriders flags: ");
target_method->access_flags().print_on(tty);
+ if (target_method->is_default_method()) {
+ tty->print("default");
+ }
+ if (target_method->is_overpass()) {
+ tty->print("overpass");
+ }
tty->cr();
}
#endif /*PRODUCT*/
@@ -438,6 +535,14 @@
return false;
}
+ // Concrete interface methods do not need new entries, they override
+ // abstract method entries using default inheritance rules
+ if (target_method()->method_holder() != NULL &&
+ target_method()->method_holder()->is_interface() &&
+ !target_method()->is_abstract() ) {
+ return false;
+ }
+
// we need a new entry if there is no superclass
if (super == NULL) {
return true;
@@ -446,7 +551,7 @@
// private methods in classes always have a new entry in the vtable
// specification interpretation since classic has
// private methods not overriding
- // JDK8 adds private methods in interfaces which require invokespecial
+ // JDK8 adds private methods in interfaces which require invokespecial
if (target_method()->is_private()) {
return true;
}
@@ -526,35 +631,40 @@
if (mhk->is_interface()) {
assert(m->is_public(), "should be public");
assert(ik()->implements_interface(method_holder) , "this class should implement the interface");
- assert(is_miranda(m, ik()->methods(), ik()->super()), "should be a miranda_method");
+ assert(is_miranda(m, ik()->methods(), ik()->default_methods(), ik()->super()), "should be a miranda_method");
return true;
}
return false;
}
-// check if a method is a miranda method, given a class's methods table and its super
-// "miranda" means not static, not defined by this class, and not defined
-// in super unless it is private and therefore inaccessible to this class.
+// check if a method is a miranda method, given a class's methods table,
+// its default_method table and its super
+// "miranda" means not static, not defined by this class.
+// private methods in interfaces do not belong in the miranda list.
// the caller must make sure that the method belongs to an interface implemented by the class
// Miranda methods only include public interface instance methods
-// Not private methods, not static methods, not default = concrete abstract
-bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods, Klass* super) {
- if (m->is_static()) {
+// Not private methods, not static methods, not default == concrete abstract
+bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
+ Array<Method*>* default_methods, Klass* super) {
+ if (m->is_static() || m->is_private()) {
return false;
}
Symbol* name = m->name();
Symbol* signature = m->signature();
if (InstanceKlass::find_method(class_methods, name, signature) == NULL) {
// did not find it in the method table of the current class
- if (super == NULL) {
- // super doesn't exist
- return true;
- }
+ if ((default_methods == NULL) ||
+ InstanceKlass::find_method(default_methods, name, signature) == NULL) {
+ if (super == NULL) {
+ // super doesn't exist
+ return true;
+ }
- Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
- if (mo == NULL || mo->access_flags().is_private() ) {
- // super class hierarchy does not implement it or protection is different
- return true;
+ Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
+ if (mo == NULL || mo->access_flags().is_private() ) {
+ // super class hierarchy does not implement it or protection is different
+ return true;
+ }
}
}
@@ -562,7 +672,7 @@
}
// Scans current_interface_methods for miranda methods that do not
-// already appear in new_mirandas and are also not defined-and-non-private
+// already appear in new_mirandas, or default methods, and are also not defined-and-non-private
// in super (superclass). These mirandas are added to all_mirandas if it is
// not null; in addition, those that are not duplicates of miranda methods
// inherited by super from its interfaces are added to new_mirandas.
@@ -572,7 +682,8 @@
void klassVtable::add_new_mirandas_to_lists(
GrowableArray<Method*>* new_mirandas, GrowableArray<Method*>* all_mirandas,
Array<Method*>* current_interface_methods, Array<Method*>* class_methods,
- Klass* super) {
+ Array<Method*>* default_methods, Klass* super) {
+
// iterate thru the current interface's method to see if it a miranda
int num_methods = current_interface_methods->length();
for (int i = 0; i < num_methods; i++) {
@@ -590,7 +701,7 @@
}
if (!is_duplicate) { // we don't want duplicate miranda entries in the vtable
- if (is_miranda(im, class_methods, super)) { // is it a miranda at all?
+ if (is_miranda(im, class_methods, default_methods, super)) { // is it a miranda at all?
InstanceKlass *sk = InstanceKlass::cast(super);
// check if it is a duplicate of a super's miranda
if (sk->lookup_method_in_all_interfaces(im->name(), im->signature()) == NULL) {
@@ -607,6 +718,7 @@
void klassVtable::get_mirandas(GrowableArray<Method*>* new_mirandas,
GrowableArray<Method*>* all_mirandas,
Klass* super, Array<Method*>* class_methods,
+ Array<Method*>* default_methods,
Array<Klass*>* local_interfaces) {
assert((new_mirandas->length() == 0) , "current mirandas must be 0");
@@ -615,14 +727,16 @@
for (int i = 0; i < num_local_ifs; i++) {
InstanceKlass *ik = InstanceKlass::cast(local_interfaces->at(i));
add_new_mirandas_to_lists(new_mirandas, all_mirandas,
- ik->methods(), class_methods, super);
+ ik->methods(), class_methods,
+ default_methods, super);
// iterate thru each local's super interfaces
Array<Klass*>* super_ifs = ik->transitive_interfaces();
int num_super_ifs = super_ifs->length();
for (int j = 0; j < num_super_ifs; j++) {
InstanceKlass *sik = InstanceKlass::cast(super_ifs->at(j));
add_new_mirandas_to_lists(new_mirandas, all_mirandas,
- sik->methods(), class_methods, super);
+ sik->methods(), class_methods,
+ default_methods, super);
}
}
}
@@ -633,8 +747,22 @@
int klassVtable::fill_in_mirandas(int initialized) {
GrowableArray<Method*> mirandas(20);
get_mirandas(&mirandas, NULL, ik()->super(), ik()->methods(),
- ik()->local_interfaces());
+ ik()->default_methods(), ik()->local_interfaces());
for (int i = 0; i < mirandas.length(); i++) {
+ if (PrintVtables && Verbose) {
+ Method* meth = mirandas.at(i);
+ ResourceMark rm(Thread::current());
+ if (meth != NULL) {
+ char* sig = meth->name_and_sig_as_C_string();
+ tty->print("fill in mirandas with %s index %d, flags: ",
+ sig, initialized);
+ meth->access_flags().print_on(tty);
+ if (meth->is_default_method()) {
+ tty->print("default");
+ }
+ tty->cr();
+ }
+ }
put_method_at(mirandas.at(i), initialized);
++initialized;
}
@@ -648,6 +776,26 @@
}
#if INCLUDE_JVMTI
+bool klassVtable::adjust_default_method(int vtable_index, Method* old_method, Method* new_method) {
+ // If old_method is default, find this vtable index in default_vtable_indices
+ // and replace that method in the _default_methods list
+ bool updated = false;
+
+ Array<Method*>* default_methods = ik()->default_methods();
+ if (default_methods != NULL) {
+ int len = default_methods->length();
+ for (int idx = 0; idx < len; idx++) {
+ if (vtable_index == ik()->default_vtable_indices()->at(idx)) {
+ if (default_methods->at(idx) == old_method) {
+ default_methods->at_put(idx, new_method);
+ updated = true;
+ }
+ break;
+ }
+ }
+ }
+ return updated;
+}
void klassVtable::adjust_method_entries(Method** old_methods, Method** new_methods,
int methods_length, bool * trace_name_printed) {
// search the vtable for uses of either obsolete or EMCP methods
@@ -663,18 +811,26 @@
for (int index = 0; index < length(); index++) {
if (unchecked_method_at(index) == old_method) {
put_method_at(new_method, index);
+ // For default methods, need to update the _default_methods array
+ // which can only have one method entry for a given signature
+ bool updated_default = false;
+ if (old_method->is_default_method()) {
+ updated_default = adjust_default_method(index, old_method, new_method);
+ }
if (RC_TRACE_IN_RANGE(0x00100000, 0x00400000)) {
if (!(*trace_name_printed)) {
// RC_TRACE_MESG macro has an embedded ResourceMark
- RC_TRACE_MESG(("adjust: name=%s",
+ RC_TRACE_MESG(("adjust: klassname=%s for methods from name=%s",
+ klass()->external_name(),
old_method->method_holder()->external_name()));
*trace_name_printed = true;
}
// RC_TRACE macro has an embedded ResourceMark
- RC_TRACE(0x00100000, ("vtable method update: %s(%s)",
+ RC_TRACE(0x00100000, ("vtable method update: %s(%s), updated default = %s",
new_method->name()->as_C_string(),
- new_method->signature()->as_C_string()));
+ new_method->signature()->as_C_string(),
+ updated_default ? "true" : "false"));
}
// cannot 'break' here; see for-loop comment above.
}
@@ -701,6 +857,12 @@
if (m != NULL) {
tty->print(" (%5d) ", i);
m->access_flags().print_on(tty);
+ if (m->is_default_method()) {
+ tty->print("default");
+ }
+ if (m->is_overpass()) {
+ tty->print("overpass");
+ }
tty->print(" -- ");
m->print_name(tty);
tty->cr();
@@ -757,9 +919,9 @@
// Initialization
void klassItable::initialize_itable(bool checkconstraints, TRAPS) {
if (_klass->is_interface()) {
- // This needs to go after vtable indexes are assigned but
- // before implementors need to know the number of itable indexes.
- assign_itable_indexes_for_interface(_klass());
+ // This needs to go after vtable indices are assigned but
+ // before implementors need to know the number of itable indices.
+ assign_itable_indices_for_interface(_klass());
}
// Cannot be setup doing bootstrapping, interfaces don't have
@@ -803,7 +965,7 @@
return true;
}
-int klassItable::assign_itable_indexes_for_interface(Klass* klass) {
+int klassItable::assign_itable_indices_for_interface(Klass* klass) {
// an interface does not have an itable, but its methods need to be numbered
if (TraceItables) tty->print_cr("%3d: Initializing itable for interface %s", ++initialize_count,
klass->name()->as_C_string());
@@ -846,7 +1008,7 @@
}
nof_methods -= 1;
}
- // no methods have itable indexes
+ // no methods have itable indices
return 0;
}
@@ -907,6 +1069,21 @@
int ime_num = m->itable_index();
assert(ime_num < ime_count, "oob");
itableOffsetEntry::method_entry(_klass(), method_table_offset)[ime_num].initialize(target());
+ if (TraceItables && Verbose) {
+ ResourceMark rm(THREAD);
+ if (target() != NULL) {
+ char* sig = target()->name_and_sig_as_C_string();
+ tty->print("interface: %s, ime_num: %d, target: %s, method_holder: %s ",
+ interf_h()->internal_name(), ime_num, sig,
+ target()->method_holder()->internal_name());
+ tty->print("target_method flags: ");
+ target()->access_flags().print_on(tty);
+ if (target()->is_default_method()) {
+ tty->print("default");
+ }
+ tty->cr();
+ }
+ }
}
}
}
@@ -980,6 +1157,9 @@
if (m != NULL) {
tty->print(" (%5d) ", i);
m->access_flags().print_on(tty);
+ if (m->is_default_method()) {
+ tty->print("default");
+ }
tty->print(" -- ");
m->print_name(tty);
tty->cr();
@@ -1116,7 +1296,7 @@
Array<Method*>* methods = InstanceKlass::cast(intf)->methods();
if (itable_index < 0 || itable_index >= method_count_for_interface(intf))
- return NULL; // help caller defend against bad indexes
+ return NULL; // help caller defend against bad indices
int index = itable_index;
Method* m = methods->at(index);
--- a/hotspot/src/share/vm/oops/klassVtable.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/klassVtable.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -97,6 +97,7 @@
// trace_name_printed is set to true if the current call has
// printed the klass name so that other routines in the adjust_*
// group don't print the klass name.
+ bool adjust_default_method(int vtable_index, Method* old_method, Method* new_method);
void adjust_method_entries(Method** old_methods, Method** new_methods,
int methods_length, bool * trace_name_printed);
bool check_no_old_or_obsolete_entries();
@@ -118,24 +119,28 @@
void put_method_at(Method* m, int index);
static bool needs_new_vtable_entry(methodHandle m, Klass* super, Handle classloader, Symbol* classname, AccessFlags access_flags, TRAPS);
- bool update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len, bool checkconstraints, TRAPS);
+ bool update_inherited_vtable(InstanceKlass* klass, methodHandle target_method, int super_vtable_len, int default_index, bool checkconstraints, TRAPS);
InstanceKlass* find_transitive_override(InstanceKlass* initialsuper, methodHandle target_method, int vtable_index,
Handle target_loader, Symbol* target_classname, Thread* THREAD);
// support for miranda methods
bool is_miranda_entry_at(int i);
int fill_in_mirandas(int initialized);
- static bool is_miranda(Method* m, Array<Method*>* class_methods, Klass* super);
+ static bool is_miranda(Method* m, Array<Method*>* class_methods,
+ Array<Method*>* default_methods, Klass* super);
static void add_new_mirandas_to_lists(
GrowableArray<Method*>* new_mirandas,
GrowableArray<Method*>* all_mirandas,
- Array<Method*>* current_interface_methods, Array<Method*>* class_methods,
+ Array<Method*>* current_interface_methods,
+ Array<Method*>* class_methods,
+ Array<Method*>* default_methods,
Klass* super);
static void get_mirandas(
GrowableArray<Method*>* new_mirandas,
GrowableArray<Method*>* all_mirandas, Klass* super,
- Array<Method*>* class_methods, Array<Klass*>* local_interfaces);
-
+ Array<Method*>* class_methods,
+ Array<Method*>* default_methods,
+ Array<Klass*>* local_interfaces);
void verify_against(outputStream* st, klassVtable* vt, int index);
inline InstanceKlass* ik() const;
};
@@ -290,7 +295,7 @@
#endif // INCLUDE_JVMTI
// Setup of itable
- static int assign_itable_indexes_for_interface(Klass* klass);
+ static int assign_itable_indices_for_interface(Klass* klass);
static int method_count_for_interface(Klass* klass);
static int compute_itable_size(Array<Klass*>* transitive_interfaces);
static void setup_itable_offset_table(instanceKlassHandle klass);
--- a/hotspot/src/share/vm/oops/method.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/method.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -511,9 +511,9 @@
bool Method::is_final_method(AccessFlags class_access_flags) const {
// or "does_not_require_vtable_entry"
- // overpass can occur, is not final (reuses vtable entry)
+ // default method or overpass can occur, is not final (reuses vtable entry)
// private methods get vtable entries for backward class compatibility.
- if (is_overpass()) return false;
+ if (is_overpass() || is_default_method()) return false;
return is_final() || class_access_flags.is_final();
}
@@ -521,11 +521,24 @@
return is_final_method(method_holder()->access_flags());
}
+bool Method::is_default_method() const {
+ if (method_holder() != NULL &&
+ method_holder()->is_interface() &&
+ !is_abstract()) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
bool Method::can_be_statically_bound(AccessFlags class_access_flags) const {
if (is_final_method(class_access_flags)) return true;
#ifdef ASSERT
+ ResourceMark rm;
bool is_nonv = (vtable_index() == nonvirtual_vtable_index);
- if (class_access_flags.is_interface()) assert(is_nonv == is_static(), err_msg("is_nonv=%s", is_nonv));
+ if (class_access_flags.is_interface()) {
+ assert(is_nonv == is_static(), err_msg("is_nonv=%s", name_and_sig_as_C_string()));
+ }
#endif
assert(valid_vtable_index() || valid_itable_index(), "method must be linked before we ask this question");
return vtable_index() == nonvirtual_vtable_index;
@@ -1371,7 +1384,8 @@
}
// This is only done during class loading, so it is OK to assume method_idnum matches the methods() array
-void Method::sort_methods(Array<Method*>* methods, bool idempotent) {
+// default_methods also uses this without the ordering for fast find_method
+void Method::sort_methods(Array<Method*>* methods, bool idempotent, bool set_idnums) {
int length = methods->length();
if (length > 1) {
{
@@ -1379,14 +1393,15 @@
QuickSort::sort<Method*>(methods->data(), length, method_comparator, idempotent);
}
// Reset method ordering
- for (int i = 0; i < length; i++) {
- Method* m = methods->at(i);
- m->set_method_idnum(i);
+ if (set_idnums) {
+ for (int i = 0; i < length; i++) {
+ Method* m = methods->at(i);
+ m->set_method_idnum(i);
+ }
}
}
}
-
//-----------------------------------------------------------------------------------
// Non-product code unless JVM/TI needs it
--- a/hotspot/src/share/vm/oops/method.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/oops/method.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -567,6 +567,7 @@
// checks method and its method holder
bool is_final_method() const;
bool is_final_method(AccessFlags class_access_flags) const;
+ bool is_default_method() const;
// true if method needs no dynamic dispatch (final and/or no vtable entry)
bool can_be_statically_bound() const;
@@ -846,7 +847,7 @@
#endif
// Helper routine used for method sorting
- static void sort_methods(Array<Method*>* methods, bool idempotent = false);
+ static void sort_methods(Array<Method*>* methods, bool idempotent = false, bool set_idnums = true);
// Deallocation function for redefine classes or if an error occurs
void deallocate_contents(ClassLoaderData* loader_data);
--- a/hotspot/src/share/vm/opto/graphKit.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/opto/graphKit.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -3713,7 +3713,8 @@
Node* no_base = __ top();
float likely = PROB_LIKELY(0.999);
float unlikely = PROB_UNLIKELY(0.999);
- Node* zero = __ ConI(0);
+ Node* young_card = __ ConI((jint)G1SATBCardTableModRefBS::g1_young_card_val());
+ Node* dirty_card = __ ConI((jint)CardTableModRefBS::dirty_card_val());
Node* zeroX = __ ConX(0);
// Get the alias_index for raw card-mark memory
@@ -3769,8 +3770,16 @@
// load the original value of the card
Node* card_val = __ load(__ ctrl(), card_adr, TypeInt::INT, T_BYTE, Compile::AliasIdxRaw);
- __ if_then(card_val, BoolTest::ne, zero); {
- g1_mark_card(ideal, card_adr, oop_store, alias_idx, index, index_adr, buffer, tf);
+ __ if_then(card_val, BoolTest::ne, young_card); {
+ sync_kit(ideal);
+ // Use Op_MemBarVolatile to achieve the effect of a StoreLoad barrier.
+ insert_mem_bar(Op_MemBarVolatile, oop_store);
+ __ sync_kit(this);
+
+ Node* card_val_reload = __ load(__ ctrl(), card_adr, TypeInt::INT, T_BYTE, Compile::AliasIdxRaw);
+ __ if_then(card_val_reload, BoolTest::ne, dirty_card); {
+ g1_mark_card(ideal, card_adr, oop_store, alias_idx, index, index_adr, buffer, tf);
+ } __ end_if();
} __ end_if();
} __ end_if();
} __ end_if();
--- a/hotspot/src/share/vm/prims/jni.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jni.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1591,10 +1591,8 @@
}
} else {
m = klass->lookup_method(name, signature);
- // Look up interfaces
- if (m == NULL && klass->oop_is_instance()) {
- m = InstanceKlass::cast(klass())->lookup_method_in_all_interfaces(name,
- signature);
+ if (m == NULL && klass->oop_is_instance()) {
+ m = InstanceKlass::cast(klass())->lookup_method_in_ordered_interfaces(name, signature);
}
}
if (m == NULL || (m->is_static() != is_static)) {
@@ -3210,7 +3208,11 @@
HOTSPOT_JNI_GETSTRINGLENGTH_ENTRY(
env, string);
#endif /* USDT2 */
- jsize ret = java_lang_String::length(JNIHandles::resolve_non_null(string));
+ jsize ret = 0;
+ oop s = JNIHandles::resolve_non_null(string);
+ if (java_lang_String::value(s) != NULL) {
+ ret = java_lang_String::length(s);
+ }
#ifndef USDT2
DTRACE_PROBE1(hotspot_jni, GetStringLength__return, ret);
#else /* USDT2 */
@@ -3230,20 +3232,23 @@
HOTSPOT_JNI_GETSTRINGCHARS_ENTRY(
env, string, (uintptr_t *) isCopy);
#endif /* USDT2 */
+ jchar* buf = NULL;
oop s = JNIHandles::resolve_non_null(string);
- int s_len = java_lang_String::length(s);
typeArrayOop s_value = java_lang_String::value(s);
- int s_offset = java_lang_String::offset(s);
- jchar* buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal); // add one for zero termination
- /* JNI Specification states return NULL on OOM */
- if (buf != NULL) {
- if (s_len > 0) {
- memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
- }
- buf[s_len] = 0;
- //%note jni_5
- if (isCopy != NULL) {
- *isCopy = JNI_TRUE;
+ if (s_value != NULL) {
+ int s_len = java_lang_String::length(s);
+ int s_offset = java_lang_String::offset(s);
+ buf = NEW_C_HEAP_ARRAY_RETURN_NULL(jchar, s_len + 1, mtInternal); // add one for zero termination
+ /* JNI Specification states return NULL on OOM */
+ if (buf != NULL) {
+ if (s_len > 0) {
+ memcpy(buf, s_value->char_at_addr(s_offset), sizeof(jchar)*s_len);
+ }
+ buf[s_len] = 0;
+ //%note jni_5
+ if (isCopy != NULL) {
+ *isCopy = JNI_TRUE;
+ }
}
}
#ifndef USDT2
@@ -3313,7 +3318,11 @@
HOTSPOT_JNI_GETSTRINGUTFLENGTH_ENTRY(
env, string);
#endif /* USDT2 */
- jsize ret = java_lang_String::utf8_length(JNIHandles::resolve_non_null(string));
+ jsize ret = 0;
+ oop java_string = JNIHandles::resolve_non_null(string);
+ if (java_lang_String::value(java_string) != NULL) {
+ ret = java_lang_String::utf8_length(java_string);
+ }
#ifndef USDT2
DTRACE_PROBE1(hotspot_jni, GetStringUTFLength__return, ret);
#else /* USDT2 */
@@ -3332,14 +3341,17 @@
HOTSPOT_JNI_GETSTRINGUTFCHARS_ENTRY(
env, string, (uintptr_t *) isCopy);
#endif /* USDT2 */
+ char* result = NULL;
oop java_string = JNIHandles::resolve_non_null(string);
- size_t length = java_lang_String::utf8_length(java_string);
- /* JNI Specification states return NULL on OOM */
- char* result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
- if (result != NULL) {
- java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
- if (isCopy != NULL) {
- *isCopy = JNI_TRUE;
+ if (java_lang_String::value(java_string) != NULL) {
+ size_t length = java_lang_String::utf8_length(java_string);
+ /* JNI Specification states return NULL on OOM */
+ result = AllocateHeap(length + 1, mtInternal, 0, AllocFailStrategy::RETURN_NULL);
+ if (result != NULL) {
+ java_lang_String::as_utf8_string(java_string, result, (int) length + 1);
+ if (isCopy != NULL) {
+ *isCopy = JNI_TRUE;
+ }
}
}
#ifndef USDT2
--- a/hotspot/src/share/vm/prims/jniCheck.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jniCheck.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1324,18 +1324,19 @@
IN_VM(
checkString(thr, str);
)
+ jchar* newResult = NULL;
const jchar *result = UNCHECKED()->GetStringChars(env,str,isCopy);
assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringChars didn't return a copy as expected");
-
- size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination
- jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), mtInternal);
- *tagLocation = STRING_TAG;
- jchar* newResult = (jchar*) (tagLocation + 1);
- memcpy(newResult, result, len * sizeof(jchar));
- // Avoiding call to UNCHECKED()->ReleaseStringChars() since that will fire unexpected dtrace probes
- // Note that the dtrace arguments for the allocated memory will not match up with this solution.
- FreeHeap((char*)result);
-
+ if (result != NULL) {
+ size_t len = UNCHECKED()->GetStringLength(env,str) + 1; // + 1 for NULL termination
+ jint* tagLocation = (jint*) AllocateHeap(len * sizeof(jchar) + sizeof(jint), mtInternal);
+ *tagLocation = STRING_TAG;
+ newResult = (jchar*) (tagLocation + 1);
+ memcpy(newResult, result, len * sizeof(jchar));
+ // Avoiding call to UNCHECKED()->ReleaseStringChars() since that will fire unexpected dtrace probes
+ // Note that the dtrace arguments for the allocated memory will not match up with this solution.
+ FreeHeap((char*)result);
+ }
functionExit(env);
return newResult;
JNI_END
@@ -1394,18 +1395,19 @@
IN_VM(
checkString(thr, str);
)
+ char* newResult = NULL;
const char *result = UNCHECKED()->GetStringUTFChars(env,str,isCopy);
assert (isCopy == NULL || *isCopy == JNI_TRUE, "GetStringUTFChars didn't return a copy as expected");
-
- size_t len = strlen(result) + 1; // + 1 for NULL termination
- jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), mtInternal);
- *tagLocation = STRING_UTF_TAG;
- char* newResult = (char*) (tagLocation + 1);
- strcpy(newResult, result);
- // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes
- // Note that the dtrace arguments for the allocated memory will not match up with this solution.
- FreeHeap((char*)result, mtInternal);
-
+ if (result != NULL) {
+ size_t len = strlen(result) + 1; // + 1 for NULL termination
+ jint* tagLocation = (jint*) AllocateHeap(len + sizeof(jint), mtInternal);
+ *tagLocation = STRING_UTF_TAG;
+ newResult = (char*) (tagLocation + 1);
+ strcpy(newResult, result);
+ // Avoiding call to UNCHECKED()->ReleaseStringUTFChars() since that will fire unexpected dtrace probes
+ // Note that the dtrace arguments for the allocated memory will not match up with this solution.
+ FreeHeap((char*)result, mtInternal);
+ }
functionExit(env);
return newResult;
JNI_END
--- a/hotspot/src/share/vm/prims/jvm.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvm.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -668,13 +668,12 @@
JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
JVMWrapper("JVM_GetCallerClass");
- // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation.
- if (SystemDictionary::reflect_CallerSensitive_klass() == NULL) {
+ // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation; or
+ // sun.reflect.Reflection.getCallerClass with a depth parameter is provided
+ // temporarily for existing code to use until a replacement API is defined.
+ if (SystemDictionary::reflect_CallerSensitive_klass() == NULL || depth != JVM_CALLER_DEPTH) {
Klass* k = thread->security_get_caller_class(depth);
return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
- } else {
- // Basic handshaking with Java_sun_reflect_Reflection_getCallerClass
- assert(depth == -1, "wrong handshake depth");
}
// Getting the class of the caller frame.
@@ -3954,248 +3953,6 @@
}
-// Serialization
-JVM_ENTRY(void, JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj,
- jlongArray fieldIDs, jcharArray typecodes, jbyteArray data))
- assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier");
-
- typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes));
- typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data));
- typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs));
- oop o = JNIHandles::resolve(obj);
-
- if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
-
- jsize nfids = fids->length();
- if (nfids == 0) return;
-
- if (tcodes->length() < nfids) {
- THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
- }
-
- jsize off = 0;
- /* loop through fields, setting values */
- for (jsize i = 0; i < nfids; i++) {
- jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i);
- int field_offset;
- if (fid != NULL) {
- // NULL is a legal value for fid, but retrieving the field offset
- // trigger assertion in that case
- field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid);
- }
-
- switch (tcodes->char_at(i)) {
- case 'Z':
- if (fid != NULL) {
- jboolean val = (dbuf->byte_at(off) != 0) ? JNI_TRUE : JNI_FALSE;
- o->bool_field_put(field_offset, val);
- }
- off++;
- break;
-
- case 'B':
- if (fid != NULL) {
- o->byte_field_put(field_offset, dbuf->byte_at(off));
- }
- off++;
- break;
-
- case 'C':
- if (fid != NULL) {
- jchar val = ((dbuf->byte_at(off + 0) & 0xFF) << 8)
- + ((dbuf->byte_at(off + 1) & 0xFF) << 0);
- o->char_field_put(field_offset, val);
- }
- off += 2;
- break;
-
- case 'S':
- if (fid != NULL) {
- jshort val = ((dbuf->byte_at(off + 0) & 0xFF) << 8)
- + ((dbuf->byte_at(off + 1) & 0xFF) << 0);
- o->short_field_put(field_offset, val);
- }
- off += 2;
- break;
-
- case 'I':
- if (fid != NULL) {
- jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24)
- + ((dbuf->byte_at(off + 1) & 0xFF) << 16)
- + ((dbuf->byte_at(off + 2) & 0xFF) << 8)
- + ((dbuf->byte_at(off + 3) & 0xFF) << 0);
- o->int_field_put(field_offset, ival);
- }
- off += 4;
- break;
-
- case 'F':
- if (fid != NULL) {
- jint ival = ((dbuf->byte_at(off + 0) & 0xFF) << 24)
- + ((dbuf->byte_at(off + 1) & 0xFF) << 16)
- + ((dbuf->byte_at(off + 2) & 0xFF) << 8)
- + ((dbuf->byte_at(off + 3) & 0xFF) << 0);
- jfloat fval = (*int_bits_to_float_fn)(env, NULL, ival);
- o->float_field_put(field_offset, fval);
- }
- off += 4;
- break;
-
- case 'J':
- if (fid != NULL) {
- jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56)
- + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48)
- + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40)
- + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32)
- + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24)
- + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16)
- + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8)
- + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0);
- o->long_field_put(field_offset, lval);
- }
- off += 8;
- break;
-
- case 'D':
- if (fid != NULL) {
- jlong lval = (((jlong) dbuf->byte_at(off + 0) & 0xFF) << 56)
- + (((jlong) dbuf->byte_at(off + 1) & 0xFF) << 48)
- + (((jlong) dbuf->byte_at(off + 2) & 0xFF) << 40)
- + (((jlong) dbuf->byte_at(off + 3) & 0xFF) << 32)
- + (((jlong) dbuf->byte_at(off + 4) & 0xFF) << 24)
- + (((jlong) dbuf->byte_at(off + 5) & 0xFF) << 16)
- + (((jlong) dbuf->byte_at(off + 6) & 0xFF) << 8)
- + (((jlong) dbuf->byte_at(off + 7) & 0xFF) << 0);
- jdouble dval = (*long_bits_to_double_fn)(env, NULL, lval);
- o->double_field_put(field_offset, dval);
- }
- off += 8;
- break;
-
- default:
- // Illegal typecode
- THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode");
- }
- }
-JVM_END
-
-
-JVM_ENTRY(void, JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj,
- jlongArray fieldIDs, jcharArray typecodes, jbyteArray data))
- assert(!JDK_Version::is_gte_jdk14x_version(), "should only be used in 1.3.1 and earlier");
-
- typeArrayOop tcodes = typeArrayOop(JNIHandles::resolve(typecodes));
- typeArrayOop dbuf = typeArrayOop(JNIHandles::resolve(data));
- typeArrayOop fids = typeArrayOop(JNIHandles::resolve(fieldIDs));
- oop o = JNIHandles::resolve(obj);
-
- if (o == NULL || fids == NULL || dbuf == NULL || tcodes == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
-
- jsize nfids = fids->length();
- if (nfids == 0) return;
-
- if (tcodes->length() < nfids) {
- THROW(vmSymbols::java_lang_ArrayIndexOutOfBoundsException());
- }
-
- /* loop through fields, fetching values */
- jsize off = 0;
- for (jsize i = 0; i < nfids; i++) {
- jfieldID fid = (jfieldID)(intptr_t) fids->long_at(i);
- if (fid == NULL) {
- THROW(vmSymbols::java_lang_NullPointerException());
- }
- int field_offset = jfieldIDWorkaround::from_instance_jfieldID(o->klass(), fid);
-
- switch (tcodes->char_at(i)) {
- case 'Z':
- {
- jboolean val = o->bool_field(field_offset);
- dbuf->byte_at_put(off++, (val != 0) ? 1 : 0);
- }
- break;
-
- case 'B':
- dbuf->byte_at_put(off++, o->byte_field(field_offset));
- break;
-
- case 'C':
- {
- jchar val = o->char_field(field_offset);
- dbuf->byte_at_put(off++, (val >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 0) & 0xFF);
- }
- break;
-
- case 'S':
- {
- jshort val = o->short_field(field_offset);
- dbuf->byte_at_put(off++, (val >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 0) & 0xFF);
- }
- break;
-
- case 'I':
- {
- jint val = o->int_field(field_offset);
- dbuf->byte_at_put(off++, (val >> 24) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 16) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 0) & 0xFF);
- }
- break;
-
- case 'F':
- {
- jfloat fval = o->float_field(field_offset);
- jint ival = (*float_to_int_bits_fn)(env, NULL, fval);
- dbuf->byte_at_put(off++, (ival >> 24) & 0xFF);
- dbuf->byte_at_put(off++, (ival >> 16) & 0xFF);
- dbuf->byte_at_put(off++, (ival >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (ival >> 0) & 0xFF);
- }
- break;
-
- case 'J':
- {
- jlong val = o->long_field(field_offset);
- dbuf->byte_at_put(off++, (val >> 56) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 48) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 40) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 32) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 24) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 16) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (val >> 0) & 0xFF);
- }
- break;
-
- case 'D':
- {
- jdouble dval = o->double_field(field_offset);
- jlong lval = (*double_to_long_bits_fn)(env, NULL, dval);
- dbuf->byte_at_put(off++, (lval >> 56) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 48) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 40) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 32) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 24) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 16) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 8) & 0xFF);
- dbuf->byte_at_put(off++, (lval >> 0) & 0xFF);
- }
- break;
-
- default:
- // Illegal typecode
- THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "illegal typecode");
- }
- }
-JVM_END
-
// Shared JNI/JVM entry points //////////////////////////////////////////////////////////////
--- a/hotspot/src/share/vm/prims/jvm.h Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvm.h Fri Oct 11 13:00:40 2013 -0700
@@ -374,6 +374,9 @@
/*
* java.lang.Class and java.lang.ClassLoader
*/
+
+#define JVM_CALLER_DEPTH -1
+
/*
* Returns the class in which the code invoking the native method
* belongs.
--- a/hotspot/src/share/vm/prims/jvm_misc.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvm_misc.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -36,22 +36,6 @@
void trace_class_resolution(Klass* to_class);
/*
- * Support for Serialization and RMI. Currently used by HotSpot only.
- */
-
-extern "C" {
-
-void JNICALL
-JVM_SetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj,
- jlongArray fieldIDs, jcharArray typecodes, jbyteArray data);
-
-void JNICALL
-JVM_GetPrimitiveFieldValues(JNIEnv *env, jclass cb, jobject obj,
- jlongArray fieldIDs, jcharArray typecodes, jbyteArray data);
-
-}
-
-/*
* Support for -Xcheck:jni
*/
--- a/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/jvmtiRedefineClasses.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -2755,13 +2755,26 @@
// InstanceKlass around to hold obsolete methods so we don't have
// any other InstanceKlass embedded vtables to update. The vtable
// holds the Method*s for virtual (but not final) methods.
- if (ik->vtable_length() > 0 && ik->is_subtype_of(_the_class_oop)) {
+ // Default methods, or concrete methods in interfaces are stored
+ // in the vtable, so if an interface changes we need to check
+ // adjust_method_entries() for every InstanceKlass, which will also
+ // adjust the default method vtable indices.
+ // We also need to adjust any default method entries that are
+ // not yet in the vtable, because the vtable setup is in progress.
+ // This must be done after we adjust the default_methods and
+ // default_vtable_indices for methods already in the vtable.
+ if (ik->vtable_length() > 0 && (_the_class_oop->is_interface()
+ || ik->is_subtype_of(_the_class_oop))) {
// ik->vtable() creates a wrapper object; rm cleans it up
ResourceMark rm(_thread);
ik->vtable()->adjust_method_entries(_matching_old_methods,
_matching_new_methods,
_matching_methods_length,
&trace_name_printed);
+ ik->adjust_default_methods(_matching_old_methods,
+ _matching_new_methods,
+ _matching_methods_length,
+ &trace_name_printed);
}
// If the current class has an itable and we are either redefining an
@@ -2931,7 +2944,8 @@
old_method->set_is_obsolete();
obsolete_count++;
- // obsolete methods need a unique idnum
+ // obsolete methods need a unique idnum so they become new entries in
+ // the jmethodID cache in InstanceKlass
u2 num = InstanceKlass::cast(_the_class_oop)->next_method_idnum();
if (num != ConstMethod::UNSET_IDNUM) {
old_method->set_method_idnum(num);
--- a/hotspot/src/share/vm/prims/methodHandles.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/methodHandles.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -187,12 +187,34 @@
receiver_limit = m->method_holder();
assert(receiver_limit->verify_itable_index(vmindex), "");
flags |= IS_METHOD | (JVM_REF_invokeInterface << REFERENCE_KIND_SHIFT);
+ if (TraceInvokeDynamic) {
+ ResourceMark rm;
+ tty->print_cr("memberName: invokeinterface method_holder::method: %s, receiver: %s, itableindex: %d, access_flags:",
+ Method::name_and_sig_as_C_string(receiver_limit(), m->name(), m->signature()),
+ receiver_limit()->internal_name(), vmindex);
+ m->access_flags().print_on(tty);
+ if (!m->is_abstract()) {
+ tty->print("default");
+ }
+ tty->cr();
+ }
break;
case CallInfo::vtable_call:
vmindex = info.vtable_index();
flags |= IS_METHOD | (JVM_REF_invokeVirtual << REFERENCE_KIND_SHIFT);
assert(receiver_limit->is_subtype_of(m->method_holder()), "virtual call must be type-safe");
+ if (TraceInvokeDynamic) {
+ ResourceMark rm;
+ tty->print_cr("memberName: invokevirtual method_holder::method: %s, receiver: %s, vtableindex: %d, access_flags:",
+ Method::name_and_sig_as_C_string(receiver_limit(), m->name(), m->signature()),
+ receiver_limit()->internal_name(), vmindex);
+ m->access_flags().print_on(tty);
+ if (m->is_default_method()) {
+ tty->print("default");
+ }
+ tty->cr();
+ }
break;
case CallInfo::direct_call:
--- a/hotspot/src/share/vm/prims/nativeLookup.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/nativeLookup.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -129,10 +129,6 @@
#define FN_PTR(f) CAST_FROM_FN_PTR(void*, &f)
static JNINativeMethod lookup_special_native_methods[] = {
- // Next two functions only exist for compatibility with 1.3.1 and earlier.
- { CC"Java_java_io_ObjectOutputStream_getPrimitiveFieldValues", NULL, FN_PTR(JVM_GetPrimitiveFieldValues) }, // intercept ObjectOutputStream getPrimitiveFieldValues for faster serialization
- { CC"Java_java_io_ObjectInputStream_setPrimitiveFieldValues", NULL, FN_PTR(JVM_SetPrimitiveFieldValues) }, // intercept ObjectInputStream setPrimitiveFieldValues for faster serialization
-
{ CC"Java_sun_misc_Unsafe_registerNatives", NULL, FN_PTR(JVM_RegisterUnsafeMethods) },
{ CC"Java_java_lang_invoke_MethodHandleNatives_registerNatives", NULL, FN_PTR(JVM_RegisterMethodHandleMethods) },
{ CC"Java_sun_misc_Perf_registerNatives", NULL, FN_PTR(JVM_RegisterPerfMethods) },
@@ -140,9 +136,8 @@
};
static address lookup_special_native(char* jni_name) {
- int i = !JDK_Version::is_gte_jdk14x_version() ? 0 : 2; // see comment in lookup_special_native_methods
int count = sizeof(lookup_special_native_methods) / sizeof(JNINativeMethod);
- for (; i < count; i++) {
+ for (int i = 0; i < count; i++) {
// NB: To ignore the jni prefix and jni postfix strstr is used matching.
if (strstr(jni_name, lookup_special_native_methods[i].name) != NULL) {
return CAST_FROM_FN_PTR(address, lookup_special_native_methods[i].fnPtr);
--- a/hotspot/src/share/vm/prims/wbtestmethods/parserTests.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/prims/wbtestmethods/parserTests.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 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
@@ -117,11 +117,12 @@
const char* c_cmdline = java_lang_String::as_utf8_string(JNIHandles::resolve(j_cmdline));
objArrayOop argumentArray = objArrayOop(JNIHandles::resolve_non_null(arguments));
+ objArrayHandle argumentArray_ah(THREAD, argumentArray);
- int length = argumentArray->length();
+ int length = argumentArray_ah->length();
for (int i = 0; i < length; i++) {
- oop argument_oop = argumentArray->obj_at(i);
+ oop argument_oop = argumentArray_ah->obj_at(i);
fill_in_parser(&parser, argument_oop);
}
@@ -130,19 +131,20 @@
Klass* k = SystemDictionary::Object_klass();
objArrayOop returnvalue_array = oopFactory::new_objArray(k, parser.num_arguments() * 2, CHECK_NULL);
+ objArrayHandle returnvalue_array_ah(THREAD, returnvalue_array);
GrowableArray<const char *>*parsedArgNames = parser.argument_name_array();
for (int i = 0; i < parser.num_arguments(); i++) {
oop parsedName = java_lang_String::create_oop_from_str(parsedArgNames->at(i), CHECK_NULL);
- returnvalue_array->obj_at_put(i*2, parsedName);
+ returnvalue_array_ah->obj_at_put(i*2, parsedName);
GenDCmdArgument* arg = parser.lookup_dcmd_option(parsedArgNames->at(i), strlen(parsedArgNames->at(i)));
char buf[VALUE_MAXLEN];
arg->value_as_str(buf, sizeof(buf));
oop parsedValue = java_lang_String::create_oop_from_str(buf, CHECK_NULL);
- returnvalue_array->obj_at_put(i*2+1, parsedValue);
+ returnvalue_array_ah->obj_at_put(i*2+1, parsedValue);
}
- return (jobjectArray) JNIHandles::make_local(returnvalue_array);
+ return (jobjectArray) JNIHandles::make_local(returnvalue_array_ah());
WB_END
--- a/hotspot/src/share/vm/runtime/arguments.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/arguments.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -2045,6 +2045,9 @@
status = status && verify_interval(StringTableSize, minimumStringTableSize,
(max_uintx / StringTable::bucket_size()), "StringTable size");
+ status = status && verify_interval(SymbolTableSize, minimumSymbolTableSize,
+ (max_uintx / SymbolTable::bucket_size()), "SymbolTable size");
+
if (MinHeapFreeRatio > MaxHeapFreeRatio) {
jio_fprintf(defaultStream::error_stream(),
"MinHeapFreeRatio (" UINTX_FORMAT ") must be less than or "
@@ -2654,16 +2657,16 @@
FLAG_SET_CMDLINE(bool, BackgroundCompilation, false);
// -Xmn for compatibility with other JVM vendors
} else if (match_option(option, "-Xmn", &tail)) {
- julong long_initial_eden_size = 0;
- ArgsRange errcode = parse_memory_size(tail, &long_initial_eden_size, 1);
+ julong long_initial_young_size = 0;
+ ArgsRange errcode = parse_memory_size(tail, &long_initial_young_size, 1);
if (errcode != arg_in_range) {
jio_fprintf(defaultStream::error_stream(),
- "Invalid initial eden size: %s\n", option->optionString);
+ "Invalid initial young generation size: %s\n", option->optionString);
describe_range_error(errcode);
return JNI_EINVAL;
}
- FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_eden_size);
- FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_eden_size);
+ FLAG_SET_CMDLINE(uintx, MaxNewSize, (uintx)long_initial_young_size);
+ FLAG_SET_CMDLINE(uintx, NewSize, (uintx)long_initial_young_size);
// -Xms
} else if (match_option(option, "-Xms", &tail)) {
julong long_initial_heap_size = 0;
@@ -3663,6 +3666,9 @@
assert(verify_serial_gc_flags(), "SerialGC unset");
#endif // INCLUDE_ALL_GCS
+ // Initialize Metaspace flags and alignments.
+ Metaspace::ergo_initialize();
+
// Set bytecode rewriting flags
set_bytecode_flags();
--- a/hotspot/src/share/vm/runtime/globals.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/globals.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -481,21 +481,21 @@
#define RUNTIME_FLAGS(develop, develop_pd, product, product_pd, diagnostic, experimental, notproduct, manageable, product_rw, lp64_product) \
\
lp64_product(bool, UseCompressedOops, false, \
- "Use 32-bit object references in 64-bit VM " \
- "lp64_product means flag is always constant in 32 bit VM") \
+ "Use 32-bit object references in 64-bit VM. " \
+ "lp64_product means flag is always constant in 32 bit VM") \
\
lp64_product(bool, UseCompressedClassPointers, false, \
- "Use 32-bit class pointers in 64-bit VM " \
- "lp64_product means flag is always constant in 32 bit VM") \
+ "Use 32-bit class pointers in 64-bit VM. " \
+ "lp64_product means flag is always constant in 32 bit VM") \
\
notproduct(bool, CheckCompressedOops, true, \
- "generate checks in encoding/decoding code in debug VM") \
+ "Generate checks in encoding/decoding code in debug VM") \
\
product_pd(uintx, HeapBaseMinAddress, \
- "OS specific low limit for heap base address") \
+ "OS specific low limit for heap base address") \
\
diagnostic(bool, PrintCompressedOopsMode, false, \
- "Print compressed oops base address and encoding mode") \
+ "Print compressed oops base address and encoding mode") \
\
lp64_product(intx, ObjectAlignmentInBytes, 8, \
"Default object alignment in bytes, 8 is minimum") \
@@ -517,7 +517,7 @@
"Use lwsync instruction if true, else use slower sync") \
\
develop(bool, CleanChunkPoolAsync, falseInEmbedded, \
- "Whether to clean the chunk pool asynchronously") \
+ "Clean the chunk pool asynchronously") \
\
/* Temporary: See 6948537 */ \
experimental(bool, UseMemSetInBOT, true, \
@@ -527,10 +527,12 @@
"Enable normal processing of flags relating to field diagnostics")\
\
experimental(bool, UnlockExperimentalVMOptions, false, \
- "Enable normal processing of flags relating to experimental features")\
+ "Enable normal processing of flags relating to experimental " \
+ "features") \
\
product(bool, JavaMonitorsInStackTrace, true, \
- "Print info. about Java monitor locks when the stacks are dumped")\
+ "Print information about Java monitor locks when the stacks are" \
+ "dumped") \
\
product_pd(bool, UseLargePages, \
"Use large page memory") \
@@ -541,8 +543,12 @@
develop(bool, LargePagesIndividualAllocationInjectError, false, \
"Fail large pages individual allocation") \
\
+ product(bool, UseLargePagesInMetaspace, false, \
+ "Use large page memory in metaspace. " \
+ "Only used if UseLargePages is enabled.") \
+ \
develop(bool, TracePageSizes, false, \
- "Trace page size selection and usage.") \
+ "Trace page size selection and usage") \
\
product(bool, UseNUMA, false, \
"Use NUMA if available") \
@@ -557,12 +563,12 @@
"Force NUMA optimizations on single-node/UMA systems") \
\
product(uintx, NUMAChunkResizeWeight, 20, \
- "Percentage (0-100) used to weigh the current sample when " \
+ "Percentage (0-100) used to weigh the current sample when " \
"computing exponentially decaying average for " \
"AdaptiveNUMAChunkSizing") \
\
product(uintx, NUMASpaceResizeRate, 1*G, \
- "Do not reallocate more that this amount per collection") \
+ "Do not reallocate more than this amount per collection") \
\
product(bool, UseAdaptiveNUMAChunkSizing, true, \
"Enable adaptive chunk sizing for NUMA") \
@@ -579,17 +585,17 @@
product(intx, UseSSE, 99, \
"Highest supported SSE instructions set on x86/x64") \
\
- product(bool, UseAES, false, \
+ product(bool, UseAES, false, \
"Control whether AES instructions can be used on x86/x64") \
\
product(uintx, LargePageSizeInBytes, 0, \
- "Large page size (0 to let VM choose the page size") \
+ "Large page size (0 to let VM choose the page size)") \
\
product(uintx, LargePageHeapSizeThreshold, 128*M, \
- "Use large pages if max heap is at least this big") \
+ "Use large pages if maximum heap is at least this big") \
\
product(bool, ForceTimeHighResolution, false, \
- "Using high time resolution(For Win32 only)") \
+ "Using high time resolution (for Win32 only)") \
\
develop(bool, TraceItables, false, \
"Trace initialization and use of itables") \
@@ -605,10 +611,10 @@
\
develop(bool, TraceLongCompiles, false, \
"Print out every time compilation is longer than " \
- "a given threashold") \
+ "a given threshold") \
\
develop(bool, SafepointALot, false, \
- "Generates a lot of safepoints. Works with " \
+ "Generate a lot of safepoints. This works with " \
"GuaranteedSafepointInterval") \
\
product_pd(bool, BackgroundCompilation, \
@@ -616,13 +622,13 @@
"compilation") \
\
product(bool, PrintVMQWaitTime, false, \
- "Prints out the waiting time in VM operation queue") \
+ "Print out the waiting time in VM operation queue") \
\
develop(bool, NoYieldsInMicrolock, false, \
"Disable yields in microlock") \
\
develop(bool, TraceOopMapGeneration, false, \
- "Shows oopmap generation") \
+ "Show OopMapGeneration") \
\
product(bool, MethodFlushing, true, \
"Reclamation of zombie and not-entrant methods") \
@@ -631,10 +637,11 @@
"Verify stack of each thread when it is entering a runtime call") \
\
diagnostic(bool, ForceUnreachable, false, \
- "Make all non code cache addresses to be unreachable with forcing use of 64bit literal fixups") \
+ "Make all non code cache addresses to be unreachable by " \
+ "forcing use of 64bit literal fixups") \
\
notproduct(bool, StressDerivedPointers, false, \
- "Force scavenge when a derived pointers is detected on stack " \
+ "Force scavenge when a derived pointer is detected on stack " \
"after rtm call") \
\
develop(bool, TraceDerivedPointers, false, \
@@ -653,86 +660,86 @@
"Use Inline Caches for virtual calls ") \
\
develop(bool, InlineArrayCopy, true, \
- "inline arraycopy native that is known to be part of " \
+ "Inline arraycopy native that is known to be part of " \
"base library DLL") \
\
develop(bool, InlineObjectHash, true, \
- "inline Object::hashCode() native that is known to be part " \
+ "Inline Object::hashCode() native that is known to be part " \
"of base library DLL") \
\
develop(bool, InlineNatives, true, \
- "inline natives that are known to be part of base library DLL") \
+ "Inline natives that are known to be part of base library DLL") \
\
develop(bool, InlineMathNatives, true, \
- "inline SinD, CosD, etc.") \
+ "Inline SinD, CosD, etc.") \
\
develop(bool, InlineClassNatives, true, \
- "inline Class.isInstance, etc") \
+ "Inline Class.isInstance, etc") \
\
develop(bool, InlineThreadNatives, true, \
- "inline Thread.currentThread, etc") \
+ "Inline Thread.currentThread, etc") \
\
develop(bool, InlineUnsafeOps, true, \
- "inline memory ops (native methods) from sun.misc.Unsafe") \
+ "Inline memory ops (native methods) from sun.misc.Unsafe") \
\
product(bool, CriticalJNINatives, true, \
- "check for critical JNI entry points") \
+ "Check for critical JNI entry points") \
\
notproduct(bool, StressCriticalJNINatives, false, \
- "Exercise register saving code in critical natives") \
+ "Exercise register saving code in critical natives") \
\
product(bool, UseSSE42Intrinsics, false, \
"SSE4.2 versions of intrinsics") \
\
product(bool, UseAESIntrinsics, false, \
- "use intrinsics for AES versions of crypto") \
+ "Use intrinsics for AES versions of crypto") \
\
product(bool, UseCRC32Intrinsics, false, \
"use intrinsics for java.util.zip.CRC32") \
\
develop(bool, TraceCallFixup, false, \
- "traces all call fixups") \
+ "Trace all call fixups") \
\
develop(bool, DeoptimizeALot, false, \
- "deoptimize at every exit from the runtime system") \
+ "Deoptimize at every exit from the runtime system") \
\
notproduct(ccstrlist, DeoptimizeOnlyAt, "", \
- "a comma separated list of bcis to deoptimize at") \
+ "A comma separated list of bcis to deoptimize at") \
\
product(bool, DeoptimizeRandom, false, \
- "deoptimize random frames on random exit from the runtime system")\
+ "Deoptimize random frames on random exit from the runtime system")\
\
notproduct(bool, ZombieALot, false, \
- "creates zombies (non-entrant) at exit from the runt. system") \
+ "Create zombies (non-entrant) at exit from the runtime system") \
\
product(bool, UnlinkSymbolsALot, false, \
- "unlink unreferenced symbols from the symbol table at safepoints")\
+ "Unlink unreferenced symbols from the symbol table at safepoints")\
\
notproduct(bool, WalkStackALot, false, \
- "trace stack (no print) at every exit from the runtime system") \
+ "Trace stack (no print) at every exit from the runtime system") \
\
product(bool, Debugging, false, \
- "set when executing debug methods in debug.ccp " \
+ "Set when executing debug methods in debug.cpp " \
"(to prevent triggering assertions)") \
\
notproduct(bool, StrictSafepointChecks, trueInDebug, \
"Enable strict checks that safepoints cannot happen for threads " \
- "that used No_Safepoint_Verifier") \
+ "that use No_Safepoint_Verifier") \
\
notproduct(bool, VerifyLastFrame, false, \
"Verify oops on last frame on entry to VM") \
\
develop(bool, TraceHandleAllocation, false, \
- "Prints out warnings when suspicious many handles are allocated") \
+ "Print out warnings when suspiciously many handles are allocated")\
\
product(bool, UseCompilerSafepoints, true, \
"Stop at safepoints in compiled code") \
\
product(bool, FailOverToOldVerifier, true, \
- "fail over to old verifier when split verifier fails") \
+ "Fail over to old verifier when split verifier fails") \
\
develop(bool, ShowSafepointMsgs, false, \
- "Show msg. about safepoint synch.") \
+ "Show message about safepoint synchronization") \
\
product(bool, SafepointTimeout, false, \
"Time out and warn or fail after SafepointTimeoutDelay " \
@@ -756,19 +763,19 @@
"Trace external suspend wait failures") \
\
product(bool, MaxFDLimit, true, \
- "Bump the number of file descriptors to max in solaris.") \
+ "Bump the number of file descriptors to maximum in Solaris") \
\
diagnostic(bool, LogEvents, true, \
- "Enable the various ring buffer event logs") \
+ "Enable the various ring buffer event logs") \
\
diagnostic(uintx, LogEventsBufferEntries, 10, \
- "Enable the various ring buffer event logs") \
+ "Number of ring buffer event logs") \
\
product(bool, BytecodeVerificationRemote, true, \
- "Enables the Java bytecode verifier for remote classes") \
+ "Enable the Java bytecode verifier for remote classes") \
\
product(bool, BytecodeVerificationLocal, false, \
- "Enables the Java bytecode verifier for local classes") \
+ "Enable the Java bytecode verifier for local classes") \
\
develop(bool, ForceFloatExceptions, trueInDebug, \
"Force exceptions on FP stack under/overflow") \
@@ -780,7 +787,7 @@
"Trace java language assertions") \
\
notproduct(bool, CheckAssertionStatusDirectives, false, \
- "temporary - see javaClasses.cpp") \
+ "Temporary - see javaClasses.cpp") \
\
notproduct(bool, PrintMallocFree, false, \
"Trace calls to C heap malloc/free allocation") \
@@ -799,16 +806,16 @@
"entering the VM") \
\
notproduct(bool, CheckOopishValues, false, \
- "Warn if value contains oop ( requires ZapDeadLocals)") \
+ "Warn if value contains oop (requires ZapDeadLocals)") \
\
develop(bool, UseMallocOnly, false, \
- "use only malloc/free for allocation (no resource area/arena)") \
+ "Use only malloc/free for allocation (no resource area/arena)") \
\
develop(bool, PrintMalloc, false, \
- "print all malloc/free calls") \
+ "Print all malloc/free calls") \
\
develop(bool, PrintMallocStatistics, false, \
- "print malloc/free statistics") \
+ "Print malloc/free statistics") \
\
develop(bool, ZapResourceArea, trueInDebug, \
"Zap freed resource/arena space with 0xABABABAB") \
@@ -820,7 +827,7 @@
"Zap freed JNI handle space with 0xFEFEFEFE") \
\
notproduct(bool, ZapStackSegments, trueInDebug, \
- "Zap allocated/freed Stack segments with 0xFADFADED") \
+ "Zap allocated/freed stack segments with 0xFADFADED") \
\
develop(bool, ZapUnusedHeapArea, trueInDebug, \
"Zap unused heap space with 0xBAADBABE") \
@@ -835,7 +842,7 @@
"Zap filler objects with 0xDEAFBABE") \
\
develop(bool, PrintVMMessages, true, \
- "Print vm messages on console") \
+ "Print VM messages on console") \
\
product(bool, PrintGCApplicationConcurrentTime, false, \
"Print the time the application has been running") \
@@ -844,21 +851,21 @@
"Print the time the application has been stopped") \
\
diagnostic(bool, VerboseVerification, false, \
- "Display detailed verification details") \
+ "Display detailed verification details") \
\
notproduct(uintx, ErrorHandlerTest, 0, \
- "If > 0, provokes an error after VM initialization; the value" \
- "determines which error to provoke. See test_error_handler()" \
+ "If > 0, provokes an error after VM initialization; the value " \
+ "determines which error to provoke. See test_error_handler() " \
"in debug.cpp.") \
\
develop(bool, Verbose, false, \
- "Prints additional debugging information from other modes") \
+ "Print additional debugging information from other modes") \
\
develop(bool, PrintMiscellaneous, false, \
- "Prints uncategorized debugging information (requires +Verbose)") \
+ "Print uncategorized debugging information (requires +Verbose)") \
\
develop(bool, WizardMode, false, \
- "Prints much more debugging information") \
+ "Print much more debugging information") \
\
product(bool, ShowMessageBoxOnError, false, \
"Keep process alive on VM fatal error") \
@@ -870,7 +877,7 @@
"Let VM fatal error propagate to the OS (ie. WER on Windows)") \
\
product(bool, SuppressFatalErrorMessage, false, \
- "Do NO Fatal Error report [Avoid deadlock]") \
+ "Report NO fatal error message (avoid deadlock)") \
\
product(ccstrlist, OnError, "", \
"Run user-defined commands on fatal error; see VMError.cpp " \
@@ -880,17 +887,17 @@
"Run user-defined commands on first java.lang.OutOfMemoryError") \
\
manageable(bool, HeapDumpBeforeFullGC, false, \
- "Dump heap to file before any major stop-world GC") \
+ "Dump heap to file before any major stop-the-world GC") \
\
manageable(bool, HeapDumpAfterFullGC, false, \
- "Dump heap to file after any major stop-world GC") \
+ "Dump heap to file after any major stop-the-world GC") \
\
manageable(bool, HeapDumpOnOutOfMemoryError, false, \
"Dump heap to file when java.lang.OutOfMemoryError is thrown") \
\
manageable(ccstr, HeapDumpPath, NULL, \
- "When HeapDumpOnOutOfMemoryError is on, the path (filename or" \
- "directory) of the dump file (defaults to java_pid<pid>.hprof" \
+ "When HeapDumpOnOutOfMemoryError is on, the path (filename or " \
+ "directory) of the dump file (defaults to java_pid<pid>.hprof " \
"in the working directory)") \
\
develop(uintx, SegmentedHeapDumpThreshold, 2*G, \
@@ -904,10 +911,10 @@
"Execute breakpoint upon encountering VM warning") \
\
develop(bool, TraceVMOperation, false, \
- "Trace vm operations") \
+ "Trace VM operations") \
\
develop(bool, UseFakeTimers, false, \
- "Tells whether the VM should use system time or a fake timer") \
+ "Tell whether the VM should use system time or a fake timer") \
\
product(ccstr, NativeMemoryTracking, "off", \
"Native memory tracking options") \
@@ -917,7 +924,7 @@
\
diagnostic(bool, AutoShutdownNMT, true, \
"Automatically shutdown native memory tracking under stress " \
- "situation. When set to false, native memory tracking tries to " \
+ "situations. When set to false, native memory tracking tries to " \
"stay alive at the expense of JVM performance") \
\
diagnostic(bool, LogCompilation, false, \
@@ -927,12 +934,12 @@
"Print compilations") \
\
diagnostic(bool, TraceNMethodInstalls, false, \
- "Trace nmethod intallation") \
+ "Trace nmethod installation") \
\
diagnostic(intx, ScavengeRootsInCode, 2, \
- "0: do not allow scavengable oops in the code cache; " \
- "1: allow scavenging from the code cache; " \
- "2: emit as many constants as the compiler can see") \
+ "0: do not allow scavengable oops in the code cache; " \
+ "1: allow scavenging from the code cache; " \
+ "2: emit as many constants as the compiler can see") \
\
product(bool, AlwaysRestoreFPU, false, \
"Restore the FPU control word after every JNI call (expensive)") \
@@ -953,7 +960,7 @@
"Print assembly code (using external disassembler.so)") \
\
diagnostic(ccstr, PrintAssemblyOptions, NULL, \
- "Options string passed to disassembler.so") \
+ "Print options string passed to disassembler.so") \
\
diagnostic(bool, PrintNMethods, false, \
"Print assembly code for nmethods when generated") \
@@ -974,20 +981,21 @@
"Print exception handler tables for all nmethods when generated") \
\
develop(bool, StressCompiledExceptionHandlers, false, \
- "Exercise compiled exception handlers") \
+ "Exercise compiled exception handlers") \
\
develop(bool, InterceptOSException, false, \
- "Starts debugger when an implicit OS (e.g., NULL) " \
+ "Start debugger when an implicit OS (e.g. NULL) " \
"exception happens") \
\
product(bool, PrintCodeCache, false, \
"Print the code cache memory usage when exiting") \
\
develop(bool, PrintCodeCache2, false, \
- "Print detailed usage info on the code cache when exiting") \
+ "Print detailed usage information on the code cache when exiting")\
\
product(bool, PrintCodeCacheOnCompilation, false, \
- "Print the code cache memory usage each time a method is compiled") \
+ "Print the code cache memory usage each time a method is " \
+ "compiled") \
\
diagnostic(bool, PrintStubCode, false, \
"Print generated stub code") \
@@ -999,40 +1007,40 @@
"Omit backtraces for some 'hot' exceptions in optimized code") \
\
product(bool, ProfilerPrintByteCodeStatistics, false, \
- "Prints byte code statictics when dumping profiler output") \
+ "Print bytecode statistics when dumping profiler output") \
\
product(bool, ProfilerRecordPC, false, \
- "Collects tick for each 16 byte interval of compiled code") \
+ "Collect ticks for each 16 byte interval of compiled code") \
\
product(bool, ProfileVM, false, \
- "Profiles ticks that fall within VM (either in the VM Thread " \
+ "Profile ticks that fall within VM (either in the VM Thread " \
"or VM code called through stubs)") \
\
product(bool, ProfileIntervals, false, \
- "Prints profiles for each interval (see ProfileIntervalsTicks)") \
+ "Print profiles for each interval (see ProfileIntervalsTicks)") \
\
notproduct(bool, ProfilerCheckIntervals, false, \
- "Collect and print info on spacing of profiler ticks") \
+ "Collect and print information on spacing of profiler ticks") \
\
develop(bool, PrintJVMWarnings, false, \
- "Prints warnings for unimplemented JVM functions") \
+ "Print warnings for unimplemented JVM functions") \
\
product(bool, PrintWarnings, true, \
- "Prints JVM warnings to output stream") \
+ "Print JVM warnings to output stream") \
\
notproduct(uintx, WarnOnStalledSpinLock, 0, \
- "Prints warnings for stalled SpinLocks") \
+ "Print warnings for stalled SpinLocks") \
\
product(bool, RegisterFinalizersAtInit, true, \
"Register finalizable objects at end of Object.<init> or " \
"after allocation") \
\
develop(bool, RegisterReferences, true, \
- "Tells whether the VM should register soft/weak/final/phantom " \
+ "Tell whether the VM should register soft/weak/final/phantom " \
"references") \
\
develop(bool, IgnoreRewrites, false, \
- "Supress rewrites of bytecodes in the oopmap generator. " \
+ "Suppress rewrites of bytecodes in the oopmap generator. " \
"This is unsafe!") \
\
develop(bool, PrintCodeCacheExtension, false, \
@@ -1042,8 +1050,7 @@
"Enable the security JVM functions") \
\
develop(bool, ProtectionDomainVerification, true, \
- "Verifies protection domain before resolution in system " \
- "dictionary") \
+ "Verify protection domain before resolution in system dictionary")\
\
product(bool, ClassUnloading, true, \
"Do unloading of classes") \
@@ -1056,14 +1063,14 @@
"Write memory usage profiling to log file") \
\
notproduct(bool, PrintSystemDictionaryAtExit, false, \
- "Prints the system dictionary at exit") \
+ "Print the system dictionary at exit") \
\
experimental(intx, PredictedLoadedClassCount, 0, \
- "Experimental: Tune loaded class cache starting size.") \
+ "Experimental: Tune loaded class cache starting size") \
\
diagnostic(bool, UnsyncloadClass, false, \
"Unstable: VM calls loadClass unsynchronized. Custom " \
- "class loader must call VM synchronized for findClass " \
+ "class loader must call VM synchronized for findClass " \
"and defineClass.") \
\
product(bool, AlwaysLockClassLoader, false, \
@@ -1079,22 +1086,22 @@
"Call loadClassInternal() rather than loadClass()") \
\
product_pd(bool, DontYieldALot, \
- "Throw away obvious excess yield calls (for SOLARIS only)") \
+ "Throw away obvious excess yield calls (for Solaris only)") \
\
product_pd(bool, ConvertSleepToYield, \
- "Converts sleep(0) to thread yield " \
- "(may be off for SOLARIS to improve GUI)") \
+ "Convert sleep(0) to thread yield " \
+ "(may be off for Solaris to improve GUI)") \
\
product(bool, ConvertYieldToSleep, false, \
- "Converts yield to a sleep of MinSleepInterval to simulate Win32 "\
- "behavior (SOLARIS only)") \
+ "Convert yield to a sleep of MinSleepInterval to simulate Win32 " \
+ "behavior (Solaris only)") \
\
product(bool, UseBoundThreads, true, \
- "Bind user level threads to kernel threads (for SOLARIS only)") \
+ "Bind user level threads to kernel threads (for Solaris only)") \
\
develop(bool, UseDetachedThreads, true, \
"Use detached threads that are recycled upon termination " \
- "(for SOLARIS only)") \
+ "(for Solaris only)") \
\
product(bool, UseLWPSynchronization, true, \
"Use LWP-based instead of libthread-based synchronization " \
@@ -1104,41 +1111,43 @@
"(Unstable) Various monitor synchronization tunables") \
\
product(intx, EmitSync, 0, \
- "(Unsafe,Unstable) " \
- " Controls emission of inline sync fast-path code") \
+ "(Unsafe, Unstable) " \
+ "Control emission of inline sync fast-path code") \
\
product(intx, MonitorBound, 0, "Bound Monitor population") \
\
product(bool, MonitorInUseLists, false, "Track Monitors for Deflation") \
\
- product(intx, SyncFlags, 0, "(Unsafe,Unstable) Experimental Sync flags" ) \
- \
- product(intx, SyncVerbose, 0, "(Unstable)" ) \
- \
- product(intx, ClearFPUAtPark, 0, "(Unsafe,Unstable)" ) \
+ product(intx, SyncFlags, 0, "(Unsafe, Unstable) Experimental Sync flags") \
+ \
+ product(intx, SyncVerbose, 0, "(Unstable)") \
+ \
+ product(intx, ClearFPUAtPark, 0, "(Unsafe, Unstable)") \
\
product(intx, hashCode, 5, \
- "(Unstable) select hashCode generation algorithm" ) \
+ "(Unstable) select hashCode generation algorithm") \
\
product(intx, WorkAroundNPTLTimedWaitHang, 1, \
- "(Unstable, Linux-specific)" \
- " avoid NPTL-FUTEX hang pthread_cond_timedwait" ) \
+ "(Unstable, Linux-specific) " \
+ "avoid NPTL-FUTEX hang pthread_cond_timedwait") \
\
product(bool, FilterSpuriousWakeups, true, \
"Prevent spurious or premature wakeups from object.wait " \
"(Solaris only)") \
\
- product(intx, NativeMonitorTimeout, -1, "(Unstable)" ) \
- product(intx, NativeMonitorFlags, 0, "(Unstable)" ) \
- product(intx, NativeMonitorSpinLimit, 20, "(Unstable)" ) \
+ product(intx, NativeMonitorTimeout, -1, "(Unstable)") \
+ \
+ product(intx, NativeMonitorFlags, 0, "(Unstable)") \
+ \
+ product(intx, NativeMonitorSpinLimit, 20, "(Unstable)") \
\
develop(bool, UsePthreads, false, \
"Use pthread-based instead of libthread-based synchronization " \
"(SPARC only)") \
\
product(bool, AdjustConcurrency, false, \
- "call thr_setconcurrency at thread create time to avoid " \
- "LWP starvation on MP systems (For Solaris Only)") \
+ "Call thr_setconcurrency at thread creation time to avoid " \
+ "LWP starvation on MP systems (for Solaris Only)") \
\
product(bool, ReduceSignalUsage, false, \
"Reduce the use of OS signals in Java and/or the VM") \
@@ -1147,13 +1156,14 @@
"Share vtable stubs (smaller code but worse branch prediction") \
\
develop(bool, LoadLineNumberTables, true, \
- "Tells whether the class file parser loads line number tables") \
+ "Tell whether the class file parser loads line number tables") \
\
develop(bool, LoadLocalVariableTables, true, \
- "Tells whether the class file parser loads local variable tables")\
+ "Tell whether the class file parser loads local variable tables") \
\
develop(bool, LoadLocalVariableTypeTables, true, \
- "Tells whether the class file parser loads local variable type tables")\
+ "Tell whether the class file parser loads local variable type" \
+ "tables") \
\
product(bool, AllowUserSignalHandlers, false, \
"Do not complain if the application installs signal handlers " \
@@ -1184,10 +1194,12 @@
\
product(bool, EagerXrunInit, false, \
"Eagerly initialize -Xrun libraries; allows startup profiling, " \
- " but not all -Xrun libraries may support the state of the VM at this time") \
+ "but not all -Xrun libraries may support the state of the VM " \
+ "at this time") \
\
product(bool, PreserveAllAnnotations, false, \
- "Preserve RuntimeInvisibleAnnotations as well as RuntimeVisibleAnnotations") \
+ "Preserve RuntimeInvisibleAnnotations as well " \
+ "as RuntimeVisibleAnnotations") \
\
develop(uintx, PreallocatedOutOfMemoryErrorCount, 4, \
"Number of OutOfMemoryErrors preallocated with backtrace") \
@@ -1262,7 +1274,7 @@
"Trace level for JVMTI RedefineClasses") \
\
develop(bool, StressMethodComparator, false, \
- "run the MethodComparator on all loaded methods") \
+ "Run the MethodComparator on all loaded methods") \
\
/* change to false by default sometime after Mustang */ \
product(bool, VerifyMergedCPBytecodes, true, \
@@ -1296,7 +1308,7 @@
"Trace dependencies") \
\
develop(bool, VerifyDependencies, trueInDebug, \
- "Exercise and verify the compilation dependency mechanism") \
+ "Exercise and verify the compilation dependency mechanism") \
\
develop(bool, TraceNewOopMapGeneration, false, \
"Trace OopMapGeneration") \
@@ -1314,7 +1326,7 @@
"Trace monitor matching failures during OopMapGeneration") \
\
develop(bool, TraceOopMapRewrites, false, \
- "Trace rewritting of method oops during oop map generation") \
+ "Trace rewriting of method oops during oop map generation") \
\
develop(bool, TraceSafepoint, false, \
"Trace safepoint operations") \
@@ -1332,10 +1344,10 @@
"Trace setup time") \
\
develop(bool, TraceProtectionDomainVerification, false, \
- "Trace protection domain verifcation") \
+ "Trace protection domain verification") \
\
develop(bool, TraceClearedExceptions, false, \
- "Prints when an exception is forcibly cleared") \
+ "Print when an exception is forcibly cleared") \
\
product(bool, TraceClassResolution, false, \
"Trace all constant pool resolutions (for debugging)") \
@@ -1349,7 +1361,7 @@
/* gc */ \
\
product(bool, UseSerialGC, false, \
- "Use the serial garbage collector") \
+ "Use the Serial garbage collector") \
\
product(bool, UseG1GC, false, \
"Use the Garbage-First garbage collector") \
@@ -1368,16 +1380,16 @@
"The collection count for the first maximum compaction") \
\
product(bool, UseMaximumCompactionOnSystemGC, true, \
- "In the Parallel Old garbage collector maximum compaction for " \
- "a system GC") \
+ "Use maximum compaction in the Parallel Old garbage collector " \
+ "for a system GC") \
\
product(uintx, ParallelOldDeadWoodLimiterMean, 50, \
- "The mean used by the par compact dead wood" \
- "limiter (a number between 0-100).") \
+ "The mean used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
\
product(uintx, ParallelOldDeadWoodLimiterStdDev, 80, \
- "The standard deviation used by the par compact dead wood" \
- "limiter (a number between 0-100).") \
+ "The standard deviation used by the parallel compact dead wood " \
+ "limiter (a number between 0-100)") \
\
product(uintx, ParallelGCThreads, 0, \
"Number of parallel threads parallel gc will use") \
@@ -1387,7 +1399,7 @@
"parallel gc will use") \
\
diagnostic(bool, ForceDynamicNumberOfGCThreads, false, \
- "Force dynamic selection of the number of" \
+ "Force dynamic selection of the number of " \
"parallel threads parallel gc will use to aid debugging") \
\
product(uintx, HeapSizePerGCThread, ScaleForWordSize(64*M), \
@@ -1398,7 +1410,7 @@
"Trace the dynamic GC thread usage") \
\
develop(bool, ParallelOldGCSplitALot, false, \
- "Provoke splitting (copying data from a young gen space to" \
+ "Provoke splitting (copying data from a young gen space to " \
"multiple destination spaces)") \
\
develop(uintx, ParallelOldGCSplitInterval, 3, \
@@ -1408,19 +1420,19 @@
"Number of threads concurrent gc will use") \
\
product(uintx, YoungPLABSize, 4096, \
- "Size of young gen promotion labs (in HeapWords)") \
+ "Size of young gen promotion LAB's (in HeapWords)") \
\
product(uintx, OldPLABSize, 1024, \
- "Size of old gen promotion labs (in HeapWords)") \
+ "Size of old gen promotion LAB's (in HeapWords)") \
\
product(uintx, GCTaskTimeStampEntries, 200, \
"Number of time stamp entries per gc worker thread") \
\
product(bool, AlwaysTenure, false, \
- "Always tenure objects in eden. (ParallelGC only)") \
+ "Always tenure objects in eden (ParallelGC only)") \
\
product(bool, NeverTenure, false, \
- "Never tenure objects in eden, May tenure on overflow " \
+ "Never tenure objects in eden, may tenure on overflow " \
"(ParallelGC only)") \
\
product(bool, ScavengeBeforeFullGC, true, \
@@ -1428,14 +1440,14 @@
"used with UseParallelGC") \
\
develop(bool, ScavengeWithObjectsInToSpace, false, \
- "Allow scavenges to occur when to_space contains objects.") \
+ "Allow scavenges to occur when to-space contains objects") \
\
product(bool, UseConcMarkSweepGC, false, \
"Use Concurrent Mark-Sweep GC in the old generation") \
\
product(bool, ExplicitGCInvokesConcurrent, false, \
- "A System.gc() request invokes a concurrent collection;" \
- " (effective only when UseConcMarkSweepGC)") \
+ "A System.gc() request invokes a concurrent collection; " \
+ "(effective only when UseConcMarkSweepGC)") \
\
product(bool, ExplicitGCInvokesConcurrentAndUnloadsClasses, false, \
"A System.gc() request invokes a concurrent collection and " \
@@ -1443,19 +1455,19 @@
"(effective only when UseConcMarkSweepGC)") \
\
product(bool, GCLockerInvokesConcurrent, false, \
- "The exit of a JNI CS necessitating a scavenge also" \
- " kicks off a bkgrd concurrent collection") \
+ "The exit of a JNI critical section necessitating a scavenge, " \
+ "also kicks off a background concurrent collection") \
\
product(uintx, GCLockerEdenExpansionPercent, 5, \
- "How much the GC can expand the eden by while the GC locker " \
+ "How much the GC can expand the eden by while the GC locker " \
"is active (as a percentage)") \
\
diagnostic(intx, GCLockerRetryAllocationCount, 2, \
- "Number of times to retry allocations when" \
- " blocked by the GC locker") \
+ "Number of times to retry allocations when " \
+ "blocked by the GC locker") \
\
develop(bool, UseCMSAdaptiveFreeLists, true, \
- "Use Adaptive Free Lists in the CMS generation") \
+ "Use adaptive free lists in the CMS generation") \
\
develop(bool, UseAsyncConcMarkSweepGC, true, \
"Use Asynchronous Concurrent Mark-Sweep GC in the old generation")\
@@ -1470,44 +1482,46 @@
"Use passing of collection from background to foreground") \
\
product(bool, UseParNewGC, false, \
- "Use parallel threads in the new generation.") \
+ "Use parallel threads in the new generation") \
\
product(bool, ParallelGCVerbose, false, \
- "Verbose output for parallel GC.") \
+ "Verbose output for parallel gc") \
\
product(uintx, ParallelGCBufferWastePct, 10, \
- "Wasted fraction of parallel allocation buffer.") \
+ "Wasted fraction of parallel allocation buffer") \
\
diagnostic(bool, ParallelGCRetainPLAB, false, \
- "Retain parallel allocation buffers across scavenges; " \
- " -- disabled because this currently conflicts with " \
- " parallel card scanning under certain conditions ") \
+ "Retain parallel allocation buffers across scavenges; " \
+ "it is disabled because this currently conflicts with " \
+ "parallel card scanning under certain conditions.") \
\
product(uintx, TargetPLABWastePct, 10, \
"Target wasted space in last buffer as percent of overall " \
"allocation") \
\
product(uintx, PLABWeight, 75, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decaying average for ResizePLAB.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponentially decaying average for ResizePLAB") \
\
product(bool, ResizePLAB, true, \
- "Dynamically resize (survivor space) promotion labs") \
+ "Dynamically resize (survivor space) promotion LAB's") \
\
product(bool, PrintPLAB, false, \
- "Print (survivor space) promotion labs sizing decisions") \
+ "Print (survivor space) promotion LAB's sizing decisions") \
\
product(intx, ParGCArrayScanChunk, 50, \
- "Scan a subset and push remainder, if array is bigger than this") \
+ "Scan a subset of object array and push remainder, if array is " \
+ "bigger than this") \
\
product(bool, ParGCUseLocalOverflow, false, \
"Instead of a global overflow list, use local overflow stacks") \
\
product(bool, ParGCTrimOverflow, true, \
- "Eagerly trim the local overflow lists (when ParGCUseLocalOverflow") \
+ "Eagerly trim the local overflow lists " \
+ "(when ParGCUseLocalOverflow)") \
\
notproduct(bool, ParGCWorkQueueOverflowALot, false, \
- "Whether we should simulate work queue overflow in ParNew") \
+ "Simulate work queue overflow in ParNew") \
\
notproduct(uintx, ParGCWorkQueueOverflowInterval, 1000, \
"An `interval' counter that determines how frequently " \
@@ -1525,43 +1539,46 @@
"during card table scanning") \
\
product(uintx, CMSParPromoteBlocksToClaim, 16, \
- "Number of blocks to attempt to claim when refilling CMS LAB for "\
- "parallel GC.") \
+ "Number of blocks to attempt to claim when refilling CMS LAB's " \
+ "for parallel GC") \
\
product(uintx, OldPLABWeight, 50, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decaying average for resizing CMSParPromoteBlocksToClaim.") \
+ "Percentage (0-100) used to weight the current sample when " \
+ "computing exponentially decaying average for resizing " \
+ "CMSParPromoteBlocksToClaim") \
\
product(bool, ResizeOldPLAB, true, \
- "Dynamically resize (old gen) promotion labs") \
+ "Dynamically resize (old gen) promotion LAB's") \
\
product(bool, PrintOldPLAB, false, \
- "Print (old gen) promotion labs sizing decisions") \
+ "Print (old gen) promotion LAB's sizing decisions") \
\
product(uintx, CMSOldPLABMin, 16, \
- "Min size of CMS gen promotion lab caches per worker per blksize")\
+ "Minimum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
\
product(uintx, CMSOldPLABMax, 1024, \
- "Max size of CMS gen promotion lab caches per worker per blksize")\
+ "Maximum size of CMS gen promotion LAB caches per worker " \
+ "per block size") \
\
product(uintx, CMSOldPLABNumRefills, 4, \
- "Nominal number of refills of CMS gen promotion lab cache" \
- " per worker per block size") \
+ "Nominal number of refills of CMS gen promotion LAB cache " \
+ "per worker per block size") \
\
product(bool, CMSOldPLABResizeQuicker, false, \
- "Whether to react on-the-fly during a scavenge to a sudden" \
- " change in block demand rate") \
+ "React on-the-fly during a scavenge to a sudden " \
+ "change in block demand rate") \
\
product(uintx, CMSOldPLABToleranceFactor, 4, \
- "The tolerance of the phase-change detector for on-the-fly" \
- " PLAB resizing during a scavenge") \
+ "The tolerance of the phase-change detector for on-the-fly " \
+ "PLAB resizing during a scavenge") \
\
product(uintx, CMSOldPLABReactivityFactor, 2, \
- "The gain in the feedback loop for on-the-fly PLAB resizing" \
- " during a scavenge") \
+ "The gain in the feedback loop for on-the-fly PLAB resizing " \
+ "during a scavenge") \
\
product(bool, AlwaysPreTouch, false, \
- "It forces all freshly committed pages to be pre-touched.") \
+ "Force all freshly committed pages to be pre-touched") \
\
product_pd(uintx, CMSYoungGenPerWorker, \
"The maximum size of young gen chosen by default per GC worker " \
@@ -1571,64 +1588,67 @@
"Whether CMS GC should operate in \"incremental\" mode") \
\
product(uintx, CMSIncrementalDutyCycle, 10, \
- "CMS incremental mode duty cycle (a percentage, 0-100). If" \
- "CMSIncrementalPacing is enabled, then this is just the initial" \
- "value") \
+ "Percentage (0-100) of CMS incremental mode duty cycle. If " \
+ "CMSIncrementalPacing is enabled, then this is just the initial " \
+ "value.") \
\
product(bool, CMSIncrementalPacing, true, \
"Whether the CMS incremental mode duty cycle should be " \
"automatically adjusted") \
\
product(uintx, CMSIncrementalDutyCycleMin, 0, \
- "Lower bound on the duty cycle when CMSIncrementalPacing is " \
- "enabled (a percentage, 0-100)") \
+ "Minimum percentage (0-100) of the CMS incremental duty cycle " \
+ "used when CMSIncrementalPacing is enabled") \
\
product(uintx, CMSIncrementalSafetyFactor, 10, \
"Percentage (0-100) used to add conservatism when computing the " \
"duty cycle") \
\
product(uintx, CMSIncrementalOffset, 0, \
- "Percentage (0-100) by which the CMS incremental mode duty cycle" \
- " is shifted to the right within the period between young GCs") \
+ "Percentage (0-100) by which the CMS incremental mode duty cycle "\
+ "is shifted to the right within the period between young GCs") \
\
product(uintx, CMSExpAvgFactor, 50, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponential averages for CMS statistics.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponential averages for CMS statistics") \
\
product(uintx, CMS_FLSWeight, 75, \
- "Percentage (0-100) used to weight the current sample when" \
- "computing exponentially decating averages for CMS FLS statistics.") \
+ "Percentage (0-100) used to weigh the current sample when " \
+ "computing exponentially decaying averages for CMS FLS " \
+ "statistics") \
\
product(uintx, CMS_FLSPadding, 1, \
- "The multiple of deviation from mean to use for buffering" \
- "against volatility in free list demand.") \
+ "The multiple of deviation from mean to use for buffering " \
+ "against volatility in free list demand") \
\
product(uintx, FLSCoalescePolicy, 2, \
- "CMS: Aggression level for coalescing, increasing from 0 to 4") \
+ "CMS: aggressiveness level for coalescing, increasing " \
+ "from 0 to 4") \
\
product(bool, FLSAlwaysCoalesceLarge, false, \
- "CMS: Larger free blocks are always available for coalescing") \
+ "CMS: larger free blocks are always available for coalescing") \
\
product(double, FLSLargestBlockCoalesceProximity, 0.99, \
- "CMS: the smaller the percentage the greater the coalition force")\
+ "CMS: the smaller the percentage the greater the coalescing " \
+ "force") \
\
product(double, CMSSmallCoalSurplusPercent, 1.05, \
- "CMS: the factor by which to inflate estimated demand of small" \
- " block sizes to prevent coalescing with an adjoining block") \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent coalescing with an adjoining block") \
\
product(double, CMSLargeCoalSurplusPercent, 0.95, \
- "CMS: the factor by which to inflate estimated demand of large" \
- " block sizes to prevent coalescing with an adjoining block") \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent coalescing with an adjoining block") \
\
product(double, CMSSmallSplitSurplusPercent, 1.10, \
- "CMS: the factor by which to inflate estimated demand of small" \
- " block sizes to prevent splitting to supply demand for smaller" \
- " blocks") \
+ "CMS: the factor by which to inflate estimated demand of small " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
\
product(double, CMSLargeSplitSurplusPercent, 1.00, \
- "CMS: the factor by which to inflate estimated demand of large" \
- " block sizes to prevent splitting to supply demand for smaller" \
- " blocks") \
+ "CMS: the factor by which to inflate estimated demand of large " \
+ "block sizes to prevent splitting to supply demand for smaller " \
+ "blocks") \
\
product(bool, CMSExtrapolateSweep, false, \
"CMS: cushion for block demand during sweep") \
@@ -1640,11 +1660,11 @@
\
product(uintx, CMS_SweepPadding, 1, \
"The multiple of deviation from mean to use for buffering " \
- "against volatility in inter-sweep duration.") \
+ "against volatility in inter-sweep duration") \
\
product(uintx, CMS_SweepTimerThresholdMillis, 10, \
"Skip block flux-rate sampling for an epoch unless inter-sweep " \
- "duration exceeds this threhold in milliseconds") \
+ "duration exceeds this threshold in milliseconds") \
\
develop(bool, CMSTraceIncrementalMode, false, \
"Trace CMS incremental mode") \
@@ -1659,14 +1679,15 @@
"Whether class unloading enabled when using CMS GC") \
\
product(uintx, CMSClassUnloadingMaxInterval, 0, \
- "When CMS class unloading is enabled, the maximum CMS cycle count"\
- " for which classes may not be unloaded") \
+ "When CMS class unloading is enabled, the maximum CMS cycle " \
+ "count for which classes may not be unloaded") \
\
product(bool, CMSCompactWhenClearAllSoftRefs, true, \
- "Compact when asked to collect CMS gen with clear_all_soft_refs") \
+ "Compact when asked to collect CMS gen with " \
+ "clear_all_soft_refs()") \
\
product(bool, UseCMSCompactAtFullCollection, true, \
- "Use mark sweep compact at full collections") \
+ "Use Mark-Sweep-Compact algorithm at full collections") \
\
product(uintx, CMSFullGCsBeforeCompaction, 0, \
"Number of CMS full collection done before compaction if > 0") \
@@ -1688,38 +1709,37 @@
"Warn in case of excessive CMS looping") \
\
develop(bool, CMSOverflowEarlyRestoration, false, \
- "Whether preserved marks should be restored early") \
+ "Restore preserved marks early") \
\
product(uintx, MarkStackSize, NOT_LP64(32*K) LP64_ONLY(4*M), \
"Size of marking stack") \
\
product(uintx, MarkStackSizeMax, NOT_LP64(4*M) LP64_ONLY(512*M), \
- "Max size of marking stack") \
+ "Maximum size of marking stack") \
\
notproduct(bool, CMSMarkStackOverflowALot, false, \
- "Whether we should simulate frequent marking stack / work queue" \
- " overflow") \
+ "Simulate frequent marking stack / work queue overflow") \
\
notproduct(uintx, CMSMarkStackOverflowInterval, 1000, \
- "An `interval' counter that determines how frequently" \
- " we simulate overflow; a smaller number increases frequency") \
+ "An \"interval\" counter that determines how frequently " \
+ "to simulate overflow; a smaller number increases frequency") \
\
product(uintx, CMSMaxAbortablePrecleanLoops, 0, \
- "(Temporary, subject to experimentation)" \
+ "(Temporary, subject to experimentation) " \
"Maximum number of abortable preclean iterations, if > 0") \
\
product(intx, CMSMaxAbortablePrecleanTime, 5000, \
- "(Temporary, subject to experimentation)" \
- "Maximum time in abortable preclean in ms") \
+ "(Temporary, subject to experimentation) " \
+ "Maximum time in abortable preclean (in milliseconds)") \
\
product(uintx, CMSAbortablePrecleanMinWorkPerIteration, 100, \
- "(Temporary, subject to experimentation)" \
+ "(Temporary, subject to experimentation) " \
"Nominal minimum work per abortable preclean iteration") \
\
manageable(intx, CMSAbortablePrecleanWaitMillis, 100, \
- "(Temporary, subject to experimentation)" \
- " Time that we sleep between iterations when not given" \
- " enough work per iteration") \
+ "(Temporary, subject to experimentation) " \
+ "Time that we sleep between iterations when not given " \
+ "enough work per iteration") \
\
product(uintx, CMSRescanMultiple, 32, \
"Size (in cards) of CMS parallel rescan task") \
@@ -1737,23 +1757,24 @@
"Whether parallel remark enabled (only if ParNewGC)") \
\
product(bool, CMSParallelSurvivorRemarkEnabled, true, \
- "Whether parallel remark of survivor space" \
- " enabled (effective only if CMSParallelRemarkEnabled)") \
+ "Whether parallel remark of survivor space " \
+ "enabled (effective only if CMSParallelRemarkEnabled)") \
\
product(bool, CMSPLABRecordAlways, true, \
- "Whether to always record survivor space PLAB bdries" \
- " (effective only if CMSParallelSurvivorRemarkEnabled)") \
+ "Always record survivor space PLAB boundaries (effective only " \
+ "if CMSParallelSurvivorRemarkEnabled)") \
\
product(bool, CMSEdenChunksRecordAlways, true, \
- "Whether to always record eden chunks used for " \
- "the parallel initial mark or remark of eden" ) \
+ "Always record eden chunks used for the parallel initial mark " \
+ "or remark of eden") \
\
product(bool, CMSPrintEdenSurvivorChunks, false, \
"Print the eden and the survivor chunks used for the parallel " \
"initial mark or remark of the eden/survivor spaces") \
\
product(bool, CMSConcurrentMTEnabled, true, \
- "Whether multi-threaded concurrent work enabled (if ParNewGC)") \
+ "Whether multi-threaded concurrent work enabled " \
+ "(effective only if ParNewGC)") \
\
product(bool, CMSPrecleaningEnabled, true, \
"Whether concurrent precleaning enabled") \
@@ -1762,12 +1783,12 @@
"Maximum number of precleaning iteration passes") \
\
product(uintx, CMSPrecleanNumerator, 2, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
- " ratio") \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
\
product(uintx, CMSPrecleanDenominator, 3, \
- "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence" \
- " ratio") \
+ "CMSPrecleanNumerator:CMSPrecleanDenominator yields convergence " \
+ "ratio") \
\
product(bool, CMSPrecleanRefLists1, true, \
"Preclean ref lists during (initial) preclean phase") \
@@ -1782,7 +1803,7 @@
"Preclean survivors during abortable preclean phase") \
\
product(uintx, CMSPrecleanThreshold, 1000, \
- "Don't re-iterate if #dirty cards less than this") \
+ "Do not iterate again if number of dirty cards is less than this")\
\
product(bool, CMSCleanOnEnter, true, \
"Clean-on-enter optimization for reducing number of dirty cards") \
@@ -1791,14 +1812,16 @@
"Choose variant (1,2) of verification following remark") \
\
product(uintx, CMSScheduleRemarkEdenSizeThreshold, 2*M, \
- "If Eden used is below this value, don't try to schedule remark") \
+ "If Eden size is below this, do not try to schedule remark") \
\
product(uintx, CMSScheduleRemarkEdenPenetration, 50, \
- "The Eden occupancy % at which to try and schedule remark pause") \
+ "The Eden occupancy percentage (0-100) at which " \
+ "to try and schedule remark pause") \
\
product(uintx, CMSScheduleRemarkSamplingRatio, 5, \
- "Start sampling Eden top at least before yg occupancy reaches" \
- " 1/<ratio> of the size at which we plan to schedule remark") \
+ "Start sampling eden top at least before young gen " \
+ "occupancy reaches 1/<ratio> of the size at which " \
+ "we plan to schedule remark") \
\
product(uintx, CMSSamplingGrain, 16*K, \
"The minimum distance between eden samples for CMS (see above)") \
@@ -1820,27 +1843,27 @@
"should start a collection cycle") \
\
product(bool, CMSYield, true, \
- "Yield between steps of concurrent mark & sweep") \
+ "Yield between steps of CMS") \
\
product(uintx, CMSBitMapYieldQuantum, 10*M, \
- "Bitmap operations should process at most this many bits" \
+ "Bitmap operations should process at most this many bits " \
"between yields") \
\
product(bool, CMSDumpAtPromotionFailure, false, \
"Dump useful information about the state of the CMS old " \
- " generation upon a promotion failure.") \
+ "generation upon a promotion failure") \
\
product(bool, CMSPrintChunksInDump, false, \
"In a dump enabled by CMSDumpAtPromotionFailure, include " \
- " more detailed information about the free chunks.") \
+ "more detailed information about the free chunks") \
\
product(bool, CMSPrintObjectsInDump, false, \
"In a dump enabled by CMSDumpAtPromotionFailure, include " \
- " more detailed information about the allocated objects.") \
+ "more detailed information about the allocated objects") \
\
diagnostic(bool, FLSVerifyAllHeapReferences, false, \
- "Verify that all refs across the FLS boundary " \
- " are to valid objects") \
+ "Verify that all references across the FLS boundary " \
+ "are to valid objects") \
\
diagnostic(bool, FLSVerifyLists, false, \
"Do lots of (expensive) FreeListSpace verification") \
@@ -1852,17 +1875,18 @@
"Do lots of (expensive) FLS dictionary verification") \
\
develop(bool, VerifyBlockOffsetArray, false, \
- "Do (expensive!) block offset array verification") \
+ "Do (expensive) block offset array verification") \
\
diagnostic(bool, BlockOffsetArrayUseUnallocatedBlock, false, \
- "Maintain _unallocated_block in BlockOffsetArray" \
- " (currently applicable only to CMS collector)") \
+ "Maintain _unallocated_block in BlockOffsetArray " \
+ "(currently applicable only to CMS collector)") \
\
develop(bool, TraceCMSState, false, \
"Trace the state of the CMS collection") \
\
product(intx, RefDiscoveryPolicy, 0, \
- "Whether reference-based(0) or referent-based(1)") \
+ "Select type of reference discovery policy: " \
+ "reference-based(0) or referent-based(1)") \
\
product(bool, ParallelRefProcEnabled, false, \
"Enable parallel reference processing whenever possible") \
@@ -1890,7 +1914,7 @@
"denotes 'do constant GC cycles'.") \
\
product(bool, UseCMSInitiatingOccupancyOnly, false, \
- "Only use occupancy as a crierion for starting a CMS collection") \
+ "Only use occupancy as a criterion for starting a CMS collection")\
\
product(uintx, CMSIsTooFullPercentage, 98, \
"An absolute ceiling above which CMS will always consider the " \
@@ -1902,7 +1926,7 @@
\
notproduct(bool, CMSVerifyReturnedBytes, false, \
"Check that all the garbage collected was returned to the " \
- "free lists.") \
+ "free lists") \
\
notproduct(bool, ScavengeALot, false, \
"Force scavenge at every Nth exit from the runtime system " \
@@ -1917,16 +1941,16 @@
\
product(bool, PrintPromotionFailure, false, \
"Print additional diagnostic information following " \
- " promotion failure") \
+ "promotion failure") \
\
notproduct(bool, PromotionFailureALot, false, \
"Use promotion failure handling on every youngest generation " \
"collection") \
\
develop(uintx, PromotionFailureALotCount, 1000, \
- "Number of promotion failures occurring at ParGCAllocBuffer" \
+ "Number of promotion failures occurring at ParGCAllocBuffer " \
"refill attempts (ParNew) or promotion attempts " \
- "(other young collectors) ") \
+ "(other young collectors)") \
\
develop(uintx, PromotionFailureALotInterval, 5, \
"Total collections between promotion failures alot") \
@@ -1945,7 +1969,7 @@
"Ratio of hard spins to calls to yield") \
\
develop(uintx, ObjArrayMarkingStride, 512, \
- "Number of ObjArray elements to push onto the marking stack" \
+ "Number of object array elements to push onto the marking stack " \
"before pushing a continuation entry") \
\
develop(bool, MetadataAllocationFailALot, false, \
@@ -1953,7 +1977,7 @@
"MetadataAllocationFailALotInterval") \
\
develop(uintx, MetadataAllocationFailALotInterval, 1000, \
- "metadata allocation failure alot interval") \
+ "Metadata allocation failure a lot interval") \
\
develop(bool, MetaDataDeallocateALot, false, \
"Deallocation bunches of metadata at intervals controlled by " \
@@ -1972,7 +1996,7 @@
"Trace virtual space metadata allocations") \
\
notproduct(bool, ExecuteInternalVMTests, false, \
- "Enable execution of internal VM tests.") \
+ "Enable execution of internal VM tests") \
\
notproduct(bool, VerboseInternalVMTests, false, \
"Turn on logging for internal VM tests.") \
@@ -1980,7 +2004,7 @@
product_pd(bool, UseTLAB, "Use thread-local object allocation") \
\
product_pd(bool, ResizeTLAB, \
- "Dynamically resize tlab size for threads") \
+ "Dynamically resize TLAB size for threads") \
\
product(bool, ZeroTLAB, false, \
"Zero out the newly created TLAB") \
@@ -1992,7 +2016,8 @@
"Print various TLAB related information") \
\
product(bool, TLABStats, true, \
- "Print various TLAB related information") \
+ "Provide more detailed and expensive TLAB statistics " \
+ "(with PrintTLAB)") \
\
EMBEDDED_ONLY(product(bool, LowMemoryProtection, true, \
"Enable LowMemoryProtection")) \
@@ -2026,14 +2051,14 @@
"Fraction (1/n) of real memory used for initial heap size") \
\
develop(uintx, MaxVirtMemFraction, 2, \
- "Maximum fraction (1/n) of virtual memory used for ergonomically" \
+ "Maximum fraction (1/n) of virtual memory used for ergonomically "\
"determining maximum heap size") \
\
product(bool, UseAutoGCSelectPolicy, false, \
"Use automatic collection selection policy") \
\
product(uintx, AutoGCSelectPauseMillis, 5000, \
- "Automatic GC selection pause threshhold in ms") \
+ "Automatic GC selection pause threshold in milliseconds") \
\
product(bool, UseAdaptiveSizePolicy, true, \
"Use adaptive generation sizing policies") \
@@ -2048,7 +2073,7 @@
"Use adaptive young-old sizing policies at major collections") \
\
product(bool, UseAdaptiveSizePolicyWithSystemGC, false, \
- "Use statistics from System.GC for adaptive size policy") \
+ "Include statistics from System.gc() for adaptive size policy") \
\
product(bool, UseAdaptiveGCBoundary, false, \
"Allow young-old boundary to move") \
@@ -2060,16 +2085,16 @@
"Resize the virtual spaces of the young or old generations") \
\
product(uintx, AdaptiveSizeThroughPutPolicy, 0, \
- "Policy for changeing generation size for throughput goals") \
+ "Policy for changing generation size for throughput goals") \
\
product(uintx, AdaptiveSizePausePolicy, 0, \
"Policy for changing generation size for pause goals") \
\
develop(bool, PSAdjustTenuredGenForMinorPause, false, \
- "Adjust tenured generation to achive a minor pause goal") \
+ "Adjust tenured generation to achieve a minor pause goal") \
\
develop(bool, PSAdjustYoungGenForMajorPause, false, \
- "Adjust young generation to achive a major pause goal") \
+ "Adjust young generation to achieve a major pause goal") \
\
product(uintx, AdaptiveSizePolicyInitializingSteps, 20, \
"Number of steps where heuristics is used before data is used") \
@@ -2124,14 +2149,15 @@
"Decay factor to TenuredGenerationSizeIncrement") \
\
product(uintx, MaxGCPauseMillis, max_uintx, \
- "Adaptive size policy maximum GC pause time goal in msec, " \
- "or (G1 Only) the max. GC time per MMU time slice") \
+ "Adaptive size policy maximum GC pause time goal in millisecond, "\
+ "or (G1 Only) the maximum GC time per MMU time slice") \
\
product(uintx, GCPauseIntervalMillis, 0, \
"Time slice for MMU specification") \
\
product(uintx, MaxGCMinorPauseMillis, max_uintx, \
- "Adaptive size policy maximum GC minor pause time goal in msec") \
+ "Adaptive size policy maximum GC minor pause time goal " \
+ "in millisecond") \
\
product(uintx, GCTimeRatio, 99, \
"Adaptive size policy application time to GC time ratio") \
@@ -2159,8 +2185,8 @@
"before an OutOfMemory error is thrown") \
\
product(uintx, GCTimeLimit, 98, \
- "Limit of proportion of time spent in GC before an OutOfMemory" \
- "error is thrown (used with GCHeapFreeLimit)") \
+ "Limit of the proportion of time spent in GC before " \
+ "an OutOfMemoryError is thrown (used with GCHeapFreeLimit)") \
\
product(uintx, GCHeapFreeLimit, 2, \
"Minimum percentage of free space after a full GC before an " \
@@ -2182,7 +2208,7 @@
"How many fields ahead to prefetch in oop scan (<= 0 means off)") \
\
diagnostic(bool, VerifySilently, false, \
- "Don't print print the verification progress") \
+ "Do not print the verification progress") \
\
diagnostic(bool, VerifyDuringStartup, false, \
"Verify memory system before executing any Java code " \
@@ -2205,7 +2231,7 @@
\
diagnostic(bool, DeferInitialCardMark, false, \
"When +ReduceInitialCardMarks, explicitly defer any that " \
- "may arise from new_pre_store_barrier") \
+ "may arise from new_pre_store_barrier") \
\
diagnostic(bool, VerifyRememberedSets, false, \
"Verify GC remembered sets") \
@@ -2214,10 +2240,10 @@
"Verify GC object start array if verify before/after") \
\
product(bool, DisableExplicitGC, false, \
- "Tells whether calling System.gc() does a full GC") \
+ "Ignore calls to System.gc()") \
\
notproduct(bool, CheckMemoryInitialization, false, \
- "Checks memory initialization") \
+ "Check memory initialization") \
\
product(bool, CollectGen0First, false, \
"Collect youngest generation before each full GC") \
@@ -2238,44 +2264,45 @@
"Stride through processors when distributing processes") \
\
product(uintx, CMSCoordinatorYieldSleepCount, 10, \
- "number of times the coordinator GC thread will sleep while " \
+ "Number of times the coordinator GC thread will sleep while " \
"yielding before giving up and resuming GC") \
\
product(uintx, CMSYieldSleepCount, 0, \
- "number of times a GC thread (minus the coordinator) " \
+ "Number of times a GC thread (minus the coordinator) " \
"will sleep while yielding before giving up and resuming GC") \
\
/* gc tracing */ \
manageable(bool, PrintGC, false, \
- "Print message at garbage collect") \
+ "Print message at garbage collection") \
\
manageable(bool, PrintGCDetails, false, \
- "Print more details at garbage collect") \
+ "Print more details at garbage collection") \
\
manageable(bool, PrintGCDateStamps, false, \
- "Print date stamps at garbage collect") \
+ "Print date stamps at garbage collection") \
\
manageable(bool, PrintGCTimeStamps, false, \
- "Print timestamps at garbage collect") \
+ "Print timestamps at garbage collection") \
\
product(bool, PrintGCTaskTimeStamps, false, \
"Print timestamps for individual gc worker thread tasks") \
\
develop(intx, ConcGCYieldTimeout, 0, \
- "If non-zero, assert that GC threads yield within this # of ms.") \
+ "If non-zero, assert that GC threads yield within this " \
+ "number of milliseconds") \
\
notproduct(bool, TraceMarkSweep, false, \
"Trace mark sweep") \
\
product(bool, PrintReferenceGC, false, \
"Print times spent handling reference objects during GC " \
- " (enabled only when PrintGCDetails)") \
+ "(enabled only when PrintGCDetails)") \
\
develop(bool, TraceReferenceGC, false, \
"Trace handling of soft/weak/final/phantom references") \
\
develop(bool, TraceFinalizerRegistration, false, \
- "Trace registration of final references") \
+ "Trace registration of final references") \
\
notproduct(bool, TraceScavenge, false, \
"Trace scavenge") \
@@ -2312,7 +2339,7 @@
"Print heap layout before and after each GC") \
\
product_rw(bool, PrintHeapAtGCExtended, false, \
- "Prints extended information about the layout of the heap " \
+ "Print extended information about the layout of the heap " \
"when -XX:+PrintHeapAtGC is set") \
\
product(bool, PrintHeapAtSIGBREAK, true, \
@@ -2349,45 +2376,45 @@
"Trace actions of the GC task threads") \
\
product(bool, PrintParallelOldGCPhaseTimes, false, \
- "Print the time taken by each parallel old gc phase." \
- "PrintGCDetails must also be enabled.") \
+ "Print the time taken by each phase in ParallelOldGC " \
+ "(PrintGCDetails must also be enabled)") \
\
develop(bool, TraceParallelOldGCMarkingPhase, false, \
- "Trace parallel old gc marking phase") \
+ "Trace marking phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCSummaryPhase, false, \
- "Trace parallel old gc summary phase") \
+ "Trace summary phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCCompactionPhase, false, \
- "Trace parallel old gc compaction phase") \
+ "Trace compaction phase in ParallelOldGC") \
\
develop(bool, TraceParallelOldGCDensePrefix, false, \
- "Trace parallel old gc dense prefix computation") \
+ "Trace dense prefix computation for ParallelOldGC") \
\
develop(bool, IgnoreLibthreadGPFault, false, \
"Suppress workaround for libthread GP fault") \
\
product(bool, PrintJNIGCStalls, false, \
- "Print diagnostic message when GC is stalled" \
+ "Print diagnostic message when GC is stalled " \
"by JNI critical section") \
\
experimental(double, ObjectCountCutOffPercent, 0.5, \
"The percentage of the used heap that the instances of a class " \
- "must occupy for the class to generate a trace event.") \
+ "must occupy for the class to generate a trace event") \
\
/* GC log rotation setting */ \
\
product(bool, UseGCLogFileRotation, false, \
- "Prevent large gclog file for long running app. " \
- "Requires -Xloggc:<filename>") \
+ "Rotate gclog files (for long running applications). It requires "\
+ "-Xloggc:<filename>") \
\
product(uintx, NumberOfGCLogFiles, 0, \
- "Number of gclog files in rotation, " \
- "Default: 0, no rotation") \
+ "Number of gclog files in rotation " \
+ "(default: 0, no rotation)") \
\
product(uintx, GCLogFileSize, 0, \
- "GC log file size, Default: 0 bytes, no rotation " \
- "Only valid with UseGCLogFileRotation") \
+ "GC log file size (default: 0 bytes, no rotation). " \
+ "It requires UseGCLogFileRotation") \
\
/* JVMTI heap profiling */ \
\
@@ -2464,40 +2491,40 @@
"Generate range checks for array accesses") \
\
develop_pd(bool, ImplicitNullChecks, \
- "generate code for implicit null checks") \
+ "Generate code for implicit null checks") \
\
product(bool, PrintSafepointStatistics, false, \
- "print statistics about safepoint synchronization") \
+ "Print statistics about safepoint synchronization") \
\
product(intx, PrintSafepointStatisticsCount, 300, \
- "total number of safepoint statistics collected " \
+ "Total number of safepoint statistics collected " \
"before printing them out") \
\
product(intx, PrintSafepointStatisticsTimeout, -1, \
- "print safepoint statistics only when safepoint takes" \
- " more than PrintSafepointSatisticsTimeout in millis") \
+ "Print safepoint statistics only when safepoint takes " \
+ "more than PrintSafepointSatisticsTimeout in millis") \
\
product(bool, TraceSafepointCleanupTime, false, \
- "print the break down of clean up tasks performed during" \
- " safepoint") \
+ "Print the break down of clean up tasks performed during " \
+ "safepoint") \
\
product(bool, Inline, true, \
- "enable inlining") \
+ "Enable inlining") \
\
product(bool, ClipInlining, true, \
- "clip inlining if aggregate method exceeds DesiredMethodLimit") \
+ "Clip inlining if aggregate method exceeds DesiredMethodLimit") \
\
develop(bool, UseCHA, true, \
- "enable CHA") \
+ "Enable CHA") \
\
product(bool, UseTypeProfile, true, \
"Check interpreter profile for historically monomorphic calls") \
\
notproduct(bool, TimeCompiler, false, \
- "time the compiler") \
+ "Time the compiler") \
\
diagnostic(bool, PrintInlining, false, \
- "prints inlining optimizations") \
+ "Print inlining optimizations") \
\
product(bool, UsePopCountInstruction, false, \
"Use population count instruction") \
@@ -2509,57 +2536,59 @@
"Print when methods are replaced do to recompilation") \
\
develop(bool, PrintMethodFlushing, false, \
- "print the nmethods being flushed") \
+ "Print the nmethods being flushed") \
\
develop(bool, UseRelocIndex, false, \
- "use an index to speed random access to relocations") \
+ "Use an index to speed random access to relocations") \
\
develop(bool, StressCodeBuffers, false, \
- "Exercise code buffer expansion and other rare state changes") \
+ "Exercise code buffer expansion and other rare state changes") \
\
diagnostic(bool, DebugNonSafepoints, trueInDebug, \
- "Generate extra debugging info for non-safepoints in nmethods") \
+ "Generate extra debugging information for non-safepoints in " \
+ "nmethods") \
\
product(bool, PrintVMOptions, false, \
- "Print flags that appeared on the command line") \
+ "Print flags that appeared on the command line") \
\
product(bool, IgnoreUnrecognizedVMOptions, false, \
- "Ignore unrecognized VM options") \
+ "Ignore unrecognized VM options") \
\
product(bool, PrintCommandLineFlags, false, \
- "Print flags specified on command line or set by ergonomics") \
+ "Print flags specified on command line or set by ergonomics") \
\
product(bool, PrintFlagsInitial, false, \
- "Print all VM flags before argument processing and exit VM") \
+ "Print all VM flags before argument processing and exit VM") \
\
product(bool, PrintFlagsFinal, false, \
- "Print all VM flags after argument and ergonomic processing") \
+ "Print all VM flags after argument and ergonomic processing") \
\
notproduct(bool, PrintFlagsWithComments, false, \
- "Print all VM flags with default values and descriptions and exit")\
+ "Print all VM flags with default values and descriptions and " \
+ "exit") \
\
diagnostic(bool, SerializeVMOutput, true, \
- "Use a mutex to serialize output to tty and LogFile") \
+ "Use a mutex to serialize output to tty and LogFile") \
\
diagnostic(bool, DisplayVMOutput, true, \
- "Display all VM output on the tty, independently of LogVMOutput") \
+ "Display all VM output on the tty, independently of LogVMOutput") \
\
diagnostic(bool, LogVMOutput, false, \
- "Save VM output to LogFile") \
+ "Save VM output to LogFile") \
\
diagnostic(ccstr, LogFile, NULL, \
- "If LogVMOutput or LogCompilation is on, save VM output to " \
- "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)") \
+ "If LogVMOutput or LogCompilation is on, save VM output to " \
+ "this file [default: ./hotspot_pid%p.log] (%p replaced with pid)")\
\
product(ccstr, ErrorFile, NULL, \
- "If an error occurs, save the error data to this file " \
- "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
+ "If an error occurs, save the error data to this file " \
+ "[default: ./hs_err_pid%p.log] (%p replaced with pid)") \
\
product(bool, DisplayVMOutputToStderr, false, \
- "If DisplayVMOutput is true, display all VM output to stderr") \
+ "If DisplayVMOutput is true, display all VM output to stderr") \
\
product(bool, DisplayVMOutputToStdout, false, \
- "If DisplayVMOutput is true, display all VM output to stdout") \
+ "If DisplayVMOutput is true, display all VM output to stdout") \
\
product(bool, UseHeavyMonitors, false, \
"use heavyweight instead of lightweight Java monitors") \
@@ -2583,7 +2612,7 @@
\
notproduct(ccstr, AbortVMOnExceptionMessage, NULL, \
"Call fatal if the exception pointed by AbortVMOnException " \
- "has this message.") \
+ "has this message") \
\
develop(bool, DebugVtables, false, \
"add debugging code to vtable dispatch") \
@@ -2650,29 +2679,29 @@
\
/* statistics */ \
develop(bool, CountCompiledCalls, false, \
- "counts method invocations") \
+ "Count method invocations") \
\
notproduct(bool, CountRuntimeCalls, false, \
- "counts VM runtime calls") \
+ "Count VM runtime calls") \
\
develop(bool, CountJNICalls, false, \
- "counts jni method invocations") \
+ "Count jni method invocations") \
\
notproduct(bool, CountJVMCalls, false, \
- "counts jvm method invocations") \
+ "Count jvm method invocations") \
\
notproduct(bool, CountRemovableExceptions, false, \
- "count exceptions that could be replaced by branches due to " \
+ "Count exceptions that could be replaced by branches due to " \
"inlining") \
\
notproduct(bool, ICMissHistogram, false, \
- "produce histogram of IC misses") \
+ "Produce histogram of IC misses") \
\
notproduct(bool, PrintClassStatistics, false, \
- "prints class statistics at end of run") \
+ "Print class statistics at end of run") \
\
notproduct(bool, PrintMethodStatistics, false, \
- "prints method statistics at end of run") \
+ "Print method statistics at end of run") \
\
/* interpreter */ \
develop(bool, ClearInterpreterLocals, false, \
@@ -2686,7 +2715,7 @@
"Rewrite frequently used bytecode pairs into a single bytecode") \
\
diagnostic(bool, PrintInterpreter, false, \
- "Prints the generated interpreter code") \
+ "Print the generated interpreter code") \
\
product(bool, UseInterpreter, true, \
"Use interpreter for non-compiled methods") \
@@ -2704,8 +2733,8 @@
"Use fast method entry code for accessor methods") \
\
product_pd(bool, UseOnStackReplacement, \
- "Use on stack replacement, calls runtime if invoc. counter " \
- "overflows in loop") \
+ "Use on stack replacement, calls runtime if invoc. counter " \
+ "overflows in loop") \
\
notproduct(bool, TraceOnStackReplacement, false, \
"Trace on stack replacement") \
@@ -2753,10 +2782,10 @@
"Trace frequency based inlining") \
\
develop_pd(bool, InlineIntrinsics, \
- "Inline intrinsics that can be statically resolved") \
+ "Inline intrinsics that can be statically resolved") \
\
product_pd(bool, ProfileInterpreter, \
- "Profile at the bytecode level during interpretation") \
+ "Profile at the bytecode level during interpretation") \
\
develop_pd(bool, ProfileTraps, \
"Profile deoptimization traps at the bytecode level") \
@@ -2766,7 +2795,7 @@
"CompileThreshold) before using the method's profile") \
\
develop(bool, PrintMethodData, false, \
- "Print the results of +ProfileInterpreter at end of run") \
+ "Print the results of +ProfileInterpreter at end of run") \
\
develop(bool, VerifyDataPointer, trueInDebug, \
"Verify the method data pointer during interpreter profiling") \
@@ -2781,7 +2810,7 @@
\
/* compilation */ \
product(bool, UseCompiler, true, \
- "use compilation") \
+ "Use Just-In-Time compilation") \
\
develop(bool, TraceCompilationPolicy, false, \
"Trace compilation policy") \
@@ -2790,20 +2819,21 @@
"Time the compilation policy") \
\
product(bool, UseCounterDecay, true, \
- "adjust recompilation counters") \
+ "Adjust recompilation counters") \
\
develop(intx, CounterHalfLifeTime, 30, \
- "half-life time of invocation counters (in secs)") \
+ "Half-life time of invocation counters (in seconds)") \
\
develop(intx, CounterDecayMinIntervalLength, 500, \
- "Min. ms. between invocation of CounterDecay") \
+ "The minimum interval (in milliseconds) between invocation of " \
+ "CounterDecay") \
\
product(bool, AlwaysCompileLoopMethods, false, \
- "when using recompilation, never interpret methods " \
+ "When using recompilation, never interpret methods " \
"containing loops") \
\
product(bool, DontCompileHugeMethods, true, \
- "don't compile methods > HugeMethodLimit") \
+ "Do not compile methods > HugeMethodLimit") \
\
/* Bytecode escape analysis estimation. */ \
product(bool, EstimateArgEscape, true, \
@@ -2813,10 +2843,10 @@
"How much tracing to do of bytecode escape analysis estimates") \
\
product(intx, MaxBCEAEstimateLevel, 5, \
- "Maximum number of nested calls that are analyzed by BC EA.") \
+ "Maximum number of nested calls that are analyzed by BC EA") \
\
product(intx, MaxBCEAEstimateSize, 150, \
- "Maximum bytecode size of a method to be analyzed by BC EA.") \
+ "Maximum bytecode size of a method to be analyzed by BC EA") \
\
product(intx, AllocatePrefetchStyle, 1, \
"0 = no prefetch, " \
@@ -2831,7 +2861,8 @@
"Number of lines to prefetch ahead of array allocation pointer") \
\
product(intx, AllocateInstancePrefetchLines, 1, \
- "Number of lines to prefetch ahead of instance allocation pointer") \
+ "Number of lines to prefetch ahead of instance allocation " \
+ "pointer") \
\
product(intx, AllocatePrefetchStepSize, 16, \
"Step size in bytes of sequential prefetch instructions") \
@@ -2851,8 +2882,8 @@
"(0 means off)") \
\
product(intx, MaxJavaStackTraceDepth, 1024, \
- "Max. no. of lines in the stack trace for Java exceptions " \
- "(0 means all)") \
+ "The maximum number of lines in the stack trace for Java " \
+ "exceptions (0 means all)") \
\
NOT_EMBEDDED(diagnostic(intx, GuaranteedSafepointInterval, 1000, \
"Guarantee a safepoint (at least) every so many milliseconds " \
@@ -2876,10 +2907,10 @@
"result in more aggressive sweeping") \
\
notproduct(bool, LogSweeper, false, \
- "Keep a ring buffer of sweeper activity") \
+ "Keep a ring buffer of sweeper activity") \
\
notproduct(intx, SweeperLogEntries, 1024, \
- "Number of records in the ring buffer of sweeper activity") \
+ "Number of records in the ring buffer of sweeper activity") \
\
notproduct(intx, MemProfilingInterval, 500, \
"Time between each invocation of the MemProfiler") \
@@ -2922,34 +2953,35 @@
"less than this") \
\
product(intx, MaxInlineSize, 35, \
- "maximum bytecode size of a method to be inlined") \
+ "The maximum bytecode size of a method to be inlined") \
\
product_pd(intx, FreqInlineSize, \
- "maximum bytecode size of a frequent method to be inlined") \
+ "The maximum bytecode size of a frequent method to be inlined") \
\
product(intx, MaxTrivialSize, 6, \
- "maximum bytecode size of a trivial method to be inlined") \
+ "The maximum bytecode size of a trivial method to be inlined") \
\
product(intx, MinInliningThreshold, 250, \
- "min. invocation count a method needs to have to be inlined") \
+ "The minimum invocation count a method needs to have to be " \
+ "inlined") \
\
develop(intx, MethodHistogramCutoff, 100, \
- "cutoff value for method invoc. histogram (+CountCalls)") \
+ "The cutoff value for method invocation histogram (+CountCalls)") \
\
develop(intx, ProfilerNumberOfInterpretedMethods, 25, \
- "# of interpreted methods to show in profile") \
+ "Number of interpreted methods to show in profile") \
\
develop(intx, ProfilerNumberOfCompiledMethods, 25, \
- "# of compiled methods to show in profile") \
+ "Number of compiled methods to show in profile") \
\
develop(intx, ProfilerNumberOfStubMethods, 25, \
- "# of stub methods to show in profile") \
+ "Number of stub methods to show in profile") \
\
develop(intx, ProfilerNumberOfRuntimeStubNodes, 25, \
- "# of runtime stub nodes to show in profile") \
+ "Number of runtime stub nodes to show in profile") \
\
product(intx, ProfileIntervalsTicks, 100, \
- "# of ticks between printing of interval profile " \
+ "Number of ticks between printing of interval profile " \
"(+ProfileIntervals)") \
\
notproduct(intx, ScavengeALotInterval, 1, \
@@ -2970,7 +3002,7 @@
\
develop(intx, MinSleepInterval, 1, \
"Minimum sleep() interval (milliseconds) when " \
- "ConvertSleepToYield is off (used for SOLARIS)") \
+ "ConvertSleepToYield is off (used for Solaris)") \
\
develop(intx, ProfilerPCTickThreshold, 15, \
"Number of ticks in a PC buckets to be a hotspot") \
@@ -2985,22 +3017,22 @@
"Mark nmethods non-entrant at registration") \
\
diagnostic(intx, MallocVerifyInterval, 0, \
- "if non-zero, verify C heap after every N calls to " \
+ "If non-zero, verify C heap after every N calls to " \
"malloc/realloc/free") \
\
diagnostic(intx, MallocVerifyStart, 0, \
- "if non-zero, start verifying C heap after Nth call to " \
+ "If non-zero, start verifying C heap after Nth call to " \
"malloc/realloc/free") \
\
diagnostic(uintx, MallocMaxTestWords, 0, \
- "if non-zero, max # of Words that malloc/realloc can allocate " \
- "(for testing only)") \
+ "If non-zero, maximum number of words that malloc/realloc can " \
+ "allocate (for testing only)") \
\
product(intx, TypeProfileWidth, 2, \
- "number of receiver types to record in call/cast profile") \
+ "Number of receiver types to record in call/cast profile") \
\
develop(intx, BciProfileWidth, 2, \
- "number of return bci's to record in ret profile") \
+ "Number of return bci's to record in ret profile") \
\
product(intx, PerMethodRecompilationCutoff, 400, \
"After recompiling N times, stay in the interpreter (-1=>'Inf')") \
@@ -3067,7 +3099,7 @@
"Percentage of Eden that can be wasted") \
\
product(uintx, TLABRefillWasteFraction, 64, \
- "Max TLAB waste at a refill (internal fragmentation)") \
+ "Maximum TLAB waste at a refill (internal fragmentation)") \
\
product(uintx, TLABWasteIncrement, 4, \
"Increment allowed waste at slow allocation") \
@@ -3076,7 +3108,7 @@
"Ratio of eden/survivor space size") \
\
product(uintx, NewRatio, 2, \
- "Ratio of new/old generation sizes") \
+ "Ratio of old/new generation sizes") \
\
product_pd(uintx, NewSizeThreadIncrease, \
"Additional size added to desired new generation size per " \
@@ -3093,28 +3125,30 @@
"class pointers are used") \
\
product(uintx, MinHeapFreeRatio, 40, \
- "Min percentage of heap free after GC to avoid expansion") \
+ "The minimum percentage of heap free after GC to avoid expansion")\
\
product(uintx, MaxHeapFreeRatio, 70, \
- "Max percentage of heap free after GC to avoid shrinking") \
+ "The maximum percentage of heap free after GC to avoid shrinking")\
\
product(intx, SoftRefLRUPolicyMSPerMB, 1000, \
"Number of milliseconds per MB of free space in the heap") \
\
product(uintx, MinHeapDeltaBytes, ScaleForWordSize(128*K), \
- "Min change in heap space due to GC (in bytes)") \
+ "The minimum change in heap space due to GC (in bytes)") \
\
product(uintx, MinMetaspaceExpansion, ScaleForWordSize(256*K), \
- "Min expansion of Metaspace (in bytes)") \
+ "The minimum expansion of Metaspace (in bytes)") \
\
product(uintx, MinMetaspaceFreeRatio, 40, \
- "Min percentage of Metaspace free after GC to avoid expansion") \
+ "The minimum percentage of Metaspace free after GC to avoid " \
+ "expansion") \
\
product(uintx, MaxMetaspaceFreeRatio, 70, \
- "Max percentage of Metaspace free after GC to avoid shrinking") \
+ "The maximum percentage of Metaspace free after GC to avoid " \
+ "shrinking") \
\
product(uintx, MaxMetaspaceExpansion, ScaleForWordSize(4*M), \
- "Max expansion of Metaspace without full GC (in bytes)") \
+ "The maximum expansion of Metaspace without full GC (in bytes)") \
\
product(uintx, QueuedAllocationWarningCount, 0, \
"Number of times an allocation that queues behind a GC " \
@@ -3136,13 +3170,14 @@
"Desired percentage of survivor space used after scavenge") \
\
product(uintx, MarkSweepDeadRatio, 5, \
- "Percentage (0-100) of the old gen allowed as dead wood." \
- "Serial mark sweep treats this as both the min and max value." \
- "CMS uses this value only if it falls back to mark sweep." \
- "Par compact uses a variable scale based on the density of the" \
- "generation and treats this as the max value when the heap is" \
- "either completely full or completely empty. Par compact also" \
- "has a smaller default value; see arguments.cpp.") \
+ "Percentage (0-100) of the old gen allowed as dead wood. " \
+ "Serial mark sweep treats this as both the minimum and maximum " \
+ "value. " \
+ "CMS uses this value only if it falls back to mark sweep. " \
+ "Par compact uses a variable scale based on the density of the " \
+ "generation and treats this as the maximum value when the heap " \
+ "is either completely full or completely empty. Par compact " \
+ "also has a smaller default value; see arguments.cpp.") \
\
product(uintx, MarkSweepAlwaysCompactCount, 4, \
"How often should we fully compact the heap (ignoring the dead " \
@@ -3161,27 +3196,27 @@
"Census for CMS' FreeListSpace") \
\
develop(uintx, GCExpandToAllocateDelayMillis, 0, \
- "Delay in ms between expansion and allocation") \
+ "Delay between expansion and allocation (in milliseconds)") \
\
develop(uintx, GCWorkerDelayMillis, 0, \
- "Delay in ms in scheduling GC workers") \
+ "Delay in scheduling GC workers (in milliseconds)") \
\
product(intx, DeferThrSuspendLoopCount, 4000, \
"(Unstable) Number of times to iterate in safepoint loop " \
- " before blocking VM threads ") \
+ "before blocking VM threads ") \
\
product(intx, DeferPollingPageLoopCount, -1, \
"(Unsafe,Unstable) Number of iterations in safepoint loop " \
"before changing safepoint polling page to RO ") \
\
- product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
+ product(intx, SafepointSpinBeforeYield, 2000, "(Unstable)") \
\
product(bool, PSChunkLargeArrays, true, \
- "true: process large arrays in chunks") \
+ "Process large arrays in chunks") \
\
product(uintx, GCDrainStackTargetSize, 64, \
- "how many entries we'll try to leave on the stack during " \
- "parallel GC") \
+ "Number of entries we will try to leave on the stack " \
+ "during parallel gc") \
\
/* stack parameters */ \
product_pd(intx, StackYellowPages, \
@@ -3191,8 +3226,8 @@
"Number of red zone (unrecoverable overflows) pages") \
\
product_pd(intx, StackShadowPages, \
- "Number of shadow zone (for overflow checking) pages" \
- " this should exceed the depth of the VM and native call stack") \
+ "Number of shadow zone (for overflow checking) pages " \
+ "this should exceed the depth of the VM and native call stack") \
\
product_pd(intx, ThreadStackSize, \
"Thread Stack Size (in Kbytes)") \
@@ -3232,16 +3267,16 @@
"Reserved code cache size (in bytes) - maximum code cache size") \
\
product(uintx, CodeCacheMinimumFreeSpace, 500*K, \
- "When less than X space left, we stop compiling.") \
+ "When less than X space left, we stop compiling") \
\
product_pd(uintx, CodeCacheExpansionSize, \
"Code cache expansion size (in bytes)") \
\
develop_pd(uintx, CodeCacheMinBlockLength, \
- "Minimum number of segments in a code cache block.") \
+ "Minimum number of segments in a code cache block") \
\
notproduct(bool, ExitOnFullCodeCache, false, \
- "Exit the VM if we fill the code cache.") \
+ "Exit the VM if we fill the code cache") \
\
product(bool, UseCodeCacheFlushing, true, \
"Attempt to clean the code cache before shutting off compiler") \
@@ -3252,31 +3287,31 @@
"switch") \
\
develop(intx, StopInterpreterAt, 0, \
- "Stops interpreter execution at specified bytecode number") \
+ "Stop interpreter execution at specified bytecode number") \
\
develop(intx, TraceBytecodesAt, 0, \
- "Traces bytecodes starting with specified bytecode number") \
+ "Trace bytecodes starting with specified bytecode number") \
\
/* compiler interface */ \
develop(intx, CIStart, 0, \
- "the id of the first compilation to permit") \
+ "The id of the first compilation to permit") \
\
develop(intx, CIStop, -1, \
- "the id of the last compilation to permit") \
+ "The id of the last compilation to permit") \
\
develop(intx, CIStartOSR, 0, \
- "the id of the first osr compilation to permit " \
+ "The id of the first osr compilation to permit " \
"(CICountOSR must be on)") \
\
develop(intx, CIStopOSR, -1, \
- "the id of the last osr compilation to permit " \
+ "The id of the last osr compilation to permit " \
"(CICountOSR must be on)") \
\
develop(intx, CIBreakAtOSR, -1, \
- "id of osr compilation to break at") \
+ "The id of osr compilation to break at") \
\
develop(intx, CIBreakAt, -1, \
- "id of compilation to break at") \
+ "The id of compilation to break at") \
\
product(ccstrlist, CompileOnly, "", \
"List of methods (pkg/class.name) to restrict compilation to") \
@@ -3295,11 +3330,11 @@
"[default: ./replay_pid%p.log] (%p replaced with pid)") \
\
develop(intx, ReplaySuppressInitializers, 2, \
- "Controls handling of class initialization during replay" \
- "0 - don't do anything special" \
- "1 - treat all class initializers as empty" \
- "2 - treat class initializers for application classes as empty" \
- "3 - allow all class initializers to run during bootstrap but" \
+ "Control handling of class initialization during replay: " \
+ "0 - don't do anything special; " \
+ "1 - treat all class initializers as empty; " \
+ "2 - treat class initializers for application classes as empty; " \
+ "3 - allow all class initializers to run during bootstrap but " \
" pretend they are empty after starting replay") \
\
develop(bool, ReplayIgnoreInitErrors, false, \
@@ -3328,14 +3363,15 @@
"0 : Normal. "\
" VM chooses priorities that are appropriate for normal "\
" applications. On Solaris NORM_PRIORITY and above are mapped "\
- " to normal native priority. Java priorities below NORM_PRIORITY"\
- " map to lower native priority values. On Windows applications"\
- " are allowed to use higher native priorities. However, with "\
- " ThreadPriorityPolicy=0, VM will not use the highest possible"\
- " native priority, THREAD_PRIORITY_TIME_CRITICAL, as it may "\
- " interfere with system threads. On Linux thread priorities "\
- " are ignored because the OS does not support static priority "\
- " in SCHED_OTHER scheduling class which is the only choice for"\
+ " to normal native priority. Java priorities below " \
+ " NORM_PRIORITY map to lower native priority values. On "\
+ " Windows applications are allowed to use higher native "\
+ " priorities. However, with ThreadPriorityPolicy=0, VM will "\
+ " not use the highest possible native priority, "\
+ " THREAD_PRIORITY_TIME_CRITICAL, as it may interfere with "\
+ " system threads. On Linux thread priorities are ignored "\
+ " because the OS does not support static priority in "\
+ " SCHED_OTHER scheduling class which is the only choice for "\
" non-root, non-realtime applications. "\
"1 : Aggressive. "\
" Java thread priorities map over to the entire range of "\
@@ -3366,16 +3402,35 @@
product(bool, VMThreadHintNoPreempt, false, \
"(Solaris only) Give VM thread an extra quanta") \
\
- product(intx, JavaPriority1_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority2_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority3_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority4_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority5_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority6_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority7_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority8_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority9_To_OSPriority, -1, "Map Java priorities to OS priorities") \
- product(intx, JavaPriority10_To_OSPriority,-1, "Map Java priorities to OS priorities") \
+ product(intx, JavaPriority1_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority2_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority3_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority4_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority5_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority6_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority7_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority8_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority9_To_OSPriority, -1, \
+ "Map Java priorities to OS priorities") \
+ \
+ product(intx, JavaPriority10_To_OSPriority,-1, \
+ "Map Java priorities to OS priorities") \
\
experimental(bool, UseCriticalJavaThreadPriority, false, \
"Java thread priority 10 maps to critical scheduling priority") \
@@ -3406,37 +3461,38 @@
"Used with +TraceLongCompiles") \
\
product(intx, StarvationMonitorInterval, 200, \
- "Pause between each check in ms") \
+ "Pause between each check (in milliseconds)") \
\
/* recompilation */ \
product_pd(intx, CompileThreshold, \
"number of interpreted method invocations before (re-)compiling") \
\
product_pd(intx, BackEdgeThreshold, \
- "Interpreter Back edge threshold at which an OSR compilation is invoked")\
+ "Interpreter Back edge threshold at which an OSR compilation is " \
+ "invoked") \
\
product(intx, Tier0InvokeNotifyFreqLog, 7, \
- "Interpreter (tier 0) invocation notification frequency.") \
+ "Interpreter (tier 0) invocation notification frequency") \
\
product(intx, Tier2InvokeNotifyFreqLog, 11, \
- "C1 without MDO (tier 2) invocation notification frequency.") \
+ "C1 without MDO (tier 2) invocation notification frequency") \
\
product(intx, Tier3InvokeNotifyFreqLog, 10, \
"C1 with MDO profiling (tier 3) invocation notification " \
- "frequency.") \
+ "frequency") \
\
product(intx, Tier23InlineeNotifyFreqLog, 20, \
"Inlinee invocation (tiers 2 and 3) notification frequency") \
\
product(intx, Tier0BackedgeNotifyFreqLog, 10, \
- "Interpreter (tier 0) invocation notification frequency.") \
+ "Interpreter (tier 0) invocation notification frequency") \
\
product(intx, Tier2BackedgeNotifyFreqLog, 14, \
- "C1 without MDO (tier 2) invocation notification frequency.") \
+ "C1 without MDO (tier 2) invocation notification frequency") \
\
product(intx, Tier3BackedgeNotifyFreqLog, 13, \
"C1 with MDO profiling (tier 3) invocation notification " \
- "frequency.") \
+ "frequency") \
\
product(intx, Tier2CompileThreshold, 0, \
"threshold at which tier 2 compilation is invoked") \
@@ -3453,7 +3509,7 @@
\
product(intx, Tier3CompileThreshold, 2000, \
"Threshold at which tier 3 compilation is invoked (invocation " \
- "minimum must be satisfied.") \
+ "minimum must be satisfied") \
\
product(intx, Tier3BackEdgeThreshold, 60000, \
"Back edge threshold at which tier 3 OSR compilation is invoked") \
@@ -3467,7 +3523,7 @@
\
product(intx, Tier4CompileThreshold, 15000, \
"Threshold at which tier 4 compilation is invoked (invocation " \
- "minimum must be satisfied.") \
+ "minimum must be satisfied") \
\
product(intx, Tier4BackEdgeThreshold, 40000, \
"Back edge threshold at which tier 4 OSR compilation is invoked") \
@@ -3496,12 +3552,12 @@
"Stop at given compilation level") \
\
product(intx, Tier0ProfilingStartPercentage, 200, \
- "Start profiling in interpreter if the counters exceed tier 3" \
+ "Start profiling in interpreter if the counters exceed tier 3 " \
"thresholds by the specified percentage") \
\
product(uintx, IncreaseFirstTierCompileThresholdAt, 50, \
- "Increase the compile threshold for C1 compilation if the code" \
- "cache is filled by the specified percentage.") \
+ "Increase the compile threshold for C1 compilation if the code " \
+ "cache is filled by the specified percentage") \
\
product(intx, TieredRateUpdateMinTime, 1, \
"Minimum rate sampling interval (in milliseconds)") \
@@ -3516,24 +3572,26 @@
"Print tiered events notifications") \
\
product_pd(intx, OnStackReplacePercentage, \
- "NON_TIERED number of method invocations/branches (expressed as %"\
- "of CompileThreshold) before (re-)compiling OSR code") \
+ "NON_TIERED number of method invocations/branches (expressed as " \
+ "% of CompileThreshold) before (re-)compiling OSR code") \
\
product(intx, InterpreterProfilePercentage, 33, \
- "NON_TIERED number of method invocations/branches (expressed as %"\
- "of CompileThreshold) before profiling in the interpreter") \
+ "NON_TIERED number of method invocations/branches (expressed as " \
+ "% of CompileThreshold) before profiling in the interpreter") \
\
develop(intx, MaxRecompilationSearchLength, 10, \
- "max. # frames to inspect searching for recompilee") \
+ "The maximum number of frames to inspect when searching for " \
+ "recompilee") \
\
develop(intx, MaxInterpretedSearchLength, 3, \
- "max. # interp. frames to skip when searching for recompilee") \
+ "The maximum number of interpreted frames to skip when searching "\
+ "for recompilee") \
\
develop(intx, DesiredMethodLimit, 8000, \
- "desired max. method size (in bytecodes) after inlining") \
+ "The desired maximum method size (in bytecodes) after inlining") \
\
develop(intx, HugeMethodLimit, 8000, \
- "don't compile methods larger than this if " \
+ "Don't compile methods larger than this if " \
"+DontCompileHugeMethods") \
\
/* New JDK 1.4 reflection implementation */ \
@@ -3555,7 +3613,7 @@
"in InvocationTargetException. See 6531596") \
\
develop(bool, VerifyLambdaBytecodes, false, \
- "Force verification of jdk 8 lambda metafactory bytecodes.") \
+ "Force verification of jdk 8 lambda metafactory bytecodes") \
\
develop(intx, FastSuperclassLimit, 8, \
"Depth of hardwired instanceof accelerator array") \
@@ -3579,18 +3637,19 @@
/* flags for performance data collection */ \
\
product(bool, UsePerfData, falseInEmbedded, \
- "Flag to disable jvmstat instrumentation for performance testing" \
- "and problem isolation purposes.") \
+ "Flag to disable jvmstat instrumentation for performance testing "\
+ "and problem isolation purposes") \
\
product(bool, PerfDataSaveToFile, false, \
"Save PerfData memory to hsperfdata_<pid> file on exit") \
\
product(ccstr, PerfDataSaveFile, NULL, \
- "Save PerfData memory to the specified absolute pathname," \
- "%p in the file name if present will be replaced by pid") \
- \
- product(intx, PerfDataSamplingInterval, 50 /*ms*/, \
- "Data sampling interval in milliseconds") \
+ "Save PerfData memory to the specified absolute pathname. " \
+ "The string %p in the file name (if present) " \
+ "will be replaced by pid") \
+ \
+ product(intx, PerfDataSamplingInterval, 50, \
+ "Data sampling interval (in milliseconds)") \
\
develop(bool, PerfTraceDataCreation, false, \
"Trace creation of Performance Data Entries") \
@@ -3615,7 +3674,7 @@
"Bypass Win32 file system criteria checks (Windows Only)") \
\
product(intx, UnguardOnExecutionViolation, 0, \
- "Unguard page and retry on no-execute fault (Win32 only)" \
+ "Unguard page and retry on no-execute fault (Win32 only) " \
"0=off, 1=conservative, 2=aggressive") \
\
/* Serviceability Support */ \
@@ -3624,7 +3683,7 @@
"Create JMX Management Server") \
\
product(bool, DisableAttachMechanism, false, \
- "Disable mechanism that allows tools to attach to this VM") \
+ "Disable mechanism that allows tools to attach to this VM") \
\
product(bool, StartAttachListener, false, \
"Always start Attach Listener at VM startup") \
@@ -3647,9 +3706,9 @@
"Require shared spaces for metadata") \
\
product(bool, DumpSharedSpaces, false, \
- "Special mode: JVM reads a class list, loads classes, builds " \
- "shared spaces, and dumps the shared spaces to a file to be " \
- "used in future JVM runs.") \
+ "Special mode: JVM reads a class list, loads classes, builds " \
+ "shared spaces, and dumps the shared spaces to a file to be " \
+ "used in future JVM runs") \
\
product(bool, PrintSharedSpaces, false, \
"Print usage of shared spaces") \
@@ -3722,11 +3781,14 @@
"Relax the access control checks in the verifier") \
\
diagnostic(bool, PrintDTraceDOF, false, \
- "Print the DTrace DOF passed to the system for JSDT probes") \
+ "Print the DTrace DOF passed to the system for JSDT probes") \
\
product(uintx, StringTableSize, defaultStringTableSize, \
"Number of buckets in the interned String table") \
\
+ experimental(uintx, SymbolTableSize, defaultSymbolTableSize, \
+ "Number of buckets in the JVM internal Symbol table") \
+ \
develop(bool, TraceDefaultMethods, false, \
"Trace the default method processing steps") \
\
@@ -3735,8 +3797,8 @@
\
product(bool, UseVMInterruptibleIO, false, \
"(Unstable, Solaris-specific) Thread interrupt before or with " \
- "EINTR for I/O operations results in OS_INTRPT. The default value"\
- " of this flag is true for JDK 6 and earlier") \
+ "EINTR for I/O operations results in OS_INTRPT. The default " \
+ "value of this flag is true for JDK 6 and earlier") \
\
diagnostic(bool, WhiteBoxAPI, false, \
"Enable internal testing APIs") \
@@ -3757,6 +3819,7 @@
\
product(bool, EnableTracing, false, \
"Enable event-based tracing") \
+ \
product(bool, UseLockedTracing, false, \
"Use locked-tracing when doing event-based tracing")
--- a/hotspot/src/share/vm/runtime/reflectionUtils.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/reflectionUtils.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 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
@@ -27,8 +27,11 @@
#include "memory/universe.inline.hpp"
#include "runtime/reflectionUtils.hpp"
-KlassStream::KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only) {
- _klass = klass;
+KlassStream::KlassStream(instanceKlassHandle klass, bool local_only,
+ bool classes_only, bool walk_defaults) {
+ _klass = _base_klass = klass;
+ _base_class_search_defaults = false;
+ _defaults_checked = false;
if (classes_only) {
_interfaces = Universe::the_empty_klass_array();
} else {
@@ -37,6 +40,7 @@
_interface_index = _interfaces->length();
_local_only = local_only;
_classes_only = classes_only;
+ _walk_defaults = walk_defaults;
}
bool KlassStream::eos() {
@@ -45,7 +49,13 @@
if (!_klass->is_interface() && _klass->super() != NULL) {
// go up superclass chain (not for interfaces)
_klass = _klass->super();
+ // Next for method walks, walk default methods
+ } else if (_walk_defaults && (_defaults_checked == false) && (_base_klass->default_methods() != NULL)) {
+ _base_class_search_defaults = true;
+ _klass = _base_klass;
+ _defaults_checked = true;
} else {
+ // Next walk transitive interfaces
if (_interface_index > 0) {
_klass = _interfaces->at(--_interface_index);
} else {
--- a/hotspot/src/share/vm/runtime/reflectionUtils.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/reflectionUtils.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -38,7 +38,7 @@
// and (super)interfaces. Streaming is done in reverse order (subclasses first,
// interfaces last).
//
-// for (KlassStream st(k, false, false); !st.eos(); st.next()) {
+// for (KlassStream st(k, false, false, false); !st.eos(); st.next()) {
// Klass* k = st.klass();
// ...
// }
@@ -46,17 +46,21 @@
class KlassStream VALUE_OBJ_CLASS_SPEC {
protected:
instanceKlassHandle _klass; // current klass/interface iterated over
- Array<Klass*>* _interfaces; // transitive interfaces for initial class
+ instanceKlassHandle _base_klass; // initial klass/interface to iterate over
+ Array<Klass*>* _interfaces; // transitive interfaces for initial class
int _interface_index; // current interface being processed
bool _local_only; // process initial class/interface only
bool _classes_only; // process classes only (no interfaces)
+ bool _walk_defaults; // process default methods
+ bool _base_class_search_defaults; // time to process default methods
+ bool _defaults_checked; // already checked for default methods
int _index;
- virtual int length() const = 0;
+ virtual int length() = 0;
public:
// constructor
- KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only);
+ KlassStream(instanceKlassHandle klass, bool local_only, bool classes_only, bool walk_defaults);
// testing
bool eos();
@@ -67,6 +71,8 @@
// accessors
instanceKlassHandle klass() const { return _klass; }
int index() const { return _index; }
+ bool base_class_search_defaults() const { return _base_class_search_defaults; }
+ void base_class_search_defaults(bool b) { _base_class_search_defaults = b; }
};
@@ -81,17 +87,24 @@
class MethodStream : public KlassStream {
private:
- int length() const { return methods()->length(); }
- Array<Method*>* methods() const { return _klass->methods(); }
+ int length() { return methods()->length(); }
+ Array<Method*>* methods() {
+ if (base_class_search_defaults()) {
+ base_class_search_defaults(false);
+ return _klass->default_methods();
+ } else {
+ return _klass->methods();
+ }
+ }
public:
MethodStream(instanceKlassHandle klass, bool local_only, bool classes_only)
- : KlassStream(klass, local_only, classes_only) {
+ : KlassStream(klass, local_only, classes_only, true) {
_index = length();
next();
}
void next() { _index--; }
- Method* method() const { return methods()->at(index()); }
+ Method* method() { return methods()->at(index()); }
};
@@ -107,13 +120,13 @@
class FieldStream : public KlassStream {
private:
- int length() const { return _klass->java_fields_count(); }
+ int length() { return _klass->java_fields_count(); }
fieldDescriptor _fd_buf;
public:
FieldStream(instanceKlassHandle klass, bool local_only, bool classes_only)
- : KlassStream(klass, local_only, classes_only) {
+ : KlassStream(klass, local_only, classes_only, false) {
_index = length();
next();
}
--- a/hotspot/src/share/vm/runtime/virtualspace.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/virtualspace.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -368,8 +368,15 @@
bool VirtualSpace::initialize(ReservedSpace rs, size_t committed_size) {
+ const size_t max_commit_granularity = os::page_size_for_region(rs.size(), rs.size(), 1);
+ return initialize_with_granularity(rs, committed_size, max_commit_granularity);
+}
+
+bool VirtualSpace::initialize_with_granularity(ReservedSpace rs, size_t committed_size, size_t max_commit_granularity) {
if(!rs.is_reserved()) return false; // allocation failed.
assert(_low_boundary == NULL, "VirtualSpace already initialized");
+ assert(max_commit_granularity > 0, "Granularity must be non-zero.");
+
_low_boundary = rs.base();
_high_boundary = low_boundary() + rs.size();
@@ -390,7 +397,7 @@
// No attempt is made to force large page alignment at the very top and
// bottom of the space if they are not aligned so already.
_lower_alignment = os::vm_page_size();
- _middle_alignment = os::page_size_for_region(rs.size(), rs.size(), 1);
+ _middle_alignment = max_commit_granularity;
_upper_alignment = os::vm_page_size();
// End of each region
@@ -966,17 +973,52 @@
class TestVirtualSpace : AllStatic {
+ enum TestLargePages {
+ Default,
+ Disable,
+ Reserve,
+ Commit
+ };
+
+ static ReservedSpace reserve_memory(size_t reserve_size_aligned, TestLargePages mode) {
+ switch(mode) {
+ default:
+ case Default:
+ case Reserve:
+ return ReservedSpace(reserve_size_aligned);
+ case Disable:
+ case Commit:
+ return ReservedSpace(reserve_size_aligned,
+ os::vm_allocation_granularity(),
+ /* large */ false, /* exec */ false);
+ }
+ }
+
+ static bool initialize_virtual_space(VirtualSpace& vs, ReservedSpace rs, TestLargePages mode) {
+ switch(mode) {
+ default:
+ case Default:
+ case Reserve:
+ return vs.initialize(rs, 0);
+ case Disable:
+ return vs.initialize_with_granularity(rs, 0, os::vm_page_size());
+ case Commit:
+ return vs.initialize_with_granularity(rs, 0, os::page_size_for_region(rs.size(), rs.size(), 1));
+ }
+ }
+
public:
- static void test_virtual_space_actual_committed_space(size_t reserve_size, size_t commit_size) {
+ static void test_virtual_space_actual_committed_space(size_t reserve_size, size_t commit_size,
+ TestLargePages mode = Default) {
size_t granularity = os::vm_allocation_granularity();
size_t reserve_size_aligned = align_size_up(reserve_size, granularity);
- ReservedSpace reserved(reserve_size_aligned);
+ ReservedSpace reserved = reserve_memory(reserve_size_aligned, mode);
assert(reserved.is_reserved(), "Must be");
VirtualSpace vs;
- bool initialized = vs.initialize(reserved, 0);
+ bool initialized = initialize_virtual_space(vs, reserved, mode);
assert(initialized, "Failed to initialize VirtualSpace");
vs.expand_by(commit_size, false);
@@ -986,7 +1028,10 @@
} else {
assert_ge(vs.actual_committed_size(), commit_size);
// Approximate the commit granularity.
- size_t commit_granularity = UseLargePages ? os::large_page_size() : os::vm_page_size();
+ // Make sure that we don't commit using large pages
+ // if large pages has been disabled for this VirtualSpace.
+ size_t commit_granularity = (mode == Disable || !UseLargePages) ?
+ os::vm_page_size() : os::large_page_size();
assert_lt(vs.actual_committed_size(), commit_size + commit_granularity);
}
@@ -1042,9 +1087,40 @@
test_virtual_space_actual_committed_space(10 * M, 10 * M);
}
+ static void test_virtual_space_disable_large_pages() {
+ if (!UseLargePages) {
+ return;
+ }
+ // These test cases verify that if we force VirtualSpace to disable large pages
+ test_virtual_space_actual_committed_space(10 * M, 0, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 4 * K, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 8 * K, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 1 * M, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 2 * M, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 5 * M, Disable);
+ test_virtual_space_actual_committed_space(10 * M, 10 * M, Disable);
+
+ test_virtual_space_actual_committed_space(10 * M, 0, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 4 * K, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 8 * K, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 1 * M, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 2 * M, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 5 * M, Reserve);
+ test_virtual_space_actual_committed_space(10 * M, 10 * M, Reserve);
+
+ test_virtual_space_actual_committed_space(10 * M, 0, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 4 * K, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 8 * K, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 1 * M, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 2 * M, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 5 * M, Commit);
+ test_virtual_space_actual_committed_space(10 * M, 10 * M, Commit);
+ }
+
static void test_virtual_space() {
test_virtual_space_actual_committed_space();
test_virtual_space_actual_committed_space_one_large_page();
+ test_virtual_space_disable_large_pages();
}
};
--- a/hotspot/src/share/vm/runtime/virtualspace.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/virtualspace.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -178,6 +178,7 @@
public:
// Initialization
VirtualSpace();
+ bool initialize_with_granularity(ReservedSpace rs, size_t committed_byte_size, size_t max_commit_ganularity);
bool initialize(ReservedSpace rs, size_t committed_byte_size);
// Destruction
--- a/hotspot/src/share/vm/runtime/vmStructs.cpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/runtime/vmStructs.cpp Fri Oct 11 13:00:40 2013 -0700
@@ -27,7 +27,6 @@
#include "classfile/javaClasses.hpp"
#include "classfile/loaderConstraints.hpp"
#include "classfile/placeholders.hpp"
-#include "classfile/symbolTable.hpp"
#include "classfile/systemDictionary.hpp"
#include "ci/ciField.hpp"
#include "ci/ciInstance.hpp"
@@ -289,6 +288,7 @@
nonstatic_field(ConstantPoolCache, _constant_pool, ConstantPool*) \
nonstatic_field(InstanceKlass, _array_klasses, Klass*) \
nonstatic_field(InstanceKlass, _methods, Array<Method*>*) \
+ nonstatic_field(InstanceKlass, _default_methods, Array<Method*>*) \
nonstatic_field(InstanceKlass, _local_interfaces, Array<Klass*>*) \
nonstatic_field(InstanceKlass, _transitive_interfaces, Array<Klass*>*) \
nonstatic_field(InstanceKlass, _fields, Array<u2>*) \
@@ -323,6 +323,7 @@
nonstatic_field(nmethodBucket, _count, int) \
nonstatic_field(nmethodBucket, _next, nmethodBucket*) \
nonstatic_field(InstanceKlass, _method_ordering, Array<int>*) \
+ nonstatic_field(InstanceKlass, _default_vtable_indices, Array<int>*) \
nonstatic_field(Klass, _super_check_offset, juint) \
nonstatic_field(Klass, _secondary_super_cache, Klass*) \
nonstatic_field(Klass, _secondary_supers, Array<Klass*>*) \
@@ -715,11 +716,17 @@
nonstatic_field(PlaceholderEntry, _loader_data, ClassLoaderData*) \
\
/**************************/ \
- /* ProctectionDomainEntry */ \
+ /* ProtectionDomainEntry */ \
/**************************/ \
\
nonstatic_field(ProtectionDomainEntry, _next, ProtectionDomainEntry*) \
- nonstatic_field(ProtectionDomainEntry, _protection_domain, oop) \
+ nonstatic_field(ProtectionDomainEntry, _pd_cache, ProtectionDomainCacheEntry*) \
+ \
+ /*******************************/ \
+ /* ProtectionDomainCacheEntry */ \
+ /*******************************/ \
+ \
+ nonstatic_field(ProtectionDomainCacheEntry, _literal, oop) \
\
/*************************/ \
/* LoaderConstraintEntry */ \
@@ -1562,6 +1569,7 @@
declare_toplevel_type(SystemDictionary) \
declare_toplevel_type(vmSymbols) \
declare_toplevel_type(ProtectionDomainEntry) \
+ declare_toplevel_type(ProtectionDomainCacheEntry) \
\
declare_toplevel_type(GenericGrowableArray) \
declare_toplevel_type(GrowableArray<int>) \
@@ -2247,12 +2255,6 @@
declare_preprocessor_constant("PERFDATA_BIG_ENDIAN", PERFDATA_BIG_ENDIAN) \
declare_preprocessor_constant("PERFDATA_LITTLE_ENDIAN", PERFDATA_LITTLE_ENDIAN) \
\
- /***************/ \
- /* SymbolTable */ \
- /***************/ \
- \
- declare_constant(SymbolTable::symbol_table_size) \
- \
/***********************************/ \
/* LoaderConstraintTable constants */ \
/***********************************/ \
--- a/hotspot/src/share/vm/services/memoryService.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/services/memoryService.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -148,6 +148,12 @@
static void track_code_cache_memory_usage() {
track_memory_pool_usage(_code_heap_pool);
}
+ static void track_metaspace_memory_usage() {
+ track_memory_pool_usage(_metaspace_pool);
+ }
+ static void track_compressed_class_memory_usage() {
+ track_memory_pool_usage(_compressed_class_pool);
+ }
static void track_memory_pool_usage(MemoryPool* pool);
static void gc_begin(bool fullGC, bool recordGCBeginTime,
--- a/hotspot/src/share/vm/utilities/globalDefinitions.hpp Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/src/share/vm/utilities/globalDefinitions.hpp Fri Oct 11 13:00:40 2013 -0700
@@ -326,12 +326,18 @@
const int max_method_code_size = 64*K - 1; // JVM spec, 2nd ed. section 4.8.1 (p.134)
+// Default ProtectionDomainCacheSize values
+
+const int defaultProtectionDomainCacheSize = NOT_LP64(137) LP64_ONLY(2017);
//----------------------------------------------------------------------------------------------------
// Default and minimum StringTableSize values
const int defaultStringTableSize = NOT_LP64(1009) LP64_ONLY(60013);
-const int minimumStringTableSize=1009;
+const int minimumStringTableSize = 1009;
+
+const int defaultSymbolTableSize = 20011;
+const int minimumSymbolTableSize = 1009;
//----------------------------------------------------------------------------------------------------
--- a/hotspot/test/TEST.groups Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/test/TEST.groups Fri Oct 11 13:00:40 2013 -0700
@@ -65,7 +65,6 @@
gc/metaspace/CompressedClassSpaceSizeInJmapHeap.java \
gc/metaspace/TestMetaspacePerfCounters.java \
runtime/6819213/TestBootNativeLibraryPath.java \
- runtime/6878713/Test6878713.sh \
runtime/6925573/SortMethodsTest.java \
runtime/7107135/Test7107135.sh \
runtime/7158988/FieldMonitor.java \
@@ -85,7 +84,9 @@
runtime/NMT/VirtualAllocTestType.java \
runtime/RedefineObject/TestRedefineObject.java \
runtime/XCheckJniJsig/XCheckJSig.java \
- serviceability/attach/AttachWithStalePidFile.java
+ serviceability/attach/AttachWithStalePidFile.java \
+ serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java
+
# JRE adds further tests to compact3
#
--- a/hotspot/test/runtime/6888954/vmerrors.sh Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/test/runtime/6888954/vmerrors.sh Fri Oct 11 13:00:40 2013 -0700
@@ -1,3 +1,25 @@
+# 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
# @bug 6888954
# @bug 8015884
@@ -63,6 +85,7 @@
[ $i -lt 10 ] && i2=0$i
"$TESTJAVA/bin/java" $TESTVMOPTS -XX:+IgnoreUnrecognizedVMOptions \
+ -XX:-TransmitErrorReport \
-XX:ErrorHandlerTest=${i} -version > ${i2}.out 2>&1
# If ErrorHandlerTest is ignored (product build), stop.
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/runtime/memory/LargePages/TestLargePagesFlags.java Fri Oct 11 13:00:40 2013 -0700
@@ -0,0 +1,389 @@
+/*
+ * 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 TestLargePagesFlags
+ * @summary Tests how large pages are choosen depending on the given large pages flag combinations.
+ * @library /testlibrary
+ * @run main TestLargePagesFlags
+ */
+
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.ProcessTools;
+import java.util.ArrayList;
+
+public class TestLargePagesFlags {
+
+ public static void main(String [] args) throws Exception {
+ if (!Platform.isLinux()) {
+ System.out.println("Skipping. TestLargePagesFlags has only been implemented for Linux.");
+ return;
+ }
+
+ testUseTransparentHugePages();
+ testUseHugeTLBFS();
+ testUseSHM();
+ testCombinations();
+ }
+
+ public static void testUseTransparentHugePages() throws Exception {
+ if (!canUse(UseTransparentHugePages(true))) {
+ System.out.println("Skipping testUseTransparentHugePages");
+ return;
+ }
+
+ // -XX:-UseLargePages overrides all other flags.
+ new FlagTester()
+ .use(UseLargePages(false),
+ UseTransparentHugePages(true))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Explicitly turn on UseTransparentHugePages.
+ new FlagTester()
+ .use(UseTransparentHugePages(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseTransparentHugePages(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Setting a specific large pages flag will turn
+ // off heuristics to choose large pages type.
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseTransparentHugePages(false))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Don't turn on UseTransparentHugePages
+ // unless the user explicitly asks for them.
+ new FlagTester()
+ .use(UseLargePages(true))
+ .expect(
+ UseTransparentHugePages(false));
+ }
+
+ public static void testUseHugeTLBFS() throws Exception {
+ if (!canUse(UseHugeTLBFS(true))) {
+ System.out.println("Skipping testUseHugeTLBFS");
+ return;
+ }
+
+ // -XX:-UseLargePages overrides all other flags.
+ new FlagTester()
+ .use(UseLargePages(false),
+ UseHugeTLBFS(true))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Explicitly turn on UseHugeTLBFS.
+ new FlagTester()
+ .use(UseHugeTLBFS(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(true),
+ UseSHM(false));
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(true),
+ UseSHM(false));
+
+ // Setting a specific large pages flag will turn
+ // off heuristics to choose large pages type.
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(false))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Using UseLargePages will default to UseHugeTLBFS large pages.
+ new FlagTester()
+ .use(UseLargePages(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(true),
+ UseSHM(false));
+ }
+
+ public static void testUseSHM() throws Exception {
+ if (!canUse(UseSHM(true))) {
+ System.out.println("Skipping testUseSHM");
+ return;
+ }
+
+ // -XX:-UseLargePages overrides all other flags.
+ new FlagTester()
+ .use(UseLargePages(false),
+ UseSHM(true))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Explicitly turn on UseSHM.
+ new FlagTester()
+ .use(UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(true)) ;
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(true)) ;
+
+ // Setting a specific large pages flag will turn
+ // off heuristics to choose large pages type.
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseSHM(false))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ // Setting UseLargePages can allow the system to choose
+ // UseHugeTLBFS instead of UseSHM, but never UseTransparentHugePages.
+ new FlagTester()
+ .use(UseLargePages(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false));
+ }
+
+ public static void testCombinations() throws Exception {
+ if (!canUse(UseSHM(true)) || !canUse(UseHugeTLBFS(true))) {
+ System.out.println("Skipping testUseHugeTLBFSAndUseSHMCombination");
+ return;
+ }
+
+ // UseHugeTLBFS takes precedence over SHM.
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(true),
+ UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(true),
+ UseSHM(false));
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(true));
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(true),
+ UseSHM(false))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(true),
+ UseSHM(false));
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(false))
+ .expect(
+ UseLargePages(false),
+ UseTransparentHugePages(false),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+
+ if (!canUse(UseTransparentHugePages(true))) {
+ return;
+ }
+
+ // UseTransparentHugePages takes precedence.
+
+ new FlagTester()
+ .use(UseLargePages(true),
+ UseTransparentHugePages(true),
+ UseHugeTLBFS(true),
+ UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+
+ new FlagTester()
+ .use(UseTransparentHugePages(true),
+ UseHugeTLBFS(true),
+ UseSHM(true))
+ .expect(
+ UseLargePages(true),
+ UseTransparentHugePages(true),
+ UseHugeTLBFS(false),
+ UseSHM(false));
+ }
+
+ private static class FlagTester {
+ private Flag [] useFlags;
+
+ public FlagTester use(Flag... useFlags) {
+ this.useFlags = useFlags;
+ return this;
+ }
+
+ public void expect(Flag... expectedFlags) throws Exception {
+ if (useFlags == null) {
+ throw new IllegalStateException("Must run use() before expect()");
+ }
+
+ OutputAnalyzer output = executeNewJVM(useFlags);
+
+ for (Flag flag : expectedFlags) {
+ System.out.println("Looking for: " + flag.flagString());
+ String strValue = output.firstMatch(".* " + flag.name() + " .* :?= (\\S+).*", 1);
+
+ if (strValue == null) {
+ throw new RuntimeException("Flag " + flag.name() + " couldn't be found");
+ }
+
+ if (!flag.value().equals(strValue)) {
+ throw new RuntimeException("Wrong value for: " + flag.name()
+ + " expected: " + flag.value()
+ + " got: " + strValue);
+ }
+ }
+
+ output.shouldHaveExitValue(0);
+ }
+ }
+
+ private static OutputAnalyzer executeNewJVM(Flag... flags) throws Exception {
+ ArrayList<String> args = new ArrayList<>();
+ for (Flag flag : flags) {
+ args.add(flag.flagString());
+ }
+ args.add("-XX:+PrintFlagsFinal");
+ args.add("-version");
+
+ ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(args.toArray(new String[args.size()]));
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+
+ return output;
+ }
+
+ private static boolean canUse(Flag flag) {
+ try {
+ new FlagTester().use(flag).expect(flag);
+ } catch (Exception e) {
+ return false;
+ }
+
+ return true;
+ }
+
+ private static Flag UseLargePages(boolean value) {
+ return new BooleanFlag("UseLargePages", value);
+ }
+
+ private static Flag UseTransparentHugePages(boolean value) {
+ return new BooleanFlag("UseTransparentHugePages", value);
+ }
+
+ private static Flag UseHugeTLBFS(boolean value) {
+ return new BooleanFlag("UseHugeTLBFS", value);
+ }
+
+ private static Flag UseSHM(boolean value) {
+ return new BooleanFlag("UseSHM", value);
+ }
+
+ private static class BooleanFlag implements Flag {
+ private String name;
+ private boolean value;
+
+ BooleanFlag(String name, boolean value) {
+ this.name = name;
+ this.value = value;
+ }
+
+ public String flagString() {
+ return "-XX:" + (value ? "+" : "-") + name;
+ }
+
+ public String name() {
+ return name;
+ }
+
+ public String value() {
+ return Boolean.toString(value);
+ }
+ }
+
+ private static interface Flag {
+ public String flagString();
+ public String name();
+ public String value();
+ }
+}
--- a/hotspot/test/runtime/memory/ReserveMemory.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/test/runtime/memory/ReserveMemory.java Fri Oct 11 13:00:40 2013 -0700
@@ -56,6 +56,7 @@
"-Xbootclasspath/a:.",
"-XX:+UnlockDiagnosticVMOptions",
"-XX:+WhiteBoxAPI",
+ "-XX:-TransmitErrorReport",
"ReserveMemory",
"test");
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/sa/jmap-hprof/JMapHProfLargeHeapProc.java Fri Oct 11 13:00:40 2013 -0700
@@ -0,0 +1,71 @@
+/*
+ * 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.
+ */
+
+import java.lang.management.ManagementFactory;
+import java.lang.management.RuntimeMXBean;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+import sun.management.VMManagement;
+
+public class JMapHProfLargeHeapProc {
+ private static final List<byte[]> heapGarbage = new ArrayList<>();
+
+ public static void main(String[] args) throws Exception {
+
+ buildLargeHeap(args);
+
+ // Print our pid on stdout
+ System.out.println("PID[" + getProcessId() + "]");
+
+ // Wait for input before termination
+ System.in.read();
+ }
+
+ private static void buildLargeHeap(String[] args) {
+ for (long i = 0; i < Integer.parseInt(args[0]); i++) {
+ heapGarbage.add(new byte[1024]);
+ }
+ }
+
+ public static int getProcessId() throws Exception {
+
+ // Get the current process id using a reflection hack
+ RuntimeMXBean runtime = ManagementFactory.getRuntimeMXBean();
+ Field jvm = runtime.getClass().getDeclaredField("jvm");
+
+ jvm.setAccessible(true);
+ VMManagement mgmt = (sun.management.VMManagement) jvm.get(runtime);
+
+ Method pid_method = mgmt.getClass().getDeclaredMethod("getProcessId");
+
+ pid_method.setAccessible(true);
+
+ int pid = (Integer) pid_method.invoke(mgmt);
+
+ return pid;
+ }
+
+}
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hotspot/test/serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java Fri Oct 11 13:00:40 2013 -0700
@@ -0,0 +1,146 @@
+/*
+ * 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.
+ */
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.nio.CharBuffer;
+import java.util.Arrays;
+import java.util.Scanner;
+
+import com.oracle.java.testlibrary.Asserts;
+import com.oracle.java.testlibrary.JDKToolFinder;
+import com.oracle.java.testlibrary.JDKToolLauncher;
+import com.oracle.java.testlibrary.OutputAnalyzer;
+import com.oracle.java.testlibrary.Platform;
+import com.oracle.java.testlibrary.ProcessTools;
+
+/*
+ * @test
+ * @bug 6313383
+ * @key regression
+ * @summary Regression test for hprof export issue due to large heaps (>2G)
+ * @library /testlibrary
+ * @compile JMapHProfLargeHeapProc.java
+ * @run main JMapHProfLargeHeapTest
+ */
+
+public class JMapHProfLargeHeapTest {
+ private static final String HEAP_DUMP_FILE_NAME = "heap.hprof";
+ private static final String HPROF_HEADER_1_0_1 = "JAVA PROFILE 1.0.1";
+ private static final String HPROF_HEADER_1_0_2 = "JAVA PROFILE 1.0.2";
+ private static final long M = 1024L;
+ private static final long G = 1024L * M;
+
+ public static void main(String[] args) throws Exception {
+ // If we are on MacOSX, test if JMap tool is signed, otherwise return
+ // since test will fail with privilege error.
+ if (Platform.isOSX()) {
+ String jmapToolPath = JDKToolFinder.getCurrentJDKTool("jmap");
+ ProcessBuilder codesignProcessBuilder = new ProcessBuilder(
+ "codesign", "-v", jmapToolPath);
+ Process codesignProcess = codesignProcessBuilder.start();
+ OutputAnalyzer analyser = new OutputAnalyzer(codesignProcess);
+ try {
+ analyser.shouldNotContain("code object is not signed at all");
+ System.out.println("Signed jmap found at: " + jmapToolPath);
+ } catch (Exception e) {
+ // Abort since we can't know if the test will work
+ System.out
+ .println("Test aborted since we are on MacOSX and the jmap tool is not signed.");
+ return;
+ }
+ }
+
+ // Small heap 22 megabytes, should create 1.0.1 file format
+ testHProfFileFormat("-Xmx1g", 22 * M, HPROF_HEADER_1_0_1);
+
+ /**
+ * This test was deliberately commented out since the test system lacks
+ * support to handle the requirements for this kind of heap size in a
+ * good way. If or when it becomes possible to run this kind of tests in
+ * the test environment the test should be enabled again.
+ * */
+ // Large heap 2,2 gigabytes, should create 1.0.2 file format
+ // testHProfFileFormat("-Xmx4g", 2 * G + 2 * M, HPROF_HEADER_1_0_2);
+ }
+
+ private static void testHProfFileFormat(String vmArgs, long heapSize,
+ String expectedFormat) throws Exception, IOException,
+ InterruptedException, FileNotFoundException {
+ ProcessBuilder procBuilder = ProcessTools.createJavaProcessBuilder(
+ vmArgs, "JMapHProfLargeHeapProc", String.valueOf(heapSize));
+ procBuilder.redirectError(ProcessBuilder.Redirect.INHERIT);
+ Process largeHeapProc = procBuilder.start();
+
+ try (Scanner largeHeapScanner = new Scanner(
+ largeHeapProc.getInputStream());) {
+ String pidstring = null;
+ while ((pidstring = largeHeapScanner.findInLine("PID\\[[0-9].*\\]")) == null) {
+ Thread.sleep(500);
+ }
+ int pid = Integer.parseInt(pidstring.substring(4,
+ pidstring.length() - 1));
+ System.out.println("Extracted pid: " + pid);
+
+ JDKToolLauncher jMapLauncher = JDKToolLauncher
+ .create("jmap", false);
+ jMapLauncher.addToolArg("-dump:format=b,file=" + pid + "-"
+ + HEAP_DUMP_FILE_NAME);
+ jMapLauncher.addToolArg(String.valueOf(pid));
+
+ ProcessBuilder jMapProcessBuilder = new ProcessBuilder(
+ jMapLauncher.getCommand());
+ System.out.println("jmap command: "
+ + Arrays.toString(jMapLauncher.getCommand()));
+
+ Process jMapProcess = jMapProcessBuilder.start();
+ OutputAnalyzer analyzer = new OutputAnalyzer(jMapProcess);
+ analyzer.shouldHaveExitValue(0);
+ analyzer.shouldContain(pid + "-" + HEAP_DUMP_FILE_NAME);
+ analyzer.shouldContain("Heap dump file created");
+
+ largeHeapProc.getOutputStream().write('\n');
+
+ File dumpFile = new File(pid + "-" + HEAP_DUMP_FILE_NAME);
+ Asserts.assertTrue(dumpFile.exists(), "Heap dump file not found.");
+
+ try (Reader reader = new BufferedReader(new FileReader(dumpFile))) {
+ CharBuffer buf = CharBuffer.allocate(expectedFormat.length());
+ reader.read(buf);
+ buf.clear();
+ Asserts.assertEQ(buf.toString(), expectedFormat,
+ "Wrong file format. Expected '" + expectedFormat
+ + "', but found '" + buf.toString() + "'");
+ }
+
+ System.out.println("Success!");
+
+ } finally {
+ largeHeapProc.destroyForcibly();
+ }
+ }
+}
--- a/hotspot/test/testlibrary/com/oracle/java/testlibrary/JDKToolLauncher.java Thu Oct 10 10:08:55 2013 -0700
+++ b/hotspot/test/testlibrary/com/oracle/java/testlibrary/JDKToolLauncher.java Fri Oct 11 13:00:40 2013 -0700
@@ -23,20 +23,17 @@
package com.oracle.java.testlibrary;
-import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
-
-import com.oracle.java.testlibrary.JDKToolFinder;
-import com.oracle.java.testlibrary.ProcessTools;
+import java.util.List;
/**
* A utility for constructing command lines for starting JDK tool processes.
*
* The JDKToolLauncher can in particular be combined with a
- * java.lang.ProcessBuilder to easily run a JDK tool. For example, the
- * following code run {@code jmap -heap} against a process with GC logging
- * turned on for the {@code jmap} process:
+ * java.lang.ProcessBuilder to easily run a JDK tool. For example, the following
+ * code run {@code jmap -heap} against a process with GC logging turned on for
+ * the {@code jmap} process:
*
* <pre>
* {@code
@@ -55,19 +52,39 @@
private final List<String> vmArgs = new ArrayList<String>();
private final List<String> toolArgs = new ArrayList<String>();
- private JDKToolLauncher(String tool) {
- executable = JDKToolFinder.getJDKTool(tool);
+ private JDKToolLauncher(String tool, boolean useCompilerJDK) {
+ if (useCompilerJDK) {
+ executable = JDKToolFinder.getJDKTool(tool);
+ } else {
+ executable = JDKToolFinder.getCurrentJDKTool(tool);
+ }
vmArgs.addAll(Arrays.asList(ProcessTools.getPlatformSpecificVMArgs()));
}
/**
+ * Creates a new JDKToolLauncher for the specified tool. Using tools path
+ * from the compiler JDK.
+ *
+ * @param tool
+ * The name of the tool
+ * @return A new JDKToolLauncher
+ */
+ public static JDKToolLauncher create(String tool) {
+ return new JDKToolLauncher(tool, true);
+ }
+
+ /**
* Creates a new JDKToolLauncher for the specified tool.
*
- * @param tool The name of the tool
+ * @param tool
+ * The name of the tool
+ * @param useCompilerPath
+ * If true use the compiler JDK path, otherwise use the tested
+ * JDK path.
* @return A new JDKToolLauncher
*/
- public static JDKToolLauncher create(String tool) {
- return new JDKToolLauncher(tool);
+ public static JDKToolLauncher create(String tool, boolean useCompilerJDK) {
+ return new JDKToolLauncher(tool, useCompilerJDK);
}
/**
@@ -80,7 +97,8 @@
* automatically added.
*
*
- * @param arg The argument to VM running the tool
+ * @param arg
+ * The argument to VM running the tool
* @return The JDKToolLauncher instance
*/
public JDKToolLauncher addVMArg(String arg) {
@@ -91,7 +109,8 @@
/**
* Adds an argument to the tool.
*
- * @param arg The argument to the tool
+ * @param arg
+ * The argument to the tool
* @return The JDKToolLauncher instance
*/
public JDKToolLauncher addToolArg(String arg) {