Mercurial > hg > graal-jvmci-8
comparison src/share/vm/classfile/classLoader.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 | f08d439fab8c |
children | 957c266d8bc5 da91efe96a93 |
comparison
equal
deleted
inserted
replaced
6174:74533f63b116 | 6197:d2a62e0f25eb |
---|---|
151 MetaIndex::MetaIndex(char** meta_package_names, int num_meta_package_names) { | 151 MetaIndex::MetaIndex(char** meta_package_names, int num_meta_package_names) { |
152 if (num_meta_package_names == 0) { | 152 if (num_meta_package_names == 0) { |
153 _meta_package_names = NULL; | 153 _meta_package_names = NULL; |
154 _num_meta_package_names = 0; | 154 _num_meta_package_names = 0; |
155 } else { | 155 } else { |
156 _meta_package_names = NEW_C_HEAP_ARRAY(char*, num_meta_package_names); | 156 _meta_package_names = NEW_C_HEAP_ARRAY(char*, num_meta_package_names, mtClass); |
157 _num_meta_package_names = num_meta_package_names; | 157 _num_meta_package_names = num_meta_package_names; |
158 memcpy(_meta_package_names, meta_package_names, num_meta_package_names * sizeof(char*)); | 158 memcpy(_meta_package_names, meta_package_names, num_meta_package_names * sizeof(char*)); |
159 } | 159 } |
160 } | 160 } |
161 | 161 |
162 | 162 |
163 MetaIndex::~MetaIndex() { | 163 MetaIndex::~MetaIndex() { |
164 FREE_C_HEAP_ARRAY(char*, _meta_package_names); | 164 FREE_C_HEAP_ARRAY(char*, _meta_package_names, mtClass); |
165 } | 165 } |
166 | 166 |
167 | 167 |
168 bool MetaIndex::may_contain(const char* class_name) { | 168 bool MetaIndex::may_contain(const char* class_name) { |
169 if ( _num_meta_package_names == 0) { | 169 if ( _num_meta_package_names == 0) { |
190 bool ClassPathEntry::is_lazy() { | 190 bool ClassPathEntry::is_lazy() { |
191 return false; | 191 return false; |
192 } | 192 } |
193 | 193 |
194 ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() { | 194 ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() { |
195 _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1); | 195 _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass); |
196 strcpy(_dir, dir); | 196 strcpy(_dir, dir); |
197 } | 197 } |
198 | 198 |
199 | 199 |
200 ClassFileStream* ClassPathDirEntry::open_stream(const char* name) { | 200 ClassFileStream* ClassPathDirEntry::open_stream(const char* name) { |
227 } | 227 } |
228 | 228 |
229 | 229 |
230 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() { | 230 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() { |
231 _zip = zip; | 231 _zip = zip; |
232 _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1); | 232 _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass); |
233 strcpy(_zip_name, zip_name); | 233 strcpy(_zip_name, zip_name); |
234 } | 234 } |
235 | 235 |
236 ClassPathZipEntry::~ClassPathZipEntry() { | 236 ClassPathZipEntry::~ClassPathZipEntry() { |
237 if (ZipClose != NULL) { | 237 if (ZipClose != NULL) { |
238 (*ZipClose)(_zip); | 238 (*ZipClose)(_zip); |
239 } | 239 } |
240 FREE_C_HEAP_ARRAY(char, _zip_name); | 240 FREE_C_HEAP_ARRAY(char, _zip_name, mtClass); |
241 } | 241 } |
242 | 242 |
243 ClassFileStream* ClassPathZipEntry::open_stream(const char* name) { | 243 ClassFileStream* ClassPathZipEntry::open_stream(const char* name) { |
244 // enable call to C land | 244 // enable call to C land |
245 JavaThread* thread = JavaThread::current(); | 245 JavaThread* thread = JavaThread::current(); |
452 // Iterate over class path entries | 452 // Iterate over class path entries |
453 for (int start = 0; start < len; start = end) { | 453 for (int start = 0; start < len; start = end) { |
454 while (sys_class_path[end] && sys_class_path[end] != os::path_separator()[0]) { | 454 while (sys_class_path[end] && sys_class_path[end] != os::path_separator()[0]) { |
455 end++; | 455 end++; |
456 } | 456 } |
457 char* path = NEW_C_HEAP_ARRAY(char, end-start+1); | 457 char* path = NEW_C_HEAP_ARRAY(char, end-start+1, mtClass); |
458 strncpy(path, &sys_class_path[start], end-start); | 458 strncpy(path, &sys_class_path[start], end-start); |
459 path[end-start] = '\0'; | 459 path[end-start] = '\0'; |
460 update_class_path_entry_list(path, false); | 460 update_class_path_entry_list(path, false); |
461 FREE_C_HEAP_ARRAY(char, path); | 461 FREE_C_HEAP_ARRAY(char, path, mtClass); |
462 while (sys_class_path[end] == os::path_separator()[0]) { | 462 while (sys_class_path[end] == os::path_separator()[0]) { |
463 end++; | 463 end++; |
464 } | 464 } |
465 } | 465 } |
466 } | 466 } |
650 // may not be the same at runtime as they were when the archive was | 650 // may not be the same at runtime as they were when the archive was |
651 // created (NFS, Samba, etc.). The actual files and directories named | 651 // created (NFS, Samba, etc.). The actual files and directories named |
652 // in the classpath must be the same files, in the same order, even | 652 // in the classpath must be the same files, in the same order, even |
653 // though the exact name is not the same. | 653 // though the exact name is not the same. |
654 | 654 |
655 class PackageInfo: public BasicHashtableEntry { | 655 class PackageInfo: public BasicHashtableEntry<mtClass> { |
656 public: | 656 public: |
657 const char* _pkgname; // Package name | 657 const char* _pkgname; // Package name |
658 int _classpath_index; // Index of directory or JAR file loaded from | 658 int _classpath_index; // Index of directory or JAR file loaded from |
659 | 659 |
660 PackageInfo* next() { | 660 PackageInfo* next() { |
661 return (PackageInfo*)BasicHashtableEntry::next(); | 661 return (PackageInfo*)BasicHashtableEntry<mtClass>::next(); |
662 } | 662 } |
663 | 663 |
664 const char* pkgname() { return _pkgname; } | 664 const char* pkgname() { return _pkgname; } |
665 void set_pkgname(char* pkgname) { _pkgname = pkgname; } | 665 void set_pkgname(char* pkgname) { _pkgname = pkgname; } |
666 | 666 |
672 _classpath_index = index; | 672 _classpath_index = index; |
673 } | 673 } |
674 }; | 674 }; |
675 | 675 |
676 | 676 |
677 class PackageHashtable : public BasicHashtable { | 677 class PackageHashtable : public BasicHashtable<mtClass> { |
678 private: | 678 private: |
679 inline unsigned int compute_hash(const char *s, int n) { | 679 inline unsigned int compute_hash(const char *s, int n) { |
680 unsigned int val = 0; | 680 unsigned int val = 0; |
681 while (--n >= 0) { | 681 while (--n >= 0) { |
682 val = *s++ + 31 * val; | 682 val = *s++ + 31 * val; |
683 } | 683 } |
684 return val; | 684 return val; |
685 } | 685 } |
686 | 686 |
687 PackageInfo* bucket(int index) { | 687 PackageInfo* bucket(int index) { |
688 return (PackageInfo*)BasicHashtable::bucket(index); | 688 return (PackageInfo*)BasicHashtable<mtClass>::bucket(index); |
689 } | 689 } |
690 | 690 |
691 PackageInfo* get_entry(int index, unsigned int hash, | 691 PackageInfo* get_entry(int index, unsigned int hash, |
692 const char* pkgname, size_t n) { | 692 const char* pkgname, size_t n) { |
693 for (PackageInfo* pp = bucket(index); pp != NULL; pp = pp->next()) { | 693 for (PackageInfo* pp = bucket(index); pp != NULL; pp = pp->next()) { |
700 return NULL; | 700 return NULL; |
701 } | 701 } |
702 | 702 |
703 public: | 703 public: |
704 PackageHashtable(int table_size) | 704 PackageHashtable(int table_size) |
705 : BasicHashtable(table_size, sizeof(PackageInfo)) {} | 705 : BasicHashtable<mtClass>(table_size, sizeof(PackageInfo)) {} |
706 | 706 |
707 PackageHashtable(int table_size, HashtableBucket* t, int number_of_entries) | 707 PackageHashtable(int table_size, HashtableBucket<mtClass>* t, int number_of_entries) |
708 : BasicHashtable(table_size, sizeof(PackageInfo), t, number_of_entries) {} | 708 : BasicHashtable<mtClass>(table_size, sizeof(PackageInfo), t, number_of_entries) {} |
709 | 709 |
710 PackageInfo* get_entry(const char* pkgname, int n) { | 710 PackageInfo* get_entry(const char* pkgname, int n) { |
711 unsigned int hash = compute_hash(pkgname, n); | 711 unsigned int hash = compute_hash(pkgname, n); |
712 return get_entry(hash_to_index(hash), hash, pkgname, n); | 712 return get_entry(hash_to_index(hash), hash, pkgname, n); |
713 } | 713 } |
714 | 714 |
715 PackageInfo* new_entry(char* pkgname, int n) { | 715 PackageInfo* new_entry(char* pkgname, int n) { |
716 unsigned int hash = compute_hash(pkgname, n); | 716 unsigned int hash = compute_hash(pkgname, n); |
717 PackageInfo* pp; | 717 PackageInfo* pp; |
718 pp = (PackageInfo*)BasicHashtable::new_entry(hash); | 718 pp = (PackageInfo*)BasicHashtable<mtClass>::new_entry(hash); |
719 pp->set_pkgname(pkgname); | 719 pp->set_pkgname(pkgname); |
720 return pp; | 720 return pp; |
721 } | 721 } |
722 | 722 |
723 void add_entry(PackageInfo* pp) { | 723 void add_entry(PackageInfo* pp) { |
724 int index = hash_to_index(pp->hash()); | 724 int index = hash_to_index(pp->hash()); |
725 BasicHashtable::add_entry(index, pp); | 725 BasicHashtable<mtClass>::add_entry(index, pp); |
726 } | 726 } |
727 | 727 |
728 void copy_pkgnames(const char** packages) { | 728 void copy_pkgnames(const char** packages) { |
729 int n = 0; | 729 int n = 0; |
730 for (int i = 0; i < table_size(); ++i) { | 730 for (int i = 0; i < table_size(); ++i) { |
740 | 740 |
741 | 741 |
742 void PackageHashtable::copy_table(char** top, char* end, | 742 void PackageHashtable::copy_table(char** top, char* end, |
743 PackageHashtable* table) { | 743 PackageHashtable* table) { |
744 // Copy (relocate) the table to the shared space. | 744 // Copy (relocate) the table to the shared space. |
745 BasicHashtable::copy_table(top, end); | 745 BasicHashtable<mtClass>::copy_table(top, end); |
746 | 746 |
747 // Calculate the space needed for the package name strings. | 747 // Calculate the space needed for the package name strings. |
748 int i; | 748 int i; |
749 int n = 0; | 749 int n = 0; |
750 for (i = 0; i < table_size(); ++i) { | 750 for (i = 0; i < table_size(); ++i) { |
813 const char *cp = strrchr(pkgname, '/'); | 813 const char *cp = strrchr(pkgname, '/'); |
814 if (cp != NULL) { | 814 if (cp != NULL) { |
815 // Package prefix found | 815 // Package prefix found |
816 int n = cp - pkgname + 1; | 816 int n = cp - pkgname + 1; |
817 | 817 |
818 char* new_pkgname = NEW_C_HEAP_ARRAY(char, n + 1); | 818 char* new_pkgname = NEW_C_HEAP_ARRAY(char, n + 1, mtClass); |
819 if (new_pkgname == NULL) { | 819 if (new_pkgname == NULL) { |
820 return false; | 820 return false; |
821 } | 821 } |
822 | 822 |
823 memcpy(new_pkgname, pkgname, n); | 823 memcpy(new_pkgname, pkgname, n); |
927 | 927 |
928 return h; | 928 return h; |
929 } | 929 } |
930 | 930 |
931 | 931 |
932 void ClassLoader::create_package_info_table(HashtableBucket *t, int length, | 932 void ClassLoader::create_package_info_table(HashtableBucket<mtClass> *t, int length, |
933 int number_of_entries) { | 933 int number_of_entries) { |
934 assert(_package_hash_table == NULL, "One package info table allowed."); | 934 assert(_package_hash_table == NULL, "One package info table allowed."); |
935 assert(length == package_hash_table_size * sizeof(HashtableBucket), | 935 assert(length == package_hash_table_size * sizeof(HashtableBucket<mtClass>), |
936 "bad shared package info size."); | 936 "bad shared package info size."); |
937 _package_hash_table = new PackageHashtable(package_hash_table_size, t, | 937 _package_hash_table = new PackageHashtable(package_hash_table_size, t, |
938 number_of_entries); | 938 number_of_entries); |
939 } | 939 } |
940 | 940 |