1 /*
   2  * Copyright (c) 2012, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_MEMORY_METASPACESHARED_HPP
  26 #define SHARE_VM_MEMORY_METASPACESHARED_HPP
  27 
  28 #include "classfile/compactHashtable.hpp"
  29 #include "memory/allocation.hpp"
  30 #include "memory/memRegion.hpp"
  31 #include "memory/virtualspace.hpp"
  32 #include "utilities/exceptions.hpp"
  33 #include "utilities/macros.hpp"
  34 
  35 #define DEFAULT_SHARED_READ_WRITE_SIZE  (NOT_LP64(6*M) LP64_ONLY(10*M))
  36 #define MIN_SHARED_READ_WRITE_SIZE      (NOT_LP64(6*M) LP64_ONLY(10*M))
  37 
  38 #define DEFAULT_SHARED_READ_ONLY_SIZE   (NOT_LP64(8*M) LP64_ONLY(13*M))
  39 #define MIN_SHARED_READ_ONLY_SIZE       (NOT_LP64(8*M) LP64_ONLY(13*M))
  40 
  41 // the MIN_SHARED_MISC_DATA_SIZE and MIN_SHARED_MISC_CODE_SIZE estimates are based on
  42 // the sizes required for dumping the archive using the default classlist. The sizes
  43 // are multiplied by 1.5 for a safety margin.
  44 
  45 #define DEFAULT_SHARED_MISC_DATA_SIZE   (NOT_LP64(2*M) LP64_ONLY(4*M))
  46 #define MIN_SHARED_MISC_DATA_SIZE       (NOT_LP64(1*M) LP64_ONLY(1200*K))
  47 
  48 #define DEFAULT_SHARED_MISC_CODE_SIZE   (120*K)
  49 #define MIN_SHARED_MISC_CODE_SIZE       (NOT_LP64(63*K) LP64_ONLY(69*K))
  50 #define DEFAULT_COMBINED_SIZE           (DEFAULT_SHARED_READ_WRITE_SIZE+DEFAULT_SHARED_READ_ONLY_SIZE+DEFAULT_SHARED_MISC_DATA_SIZE+DEFAULT_SHARED_MISC_CODE_SIZE)
  51 
  52 // the max size is the MAX size (ie. 0x7FFFFFFF) - the total size of
  53 // the other 3 sections - page size (to avoid overflow in case the final
  54 // size will get aligned up on page size)
  55 #define SHARED_PAGE                     ((size_t)os::vm_page_size())
  56 #define MAX_SHARED_DELTA                (0x7FFFFFFF)
  57 #define MAX_SHARED_READ_WRITE_SIZE      (MAX_SHARED_DELTA-(MIN_SHARED_READ_ONLY_SIZE+MIN_SHARED_MISC_DATA_SIZE+MIN_SHARED_MISC_CODE_SIZE)-SHARED_PAGE)
  58 #define MAX_SHARED_READ_ONLY_SIZE       (MAX_SHARED_DELTA-(MIN_SHARED_READ_WRITE_SIZE+MIN_SHARED_MISC_DATA_SIZE+MIN_SHARED_MISC_CODE_SIZE)-SHARED_PAGE)
  59 #define MAX_SHARED_MISC_DATA_SIZE       (MAX_SHARED_DELTA-(MIN_SHARED_READ_WRITE_SIZE+MIN_SHARED_READ_ONLY_SIZE+MIN_SHARED_MISC_CODE_SIZE)-SHARED_PAGE)
  60 #define MAX_SHARED_MISC_CODE_SIZE       (MAX_SHARED_DELTA-(MIN_SHARED_READ_WRITE_SIZE+MIN_SHARED_READ_ONLY_SIZE+MIN_SHARED_MISC_DATA_SIZE)-SHARED_PAGE)
  61 
  62 #define LargeSharedArchiveSize          (300*M)
  63 #define HugeSharedArchiveSize           (800*M)
  64 #define ReadOnlyRegionPercentage        0.52
  65 #define ReadWriteRegionPercentage       0.43
  66 #define MiscDataRegionPercentage        0.03
  67 #define MiscCodeRegionPercentage        0.02
  68 #define LargeThresholdClassCount        5000
  69 #define HugeThresholdClassCount         40000
  70 
  71 #define SET_ESTIMATED_SIZE(type, region)                              \
  72   Shared ##region## Size  = FLAG_IS_DEFAULT(Shared ##region## Size) ? \
  73     (uintx)(type ## SharedArchiveSize *  region ## RegionPercentage) : Shared ## region ## Size
  74 
  75 class FileMapInfo;
  76 
  77 class MetaspaceSharedStats VALUE_OBJ_CLASS_SPEC {
  78 public:
  79   MetaspaceSharedStats() {
  80     memset(this, 0, sizeof(*this));
  81   }
  82   CompactHashtableStats symbol;
  83   CompactHashtableStats string;
  84 };
  85 
  86 class SharedMiscRegion VALUE_OBJ_CLASS_SPEC {
  87 private:
  88   VirtualSpace _vs;
  89   char* _alloc_top;
  90   SharedSpaceType _space_type;
  91 
  92 public:
  93   void initialize(ReservedSpace rs, size_t committed_byte_size,  SharedSpaceType space_type);
  94   VirtualSpace* virtual_space() {
  95     return &_vs;
  96   }
  97   char* low() const {
  98     return _vs.low();
  99   }
 100   char* alloc_top() const {
 101     return _alloc_top;
 102   }
 103   char* alloc(size_t num_bytes) NOT_CDS_RETURN_(NULL);
 104 };
 105 
 106 // Class Data Sharing Support
 107 class MetaspaceShared : AllStatic {
 108 
 109   // CDS support
 110   static ReservedSpace* _shared_rs;
 111   static int _max_alignment;
 112   static MetaspaceSharedStats _stats;
 113   static bool _has_error_classes;
 114   static bool _archive_loading_failed;
 115   static bool _remapped_readwrite;
 116   static address _cds_i2i_entry_code_buffers;
 117   static size_t  _cds_i2i_entry_code_buffers_size;
 118 
 119   // Used only during dumping.
 120   static SharedMiscRegion _md;
 121   static SharedMiscRegion _mc;
 122   static SharedMiscRegion _od;
 123  public:
 124   enum {
 125     ro = 0,  // read-only shared space in the heap
 126     rw = 1,  // read-write shared space in the heap
 127     md = 2,  // miscellaneous data for initializing tables, etc.
 128     mc = 3,  // miscellaneous code - vtable replacement.
 129     max_strings = 2, // max number of string regions in string space
 130     num_non_strings = 4, // number of non-string regions
 131     first_string = num_non_strings, // index of first string region
 132     // The optional data region is the last region.
 133     // Currently it only contains class file data.
 134     od = max_strings + num_non_strings,
 135     n_regions = od + 1 // total number of regions
 136   };
 137 
 138   // Accessor functions to save shared space created for metadata, which has
 139   // extra space allocated at the end for miscellaneous data and code.
 140   static void set_max_alignment(int alignment) {
 141     CDS_ONLY(_max_alignment = alignment);
 142   }
 143 
 144   static int max_alignment() {
 145     CDS_ONLY(return _max_alignment);
 146     NOT_CDS(return 0);
 147   }
 148 
 149   static void prepare_for_dumping() NOT_CDS_RETURN;
 150   static void preload_and_dump(TRAPS) NOT_CDS_RETURN;
 151   static int preload_and_dump(const char * class_list_path,
 152                               GrowableArray<Klass*>* class_promote_order,
 153                               TRAPS) NOT_CDS_RETURN_(0);
 154 
 155   static ReservedSpace* shared_rs() {
 156     CDS_ONLY(return _shared_rs);
 157     NOT_CDS(return NULL);
 158   }
 159 
 160   static void initialize_shared_rs(ReservedSpace* rs) NOT_CDS_RETURN;
 161 
 162   static void set_archive_loading_failed() {
 163     _archive_loading_failed = true;
 164   }
 165   static bool map_shared_spaces(FileMapInfo* mapinfo) NOT_CDS_RETURN_(false);
 166   static void initialize_shared_spaces() NOT_CDS_RETURN;
 167   static void fixup_shared_string_regions() NOT_CDS_RETURN;
 168 
 169   // Return true if given address is in the mapped shared space.
 170   static bool is_in_shared_space(const void* p) NOT_CDS_RETURN_(false);
 171 
 172   // Return true if given address is in the shared region corresponding to the idx
 173   static bool is_in_shared_region(const void* p, int idx) NOT_CDS_RETURN_(false);
 174 
 175   static bool is_string_region(int idx) NOT_CDS_RETURN_(false);
 176 
 177   static intptr_t* allocate_cpp_vtable_clones(intptr_t* top, intptr_t* end);
 178   static intptr_t* clone_cpp_vtables(intptr_t* p);
 179   static void zero_cpp_vtable_clones_for_writing();
 180   static void patch_cpp_vtable_pointers();
 181   static bool is_valid_shared_method(const Method* m);
 182 
 183   static void serialize(SerializeClosure* sc, GrowableArray<MemRegion> *string_space,
 184                         size_t* space_size);
 185 
 186   static MetaspaceSharedStats* stats() {
 187     return &_stats;
 188   }
 189 
 190   // JVM/TI RedefineClasses() support:
 191   // Remap the shared readonly space to shared readwrite, private if
 192   // sharing is enabled. Simply returns true if sharing is not enabled
 193   // or if the remapping has already been done by a prior call.
 194   static bool remap_shared_readonly_as_readwrite() NOT_CDS_RETURN_(true);
 195   static bool remapped_readwrite() {
 196     CDS_ONLY(return _remapped_readwrite);
 197     NOT_CDS(return false);
 198   }
 199 
 200   static void print_shared_spaces();
 201 
 202   static bool try_link_class(InstanceKlass* ik, TRAPS);
 203   static void link_and_cleanup_shared_classes(TRAPS);
 204   static void check_shared_class_loader_type(Klass* obj);
 205 
 206   static int count_class(const char* classlist_file);
 207   static void estimate_regions_size() NOT_CDS_RETURN;
 208 
 209   // Allocate a block of memory from the "mc", "md", or "od" regions.
 210   static char* misc_code_space_alloc(size_t num_bytes) {  return _mc.alloc(num_bytes); }
 211   static char* misc_data_space_alloc(size_t num_bytes) {  return _md.alloc(num_bytes); }
 212   static char* optional_data_space_alloc(size_t num_bytes) { return _od.alloc(num_bytes); }
 213 
 214   static address cds_i2i_entry_code_buffers(size_t total_size);
 215 
 216   static address cds_i2i_entry_code_buffers() {
 217     return _cds_i2i_entry_code_buffers;
 218   }
 219   static size_t cds_i2i_entry_code_buffers_size() {
 220     return _cds_i2i_entry_code_buffers_size;
 221   }
 222 
 223   static SharedMiscRegion* misc_code_region() {
 224     assert(DumpSharedSpaces, "used during dumping only");
 225     return &_mc;
 226   }
 227   static SharedMiscRegion* misc_data_region() {
 228     assert(DumpSharedSpaces, "used during dumping only");
 229     return &_md;
 230   }
 231   static SharedMiscRegion* optional_data_region() {
 232     assert(DumpSharedSpaces, "used during dumping only");
 233     return &_od;
 234   }
 235 };
 236 #endif // SHARE_VM_MEMORY_METASPACESHARED_HPP