jdk8-mips64-public/hotspot: src/share/vm/memory/universe.hpp@09d00c18e323

     1 /*

     2  * Copyright (c) 1997, 2011, 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  */

    25 #ifndef SHARE_VM_MEMORY_UNIVERSE_HPP

    26 #define SHARE_VM_MEMORY_UNIVERSE_HPP

    28 #include "runtime/handles.hpp"

    29 #include "utilities/growableArray.hpp"

    31 // Universe is a name space holding known system classes and objects in the VM.

    32 //

    33 // Loaded classes are accessible through the SystemDictionary.

    34 //

    35 // The object heap is allocated and accessed through Universe, and various allocation

    36 // support is provided. Allocation by the interpreter and compiled code is done inline

    37 // and bails out to Scavenge::invoke_and_allocate.

    39 class CollectedHeap;

    40 class DeferredObjAllocEvent;

    43 // Common parts of a methodOop cache. This cache safely interacts with

    44 // the RedefineClasses API.

    45 //

    46 class CommonMethodOopCache : public CHeapObj {

    47   // We save the klassOop and the idnum of methodOop in order to get

    48   // the current cached methodOop.

    49  private:

    50   klassOop              _klass;

    51   int                   _method_idnum;

    53  public:

    54   CommonMethodOopCache()   { _klass = NULL; _method_idnum = -1; }

    55   ~CommonMethodOopCache()  { _klass = NULL; _method_idnum = -1; }

    57   void     init(klassOop k, methodOop m, TRAPS);

    58   klassOop klass() const         { return _klass; }

    59   int      method_idnum() const  { return _method_idnum; }

    61   // GC support

    62   void     oops_do(OopClosure* f)  { f->do_oop((oop*)&_klass); }

    63 };

    66 // A helper class for caching a methodOop when the user of the cache

    67 // cares about all versions of the methodOop.

    68 //

    69 class ActiveMethodOopsCache : public CommonMethodOopCache {

    70   // This subclass adds weak references to older versions of the

    71   // methodOop and a query method for a methodOop.

    73  private:

    74   // If the cached methodOop has not been redefined, then

    75   // _prev_methods will be NULL. If all of the previous

    76   // versions of the method have been collected, then

    77   // _prev_methods can have a length of zero.

    78   GrowableArray<jweak>* _prev_methods;

    80  public:

    81   ActiveMethodOopsCache()   { _prev_methods = NULL; }

    82   ~ActiveMethodOopsCache();

    84   void add_previous_version(const methodOop method);

    85   bool is_same_method(const methodOop method) const;

    86 };

    89 // A helper class for caching a methodOop when the user of the cache

    90 // only cares about the latest version of the methodOop.

    91 //

    92 class LatestMethodOopCache : public CommonMethodOopCache {

    93   // This subclass adds a getter method for the latest methodOop.

    95  public:

    96   methodOop get_methodOop();

    97 };

    99 // For UseCompressedOops.

   100 struct NarrowOopStruct {

   101   // Base address for oop-within-java-object materialization.

   102   // NULL if using wide oops or zero based narrow oops.

   103   address _base;

   104   // Number of shift bits for encoding/decoding narrow oops.

   105   // 0 if using wide oops or zero based unscaled narrow oops,

   106   // LogMinObjAlignmentInBytes otherwise.

   107   int     _shift;

   108   // Generate code with implicit null checks for narrow oops.

   109   bool    _use_implicit_null_checks;

   110 };

   112 enum VerifyOption {

   113       VerifyOption_Default = 0,

   115       // G1

   116       VerifyOption_G1UsePrevMarking = VerifyOption_Default,

   117       VerifyOption_G1UseNextMarking = VerifyOption_G1UsePrevMarking + 1,

   118       VerifyOption_G1UseMarkWord    = VerifyOption_G1UseNextMarking + 1

   119 };

   121 class Universe: AllStatic {

   122   // Ugh.  Universe is much too friendly.

   123   friend class MarkSweep;

   124   friend class oopDesc;

   125   friend class ClassLoader;

   126   friend class Arguments;

   127   friend class SystemDictionary;

   128   friend class VMStructs;

   129   friend class CompactingPermGenGen;

   130   friend class VM_PopulateDumpSharedSpace;

   132   friend jint  universe_init();

   133   friend void  universe2_init();

   134   friend bool  universe_post_init();

   136  private:

   137   // Known classes in the VM

   138   static klassOop _boolArrayKlassObj;

   139   static klassOop _byteArrayKlassObj;

   140   static klassOop _charArrayKlassObj;

   141   static klassOop _intArrayKlassObj;

   142   static klassOop _shortArrayKlassObj;

   143   static klassOop _longArrayKlassObj;

   144   static klassOop _singleArrayKlassObj;

   145   static klassOop _doubleArrayKlassObj;

   146   static klassOop _typeArrayKlassObjs[T_VOID+1];

   148   static klassOop _objectArrayKlassObj;

   150   static klassOop _methodKlassObj;

   151   static klassOop _constMethodKlassObj;

   152   static klassOop _methodDataKlassObj;

   153   static klassOop _klassKlassObj;

   154   static klassOop _arrayKlassKlassObj;

   155   static klassOop _objArrayKlassKlassObj;

   156   static klassOop _typeArrayKlassKlassObj;

   157   static klassOop _instanceKlassKlassObj;

   158   static klassOop _constantPoolKlassObj;

   159   static klassOop _constantPoolCacheKlassObj;

   160   static klassOop _compiledICHolderKlassObj;

   161   static klassOop _systemObjArrayKlassObj;

   163   // Known objects in the VM

   165   // Primitive objects

   166   static oop _int_mirror;

   167   static oop _float_mirror;

   168   static oop _double_mirror;

   169   static oop _byte_mirror;

   170   static oop _bool_mirror;

   171   static oop _char_mirror;

   172   static oop _long_mirror;

   173   static oop _short_mirror;

   174   static oop _void_mirror;

   176   static oop          _main_thread_group;             // Reference to the main thread group object

   177   static oop          _system_thread_group;           // Reference to the system thread group object

   179   static typeArrayOop _the_empty_byte_array;          // Canonicalized byte array

   180   static typeArrayOop _the_empty_short_array;         // Canonicalized short array

   181   static typeArrayOop _the_empty_int_array;           // Canonicalized int array

   182   static objArrayOop  _the_empty_system_obj_array;    // Canonicalized system obj array

   183   static objArrayOop  _the_empty_class_klass_array;   // Canonicalized obj array of type java.lang.Class

   184   static objArrayOop  _the_array_interfaces_array;    // Canonicalized 2-array of cloneable & serializable klasses

   185   static oop          _the_null_string;               // A cache of "null" as a Java string

   186   static oop          _the_min_jint_string;          // A cache of "-2147483648" as a Java string

   187   static LatestMethodOopCache* _finalizer_register_cache; // static method for registering finalizable objects

   188   static LatestMethodOopCache* _loader_addClass_cache;    // method for registering loaded classes in class loader vector

   189   static ActiveMethodOopsCache* _reflect_invoke_cache;    // method for security checks

   190   static oop          _out_of_memory_error_java_heap; // preallocated error object (no backtrace)

   191   static oop          _out_of_memory_error_perm_gen;  // preallocated error object (no backtrace)

   192   static oop          _out_of_memory_error_array_size;// preallocated error object (no backtrace)

   193   static oop          _out_of_memory_error_gc_overhead_limit; // preallocated error object (no backtrace)

   195   // array of preallocated error objects with backtrace

   196   static objArrayOop   _preallocated_out_of_memory_error_array;

   198   // number of preallocated error objects available for use

   199   static volatile jint _preallocated_out_of_memory_error_avail_count;

   201   static oop          _null_ptr_exception_instance;   // preallocated exception object

   202   static oop          _arithmetic_exception_instance; // preallocated exception object

   203   static oop          _virtual_machine_error_instance; // preallocated exception object

   204   // The object used as an exception dummy when exceptions are thrown for

   205   // the vm thread.

   206   static oop          _vm_exception;

   208   // The particular choice of collected heap.

   209   static CollectedHeap* _collectedHeap;

   211   // For UseCompressedOops.

   212   static struct NarrowOopStruct _narrow_oop;

   214   // array of dummy objects used with +FullGCAlot

   215   debug_only(static objArrayOop _fullgc_alot_dummy_array;)

   216   // index of next entry to clear

   217   debug_only(static int         _fullgc_alot_dummy_next;)

   219   // Compiler/dispatch support

   220   static int  _base_vtable_size;                      // Java vtbl size of klass Object (in words)

   222   // Initialization

   223   static bool _bootstrapping;                         // true during genesis

   224   static bool _fully_initialized;                     // true after universe_init and initialize_vtables called

   226   // the array of preallocated errors with backtraces

   227   static objArrayOop  preallocated_out_of_memory_errors()     { return _preallocated_out_of_memory_error_array; }

   229   // generate an out of memory error; if possible using an error with preallocated backtrace;

   230   // otherwise return the given default error.

   231   static oop        gen_out_of_memory_error(oop default_err);

   233   // Historic gc information

   234   static size_t _heap_capacity_at_last_gc;

   235   static size_t _heap_used_at_last_gc;

   237   static jint initialize_heap();

   238   static void initialize_basic_type_mirrors(TRAPS);

   239   static void fixup_mirrors(TRAPS);

   241   static void reinitialize_vtable_of(KlassHandle h_k, TRAPS);

   242   static void reinitialize_itables(TRAPS);

   243   static void compute_base_vtable_size();             // compute vtable size of class Object

   245   static void genesis(TRAPS);                         // Create the initial world

   247   // Mirrors for primitive classes (created eagerly)

   248   static oop check_mirror(oop m) {

   249     assert(m != NULL, "mirror not initialized");

   250     return m;

   251   }

   253   // Debugging

   254   static int _verify_count;                           // number of verifies done

   255   // True during call to verify().  Should only be set/cleared in verify().

   256   static bool _verify_in_progress;

   258   static void compute_verify_oop_data();

   260  public:

   261   // Known classes in the VM

   262   static klassOop boolArrayKlassObj()                 { return _boolArrayKlassObj;   }

   263   static klassOop byteArrayKlassObj()                 { return _byteArrayKlassObj;   }

   264   static klassOop charArrayKlassObj()                 { return _charArrayKlassObj;   }

   265   static klassOop intArrayKlassObj()                  { return _intArrayKlassObj;    }

   266   static klassOop shortArrayKlassObj()                { return _shortArrayKlassObj;  }

   267   static klassOop longArrayKlassObj()                 { return _longArrayKlassObj;   }

   268   static klassOop singleArrayKlassObj()               { return _singleArrayKlassObj; }

   269   static klassOop doubleArrayKlassObj()               { return _doubleArrayKlassObj; }

   271   static klassOop objectArrayKlassObj() {

   272     return _objectArrayKlassObj;

   273   }

   275   static klassOop typeArrayKlassObj(BasicType t) {

   276     assert((uint)t < T_VOID+1, "range check");

   277     assert(_typeArrayKlassObjs[t] != NULL, "domain check");

   278     return _typeArrayKlassObjs[t];

   279   }

   281   static klassOop methodKlassObj()                    { return _methodKlassObj;            }

   282   static klassOop constMethodKlassObj()               { return _constMethodKlassObj;         }

   283   static klassOop methodDataKlassObj()                { return _methodDataKlassObj;        }

   284   static klassOop klassKlassObj()                     { return _klassKlassObj;             }

   285   static klassOop arrayKlassKlassObj()                { return _arrayKlassKlassObj;        }

   286   static klassOop objArrayKlassKlassObj()             { return _objArrayKlassKlassObj;     }

   287   static klassOop typeArrayKlassKlassObj()            { return _typeArrayKlassKlassObj;    }

   288   static klassOop instanceKlassKlassObj()             { return _instanceKlassKlassObj;     }

   289   static klassOop constantPoolKlassObj()              { return _constantPoolKlassObj;      }

   290   static klassOop constantPoolCacheKlassObj()         { return _constantPoolCacheKlassObj; }

   291   static klassOop compiledICHolderKlassObj()          { return _compiledICHolderKlassObj;  }

   292   static klassOop systemObjArrayKlassObj()            { return _systemObjArrayKlassObj;    }

   294   // Known objects in the VM

   295   static oop int_mirror()                   { return check_mirror(_int_mirror); }

   296   static oop float_mirror()                 { return check_mirror(_float_mirror); }

   297   static oop double_mirror()                { return check_mirror(_double_mirror); }

   298   static oop byte_mirror()                  { return check_mirror(_byte_mirror); }

   299   static oop bool_mirror()                  { return check_mirror(_bool_mirror); }

   300   static oop char_mirror()                  { return check_mirror(_char_mirror); }

   301   static oop long_mirror()                  { return check_mirror(_long_mirror); }

   302   static oop short_mirror()                 { return check_mirror(_short_mirror); }

   303   static oop void_mirror()                  { return check_mirror(_void_mirror); }

   305   // table of same

   306   static oop _mirrors[T_VOID+1];

   308   static oop java_mirror(BasicType t) {

   309     assert((uint)t < T_VOID+1, "range check");

   310     return check_mirror(_mirrors[t]);

   311   }

   312   static oop      main_thread_group()                 { return _main_thread_group; }

   313   static void set_main_thread_group(oop group)        { _main_thread_group = group;}

   315   static oop      system_thread_group()               { return _system_thread_group; }

   316   static void set_system_thread_group(oop group)      { _system_thread_group = group;}

   318   static typeArrayOop the_empty_byte_array()          { return _the_empty_byte_array;          }

   319   static typeArrayOop the_empty_short_array()         { return _the_empty_short_array;         }

   320   static typeArrayOop the_empty_int_array()           { return _the_empty_int_array;           }

   321   static objArrayOop  the_empty_system_obj_array ()   { return _the_empty_system_obj_array;    }

   322   static objArrayOop  the_empty_class_klass_array ()  { return _the_empty_class_klass_array;   }

   323   static objArrayOop  the_array_interfaces_array()    { return _the_array_interfaces_array;    }

   324   static oop          the_null_string()               { return _the_null_string;               }

   325   static oop          the_min_jint_string()          { return _the_min_jint_string;          }

   326   static methodOop    finalizer_register_method()     { return _finalizer_register_cache->get_methodOop(); }

   327   static methodOop    loader_addClass_method()        { return _loader_addClass_cache->get_methodOop(); }

   328   static ActiveMethodOopsCache* reflect_invoke_cache() { return _reflect_invoke_cache; }

   329   static oop          null_ptr_exception_instance()   { return _null_ptr_exception_instance;   }

   330   static oop          arithmetic_exception_instance() { return _arithmetic_exception_instance; }

   331   static oop          virtual_machine_error_instance() { return _virtual_machine_error_instance; }

   332   static oop          vm_exception()                  { return _vm_exception; }

   334   // OutOfMemoryError support. Returns an error with the required message. The returned error

   335   // may or may not have a backtrace. If error has a backtrace then the stack trace is already

   336   // filled in.

   337   static oop out_of_memory_error_java_heap()          { return gen_out_of_memory_error(_out_of_memory_error_java_heap);  }

   338   static oop out_of_memory_error_perm_gen()           { return gen_out_of_memory_error(_out_of_memory_error_perm_gen);   }

   339   static oop out_of_memory_error_array_size()         { return gen_out_of_memory_error(_out_of_memory_error_array_size); }

   340   static oop out_of_memory_error_gc_overhead_limit()  { return gen_out_of_memory_error(_out_of_memory_error_gc_overhead_limit);  }

   342   // Accessors needed for fast allocation

   343   static klassOop* boolArrayKlassObj_addr()           { return &_boolArrayKlassObj;   }

   344   static klassOop* byteArrayKlassObj_addr()           { return &_byteArrayKlassObj;   }

   345   static klassOop* charArrayKlassObj_addr()           { return &_charArrayKlassObj;   }

   346   static klassOop* intArrayKlassObj_addr()            { return &_intArrayKlassObj;    }

   347   static klassOop* shortArrayKlassObj_addr()          { return &_shortArrayKlassObj;  }

   348   static klassOop* longArrayKlassObj_addr()           { return &_longArrayKlassObj;   }

   349   static klassOop* singleArrayKlassObj_addr()         { return &_singleArrayKlassObj; }

   350   static klassOop* doubleArrayKlassObj_addr()         { return &_doubleArrayKlassObj; }

   351   static klassOop* systemObjArrayKlassObj_addr()      { return &_systemObjArrayKlassObj; }

   353   // The particular choice of collected heap.

   354   static CollectedHeap* heap() { return _collectedHeap; }

   356   // For UseCompressedOops

   357   static address* narrow_oop_base_addr()              { return &_narrow_oop._base; }

   358   static address  narrow_oop_base()                   { return  _narrow_oop._base; }

   359   static bool  is_narrow_oop_base(void* addr)         { return (narrow_oop_base() == (address)addr); }

   360   static int      narrow_oop_shift()                  { return  _narrow_oop._shift; }

   361   static void     set_narrow_oop_base(address base)   { _narrow_oop._base  = base; }

   362   static void     set_narrow_oop_shift(int shift)     { _narrow_oop._shift = shift; }

   363   static bool     narrow_oop_use_implicit_null_checks()             { return  _narrow_oop._use_implicit_null_checks; }

   364   static void     set_narrow_oop_use_implicit_null_checks(bool use) { _narrow_oop._use_implicit_null_checks = use; }

   365   // Narrow Oop encoding mode:

   366   // 0 - Use 32-bits oops without encoding when

   367   //     NarrowOopHeapBaseMin + heap_size < 4Gb

   368   // 1 - Use zero based compressed oops with encoding when

   369   //     NarrowOopHeapBaseMin + heap_size < 32Gb

   370   // 2 - Use compressed oops with heap base + encoding.

   371   enum NARROW_OOP_MODE {

   372     UnscaledNarrowOop  = 0,

   373     ZeroBasedNarrowOop = 1,

   374     HeapBasedNarrowOop = 2

   375   };

   376   static char* preferred_heap_base(size_t heap_size, NARROW_OOP_MODE mode);

   378   // Historic gc information

   379   static size_t get_heap_capacity_at_last_gc()         { return _heap_capacity_at_last_gc; }

   380   static size_t get_heap_free_at_last_gc()             { return _heap_capacity_at_last_gc - _heap_used_at_last_gc; }

   381   static size_t get_heap_used_at_last_gc()             { return _heap_used_at_last_gc; }

   382   static void update_heap_info_at_gc();

   384   // Testers

   385   static bool is_bootstrapping()                      { return _bootstrapping; }

   386   static bool is_fully_initialized()                  { return _fully_initialized; }

   388   static inline bool element_type_should_be_aligned(BasicType type);

   389   static inline bool field_type_should_be_aligned(BasicType type);

   390   static bool        on_page_boundary(void* addr);

   391   static bool        should_fill_in_stack_trace(Handle throwable);

   392   static void check_alignment(uintx size, uintx alignment, const char* name);

   394   // Finalizer support.

   395   static void run_finalizers_on_exit();

   397   // Iteration

   399   // Apply "f" to the addresses of all the direct heap pointers maintained

   400   // as static fields of "Universe".

   401   static void oops_do(OopClosure* f, bool do_all = false);

   403   // Apply "f" to all klasses for basic types (classes not present in

   404   // SystemDictionary).

   405   static void basic_type_classes_do(void f(klassOop));

   407   // Apply "f" to all system klasses (classes not present in SystemDictionary).

   408   static void system_classes_do(void f(klassOop));

   410   // For sharing -- fill in a list of known vtable pointers.

   411   static void init_self_patching_vtbl_list(void** list, int count);

   413   // Debugging

   414   static bool verify_in_progress() { return _verify_in_progress; }

   415   static void verify(bool allow_dirty = true, bool silent = false,

   416                      VerifyOption option = VerifyOption_Default );

   417   static int  verify_count()       { return _verify_count; }

   418   // The default behavior is to call print_on() on gclog_or_tty.

   419   static void print();

   420   // The extended parameter determines which method on the heap will

   421   // be called: print_on() (extended == false) or print_extended_on()

   422   // (extended == true).

   423   static void print_on(outputStream* st, bool extended = false);

   424   static void print_heap_at_SIGBREAK();

   425   static void print_heap_before_gc() { print_heap_before_gc(gclog_or_tty); }

   426   static void print_heap_after_gc()  { print_heap_after_gc(gclog_or_tty); }

   427   static void print_heap_before_gc(outputStream* st, bool ignore_extended = false);

   428   static void print_heap_after_gc(outputStream* st, bool ignore_extended = false);

   430   // Change the number of dummy objects kept reachable by the full gc dummy

   431   // array; this should trigger relocation in a sliding compaction collector.

   432   debug_only(static bool release_fullgc_alot_dummy();)

   433   // The non-oop pattern (see compiledIC.hpp, etc)

   434   static void*   non_oop_word();

   436   // Oop verification (see MacroAssembler::verify_oop)

   437   static uintptr_t verify_oop_mask()          PRODUCT_RETURN0;

   438   static uintptr_t verify_oop_bits()          PRODUCT_RETURN0;

   439   static uintptr_t verify_mark_bits()         PRODUCT_RETURN0;

   440   static uintptr_t verify_mark_mask()         PRODUCT_RETURN0;

   441   static uintptr_t verify_klass_mask()        PRODUCT_RETURN0;

   442   static uintptr_t verify_klass_bits()        PRODUCT_RETURN0;

   444   // Flushing and deoptimization

   445   static void flush_dependents_on(instanceKlassHandle dependee);

   446   static void flush_dependents_on(Handle call_site, Handle method_handle);

   447 #ifdef HOTSWAP

   448   // Flushing and deoptimization in case of evolution

   449   static void flush_evol_dependents_on(instanceKlassHandle dependee);

   450 #endif // HOTSWAP

   451   // Support for fullspeed debugging

   452   static void flush_dependents_on_method(methodHandle dependee);

   454   // Compiler support

   455   static int base_vtable_size()               { return _base_vtable_size; }

   456 };

   458 class DeferredObjAllocEvent : public CHeapObj {

   459   private:

   460     oop    _oop;

   461     size_t _bytesize;

   462     jint   _arena_id;

   464   public:

   465     DeferredObjAllocEvent(const oop o, const size_t s, const jint id) {

   466       _oop      = o;

   467       _bytesize = s;

   468       _arena_id = id;

   469     }

   471     ~DeferredObjAllocEvent() {

   472     }

   474     jint   arena_id() { return _arena_id; }

   475     size_t bytesize() { return _bytesize; }

   476     oop    get_oop()  { return _oop; }

   477 };

   479 #endif // SHARE_VM_MEMORY_UNIVERSE_HPP

Mercurial > jdk8-mips64-public > hotspot / file revision

src/share/vm/memory/universe.hpp@09d00c18e323

src/share/vm/memory/universe.hpp