1 /*
  2  * Copyright (c) 2020, 2021, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2020 SAP SE. All rights reserved.
  4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  5  *
  6  * This code is free software; you can redistribute it and/or modify it
  7  * under the terms of the GNU General Public License version 2 only, as
  8  * published by the Free Software Foundation.
  9  *
 10  * This code is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 13  * version 2 for more details (a copy is included in the LICENSE file that
 14  * accompanied this code).
 15  *
 16  * You should have received a copy of the GNU General Public License version
 17  * 2 along with this work; if not, write to the Free Software Foundation,
 18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 19  *
 20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 21  * or visit www.oracle.com if you need additional information or have any
 22  * questions.
 23  *
 24  */
 25 
 26 #include "precompiled.hpp"
 27 #include "memory/metaspace.hpp"
 28 #include "memory/metaspaceUtils.hpp"
 29 #include "unittest.hpp"
 30 
 31 TEST_VM(MetaspaceUtils, reserved) {
 32   size_t reserved = MetaspaceUtils::reserved_bytes();
 33   EXPECT_GT(reserved, 0UL);
 34 
 35   size_t reserved_metadata = MetaspaceUtils::reserved_bytes(Metaspace::NonClassType);
 36   EXPECT_GT(reserved_metadata, 0UL);
 37   EXPECT_LE(reserved_metadata, reserved);
 38 }
 39 
 40 TEST_VM(MetaspaceUtils, reserved_compressed_class_pointers) {
 41   if (!UseCompressedClassPointers) {
 42     return;
 43   }
 44   size_t reserved = MetaspaceUtils::reserved_bytes();
 45   EXPECT_GT(reserved, 0UL);
 46 
 47   size_t reserved_class = MetaspaceUtils::reserved_bytes(Metaspace::ClassType);
 48   EXPECT_GT(reserved_class, 0UL);
 49   EXPECT_LE(reserved_class, reserved);
 50 }
 51 
 52 TEST_VM(MetaspaceUtils, committed) {
 53   size_t committed = MetaspaceUtils::committed_bytes();
 54   EXPECT_GT(committed, 0UL);
 55 
 56   size_t reserved  = MetaspaceUtils::reserved_bytes();
 57   EXPECT_LE(committed, reserved);
 58 
 59   size_t committed_metadata = MetaspaceUtils::committed_bytes(Metaspace::NonClassType);
 60   EXPECT_GT(committed_metadata, 0UL);
 61   EXPECT_LE(committed_metadata, committed);
 62 }
 63 
 64 TEST_VM(MetaspaceUtils, committed_compressed_class_pointers) {
 65   if (!UseCompressedClassPointers) {
 66     return;
 67   }
 68   size_t committed = MetaspaceUtils::committed_bytes();
 69   EXPECT_GT(committed, 0UL);
 70 
 71   size_t committed_class = MetaspaceUtils::committed_bytes(Metaspace::ClassType);
 72   EXPECT_GT(committed_class, 0UL);
 73   EXPECT_LE(committed_class, committed);
 74 }
 75 
 76 TEST_VM(MetaspaceUtils, non_compressed_class_pointers) {
 77   if (UseCompressedClassPointers) {
 78     return;
 79   }
 80 
 81   size_t committed_class = MetaspaceUtils::committed_bytes(Metaspace::ClassType);
 82   EXPECT_EQ(committed_class, 0UL);
 83 
 84   size_t used_class = MetaspaceUtils::used_bytes(Metaspace::ClassType);
 85   EXPECT_EQ(used_class, 0UL);
 86 
 87   size_t reserved_class = MetaspaceUtils::reserved_bytes(Metaspace::ClassType);
 88   EXPECT_EQ(reserved_class, 0UL);
 89 }
 90 
 91 static void check_metaspace_stats_are_consistent(const MetaspaceStats& stats) {
 92   EXPECT_LE(stats.committed(), stats.reserved());
 93   EXPECT_LE(stats.used(), stats.committed());
 94 }
 95 
 96 static void check_metaspace_stats_are_not_null(const MetaspaceStats& stats) {
 97   EXPECT_GT(stats.reserved(), 0UL);
 98   EXPECT_GT(stats.committed(), 0UL);
 99   EXPECT_GT(stats.used(), 0UL);
100 }
101 
102 TEST_VM(MetaspaceUtils, get_statistics) {
103   MetaspaceCombinedStats combined_stats = MetaspaceUtils::get_combined_statistics();
104   check_metaspace_stats_are_not_null(combined_stats);
105   check_metaspace_stats_are_consistent(combined_stats);
106   check_metaspace_stats_are_not_null(combined_stats.non_class_space_stats());
107   check_metaspace_stats_are_consistent(combined_stats.non_class_space_stats());
108 
109   if (UseCompressedClassPointers) {
110     check_metaspace_stats_are_not_null(combined_stats.class_space_stats());
111     check_metaspace_stats_are_consistent(combined_stats.class_space_stats());
112   } else {
113     // if we don't have a class space, combined stats should equal non-class stats
114     EXPECT_EQ(combined_stats.non_class_space_stats().reserved(), combined_stats.reserved());
115     EXPECT_EQ(combined_stats.non_class_space_stats().committed(), combined_stats.committed());
116     EXPECT_EQ(combined_stats.non_class_space_stats().used(), combined_stats.used());
117   }
118 }