68   class ChunkManager;

    68 class MetaspaceSizesSnapshot;

    69   class ClassLoaderMetaspaceStatistics;

    70   class Metablock;

    71   class Metachunk;

    72   class PrintCLDMetaspaceInfoClosure;

    73   class SpaceManager;

    74   class VirtualSpaceList;

    75   class VirtualSpaceNode;

    97  public:

    92   // Base and size of the compressed class space.

    98   enum MetadataType {

    93   static MetaWord* _compressed_class_space_base;

    99     ClassType,

   100     NonClassType,

   101     MetadataTypeCount

   102   };

   103   enum MetaspaceType {

   104     ZeroMetaspaceType = 0,

   105     StandardMetaspaceType = ZeroMetaspaceType,

   106     BootMetaspaceType = StandardMetaspaceType + 1,

   107     UnsafeAnonymousMetaspaceType = BootMetaspaceType + 1,

   108     ReflectionMetaspaceType = UnsafeAnonymousMetaspaceType + 1,

   109     MetaspaceTypeCount

   110   };

   111 

   112  private:

   113 

   114   // Align up the word size to the allocation word size

   115   static size_t align_word_size_up(size_t);

   116 

   117   // Aligned size of the metaspace.

   146  public:

   104   static MetaWord* compressed_class_space_base()              { return _compressed_class_space_base; }

   147   static metaspace::VirtualSpaceList* space_list()       { return _space_list; }

   105   static size_t compressed_class_space_size()                 { return _compressed_class_space_size; }

   148   static metaspace::VirtualSpaceList* class_space_list() { return _class_space_list; }

   106 

   149   static metaspace::VirtualSpaceList* get_space_list(MetadataType mdtype) {

   107 public:

   150     assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");

   151     return mdtype == ClassType ? class_space_list() : space_list();

   152   }

   153 

   154   static metaspace::ChunkManager* chunk_manager_metadata() { return _chunk_manager_metadata; }

   155   static metaspace::ChunkManager* chunk_manager_class()    { return _chunk_manager_class; }

   156   static metaspace::ChunkManager* get_chunk_manager(MetadataType mdtype) {

   157     assert(mdtype != MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");

   158     return mdtype == ClassType ? chunk_manager_class() : chunk_manager_metadata();

   159   }

   160 

   161   // convenience function

   162   static metaspace::ChunkManager* get_chunk_manager(bool is_class) {

   163     return is_class ? chunk_manager_class() : chunk_manager_metadata();

   164   }

   195   static void verify_global_initialization();

   138   // The alignment at which Metaspace mappings are reserved.

   196 

   197   static size_t first_chunk_word_size() { return _first_chunk_word_size; }

   198   static size_t first_class_chunk_word_size() { return _first_class_chunk_word_size; }

   199 

   203   static size_t commit_alignment_words()  { return _commit_alignment / BytesPerWord; }

   144   static size_t commit_words()            { return _commit_alignment / BytesPerWord; }

   216                                    MetaspaceObj::Type type, MetadataType mdtype, TRAPS);

   156                                    MetaspaceObj::Type type, metaspace::MetadataType mdtype, TRAPS);

   217 

   218   static const char* metadata_type_name(Metaspace::MetadataType mdtype);

   235 // Manages the metaspace portion belonging to a class loader

   169 ////////////////// MetaspaceGC ///////////////////////

   236 class ClassLoaderMetaspace : public CHeapObj<mtClass> {

   237   friend class CollectedHeap; // For expand_and_allocate()

   238   friend class ZCollectedHeap; // For expand_and_allocate()

   239   friend class ShenandoahHeap; // For expand_and_allocate()

   240   friend class Metaspace;

   241   friend class MetaspaceUtils;

   242   friend class metaspace::PrintCLDMetaspaceInfoClosure;

   243   friend class VM_CollectForMetadataAllocation; // For expand_and_allocate()

   244 

   245  private:

   246 

   247   void initialize(Mutex* lock, Metaspace::MetaspaceType type);

   248 

   249   // Initialize the first chunk for a Metaspace.  Used for

   250   // special cases such as the boot class loader, reflection

   251   // class loader and anonymous class loader.

   252   void initialize_first_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);

   253   metaspace::Metachunk* get_initialization_chunk(Metaspace::MetaspaceType type, Metaspace::MetadataType mdtype);

   254 

   255   const Metaspace::MetaspaceType _space_type;

   256   Mutex* const  _lock;

   257   metaspace::SpaceManager* _vsm;

   258   metaspace::SpaceManager* _class_vsm;

   259 

   260   metaspace::SpaceManager* vsm() const { return _vsm; }

   261   metaspace::SpaceManager* class_vsm() const { return _class_vsm; }

   262   metaspace::SpaceManager* get_space_manager(Metaspace::MetadataType mdtype) {

   263     assert(mdtype != Metaspace::MetadataTypeCount, "MetadaTypeCount can't be used as mdtype");

   264     return mdtype == Metaspace::ClassType ? class_vsm() : vsm();

   265   }

   266 

   267   Mutex* lock() const { return _lock; }

   268 

   269   MetaWord* expand_and_allocate(size_t size, Metaspace::MetadataType mdtype);

   270 

   271   size_t class_chunk_size(size_t word_size);

   272 

   273   // Adds to the given statistic object. Must be locked with CLD metaspace lock.

   274   void add_to_statistics_locked(metaspace::ClassLoaderMetaspaceStatistics* out) const;

   275 

   276   Metaspace::MetaspaceType space_type() const { return _space_type; }

   277 

   278  public:

   279 

   280   ClassLoaderMetaspace(Mutex* lock, Metaspace::MetaspaceType type);

   281   ~ClassLoaderMetaspace();

   282 

   283   // Allocate space for metadata of type mdtype. This is space

   284   // within a Metachunk and is used by

   285   //   allocate(ClassLoaderData*, size_t, bool, MetadataType, TRAPS)

   286   MetaWord* allocate(size_t word_size, Metaspace::MetadataType mdtype);

   287 

   288   size_t allocated_blocks_bytes() const;

   289   size_t allocated_chunks_bytes() const;

   290 

   291   void deallocate(MetaWord* ptr, size_t byte_size, bool is_class);

   292 

   293   void print_on(outputStream* st) const;

   294   // Debugging support

   295   void verify();

   296 

   297   // Adds to the given statistic object. Will lock with CLD metaspace lock.

   298   void add_to_statistics(metaspace::ClassLoaderMetaspaceStatistics* out) const;

   299 

   300 }; // ClassLoaderMetaspace

   301 

   302 class MetaspaceUtils : AllStatic {

   303 

   304   // Spacemanager updates running counters.

   305   friend class metaspace::SpaceManager;

   306 

   307   // Special access for error reporting (checks without locks).

   308   friend class oopDesc;

   309   friend class Klass;

   310 

   311   // Running counters for statistics concerning in-use chunks.

   312   // Note: capacity = used + free + waste + overhead. Note that we do not

   313   // count free and waste. Their sum can be deduces from the three other values.

   314   // For more details, one should call print_report() from within a safe point.

   315   static size_t _capacity_words [Metaspace:: MetadataTypeCount];

   316   static size_t _overhead_words [Metaspace:: MetadataTypeCount];

   317   static volatile size_t _used_words [Metaspace:: MetadataTypeCount];

   318 

   319   // Atomically decrement or increment in-use statistic counters

   320   static void dec_capacity(Metaspace::MetadataType mdtype, size_t words);

   321   static void inc_capacity(Metaspace::MetadataType mdtype, size_t words);

   322   static void dec_used(Metaspace::MetadataType mdtype, size_t words);

   323   static void inc_used(Metaspace::MetadataType mdtype, size_t words);

   324   static void dec_overhead(Metaspace::MetadataType mdtype, size_t words);

   325   static void inc_overhead(Metaspace::MetadataType mdtype, size_t words);

   326 

   327 

   328   // Getters for the in-use counters.

   329   static size_t capacity_words(Metaspace::MetadataType mdtype)        { return _capacity_words[mdtype]; }

   330   static size_t used_words(Metaspace::MetadataType mdtype)            { return _used_words[mdtype]; }

   331   static size_t overhead_words(Metaspace::MetadataType mdtype)        { return _overhead_words[mdtype]; }

   332 

   333   static size_t free_chunks_total_words(Metaspace::MetadataType mdtype);

   334 

   335   // Helper for print_xx_report.

   336   static void print_vs(outputStream* out, size_t scale);

   337 

   338 public:

   339 

   340   // Collect used metaspace statistics. This involves walking the CLDG. The resulting

   341   // output will be the accumulated values for all live metaspaces.

   342   // Note: method does not do any locking.

   343   static void collect_statistics(metaspace::ClassLoaderMetaspaceStatistics* out);

   344 

   345   // Used by MetaspaceCounters

   346   static size_t free_chunks_total_words();

   347   static size_t free_chunks_total_bytes();

   348   static size_t free_chunks_total_bytes(Metaspace::MetadataType mdtype);

   349 

   350   static size_t capacity_words() {

   351     return capacity_words(Metaspace::NonClassType) +

   352            capacity_words(Metaspace::ClassType);

   353   }

   354   static size_t capacity_bytes(Metaspace::MetadataType mdtype) {

   355     return capacity_words(mdtype) * BytesPerWord;

   356   }

   357   static size_t capacity_bytes() {

   358     return capacity_words() * BytesPerWord;

   359   }

   360 

   361   static size_t used_words() {

   362     return used_words(Metaspace::NonClassType) +

   363            used_words(Metaspace::ClassType);

   364   }

   365   static size_t used_bytes(Metaspace::MetadataType mdtype) {

   366     return used_words(mdtype) * BytesPerWord;

   367   }

   368   static size_t used_bytes() {

   369     return used_words() * BytesPerWord;

   370   }

   371 

   372   // Space committed but yet unclaimed by any class loader.

   373   static size_t free_in_vs_bytes();

   374   static size_t free_in_vs_bytes(Metaspace::MetadataType mdtype);

   375 

   376   static size_t reserved_bytes(Metaspace::MetadataType mdtype);

   377   static size_t reserved_bytes() {

   378     return reserved_bytes(Metaspace::ClassType) +

   379            reserved_bytes(Metaspace::NonClassType);

   380   }

   381 

   382   static size_t committed_bytes(Metaspace::MetadataType mdtype);

   383   static size_t committed_bytes() {

   384     return committed_bytes(Metaspace::ClassType) +

   385            committed_bytes(Metaspace::NonClassType);

   386   }

   387 

   388   static size_t min_chunk_size_words();

   389 

   390   // Flags for print_report().

   391   enum ReportFlag {

   392     // Show usage by class loader.

   393     rf_show_loaders                 = (1 << 0),

   394     // Breaks report down by chunk type (small, medium, ...).

   395     rf_break_down_by_chunktype      = (1 << 1),

   396     // Breaks report down by space type (anonymous, reflection, ...).

   397     rf_break_down_by_spacetype      = (1 << 2),

   398     // Print details about the underlying virtual spaces.

   399     rf_show_vslist                  = (1 << 3),

   400     // Print metaspace map.

   401     rf_show_vsmap                   = (1 << 4),

   402     // If show_loaders: show loaded classes for each loader.

   403     rf_show_classes                 = (1 << 5)

   404   };

   405 

   406   // This will print out a basic metaspace usage report but

   407   // unlike print_report() is guaranteed not to lock or to walk the CLDG.

   408   static void print_basic_report(outputStream* st, size_t scale);

   409 

   410   // Prints a report about the current metaspace state.

   411   // Optional parts can be enabled via flags.

   412   // Function will walk the CLDG and will lock the expand lock; if that is not

   413   // convenient, use print_basic_report() instead.

   414   static void print_report(outputStream* out, size_t scale = 0, int flags = 0);

   415 

   416   static bool has_chunk_free_list(Metaspace::MetadataType mdtype);

   417   static MetaspaceChunkFreeListSummary chunk_free_list_summary(Metaspace::MetadataType mdtype);

   418 

   419   // Log change in used metadata.

   420   static void print_metaspace_change(const metaspace::MetaspaceSizesSnapshot& pre_meta_values);

   421   static void print_on(outputStream * out);

   422 

   423   // Prints an ASCII representation of the given space.

   424   static void print_metaspace_map(outputStream* out, Metaspace::MetadataType mdtype);

   425 

   426   static void dump(outputStream* out);

   427   static void verify_free_chunks();

   428   // Check internal counters (capacity, used).

   429   static void verify_metrics();

   430 };

   436 class MetaspaceGC : AllStatic {

   175 class MetaspaceGCThresholdUpdater : public AllStatic {

   176  public:

   177   enum Type {

   178     ComputeNewSize,

   179     ExpandAndAllocate,

   180     Last

   181   };

   182 

   183   static const char* to_string(MetaspaceGCThresholdUpdater::Type updater) {

   184     switch (updater) {

   185       case ComputeNewSize:

   186         return "compute_new_size";

   187       case ExpandAndAllocate:

   188         return "expand_and_allocate";

   189       default:

   190         assert(false, "Got bad updater: %d", (int) updater);

   191         return NULL;

   192     };

   193   }

   194 };

   195 

   196 class MetaspaceGC : public AllStatic {