# HG changeset patch # User pliden # Date 1556175350 -7200 # Node ID 24f6b0e413a0b485e5090eababe40654e79590cb # Parent 3ab77d8dc60a342b424384c77e56883a31a61e8c 8221786: ZGC: Increase max heap size to 16TB Reviewed-by: stefank diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/os_cpu/linux_x86/gc/z/zAddress_linux_x86.inline.hpp --- a/src/hotspot/os_cpu/linux_x86/gc/z/zAddress_linux_x86.inline.hpp Thu Apr 25 08:55:49 2019 +0200 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,31 +0,0 @@ -/* - * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved. - * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. - * - * This code is free software; you can redistribute it and/or modify it - * under the terms of the GNU General Public License version 2 only, as - * published by the Free Software Foundation. - * - * This code is distributed in the hope that it will be useful, but WITHOUT - * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or - * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License - * version 2 for more details (a copy is included in the LICENSE file that - * accompanied this code). - * - * You should have received a copy of the GNU General Public License version - * 2 along with this work; if not, write to the Free Software Foundation, - * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. - * - * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA - * or visit www.oracle.com if you need additional information or have any - * questions. - */ - -#ifndef OS_CPU_LINUX_X86_GC_Z_ZADDRESS_LINUX_X86_INLINE_HPP -#define OS_CPU_LINUX_X86_GC_Z_ZADDRESS_LINUX_X86_INLINE_HPP - -inline uintptr_t ZAddress::address(uintptr_t value) { - return value; -} - -#endif // OS_CPU_LINUX_X86_GC_Z_ZADDRESS_LINUX_X86_INLINE_HPP diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.cpp --- a/src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -23,11 +23,151 @@ #include "precompiled.hpp" #include "gc/z/zGlobals.hpp" +#include "gc/z/zUtils.inline.hpp" +#include "runtime/globals.hpp" +#include "utilities/globalDefinitions.hpp" -uintptr_t ZAddressReservedStart() { - return ZAddressMetadataMarked0; +// +// The heap can have three different layouts, depending on the max heap size. +// +// Address Space & Pointer Layout 1 +// -------------------------------- +// +// +--------------------------------+ 0x00007FFFFFFFFFFF (127TB) +// . . +// . . +// . . +// +--------------------------------+ 0x0000014000000000 (20TB) +// | Remapped View | +// +--------------------------------+ 0x0000010000000000 (16TB) +// | (Reserved, but unused) | +// +--------------------------------+ 0x00000c0000000000 (12TB) +// | Marked1 View | +// +--------------------------------+ 0x0000080000000000 (8TB) +// | Marked0 View | +// +--------------------------------+ 0x0000040000000000 (4TB) +// . . +// +--------------------------------+ 0x0000000000000000 +// +// 6 4 4 4 4 +// 3 6 5 2 1 0 +// +--------------------+----+-----------------------------------------------+ +// |00000000 00000000 00|1111|11 11111111 11111111 11111111 11111111 11111111| +// +--------------------+----+-----------------------------------------------+ +// | | | +// | | * 41-0 Object Offset (42-bits, 4TB address space) +// | | +// | * 45-42 Metadata Bits (4-bits) 0001 = Marked0 (Address view 4-8TB) +// | 0010 = Marked1 (Address view 8-12TB) +// | 0100 = Remapped (Address view 16-20TB) +// | 1000 = Finalizable (Address view N/A) +// | +// * 63-46 Fixed (18-bits, always zero) +// +// +// Address Space & Pointer Layout 2 +// -------------------------------- +// +// +--------------------------------+ 0x00007FFFFFFFFFFF (127TB) +// . . +// . . +// . . +// +--------------------------------+ 0x0000280000000000 (40TB) +// | Remapped View | +// +--------------------------------+ 0x0000200000000000 (32TB) +// | (Reserved, but unused) | +// +--------------------------------+ 0x0000180000000000 (24TB) +// | Marked1 View | +// +--------------------------------+ 0x0000100000000000 (16TB) +// | Marked0 View | +// +--------------------------------+ 0x0000080000000000 (8TB) +// . . +// +--------------------------------+ 0x0000000000000000 +// +// 6 4 4 4 4 +// 3 7 6 3 2 0 +// +------------------+-----+------------------------------------------------+ +// |00000000 00000000 0|1111|111 11111111 11111111 11111111 11111111 11111111| +// +-------------------+----+------------------------------------------------+ +// | | | +// | | * 42-0 Object Offset (43-bits, 8TB address space) +// | | +// | * 46-43 Metadata Bits (4-bits) 0001 = Marked0 (Address view 8-16TB) +// | 0010 = Marked1 (Address view 16-24TB) +// | 0100 = Remapped (Address view 32-40TB) +// | 1000 = Finalizable (Address view N/A) +// | +// * 63-47 Fixed (17-bits, always zero) +// +// +// Address Space & Pointer Layout 3 +// -------------------------------- +// +// +--------------------------------+ 0x00007FFFFFFFFFFF (127TB) +// . . +// . . +// . . +// +--------------------------------+ 0x0000500000000000 (80TB) +// | Remapped View | +// +--------------------------------+ 0x0000400000000000 (64TB) +// | (Reserved, but unused) | +// +--------------------------------+ 0x0000300000000000 (48TB) +// | Marked1 View | +// +--------------------------------+ 0x0000200000000000 (32TB) +// | Marked0 View | +// +--------------------------------+ 0x0000100000000000 (16TB) +// . . +// +--------------------------------+ 0x0000000000000000 +// +// 6 4 4 4 4 +// 3 8 7 4 3 0 +// +------------------+----+-------------------------------------------------+ +// |00000000 00000000 |1111|1111 11111111 11111111 11111111 11111111 11111111| +// +------------------+----+-------------------------------------------------+ +// | | | +// | | * 43-0 Object Offset (44-bits, 16TB address space) +// | | +// | * 47-44 Metadata Bits (4-bits) 0001 = Marked0 (Address view 16-32TB) +// | 0010 = Marked1 (Address view 32-48TB) +// | 0100 = Remapped (Address view 64-80TB) +// | 1000 = Finalizable (Address view N/A) +// | +// * 63-48 Fixed (16-bits, always zero) +// + +uintptr_t ZPlatformAddressSpaceStart() { + const uintptr_t first_heap_view_address = (uintptr_t)1 << (ZPlatformAddressMetadataShift() + 0); + const size_t min_address_offset = 0; + return first_heap_view_address + min_address_offset; } -uintptr_t ZAddressReservedEnd() { - return ZAddressMetadataRemapped + ZAddressOffsetMax; +uintptr_t ZPlatformAddressSpaceEnd() { + const uintptr_t last_heap_view_address = (uintptr_t)1 << (ZPlatformAddressMetadataShift() + 2); + const size_t max_address_offset = (size_t)1 << ZPlatformAddressOffsetBits(); + return last_heap_view_address + max_address_offset; +} + +uintptr_t ZPlatformAddressReservedStart() { + return ZPlatformAddressSpaceStart(); +} + +uintptr_t ZPlatformAddressReservedEnd() { + return ZPlatformAddressSpaceEnd(); } + +uintptr_t ZPlatformAddressBase() { + return 0; +} + +size_t ZPlatformAddressOffsetBits() { + const size_t min_address_offset_bits = 42; // 4TB + const size_t max_address_offset_bits = 44; // 16TB + const size_t virtual_to_physical_ratio = 7; // 7:1 + const size_t address_offset = ZUtils::round_up_power_of_2(MaxHeapSize * virtual_to_physical_ratio); + const size_t address_offset_bits = log2_intptr(address_offset); + return MIN2(MAX2(address_offset_bits, min_address_offset_bits), max_address_offset_bits); +} + +size_t ZPlatformAddressMetadataShift() { + return ZPlatformAddressOffsetBits(); +} diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.hpp --- a/src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.hpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/os_cpu/linux_x86/gc/z/zGlobals_linux_x86.hpp Thu Apr 25 08:55:50 2019 +0200 @@ -35,56 +35,17 @@ // Large X*M > 4M 2M // ------------------------------------------------------------------ // -// -// Address Space & Pointer Layout -// ------------------------------ -// -// +--------------------------------+ 0x00007FFFFFFFFFFF (127TB) -// . . -// . . -// . . -// +--------------------------------+ 0x0000140000000000 (20TB) -// | Remapped View | -// +--------------------------------+ 0x0000100000000000 (16TB) -// | (Reserved, but unused) | -// +--------------------------------+ 0x00000c0000000000 (12TB) -// | Marked1 View | -// +--------------------------------+ 0x0000080000000000 (8TB) -// | Marked0 View | -// +--------------------------------+ 0x0000040000000000 (4TB) -// . . -// +--------------------------------+ 0x0000000000000000 -// -// -// 6 4 4 4 4 4 0 -// 3 7 6 5 2 1 0 -// +-------------------+-+----+-----------------------------------------------+ -// |00000000 00000000 0|0|1111|11 11111111 11111111 11111111 11111111 11111111| -// +-------------------+-+----+-----------------------------------------------+ -// | | | | -// | | | * 41-0 Object Offset (42-bits, 4TB address space) -// | | | -// | | * 45-42 Metadata Bits (4-bits) 0001 = Marked0 (Address view 4-8TB) -// | | 0010 = Marked1 (Address view 8-12TB) -// | | 0100 = Remapped (Address view 16-20TB) -// | | 1000 = Finalizable (Address view N/A) -// | | -// | * 46-46 Unused (1-bit, always zero) -// | -// * 63-47 Fixed (17-bits, always zero) -// +const size_t ZPlatformGranuleSizeShift = 21; // 2MB +const size_t ZPlatformMaxHeapSizeShift = 46; // 16TB +const size_t ZPlatformNMethodDisarmedOffset = 4; +const size_t ZPlatformCacheLineSize = 64; -const size_t ZPlatformGranuleSizeShift = 21; // 2M - -const size_t ZPlatformAddressOffsetBits = 42; // 4TB - -const uintptr_t ZPlatformAddressMetadataShift = ZPlatformAddressOffsetBits; - -const uintptr_t ZPlatformAddressSpaceStart = (uintptr_t)1 << ZPlatformAddressOffsetBits; -const uintptr_t ZPlatformAddressSpaceSize = ((uintptr_t)1 << ZPlatformAddressOffsetBits) * 4; - -const size_t ZPlatformNMethodDisarmedOffset = 4; - -const size_t ZPlatformCacheLineSize = 64; +uintptr_t ZPlatformAddressSpaceStart(); +uintptr_t ZPlatformAddressSpaceEnd(); +uintptr_t ZPlatformAddressReservedStart(); +uintptr_t ZPlatformAddressReservedEnd(); +uintptr_t ZPlatformAddressBase(); +size_t ZPlatformAddressOffsetBits(); +size_t ZPlatformAddressMetadataShift(); #endif // OS_CPU_LINUX_X86_GC_Z_ZGLOBALS_LINUX_X86_HPP diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zAddress.cpp --- a/src/hotspot/share/gc/z/zAddress.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zAddress.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -22,27 +22,47 @@ */ #include "precompiled.hpp" -#include "gc/z/zAddress.inline.hpp" +#include "gc/z/zAddress.hpp" #include "gc/z/zGlobals.hpp" -#include "runtime/thread.hpp" -void ZAddressMasks::set_good_mask(uintptr_t mask) { - uintptr_t old_bad_mask = ZAddressBadMask; +void ZAddress::set_good_mask(uintptr_t mask) { ZAddressGoodMask = mask; ZAddressBadMask = ZAddressGoodMask ^ ZAddressMetadataMask; ZAddressWeakBadMask = (ZAddressGoodMask | ZAddressMetadataRemapped | ZAddressMetadataFinalizable) ^ ZAddressMetadataMask; } -void ZAddressMasks::initialize() { +void ZAddress::initialize() { + ZAddressSpaceStart = ZPlatformAddressSpaceStart(); + ZAddressSpaceEnd = ZPlatformAddressSpaceEnd(); + ZAddressSpaceSize = ZAddressSpaceEnd - ZAddressSpaceStart; + + ZAddressReservedStart = ZPlatformAddressReservedStart(); + ZAddressReservedEnd = ZPlatformAddressReservedEnd(); + ZAddressReservedSize = ZAddressReservedEnd - ZAddressReservedStart; + + ZAddressBase = ZPlatformAddressBase(); + + ZAddressOffsetBits = ZPlatformAddressOffsetBits(); + ZAddressOffsetMask = (((uintptr_t)1 << ZAddressOffsetBits) - 1) << ZAddressOffsetShift; + ZAddressOffsetMax = (uintptr_t)1 << ZAddressOffsetBits; + + ZAddressMetadataShift = ZPlatformAddressMetadataShift(); + ZAddressMetadataMask = (((uintptr_t)1 << ZAddressMetadataBits) - 1) << ZAddressMetadataShift; + + ZAddressMetadataMarked0 = (uintptr_t)1 << (ZAddressMetadataShift + 0); + ZAddressMetadataMarked1 = (uintptr_t)1 << (ZAddressMetadataShift + 1); + ZAddressMetadataRemapped = (uintptr_t)1 << (ZAddressMetadataShift + 2); + ZAddressMetadataFinalizable = (uintptr_t)1 << (ZAddressMetadataShift + 3); + ZAddressMetadataMarked = ZAddressMetadataMarked0; set_good_mask(ZAddressMetadataRemapped); } -void ZAddressMasks::flip_to_marked() { +void ZAddress::flip_to_marked() { ZAddressMetadataMarked ^= (ZAddressMetadataMarked0 | ZAddressMetadataMarked1); set_good_mask(ZAddressMetadataMarked); } -void ZAddressMasks::flip_to_remapped() { +void ZAddress::flip_to_remapped() { set_good_mask(ZAddressMetadataRemapped); } diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zAddress.hpp --- a/src/hotspot/share/gc/z/zAddress.hpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zAddress.hpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,17 @@ #include "memory/allocation.hpp" class ZAddress : public AllStatic { + friend class ZAddressTest; + +private: + static void set_good_mask(uintptr_t mask); + public: + static void initialize(); + + static void flip_to_marked(); + static void flip_to_remapped(); + static bool is_null(uintptr_t value); static bool is_bad(uintptr_t value); static bool is_good(uintptr_t value); @@ -52,16 +62,4 @@ static uintptr_t remapped_or_null(uintptr_t value); }; -class ZAddressMasks : public AllStatic { - friend class ZAddressTest; - -private: - static void set_good_mask(uintptr_t mask); - -public: - static void initialize(); - static void flip_to_marked(); - static void flip_to_remapped(); -}; - #endif // SHARE_GC_Z_ZADDRESS_HPP diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zAddress.inline.hpp --- a/src/hotspot/share/gc/z/zAddress.inline.hpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zAddress.inline.hpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -27,7 +27,6 @@ #include "gc/z/zAddress.hpp" #include "gc/z/zGlobals.hpp" #include "utilities/macros.hpp" -#include OS_CPU_HEADER_INLINE(gc/z/zAddress) inline bool ZAddress::is_null(uintptr_t value) { return value == 0; @@ -82,6 +81,10 @@ return value & ZAddressMetadataRemapped; } +inline uintptr_t ZAddress::address(uintptr_t value) { + return value | ZAddressBase; +} + inline uintptr_t ZAddress::offset(uintptr_t value) { return value & ZAddressOffsetMask; } diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zArguments.cpp --- a/src/hotspot/share/gc/z/zArguments.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zArguments.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -30,13 +30,14 @@ #include "runtime/globals.hpp" #include "runtime/globals_extension.hpp" -size_t ZArguments::conservative_max_heap_alignment() { - return 0; -} - void ZArguments::initialize() { GCArguments::initialize(); + // Check max heap size + if (MaxHeapSize > ZMaxHeapSize) { + vm_exit_during_initialization("Java heap too large"); + } + // Enable NUMA by default if (FLAG_IS_DEFAULT(UseNUMA)) { FLAG_SET_DEFAULT(UseNUMA, true); @@ -95,6 +96,10 @@ initialize_platform(); } +size_t ZArguments::conservative_max_heap_alignment() { + return 0; +} + CollectedHeap* ZArguments::create_heap() { return create_heap_with_policy(); } diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zCollectedHeap.cpp --- a/src/hotspot/share/gc/z/zCollectedHeap.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zCollectedHeap.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -56,7 +56,7 @@ } const char* ZCollectedHeap::name() const { - return ZGCName; + return ZName; } jint ZCollectedHeap::initialize() { @@ -64,8 +64,8 @@ return JNI_ENOMEM; } - initialize_reserved_region((HeapWord*)ZAddressReservedStart(), - (HeapWord*)ZAddressReservedEnd()); + initialize_reserved_region((HeapWord*)ZAddressReservedStart, + (HeapWord*)ZAddressReservedEnd); return JNI_OK; } diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zGlobals.cpp --- a/src/hotspot/share/gc/z/zGlobals.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zGlobals.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2017, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -31,7 +31,28 @@ const int& ZObjectAlignmentSmall = MinObjAlignmentInBytes; uintptr_t ZAddressGoodMask; -uintptr_t ZAddressBadMask = 0; +uintptr_t ZAddressBadMask; uintptr_t ZAddressWeakBadMask; +uintptr_t ZAddressBase; + +size_t ZAddressOffsetBits; +uintptr_t ZAddressOffsetMask; +size_t ZAddressOffsetMax; + +size_t ZAddressMetadataShift; +uintptr_t ZAddressMetadataMask; + uintptr_t ZAddressMetadataMarked; +uintptr_t ZAddressMetadataMarked0; +uintptr_t ZAddressMetadataMarked1; +uintptr_t ZAddressMetadataRemapped; +uintptr_t ZAddressMetadataFinalizable; + +uintptr_t ZAddressSpaceStart; +uintptr_t ZAddressSpaceEnd; +size_t ZAddressSpaceSize; + +uintptr_t ZAddressReservedStart; +uintptr_t ZAddressReservedEnd; +size_t ZAddressReservedSize; diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zGlobals.hpp --- a/src/hotspot/share/gc/z/zGlobals.hpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zGlobals.hpp Thu Apr 25 08:55:50 2019 +0200 @@ -29,7 +29,7 @@ #include OS_CPU_HEADER(gc/z/zGlobals) // Collector name -const char* const ZGCName = "The Z Garbage Collector"; +const char* const ZName = "The Z Garbage Collector"; // Global phase state extern uint32_t ZGlobalPhase; @@ -44,6 +44,10 @@ const size_t ZGranuleSizeShift = ZPlatformGranuleSizeShift; const size_t ZGranuleSize = (size_t)1 << ZGranuleSizeShift; +// Max heap size shift/size +const size_t ZMaxHeapSizeShift = ZPlatformMaxHeapSizeShift; +const size_t ZMaxHeapSize = (size_t)1 << ZMaxHeapSizeShift; + // Page types const uint8_t ZPageTypeSmall = 0; const uint8_t ZPageTypeMedium = 1; @@ -71,38 +75,6 @@ const int ZObjectAlignmentMedium = 1 << ZObjectAlignmentMediumShift; const int ZObjectAlignmentLarge = 1 << ZObjectAlignmentLargeShift; -// Pointer part of address -const uintptr_t ZAddressOffsetShift = 0; -const uintptr_t ZAddressOffsetBits = ZPlatformAddressOffsetBits; -const uintptr_t ZAddressOffsetMask = (((uintptr_t)1 << ZAddressOffsetBits) - 1) << ZAddressOffsetShift; -const size_t ZAddressOffsetMax = (uintptr_t)1 << ZAddressOffsetBits; - -// Metadata part of address -const uintptr_t ZAddressMetadataShift = ZPlatformAddressMetadataShift; -const uintptr_t ZAddressMetadataBits = 4; -const uintptr_t ZAddressMetadataMask = (((uintptr_t)1 << ZAddressMetadataBits) - 1) << ZAddressMetadataShift; - -// Metadata types -const uintptr_t ZAddressMetadataMarked0 = (uintptr_t)1 << (ZAddressMetadataShift + 0); -const uintptr_t ZAddressMetadataMarked1 = (uintptr_t)1 << (ZAddressMetadataShift + 1); -const uintptr_t ZAddressMetadataRemapped = (uintptr_t)1 << (ZAddressMetadataShift + 2); -const uintptr_t ZAddressMetadataFinalizable = (uintptr_t)1 << (ZAddressMetadataShift + 3); - -// Address space start/end/size -const uintptr_t ZAddressSpaceStart = ZPlatformAddressSpaceStart; -const uintptr_t ZAddressSpaceSize = ZPlatformAddressSpaceSize; -const uintptr_t ZAddressSpaceEnd = ZAddressSpaceStart + ZAddressSpaceSize; - -// NMethod entry barrier -const size_t ZNMethodDisarmedOffset = ZPlatformNMethodDisarmedOffset; - -// Cache line size -const size_t ZCacheLineSize = ZPlatformCacheLineSize; - -// Reserved start/end -uintptr_t ZAddressReservedStart(); -uintptr_t ZAddressReservedEnd(); - // // Good/Bad mask states // -------------------- @@ -119,8 +91,42 @@ extern uintptr_t ZAddressBadMask; extern uintptr_t ZAddressWeakBadMask; -// Marked state +// Pointer base address +extern uintptr_t ZAddressBase; + +// Pointer part of address +extern size_t ZAddressOffsetBits; +const size_t ZAddressOffsetShift = 0; +extern uintptr_t ZAddressOffsetMask; +extern size_t ZAddressOffsetMax; + +// Metadata part of address +const size_t ZAddressMetadataBits = 4; +extern size_t ZAddressMetadataShift; +extern uintptr_t ZAddressMetadataMask; + +// Metadata types extern uintptr_t ZAddressMetadataMarked; +extern uintptr_t ZAddressMetadataMarked0; +extern uintptr_t ZAddressMetadataMarked1; +extern uintptr_t ZAddressMetadataRemapped; +extern uintptr_t ZAddressMetadataFinalizable; + +// Address space start/end/size +extern uintptr_t ZAddressSpaceStart; +extern uintptr_t ZAddressSpaceEnd; +extern size_t ZAddressSpaceSize; + +// Reserved space start/end +extern uintptr_t ZAddressReservedStart; +extern uintptr_t ZAddressReservedEnd; +extern size_t ZAddressReservedSize; + +// NMethod entry barrier +const size_t ZNMethodDisarmedOffset = ZPlatformNMethodDisarmedOffset; + +// Cache line size +const size_t ZCacheLineSize = ZPlatformCacheLineSize; // Mark stack space extern uintptr_t ZMarkStackSpaceStart; diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zHeap.cpp --- a/src/hotspot/share/gc/z/zHeap.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zHeap.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -173,7 +173,7 @@ } bool ZHeap::is_in(uintptr_t addr) const { - if (addr < ZAddressReservedStart() || addr >= ZAddressReservedEnd()) { + if (addr < ZAddressReservedStart || addr >= ZAddressReservedEnd) { return false; } @@ -269,13 +269,13 @@ void ZHeap::flip_to_marked() { before_flip(); - ZAddressMasks::flip_to_marked(); + ZAddress::flip_to_marked(); after_flip(); } void ZHeap::flip_to_remapped() { before_flip(); - ZAddressMasks::flip_to_remapped(); + ZAddress::flip_to_remapped(); after_flip(); } diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zInitialize.cpp --- a/src/hotspot/share/gc/z/zInitialize.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zInitialize.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -36,13 +36,13 @@ #include "runtime/vm_version.hpp" ZInitialize::ZInitialize(ZBarrierSet* barrier_set) { - log_info(gc, init)("Initializing %s", ZGCName); + log_info(gc, init)("Initializing %s", ZName); log_info(gc, init)("Version: %s (%s)", VM_Version::vm_release(), VM_Version::jdk_debug_level()); // Early initialization - ZAddressMasks::initialize(); + ZAddress::initialize(); ZNUMA::initialize(); ZCPU::initialize(); ZStatValue::initialize(); diff -r 3ab77d8dc60a -r 24f6b0e413a0 src/hotspot/share/gc/z/zVirtualMemory.cpp --- a/src/hotspot/share/gc/z/zVirtualMemory.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/src/hotspot/share/gc/z/zVirtualMemory.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -24,11 +24,16 @@ #include "precompiled.hpp" #include "gc/z/zGlobals.hpp" #include "gc/z/zVirtualMemory.inline.hpp" +#include "logging/log.hpp" #include "services/memTracker.hpp" ZVirtualMemoryManager::ZVirtualMemoryManager() : _manager(), _initialized(false) { + + log_info(gc, init)("Address Space: " PTR_FORMAT " - " PTR_FORMAT " (" SIZE_FORMAT "T)", + ZAddressSpaceStart, ZAddressSpaceEnd, ZAddressSpaceSize / K / G); + // Reserve address space if (!reserve(ZAddressSpaceStart, ZAddressSpaceSize)) { return; diff -r 3ab77d8dc60a -r 24f6b0e413a0 test/hotspot/gtest/gc/z/test_zAddress.cpp --- a/test/hotspot/gtest/gc/z/test_zAddress.cpp Thu Apr 25 08:55:49 2019 +0200 +++ b/test/hotspot/gtest/gc/z/test_zAddress.cpp Thu Apr 25 08:55:50 2019 +0200 @@ -1,5 +1,5 @@ /* - * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it @@ -30,9 +30,8 @@ protected: static void is_good_bit(uintptr_t bit_mask) { // Setup - uintptr_t mask_before = ZAddressGoodMask; - - ZAddressMasks::set_good_mask(bit_mask); + ZAddress::initialize(); + ZAddress::set_good_mask(bit_mask); // Test that a pointer with only the given bit is considered good. EXPECT_EQ(ZAddress::is_good(ZAddressMetadataMarked0), (bit_mask == ZAddressMetadataMarked0)); @@ -46,16 +45,12 @@ // Test that null is not considered good. EXPECT_FALSE(ZAddress::is_good(0)); - - // Teardown - ZAddressMasks::set_good_mask(mask_before); } static void is_good_or_null_bit(uintptr_t bit_mask) { // Setup - uintptr_t mask_before = ZAddressGoodMask; - - ZAddressMasks::set_good_mask(bit_mask); + ZAddress::initialize(); + ZAddress::set_good_mask(bit_mask); // Test that a pointer with only the given bit is considered good. EXPECT_EQ(ZAddress::is_good_or_null(ZAddressMetadataMarked0), (bit_mask == ZAddressMetadataMarked0)); @@ -69,15 +64,12 @@ // Test that null is considered good_or_null. EXPECT_TRUE(ZAddress::is_good_or_null(0)); - - // Teardown - ZAddressMasks::set_good_mask(mask_before); } static void finalizable() { // Setup - ZAddressMasks::initialize(); - ZAddressMasks::flip_to_marked(); + ZAddress::initialize(); + ZAddress::flip_to_marked(); // Test that a normal good pointer is good and weak good, but not finalizable const uintptr_t addr1 = ZAddress::good(1); @@ -100,7 +92,7 @@ EXPECT_FALSE(ZAddress::is_good_or_null(addr2)); // Flip to remapped and test that it's no longer weak good - ZAddressMasks::flip_to_remapped(); + ZAddress::flip_to_remapped(); EXPECT_TRUE(ZAddress::is_finalizable(addr2)); EXPECT_TRUE(ZAddress::is_marked(addr2)); EXPECT_FALSE(ZAddress::is_remapped(addr2));