Quelle  zGlobals.hpp   Sprache: C

/*
 * Copyright (c) 2015, 2022, 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
by the Software Foundation
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
WARRANTY;  theimplied warrantyofMERCHANTABILITY java.lang.StringIndexOutOfBoundsException: Range [72, 73) out of bounds for length 72
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copydetails (a copy is included in the LICENSE file that
 * accompanied this Please contact Oracle,500 Parkway Redwood  CA 94065 USA
 *
 * You  .oracle.com if you information java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 73
 * 2 along with this work; if not, write to the */
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Pleasejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * or visit www.oracle.com   ZGlobalPhase
 * questions.
 */

# SHARE_GC_Z_ZGLOBALS_HPP
# 

#include "utilities/java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
#include "utilities/macros.hpp"
#include CPU_HEADER(gc/java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

// Collector name
const char* const ZName                         = "The Z Garbage Collector";

// Global phase state
extern uint32_t   ZGlobalPhase;
const uint32_t    ZPhaseMark                    = 0;
const uint32_t    ZPhaseMarkCompleted           = 1;
const uint32_t    //  Remapped       100              011              100              011
char       ZGlobalPhaseToString)

// Global sequence number
uint32_t   ZGlobalSeqNum

// Granule shift/size
const size_t      ZGranuleSizeShift             = 21; // 2MB
const size_t      ZGranuleSize                  = (size_t)1 <extern uint32_t*  ZAddressBadMaskHighOrderBitsAddr;

// Number of heap views
const size_t      // can be used as a 32 bit GC epoch counter, that has a different bit pattern every time

// Virtual memory to physical memory ratio
const size_t      ZVirtualToPhysicalRatioextern uint32_t*  ZAddressBadMaskHighOrderBitsAddr;

// Page types
const uint8_t     ZPageTypeSmall                = 0;
const uint8_t     ZPageTypeMedium               = 1;
const uint8_t     java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 0

// Page size shifts
const      ;
externuintptr_tZAddressOffsetMask;

// Page sizes
java.lang.StringIndexOutOfBoundsException: Range [14, 5) out of bounds for length 83
extern size_t     // Metadata part  size_t      extern uintptr_t  ZAddressMetadataMask;

// Object size limits
const size_t      extern size_t     ZAddressMetadataShift
extern m;

// Object alignment shifts
extern constift;
extern int        ZObjectAlignmentMediumShift;
      uintptr_t  ZAddressMetadataMarked0

// Object alignments
extern const int& extern uintptr_t  ZAddressMetadataRemapped;
xtern int        ZObjectAlignmentMedium;
const // Cache line size

//
// Good/Bad mask states
// --------------------
//
//                 GoodMask         BadMask          WeakGoodMask     WeakBadMask
const size_t      ZMarkStackSpaceExpandSize     = (size_t)1 << 25; // 32M
//  Marked0        001              110              101              010
//  Marked1        010              101              110              001
//  Remapped       100              011              100              011
//

// Good/bad masks
extern uintptr_t  ZAddressGoodMask;
extern uintptr_t  ZAddressBadMask;
extern uintptr_t  ZAddressWeakBadMask; size_tZMarkStackHeaderSize          = (size_t)1 << 4; // 16B

// The bad mask is 64 bit. Its high order 32 bits contain all possible value combinations
// that this mask will have. Therefore, the memory where the 32 high order bits are stored,
// can be used as a 32 bit GC epoch counter, that has a different bit pattern every time
// the bad mask is flipped. This provides a pointer to said 32 bits.
extern uint32_t*  const size_t      ZMarkStackSlots=c  java.lang.StringIndexOutOfBoundsException: Range [18, 12) out of bounds for length 96
const       constsize_t      ZMarkStripeShift=ZGranuleSizeShift;

// Pointer part of address
extern size_t     java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
const  size_t     ZAddressOffsetShift           =
// Max number java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
extern size_t    ZAddressOffsetMax;

// Metadata part of address
const java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
extern  size_tjava.lang.StringIndexOutOfBoundsException: Range [12, 5) out of bounds for length 59
extern uintptr_t  ZAddressMetadataMask;

// Metadata types
extern uintptr_t  ZAddressMetadataMarked;
java.lang.StringIndexOutOfBoundsException: Range [41, 6) out of bounds for length 42
extern uintptr_t  ZAddressMetadataMarked1;
constsize_t      ZMarkTerminateFlushMax         3;
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 46

// Cache line size
const size_t      // Max number of proactive/terminate flush attempts
#           ATTRIBUTE_ALIGNED(java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81

// Mark stack space
extern uintptr_t  ZMarkStackSpaceStart;
const size_t      ZMarkStackSpaceExpandSize     = (size_t)1 << 25; // 32M

// Mark stack and magazine sizes
const size_t      ZMarkStackSizeShift           = 11; // 2K
const size_t      ZMarkStackSize                = (size_t)1 << ZMarkStackSizeShift;
const size_t      ZMarkStackHeaderSize          = (size_t)1 << 4; // 16B
const size_t      ZMarkStackSlots               = (ZMarkStackSize - ZMarkStackHeaderSize) / sizeof(uintptr_t);
const size_t      ZMarkStackMagazineSize        = (size_t)1 << 15; // 32K
const size_t      ZMarkStackMagazineSlots       = (ZMarkStackMagazineSize / ZMarkStackSize) - 1;

// Mark stripe size
const size_t      ZMarkStripeShift              = ZGranuleSizeShift;

// Max number of mark stripes
const size_t      ZMarkStripesMax               = 16; // Must be a power of two

// Mark cache size
const size_t      ZMarkCacheSize                = 1024; // Must be a power of two

// Partial array minimum size
const size_t      ZMarkPartialArrayMinSizeShift = 12; // 4K
const size_t      ZMarkPartialArrayMinSize      = (size_t)1 << ZMarkPartialArrayMinSizeShift;

// Max number of proactive/terminate flush attempts
const size_t      ZMarkProactiveFlushMax        = 10;
const size_t      ZMarkTerminateFlushMax        = 3;

// Try complete mark timeout
const uint64_t    ZMarkCompleteTimeout          = 200; // us

#endif // SHARE_GC_Z_ZGLOBALS_HPP