< prev index next >

src/hotspot/share/memory/metaspace/chunkManager.cpp

Print this page
rev 60538 : imported patch jep387-core.patch
   1 /*
   2  * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.

   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */

  24 #include "precompiled.hpp"
  25 

  26 #include "logging/log.hpp"
  27 #include "logging/logStream.hpp"
  28 #include "memory/binaryTreeDictionary.inline.hpp"
  29 #include "memory/freeList.inline.hpp"
  30 #include "memory/metaspace/chunkManager.hpp"

  31 #include "memory/metaspace/metachunk.hpp"
  32 #include "memory/metaspace/metaDebug.hpp"
  33 #include "memory/metaspace/metaspaceCommon.hpp"

  34 #include "memory/metaspace/metaspaceStatistics.hpp"
  35 #include "memory/metaspace/occupancyMap.hpp"
  36 #include "memory/metaspace/virtualSpaceNode.hpp"

  37 #include "runtime/mutexLocker.hpp"
  38 #include "utilities/debug.hpp"
  39 #include "utilities/globalDefinitions.hpp"
  40 #include "utilities/ostream.hpp"
  41 
  42 namespace metaspace {
  43 
  44 ChunkManager::ChunkManager(bool is_class)
  45       : _is_class(is_class), _free_chunks_total(0), _free_chunks_count(0) {
  46   _free_chunks[SpecializedIndex].set_size(get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class));
  47   _free_chunks[SmallIndex].set_size(get_size_for_nonhumongous_chunktype(SmallIndex, is_class));
  48   _free_chunks[MediumIndex].set_size(get_size_for_nonhumongous_chunktype(MediumIndex, is_class));
  49 }
  50 
  51 void ChunkManager::remove_chunk(Metachunk* chunk) {
  52   size_t word_size = chunk->word_size();
  53   ChunkIndex index = list_index(word_size);
  54   if (index != HumongousIndex) {
  55     free_chunks(index)->remove_chunk(chunk);
  56   } else {
  57     humongous_dictionary()->remove_chunk(chunk);
  58   }






  59 
  60   // Chunk has been removed from the chunks free list, update counters.
  61   account_for_removed_chunk(chunk);
  62 }
  63 
  64 bool ChunkManager::attempt_to_coalesce_around_chunk(Metachunk* chunk, ChunkIndex target_chunk_type) {



















  65   assert_lock_strong(MetaspaceExpand_lock);
  66   assert(chunk != NULL, "invalid chunk pointer");
  67   // Check for valid merge combinations.
  68   assert((chunk->get_chunk_type() == SpecializedIndex &&
  69           (target_chunk_type == SmallIndex || target_chunk_type == MediumIndex)) ||
  70          (chunk->get_chunk_type() == SmallIndex && target_chunk_type == MediumIndex),
  71         "Invalid chunk merge combination.");
  72 
  73   const size_t target_chunk_word_size =
  74     get_size_for_nonhumongous_chunktype(target_chunk_type, this->is_class());
  75 
  76   // [ prospective merge region )
  77   MetaWord* const p_merge_region_start =
  78     (MetaWord*) align_down(chunk, target_chunk_word_size * sizeof(MetaWord));
  79   MetaWord* const p_merge_region_end =
  80     p_merge_region_start + target_chunk_word_size;
  81 
  82   // We need the VirtualSpaceNode containing this chunk and its occupancy map.
  83   VirtualSpaceNode* const vsn = chunk->container();
  84   OccupancyMap* const ocmap = vsn->occupancy_map();
  85 
  86   // The prospective chunk merge range must be completely contained by the
  87   // committed range of the virtual space node.
  88   if (p_merge_region_start < vsn->bottom() || p_merge_region_end > vsn->top()) {
  89     return false;
  90   }
  91 
  92   // Only attempt to merge this range if at its start a chunk starts and at its end
  93   // a chunk ends. If a chunk (can only be humongous) straddles either start or end
  94   // of that range, we cannot merge.
  95   if (!ocmap->chunk_starts_at_address(p_merge_region_start)) {
  96     return false;
  97   }
  98   if (p_merge_region_end < vsn->top() &&
  99       !ocmap->chunk_starts_at_address(p_merge_region_end)) {
 100     return false;
 101   }
 102 
 103   // Now check if the prospective merge area contains live chunks. If it does we cannot merge.
 104   if (ocmap->is_region_in_use(p_merge_region_start, target_chunk_word_size)) {
 105     return false;
 106   }
 107 
 108   // Success! Remove all chunks in this region...
 109   log_trace(gc, metaspace, freelist)("%s: coalescing chunks in area [%p-%p)...",
 110     (is_class() ? "class space" : "metaspace"),
 111     p_merge_region_start, p_merge_region_end);
 112 
 113   const int num_chunks_removed =
 114     remove_chunks_in_area(p_merge_region_start, target_chunk_word_size);
 115 
 116   // ... and create a single new bigger chunk.
 117   Metachunk* const p_new_chunk =
 118       ::new (p_merge_region_start) Metachunk(target_chunk_type, is_class(), target_chunk_word_size, vsn);
 119   assert(p_new_chunk == (Metachunk*)p_merge_region_start, "Sanity");
 120   p_new_chunk->set_origin(origin_merge);
 121 
 122   log_trace(gc, metaspace, freelist)("%s: created coalesced chunk at %p, size " SIZE_FORMAT_HEX ".",
 123     (is_class() ? "class space" : "metaspace"),
 124     p_new_chunk, p_new_chunk->word_size() * sizeof(MetaWord));
 125 
 126   // Fix occupancy map: remove old start bits of the small chunks and set new start bit.
 127   ocmap->wipe_chunk_start_bits_in_region(p_merge_region_start, target_chunk_word_size);
 128   ocmap->set_chunk_starts_at_address(p_merge_region_start, true);
 129 
 130   // Mark chunk as free. Note: it is not necessary to update the occupancy
 131   // map in-use map, because the old chunks were also free, so nothing
 132   // should have changed.
 133   p_new_chunk->set_is_tagged_free(true);
 134 
 135   // Add new chunk to its freelist.
 136   ChunkList* const list = free_chunks(target_chunk_type);
 137   list->return_chunk_at_head(p_new_chunk);
 138 
 139   // And adjust ChunkManager:: _free_chunks_count (_free_chunks_total
 140   // should not have changed, because the size of the space should be the same)
 141   _free_chunks_count -= num_chunks_removed;
 142   _free_chunks_count ++;
 143 
 144   // VirtualSpaceNode::chunk_count does not have to be modified:
 145   // it means "number of active (non-free) chunks", so merging free chunks
 146   // should not affect that count.
 147 
 148   // At the end of a chunk merge, run verification tests.
 149 #ifdef ASSERT

 150 
 151   EVERY_NTH(VerifyMetaspaceInterval)
 152     locked_verify(true);
 153     vsn->verify(true);
 154   END_EVERY_NTH
 155 
 156   g_internal_statistics.num_chunk_merges ++;

 157 
 158 #endif
 159 
 160   return true;
 161 }



 162 
 163 // Remove all chunks in the given area - the chunks are supposed to be free -
 164 // from their corresponding freelists. Mark them as invalid.
 165 // - This does not correct the occupancy map.
 166 // - This does not adjust the counters in ChunkManager.
 167 // - Does not adjust container count counter in containing VirtualSpaceNode
 168 // Returns number of chunks removed.
 169 int ChunkManager::remove_chunks_in_area(MetaWord* p, size_t word_size) {
 170   assert(p != NULL && word_size > 0, "Invalid range.");
 171   const size_t smallest_chunk_size = get_size_for_nonhumongous_chunktype(SpecializedIndex, is_class());
 172   assert_is_aligned(word_size, smallest_chunk_size);
 173 
 174   Metachunk* const start = (Metachunk*) p;
 175   const Metachunk* const end = (Metachunk*)(p + word_size);
 176   Metachunk* cur = start;
 177   int num_removed = 0;
 178   while (cur < end) {
 179     Metachunk* next = (Metachunk*)(((MetaWord*)cur) + cur->word_size());
 180     DEBUG_ONLY(do_verify_chunk(cur));
 181     assert(cur->get_chunk_type() != HumongousIndex, "Unexpected humongous chunk found at %p.", cur);
 182     assert(cur->is_tagged_free(), "Chunk expected to be free (%p)", cur);
 183     log_trace(gc, metaspace, freelist)("%s: removing chunk %p, size " SIZE_FORMAT_HEX ".",
 184       (is_class() ? "class space" : "metaspace"),
 185       cur, cur->word_size() * sizeof(MetaWord));
 186     cur->remove_sentinel();
 187     // Note: cannot call ChunkManager::remove_chunk, because that
 188     // modifies the counters in ChunkManager, which we do not want. So
 189     // we call remove_chunk on the freelist directly (see also the
 190     // splitting function which does the same).
 191     ChunkList* const list = free_chunks(list_index(cur->word_size()));
 192     list->remove_chunk(cur);
 193     num_removed ++;
 194     cur = next;
 195   }
 196   return num_removed;
 197 }
 198 
 199 // Update internal accounting after a chunk was added
 200 void ChunkManager::account_for_added_chunk(const Metachunk* c) {
 201   assert_lock_strong(MetaspaceExpand_lock);
 202   _free_chunks_count ++;
 203   _free_chunks_total += c->word_size();
 204 }
 205 
 206 // Update internal accounting after a chunk was removed
 207 void ChunkManager::account_for_removed_chunk(const Metachunk* c) {
 208   assert_lock_strong(MetaspaceExpand_lock);
 209   assert(_free_chunks_count >= 1,
 210     "ChunkManager::_free_chunks_count: about to go negative (" SIZE_FORMAT ").", _free_chunks_count);
 211   assert(_free_chunks_total >= c->word_size(),
 212     "ChunkManager::_free_chunks_total: about to go negative"
 213      "(now: " SIZE_FORMAT ", decrement value: " SIZE_FORMAT ").", _free_chunks_total, c->word_size());
 214   _free_chunks_count --;
 215   _free_chunks_total -= c->word_size();
 216 }
 217 
 218 ChunkIndex ChunkManager::list_index(size_t size) {
 219   return get_chunk_type_by_size(size, is_class());
 220 }
 221 
 222 size_t ChunkManager::size_by_index(ChunkIndex index) const {
 223   index_bounds_check(index);
 224   assert(index != HumongousIndex, "Do not call for humongous chunks.");
 225   return get_size_for_nonhumongous_chunktype(index, is_class());
 226 }
 227 
 228 #ifdef ASSERT
 229 void ChunkManager::verify(bool slow) const {
 230   MutexLocker cl(MetaspaceExpand_lock,
 231                      Mutex::_no_safepoint_check_flag);
 232   locked_verify(slow);
 233 }
 234 
 235 void ChunkManager::locked_verify(bool slow) const {
 236   log_trace(gc, metaspace, freelist)("verifying %s chunkmanager (%s).",
 237     (is_class() ? "class space" : "metaspace"), (slow ? "slow" : "quick"));







 238 
 239   assert_lock_strong(MetaspaceExpand_lock);



 240 
 241   size_t chunks_counted = 0;
 242   size_t wordsize_chunks_counted = 0;
 243   for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
 244     const ChunkList* list = _free_chunks + i;
 245     if (list != NULL) {
 246       Metachunk* chunk = list->head();
 247       while (chunk) {
 248         if (slow) {
 249           do_verify_chunk(chunk);
 250         }
 251         assert(chunk->is_tagged_free(), "Chunk should be tagged as free.");
 252         chunks_counted ++;
 253         wordsize_chunks_counted += chunk->size();
 254         chunk = chunk->next();











 255       }






 256     }






 257   }
 258 
 259   chunks_counted += humongous_dictionary()->total_free_blocks();
 260   wordsize_chunks_counted += humongous_dictionary()->total_size();
 261 
 262   assert(chunks_counted == _free_chunks_count && wordsize_chunks_counted == _free_chunks_total,
 263          "freelist accounting mismatch: "
 264          "we think: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words, "
 265          "reality: " SIZE_FORMAT " chunks, total " SIZE_FORMAT " words.",
 266          _free_chunks_count, _free_chunks_total,
 267          chunks_counted, wordsize_chunks_counted);
 268 }
 269 #endif // ASSERT
 270 
 271 void ChunkManager::locked_print_free_chunks(outputStream* st) {
 272   assert_lock_strong(MetaspaceExpand_lock);
 273   st->print_cr("Free chunk total " SIZE_FORMAT "  count " SIZE_FORMAT,
 274                 _free_chunks_total, _free_chunks_count);
 275 }
 276 
 277 ChunkList* ChunkManager::free_chunks(ChunkIndex index) {
 278   assert(index == SpecializedIndex || index == SmallIndex || index == MediumIndex,
 279          "Bad index: %d", (int)index);
 280   return &_free_chunks[index];
 281 }
 282 
 283 ChunkList* ChunkManager::find_free_chunks_list(size_t word_size) {
 284   ChunkIndex index = list_index(word_size);
 285   assert(index < HumongousIndex, "No humongous list");
 286   return free_chunks(index);
 287 }
 288 
 289 // Helper for chunk splitting: given a target chunk size and a larger free chunk,
 290 // split up the larger chunk into n smaller chunks, at least one of which should be
 291 // the target chunk of target chunk size. The smaller chunks, including the target
 292 // chunk, are returned to the freelist. The pointer to the target chunk is returned.
 293 // Note that this chunk is supposed to be removed from the freelist right away.
 294 Metachunk* ChunkManager::split_chunk(size_t target_chunk_word_size, Metachunk* larger_chunk) {
 295   assert(larger_chunk->word_size() > target_chunk_word_size, "Sanity");
 296 
 297   const ChunkIndex larger_chunk_index = larger_chunk->get_chunk_type();
 298   const ChunkIndex target_chunk_index = get_chunk_type_by_size(target_chunk_word_size, is_class());
 299 
 300   MetaWord* const region_start = (MetaWord*)larger_chunk;
 301   const size_t region_word_len = larger_chunk->word_size();
 302   MetaWord* const region_end = region_start + region_word_len;
 303   VirtualSpaceNode* const vsn = larger_chunk->container();
 304   OccupancyMap* const ocmap = vsn->occupancy_map();
 305 
 306   // Any larger non-humongous chunk size is a multiple of any smaller chunk size.
 307   // Since non-humongous chunks are aligned to their chunk size, the larger chunk should start
 308   // at an address suitable to place the smaller target chunk.
 309   assert_is_aligned(region_start, target_chunk_word_size);
 310 
 311   // Remove old chunk.
 312   free_chunks(larger_chunk_index)->remove_chunk(larger_chunk);
 313   larger_chunk->remove_sentinel();
 314 
 315   // Prevent access to the old chunk from here on.
 316   larger_chunk = NULL;
 317   // ... and wipe it.
 318   DEBUG_ONLY(memset(region_start, 0xfe, region_word_len * BytesPerWord));
 319 
 320   // In its place create first the target chunk...
 321   MetaWord* p = region_start;
 322   Metachunk* target_chunk = ::new (p) Metachunk(target_chunk_index, is_class(), target_chunk_word_size, vsn);
 323   assert(target_chunk == (Metachunk*)p, "Sanity");
 324   target_chunk->set_origin(origin_split);
 325 
 326   // Note: we do not need to mark its start in the occupancy map
 327   // because it coincides with the old chunk start.
 328 
 329   // Mark chunk as free and return to the freelist.
 330   do_update_in_use_info_for_chunk(target_chunk, false);
 331   free_chunks(target_chunk_index)->return_chunk_at_head(target_chunk);
 332 
 333   // This chunk should now be valid and can be verified.
 334   DEBUG_ONLY(do_verify_chunk(target_chunk));
 335 
 336   // In the remaining space create the remainder chunks.
 337   p += target_chunk->word_size();
 338   assert(p < region_end, "Sanity");
 339 
 340   while (p < region_end) {
 341 
 342     // Find the largest chunk size which fits the alignment requirements at address p.
 343     ChunkIndex this_chunk_index = prev_chunk_index(larger_chunk_index);
 344     size_t this_chunk_word_size = 0;
 345     for(;;) {
 346       this_chunk_word_size = get_size_for_nonhumongous_chunktype(this_chunk_index, is_class());
 347       if (is_aligned(p, this_chunk_word_size * BytesPerWord)) {
 348         break;
 349       } else {
 350         this_chunk_index = prev_chunk_index(this_chunk_index);
 351         assert(this_chunk_index >= target_chunk_index, "Sanity");
 352       }
 353     }
 354 
 355     assert(this_chunk_word_size >= target_chunk_word_size, "Sanity");
 356     assert(is_aligned(p, this_chunk_word_size * BytesPerWord), "Sanity");
 357     assert(p + this_chunk_word_size <= region_end, "Sanity");




 358 
 359     // Create splitting chunk.
 360     Metachunk* this_chunk = ::new (p) Metachunk(this_chunk_index, is_class(), this_chunk_word_size, vsn);
 361     assert(this_chunk == (Metachunk*)p, "Sanity");
 362     this_chunk->set_origin(origin_split);
 363     ocmap->set_chunk_starts_at_address(p, true);
 364     do_update_in_use_info_for_chunk(this_chunk, false);
 365 
 366     // This chunk should be valid and can be verified.
 367     DEBUG_ONLY(do_verify_chunk(this_chunk));





 368 
 369     // Return this chunk to freelist and correct counter.
 370     free_chunks(this_chunk_index)->return_chunk_at_head(this_chunk);
 371     _free_chunks_count ++;











 372 
 373     log_trace(gc, metaspace, freelist)("Created chunk at " PTR_FORMAT ", word size "
 374       SIZE_FORMAT_HEX " (%s), in split region [" PTR_FORMAT "..." PTR_FORMAT ").",
 375       p2i(this_chunk), this_chunk->word_size(), chunk_size_name(this_chunk_index),
 376       p2i(region_start), p2i(region_end));
 377 
 378     p += this_chunk_word_size;

 379 
 380   }

 381 
 382   // Note: at this point, the VirtualSpaceNode is invalid since we split a chunk and
 383   // did not yet hand out part of that split; so, vsn->verify_free_chunks_are_ideally_merged()
 384   // would assert. Instead, do all verifications in the caller.
 385 
 386   DEBUG_ONLY(g_internal_statistics.num_chunk_splits ++);
 387 
 388   return target_chunk;
 389 }
 390 
 391 Metachunk* ChunkManager::free_chunks_get(size_t word_size) {
 392   assert_lock_strong(MetaspaceExpand_lock);
 393 
 394   Metachunk* chunk = NULL;
 395   bool we_did_split_a_chunk = false;
 396 
 397   if (list_index(word_size) != HumongousIndex) {
 398 
 399     ChunkList* free_list = find_free_chunks_list(word_size);
 400     assert(free_list != NULL, "Sanity check");
 401 
 402     chunk = free_list->head();
 403 
 404     if (chunk == NULL) {
 405       // Split large chunks into smaller chunks if there are no smaller chunks, just large chunks.
 406       // This is the counterpart of the coalescing-upon-chunk-return.
 407 
 408       ChunkIndex target_chunk_index = get_chunk_type_by_size(word_size, is_class());









 409 
 410       // Is there a larger chunk we could split?
 411       Metachunk* larger_chunk = NULL;
 412       ChunkIndex larger_chunk_index = next_chunk_index(target_chunk_index);
 413       while (larger_chunk == NULL && larger_chunk_index < NumberOfFreeLists) {
 414         larger_chunk = free_chunks(larger_chunk_index)->head();
 415         if (larger_chunk == NULL) {
 416           larger_chunk_index = next_chunk_index(larger_chunk_index);
 417         }
 418       }
 419 
 420       if (larger_chunk != NULL) {
 421         assert(larger_chunk->word_size() > word_size, "Sanity");
 422         assert(larger_chunk->get_chunk_type() == larger_chunk_index, "Sanity");
 423 
 424         // We found a larger chunk. Lets split it up:
 425         // - remove old chunk
 426         // - in its place, create new smaller chunks, with at least one chunk
 427         //   being of target size, the others sized as large as possible. This
 428         //   is to make sure the resulting chunks are "as coalesced as possible"
 429         //   (similar to VirtualSpaceNode::retire()).
 430         // Note: during this operation both ChunkManager and VirtualSpaceNode
 431         //  are temporarily invalid, so be careful with asserts.
 432 
 433         log_trace(gc, metaspace, freelist)("%s: splitting chunk " PTR_FORMAT
 434            ", word size " SIZE_FORMAT_HEX " (%s), to get a chunk of word size " SIZE_FORMAT_HEX " (%s)...",
 435           (is_class() ? "class space" : "metaspace"), p2i(larger_chunk), larger_chunk->word_size(),
 436           chunk_size_name(larger_chunk_index), word_size, chunk_size_name(target_chunk_index));
 437 
 438         chunk = split_chunk(word_size, larger_chunk);
 439 
 440         // This should have worked.
 441         assert(chunk != NULL, "Sanity");
 442         assert(chunk->word_size() == word_size, "Sanity");
 443         assert(chunk->is_tagged_free(), "Sanity");
 444 
 445         we_did_split_a_chunk = true;
 446 
 447       }



 448     }
 449 
 450     if (chunk == NULL) {
 451       return NULL;
 452     }
 453 
 454     // Remove the chunk as the head of the list.
 455     free_list->remove_chunk(chunk);
 456 
 457     log_trace(gc, metaspace, freelist)("ChunkManager::free_chunks_get: free_list: " PTR_FORMAT " chunks left: " SSIZE_FORMAT ".",
 458                                        p2i(free_list), free_list->count());
 459 
 460   } else {
 461     chunk = humongous_dictionary()->get_chunk(word_size);






 462 
 463     if (chunk == NULL) {
 464       return NULL;
 465     }
 466 
 467     log_trace(gc, metaspace, alloc)("Free list allocate humongous chunk size " SIZE_FORMAT " for requested size " SIZE_FORMAT " waste " SIZE_FORMAT,
 468                                     chunk->word_size(), word_size, chunk->word_size() - word_size);



 469   }
 470 
 471   // Chunk has been removed from the chunk manager; update counters.
 472   account_for_removed_chunk(chunk);
 473   do_update_in_use_info_for_chunk(chunk, true);
 474   chunk->container()->inc_container_count();
 475   chunk->inc_use_count();
 476 
 477   // Remove it from the links to this freelist
 478   chunk->set_next(NULL);
 479   chunk->set_prev(NULL);
 480 
 481   // Run some verifications (some more if we did a chunk split)
 482 #ifdef ASSERT

 483 
 484   EVERY_NTH(VerifyMetaspaceInterval)
 485     // Be extra verify-y when chunk split happened.
 486     locked_verify(true);
 487     VirtualSpaceNode* const vsn = chunk->container();
 488     vsn->verify(true);
 489     if (we_did_split_a_chunk) {
 490       vsn->verify_free_chunks_are_ideally_merged();






















 491     }
 492   END_EVERY_NTH


 493 
 494   g_internal_statistics.num_chunks_removed_from_freelist ++;
 495 
 496 #endif
 497 
 498   return chunk;
 499 }
 500 
 501 Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
 502   assert_lock_strong(MetaspaceExpand_lock);





 503 
 504   // Take from the beginning of the list
 505   Metachunk* chunk = free_chunks_get(word_size);
 506   if (chunk == NULL) {
 507     return NULL;










 508   }
 509 
 510   assert((word_size <= chunk->word_size()) ||
 511          (list_index(chunk->word_size()) == HumongousIndex),
 512          "Non-humongous variable sized chunk");
 513   LogTarget(Trace, gc, metaspace, freelist) lt;
 514   if (lt.is_enabled()) {
 515     size_t list_count;
 516     if (list_index(word_size) < HumongousIndex) {
 517       ChunkList* list = find_free_chunks_list(word_size);
 518       list_count = list->count();
 519     } else {
 520       list_count = humongous_dictionary()->total_count();
 521     }
 522     LogStream ls(lt);
 523     ls.print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk " PTR_FORMAT "  size " SIZE_FORMAT " count " SIZE_FORMAT " ",
 524              p2i(this), p2i(chunk), chunk->word_size(), list_count);
 525     ResourceMark rm;
 526     locked_print_free_chunks(&ls);







 527   }




 528 
 529   return chunk;
 530 }
 531 
 532 void ChunkManager::return_single_chunk(Metachunk* chunk) {




 533 
 534 #ifdef ASSERT
 535   EVERY_NTH(VerifyMetaspaceInterval)
 536     this->locked_verify(false);
 537     do_verify_chunk(chunk);
 538   END_EVERY_NTH
 539 #endif
 540 
 541   const ChunkIndex index = chunk->get_chunk_type();
 542   assert_lock_strong(MetaspaceExpand_lock);
 543   DEBUG_ONLY(g_internal_statistics.num_chunks_added_to_freelist ++;)
 544   assert(chunk != NULL, "Expected chunk.");
 545   assert(chunk->container() != NULL, "Container should have been set.");
 546   assert(chunk->is_tagged_free() == false, "Chunk should be in use.");
 547   index_bounds_check(index);
 548 
 549   // Note: mangle *before* returning the chunk to the freelist or dictionary. It does not
 550   // matter for the freelist (non-humongous chunks), but the humongous chunk dictionary
 551   // keeps tree node pointers in the chunk payload area which mangle will overwrite.
 552   DEBUG_ONLY(chunk->mangle(badMetaWordVal);)
 553 
 554   // may need node for verification later after chunk may have been merged away.
 555   DEBUG_ONLY(VirtualSpaceNode* vsn = chunk->container(); )
 556 
 557   if (index != HumongousIndex) {
 558     // Return non-humongous chunk to freelist.
 559     ChunkList* list = free_chunks(index);
 560     assert(list->size() == chunk->word_size(), "Wrong chunk type.");
 561     list->return_chunk_at_head(chunk);
 562     log_trace(gc, metaspace, freelist)("returned one %s chunk at " PTR_FORMAT " to freelist.",
 563         chunk_size_name(index), p2i(chunk));
 564   } else {
 565     // Return humongous chunk to dictionary.
 566     assert(chunk->word_size() > free_chunks(MediumIndex)->size(), "Wrong chunk type.");
 567     assert(chunk->word_size() % free_chunks(SpecializedIndex)->size() == 0,
 568            "Humongous chunk has wrong alignment.");
 569     _humongous_dictionary.return_chunk(chunk);
 570     log_trace(gc, metaspace, freelist)("returned one %s chunk at " PTR_FORMAT " (word size " SIZE_FORMAT ") to freelist.",
 571         chunk_size_name(index), p2i(chunk), chunk->word_size());
 572   }
 573   chunk->container()->dec_container_count();
 574   do_update_in_use_info_for_chunk(chunk, false);
 575 
 576   // Chunk has been added; update counters.
 577   account_for_added_chunk(chunk);
 578 
 579   // Attempt coalesce returned chunks with its neighboring chunks:
 580   // if this chunk is small or special, attempt to coalesce to a medium chunk.
 581   if (index == SmallIndex || index == SpecializedIndex) {
 582     if (!attempt_to_coalesce_around_chunk(chunk, MediumIndex)) {
 583       // This did not work. But if this chunk is special, we still may form a small chunk?
 584       if (index == SpecializedIndex) {
 585         if (!attempt_to_coalesce_around_chunk(chunk, SmallIndex)) {
 586           // give up.
 587         }
 588       }
 589     }
 590   }
 591 
 592   // From here on do not access chunk anymore, it may have been merged with another chunk.


 593 
 594 #ifdef ASSERT
 595   EVERY_NTH(VerifyMetaspaceInterval)
 596     this->locked_verify(true);
 597     vsn->verify(true);
 598     vsn->verify_free_chunks_are_ideally_merged();
 599   END_EVERY_NTH
 600 #endif
 601 



 602 }
 603 
 604 void ChunkManager::return_chunk_list(Metachunk* chunks) {
 605   if (chunks == NULL) {
 606     return;
 607   }
 608   LogTarget(Trace, gc, metaspace, freelist) log;
 609   if (log.is_enabled()) { // tracing
 610     log.print("returning list of chunks...");
 611   }
 612   unsigned num_chunks_returned = 0;
 613   size_t size_chunks_returned = 0;
 614   Metachunk* cur = chunks;
 615   while (cur != NULL) {
 616     // Capture the next link before it is changed
 617     // by the call to return_chunk_at_head();
 618     Metachunk* next = cur->next();
 619     if (log.is_enabled()) { // tracing
 620       num_chunks_returned ++;
 621       size_chunks_returned += cur->word_size();
 622     }
 623     return_single_chunk(cur);
 624     cur = next;
 625   }
 626   if (log.is_enabled()) { // tracing
 627     log.print("returned %u chunks to freelist, total word size " SIZE_FORMAT ".",
 628         num_chunks_returned, size_chunks_returned);
 629   }
 630 }
 631 
 632 void ChunkManager::collect_statistics(ChunkManagerStatistics* out) const {
 633   MutexLocker cl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 634   for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
 635     out->chunk_stats(i).add(num_free_chunks(i), size_free_chunks_in_bytes(i) / sizeof(MetaWord));
 636   }
 637 }
 638 
 639 } // namespace metaspace
 640 




 641 






 642 

   1 /*
   2  * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * Copyright (c) 2018, 2020 SAP SE. All rights reserved.
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This code is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License version 2 only, as
   8  * published by the Free Software Foundation.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  *
  24  */
  25 
  26 #include "precompiled.hpp"
  27 
  28 
  29 #include "logging/log.hpp"
  30 #include "logging/logStream.hpp"
  31 #include "memory/metaspace/arenaGrowthPolicy.hpp"
  32 #include "memory/metaspace/chunkLevel.hpp"
  33 #include "memory/metaspace/chunkManager.hpp"
  34 #include "memory/metaspace/internStat.hpp"
  35 #include "memory/metaspace/metachunk.hpp"

  36 #include "memory/metaspace/metaspaceCommon.hpp"
  37 #include "memory/metaspace/metaspaceContext.hpp"
  38 #include "memory/metaspace/metaspaceStatistics.hpp"
  39 #include "memory/metaspace/settings.hpp"
  40 #include "memory/metaspace/virtualSpaceNode.hpp"
  41 #include "memory/metaspace/virtualSpaceList.hpp"
  42 #include "runtime/mutexLocker.hpp"
  43 #include "utilities/debug.hpp"
  44 #include "utilities/globalDefinitions.hpp"

  45 
  46 namespace metaspace {
  47 
  48 #define LOGFMT         "ChkMgr @" PTR_FORMAT " (%s)"
  49 #define LOGFMT_ARGS    p2i(this), this->_name




  50 
  51 // Return a single chunk to the freelist and adjust accounting. No merge is attempted.
  52 void ChunkManager::return_chunk_simple_locked(Metachunk* c) {
  53 
  54   assert_lock_strong(MetaspaceExpand_lock);
  55 
  56   DEBUG_ONLY(c->verify(false));
  57 
  58   const chunklevel_t lvl = c->level();
  59   _chunks.add(c);
  60   c->reset_used_words();
  61 
  62   // Tracing
  63   log_debug(metaspace)("ChunkManager %s: returned chunk " METACHUNK_FORMAT ".",
  64                        _name, METACHUNK_FORMAT_ARGS(c));
  65 


  66 }
  67 
  68 // Creates a chunk manager with a given name (which is for debug purposes only)
  69 // and an associated space list which will be used to request new chunks from
  70 // (see get_chunk())
  71 ChunkManager::ChunkManager(const char* name, VirtualSpaceList* space_list)
  72   : _vslist(space_list),
  73     _name(name),
  74     _chunks()
  75 {
  76 }
  77 
  78 // Given a chunk, split it into a target chunk of a smaller size (higher target level)
  79 //  and at least one, possible several splinter chunks.
  80 // The original chunk must be outside of the freelist and its state must be free.
  81 // The splinter chunks are added to the freelist.
  82 // The resulting target chunk will be located at the same address as the original
  83 //  chunk, but it will of course be smaller (of a higher level).
  84 // The committed areas within the original chunk carry over to the resulting
  85 //  chunks.
  86 void ChunkManager::split_chunk_and_add_splinters(Metachunk* c, chunklevel_t target_level) {
  87 
  88   assert_lock_strong(MetaspaceExpand_lock);

















































































  89 
  90   assert(c->is_free(), "chunk to be split must be free.");
  91   assert(c->level() < target_level, "Target level must be higher than current level.");
  92   assert(c->prev() == NULL && c->next() == NULL, "Chunk must be outside of any list.");
  93 
  94   DEBUG_ONLY(chunklevel::check_valid_level(target_level);)
  95   DEBUG_ONLY(c->verify(true);)


  96 
  97   UL2(debug, "splitting chunk " METACHUNK_FORMAT " to " CHKLVL_FORMAT ".",
  98       METACHUNK_FORMAT_ARGS(c), target_level);
  99 
 100   DEBUG_ONLY(size_t committed_words_before = c->committed_words();)
 101 
 102   const chunklevel_t orig_level = c->level();
 103   c->vsnode()->split(target_level, c, &_chunks);
 104 
 105   // Splitting should never fail.
 106   assert(c->level() == target_level, "Sanity");
 107 
 108   // The size of the committed portion should not change (subject to the reduced chunk size of course)
 109 #ifdef ASSERT
 110   if (committed_words_before > c->word_size()) {
 111     assert(c->is_fully_committed(), "Sanity");
 112   } else {
 113     assert(c->committed_words() == committed_words_before, "Sanity");


























 114   }
 115 #endif

 116 
 117   DEBUG_ONLY(c->verify(false));





 118 
 119   DEBUG_ONLY(verify_locked(true);)
 120 
 121   SOMETIMES(c->vsnode()->verify_locked(true);)
 122 
 123   InternalStats::inc_num_chunk_splits();
















 124 





 125 }
 126 
 127 // On success, returns a chunk of level of <preferred_level>, but at most <max_level>.
 128 //  The first first <min_committed_words> of the chunk are guaranteed to be committed.
 129 // On error, will return NULL.
 130 //
 131 // This function may fail for two reasons:
 132 // - Either we are unable to reserve space for a new chunk (if the underlying VirtualSpaceList
 133 //   is non-expandable but needs expanding - aka out of compressed class space).
 134 // - Or, if the necessary space cannot be committed because we hit a commit limit.
 135 //   This may be either the GC threshold or MaxMetaspaceSize.
 136 Metachunk* ChunkManager::get_chunk(chunklevel_t preferred_level, chunklevel_t max_level, size_t min_committed_words) {
 137 
 138   assert(preferred_level <= max_level, "Sanity");
 139   assert(chunklevel::level_fitting_word_size(min_committed_words) >= max_level, "Sanity");
 140 
 141   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 142 
 143   DEBUG_ONLY(verify_locked(false);)
 144 
 145   DEBUG_ONLY(chunklevel::check_valid_level(max_level);)
 146   DEBUG_ONLY(chunklevel::check_valid_level(preferred_level);)
 147   assert(max_level >= preferred_level, "invalid level.");
 148 
 149   UL2(debug, "requested chunk: pref_level: " CHKLVL_FORMAT
 150      ", max_level: " CHKLVL_FORMAT ", min committed size: " SIZE_FORMAT ".",
 151      preferred_level, max_level, min_committed_words);
 152 
 153   // First, optimistically look for a chunk which is already committed far enough to hold min_word_size.
 154 
 155   // 1) Search best or smaller committed chunks (first attempt):
 156   //    Start at the preferred chunk size and work your way down (level up).
 157   //    But for now, only consider chunks larger than a certain threshold -
 158   //    this is to prevent large loaders (eg boot) from unnecessarily gobbling up
 159   //    all the tiny splinter chunks lambdas leave around.
 160   Metachunk* c = NULL;
 161   c = _chunks.search_chunk_ascending(preferred_level, MIN2((chunklevel_t)(preferred_level + 2), max_level), min_committed_words);
 162 
 163   // 2) Search larger committed chunks:
 164   //    If that did not yield anything, look at larger chunks, which may be committed. We would have to split
 165   //    them first, of course.
 166   if (c == NULL) {
 167     c = _chunks.search_chunk_descending(preferred_level, min_committed_words);
 168   }
 169 
 170   // 3) Search best or smaller committed chunks (second attempt):
 171   //    Repeat (1) but now consider even the tiniest chunks as long as they are large enough to hold the
 172   //    committed min size.
 173   if (c == NULL) {
 174     c = _chunks.search_chunk_ascending(preferred_level, max_level, min_committed_words);
 175   }
 176 
 177   // if we did not get anything yet, there are no free chunks commmitted enough. Repeat search but look for uncommitted chunks too:
 178 
 179   // 4) Search best or smaller chunks, can be uncommitted:
 180   if (c == NULL) {
 181     c = _chunks.search_chunk_ascending(preferred_level, max_level, 0);
 182   }
 183 
 184   // 5) Search a larger uncommitted chunk:
 185   if (c == NULL) {
 186     c = _chunks.search_chunk_descending(preferred_level, 0);
 187   }







 188 
 189   if (c != NULL) {
 190     UL(trace, "taken from freelist.");
 191   }


 192 
 193   // Failing all that, allocate a new root chunk from the connected virtual space.
 194   // This may fail if the underlying vslist cannot be expanded (e.g. compressed class space)
 195   if (c == NULL) {
 196     c = _vslist->allocate_root_chunk();
 197     if (c == NULL) {
 198       UL(info, "failed to get new root chunk.");


































































 199     } else {
 200       assert(c->level() == chunklevel::ROOT_CHUNK_LEVEL, "root chunk expected");
 201       UL(debug, "allocated new root chunk.");
 202     }
 203   }
 204 
 205   if (c == NULL) {
 206     // If we end up here, we found no match in the freelists and were unable to get a new
 207     // root chunk (so we used up all address space, e.g. out of CompressedClassSpace).
 208     UL2(info, "failed to get chunk (preferred level: " CHKLVL_FORMAT
 209        ", max level " CHKLVL_FORMAT ".", preferred_level, max_level);
 210     c = NULL;
 211   }
 212 
 213   if (c != NULL) {





 214 
 215     // Now we have a chunk.
 216     //  It may be larger than what the caller wanted, so we may want to split it. This should
 217     //  always work.
 218     if (c->level() < preferred_level) {
 219       split_chunk_and_add_splinters(c, preferred_level);
 220       assert(c->level() == preferred_level, "split failed?");
 221     }
 222 
 223     // Attempt to commit the chunk (depending on settings, we either fully commit it or just
 224     //  commit enough to get the caller going). That may fail if we hit a commit limit. In
 225     //  that case put the chunk back to the freelist (re-merging it with its neighbors if we
 226     //  did split it) and return NULL.
 227     const size_t to_commit = Settings::new_chunks_are_fully_committed() ? c->word_size() : min_committed_words;
 228     if (c->committed_words() < to_commit) {
 229       if (c->ensure_committed_locked(to_commit) == false) {
 230         UL2(info, "failed to commit " SIZE_FORMAT " words on chunk " METACHUNK_FORMAT ".",
 231             to_commit,  METACHUNK_FORMAT_ARGS(c));
 232         c->set_in_use(); // gets asserted in return_chunk().
 233         return_chunk_locked(c);
 234         c = NULL;
 235       }
 236     }
 237 
 238     if (c != NULL) {



 239 
 240       // Still here? We have now a good chunk, all is well.
 241       assert(c->committed_words() >= min_committed_words, "Sanity");
 242 
 243       // Any chunk returned from ChunkManager shall be marked as in use.
 244       c->set_in_use();
 245 
 246       UL2(debug, "handing out chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));


 247 
 248       InternalStats::inc_num_chunks_taken_from_freelist();
 249 
 250       SOMETIMES(c->vsnode()->verify_locked(true);)

 251 
 252     }

 253 
 254   }

 255 
 256   DEBUG_ONLY(verify_locked(false);)
 257 
 258   return c;

 259 
 260 }
 261 



 262 
 263 // Return a single chunk to the ChunkManager and adjust accounting. May merge chunk
 264 //  with neighbors.
 265 // As a side effect this removes the chunk from whatever list it has been in previously.
 266 // Happens after a Classloader was unloaded and releases its metaspace chunks.
 267 // !! Note: this may invalidate the chunk. Do not access the chunk after
 268 //    this function returns !!
 269 void ChunkManager::return_chunk(Metachunk* c) {
 270   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 271   return_chunk_locked(c);
 272 }
 273 
 274 // See return_chunk().
 275 void ChunkManager::return_chunk_locked(Metachunk* c) {







 276 
 277   assert_lock_strong(MetaspaceExpand_lock);


 278 
 279   UL2(debug, ": returning chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));







 280 
 281   DEBUG_ONLY(c->verify(true);)



 282 
 283   assert(contains_chunk(c) == false, "A chunk to be added to the freelist must not be in the freelist already.");
 284 
 285   assert(c->is_in_use(), "Unexpected chunk state");
 286   assert(!c->in_list(), "Remove from list first");
 287   c->set_free();
 288   c->reset_used_words();
 289 
 290   const chunklevel_t orig_lvl = c->level();
 291 
 292   Metachunk* merged = NULL;
 293   if (!c->is_root_chunk()) {
 294     // Only attempt merging if we are not of the lowest level already.
 295     merged = c->vsnode()->merge(c, &_chunks);
 296   }
 297 
 298   if (merged != NULL) {


 299 
 300     InternalStats::inc_num_chunk_merges();

 301 
 302     DEBUG_ONLY(merged->verify(false));

 303 
 304     // We did merge our chunk into a different chunk.
 305 
 306     // We did merge chunks and now have a bigger chunk.
 307     assert(merged->level() < orig_lvl, "Sanity");
 308 
 309     UL2(debug, "merged into chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(merged));
 310 
 311     c = merged;
 312 


 313   }
 314 
 315   if (Settings::uncommit_free_chunks() &&
 316       c->word_size() >= Settings::commit_granule_words())
 317   {
 318     UL2(debug, "uncommitting free chunk " METACHUNK_FORMAT ".", METACHUNK_FORMAT_ARGS(c));
 319     c->uncommit_locked();
 320   }
 321 
 322   return_chunk_simple_locked(c);




 323 
 324   DEBUG_ONLY(verify_locked(false);)
 325   SOMETIMES(c->vsnode()->verify_locked(true);)

 326 
 327   InternalStats::inc_num_chunks_returned_to_freelist();
 328 
 329 }
 330 
 331 // Given a chunk c, whose state must be "in-use" and must not be a root chunk, attempt to
 332 // enlarge it in place by claiming its trailing buddy.
 333 //
 334 // This will only work if c is the leader of the buddy pair and the trailing buddy is free.
 335 //
 336 // If successful, the follower chunk will be removed from the freelists, the leader chunk c will
 337 // double in size (level decreased by one).
 338 //
 339 // On success, true is returned, false otherwise.
 340 bool ChunkManager::attempt_enlarge_chunk(Metachunk* c) {
 341   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 342   return c->vsnode()->attempt_enlarge_chunk(c, &_chunks);
 343 }
 344 
 345 static void print_word_size_delta(outputStream* st, size_t word_size_1, size_t word_size_2) {
 346   if (word_size_1 == word_size_2) {
 347     print_scaled_words(st, word_size_1);
 348     st->print (" (no change)");
 349   } else {
 350     print_scaled_words(st, word_size_1);
 351     st->print("->");
 352     print_scaled_words(st, word_size_2);
 353     st->print(" (");
 354     if (word_size_2 <= word_size_1) {
 355       st->print("-");
 356       print_scaled_words(st, word_size_1 - word_size_2);
 357     } else {
 358       st->print("+");
 359       print_scaled_words(st, word_size_2 - word_size_1);
 360     }
 361     st->print(")");
 362   }
 363 }
 364 
 365 void ChunkManager::purge() {
 366 
 367   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 368 
 369   UL(info, ": reclaiming memory...");

 370 
 371   const size_t reserved_before = _vslist->reserved_words();
 372   const size_t committed_before = _vslist->committed_words();
 373   int num_nodes_purged = 0;
 374 
 375   // 1) purge virtual space list
 376   num_nodes_purged = _vslist->purge(&_chunks);
 377   InternalStats::inc_num_purges();
 378 
 379   // 2) uncommit free chunks
 380   if (Settings::uncommit_free_chunks()) {
 381     const chunklevel_t max_level =
 382         chunklevel::level_fitting_word_size(Settings::commit_granule_words());
 383     for (chunklevel_t l = chunklevel::LOWEST_CHUNK_LEVEL;
 384          l <= max_level;
 385          l ++)
 386     {
 387       // Since we uncommit all chunks at this level, we do not break the "committed chunks are
 388       //  at the front of the list" condition.
 389       for (Metachunk* c = _chunks.first_at_level(l); c != NULL; c = c->next()) {
 390         c->uncommit_locked();
 391       }
 392     }
 393   }
 394 
 395   const size_t reserved_after = _vslist->reserved_words();
 396   const size_t committed_after = _vslist->committed_words();
 397 
 398   // Print a nice report.
 399   if (reserved_after == reserved_before && committed_after == committed_before) {
 400     UL(info, "nothing reclaimed.");



 401   } else {
 402     LogTarget(Info, metaspace) lt;
 403     if (lt.is_enabled()) {
 404       LogStream ls(lt);
 405       ls.print_cr(LOGFMT ": finished reclaiming memory: ", LOGFMT_ARGS);
 406 
 407       ls.print("reserved: ");
 408       print_word_size_delta(&ls, reserved_before, reserved_after);
 409       ls.cr();
 410 
 411       ls.print("committed: ");
 412       print_word_size_delta(&ls, committed_before, committed_after);
 413       ls.cr();
 414 
 415       ls.print_cr("full nodes purged: %d", num_nodes_purged);
 416     }
 417   }
 418 
 419   DEBUG_ONLY(_vslist->verify_locked(true));
 420   DEBUG_ONLY(verify_locked(true));
 421 

 422 }
 423 
 424 // Convenience methods to return the global class-space chunkmanager
 425 //  and non-class chunkmanager, respectively.
 426 ChunkManager* ChunkManager::chunkmanager_class() {
 427   return MetaspaceContext::context_class() == NULL ? NULL : MetaspaceContext::context_class()->cm();
 428 }
 429 
 430 ChunkManager* ChunkManager::chunkmanager_nonclass() {
 431   return MetaspaceContext::context_nonclass() == NULL ? NULL : MetaspaceContext::context_nonclass()->cm();
 432 }



 433 
 434 // Update statistics.
 435 void ChunkManager::add_to_statistics(cm_stats_t* out) const {
































 436 
 437   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);

 438 
 439   for (chunklevel_t l = chunklevel::ROOT_CHUNK_LEVEL; l <= chunklevel::HIGHEST_CHUNK_LEVEL; l ++) {
 440     out->num_chunks[l] += _chunks.num_chunks_at_level(l);
 441     out->committed_word_size[l] += _chunks.committed_word_size_at_level(l);








 442   }
 443 
 444   DEBUG_ONLY(out->verify();)
 445 
 446 }
 447 
 448 #ifdef ASSERT






 449 
 450 void ChunkManager::verify(bool slow) const {
 451   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 452   verify_locked(slow);
 453 }
 454 
 455 void ChunkManager::verify_locked(bool slow) const {
 456   assert_lock_strong(MetaspaceExpand_lock);
 457   assert(_vslist != NULL, "No vslist");
 458   _chunks.verify();






















 459 }
 460 
 461 bool ChunkManager::contains_chunk(Metachunk* c) const {
 462   return _chunks.contains(c);



 463 }
 464 
 465 #endif // ASSERT
 466 
 467 void ChunkManager::print_on(outputStream* st) const {
 468   MutexLocker fcl(MetaspaceExpand_lock, Mutex::_no_safepoint_check_flag);
 469   print_on_locked(st);
 470 }
 471 
 472 void ChunkManager::print_on_locked(outputStream* st) const {
 473   assert_lock_strong(MetaspaceExpand_lock);
 474   st->print_cr("cm %s: %d chunks, total word size: " SIZE_FORMAT ", committed word size: " SIZE_FORMAT, _name,
 475                total_num_chunks(), total_word_size(), _chunks.committed_word_size());
 476   _chunks.print_on(st);
 477 }
 478 
 479 } // namespace metaspace
< prev index next >