jdk-sandbox: comparison src/hotspot/share/memory/metaspace.cpp

equal deleted inserted replaced

-:1558266946de
+:54750b448264
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */
-#include <memory/metaspace/settings.hpp>
 #include "precompiled.hpp"
 #include "aot/aotLoader.hpp"
 #include "gc/shared/collectedHeap.hpp"
 #include "logging/log.hpp"
 #include "memory/metaspace/metaspaceCommon.hpp"
 #include "memory/metaspace/metaspaceEnums.hpp"
 #include "memory/metaspace/metaspaceReport.hpp"
 #include "memory/metaspace/metaspaceSizesSnapshot.hpp"
 #include "memory/metaspace/runningCounters.hpp"
+#include "memory/metaspace/settings.hpp"
 #include "memory/metaspace/virtualSpaceList.hpp"
 #include "memory/universe.hpp"
 #include "oops/compressedOops.hpp"
 #include "runtime/init.hpp"
 #include "runtime/java.hpp"
 using metaspace::ChunkManager;
 using metaspace::ClassLoaderMetaspace;
 using metaspace::CommitLimiter;
 using metaspace::MetaspaceType;
-using metaspace::MetadataType;
 using metaspace::MetaspaceReporter;
 using metaspace::RunningCounters;
 using metaspace::VirtualSpaceList;
 // Used by MetaspaceCounters
-size_t MetaspaceUtils::free_chunks_total_words(MetadataType mdtype) {
+size_t MetaspaceUtils::free_chunks_total_words(Metaspace::MetadataType mdtype) {
-return is_class(mdtype) ? RunningCounters::free_chunks_words_class() : RunningCounters::free_chunks_words_nonclass();
+return metaspace::is_class(mdtype) ? RunningCounters::free_chunks_words_class() : RunningCounters::free_chunks_words_nonclass();
 }
 size_t MetaspaceUtils::used_words() {
 return RunningCounters::used_words();
 }
-size_t MetaspaceUtils::used_words(MetadataType mdtype) {
+size_t MetaspaceUtils::used_words(Metaspace::MetadataType mdtype) {
-return is_class(mdtype) ? RunningCounters::used_words_class() : RunningCounters::used_words_nonclass();
+return metaspace::is_class(mdtype) ? RunningCounters::used_words_class() : RunningCounters::used_words_nonclass();
 }
 size_t MetaspaceUtils::reserved_words() {
 return RunningCounters::reserved_words();
 }
-size_t MetaspaceUtils::reserved_words(MetadataType mdtype) {
+size_t MetaspaceUtils::reserved_words(Metaspace::MetadataType mdtype) {
-return is_class(mdtype) ? RunningCounters::reserved_words_class() : RunningCounters::reserved_words_nonclass();
+return metaspace::is_class(mdtype) ? RunningCounters::reserved_words_class() : RunningCounters::reserved_words_nonclass();
 }
 size_t MetaspaceUtils::committed_words() {
 return RunningCounters::committed_words();
 }
-size_t MetaspaceUtils::committed_words(MetadataType mdtype) {
+size_t MetaspaceUtils::committed_words(Metaspace::MetadataType mdtype) {
-return is_class(mdtype) ? RunningCounters::committed_words_class() : RunningCounters::committed_words_nonclass();
+return metaspace::is_class(mdtype) ? RunningCounters::committed_words_class() : RunningCounters::committed_words_nonclass();
 }
 void MetaspaceUtils::print_metaspace_change(const metaspace::MetaspaceSizesSnapshot& pre_meta_values) {
 }
 }
 // Prints an ASCII representation of the given space.
-void MetaspaceUtils::print_metaspace_map(outputStream* out, MetadataType mdtype) {
+void MetaspaceUtils::print_metaspace_map(outputStream* out, Metaspace::MetadataType mdtype) {
 out->print_cr("-- not yet implemented ---");
 }
 // This will print out a basic metaspace usage report but
 // unlike print_report() is guaranteed not to lock or to walk the CLDG.
 used_bytes()/K,
 committed_bytes()/K,
 reserved_bytes()/K);
 if (Metaspace::using_class_space()) {
-const MetadataType ct = metaspace::ClassType;
+const Metaspace::MetadataType ct = Metaspace::ClassType;
 out->print_cr("  class space    "
 "used "      SIZE_FORMAT "K, "
 "committed " SIZE_FORMAT "K, "
 "reserved "  SIZE_FORMAT "K",
 used_bytes(ct)/K,
 }
 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 = MetaspaceUtils::committed_bytes(metaspace::ClassType);
+size_t class_committed = MetaspaceUtils::committed_bytes(Metaspace::ClassType);
 if (class_committed + word_size * BytesPerWord > CompressedClassSpaceSize) {
 log_trace(gc, metaspace, freelist)("Cannot expand %s metaspace by " SIZE_FORMAT " words (CompressedClassSpaceSize = " SIZE_FORMAT " words)",
 (is_class ? "class" : "non-class"), word_size, CompressedClassSpaceSize / sizeof(MetaWord));
 return false;
 }
 }
 assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
 "ClassLoaderData::the_null_class_loader_data() should have been used.");
-MetadataType mdtype = (type == MetaspaceObj::ClassType) ? metaspace::ClassType : metaspace::NonClassType;
+Metaspace::MetadataType mdtype = (type == MetaspaceObj::ClassType) ? Metaspace::ClassType : Metaspace::NonClassType;
 // Try to allocate metadata.
 MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
 if (result == NULL) {
 // If result is still null, we are out of memory.
 Log(gc, metaspace, freelist, oom) log;
 if (log.is_info()) {
 log.info("Metaspace (%s) allocation failed for size " SIZE_FORMAT,
-is_class(mdtype) ? "class" : "data", word_size);
+metaspace::is_class(mdtype) ? "class" : "data", word_size);
 ResourceMark rm;
 if (log.is_debug()) {
 if (loader_data->metaspace_or_null() != NULL) {
 LogStream ls(log.debug());
 loader_data->print_value_on(&ls);
 MetaspaceUtils::print_basic_report(&ls, 0);
 }
 // Which limit did we hit? CompressedClassSpaceSize or MaxMetaspaceSize?
 bool out_of_compressed_class_space = false;
-if (is_class(mdtype)) {
+if (metaspace::is_class(mdtype)) {
 ClassLoaderMetaspace* metaspace = loader_data->metaspace_non_null();
 out_of_compressed_class_space =
-MetaspaceUtils::committed_bytes(metaspace::ClassType) +
+MetaspaceUtils::committed_bytes(Metaspace::ClassType) +
 // TODO: Okay this is just cheesy.
 // Of course this may fail and return incorrect results.
 // Think this over - we need some clean way to remember which limit
 // exactly we hit during an allocation. Some sort of allocation context structure?
 align_up(word_size * BytesPerWord, 4 * M) >

branch	stuefe-new-metaspace-branch
changeset 59272	54750b448264
parent 58839	d888a9d9f9a5