821 gc_policy->initialize_all();
822
823 Universe::_collectedHeap = new GenCollectedHeap(gc_policy);
824 }
825
826 ThreadLocalAllocBuffer::set_max_size(Universe::heap()->max_tlab_size());
827
828 jint status = Universe::heap()->initialize();
829 if (status != JNI_OK) {
830 return status;
831 }
832
833 #ifdef _LP64
834 if (UseCompressedOops) {
835 // Subtract a page because something can get allocated at heap base.
836 // This also makes implicit null checking work, because the
837 // memory+1 page below heap_base needs to cause a signal.
838 // See needs_explicit_null_check.
839 // Only set the heap base for compressed oops because it indicates
840 // compressed oops for pstack code.
841 bool verbose = PrintCompressedOopsMode || (PrintMiscellaneous && Verbose);
842 if (verbose) {
843 tty->cr();
844 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
845 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
846 }
847 if (((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax)) {
848 // Can't reserve heap below 32Gb.
849 // keep the Universe::narrow_oop_base() set in Universe::reserve_heap()
850 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
851 #ifdef AIX
852 // There is no protected page before the heap. This assures all oops
853 // are decoded so that NULL is preserved, so this page will not be accessed.
854 Universe::set_narrow_oop_use_implicit_null_checks(false);
855 #endif
856 if (verbose) {
857 tty->print(", %s: "PTR_FORMAT,
858 narrow_oop_mode_to_string(HeapBasedNarrowOop),
859 Universe::narrow_oop_base());
860 }
861 } else {
862 Universe::set_narrow_oop_base(0);
863 if (verbose) {
864 tty->print(", %s", narrow_oop_mode_to_string(ZeroBasedNarrowOop));
865 }
866 #ifdef _WIN64
867 if (!Universe::narrow_oop_use_implicit_null_checks()) {
868 // Don't need guard page for implicit checks in indexed addressing
869 // mode with zero based Compressed Oops.
870 Universe::set_narrow_oop_use_implicit_null_checks(true);
871 }
872 #endif // _WIN64
873 if((uint64_t)Universe::heap()->reserved_region().end() > UnscaledOopHeapMax) {
874 // Can't reserve heap below 4Gb.
875 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
876 } else {
877 Universe::set_narrow_oop_shift(0);
878 if (verbose) {
879 tty->print(", %s", narrow_oop_mode_to_string(UnscaledNarrowOop));
880 }
881 }
882 }
883
884 if (verbose) {
885 tty->cr();
886 tty->cr();
887 }
888 Universe::set_narrow_ptrs_base(Universe::narrow_oop_base());
889 }
890 // Universe::narrow_oop_base() is one page below the heap.
891 assert((intptr_t)Universe::narrow_oop_base() <= (intptr_t)(Universe::heap()->base() -
892 os::vm_page_size()) ||
893 Universe::narrow_oop_base() == NULL, "invalid value");
894 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes ||
895 Universe::narrow_oop_shift() == 0, "invalid value");
896 #endif
897
898 // We will never reach the CATCH below since Exceptions::_throw will cause
899 // the VM to exit if an exception is thrown during initialization
900
901 if (UseTLAB) {
902 assert(Universe::heap()->supports_tlab_allocation(),
903 "Should support thread-local allocation buffers");
904 ThreadLocalAllocBuffer::startup_initialization();
905 }
906 return JNI_OK;
907 }
908
909
910 // Reserve the Java heap, which is now the same for all GCs.
911 ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) {
912 assert(alignment <= Arguments::conservative_max_heap_alignment(),
913 err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT,
914 alignment, Arguments::conservative_max_heap_alignment()));
915 size_t total_reserved = align_size_up(heap_size, alignment);
916 assert(!UseCompressedOops || (total_reserved <= (OopEncodingHeapMax - os::vm_page_size())),
917 "heap size is too big for compressed oops");
918
919 bool use_large_pages = UseLargePages && is_size_aligned(alignment, os::large_page_size());
920 assert(!UseLargePages
921 || UseParallelGC
922 || use_large_pages, "Wrong alignment to use large pages");
923
924 char* addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::UnscaledNarrowOop);
925
926 ReservedHeapSpace total_rs(total_reserved, alignment, use_large_pages, addr);
927
928 if (UseCompressedOops) {
958 // Universe::initialize_heap() will reset this to NULL if unscaled
959 // or zero-based narrow oops are actually used.
960 address base = (address)(total_rs.base() - os::vm_page_size());
961 Universe::set_narrow_oop_base(base);
962 }
963 return total_rs;
964 }
965
966
967 // It's the caller's responsibility to ensure glitch-freedom
968 // (if required).
969 void Universe::update_heap_info_at_gc() {
970 _heap_capacity_at_last_gc = heap()->capacity();
971 _heap_used_at_last_gc = heap()->used();
972 }
973
974
975 const char* Universe::narrow_oop_mode_to_string(Universe::NARROW_OOP_MODE mode) {
976 switch (mode) {
977 case UnscaledNarrowOop:
978 return "32-bits Oops";
979 case ZeroBasedNarrowOop:
980 return "zero based Compressed Oops";
981 case HeapBasedNarrowOop:
982 return "Compressed Oops with base";
983 }
984
985 ShouldNotReachHere();
986 return "";
987 }
988
989
990 Universe::NARROW_OOP_MODE Universe::narrow_oop_mode() {
991 if (narrow_oop_base() != 0) {
992 return HeapBasedNarrowOop;
993 }
994
995 if (narrow_oop_shift() != 0) {
996 return ZeroBasedNarrowOop;
997 }
998
999 return UnscaledNarrowOop;
1000 }
1001
1002
|
821 gc_policy->initialize_all();
822
823 Universe::_collectedHeap = new GenCollectedHeap(gc_policy);
824 }
825
826 ThreadLocalAllocBuffer::set_max_size(Universe::heap()->max_tlab_size());
827
828 jint status = Universe::heap()->initialize();
829 if (status != JNI_OK) {
830 return status;
831 }
832
833 #ifdef _LP64
834 if (UseCompressedOops) {
835 // Subtract a page because something can get allocated at heap base.
836 // This also makes implicit null checking work, because the
837 // memory+1 page below heap_base needs to cause a signal.
838 // See needs_explicit_null_check.
839 // Only set the heap base for compressed oops because it indicates
840 // compressed oops for pstack code.
841 if (((uint64_t)Universe::heap()->reserved_region().end() > OopEncodingHeapMax)) {
842 // Can't reserve heap below 32Gb.
843 // keep the Universe::narrow_oop_base() set in Universe::reserve_heap()
844 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
845 #ifdef AIX
846 // There is no protected page before the heap. This assures all oops
847 // are decoded so that NULL is preserved, so this page will not be accessed.
848 Universe::set_narrow_oop_use_implicit_null_checks(false);
849 #endif
850 } else {
851 Universe::set_narrow_oop_base(0);
852 #ifdef _WIN64
853 if (!Universe::narrow_oop_use_implicit_null_checks()) {
854 // Don't need guard page for implicit checks in indexed addressing
855 // mode with zero based Compressed Oops.
856 Universe::set_narrow_oop_use_implicit_null_checks(true);
857 }
858 #endif // _WIN64
859 if((uint64_t)Universe::heap()->reserved_region().end() > UnscaledOopHeapMax) {
860 // Can't reserve heap below 4Gb.
861 Universe::set_narrow_oop_shift(LogMinObjAlignmentInBytes);
862 } else {
863 Universe::set_narrow_oop_shift(0);
864 }
865 }
866
867 Universe::set_narrow_ptrs_base(Universe::narrow_oop_base());
868
869 if (PrintCompressedOopsMode || (PrintMiscellaneous && Verbose)) {
870 Universe::print_compressed_oops_mode();
871 }
872 }
873 // Universe::narrow_oop_base() is one page below the heap.
874 assert((intptr_t)Universe::narrow_oop_base() <= (intptr_t)(Universe::heap()->base() -
875 os::vm_page_size()) ||
876 Universe::narrow_oop_base() == NULL, "invalid value");
877 assert(Universe::narrow_oop_shift() == LogMinObjAlignmentInBytes ||
878 Universe::narrow_oop_shift() == 0, "invalid value");
879 #endif
880
881 // We will never reach the CATCH below since Exceptions::_throw will cause
882 // the VM to exit if an exception is thrown during initialization
883
884 if (UseTLAB) {
885 assert(Universe::heap()->supports_tlab_allocation(),
886 "Should support thread-local allocation buffers");
887 ThreadLocalAllocBuffer::startup_initialization();
888 }
889 return JNI_OK;
890 }
891
892 void Universe::print_compressed_oops_mode() {
893 tty->cr();
894 tty->print("heap address: " PTR_FORMAT ", size: " SIZE_FORMAT " MB",
895 Universe::heap()->base(), Universe::heap()->reserved_region().byte_size()/M);
896
897 tty->print(", Compressed Oops mode: %s", narrow_oop_mode_to_string(narrow_oop_mode()));
898
899 if (Universe::narrow_oop_base() != 0) {
900 tty->print(":" PTR_FORMAT, Universe::narrow_oop_base());
901 }
902
903 if (Universe::narrow_oop_shift() != 0) {
904 tty->print(", Oop shift amount: %d", Universe::narrow_oop_shift());
905 }
906
907 tty->cr();
908 tty->cr();
909 }
910
911 // Reserve the Java heap, which is now the same for all GCs.
912 ReservedSpace Universe::reserve_heap(size_t heap_size, size_t alignment) {
913 assert(alignment <= Arguments::conservative_max_heap_alignment(),
914 err_msg("actual alignment "SIZE_FORMAT" must be within maximum heap alignment "SIZE_FORMAT,
915 alignment, Arguments::conservative_max_heap_alignment()));
916 size_t total_reserved = align_size_up(heap_size, alignment);
917 assert(!UseCompressedOops || (total_reserved <= (OopEncodingHeapMax - os::vm_page_size())),
918 "heap size is too big for compressed oops");
919
920 bool use_large_pages = UseLargePages && is_size_aligned(alignment, os::large_page_size());
921 assert(!UseLargePages
922 || UseParallelGC
923 || use_large_pages, "Wrong alignment to use large pages");
924
925 char* addr = Universe::preferred_heap_base(total_reserved, alignment, Universe::UnscaledNarrowOop);
926
927 ReservedHeapSpace total_rs(total_reserved, alignment, use_large_pages, addr);
928
929 if (UseCompressedOops) {
959 // Universe::initialize_heap() will reset this to NULL if unscaled
960 // or zero-based narrow oops are actually used.
961 address base = (address)(total_rs.base() - os::vm_page_size());
962 Universe::set_narrow_oop_base(base);
963 }
964 return total_rs;
965 }
966
967
968 // It's the caller's responsibility to ensure glitch-freedom
969 // (if required).
970 void Universe::update_heap_info_at_gc() {
971 _heap_capacity_at_last_gc = heap()->capacity();
972 _heap_used_at_last_gc = heap()->used();
973 }
974
975
976 const char* Universe::narrow_oop_mode_to_string(Universe::NARROW_OOP_MODE mode) {
977 switch (mode) {
978 case UnscaledNarrowOop:
979 return "32-bit";
980 case ZeroBasedNarrowOop:
981 return "Zero based";
982 case HeapBasedNarrowOop:
983 return "Non-zero based";
984 }
985
986 ShouldNotReachHere();
987 return "";
988 }
989
990
991 Universe::NARROW_OOP_MODE Universe::narrow_oop_mode() {
992 if (narrow_oop_base() != 0) {
993 return HeapBasedNarrowOop;
994 }
995
996 if (narrow_oop_shift() != 0) {
997 return ZeroBasedNarrowOop;
998 }
999
1000 return UnscaledNarrowOop;
1001 }
1002
1003
|