--- /dev/null 2018-04-24 09:11:08.850175259 +0200 +++ new/src/hotspot/share/memory/metaspace/metaspaceStatistics.hpp 2018-04-24 07:16:47.333262615 +0200 @@ -0,0 +1,189 @@ +/* + * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2018, SAP and/or its affiliates. All rights reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA + * or visit www.oracle.com if you need additional information or have any + * questions. + * + */ + +#ifndef SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP_ +#define SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP_ + +#include "utilities/globalDefinitions.hpp" +#include "memory/metachunk.hpp" // for ChunkIndex enum +#include "memory/metaspace.hpp" // for MetadataType enum + +class outputStream; + +namespace metaspace { +namespace internals { + +// Contains statistics for a number of free chunks. +class FreeChunksStatistics { + uintx _num; // Number of chunks + size_t _cap; // Total capacity, in words + +public: + FreeChunksStatistics(); + + void reset(); + + uintx num() const { return _num; } + size_t cap() const { return _cap; } + + void add(uintx n, size_t s); + void add(const FreeChunksStatistics& other); + void print_on(outputStream* st, size_t scale) const; + +}; // end: FreeChunksStatistics + + +// Contains statistics for a ChunkManager. +class ChunkManagerStatistics { + + FreeChunksStatistics _chunk_stats[NumberOfInUseLists]; + +public: + + // Free chunk statistics, by chunk index. + const FreeChunksStatistics& chunk_stats(ChunkIndex index) const { return _chunk_stats[index]; } + FreeChunksStatistics& chunk_stats(ChunkIndex index) { return _chunk_stats[index]; } + + void reset(); + size_t total_capacity() const; + + void print_on(outputStream* st, size_t scale) const; + +}; // ChunkManagerStatistics + +// Contains statistics for a number of chunks in use. +// Each chunk has a used and free portion; however, there are current chunks (serving +// potential future metaspace allocations) and non-current chunks. Unused portion of the +// former is counted as free, unused portion of the latter counts as waste. +class UsedChunksStatistics { + uintx _num; // Number of chunks + size_t _cap; // Total capacity in words. + size_t _used; // Total used area, in words + size_t _free; // Total free area (unused portions of current chunks), in words + size_t _waste; // Total waste area (unused portions of non-current chunks), in words + size_t _overhead; // Total sum of chunk overheads, in words. + +public: + + UsedChunksStatistics(); + + void reset(); + + uintx num() const { return _num; } + + // Total capacity, in words + size_t cap() const { return _cap; } + + // Total used area, in words + size_t used() const { return _used; } + + // Total free area (unused portions of current chunks), in words + size_t free() const { return _free; } + + // Total waste area (unused portions of non-current chunks), in words + size_t waste() const { return _waste; } + + // Total area spent in overhead (chunk headers), in words + size_t overhead() const { return _overhead; } + + void add_num(uintx n) { _num += n; } + void add_cap(size_t s) { _cap += s; } + void add_used(size_t s) { _used += s; } + void add_free(size_t s) { _free += s; } + void add_waste(size_t s) { _waste += s; } + void add_overhead(size_t s) { _overhead += s; } + + void add(const UsedChunksStatistics& other); + + void print_on(outputStream* st, size_t scale) const; + +#ifdef ASSERT + void check_sanity() const; +#endif + +}; // UsedChunksStatistics + +// Class containing statistics for one or more space managers. +class SpaceManagerStatistics { + + UsedChunksStatistics _chunk_stats[NumberOfInUseLists]; + uintx _free_blocks_num; + size_t _free_blocks_cap_words; + +public: + + SpaceManagerStatistics(); + + // Chunk statistics by chunk index + const UsedChunksStatistics& chunk_stats(ChunkIndex index) const { return _chunk_stats[index]; } + UsedChunksStatistics& chunk_stats(ChunkIndex index) { return _chunk_stats[index]; } + + uintx free_blocks_num () const { return _free_blocks_num; } + size_t free_blocks_cap_words () const { return _free_blocks_cap_words; } + + void reset(); + + void add_free_blocks_info(uintx num, size_t cap); + + // Returns total chunk statistics over all chunk types. + UsedChunksStatistics totals() const; + + void add(const SpaceManagerStatistics& other); + + void print_on(outputStream* st, size_t scale, bool detailed) const; + +}; // SpaceManagerStatistics + +class ClassLoaderMetaspaceStatistics { + + SpaceManagerStatistics _sm_stats[Metaspace::MetadataTypeCount]; + +public: + + ClassLoaderMetaspaceStatistics(); + + const SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) const { return _sm_stats[mdType]; } + SpaceManagerStatistics& sm_stats(Metaspace::MetadataType mdType) { return _sm_stats[mdType]; } + + const SpaceManagerStatistics& nonclass_sm_stats() const { return sm_stats(Metaspace::NonClassType); } + SpaceManagerStatistics& nonclass_sm_stats() { return sm_stats(Metaspace::NonClassType); } + const SpaceManagerStatistics& class_sm_stats() const { return sm_stats(Metaspace::ClassType); } + SpaceManagerStatistics& class_sm_stats() { return sm_stats(Metaspace::ClassType); } + + void reset(); + + void add(const ClassLoaderMetaspaceStatistics& other); + + // Returns total space manager statistics for both class and non-class metaspace + SpaceManagerStatistics totals() const; + + void print_on(outputStream* st, size_t scale, bool detailed) const; + +}; // ClassLoaderMetaspaceStatistics + +} // namespace internals +} // namespace metaspace + +#endif /* SHARE_MEMORY_METASPACE_METASPACESTATISTICS_HPP_ */