1 /* 2 * Copyright (c) 2018, 2020, Oracle and/or its affiliates. All rights reserved. 3 * Copyright (c) 2018, 2020 SAP SE. All rights reserved. 4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 5 * 6 * This code is free software; you can redistribute it and/or modify it 7 * under the terms of the GNU General Public License version 2 only, as 8 * published by the Free Software Foundation. 9 * 10 * This code is distributed in the hope that it will be useful, but WITHOUT 11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 * version 2 for more details (a copy is included in the LICENSE file that 14 * accompanied this code). 15 * 16 * You should have received a copy of the GNU General Public License version 17 * 2 along with this work; if not, write to the Free Software Foundation, 18 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 19 * 20 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 21 * or visit www.oracle.com if you need additional information or have any 22 * questions. 23 * 24 */ 25 26 #ifndef SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP 27 #define SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP 28 29 #include "runtime/globals.hpp" 30 #include "utilities/align.hpp" 31 #include "utilities/debug.hpp" 32 #include "utilities/globalDefinitions.hpp" 33 34 class outputStream; 35 36 namespace metaspace { 37 38 39 // Metaspace allocation alignment: 40 41 // 1) Metaspace allocations have to be aligned such that 64bit values are aligned 42 // correctly. 43 // 44 // 2) Klass* structures allocated from Metaspace have to be aligned to KlassAlignmentInBytes. 45 // 46 // At the moment LogKlassAlignmentInBytes is 3, so KlassAlignmentInBytes == 8, 47 // so (1) and (2) can both be fulfilled with an alignment of 8. Should we increase 48 // KlassAlignmentInBytes at any time this will increase the necessary alignment as well. In 49 // that case we may think about introducing a separate alignment just for the class space 50 // since that alignment would only be needed for Klass structures. 51 52 static const size_t allocation_alignment_bytes = 8; 53 STATIC_ASSERT(allocation_alignment_bytes == (size_t)KlassAlignmentInBytes); 54 55 static const size_t allocation_alignment_words = allocation_alignment_bytes / BytesPerWord; 56 57 // Returns the raw word size allocated for a given net allocation 58 size_t get_raw_word_size_for_requested_word_size(size_t word_size); 59 60 61 // Utility functions 62 63 // Print a size, in words, scaled. 64 void print_scaled_words(outputStream* st, size_t word_size, size_t scale = 0, int width = -1); 65 66 // Convenience helper: prints a size value and a percentage. 67 void print_scaled_words_and_percentage(outputStream* st, size_t word_size, size_t compare_word_size, size_t scale = 0, int width = -1); 68 69 // Print a human readable size. 70 // byte_size: size, in bytes, to be printed. 71 // scale: one of 1 (byte-wise printing), sizeof(word) (word-size printing), K, M, G (scaled by KB, MB, GB respectively, 72 // or 0, which means the best scale is choosen dynamically. 73 // width: printing width. 74 void print_human_readable_size(outputStream* st, size_t byte_size, size_t scale = 0, int width = -1); 75 76 // Prints a percentage value. Values smaller than 1% but not 0 are displayed as "<1%", values 77 // larger than 99% but not 100% are displayed as ">100%". 78 void print_percentage(outputStream* st, size_t total, size_t part); 79 80 81 #ifdef ASSERT 82 #define assert_is_aligned(value, alignment) \ 83 assert(is_aligned((value), (alignment)), \ 84 SIZE_FORMAT_HEX " is not aligned to " \ 85 SIZE_FORMAT_HEX, (size_t)(uintptr_t)value, (size_t)(alignment)) 86 #else 87 #define assert_is_aligned(value, alignment) 88 #endif 89 90 91 // Pretty printing helpers 92 const char* classes_plural(uintx num); 93 const char* loaders_plural(uintx num); 94 void print_number_of_classes(outputStream* out, uintx classes, uintx classes_shared); 95 96 97 // Since Metaspace verifications are expensive, we want to do them at a reduced rate, 98 // but not completely avoiding them. 99 // For that we introduce the macros SOMETIMES() and ASSERT_SOMETIMES() which will 100 // execute code or assert at intervals controlled via VerifyMetaspaceInterval. 101 #ifdef ASSERT 102 103 #define EVERY_NTH(n) \ 104 { static int counter_ = 0; \ 105 if (n > 0) { \ 106 counter_ ++; \ 107 if (counter_ > n) { \ 108 counter_ = 0; \ 109 110 #define END_EVERY_NTH } } } 111 112 #define SOMETIMES(code) \ 113 EVERY_NTH(VerifyMetaspaceInterval) \ 114 { code } \ 115 END_EVERY_NTH 116 117 #define ASSERT_SOMETIMES(condition, ...) \ 118 EVERY_NTH(VerifyMetaspaceInterval) \ 119 assert( (condition), __VA_ARGS__); \ 120 END_EVERY_NTH 121 122 #else 123 124 #define SOMETIMES(code) 125 #define ASSERT_SOMETIMES(condition, ...) 126 127 #endif // ASSERT 128 129 ///////// Logging ////////////// 130 131 // What we log at which levels: 132 133 // "info" : metaspace failed allocation, commit failure, reserve failure, metaspace oom, metaspace gc threshold changed, Arena created, destroyed, metaspace purged 134 135 // "debug" : "info" + vslist extended, memory committed/uncommitted, chunk created/split/merged/enlarged, chunk returned 136 137 // "trace" : "debug" + every single allocation and deallocation, internals 138 139 #define HAVE_UL 140 141 #ifdef HAVE_UL 142 #define UL(level, message) log_##level(metaspace)(LOGFMT ": " message, LOGFMT_ARGS); 143 #define UL2(level, message, ...) log_##level(metaspace)(LOGFMT ": " message, LOGFMT_ARGS, __VA_ARGS__); 144 #else 145 #define UL(level, ...) 146 #define UL2(level, ...) 147 #endif 148 149 } // namespace metaspace 150 151 #endif // SHARE_MEMORY_METASPACE_METASPACECOMMON_HPP