1 /*
  2  * Copyright (c) 2011, 2021, Oracle and/or its affiliates. All rights reserved.
  3  * Copyright (c) 2017, 2021 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 #ifndef SHARE_MEMORY_METASPACE_HPP
 26 #define SHARE_MEMORY_METASPACE_HPP
 27 
 28 #include "memory/allocation.hpp"
 29 #include "runtime/globals.hpp"
 30 #include "utilities/exceptions.hpp"
 31 #include "utilities/globalDefinitions.hpp"
 32 
 33 class ClassLoaderData;
 34 class MetaspaceShared;
 35 class MetaspaceTracer;
 36 class Mutex;
 37 class outputStream;
 38 class ReservedSpace;
 39 
 40 ////////////////// Metaspace ///////////////////////
 41 
 42 // Namespace for important central static functions
 43 // (auxiliary stuff goes into MetaspaceUtils)
 44 class Metaspace : public AllStatic {
 45 
 46   friend class MetaspaceShared;
 47 
 48 public:
 49   enum MetadataType {
 50     ClassType,
 51     NonClassType,
 52     MetadataTypeCount
 53   };
 54   enum MetaspaceType {
 55     ZeroMetaspaceType = 0,
 56     StandardMetaspaceType = ZeroMetaspaceType,
 57     BootMetaspaceType = StandardMetaspaceType + 1,
 58     ClassMirrorHolderMetaspaceType = BootMetaspaceType + 1,
 59     ReflectionMetaspaceType = ClassMirrorHolderMetaspaceType + 1,
 60     MetaspaceTypeCount
 61   };
 62 
 63 private:
 64 
 65   static const MetaspaceTracer* _tracer;
 66 
 67   static bool _initialized;
 68 
 69 public:
 70 
 71   static const MetaspaceTracer* tracer() { return _tracer; }
 72 
 73  private:
 74 
 75 #ifdef _LP64
 76 
 77   // Reserve a range of memory at an address suitable for en/decoding narrow
 78   // Klass pointers (see: CompressedClassPointers::is_valid_base()).
 79   // The returned address shall both be suitable as a compressed class pointers
 80   //  base, and aligned to Metaspace::reserve_alignment (which is equal to or a
 81   //  multiple of allocation granularity).
 82   // On error, returns an unreserved space.
 83   static ReservedSpace reserve_address_space_for_compressed_classes(size_t size);
 84 
 85   // Given a prereserved space, use that to set up the compressed class space list.
 86   static void initialize_class_space(ReservedSpace rs);
 87 
 88   // Returns true if class space has been setup (initialize_class_space).
 89   static bool class_space_is_initialized();
 90 
 91 #endif
 92 
 93  public:
 94 
 95   static void ergo_initialize();
 96   static void global_initialize();
 97   static void post_initialize();
 98 
 99   // Alignment, in bytes, of metaspace mappings
100   static size_t reserve_alignment()       { return reserve_alignment_words() * BytesPerWord; }
101   // Alignment, in words, of metaspace mappings
102   static size_t reserve_alignment_words();
103 
104   // The granularity at which Metaspace is committed and uncommitted.
105   // (Todo: Why does this have to be exposed?)
106   static size_t commit_alignment()        { return commit_alignment_words() * BytesPerWord; }
107   static size_t commit_alignment_words();
108 
109   // The largest possible single allocation
110   static size_t max_allocation_word_size();
111 
112   // The largest allowed size for class space
113   LP64_ONLY(static size_t max_class_space_size();)
114 
115   static MetaWord* allocate(ClassLoaderData* loader_data, size_t word_size,
116                             MetaspaceObj::Type type, TRAPS);
117 
118   // Non-TRAPS version of allocate which can be called by a non-Java thread, that returns
119   // NULL on failure.
120   static MetaWord* allocate(ClassLoaderData* loader_data, size_t word_size,
121                             MetaspaceObj::Type type);
122 
123   static bool contains(const void* ptr);
124   static bool contains_non_shared(const void* ptr);
125 
126   // Free empty virtualspaces
127   static void purge();
128 
129   static void report_metadata_oome(ClassLoaderData* loader_data, size_t word_size,
130                                    MetaspaceObj::Type type, MetadataType mdtype, TRAPS);
131 
132   static const char* metadata_type_name(Metaspace::MetadataType mdtype);
133 
134   static void print_compressed_class_space(outputStream* st) NOT_LP64({});
135 
136   // Return TRUE only if UseCompressedClassPointers is True.
137   static bool using_class_space() {
138     return NOT_LP64(false) LP64_ONLY(UseCompressedClassPointers);
139   }
140 
141   static bool is_class_space_allocation(MetadataType mdType) {
142     return mdType == ClassType && using_class_space();
143   }
144 
145   static bool initialized();
146 
147 };
148 
149 
150 #endif // SHARE_MEMORY_METASPACE_HPP