truffle: src/share/vm/memory/metaspace.cpp annotate

annotate src/share/vm/memory/metaspace.cpp @ 20543:e7d0505c8a30

8059758: Footprint regressions with JDK-8038423 Summary: Changes in JDK-8038423 always initialize (zero out) virtual memory used for auxiliary data structures. This causes a footprint regression for G1 in startup benchmarks. This is because they do not touch that memory at all, so the operating system does not actually commit these pages. The fix is to, if the initialization value of the data structures matches the default value of just committed memory (=0), do not do anything. Reviewed-by: jwilhelm, brutisso

author	tschatzl
date	Fri, 10 Oct 2014 15:51:58 +0200
parents	b509b7ff561c
children	678a467a733b

rev	line source
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1 /*
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17935 diff changeset	2 * Copyright (c) 2011, 2014, Oracle and/or its affiliates. All rights reserved.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	4 *
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	7 * published by the Free Software Foundation.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	8 *
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	13 * accompanied this code).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	14 *
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	18 *
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	20 * or visit www.oracle.com if you need additional information or have any
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	21 * questions.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	22 *
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	23 */
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	24 #include "precompiled.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	25 #include "gc_interface/collectedHeap.hpp"
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	26 #include "memory/allocation.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	27 #include "memory/binaryTreeDictionary.hpp"
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	28 #include "memory/freeList.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	29 #include "memory/collectorPolicy.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	30 #include "memory/filemap.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	31 #include "memory/freeList.hpp"
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	32 #include "memory/gcLocker.hpp"
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	33 #include "memory/metachunk.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	34 #include "memory/metaspace.hpp"
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	35 #include "memory/metaspaceGCThresholdUpdater.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	36 #include "memory/metaspaceShared.hpp"
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	37 #include "memory/metaspaceTracer.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	38 #include "memory/resourceArea.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	39 #include "memory/universe.hpp"
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	40 #include "runtime/atomic.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	41 #include "runtime/globals.hpp"
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	42 #include "runtime/init.hpp"
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	43 #include "runtime/java.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	44 #include "runtime/mutex.hpp"
20197 ce8f6bb717c9 8042195: Introduce umbrella header orderAccess.inline.hpp. goetz parents: 17979 diff changeset	45 #include "runtime/orderAccess.inline.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	46 #include "services/memTracker.hpp"
12839 a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	47 #include "services/memoryService.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	48 #include "utilities/copy.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	49 #include "utilities/debug.hpp"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	50
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17935 diff changeset	51 PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17935 diff changeset	52
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	53 typedef BinaryTreeDictionary<Metablock, FreeList<Metablock> > BlockTreeDictionary;
ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	54 typedef BinaryTreeDictionary<Metachunk, FreeList<Metachunk> > ChunkTreeDictionary;
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	55
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	56 // Set this constant to enable slow integrity checking of the free chunk lists
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	57 const bool metaspace_slow_verify = false;
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	58
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	59 size_t const allocation_from_dictionary_limit = 4 * K;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	60
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	61 MetaWord* last_allocated = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	62
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	63 size_t Metaspace::_compressed_class_space_size;
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	64 const MetaspaceTracer* Metaspace::_tracer = NULL;
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	65
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	66 // Used in declarations in SpaceManager and ChunkManager
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	67 enum ChunkIndex {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	68 ZeroIndex = 0,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	69 SpecializedIndex = ZeroIndex,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	70 SmallIndex = SpecializedIndex + 1,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	71 MediumIndex = SmallIndex + 1,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	72 HumongousIndex = MediumIndex + 1,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	73 NumberOfFreeLists = 3,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	74 NumberOfInUseLists = 4
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	75 };
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	76
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	77 enum ChunkSizes { // in words.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	78 ClassSpecializedChunk = 128,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	79 SpecializedChunk = 128,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	80 ClassSmallChunk = 256,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	81 SmallChunk = 512,
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	82 ClassMediumChunk = 4 * K,
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	83 MediumChunk = 8 * K
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	84 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	85
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	86 static ChunkIndex next_chunk_index(ChunkIndex i) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	87 assert(i < NumberOfInUseLists, "Out of bound");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	88 return (ChunkIndex) (i+1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	89 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	90
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	91 volatile intptr_t MetaspaceGC::_capacity_until_GC = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	92 uint MetaspaceGC::_shrink_factor = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	93 bool MetaspaceGC::_should_concurrent_collect = false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	94
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	95 typedef class FreeList<Metachunk> ChunkList;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	96
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	97 // Manages the global free lists of chunks.
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	98 class ChunkManager : public CHeapObj<mtInternal> {
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	99 friend class TestVirtualSpaceNodeTest;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	100
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	101 // Free list of chunks of different sizes.
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	102 // SpecializedChunk
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	103 // SmallChunk
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	104 // MediumChunk
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	105 // HumongousChunk
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	106 ChunkList _free_chunks[NumberOfFreeLists];
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	107
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	108 // HumongousChunk
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	109 ChunkTreeDictionary _humongous_dictionary;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	110
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	111 // ChunkManager in all lists of this type
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	112 size_t _free_chunks_total;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	113 size_t _free_chunks_count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	114
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	115 void dec_free_chunks_total(size_t v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	116 assert(_free_chunks_count > 0 &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	117 _free_chunks_total > 0,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	118 "About to go negative");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	119 Atomic::add_ptr(-1, &_free_chunks_count);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	120 jlong minus_v = (jlong) - (jlong) v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	121 Atomic::add_ptr(minus_v, &_free_chunks_total);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	122 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	123
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	124 // Debug support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	125
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	126 size_t sum_free_chunks();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	127 size_t sum_free_chunks_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	128
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	129 void locked_verify_free_chunks_total();
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	130 void slow_locked_verify_free_chunks_total() {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	131 if (metaspace_slow_verify) {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	132 locked_verify_free_chunks_total();
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	133 }
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	134 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	135 void locked_verify_free_chunks_count();
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	136 void slow_locked_verify_free_chunks_count() {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	137 if (metaspace_slow_verify) {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	138 locked_verify_free_chunks_count();
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	139 }
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	140 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	141 void verify_free_chunks_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	142
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	143 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	144
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	145 ChunkManager(size_t specialized_size, size_t small_size, size_t medium_size)
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	146 : _free_chunks_total(0), _free_chunks_count(0) {
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	147 _free_chunks[SpecializedIndex].set_size(specialized_size);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	148 _free_chunks[SmallIndex].set_size(small_size);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	149 _free_chunks[MediumIndex].set_size(medium_size);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	150 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	151
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	152 // add or delete (return) a chunk to the global freelist.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	153 Metachunk* chunk_freelist_allocate(size_t word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	154
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	155 // Map a size to a list index assuming that there are lists
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	156 // for special, small, medium, and humongous chunks.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	157 static ChunkIndex list_index(size_t size);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	158
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	159 // Remove the chunk from its freelist. It is
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	160 // expected to be on one of the _free_chunks[] lists.
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	161 void remove_chunk(Metachunk* chunk);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	162
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	163 // Add the simple linked list of chunks to the freelist of chunks
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	164 // of type index.
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	165 void return_chunks(ChunkIndex index, Metachunk* chunks);
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	166
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	167 // Total of the space in the free chunks list
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	168 size_t free_chunks_total_words();
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	169 size_t free_chunks_total_bytes();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	170
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	171 // Number of chunks in the free chunks list
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	172 size_t free_chunks_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	173
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	174 void inc_free_chunks_total(size_t v, size_t count = 1) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	175 Atomic::add_ptr(count, &_free_chunks_count);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	176 Atomic::add_ptr(v, &_free_chunks_total);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	177 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	178 ChunkTreeDictionary* humongous_dictionary() {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	179 return &_humongous_dictionary;
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	180 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	181
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	182 ChunkList* free_chunks(ChunkIndex index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	183
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	184 // Returns the list for the given chunk word size.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	185 ChunkList* find_free_chunks_list(size_t word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	186
12906 94c0343b1887 8026715: Remove the MetaDataDeallocateALot develop flag stefank parents: 12902 diff changeset	187 // Remove from a list by size. Selects list based on size of chunk.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	188 Metachunk* free_chunks_get(size_t chunk_word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	189
17771 9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	190 #define index_bounds_check(index) \
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	191 assert(index == SpecializedIndex \|\| \
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	192 index == SmallIndex \|\| \
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	193 index == MediumIndex \|\| \
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	194 index == HumongousIndex, err_msg("Bad index: %d", (int) index))
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	195
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	196 size_t num_free_chunks(ChunkIndex index) const {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	197 index_bounds_check(index);
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	198
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	199 if (index == HumongousIndex) {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	200 return _humongous_dictionary.total_free_blocks();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	201 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	202
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	203 ssize_t count = _free_chunks[index].count();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	204 return count == -1 ? 0 : (size_t) count;
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	205 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	206
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	207 size_t size_free_chunks_in_bytes(ChunkIndex index) const {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	208 index_bounds_check(index);
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	209
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	210 size_t word_size = 0;
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	211 if (index == HumongousIndex) {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	212 word_size = _humongous_dictionary.total_size();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	213 } else {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	214 const size_t size_per_chunk_in_words = _free_chunks[index].size();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	215 word_size = size_per_chunk_in_words * num_free_chunks(index);
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	216 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	217
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	218 return word_size * BytesPerWord;
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	219 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	220
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	221 MetaspaceChunkFreeListSummary chunk_free_list_summary() const {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	222 return MetaspaceChunkFreeListSummary(num_free_chunks(SpecializedIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	223 num_free_chunks(SmallIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	224 num_free_chunks(MediumIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	225 num_free_chunks(HumongousIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	226 size_free_chunks_in_bytes(SpecializedIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	227 size_free_chunks_in_bytes(SmallIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	228 size_free_chunks_in_bytes(MediumIndex),
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	229 size_free_chunks_in_bytes(HumongousIndex));
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	230 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	231
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	232 // Debug support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	233 void verify();
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	234 void slow_verify() {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	235 if (metaspace_slow_verify) {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	236 verify();
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	237 }
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	238 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	239 void locked_verify();
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	240 void slow_locked_verify() {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	241 if (metaspace_slow_verify) {
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	242 locked_verify();
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	243 }
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	244 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	245 void verify_free_chunks_total();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	246
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	247 void locked_print_free_chunks(outputStream* st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	248 void locked_print_sum_free_chunks(outputStream* st);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	249
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	250 void print_on(outputStream* st) const;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	251 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	252
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	253 // Used to manage the free list of Metablocks (a block corresponds
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	254 // to the allocation of a quantum of metadata).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	255 class BlockFreelist VALUE_OBJ_CLASS_SPEC {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	256 BlockTreeDictionary* _dictionary;
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	257
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	258 // Only allocate and split from freelist if the size of the allocation
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	259 // is at least 1/4th the size of the available block.
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	260 const static int WasteMultiplier = 4;
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	261
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	262 // Accessors
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	263 BlockTreeDictionary* dictionary() const { return _dictionary; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	264
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	265 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	266 BlockFreelist();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	267 ~BlockFreelist();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	268
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	269 // Get and return a block to the free list
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	270 MetaWord* get_block(size_t word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	271 void return_block(MetaWord* p, size_t word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	272
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	273 size_t total_size() {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	274 if (dictionary() == NULL) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	275 return 0;
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	276 } else {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	277 return dictionary()->total_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	278 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	279 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	280
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	281 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	282 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	283
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	284 // A VirtualSpaceList node.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	285 class VirtualSpaceNode : public CHeapObj<mtClass> {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	286 friend class VirtualSpaceList;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	287
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	288 // Link to next VirtualSpaceNode
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	289 VirtualSpaceNode* _next;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	290
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	291 // total in the VirtualSpace
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	292 MemRegion _reserved;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	293 ReservedSpace _rs;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	294 VirtualSpace _virtual_space;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	295 MetaWord* _top;
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	296 // count of chunks contained in this VirtualSpace
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	297 uintx _container_count;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	298
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	299 // Convenience functions to access the _virtual_space
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	300 char* low() const { return virtual_space()->low(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	301 char* high() const { return virtual_space()->high(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	302
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	303 // The first Metachunk will be allocated at the bottom of the
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	304 // VirtualSpace
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	305 Metachunk* first_chunk() { return (Metachunk*) bottom(); }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	306
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	307 // Committed but unused space in the virtual space
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	308 size_t free_words_in_vs() const;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	309 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	310
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	311 VirtualSpaceNode(size_t byte_size);
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	312 VirtualSpaceNode(ReservedSpace rs) : _top(NULL), _next(NULL), _rs(rs), _container_count(0) {}
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	313 ~VirtualSpaceNode();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	314
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	315 // Convenience functions for logical bottom and end
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	316 MetaWord* bottom() const { return (MetaWord*) _virtual_space.low(); }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	317 MetaWord* end() const { return (MetaWord*) _virtual_space.high(); }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	318
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	319 bool contains(const void* ptr) { return ptr >= low() && ptr < high(); }
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	320
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	321 size_t reserved_words() const { return _virtual_space.reserved_size() / BytesPerWord; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	322 size_t committed_words() const { return _virtual_space.actual_committed_size() / BytesPerWord; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	323
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	324 bool is_pre_committed() const { return _virtual_space.special(); }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	325
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	326 // address of next available space in _virtual_space;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	327 // Accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	328 VirtualSpaceNode* next() { return _next; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	329 void set_next(VirtualSpaceNode* v) { _next = v; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	330
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	331 void set_reserved(MemRegion const v) { _reserved = v; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	332 void set_top(MetaWord* v) { _top = v; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	333
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	334 // Accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	335 MemRegion* reserved() { return &_reserved; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	336 VirtualSpace* virtual_space() const { return (VirtualSpace*) &_virtual_space; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	337
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	338 // Returns true if "word_size" is available in the VirtualSpace
13439 fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	339 bool is_available(size_t word_size) { return word_size <= pointer_delta(end(), _top, sizeof(MetaWord)); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	340
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	341 MetaWord* top() const { return _top; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	342 void inc_top(size_t word_size) { _top += word_size; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	343
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	344 uintx container_count() { return _container_count; }
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	345 void inc_container_count();
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	346 void dec_container_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	347 #ifdef ASSERT
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	348 uint container_count_slow();
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	349 void verify_container_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	350 #endif
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	351
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	352 // used and capacity in this single entry in the list
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	353 size_t used_words_in_vs() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	354 size_t capacity_words_in_vs() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	355
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	356 bool initialize();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	357
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	358 // get space from the virtual space
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	359 Metachunk* take_from_committed(size_t chunk_word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	360
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	361 // Allocate a chunk from the virtual space and return it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	362 Metachunk* get_chunk_vs(size_t chunk_word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	363
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	364 // Expands/shrinks the committed space in a virtual space. Delegates
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	365 // to Virtualspace
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	366 bool expand_by(size_t min_words, size_t preferred_words);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	367
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	368 // In preparation for deleting this node, remove all the chunks
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	369 // in the node from any freelist.
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	370 void purge(ChunkManager* chunk_manager);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	371
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	372 // If an allocation doesn't fit in the current node a new node is created.
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	373 // Allocate chunks out of the remaining committed space in this node
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	374 // to avoid wasting that memory.
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	375 // This always adds up because all the chunk sizes are multiples of
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	376 // the smallest chunk size.
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	377 void retire(ChunkManager* chunk_manager);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	378
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	379 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	380 // Debug support
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	381 void mangle();
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	382 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	383
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	384 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	385 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	386
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	387 #define assert_is_ptr_aligned(ptr, alignment) \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	388 assert(is_ptr_aligned(ptr, alignment), \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	389 err_msg(PTR_FORMAT " is not aligned to " \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	390 SIZE_FORMAT, ptr, alignment))
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	391
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	392 #define assert_is_size_aligned(size, alignment) \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	393 assert(is_size_aligned(size, alignment), \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	394 err_msg(SIZE_FORMAT " is not aligned to " \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	395 SIZE_FORMAT, size, alignment))
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	396
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	397
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	398 // Decide if large pages should be committed when the memory is reserved.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	399 static bool should_commit_large_pages_when_reserving(size_t bytes) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	400 if (UseLargePages && UseLargePagesInMetaspace && !os::can_commit_large_page_memory()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	401 size_t words = bytes / BytesPerWord;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	402 bool is_class = false; // We never reserve large pages for the class space.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	403 if (MetaspaceGC::can_expand(words, is_class) &&
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	404 MetaspaceGC::allowed_expansion() >= words) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	405 return true;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	406 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	407 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	408
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	409 return false;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	410 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	411
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	412 // byte_size is the size of the associated virtualspace.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	413 VirtualSpaceNode::VirtualSpaceNode(size_t bytes) : _top(NULL), _next(NULL), _rs(), _container_count(0) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	414 assert_is_size_aligned(bytes, Metaspace::reserve_alignment());
8752 82f49e8e2c28 8009614: nsk/split_verifier/stress/ifelse/ifelse002_30 fails with 'assert((size & (granularity - 1)) == 0) failed: size not aligned to os::vm_allocation_granularity() zgu parents: 8712 diff changeset	415
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	416 #if INCLUDE_CDS
8804 91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8754 diff changeset	417 // This allocates memory with mmap. For DumpSharedspaces, try to reserve
91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8754 diff changeset	418 // configurable address, generally at the top of the Java heap so other
91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8754 diff changeset	419 // memory addresses don't conflict.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	420 if (DumpSharedSpaces) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	421 bool large_pages = false; // No large pages when dumping the CDS archive.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	422 char* shared_base = (char)align_ptr_up((char)SharedBaseAddress, Metaspace::reserve_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	423
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	424 _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages, shared_base, 0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	425 if (_rs.is_reserved()) {
8804 91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8754 diff changeset	426 assert(shared_base == 0 \|\| _rs.base() == shared_base, "should match");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	427 } else {
8804 91bf0bdae37b 8008217: CDS: Class data sharing limits the malloc heap on Solaris coleenp parents: 8754 diff changeset	428 // Get a mmap region anywhere if the SharedBaseAddress fails.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	429 _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	430 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	431 MetaspaceShared::set_shared_rs(&_rs);
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	432 } else
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	433 #endif
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	434 {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	435 bool large_pages = should_commit_large_pages_when_reserving(bytes);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	436
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	437 _rs = ReservedSpace(bytes, Metaspace::reserve_alignment(), large_pages);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	438 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	439
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	440 if (_rs.is_reserved()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	441 assert(_rs.base() != NULL, "Catch if we get a NULL address");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	442 assert(_rs.size() != 0, "Catch if we get a 0 size");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	443 assert_is_ptr_aligned(_rs.base(), Metaspace::reserve_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	444 assert_is_size_aligned(_rs.size(), Metaspace::reserve_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	445
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	446 MemTracker::record_virtual_memory_type((address)_rs.base(), mtClass);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	447 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	448 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	449
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	450 void VirtualSpaceNode::purge(ChunkManager* chunk_manager) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	451 Metachunk* chunk = first_chunk();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	452 Metachunk* invalid_chunk = (Metachunk*) top();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	453 while (chunk < invalid_chunk ) {
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	454 assert(chunk->is_tagged_free(), "Should be tagged free");
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	455 MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	456 chunk_manager->remove_chunk(chunk);
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	457 assert(chunk->next() == NULL &&
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	458 chunk->prev() == NULL,
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	459 "Was not removed from its list");
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	460 chunk = (Metachunk*) next;
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	461 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	462 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	463
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	464 #ifdef ASSERT
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	465 uint VirtualSpaceNode::container_count_slow() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	466 uint count = 0;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	467 Metachunk* chunk = first_chunk();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	468 Metachunk* invalid_chunk = (Metachunk*) top();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	469 while (chunk < invalid_chunk ) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	470 MetaWord* next = ((MetaWord*)chunk) + chunk->word_size();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	471 // Don't count the chunks on the free lists. Those are
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	472 // still part of the VirtualSpaceNode but not currently
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	473 // counted.
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	474 if (!chunk->is_tagged_free()) {
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	475 count++;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	476 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	477 chunk = (Metachunk*) next;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	478 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	479 return count;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	480 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	481 #endif
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	482
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	483 // List of VirtualSpaces for metadata allocation.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	484 class VirtualSpaceList : public CHeapObj<mtClass> {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	485 friend class VirtualSpaceNode;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	486
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	487 enum VirtualSpaceSizes {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	488 VirtualSpaceSize = 256 * K
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	489 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	490
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	491 // Head of the list
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	492 VirtualSpaceNode* _virtual_space_list;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	493 // virtual space currently being used for allocations
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	494 VirtualSpaceNode* _current_virtual_space;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	495
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	496 // Is this VirtualSpaceList used for the compressed class space
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	497 bool _is_class;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	498
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	499 // Sum of reserved and committed memory in the virtual spaces
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	500 size_t _reserved_words;
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	501 size_t _committed_words;
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	502
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	503 // Number of virtual spaces
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	504 size_t _virtual_space_count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	505
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	506 ~VirtualSpaceList();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	507
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	508 VirtualSpaceNode* virtual_space_list() const { return _virtual_space_list; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	509
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	510 void set_virtual_space_list(VirtualSpaceNode* v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	511 _virtual_space_list = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	512 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	513 void set_current_virtual_space(VirtualSpaceNode* v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	514 _current_virtual_space = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	515 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	516
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	517 void link_vs(VirtualSpaceNode* new_entry);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	518
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	519 // Get another virtual space and add it to the list. This
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	520 // is typically prompted by a failed attempt to allocate a chunk
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	521 // and is typically followed by the allocation of a chunk.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	522 bool create_new_virtual_space(size_t vs_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	523
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	524 // Chunk up the unused committed space in the current
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	525 // virtual space and add the chunks to the free list.
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	526 void retire_current_virtual_space();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	527
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	528 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	529 VirtualSpaceList(size_t word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	530 VirtualSpaceList(ReservedSpace rs);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	531
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	532 size_t free_bytes();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	533
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	534 Metachunk* get_new_chunk(size_t word_size,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	535 size_t grow_chunks_by_words,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	536 size_t medium_chunk_bunch);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	537
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	538 bool expand_node_by(VirtualSpaceNode* node,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	539 size_t min_words,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	540 size_t preferred_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	541
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	542 bool expand_by(size_t min_words,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	543 size_t preferred_words);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	544
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	545 VirtualSpaceNode* current_virtual_space() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	546 return _current_virtual_space;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	547 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	548
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	549 bool is_class() const { return _is_class; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	550
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	551 bool initialization_succeeded() { return _virtual_space_list != NULL; }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	552
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	553 size_t reserved_words() { return _reserved_words; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	554 size_t reserved_bytes() { return reserved_words() * BytesPerWord; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	555 size_t committed_words() { return _committed_words; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	556 size_t committed_bytes() { return committed_words() * BytesPerWord; }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	557
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	558 void inc_reserved_words(size_t v);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	559 void dec_reserved_words(size_t v);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	560 void inc_committed_words(size_t v);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	561 void dec_committed_words(size_t v);
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	562 void inc_virtual_space_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	563 void dec_virtual_space_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	564
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	565 bool contains(const void* ptr);
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	566
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	567 // Unlink empty VirtualSpaceNodes and free it.
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	568 void purge(ChunkManager* chunk_manager);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	569
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	570 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	571
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	572 class VirtualSpaceListIterator : public StackObj {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	573 VirtualSpaceNode* _virtual_spaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	574 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	575 VirtualSpaceListIterator(VirtualSpaceNode* virtual_spaces) :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	576 _virtual_spaces(virtual_spaces) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	577
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	578 bool repeat() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	579 return _virtual_spaces != NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	580 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	581
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	582 VirtualSpaceNode* get_next() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	583 VirtualSpaceNode* result = _virtual_spaces;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	584 if (_virtual_spaces != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	585 _virtual_spaces = _virtual_spaces->next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	586 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	587 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	588 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	589 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	590 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	591
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	592 class Metadebug : AllStatic {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	593 // Debugging support for Metaspaces
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	594 static int _allocation_fail_alot_count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	595
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	596 public:
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	597
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	598 static void init_allocation_fail_alot_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	599 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	600 static bool test_metadata_failure();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	601 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	602 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	603
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	604 int Metadebug::_allocation_fail_alot_count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	605
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	606 // SpaceManager - used by Metaspace to handle allocations
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	607 class SpaceManager : public CHeapObj<mtClass> {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	608 friend class Metaspace;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	609 friend class Metadebug;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	610
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	611 private:
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	612
17663 40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 13439 diff changeset	613 // protects allocations
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	614 Mutex* const _lock;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	615
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	616 // Type of metadata allocated.
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	617 Metaspace::MetadataType _mdtype;
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	618
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	619 // List of chunks in use by this SpaceManager. Allocations
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	620 // are done from the current chunk. The list is used for deallocating
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	621 // chunks when the SpaceManager is freed.
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	622 Metachunk* _chunks_in_use[NumberOfInUseLists];
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	623 Metachunk* _current_chunk;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	624
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	625 // Number of small chunks to allocate to a manager
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	626 // If class space manager, small chunks are unlimited
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	627 static uint const _small_chunk_limit;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	628
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	629 // Sum of all space in allocated chunks
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	630 size_t _allocated_blocks_words;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	631
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	632 // Sum of all allocated chunks
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	633 size_t _allocated_chunks_words;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	634 size_t _allocated_chunks_count;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	635
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	636 // Free lists of blocks are per SpaceManager since they
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	637 // are assumed to be in chunks in use by the SpaceManager
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	638 // and all chunks in use by a SpaceManager are freed when
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	639 // the class loader using the SpaceManager is collected.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	640 BlockFreelist _block_freelists;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	641
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	642 // protects virtualspace and chunk expansions
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	643 static const char* _expand_lock_name;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	644 static const int _expand_lock_rank;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	645 static Mutex* const _expand_lock;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	646
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	647 private:
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	648 // Accessors
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	649 Metachunk* chunks_in_use(ChunkIndex index) const { return _chunks_in_use[index]; }
17663 40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 13439 diff changeset	650 void set_chunks_in_use(ChunkIndex index, Metachunk* v) {
40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 13439 diff changeset	651 _chunks_in_use[index] = v;
40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 13439 diff changeset	652 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	653
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	654 BlockFreelist* block_freelists() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	655 return (BlockFreelist*) &_block_freelists;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	656 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	657
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	658 Metaspace::MetadataType mdtype() { return _mdtype; }
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	659
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	660 VirtualSpaceList* vs_list() const { return Metaspace::get_space_list(_mdtype); }
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	661 ChunkManager* chunk_manager() const { return Metaspace::get_chunk_manager(_mdtype); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	662
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	663 Metachunk* current_chunk() const { return _current_chunk; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	664 void set_current_chunk(Metachunk* v) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	665 _current_chunk = v;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	666 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	667
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	668 Metachunk* find_current_chunk(size_t word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	669
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	670 // Add chunk to the list of chunks in use
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	671 void add_chunk(Metachunk* v, bool make_current);
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	672 void retire_current_chunk();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	673
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	674 Mutex* lock() const { return _lock; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	675
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	676 const char* chunk_size_name(ChunkIndex index) const;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	677
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	678 protected:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	679 void initialize();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	680
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	681 public:
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	682 SpaceManager(Metaspace::MetadataType mdtype,
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	683 Mutex* lock);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	684 ~SpaceManager();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	685
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	686 enum ChunkMultiples {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	687 MediumChunkMultiple = 4
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	688 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	689
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	690 bool is_class() { return _mdtype == Metaspace::ClassType; }
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	691
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	692 // Accessors
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	693 size_t specialized_chunk_size() { return (size_t) is_class() ? ClassSpecializedChunk : SpecializedChunk; }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	694 size_t small_chunk_size() { return (size_t) is_class() ? ClassSmallChunk : SmallChunk; }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	695 size_t medium_chunk_size() { return (size_t) is_class() ? ClassMediumChunk : MediumChunk; }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	696 size_t medium_chunk_bunch() { return medium_chunk_size() * MediumChunkMultiple; }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	697
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	698 size_t smallest_chunk_size() { return specialized_chunk_size(); }
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	699
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	700 size_t allocated_blocks_words() const { return _allocated_blocks_words; }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	701 size_t allocated_blocks_bytes() const { return _allocated_blocks_words * BytesPerWord; }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	702 size_t allocated_chunks_words() const { return _allocated_chunks_words; }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	703 size_t allocated_chunks_count() const { return _allocated_chunks_count; }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	704
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	705 bool is_humongous(size_t word_size) { return word_size > medium_chunk_size(); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	706
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	707 static Mutex* expand_lock() { return _expand_lock; }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	708
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	709 // Increment the per Metaspace and global running sums for Metachunks
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	710 // by the given size. This is used when a Metachunk to added to
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	711 // the in-use list.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	712 void inc_size_metrics(size_t words);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	713 // Increment the per Metaspace and global running sums Metablocks by the given
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	714 // size. This is used when a Metablock is allocated.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	715 void inc_used_metrics(size_t words);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	716 // Delete the portion of the running sums for this SpaceManager. That is,
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	717 // the globals running sums for the Metachunks and Metablocks are
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	718 // decremented for all the Metachunks in-use by this SpaceManager.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	719 void dec_total_from_size_metrics();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	720
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	721 // Set the sizes for the initial chunks.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	722 void get_initial_chunk_sizes(Metaspace::MetaspaceType type,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	723 size_t* chunk_word_size,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	724 size_t* class_chunk_word_size);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	725
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	726 size_t sum_capacity_in_chunks_in_use() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	727 size_t sum_used_in_chunks_in_use() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	728 size_t sum_free_in_chunks_in_use() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	729 size_t sum_waste_in_chunks_in_use() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	730 size_t sum_waste_in_chunks_in_use(ChunkIndex index ) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	731
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	732 size_t sum_count_in_chunks_in_use();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	733 size_t sum_count_in_chunks_in_use(ChunkIndex i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	734
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	735 Metachunk* get_new_chunk(size_t word_size, size_t grow_chunks_by_words);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	736
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	737 // Block allocation and deallocation.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	738 // Allocates a block from the current chunk
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	739 MetaWord* allocate(size_t word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	740
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	741 // Helper for allocations
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	742 MetaWord* allocate_work(size_t word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	743
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	744 // Returns a block to the per manager freelist
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	745 void deallocate(MetaWord* p, size_t word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	746
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	747 // Based on the allocation size and a minimum chunk size,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	748 // returned chunk size (for expanding space for chunk allocation).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	749 size_t calc_chunk_size(size_t allocation_word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	750
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	751 // Called when an allocation from the current chunk fails.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	752 // Gets a new chunk (may require getting a new virtual space),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	753 // and allocates from that chunk.
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	754 MetaWord* grow_and_allocate(size_t word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	755
12839 a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	756 // Notify memory usage to MemoryService.
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	757 void track_metaspace_memory_usage();
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	758
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	759 // debugging support.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	760
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	761 void dump(outputStream* const out) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	762 void print_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	763 void locked_print_chunks_in_use_on(outputStream* st) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	764
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	765 void verify();
7208 eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	766 void verify_chunk_size(Metachunk* chunk);
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	767 NOT_PRODUCT(void mangle_freed_chunks();)
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	768 #ifdef ASSERT
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	769 void verify_allocated_blocks_words();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	770 #endif
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	771
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	772 size_t get_raw_word_size(size_t word_size) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	773 size_t byte_size = word_size * BytesPerWord;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	774
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	775 size_t raw_bytes_size = MAX2(byte_size, sizeof(Metablock));
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	776 raw_bytes_size = align_size_up(raw_bytes_size, Metachunk::object_alignment());
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	777
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	778 size_t raw_word_size = raw_bytes_size / BytesPerWord;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	779 assert(raw_word_size * BytesPerWord == raw_bytes_size, "Size problem");
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	780
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	781 return raw_word_size;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	782 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	783 };
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	784
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	785 uint const SpaceManager::_small_chunk_limit = 4;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	786
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	787 const char* SpaceManager::_expand_lock_name =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	788 "SpaceManager chunk allocation lock";
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	789 const int SpaceManager::_expand_lock_rank = Monitor::leaf - 1;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	790 Mutex* const SpaceManager::_expand_lock =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	791 new Mutex(SpaceManager::_expand_lock_rank,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	792 SpaceManager::_expand_lock_name,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	793 Mutex::_allow_vm_block_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	794
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	795 void VirtualSpaceNode::inc_container_count() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	796 assert_lock_strong(SpaceManager::expand_lock());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	797 _container_count++;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	798 assert(_container_count == container_count_slow(),
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	799 err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	800 " container_count_slow() " SIZE_FORMAT,
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	801 _container_count, container_count_slow()));
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	802 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	803
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	804 void VirtualSpaceNode::dec_container_count() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	805 assert_lock_strong(SpaceManager::expand_lock());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	806 _container_count--;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	807 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	808
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	809 #ifdef ASSERT
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	810 void VirtualSpaceNode::verify_container_count() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	811 assert(_container_count == container_count_slow(),
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	812 err_msg("Inconsistency in countainer_count _container_count " SIZE_FORMAT
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	813 " container_count_slow() " SIZE_FORMAT, _container_count, container_count_slow()));
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	814 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	815 #endif
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	816
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	817 // BlockFreelist methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	818
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	819 BlockFreelist::BlockFreelist() : _dictionary(NULL) {}
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	820
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	821 BlockFreelist::~BlockFreelist() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	822 if (_dictionary != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	823 if (Verbose && TraceMetadataChunkAllocation) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	824 _dictionary->print_free_lists(gclog_or_tty);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	825 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	826 delete _dictionary;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	827 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	828 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	829
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	830 void BlockFreelist::return_block(MetaWord* p, size_t word_size) {
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	831 Metablock* free_chunk = ::new (p) Metablock(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	832 if (dictionary() == NULL) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	833 _dictionary = new BlockTreeDictionary();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	834 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	835 dictionary()->return_chunk(free_chunk);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	836 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	837
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	838 MetaWord* BlockFreelist::get_block(size_t word_size) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	839 if (dictionary() == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	840 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	841 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	842
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	843 if (word_size < TreeChunk<Metablock, FreeList<Metablock> >::min_size()) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	844 // Dark matter. Too small for dictionary.
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	845 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	846 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	847
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	848 Metablock* free_block =
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	849 dictionary()->get_chunk(word_size, FreeBlockDictionary<Metablock>::atLeast);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	850 if (free_block == NULL) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	851 return NULL;
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	852 }
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	853
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	854 const size_t block_size = free_block->size();
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	855 if (block_size > WasteMultiplier * word_size) {
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	856 return_block((MetaWord*)free_block, block_size);
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	857 return NULL;
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	858 }
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	859
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	860 MetaWord* new_block = (MetaWord*)free_block;
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	861 assert(block_size >= word_size, "Incorrect size of block from freelist");
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	862 const size_t unused = block_size - word_size;
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	863 if (unused >= TreeChunk<Metablock, FreeList<Metablock> >::min_size()) {
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	864 return_block(new_block + word_size, unused);
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	865 }
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	866
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	867 return new_block;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	868 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	869
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	870 void BlockFreelist::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	871 if (dictionary() == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	872 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	873 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	874 dictionary()->print_free_lists(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	875 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	876
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	877 // VirtualSpaceNode methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	878
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	879 VirtualSpaceNode::~VirtualSpaceNode() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	880 _rs.release();
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	881 #ifdef ASSERT
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	882 size_t word_size = sizeof(*this) / BytesPerWord;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	883 Copy::fill_to_words((HeapWord*) this, word_size, 0xf1f1f1f1);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	884 #endif
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	885 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	886
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	887 size_t VirtualSpaceNode::used_words_in_vs() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	888 return pointer_delta(top(), bottom(), sizeof(MetaWord));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	889 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	890
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	891 // Space committed in the VirtualSpace
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	892 size_t VirtualSpaceNode::capacity_words_in_vs() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	893 return pointer_delta(end(), bottom(), sizeof(MetaWord));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	894 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	895
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	896 size_t VirtualSpaceNode::free_words_in_vs() const {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	897 return pointer_delta(end(), top(), sizeof(MetaWord));
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	898 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	899
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	900 // Allocates the chunk from the virtual space only.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	901 // This interface is also used internally for debugging. Not all
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	902 // chunks removed here are necessarily used for allocation.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	903 Metachunk* VirtualSpaceNode::take_from_committed(size_t chunk_word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	904 // Bottom of the new chunk
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	905 MetaWord* chunk_limit = top();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	906 assert(chunk_limit != NULL, "Not safe to call this method");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	907
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	908 // The virtual spaces are always expanded by the
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	909 // commit granularity to enforce the following condition.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	910 // Without this the is_available check will not work correctly.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	911 assert(_virtual_space.committed_size() == _virtual_space.actual_committed_size(),
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	912 "The committed memory doesn't match the expanded memory.");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	913
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	914 if (!is_available(chunk_word_size)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	915 if (TraceMetadataChunkAllocation) {
12240 8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	916 gclog_or_tty->print("VirtualSpaceNode::take_from_committed() not available %d words ", chunk_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	917 // Dump some information about the virtual space that is nearly full
12240 8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	918 print_on(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	919 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	920 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	921 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	922
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	923 // Take the space (bump top on the current virtual space).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	924 inc_top(chunk_word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	925
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	926 // Initialize the chunk
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	927 Metachunk* result = ::new (chunk_limit) Metachunk(chunk_word_size, this);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	928 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	929 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	930
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	931
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	932 // Expand the virtual space (commit more of the reserved space)
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	933 bool VirtualSpaceNode::expand_by(size_t min_words, size_t preferred_words) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	934 size_t min_bytes = min_words * BytesPerWord;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	935 size_t preferred_bytes = preferred_words * BytesPerWord;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	936
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	937 size_t uncommitted = virtual_space()->reserved_size() - virtual_space()->actual_committed_size();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	938
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	939 if (uncommitted < min_bytes) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	940 return false;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	941 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	942
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	943 size_t commit = MIN2(preferred_bytes, uncommitted);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	944 bool result = virtual_space()->expand_by(commit, false);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	945
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	946 assert(result, "Failed to commit memory");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	947
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	948 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	949 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	950
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	951 Metachunk* VirtualSpaceNode::get_chunk_vs(size_t chunk_word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	952 assert_lock_strong(SpaceManager::expand_lock());
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	953 Metachunk* result = take_from_committed(chunk_word_size);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	954 if (result != NULL) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	955 inc_container_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	956 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	957 return result;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	958 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	959
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	960 bool VirtualSpaceNode::initialize() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	961
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	962 if (!_rs.is_reserved()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	963 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	964 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	965
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	966 // These are necessary restriction to make sure that the virtual space always
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	967 // grows in steps of Metaspace::commit_alignment(). If both base and size are
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	968 // aligned only the middle alignment of the VirtualSpace is used.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	969 assert_is_ptr_aligned(_rs.base(), Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	970 assert_is_size_aligned(_rs.size(), Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	971
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	972 // ReservedSpaces marked as special will have the entire memory
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	973 // pre-committed. Setting a committed size will make sure that
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	974 // committed_size and actual_committed_size agrees.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	975 size_t pre_committed_size = _rs.special() ? _rs.size() : 0;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	976
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	977 bool result = virtual_space()->initialize_with_granularity(_rs, pre_committed_size,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	978 Metaspace::commit_alignment());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	979 if (result) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	980 assert(virtual_space()->committed_size() == virtual_space()->actual_committed_size(),
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	981 "Checking that the pre-committed memory was registered by the VirtualSpace");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	982
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	983 set_top((MetaWord*)virtual_space()->low());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	984 set_reserved(MemRegion((HeapWord*)_rs.base(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	985 (HeapWord*)(_rs.base() + _rs.size())));
6726 03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	986
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	987 assert(reserved()->start() == (HeapWord*) _rs.base(),
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	988 err_msg("Reserved start was not set properly " PTR_FORMAT
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	989 " != " PTR_FORMAT, reserved()->start(), _rs.base()));
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	990 assert(reserved()->word_size() == _rs.size() / BytesPerWord,
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	991 err_msg("Reserved size was not set properly " SIZE_FORMAT
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	992 " != " SIZE_FORMAT, reserved()->word_size(),
03049e0e8544 7195823: NPG: CMS reserved() doesn't match _rs.base(). coleenp parents: 6725 diff changeset	993 _rs.size() / BytesPerWord));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	994 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	995
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	996 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	997 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	998
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	999 void VirtualSpaceNode::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1000 size_t used = used_words_in_vs();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1001 size_t capacity = capacity_words_in_vs();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1002 VirtualSpace* vs = virtual_space();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1003 st->print_cr(" space @ " PTR_FORMAT " " SIZE_FORMAT "K, %3d%% used "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1004 "[" PTR_FORMAT ", " PTR_FORMAT ", "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1005 PTR_FORMAT ", " PTR_FORMAT ")",
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1006 vs, capacity / K,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1007 capacity == 0 ? 0 : used * 100 / capacity,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1008 bottom(), top(), end(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1009 vs->high_boundary());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1010 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1011
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	1012 #ifdef ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1013 void VirtualSpaceNode::mangle() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1014 size_t word_size = capacity_words_in_vs();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1015 Copy::fill_to_words((HeapWord*) low(), word_size, 0xf1f1f1f1);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1016 }
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	1017 #endif // ASSERT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1018
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1019 // VirtualSpaceList methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1020 // Space allocated from the VirtualSpace
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1021
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1022 VirtualSpaceList::~VirtualSpaceList() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1023 VirtualSpaceListIterator iter(virtual_space_list());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1024 while (iter.repeat()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1025 VirtualSpaceNode* vsl = iter.get_next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1026 delete vsl;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1027 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1028 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1029
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1030 void VirtualSpaceList::inc_reserved_words(size_t v) {
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1031 assert_lock_strong(SpaceManager::expand_lock());
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1032 _reserved_words = _reserved_words + v;
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1033 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1034 void VirtualSpaceList::dec_reserved_words(size_t v) {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1035 assert_lock_strong(SpaceManager::expand_lock());
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1036 _reserved_words = _reserved_words - v;
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1037 }
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1038
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1039 #define assert_committed_below_limit() \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1040 assert(MetaspaceAux::committed_bytes() <= MaxMetaspaceSize, \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1041 err_msg("Too much committed memory. Committed: " SIZE_FORMAT \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1042 " limit (MaxMetaspaceSize): " SIZE_FORMAT, \
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1043 MetaspaceAux::committed_bytes(), MaxMetaspaceSize));
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1044
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1045 void VirtualSpaceList::inc_committed_words(size_t v) {
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1046 assert_lock_strong(SpaceManager::expand_lock());
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1047 _committed_words = _committed_words + v;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1048
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1049 assert_committed_below_limit();
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1050 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1051 void VirtualSpaceList::dec_committed_words(size_t v) {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1052 assert_lock_strong(SpaceManager::expand_lock());
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1053 _committed_words = _committed_words - v;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1054
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1055 assert_committed_below_limit();
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1056 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1057
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1058 void VirtualSpaceList::inc_virtual_space_count() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1059 assert_lock_strong(SpaceManager::expand_lock());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1060 _virtual_space_count++;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1061 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1062 void VirtualSpaceList::dec_virtual_space_count() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1063 assert_lock_strong(SpaceManager::expand_lock());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1064 _virtual_space_count--;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1065 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1066
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1067 void ChunkManager::remove_chunk(Metachunk* chunk) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1068 size_t word_size = chunk->word_size();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1069 ChunkIndex index = list_index(word_size);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1070 if (index != HumongousIndex) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1071 free_chunks(index)->remove_chunk(chunk);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1072 } else {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1073 humongous_dictionary()->remove_chunk(chunk);
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1074 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1075
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1076 // Chunk is being removed from the chunks free list.
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	1077 dec_free_chunks_total(chunk->word_size());
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1078 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1079
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1080 // Walk the list of VirtualSpaceNodes and delete
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1081 // nodes with a 0 container_count. Remove Metachunks in
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1082 // the node from their respective freelists.
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1083 void VirtualSpaceList::purge(ChunkManager* chunk_manager) {
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1084 assert(SafepointSynchronize::is_at_safepoint(), "must be called at safepoint for contains to work");
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1085 assert_lock_strong(SpaceManager::expand_lock());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1086 // Don't use a VirtualSpaceListIterator because this
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1087 // list is being changed and a straightforward use of an iterator is not safe.
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1088 VirtualSpaceNode* purged_vsl = NULL;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1089 VirtualSpaceNode* prev_vsl = virtual_space_list();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1090 VirtualSpaceNode* next_vsl = prev_vsl;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1091 while (next_vsl != NULL) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1092 VirtualSpaceNode* vsl = next_vsl;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1093 next_vsl = vsl->next();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1094 // Don't free the current virtual space since it will likely
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1095 // be needed soon.
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1096 if (vsl->container_count() == 0 && vsl != current_virtual_space()) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1097 // Unlink it from the list
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1098 if (prev_vsl == vsl) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1099 // This is the case of the current node being the first node.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1100 assert(vsl == virtual_space_list(), "Expected to be the first node");
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1101 set_virtual_space_list(vsl->next());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1102 } else {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1103 prev_vsl->set_next(vsl->next());
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1104 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1105
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1106 vsl->purge(chunk_manager);
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1107 dec_reserved_words(vsl->reserved_words());
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1108 dec_committed_words(vsl->committed_words());
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1109 dec_virtual_space_count();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1110 purged_vsl = vsl;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1111 delete vsl;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1112 } else {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1113 prev_vsl = vsl;
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1114 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1115 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1116 #ifdef ASSERT
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1117 if (purged_vsl != NULL) {
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1118 // List should be stable enough to use an iterator here.
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1119 VirtualSpaceListIterator iter(virtual_space_list());
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1120 while (iter.repeat()) {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1121 VirtualSpaceNode* vsl = iter.get_next();
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1122 assert(vsl != purged_vsl, "Purge of vsl failed");
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1123 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1124 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1125 #endif
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1126 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1127
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1128
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1129 // This function looks at the mmap regions in the metaspace without locking.
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1130 // The chunks are added with store ordering and not deleted except for at
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1131 // unloading time during a safepoint.
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1132 bool VirtualSpaceList::contains(const void* ptr) {
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1133 // List should be stable enough to use an iterator here because removing virtual
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1134 // space nodes is only allowed at a safepoint.
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1135 VirtualSpaceListIterator iter(virtual_space_list());
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1136 while (iter.repeat()) {
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1137 VirtualSpaceNode* vsn = iter.get_next();
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1138 if (vsn->contains(ptr)) {
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1139 return true;
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1140 }
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1141 }
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1142 return false;
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1143 }
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1144
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1145 void VirtualSpaceList::retire_current_virtual_space() {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1146 assert_lock_strong(SpaceManager::expand_lock());
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1147
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1148 VirtualSpaceNode* vsn = current_virtual_space();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1149
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1150 ChunkManager* cm = is_class() ? Metaspace::chunk_manager_class() :
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1151 Metaspace::chunk_manager_metadata();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1152
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1153 vsn->retire(cm);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1154 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1155
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1156 void VirtualSpaceNode::retire(ChunkManager* chunk_manager) {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1157 for (int i = (int)MediumIndex; i >= (int)ZeroIndex; --i) {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1158 ChunkIndex index = (ChunkIndex)i;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1159 size_t chunk_size = chunk_manager->free_chunks(index)->size();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1160
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1161 while (free_words_in_vs() >= chunk_size) {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1162 DEBUG_ONLY(verify_container_count();)
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1163 Metachunk* chunk = get_chunk_vs(chunk_size);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1164 assert(chunk != NULL, "allocation should have been successful");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1165
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1166 chunk_manager->return_chunks(index, chunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1167 chunk_manager->inc_free_chunks_total(chunk_size);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1168 DEBUG_ONLY(verify_container_count();)
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1169 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1170 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1171 assert(free_words_in_vs() == 0, "should be empty now");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1172 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1173
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1174 VirtualSpaceList::VirtualSpaceList(size_t word_size) :
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1175 _is_class(false),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1176 _virtual_space_list(NULL),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1177 _current_virtual_space(NULL),
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1178 _reserved_words(0),
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1179 _committed_words(0),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1180 _virtual_space_count(0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1181 MutexLockerEx cl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1182 Mutex::_no_safepoint_check_flag);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1183 create_new_virtual_space(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1184 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1185
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1186 VirtualSpaceList::VirtualSpaceList(ReservedSpace rs) :
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1187 _is_class(true),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1188 _virtual_space_list(NULL),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1189 _current_virtual_space(NULL),
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1190 _reserved_words(0),
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1191 _committed_words(0),
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1192 _virtual_space_count(0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1193 MutexLockerEx cl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1194 Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1195 VirtualSpaceNode* class_entry = new VirtualSpaceNode(rs);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1196 bool succeeded = class_entry->initialize();
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1197 if (succeeded) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1198 link_vs(class_entry);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1199 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1200 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1201
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1202 size_t VirtualSpaceList::free_bytes() {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1203 return virtual_space_list()->free_words_in_vs() * BytesPerWord;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1204 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1205
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1206 // Allocate another meta virtual space and add it to the list.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1207 bool VirtualSpaceList::create_new_virtual_space(size_t vs_word_size) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1208 assert_lock_strong(SpaceManager::expand_lock());
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1209
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1210 if (is_class()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1211 assert(false, "We currently don't support more than one VirtualSpace for"
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1212 " the compressed class space. The initialization of the"
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1213 " CCS uses another code path and should not hit this path.");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1214 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1215 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1216
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1217 if (vs_word_size == 0) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1218 assert(false, "vs_word_size should always be at least _reserve_alignment large.");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1219 return false;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1220 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1221
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1222 // Reserve the space
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1223 size_t vs_byte_size = vs_word_size * BytesPerWord;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1224 assert_is_size_aligned(vs_byte_size, Metaspace::reserve_alignment());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1225
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1226 // Allocate the meta virtual space and initialize it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1227 VirtualSpaceNode* new_entry = new VirtualSpaceNode(vs_byte_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1228 if (!new_entry->initialize()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1229 delete new_entry;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1230 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1231 } else {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1232 assert(new_entry->reserved_words() == vs_word_size,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1233 "Reserved memory size differs from requested memory size");
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1234 // ensure lock-free iteration sees fully initialized node
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	1235 OrderAccess::storestore();
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1236 link_vs(new_entry);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1237 return true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1238 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1239 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1240
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1241 void VirtualSpaceList::link_vs(VirtualSpaceNode* new_entry) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1242 if (virtual_space_list() == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1243 set_virtual_space_list(new_entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1244 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1245 current_virtual_space()->set_next(new_entry);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1246 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1247 set_current_virtual_space(new_entry);
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1248 inc_reserved_words(new_entry->reserved_words());
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1249 inc_committed_words(new_entry->committed_words());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1250 inc_virtual_space_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1251 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1252 new_entry->mangle();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1253 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1254 if (TraceMetavirtualspaceAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1255 VirtualSpaceNode* vsl = current_virtual_space();
12240 8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1256 vsl->print_on(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1257 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1258 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1259
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1260 bool VirtualSpaceList::expand_node_by(VirtualSpaceNode* node,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1261 size_t min_words,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1262 size_t preferred_words) {
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1263 size_t before = node->committed_words();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1264
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1265 bool result = node->expand_by(min_words, preferred_words);
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1266
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1267 size_t after = node->committed_words();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1268
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1269 // after and before can be the same if the memory was pre-committed.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1270 assert(after >= before, "Inconsistency");
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1271 inc_committed_words(after - before);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1272
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1273 return result;
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1274 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	1275
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1276 bool VirtualSpaceList::expand_by(size_t min_words, size_t preferred_words) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1277 assert_is_size_aligned(min_words, Metaspace::commit_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1278 assert_is_size_aligned(preferred_words, Metaspace::commit_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1279 assert(min_words <= preferred_words, "Invalid arguments");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1280
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1281 if (!MetaspaceGC::can_expand(min_words, this->is_class())) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1282 return false;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1283 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1284
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1285 size_t allowed_expansion_words = MetaspaceGC::allowed_expansion();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1286 if (allowed_expansion_words < min_words) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1287 return false;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1288 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1289
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1290 size_t max_expansion_words = MIN2(preferred_words, allowed_expansion_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1291
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1292 // Commit more memory from the the current virtual space.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1293 bool vs_expanded = expand_node_by(current_virtual_space(),
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1294 min_words,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1295 max_expansion_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1296 if (vs_expanded) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1297 return true;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1298 }
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	1299 retire_current_virtual_space();
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1300
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1301 // Get another virtual space.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1302 size_t grow_vs_words = MAX2((size_t)VirtualSpaceSize, preferred_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1303 grow_vs_words = align_size_up(grow_vs_words, Metaspace::reserve_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1304
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1305 if (create_new_virtual_space(grow_vs_words)) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1306 if (current_virtual_space()->is_pre_committed()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1307 // The memory was pre-committed, so we are done here.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1308 assert(min_words <= current_virtual_space()->committed_words(),
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1309 "The new VirtualSpace was pre-committed, so it"
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1310 "should be large enough to fit the alloc request.");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1311 return true;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1312 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1313
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1314 return expand_node_by(current_virtual_space(),
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1315 min_words,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1316 max_expansion_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1317 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1318
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1319 return false;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1320 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1321
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1322 Metachunk* VirtualSpaceList::get_new_chunk(size_t word_size,
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1323 size_t grow_chunks_by_words,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1324 size_t medium_chunk_bunch) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1325
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1326 // Allocate a chunk out of the current virtual space.
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1327 Metachunk* next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1328
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1329 if (next != NULL) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1330 return next;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1331 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1332
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1333 // The expand amount is currently only determined by the requested sizes
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1334 // and not how much committed memory is left in the current virtual space.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1335
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1336 size_t min_word_size = align_size_up(grow_chunks_by_words, Metaspace::commit_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1337 size_t preferred_word_size = align_size_up(medium_chunk_bunch, Metaspace::commit_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1338 if (min_word_size >= preferred_word_size) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1339 // Can happen when humongous chunks are allocated.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1340 preferred_word_size = min_word_size;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1341 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1342
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1343 bool expanded = expand_by(min_word_size, preferred_word_size);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1344 if (expanded) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1345 next = current_virtual_space()->get_chunk_vs(grow_chunks_by_words);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1346 assert(next != NULL, "The allocation was expected to succeed after the expansion");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1347 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1348
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1349 return next;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1350 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1351
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1352 void VirtualSpaceList::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1353 if (TraceMetadataChunkAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1354 VirtualSpaceListIterator iter(virtual_space_list());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1355 while (iter.repeat()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1356 VirtualSpaceNode* node = iter.get_next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1357 node->print_on(st);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1358 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1359 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1360 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1361
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1362 // MetaspaceGC methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1363
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1364 // VM_CollectForMetadataAllocation is the vm operation used to GC.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1365 // Within the VM operation after the GC the attempt to allocate the metadata
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1366 // should succeed. If the GC did not free enough space for the metaspace
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1367 // allocation, the HWM is increased so that another virtualspace will be
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1368 // allocated for the metadata. With perm gen the increase in the perm
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1369 // gen had bounds, MinMetaspaceExpansion and MaxMetaspaceExpansion. The
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1370 // metaspace policy uses those as the small and large steps for the HWM.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1371 //
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1372 // After the GC the compute_new_size() for MetaspaceGC is called to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1373 // resize the capacity of the metaspaces. The current implementation
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1374 // is based on the flags MinMetaspaceFreeRatio and MaxMetaspaceFreeRatio used
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1375 // to resize the Java heap by some GC's. New flags can be implemented
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1376 // if really needed. MinMetaspaceFreeRatio is used to calculate how much
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1377 // free space is desirable in the metaspace capacity to decide how much
8040 a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8007 diff changeset	1378 // to increase the HWM. MaxMetaspaceFreeRatio is used to decide how much
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1379 // free space is desirable in the metaspace capacity before decreasing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1380 // the HWM.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1381
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1382 // Calculate the amount to increase the high water mark (HWM).
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1383 // Increase by a minimum amount (MinMetaspaceExpansion) so that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1384 // another expansion is not requested too soon. If that is not
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1385 // enough to satisfy the allocation, increase by MaxMetaspaceExpansion.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1386 // If that is still not enough, expand by the size of the allocation
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1387 // plus some.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1388 size_t MetaspaceGC::delta_capacity_until_GC(size_t bytes) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1389 size_t min_delta = MinMetaspaceExpansion;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1390 size_t max_delta = MaxMetaspaceExpansion;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1391 size_t delta = align_size_up(bytes, Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1392
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1393 if (delta <= min_delta) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1394 delta = min_delta;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1395 } else if (delta <= max_delta) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1396 // Don't want to hit the high water mark on the next
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1397 // allocation so make the delta greater than just enough
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1398 // for this allocation.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1399 delta = max_delta;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1400 } else {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1401 // This allocation is large but the next ones are probably not
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1402 // so increase by the minimum.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1403 delta = delta + min_delta;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1404 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1405
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1406 assert_is_size_aligned(delta, Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1407
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1408 return delta;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1409 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1410
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1411 size_t MetaspaceGC::capacity_until_GC() {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1412 size_t value = (size_t)OrderAccess::load_ptr_acquire(&_capacity_until_GC);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1413 assert(value >= MetaspaceSize, "Not initialied properly?");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1414 return value;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1415 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1416
20540 b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1417 bool MetaspaceGC::inc_capacity_until_GC(size_t v, size_t* new_cap_until_GC, size_t* old_cap_until_GC) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1418 assert_is_size_aligned(v, Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1419
20540 b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1420 size_t capacity_until_GC = (size_t) _capacity_until_GC;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1421 size_t new_value = capacity_until_GC + v;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1422
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1423 if (new_value < capacity_until_GC) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1424 // The addition wrapped around, set new_value to aligned max value.
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1425 new_value = align_size_down(max_uintx, Metaspace::commit_alignment());
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1426 }
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1427
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1428 intptr_t expected = (intptr_t) capacity_until_GC;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1429 intptr_t actual = Atomic::cmpxchg_ptr((intptr_t) new_value, &_capacity_until_GC, expected);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1430
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1431 if (expected != actual) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1432 return false;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1433 }
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1434
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1435 if (new_cap_until_GC != NULL) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1436 *new_cap_until_GC = new_value;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1437 }
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1438 if (old_cap_until_GC != NULL) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1439 *old_cap_until_GC = capacity_until_GC;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1440 }
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1441 return true;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1442 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1443
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1444 size_t MetaspaceGC::dec_capacity_until_GC(size_t v) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1445 assert_is_size_aligned(v, Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1446
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1447 return (size_t)Atomic::add_ptr(-(intptr_t)v, &_capacity_until_GC);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1448 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1449
17979 e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1450 void MetaspaceGC::initialize() {
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1451 // Set the high-water mark to MaxMetapaceSize during VM initializaton since
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1452 // we can't do a GC during initialization.
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1453 _capacity_until_GC = MaxMetaspaceSize;
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1454 }
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1455
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1456 void MetaspaceGC::post_initialize() {
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1457 // Reset the high-water mark once the VM initialization is done.
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1458 _capacity_until_GC = MAX2(MetaspaceAux::committed_bytes(), MetaspaceSize);
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1459 }
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1460
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1461 bool MetaspaceGC::can_expand(size_t word_size, bool is_class) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1462 // Check if the compressed class space is full.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1463 if (is_class && Metaspace::using_class_space()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1464 size_t class_committed = MetaspaceAux::committed_bytes(Metaspace::ClassType);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1465 if (class_committed + word_size * BytesPerWord > CompressedClassSpaceSize) {
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	1466 return false;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	1467 }
8790 7f0cb32dd233 8004241: NPG: Metaspace occupies more memory than specified by -XX:MaxMetaspaceSize option mgerdin parents: 8786 diff changeset	1468 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1469
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1470 // Check if the user has imposed a limit on the metaspace memory.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1471 size_t committed_bytes = MetaspaceAux::committed_bytes();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1472 if (committed_bytes + word_size * BytesPerWord > MaxMetaspaceSize) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1473 return false;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1474 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1475
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1476 return true;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1477 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1478
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1479 size_t MetaspaceGC::allowed_expansion() {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1480 size_t committed_bytes = MetaspaceAux::committed_bytes();
17979 e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1481 size_t capacity_until_gc = capacity_until_GC();
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1482
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1483 assert(capacity_until_gc >= committed_bytes,
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1484 err_msg("capacity_until_gc: " SIZE_FORMAT " < committed_bytes: " SIZE_FORMAT,
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1485 capacity_until_gc, committed_bytes));
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1486
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1487 size_t left_until_max = MaxMetaspaceSize - committed_bytes;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1488 size_t left_until_GC = capacity_until_gc - committed_bytes;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1489 size_t left_to_commit = MIN2(left_until_GC, left_until_max);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1490
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1491 return left_to_commit / BytesPerWord;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1492 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1493
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1494 void MetaspaceGC::compute_new_size() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1495 assert(_shrink_factor <= 100, "invalid shrink factor");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1496 uint current_shrink_factor = _shrink_factor;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1497 _shrink_factor = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1498
17979 e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1499 // Using committed_bytes() for used_after_gc is an overestimation, since the
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1500 // chunk free lists are included in committed_bytes() and the memory in an
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1501 // un-fragmented chunk free list is available for future allocations.
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1502 // However, if the chunk free lists becomes fragmented, then the memory may
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1503 // not be available for future allocations and the memory is therefore "in use".
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1504 // Including the chunk free lists in the definition of "in use" is therefore
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1505 // necessary. Not including the chunk free lists can cause capacity_until_GC to
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1506 // shrink below committed_bytes() and this has caused serious bugs in the past.
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	1507 const size_t used_after_gc = MetaspaceAux::committed_bytes();
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1508 const size_t capacity_until_GC = MetaspaceGC::capacity_until_GC();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1509
8040 a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8007 diff changeset	1510 const double minimum_free_percentage = MinMetaspaceFreeRatio / 100.0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1511 const double maximum_used_percentage = 1.0 - minimum_free_percentage;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1512
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1513 const double min_tmp = used_after_gc / maximum_used_percentage;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1514 size_t minimum_desired_capacity =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1515 (size_t)MIN2(min_tmp, double(max_uintx));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1516 // Don't shrink less than the initial generation size
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1517 minimum_desired_capacity = MAX2(minimum_desired_capacity,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1518 MetaspaceSize);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1519
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1520 if (PrintGCDetails && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1521 gclog_or_tty->print_cr("\nMetaspaceGC::compute_new_size: ");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1522 gclog_or_tty->print_cr(" "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1523 " minimum_free_percentage: %6.2f"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1524 " maximum_used_percentage: %6.2f",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1525 minimum_free_percentage,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1526 maximum_used_percentage);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1527 gclog_or_tty->print_cr(" "
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1528 " used_after_gc : %6.1fKB",
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1529 used_after_gc / (double) K);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1530 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1531
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1532
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1533 size_t shrink_bytes = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1534 if (capacity_until_GC < minimum_desired_capacity) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1535 // If we have less capacity below the metaspace HWM, then
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1536 // increment the HWM.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1537 size_t expand_bytes = minimum_desired_capacity - capacity_until_GC;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1538 expand_bytes = align_size_up(expand_bytes, Metaspace::commit_alignment());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1539 // Don't expand unless it's significant
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1540 if (expand_bytes >= MinMetaspaceExpansion) {
20540 b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1541 size_t new_capacity_until_GC = 0;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1542 bool succeeded = MetaspaceGC::inc_capacity_until_GC(expand_bytes, &new_capacity_until_GC);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1543 assert(succeeded, "Should always succesfully increment HWM when at safepoint");
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	1544
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1545 Metaspace::tracer()->report_gc_threshold(capacity_until_GC,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1546 new_capacity_until_GC,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1547 MetaspaceGCThresholdUpdater::ComputeNewSize);
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1548 if (PrintGCDetails && Verbose) {
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1549 gclog_or_tty->print_cr(" expanding:"
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1550 " minimum_desired_capacity: %6.1fKB"
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1551 " expand_bytes: %6.1fKB"
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1552 " MinMetaspaceExpansion: %6.1fKB"
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1553 " new metaspace HWM: %6.1fKB",
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1554 minimum_desired_capacity / (double) K,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1555 expand_bytes / (double) K,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1556 MinMetaspaceExpansion / (double) K,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1557 new_capacity_until_GC / (double) K);
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1558 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1559 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1560 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1561 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1562
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1563 // No expansion, now see if we want to shrink
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1564 // We would never want to shrink more than this
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1565 size_t max_shrink_bytes = capacity_until_GC - minimum_desired_capacity;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1566 assert(max_shrink_bytes >= 0, err_msg("max_shrink_bytes " SIZE_FORMAT,
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1567 max_shrink_bytes));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1568
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1569 // Should shrinking be considered?
8040 a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8007 diff changeset	1570 if (MaxMetaspaceFreeRatio < 100) {
a83cd101fd62 8005452: NPG: Create new flags for Metaspace resizing policy jmasa parents: 8007 diff changeset	1571 const double maximum_free_percentage = MaxMetaspaceFreeRatio / 100.0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1572 const double minimum_used_percentage = 1.0 - maximum_free_percentage;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1573 const double max_tmp = used_after_gc / minimum_used_percentage;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1574 size_t maximum_desired_capacity = (size_t)MIN2(max_tmp, double(max_uintx));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1575 maximum_desired_capacity = MAX2(maximum_desired_capacity,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1576 MetaspaceSize);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1577 if (PrintGCDetails && Verbose) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1578 gclog_or_tty->print_cr(" "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1579 " maximum_free_percentage: %6.2f"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1580 " minimum_used_percentage: %6.2f",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1581 maximum_free_percentage,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1582 minimum_used_percentage);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1583 gclog_or_tty->print_cr(" "
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1584 " minimum_desired_capacity: %6.1fKB"
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1585 " maximum_desired_capacity: %6.1fKB",
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1586 minimum_desired_capacity / (double) K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1587 maximum_desired_capacity / (double) K);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1588 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1589
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1590 assert(minimum_desired_capacity <= maximum_desired_capacity,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1591 "sanity check");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1592
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1593 if (capacity_until_GC > maximum_desired_capacity) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1594 // Capacity too large, compute shrinking size
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1595 shrink_bytes = capacity_until_GC - maximum_desired_capacity;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1596 // We don't want shrink all the way back to initSize if people call
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1597 // System.gc(), because some programs do that between "phases" and then
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1598 // we'd just have to grow the heap up again for the next phase. So we
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1599 // damp the shrinking: 0% on the first call, 10% on the second call, 40%
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1600 // on the third call, and 100% by the fourth call. But if we recompute
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1601 // size without shrinking, it goes back to 0%.
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1602 shrink_bytes = shrink_bytes / 100 * current_shrink_factor;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1603
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1604 shrink_bytes = align_size_down(shrink_bytes, Metaspace::commit_alignment());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1605
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1606 assert(shrink_bytes <= max_shrink_bytes,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1607 err_msg("invalid shrink size " SIZE_FORMAT " not <= " SIZE_FORMAT,
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1608 shrink_bytes, max_shrink_bytes));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1609 if (current_shrink_factor == 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1610 _shrink_factor = 10;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1611 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1612 _shrink_factor = MIN2(current_shrink_factor * 4, (uint) 100);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1613 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1614 if (PrintGCDetails && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1615 gclog_or_tty->print_cr(" "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1616 " shrinking:"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1617 " initSize: %.1fK"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1618 " maximum_desired_capacity: %.1fK",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1619 MetaspaceSize / (double) K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1620 maximum_desired_capacity / (double) K);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1621 gclog_or_tty->print_cr(" "
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1622 " shrink_bytes: %.1fK"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1623 " current_shrink_factor: %d"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1624 " new shrink factor: %d"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1625 " MinMetaspaceExpansion: %.1fK",
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1626 shrink_bytes / (double) K,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1627 current_shrink_factor,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1628 _shrink_factor,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1629 MinMetaspaceExpansion / (double) K);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1630 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1631 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1632 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1633
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1634 // Don't shrink unless it's significant
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1635 if (shrink_bytes >= MinMetaspaceExpansion &&
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1636 ((capacity_until_GC - shrink_bytes) >= MetaspaceSize)) {
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1637 size_t new_capacity_until_GC = MetaspaceGC::dec_capacity_until_GC(shrink_bytes);
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1638 Metaspace::tracer()->report_gc_threshold(capacity_until_GC,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1639 new_capacity_until_GC,
daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	1640 MetaspaceGCThresholdUpdater::ComputeNewSize);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1641 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1642 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1643
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1644 // Metadebug methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1645
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1646 void Metadebug::init_allocation_fail_alot_count() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1647 if (MetadataAllocationFailALot) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1648 _allocation_fail_alot_count =
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1649 1+(long)((double)MetadataAllocationFailALotInterval*os::random()/(max_jint+1.0));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1650 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1651 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1652
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1653 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1654 bool Metadebug::test_metadata_failure() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1655 if (MetadataAllocationFailALot &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1656 Threads::is_vm_complete()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1657 if (_allocation_fail_alot_count > 0) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1658 _allocation_fail_alot_count--;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1659 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1660 if (TraceMetadataChunkAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1661 gclog_or_tty->print_cr("Metadata allocation failing for "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1662 "MetadataAllocationFailALot");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1663 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1664 init_allocation_fail_alot_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1665 return true;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1666 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1667 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1668 return false;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1669 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1670 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1671
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1672 // ChunkManager methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1673
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	1674 size_t ChunkManager::free_chunks_total_words() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1675 return _free_chunks_total;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1676 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1677
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	1678 size_t ChunkManager::free_chunks_total_bytes() {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	1679 return free_chunks_total_words() * BytesPerWord;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1680 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1681
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1682 size_t ChunkManager::free_chunks_count() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1683 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1684 if (!UseConcMarkSweepGC && !SpaceManager::expand_lock()->is_locked()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1685 MutexLockerEx cl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1686 Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1687 // This lock is only needed in debug because the verification
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1688 // of the _free_chunks_totals walks the list of free chunks
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1689 slow_locked_verify_free_chunks_count();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1690 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1691 #endif
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1692 return _free_chunks_count;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1693 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1694
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1695 void ChunkManager::locked_verify_free_chunks_total() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1696 assert_lock_strong(SpaceManager::expand_lock());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1697 assert(sum_free_chunks() == _free_chunks_total,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1698 err_msg("_free_chunks_total " SIZE_FORMAT " is not the"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1699 " same as sum " SIZE_FORMAT, _free_chunks_total,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1700 sum_free_chunks()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1701 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1702
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1703 void ChunkManager::verify_free_chunks_total() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1704 MutexLockerEx cl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1705 Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1706 locked_verify_free_chunks_total();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1707 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1708
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1709 void ChunkManager::locked_verify_free_chunks_count() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1710 assert_lock_strong(SpaceManager::expand_lock());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1711 assert(sum_free_chunks_count() == _free_chunks_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1712 err_msg("_free_chunks_count " SIZE_FORMAT " is not the"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1713 " same as sum " SIZE_FORMAT, _free_chunks_count,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1714 sum_free_chunks_count()));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1715 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1716
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1717 void ChunkManager::verify_free_chunks_count() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1718 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1719 MutexLockerEx cl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1720 Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1721 locked_verify_free_chunks_count();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1722 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1723 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1724
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1725 void ChunkManager::verify() {
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1726 MutexLockerEx cl(SpaceManager::expand_lock(),
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1727 Mutex::_no_safepoint_check_flag);
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1728 locked_verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1729 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1730
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1731 void ChunkManager::locked_verify() {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1732 locked_verify_free_chunks_count();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1733 locked_verify_free_chunks_total();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1734 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1735
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1736 void ChunkManager::locked_print_free_chunks(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1737 assert_lock_strong(SpaceManager::expand_lock());
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1738 st->print_cr("Free chunk total " SIZE_FORMAT " count " SIZE_FORMAT,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1739 _free_chunks_total, _free_chunks_count);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1740 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1741
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1742 void ChunkManager::locked_print_sum_free_chunks(outputStream* st) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1743 assert_lock_strong(SpaceManager::expand_lock());
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1744 st->print_cr("Sum free chunk total " SIZE_FORMAT " count " SIZE_FORMAT,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1745 sum_free_chunks(), sum_free_chunks_count());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1746 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1747 ChunkList* ChunkManager::free_chunks(ChunkIndex index) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1748 return &_free_chunks[index];
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1749 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1750
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1751 // These methods that sum the free chunk lists are used in printing
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1752 // methods that are used in product builds.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1753 size_t ChunkManager::sum_free_chunks() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1754 assert_lock_strong(SpaceManager::expand_lock());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1755 size_t result = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1756 for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1757 ChunkList* list = free_chunks(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1758
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1759 if (list == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1760 continue;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1761 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1762
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	1763 result = result + list->count() * list->size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1764 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1765 result = result + humongous_dictionary()->total_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1766 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1767 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1768
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1769 size_t ChunkManager::sum_free_chunks_count() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1770 assert_lock_strong(SpaceManager::expand_lock());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1771 size_t count = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1772 for (ChunkIndex i = ZeroIndex; i < NumberOfFreeLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1773 ChunkList* list = free_chunks(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1774 if (list == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1775 continue;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1776 }
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	1777 count = count + list->count();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1778 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1779 count = count + humongous_dictionary()->total_free_blocks();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1780 return count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1781 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1782
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1783 ChunkList* ChunkManager::find_free_chunks_list(size_t word_size) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1784 ChunkIndex index = list_index(word_size);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1785 assert(index < HumongousIndex, "No humongous list");
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1786 return free_chunks(index);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1787 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1788
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1789 Metachunk* ChunkManager::free_chunks_get(size_t word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1790 assert_lock_strong(SpaceManager::expand_lock());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1791
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1792 slow_locked_verify();
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1793
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1794 Metachunk* chunk = NULL;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1795 if (list_index(word_size) != HumongousIndex) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1796 ChunkList* free_list = find_free_chunks_list(word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1797 assert(free_list != NULL, "Sanity check");
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1798
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1799 chunk = free_list->head();
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1800
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1801 if (chunk == NULL) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1802 return NULL;
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1803 }
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1804
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1805 // Remove the chunk as the head of the list.
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	1806 free_list->remove_chunk(chunk);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1807
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1808 if (TraceMetadataChunkAllocation && Verbose) {
12240 8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1809 gclog_or_tty->print_cr("ChunkManager::free_chunks_get: free_list "
8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1810 PTR_FORMAT " head " PTR_FORMAT " size " SIZE_FORMAT,
8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1811 free_list, chunk, chunk->word_size());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1812 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1813 } else {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1814 chunk = humongous_dictionary()->get_chunk(
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1815 word_size,
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1816 FreeBlockDictionary<Metachunk>::atLeast);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1817
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1818 if (chunk == NULL) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1819 return NULL;
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1820 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1821
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1822 if (TraceMetadataHumongousAllocation) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1823 size_t waste = chunk->word_size() - word_size;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1824 gclog_or_tty->print_cr("Free list allocate humongous chunk size "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1825 SIZE_FORMAT " for requested size " SIZE_FORMAT
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1826 " waste " SIZE_FORMAT,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1827 chunk->word_size(), word_size, waste);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1828 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1829 }
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1830
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1831 // Chunk is being removed from the chunks free list.
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	1832 dec_free_chunks_total(chunk->word_size());
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	1833
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1834 // Remove it from the links to this freelist
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1835 chunk->set_next(NULL);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1836 chunk->set_prev(NULL);
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1837 #ifdef ASSERT
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1838 // Chunk is no longer on any freelist. Setting to false make container_count_slow()
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1839 // work.
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	1840 chunk->set_is_tagged_free(false);
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	1841 #endif
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1842 chunk->container()->inc_container_count();
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1843
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1844 slow_locked_verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1845 return chunk;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1846 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1847
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1848 Metachunk* ChunkManager::chunk_freelist_allocate(size_t word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1849 assert_lock_strong(SpaceManager::expand_lock());
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	1850 slow_locked_verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1851
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1852 // Take from the beginning of the list
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1853 Metachunk* chunk = free_chunks_get(word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1854 if (chunk == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1855 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1856 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1857
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1858 assert((word_size <= chunk->word_size()) \|\|
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1859 list_index(chunk->word_size() == HumongousIndex),
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1860 "Non-humongous variable sized chunk");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1861 if (TraceMetadataChunkAllocation) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1862 size_t list_count;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1863 if (list_index(word_size) < HumongousIndex) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1864 ChunkList* list = find_free_chunks_list(word_size);
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	1865 list_count = list->count();
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1866 } else {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1867 list_count = humongous_dictionary()->total_count();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1868 }
12240 8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1869 gclog_or_tty->print("ChunkManager::chunk_freelist_allocate: " PTR_FORMAT " chunk "
8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1870 PTR_FORMAT " size " SIZE_FORMAT " count " SIZE_FORMAT " ",
8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1871 this, chunk, chunk->word_size(), list_count);
8c5e6482cbfc 8024752: Log TraceMetadata* output to gclog_or_tty instead of tty stefank parents: 12239 diff changeset	1872 locked_print_free_chunks(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1873 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1874
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1875 return chunk;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1876 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1877
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1878 void ChunkManager::print_on(outputStream* out) const {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1879 if (PrintFLSStatistics != 0) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	1880 const_cast<ChunkManager *>(this)->humongous_dictionary()->report_statistics();
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1881 }
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1882 }
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1883
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1884 // SpaceManager methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1885
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1886 void SpaceManager::get_initial_chunk_sizes(Metaspace::MetaspaceType type,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1887 size_t* chunk_word_size,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1888 size_t* class_chunk_word_size) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1889 switch (type) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1890 case Metaspace::BootMetaspaceType:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1891 *chunk_word_size = Metaspace::first_chunk_word_size();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1892 *class_chunk_word_size = Metaspace::first_class_chunk_word_size();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1893 break;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1894 case Metaspace::ROMetaspaceType:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1895 *chunk_word_size = SharedReadOnlySize / wordSize;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1896 *class_chunk_word_size = ClassSpecializedChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1897 break;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1898 case Metaspace::ReadWriteMetaspaceType:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1899 *chunk_word_size = SharedReadWriteSize / wordSize;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1900 *class_chunk_word_size = ClassSpecializedChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1901 break;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1902 case Metaspace::AnonymousMetaspaceType:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1903 case Metaspace::ReflectionMetaspaceType:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1904 *chunk_word_size = SpecializedChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1905 *class_chunk_word_size = ClassSpecializedChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1906 break;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1907 default:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1908 *chunk_word_size = SmallChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1909 *class_chunk_word_size = ClassSmallChunk;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1910 break;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1911 }
8007 d9058e388631 8007257: NPG: metaspace.cpp: Incorrect arguments in calls to err_msg mikael parents: 7447 diff changeset	1912 assert(chunk_word_size != 0 && class_chunk_word_size != 0,
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1913 err_msg("Initial chunks sizes bad: data " SIZE_FORMAT
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1914 " class " SIZE_FORMAT,
8007 d9058e388631 8007257: NPG: metaspace.cpp: Incorrect arguments in calls to err_msg mikael parents: 7447 diff changeset	1915 chunk_word_size, class_chunk_word_size));
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1916 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1917
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1918 size_t SpaceManager::sum_free_in_chunks_in_use() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1919 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1920 size_t free = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1921 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1922 Metachunk* chunk = chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1923 while (chunk != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1924 free += chunk->free_word_size();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1925 chunk = chunk->next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1926 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1927 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1928 return free;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1929 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1930
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1931 size_t SpaceManager::sum_waste_in_chunks_in_use() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1932 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1933 size_t result = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1934 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1935 result += sum_waste_in_chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1936 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1937
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1938 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1939 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1940
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1941 size_t SpaceManager::sum_waste_in_chunks_in_use(ChunkIndex index) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1942 size_t result = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1943 Metachunk* chunk = chunks_in_use(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1944 // Count the free space in all the chunk but not the
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1945 // current chunk from which allocations are still being done.
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	1946 while (chunk != NULL) {
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	1947 if (chunk != current_chunk()) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1948 result += chunk->free_word_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1949 }
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	1950 chunk = chunk->next();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1951 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1952 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1953 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1954
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1955 size_t SpaceManager::sum_capacity_in_chunks_in_use() const {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1956 // For CMS use "allocated_chunks_words()" which does not need the
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1957 // Metaspace lock. For the other collectors sum over the
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1958 // lists. Use both methods as a check that "allocated_chunks_words()"
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1959 // is correct. That is, sum_capacity_in_chunks() is too expensive
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1960 // to use in the product and allocated_chunks_words() should be used
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1961 // but allow for checking that allocated_chunks_words() returns the same
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1962 // value as sum_capacity_in_chunks_in_use() which is the definitive
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1963 // answer.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1964 if (UseConcMarkSweepGC) {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1965 return allocated_chunks_words();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1966 } else {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1967 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1968 size_t sum = 0;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1969 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1970 Metachunk* chunk = chunks_in_use(i);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1971 while (chunk != NULL) {
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	1972 sum += chunk->word_size();
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1973 chunk = chunk->next();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1974 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1975 }
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	1976 return sum;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1977 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1978 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1979
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1980 size_t SpaceManager::sum_count_in_chunks_in_use() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1981 size_t count = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	1982 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1983 count = count + sum_count_in_chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1984 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	1985
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1986 return count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1987 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1988
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1989 size_t SpaceManager::sum_count_in_chunks_in_use(ChunkIndex i) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1990 size_t count = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1991 Metachunk* chunk = chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1992 while (chunk != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1993 count++;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1994 chunk = chunk->next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1995 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1996 return count;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1997 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1998
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	1999
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2000 size_t SpaceManager::sum_used_in_chunks_in_use() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2001 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2002 size_t used = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2003 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2004 Metachunk* chunk = chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2005 while (chunk != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2006 used += chunk->used_word_size();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2007 chunk = chunk->next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2008 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2009 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2010 return used;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2011 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2012
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2013 void SpaceManager::locked_print_chunks_in_use_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2014
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2015 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2016 Metachunk* chunk = chunks_in_use(i);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2017 st->print("SpaceManager: %s " PTR_FORMAT,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2018 chunk_size_name(i), chunk);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2019 if (chunk != NULL) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2020 st->print_cr(" free " SIZE_FORMAT,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2021 chunk->free_word_size());
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2022 } else {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17935 diff changeset	2023 st->cr();
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2024 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2025 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2026
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2027 chunk_manager()->locked_print_free_chunks(st);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2028 chunk_manager()->locked_print_sum_free_chunks(st);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2029 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2030
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2031 size_t SpaceManager::calc_chunk_size(size_t word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2032
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2033 // Decide between a small chunk and a medium chunk. Up to
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2034 // _small_chunk_limit small chunks can be allocated but
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2035 // once a medium chunk has been allocated, no more small
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2036 // chunks will be allocated.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2037 size_t chunk_word_size;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2038 if (chunks_in_use(MediumIndex) == NULL &&
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2039 sum_count_in_chunks_in_use(SmallIndex) < _small_chunk_limit) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2040 chunk_word_size = (size_t) small_chunk_size();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2041 if (word_size + Metachunk::overhead() > small_chunk_size()) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2042 chunk_word_size = medium_chunk_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2043 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2044 } else {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2045 chunk_word_size = medium_chunk_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2046 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2047
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2048 // Might still need a humongous chunk. Enforce
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2049 // humongous allocations sizes to be aligned up to
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2050 // the smallest chunk size.
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2051 size_t if_humongous_sized_chunk =
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2052 align_size_up(word_size + Metachunk::overhead(),
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2053 smallest_chunk_size());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2054 chunk_word_size =
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2055 MAX2((size_t) chunk_word_size, if_humongous_sized_chunk);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2056
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2057 assert(!SpaceManager::is_humongous(word_size) \|\|
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2058 chunk_word_size == if_humongous_sized_chunk,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2059 err_msg("Size calculation is wrong, word_size " SIZE_FORMAT
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2060 " chunk_word_size " SIZE_FORMAT,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2061 word_size, chunk_word_size));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2062 if (TraceMetadataHumongousAllocation &&
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2063 SpaceManager::is_humongous(word_size)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2064 gclog_or_tty->print_cr("Metadata humongous allocation:");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2065 gclog_or_tty->print_cr(" word_size " PTR_FORMAT, word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2066 gclog_or_tty->print_cr(" chunk_word_size " PTR_FORMAT,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2067 chunk_word_size);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2068 gclog_or_tty->print_cr(" chunk overhead " PTR_FORMAT,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2069 Metachunk::overhead());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2070 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2071 return chunk_word_size;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2072 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2073
12839 a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2074 void SpaceManager::track_metaspace_memory_usage() {
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2075 if (is_init_completed()) {
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2076 if (is_class()) {
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2077 MemoryService::track_compressed_class_memory_usage();
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2078 }
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2079 MemoryService::track_metaspace_memory_usage();
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2080 }
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2081 }
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2082
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2083 MetaWord* SpaceManager::grow_and_allocate(size_t word_size) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2084 assert(vs_list()->current_virtual_space() != NULL,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2085 "Should have been set");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2086 assert(current_chunk() == NULL \|\|
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2087 current_chunk()->allocate(word_size) == NULL,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2088 "Don't need to expand");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2089 MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2090
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2091 if (TraceMetadataChunkAllocation && Verbose) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2092 size_t words_left = 0;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2093 size_t words_used = 0;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2094 if (current_chunk() != NULL) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2095 words_left = current_chunk()->free_word_size();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2096 words_used = current_chunk()->used_word_size();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2097 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2098 gclog_or_tty->print_cr("SpaceManager::grow_and_allocate for " SIZE_FORMAT
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2099 " words " SIZE_FORMAT " words used " SIZE_FORMAT
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2100 " words left",
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2101 word_size, words_used, words_left);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2102 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2103
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2104 // Get another chunk out of the virtual space
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2105 size_t grow_chunks_by_words = calc_chunk_size(word_size);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2106 Metachunk* next = get_new_chunk(word_size, grow_chunks_by_words);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2107
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2108 MetaWord* mem = NULL;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2109
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2110 // If a chunk was available, add it to the in-use chunk list
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2111 // and do an allocation from it.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2112 if (next != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2113 // Add to this manager's list of chunks in use.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2114 add_chunk(next, false);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2115 mem = next->allocate(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2116 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2117
12839 a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2118 // Track metaspace memory usage statistic.
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2119 track_metaspace_memory_usage();
a6414751d537 8025996: Track metaspace usage when metaspace is expanded stefank parents: 12838 diff changeset	2120
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2121 return mem;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2122 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2123
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2124 void SpaceManager::print_on(outputStream* st) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2125
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2126 for (ChunkIndex i = ZeroIndex;
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2127 i < NumberOfInUseLists ;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2128 i = next_chunk_index(i) ) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2129 st->print_cr(" chunks_in_use " PTR_FORMAT " chunk size " PTR_FORMAT,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2130 chunks_in_use(i),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2131 chunks_in_use(i) == NULL ? 0 : chunks_in_use(i)->word_size());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2132 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2133 st->print_cr(" waste: Small " SIZE_FORMAT " Medium " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2134 " Humongous " SIZE_FORMAT,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2135 sum_waste_in_chunks_in_use(SmallIndex),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2136 sum_waste_in_chunks_in_use(MediumIndex),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2137 sum_waste_in_chunks_in_use(HumongousIndex));
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2138 // block free lists
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2139 if (block_freelists() != NULL) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2140 st->print_cr("total in block free lists " SIZE_FORMAT,
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2141 block_freelists()->total_size());
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2142 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2143 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2144
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2145 SpaceManager::SpaceManager(Metaspace::MetadataType mdtype,
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2146 Mutex* lock) :
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2147 _mdtype(mdtype),
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2148 _allocated_blocks_words(0),
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2149 _allocated_chunks_words(0),
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2150 _allocated_chunks_count(0),
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2151 _lock(lock)
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2152 {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2153 initialize();
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2154 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2155
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2156 void SpaceManager::inc_size_metrics(size_t words) {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2157 assert_lock_strong(SpaceManager::expand_lock());
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2158 // Total of allocated Metachunks and allocated Metachunks count
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2159 // for each SpaceManager
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2160 _allocated_chunks_words = _allocated_chunks_words + words;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2161 _allocated_chunks_count++;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2162 // Global total of capacity in allocated Metachunks
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2163 MetaspaceAux::inc_capacity(mdtype(), words);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2164 // Global total of allocated Metablocks.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2165 // used_words_slow() includes the overhead in each
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2166 // Metachunk so include it in the used when the
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2167 // Metachunk is first added (so only added once per
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2168 // Metachunk).
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2169 MetaspaceAux::inc_used(mdtype(), Metachunk::overhead());
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2170 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2171
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2172 void SpaceManager::inc_used_metrics(size_t words) {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2173 // Add to the per SpaceManager total
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2174 Atomic::add_ptr(words, &_allocated_blocks_words);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2175 // Add to the global total
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2176 MetaspaceAux::inc_used(mdtype(), words);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2177 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2178
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2179 void SpaceManager::dec_total_from_size_metrics() {
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2180 MetaspaceAux::dec_capacity(mdtype(), allocated_chunks_words());
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2181 MetaspaceAux::dec_used(mdtype(), allocated_blocks_words());
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2182 // Also deduct the overhead per Metachunk
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2183 MetaspaceAux::dec_used(mdtype(), allocated_chunks_count() * Metachunk::overhead());
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2184 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2185
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2186 void SpaceManager::initialize() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2187 Metadebug::init_allocation_fail_alot_count();
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2188 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2189 _chunks_in_use[i] = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2190 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2191 _current_chunk = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2192 if (TraceMetadataChunkAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2193 gclog_or_tty->print_cr("SpaceManager(): " PTR_FORMAT, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2194 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2195 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2196
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2197 void ChunkManager::return_chunks(ChunkIndex index, Metachunk* chunks) {
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2198 if (chunks == NULL) {
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2199 return;
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2200 }
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2201 ChunkList* list = free_chunks(index);
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2202 assert(list->size() == chunks->word_size(), "Mismatch in chunk sizes");
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2203 assert_lock_strong(SpaceManager::expand_lock());
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2204 Metachunk* cur = chunks;
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2205
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2206 // This returns chunks one at a time. If a new
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2207 // class List can be created that is a base class
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2208 // of FreeList then something like FreeList::prepend()
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2209 // can be used in place of this loop
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2210 while (cur != NULL) {
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2211 assert(cur->container() != NULL, "Container should have been set");
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2212 cur->container()->dec_container_count();
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2213 // Capture the next link before it is changed
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2214 // by the call to return_chunk_at_head();
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2215 Metachunk* next = cur->next();
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	2216 DEBUG_ONLY(cur->set_is_tagged_free(true);)
10101 df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2217 list->return_chunk_at_head(cur);
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2218 cur = next;
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2219 }
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2220 }
df254344edf1 8011173: NPG: Replace the ChunkList implementation with class FreeList<Metachunk> jmasa parents: 8813 diff changeset	2221
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2222 SpaceManager::~SpaceManager() {
8784 79af1312fc2c 8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used mgerdin parents: 8738 diff changeset	2223 // This call this->_lock which can't be done while holding expand_lock()
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2224 assert(sum_capacity_in_chunks_in_use() == allocated_chunks_words(),
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2225 err_msg("sum_capacity_in_chunks_in_use() " SIZE_FORMAT
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2226 " allocated_chunks_words() " SIZE_FORMAT,
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2227 sum_capacity_in_chunks_in_use(), allocated_chunks_words()));
8784 79af1312fc2c 8005602: NPG: classunloading does not happen while CMS GC with -XX:+CMSClassUnloadingEnabled is used mgerdin parents: 8738 diff changeset	2228
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2229 MutexLockerEx fcl(SpaceManager::expand_lock(),
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2230 Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2231
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2232 chunk_manager()->slow_locked_verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2233
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2234 dec_total_from_size_metrics();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2235
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2236 if (TraceMetadataChunkAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2237 gclog_or_tty->print_cr("~SpaceManager(): " PTR_FORMAT, this);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2238 locked_print_chunks_in_use_on(gclog_or_tty);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2239 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2240
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2241 // Do not mangle freed Metachunks. The chunk size inside Metachunks
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2242 // is during the freeing of a VirtualSpaceNodes.
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	2243
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2244 // Have to update before the chunks_in_use lists are emptied
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2245 // below.
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2246 chunk_manager()->inc_free_chunks_total(allocated_chunks_words(),
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2247 sum_count_in_chunks_in_use());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2248
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2249 // Add all the chunks in use by this space manager
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2250 // to the global list of free chunks.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2251
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2252 // Follow each list of chunks-in-use and add them to the
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2253 // free lists. Each list is NULL terminated.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2254
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2255 for (ChunkIndex i = ZeroIndex; i < HumongousIndex; i = next_chunk_index(i)) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2256 if (TraceMetadataChunkAllocation && Verbose) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2257 gclog_or_tty->print_cr("returned %d %s chunks to freelist",
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2258 sum_count_in_chunks_in_use(i),
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2259 chunk_size_name(i));
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2260 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2261 Metachunk* chunks = chunks_in_use(i);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2262 chunk_manager()->return_chunks(i, chunks);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2263 set_chunks_in_use(i, NULL);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2264 if (TraceMetadataChunkAllocation && Verbose) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2265 gclog_or_tty->print_cr("updated freelist count %d %s",
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2266 chunk_manager()->free_chunks(i)->count(),
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2267 chunk_size_name(i));
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2268 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2269 assert(i != HumongousIndex, "Humongous chunks are handled explicitly later");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2270 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2271
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2272 // The medium chunk case may be optimized by passing the head and
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2273 // tail of the medium chunk list to add_at_head(). The tail is often
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2274 // the current chunk but there are probably exceptions.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2275
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2276 // Humongous chunks
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2277 if (TraceMetadataChunkAllocation && Verbose) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2278 gclog_or_tty->print_cr("returned %d %s humongous chunks to dictionary",
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2279 sum_count_in_chunks_in_use(HumongousIndex),
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2280 chunk_size_name(HumongousIndex));
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2281 gclog_or_tty->print("Humongous chunk dictionary: ");
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2282 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2283 // Humongous chunks are never the current chunk.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2284 Metachunk* humongous_chunks = chunks_in_use(HumongousIndex);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2285
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2286 while (humongous_chunks != NULL) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2287 #ifdef ASSERT
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	2288 humongous_chunks->set_is_tagged_free(true);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2289 #endif
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2290 if (TraceMetadataChunkAllocation && Verbose) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2291 gclog_or_tty->print(PTR_FORMAT " (" SIZE_FORMAT ") ",
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2292 humongous_chunks,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2293 humongous_chunks->word_size());
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2294 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2295 assert(humongous_chunks->word_size() == (size_t)
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2296 align_size_up(humongous_chunks->word_size(),
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2297 smallest_chunk_size()),
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2298 err_msg("Humongous chunk size is wrong: word size " SIZE_FORMAT
8007 d9058e388631 8007257: NPG: metaspace.cpp: Incorrect arguments in calls to err_msg mikael parents: 7447 diff changeset	2299 " granularity %d",
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	2300 humongous_chunks->word_size(), smallest_chunk_size()));
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2301 Metachunk* next_humongous_chunks = humongous_chunks->next();
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	2302 humongous_chunks->container()->dec_container_count();
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2303 chunk_manager()->humongous_dictionary()->return_chunk(humongous_chunks);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2304 humongous_chunks = next_humongous_chunks;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2305 }
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2306 if (TraceMetadataChunkAllocation && Verbose) {
17937 78bbf4d43a14 8037816: Fix for 8036122 breaks build with Xcode5/clang drchase parents: 17935 diff changeset	2307 gclog_or_tty->cr();
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2308 gclog_or_tty->print_cr("updated dictionary count %d %s",
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2309 chunk_manager()->humongous_dictionary()->total_count(),
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2310 chunk_size_name(HumongousIndex));
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2311 }
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2312 chunk_manager()->slow_locked_verify();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2313 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2314
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2315 const char* SpaceManager::chunk_size_name(ChunkIndex index) const {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2316 switch (index) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2317 case SpecializedIndex:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2318 return "Specialized";
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2319 case SmallIndex:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2320 return "Small";
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2321 case MediumIndex:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2322 return "Medium";
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2323 case HumongousIndex:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2324 return "Humongous";
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2325 default:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2326 return NULL;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2327 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2328 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2329
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2330 ChunkIndex ChunkManager::list_index(size_t size) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2331 switch (size) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2332 case SpecializedChunk:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2333 assert(SpecializedChunk == ClassSpecializedChunk,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2334 "Need branch for ClassSpecializedChunk");
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2335 return SpecializedIndex;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2336 case SmallChunk:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2337 case ClassSmallChunk:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2338 return SmallIndex;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2339 case MediumChunk:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2340 case ClassMediumChunk:
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2341 return MediumIndex;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2342 default:
7447 1de1b145f6bc 8005486: NPG: Incorrect assertion in ChunkManager::list_index() jmasa parents: 7446 diff changeset	2343 assert(size > MediumChunk \|\| size > ClassMediumChunk,
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2344 "Not a humongous chunk");
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2345 return HumongousIndex;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2346 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2347 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2348
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2349 void SpaceManager::deallocate(MetaWord* p, size_t word_size) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2350 assert_lock_strong(_lock);
11966 83ca9dc4564d 8019845: Memory leak during class redefinition fparain parents: 11065 diff changeset	2351 size_t raw_word_size = get_raw_word_size(word_size);
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	2352 size_t min_size = TreeChunk<Metablock, FreeList<Metablock> >::min_size();
11966 83ca9dc4564d 8019845: Memory leak during class redefinition fparain parents: 11065 diff changeset	2353 assert(raw_word_size >= min_size,
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2354 err_msg("Should not deallocate dark matter " SIZE_FORMAT "<" SIZE_FORMAT, word_size, min_size));
11966 83ca9dc4564d 8019845: Memory leak during class redefinition fparain parents: 11065 diff changeset	2355 block_freelists()->return_block(p, raw_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2356 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2357
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2358 // Adds a chunk to the list of chunks in use.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2359 void SpaceManager::add_chunk(Metachunk* new_chunk, bool make_current) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2360
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2361 assert(new_chunk != NULL, "Should not be NULL");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2362 assert(new_chunk->next() == NULL, "Should not be on a list");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2363
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2364 new_chunk->reset_empty();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2365
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2366 // Find the correct list and and set the current
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2367 // chunk for that list.
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2368 ChunkIndex index = ChunkManager::list_index(new_chunk->word_size());
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2369
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2370 if (index != HumongousIndex) {
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2371 retire_current_chunk();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2372 set_current_chunk(new_chunk);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2373 new_chunk->set_next(chunks_in_use(index));
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2374 set_chunks_in_use(index, new_chunk);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2375 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2376 // For null class loader data and DumpSharedSpaces, the first chunk isn't
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2377 // small, so small will be null. Link this first chunk as the current
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2378 // chunk.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2379 if (make_current) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2380 // Set as the current chunk but otherwise treat as a humongous chunk.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2381 set_current_chunk(new_chunk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2382 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2383 // Link at head. The _current_chunk only points to a humongous chunk for
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2384 // the null class loader metaspace (class and data virtual space managers)
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2385 // any humongous chunks so will not point to the tail
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2386 // of the humongous chunks list.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2387 new_chunk->set_next(chunks_in_use(HumongousIndex));
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2388 set_chunks_in_use(HumongousIndex, new_chunk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2389
7447 1de1b145f6bc 8005486: NPG: Incorrect assertion in ChunkManager::list_index() jmasa parents: 7446 diff changeset	2390 assert(new_chunk->word_size() > medium_chunk_size(), "List inconsistency");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2391 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2392
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2393 // Add to the running sum of capacity
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2394 inc_size_metrics(new_chunk->word_size());
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2395
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2396 assert(new_chunk->is_empty(), "Not ready for reuse");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2397 if (TraceMetadataChunkAllocation && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2398 gclog_or_tty->print("SpaceManager::add_chunk: %d) ",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2399 sum_count_in_chunks_in_use());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2400 new_chunk->print_on(gclog_or_tty);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2401 chunk_manager()->locked_print_free_chunks(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2402 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2403 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2404
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2405 void SpaceManager::retire_current_chunk() {
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2406 if (current_chunk() != NULL) {
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2407 size_t remaining_words = current_chunk()->free_word_size();
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	2408 if (remaining_words >= TreeChunk<Metablock, FreeList<Metablock> >::min_size()) {
12231 24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2409 block_freelists()->return_block(current_chunk()->allocate(remaining_words), remaining_words);
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2410 inc_used_metrics(remaining_words);
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2411 }
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2412 }
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2413 }
24e87613ee58 8009561: NPG: Metaspace fragmentation when retiring a Metachunk mgerdin parents: 12226 diff changeset	2414
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2415 Metachunk* SpaceManager::get_new_chunk(size_t word_size,
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2416 size_t grow_chunks_by_words) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2417 // Get a chunk from the chunk freelist
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2418 Metachunk* next = chunk_manager()->chunk_freelist_allocate(grow_chunks_by_words);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2419
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2420 if (next == NULL) {
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2421 next = vs_list()->get_new_chunk(word_size,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2422 grow_chunks_by_words,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2423 medium_chunk_bunch());
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2424 }
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2425
12239 8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2426 if (TraceMetadataHumongousAllocation && next != NULL &&
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2427 SpaceManager::is_humongous(next->word_size())) {
12239 8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2428 gclog_or_tty->print_cr(" new humongous chunk word size "
8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2429 PTR_FORMAT, next->word_size());
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2430 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2431
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2432 return next;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2433 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2434
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2435 MetaWord* SpaceManager::allocate(size_t word_size) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2436 MutexLockerEx cl(lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2437
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	2438 size_t raw_word_size = get_raw_word_size(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2439 BlockFreelist* fl = block_freelists();
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2440 MetaWord* p = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2441 // Allocation from the dictionary is expensive in the sense that
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2442 // the dictionary has to be searched for a size. Don't allocate
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2443 // from the dictionary until it starts to get fat. Is this
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2444 // a reasonable policy? Maybe an skinny dictionary is fast enough
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2445 // for allocations. Do some profiling. JJJ
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2446 if (fl->total_size() > allocation_from_dictionary_limit) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2447 p = fl->get_block(raw_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2448 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2449 if (p == NULL) {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2450 p = allocate_work(raw_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2451 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2452
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2453 return p;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2454 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2455
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2456 // Returns the address of spaced allocated for "word_size".
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2457 // This methods does not know about blocks (Metablocks)
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2458 MetaWord* SpaceManager::allocate_work(size_t word_size) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2459 assert_lock_strong(_lock);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2460 #ifdef ASSERT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2461 if (Metadebug::test_metadata_failure()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2462 return NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2463 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2464 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2465 // Is there space in the current chunk?
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2466 MetaWord* result = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2467
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2468 // For DumpSharedSpaces, only allocate out of the current chunk which is
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2469 // never null because we gave it the size we wanted. Caller reports out
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2470 // of memory if this returns null.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2471 if (DumpSharedSpaces) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2472 assert(current_chunk() != NULL, "should never happen");
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2473 inc_used_metrics(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2474 return current_chunk()->allocate(word_size); // caller handles null result
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2475 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2476
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2477 if (current_chunk() != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2478 result = current_chunk()->allocate(word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2479 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2480
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2481 if (result == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2482 result = grow_and_allocate(word_size);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2483 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2484
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2485 if (result != NULL) {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2486 inc_used_metrics(word_size);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2487 assert(result != (MetaWord*) chunks_in_use(MediumIndex),
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2488 "Head of the list is being allocated");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2489 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2490
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2491 return result;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2492 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2493
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2494 void SpaceManager::verify() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2495 // If there are blocks in the dictionary, then
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2496 // verfication of chunks does not work since
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2497 // being in the dictionary alters a chunk.
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2498 if (block_freelists()->total_size() == 0) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2499 for (ChunkIndex i = ZeroIndex; i < NumberOfInUseLists; i = next_chunk_index(i)) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2500 Metachunk* curr = chunks_in_use(i);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2501 while (curr != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2502 curr->verify();
7208 eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2503 verify_chunk_size(curr);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2504 curr = curr->next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2505 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2506 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2507 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2508 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2509
7208 eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2510 void SpaceManager::verify_chunk_size(Metachunk* chunk) {
eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2511 assert(is_humongous(chunk->word_size()) \|\|
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2512 chunk->word_size() == medium_chunk_size() \|\|
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2513 chunk->word_size() == small_chunk_size() \|\|
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2514 chunk->word_size() == specialized_chunk_size(),
7208 eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2515 "Chunk size is wrong");
eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2516 return;
eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2517 }
eade6b2e4782 8003554: NPG: move Metablock and Metachunk code out of metaspace.cpp jmasa parents: 7187 diff changeset	2518
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2519 #ifdef ASSERT
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2520 void SpaceManager::verify_allocated_blocks_words() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2521 // Verification is only guaranteed at a safepoint.
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2522 assert(SafepointSynchronize::is_at_safepoint() \|\| !Universe::is_fully_initialized(),
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2523 "Verification can fail if the applications is running");
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2524 assert(allocated_blocks_words() == sum_used_in_chunks_in_use(),
8007 d9058e388631 8007257: NPG: metaspace.cpp: Incorrect arguments in calls to err_msg mikael parents: 7447 diff changeset	2525 err_msg("allocation total is not consistent " SIZE_FORMAT
d9058e388631 8007257: NPG: metaspace.cpp: Incorrect arguments in calls to err_msg mikael parents: 7447 diff changeset	2526 " vs " SIZE_FORMAT,
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2527 allocated_blocks_words(), sum_used_in_chunks_in_use()));
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2528 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2529
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2530 #endif
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2531
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2532 void SpaceManager::dump(outputStream* const out) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2533 size_t curr_total = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2534 size_t waste = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2535 uint i = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2536 size_t used = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2537 size_t capacity = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2538
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2539 // Add up statistics for all chunks in this SpaceManager.
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2540 for (ChunkIndex index = ZeroIndex;
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2541 index < NumberOfInUseLists;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2542 index = next_chunk_index(index)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2543 for (Metachunk* curr = chunks_in_use(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2544 curr != NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2545 curr = curr->next()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2546 out->print("%d) ", i++);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2547 curr->print_on(out);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2548 curr_total += curr->word_size();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2549 used += curr->used_word_size();
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	2550 capacity += curr->word_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2551 waste += curr->free_word_size() + curr->overhead();;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2552 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2553 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2554
12239 8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2555 if (TraceMetadataChunkAllocation && Verbose) {
8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2556 block_freelists()->print_on(out);
8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2557 }
8227700da288 8024751: Fix bugs in TraceMetadata stefank parents: 12237 diff changeset	2558
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2559 size_t free = current_chunk() == NULL ? 0 : current_chunk()->free_word_size();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2560 // Free space isn't wasted.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2561 waste -= free;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2562
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2563 out->print_cr("total of all chunks " SIZE_FORMAT " used " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2564 " free " SIZE_FORMAT " capacity " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2565 " waste " SIZE_FORMAT, curr_total, used, free, capacity, waste);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2566 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2567
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	2568 #ifndef PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2569 void SpaceManager::mangle_freed_chunks() {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2570 for (ChunkIndex index = ZeroIndex;
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	2571 index < NumberOfInUseLists;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2572 index = next_chunk_index(index)) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2573 for (Metachunk* curr = chunks_in_use(index);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2574 curr != NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2575 curr = curr->next()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2576 curr->mangle();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2577 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2578 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2579 }
7185 90273fc0a981 8000662: NPG: nashorn ant clean test262 out-of-memory with Java heap coleenp parents: 6969 diff changeset	2580 #endif // PRODUCT
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2581
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2582 // MetaspaceAux
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2583
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2584
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2585 size_t MetaspaceAux::_capacity_words[] = {0, 0};
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2586 size_t MetaspaceAux::_used_words[] = {0, 0};
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2587
12063 1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2588 size_t MetaspaceAux::free_bytes(Metaspace::MetadataType mdtype) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2589 VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2590 return list == NULL ? 0 : list->free_bytes();
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2591 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2592
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2593 size_t MetaspaceAux::free_bytes() {
12063 1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space ehelin parents: 12056 diff changeset	2594 return free_bytes(Metaspace::ClassType) + free_bytes(Metaspace::NonClassType);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2595 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2596
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2597 void MetaspaceAux::dec_capacity(Metaspace::MetadataType mdtype, size_t words) {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2598 assert_lock_strong(SpaceManager::expand_lock());
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2599 assert(words <= capacity_words(mdtype),
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2600 err_msg("About to decrement below 0: words " SIZE_FORMAT
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2601 " is greater than _capacity_words[%u] " SIZE_FORMAT,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2602 words, mdtype, capacity_words(mdtype)));
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2603 _capacity_words[mdtype] -= words;
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2604 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2605
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2606 void MetaspaceAux::inc_capacity(Metaspace::MetadataType mdtype, size_t words) {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2607 assert_lock_strong(SpaceManager::expand_lock());
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2608 // Needs to be atomic
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2609 _capacity_words[mdtype] += words;
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2610 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2611
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2612 void MetaspaceAux::dec_used(Metaspace::MetadataType mdtype, size_t words) {
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2613 assert(words <= used_words(mdtype),
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2614 err_msg("About to decrement below 0: words " SIZE_FORMAT
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2615 " is greater than _used_words[%u] " SIZE_FORMAT,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2616 words, mdtype, used_words(mdtype)));
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2617 // For CMS deallocation of the Metaspaces occurs during the
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2618 // sweep which is a concurrent phase. Protection by the expand_lock()
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2619 // is not enough since allocation is on a per Metaspace basis
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2620 // and protected by the Metaspace lock.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2621 jlong minus_words = (jlong) - (jlong) words;
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2622 Atomic::add_ptr(minus_words, &_used_words[mdtype]);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2623 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2624
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2625 void MetaspaceAux::inc_used(Metaspace::MetadataType mdtype, size_t words) {
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2626 // _used_words tracks allocations for
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2627 // each piece of metadata. Those allocations are
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2628 // generally done concurrently by different application
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2629 // threads so must be done atomically.
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2630 Atomic::add_ptr(words, &_used_words[mdtype]);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2631 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2632
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2633 size_t MetaspaceAux::used_bytes_slow(Metaspace::MetadataType mdtype) {
6730 5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2634 size_t used = 0;
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2635 ClassLoaderDataGraphMetaspaceIterator iter;
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2636 while (iter.repeat()) {
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2637 Metaspace* msp = iter.get_next();
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2638 // Sum allocated_blocks_words for each metaspace
6730 5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2639 if (msp != NULL) {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2640 used += msp->used_words_slow(mdtype);
6730 5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2641 }
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2642 }
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2643 return used * BytesPerWord;
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2644 }
5d2156bcb78b 7195789: NPG: assert(used + free == capacity) failed: Accounting is wrong jmasa parents: 6726 diff changeset	2645
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2646 size_t MetaspaceAux::free_bytes_slow(Metaspace::MetadataType mdtype) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2647 size_t free = 0;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2648 ClassLoaderDataGraphMetaspaceIterator iter;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2649 while (iter.repeat()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2650 Metaspace* msp = iter.get_next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2651 if (msp != NULL) {
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2652 free += msp->free_words_slow(mdtype);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2653 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2654 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2655 return free * BytesPerWord;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2656 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2657
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2658 size_t MetaspaceAux::capacity_bytes_slow(Metaspace::MetadataType mdtype) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2659 if ((mdtype == Metaspace::ClassType) && !Metaspace::using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2660 return 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2661 }
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2662 // Don't count the space in the freelists. That space will be
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2663 // added to the capacity calculation as needed.
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2664 size_t capacity = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2665 ClassLoaderDataGraphMetaspaceIterator iter;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2666 while (iter.repeat()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2667 Metaspace* msp = iter.get_next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2668 if (msp != NULL) {
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2669 capacity += msp->capacity_words_slow(mdtype);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2670 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2671 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2672 return capacity * BytesPerWord;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2673 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2674
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2675 size_t MetaspaceAux::capacity_bytes_slow() {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2676 #ifdef PRODUCT
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2677 // Use capacity_bytes() in PRODUCT instead of this function.
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2678 guarantee(false, "Should not call capacity_bytes_slow() in the PRODUCT");
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2679 #endif
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2680 size_t class_capacity = capacity_bytes_slow(Metaspace::ClassType);
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2681 size_t non_class_capacity = capacity_bytes_slow(Metaspace::NonClassType);
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2682 assert(capacity_bytes() == class_capacity + non_class_capacity,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2683 err_msg("bad accounting: capacity_bytes() " SIZE_FORMAT
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2684 " class_capacity + non_class_capacity " SIZE_FORMAT
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2685 " class_capacity " SIZE_FORMAT " non_class_capacity " SIZE_FORMAT,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2686 capacity_bytes(), class_capacity + non_class_capacity,
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2687 class_capacity, non_class_capacity));
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2688
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2689 return class_capacity + non_class_capacity;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2690 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2691
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2692 size_t MetaspaceAux::reserved_bytes(Metaspace::MetadataType mdtype) {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2693 VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2694 return list == NULL ? 0 : list->reserved_bytes();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2695 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2696
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2697 size_t MetaspaceAux::committed_bytes(Metaspace::MetadataType mdtype) {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2698 VirtualSpaceList* list = Metaspace::get_space_list(mdtype);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	2699 return list == NULL ? 0 : list->committed_bytes();
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2700 }
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2701
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2702 size_t MetaspaceAux::min_chunk_size_words() { return Metaspace::first_chunk_word_size(); }
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2703
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2704 size_t MetaspaceAux::free_chunks_total_words(Metaspace::MetadataType mdtype) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2705 ChunkManager* chunk_manager = Metaspace::get_chunk_manager(mdtype);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2706 if (chunk_manager == NULL) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2707 return 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2708 }
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2709 chunk_manager->slow_verify();
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2710 return chunk_manager->free_chunks_total_words();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2711 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2712
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2713 size_t MetaspaceAux::free_chunks_total_bytes(Metaspace::MetadataType mdtype) {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2714 return free_chunks_total_words(mdtype) * BytesPerWord;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2715 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2716
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2717 size_t MetaspaceAux::free_chunks_total_words() {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2718 return free_chunks_total_words(Metaspace::ClassType) +
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2719 free_chunks_total_words(Metaspace::NonClassType);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2720 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2721
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2722 size_t MetaspaceAux::free_chunks_total_bytes() {
d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2723 return free_chunks_total_words() * BytesPerWord;
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2724 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2725
17771 9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2726 bool MetaspaceAux::has_chunk_free_list(Metaspace::MetadataType mdtype) {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2727 return Metaspace::get_chunk_manager(mdtype) != NULL;
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2728 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2729
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2730 MetaspaceChunkFreeListSummary MetaspaceAux::chunk_free_list_summary(Metaspace::MetadataType mdtype) {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2731 if (!has_chunk_free_list(mdtype)) {
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2732 return MetaspaceChunkFreeListSummary();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2733 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2734
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2735 const ChunkManager* cm = Metaspace::get_chunk_manager(mdtype);
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2736 return cm->chunk_free_list_summary();
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2737 }
9fdaa79b0c27 8036703: Add trace event with statistics for the metaspace chunk free lists ehelin parents: 17770 diff changeset	2738
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2739 void MetaspaceAux::print_metaspace_change(size_t prev_metadata_used) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2740 gclog_or_tty->print(", [Metaspace:");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2741 if (PrintGCDetails && Verbose) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2742 gclog_or_tty->print(" " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2743 "->" SIZE_FORMAT
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2744 "(" SIZE_FORMAT ")",
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2745 prev_metadata_used,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2746 used_bytes(),
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2747 reserved_bytes());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2748 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2749 gclog_or_tty->print(" " SIZE_FORMAT "K"
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2750 "->" SIZE_FORMAT "K"
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2751 "(" SIZE_FORMAT "K)",
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2752 prev_metadata_used/K,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2753 used_bytes()/K,
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2754 reserved_bytes()/K);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2755 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2756
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2757 gclog_or_tty->print("]");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2758 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2759
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2760 // This is printed when PrintGCDetails
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2761 void MetaspaceAux::print_on(outputStream* out) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2762 Metaspace::MetadataType nct = Metaspace::NonClassType;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2763
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2764 out->print_cr(" Metaspace "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2765 "used " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2766 "capacity " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2767 "committed " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2768 "reserved " SIZE_FORMAT "K",
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2769 used_bytes()/K,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2770 capacity_bytes()/K,
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2771 committed_bytes()/K,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2772 reserved_bytes()/K);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2773
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2774 if (Metaspace::using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2775 Metaspace::MetadataType ct = Metaspace::ClassType;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2776 out->print_cr(" class space "
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2777 "used " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2778 "capacity " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2779 "committed " SIZE_FORMAT "K, "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2780 "reserved " SIZE_FORMAT "K",
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2781 used_bytes(ct)/K,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2782 capacity_bytes(ct)/K,
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2783 committed_bytes(ct)/K,
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2784 reserved_bytes(ct)/K);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2785 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2786 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2787
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2788 // Print information for class space and data space separately.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2789 // This is almost the same as above.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2790 void MetaspaceAux::print_on(outputStream* out, Metaspace::MetadataType mdtype) {
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2791 size_t free_chunks_capacity_bytes = free_chunks_total_bytes(mdtype);
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2792 size_t capacity_bytes = capacity_bytes_slow(mdtype);
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2793 size_t used_bytes = used_bytes_slow(mdtype);
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	2794 size_t free_bytes = free_bytes_slow(mdtype);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2795 size_t used_and_free = used_bytes + free_bytes +
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2796 free_chunks_capacity_bytes;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2797 out->print_cr(" Chunk accounting: used in chunks " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2798 "K + unused in chunks " SIZE_FORMAT "K + "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2799 " capacity in free chunks " SIZE_FORMAT "K = " SIZE_FORMAT
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2800 "K capacity in allocated chunks " SIZE_FORMAT "K",
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2801 used_bytes / K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2802 free_bytes / K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2803 free_chunks_capacity_bytes / K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2804 used_and_free / K,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2805 capacity_bytes / K);
8738 1c88b99a2b01 8009282: Assertion "assert(used_and_free == capacity_bytes) failed: Accounting is wrong" failed with -XX:+Verbose -XX:+TraceMetadataChunkAllocation mgerdin parents: 8040 diff changeset	2806 // Accounting can only be correct if we got the values during a safepoint
1c88b99a2b01 8009282: Assertion "assert(used_and_free == capacity_bytes) failed: Accounting is wrong" failed with -XX:+Verbose -XX:+TraceMetadataChunkAllocation mgerdin parents: 8040 diff changeset	2807 assert(!SafepointSynchronize::is_at_safepoint() \|\| used_and_free == capacity_bytes, "Accounting is wrong");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2808 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2809
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2810 // Print total fragmentation for class metaspaces
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2811 void MetaspaceAux::print_class_waste(outputStream* out) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2812 assert(Metaspace::using_class_space(), "class metaspace not used");
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2813 size_t cls_specialized_waste = 0, cls_small_waste = 0, cls_medium_waste = 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2814 size_t cls_specialized_count = 0, cls_small_count = 0, cls_medium_count = 0, cls_humongous_count = 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2815 ClassLoaderDataGraphMetaspaceIterator iter;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2816 while (iter.repeat()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2817 Metaspace* msp = iter.get_next();
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2818 if (msp != NULL) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2819 cls_specialized_waste += msp->class_vsm()->sum_waste_in_chunks_in_use(SpecializedIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2820 cls_specialized_count += msp->class_vsm()->sum_count_in_chunks_in_use(SpecializedIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2821 cls_small_waste += msp->class_vsm()->sum_waste_in_chunks_in_use(SmallIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2822 cls_small_count += msp->class_vsm()->sum_count_in_chunks_in_use(SmallIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2823 cls_medium_waste += msp->class_vsm()->sum_waste_in_chunks_in_use(MediumIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2824 cls_medium_count += msp->class_vsm()->sum_count_in_chunks_in_use(MediumIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2825 cls_humongous_count += msp->class_vsm()->sum_count_in_chunks_in_use(HumongousIndex);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2826 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2827 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2828 out->print_cr(" class: " SIZE_FORMAT " specialized(s) " SIZE_FORMAT ", "
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2829 SIZE_FORMAT " small(s) " SIZE_FORMAT ", "
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2830 SIZE_FORMAT " medium(s) " SIZE_FORMAT ", "
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2831 "large count " SIZE_FORMAT,
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2832 cls_specialized_count, cls_specialized_waste,
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2833 cls_small_count, cls_small_waste,
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2834 cls_medium_count, cls_medium_waste, cls_humongous_count);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2835 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2836
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2837 // Print total fragmentation for data and class metaspaces separately
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2838 void MetaspaceAux::print_waste(outputStream* out) {
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2839 size_t specialized_waste = 0, small_waste = 0, medium_waste = 0;
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2840 size_t specialized_count = 0, small_count = 0, medium_count = 0, humongous_count = 0;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2841
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2842 ClassLoaderDataGraphMetaspaceIterator iter;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2843 while (iter.repeat()) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2844 Metaspace* msp = iter.get_next();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2845 if (msp != NULL) {
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2846 specialized_waste += msp->vsm()->sum_waste_in_chunks_in_use(SpecializedIndex);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2847 specialized_count += msp->vsm()->sum_count_in_chunks_in_use(SpecializedIndex);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2848 small_waste += msp->vsm()->sum_waste_in_chunks_in_use(SmallIndex);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2849 small_count += msp->vsm()->sum_count_in_chunks_in_use(SmallIndex);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2850 medium_waste += msp->vsm()->sum_waste_in_chunks_in_use(MediumIndex);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2851 medium_count += msp->vsm()->sum_count_in_chunks_in_use(MediumIndex);
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2852 humongous_count += msp->vsm()->sum_count_in_chunks_in_use(HumongousIndex);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2853 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2854 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2855 out->print_cr("Total fragmentation waste (words) doesn't count free space");
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2856 out->print_cr(" data: " SIZE_FORMAT " specialized(s) " SIZE_FORMAT ", "
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2857 SIZE_FORMAT " small(s) " SIZE_FORMAT ", "
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2858 SIZE_FORMAT " medium(s) " SIZE_FORMAT ", "
de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2859 "large count " SIZE_FORMAT,
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2860 specialized_count, specialized_waste, small_count,
11064 de2d15ce3d4a 8015391: NPG: With -XX:+UseCompressedKlassPointers OOME due to exhausted metadata space could occur when metaspace is almost empty coleenp parents: 10376 diff changeset	2861 small_waste, medium_count, medium_waste, humongous_count);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2862 if (Metaspace::using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2863 print_class_waste(out);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2864 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2865 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2866
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2867 // Dump global metaspace things from the end of ClassLoaderDataGraph
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2868 void MetaspaceAux::dump(outputStream* out) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2869 out->print_cr("All Metaspace:");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2870 out->print("data space: "); print_on(out, Metaspace::NonClassType);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2871 out->print("class space: "); print_on(out, Metaspace::ClassType);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2872 print_waste(out);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2873 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2874
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	2875 void MetaspaceAux::verify_free_chunks() {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2876 Metaspace::chunk_manager_metadata()->verify();
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2877 if (Metaspace::using_class_space()) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2878 Metaspace::chunk_manager_class()->verify();
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2879 }
6969 6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	2880 }
6bc207d87e5d 7200229: NPG: possible performance issue exposed by closed/runtime/6559877/Test6559877.java mgerdin parents: 6885 diff changeset	2881
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2882 void MetaspaceAux::verify_capacity() {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2883 #ifdef ASSERT
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2884 size_t running_sum_capacity_bytes = capacity_bytes();
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2885 // For purposes of the running sum of capacity, verify against capacity
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2886 size_t capacity_in_use_bytes = capacity_bytes_slow();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2887 assert(running_sum_capacity_bytes == capacity_in_use_bytes,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2888 err_msg("capacity_words() * BytesPerWord " SIZE_FORMAT
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2889 " capacity_bytes_slow()" SIZE_FORMAT,
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2890 running_sum_capacity_bytes, capacity_in_use_bytes));
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2891 for (Metaspace::MetadataType i = Metaspace::ClassType;
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2892 i < Metaspace:: MetadataTypeCount;
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2893 i = (Metaspace::MetadataType)(i + 1)) {
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2894 size_t capacity_in_use_bytes = capacity_bytes_slow(i);
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2895 assert(capacity_bytes(i) == capacity_in_use_bytes,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2896 err_msg("capacity_bytes(%u) " SIZE_FORMAT
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2897 " capacity_bytes_slow(%u)" SIZE_FORMAT,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2898 i, capacity_bytes(i), i, capacity_in_use_bytes));
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2899 }
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2900 #endif
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2901 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2902
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2903 void MetaspaceAux::verify_used() {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2904 #ifdef ASSERT
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2905 size_t running_sum_used_bytes = used_bytes();
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2906 // For purposes of the running sum of used, verify against used
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2907 size_t used_in_use_bytes = used_bytes_slow();
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2908 assert(used_bytes() == used_in_use_bytes,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2909 err_msg("used_bytes() " SIZE_FORMAT
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2910 " used_bytes_slow()" SIZE_FORMAT,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2911 used_bytes(), used_in_use_bytes));
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2912 for (Metaspace::MetadataType i = Metaspace::ClassType;
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2913 i < Metaspace:: MetadataTypeCount;
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2914 i = (Metaspace::MetadataType)(i + 1)) {
2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2915 size_t used_in_use_bytes = used_bytes_slow(i);
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2916 assert(used_bytes(i) == used_in_use_bytes,
270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2917 err_msg("used_bytes(%u) " SIZE_FORMAT
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2918 " used_bytes_slow(%u)" SIZE_FORMAT,
17866 270d7cb38f40 8038934: Remove prefix allocated_ from methods and variables in Metaspace ehelin parents: 17771 diff changeset	2919 i, used_bytes(i), i, used_in_use_bytes));
10330 2b1a9d972fc2 8014862: Add fast Metasapce capacity and used per MetadataType jmasa parents: 10191 diff changeset	2920 }
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2921 #endif
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2922 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2923
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2924 void MetaspaceAux::verify_metrics() {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2925 verify_capacity();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2926 verify_used();
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2927 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2928
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	2929
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2930 // Metaspace methods
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2931
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2932 size_t Metaspace::_first_chunk_word_size = 0;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2933 size_t Metaspace::_first_class_chunk_word_size = 0;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2934
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2935 size_t Metaspace::_commit_alignment = 0;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2936 size_t Metaspace::_reserve_alignment = 0;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	2937
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2938 Metaspace::Metaspace(Mutex* lock, MetaspaceType type) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	2939 initialize(lock, type);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2940 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2941
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2942 Metaspace::~Metaspace() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2943 delete _vsm;
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2944 if (using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2945 delete _class_vsm;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2946 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2947 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2948
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2949 VirtualSpaceList* Metaspace::_space_list = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2950 VirtualSpaceList* Metaspace::_class_space_list = NULL;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2951
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2952 ChunkManager* Metaspace::_chunk_manager_metadata = NULL;
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2953 ChunkManager* Metaspace::_chunk_manager_class = NULL;
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	2954
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2955 #define VIRTUALSPACEMULTIPLIER 2
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	2956
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2957 #ifdef _LP64
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2958 static const uint64_t UnscaledClassSpaceMax = (uint64_t(max_juint) + 1);
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2959
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2960 void Metaspace::set_narrow_klass_base_and_shift(address metaspace_base, address cds_base) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2961 // Figure out the narrow_klass_base and the narrow_klass_shift. The
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2962 // narrow_klass_base is the lower of the metaspace base and the cds base
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2963 // (if cds is enabled). The narrow_klass_shift depends on the distance
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2964 // between the lower base and higher address.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2965 address lower_base;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2966 address higher_address;
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	2967 #if INCLUDE_CDS
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2968 if (UseSharedSpaces) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2969 higher_address = MAX2((address)(cds_base + FileMapInfo::shared_spaces_size()),
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2970 (address)(metaspace_base + compressed_class_space_size()));
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2971 lower_base = MIN2(metaspace_base, cds_base);
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	2972 } else
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	2973 #endif
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	2974 {
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2975 higher_address = metaspace_base + compressed_class_space_size();
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2976 lower_base = metaspace_base;
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2977
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2978 uint64_t klass_encoding_max = UnscaledClassSpaceMax << LogKlassAlignmentInBytes;
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2979 // If compressed class space fits in lower 32G, we don't need a base.
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2980 if (higher_address <= (address)klass_encoding_max) {
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2981 lower_base = 0; // effectively lower base is zero.
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2982 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2983 }
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2984
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2985 Universe::set_narrow_klass_base(lower_base);
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	2986
13037 c8fc12209830 8027616: Off by one error in putback for compressed oops nashorn performance improvement coleenp parents: 13001 diff changeset	2987 if ((uint64_t)(higher_address - lower_base) <= UnscaledClassSpaceMax) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2988 Universe::set_narrow_klass_shift(0);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2989 } else {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2990 assert(!UseSharedSpaces, "Cannot shift with UseSharedSpaces");
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2991 Universe::set_narrow_klass_shift(LogKlassAlignmentInBytes);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2992 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2993 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2994
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	2995 #if INCLUDE_CDS
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2996 // Return TRUE if the specified metaspace_base and cds_base are close enough
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2997 // to work with compressed klass pointers.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2998 bool Metaspace::can_use_cds_with_metaspace_addr(char* metaspace_base, address cds_base) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	2999 assert(cds_base != 0 && UseSharedSpaces, "Only use with CDS");
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3000 assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3001 address lower_base = MIN2((address)metaspace_base, cds_base);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3002 address higher_address = MAX2((address)(cds_base + FileMapInfo::shared_spaces_size()),
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3003 (address)(metaspace_base + compressed_class_space_size()));
13037 c8fc12209830 8027616: Off by one error in putback for compressed oops nashorn performance improvement coleenp parents: 13001 diff changeset	3004 return ((uint64_t)(higher_address - lower_base) <= UnscaledClassSpaceMax);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3005 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3006 #endif
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3007
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3008 // Try to allocate the metaspace at the requested addr.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3009 void Metaspace::allocate_metaspace_compressed_klass_ptrs(char* requested_addr, address cds_base) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3010 assert(using_class_space(), "called improperly");
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3011 assert(UseCompressedClassPointers, "Only use with CompressedKlassPtrs");
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3012 assert(compressed_class_space_size() < KlassEncodingMetaspaceMax,
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3013 "Metaspace size is too big");
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3014 assert_is_ptr_aligned(requested_addr, _reserve_alignment);
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3015 assert_is_ptr_aligned(cds_base, _reserve_alignment);
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3016 assert_is_size_aligned(compressed_class_space_size(), _reserve_alignment);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3017
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3018 // Don't use large pages for the class space.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3019 bool large_pages = false;
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3020
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3021 ReservedSpace metaspace_rs = ReservedSpace(compressed_class_space_size(),
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3022 _reserve_alignment,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3023 large_pages,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3024 requested_addr, 0);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3025 if (!metaspace_rs.is_reserved()) {
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3026 #if INCLUDE_CDS
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3027 if (UseSharedSpaces) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3028 size_t increment = align_size_up(1*G, _reserve_alignment);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3029
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3030 // Keep trying to allocate the metaspace, increasing the requested_addr
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3031 // by 1GB each time, until we reach an address that will no longer allow
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3032 // use of CDS with compressed klass pointers.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3033 char *addr = requested_addr;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3034 while (!metaspace_rs.is_reserved() && (addr + increment > addr) &&
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3035 can_use_cds_with_metaspace_addr(addr + increment, cds_base)) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3036 addr = addr + increment;
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3037 metaspace_rs = ReservedSpace(compressed_class_space_size(),
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3038 _reserve_alignment, large_pages, addr, 0);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3039 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3040 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3041 #endif
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3042 // If no successful allocation then try to allocate the space anywhere. If
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3043 // that fails then OOM doom. At this point we cannot try allocating the
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3044 // metaspace as if UseCompressedClassPointers is off because too much
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3045 // initialization has happened that depends on UseCompressedClassPointers.
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3046 // So, UseCompressedClassPointers cannot be turned off at this point.
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3047 if (!metaspace_rs.is_reserved()) {
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3048 metaspace_rs = ReservedSpace(compressed_class_space_size(),
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3049 _reserve_alignment, large_pages);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3050 if (!metaspace_rs.is_reserved()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3051 vm_exit_during_initialization(err_msg("Could not allocate metaspace: %d bytes",
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3052 compressed_class_space_size()));
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3053 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3054 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3055 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3056
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3057 // If we got here then the metaspace got allocated.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3058 MemTracker::record_virtual_memory_type((address)metaspace_rs.base(), mtClass);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3059
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3060 #if INCLUDE_CDS
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3061 // Verify that we can use shared spaces. Otherwise, turn off CDS.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3062 if (UseSharedSpaces && !can_use_cds_with_metaspace_addr(metaspace_rs.base(), cds_base)) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3063 FileMapInfo::stop_sharing_and_unmap(
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3064 "Could not allocate metaspace at a compatible address");
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3065 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3066 #endif
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3067 set_narrow_klass_base_and_shift((address)metaspace_rs.base(),
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3068 UseSharedSpaces ? (address)cds_base : 0);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3069
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3070 initialize_class_space(metaspace_rs);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3071
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3072 if (PrintCompressedOopsMode \|\| (PrintMiscellaneous && Verbose)) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3073 gclog_or_tty->print_cr("Narrow klass base: " PTR_FORMAT ", Narrow klass shift: " SIZE_FORMAT,
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3074 Universe::narrow_klass_base(), Universe::narrow_klass_shift());
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3075 gclog_or_tty->print_cr("Compressed class space size: " SIZE_FORMAT " Address: " PTR_FORMAT " Req Addr: " PTR_FORMAT,
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3076 compressed_class_space_size(), metaspace_rs.base(), requested_addr);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3077 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3078 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3079
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3080 // For UseCompressedClassPointers the class space is reserved above the top of
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3081 // the Java heap. The argument passed in is at the base of the compressed space.
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3082 void Metaspace::initialize_class_space(ReservedSpace rs) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3083 // The reserved space size may be bigger because of alignment, esp with UseLargePages
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3084 assert(rs.size() >= CompressedClassSpaceSize,
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3085 err_msg(SIZE_FORMAT " != " UINTX_FORMAT, rs.size(), CompressedClassSpaceSize));
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3086 assert(using_class_space(), "Must be using class space");
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3087 _class_space_list = new VirtualSpaceList(rs);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3088 _chunk_manager_class = new ChunkManager(SpecializedChunk, ClassSmallChunk, ClassMediumChunk);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3089
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3090 if (!_class_space_list->initialization_succeeded()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3091 vm_exit_during_initialization("Failed to setup compressed class space virtual space list.");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3092 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3093 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3094
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3095 #endif
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3096
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3097 void Metaspace::ergo_initialize() {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3098 if (DumpSharedSpaces) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3099 // Using large pages when dumping the shared archive is currently not implemented.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3100 FLAG_SET_ERGO(bool, UseLargePagesInMetaspace, false);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3101 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3102
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3103 size_t page_size = os::vm_page_size();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3104 if (UseLargePages && UseLargePagesInMetaspace) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3105 page_size = os::large_page_size();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3106 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3107
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3108 _commit_alignment = page_size;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3109 _reserve_alignment = MAX2(page_size, (size_t)os::vm_allocation_granularity());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3110
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3111 // Do not use FLAG_SET_ERGO to update MaxMetaspaceSize, since this will
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3112 // override if MaxMetaspaceSize was set on the command line or not.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3113 // This information is needed later to conform to the specification of the
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3114 // java.lang.management.MemoryUsage API.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3115 //
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3116 // Ideally, we would be able to set the default value of MaxMetaspaceSize in
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3117 // globals.hpp to the aligned value, but this is not possible, since the
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3118 // alignment depends on other flags being parsed.
13058 3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3119 MaxMetaspaceSize = align_size_down_bounded(MaxMetaspaceSize, _reserve_alignment);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3120
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3121 if (MetaspaceSize > MaxMetaspaceSize) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3122 MetaspaceSize = MaxMetaspaceSize;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3123 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3124
13058 3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3125 MetaspaceSize = align_size_down_bounded(MetaspaceSize, _commit_alignment);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3126
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3127 assert(MetaspaceSize <= MaxMetaspaceSize, "MetaspaceSize should be limited by MaxMetaspaceSize");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3128
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3129 if (MetaspaceSize < 256*K) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3130 vm_exit_during_initialization("Too small initial Metaspace size");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3131 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3132
13058 3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3133 MinMetaspaceExpansion = align_size_down_bounded(MinMetaspaceExpansion, _commit_alignment);
3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3134 MaxMetaspaceExpansion = align_size_down_bounded(MaxMetaspaceExpansion, _commit_alignment);
3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3135
3aee6bc29547 8026852: Use restricted_align_down in collector policy code jwilhelm parents: 12980 diff changeset	3136 CompressedClassSpaceSize = align_size_down_bounded(CompressedClassSpaceSize, _reserve_alignment);
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3137 set_compressed_class_space_size(CompressedClassSpaceSize);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3138 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3139
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3140 void Metaspace::global_initialize() {
17979 e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3141 MetaspaceGC::initialize();
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3142
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3143 // Initialize the alignment for shared spaces.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3144 int max_alignment = os::vm_page_size();
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3145 size_t cds_total = 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3146
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3147 MetaspaceShared::set_max_alignment(max_alignment);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3148
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3149 if (DumpSharedSpaces) {
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3150 #if INCLUDE_CDS
20389 622c6e0ad4d6 8048150: Allow easy configurations for large CDS archives ccheung parents: 20375 diff changeset	3151 MetaspaceShared::estimate_regions_size();
622c6e0ad4d6 8048150: Allow easy configurations for large CDS archives ccheung parents: 20375 diff changeset	3152
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3153 SharedReadOnlySize = align_size_up(SharedReadOnlySize, max_alignment);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3154 SharedReadWriteSize = align_size_up(SharedReadWriteSize, max_alignment);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3155 SharedMiscDataSize = align_size_up(SharedMiscDataSize, max_alignment);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3156 SharedMiscCodeSize = align_size_up(SharedMiscCodeSize, max_alignment);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3157
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3158 // Initialize with the sum of the shared space sizes. The read-only
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3159 // and read write metaspace chunks will be allocated out of this and the
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3160 // remainder is the misc code and data chunks.
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3161 cds_total = FileMapInfo::shared_spaces_size();
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3162 cds_total = align_size_up(cds_total, _reserve_alignment);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3163 _space_list = new VirtualSpaceList(cds_total/wordSize);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3164 _chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3165
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3166 if (!_space_list->initialization_succeeded()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3167 vm_exit_during_initialization("Unable to dump shared archive.", NULL);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3168 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3169
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3170 #ifdef _LP64
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3171 if (cds_total + compressed_class_space_size() > UnscaledClassSpaceMax) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3172 vm_exit_during_initialization("Unable to dump shared archive.",
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3173 err_msg("Size of archive (" SIZE_FORMAT ") + compressed class space ("
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3174 SIZE_FORMAT ") == total (" SIZE_FORMAT ") is larger than compressed "
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3175 "klass limit: " SIZE_FORMAT, cds_total, compressed_class_space_size(),
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3176 cds_total + compressed_class_space_size(), UnscaledClassSpaceMax));
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3177 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3178
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3179 // Set the compressed klass pointer base so that decoding of these pointers works
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3180 // properly when creating the shared archive.
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3181 assert(UseCompressedOops && UseCompressedClassPointers,
7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3182 "UseCompressedOops and UseCompressedClassPointers must be set");
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3183 Universe::set_narrow_klass_base((address)_space_list->current_virtual_space()->bottom());
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3184 if (TraceMetavirtualspaceAllocation && Verbose) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3185 gclog_or_tty->print_cr("Setting_narrow_klass_base to Address: " PTR_FORMAT,
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3186 _space_list->current_virtual_space()->bottom());
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3187 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3188
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3189 Universe::set_narrow_klass_shift(0);
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3190 #endif // _LP64
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3191 #endif // INCLUDE_CDS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3192 } else {
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3193 #if INCLUDE_CDS
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3194 // If using shared space, open the file that contains the shared space
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3195 // and map in the memory before initializing the rest of metaspace (so
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3196 // the addresses don't conflict)
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3197 address cds_address = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3198 if (UseSharedSpaces) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3199 FileMapInfo* mapinfo = new FileMapInfo();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3200
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3201 // Open the shared archive file, read and validate the header. If
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3202 // initialization fails, shared spaces [UseSharedSpaces] are
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3203 // disabled and the file is closed.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3204 // Map in spaces now also
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3205 if (mapinfo->initialize() && MetaspaceShared::map_shared_spaces(mapinfo)) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3206 cds_total = FileMapInfo::shared_spaces_size();
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3207 cds_address = (address)mapinfo->region_base(0);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3208 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3209 assert(!mapinfo->is_open() && !UseSharedSpaces,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3210 "archive file not closed or shared spaces not disabled.");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3211 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3212 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3213 #endif // INCLUDE_CDS
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3214 #ifdef _LP64
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3215 // If UseCompressedClassPointers is set then allocate the metaspace area
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3216 // above the heap and above the CDS area (if it exists).
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3217 if (using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3218 if (UseSharedSpaces) {
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3219 #if INCLUDE_CDS
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3220 char* cds_end = (char*)(cds_address + cds_total);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3221 cds_end = (char *)align_ptr_up(cds_end, _reserve_alignment);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3222 allocate_metaspace_compressed_klass_ptrs(cds_end, cds_address);
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3223 #endif
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3224 } else {
13000 209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3225 char* base = (char*)align_ptr_up(Universe::heap()->reserved_region().end(), _reserve_alignment);
209aa13ab8c0 8024927: Nashorn performance regression with CompressedOops coleenp parents: 12998 diff changeset	3226 allocate_metaspace_compressed_klass_ptrs(base, 0);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3227 }
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3228 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3229 #endif // _LP64
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3230
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3231 // Initialize these before initializing the VirtualSpaceList
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3232 _first_chunk_word_size = InitialBootClassLoaderMetaspaceSize / BytesPerWord;
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3233 _first_chunk_word_size = align_word_size_up(_first_chunk_word_size);
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3234 // Make the first class chunk bigger than a medium chunk so it's not put
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3235 // on the medium chunk list. The next chunk will be small and progress
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3236 // from there. This size calculated by -version.
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3237 _first_class_chunk_word_size = MIN2((size_t)MediumChunk*6,
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3238 (CompressedClassSpaceSize/BytesPerWord)*2);
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3239 _first_class_chunk_word_size = align_word_size_up(_first_class_chunk_word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3240 // Arbitrarily set the initial virtual space to a multiple
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3241 // of the boot class loader size.
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3242 size_t word_size = VIRTUALSPACEMULTIPLIER * _first_chunk_word_size;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3243 word_size = align_size_up(word_size, Metaspace::reserve_alignment_words());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3244
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3245 // Initialize the list of virtual spaces.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3246 _space_list = new VirtualSpaceList(word_size);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3247 _chunk_manager_metadata = new ChunkManager(SpecializedChunk, SmallChunk, MediumChunk);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3248
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3249 if (!_space_list->initialization_succeeded()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3250 vm_exit_during_initialization("Unable to setup metadata virtual space list.", NULL);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3251 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3252 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3253
17768 daef39043d2c 8036698: Add trace event for updates to metaspace gc threshold ehelin parents: 17695 diff changeset	3254 _tracer = new MetaspaceTracer();
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3255 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3256
17979 e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3257 void Metaspace::post_initialize() {
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3258 MetaspaceGC::post_initialize();
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3259 }
e204777ac770 8042933: assert(capacity_until_gc >= committed_bytes) failed ehelin parents: 17937 diff changeset	3260
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3261 Metachunk* Metaspace::get_initialization_chunk(MetadataType mdtype,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3262 size_t chunk_word_size,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3263 size_t chunk_bunch) {
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3264 // Get a chunk from the chunk freelist
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3265 Metachunk* chunk = get_chunk_manager(mdtype)->chunk_freelist_allocate(chunk_word_size);
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3266 if (chunk != NULL) {
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3267 return chunk;
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3268 }
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3269
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3270 return get_space_list(mdtype)->get_new_chunk(chunk_word_size, chunk_word_size, chunk_bunch);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3271 }
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3272
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3273 void Metaspace::initialize(Mutex* lock, MetaspaceType type) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3274
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3275 assert(space_list() != NULL,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3276 "Metadata VirtualSpaceList has not been initialized");
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3277 assert(chunk_manager_metadata() != NULL,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3278 "Metadata ChunkManager has not been initialized");
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3279
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3280 _vsm = new SpaceManager(NonClassType, lock);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3281 if (_vsm == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3282 return;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3283 }
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3284 size_t word_size;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3285 size_t class_word_size;
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3286 vsm()->get_initial_chunk_sizes(type, &word_size, &class_word_size);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3287
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3288 if (using_class_space()) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3289 assert(class_space_list() != NULL,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3290 "Class VirtualSpaceList has not been initialized");
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3291 assert(chunk_manager_class() != NULL,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3292 "Class ChunkManager has not been initialized");
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3293
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3294 // Allocate SpaceManager for classes.
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3295 _class_vsm = new SpaceManager(ClassType, lock);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3296 if (_class_vsm == NULL) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3297 return;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3298 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3299 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3300
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3301 MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3302
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3303 // Allocate chunk for metadata objects
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3304 Metachunk* new_chunk = get_initialization_chunk(NonClassType,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3305 word_size,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3306 vsm()->medium_chunk_bunch());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3307 assert(!DumpSharedSpaces \|\| new_chunk != NULL, "should have enough space for both chunks");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3308 if (new_chunk != NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3309 // Add to this manager's list of chunks in use and current_chunk().
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3310 vsm()->add_chunk(new_chunk, true);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3311 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3312
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3313 // Allocate chunk for class metadata objects
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3314 if (using_class_space()) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3315 Metachunk* class_chunk = get_initialization_chunk(ClassType,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3316 class_word_size,
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3317 class_vsm()->medium_chunk_bunch());
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3318 if (class_chunk != NULL) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3319 class_vsm()->add_chunk(class_chunk, true);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3320 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3321 }
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3322
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3323 _alloc_record_head = NULL;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3324 _alloc_record_tail = NULL;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3325 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3326
7446 e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3327 size_t Metaspace::align_word_size_up(size_t word_size) {
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3328 size_t byte_size = word_size * wordSize;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3329 return ReservedSpace::allocation_align_size_up(byte_size) / wordSize;
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3330 }
e51c9860cf66 8005082: NPG: Add specialized Metachunk sizes for reflection and anonymous classloaders jmasa parents: 7435 diff changeset	3331
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3332 MetaWord* Metaspace::allocate(size_t word_size, MetadataType mdtype) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3333 // DumpSharedSpaces doesn't use class metadata area (yet)
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12110 diff changeset	3334 // Also, don't use class_vsm() unless UseCompressedClassPointers is true.
12340 bc918fd1e584 8025279: metaspace/flags/maxMetaspaceSize throws OOM: out of Compressed Klass space mgerdin parents: 12306 diff changeset	3335 if (is_class_space_allocation(mdtype)) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3336 return class_vsm()->allocate(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3337 } else {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3338 return vsm()->allocate(word_size);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3339 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3340 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3341
6753 8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6736 diff changeset	3342 MetaWord* Metaspace::expand_and_allocate(size_t word_size, MetadataType mdtype) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3343 size_t delta_bytes = MetaspaceGC::delta_capacity_until_GC(word_size * BytesPerWord);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3344 assert(delta_bytes > 0, "Must be");
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3345
20540 b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3346 size_t before = 0;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3347 size_t after = 0;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3348 MetaWord* res;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3349 bool incremented;
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3350
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3351 // Each thread increments the HWM at most once. Even if the thread fails to increment
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3352 // the HWM, an allocation is still attempted. This is because another thread must then
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3353 // have incremented the HWM and therefore the allocation might still succeed.
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3354 do {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3355 incremented = MetaspaceGC::inc_capacity_until_GC(delta_bytes, &after, &before);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3356 res = allocate(word_size, mdtype);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3357 } while (!incremented && res == NULL);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3358
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3359 if (incremented) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3360 tracer()->report_gc_threshold(before, after,
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3361 MetaspaceGCThresholdUpdater::ExpandAndAllocate);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3362 if (PrintGCDetails && Verbose) {
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3363 gclog_or_tty->print_cr("Increase capacity to GC from " SIZE_FORMAT
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3364 " to " SIZE_FORMAT, before, after);
b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3365 }
6753 8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6736 diff changeset	3366 }
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3367
20540 b509b7ff561c 8049599: MetaspaceGC::_capacity_until_GC can overflow ehelin parents: 20389 diff changeset	3368 return res;
6753 8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6736 diff changeset	3369 }
8da5e203b993 7197557: NPG: nsk/sysdict/vm/stress/chain/chain004 hangs intermittently jmasa parents: 6736 diff changeset	3370
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3371 // Space allocated in the Metaspace. This may
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3372 // be across several metadata virtual spaces.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3373 char* Metaspace::bottom() const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3374 assert(DumpSharedSpaces, "only useful and valid for dumping shared spaces");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3375 return (char*)vsm()->current_chunk()->bottom();
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3376 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3377
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3378 size_t Metaspace::used_words_slow(MetadataType mdtype) const {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3379 if (mdtype == ClassType) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3380 return using_class_space() ? class_vsm()->sum_used_in_chunks_in_use() : 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3381 } else {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3382 return vsm()->sum_used_in_chunks_in_use(); // includes overhead!
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3383 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3384 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3385
12235 d6c266999345 8023476: Metaspace capacity > reserved ehelin parents: 12231 diff changeset	3386 size_t Metaspace::free_words_slow(MetadataType mdtype) const {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3387 if (mdtype == ClassType) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3388 return using_class_space() ? class_vsm()->sum_free_in_chunks_in_use() : 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3389 } else {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3390 return vsm()->sum_free_in_chunks_in_use();
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3391 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3392 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3393
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3394 // Space capacity in the Metaspace. It includes
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3395 // space in the list of chunks from which allocations
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3396 // have been made. Don't include space in the global freelist and
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3397 // in the space available in the dictionary which
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3398 // is already counted in some chunk.
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3399 size_t Metaspace::capacity_words_slow(MetadataType mdtype) const {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3400 if (mdtype == ClassType) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3401 return using_class_space() ? class_vsm()->sum_capacity_in_chunks_in_use() : 0;
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3402 } else {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3403 return vsm()->sum_capacity_in_chunks_in_use();
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3404 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3405 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3406
10183 868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3407 size_t Metaspace::used_bytes_slow(MetadataType mdtype) const {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3408 return used_words_slow(mdtype) * BytesPerWord;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3409 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3410
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3411 size_t Metaspace::capacity_bytes_slow(MetadataType mdtype) const {
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3412 return capacity_words_slow(mdtype) * BytesPerWord;
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3413 }
868d87ed63c8 8008966: NPG: Inefficient Metaspace counter functions cause large young GC regressions jmasa parents: 10175 diff changeset	3414
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3415 void Metaspace::deallocate(MetaWord* ptr, size_t word_size, bool is_class) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3416 if (SafepointSynchronize::is_at_safepoint()) {
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3417 if (DumpSharedSpaces && PrintSharedSpaces) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3418 record_deallocation(ptr, vsm()->get_raw_word_size(word_size));
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3419 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3420
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3421 assert(Thread::current()->is_VM_thread(), "should be the VM thread");
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3422 // Don't take Heap_lock
10191 601183f604b2 8013129: Possible deadlock with Metaspace locks due to mixed usage of safepoint aware and non-safepoint aware locking mgerdin parents: 10183 diff changeset	3423 MutexLockerEx ml(vsm()->lock(), Mutex::_no_safepoint_check_flag);
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	3424 if (word_size < TreeChunk<Metablock, FreeList<Metablock> >::min_size()) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3425 // Dark matter. Too small for dictionary.
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3426 #ifdef ASSERT
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3427 Copy::fill_to_words((HeapWord*)ptr, word_size, 0xf5f5f5f5);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3428 #endif
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3429 return;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3430 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3431 if (is_class && using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3432 class_vsm()->deallocate(ptr, word_size);
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3433 } else {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3434 vsm()->deallocate(ptr, word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3435 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3436 } else {
10191 601183f604b2 8013129: Possible deadlock with Metaspace locks due to mixed usage of safepoint aware and non-safepoint aware locking mgerdin parents: 10183 diff changeset	3437 MutexLockerEx ml(vsm()->lock(), Mutex::_no_safepoint_check_flag);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3438
17695 ab36007d6358 8034171: Remove use of template template parameters from binaryTreeDictionary. goetz parents: 17663 diff changeset	3439 if (word_size < TreeChunk<Metablock, FreeList<Metablock> >::min_size()) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3440 // Dark matter. Too small for dictionary.
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3441 #ifdef ASSERT
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3442 Copy::fill_to_words((HeapWord*)ptr, word_size, 0xf5f5f5f5);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3443 #endif
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3444 return;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3445 }
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3446 if (is_class && using_class_space()) {
6885 685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3447 class_vsm()->deallocate(ptr, word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3448 } else {
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3449 vsm()->deallocate(ptr, word_size);
685df3c6f84b 7045397: NPG: Add freelists to class loader arenas. jmasa parents: 6786 diff changeset	3450 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3451 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3452 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3453
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3454
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3455 MetaWord* Metaspace::allocate(ClassLoaderData* loader_data, size_t word_size,
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3456 bool read_only, MetaspaceObj::Type type, TRAPS) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3457 if (HAS_PENDING_EXCEPTION) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3458 assert(false, "Should not allocate with exception pending");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3459 return NULL; // caller does a CHECK_NULL too
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3460 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3461
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3462 assert(loader_data != NULL, "Should never pass around a NULL loader_data. "
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3463 "ClassLoaderData::the_null_class_loader_data() should have been used.");
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3464
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3465 // Allocate in metaspaces without taking out a lock, because it deadlocks
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3466 // with the SymbolTable_lock. Dumping is single threaded for now. We'll have
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3467 // to revisit this for application class data sharing.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3468 if (DumpSharedSpaces) {
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3469 assert(type > MetaspaceObj::UnknownType && type < MetaspaceObj::_number_of_types, "sanity");
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3470 Metaspace* space = read_only ? loader_data->ro_metaspace() : loader_data->rw_metaspace();
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3471 MetaWord* result = space->allocate(word_size, NonClassType);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3472 if (result == NULL) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3473 report_out_of_shared_space(read_only ? SharedReadOnly : SharedReadWrite);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3474 }
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3475 if (PrintSharedSpaces) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3476 space->record_allocation(result, type, space->vsm()->get_raw_word_size(word_size));
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3477 }
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3478
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3479 // Zero initialize.
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3480 Copy::fill_to_aligned_words((HeapWord*)result, word_size, 0);
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3481
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3482 return result;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3483 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3484
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3485 MetadataType mdtype = (type == MetaspaceObj::ClassType) ? ClassType : NonClassType;
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3486
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3487 // Try to allocate metadata.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3488 MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3489
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3490 if (result == NULL) {
17769 bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3491 tracer()->report_metaspace_allocation_failure(loader_data, word_size, type, mdtype);
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3492
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3493 // Allocation failed.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3494 if (is_init_completed()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3495 // Only start a GC if the bootstrapping has completed.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3496
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3497 // Try to clean out some memory and retry.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3498 result = Universe::heap()->collector_policy()->satisfy_failed_metadata_allocation(
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3499 loader_data, word_size, mdtype);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3500 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3501 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3502
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3503 if (result == NULL) {
17770 5af31f70a866 8036701: Add trace event when a metaspace throws out of memory error ehelin parents: 17769 diff changeset	3504 report_metadata_oome(loader_data, word_size, type, mdtype, CHECK_NULL);
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3505 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3506
12902 bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3507 // Zero initialize.
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3508 Copy::fill_to_aligned_words((HeapWord*)result, word_size, 0);
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3509
bdfbb1fb19ca 8026391: The Metachunk header wastes memory stefank parents: 12839 diff changeset	3510 return result;
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3511 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3512
12998 a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3513 size_t Metaspace::class_chunk_size(size_t word_size) {
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3514 assert(using_class_space(), "Has to use class space");
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3515 return class_vsm()->calc_chunk_size(word_size);
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3516 }
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3517
17770 5af31f70a866 8036701: Add trace event when a metaspace throws out of memory error ehelin parents: 17769 diff changeset	3518 void Metaspace::report_metadata_oome(ClassLoaderData* loader_data, size_t word_size, MetaspaceObj::Type type, MetadataType mdtype, TRAPS) {
5af31f70a866 8036701: Add trace event when a metaspace throws out of memory error ehelin parents: 17769 diff changeset	3519 tracer()->report_metadata_oom(loader_data, word_size, type, mdtype);
5af31f70a866 8036701: Add trace event when a metaspace throws out of memory error ehelin parents: 17769 diff changeset	3520
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3521 // If result is still null, we are out of memory.
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3522 if (Verbose && TraceMetadataChunkAllocation) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3523 gclog_or_tty->print_cr("Metaspace allocation failed for size "
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3524 SIZE_FORMAT, word_size);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3525 if (loader_data->metaspace_or_null() != NULL) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3526 loader_data->dump(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3527 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3528 MetaspaceAux::dump(gclog_or_tty);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3529 }
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3530
12998 a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3531 bool out_of_compressed_class_space = false;
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3532 if (is_class_space_allocation(mdtype)) {
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3533 Metaspace* metaspace = loader_data->metaspace_non_null();
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3534 out_of_compressed_class_space =
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3535 MetaspaceAux::committed_bytes(Metaspace::ClassType) +
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3536 (metaspace->class_chunk_size(word_size) * BytesPerWord) >
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3537 CompressedClassSpaceSize;
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3538 }
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3539
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3540 // -XX:+HeapDumpOnOutOfMemoryError and -XX:OnOutOfMemoryError support
12998 a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3541 const char* space_string = out_of_compressed_class_space ?
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3542 "Compressed class space" : "Metaspace";
a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3543
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3544 report_java_out_of_memory(space_string);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3545
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3546 if (JvmtiExport::should_post_resource_exhausted()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3547 JvmtiExport::post_resource_exhausted(
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3548 JVMTI_RESOURCE_EXHAUSTED_OOM_ERROR,
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3549 space_string);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3550 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3551
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3552 if (!is_init_completed()) {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3553 vm_exit_during_initialization("OutOfMemoryError", space_string);
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3554 }
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3555
12998 a6177f601c64 8026822: metaspace/flags/maxMetaspaceSize throws OOM of unexpected type.java.lang.OutOfMemoryError: Compressed class space hseigel parents: 12906 diff changeset	3556 if (out_of_compressed_class_space) {
12838 85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3557 THROW_OOP(Universe::out_of_memory_error_class_metaspace());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3558 } else {
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3559 THROW_OOP(Universe::out_of_memory_error_metaspace());
85c1ca43713f 8024547: MaxMetaspaceSize should limit the committed memory used by the metaspaces stefank parents: 12340 diff changeset	3560 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3561 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3562
17769 bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3563 const char* Metaspace::metadata_type_name(Metaspace::MetadataType mdtype) {
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3564 switch (mdtype) {
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3565 case Metaspace::ClassType: return "Class";
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3566 case Metaspace::NonClassType: return "Metadata";
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3567 default:
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3568 assert(false, err_msg("Got bad mdtype: %d", (int) mdtype));
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3569 return NULL;
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3570 }
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3571 }
bc7714614ad8 8036699: Add trace event when a metaspace allocation fails ehelin parents: 17768 diff changeset	3572
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3573 void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3574 assert(DumpSharedSpaces, "sanity");
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3575
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3576 int byte_size = (int)word_size * HeapWordSize;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3577 AllocRecord *rec = new AllocRecord((address)ptr, type, byte_size);
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3578
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3579 if (_alloc_record_head == NULL) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3580 _alloc_record_head = _alloc_record_tail = rec;
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3581 } else if (_alloc_record_tail->_ptr + _alloc_record_tail->_byte_size == (address)ptr) {
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3582 _alloc_record_tail->_next = rec;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3583 _alloc_record_tail = rec;
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3584 } else {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3585 // slow linear search, but this doesn't happen that often, and only when dumping
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3586 for (AllocRecord *old = _alloc_record_head; old; old = old->_next) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3587 if (old->_ptr == ptr) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3588 assert(old->_type == MetaspaceObj::DeallocatedType, "sanity");
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3589 int remain_bytes = old->_byte_size - byte_size;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3590 assert(remain_bytes >= 0, "sanity");
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3591 old->_type = type;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3592
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3593 if (remain_bytes == 0) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3594 delete(rec);
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3595 } else {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3596 address remain_ptr = address(ptr) + byte_size;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3597 rec->_ptr = remain_ptr;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3598 rec->_byte_size = remain_bytes;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3599 rec->_type = MetaspaceObj::DeallocatedType;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3600 rec->_next = old->_next;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3601 old->_byte_size = byte_size;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3602 old->_next = rec;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3603 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3604 return;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3605 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3606 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3607 assert(0, "reallocating a freed pointer that was not recorded");
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3608 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3609 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3610
20375 6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3611 void Metaspace::record_deallocation(void* ptr, size_t word_size) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3612 assert(DumpSharedSpaces, "sanity");
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3613
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3614 for (AllocRecord *rec = _alloc_record_head; rec; rec = rec->_next) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3615 if (rec->_ptr == ptr) {
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3616 assert(rec->_byte_size == (int)word_size * HeapWordSize, "sanity");
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3617 rec->_type = MetaspaceObj::DeallocatedType;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3618 return;
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3619 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3620 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3621
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3622 assert(0, "deallocating a pointer that was not recorded");
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3623 }
6e0cb14ce59b 8046070: Class Data Sharing clean up and refactoring iklam parents: 20197 diff changeset	3624
10376 a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3625 void Metaspace::iterate(Metaspace::AllocRecordClosure *closure) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3626 assert(DumpSharedSpaces, "unimplemented for !DumpSharedSpaces");
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3627
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3628 address last_addr = (address)bottom();
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3629
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3630 for (AllocRecord *rec = _alloc_record_head; rec; rec = rec->_next) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3631 address ptr = rec->_ptr;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3632 if (last_addr < ptr) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3633 closure->doit(last_addr, MetaspaceObj::UnknownType, ptr - last_addr);
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3634 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3635 closure->doit(ptr, rec->_type, rec->_byte_size);
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3636 last_addr = ptr + rec->_byte_size;
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3637 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3638
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3639 address top = ((address)bottom()) + used_bytes_slow(Metaspace::NonClassType);
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3640 if (last_addr < top) {
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3641 closure->doit(last_addr, MetaspaceObj::UnknownType, top - last_addr);
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3642 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3643 }
a1ebd310d5c1 8014912: Restore PrintSharedSpaces functionality after NPG iklam parents: 10330 diff changeset	3644
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3645 void Metaspace::purge(MetadataType mdtype) {
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3646 get_space_list(mdtype)->purge(get_chunk_manager(mdtype));
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3647 }
b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3648
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	3649 void Metaspace::purge() {
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	3650 MutexLockerEx cl(SpaceManager::expand_lock(),
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	3651 Mutex::_no_safepoint_check_flag);
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3652 purge(NonClassType);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3653 if (using_class_space()) {
12303 b960c9df4f11 8025096: Move the ChunkManager instances out of the VirtualSpaceLists stefank parents: 12302 diff changeset	3654 purge(ClassType);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3655 }
10175 c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	3656 }
c23dbf0e8ab7 8011268: NPG: Free unused VirtualSpaceNodes jmasa parents: 10101 diff changeset	3657
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3658 void Metaspace::print_on(outputStream* out) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3659 // Print both class virtual space counts and metaspace.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3660 if (Verbose) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3661 vsm()->print_on(out);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3662 if (using_class_space()) {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3663 class_vsm()->print_on(out);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3664 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3665 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3666 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3667
17663 40353abd7984 8029178: Parallel class loading test anonymous-simple gets SIGSEGV in Metaspace::contains coleenp parents: 13439 diff changeset	3668 bool Metaspace::contains(const void* ptr) {
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3669 if (UseSharedSpaces && MetaspaceShared::is_in_shared_space(ptr)) {
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3670 return true;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3671 }
17935 7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3672
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3673 if (using_class_space() && get_space_list(ClassType)->contains(ptr)) {
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3674 return true;
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3675 }
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3676
7384f6a12fc1 8038212: Method::is_valid_method() check has performance regression impact for stackwalking coleenp parents: 17866 diff changeset	3677 return get_space_list(NonClassType)->contains(ptr);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3678 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3679
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3680 void Metaspace::verify() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3681 vsm()->verify();
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3682 if (using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3683 class_vsm()->verify();
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3684 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3685 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3686
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3687 void Metaspace::dump(outputStream* const out) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3688 out->print_cr("\nVirtual space manager: " INTPTR_FORMAT, vsm());
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3689 vsm()->dump(out);
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3690 if (using_class_space()) {
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3691 out->print_cr("\nClass space manager: " INTPTR_FORMAT, class_vsm());
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3692 class_vsm()->dump(out);
740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 11966 diff changeset	3693 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: diff changeset	3694 }
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3695
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3696 /////////////// Unit tests ///////////////
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3697
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3698 #ifndef PRODUCT
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3699
12306 03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3700 class TestMetaspaceAuxTest : AllStatic {
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3701 public:
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3702 static void test_reserved() {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3703 size_t reserved = MetaspaceAux::reserved_bytes();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3704
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3705 assert(reserved > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3706
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3707 size_t committed = MetaspaceAux::committed_bytes();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3708 assert(committed <= reserved, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3709
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3710 size_t reserved_metadata = MetaspaceAux::reserved_bytes(Metaspace::NonClassType);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3711 assert(reserved_metadata > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3712 assert(reserved_metadata <= reserved, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3713
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3714 if (UseCompressedClassPointers) {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3715 size_t reserved_class = MetaspaceAux::reserved_bytes(Metaspace::ClassType);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3716 assert(reserved_class > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3717 assert(reserved_class < reserved, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3718 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3719 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3720
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3721 static void test_committed() {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3722 size_t committed = MetaspaceAux::committed_bytes();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3723
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3724 assert(committed > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3725
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3726 size_t reserved = MetaspaceAux::reserved_bytes();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3727 assert(committed <= reserved, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3728
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3729 size_t committed_metadata = MetaspaceAux::committed_bytes(Metaspace::NonClassType);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3730 assert(committed_metadata > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3731 assert(committed_metadata <= committed, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3732
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3733 if (UseCompressedClassPointers) {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3734 size_t committed_class = MetaspaceAux::committed_bytes(Metaspace::ClassType);
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3735 assert(committed_class > 0, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3736 assert(committed_class < committed, "assert");
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3737 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3738 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3739
12306 03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3740 static void test_virtual_space_list_large_chunk() {
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3741 VirtualSpaceList* vs_list = new VirtualSpaceList(os::vm_allocation_granularity());
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3742 MutexLockerEx cl(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3743 // A size larger than VirtualSpaceSize (256k) and add one page to make it _not_ be
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3744 // vm_allocation_granularity aligned on Windows.
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3745 size_t large_size = (size_t)(2256K + (os::vm_page_size()/BytesPerWord));
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3746 large_size += (os::vm_page_size()/BytesPerWord);
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3747 vs_list->get_new_chunk(large_size, large_size, 0);
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3748 }
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3749
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3750 static void test() {
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3751 test_reserved();
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3752 test_committed();
12306 03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3753 test_virtual_space_list_large_chunk();
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3754 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3755 };
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3756
12306 03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3757 void TestMetaspaceAux_test() {
03f493ce3a71 8025228: assert(new_entry->reserved_words() == vs_word_size) fails in nightly brutisso parents: 12303 diff changeset	3758 TestMetaspaceAuxTest::test();
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3759 }
c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3760
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3761 class TestVirtualSpaceNodeTest {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3762 static void chunk_up(size_t words_left, size_t& num_medium_chunks,
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3763 size_t& num_small_chunks,
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3764 size_t& num_specialized_chunks) {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3765 num_medium_chunks = words_left / MediumChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3766 words_left = words_left % MediumChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3767
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3768 num_small_chunks = words_left / SmallChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3769 words_left = words_left % SmallChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3770 // how many specialized chunks can we get?
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3771 num_specialized_chunks = words_left / SpecializedChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3772 assert(words_left % SpecializedChunk == 0, "should be nothing left");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3773 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3774
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3775 public:
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3776 static void test() {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3777 MutexLockerEx ml(SpaceManager::expand_lock(), Mutex::_no_safepoint_check_flag);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3778 const size_t vsn_test_size_words = MediumChunk * 4;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3779 const size_t vsn_test_size_bytes = vsn_test_size_words * BytesPerWord;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3780
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3781 // The chunk sizes must be multiples of eachother, or this will fail
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3782 STATIC_ASSERT(MediumChunk % SmallChunk == 0);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3783 STATIC_ASSERT(SmallChunk % SpecializedChunk == 0);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3784
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3785 { // No committed memory in VSN
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3786 ChunkManager cm(SpecializedChunk, SmallChunk, MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3787 VirtualSpaceNode vsn(vsn_test_size_bytes);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3788 vsn.initialize();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3789 vsn.retire(&cm);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3790 assert(cm.sum_free_chunks_count() == 0, "did not commit any memory in the VSN");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3791 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3792
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3793 { // All of VSN is committed, half is used by chunks
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3794 ChunkManager cm(SpecializedChunk, SmallChunk, MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3795 VirtualSpaceNode vsn(vsn_test_size_bytes);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3796 vsn.initialize();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3797 vsn.expand_by(vsn_test_size_words, vsn_test_size_words);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3798 vsn.get_chunk_vs(MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3799 vsn.get_chunk_vs(MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3800 vsn.retire(&cm);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3801 assert(cm.sum_free_chunks_count() == 2, "should have been memory left for 2 medium chunks");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3802 assert(cm.sum_free_chunks() == 2*MediumChunk, "sizes should add up");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3803 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3804
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3805 { // 4 pages of VSN is committed, some is used by chunks
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3806 ChunkManager cm(SpecializedChunk, SmallChunk, MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3807 VirtualSpaceNode vsn(vsn_test_size_bytes);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3808 const size_t page_chunks = 4 * (size_t)os::vm_page_size() / BytesPerWord;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3809 assert(page_chunks < MediumChunk, "Test expects medium chunks to be at least 4*page_size");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3810 vsn.initialize();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3811 vsn.expand_by(page_chunks, page_chunks);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3812 vsn.get_chunk_vs(SmallChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3813 vsn.get_chunk_vs(SpecializedChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3814 vsn.retire(&cm);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3815
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3816 // committed - used = words left to retire
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3817 const size_t words_left = page_chunks - SmallChunk - SpecializedChunk;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3818
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3819 size_t num_medium_chunks, num_small_chunks, num_spec_chunks;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3820 chunk_up(words_left, num_medium_chunks, num_small_chunks, num_spec_chunks);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3821
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3822 assert(num_medium_chunks == 0, "should not get any medium chunks");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3823 assert(cm.sum_free_chunks_count() == (num_small_chunks + num_spec_chunks), "should be space for 3 chunks");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3824 assert(cm.sum_free_chunks() == words_left, "sizes should add up");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3825 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3826
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3827 { // Half of VSN is committed, a humongous chunk is used
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3828 ChunkManager cm(SpecializedChunk, SmallChunk, MediumChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3829 VirtualSpaceNode vsn(vsn_test_size_bytes);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3830 vsn.initialize();
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3831 vsn.expand_by(MediumChunk * 2, MediumChunk * 2);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3832 vsn.get_chunk_vs(MediumChunk + SpecializedChunk); // Humongous chunks will be aligned up to MediumChunk + SpecializedChunk
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3833 vsn.retire(&cm);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3834
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3835 const size_t words_left = MediumChunk * 2 - (MediumChunk + SpecializedChunk);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3836 size_t num_medium_chunks, num_small_chunks, num_spec_chunks;
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3837 chunk_up(words_left, num_medium_chunks, num_small_chunks, num_spec_chunks);
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3838
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3839 assert(num_medium_chunks == 0, "should not get any medium chunks");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3840 assert(cm.sum_free_chunks_count() == (num_small_chunks + num_spec_chunks), "should be space for 3 chunks");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3841 assert(cm.sum_free_chunks() == words_left, "sizes should add up");
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3842 }
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3843
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3844 }
13439 fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3845
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3846 #define assert_is_available_positive(word_size) \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3847 assert(vsn.is_available(word_size), \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3848 err_msg(#word_size ": " PTR_FORMAT " bytes were not available in " \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3849 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3850 (uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3851
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3852 #define assert_is_available_negative(word_size) \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3853 assert(!vsn.is_available(word_size), \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3854 err_msg(#word_size ": " PTR_FORMAT " bytes should not be available in " \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3855 "VirtualSpaceNode [" PTR_FORMAT ", " PTR_FORMAT ")", \
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3856 (uintptr_t)(word_size * BytesPerWord), vsn.bottom(), vsn.end()));
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3857
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3858 static void test_is_available_positive() {
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3859 // Reserve some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3860 VirtualSpaceNode vsn(os::vm_allocation_granularity());
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3861 assert(vsn.initialize(), "Failed to setup VirtualSpaceNode");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3862
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3863 // Commit some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3864 size_t commit_word_size = os::vm_allocation_granularity() / BytesPerWord;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3865 bool expanded = vsn.expand_by(commit_word_size, commit_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3866 assert(expanded, "Failed to commit");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3867
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3868 // Check that is_available accepts the committed size.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3869 assert_is_available_positive(commit_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3870
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3871 // Check that is_available accepts half the committed size.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3872 size_t expand_word_size = commit_word_size / 2;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3873 assert_is_available_positive(expand_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3874 }
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3875
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3876 static void test_is_available_negative() {
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3877 // Reserve some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3878 VirtualSpaceNode vsn(os::vm_allocation_granularity());
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3879 assert(vsn.initialize(), "Failed to setup VirtualSpaceNode");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3880
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3881 // Commit some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3882 size_t commit_word_size = os::vm_allocation_granularity() / BytesPerWord;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3883 bool expanded = vsn.expand_by(commit_word_size, commit_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3884 assert(expanded, "Failed to commit");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3885
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3886 // Check that is_available doesn't accept a too large size.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3887 size_t two_times_commit_word_size = commit_word_size * 2;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3888 assert_is_available_negative(two_times_commit_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3889 }
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3890
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3891 static void test_is_available_overflow() {
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3892 // Reserve some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3893 VirtualSpaceNode vsn(os::vm_allocation_granularity());
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3894 assert(vsn.initialize(), "Failed to setup VirtualSpaceNode");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3895
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3896 // Commit some memory.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3897 size_t commit_word_size = os::vm_allocation_granularity() / BytesPerWord;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3898 bool expanded = vsn.expand_by(commit_word_size, commit_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3899 assert(expanded, "Failed to commit");
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3900
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3901 // Calculate a size that will overflow the virtual space size.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3902 void* virtual_space_max = (void*)(uintptr_t)-1;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3903 size_t bottom_to_max = pointer_delta(virtual_space_max, vsn.bottom(), 1);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3904 size_t overflow_size = bottom_to_max + BytesPerWord;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3905 size_t overflow_word_size = overflow_size / BytesPerWord;
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3906
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3907 // Check that is_available can handle the overflow.
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3908 assert_is_available_negative(overflow_word_size);
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3909 }
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3910
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3911 static void test_is_available() {
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3912 TestVirtualSpaceNodeTest::test_is_available_positive();
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3913 TestVirtualSpaceNodeTest::test_is_available_negative();
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3914 TestVirtualSpaceNodeTest::test_is_available_overflow();
fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3915 }
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3916 };
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3917
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3918 void TestVirtualSpaceNode_test() {
1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3919 TestVirtualSpaceNodeTest::test();
13439 fa76dce60db7 8029106: JVM crashes in Metachunk::Metachunk during parallel class redefinition (PrivateMLetController, anonymous-simple_copy_1) stefank parents: 13068 diff changeset	3920 TestVirtualSpaceNodeTest::test_is_available();
12979 1d1ea10fe09f 8015255: NPG: Don't waste fragment at the end of a VirtualSpaceNode before retiring it. mgerdin parents: 12906 diff changeset	3921 }
12236 c4c768305a8f 8024638: Count and expose the amount of committed memory in the metaspaces stefank parents: 12235 diff changeset	3922 #endif

Mercurial > hg > truffle

annotate src/share/vm/memory/metaspace.cpp @ 20543:e7d0505c8a30