src/hotspot/share/memory/metaspace.hpp

rev 50187 : imported patch metaspace-split
rev 50188 : [mq]: 8176808-split-metaspace-cpp-2

@@ -62,19 +62,18 @@
 class outputStream;
 
 class CollectedHeap;
 
 namespace metaspace {
-namespace internals {
   class ChunkManager;
   class ClassLoaderMetaspaceStatistics;
   class Metablock;
   class Metachunk;
   class PrintCLDMetaspaceInfoClosure;
   class SpaceManager;
   class VirtualSpaceList;
-}}
+}
 
 // Metaspaces each have a  SpaceManager and allocations
 // are done by the SpaceManager.  Allocations are done
 // out of the current Metachunk.  When the current Metachunk
 // is exhausted, the SpaceManager gets a new one from

@@ -130,35 +129,35 @@
   static size_t _commit_alignment;
   static size_t _reserve_alignment;
   DEBUG_ONLY(static bool   _frozen;)
 
   // Virtual Space lists for both classes and other metadata
-  static metaspace::internals::VirtualSpaceList* _space_list;
-  static metaspace::internals::VirtualSpaceList* _class_space_list;
+  static metaspace::VirtualSpaceList* _space_list;
+  static metaspace::VirtualSpaceList* _class_space_list;
 
-  static metaspace::internals::ChunkManager* _chunk_manager_metadata;
-  static metaspace::internals::ChunkManager* _chunk_manager_class;
+  static metaspace::ChunkManager* _chunk_manager_metadata;
+  static metaspace::ChunkManager* _chunk_manager_class;
 
   static const MetaspaceTracer* _tracer;
 
  public:
-  static metaspace::internals::VirtualSpaceList* space_list()       { return _space_list; }
-  static metaspace::internals::VirtualSpaceList* class_space_list() { return _class_space_list; }
-  static metaspace::internals::VirtualSpaceList* get_space_list(MetadataType mdtype) {
+  static metaspace::VirtualSpaceList* space_list()       { return _space_list; }
+  static metaspace::VirtualSpaceList* class_space_list() { return _class_space_list; }
+  static metaspace::VirtualSpaceList* get_space_list(MetadataType mdtype) {
     assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
     return mdtype == ClassType ? class_space_list() : space_list();
   }
 
-  static metaspace::internals::ChunkManager* chunk_manager_metadata() { return _chunk_manager_metadata; }
-  static metaspace::internals::ChunkManager* chunk_manager_class()    { return _chunk_manager_class; }
-  static metaspace::internals::ChunkManager* get_chunk_manager(MetadataType mdtype) {
+  static metaspace::ChunkManager* chunk_manager_metadata() { return _chunk_manager_metadata; }
+  static metaspace::ChunkManager* chunk_manager_class()    { return _chunk_manager_class; }
+  static metaspace::ChunkManager* get_chunk_manager(MetadataType mdtype) {
     assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
     return mdtype == ClassType ? chunk_manager_class() : chunk_manager_metadata();
   }
 
   // convenience function
-  static metaspace::internals::ChunkManager* get_chunk_manager(bool is_class) {
+  static metaspace::ChunkManager* get_chunk_manager(bool is_class) {
     return is_class ? chunk_manager_class() : chunk_manager_metadata();
   }
 
   static const MetaspaceTracer* tracer() { return _tracer; }
   static void freeze() {

@@ -230,31 +229,31 @@
 // Manages the metaspace portion belonging to a class loader
 class ClassLoaderMetaspace : public CHeapObj<mtClass> {
   friend class CollectedHeap; // For expand_and_allocate()
   friend class Metaspace;
   friend class MetaspaceUtils;
-  friend class metaspace::internals::PrintCLDMetaspaceInfoClosure;
+  friend class metaspace::PrintCLDMetaspaceInfoClosure;
   friend class VM_CollectForMetadataAllocation; // For expand_and_allocate()
 
  private:
 
   void initialize(Mutex* lock, Metaspace::MetaspaceType type);
 
   // Initialize the first chunk for a Metaspace.  Used for
   // special cases such as the boot class loader, reflection
   // class loader and anonymous class loader.
   void initialize_first_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);
-  metaspace::internals::Metachunk* get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);
+  metaspace::Metachunk* get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);
 
   const Metaspace::MetaspaceType _space_type;
   Mutex* const  _lock;
-  metaspace::internals::SpaceManager* _vsm;
-  metaspace::internals::SpaceManager* _class_vsm;
+  metaspace::SpaceManager* _vsm;
+  metaspace::SpaceManager* _class_vsm;
 
-  metaspace::internals::SpaceManager* vsm() const { return _vsm; }
-  metaspace::internals::SpaceManager* class_vsm() const { return _class_vsm; }
-  metaspace::internals::SpaceManager* get_space_manager(Metaspace::MetadataType mdtype) {
+  metaspace::SpaceManager* vsm() const { return _vsm; }
+  metaspace::SpaceManager* class_vsm() const { return _class_vsm; }
+  metaspace::SpaceManager* get_space_manager(Metaspace::MetadataType mdtype) {
     assert(mdtype != Metaspace::MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");
     return mdtype == Metaspace::ClassType ? class_vsm() : vsm();
   }
 
   Mutex* lock() const { return _lock; }

@@ -262,11 +261,11 @@
   MetaWord* expand_and_allocate(size_t size, Metaspace::MetadataType mdtype);
 
   size_t class_chunk_size(size_t word_size);
 
   // Adds to the given statistic object. Must be locked with CLD metaspace lock.
-  void add_to_statistics_locked(metaspace::internals::ClassLoaderMetaspaceStatistics* out) const;
+  void add_to_statistics_locked(metaspace::ClassLoaderMetaspaceStatistics* out) const;
 
   Metaspace::MetaspaceType space_type() const { return _space_type; }
 
  public:
 

@@ -286,18 +285,18 @@
   void print_on(outputStream* st) const;
   // Debugging support
   void verify();
 
   // Adds to the given statistic object. Will lock with CLD metaspace lock.
-  void add_to_statistics(metaspace::internals::ClassLoaderMetaspaceStatistics* out) const;
+  void add_to_statistics(metaspace::ClassLoaderMetaspaceStatistics* out) const;
 
 }; // ClassLoaderMetaspace
 
 class MetaspaceUtils : AllStatic {
 
   // Spacemanager updates running counters.
-  friend class metaspace::internals::SpaceManager;
+  friend class metaspace::SpaceManager;
 
   // Running counters for statistics concerning in-use chunks.
   // Note: capacity = used + free + waste + overhead. Note that we do not
   // count free and waste. Their sum can be deduces from the three other values.
   // For more details, one should call print_report() from within a safe point.

@@ -327,11 +326,11 @@
 public:
 
   // Collect used metaspace statistics. This involves walking the CLDG. The resulting
   // output will be the accumulated values for all live metaspaces.
   // Note: method does not do any locking.
-  static void collect_statistics(metaspace::internals::ClassLoaderMetaspaceStatistics* out);
+  static void collect_statistics(metaspace::ClassLoaderMetaspaceStatistics* out);
 
   // Used by MetaspaceCounters
   static size_t free_chunks_total_words();
   static size_t free_chunks_total_bytes();
   static size_t free_chunks_total_bytes(Metaspace::MetadataType mdtype);