truffle: src/share/vm/runtime/arguments.cpp comparison

comparison src/share/vm/runtime/arguments.cpp @ 6197:d2a62e0f25eb

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

author	zgu
date	Thu, 28 Jun 2012 17:03:16 -0400
parents	cdeda3fd141e
children	24b9c7f4cae6

comparison

equal deleted inserted replaced

-:74533f63b116
+:d2a62e0f25eb
 #include "prims/jvmtiExport.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/globals_extension.hpp"
 #include "runtime/java.hpp"
 #include "services/management.hpp"
+#include "services/memTracker.hpp"
 #include "utilities/defaultStream.hpp"
 #include "utilities/taskqueue.hpp"
 #ifdef TARGET_OS_FAMILY_linux
 # include "os_linux.inline.hpp"
 #endif
 }
 inline void SysClassPath::reset_item_at(int index) {
 assert(index < _scp_nitems && index != _scp_base, "just checking");
 if (_items[index] != NULL) {
-FREE_C_HEAP_ARRAY(char, _items[index]);
+FREE_C_HEAP_ARRAY(char, _items[index], mtInternal);
 _items[index] = NULL;
 }
 }
 inline void SysClassPath::reset_path(const char* base) {
 const char* tmp_end = strchr(path, separator);
 if (tmp_end == NULL) {
 expanded_path = add_jars_to_path(expanded_path, path);
 path = end;
 } else {
-char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1);
+char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1, mtInternal);
 memcpy(dirpath, path, tmp_end - path);
 dirpath[tmp_end - path] = '\0';
 expanded_path = add_jars_to_path(expanded_path, dirpath);
-FREE_C_HEAP_ARRAY(char, dirpath);
+FREE_C_HEAP_ARRAY(char, dirpath, mtInternal);
 path = tmp_end + 1;
 }
 }
 _items[_scp_endorsed] = expanded_path;
 DEBUG_ONLY(_expansion_done = true;)
 }
 }
 assert(total_len > 0, "empty sysclasspath not allowed");
 // Copy the _items to a single string.
-char* cp = NEW_C_HEAP_ARRAY(char, total_len);
+char* cp = NEW_C_HEAP_ARRAY(char, total_len, mtInternal);
 char* cp_tmp = cp;
 for (i = 0; i < _scp_nitems; ++i) {
 if (_items[i] != NULL) {
 memcpy(cp_tmp, _items[i], lengths[i]);
 cp_tmp += lengths[i];
 char *cp;
 assert(str != NULL, "just checking");
 if (path == NULL) {
 size_t len = strlen(str) + 1;
-cp = NEW_C_HEAP_ARRAY(char, len);
+cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 memcpy(cp, str, len);                       // copy the trailing null
 } else {
 const char separator = *os::path_separator();
 size_t old_len = strlen(path);
 size_t str_len = strlen(str);
 size_t len = old_len + str_len + 2;
 if (prepend) {
-cp = NEW_C_HEAP_ARRAY(char, len);
+cp = NEW_C_HEAP_ARRAY(char, len, mtInternal);
 char* cp_tmp = cp;
 memcpy(cp_tmp, str, str_len);
 cp_tmp += str_len;
 *cp_tmp = separator;
 memcpy(++cp_tmp, path, old_len + 1);      // copy the trailing null
-FREE_C_HEAP_ARRAY(char, path);
+FREE_C_HEAP_ARRAY(char, path, mtInternal);
 } else {
-cp = REALLOC_C_HEAP_ARRAY(char, path, len);
+cp = REALLOC_C_HEAP_ARRAY(char, path, len, mtInternal);
 char* cp_tmp = cp + old_len;
 *cp_tmp = separator;
 memcpy(++cp_tmp, str, str_len + 1);       // copy the trailing null
 }
 }
 const char fileSep = *os::file_separator();
 if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;
 /* Scan the directory for jars/zips, appending them to path. */
 struct dirent *entry;
-char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory));
+char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory), mtInternal);
 while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {
 const char* name = entry->d_name;
 const char* ext = name + strlen(name) - 4;
 bool isJarOrZip = ext > name &&
 (os::file_name_strcmp(ext, ".jar") == 0 ||
 os::file_name_strcmp(ext, ".zip") == 0);
 if (isJarOrZip) {
-char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name));
+char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name), mtInternal);
 sprintf(jarpath, "%s%s%s", directory, dir_sep, name);
 path = add_to_path(path, jarpath, false);
-FREE_C_HEAP_ARRAY(char, jarpath);
+FREE_C_HEAP_ARRAY(char, jarpath, mtInternal);
 }
 }
-FREE_C_HEAP_ARRAY(char, dbuf);
+FREE_C_HEAP_ARRAY(char, dbuf, mtInternal);
 os::closedir(dir);
 return path;
 }
 // Parses a memory size specification string.
 }
 static bool set_string_flag(char* name, const char* value, FlagValueOrigin origin) {
 if (!CommandLineFlags::ccstrAtPut(name, &value, origin))  return false;
 // Contract:  CommandLineFlags always returns a pointer that needs freeing.
-FREE_C_HEAP_ARRAY(char, value);
+FREE_C_HEAP_ARRAY(char, value, mtInternal);
 return true;
 }
 static bool append_to_string_flag(char* name, const char* new_value, FlagValueOrigin origin) {
 const char* old_value = "";
 if (old_len == 0) {
 value = new_value;
 } else if (new_len == 0) {
 value = old_value;
 } else {
-char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1);
+char* buf = NEW_C_HEAP_ARRAY(char, old_len + 1 + new_len + 1, mtInternal);
 // each new setting adds another LINE to the switch:
 sprintf(buf, "%s\n%s", old_value, new_value);
 value = buf;
 free_this_too = buf;
 }
 (void) CommandLineFlags::ccstrAtPut(name, &value, origin);
 // CommandLineFlags always returns a pointer that needs freeing.
-FREE_C_HEAP_ARRAY(char, value);
+FREE_C_HEAP_ARRAY(char, value, mtInternal);
 if (free_this_too != NULL) {
 // CommandLineFlags made its own copy, so I must delete my own temp. buffer.
-FREE_C_HEAP_ARRAY(char, free_this_too);
+FREE_C_HEAP_ARRAY(char, free_this_too, mtInternal);
 }
 return true;
 }
 bool Arguments::parse_argument(const char* arg, FlagValueOrigin origin) {
 int index = *count;
 // expand the array and add arg to the last element
 (*count)++;
 if (*bldarray == NULL) {
-*bldarray = NEW_C_HEAP_ARRAY(char*, *count);
+*bldarray = NEW_C_HEAP_ARRAY(char*, *count, mtInternal);
 } else {
-*bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count);
+*bldarray = REALLOC_C_HEAP_ARRAY(char*, *bldarray, *count, mtInternal);
 }
 (*bldarray)[index] = strdup(arg);
 }
 void Arguments::build_jvm_args(const char* arg) {
 // ns must be static--its address may be stored in a SystemProperty object.
 const static char ns[1] = {0};
 char* value = (char *)ns;
 size_t key_len = (eq == NULL) ? strlen(prop) : (eq - prop);
-key = AllocateHeap(key_len + 1, "add_property");
+key = AllocateHeap(key_len + 1, mtInternal);
 strncpy(key, prop, key_len);
 key[key_len] = '\0';
 if (eq != NULL) {
 size_t value_len = strlen(prop) - key_len - 1;
-value = AllocateHeap(value_len + 1, "add_property");
+value = AllocateHeap(value_len + 1, mtInternal);
 strncpy(value, &prop[key_len + 1], value_len + 1);
 }
 if (strcmp(key, "java.compiler") == 0) {
 process_java_compiler_argument(value);
 // prefix and the default bootclasspath.  os::set_boot_path()
 // uses meta_index_dir as the default bootclasspath directory.
 const char* altclasses_jar = "alt-rt.jar";
 size_t altclasses_path_len = strlen(get_meta_index_dir()) + 1 +
 strlen(altclasses_jar);
-char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len);
+char* altclasses_path = NEW_C_HEAP_ARRAY(char, altclasses_path_len, mtInternal);
 strcpy(altclasses_path, get_meta_index_dir());
 strcat(altclasses_path, altclasses_jar);
 scp.add_suffix_to_prefix(altclasses_path);
 scp_assembly_required = true;
-FREE_C_HEAP_ARRAY(char, altclasses_path);
+FREE_C_HEAP_ARRAY(char, altclasses_path, mtInternal);
 }
 if (WhiteBoxAPI) {
 // Append wb.jar to bootclasspath if enabled
 const char* wb_jar = "wb.jar";
 size_t wb_path_len = strlen(get_meta_index_dir()) + 1 +
 strlen(wb_jar);
-char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len);
+char* wb_path = NEW_C_HEAP_ARRAY(char, wb_path_len, mtInternal);
 strcpy(wb_path, get_meta_index_dir());
 strcat(wb_path, wb_jar);
 scp.add_suffix(wb_path);
 scp_assembly_required = true;
-FREE_C_HEAP_ARRAY(char, wb_path);
+FREE_C_HEAP_ARRAY(char, wb_path, mtInternal);
 }
 // Parse _JAVA_OPTIONS environment variable (if present) (mimics classic VM)
 result = parse_java_options_environment_variable(&scp, &scp_assembly_required);
 if (result != JNI_OK) {
 // -Xrun
 } else if (match_option(option, "-Xrun", &tail)) {
 if (tail != NULL) {
 const char* pos = strchr(tail, ':');
 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
-char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len);
+char* name = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
 name[len] = '\0';
 char *options = NULL;
 if(pos != NULL) {
 size_t len2 = strlen(pos+1) + 1; // options start after ':'.  Final zero must be copied.
-options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2), pos+1, len2);
+options = (char*)memcpy(NEW_C_HEAP_ARRAY(char, len2, mtInternal), pos+1, len2);
 }
 #ifdef JVMTI_KERNEL
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
 warning("profiling and debugging agents are not supported with Kernel VM");
 } else
 } else if (match_option(option, "-agentlib:", &tail) ||
 (is_absolute_path = match_option(option, "-agentpath:", &tail))) {
 if(tail != NULL) {
 const char* pos = strchr(tail, '=');
 size_t len = (pos == NULL) ? strlen(tail) : pos - tail;
-char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1), tail, len);
+char* name = strncpy(NEW_C_HEAP_ARRAY(char, len + 1, mtInternal), tail, len);
 name[len] = '\0';
 char *options = NULL;
 if(pos != NULL) {
-options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1), pos + 1);
+options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(pos + 1) + 1, mtInternal), pos + 1);
 }
 #ifdef JVMTI_KERNEL
 if ((strcmp(name, "hprof") == 0) || (strcmp(name, "jdwp") == 0)) {
 warning("profiling and debugging agents are not supported with Kernel VM");
 } else
 }
 // -javaagent
 } else if (match_option(option, "-javaagent:", &tail)) {
 if(tail != NULL) {
-char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1), tail);
+char *options = strcpy(NEW_C_HEAP_ARRAY(char, strlen(tail) + 1, mtInternal), tail);
 add_init_agent("instrument", options, false);
 }
 // -Xnoclassgc
 } else if (match_option(option, "-Xnoclassgc", &tail)) {
 FLAG_SET_CMDLINE(bool, ClassUnloading, false);
 char jvm_path[JVM_MAXPATHLEN];
 os::jvm_path(jvm_path, sizeof(jvm_path));
 char *end = strrchr(jvm_path, *os::file_separator());
 if (end != NULL) *end = '\0';
 char *shared_archive_path = NEW_C_HEAP_ARRAY(char, strlen(jvm_path) +
-strlen(os::file_separator()) + 20);
+strlen(os::file_separator()) + 20, mtInternal);
 if (shared_archive_path == NULL) return JNI_ENOMEM;
 strcpy(shared_archive_path, jvm_path);
 strcat(shared_archive_path, os::file_separator());
 strcat(shared_archive_path, "classes");
 DEBUG_ONLY(strcat(shared_archive_path, "_g");)
 }
 if (match_option(option, "-XX:+PrintFlagsInitial", &tail)) {
 CommandLineFlags::printFlags(tty, false);
 vm_exit(0);
 }
+if (match_option(option, "-XX:NativeMemoryTracking", &tail)) {
+MemTracker::init_tracking_options(tail);
+}
 #ifndef PRODUCT
 if (match_option(option, "-XX:+PrintFlagsWithComments", &tail)) {
 CommandLineFlags::printFlags(tty, true);
 vm_exit(0);
 if (strncmp(prop->key(), "kernel.", 7 ) == 0) {
 length += (strlen(prop->key()) + strlen(prop->value()) + 5);  // "-D ="
 }
 }
 // Add one for null terminator.
-char *props = AllocateHeap(length + 1, "get_kernel_properties");
+char *props = AllocateHeap(length + 1, mtInternal);
 if (length != 0) {
 int pos = 0;
 for (prop = _system_properties; prop != NULL; prop = prop->next()) {
 if (strncmp(prop->key(), "kernel.", 7 ) == 0) {
 jio_snprintf(&props[pos], length-pos,

Mercurial > hg > truffle

comparison src/share/vm/runtime/arguments.cpp @ 6197:d2a62e0f25eb