Go to Debian
Package Search, search for the following packages for your
diff --git a/doc/building.md b/doc/building.md
index b626027f101..d653d36eb55 100644
--- a/doc/building.md
+++ b/doc/building.md
@@ -1178,10 +1178,8 @@ Note that alsa is needed even if you only want to build a headless JDK.
#### X11
-You will need X11 libraries suitable for your *target* system. In most cases,
-using Debian's pre-built libraries work fine.
-
-Note that X11 is needed even if you only want to build a headless JDK.
+When not building a headless JDK, you will need X11 libraries suitable for your
+*target* system. In most cases, using Debian's pre-built libraries work fine.
* Go to [Debian Package Search](https://www.debian.org/distrib/packages),
search for the following packages for your *target* system, and download them
diff --git a/make/RunTests.gmk b/make/RunTests.gmk
index 946b1332edc..02ea632e3ec 100644
--- a/make/RunTests.gmk
+++ b/make/RunTests.gmk
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2016, 2026, 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
@@ -972,6 +972,10 @@ define SetupRunJtregTestBody
JTREG_AUTO_PROBLEM_LISTS += ProblemList-enable-preview.txt
endif
+ ifneq ($$(findstring -XX:+UseCompactObjectHeaders, $$(JTREG_ALL_OPTIONS)), )
+ JTREG_AUTO_PROBLEM_LISTS += ProblemList-coh.txt
+ endif
+
ifneq ($$(JTREG_EXTRA_PROBLEM_LISTS), )
# Accept both absolute paths as well as relative to the current test root.
diff --git a/make/autoconf/libraries.m4 b/make/autoconf/libraries.m4
index 8dc3d55ed0c..5daacdc1ced 100644
--- a/make/autoconf/libraries.m4
+++ b/make/autoconf/libraries.m4
@@ -42,12 +42,12 @@ m4_include([lib-tests.m4])
AC_DEFUN_ONCE([LIB_DETERMINE_DEPENDENCIES],
[
# Check if X11 is needed
- if test "x$OPENJDK_TARGET_OS" = xwindows || test "x$OPENJDK_TARGET_OS" = xmacosx; then
- # No X11 support on windows or macosx
+ if test "x$OPENJDK_TARGET_OS" = xwindows ||
+ test "x$OPENJDK_TARGET_OS" = xmacosx ||
+ test "x$ENABLE_HEADLESS_ONLY" = xtrue; then
NEEDS_LIB_X11=false
else
- # All other instances need X11, even if building headless only, libawt still
- # needs X11 headers.
+ # All other instances need X11 for libawt.
NEEDS_LIB_X11=true
fi
diff --git a/make/modules/java.desktop/lib/AwtLibraries.gmk b/make/modules/java.desktop/lib/AwtLibraries.gmk
index 463e09e12dc..8b6b50b9e62 100644
--- a/make/modules/java.desktop/lib/AwtLibraries.gmk
+++ b/make/modules/java.desktop/lib/AwtLibraries.gmk
@@ -88,6 +88,10 @@ LIBAWT_EXTRA_HEADER_DIRS := \
LIBAWT_CFLAGS := -D__MEDIALIB_OLD_NAMES -D__USE_J2D_NAMES -DMLIB_NO_LIBSUNMATH
+ifeq ($(ENABLE_HEADLESS_ONLY), true)
+ LIBAWT_CFLAGS += -DHEADLESS
+endif
+
ifeq ($(call isTargetOs, windows), true)
LIBAWT_CFLAGS += -EHsc -DUNICODE -D_UNICODE -DMLIB_OS64BIT
LIBAWT_RCFLAGS ?= -I$(TOPDIR)/src/java.base/windows/native/launcher/icons
@@ -167,11 +171,18 @@ ifeq ($(call isTargetOs, windows macosx), false)
$(TOPDIR)/src/$(MODULE)/$(OPENJDK_TARGET_OS_TYPE)/native/common/awt \
#
+ LIBAWT_HEADLESS_EXCLUDE_FILES := \
+ GLXGraphicsConfig.c \
+ GLXSurfaceData.c \
+ X11PMBlitLoops.c \
+ X11Renderer.c \
+ X11SurfaceData.c \
+ #
+
LIBAWT_HEADLESS_EXTRA_HEADER_DIRS := \
$(LIBAWT_DEFAULT_HEADER_DIRS) \
common/awt/debug \
common/font \
- common/java2d/opengl \
java.base:libjvm \
#
@@ -191,7 +202,8 @@ ifeq ($(call isTargetOs, windows macosx), false)
$(eval $(call SetupJdkLibrary, BUILD_LIBAWT_HEADLESS, \
NAME := awt_headless, \
EXTRA_SRC := $(LIBAWT_HEADLESS_EXTRA_SRC), \
- EXCLUDES := medialib, \
+ EXCLUDES := medialib opengl, \
+ EXCLUDE_FILES := $(LIBAWT_HEADLESS_EXCLUDE_FILES), \
ONLY_EXPORTED := $(LIBAWT_HEADLESS_ONLY_EXPORTED), \
OPTIMIZATION := LOW, \
CFLAGS := -DHEADLESS=true $(CUPS_CFLAGS) $(FONTCONFIG_CFLAGS) \
diff --git a/src/demo/share/jfc/TableExample/OldJTable.java b/src/demo/share/jfc/TableExample/OldJTable.java
deleted file mode 100644
index 8c77978fe8a..00000000000
--- a/src/demo/share/jfc/TableExample/OldJTable.java
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
- * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * - Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- *
- * - Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- *
- * - Neither the name of Oracle nor the names of its
- * contributors may be used to endorse or promote products derived
- * from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
- * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
- * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-/*
- * This source code is provided to illustrate the usage of a given feature
- * or technique and has been deliberately simplified. Additional steps
- * required for a production-quality application, such as security checks,
- * input validation and proper error handling, might not be present in
- * this sample code.
- */
-
-
-
-import java.util.EventObject;
-import java.util.List;
-import javax.swing.JTable;
-import javax.swing.table.DefaultTableModel;
-import javax.swing.table.TableCellEditor;
-import javax.swing.table.TableCellRenderer;
-import javax.swing.table.TableColumn;
-
-
-/**
- * The OldJTable is an unsupported class containing some methods that were
- * deleted from the JTable between releases 0.6 and 0.7
- */
-@SuppressWarnings("serial")
-public class OldJTable extends JTable
-{
- /*
- * A new convenience method returning the index of the column in the
- * co-ordinate space of the view.
- */
- public int getColumnIndex(Object identifier) {
- return getColumnModel().getColumnIndex(identifier);
- }
-
-//
-// Methods deleted from the JTable because they only work with the
-// DefaultTableModel.
-//
-
- public TableColumn addColumn(Object columnIdentifier, int width) {
- return addColumn(columnIdentifier, width, null, null, null);
- }
-
- public TableColumn addColumn(Object columnIdentifier, List> columnData) {
- return addColumn(columnIdentifier, -1, null, null, columnData);
- }
-
- // Override the new JTable implementation - it will not add a column to the
- // DefaultTableModel.
- public TableColumn addColumn(Object columnIdentifier, int width,
- TableCellRenderer renderer,
- TableCellEditor editor) {
- return addColumn(columnIdentifier, width, renderer, editor, null);
- }
-
- public TableColumn addColumn(Object columnIdentifier, int width,
- TableCellRenderer renderer,
- TableCellEditor editor, List> columnData) {
- checkDefaultTableModel();
-
- // Set up the model side first
- DefaultTableModel m = (DefaultTableModel)getModel();
- m.addColumn(columnIdentifier, columnData.toArray());
-
- // The column will have been added to the end, so the index of the
- // column in the model is the last element.
- TableColumn newColumn = new TableColumn(
- m.getColumnCount()-1, width, renderer, editor);
- super.addColumn(newColumn);
- return newColumn;
- }
-
- // Not possilble to make this work the same way ... change it so that
- // it does not delete columns from the model.
- public void removeColumn(Object columnIdentifier) {
- super.removeColumn(getColumn(columnIdentifier));
- }
-
- public void addRow(Object[] rowData) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).addRow(rowData);
- }
-
- public void addRow(List> rowData) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).addRow(rowData.toArray());
- }
-
- public void removeRow(int rowIndex) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).removeRow(rowIndex);
- }
-
- public void moveRow(int startIndex, int endIndex, int toIndex) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).moveRow(startIndex, endIndex, toIndex);
- }
-
- public void insertRow(int rowIndex, Object[] rowData) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData);
- }
-
- public void insertRow(int rowIndex, List> rowData) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).insertRow(rowIndex, rowData.toArray());
- }
-
- public void setNumRows(int newSize) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).setNumRows(newSize);
- }
-
- public void setDataVector(Object[][] newData, List> columnIds) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).setDataVector(
- newData, columnIds.toArray());
- }
-
- public void setDataVector(Object[][] newData, Object[] columnIds) {
- checkDefaultTableModel();
- ((DefaultTableModel)getModel()).setDataVector(newData, columnIds);
- }
-
- protected void checkDefaultTableModel() {
- if(!(dataModel instanceof DefaultTableModel))
- throw new InternalError("In order to use this method, the data model must be an instance of DefaultTableModel.");
- }
-
-//
-// Methods removed from JTable in the move from identifiers to ints.
-//
-
- public Object getValueAt(Object columnIdentifier, int rowIndex) {
- return super.getValueAt(rowIndex, getColumnIndex(columnIdentifier));
- }
-
- public boolean isCellEditable(Object columnIdentifier, int rowIndex) {
- return super.isCellEditable(rowIndex, getColumnIndex(columnIdentifier));
- }
-
- public void setValueAt(Object aValue, Object columnIdentifier, int rowIndex) {
- super.setValueAt(aValue, rowIndex, getColumnIndex(columnIdentifier));
- }
-
- public boolean editColumnRow(Object identifier, int row) {
- return super.editCellAt(row, getColumnIndex(identifier));
- }
-
- public void moveColumn(Object columnIdentifier, Object targetColumnIdentifier) {
- moveColumn(getColumnIndex(columnIdentifier),
- getColumnIndex(targetColumnIdentifier));
- }
-
- public boolean isColumnSelected(Object identifier) {
- return isColumnSelected(getColumnIndex(identifier));
- }
-
- public TableColumn addColumn(int modelColumn, int width) {
- return addColumn(modelColumn, width, null, null);
- }
-
- public TableColumn addColumn(int modelColumn) {
- return addColumn(modelColumn, 75, null, null);
- }
-
- /**
- * Creates a new column with modelColumn, width,
- * renderer, and editor and adds it to the end of
- * the JTable's array of columns. This method also retrieves the
- * name of the column using the model's getColumnName(modelColumn)
- * method, and sets the both the header value and the identifier
- * for this TableColumn accordingly.
- *
- * The modelColumn is the index of the column in the model which
- * will supply the data for this column in the table. This, like the
- * columnIdentifier in previous releases, does not change as the
- * columns are moved in the view.
- *
- * For the rest of the JTable API, and all of its associated classes,
- * columns are referred to in the co-ordinate system of the view, the
- * index of the column in the model is kept inside the TableColumn
- * and is used only to retrieve the information from the appropraite
- * column in the model.
- *
- *
- * @param modelColumn The index of the column in the model
- * @param width The new column's width. Or -1 to use
- * the default width
- * @param renderer The renderer used with the new column.
- * Or null to use the default renderer.
- * @param editor The editor used with the new column.
- * Or null to use the default editor.
- */
- public TableColumn addColumn(int modelColumn, int width,
- TableCellRenderer renderer,
- TableCellEditor editor) {
- TableColumn newColumn = new TableColumn(
- modelColumn, width, renderer, editor);
- addColumn(newColumn);
- return newColumn;
- }
-
-//
-// Methods that had their arguments switched.
-//
-
-// These won't work with the new table package.
-
-/*
- public Object getValueAt(int columnIndex, int rowIndex) {
- return super.getValueAt(rowIndex, columnIndex);
- }
-
- public boolean isCellEditable(int columnIndex, int rowIndex) {
- return super.isCellEditable(rowIndex, columnIndex);
- }
-
- public void setValueAt(Object aValue, int columnIndex, int rowIndex) {
- super.setValueAt(aValue, rowIndex, columnIndex);
- }
-*/
-
- public boolean editColumnRow(int columnIndex, int rowIndex) {
- return super.editCellAt(rowIndex, columnIndex);
- }
-
- public boolean editColumnRow(int columnIndex, int rowIndex, EventObject e){
- return super.editCellAt(rowIndex, columnIndex, e);
- }
-
-
-} // End Of Class OldJTable
diff --git a/src/hotspot/cpu/aarch64/aarch64.ad b/src/hotspot/cpu/aarch64/aarch64.ad
index b9252cc56ff..a9ca91d9309 100644
--- a/src/hotspot/cpu/aarch64/aarch64.ad
+++ b/src/hotspot/cpu/aarch64/aarch64.ad
@@ -1229,7 +1229,7 @@ public:
// predicate controlling addressing modes
bool size_fits_all_mem_uses(AddPNode* addp, int shift);
- // Convert BootTest condition to Assembler condition.
+ // Convert BoolTest condition to Assembler condition.
// Replicate the logic of cmpOpOper::ccode() and cmpOpUOper::ccode().
Assembler::Condition to_assembler_cond(BoolTest::mask cond);
%}
@@ -2579,7 +2579,7 @@ bool size_fits_all_mem_uses(AddPNode* addp, int shift) {
return true;
}
-// Convert BootTest condition to Assembler condition.
+// Convert BoolTest condition to Assembler condition.
// Replicate the logic of cmpOpOper::ccode() and cmpOpUOper::ccode().
Assembler::Condition to_assembler_cond(BoolTest::mask cond) {
Assembler::Condition result;
diff --git a/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp b/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp
index 9a035d9f40e..ad7bac4e067 100644
--- a/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.cpp
@@ -85,26 +85,16 @@ void ShenandoahBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, Dec
}
}
-void ShenandoahBarrierSetAssembler::shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp,
- bool tosca_live,
- bool expand_call) {
- if (ShenandoahSATBBarrier) {
- satb_write_barrier_pre(masm, obj, pre_val, thread, tmp, rscratch1, tosca_live, expand_call);
- }
-}
+void ShenandoahBarrierSetAssembler::satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register thread,
+ Register tmp1,
+ Register tmp2,
+ bool tosca_live,
+ bool expand_call) {
+ assert(ShenandoahSATBBarrier, "Should be checked by caller");
-void ShenandoahBarrierSetAssembler::satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp1,
- Register tmp2,
- bool tosca_live,
- bool expand_call) {
// If expand_call is true then we expand the call_VM_leaf macro
// directly to skip generating the check by
// InterpreterMacroAssembler::call_VM_leaf_base that checks _last_sp.
@@ -358,20 +348,20 @@ void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet d
if (ShenandoahBarrierSet::need_keep_alive_barrier(decorators, type)) {
__ enter(/*strip_ret_addr*/true);
__ push_call_clobbered_registers();
- satb_write_barrier_pre(masm /* masm */,
- noreg /* obj */,
- dst /* pre_val */,
- rthread /* thread */,
- tmp1 /* tmp1 */,
- tmp2 /* tmp2 */,
- true /* tosca_live */,
- true /* expand_call */);
+ satb_barrier(masm /* masm */,
+ noreg /* obj */,
+ dst /* pre_val */,
+ rthread /* thread */,
+ tmp1 /* tmp1 */,
+ tmp2 /* tmp2 */,
+ true /* tosca_live */,
+ true /* expand_call */);
__ pop_call_clobbered_registers();
__ leave();
}
}
-void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register obj) {
+void ShenandoahBarrierSetAssembler::card_barrier(MacroAssembler* masm, Register obj) {
assert(ShenandoahCardBarrier, "Should have been checked by caller");
__ lsr(obj, obj, CardTable::card_shift());
@@ -394,13 +384,13 @@ void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register o
void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
- bool on_oop = is_reference_type(type);
- if (!on_oop) {
+ // 1: non-reference types require no barriers
+ if (!is_reference_type(type)) {
BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);
return;
}
- // flatten object address if needed
+ // Flatten object address right away for simplicity: likely needed by barriers
if (dst.index() == noreg && dst.offset() == 0) {
if (dst.base() != tmp3) {
__ mov(tmp3, dst.base());
@@ -409,20 +399,26 @@ void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet
__ lea(tmp3, dst);
}
- shenandoah_write_barrier_pre(masm,
- tmp3 /* obj */,
- tmp2 /* pre_val */,
- rthread /* thread */,
- tmp1 /* tmp */,
- val != noreg /* tosca_live */,
- false /* expand_call */);
+ bool storing_non_null = (val != noreg);
+
+ // 2: pre-barrier: SATB needs the previous value
+ if (ShenandoahBarrierSet::need_satb_barrier(decorators, type)) {
+ satb_barrier(masm,
+ tmp3 /* obj */,
+ tmp2 /* pre_val */,
+ rthread /* thread */,
+ tmp1 /* tmp */,
+ rscratch1 /* tmp2 */,
+ storing_non_null /* tosca_live */,
+ false /* expand_call */);
+ }
+ // Store!
BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp3, 0), val, noreg, noreg, noreg);
- bool in_heap = (decorators & IN_HEAP) != 0;
- bool needs_post_barrier = (val != noreg) && in_heap && ShenandoahCardBarrier;
- if (needs_post_barrier) {
- store_check(masm, tmp3);
+ // 3: post-barrier: card barrier needs store address
+ if (ShenandoahBarrierSet::need_card_barrier(decorators, type) && storing_non_null) {
+ card_barrier(masm, tmp3);
}
}
diff --git a/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp b/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp
index c0e708e1292..362fcae1ccd 100644
--- a/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/gc/shenandoah/shenandoahBarrierSetAssembler_aarch64.hpp
@@ -40,23 +40,16 @@ class StubCodeGenerator;
class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
private:
- void satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp1,
- Register tmp2,
- bool tosca_live,
- bool expand_call);
- void shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp,
- bool tosca_live,
- bool expand_call);
+ void satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register thread,
+ Register tmp1,
+ Register tmp2,
+ bool tosca_live,
+ bool expand_call);
- void store_check(MacroAssembler* masm, Register obj);
+ void card_barrier(MacroAssembler* masm, Register obj);
void resolve_forward_pointer(MacroAssembler* masm, Register dst, Register tmp = noreg);
void resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst, Register tmp = noreg);
diff --git a/src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp b/src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp
index 7e2f333ba40..db653bcf236 100644
--- a/src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/stubGenerator_aarch64.cpp
@@ -6081,14 +6081,18 @@ class StubGenerator: public StubCodeGenerator {
// static int implKyber12To16(
// byte[] condensed, int index, short[] parsed, int parsedLength) {}
//
- // (parsedLength or (parsedLength - 48) must be divisible by 64.)
+ // we assume that parsed and condensed are allocated such that for
+ // n = (parsedLength + 63) / 64
+ // n blocks of 96 bytes of input can be processed, i.e.
+ // index + n * 96 <= condensed.length and
+ // n * 64 <= parsed.length
//
// condensed (byte[]) = c_rarg0
// condensedIndex = c_rarg1
- // parsed (short[112 or 256]) = c_rarg2
- // parsedLength (112 or 256) = c_rarg3
+ // parsed (short[]) = c_rarg2
+ // parsedLength = c_rarg3
address generate_kyber12To16() {
- Label L_F00, L_loop, L_end;
+ Label L_F00, L_loop;
__ align(CodeEntryAlignment);
StubId stub_id = StubId::stubgen_kyber12To16_id;
@@ -6209,75 +6213,8 @@ class StubGenerator: public StubCodeGenerator {
vs_st2_post(vs_front(vb), __ T8H, parsed);
__ sub(parsedLength, parsedLength, 64);
- __ cmp(parsedLength, (u1)64);
- __ br(Assembler::GE, L_loop);
- __ cbz(parsedLength, L_end);
-
- // if anything is left it should be a final 72 bytes of input
- // i.e. a final 48 12-bit values. so we handle this by loading
- // 48 bytes into all 16B lanes of front(vin) and only 24
- // bytes into the lower 8B lane of back(vin)
- vs_ld3_post(vs_front(vin), __ T16B, condensed);
- vs_ld3(vs_back(vin), __ T8B, condensed);
-
- // Expand vin[0] into va[0:1], and vin[1] into va[2:3] and va[4:5]
- // n.b. target elements 2 and 3 of va duplicate elements 4 and
- // 5 and target element 2 of vb duplicates element 4.
- __ ushll(va[0], __ T8H, vin[0], __ T8B, 0);
- __ ushll2(va[1], __ T8H, vin[0], __ T16B, 0);
- __ ushll(va[2], __ T8H, vin[1], __ T8B, 0);
- __ ushll2(va[3], __ T8H, vin[1], __ T16B, 0);
- __ ushll(va[4], __ T8H, vin[1], __ T8B, 0);
- __ ushll2(va[5], __ T8H, vin[1], __ T16B, 0);
-
- // This time expand just the lower 8 lanes
- __ ushll(vb[0], __ T8H, vin[3], __ T8B, 0);
- __ ushll(vb[2], __ T8H, vin[4], __ T8B, 0);
- __ ushll(vb[4], __ T8H, vin[4], __ T8B, 0);
-
- // shift lo byte of copy 1 of the middle stripe into the high byte
- __ shl(va[2], __ T8H, va[2], 8);
- __ shl(va[3], __ T8H, va[3], 8);
- __ shl(vb[2], __ T8H, vb[2], 8);
-
- // expand vin[2] into va[6:7] and lower 8 lanes of vin[5] into
- // vb[6] pre-shifted by 4 to ensure top bits of the input 12-bit
- // int are in bit positions [4..11].
- __ ushll(va[6], __ T8H, vin[2], __ T8B, 4);
- __ ushll2(va[7], __ T8H, vin[2], __ T16B, 4);
- __ ushll(vb[6], __ T8H, vin[5], __ T8B, 4);
-
- // mask hi 4 bits of each 1st 12-bit int in pair from copy1 and
- // shift lo 4 bits of each 2nd 12-bit int in pair to bottom of
- // copy2
- __ andr(va[2], __ T16B, va[2], v31);
- __ andr(va[3], __ T16B, va[3], v31);
- __ ushr(va[4], __ T8H, va[4], 4);
- __ ushr(va[5], __ T8H, va[5], 4);
- __ andr(vb[2], __ T16B, vb[2], v31);
- __ ushr(vb[4], __ T8H, vb[4], 4);
-
-
-
- // sum hi 4 bits and lo 8 bits of each 1st 12-bit int in pair and
- // hi 8 bits plus lo 4 bits of each 2nd 12-bit int in pair
-
- // n.b. ordering ensures: i) inputs are consumed before they are
- // overwritten ii) order of 16-bit results across succsessive
- // pairs of vectors in va and then lower half of vb reflects order
- // of corresponding 12-bit inputs
- __ addv(va[0], __ T8H, va[0], va[2]);
- __ addv(va[2], __ T8H, va[1], va[3]);
- __ addv(va[1], __ T8H, va[4], va[6]);
- __ addv(va[3], __ T8H, va[5], va[7]);
- __ addv(vb[0], __ T8H, vb[0], vb[2]);
- __ addv(vb[1], __ T8H, vb[4], vb[6]);
-
- // store 48 results interleaved as shorts
- vs_st2_post(vs_front(va), __ T8H, parsed);
- vs_st2_post(vs_front(vs_front(vb)), __ T8H, parsed);
-
- __ BIND(L_end);
+ __ cmp(parsedLength, (u1)0);
+ __ br(Assembler::GT, L_loop);
__ leave(); // required for proper stackwalking of RuntimeStub frame
__ mov(r0, zr); // return 0
diff --git a/src/hotspot/cpu/aarch64/vm_version_aarch64.cpp b/src/hotspot/cpu/aarch64/vm_version_aarch64.cpp
index 659c231464a..3fa85f8f47d 100644
--- a/src/hotspot/cpu/aarch64/vm_version_aarch64.cpp
+++ b/src/hotspot/cpu/aarch64/vm_version_aarch64.cpp
@@ -201,16 +201,14 @@ void VM_Version::initialize() {
}
}
- // Cortex A53
- if (_cpu == CPU_ARM && model_is(0xd03)) {
+ if (_cpu == CPU_ARM && model_is(CPU_MODEL_ARM_CORTEX_A53)) {
set_feature(CPU_A53MAC);
if (FLAG_IS_DEFAULT(UseSIMDForArrayEquals)) {
FLAG_SET_DEFAULT(UseSIMDForArrayEquals, false);
}
}
- // Cortex A73
- if (_cpu == CPU_ARM && model_is(0xd09)) {
+ if (_cpu == CPU_ARM && model_is(CPU_MODEL_ARM_CORTEX_A73)) {
if (FLAG_IS_DEFAULT(SoftwarePrefetchHintDistance)) {
FLAG_SET_DEFAULT(SoftwarePrefetchHintDistance, -1);
}
@@ -220,16 +218,11 @@ void VM_Version::initialize() {
}
}
- // Neoverse
- // N1: 0xd0c
- // N2: 0xd49
- // N3: 0xd8e
- // V1: 0xd40
- // V2: 0xd4f
- // V3: 0xd84
- if (_cpu == CPU_ARM && (model_is(0xd0c) || model_is(0xd49) ||
- model_is(0xd40) || model_is(0xd4f) ||
- model_is(0xd8e) || model_is(0xd84))) {
+ if (_cpu == CPU_ARM &&
+ model_is_in({ CPU_MODEL_ARM_NEOVERSE_N1, CPU_MODEL_ARM_NEOVERSE_V1,
+ CPU_MODEL_ARM_NEOVERSE_N2, CPU_MODEL_ARM_NEOVERSE_V2,
+ CPU_MODEL_ARM_NEOVERSE_N3, CPU_MODEL_ARM_NEOVERSE_V3,
+ CPU_MODEL_ARM_NEOVERSE_V3AE })) {
if (FLAG_IS_DEFAULT(UseSIMDForMemoryOps)) {
FLAG_SET_DEFAULT(UseSIMDForMemoryOps, true);
}
@@ -261,12 +254,9 @@ void VM_Version::initialize() {
FLAG_SET_DEFAULT(UseCRC32, false);
}
- // Neoverse
- // V1: 0xd40
- // V2: 0xd4f
- // V3: 0xd84
if (_cpu == CPU_ARM &&
- (model_is(0xd40) || model_is(0xd4f) || model_is(0xd84))) {
+ model_is_in({ CPU_MODEL_ARM_NEOVERSE_V1, CPU_MODEL_ARM_NEOVERSE_V2,
+ CPU_MODEL_ARM_NEOVERSE_V3, CPU_MODEL_ARM_NEOVERSE_V3AE })) {
if (FLAG_IS_DEFAULT(UseCryptoPmullForCRC32)) {
FLAG_SET_DEFAULT(UseCryptoPmullForCRC32, true);
}
diff --git a/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp b/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp
index 17087d243d3..38b112d9936 100644
--- a/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp
+++ b/src/hotspot/cpu/aarch64/vm_version_aarch64.hpp
@@ -30,6 +30,8 @@
#include "runtime/abstract_vm_version.hpp"
#include "utilities/sizes.hpp"
+#include
+
class stringStream;
#define BIT_MASK(flag) (1ULL<<(flag))
@@ -112,14 +114,26 @@ class VM_Version : public Abstract_VM_Version {
CPU_APPLE = 'a',
};
-enum Ampere_CPU_Model {
+ enum Ampere_CPU_Model {
CPU_MODEL_EMAG = 0x0, /* CPU implementer is CPU_AMCC */
CPU_MODEL_ALTRA = 0xd0c, /* CPU implementer is CPU_ARM, Neoverse N1 */
CPU_MODEL_ALTRAMAX = 0xd0c, /* CPU implementer is CPU_ARM, Neoverse N1 */
CPU_MODEL_AMPERE_1 = 0xac3, /* CPU implementer is CPU_AMPERE */
CPU_MODEL_AMPERE_1A = 0xac4, /* CPU implementer is CPU_AMPERE */
CPU_MODEL_AMPERE_1B = 0xac5 /* AMPERE_1B core Implements ARMv8.7 with CSSC, MTE, SM3/SM4 extensions */
-};
+ };
+
+ enum ARM_CPU_Model {
+ CPU_MODEL_ARM_CORTEX_A53 = 0xd03,
+ CPU_MODEL_ARM_CORTEX_A73 = 0xd09,
+ CPU_MODEL_ARM_NEOVERSE_N1 = 0xd0c,
+ CPU_MODEL_ARM_NEOVERSE_V1 = 0xd40,
+ CPU_MODEL_ARM_NEOVERSE_N2 = 0xd49,
+ CPU_MODEL_ARM_NEOVERSE_V2 = 0xd4f,
+ CPU_MODEL_ARM_NEOVERSE_V3AE = 0xd83,
+ CPU_MODEL_ARM_NEOVERSE_V3 = 0xd84,
+ CPU_MODEL_ARM_NEOVERSE_N3 = 0xd8e,
+ };
#define CPU_FEATURE_FLAGS(decl) \
decl(FP, fp, 0) \
@@ -181,6 +195,15 @@ enum Ampere_CPU_Model {
return _model == cpu_model || _model2 == cpu_model;
}
+ static bool model_is_in(std::initializer_list cpu_models) {
+ for (const int& cpu_model : cpu_models) {
+ if (_model == cpu_model || _model2 == cpu_model) {
+ return true;
+ }
+ }
+ return false;
+ }
+
static bool is_zva_enabled() { return 0 <= _zva_length; }
static int zva_length() {
assert(is_zva_enabled(), "ZVA not available");
diff --git a/src/hotspot/cpu/ppc/assembler_ppc.hpp b/src/hotspot/cpu/ppc/assembler_ppc.hpp
index 15e38411482..23775a3a52e 100644
--- a/src/hotspot/cpu/ppc/assembler_ppc.hpp
+++ b/src/hotspot/cpu/ppc/assembler_ppc.hpp
@@ -568,6 +568,9 @@ class Assembler : public AbstractAssembler {
XSCVDPHP_OPCODE= (60u << OPCODE_SHIFT | 347u << 2 | 17u << 16), // XX2-FORM
XXPERM_OPCODE = (60u << OPCODE_SHIFT | 26u << 3),
XXSEL_OPCODE = (60u << OPCODE_SHIFT | 3u << 4),
+ XSCMPEQDP_OPCODE=(60u << OPCODE_SHIFT | 3u << 3),
+ XSCMPGEDP_OPCODE=(60u << OPCODE_SHIFT | 19u << 3),
+ XSCMPGTDP_OPCODE=(60u << OPCODE_SHIFT | 11u << 3),
XXSPLTIB_OPCODE= (60u << OPCODE_SHIFT | 360u << 1),
XVDIVDP_OPCODE = (60u << OPCODE_SHIFT | 120u << 3),
XVABSSP_OPCODE = (60u << OPCODE_SHIFT | 409u << 2),
@@ -2424,6 +2427,9 @@ class Assembler : public AbstractAssembler {
inline void xscvdphp( VectorSRegister d, VectorSRegister b);
inline void xxland( VectorSRegister d, VectorSRegister a, VectorSRegister b);
inline void xxsel( VectorSRegister d, VectorSRegister a, VectorSRegister b, VectorSRegister c);
+ inline void xscmpeqdp(VectorSRegister t, VectorSRegister a, VectorSRegister b); // Requires Power9
+ inline void xscmpgedp(VectorSRegister t, VectorSRegister a, VectorSRegister b); // Requires Power9
+ inline void xscmpgtdp(VectorSRegister t, VectorSRegister a, VectorSRegister b); // Requires Power9
inline void xxspltib( VectorSRegister d, int ui8);
inline void xvdivsp( VectorSRegister d, VectorSRegister a, VectorSRegister b);
inline void xvdivdp( VectorSRegister d, VectorSRegister a, VectorSRegister b);
diff --git a/src/hotspot/cpu/ppc/assembler_ppc.inline.hpp b/src/hotspot/cpu/ppc/assembler_ppc.inline.hpp
index 7e49ec7455d..4cda782067e 100644
--- a/src/hotspot/cpu/ppc/assembler_ppc.inline.hpp
+++ b/src/hotspot/cpu/ppc/assembler_ppc.inline.hpp
@@ -923,6 +923,10 @@ inline void Assembler::xxmrghw( VectorSRegister d, VectorSRegister a, VectorSReg
inline void Assembler::xxmrglw( VectorSRegister d, VectorSRegister a, VectorSRegister b) { emit_int32( XXMRGHW_OPCODE | vsrt(d) | vsra(a) | vsrb(b)); }
inline void Assembler::xxsel( VectorSRegister d, VectorSRegister a, VectorSRegister b, VectorSRegister c) { emit_int32( XXSEL_OPCODE | vsrt(d) | vsra(a) | vsrb(b) | vsrc(c)); }
+inline void Assembler::xscmpeqdp(VectorSRegister t, VectorSRegister a, VectorSRegister b) { emit_int32( XSCMPEQDP_OPCODE | vsrt(t) | vsra(a) | vsrb(b) );}
+inline void Assembler::xscmpgedp(VectorSRegister t, VectorSRegister a, VectorSRegister b) { emit_int32( XSCMPGEDP_OPCODE | vsrt(t) | vsra(a) | vsrb(b) );}
+inline void Assembler::xscmpgtdp(VectorSRegister t, VectorSRegister a, VectorSRegister b) { emit_int32( XSCMPGTDP_OPCODE | vsrt(t) | vsra(a) | vsrb(b) );}
+
// VSX Extended Mnemonics
inline void Assembler::xxspltd( VectorSRegister d, VectorSRegister a, int x) { xxpermdi(d, a, a, x ? 3 : 0); }
inline void Assembler::xxmrghd( VectorSRegister d, VectorSRegister a, VectorSRegister b) { xxpermdi(d, a, b, 0); }
diff --git a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp
index edf348fdc50..73b6b132895 100644
--- a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp
+++ b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.cpp
@@ -664,3 +664,37 @@ void C2_MacroAssembler::reduceI(int opcode, Register dst, Register iSrc, VectorR
fn_scalar_op(opcode, dst, iSrc, R0); // dst <- op(iSrc, R0)
}
+// Works for single and double precision floats.
+// dst = (op1 cmp(cc) op2) ? src1 : src2;
+// Unordered semantics are the same as for CmpF3Node/CmpD3Node which implement the fcmpl/dcmpl bytecodes.
+// Comparing unordered values has the same result as when src1 is less than src2.
+// So dst = src1 for <, <=, != and dst = src2 for >, >=, ==.
+void C2_MacroAssembler::cmovF(int cc, VectorSRegister dst, VectorSRegister op1, VectorSRegister op2,
+ VectorSRegister src1, VectorSRegister src2, VectorSRegister tmp) {
+ // See operand cmpOp() for details.
+ bool invert_cond = (cc & 8) == 0; // invert reflects bcondCRbiIs0
+ auto cmp = (Assembler::Condition)(cc & 3);
+
+ switch(cmp) {
+ case Assembler::Condition::equal:
+ // Use false_result if "unordered".
+ xscmpeqdp(tmp, op1, op2);
+ break;
+ case Assembler::Condition::greater:
+ // Use false_result if "unordered".
+ xscmpgtdp(tmp, op1, op2);
+ break;
+ case Assembler::Condition::less:
+ // Use true_result if "unordered".
+ xscmpgedp(tmp, op1, op2);
+ invert_cond = !invert_cond;
+ break;
+ default:
+ assert(false, "unsupported compare condition: %d", cc);
+ ShouldNotReachHere();
+ }
+
+ VectorSRegister true_result = invert_cond ? src2 : src1;
+ VectorSRegister false_result = invert_cond ? src1 : src2;
+ xxsel(dst, false_result, true_result, tmp);
+}
diff --git a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.hpp b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.hpp
index 5a114294c1f..e0dffec8396 100644
--- a/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.hpp
+++ b/src/hotspot/cpu/ppc/c2_MacroAssembler_ppc.hpp
@@ -74,5 +74,7 @@
void count_positives(Register src, Register cnt, Register result, Register tmp1, Register tmp2);
void reduceI(int opcode, Register dst, Register iSrc, VectorRegister vSrc, VectorRegister vTmp1, VectorRegister vTmp2);
+ void cmovF(int cc, VectorSRegister dst, VectorSRegister op1, VectorSRegister op2,
+ VectorSRegister src1, VectorSRegister src2, VectorSRegister tmp);
#endif // CPU_PPC_C2_MACROASSEMBLER_PPC_HPP
diff --git a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp
index 9d143c14d27..c3bb1811031 100644
--- a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp
+++ b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.cpp
@@ -50,14 +50,14 @@
#define __ masm->
-void ShenandoahBarrierSetAssembler::satb_write_barrier(MacroAssembler *masm,
- Register base, RegisterOrConstant ind_or_offs,
- Register tmp1, Register tmp2, Register tmp3,
- MacroAssembler::PreservationLevel preservation_level) {
+void ShenandoahBarrierSetAssembler::satb_barrier(MacroAssembler *masm,
+ Register base, RegisterOrConstant ind_or_offs,
+ Register tmp1, Register tmp2, Register tmp3,
+ MacroAssembler::PreservationLevel preservation_level) {
if (ShenandoahSATBBarrier) {
- __ block_comment("satb_write_barrier (shenandoahgc) {");
- satb_write_barrier_impl(masm, 0, base, ind_or_offs, tmp1, tmp2, tmp3, preservation_level);
- __ block_comment("} satb_write_barrier (shenandoahgc)");
+ __ block_comment("satb_barrier (shenandoahgc) {");
+ satb_barrier_impl(masm, 0, base, ind_or_offs, tmp1, tmp2, tmp3, preservation_level);
+ __ block_comment("} satb_barrier (shenandoahgc)");
}
}
@@ -198,11 +198,12 @@ void ShenandoahBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, Dec
// In "load mode", this register acts as a temporary register and must
// thus not be 'noreg'. In "preloaded mode", its content will be sustained.
// tmp1/tmp2: Temporary registers, one of which must be non-volatile in "preloaded mode".
-void ShenandoahBarrierSetAssembler::satb_write_barrier_impl(MacroAssembler *masm, DecoratorSet decorators,
- Register base, RegisterOrConstant ind_or_offs,
- Register pre_val,
- Register tmp1, Register tmp2,
- MacroAssembler::PreservationLevel preservation_level) {
+void ShenandoahBarrierSetAssembler::satb_barrier_impl(MacroAssembler *masm, DecoratorSet decorators,
+ Register base, RegisterOrConstant ind_or_offs,
+ Register pre_val,
+ Register tmp1, Register tmp2,
+ MacroAssembler::PreservationLevel preservation_level) {
+ assert(ShenandoahSATBBarrier, "Should be checked by caller");
assert_different_registers(tmp1, tmp2, pre_val, noreg);
Label skip_barrier;
@@ -574,13 +575,13 @@ void ShenandoahBarrierSetAssembler::load_at(
if (ShenandoahBarrierSet::need_keep_alive_barrier(decorators, type)) {
if (ShenandoahSATBBarrier) {
__ block_comment("keep_alive_barrier (shenandoahgc) {");
- satb_write_barrier_impl(masm, 0, noreg, noreg, dst, tmp1, tmp2, preservation_level);
+ satb_barrier_impl(masm, 0, noreg, noreg, dst, tmp1, tmp2, preservation_level);
__ block_comment("} keep_alive_barrier (shenandoahgc)");
}
}
}
-void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register base, RegisterOrConstant ind_or_offs, Register tmp) {
+void ShenandoahBarrierSetAssembler::card_barrier(MacroAssembler* masm, Register base, RegisterOrConstant ind_or_offs, Register tmp) {
assert(ShenandoahCardBarrier, "Should have been checked by caller");
assert_different_registers(base, tmp, R0);
@@ -603,21 +604,33 @@ void ShenandoahBarrierSetAssembler::store_at(MacroAssembler *masm, DecoratorSet
Register base, RegisterOrConstant ind_or_offs, Register val,
Register tmp1, Register tmp2, Register tmp3,
MacroAssembler::PreservationLevel preservation_level) {
- if (is_reference_type(type)) {
- if (ShenandoahSATBBarrier) {
- satb_write_barrier(masm, base, ind_or_offs, tmp1, tmp2, tmp3, preservation_level);
- }
+ // 1: non-reference types require no barriers
+ if (!is_reference_type(type)) {
+ BarrierSetAssembler::store_at(masm, decorators, type,
+ base, ind_or_offs,
+ val,
+ tmp1, tmp2, tmp3,
+ preservation_level);
+ return;
+ }
+
+ bool storing_non_null = (val != noreg);
+
+ // 2: pre-barrier: SATB needs the previous value
+ if (ShenandoahBarrierSet::need_satb_barrier(decorators, type)) {
+ satb_barrier(masm, base, ind_or_offs, tmp1, tmp2, tmp3, preservation_level);
}
+ // Store!
BarrierSetAssembler::store_at(masm, decorators, type,
base, ind_or_offs,
val,
tmp1, tmp2, tmp3,
preservation_level);
- // No need for post barrier if storing null
- if (ShenandoahCardBarrier && is_reference_type(type) && val != noreg) {
- store_check(masm, base, ind_or_offs, tmp1);
+ // 3: post-barrier: card barrier needs store address
+ if (ShenandoahBarrierSet::need_card_barrier(decorators, type) && storing_non_null) {
+ card_barrier(masm, base, ind_or_offs, tmp1);
}
}
diff --git a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.hpp b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.hpp
index b058dcf1a2e..52615a740af 100644
--- a/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.hpp
+++ b/src/hotspot/cpu/ppc/gc/shenandoah/shenandoahBarrierSetAssembler_ppc.hpp
@@ -45,15 +45,15 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
private:
/* ==== Actual barrier implementations ==== */
- void satb_write_barrier_impl(MacroAssembler* masm, DecoratorSet decorators,
- Register base, RegisterOrConstant ind_or_offs,
- Register pre_val,
- Register tmp1, Register tmp2,
- MacroAssembler::PreservationLevel preservation_level);
+ void satb_barrier_impl(MacroAssembler* masm, DecoratorSet decorators,
+ Register base, RegisterOrConstant ind_or_offs,
+ Register pre_val,
+ Register tmp1, Register tmp2,
+ MacroAssembler::PreservationLevel preservation_level);
- void store_check(MacroAssembler* masm,
- Register base, RegisterOrConstant ind_or_offs,
- Register tmp);
+ void card_barrier(MacroAssembler* masm,
+ Register base, RegisterOrConstant ind_or_offs,
+ Register tmp);
void load_reference_barrier_impl(MacroAssembler* masm, DecoratorSet decorators,
Register base, RegisterOrConstant ind_or_offs,
@@ -85,10 +85,10 @@ class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
#endif
/* ==== Available barriers (facades of the actual implementations) ==== */
- void satb_write_barrier(MacroAssembler* masm,
- Register base, RegisterOrConstant ind_or_offs,
- Register tmp1, Register tmp2, Register tmp3,
- MacroAssembler::PreservationLevel preservation_level);
+ void satb_barrier(MacroAssembler* masm,
+ Register base, RegisterOrConstant ind_or_offs,
+ Register tmp1, Register tmp2, Register tmp3,
+ MacroAssembler::PreservationLevel preservation_level);
void load_reference_barrier(MacroAssembler* masm, DecoratorSet decorators,
Register base, RegisterOrConstant ind_or_offs,
diff --git a/src/hotspot/cpu/ppc/matcher_ppc.hpp b/src/hotspot/cpu/ppc/matcher_ppc.hpp
index aad41fb7b1c..b50de6323de 100644
--- a/src/hotspot/cpu/ppc/matcher_ppc.hpp
+++ b/src/hotspot/cpu/ppc/matcher_ppc.hpp
@@ -64,12 +64,10 @@
return true;
}
- // Use conditional move (CMOVL) on Power7.
static constexpr int long_cmove_cost() { return 0; } // this only makes long cmoves more expensive than int cmoves
- // Suppress CMOVF. Conditional move available (sort of) on PPC64 only from P7 onwards. Not exploited yet.
- // fsel doesn't accept a condition register as input, so this would be slightly different.
- static int float_cmove_cost() { return ConditionalMoveLimit; }
+ // Suppress CMOVF for Power8 because there are no fast nodes.
+ static int float_cmove_cost() { return (PowerArchitecturePPC64 >= 9) ? 0 : ConditionalMoveLimit; }
// This affects two different things:
// - how Decode nodes are matched
diff --git a/src/hotspot/cpu/ppc/ppc.ad b/src/hotspot/cpu/ppc/ppc.ad
index 2a0a9149bb3..d926fabd353 100644
--- a/src/hotspot/cpu/ppc/ppc.ad
+++ b/src/hotspot/cpu/ppc/ppc.ad
@@ -3024,7 +3024,6 @@ encode %{
%}
enc_class postalloc_expand_encode_oop(iRegNdst dst, iRegPdst src, flagsReg crx) %{
- // use isel instruction with Power 7
cmpP_reg_imm16Node *n_compare = new cmpP_reg_imm16Node();
encodeP_subNode *n_sub_base = new encodeP_subNode();
encodeP_shiftNode *n_shift = new encodeP_shiftNode();
@@ -3099,7 +3098,6 @@ encode %{
n_shift->_opnds[1] = op_src;
n_shift->_bottom_type = _bottom_type;
- // use isel instruction with Power 7
decodeN_addNode *n_add_base = new decodeN_addNode();
n_add_base->add_req(n_region, n_shift);
n_add_base->_opnds[0] = op_dst;
@@ -6618,7 +6616,6 @@ instruct cond_sub_base(iRegNdst dst, flagsRegSrc crx, iRegPsrc src1) %{
ins_pipe(pipe_class_default);
%}
-// Power 7 can use isel instruction
instruct cond_set_0_oop(iRegNdst dst, flagsRegSrc crx, iRegPsrc src1) %{
// The match rule is needed to make it a 'MachTypeNode'!
match(Set dst (EncodeP (Binary crx src1)));
@@ -7293,7 +7290,6 @@ instruct cmovF_reg(cmpOp cmp, flagsRegSrc crx, regF dst, regF src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "CMOVEF $cmp, $crx, $dst, $src\n\t" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode %{
Label done;
@@ -7313,7 +7309,6 @@ instruct cmovD_reg(cmpOp cmp, flagsRegSrc crx, regD dst, regD src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "CMOVEF $cmp, $crx, $dst, $src\n\t" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode %{
Label done;
@@ -7326,6 +7321,70 @@ instruct cmovD_reg(cmpOp cmp, flagsRegSrc crx, regD dst, regD src) %{
ins_pipe(pipe_class_default);
%}
+instruct cmovF_cmpF(cmpOp cop, regF op1, regF op2, regF dst, regF false_result, regF true_result, regD tmp) %{
+ match(Set dst (CMoveF (Binary cop (CmpF op1 op2)) (Binary false_result true_result)));
+ predicate(PowerArchitecturePPC64 >= 9);
+ effect(TEMP tmp);
+ ins_cost(2*DEFAULT_COST);
+ format %{ "cmovF_cmpF $dst = ($op1 $cop $op2) ? $true_result : $false_result\n\t" %}
+ size(8);
+ ins_encode %{
+ __ cmovF($cop$$cmpcode, $dst$$FloatRegister->to_vsr(),
+ $op1$$FloatRegister->to_vsr(), $op2$$FloatRegister->to_vsr(),
+ $true_result$$FloatRegister->to_vsr(), $false_result$$FloatRegister->to_vsr(),
+ $tmp$$FloatRegister->to_vsr());
+ %}
+ ins_pipe(pipe_class_default);
+%}
+
+instruct cmovF_cmpD(cmpOp cop, regD op1, regD op2, regF dst, regF false_result, regF true_result, regD tmp) %{
+ match(Set dst (CMoveF (Binary cop (CmpD op1 op2)) (Binary false_result true_result)));
+ predicate(PowerArchitecturePPC64 >= 9);
+ effect(TEMP tmp);
+ ins_cost(2*DEFAULT_COST);
+ format %{ "cmovF_cmpD $dst = ($op1 $cop $op2) ? $true_result : $false_result\n\t" %}
+ size(8);
+ ins_encode %{
+ __ cmovF($cop$$cmpcode, $dst$$FloatRegister->to_vsr(),
+ $op1$$FloatRegister->to_vsr(), $op2$$FloatRegister->to_vsr(),
+ $true_result$$FloatRegister->to_vsr(), $false_result$$FloatRegister->to_vsr(),
+ $tmp$$FloatRegister->to_vsr());
+ %}
+ ins_pipe(pipe_class_default);
+%}
+
+instruct cmovD_cmpD(cmpOp cop, regD op1, regD op2, regD dst, regD false_result, regD true_result, regD tmp) %{
+ match(Set dst (CMoveD (Binary cop (CmpD op1 op2)) (Binary false_result true_result)));
+ predicate(PowerArchitecturePPC64 >= 9);
+ effect(TEMP tmp);
+ ins_cost(2*DEFAULT_COST);
+ format %{ "cmovD_cmpD $dst = ($op1 $cop $op2) ? $true_result : $false_result\n\t" %}
+ size(8);
+ ins_encode %{
+ __ cmovF($cop$$cmpcode, $dst$$FloatRegister->to_vsr(),
+ $op1$$FloatRegister->to_vsr(), $op2$$FloatRegister->to_vsr(),
+ $true_result$$FloatRegister->to_vsr(), $false_result$$FloatRegister->to_vsr(),
+ $tmp$$FloatRegister->to_vsr());
+ %}
+ ins_pipe(pipe_class_default);
+%}
+
+instruct cmovD_cmpF(cmpOp cop, regF op1, regF op2, regD dst, regD false_result, regD true_result, regD tmp) %{
+ match(Set dst (CMoveD (Binary cop (CmpF op1 op2)) (Binary false_result true_result)));
+ predicate(PowerArchitecturePPC64 >= 9);
+ effect(TEMP tmp);
+ ins_cost(2*DEFAULT_COST);
+ format %{ "cmovD_cmpF $dst = ($op1 $cop $op2) ? $true_result : $false_result\n\t" %}
+ size(8);
+ ins_encode %{
+ __ cmovF($cop$$cmpcode, $dst$$FloatRegister->to_vsr(),
+ $op1$$FloatRegister->to_vsr(), $op2$$FloatRegister->to_vsr(),
+ $true_result$$FloatRegister->to_vsr(), $false_result$$FloatRegister->to_vsr(),
+ $tmp$$FloatRegister->to_vsr());
+ %}
+ ins_pipe(pipe_class_default);
+%}
+
//----------Compare-And-Swap---------------------------------------------------
// CompareAndSwap{P,I,L} have more than one output, therefore "CmpI
@@ -8492,7 +8551,6 @@ instruct cmovI_bne_negI_reg(iRegIdst dst, flagsRegSrc crx, iRegIsrc src1) %{
ins_variable_size_depending_on_alignment(true);
format %{ "CMOVE $dst, neg($src1), $crx" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode %{
Label done;
@@ -8551,7 +8609,6 @@ instruct cmovL_bne_negL_reg(iRegLdst dst, flagsRegSrc crx, iRegLsrc src1) %{
ins_variable_size_depending_on_alignment(true);
format %{ "CMOVE $dst, neg($src1), $crx" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode %{
Label done;
@@ -10262,7 +10319,6 @@ instruct cmovI_bso_stackSlotL(iRegIdst dst, flagsRegSrc crx, stackSlotL src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "cmovI $crx, $dst, $src" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode( enc_cmove_bso_stackSlotL(dst, crx, src) );
ins_pipe(pipe_class_default);
@@ -10276,7 +10332,6 @@ instruct cmovI_bso_reg(iRegIdst dst, flagsRegSrc crx, regD src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "cmovI $crx, $dst, $src" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode( enc_cmove_bso_reg(dst, crx, src) );
ins_pipe(pipe_class_default);
@@ -10439,7 +10494,6 @@ instruct cmovL_bso_stackSlotL(iRegLdst dst, flagsRegSrc crx, stackSlotL src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "cmovL $crx, $dst, $src" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode( enc_cmove_bso_stackSlotL(dst, crx, src) );
ins_pipe(pipe_class_default);
@@ -10453,7 +10507,6 @@ instruct cmovL_bso_reg(iRegLdst dst, flagsRegSrc crx, regD src) %{
ins_variable_size_depending_on_alignment(true);
format %{ "cmovL $crx, $dst, $src" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(8);
ins_encode( enc_cmove_bso_reg(dst, crx, src) );
ins_pipe(pipe_class_default);
@@ -11080,7 +11133,6 @@ instruct cmov_bns_less(flagsReg crx) %{
ins_variable_size_depending_on_alignment(true);
format %{ "cmov $crx" %}
- // Worst case is branch + move + stop, no stop without scheduler.
size(12);
ins_encode %{
Label done;
diff --git a/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.cpp b/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.cpp
index dd6c8556307..3cbbb783258 100644
--- a/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.cpp
+++ b/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.cpp
@@ -88,26 +88,16 @@ void ShenandoahBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, Dec
}
}
-void ShenandoahBarrierSetAssembler::shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp,
- bool tosca_live,
- bool expand_call) {
- if (ShenandoahSATBBarrier) {
- satb_write_barrier_pre(masm, obj, pre_val, thread, tmp, t0, tosca_live, expand_call);
- }
-}
+void ShenandoahBarrierSetAssembler::satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register thread,
+ Register tmp1,
+ Register tmp2,
+ bool tosca_live,
+ bool expand_call) {
+ assert(ShenandoahSATBBarrier, "Should be checked by caller");
-void ShenandoahBarrierSetAssembler::satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp1,
- Register tmp2,
- bool tosca_live,
- bool expand_call) {
// If expand_call is true then we expand the call_VM_leaf macro
// directly to skip generating the check by
// InterpreterMacroAssembler::call_VM_leaf_base that checks _last_sp.
@@ -376,21 +366,21 @@ void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm,
if (ShenandoahBarrierSet::need_keep_alive_barrier(decorators, type)) {
__ enter();
__ push_call_clobbered_registers();
- satb_write_barrier_pre(masm /* masm */,
- noreg /* obj */,
- dst /* pre_val */,
- xthread /* thread */,
- tmp1 /* tmp1 */,
- tmp2 /* tmp2 */,
- true /* tosca_live */,
- true /* expand_call */);
+ satb_barrier(masm /* masm */,
+ noreg /* obj */,
+ dst /* pre_val */,
+ xthread /* thread */,
+ tmp1 /* tmp1 */,
+ tmp2 /* tmp2 */,
+ true /* tosca_live */,
+ true /* expand_call */);
__ pop_call_clobbered_registers();
__ leave();
}
}
-void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register obj) {
- assert(ShenandoahCardBarrier, "Did you mean to enable ShenandoahCardBarrier?");
+void ShenandoahBarrierSetAssembler::card_barrier(MacroAssembler* masm, Register obj) {
+ assert(ShenandoahCardBarrier, "Should have been checked by caller");
__ srli(obj, obj, CardTable::card_shift());
@@ -413,13 +403,13 @@ void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register o
void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
- bool on_oop = is_reference_type(type);
- if (!on_oop) {
+ // 1: non-reference types require no barriers
+ if (!is_reference_type(type)) {
BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);
return;
}
- // flatten object address if needed
+ // Flatten object address right away for simplicity: likely needed by barriers
if (dst.offset() == 0) {
if (dst.base() != tmp3) {
__ mv(tmp3, dst.base());
@@ -428,20 +418,26 @@ void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet
__ la(tmp3, dst);
}
- shenandoah_write_barrier_pre(masm,
- tmp3 /* obj */,
- tmp2 /* pre_val */,
- xthread /* thread */,
- tmp1 /* tmp */,
- val != noreg /* tosca_live */,
- false /* expand_call */);
+ bool storing_non_null = (val != noreg);
+
+ // 2: pre-barrier: SATB needs the previous value
+ if (ShenandoahBarrierSet::need_satb_barrier(decorators, type)) {
+ satb_barrier(masm,
+ tmp3 /* obj */,
+ tmp2 /* pre_val */,
+ xthread /* thread */,
+ tmp1 /* tmp */,
+ t0 /* tmp2 */,
+ storing_non_null /* tosca_live */,
+ false /* expand_call */);
+ }
+ // Store!
BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp3, 0), val, noreg, noreg, noreg);
- bool in_heap = (decorators & IN_HEAP) != 0;
- bool needs_post_barrier = (val != noreg) && in_heap && ShenandoahCardBarrier;
- if (needs_post_barrier) {
- store_check(masm, tmp3);
+ // 3: post-barrier: card barrier needs store address
+ if (ShenandoahBarrierSet::need_card_barrier(decorators, type) && storing_non_null) {
+ card_barrier(masm, tmp3);
}
}
diff --git a/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.hpp b/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.hpp
index c8a7c35fb83..5085be26b2e 100644
--- a/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.hpp
+++ b/src/hotspot/cpu/riscv/gc/shenandoah/shenandoahBarrierSetAssembler_riscv.hpp
@@ -41,23 +41,16 @@ class StubCodeGenerator;
class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
private:
- void satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp1,
- Register tmp2,
- bool tosca_live,
- bool expand_call);
- void shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register thread,
- Register tmp,
- bool tosca_live,
- bool expand_call);
-
- void store_check(MacroAssembler* masm, Register obj);
+ void satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register thread,
+ Register tmp1,
+ Register tmp2,
+ bool tosca_live,
+ bool expand_call);
+
+ void card_barrier(MacroAssembler* masm, Register obj);
void resolve_forward_pointer(MacroAssembler* masm, Register dst, Register tmp = noreg);
void resolve_forward_pointer_not_null(MacroAssembler* masm, Register dst, Register tmp = noreg);
diff --git a/src/hotspot/cpu/riscv/templateTable_riscv.cpp b/src/hotspot/cpu/riscv/templateTable_riscv.cpp
index 5a3644f70bb..0fb529d1683 100644
--- a/src/hotspot/cpu/riscv/templateTable_riscv.cpp
+++ b/src/hotspot/cpu/riscv/templateTable_riscv.cpp
@@ -708,7 +708,6 @@ void TemplateTable::index_check(Register array, Register index) {
__ mv(x11, index);
}
Label ok;
- __ sext(index, index, 32);
__ bltu(index, length, ok);
__ mv(x13, array);
__ mv(t1, Interpreter::_throw_ArrayIndexOutOfBoundsException_entry);
@@ -1052,7 +1051,7 @@ void TemplateTable::aastore() {
transition(vtos, vtos);
// stack: ..., array, index, value
__ ld(x10, at_tos()); // value
- __ ld(x12, at_tos_p1()); // index
+ __ lw(x12, at_tos_p1()); // index
__ ld(x13, at_tos_p2()); // array
index_check(x13, x12); // kills x11
@@ -1462,9 +1461,9 @@ void TemplateTable::iinc() {
transition(vtos, vtos);
__ load_signed_byte(x11, at_bcp(2)); // get constant
locals_index(x12);
- __ ld(x10, iaddress(x12, x10, _masm));
+ __ lw(x10, iaddress(x12, x10, _masm));
__ addw(x10, x10, x11);
- __ sd(x10, iaddress(x12, t0, _masm));
+ __ sw(x10, iaddress(x12, t0, _masm));
}
void TemplateTable::wide_iinc() {
@@ -1477,9 +1476,9 @@ void TemplateTable::wide_iinc() {
__ orr(x11, x11, t1);
locals_index_wide(x12);
- __ ld(x10, iaddress(x12, t0, _masm));
+ __ lw(x10, iaddress(x12, t0, _masm));
__ addw(x10, x10, x11);
- __ sd(x10, iaddress(x12, t0, _masm));
+ __ sw(x10, iaddress(x12, t0, _masm));
}
void TemplateTable::convert() {
diff --git a/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.cpp b/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.cpp
index 9e321391f6c..97829a10a3b 100644
--- a/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.cpp
+++ b/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.cpp
@@ -174,24 +174,14 @@ void ShenandoahBarrierSetAssembler::arraycopy_epilogue(MacroAssembler* masm, Dec
}
}
-void ShenandoahBarrierSetAssembler::shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register tmp,
- bool tosca_live,
- bool expand_call) {
+void ShenandoahBarrierSetAssembler::satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register tmp,
+ bool tosca_live,
+ bool expand_call) {
+ assert(ShenandoahSATBBarrier, "Should be checked by caller");
- if (ShenandoahSATBBarrier) {
- satb_write_barrier_pre(masm, obj, pre_val, tmp, tosca_live, expand_call);
- }
-}
-
-void ShenandoahBarrierSetAssembler::satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register tmp,
- bool tosca_live,
- bool expand_call) {
// If expand_call is true then we expand the call_VM_leaf macro
// directly to skip generating the check by
// InterpreterMacroAssembler::call_VM_leaf_base that checks _last_sp.
@@ -533,18 +523,18 @@ void ShenandoahBarrierSetAssembler::load_at(MacroAssembler* masm, DecoratorSet d
assert_different_registers(dst, tmp1, r15_thread);
// Generate the SATB pre-barrier code to log the value of
// the referent field in an SATB buffer.
- shenandoah_write_barrier_pre(masm /* masm */,
- noreg /* obj */,
- dst /* pre_val */,
- tmp1 /* tmp */,
- true /* tosca_live */,
- true /* expand_call */);
+ satb_barrier(masm /* masm */,
+ noreg /* obj */,
+ dst /* pre_val */,
+ tmp1 /* tmp */,
+ true /* tosca_live */,
+ true /* expand_call */);
restore_machine_state(masm, /* handle_gpr = */ true, /* handle_fp = */ true);
}
}
-void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register obj) {
+void ShenandoahBarrierSetAssembler::card_barrier(MacroAssembler* masm, Register obj) {
assert(ShenandoahCardBarrier, "Should have been checked by caller");
// Does a store check for the oop in register obj. The content of
@@ -575,41 +565,40 @@ void ShenandoahBarrierSetAssembler::store_check(MacroAssembler* masm, Register o
void ShenandoahBarrierSetAssembler::store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type,
Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) {
- bool on_oop = is_reference_type(type);
- bool in_heap = (decorators & IN_HEAP) != 0;
- bool as_normal = (decorators & AS_NORMAL) != 0;
- if (on_oop && in_heap) {
- bool needs_pre_barrier = as_normal;
-
- // flatten object address if needed
- // We do it regardless of precise because we need the registers
- if (dst.index() == noreg && dst.disp() == 0) {
- if (dst.base() != tmp1) {
- __ movptr(tmp1, dst.base());
- }
- } else {
- __ lea(tmp1, dst);
+ // 1: non-reference types require no barriers
+ if (!is_reference_type(type)) {
+ BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);
+ return;
+ }
+
+ // Flatten object address right away for simplicity: likely needed by barriers
+ assert_different_registers(val, tmp1, tmp2, tmp3, r15_thread);
+ if (dst.index() == noreg && dst.disp() == 0) {
+ if (dst.base() != tmp1) {
+ __ movptr(tmp1, dst.base());
}
+ } else {
+ __ lea(tmp1, dst);
+ }
- assert_different_registers(val, tmp1, tmp2, tmp3, r15_thread);
+ bool storing_non_null = (val != noreg);
- if (needs_pre_barrier) {
- shenandoah_write_barrier_pre(masm /*masm*/,
- tmp1 /* obj */,
- tmp2 /* pre_val */,
- tmp3 /* tmp */,
- val != noreg /* tosca_live */,
- false /* expand_call */);
- }
+ // 2: pre-barrier: SATB needs the previous value
+ if (ShenandoahBarrierSet::need_satb_barrier(decorators, type)) {
+ satb_barrier(masm,
+ tmp1 /* obj */,
+ tmp2 /* pre_val */,
+ tmp3 /* tmp */,
+ storing_non_null /* tosca_live */,
+ false /* expand_call */);
+ }
- BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp1, 0), val, noreg, noreg, noreg);
- if (val != noreg) {
- if (ShenandoahCardBarrier) {
- store_check(masm, tmp1);
- }
- }
- } else {
- BarrierSetAssembler::store_at(masm, decorators, type, dst, val, tmp1, tmp2, tmp3);
+ // Store!
+ BarrierSetAssembler::store_at(masm, decorators, type, Address(tmp1, 0), val, noreg, noreg, noreg);
+
+ // 3: post-barrier: card barrier needs store address
+ if (ShenandoahBarrierSet::need_card_barrier(decorators, type) && storing_non_null) {
+ card_barrier(masm, tmp1);
}
}
diff --git a/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp b/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp
index b0185f2dbff..b5cc5c8d834 100644
--- a/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp
+++ b/src/hotspot/cpu/x86/gc/shenandoah/shenandoahBarrierSetAssembler_x86.hpp
@@ -41,21 +41,14 @@ class StubCodeGenerator;
class ShenandoahBarrierSetAssembler: public BarrierSetAssembler {
private:
- void satb_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register tmp,
- bool tosca_live,
- bool expand_call);
+ void satb_barrier(MacroAssembler* masm,
+ Register obj,
+ Register pre_val,
+ Register tmp,
+ bool tosca_live,
+ bool expand_call);
- void shenandoah_write_barrier_pre(MacroAssembler* masm,
- Register obj,
- Register pre_val,
- Register tmp,
- bool tosca_live,
- bool expand_call);
-
- void store_check(MacroAssembler* masm, Register obj);
+ void card_barrier(MacroAssembler* masm, Register obj);
void gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators,
Register addr, Register count,
diff --git a/src/hotspot/cpu/x86/vm_version_x86.cpp b/src/hotspot/cpu/x86/vm_version_x86.cpp
index 0fff5b44e00..74df41f8682 100644
--- a/src/hotspot/cpu/x86/vm_version_x86.cpp
+++ b/src/hotspot/cpu/x86/vm_version_x86.cpp
@@ -143,7 +143,7 @@ class VM_Version_StubGenerator: public StubCodeGenerator {
Label detect_486, cpu486, detect_586, std_cpuid1, std_cpuid4, std_cpuid24, std_cpuid29;
Label sef_cpuid, sefsl1_cpuid, ext_cpuid, ext_cpuid1, ext_cpuid5, ext_cpuid7;
- Label ext_cpuid8, done, wrapup, vector_save_restore, apx_save_restore_warning;
+ Label ext_cpuid8, done, wrapup, vector_save_restore, apx_save_restore_warning, apx_xstate;
Label legacy_setup, save_restore_except, legacy_save_restore, start_simd_check;
StubCodeMark mark(this, "VM_Version", "get_cpu_info_stub");
@@ -468,6 +468,20 @@ class VM_Version_StubGenerator: public StubCodeGenerator {
__ movq(Address(rsi, 0), r16);
__ movq(Address(rsi, 8), r31);
+ //
+ // Query CPUID 0xD.19 for APX XSAVE offset
+ // Extended State Enumeration Sub-leaf 19 (APX)
+ // EAX = size of APX state (should be 128)
+ // EBX = offset in standard XSAVE format
+ //
+ __ movl(rax, 0xD);
+ __ movl(rcx, 19);
+ __ cpuid();
+ __ lea(rsi, Address(rbp, in_bytes(VM_Version::apx_xstate_size_offset())));
+ __ movl(Address(rsi, 0), rax);
+ __ lea(rsi, Address(rbp, in_bytes(VM_Version::apx_xstate_offset_offset())));
+ __ movl(Address(rsi, 0), rbx);
+
UseAPX = save_apx;
__ bind(vector_save_restore);
//
diff --git a/src/hotspot/cpu/x86/vm_version_x86.hpp b/src/hotspot/cpu/x86/vm_version_x86.hpp
index cc93ee3564e..a3f2a801198 100644
--- a/src/hotspot/cpu/x86/vm_version_x86.hpp
+++ b/src/hotspot/cpu/x86/vm_version_x86.hpp
@@ -676,6 +676,10 @@ class VM_Version : public Abstract_VM_Version {
// Space to save apx registers after signal handle
jlong apx_save[2]; // Save r16 and r31
+ // cpuid function 0xD, subleaf 19 (APX extended state)
+ uint32_t apx_xstate_size; // EAX: size of APX state (128)
+ uint32_t apx_xstate_offset; // EBX: offset in standard XSAVE area
+
VM_Features feature_flags() const;
// Asserts
@@ -739,6 +743,11 @@ class VM_Version : public Abstract_VM_Version {
static ByteSize ymm_save_offset() { return byte_offset_of(CpuidInfo, ymm_save); }
static ByteSize zmm_save_offset() { return byte_offset_of(CpuidInfo, zmm_save); }
static ByteSize apx_save_offset() { return byte_offset_of(CpuidInfo, apx_save); }
+ static ByteSize apx_xstate_offset_offset() { return byte_offset_of(CpuidInfo, apx_xstate_offset); }
+ static ByteSize apx_xstate_size_offset() { return byte_offset_of(CpuidInfo, apx_xstate_size); }
+
+ static uint32_t apx_xstate_offset() { return _cpuid_info.apx_xstate_offset; }
+ static uint32_t apx_xstate_size() { return _cpuid_info.apx_xstate_size; }
// The value used to check ymm register after signal handle
static int ymm_test_value() { return 0xCAFEBABE; }
diff --git a/src/hotspot/os/aix/decoder_aix.hpp b/src/hotspot/os/aix/decoder_aix.hpp
index 2ba3e1c5a3a..632355ccf4e 100644
--- a/src/hotspot/os/aix/decoder_aix.hpp
+++ b/src/hotspot/os/aix/decoder_aix.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2011, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2011, 2026, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2013 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@@ -38,7 +38,7 @@ class AIXDecoder: public AbstractDecoder {
virtual bool demangle(const char* symbol, char* buf, int buflen) { return false; } // use AixSymbols::get_function_name to demangle
virtual bool decode(address addr, char* buf, int buflen, int* offset, const char* modulepath, bool demangle) {
- return AixSymbols::get_function_name(addr, buf, buflen, offset, 0, demangle);
+ return AixSymbols::get_function_name(addr, buf, buflen, offset, nullptr, demangle);
}
virtual bool decode(address addr, char *buf, int buflen, int* offset, const void *base) {
ShouldNotReachHere();
diff --git a/src/hotspot/os/aix/os_aix.cpp b/src/hotspot/os/aix/os_aix.cpp
index d7c1911a914..0a8efbece8d 100644
--- a/src/hotspot/os/aix/os_aix.cpp
+++ b/src/hotspot/os/aix/os_aix.cpp
@@ -703,7 +703,7 @@ static void *thread_native_entry(Thread *thread) {
log_info(os, thread)("Thread finished (tid: %zu, kernel thread id: %zu).",
os::current_thread_id(), (uintx) kernel_thread_id);
- return 0;
+ return nullptr;
}
bool os::create_thread(Thread* thread, ThreadType thr_type,
diff --git a/src/hotspot/os/aix/porting_aix.cpp b/src/hotspot/os/aix/porting_aix.cpp
index 7311afc197b..b3f878fbfdd 100644
--- a/src/hotspot/os/aix/porting_aix.cpp
+++ b/src/hotspot/os/aix/porting_aix.cpp
@@ -1,6 +1,6 @@
/*
* Copyright (c) 2012, 2024 SAP SE. All rights reserved.
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, 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
@@ -78,7 +78,7 @@ class fixed_strings {
public:
- fixed_strings() : first(0) {}
+ fixed_strings() : first(nullptr) {}
~fixed_strings() {
node* n = first;
while (n) {
@@ -113,7 +113,7 @@ bool AixSymbols::get_function_name (
// information (null if not available)
bool demangle // [in] whether to demangle the name
) {
- struct tbtable* tb = 0;
+ struct tbtable* tb = nullptr;
unsigned int searchcount = 0;
// initialize output parameters
@@ -653,10 +653,10 @@ void AixNativeCallstack::print_callstack_for_context(outputStream* st, const uco
// To print the first frame, use the current value of iar:
// current entry indicated by iar (the current pc)
- codeptr_t cur_iar = 0;
- stackptr_t cur_sp = 0;
- codeptr_t cur_rtoc = 0;
- codeptr_t cur_lr = 0;
+ codeptr_t cur_iar = nullptr;
+ stackptr_t cur_sp = nullptr;
+ codeptr_t cur_rtoc = nullptr;
+ codeptr_t cur_lr = nullptr;
const ucontext_t* uc = (const ucontext_t*) context;
@@ -926,7 +926,7 @@ static struct handletableentry* p_handletable = nullptr;
static const char* rtv_linkedin_libpath() {
constexpr int bufsize = 4096;
static char buffer[bufsize];
- static const char* libpath = 0;
+ static const char* libpath = nullptr;
// we only try to retrieve the libpath once. After that try we
// let libpath point to buffer, which then contains a valid libpath
diff --git a/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp b/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp
index d82b9d90417..2b96e978980 100644
--- a/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp
+++ b/src/hotspot/os_cpu/linux_arm/javaThread_linux_arm.cpp
@@ -42,6 +42,16 @@ frame JavaThread::pd_last_frame() {
void JavaThread::cache_global_variables() {
BarrierSet* bs = BarrierSet::barrier_set();
+#if INCLUDE_G1GC
+ if (bs->is_a(BarrierSet::G1BarrierSet)) {
+ _card_table_base = nullptr;
+ } else
+#endif
+#if INCLUDE_SHENANDOAHGC
+ if (bs->is_a(BarrierSet::ShenandoahBarrierSet)) {
+ _card_table_base = nullptr;
+ } else
+#endif
if (bs->is_a(BarrierSet::CardTableBarrierSet)) {
CardTableBarrierSet* ctbs = CardTableBarrierSet::barrier_set();
_card_table_base = (address)ctbs->card_table_base_const();
diff --git a/src/hotspot/os_cpu/linux_x86/os_linux_x86.cpp b/src/hotspot/os_cpu/linux_x86/os_linux_x86.cpp
index 07f53582a76..ee08738c678 100644
--- a/src/hotspot/os_cpu/linux_x86/os_linux_x86.cpp
+++ b/src/hotspot/os_cpu/linux_x86/os_linux_x86.cpp
@@ -52,6 +52,7 @@
#include "utilities/debug.hpp"
#include "utilities/events.hpp"
#include "utilities/vmError.hpp"
+#include "runtime/vm_version.hpp"
// put OS-includes here
# include
@@ -380,6 +381,43 @@ size_t os::Posix::default_stack_size(os::ThreadType thr_type) {
/////////////////////////////////////////////////////////////////////////////
// helper functions for fatal error handler
+// XSAVE constants - from Intel SDM Vol. 1, Chapter 13
+#define XSAVE_HDR_OFFSET 512
+#define XFEATURE_APX (1ULL << 19)
+
+// XSAVE header structure
+// See: Intel SDM Vol. 1, Section 13.4.2 "XSAVE Header"
+// Also: Linux kernel arch/x86/include/asm/fpu/types.h
+struct xstate_header {
+ uint64_t xfeatures;
+ uint64_t xcomp_bv;
+ uint64_t reserved[6];
+};
+
+// APX extended state - R16-R31 (16 x 64-bit registers)
+// See: Intel APX Architecture Specification
+struct apx_state {
+ uint64_t regs[16]; // r16-r31
+};
+
+static apx_state* get_apx_state(const ucontext_t* uc) {
+ uint32_t offset = VM_Version::apx_xstate_offset();
+ if (offset == 0 || uc->uc_mcontext.fpregs == nullptr) {
+ return nullptr;
+ }
+
+ char* xsave = (char*)uc->uc_mcontext.fpregs;
+ xstate_header* hdr = (xstate_header*)(xsave + XSAVE_HDR_OFFSET);
+
+ // Check if APX state is present in this context
+ if (!(hdr->xfeatures & XFEATURE_APX)) {
+ return nullptr;
+ }
+
+ return (apx_state*)(xsave + offset);
+}
+
+
void os::print_context(outputStream *st, const void *context) {
if (context == nullptr) return;
@@ -406,6 +444,14 @@ void os::print_context(outputStream *st, const void *context) {
st->print(", R14=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R14]);
st->print(", R15=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_R15]);
st->cr();
+ // Dump APX EGPRs (R16-R31)
+ apx_state* apx = UseAPX ? get_apx_state(uc) : nullptr;
+ if (apx != nullptr) {
+ for (int i = 0; i < 16; i++) {
+ st->print("%sR%d=" INTPTR_FORMAT, (i % 4 == 0) ? "" : ", ", 16 + i, (intptr_t)apx->regs[i]);
+ if (i % 4 == 3) st->cr();
+ }
+ }
st->print( "RIP=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_RIP]);
st->print(", EFLAGS=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_EFL]);
st->print(", CSGSFS=" INTPTR_FORMAT, (intptr_t)uc->uc_mcontext.gregs[REG_CSGSFS]);
@@ -432,37 +478,50 @@ void os::print_context(outputStream *st, const void *context) {
}
void os::print_register_info(outputStream *st, const void *context, int& continuation) {
- const int register_count = 16;
+ if (context == nullptr) {
+ return;
+ }
+ const ucontext_t *uc = (const ucontext_t*)context;
+ apx_state* apx = UseAPX ? get_apx_state(uc) : nullptr;
+
+ const int register_count = 16 + (apx != nullptr ? 16 : 0);
int n = continuation;
assert(n >= 0 && n <= register_count, "Invalid continuation value");
- if (context == nullptr || n == register_count) {
+ if (n == register_count) {
return;
}
- const ucontext_t *uc = (const ucontext_t*)context;
while (n < register_count) {
// Update continuation with next index before printing location
continuation = n + 1;
+
+ if (n < 16) {
+ // Standard registers (RAX-R15)
# define CASE_PRINT_REG(n, str, id) case n: st->print(str); print_location(st, uc->uc_mcontext.gregs[REG_##id]);
- switch (n) {
- CASE_PRINT_REG( 0, "RAX=", RAX); break;
- CASE_PRINT_REG( 1, "RBX=", RBX); break;
- CASE_PRINT_REG( 2, "RCX=", RCX); break;
- CASE_PRINT_REG( 3, "RDX=", RDX); break;
- CASE_PRINT_REG( 4, "RSP=", RSP); break;
- CASE_PRINT_REG( 5, "RBP=", RBP); break;
- CASE_PRINT_REG( 6, "RSI=", RSI); break;
- CASE_PRINT_REG( 7, "RDI=", RDI); break;
- CASE_PRINT_REG( 8, "R8 =", R8); break;
- CASE_PRINT_REG( 9, "R9 =", R9); break;
- CASE_PRINT_REG(10, "R10=", R10); break;
- CASE_PRINT_REG(11, "R11=", R11); break;
- CASE_PRINT_REG(12, "R12=", R12); break;
- CASE_PRINT_REG(13, "R13=", R13); break;
- CASE_PRINT_REG(14, "R14=", R14); break;
- CASE_PRINT_REG(15, "R15=", R15); break;
- }
+ switch (n) {
+ CASE_PRINT_REG( 0, "RAX=", RAX); break;
+ CASE_PRINT_REG( 1, "RBX=", RBX); break;
+ CASE_PRINT_REG( 2, "RCX=", RCX); break;
+ CASE_PRINT_REG( 3, "RDX=", RDX); break;
+ CASE_PRINT_REG( 4, "RSP=", RSP); break;
+ CASE_PRINT_REG( 5, "RBP=", RBP); break;
+ CASE_PRINT_REG( 6, "RSI=", RSI); break;
+ CASE_PRINT_REG( 7, "RDI=", RDI); break;
+ CASE_PRINT_REG( 8, "R8 =", R8); break;
+ CASE_PRINT_REG( 9, "R9 =", R9); break;
+ CASE_PRINT_REG(10, "R10=", R10); break;
+ CASE_PRINT_REG(11, "R11=", R11); break;
+ CASE_PRINT_REG(12, "R12=", R12); break;
+ CASE_PRINT_REG(13, "R13=", R13); break;
+ CASE_PRINT_REG(14, "R14=", R14); break;
+ CASE_PRINT_REG(15, "R15=", R15); break;
+ }
# undef CASE_PRINT_REG
+ } else {
+ // APX extended general purpose registers (R16-R31)
+ st->print("R%d=", n);
+ print_location(st, apx->regs[n - 16]);
+ }
++n;
}
}
diff --git a/src/hotspot/share/cds/aotMappedHeapLoader.cpp b/src/hotspot/share/cds/aotMappedHeapLoader.cpp
index a8678ed757f..210867be70c 100644
--- a/src/hotspot/share/cds/aotMappedHeapLoader.cpp
+++ b/src/hotspot/share/cds/aotMappedHeapLoader.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2026, 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
@@ -360,10 +360,8 @@ bool AOTMappedHeapLoader::load_heap_region(FileMapInfo* mapinfo) {
}
objArrayOop AOTMappedHeapLoader::root_segment(int segment_idx) {
- if (CDSConfig::is_dumping_heap()) {
- assert(Thread::current() == (Thread*)VMThread::vm_thread(), "should be in vm thread");
- } else {
- assert(CDSConfig::is_using_archive(), "must be");
+ if (!CDSConfig::is_using_archive()) {
+ assert(CDSConfig::is_dumping_heap() && Thread::current() == (Thread*)VMThread::vm_thread(), "sanity");
}
objArrayOop segment = (objArrayOop)_root_segments->at(segment_idx).resolve();
@@ -466,7 +464,9 @@ void AOTMappedHeapLoader::finish_initialization(FileMapInfo* info) {
add_root_segment((objArrayOop)segment_oop);
}
- StringTable::load_shared_strings_array();
+ if (CDSConfig::is_dumping_final_static_archive()) {
+ StringTable::move_shared_strings_into_runtime_table();
+ }
}
}
diff --git a/src/hotspot/share/cds/aotMetaspace.cpp b/src/hotspot/share/cds/aotMetaspace.cpp
index 683c897d855..894a35183ca 100644
--- a/src/hotspot/share/cds/aotMetaspace.cpp
+++ b/src/hotspot/share/cds/aotMetaspace.cpp
@@ -1104,7 +1104,12 @@ void AOTMetaspace::dump_static_archive_impl(StaticArchiveBuilder& builder, TRAPS
#if INCLUDE_CDS_JAVA_HEAP
if (CDSConfig::is_dumping_heap()) {
- assert(CDSConfig::allow_only_single_java_thread(), "Required");
+ if (!CDSConfig::is_dumping_preimage_static_archive()) {
+ // A single thread is required for Reference handling and deterministic CDS archive.
+ // Its's not required for dumping preimage, where References won't be archived and
+ // determinism is not needed.
+ assert(CDSConfig::allow_only_single_java_thread(), "Required");
+ }
if (!HeapShared::is_archived_boot_layer_available(THREAD)) {
report_loading_error("archivedBootLayer not available, disabling full module graph");
CDSConfig::stop_dumping_full_module_graph();
@@ -1162,12 +1167,6 @@ void AOTMetaspace::dump_static_archive_impl(StaticArchiveBuilder& builder, TRAPS
// Perhaps there is a way to avoid hard-coding these names here.
// See discussion in JDK-8342481.
}
-
- if (HeapShared::is_writing_mapping_mode()) {
- // Do this at the very end, when no Java code will be executed. Otherwise
- // some new strings may be added to the intern table.
- StringTable::allocate_shared_strings_array(CHECK);
- }
} else {
log_info(aot)("Not dumping heap, reset CDSConfig::_is_using_optimized_module_handling");
CDSConfig::stop_using_optimized_module_handling();
diff --git a/src/hotspot/share/cds/aotReferenceObjSupport.cpp b/src/hotspot/share/cds/aotReferenceObjSupport.cpp
index aa7cc875533..0c27c8ce5f0 100644
--- a/src/hotspot/share/cds/aotReferenceObjSupport.cpp
+++ b/src/hotspot/share/cds/aotReferenceObjSupport.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2025, 2026, 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
@@ -177,12 +177,17 @@ void AOTReferenceObjSupport::init_keep_alive_objs_table() {
// Returns true IFF obj is an instance of java.lang.ref.Reference. If so, perform extra eligibility checks.
bool AOTReferenceObjSupport::check_if_ref_obj(oop obj) {
- // We have a single Java thread. This means java.lang.ref.Reference$ReferenceHandler thread
- // is not running. Otherwise the checks for next/discovered may not work.
- precond(CDSConfig::allow_only_single_java_thread());
assert_at_safepoint(); // _keep_alive_objs_table uses raw oops
if (obj->klass()->is_subclass_of(vmClasses::Reference_klass())) {
+ // The following check works only if the java.lang.ref.Reference$ReferenceHandler thread
+ // is not running.
+ //
+ // This code is called on every object found by AOTArtifactFinder. When dumping the
+ // preimage archive, AOTArtifactFinder should not find any Reference objects.
+ precond(!CDSConfig::is_dumping_preimage_static_archive());
+ precond(CDSConfig::allow_only_single_java_thread());
+
precond(AOTReferenceObjSupport::is_enabled());
precond(JavaClasses::is_supported_for_archiving(obj));
precond(_keep_alive_objs_table != nullptr);
diff --git a/src/hotspot/share/cds/cdsConfig.cpp b/src/hotspot/share/cds/cdsConfig.cpp
index 5f6b568dd6e..f4ef3c66f7a 100644
--- a/src/hotspot/share/cds/cdsConfig.cpp
+++ b/src/hotspot/share/cds/cdsConfig.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2026, 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
@@ -556,7 +556,9 @@ void CDSConfig::check_aotmode_record() {
// At VM exit, the module graph may be contaminated with program states.
// We will rebuild the module graph when dumping the CDS final image.
- disable_heap_dumping();
+ _is_using_optimized_module_handling = false;
+ _is_using_full_module_graph = false;
+ _is_dumping_full_module_graph = false;
}
void CDSConfig::check_aotmode_create() {
@@ -582,6 +584,7 @@ void CDSConfig::check_aotmode_create() {
substitute_aot_filename(FLAG_MEMBER_ENUM(AOTCache));
_is_dumping_final_static_archive = true;
+ _is_using_full_module_graph = false;
UseSharedSpaces = true;
RequireSharedSpaces = true;
@@ -954,7 +957,9 @@ bool CDSConfig::are_vm_options_incompatible_with_dumping_heap() {
}
bool CDSConfig::is_dumping_heap() {
- if (!(is_dumping_classic_static_archive() || is_dumping_final_static_archive())
+ // Note: when dumping preimage static archive, only a very limited set of oops
+ // are dumped.
+ if (!is_dumping_static_archive()
|| are_vm_options_incompatible_with_dumping_heap()
|| _disable_heap_dumping) {
return false;
@@ -966,6 +971,26 @@ bool CDSConfig::is_loading_heap() {
return HeapShared::is_archived_heap_in_use();
}
+bool CDSConfig::is_dumping_klass_subgraphs() {
+ if (is_dumping_classic_static_archive() || is_dumping_final_static_archive()) {
+ // KlassSubGraphs (see heapShared.cpp) is a legacy mechanism for archiving oops. It
+ // has been superceded by AOT class linking. This feature is used only when
+ // AOT class linking is disabled.
+ //
+ // KlassSubGraphs are disabled in the preimage static archive, which contains a very
+ // limited set of oops.
+ return is_dumping_heap() && !is_dumping_aot_linked_classes();
+ } else {
+ return false;
+ }
+}
+
+bool CDSConfig::is_using_klass_subgraphs() {
+ return (is_loading_heap() &&
+ !CDSConfig::is_using_aot_linked_classes() &&
+ !CDSConfig::is_dumping_final_static_archive());
+}
+
bool CDSConfig::is_using_full_module_graph() {
if (ClassLoaderDataShared::is_full_module_graph_loaded()) {
return true;
diff --git a/src/hotspot/share/cds/cdsConfig.hpp b/src/hotspot/share/cds/cdsConfig.hpp
index 202904e8231..739dbb4937b 100644
--- a/src/hotspot/share/cds/cdsConfig.hpp
+++ b/src/hotspot/share/cds/cdsConfig.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2023, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2023, 2026, 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
@@ -188,6 +188,9 @@ class CDSConfig : public AllStatic {
static bool is_dumping_heap() NOT_CDS_JAVA_HEAP_RETURN_(false);
static bool is_loading_heap() NOT_CDS_JAVA_HEAP_RETURN_(false);
+ static bool is_dumping_klass_subgraphs() NOT_CDS_JAVA_HEAP_RETURN_(false);
+ static bool is_using_klass_subgraphs() NOT_CDS_JAVA_HEAP_RETURN_(false);
+
static bool is_dumping_invokedynamic() NOT_CDS_JAVA_HEAP_RETURN_(false);
static bool is_dumping_method_handles() NOT_CDS_JAVA_HEAP_RETURN_(false);
diff --git a/src/hotspot/share/cds/heapShared.cpp b/src/hotspot/share/cds/heapShared.cpp
index 89694c6780e..143f9147853 100644
--- a/src/hotspot/share/cds/heapShared.cpp
+++ b/src/hotspot/share/cds/heapShared.cpp
@@ -210,7 +210,7 @@ static bool is_subgraph_root_class_of(ArchivableStaticFieldInfo fields[], Instan
bool HeapShared::is_subgraph_root_class(InstanceKlass* ik) {
assert(CDSConfig::is_dumping_heap(), "dump-time only");
- if (!CDSConfig::is_dumping_aot_linked_classes()) {
+ if (CDSConfig::is_dumping_klass_subgraphs()) {
// Legacy CDS archive support (to be deprecated)
return is_subgraph_root_class_of(archive_subgraph_entry_fields, ik) ||
is_subgraph_root_class_of(fmg_archive_subgraph_entry_fields, ik);
@@ -413,6 +413,8 @@ void HeapShared::materialize_thread_object() {
void HeapShared::add_to_dumped_interned_strings(oop string) {
assert(HeapShared::is_writing_mapping_mode(), "Only used by this mode");
AOTMappedHeapWriter::add_to_dumped_interned_strings(string);
+ bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, string);
+ assert(success, "shared strings array must not point to arrays or strings that are too large to archive");
}
void HeapShared::finalize_initialization(FileMapInfo* static_mapinfo) {
@@ -453,7 +455,6 @@ int HeapShared::append_root(oop obj) {
oop HeapShared::get_root(int index, bool clear) {
assert(index >= 0, "sanity");
- assert(!CDSConfig::is_dumping_heap() && CDSConfig::is_using_archive(), "runtime only");
assert(is_archived_heap_in_use(), "getting roots into heap that is not used");
oop result;
@@ -598,8 +599,7 @@ class MetaspaceObjToOopHandleTable: public HashTablepool_holder()->class_loader_data())) {
_scratch_objects_table->set_oop(src, dest);
}
@@ -831,14 +836,6 @@ static objArrayOop get_archived_resolved_references(InstanceKlass* src_ik) {
return nullptr;
}
-void HeapShared::archive_strings() {
- assert(HeapShared::is_writing_mapping_mode(), "should not reach here");
- oop shared_strings_array = StringTable::init_shared_strings_array();
- bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, shared_strings_array);
- assert(success, "shared strings array must not point to arrays or strings that are too large to archive");
- StringTable::set_shared_strings_array_index(append_root(shared_strings_array));
-}
-
int HeapShared::archive_exception_instance(oop exception) {
bool success = archive_reachable_objects_from(1, _dump_time_special_subgraph, exception);
assert(success, "sanity");
@@ -890,7 +887,7 @@ void HeapShared::start_scanning_for_oops() {
void HeapShared::end_scanning_for_oops() {
if (is_writing_mapping_mode()) {
- archive_strings();
+ StringTable::init_shared_table();
}
delete_seen_objects_table();
}
@@ -940,7 +937,7 @@ void HeapShared::scan_java_class(Klass* orig_k) {
void HeapShared::archive_subgraphs() {
assert(CDSConfig::is_dumping_heap(), "must be");
- if (!CDSConfig::is_dumping_aot_linked_classes()) {
+ if (CDSConfig::is_dumping_klass_subgraphs()) {
archive_object_subgraphs(archive_subgraph_entry_fields,
false /* is_full_module_graph */);
if (CDSConfig::is_dumping_full_module_graph()) {
@@ -1298,10 +1295,7 @@ static void verify_the_heap(Klass* k, const char* which) {
// this case, we will not load the ArchivedKlassSubGraphInfoRecord and will clear its roots.
void HeapShared::resolve_classes(JavaThread* current) {
assert(CDSConfig::is_using_archive(), "runtime only!");
- if (!is_archived_heap_in_use()) {
- return; // nothing to do
- }
- if (!CDSConfig::is_using_aot_linked_classes()) {
+ if (CDSConfig::is_using_klass_subgraphs()) {
resolve_classes_for_subgraphs(current, archive_subgraph_entry_fields);
resolve_classes_for_subgraphs(current, fmg_archive_subgraph_entry_fields);
}
@@ -1391,7 +1385,7 @@ void HeapShared::init_classes_for_special_subgraph(Handle class_loader, TRAPS) {
void HeapShared::initialize_from_archived_subgraph(JavaThread* current, Klass* k) {
JavaThread* THREAD = current;
- if (!is_archived_heap_in_use()) {
+ if (!CDSConfig::is_using_klass_subgraphs()) {
return; // nothing to do
}
@@ -1867,7 +1861,7 @@ void HeapShared::archive_reachable_objects_from_static_field(InstanceKlass *k,
const char* klass_name,
int field_offset,
const char* field_name) {
- assert(CDSConfig::is_dumping_heap(), "dump time only");
+ precond(CDSConfig::is_dumping_klass_subgraphs());
assert(k->defined_by_boot_loader(), "must be boot class");
oop m = k->java_mirror();
@@ -1918,7 +1912,7 @@ class VerifySharedOopClosure: public BasicOopIterateClosure {
};
void HeapShared::verify_subgraph_from_static_field(InstanceKlass* k, int field_offset) {
- assert(CDSConfig::is_dumping_heap(), "dump time only");
+ precond(CDSConfig::is_dumping_klass_subgraphs());
assert(k->defined_by_boot_loader(), "must be boot class");
oop m = k->java_mirror();
@@ -2144,7 +2138,7 @@ void HeapShared::init_subgraph_entry_fields(ArchivableStaticFieldInfo fields[],
void HeapShared::init_subgraph_entry_fields(TRAPS) {
assert(CDSConfig::is_dumping_heap(), "must be");
_dump_time_subgraph_info_table = new (mtClass)DumpTimeKlassSubGraphInfoTable();
- if (!CDSConfig::is_dumping_aot_linked_classes()) {
+ if (CDSConfig::is_dumping_klass_subgraphs()) {
init_subgraph_entry_fields(archive_subgraph_entry_fields, CHECK);
if (CDSConfig::is_dumping_full_module_graph()) {
init_subgraph_entry_fields(fmg_archive_subgraph_entry_fields, CHECK);
diff --git a/src/hotspot/share/cds/heapShared.hpp b/src/hotspot/share/cds/heapShared.hpp
index 118c60faa60..3c7068e96ab 100644
--- a/src/hotspot/share/cds/heapShared.hpp
+++ b/src/hotspot/share/cds/heapShared.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2026, 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
@@ -478,7 +478,6 @@ class HeapShared: AllStatic {
static bool has_been_archived(oop orig_obj);
static void prepare_resolved_references();
- static void archive_strings();
static void archive_subgraphs();
static void copy_java_mirror(oop orig_mirror, oop scratch_m);
diff --git a/src/hotspot/share/classfile/classLoader.cpp b/src/hotspot/share/classfile/classLoader.cpp
index d9a63cd154b..f631bfaa102 100644
--- a/src/hotspot/share/classfile/classLoader.cpp
+++ b/src/hotspot/share/classfile/classLoader.cpp
@@ -1418,6 +1418,10 @@ char* ClassLoader::lookup_vm_options() {
jio_snprintf(modules_path, JVM_MAXPATHLEN, "%s%slib%smodules", Arguments::get_java_home(), fileSep, fileSep);
JImage_file =(*JImageOpen)(modules_path, &error);
if (JImage_file == nullptr) {
+ if (Arguments::has_jimage()) {
+ // The modules file exists but is unreadable or corrupt
+ vm_exit_during_initialization(err_msg("Unable to load %s", modules_path));
+ }
return nullptr;
}
diff --git a/src/hotspot/share/classfile/javaClasses.cpp b/src/hotspot/share/classfile/javaClasses.cpp
index dd70d7b49ab..b650bf8cfb8 100644
--- a/src/hotspot/share/classfile/javaClasses.cpp
+++ b/src/hotspot/share/classfile/javaClasses.cpp
@@ -1263,6 +1263,10 @@ bool java_lang_Class::restore_archived_mirror(Klass *k,
"Restored %s archived mirror " PTR_FORMAT, k->external_name(), p2i(mirror()));
}
+ if (CDSConfig::is_dumping_heap()) {
+ create_scratch_mirror(k, CHECK_(false));
+ }
+
return true;
}
#endif // INCLUDE_CDS_JAVA_HEAP
diff --git a/src/hotspot/share/classfile/stringTable.cpp b/src/hotspot/share/classfile/stringTable.cpp
index 20dfad0d980..2b8b7780a41 100644
--- a/src/hotspot/share/classfile/stringTable.cpp
+++ b/src/hotspot/share/classfile/stringTable.cpp
@@ -74,24 +74,9 @@ const size_t REHASH_LEN = 100;
const double CLEAN_DEAD_HIGH_WATER_MARK = 0.5;
#if INCLUDE_CDS_JAVA_HEAP
-bool StringTable::_is_two_dimensional_shared_strings_array = false;
-OopHandle StringTable::_shared_strings_array;
-int StringTable::_shared_strings_array_root_index;
-
inline oop StringTable::read_string_from_compact_hashtable(address base_address, u4 index) {
assert(AOTMappedHeapLoader::is_in_use(), "sanity");
- objArrayOop array = (objArrayOop)(_shared_strings_array.resolve());
- oop s;
-
- if (!_is_two_dimensional_shared_strings_array) {
- s = array->obj_at((int)index);
- } else {
- int primary_index = index >> _secondary_array_index_bits;
- int secondary_index = index & _secondary_array_index_mask;
- objArrayOop secondary = (objArrayOop)array->obj_at(primary_index);
- s = secondary->obj_at(secondary_index);
- }
-
+ oop s = HeapShared::get_root((int)index, false);
assert(java_lang_String::is_instance(s), "must be");
return s;
}
@@ -115,7 +100,6 @@ OopStorage* StringTable::_oop_storage;
static size_t _current_size = 0;
static volatile size_t _items_count = 0;
-DEBUG_ONLY(static bool _disable_interning_during_cds_dump = false);
volatile bool _alt_hash = false;
@@ -317,12 +301,6 @@ void StringTable::create_table() {
_oop_storage->register_num_dead_callback(&gc_notification);
}
-#if INCLUDE_CDS_JAVA_HEAP
-void StringTable::load_shared_strings_array() {
- _shared_strings_array = OopHandle(Universe::vm_global(), HeapShared::get_root(_shared_strings_array_root_index));
-}
-#endif
-
void StringTable::item_added() {
AtomicAccess::inc(&_items_count);
}
@@ -509,9 +487,6 @@ oop StringTable::intern(const char* utf8_string, TRAPS) {
}
oop StringTable::intern(const StringWrapper& name, TRAPS) {
- assert(!AtomicAccess::load_acquire(&_disable_interning_during_cds_dump),
- "All threads that may intern strings should have been stopped before CDS starts copying the interned string table");
-
// shared table always uses java_lang_String::hash_code
unsigned int hash = hash_wrapped_string(name);
oop found_string = lookup_shared(name, hash);
@@ -957,118 +932,13 @@ oop StringTable::lookup_shared(const jchar* name, int len) {
return _shared_table.lookup(wrapped_name, java_lang_String::hash_code(name, len), 0);
}
-// This is called BEFORE we enter the CDS safepoint. We can still allocate Java object arrays to
-// be used by the shared strings table.
-void StringTable::allocate_shared_strings_array(TRAPS) {
- if (!CDSConfig::is_dumping_heap()) {
- return;
- }
+void StringTable::init_shared_table() {
+ assert(SafepointSynchronize::is_at_safepoint(), "inside AOT safepoint");
+ precond(CDSConfig::is_dumping_heap());
+ assert(HeapShared::is_writing_mapping_mode(), "not used for streamed oops");
- assert(HeapShared::is_writing_mapping_mode(), "should not reach here");
-
- CompileBroker::wait_for_no_active_tasks();
-
- precond(CDSConfig::allow_only_single_java_thread());
-
- // At this point, no more strings will be added:
- // - There's only a single Java thread (this thread). It no longer executes Java bytecodes
- // so JIT compilation will eventually stop.
- // - CompileBroker has no more active tasks, so all JIT requests have been processed.
-
- // This flag will be cleared after intern table dumping has completed, so we can run the
- // compiler again (for future AOT method compilation, etc).
- DEBUG_ONLY(AtomicAccess::release_store(&_disable_interning_during_cds_dump, true));
-
- if (items_count_acquire() > (size_t)max_jint) {
- fatal("Too many strings to be archived: %zu", items_count_acquire());
- }
-
- int total = (int)items_count_acquire();
- size_t single_array_size = objArrayOopDesc::object_size(total);
-
- log_info(aot)("allocated string table for %d strings", total);
-
- if (!HeapShared::is_too_large_to_archive(single_array_size)) {
- // The entire table can fit in a single array
- objArrayOop array = oopFactory::new_objArray(vmClasses::Object_klass(), total, CHECK);
- _shared_strings_array = OopHandle(Universe::vm_global(), array);
- log_info(aot)("string table array (single level) length = %d", total);
- } else {
- // Split the table in two levels of arrays.
- int primary_array_length = (total + _secondary_array_max_length - 1) / _secondary_array_max_length;
- size_t primary_array_size = objArrayOopDesc::object_size(primary_array_length);
- size_t secondary_array_size = objArrayOopDesc::object_size(_secondary_array_max_length);
-
- if (HeapShared::is_too_large_to_archive(secondary_array_size)) {
- // This can only happen if you have an extremely large number of classes that
- // refer to more than 16384 * 16384 = 26M interned strings! Not a practical concern
- // but bail out for safety.
- log_error(aot)("Too many strings to be archived: %zu", items_count_acquire());
- AOTMetaspace::unrecoverable_writing_error();
- }
-
- objArrayOop primary = oopFactory::new_objArray(vmClasses::Object_klass(), primary_array_length, CHECK);
- objArrayHandle primaryHandle(THREAD, primary);
- _shared_strings_array = OopHandle(Universe::vm_global(), primary);
-
- log_info(aot)("string table array (primary) length = %d", primary_array_length);
- for (int i = 0; i < primary_array_length; i++) {
- int len;
- if (total > _secondary_array_max_length) {
- len = _secondary_array_max_length;
- } else {
- len = total;
- }
- total -= len;
-
- objArrayOop secondary = oopFactory::new_objArray(vmClasses::Object_klass(), len, CHECK);
- primaryHandle()->obj_at_put(i, secondary);
-
- log_info(aot)("string table array (secondary)[%d] length = %d", i, len);
- assert(!HeapShared::is_too_large_to_archive(secondary), "sanity");
- }
-
- assert(total == 0, "must be");
- _is_two_dimensional_shared_strings_array = true;
- }
-}
-
-#ifndef PRODUCT
-void StringTable::verify_secondary_array_index_bits() {
- assert(HeapShared::is_writing_mapping_mode(), "should not reach here");
- int max;
- for (max = 1; ; max++) {
- size_t next_size = objArrayOopDesc::object_size(1 << (max + 1));
- if (HeapShared::is_too_large_to_archive(next_size)) {
- break;
- }
- }
- // Currently max is 17 for +UseCompressedOops, 16 for -UseCompressedOops.
- // When we add support for Shenandoah (which has a smaller mininum region size than G1),
- // max will become 15/14.
- //
- // We use _secondary_array_index_bits==14 as that will be the eventual value, and will
- // make testing easier.
- assert(_secondary_array_index_bits <= max,
- "_secondary_array_index_bits (%d) must be smaller than max possible value (%d)",
- _secondary_array_index_bits, max);
-}
-#endif // PRODUCT
-
-// This is called AFTER we enter the CDS safepoint.
-//
-// For each shared string:
-// [1] Store it into _shared_strings_array. Encode its position as a 32-bit index.
-// [2] Store the index and hashcode into _shared_table.
-oop StringTable::init_shared_strings_array() {
- assert(CDSConfig::is_dumping_heap(), "must be");
- assert(HeapShared::is_writing_mapping_mode(), "should not reach here");
- objArrayOop array = (objArrayOop)(_shared_strings_array.resolve());
-
- verify_secondary_array_index_bits();
-
- int index = 0;
- auto copy_into_array = [&] (WeakHandle* val) {
+ int n = 0;
+ auto copy_into_aot_heap = [&] (WeakHandle* val) {
oop string = val->peek();
if (string != nullptr && !HeapShared::is_string_too_large_to_archive(string)) {
// If string is too large, don't put it into the string table.
@@ -1077,53 +947,34 @@ oop StringTable::init_shared_strings_array() {
// - If there's a reference to it, we will report an error inside HeapShared.cpp and
// dumping will fail.
HeapShared::add_to_dumped_interned_strings(string);
- if (!_is_two_dimensional_shared_strings_array) {
- assert(index < array->length(), "no strings should have been added");
- array->obj_at_put(index, string);
- } else {
- int primary_index = index >> _secondary_array_index_bits;
- int secondary_index = index & _secondary_array_index_mask;
-
- assert(primary_index < array->length(), "no strings should have been added");
- objArrayOop secondary = (objArrayOop)array->obj_at(primary_index);
-
- assert(secondary != nullptr && secondary->is_objArray(), "must be");
- assert(secondary_index < secondary->length(), "no strings should have been added");
- secondary->obj_at_put(secondary_index, string);
- }
- index ++;
}
+ n++;
return true;
};
- _local_table->do_safepoint_scan(copy_into_array);
- log_info(aot)("Archived %d interned strings", index);
- return array;
+ _local_table->do_safepoint_scan(copy_into_aot_heap);
+ log_info(aot)("Archived %d interned strings", n);
};
void StringTable::write_shared_table() {
+ assert(SafepointSynchronize::is_at_safepoint(), "inside AOT safepoint");
+ precond(CDSConfig::is_dumping_heap());
+ assert(HeapShared::is_writing_mapping_mode(), "not used for streamed oops");
+
_shared_table.reset();
CompactHashtableWriter writer((int)items_count_acquire(), ArchiveBuilder::string_stats());
- int index = 0;
auto copy_into_shared_table = [&] (WeakHandle* val) {
oop string = val->peek();
if (string != nullptr && !HeapShared::is_string_too_large_to_archive(string)) {
unsigned int hash = java_lang_String::hash_code(string);
- writer.add(hash, index);
- index ++;
+ int root_id = HeapShared::append_root(string);
+ writer.add(hash, root_id);
}
return true;
};
_local_table->do_safepoint_scan(copy_into_shared_table);
writer.dump(&_shared_table, "string");
-
- DEBUG_ONLY(AtomicAccess::release_store(&_disable_interning_during_cds_dump, false));
-}
-
-void StringTable::set_shared_strings_array_index(int root_index) {
- assert(HeapShared::is_writing_mapping_mode(), "should not reach here");
- _shared_strings_array_root_index = root_index;
}
void StringTable::serialize_shared_table_header(SerializeClosure* soc) {
@@ -1135,8 +986,27 @@ void StringTable::serialize_shared_table_header(SerializeClosure* soc) {
} else if (!AOTMappedHeapLoader::is_in_use()) {
_shared_table.reset();
}
+}
+
+void StringTable::move_shared_strings_into_runtime_table() {
+ precond(CDSConfig::is_dumping_final_static_archive());
+ JavaThread* THREAD = JavaThread::current();
+ HandleMark hm(THREAD);
+
+ int n = 0;
+ _shared_table.iterate_all([&](oop string) {
+ int length = java_lang_String::length(string);
+ Handle h_string (THREAD, string);
+ StringWrapper name(h_string, length);
+ unsigned int hash = hash_wrapped_string(name);
- soc->do_bool(&_is_two_dimensional_shared_strings_array);
- soc->do_int(&_shared_strings_array_root_index);
+ assert(!_alt_hash, "too early");
+ oop interned = do_intern(name, hash, THREAD);
+ assert(string == interned, "must be");
+ n++;
+ });
+
+ _shared_table.reset();
+ log_info(aot)("Moved %d interned strings to runtime table", n);
}
#endif //INCLUDE_CDS_JAVA_HEAP
diff --git a/src/hotspot/share/classfile/stringTable.hpp b/src/hotspot/share/classfile/stringTable.hpp
index 839e9d9053d..0024a45a2f2 100644
--- a/src/hotspot/share/classfile/stringTable.hpp
+++ b/src/hotspot/share/classfile/stringTable.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, 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
@@ -109,49 +109,17 @@ class StringTable : AllStatic {
static bool needs_rehashing() { return _needs_rehashing; }
static inline void update_needs_rehash(bool rehash);
- // Sharing
-#if INCLUDE_CDS_JAVA_HEAP
- static inline oop read_string_from_compact_hashtable(address base_address, u4 index);
-
+ // AOT support
+ static inline oop read_string_from_compact_hashtable(address base_address, u4 index) NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
private:
- static bool _is_two_dimensional_shared_strings_array;
- static OopHandle _shared_strings_array;
- static int _shared_strings_array_root_index;
-
- // All the shared strings are referenced through _shared_strings_array to keep them alive.
- // Each shared string is stored as a 32-bit index in ::_shared_table. The index
- // is interpreted in two ways:
- //
- // [1] _is_two_dimensional_shared_strings_array = false: _shared_strings_array is an Object[].
- // Each shared string is stored as _shared_strings_array[index]
- //
- // [2] _is_two_dimensional_shared_strings_array = true: _shared_strings_array is an Object[][]
- // This happens when there are too many elements in the shared table. We store them
- // using two levels of objArrays, such that none of the arrays are too big for
- // AOTMappedHeapWriter::is_too_large_to_archive(). In this case, the index is splited into two
- // parts. Each shared string is stored as _shared_strings_array[primary_index][secondary_index]:
- //
- // [bits 31 .. 14][ bits 13 .. 0 ]
- // primary_index secondary_index
- const static int _secondary_array_index_bits = 14;
- const static int _secondary_array_max_length = 1 << _secondary_array_index_bits;
- const static int _secondary_array_index_mask = _secondary_array_max_length - 1;
-
- // make sure _secondary_array_index_bits is not too big
- static void verify_secondary_array_index_bits() PRODUCT_RETURN;
-#endif // INCLUDE_CDS_JAVA_HEAP
-
- private:
static oop lookup_shared(const StringWrapper& name, unsigned int hash) NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
- public:
+public:
static oop lookup_shared(const jchar* name, int len) NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
static size_t shared_entry_count() NOT_CDS_JAVA_HEAP_RETURN_(0);
- static void allocate_shared_strings_array(TRAPS) NOT_CDS_JAVA_HEAP_RETURN;
- static void load_shared_strings_array() NOT_CDS_JAVA_HEAP_RETURN;
- static oop init_shared_strings_array() NOT_CDS_JAVA_HEAP_RETURN_(nullptr);
+ static void init_shared_table() NOT_CDS_JAVA_HEAP_RETURN;
static void write_shared_table() NOT_CDS_JAVA_HEAP_RETURN;
- static void set_shared_strings_array_index(int root_index) NOT_CDS_JAVA_HEAP_RETURN;
static void serialize_shared_table_header(SerializeClosure* soc) NOT_CDS_JAVA_HEAP_RETURN;
+ static void move_shared_strings_into_runtime_table();
// Jcmd
static void dump(outputStream* st, bool verbose=false);
diff --git a/src/hotspot/share/classfile/verifier.cpp b/src/hotspot/share/classfile/verifier.cpp
index 38dba1d3d5f..30f147b9ae7 100644
--- a/src/hotspot/share/classfile/verifier.cpp
+++ b/src/hotspot/share/classfile/verifier.cpp
@@ -190,9 +190,8 @@ bool Verifier::verify(InstanceKlass* klass, bool should_verify_class, TRAPS) {
// effect (sic!) for external_name(), but instead of doing that, we opt to
// explicitly push the hashcode in here. This is signify the following block
// is IMPORTANT:
- if (klass->java_mirror() != nullptr) {
- klass->java_mirror()->identity_hash();
- }
+ assert(klass->java_mirror() != nullptr, "must be");
+ klass->java_mirror()->identity_hash();
if (!is_eligible_for_verification(klass, should_verify_class)) {
return true;
diff --git a/src/hotspot/share/compiler/compileBroker.cpp b/src/hotspot/share/compiler/compileBroker.cpp
index 574f4d6543b..7b236ed3589 100644
--- a/src/hotspot/share/compiler/compileBroker.cpp
+++ b/src/hotspot/share/compiler/compileBroker.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1999, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2026, 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
@@ -2346,12 +2346,18 @@ void CompileBroker::invoke_compiler_on_method(CompileTask* task) {
/* Repeat compilation without installing code for profiling purposes */
int repeat_compilation_count = directive->RepeatCompilationOption;
- while (repeat_compilation_count > 0) {
- ResourceMark rm(thread);
- task->print_ul("NO CODE INSTALLED");
- thread->timeout()->reset();
- comp->compile_method(&ci_env, target, osr_bci, false, directive);
- repeat_compilation_count--;
+ if (repeat_compilation_count > 0) {
+ CHeapStringHolder failure_reason;
+ failure_reason.set(ci_env._failure_reason.get());
+ while (repeat_compilation_count > 0) {
+ ResourceMark rm(thread);
+ task->print_ul("NO CODE INSTALLED");
+ thread->timeout()->reset();
+ ci_env._failure_reason.clear();
+ comp->compile_method(&ci_env, target, osr_bci, false, directive);
+ repeat_compilation_count--;
+ }
+ ci_env._failure_reason.set(failure_reason.get());
}
}
diff --git a/src/hotspot/share/gc/g1/c2/g1BarrierSetC2.cpp b/src/hotspot/share/gc/g1/c2/g1BarrierSetC2.cpp
index 61402301eb1..34d31702e80 100644
--- a/src/hotspot/share/gc/g1/c2/g1BarrierSetC2.cpp
+++ b/src/hotspot/share/gc/g1/c2/g1BarrierSetC2.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2026, 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
@@ -351,7 +351,6 @@ Node* G1BarrierSetC2::store_at_resolved(C2Access& access, C2AccessValue& val) co
Node* G1BarrierSetC2::atomic_cmpxchg_val_at_resolved(C2AtomicParseAccess& access, Node* expected_val,
Node* new_val, const Type* value_type) const {
- GraphKit* kit = access.kit();
if (!access.is_oop()) {
return BarrierSetC2::atomic_cmpxchg_val_at_resolved(access, expected_val, new_val, value_type);
}
@@ -361,7 +360,6 @@ Node* G1BarrierSetC2::atomic_cmpxchg_val_at_resolved(C2AtomicParseAccess& access
Node* G1BarrierSetC2::atomic_cmpxchg_bool_at_resolved(C2AtomicParseAccess& access, Node* expected_val,
Node* new_val, const Type* value_type) const {
- GraphKit* kit = access.kit();
if (!access.is_oop()) {
return BarrierSetC2::atomic_cmpxchg_bool_at_resolved(access, expected_val, new_val, value_type);
}
@@ -370,7 +368,6 @@ Node* G1BarrierSetC2::atomic_cmpxchg_bool_at_resolved(C2AtomicParseAccess& acces
}
Node* G1BarrierSetC2::atomic_xchg_at_resolved(C2AtomicParseAccess& access, Node* new_val, const Type* value_type) const {
- GraphKit* kit = access.kit();
if (!access.is_oop()) {
return BarrierSetC2::atomic_xchg_at_resolved(access, new_val, value_type);
}
diff --git a/src/hotspot/share/gc/g1/g1BarrierSet.cpp b/src/hotspot/share/gc/g1/g1BarrierSet.cpp
index 622651ce0d8..dee50500e07 100644
--- a/src/hotspot/share/gc/g1/g1BarrierSet.cpp
+++ b/src/hotspot/share/gc/g1/g1BarrierSet.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -64,13 +64,13 @@ G1BarrierSet::G1BarrierSet(G1CardTable* card_table,
{}
G1BarrierSet::~G1BarrierSet() {
- delete _refinement_table;
+ delete refinement_table();
}
void G1BarrierSet::swap_global_card_table() {
- G1CardTable* temp = static_cast(_card_table);
- _card_table = _refinement_table;
- _refinement_table = temp;
+ G1CardTable* temp = static_cast(card_table());
+ _card_table.store_relaxed(refinement_table());
+ _refinement_table.store_relaxed(temp);
}
void G1BarrierSet::update_card_table_base(Thread* thread) {
@@ -80,7 +80,7 @@ void G1BarrierSet::update_card_table_base(Thread* thread) {
assert(thread->is_Java_thread(), "may only update card table base of JavaThreads, not %s", thread->name());
}
#endif
- G1ThreadLocalData::set_byte_map_base(thread, _card_table->byte_map_base());
+ G1ThreadLocalData::set_byte_map_base(thread, card_table()->byte_map_base());
}
template void
@@ -135,10 +135,10 @@ void G1BarrierSet::write_region(MemRegion mr) {
// marks next time.
// If we write to the old card table (after the switching, then the refinement
// table) the oncoming handshake will do the memory synchronization.
- CardTable* card_table = AtomicAccess::load(&_card_table);
+ CardTable* local_card_table = card_table();
- volatile CardValue* byte = card_table->byte_for(mr.start());
- CardValue* last_byte = card_table->byte_for(mr.last());
+ volatile CardValue* byte = local_card_table->byte_for(mr.start());
+ CardValue* last_byte = local_card_table->byte_for(mr.last());
// Dirty cards only if necessary.
for (; byte <= last_byte; byte++) {
@@ -190,6 +190,6 @@ void G1BarrierSet::on_thread_detach(Thread* thread) {
}
void G1BarrierSet::print_on(outputStream* st) const {
- _card_table->print_on(st, "Card");
- _refinement_table->print_on(st, "Refinement");
+ card_table()->print_on(st, "Card");
+ refinement_table()->print_on(st, "Refinement");
}
diff --git a/src/hotspot/share/gc/g1/g1BarrierSet.hpp b/src/hotspot/share/gc/g1/g1BarrierSet.hpp
index bf595973a32..406096acf10 100644
--- a/src/hotspot/share/gc/g1/g1BarrierSet.hpp
+++ b/src/hotspot/share/gc/g1/g1BarrierSet.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -29,6 +29,7 @@
#include "gc/shared/bufferNode.hpp"
#include "gc/shared/cardTable.hpp"
#include "gc/shared/cardTableBarrierSet.hpp"
+#include "runtime/atomic.hpp"
class G1CardTable;
class Thread;
@@ -66,7 +67,7 @@ class G1BarrierSet: public CardTableBarrierSet {
BufferNode::Allocator _satb_mark_queue_buffer_allocator;
G1SATBMarkQueueSet _satb_mark_queue_set;
- G1CardTable* _refinement_table;
+ Atomic _refinement_table;
public:
G1BarrierSet(G1CardTable* card_table, G1CardTable* refinement_table);
@@ -76,7 +77,7 @@ class G1BarrierSet: public CardTableBarrierSet {
return barrier_set_cast(BarrierSet::barrier_set());
}
- G1CardTable* refinement_table() const { return _refinement_table; }
+ G1CardTable* refinement_table() const { return _refinement_table.load_relaxed(); }
// Swap the global card table references, without synchronization.
void swap_global_card_table();
diff --git a/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp b/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp
index 794e5db0634..54892c9191d 100644
--- a/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp
+++ b/src/hotspot/share/gc/g1/g1BarrierSet.inline.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2026, 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
@@ -73,8 +73,8 @@ inline void G1BarrierSet::write_ref_field_post(T* field) {
// Make sure that the card table reference is read only once. Otherwise the compiler
// might reload that value in the two accesses below, that could cause writes to
// the wrong card table.
- CardTable* card_table = AtomicAccess::load(&_card_table);
- CardValue* byte = card_table->byte_for(field);
+ CardTable* local_card_table = card_table();
+ CardValue* byte = local_card_table->byte_for(field);
if (*byte == G1CardTable::clean_card_val()) {
*byte = G1CardTable::dirty_card_val();
}
diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp
index 8f83a653885..9424a804bd8 100644
--- a/src/hotspot/share/gc/g1/g1CollectedHeap.cpp
+++ b/src/hotspot/share/gc/g1/g1CollectedHeap.cpp
@@ -1320,7 +1320,6 @@ G1CollectedHeap::G1CollectedHeap() :
_card_set_freelist_pool(G1CardSetConfiguration::num_mem_object_types()),
_young_regions_cset_group(card_set_config(), &_card_set_freelist_pool, G1CSetCandidateGroup::YoungRegionId),
_cm(nullptr),
- _cm_thread(nullptr),
_cr(nullptr),
_task_queues(nullptr),
_partial_array_state_manager(nullptr),
@@ -1564,7 +1563,6 @@ jint G1CollectedHeap::initialize() {
// Create the G1ConcurrentMark data structure and thread.
// (Must do this late, so that "max_[reserved_]regions" is defined.)
_cm = new G1ConcurrentMark(this, bitmap_storage);
- _cm_thread = _cm->cm_thread();
// Now expand into the initial heap size.
if (!expand(init_byte_size, _workers)) {
@@ -1636,7 +1634,9 @@ jint G1CollectedHeap::initialize() {
}
bool G1CollectedHeap::concurrent_mark_is_terminating() const {
- return _cm_thread->should_terminate();
+ assert(_cm != nullptr, "_cm must have been created");
+ assert(_cm->is_fully_initialized(), "thread must exist in order to check if mark is terminating");
+ return _cm->cm_thread()->should_terminate();
}
void G1CollectedHeap::stop() {
@@ -1645,7 +1645,9 @@ void G1CollectedHeap::stop() {
// that are destroyed during shutdown.
_cr->stop();
_service_thread->stop();
- _cm_thread->stop();
+ if (_cm->is_fully_initialized()) {
+ _cm->cm_thread()->stop();
+ }
}
void G1CollectedHeap::safepoint_synchronize_begin() {
@@ -1842,7 +1844,7 @@ void G1CollectedHeap::increment_old_marking_cycles_completed(bool concurrent,
// is set) so that if a waiter requests another System.gc() it doesn't
// incorrectly see that a marking cycle is still in progress.
if (concurrent) {
- _cm_thread->set_idle();
+ _cm->cm_thread()->set_idle();
}
// Notify threads waiting in System.gc() (with ExplicitGCInvokesConcurrent)
@@ -2421,7 +2423,6 @@ void G1CollectedHeap::print_gc_on(outputStream* st) const {
void G1CollectedHeap::gc_threads_do(ThreadClosure* tc) const {
workers()->threads_do(tc);
- tc->do_thread(_cm_thread);
_cm->threads_do(tc);
_cr->threads_do(tc);
tc->do_thread(_service_thread);
@@ -2542,15 +2543,15 @@ HeapWord* G1CollectedHeap::do_collection_pause(size_t word_size,
}
void G1CollectedHeap::start_concurrent_cycle(bool concurrent_operation_is_full_mark) {
- assert(!_cm_thread->in_progress(), "Can not start concurrent operation while in progress");
-
+ assert(_cm->is_fully_initialized(), "sanity");
+ assert(!_cm->in_progress(), "Can not start concurrent operation while in progress");
MutexLocker x(G1CGC_lock, Mutex::_no_safepoint_check_flag);
if (concurrent_operation_is_full_mark) {
_cm->post_concurrent_mark_start();
- _cm_thread->start_full_mark();
+ _cm->cm_thread()->start_full_mark();
} else {
_cm->post_concurrent_undo_start();
- _cm_thread->start_undo_mark();
+ _cm->cm_thread()->start_undo_mark();
}
G1CGC_lock->notify();
}
@@ -2726,6 +2727,8 @@ void G1CollectedHeap::do_collection_pause_at_safepoint(size_t allocation_word_si
_bytes_used_during_gc = 0;
+ _cm->fully_initialize();
+
policy()->decide_on_concurrent_start_pause();
// Record whether this pause may need to trigger a concurrent operation. Later,
// when we signal the G1ConcurrentMarkThread, the collector state has already
diff --git a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp
index 1f900c76851..8ff9d481000 100644
--- a/src/hotspot/share/gc/g1/g1CollectedHeap.hpp
+++ b/src/hotspot/share/gc/g1/g1CollectedHeap.hpp
@@ -823,7 +823,6 @@ class G1CollectedHeap : public CollectedHeap {
// The concurrent marker (and the thread it runs in.)
G1ConcurrentMark* _cm;
- G1ConcurrentMarkThread* _cm_thread;
// The concurrent refiner.
G1ConcurrentRefine* _cr;
diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp
index 2bbfb5032b3..8f3cafe1f5b 100644
--- a/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp
+++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.cpp
@@ -382,12 +382,12 @@ G1CMRootMemRegions::~G1CMRootMemRegions() {
}
void G1CMRootMemRegions::reset() {
- _num_root_regions = 0;
+ _num_root_regions.store_relaxed(0);
}
void G1CMRootMemRegions::add(HeapWord* start, HeapWord* end) {
assert_at_safepoint();
- size_t idx = AtomicAccess::fetch_then_add(&_num_root_regions, 1u);
+ size_t idx = _num_root_regions.fetch_then_add(1u);
assert(idx < _max_regions, "Trying to add more root MemRegions than there is space %zu", _max_regions);
assert(start != nullptr && end != nullptr && start <= end, "Start (" PTR_FORMAT ") should be less or equal to "
"end (" PTR_FORMAT ")", p2i(start), p2i(end));
@@ -398,36 +398,38 @@ void G1CMRootMemRegions::add(HeapWord* start, HeapWord* end) {
void G1CMRootMemRegions::prepare_for_scan() {
assert(!scan_in_progress(), "pre-condition");
- _scan_in_progress = _num_root_regions > 0;
+ _scan_in_progress.store_relaxed(num_root_regions() > 0);
- _claimed_root_regions = 0;
- _should_abort = false;
+ _claimed_root_regions.store_relaxed(0);
+ _should_abort.store_relaxed(false);
}
const MemRegion* G1CMRootMemRegions::claim_next() {
- if (_should_abort) {
+ if (_should_abort.load_relaxed()) {
// If someone has set the should_abort flag, we return null to
// force the caller to bail out of their loop.
return nullptr;
}
- if (_claimed_root_regions >= _num_root_regions) {
+ uint local_num_root_regions = num_root_regions();
+ if (_claimed_root_regions.load_relaxed() >= local_num_root_regions) {
return nullptr;
}
- size_t claimed_index = AtomicAccess::fetch_then_add(&_claimed_root_regions, 1u);
- if (claimed_index < _num_root_regions) {
+ size_t claimed_index = _claimed_root_regions.fetch_then_add(1u);
+ if (claimed_index < local_num_root_regions) {
return &_root_regions[claimed_index];
}
return nullptr;
}
uint G1CMRootMemRegions::num_root_regions() const {
- return (uint)_num_root_regions;
+ return (uint)_num_root_regions.load_relaxed();
}
bool G1CMRootMemRegions::contains(const MemRegion mr) const {
- for (uint i = 0; i < _num_root_regions; i++) {
+ uint local_num_root_regions = num_root_regions();
+ for (uint i = 0; i < local_num_root_regions; i++) {
if (_root_regions[i].equals(mr)) {
return true;
}
@@ -437,7 +439,7 @@ bool G1CMRootMemRegions::contains(const MemRegion mr) const {
void G1CMRootMemRegions::notify_scan_done() {
MutexLocker x(G1RootRegionScan_lock, Mutex::_no_safepoint_check_flag);
- _scan_in_progress = false;
+ _scan_in_progress.store_relaxed(false);
G1RootRegionScan_lock->notify_all();
}
@@ -448,10 +450,10 @@ void G1CMRootMemRegions::cancel_scan() {
void G1CMRootMemRegions::scan_finished() {
assert(scan_in_progress(), "pre-condition");
- if (!_should_abort) {
- assert(_claimed_root_regions >= num_root_regions(),
+ if (!_should_abort.load_relaxed()) {
+ assert(_claimed_root_regions.load_relaxed() >= num_root_regions(),
"we should have claimed all root regions, claimed %zu, length = %u",
- _claimed_root_regions, num_root_regions());
+ _claimed_root_regions.load_relaxed(), num_root_regions());
}
notify_scan_done();
@@ -473,7 +475,7 @@ bool G1CMRootMemRegions::wait_until_scan_finished() {
G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h,
G1RegionToSpaceMapper* bitmap_storage) :
- // _cm_thread set inside the constructor
+ _cm_thread(nullptr),
_g1h(g1h),
_mark_bitmap(),
@@ -484,13 +486,12 @@ G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h,
_global_mark_stack(),
- // _finger set in set_non_marking_state
+ _finger(nullptr), // _finger set in set_non_marking_state
_worker_id_offset(G1ConcRefinementThreads), // The refinement control thread does not refine cards, so it's just the worker threads.
_max_num_tasks(MAX2(ConcGCThreads, ParallelGCThreads)),
- // _num_active_tasks set in set_non_marking_state()
- // _tasks set inside the constructor
-
+ _num_active_tasks(0), // _num_active_tasks set in set_non_marking_state()
+ _tasks(nullptr), // _tasks set inside late_init()
_task_queues(new G1CMTaskQueueSet(_max_num_tasks)),
_terminator(_max_num_tasks, _task_queues),
_partial_array_state_manager(new PartialArrayStateManager(_max_num_tasks)),
@@ -525,6 +526,12 @@ G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h,
assert(G1CGC_lock != nullptr, "CGC_lock must be initialized");
_mark_bitmap.initialize(g1h->reserved(), bitmap_storage);
+}
+
+void G1ConcurrentMark::fully_initialize() {
+ if (is_fully_initialized()) {
+ return;
+ }
// Create & start ConcurrentMark thread.
_cm_thread = new G1ConcurrentMarkThread(this);
@@ -560,6 +567,10 @@ G1ConcurrentMark::G1ConcurrentMark(G1CollectedHeap* g1h,
reset_at_marking_complete();
}
+bool G1ConcurrentMark::in_progress() const {
+ return is_fully_initialized() ? _cm_thread->in_progress() : false;
+}
+
PartialArrayStateManager* G1ConcurrentMark::partial_array_state_manager() const {
return _partial_array_state_manager;
}
@@ -628,8 +639,7 @@ void G1ConcurrentMark::reset_marking_for_restart() {
_finger = _heap.start();
for (uint i = 0; i < _max_num_tasks; ++i) {
- G1CMTaskQueue* queue = _task_queues->queue(i);
- queue->set_empty();
+ _tasks[i]->reset_for_restart();
}
}
@@ -765,7 +775,7 @@ class G1ClearBitMapTask : public WorkerTask {
// as asserts here to minimize their overhead on the product. However, we
// will have them as guarantees at the beginning / end of the bitmap
// clearing to get some checking in the product.
- assert(!suspendible() || _cm->cm_thread()->in_progress(), "invariant");
+ assert(!suspendible() || _cm->in_progress(), "invariant");
assert(!suspendible() || !G1CollectedHeap::heap()->collector_state()->mark_or_rebuild_in_progress(), "invariant");
// Abort iteration if necessary.
@@ -821,7 +831,8 @@ void G1ConcurrentMark::clear_bitmap(WorkerThreads* workers, bool may_yield) {
void G1ConcurrentMark::cleanup_for_next_mark() {
// Make sure that the concurrent mark thread looks to still be in
// the current cycle.
- guarantee(cm_thread()->in_progress(), "invariant");
+ guarantee(is_fully_initialized(), "should be initializd");
+ guarantee(in_progress(), "invariant");
// We are finishing up the current cycle by clearing the next
// marking bitmap and getting it ready for the next cycle. During
@@ -834,7 +845,8 @@ void G1ConcurrentMark::cleanup_for_next_mark() {
reset_partial_array_state_manager();
// Repeat the asserts from above.
- guarantee(cm_thread()->in_progress(), "invariant");
+ guarantee(is_fully_initialized(), "should be initializd");
+ guarantee(in_progress(), "invariant");
guarantee(!_g1h->collector_state()->mark_or_rebuild_in_progress(), "invariant");
}
@@ -1925,15 +1937,12 @@ bool G1ConcurrentMark::concurrent_cycle_abort() {
// nothing, but this situation should be extremely rare (a full gc after shutdown
// has been signalled is already rare), and this work should be negligible compared
// to actual full gc work.
- if (!cm_thread()->in_progress() && !_g1h->concurrent_mark_is_terminating()) {
+
+ if (!is_fully_initialized() || (!cm_thread()->in_progress() && !_g1h->concurrent_mark_is_terminating())) {
return false;
}
- // Empty mark stack
reset_marking_for_restart();
- for (uint i = 0; i < _max_num_tasks; ++i) {
- _tasks[i]->clear_region_fields();
- }
abort_marking_threads();
@@ -1987,6 +1996,10 @@ void G1ConcurrentMark::print_summary_info() {
}
log.trace(" Concurrent marking:");
+ if (!is_fully_initialized()) {
+ log.trace(" has not been initialized yet");
+ return;
+ }
print_ms_time_info(" ", "remarks", _remark_times);
{
print_ms_time_info(" ", "final marks", _remark_mark_times);
@@ -2003,7 +2016,10 @@ void G1ConcurrentMark::print_summary_info() {
}
void G1ConcurrentMark::threads_do(ThreadClosure* tc) const {
- _concurrent_workers->threads_do(tc);
+ if (is_fully_initialized()) { // they are initialized late
+ tc->do_thread(_cm_thread);
+ _concurrent_workers->threads_do(tc);
+ }
}
void G1ConcurrentMark::print_on(outputStream* st) const {
@@ -2097,6 +2113,13 @@ void G1CMTask::reset(G1CMBitMap* mark_bitmap) {
_mark_stats_cache.reset();
}
+void G1CMTask::reset_for_restart() {
+ clear_region_fields();
+ _task_queue->set_empty();
+ TASKQUEUE_STATS_ONLY(_partial_array_splitter.stats()->reset());
+ TASKQUEUE_STATS_ONLY(_task_queue->stats.reset());
+}
+
void G1CMTask::register_partial_array_splitter() {
::new (&_partial_array_splitter) PartialArraySplitter(_cm->partial_array_state_manager(),
diff --git a/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp b/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp
index 836d7793f81..0271e6a4208 100644
--- a/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp
+++ b/src/hotspot/share/gc/g1/g1ConcurrentMark.hpp
@@ -290,12 +290,12 @@ class G1CMRootMemRegions {
MemRegion* _root_regions;
size_t const _max_regions;
- volatile size_t _num_root_regions; // Actual number of root regions.
+ Atomic _num_root_regions; // Actual number of root regions.
- volatile size_t _claimed_root_regions; // Number of root regions currently claimed.
+ Atomic _claimed_root_regions; // Number of root regions currently claimed.
- volatile bool _scan_in_progress;
- volatile bool _should_abort;
+ Atomic _scan_in_progress;
+ Atomic _should_abort;
void notify_scan_done();
@@ -312,11 +312,11 @@ class G1CMRootMemRegions {
void prepare_for_scan();
// Forces get_next() to return null so that the iteration aborts early.
- void abort() { _should_abort = true; }
+ void abort() { _should_abort.store_relaxed(true); }
// Return true if the CM thread are actively scanning root regions,
// false otherwise.
- bool scan_in_progress() { return _scan_in_progress; }
+ bool scan_in_progress() { return _scan_in_progress.load_relaxed(); }
// Claim the next root MemRegion to scan atomically, or return null if
// all have been claimed.
@@ -555,6 +555,9 @@ class G1ConcurrentMark : public CHeapObj {
uint worker_id_offset() const { return _worker_id_offset; }
+ void fully_initialize();
+ bool is_fully_initialized() const { return _cm_thread != nullptr; }
+ bool in_progress() const;
uint max_num_tasks() const {return _max_num_tasks; }
// Clear statistics gathered during the concurrent cycle for the given region after
@@ -841,8 +844,10 @@ class G1CMTask : public TerminatorTerminator {
// Apply the closure to the given range of elements in the objArray.
inline void process_array_chunk(objArrayOop obj, size_t start, size_t end);
public:
- // Resets the task; should be called right at the beginning of a marking phase.
+ // Resets the task completely for a new marking; should be called right at the beginning of a marking phase.
void reset(G1CMBitMap* mark_bitmap);
+ // Minimal reset of the task, making it ready for continuing to mark.
+ void reset_for_restart();
// Register/unregister Partial Array Splitter Allocator with the PartialArrayStateManager.
// This allows us to discard memory arenas used for partial object array states at the end
// of a concurrent mark cycle.
diff --git a/src/hotspot/share/gc/g1/g1HeapRegion.cpp b/src/hotspot/share/gc/g1/g1HeapRegion.cpp
index 361e19d4be5..2052a3ce156 100644
--- a/src/hotspot/share/gc/g1/g1HeapRegion.cpp
+++ b/src/hotspot/share/gc/g1/g1HeapRegion.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -44,7 +44,7 @@
#include "oops/access.inline.hpp"
#include "oops/compressedOops.inline.hpp"
#include "oops/oop.inline.hpp"
-#include "runtime/atomicAccess.hpp"
+#include "runtime/atomic.hpp"
#include "runtime/globals_extension.hpp"
#include "utilities/powerOfTwo.hpp"
@@ -131,8 +131,8 @@ void G1HeapRegion::hr_clear(bool clear_space) {
G1CollectedHeap::heap()->concurrent_mark()->reset_top_at_mark_start(this);
- _parsable_bottom = bottom();
- _garbage_bytes = 0;
+ _parsable_bottom.store_relaxed(bottom());
+ _garbage_bytes.store_relaxed(0);
_incoming_refs = 0;
if (clear_space) clear(SpaceDecorator::Mangle);
@@ -294,12 +294,12 @@ void G1HeapRegion::report_region_type_change(G1HeapRegionTraceType::Type to) {
// young gen regions never have their PB set to anything other than bottom.
assert(parsable_bottom_acquire() == bottom(), "must be");
- _garbage_bytes = 0;
+ _garbage_bytes.store_relaxed(0);
_incoming_refs = 0;
}
void G1HeapRegion::note_self_forward_chunk_done(size_t garbage_bytes) {
- AtomicAccess::add(&_garbage_bytes, garbage_bytes, memory_order_relaxed);
+ _garbage_bytes.add_then_fetch(garbage_bytes, memory_order_relaxed);
}
// Code roots support
@@ -448,7 +448,7 @@ void G1HeapRegion::print_on(outputStream* st) const {
st->print("|-");
}
}
- st->print("|%3zu", AtomicAccess::load(&_pinned_object_count));
+ st->print("|%3zu", _pinned_object_count.load_relaxed());
st->print_cr("");
}
diff --git a/src/hotspot/share/gc/g1/g1HeapRegion.hpp b/src/hotspot/share/gc/g1/g1HeapRegion.hpp
index fe915b0dafe..2b4b640d52b 100644
--- a/src/hotspot/share/gc/g1/g1HeapRegion.hpp
+++ b/src/hotspot/share/gc/g1/g1HeapRegion.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -33,6 +33,7 @@
#include "gc/shared/ageTable.hpp"
#include "gc/shared/spaceDecorator.hpp"
#include "gc/shared/verifyOption.hpp"
+#include "runtime/atomic.hpp"
#include "runtime/mutex.hpp"
#include "utilities/macros.hpp"
@@ -73,7 +74,7 @@ class G1HeapRegion : public CHeapObj {
HeapWord* const _bottom;
HeapWord* const _end;
- HeapWord* volatile _top;
+ Atomic _top;
G1BlockOffsetTable* _bot;
@@ -89,8 +90,8 @@ class G1HeapRegion : public CHeapObj {
HeapWord* bottom() const { return _bottom; }
HeapWord* end() const { return _end; }
- void set_top(HeapWord* value) { _top = value; }
- HeapWord* top() const { return _top; }
+ void set_top(HeapWord* value) { _top.store_relaxed(value); }
+ HeapWord* top() const { return _top.load_relaxed(); }
// See the comment above in the declaration of _pre_dummy_top for an
// explanation of what it is.
@@ -231,10 +232,10 @@ class G1HeapRegion : public CHeapObj {
//
// Below this limit the marking bitmap must be used to determine size and
// liveness.
- HeapWord* volatile _parsable_bottom;
+ Atomic _parsable_bottom;
// Amount of dead data in the region.
- size_t _garbage_bytes;
+ Atomic _garbage_bytes;
// Approximate number of references to this regions at the end of concurrent
// marking. We we do not mark through all objects, so this is an estimate.
@@ -249,7 +250,7 @@ class G1HeapRegion : public CHeapObj {
uint _node_index;
// Number of objects in this region that are currently pinned.
- volatile size_t _pinned_object_count;
+ Atomic _pinned_object_count;
void report_region_type_change(G1HeapRegionTraceType::Type to);
@@ -331,7 +332,7 @@ class G1HeapRegion : public CHeapObj {
}
// A lower bound on the amount of garbage bytes in the region.
- size_t garbage_bytes() const { return _garbage_bytes; }
+ size_t garbage_bytes() const { return _garbage_bytes.load_relaxed(); }
// Return the amount of bytes we'll reclaim if we collect this
// region. This includes not only the known garbage bytes in the
@@ -393,8 +394,8 @@ class G1HeapRegion : public CHeapObj {
bool is_old_or_humongous() const { return _type.is_old_or_humongous(); }
- size_t pinned_count() const { return AtomicAccess::load(&_pinned_object_count); }
- bool has_pinned_objects() const { return pinned_count() > 0; }
+ inline size_t pinned_count() const;
+ inline bool has_pinned_objects() const;
void set_free();
diff --git a/src/hotspot/share/gc/g1/g1HeapRegion.inline.hpp b/src/hotspot/share/gc/g1/g1HeapRegion.inline.hpp
index f25bf62c9be..4f242b7a537 100644
--- a/src/hotspot/share/gc/g1/g1HeapRegion.inline.hpp
+++ b/src/hotspot/share/gc/g1/g1HeapRegion.inline.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -35,7 +35,6 @@
#include "gc/g1/g1Policy.hpp"
#include "gc/g1/g1Predictions.hpp"
#include "oops/oop.inline.hpp"
-#include "runtime/atomicAccess.hpp"
#include "runtime/init.hpp"
#include "runtime/prefetch.inline.hpp"
#include "runtime/safepoint.hpp"
@@ -131,7 +130,7 @@ inline void G1HeapRegion::prepare_for_full_gc() {
// After marking and class unloading the heap temporarily contains dead objects
// with unloaded klasses. Moving parsable_bottom makes some (debug) code correctly
// skip dead objects.
- _parsable_bottom = top();
+ _parsable_bottom.store_relaxed(top());
}
inline void G1HeapRegion::reset_compacted_after_full_gc(HeapWord* new_top) {
@@ -154,7 +153,7 @@ inline void G1HeapRegion::reset_after_full_gc_common() {
// Everything above bottom() is parsable and live.
reset_parsable_bottom();
- _garbage_bytes = 0;
+ _garbage_bytes.store_relaxed(0);
_incoming_refs = 0;
@@ -188,20 +187,22 @@ inline void G1HeapRegion::apply_to_marked_objects(G1CMBitMap* bitmap, ApplyToMar
inline HeapWord* G1HeapRegion::par_allocate(size_t min_word_size,
size_t desired_word_size,
size_t* actual_word_size) {
+ HeapWord* obj = top();
do {
- HeapWord* obj = top();
size_t available = pointer_delta(end(), obj);
size_t want_to_allocate = MIN2(available, desired_word_size);
if (want_to_allocate >= min_word_size) {
HeapWord* new_top = obj + want_to_allocate;
- HeapWord* result = AtomicAccess::cmpxchg(&_top, obj, new_top);
- // result can be one of two:
- // the old top value: the exchange succeeded
+ HeapWord* result = _top.compare_exchange(obj, new_top);
+ // Result can be one of two:
+ // the old top value: the exchange succeeded, return.
// otherwise: the new value of the top is returned.
if (result == obj) {
assert(is_object_aligned(obj) && is_object_aligned(new_top), "checking alignment");
*actual_word_size = want_to_allocate;
return obj;
+ } else {
+ obj = result;
}
} else {
return nullptr;
@@ -254,27 +255,27 @@ inline void G1HeapRegion::update_bot_for_block(HeapWord* start, HeapWord* end) {
inline HeapWord* G1HeapRegion::parsable_bottom() const {
assert(!is_init_completed() || SafepointSynchronize::is_at_safepoint(), "only during initialization or safepoint");
- return _parsable_bottom;
+ return _parsable_bottom.load_relaxed();
}
inline HeapWord* G1HeapRegion::parsable_bottom_acquire() const {
- return AtomicAccess::load_acquire(&_parsable_bottom);
+ return _parsable_bottom.load_acquire();
}
inline void G1HeapRegion::reset_parsable_bottom() {
- AtomicAccess::release_store(&_parsable_bottom, bottom());
+ _parsable_bottom.release_store(bottom());
}
inline void G1HeapRegion::note_end_of_marking(HeapWord* top_at_mark_start, size_t marked_bytes, size_t incoming_refs) {
assert_at_safepoint();
if (top_at_mark_start != bottom()) {
- _garbage_bytes = byte_size(bottom(), top_at_mark_start) - marked_bytes;
+ _garbage_bytes.store_relaxed(byte_size(bottom(), top_at_mark_start) - marked_bytes);
_incoming_refs = incoming_refs;
}
if (needs_scrubbing()) {
- _parsable_bottom = top_at_mark_start;
+ _parsable_bottom.store_relaxed(top_at_mark_start);
}
}
@@ -286,6 +287,14 @@ inline bool G1HeapRegion::needs_scrubbing() const {
return is_old();
}
+inline size_t G1HeapRegion::pinned_count() const {
+ return _pinned_object_count.load_relaxed();
+}
+
+inline bool G1HeapRegion::has_pinned_objects() const {
+ return pinned_count() > 0;
+}
+
inline bool G1HeapRegion::in_collection_set() const {
return G1CollectedHeap::heap()->is_in_cset(this);
}
@@ -511,7 +520,7 @@ inline void G1HeapRegion::record_surv_words_in_group(size_t words_survived) {
inline void G1HeapRegion::add_pinned_object_count(size_t value) {
assert(value != 0, "wasted effort");
assert(!is_free(), "trying to pin free region %u, adding %zu", hrm_index(), value);
- AtomicAccess::add(&_pinned_object_count, value, memory_order_relaxed);
+ _pinned_object_count.add_then_fetch(value, memory_order_relaxed);
}
inline void G1HeapRegion::install_cset_group(G1CSetCandidateGroup* cset_group) {
diff --git a/src/hotspot/share/gc/g1/g1HeapRegionManager.cpp b/src/hotspot/share/gc/g1/g1HeapRegionManager.cpp
index 795b6543bae..44897c8a277 100644
--- a/src/hotspot/share/gc/g1/g1HeapRegionManager.cpp
+++ b/src/hotspot/share/gc/g1/g1HeapRegionManager.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -713,8 +713,10 @@ void G1HeapRegionManager::verify_optional() {
G1HeapRegionClaimer::G1HeapRegionClaimer(uint n_workers) :
_n_workers(n_workers), _n_regions(G1CollectedHeap::heap()->_hrm._next_highest_used_hrm_index), _claims(nullptr) {
- uint* new_claims = NEW_C_HEAP_ARRAY(uint, _n_regions, mtGC);
- memset(new_claims, Unclaimed, sizeof(*_claims) * _n_regions);
+ Atomic* new_claims = NEW_C_HEAP_ARRAY(Atomic, _n_regions, mtGC);
+ for (uint i = 0; i < _n_regions; i++) {
+ new_claims[i].store_relaxed(Unclaimed);
+ }
_claims = new_claims;
}
@@ -730,13 +732,12 @@ uint G1HeapRegionClaimer::offset_for_worker(uint worker_id) const {
bool G1HeapRegionClaimer::is_region_claimed(uint region_index) const {
assert(region_index < _n_regions, "Invalid index.");
- return _claims[region_index] == Claimed;
+ return _claims[region_index].load_relaxed() == Claimed;
}
bool G1HeapRegionClaimer::claim_region(uint region_index) {
assert(region_index < _n_regions, "Invalid index.");
- uint old_val = AtomicAccess::cmpxchg(&_claims[region_index], Unclaimed, Claimed);
- return old_val == Unclaimed;
+ return _claims[region_index].compare_set(Unclaimed, Claimed);
}
class G1RebuildFreeListTask : public WorkerTask {
diff --git a/src/hotspot/share/gc/g1/g1HeapRegionManager.hpp b/src/hotspot/share/gc/g1/g1HeapRegionManager.hpp
index b4ce3b0a8be..eb593ff408e 100644
--- a/src/hotspot/share/gc/g1/g1HeapRegionManager.hpp
+++ b/src/hotspot/share/gc/g1/g1HeapRegionManager.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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,6 +30,7 @@
#include "gc/g1/g1HeapRegionSet.hpp"
#include "gc/g1/g1RegionToSpaceMapper.hpp"
#include "memory/allocation.hpp"
+#include "runtime/atomic.hpp"
#include "services/memoryUsage.hpp"
class G1HeapRegion;
@@ -294,7 +295,7 @@ class G1HeapRegionManager: public CHeapObj {
class G1HeapRegionClaimer : public StackObj {
uint _n_workers;
uint _n_regions;
- volatile uint* _claims;
+ Atomic* _claims;
static const uint Unclaimed = 0;
static const uint Claimed = 1;
diff --git a/src/hotspot/share/gc/g1/g1PeriodicGCTask.cpp b/src/hotspot/share/gc/g1/g1PeriodicGCTask.cpp
index 50002ac2bfe..f280d76f3c7 100644
--- a/src/hotspot/share/gc/g1/g1PeriodicGCTask.cpp
+++ b/src/hotspot/share/gc/g1/g1PeriodicGCTask.cpp
@@ -39,7 +39,7 @@ bool G1PeriodicGCTask::should_start_periodic_gc(G1CollectedHeap* g1h,
SuspendibleThreadSetJoiner sts;
// If we are currently in a concurrent mark we are going to uncommit memory soon.
- if (g1h->concurrent_mark()->cm_thread()->in_progress()) {
+ if (g1h->concurrent_mark()->in_progress()) {
log_debug(gc, periodic)("Concurrent cycle in progress. Skipping.");
return false;
}
diff --git a/src/hotspot/share/gc/g1/g1Policy.cpp b/src/hotspot/share/gc/g1/g1Policy.cpp
index 1d0b29c303e..98e6acc1d77 100644
--- a/src/hotspot/share/gc/g1/g1Policy.cpp
+++ b/src/hotspot/share/gc/g1/g1Policy.cpp
@@ -739,7 +739,7 @@ double G1Policy::constant_other_time_ms(double pause_time_ms) const {
}
bool G1Policy::about_to_start_mixed_phase() const {
- return _g1h->concurrent_mark()->cm_thread()->in_progress() || collector_state()->in_young_gc_before_mixed();
+ return _g1h->concurrent_mark()->in_progress() || collector_state()->in_young_gc_before_mixed();
}
bool G1Policy::need_to_start_conc_mark(const char* source, size_t allocation_word_size) {
@@ -1235,7 +1235,7 @@ bool G1Policy::force_concurrent_start_if_outside_cycle(GCCause::Cause gc_cause)
// We actually check whether we are marking here and not if we are in a
// reclamation phase. This means that we will schedule a concurrent mark
// even while we are still in the process of reclaiming memory.
- bool during_cycle = _g1h->concurrent_mark()->cm_thread()->in_progress();
+ bool during_cycle = _g1h->concurrent_mark()->in_progress();
if (!during_cycle) {
log_debug(gc, ergo)("Request concurrent cycle initiation (requested by GC cause). "
"GC cause: %s",
diff --git a/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp b/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp
index d9b7ec294bd..c5f55e1d20c 100644
--- a/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp
+++ b/src/hotspot/share/gc/g1/g1RegionMarkStatsCache.cpp
@@ -29,12 +29,12 @@
G1RegionMarkStatsCache::G1RegionMarkStatsCache(G1RegionMarkStats* target, uint num_cache_entries) :
_target(target),
+ _cache(NEW_C_HEAP_ARRAY(G1RegionMarkStatsCacheEntry, num_cache_entries, mtGC)),
_num_cache_entries(num_cache_entries),
_num_cache_entries_mask(_num_cache_entries - 1) {
guarantee(is_power_of_2(num_cache_entries),
"Number of cache entries must be power of two, but is %u", num_cache_entries);
- _cache = NEW_C_HEAP_ARRAY(G1RegionMarkStatsCacheEntry, _num_cache_entries, mtGC);
}
G1RegionMarkStatsCache::~G1RegionMarkStatsCache() {
diff --git a/src/hotspot/share/gc/g1/g1VMOperations.cpp b/src/hotspot/share/gc/g1/g1VMOperations.cpp
index 1c024f2943b..56ab3a4b0fe 100644
--- a/src/hotspot/share/gc/g1/g1VMOperations.cpp
+++ b/src/hotspot/share/gc/g1/g1VMOperations.cpp
@@ -85,7 +85,7 @@ void VM_G1TryInitiateConcMark::doit() {
GCCauseSetter x(g1h, _gc_cause);
_mark_in_progress = g1h->collector_state()->mark_in_progress();
- _cycle_already_in_progress = g1h->concurrent_mark()->cm_thread()->in_progress();
+ _cycle_already_in_progress = g1h->concurrent_mark()->in_progress();
if (!g1h->policy()->force_concurrent_start_if_outside_cycle(_gc_cause)) {
// Failure to force the next GC pause to be a concurrent start indicates
diff --git a/src/hotspot/share/gc/g1/g1YoungCollector.cpp b/src/hotspot/share/gc/g1/g1YoungCollector.cpp
index 36cc44a8b7c..a9db9a7c269 100644
--- a/src/hotspot/share/gc/g1/g1YoungCollector.cpp
+++ b/src/hotspot/share/gc/g1/g1YoungCollector.cpp
@@ -36,6 +36,7 @@
#include "gc/g1/g1EvacFailureRegions.inline.hpp"
#include "gc/g1/g1EvacInfo.hpp"
#include "gc/g1/g1GCPhaseTimes.hpp"
+#include "gc/g1/g1HeapRegion.inline.hpp"
#include "gc/g1/g1HeapRegionPrinter.hpp"
#include "gc/g1/g1MonitoringSupport.hpp"
#include "gc/g1/g1ParScanThreadState.inline.hpp"
diff --git a/src/hotspot/share/gc/g1/vmStructs_g1.hpp b/src/hotspot/share/gc/g1/vmStructs_g1.hpp
index 21c86d47a6b..af236ec8581 100644
--- a/src/hotspot/share/gc/g1/vmStructs_g1.hpp
+++ b/src/hotspot/share/gc/g1/vmStructs_g1.hpp
@@ -28,6 +28,7 @@
#include "gc/g1/g1CollectedHeap.hpp"
#include "gc/g1/g1HeapRegion.hpp"
#include "gc/g1/g1HeapRegionManager.hpp"
+#include "runtime/atomic.hpp"
#include "utilities/macros.hpp"
#define VM_STRUCTS_G1GC(nonstatic_field, \
@@ -39,9 +40,9 @@
\
nonstatic_field(G1HeapRegion, _type, G1HeapRegionType) \
nonstatic_field(G1HeapRegion, _bottom, HeapWord* const) \
- nonstatic_field(G1HeapRegion, _top, HeapWord* volatile) \
+ nonstatic_field(G1HeapRegion, _top, Atomic) \
nonstatic_field(G1HeapRegion, _end, HeapWord* const) \
- volatile_nonstatic_field(G1HeapRegion, _pinned_object_count, size_t) \
+ volatile_nonstatic_field(G1HeapRegion, _pinned_object_count, Atomic)\
\
nonstatic_field(G1HeapRegionType, _tag, G1HeapRegionType::Tag volatile) \
\
diff --git a/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp b/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp
index e0b1edf2efc..c5d112ffbc1 100644
--- a/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp
+++ b/src/hotspot/share/gc/parallel/mutableNUMASpace.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2006, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2006, 2026, 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,7 @@
#include "memory/allocation.inline.hpp"
#include "oops/oop.inline.hpp"
#include "oops/typeArrayOop.hpp"
-#include "runtime/atomicAccess.hpp"
+#include "runtime/atomic.hpp"
#include "runtime/java.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/os.inline.hpp"
@@ -489,7 +489,7 @@ HeapWord* MutableNUMASpace::cas_allocate(size_t size) {
if (p != nullptr) {
HeapWord* cur_top, *cur_chunk_top = p + size;
while ((cur_top = top()) < cur_chunk_top) { // Keep _top updated.
- if (AtomicAccess::cmpxchg(top_addr(), cur_top, cur_chunk_top) == cur_top) {
+ if (top_addr()->compare_set(cur_top, cur_chunk_top)) {
break;
}
}
diff --git a/src/hotspot/share/gc/parallel/mutableSpace.cpp b/src/hotspot/share/gc/parallel/mutableSpace.cpp
index fc42fc1eab2..d99db493989 100644
--- a/src/hotspot/share/gc/parallel/mutableSpace.cpp
+++ b/src/hotspot/share/gc/parallel/mutableSpace.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -28,7 +28,6 @@
#include "memory/iterator.inline.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"
-#include "runtime/atomicAccess.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/safepoint.hpp"
#include "utilities/align.hpp"
@@ -123,7 +122,7 @@ void MutableSpace::initialize(MemRegion mr,
// makes the new space available for allocation by other threads. So this
// assignment must follow all other configuration and initialization that
// might be done for expansion.
- AtomicAccess::release_store(end_addr(), mr.end());
+ _end.release_store(mr.end());
if (clear_space) {
clear(mangle_space);
@@ -140,7 +139,7 @@ void MutableSpace::clear(bool mangle_space) {
#ifndef PRODUCT
void MutableSpace::mangle_unused_area() {
- mangle_region(MemRegion(_top, _end));
+ mangle_region(MemRegion(top(), end()));
}
void MutableSpace::mangle_region(MemRegion mr) {
@@ -155,14 +154,10 @@ HeapWord* MutableSpace::cas_allocate(size_t size) {
// If end is read first, other threads may advance end and top such that
// current top > old end and current top + size > current end. Then
// pointer_delta underflows, allowing installation of top > current end.
- HeapWord* obj = AtomicAccess::load_acquire(top_addr());
+ HeapWord* obj = _top.load_acquire();
if (pointer_delta(end(), obj) >= size) {
HeapWord* new_top = obj + size;
- HeapWord* result = AtomicAccess::cmpxchg(top_addr(), obj, new_top);
- // result can be one of two:
- // the old top value: the exchange succeeded
- // otherwise: the new value of the top is returned.
- if (result != obj) {
+ if (!_top.compare_set(obj, new_top)) {
continue; // another thread beat us to the allocation, try again
}
assert(is_object_aligned(obj) && is_object_aligned(new_top),
@@ -177,7 +172,7 @@ HeapWord* MutableSpace::cas_allocate(size_t size) {
// Try to deallocate previous allocation. Returns true upon success.
bool MutableSpace::cas_deallocate(HeapWord *obj, size_t size) {
HeapWord* expected_top = obj + size;
- return AtomicAccess::cmpxchg(top_addr(), expected_top, obj) == expected_top;
+ return _top.compare_set(expected_top, obj);
}
void MutableSpace::oop_iterate(OopIterateClosure* cl) {
diff --git a/src/hotspot/share/gc/parallel/mutableSpace.hpp b/src/hotspot/share/gc/parallel/mutableSpace.hpp
index 9d3894e2489..28df19a7c4b 100644
--- a/src/hotspot/share/gc/parallel/mutableSpace.hpp
+++ b/src/hotspot/share/gc/parallel/mutableSpace.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2001, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2026, 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
@@ -28,6 +28,7 @@
#include "memory/allocation.hpp"
#include "memory/iterator.hpp"
#include "memory/memRegion.hpp"
+#include "runtime/atomic.hpp"
#include "utilities/copy.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
@@ -53,8 +54,8 @@ class MutableSpace: public CHeapObj {
MemRegion _last_setup_region;
size_t _page_size;
HeapWord* _bottom;
- HeapWord* volatile _top;
- HeapWord* _end;
+ Atomic _top;
+ Atomic _end;
void numa_setup_pages(MemRegion mr, bool clear_space);
@@ -64,21 +65,20 @@ class MutableSpace: public CHeapObj {
protected:
size_t page_size() const { return _page_size; }
+ Atomic* top_addr() { return &_top; }
+
public:
virtual ~MutableSpace() = default;
MutableSpace(size_t page_size);
// Accessors
HeapWord* bottom() const { return _bottom; }
- HeapWord* top() const { return _top; }
- HeapWord* end() const { return _end; }
+ HeapWord* top() const { return _top.load_relaxed(); }
+ HeapWord* end() const { return _end.load_relaxed(); }
void set_bottom(HeapWord* value) { _bottom = value; }
- virtual void set_top(HeapWord* value) { _top = value; }
- void set_end(HeapWord* value) { _end = value; }
-
- HeapWord* volatile* top_addr() { return &_top; }
- HeapWord** end_addr() { return &_end; }
+ virtual void set_top(HeapWord* value) { _top.store_relaxed(value); }
+ void set_end(HeapWord* value) { _end.store_relaxed(value); }
MemRegion region() const { return MemRegion(bottom(), end()); }
@@ -110,7 +110,7 @@ class MutableSpace: public CHeapObj {
// Boolean queries.
bool is_empty() const { return used_in_words() == 0; }
bool not_empty() const { return used_in_words() > 0; }
- bool contains(const void* p) const { return _bottom <= p && p < _end; }
+ bool contains(const void* p) const { return _bottom <= p && p < end(); }
// Size computations. Sizes are in bytes.
size_t used_in_bytes() const { return used_in_words() * HeapWordSize; }
diff --git a/src/hotspot/share/gc/parallel/psPromotionManager.cpp b/src/hotspot/share/gc/parallel/psPromotionManager.cpp
index a41a9403082..d6208755374 100644
--- a/src/hotspot/share/gc/parallel/psPromotionManager.cpp
+++ b/src/hotspot/share/gc/parallel/psPromotionManager.cpp
@@ -43,6 +43,7 @@
#include "memory/resourceArea.hpp"
#include "oops/access.inline.hpp"
#include "oops/compressedOops.inline.hpp"
+#include "oops/oopsHierarchy.hpp"
#include "utilities/checkedCast.hpp"
PaddedEnd* PSPromotionManager::_manager_array = nullptr;
@@ -248,30 +249,19 @@ void PSPromotionManager::flush_labs() {
}
}
-template
-void PSPromotionManager::process_array_chunk_work(oop obj, int start, int end) {
- assert(start <= end, "invariant");
- T* const base = (T*)objArrayOop(obj)->base();
- T* p = base + start;
- T* const chunk_end = base + end;
- while (p < chunk_end) {
- claim_or_forward_depth(p);
- ++p;
- }
+void PSPromotionManager::process_array_chunk(objArrayOop obj, size_t start, size_t end) {
+ PSPushContentsClosure pcc(this);
+ obj->oop_iterate_elements_range(&pcc,
+ checked_cast(start),
+ checked_cast(end));
}
void PSPromotionManager::process_array_chunk(PartialArrayState* state, bool stolen) {
// Access before release by claim().
- oop new_obj = state->destination();
+ objArrayOop to_array = objArrayOop(state->destination());
PartialArraySplitter::Claim claim =
_partial_array_splitter.claim(state, &_claimed_stack_depth, stolen);
- int start = checked_cast(claim._start);
- int end = checked_cast(claim._end);
- if (UseCompressedOops) {
- process_array_chunk_work(new_obj, start, end);
- } else {
- process_array_chunk_work(new_obj, start, end);
- }
+ process_array_chunk(to_array, claim._start, claim._end);
}
void PSPromotionManager::push_objArray(oop old_obj, oop new_obj) {
@@ -284,12 +274,8 @@ void PSPromotionManager::push_objArray(oop old_obj, oop new_obj) {
size_t initial_chunk_size =
// The source array is unused when processing states.
_partial_array_splitter.start(&_claimed_stack_depth, nullptr, to_array, array_length);
- int end = checked_cast(initial_chunk_size);
- if (UseCompressedOops) {
- process_array_chunk_work(to_array, 0, end);
- } else {
- process_array_chunk_work(to_array, 0, end);
- }
+
+ process_array_chunk(to_array, 0, initial_chunk_size);
}
oop PSPromotionManager::oop_promotion_failed(oop obj, markWord obj_mark) {
diff --git a/src/hotspot/share/gc/parallel/psPromotionManager.hpp b/src/hotspot/share/gc/parallel/psPromotionManager.hpp
index 44df708eea4..2b0fc56c0bf 100644
--- a/src/hotspot/share/gc/parallel/psPromotionManager.hpp
+++ b/src/hotspot/share/gc/parallel/psPromotionManager.hpp
@@ -97,9 +97,8 @@ class PSPromotionManager {
inline static PSPromotionManager* manager_array(uint index);
- template void process_array_chunk_work(oop obj,
- int start, int end);
void process_array_chunk(PartialArrayState* state, bool stolen);
+ void process_array_chunk(objArrayOop obj, size_t start, size_t end);
void push_objArray(oop old_obj, oop new_obj);
inline void promotion_trace_event(oop new_obj, Klass* klass, size_t obj_size,
diff --git a/src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp b/src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp
index f1fd49c7dfe..9e904e44b22 100644
--- a/src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp
+++ b/src/hotspot/share/gc/parallel/psPromotionManager.inline.hpp
@@ -51,7 +51,7 @@ inline PSPromotionManager* PSPromotionManager::manager_array(uint index) {
}
template
-inline void PSPromotionManager::claim_or_forward_depth(T* p) {
+ALWAYSINLINE void PSPromotionManager::claim_or_forward_depth(T* p) {
assert(ParallelScavengeHeap::heap()->is_in(p), "pointer outside heap");
T heap_oop = RawAccess<>::oop_load(p);
if (PSScavenge::is_obj_in_young(heap_oop)) {
diff --git a/src/hotspot/share/gc/parallel/vmStructs_parallelgc.hpp b/src/hotspot/share/gc/parallel/vmStructs_parallelgc.hpp
index f69219a1f40..f8dabc4539e 100644
--- a/src/hotspot/share/gc/parallel/vmStructs_parallelgc.hpp
+++ b/src/hotspot/share/gc/parallel/vmStructs_parallelgc.hpp
@@ -47,8 +47,8 @@
nonstatic_field(PSVirtualSpace, _committed_high_addr, char*) \
\
nonstatic_field(MutableSpace, _bottom, HeapWord*) \
- nonstatic_field(MutableSpace, _end, HeapWord*) \
- volatile_nonstatic_field(MutableSpace, _top, HeapWord*) \
+ nonstatic_field(MutableSpace, _end, Atomic) \
+ volatile_nonstatic_field(MutableSpace, _top, Atomic) \
\
nonstatic_field(PSYoungGen, _reserved, MemRegion) \
nonstatic_field(PSYoungGen, _virtual_space, PSVirtualSpace*) \
diff --git a/src/hotspot/share/gc/shared/cardTableBarrierSet.cpp b/src/hotspot/share/gc/shared/cardTableBarrierSet.cpp
index 539e40820a8..d6541198858 100644
--- a/src/hotspot/share/gc/shared/cardTableBarrierSet.cpp
+++ b/src/hotspot/share/gc/shared/cardTableBarrierSet.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2026, 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
@@ -73,15 +73,15 @@ CardTableBarrierSet::CardTableBarrierSet(CardTable* card_table) :
{}
CardTableBarrierSet::~CardTableBarrierSet() {
- delete _card_table;
+ delete card_table();
}
void CardTableBarrierSet::write_region(MemRegion mr) {
- _card_table->dirty_MemRegion(mr);
+ card_table()->dirty_MemRegion(mr);
}
void CardTableBarrierSet::print_on(outputStream* st) const {
- _card_table->print_on(st);
+ card_table()->print_on(st);
}
// Helper for ReduceInitialCardMarks. For performance,
@@ -116,7 +116,7 @@ void CardTableBarrierSet::on_slowpath_allocation_exit(JavaThread* thread, oop ne
if (!ReduceInitialCardMarks) {
return;
}
- if (new_obj->is_typeArray() || _card_table->is_in_young(new_obj)) {
+ if (new_obj->is_typeArray() || card_table()->is_in_young(new_obj)) {
// Arrays of non-references don't need a post-barrier.
} else {
MemRegion mr(cast_from_oop(new_obj), new_obj->size());
diff --git a/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp b/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp
index c298bfcd0c2..3a9b46d9df8 100644
--- a/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp
+++ b/src/hotspot/share/gc/shared/cardTableBarrierSet.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2026, 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
@@ -29,6 +29,7 @@
#include "gc/shared/cardTable.hpp"
#include "gc/shared/gc_globals.hpp"
#include "memory/memRegion.hpp"
+#include "runtime/atomic.hpp"
#include "utilities/align.hpp"
// This kind of "BarrierSet" allows a "CollectedHeap" to detect and
@@ -49,7 +50,7 @@ class CardTableBarrierSet: public BarrierSet {
protected:
typedef CardTable::CardValue CardValue;
- CardTable* _card_table;
+ Atomic _card_table;
CardTableBarrierSet(BarrierSetAssembler* barrier_set_assembler,
BarrierSetC1* barrier_set_c1,
@@ -90,10 +91,12 @@ class CardTableBarrierSet: public BarrierSet {
// at the address "start", which may not necessarily be HeapWord-aligned
inline void write_ref_array(HeapWord* start, size_t count);
- CardTable* card_table() const { return _card_table; }
+ CardTable* card_table() { return _card_table.load_relaxed(); }
+ CardTable* card_table() const { return _card_table.load_relaxed(); }
+
CardValue* card_table_base_const() const {
assert(UseSerialGC || UseParallelGC, "Only these GCs have constant card table base");
- return _card_table->byte_map_base();
+ return card_table()->byte_map_base();
}
virtual void on_slowpath_allocation_exit(JavaThread* thread, oop new_obj);
diff --git a/src/hotspot/share/gc/shared/cardTableBarrierSet.inline.hpp b/src/hotspot/share/gc/shared/cardTableBarrierSet.inline.hpp
index ea539a70be5..f60a7f47a19 100644
--- a/src/hotspot/share/gc/shared/cardTableBarrierSet.inline.hpp
+++ b/src/hotspot/share/gc/shared/cardTableBarrierSet.inline.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2026, 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
@@ -35,7 +35,7 @@
template
inline void CardTableBarrierSet::write_ref_field_post(T* field) {
- volatile CardValue* byte = _card_table->byte_for(field);
+ volatile CardValue* byte = card_table()->byte_for(field);
*byte = CardTable::dirty_card_val();
}
diff --git a/src/hotspot/share/gc/shared/gc_globals.hpp b/src/hotspot/share/gc/shared/gc_globals.hpp
index d08e95378f7..6aa1fcf066b 100644
--- a/src/hotspot/share/gc/shared/gc_globals.hpp
+++ b/src/hotspot/share/gc/shared/gc_globals.hpp
@@ -261,6 +261,7 @@
develop(uintx, ObjArrayMarkingStride, 2048, \
"Number of object array elements to push onto the marking stack " \
"before pushing a continuation entry") \
+ range(1, INT_MAX/2) \
\
product_pd(bool, NeverActAsServerClassMachine, \
"(Deprecated) Never act like a server-class machine") \
diff --git a/src/hotspot/share/gc/shared/preservedMarks.cpp b/src/hotspot/share/gc/shared/preservedMarks.cpp
index 1c9f1c82e6f..605b7afe072 100644
--- a/src/hotspot/share/gc/shared/preservedMarks.cpp
+++ b/src/hotspot/share/gc/shared/preservedMarks.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2026, 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
@@ -29,7 +29,7 @@
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
#include "oops/oop.inline.hpp"
-#include "runtime/atomicAccess.hpp"
+#include "runtime/atomic.hpp"
#include "utilities/macros.hpp"
void PreservedMarks::restore() {
@@ -55,15 +55,6 @@ void PreservedMarks::adjust_during_full_gc() {
}
}
-void PreservedMarks::restore_and_increment(volatile size_t* const total_size_addr) {
- const size_t stack_size = size();
- restore();
- // Only do the atomic add if the size is > 0.
- if (stack_size > 0) {
- AtomicAccess::add(total_size_addr, stack_size);
- }
-}
-
#ifndef PRODUCT
void PreservedMarks::assert_empty() {
assert(_stack.is_empty(), "stack expected to be empty, size = %zu",
@@ -93,7 +84,7 @@ void PreservedMarksSet::init(uint num) {
class RestorePreservedMarksTask : public WorkerTask {
PreservedMarksSet* const _preserved_marks_set;
SequentialSubTasksDone _sub_tasks;
- volatile size_t _total_size;
+ Atomic _total_size;
#ifdef ASSERT
size_t _total_size_before;
#endif // ASSERT
@@ -102,7 +93,12 @@ class RestorePreservedMarksTask : public WorkerTask {
void work(uint worker_id) override {
uint task_id = 0;
while (_sub_tasks.try_claim_task(task_id)) {
- _preserved_marks_set->get(task_id)->restore_and_increment(&_total_size);
+ PreservedMarks* next = _preserved_marks_set->get(task_id);
+ size_t num_restored = next->size();
+ next->restore();
+ if (num_restored > 0) {
+ _total_size.add_then_fetch(num_restored);
+ }
}
}
@@ -121,9 +117,11 @@ class RestorePreservedMarksTask : public WorkerTask {
}
~RestorePreservedMarksTask() {
- assert(_total_size == _total_size_before, "total_size = %zu before = %zu", _total_size, _total_size_before);
- size_t mem_size = _total_size * (sizeof(oop) + sizeof(markWord));
- log_trace(gc)("Restored %zu marks, occupying %zu %s", _total_size,
+ size_t local_total_size = _total_size.load_relaxed();
+
+ assert(local_total_size == _total_size_before, "total_size = %zu before = %zu", local_total_size, _total_size_before);
+ size_t mem_size = local_total_size * (sizeof(oop) + sizeof(markWord));
+ log_trace(gc)("Restored %zu marks, occupying %zu %s", local_total_size,
byte_size_in_proper_unit(mem_size),
proper_unit_for_byte_size(mem_size));
}
diff --git a/src/hotspot/share/gc/shared/preservedMarks.hpp b/src/hotspot/share/gc/shared/preservedMarks.hpp
index 10f75116524..3bbbd335011 100644
--- a/src/hotspot/share/gc/shared/preservedMarks.hpp
+++ b/src/hotspot/share/gc/shared/preservedMarks.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2016, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2016, 2026, 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
@@ -59,8 +59,7 @@ class PreservedMarks {
size_t size() const { return _stack.size(); }
inline void push_if_necessary(oop obj, markWord m);
inline void push_always(oop obj, markWord m);
- // Iterate over the stack, restore all preserved marks, and
- // reclaim the memory taken up by the stack segments.
+ // Restore all preserved marks, and reclaim the memory taken up by the stack segments.
void restore();
// Adjust the preserved mark according to its
@@ -71,8 +70,6 @@ class PreservedMarks {
// to their forwarding location stored in the mark.
void adjust_during_full_gc();
- void restore_and_increment(volatile size_t* const _total_size_addr);
-
// Assert the stack is empty and has no cached segments.
void assert_empty() PRODUCT_RETURN;
diff --git a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp
index df7d8f7b38d..0371ed2c73b 100644
--- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp
+++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, 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,7 +30,6 @@
#include "logging/logStream.hpp"
#include "memory/allocation.inline.hpp"
#include "memory/resourceArea.hpp"
-#include "runtime/atomicAccess.hpp"
#define ASSERT_REF_TYPE(ref_type) assert((ref_type) >= REF_SOFT && (ref_type) <= REF_PHANTOM, \
"Invariant (%d)", (int)ref_type)
@@ -196,7 +195,7 @@ void ReferenceProcessorPhaseTimes::reset() {
_soft_weak_final_refs_phase_worker_time_sec->reset();
for (int i = 0; i < number_of_subclasses_of_ref; i++) {
- _ref_dropped[i] = 0;
+ _ref_dropped[i].store_relaxed(0);
_ref_discovered[i] = 0;
}
@@ -214,7 +213,7 @@ ReferenceProcessorPhaseTimes::~ReferenceProcessorPhaseTimes() {
void ReferenceProcessorPhaseTimes::add_ref_dropped(ReferenceType ref_type, size_t count) {
ASSERT_REF_TYPE(ref_type);
- AtomicAccess::add(&_ref_dropped[ref_type_2_index(ref_type)], count, memory_order_relaxed);
+ _ref_dropped[ref_type_2_index(ref_type)].add_then_fetch(count, memory_order_relaxed);
}
void ReferenceProcessorPhaseTimes::set_ref_discovered(ReferenceType ref_type, size_t count) {
@@ -271,7 +270,7 @@ void ReferenceProcessorPhaseTimes::print_reference(ReferenceType ref_type, uint
int const ref_type_index = ref_type_2_index(ref_type);
size_t discovered = _ref_discovered[ref_type_index];
- size_t dropped = _ref_dropped[ref_type_index];
+ size_t dropped = _ref_dropped[ref_type_index].load_relaxed();
assert(discovered >= dropped, "invariant");
size_t processed = discovered - dropped;
diff --git a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp
index 16691452ef4..82d26902bce 100644
--- a/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp
+++ b/src/hotspot/share/gc/shared/referenceProcessorPhaseTimes.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, 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,6 +30,7 @@
#include "gc/shared/workerDataArray.hpp"
#include "memory/allocation.hpp"
#include "memory/referenceType.hpp"
+#include "runtime/atomic.hpp"
#include "utilities/ticks.hpp"
class DiscoveredList;
@@ -52,7 +53,7 @@ class ReferenceProcessorPhaseTimes : public CHeapObj {
// Total spent time for reference processing.
double _total_time_ms;
- size_t _ref_dropped[number_of_subclasses_of_ref];
+ Atomic _ref_dropped[number_of_subclasses_of_ref];
size_t _ref_discovered[number_of_subclasses_of_ref];
bool _processing_is_mt;
diff --git a/src/hotspot/share/gc/shared/space.cpp b/src/hotspot/share/gc/shared/space.cpp
index 011a0f5cfd8..84ba21527fd 100644
--- a/src/hotspot/share/gc/shared/space.cpp
+++ b/src/hotspot/share/gc/shared/space.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, 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,7 +30,6 @@
#include "memory/iterator.inline.hpp"
#include "memory/universe.hpp"
#include "oops/oop.inline.hpp"
-#include "runtime/atomicAccess.hpp"
#include "runtime/java.hpp"
#include "runtime/safepoint.hpp"
#include "utilities/align.hpp"
@@ -69,7 +68,7 @@ void ContiguousSpace::clear(bool mangle_space) {
#ifndef PRODUCT
void ContiguousSpace::mangle_unused_area() {
- mangle_unused_area(MemRegion(_top, _end));
+ mangle_unused_area(MemRegion(top(), _end));
}
void ContiguousSpace::mangle_unused_area(MemRegion mr) {
@@ -128,11 +127,8 @@ inline HeapWord* ContiguousSpace::par_allocate_impl(size_t size) {
HeapWord* obj = top();
if (pointer_delta(end(), obj) >= size) {
HeapWord* new_top = obj + size;
- HeapWord* result = AtomicAccess::cmpxchg(top_addr(), obj, new_top);
- // result can be one of two:
- // the old top value: the exchange succeeded
- // otherwise: the new value of the top is returned.
- if (result == obj) {
+ // Retry if we did not successfully updated the top pointers.
+ if (_top.compare_set(obj, new_top)) {
assert(is_object_aligned(obj) && is_object_aligned(new_top), "checking alignment");
return obj;
}
diff --git a/src/hotspot/share/gc/shared/space.hpp b/src/hotspot/share/gc/shared/space.hpp
index 7f2887275b3..05b22f680bf 100644
--- a/src/hotspot/share/gc/shared/space.hpp
+++ b/src/hotspot/share/gc/shared/space.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1997, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2026, 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
@@ -32,6 +32,7 @@
#include "memory/iterator.hpp"
#include "memory/memRegion.hpp"
#include "oops/markWord.hpp"
+#include "runtime/atomic.hpp"
#include "runtime/mutexLocker.hpp"
#include "utilities/align.hpp"
#include "utilities/macros.hpp"
@@ -53,7 +54,7 @@ class ContiguousSpace: public CHeapObj {
private:
HeapWord* _bottom;
HeapWord* _end;
- HeapWord* _top;
+ Atomic _top;
// Allocation helpers (return null if full).
inline HeapWord* allocate_impl(size_t word_size);
@@ -64,12 +65,12 @@ class ContiguousSpace: public CHeapObj {
// Accessors
HeapWord* bottom() const { return _bottom; }
- HeapWord* end() const { return _end; }
- HeapWord* top() const { return _top; }
+ HeapWord* end() const { return _end; }
+ HeapWord* top() const { return _top.load_relaxed(); }
void set_bottom(HeapWord* value) { _bottom = value; }
void set_end(HeapWord* value) { _end = value; }
- void set_top(HeapWord* value) { _top = value; }
+ void set_top(HeapWord* value) { _top.store_relaxed(value); }
// Testers
bool is_empty() const { return used() == 0; }
@@ -121,9 +122,6 @@ class ContiguousSpace: public CHeapObj {
// Iteration
void object_iterate(ObjectClosure* blk);
- // Addresses for inlined allocation
- HeapWord** top_addr() { return &_top; }
-
// Debugging
void verify() const;
};
diff --git a/src/hotspot/share/gc/shared/vmStructs_gc.hpp b/src/hotspot/share/gc/shared/vmStructs_gc.hpp
index db968e28f67..9348fd980f4 100644
--- a/src/hotspot/share/gc/shared/vmStructs_gc.hpp
+++ b/src/hotspot/share/gc/shared/vmStructs_gc.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2026, 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
@@ -48,6 +48,7 @@
#if INCLUDE_ZGC
#include "gc/z/vmStructs_z.hpp"
#endif
+#include "runtime/atomic.hpp"
#define VM_STRUCTS_GC(nonstatic_field, \
volatile_static_field, \
@@ -88,7 +89,7 @@
nonstatic_field(CardTable, _byte_map_size, const size_t) \
nonstatic_field(CardTable, _byte_map, CardTable::CardValue*) \
nonstatic_field(CardTable, _byte_map_base, CardTable::CardValue*) \
- nonstatic_field(CardTableBarrierSet, _card_table, CardTable*) \
+ nonstatic_field(CardTableBarrierSet, _card_table, Atomic) \
\
static_field(CollectedHeap, _lab_alignment_reserve, size_t) \
nonstatic_field(CollectedHeap, _reserved, MemRegion) \
@@ -97,7 +98,7 @@
\
nonstatic_field(ContiguousSpace, _bottom, HeapWord*) \
nonstatic_field(ContiguousSpace, _end, HeapWord*) \
- nonstatic_field(ContiguousSpace, _top, HeapWord*) \
+ nonstatic_field(ContiguousSpace, _top, Atomic) \
\
nonstatic_field(MemRegion, _start, HeapWord*) \
nonstatic_field(MemRegion, _word_size, size_t)
@@ -149,6 +150,7 @@
\
declare_toplevel_type(BarrierSet*) \
declare_toplevel_type(CardTable*) \
+ declare_toplevel_type(Atomic) \
declare_toplevel_type(CardTable*const) \
declare_toplevel_type(CardTableBarrierSet*) \
declare_toplevel_type(CardTableBarrierSet**) \
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp
index 46d9f19d35f..7a8bd55c795 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.cpp
@@ -68,9 +68,9 @@ ShenandoahAdaptiveHeuristics::ShenandoahAdaptiveHeuristics(ShenandoahSpaceInfo*
ShenandoahAdaptiveHeuristics::~ShenandoahAdaptiveHeuristics() {}
-size_t ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) {
+void ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) {
size_t garbage_threshold = ShenandoahHeapRegion::region_size_bytes() * ShenandoahGarbageThreshold / 100;
// The logic for cset selection in adaptive is as follows:
@@ -124,7 +124,6 @@ size_t ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata(Shena
cur_garbage = new_garbage;
}
}
- return 0;
}
void ShenandoahAdaptiveHeuristics::record_cycle_start() {
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp
index c4fdf819391..9b7824a50d7 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp
@@ -33,7 +33,7 @@
#include "utilities/numberSeq.hpp"
/**
- * ShenanoahAllocationRate maintains a truncated history of recently sampled allocation rates for the purpose of providing
+ * ShenandoahAllocationRate maintains a truncated history of recently sampled allocation rates for the purpose of providing
* informed estimates of current and future allocation rates based on weighted averages and standard deviations of the
* truncated history. More recently sampled allocations are weighted more heavily than older samples when computing
* averages and standard deviations.
@@ -108,20 +108,20 @@ class ShenandoahAdaptiveHeuristics : public ShenandoahHeuristics {
virtual ~ShenandoahAdaptiveHeuristics();
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
RegionData* data, size_t size,
size_t actual_free) override;
- virtual void record_cycle_start() override;
- virtual void record_success_concurrent() override;
- virtual void record_degenerated() override;
- virtual void record_success_full() override;
+ void record_cycle_start() override;
+ void record_success_concurrent() override;
+ void record_degenerated() override;
+ void record_success_full() override;
- virtual bool should_start_gc() override;
+ bool should_start_gc() override;
- virtual const char* name() override { return "Adaptive"; }
- virtual bool is_diagnostic() override { return false; }
- virtual bool is_experimental() override { return false; }
+ const char* name() override { return "Adaptive"; }
+ bool is_diagnostic() override { return false; }
+ bool is_experimental() override { return false; }
private:
// These are used to adjust the margin of error and the spike threshold
@@ -185,7 +185,7 @@ class ShenandoahAdaptiveHeuristics : public ShenandoahHeuristics {
// in the generational case. Controlled by global flag ShenandoahMinFreeThreshold.
size_t min_free_threshold();
- inline void accept_trigger_with_type(Trigger trigger_type) {
+ void accept_trigger_with_type(Trigger trigger_type) {
_last_trigger = trigger_type;
ShenandoahHeuristics::accept_trigger();
}
@@ -193,7 +193,7 @@ class ShenandoahAdaptiveHeuristics : public ShenandoahHeuristics {
public:
// Sample the allocation rate at GC trigger time if possible. Return the number of allocated bytes that were
// not accounted for in the sample. This must be called before resetting bytes allocated since gc start.
- virtual size_t force_alloc_rate_sample(size_t bytes_allocated) override {
+ size_t force_alloc_rate_sample(size_t bytes_allocated) override {
size_t unaccounted_bytes;
_allocation_rate.force_sample(bytes_allocated, unaccounted_bytes);
return unaccounted_bytes;
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp
index 990b59ec853..a833e39631c 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.cpp
@@ -39,16 +39,15 @@ ShenandoahAggressiveHeuristics::ShenandoahAggressiveHeuristics(ShenandoahSpaceIn
SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahEvacReserveOverflow);
}
-size_t ShenandoahAggressiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t free) {
+void ShenandoahAggressiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t free) {
for (size_t idx = 0; idx < size; idx++) {
ShenandoahHeapRegion* r = data[idx].get_region();
if (r->garbage() > 0) {
cset->add_region(r);
}
}
- return 0;
}
bool ShenandoahAggressiveHeuristics::should_start_gc() {
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp
index 25c8635489f..9dc88a61bf5 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahAggressiveHeuristics.hpp
@@ -35,17 +35,17 @@ class ShenandoahAggressiveHeuristics : public ShenandoahHeuristics {
public:
ShenandoahAggressiveHeuristics(ShenandoahSpaceInfo* space_info);
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t free);
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t free) override;
- virtual bool should_start_gc();
+ bool should_start_gc() override;
- virtual bool should_unload_classes();
+ bool should_unload_classes() override;
- virtual const char* name() { return "Aggressive"; }
- virtual bool is_diagnostic() { return true; }
- virtual bool is_experimental() { return false; }
+ const char* name() override { return "Aggressive"; }
+ bool is_diagnostic() override { return true; }
+ bool is_experimental() override { return false; }
};
#endif // SHARE_GC_SHENANDOAH_HEURISTICS_SHENANDOAHAGGRESSIVEHEURISTICS_HPP
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp
index 09a8394a4b1..28673b28612 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.cpp
@@ -76,9 +76,9 @@ bool ShenandoahCompactHeuristics::should_start_gc() {
return ShenandoahHeuristics::should_start_gc();
}
-size_t ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) {
+void ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) {
// Do not select too large CSet that would overflow the available free space
size_t max_cset = actual_free * 3 / 4;
@@ -97,5 +97,4 @@ size_t ShenandoahCompactHeuristics::choose_collection_set_from_regiondata(Shenan
cset->add_region(r);
}
}
- return 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp
index 4988d5d495d..a32c9c88478 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahCompactHeuristics.hpp
@@ -33,17 +33,17 @@
*/
class ShenandoahCompactHeuristics : public ShenandoahHeuristics {
public:
- ShenandoahCompactHeuristics(ShenandoahSpaceInfo* space_info);
+ explicit ShenandoahCompactHeuristics(ShenandoahSpaceInfo* space_info);
- virtual bool should_start_gc();
+ bool should_start_gc() override;
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free);
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) override;
- virtual const char* name() { return "Compact"; }
- virtual bool is_diagnostic() { return false; }
- virtual bool is_experimental() { return false; }
+ const char* name() override { return "Compact"; }
+ bool is_diagnostic() override { return false; }
+ bool is_experimental() override { return false; }
};
#endif // SHARE_GC_SHENANDOAH_HEURISTICS_SHENANDOAHCOMPACTHEURISTICS_HPP
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp
index ee315ce5c7e..80e6decf57d 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.cpp
@@ -25,19 +25,205 @@
#include "gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp"
#include "gc/shenandoah/shenandoahCollectionSet.hpp"
+#include "gc/shenandoah/shenandoahCollectionSetPreselector.hpp"
#include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
#include "gc/shenandoah/shenandoahGeneration.hpp"
#include "gc/shenandoah/shenandoahGenerationalHeap.inline.hpp"
#include "gc/shenandoah/shenandoahHeapRegion.inline.hpp"
#include "gc/shenandoah/shenandoahOldGeneration.hpp"
#include "gc/shenandoah/shenandoahTrace.hpp"
+#include "gc/shenandoah/shenandoahYoungGeneration.hpp"
#include "logging/log.hpp"
+#include "utilities/quickSort.hpp"
+
+using idx_t = ShenandoahSimpleBitMap::idx_t;
+
+typedef struct {
+ ShenandoahHeapRegion* _region;
+ size_t _live_data;
+} AgedRegionData;
+
+static int compare_by_aged_live(AgedRegionData a, AgedRegionData b) {
+ if (a._live_data < b._live_data)
+ return -1;
+ if (a._live_data > b._live_data)
+ return 1;
+ return 0;
+}
+
+inline void assert_no_in_place_promotions() {
+#ifdef ASSERT
+ class ShenandoahNoInPlacePromotions : public ShenandoahHeapRegionClosure {
+ public:
+ void heap_region_do(ShenandoahHeapRegion *r) override {
+ assert(r->get_top_before_promote() == nullptr,
+ "Region %zu should not be ready for in-place promotion", r->index());
+ }
+ } cl;
+ ShenandoahHeap::heap()->heap_region_iterate(&cl);
+#endif
+}
ShenandoahGenerationalHeuristics::ShenandoahGenerationalHeuristics(ShenandoahGeneration* generation)
- : ShenandoahAdaptiveHeuristics(generation), _generation(generation) {
+ : ShenandoahAdaptiveHeuristics(generation), _generation(generation), _add_regions_to_old(0) {
+}
+
+void ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
+ ShenandoahHeap* heap = ShenandoahHeap::heap();
+
+ _add_regions_to_old = 0;
+
+ // Seed the collection set with resource area-allocated
+ // preselected regions, which are removed when we exit this scope.
+ ShenandoahCollectionSetPreselector preselector(collection_set, heap->num_regions());
+
+ // Find the amount that will be promoted, regions that will be promoted in
+ // place, and preselected older regions that will be promoted by evacuation.
+ compute_evacuation_budgets(heap);
+
+ // Choose the collection set, including the regions preselected above for promotion into the old generation.
+ filter_regions(collection_set);
+
+ // Even if collection_set->is_empty(), we want to adjust budgets, making reserves available to mutator.
+ adjust_evacuation_budgets(heap, collection_set);
+
+ if (_generation->is_global()) {
+ // We have just chosen a collection set for a global cycle. The mark bitmap covering old regions is complete, so
+ // the remembered set scan can use that to avoid walking into garbage. When the next old mark begins, we will
+ // use the mark bitmap to make the old regions parsable by coalescing and filling any unmarked objects. Thus,
+ // we prepare for old collections by remembering which regions are old at this time. Note that any objects
+ // promoted into old regions will be above TAMS, and so will be considered marked. However, free regions that
+ // become old after this point will not be covered correctly by the mark bitmap, so we must be careful not to
+ // coalesce those regions. Only the old regions which are not part of the collection set at this point are
+ // eligible for coalescing. As implemented now, this has the side effect of possibly initiating mixed-evacuations
+ // after a global cycle for old regions that were not included in this collection set.
+ heap->old_generation()->prepare_for_mixed_collections_after_global_gc();
+ }
+}
+
+void ShenandoahGenerationalHeuristics::compute_evacuation_budgets(ShenandoahHeap* const heap) {
+ shenandoah_assert_generational();
+
+ ShenandoahOldGeneration* const old_generation = heap->old_generation();
+ ShenandoahYoungGeneration* const young_generation = heap->young_generation();
+ const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes();
+
+ // During initialization and phase changes, it is more likely that fewer objects die young and old-gen
+ // memory is not yet full (or is in the process of being replaced). During these times especially, it
+ // is beneficial to loan memory from old-gen to young-gen during the evacuation and update-refs phases
+ // of execution.
+
+ // Calculate EvacuationReserve before PromotionReserve. Evacuation is more critical than promotion.
+ // If we cannot evacuate old-gen, we will not be able to reclaim old-gen memory. Promotions are less
+ // critical. If we cannot promote, there may be degradation of young-gen memory because old objects
+ // accumulate there until they can be promoted. This increases the young-gen marking and evacuation work.
+
+ // First priority is to reclaim the easy garbage out of young-gen.
+
+ // maximum_young_evacuation_reserve is upper bound on memory to be evacuated into young Collector Reserve. This is
+ // bounded at the end of previous GC cycle, based on available memory and balancing of evacuation to old and young.
+ size_t maximum_young_evacuation_reserve = young_generation->get_evacuation_reserve();
+
+ // maximum_old_evacuation_reserve is an upper bound on memory evacuated from old and evacuated to old (promoted),
+ // clamped by the old generation space available.
+ //
+ // Here's the algebra.
+ // Let SOEP = ShenandoahOldEvacPercent,
+ // OE = old evac,
+ // YE = young evac, and
+ // TE = total evac = OE + YE
+ // By definition:
+ // SOEP/100 = OE/TE
+ // = OE/(OE+YE)
+ // => SOEP/(100-SOEP) = OE/((OE+YE)-OE) // componendo-dividendo: If a/b = c/d, then a/(b-a) = c/(d-c)
+ // = OE/YE
+ // => OE = YE*SOEP/(100-SOEP)
+
+ // We have to be careful in the event that SOEP is set to 100 by the user.
+ assert(ShenandoahOldEvacPercent <= 100, "Error");
+ const size_t old_available = old_generation->available();
+ const size_t maximum_old_evacuation_reserve = (ShenandoahOldEvacPercent == 100) ?
+ old_available : MIN2((maximum_young_evacuation_reserve * ShenandoahOldEvacPercent) / (100 - ShenandoahOldEvacPercent),
+ old_available);
+
+ // In some cases, maximum_old_reserve < old_available (when limited by ShenandoahOldEvacPercent)
+ // This limit affects mixed evacuations, but does not affect promotions.
+
+ // Second priority is to reclaim garbage out of old-gen if there are old-gen collection candidates. Third priority
+ // is to promote as much as we have room to promote. However, if old-gen memory is in short supply, this means young
+ // GC is operating under "duress" and was unable to transfer the memory that we would normally expect. In this case,
+ // old-gen will refrain from compacting itself in order to allow a quicker young-gen cycle (by avoiding the update-refs
+ // through ALL of old-gen). If there is some memory available in old-gen, we will use this for promotions as promotions
+ // do not add to the update-refs burden of GC.
+
+ size_t old_evacuation_reserve, old_promo_reserve;
+ if (_generation->is_global()) {
+ // Global GC is typically triggered by user invocation of System.gc(), and typically indicates that there is lots
+ // of garbage to be reclaimed because we are starting a new phase of execution. Marking for global GC may take
+ // significantly longer than typical young marking because we must mark through all old objects. To expedite
+ // evacuation and update-refs, we give emphasis to reclaiming garbage first, wherever that garbage is found.
+ // Global GC will adjust generation sizes to accommodate the collection set it chooses.
+
+ // Use remnant of old_available to hold promotions.
+ old_promo_reserve = old_available - maximum_old_evacuation_reserve;
+
+ // Dedicate all available old memory to old_evacuation reserve. This may be small, because old-gen is only
+ // expanded based on an existing mixed evacuation workload at the end of the previous GC cycle. We'll expand
+ // the budget for evacuation of old during GLOBAL cset selection.
+ old_evacuation_reserve = maximum_old_evacuation_reserve;
+ } else if (old_generation->has_unprocessed_collection_candidates()) {
+ // We reserved all old-gen memory at end of previous GC to hold anticipated evacuations to old-gen. If this is
+ // mixed evacuation, reserve all of this memory for compaction of old-gen and do not promote. Prioritize compaction
+ // over promotion in order to defragment OLD so that it will be better prepared to efficiently receive promoted memory.
+ old_evacuation_reserve = maximum_old_evacuation_reserve;
+ old_promo_reserve = old_available - maximum_old_evacuation_reserve;
+ } else {
+ // Make all old-evacuation memory for promotion, but if we can't use it all for promotion, we'll allow some evacuation.
+ old_evacuation_reserve = old_available - maximum_old_evacuation_reserve;
+ old_promo_reserve = maximum_old_evacuation_reserve;
+ }
+ assert(old_evacuation_reserve <= old_available, "Error");
+
+
+ // We see too many old-evacuation failures if we force ourselves to evacuate into regions that are not initially empty.
+ // So we limit the old-evacuation reserve to unfragmented memory. Even so, old-evacuation is free to fill in nooks and
+ // crannies within existing partially used regions and it generally tries to do so.
+ const size_t old_free_unfragmented = old_generation->free_unaffiliated_regions() * region_size_bytes;
+ if (old_evacuation_reserve > old_free_unfragmented) {
+ const size_t delta = old_evacuation_reserve - old_free_unfragmented;
+ old_evacuation_reserve -= delta;
+ // Let promo consume fragments of old-gen memory
+ old_promo_reserve += delta;
+ }
+
+ // If is_global(), we let garbage-first heuristic determine cset membership. Otherwise, we give priority
+ // to tenurable regions by preselecting regions for promotion by evacuation (obtaining the live data to seed promoted_reserve).
+ // This also identifies regions that will be promoted in place. These use the tenuring threshold.
+ const size_t consumed_by_advance_promotion = select_aged_regions(_generation->is_global()? 0: old_promo_reserve);
+ assert(consumed_by_advance_promotion <= old_promo_reserve, "Do not promote more than budgeted");
+
+ // The young evacuation reserve can be no larger than young_unaffiliated. Planning to evacuate into partially consumed
+ // young regions is doomed to failure if any of those partially consumed regions is selected for the collection set.
+ size_t young_unaffiliated = young_generation->free_unaffiliated_regions() * region_size_bytes;
+
+ // If any regions have been selected for promotion in place, this has the effect of decreasing available within mutator
+ // and collector partitions, due to padding of remnant memory within each promoted in place region. This will affect
+ // young_evacuation_reserve but not old_evacuation_reserve or consumed_by_advance_promotion. So recompute.
+ size_t young_evacuation_reserve = MIN2(maximum_young_evacuation_reserve, young_unaffiliated);
+
+ // Note that unused old_promo_reserve might not be entirely consumed_by_advance_promotion. Do not transfer this
+ // to old_evacuation_reserve because this memory is likely very fragmented, and we do not want to increase the likelihood
+ // of old evacuation failure. Leave this memory in the promoted reserve as it may be targeted by opportunistic
+ // promotions (found during evacuation of young regions).
+ young_generation->set_evacuation_reserve(young_evacuation_reserve);
+ old_generation->set_evacuation_reserve(old_evacuation_reserve);
+ old_generation->set_promoted_reserve(old_promo_reserve);
+
+ // There is no need to expand OLD because all memory used here was set aside at end of previous GC, except in the
+ // case of a GLOBAL gc. During choose_collection_set() of GLOBAL, old will be expanded on demand.
}
-size_t ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
+void ShenandoahGenerationalHeuristics::filter_regions(ShenandoahCollectionSet* collection_set) {
assert(collection_set->is_empty(), "Must be empty");
auto heap = ShenandoahGenerationalHeap::heap();
@@ -170,10 +356,9 @@ size_t ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollect
size_t immediate_percent = (total_garbage == 0) ? 0 : (immediate_garbage * 100 / total_garbage);
bool doing_promote_in_place = (humongous_regions_promoted + regular_regions_promoted_in_place > 0);
- size_t add_regions_to_old = 0;
if (doing_promote_in_place || (preselected_candidates > 0) || (immediate_percent <= ShenandoahImmediateThreshold)) {
// Call the subclasses to add young-gen regions into the collection set.
- add_regions_to_old = choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
+ choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
}
if (collection_set->has_old_regions()) {
@@ -190,9 +375,359 @@ size_t ShenandoahGenerationalHeuristics::choose_collection_set(ShenandoahCollect
regular_regions_promoted_free,
immediate_regions,
immediate_garbage);
- return add_regions_to_old;
}
+// Preselect for inclusion into the collection set all regions whose age is at or above tenure age and for which the
+// garbage percentage exceeds a dynamically adjusted threshold (known as the old-garbage threshold percentage). We
+// identify these regions by setting the appropriate entry of the collection set's preselected regions array to true.
+// All entries are initialized to false before calling this function.
+//
+// During the subsequent selection of the collection set, we give priority to these promotion set candidates.
+// Without this prioritization, we found that the aged regions tend to be ignored because they typically have
+// much less garbage and much more live data than the recently allocated "eden" regions. When aged regions are
+// repeatedly excluded from the collection set, the amount of live memory within the young generation tends to
+// accumulate and this has the undesirable side effect of causing young-generation collections to require much more
+// CPU and wall-clock time.
+//
+// A second benefit of treating aged regions differently than other regions during collection set selection is
+// that this allows us to more accurately budget memory to hold the results of evacuation. Memory for evacuation
+// of aged regions must be reserved in the old generation. Memory for evacuation of all other regions must be
+// reserved in the young generation.
+size_t ShenandoahGenerationalHeuristics::select_aged_regions(const size_t old_promotion_reserve) {
+
+ // There should be no regions configured for subsequent in-place-promotions carried over from the previous cycle.
+ assert_no_in_place_promotions();
+
+ auto const heap = ShenandoahGenerationalHeap::heap();
+ ShenandoahFreeSet* free_set = heap->free_set();
+ bool* const candidate_regions_for_promotion_by_copy = heap->collection_set()->preselected_regions();
+ ShenandoahMarkingContext* const ctx = heap->marking_context();
+
+ const size_t old_garbage_threshold =
+ (ShenandoahHeapRegion::region_size_bytes() * heap->old_generation()->heuristics()->get_old_garbage_threshold()) / 100;
+
+ const size_t pip_used_threshold = (ShenandoahHeapRegion::region_size_bytes() * ShenandoahGenerationalMinPIPUsage) / 100;
+
+ size_t promo_potential = 0;
+ size_t candidates = 0;
+
+ // Tracks the padding of space above top in regions eligible for promotion in place
+ size_t promote_in_place_pad = 0;
+
+ // Sort the promotion-eligible regions in order of increasing live-data-bytes so that we can first reclaim regions that require
+ // less evacuation effort. This prioritizes garbage first, expanding the allocation pool early before we reclaim regions that
+ // have more live data.
+ const idx_t num_regions = heap->num_regions();
+
+ ResourceMark rm;
+ AgedRegionData* sorted_regions = NEW_RESOURCE_ARRAY(AgedRegionData, num_regions);
+
+ ShenandoahFreeSet* freeset = heap->free_set();
+
+ // Any region that is to be promoted in place needs to be retired from its Collector or Mutator partition.
+ idx_t pip_low_collector_idx = freeset->max_regions();
+ idx_t pip_high_collector_idx = -1;
+ idx_t pip_low_mutator_idx = freeset->max_regions();
+ idx_t pip_high_mutator_idx = -1;
+ size_t collector_regions_to_pip = 0;
+ size_t mutator_regions_to_pip = 0;
+
+ size_t pip_mutator_regions = 0;
+ size_t pip_collector_regions = 0;
+ size_t pip_mutator_bytes = 0;
+ size_t pip_collector_bytes = 0;
+
+ for (idx_t i = 0; i < num_regions; i++) {
+ ShenandoahHeapRegion* const r = heap->get_region(i);
+ if (r->is_empty() || !r->has_live() || !r->is_young() || !r->is_regular()) {
+ // skip over regions that aren't regular young with some live data
+ continue;
+ }
+ if (heap->is_tenurable(r)) {
+ if ((r->garbage() < old_garbage_threshold) && (r->used() > pip_used_threshold)) {
+ // We prefer to promote this region in place because it has a small amount of garbage and a large usage.
+ HeapWord* tams = ctx->top_at_mark_start(r);
+ HeapWord* original_top = r->top();
+ if (!heap->is_concurrent_old_mark_in_progress() && tams == original_top) {
+ // No allocations from this region have been made during concurrent mark. It meets all the criteria
+ // for in-place-promotion. Though we only need the value of top when we fill the end of the region,
+ // we use this field to indicate that this region should be promoted in place during the evacuation
+ // phase.
+ r->save_top_before_promote();
+ size_t remnant_bytes = r->free();
+ size_t remnant_words = remnant_bytes / HeapWordSize;
+ assert(ShenandoahHeap::min_fill_size() <= PLAB::min_size(), "Implementation makes invalid assumptions");
+ if (remnant_words >= ShenandoahHeap::min_fill_size()) {
+ ShenandoahHeap::fill_with_object(original_top, remnant_words);
+ // Fill the remnant memory within this region to assure no allocations prior to promote in place. Otherwise,
+ // newly allocated objects will not be parsable when promote in place tries to register them. Furthermore, any
+ // new allocations would not necessarily be eligible for promotion. This addresses both issues.
+ r->set_top(r->end());
+ // The region r is either in the Mutator or Collector partition if remnant_words > heap()->plab_min_size.
+ // Otherwise, the region is in the NotFree partition.
+ ShenandoahFreeSetPartitionId p = free_set->membership(i);
+ if (p == ShenandoahFreeSetPartitionId::Mutator) {
+ mutator_regions_to_pip++;
+ if (i < pip_low_mutator_idx) {
+ pip_low_mutator_idx = i;
+ }
+ if (i > pip_high_mutator_idx) {
+ pip_high_mutator_idx = i;
+ }
+ pip_mutator_regions++;
+ pip_mutator_bytes += remnant_bytes;
+ } else if (p == ShenandoahFreeSetPartitionId::Collector) {
+ collector_regions_to_pip++;
+ if (i < pip_low_collector_idx) {
+ pip_low_collector_idx = i;
+ }
+ if (i > pip_high_collector_idx) {
+ pip_high_collector_idx = i;
+ }
+ pip_collector_regions++;
+ pip_collector_bytes += remnant_bytes;
+ } else {
+ assert((p == ShenandoahFreeSetPartitionId::NotFree) && (remnant_words < heap->plab_min_size()),
+ "Should be NotFree if not in Collector or Mutator partitions");
+ // In this case, the memory is already counted as used and the region has already been retired. There is
+ // no need for further adjustments to used. Further, the remnant memory for this region will not be
+ // unallocated or made available to OldCollector after pip.
+ remnant_bytes = 0;
+ }
+ promote_in_place_pad += remnant_bytes;
+ free_set->prepare_to_promote_in_place(i, remnant_bytes);
+ } else {
+ // Since the remnant is so small that this region has already been retired, we don't have to worry about any
+ // accidental allocations occurring within this region before the region is promoted in place.
+
+ // This region was already not in the Collector or Mutator set, so no need to remove it.
+ assert(free_set->membership(i) == ShenandoahFreeSetPartitionId::NotFree, "sanity");
+ }
+ }
+ // Else, we do not promote this region (either in place or by copy) because it has received new allocations.
+
+ // During evacuation, we exclude from promotion regions for which age > tenure threshold, garbage < garbage-threshold,
+ // used > pip_used_threshold, and get_top_before_promote() != tams
+ } else {
+ // Record this promotion-eligible candidate region. After sorting and selecting the best candidates below,
+ // we may still decide to exclude this promotion-eligible region from the current collection set. If this
+ // happens, we will consider this region as part of the anticipated promotion potential for the next GC
+ // pass; see further below.
+ sorted_regions[candidates]._region = r;
+ sorted_regions[candidates++]._live_data = r->get_live_data_bytes();
+ }
+ } else {
+ // We only evacuate & promote objects from regular regions whose garbage() is above old-garbage-threshold.
+ // Objects in tenure-worthy regions with less garbage are promoted in place. These take a different path to
+ // old-gen. Regions excluded from promotion because their garbage content is too low (causing us to anticipate that
+ // the region would be promoted in place) may be eligible for evacuation promotion by the time promotion takes
+ // place during a subsequent GC pass because more garbage is found within the region between now and then. This
+ // should not happen if we are properly adapting the tenure age. The theory behind adaptive tenuring threshold
+ // is to choose the youngest age that demonstrates no "significant" further loss of population since the previous
+ // age. If not this, we expect the tenure age to demonstrate linear population decay for at least two population
+ // samples, whereas we expect to observe exponential population decay for ages younger than the tenure age.
+ //
+ // In the case that certain regions which were anticipated to be promoted in place need to be promoted by
+ // evacuation, it may be the case that there is not sufficient reserve within old-gen to hold evacuation of
+ // these regions. The likely outcome is that these regions will not be selected for evacuation or promotion
+ // in the current cycle and we will anticipate that they will be promoted in the next cycle. This will cause
+ // us to reserve more old-gen memory so that these objects can be promoted in the subsequent cycle.
+ if (heap->is_aging_cycle() && heap->age_census()->is_tenurable(r->age() + 1)) {
+ if (r->garbage() >= old_garbage_threshold) {
+ promo_potential += r->get_live_data_bytes();
+ }
+ }
+ }
+ // Note that we keep going even if one region is excluded from selection.
+ // Subsequent regions may be selected if they have smaller live data.
+ }
+
+ if (pip_mutator_regions + pip_collector_regions > 0) {
+ freeset->account_for_pip_regions(pip_mutator_regions, pip_mutator_bytes, pip_collector_regions, pip_collector_bytes);
+ }
+
+ // Retire any regions that have been selected for promote in place
+ if (collector_regions_to_pip > 0) {
+ freeset->shrink_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::Collector,
+ pip_low_collector_idx, pip_high_collector_idx,
+ collector_regions_to_pip);
+ }
+ if (mutator_regions_to_pip > 0) {
+ freeset->shrink_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::Mutator,
+ pip_low_mutator_idx, pip_high_mutator_idx,
+ mutator_regions_to_pip);
+ }
+
+ // Sort in increasing order according to live data bytes. Note that candidates represents the number of regions
+ // that qualify to be promoted by evacuation.
+ size_t old_consumed = 0;
+ if (candidates > 0) {
+ size_t selected_regions = 0;
+ size_t selected_live = 0;
+ QuickSort::sort(sorted_regions, candidates, compare_by_aged_live);
+ for (size_t i = 0; i < candidates; i++) {
+ ShenandoahHeapRegion* const region = sorted_regions[i]._region;
+ const size_t region_live_data = sorted_regions[i]._live_data;
+ const size_t promotion_need = (size_t) (region_live_data * ShenandoahPromoEvacWaste);
+ if (old_consumed + promotion_need <= old_promotion_reserve) {
+ old_consumed += promotion_need;
+ candidate_regions_for_promotion_by_copy[region->index()] = true;
+ selected_regions++;
+ selected_live += region_live_data;
+ } else {
+ // We rejected this promotable region from the collection set because we had no room to hold its copy.
+ // Add this region to promo potential for next GC.
+ promo_potential += region_live_data;
+ assert(!candidate_regions_for_promotion_by_copy[region->index()], "Shouldn't be selected");
+ }
+ // We keep going even if one region is excluded from selection because we need to accumulate all eligible
+ // regions that are not preselected into promo_potential
+ }
+ log_debug(gc, ergo)("Preselected %zu regions containing " PROPERFMT " live data,"
+ " consuming: " PROPERFMT " of budgeted: " PROPERFMT,
+ selected_regions, PROPERFMTARGS(selected_live), PROPERFMTARGS(old_consumed), PROPERFMTARGS(old_promotion_reserve));
+ }
+
+ log_info(gc, ergo)("Promotion potential of aged regions with sufficient garbage: " PROPERFMT, PROPERFMTARGS(promo_potential));
+
+ heap->old_generation()->set_pad_for_promote_in_place(promote_in_place_pad);
+ heap->old_generation()->set_promotion_potential(promo_potential);
+ return old_consumed;
+}
+
+// Having chosen the collection set, adjust the budgets for generational mode based on its composition. Note
+// that young_generation->available() now knows about recently discovered immediate garbage.
+void ShenandoahGenerationalHeuristics::adjust_evacuation_budgets(ShenandoahHeap* const heap,
+ ShenandoahCollectionSet* const collection_set) {
+ shenandoah_assert_generational();
+ // We may find that old_evacuation_reserve and/or loaned_for_young_evacuation are not fully consumed, in which case we may
+ // be able to increase regions_available_to_loan
+
+ // The role of adjust_evacuation_budgets() is to compute the correct value of regions_available_to_loan and to make
+ // effective use of this memory, including the remnant memory within these regions that may result from rounding loan to
+ // integral number of regions. Excess memory that is available to be loaned is applied to an allocation supplement,
+ // which allows mutators to allocate memory beyond the current capacity of young-gen on the promise that the loan
+ // will be repaid as soon as we finish updating references for the recently evacuated collection set.
+
+ // We cannot recalculate regions_available_to_loan by simply dividing old_generation->available() by region_size_bytes
+ // because the available memory may be distributed between many partially occupied regions that are already holding old-gen
+ // objects. Memory in partially occupied regions is not "available" to be loaned. Note that an increase in old-gen
+ // available that results from a decrease in memory consumed by old evacuation is not necessarily available to be loaned
+ // to young-gen.
+
+ const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes();
+ ShenandoahOldGeneration* const old_generation = heap->old_generation();
+ ShenandoahYoungGeneration* const young_generation = heap->young_generation();
+
+ const size_t old_evacuated = collection_set->get_live_bytes_in_old_regions();
+ size_t old_evacuated_committed = (size_t) (ShenandoahOldEvacWaste * double(old_evacuated));
+ size_t old_evacuation_reserve = old_generation->get_evacuation_reserve();
+
+ if (old_evacuated_committed > old_evacuation_reserve) {
+ // This should only happen due to round-off errors when enforcing ShenandoahOldEvacWaste
+ assert(old_evacuated_committed <= (33 * old_evacuation_reserve) / 32,
+ "Round-off errors should be less than 3.125%%, committed: %zu, reserved: %zu",
+ old_evacuated_committed, old_evacuation_reserve);
+ old_evacuated_committed = old_evacuation_reserve;
+ // Leave old_evac_reserve as previously configured
+ } else if (old_evacuated_committed < old_evacuation_reserve) {
+ // This happens if the old-gen collection consumes less than full budget.
+ log_debug(gc, cset)("Shrinking old evac reserve to match old_evac_commited: " PROPERFMT,
+ PROPERFMTARGS(old_evacuated_committed));
+ old_evacuation_reserve = old_evacuated_committed;
+ old_generation->set_evacuation_reserve(old_evacuation_reserve);
+ }
+
+ size_t young_advance_promoted = collection_set->get_live_bytes_in_tenurable_regions();
+ size_t young_advance_promoted_reserve_used = (size_t) (ShenandoahPromoEvacWaste * double(young_advance_promoted));
+
+ size_t young_evacuated = collection_set->get_live_bytes_in_untenurable_regions();
+ size_t young_evacuated_reserve_used = (size_t) (ShenandoahEvacWaste * double(young_evacuated));
+
+ size_t total_young_available = young_generation->available_with_reserve() - _add_regions_to_old * region_size_bytes;;
+ assert(young_evacuated_reserve_used <= total_young_available, "Cannot evacuate (%zu) more than is available in young (%zu)",
+ young_evacuated_reserve_used, total_young_available);
+ young_generation->set_evacuation_reserve(young_evacuated_reserve_used);
+
+ // We have not yet rebuilt the free set. Some of the memory that is thought to be avaiable within old may no
+ // longer be available if that memory had been free within regions that were selected for the collection set.
+ // Make the necessary adjustments to old_available.
+ size_t old_available =
+ old_generation->available() + _add_regions_to_old * region_size_bytes - collection_set->get_old_available_bytes_collected();
+
+ // Now that we've established the collection set, we know how much memory is really required by old-gen for evacuation
+ // and promotion reserves. Try shrinking OLD now in case that gives us a bit more runway for mutator allocations during
+ // evac and update phases.
+ size_t old_consumed = old_evacuated_committed + young_advance_promoted_reserve_used;
+
+ if (old_available < old_consumed) {
+ // This can happen due to round-off errors when adding the results of truncated integer arithmetic.
+ // We've already truncated old_evacuated_committed. Truncate young_advance_promoted_reserve_used here.
+
+ assert(young_advance_promoted_reserve_used <= (33 * (old_available - old_evacuated_committed)) / 32,
+ "Round-off errors should be less than 3.125%%, committed: %zu, reserved: %zu",
+ young_advance_promoted_reserve_used, old_available - old_evacuated_committed);
+ if (old_available > old_evacuated_committed) {
+ young_advance_promoted_reserve_used = old_available - old_evacuated_committed;
+ } else {
+ young_advance_promoted_reserve_used = 0;
+ old_evacuated_committed = old_available;
+ }
+ // TODO: reserve for full promotion reserve, not just for advance (preselected) promotion
+ old_consumed = old_evacuated_committed + young_advance_promoted_reserve_used;
+ }
+
+ assert(old_available >= old_consumed, "Cannot consume (%zu) more than is available (%zu)",
+ old_consumed, old_available);
+ size_t excess_old = old_available - old_consumed;
+ size_t unaffiliated_old_regions = old_generation->free_unaffiliated_regions() + _add_regions_to_old;
+ size_t unaffiliated_old = unaffiliated_old_regions * region_size_bytes;
+ assert(unaffiliated_old >= old_evacuated_committed, "Do not evacuate (%zu) more than unaffiliated old (%zu)",
+ old_evacuated_committed, unaffiliated_old);
+
+ // Make sure old_evac_committed is unaffiliated
+ if (old_evacuated_committed > 0) {
+ if (unaffiliated_old > old_evacuated_committed) {
+ size_t giveaway = unaffiliated_old - old_evacuated_committed;
+ size_t giveaway_regions = giveaway / region_size_bytes; // round down
+ if (giveaway_regions > 0) {
+ excess_old = MIN2(excess_old, giveaway_regions * region_size_bytes);
+ } else {
+ excess_old = 0;
+ }
+ } else {
+ excess_old = 0;
+ }
+ }
+
+ // If we find that OLD has excess regions, give them back to YOUNG now to reduce likelihood we run out of allocation
+ // runway during evacuation and update-refs. We may make further adjustments to balance.
+ ssize_t add_regions_to_young = 0;
+ if (excess_old > unaffiliated_old) {
+ // we can give back unaffiliated_old (all of unaffiliated is excess)
+ if (unaffiliated_old_regions > 0) {
+ add_regions_to_young = unaffiliated_old_regions;
+ }
+ } else if (unaffiliated_old_regions > 0) {
+ // excess_old < unaffiliated old: we can give back MIN(excess_old/region_size_bytes, unaffiliated_old_regions)
+ size_t excess_regions = excess_old / region_size_bytes;
+ add_regions_to_young = MIN2(excess_regions, unaffiliated_old_regions);
+ }
+
+ if (add_regions_to_young > 0) {
+ assert(excess_old >= add_regions_to_young * region_size_bytes, "Cannot xfer more than excess old");
+ excess_old -= add_regions_to_young * region_size_bytes;
+ log_debug(gc, ergo)("Before start of evacuation, total_promotion reserve is young_advance_promoted_reserve: %zu "
+ "plus excess: old: %zu", young_advance_promoted_reserve_used, excess_old);
+ }
+
+ // Add in the excess_old memory to hold unanticipated promotions, if any. If there are more unanticipated
+ // promotions than fit in reserved memory, they will be deferred until a future GC pass.
+ size_t total_promotion_reserve = young_advance_promoted_reserve_used + excess_old;
+
+ old_generation->set_promoted_reserve(total_promotion_reserve);
+ old_generation->reset_promoted_expended();
+}
size_t ShenandoahGenerationalHeuristics::add_preselected_regions_to_collection_set(ShenandoahCollectionSet* cset,
const RegionData* data,
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp
index 9b4c93af9b4..74d657feab7 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGenerationalHeuristics.hpp
@@ -29,6 +29,9 @@
#include "gc/shenandoah/heuristics/shenandoahAdaptiveHeuristics.hpp"
class ShenandoahGeneration;
+class ShenandoahHeap;
+class ShenandoahCollectionSet;
+class RegionData;
/*
* This class serves as the base class for heuristics used to trigger and
@@ -44,10 +47,42 @@ class ShenandoahGenerationalHeuristics : public ShenandoahAdaptiveHeuristics {
public:
explicit ShenandoahGenerationalHeuristics(ShenandoahGeneration* generation);
- size_t choose_collection_set(ShenandoahCollectionSet* collection_set) override;
+ void choose_collection_set(ShenandoahCollectionSet* collection_set) override;
+
+private:
+ // Compute evacuation budgets prior to choosing collection set.
+ void compute_evacuation_budgets(ShenandoahHeap* const heap);
+
+ // Preselect for possible inclusion into the collection set exactly the most
+ // garbage-dense regions, including those that satisfy criteria 1 & 2 below,
+ // and whose live bytes will fit within old_available budget:
+ // Criterion 1. region age >= tenuring threshold
+ // Criterion 2. region garbage percentage > old garbage threshold
+ //
+ // Identifies regions eligible for promotion in place,
+ // being those of at least tenuring_threshold age that have lower garbage
+ // density.
+ //
+ // Updates promotion_potential and pad_for_promote_in_place fields
+ // of the heap. Returns bytes of live object memory in the preselected
+ // regions, which are marked in the preselected_regions() indicator
+ // array of the heap's collection set, which should be initialized
+ // to false.
+ size_t select_aged_regions(const size_t old_promotion_reserve);
+
+ // Filter and sort remaining regions before adding to collection set.
+ void filter_regions(ShenandoahCollectionSet* collection_set);
+
+ // Adjust evacuation budgets after choosing collection set. The argument regions_to_xfer
+ // represents regions to be transferred to old based on decisions made in top_off_collection_set()
+ void adjust_evacuation_budgets(ShenandoahHeap* const heap,
+ ShenandoahCollectionSet* const collection_set);
+
protected:
ShenandoahGeneration* _generation;
+ size_t _add_regions_to_old;
+
size_t add_preselected_regions_to_collection_set(ShenandoahCollectionSet* cset,
const RegionData* data,
size_t size) const;
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp
index f47371c14d5..dd2ad28aa4b 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.cpp
@@ -36,14 +36,13 @@ ShenandoahGlobalHeuristics::ShenandoahGlobalHeuristics(ShenandoahGlobalGeneratio
}
-size_t ShenandoahGlobalHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) {
+void ShenandoahGlobalHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) {
// Better select garbage-first regions
- QuickSort::sort(data, (int) size, compare_by_garbage);
+ QuickSort::sort(data, size, compare_by_garbage);
choose_global_collection_set(cset, data, size, actual_free, 0 /* cur_young_garbage */);
- return 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp
index e0513f60da9..1f95f75c521 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahGlobalHeuristics.hpp
@@ -39,9 +39,9 @@ class ShenandoahGlobalHeuristics : public ShenandoahGenerationalHeuristics {
public:
ShenandoahGlobalHeuristics(ShenandoahGlobalGeneration* generation);
- size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) override;
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) override;
private:
void choose_global_collection_set(ShenandoahCollectionSet* cset,
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp
index aeb64b6f1df..8fc744112bf 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.cpp
@@ -72,7 +72,7 @@ ShenandoahHeuristics::~ShenandoahHeuristics() {
FREE_C_HEAP_ARRAY(RegionGarbage, _region_data);
}
-size_t ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
+void ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* collection_set) {
ShenandoahHeap* heap = ShenandoahHeap::heap();
assert(collection_set->is_empty(), "Must be empty");
@@ -154,7 +154,6 @@ size_t ShenandoahHeuristics::choose_collection_set(ShenandoahCollectionSet* coll
choose_collection_set_from_regiondata(collection_set, candidates, cand_idx, immediate_garbage + free);
}
collection_set->summarize(total_garbage, immediate_garbage, immediate_regions);
- return 0;
}
void ShenandoahHeuristics::record_cycle_start() {
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp
index ae34a9743a9..633c4e87126 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahHeuristics.hpp
@@ -183,12 +183,10 @@ class ShenandoahHeuristics : public CHeapObj {
static int compare_by_garbage(RegionData a, RegionData b);
- // This is a helper function to choose_collection_set(), returning the number of regions that need to be transferred to
- // the old reserve from the young reserve in order to effectively evacuate the chosen collection set. In non-generational
- // mode, the return value is 0.
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
- RegionData* data, size_t data_size,
- size_t free) = 0;
+ // This is a helper function to choose_collection_set()
+ virtual void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
+ RegionData* data, size_t data_size,
+ size_t free) = 0;
void adjust_penalty(intx step);
@@ -238,7 +236,7 @@ class ShenandoahHeuristics : public CHeapObj {
// Choose the collection set, returning the number of regions that need to be transferred to the old reserve from the young
// reserve in order to effectively evacuate the chosen collection set. In non-generational mode, the return value is 0.
- virtual size_t choose_collection_set(ShenandoahCollectionSet* collection_set);
+ virtual void choose_collection_set(ShenandoahCollectionSet* collection_set);
virtual bool can_unload_classes();
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp
index f47d0cbe819..e0cab781674 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.cpp
@@ -884,9 +884,8 @@ bool ShenandoahOldHeuristics::is_experimental() {
return true;
}
-size_t ShenandoahOldHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
- ShenandoahHeuristics::RegionData* data,
- size_t data_size, size_t free) {
+void ShenandoahOldHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
+ ShenandoahHeuristics::RegionData* data,
+ size_t data_size, size_t free) {
ShouldNotReachHere();
- return 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp
index 97a5b1ebf24..fc7a35aa6c8 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahOldHeuristics.hpp
@@ -155,8 +155,8 @@ class ShenandoahOldHeuristics : public ShenandoahHeuristics {
void set_trigger_if_old_is_overgrown();
protected:
- size_t
- choose_collection_set_from_regiondata(ShenandoahCollectionSet* set, RegionData* data, size_t data_size, size_t free) override;
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
+ RegionData* data, size_t data_size, size_t free) override;
// This internal helper routine adds as many mixed evacuation candidate regions as fit within the old-gen evacuation budget
// to the collection set. This may be called twice to prepare for any given mixed evacuation cycle, the first time with
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp
index d4a38278161..b5e9cc433ea 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.cpp
@@ -50,9 +50,9 @@ bool ShenandoahPassiveHeuristics::should_degenerate_cycle() {
return ShenandoahDegeneratedGC;
}
-size_t ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) {
+void ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) {
assert(ShenandoahDegeneratedGC, "This path is only taken for Degenerated GC");
// Do not select too large CSet that would overflow the available free space.
@@ -76,5 +76,4 @@ size_t ShenandoahPassiveHeuristics::choose_collection_set_from_regiondata(Shenan
cset->add_region(r);
}
}
- return 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp
index 7a64fad7cc9..3cb85f5d05f 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahPassiveHeuristics.hpp
@@ -40,19 +40,19 @@ class ShenandoahPassiveHeuristics : public ShenandoahHeuristics {
public:
ShenandoahPassiveHeuristics(ShenandoahSpaceInfo* space_info);
- virtual bool should_start_gc();
+ bool should_start_gc() override;
- virtual bool should_unload_classes();
+ bool should_unload_classes() override;
- virtual bool should_degenerate_cycle();
+ bool should_degenerate_cycle() override;
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
- RegionData* data, size_t data_size,
- size_t free);
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* set,
+ RegionData* data, size_t data_size,
+ size_t free) override;
- virtual const char* name() { return "Passive"; }
- virtual bool is_diagnostic() { return true; }
- virtual bool is_experimental() { return false; }
+ const char* name() override { return "Passive"; }
+ bool is_diagnostic() override { return true; }
+ bool is_experimental() override { return false; }
};
#endif // SHARE_GC_SHENANDOAH_HEURISTICS_SHENANDOAHPASSIVEHEURISTICS_HPP
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp
index 3843e434781..5f384f3dc73 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.cpp
@@ -37,8 +37,6 @@ ShenandoahStaticHeuristics::ShenandoahStaticHeuristics(ShenandoahSpaceInfo* spac
SHENANDOAH_ERGO_ENABLE_FLAG(ShenandoahImplicitGCInvokesConcurrent);
}
-ShenandoahStaticHeuristics::~ShenandoahStaticHeuristics() {}
-
bool ShenandoahStaticHeuristics::should_start_gc() {
size_t capacity = ShenandoahHeap::heap()->soft_max_capacity();
size_t available = _space_info->soft_mutator_available();
@@ -59,9 +57,9 @@ bool ShenandoahStaticHeuristics::should_start_gc() {
return ShenandoahHeuristics::should_start_gc();
}
-size_t ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t free) {
+void ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t free) {
size_t threshold = ShenandoahHeapRegion::region_size_bytes() * ShenandoahGarbageThreshold / 100;
for (size_t idx = 0; idx < size; idx++) {
@@ -70,5 +68,4 @@ size_t ShenandoahStaticHeuristics::choose_collection_set_from_regiondata(Shenand
cset->add_region(r);
}
}
- return 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp
index 27dc3c8e0ae..b1514b55e5a 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahStaticHeuristics.hpp
@@ -34,19 +34,17 @@
*/
class ShenandoahStaticHeuristics : public ShenandoahHeuristics {
public:
- ShenandoahStaticHeuristics(ShenandoahSpaceInfo* space_info);
+ explicit ShenandoahStaticHeuristics(ShenandoahSpaceInfo* space_info);
- virtual ~ShenandoahStaticHeuristics();
+ bool should_start_gc() override;
- virtual bool should_start_gc();
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t free) override;
- virtual size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t free);
-
- virtual const char* name() { return "Static"; }
- virtual bool is_diagnostic() { return false; }
- virtual bool is_experimental() { return false; }
+ const char* name() override { return "Static"; }
+ bool is_diagnostic() override { return false; }
+ bool is_experimental() override { return false; }
};
#endif // SHARE_GC_SHENANDOAH_HEURISTICS_SHENANDOAHSTATICHEURISTICS_HPP
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp
index 01c3873df72..beff2200d90 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.cpp
@@ -37,7 +37,7 @@ ShenandoahYoungHeuristics::ShenandoahYoungHeuristics(ShenandoahYoungGeneration*
}
-size_t ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+void ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
RegionData* data, size_t size,
size_t actual_free) {
// See comments in ShenandoahAdaptiveHeuristics::choose_collection_set_from_regiondata():
@@ -52,7 +52,7 @@ size_t ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenando
bool need_to_finalize_mixed = heap->old_generation()->heuristics()->prime_collection_set(cset);
// Better select garbage-first regions
- QuickSort::sort(data, (int) size, compare_by_garbage);
+ QuickSort::sort(data, size, compare_by_garbage);
size_t cur_young_garbage = add_preselected_regions_to_collection_set(cset, data, size);
@@ -62,12 +62,10 @@ size_t ShenandoahYoungHeuristics::choose_collection_set_from_regiondata(Shenando
// enough consolidated garbage to make effective use of young-gen evacuation reserve. If there is still
// young-gen reserve available following selection of the young-gen collection set, see if we can use
// this memory to expand the old-gen evacuation collection set.
- size_t add_regions_to_old;
- need_to_finalize_mixed |= heap->old_generation()->heuristics()->top_off_collection_set(add_regions_to_old);
+ need_to_finalize_mixed |= heap->old_generation()->heuristics()->top_off_collection_set(_add_regions_to_old);
if (need_to_finalize_mixed) {
heap->old_generation()->heuristics()->finalize_mixed_evacs();
}
- return add_regions_to_old;
}
void ShenandoahYoungHeuristics::choose_young_collection_set(ShenandoahCollectionSet* cset,
diff --git a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp
index 85587887663..b9d64059680 100644
--- a/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp
+++ b/src/hotspot/share/gc/shenandoah/heuristics/shenandoahYoungHeuristics.hpp
@@ -38,9 +38,9 @@ class ShenandoahYoungHeuristics : public ShenandoahGenerationalHeuristics {
explicit ShenandoahYoungHeuristics(ShenandoahYoungGeneration* generation);
- size_t choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
- RegionData* data, size_t size,
- size_t actual_free) override;
+ void choose_collection_set_from_regiondata(ShenandoahCollectionSet* cset,
+ RegionData* data, size_t size,
+ size_t actual_free) override;
bool should_start_gc() override;
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp
index 2aa37d7c575..004558a9fa8 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.cpp
@@ -72,21 +72,33 @@ void ShenandoahBarrierSet::print_on(outputStream* st) const {
bool ShenandoahBarrierSet::need_load_reference_barrier(DecoratorSet decorators, BasicType type) {
if (!ShenandoahLoadRefBarrier) return false;
- // Only needed for references
return is_reference_type(type);
}
bool ShenandoahBarrierSet::need_keep_alive_barrier(DecoratorSet decorators, BasicType type) {
if (!ShenandoahSATBBarrier) return false;
- // Only needed for references
if (!is_reference_type(type)) return false;
-
bool keep_alive = (decorators & AS_NO_KEEPALIVE) == 0;
bool unknown = (decorators & ON_UNKNOWN_OOP_REF) != 0;
bool on_weak_ref = (decorators & (ON_WEAK_OOP_REF | ON_PHANTOM_OOP_REF)) != 0;
return (on_weak_ref || unknown) && keep_alive;
}
+bool ShenandoahBarrierSet::need_satb_barrier(DecoratorSet decorators, BasicType type) {
+ if (!ShenandoahSATBBarrier) return false;
+ if (!is_reference_type(type)) return false;
+ bool as_normal = (decorators & AS_NORMAL) != 0;
+ bool dest_uninitialized = (decorators & IS_DEST_UNINITIALIZED) != 0;
+ return as_normal && !dest_uninitialized;
+}
+
+bool ShenandoahBarrierSet::need_card_barrier(DecoratorSet decorators, BasicType type) {
+ if (!ShenandoahCardBarrier) return false;
+ if (!is_reference_type(type)) return false;
+ bool in_heap = (decorators & IN_HEAP) != 0;
+ return in_heap;
+}
+
void ShenandoahBarrierSet::on_slowpath_allocation_exit(JavaThread* thread, oop new_obj) {
#if COMPILER2_OR_JVMCI
if (ReduceInitialCardMarks && ShenandoahCardBarrier && !ShenandoahHeap::heap()->is_in_young(new_obj)) {
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp
index 28765605267..e7a0ed57740 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahBarrierSet.hpp
@@ -60,6 +60,8 @@ class ShenandoahBarrierSet: public BarrierSet {
static bool need_load_reference_barrier(DecoratorSet decorators, BasicType type);
static bool need_keep_alive_barrier(DecoratorSet decorators, BasicType type);
+ static bool need_satb_barrier(DecoratorSet decorators, BasicType type);
+ static bool need_card_barrier(DecoratorSet decorators, BasicType type);
static bool is_strong_access(DecoratorSet decorators) {
return (decorators & (ON_WEAK_OOP_REF | ON_PHANTOM_OOP_REF)) == 0;
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp b/src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp
index 590e7831f07..bc11659c5e5 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahControlThread.cpp
@@ -44,7 +44,7 @@ ShenandoahControlThread::ShenandoahControlThread() :
ShenandoahController(),
_requested_gc_cause(GCCause::_no_gc),
_degen_point(ShenandoahGC::_degenerated_outside_cycle),
- _control_lock(Mutex::nosafepoint - 2, "ShenandoahGCRequest_lock", true) {
+ _control_lock(CONTROL_LOCK_RANK, "ShenandoahControl_lock", true) {
set_name("Shenandoah Control Thread");
create_and_start();
}
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahController.hpp b/src/hotspot/share/gc/shenandoah/shenandoahController.hpp
index a6a699fac3b..b8ff4df4771 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahController.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahController.hpp
@@ -42,6 +42,9 @@ class ShenandoahController: public ConcurrentGCThread {
shenandoah_padding(1);
protected:
+ const Mutex::Rank WAITERS_LOCK_RANK = Mutex::safepoint - 5;
+ const Mutex::Rank CONTROL_LOCK_RANK = Mutex::nosafepoint - 2;
+
// While we could have a single lock for these, it may risk unblocking
// GC waiters when alloc failure GC cycle finishes. We want instead
// to make complete explicit cycle for demanding customers.
@@ -54,8 +57,8 @@ class ShenandoahController: public ConcurrentGCThread {
public:
ShenandoahController():
_gc_id(0),
- _alloc_failure_waiters_lock(Mutex::safepoint-2, "ShenandoahAllocFailureGC_lock", true),
- _gc_waiters_lock(Mutex::safepoint-2, "ShenandoahRequestedGC_lock", true)
+ _alloc_failure_waiters_lock(WAITERS_LOCK_RANK, "ShenandoahAllocFailureWaiters_lock", true),
+ _gc_waiters_lock(WAITERS_LOCK_RANK, "ShenandoahGCWaiters_lock", true)
{ }
// Request a collection cycle. This handles "explicit" gc requests
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp
index cdc7e1a328a..ddb50ee0020 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.cpp
@@ -24,7 +24,6 @@
*/
#include "gc/shenandoah/heuristics/shenandoahHeuristics.hpp"
-#include "gc/shenandoah/shenandoahCollectionSetPreselector.hpp"
#include "gc/shenandoah/shenandoahCollectorPolicy.hpp"
#include "gc/shenandoah/shenandoahFreeSet.hpp"
#include "gc/shenandoah/shenandoahGeneration.hpp"
@@ -245,506 +244,6 @@ void ShenandoahGeneration::parallel_heap_region_iterate_free(ShenandoahHeapRegio
ShenandoahHeap::heap()->parallel_heap_region_iterate(cl);
}
-void ShenandoahGeneration::compute_evacuation_budgets(ShenandoahHeap* const heap) {
- shenandoah_assert_generational();
-
- ShenandoahOldGeneration* const old_generation = heap->old_generation();
- ShenandoahYoungGeneration* const young_generation = heap->young_generation();
- const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes();
-
- // During initialization and phase changes, it is more likely that fewer objects die young and old-gen
- // memory is not yet full (or is in the process of being replaced). During these times especially, it
- // is beneficial to loan memory from old-gen to young-gen during the evacuation and update-refs phases
- // of execution.
-
- // Calculate EvacuationReserve before PromotionReserve. Evacuation is more critical than promotion.
- // If we cannot evacuate old-gen, we will not be able to reclaim old-gen memory. Promotions are less
- // critical. If we cannot promote, there may be degradation of young-gen memory because old objects
- // accumulate there until they can be promoted. This increases the young-gen marking and evacuation work.
-
- // First priority is to reclaim the easy garbage out of young-gen.
-
- // maximum_young_evacuation_reserve is upper bound on memory to be evacuated into young Collector Reserve. This is
- // bounded at the end of previous GC cycle, based on available memory and balancing of evacuation to old and young.
- size_t maximum_young_evacuation_reserve = young_generation->get_evacuation_reserve();
-
- // maximum_old_evacuation_reserve is an upper bound on memory evacuated from old and evacuated to old (promoted),
- // clamped by the old generation space available.
- //
- // Here's the algebra.
- // Let SOEP = ShenandoahOldEvacPercent,
- // OE = old evac,
- // YE = young evac, and
- // TE = total evac = OE + YE
- // By definition:
- // SOEP/100 = OE/TE
- // = OE/(OE+YE)
- // => SOEP/(100-SOEP) = OE/((OE+YE)-OE) // componendo-dividendo: If a/b = c/d, then a/(b-a) = c/(d-c)
- // = OE/YE
- // => OE = YE*SOEP/(100-SOEP)
-
- // We have to be careful in the event that SOEP is set to 100 by the user.
- assert(ShenandoahOldEvacPercent <= 100, "Error");
- const size_t old_available = old_generation->available();
- const size_t maximum_old_evacuation_reserve = (ShenandoahOldEvacPercent == 100) ?
- old_available : MIN2((maximum_young_evacuation_reserve * ShenandoahOldEvacPercent) / (100 - ShenandoahOldEvacPercent),
- old_available);
-
- // In some cases, maximum_old_reserve < old_available (when limited by ShenandoahOldEvacPercent)
- // This limit affects mixed evacuations, but does not affect promotions.
-
- // Second priority is to reclaim garbage out of old-gen if there are old-gen collection candidates. Third priority
- // is to promote as much as we have room to promote. However, if old-gen memory is in short supply, this means young
- // GC is operating under "duress" and was unable to transfer the memory that we would normally expect. In this case,
- // old-gen will refrain from compacting itself in order to allow a quicker young-gen cycle (by avoiding the update-refs
- // through ALL of old-gen). If there is some memory available in old-gen, we will use this for promotions as promotions
- // do not add to the update-refs burden of GC.
-
- size_t old_evacuation_reserve, old_promo_reserve;
- if (is_global()) {
- // Global GC is typically triggered by user invocation of System.gc(), and typically indicates that there is lots
- // of garbage to be reclaimed because we are starting a new phase of execution. Marking for global GC may take
- // significantly longer than typical young marking because we must mark through all old objects. To expedite
- // evacuation and update-refs, we give emphasis to reclaiming garbage first, wherever that garbage is found.
- // Global GC will adjust generation sizes to accommodate the collection set it chooses.
-
- // Use remnant of old_available to hold promotions.
- old_promo_reserve = old_available - maximum_old_evacuation_reserve;
-
- // Dedicate all available old memory to old_evacuation reserve. This may be small, because old-gen is only
- // expanded based on an existing mixed evacuation workload at the end of the previous GC cycle. We'll expand
- // the budget for evacuation of old during GLOBAL cset selection.
- old_evacuation_reserve = maximum_old_evacuation_reserve;
- } else if (old_generation->has_unprocessed_collection_candidates()) {
- // We reserved all old-gen memory at end of previous GC to hold anticipated evacuations to old-gen. If this is
- // mixed evacuation, reserve all of this memory for compaction of old-gen and do not promote. Prioritize compaction
- // over promotion in order to defragment OLD so that it will be better prepared to efficiently receive promoted memory.
- old_evacuation_reserve = maximum_old_evacuation_reserve;
- old_promo_reserve = old_available - maximum_old_evacuation_reserve;
- } else {
- // Make all old-evacuation memory for promotion, but if we can't use it all for promotion, we'll allow some evacuation.
- old_evacuation_reserve = old_available - maximum_old_evacuation_reserve;
- old_promo_reserve = maximum_old_evacuation_reserve;
- }
- assert(old_evacuation_reserve <= old_available, "Error");
-
-
- // We see too many old-evacuation failures if we force ourselves to evacuate into regions that are not initially empty.
- // So we limit the old-evacuation reserve to unfragmented memory. Even so, old-evacuation is free to fill in nooks and
- // crannies within existing partially used regions and it generally tries to do so.
- const size_t old_free_unfragmented = old_generation->free_unaffiliated_regions() * region_size_bytes;
- if (old_evacuation_reserve > old_free_unfragmented) {
- const size_t delta = old_evacuation_reserve - old_free_unfragmented;
- old_evacuation_reserve -= delta;
- // Let promo consume fragments of old-gen memory
- old_promo_reserve += delta;
- }
-
- // If is_global(), we let garbage-first heuristic determine cset membership. Otherwise, we give priority
- // to tenurable regions by preselecting regions for promotion by evacuation (obtaining the live data to seed promoted_reserve).
- // This also identifies regions that will be promoted in place. These use the tenuring threshold.
- const size_t consumed_by_advance_promotion = select_aged_regions(is_global()? 0: old_promo_reserve);
- assert(consumed_by_advance_promotion <= old_promo_reserve, "Do not promote more than budgeted");
-
- // The young evacuation reserve can be no larger than young_unaffiliated. Planning to evacuate into partially consumed
- // young regions is doomed to failure if any of those partially consumed regions is selected for the collection set.
- size_t young_unaffiliated = young_generation->free_unaffiliated_regions() * region_size_bytes;
-
- // If any regions have been selected for promotion in place, this has the effect of decreasing available within mutator
- // and collector partitions, due to padding of remnant memory within each promoted in place region. This will affect
- // young_evacuation_reserve but not old_evacuation_reserve or consumed_by_advance_promotion. So recompute.
- size_t young_evacuation_reserve = MIN2(maximum_young_evacuation_reserve, young_unaffiliated);
-
- // Note that unused old_promo_reserve might not be entirely consumed_by_advance_promotion. Do not transfer this
- // to old_evacuation_reserve because this memory is likely very fragmented, and we do not want to increase the likelihood
- // of old evacuation failure. Leave this memory in the promoted reserve as it may be targeted by opportunistic
- // promotions (found during evacuation of young regions).
- young_generation->set_evacuation_reserve(young_evacuation_reserve);
- old_generation->set_evacuation_reserve(old_evacuation_reserve);
- old_generation->set_promoted_reserve(old_promo_reserve);
-
- // There is no need to expand OLD because all memory used here was set aside at end of previous GC, except in the
- // case of a GLOBAL gc. During choose_collection_set() of GLOBAL, old will be expanded on demand.
-}
-
-// Having chosen the collection set, adjust the budgets for generational mode based on its composition. Note
-// that young_generation->available() now knows about recently discovered immediate garbage.
-void ShenandoahGeneration::adjust_evacuation_budgets(ShenandoahHeap* const heap,
- ShenandoahCollectionSet* const collection_set, size_t add_regions_to_old) {
- shenandoah_assert_generational();
- // We may find that old_evacuation_reserve and/or loaned_for_young_evacuation are not fully consumed, in which case we may
- // be able to increase regions_available_to_loan
-
- // The role of adjust_evacuation_budgets() is to compute the correct value of regions_available_to_loan and to make
- // effective use of this memory, including the remnant memory within these regions that may result from rounding loan to
- // integral number of regions. Excess memory that is available to be loaned is applied to an allocation supplement,
- // which allows mutators to allocate memory beyond the current capacity of young-gen on the promise that the loan
- // will be repaid as soon as we finish updating references for the recently evacuated collection set.
-
- // We cannot recalculate regions_available_to_loan by simply dividing old_generation->available() by region_size_bytes
- // because the available memory may be distributed between many partially occupied regions that are already holding old-gen
- // objects. Memory in partially occupied regions is not "available" to be loaned. Note that an increase in old-gen
- // available that results from a decrease in memory consumed by old evacuation is not necessarily available to be loaned
- // to young-gen.
-
- const size_t region_size_bytes = ShenandoahHeapRegion::region_size_bytes();
- ShenandoahOldGeneration* const old_generation = heap->old_generation();
- ShenandoahYoungGeneration* const young_generation = heap->young_generation();
-
- const size_t old_evacuated = collection_set->get_live_bytes_in_old_regions();
- size_t old_evacuated_committed = (size_t) (ShenandoahOldEvacWaste * double(old_evacuated));
- size_t old_evacuation_reserve = old_generation->get_evacuation_reserve();
-
- if (old_evacuated_committed > old_evacuation_reserve) {
- // This should only happen due to round-off errors when enforcing ShenandoahOldEvacWaste
- assert(old_evacuated_committed <= (33 * old_evacuation_reserve) / 32,
- "Round-off errors should be less than 3.125%%, committed: %zu, reserved: %zu",
- old_evacuated_committed, old_evacuation_reserve);
- old_evacuated_committed = old_evacuation_reserve;
- // Leave old_evac_reserve as previously configured
- } else if (old_evacuated_committed < old_evacuation_reserve) {
- // This happens if the old-gen collection consumes less than full budget.
- log_debug(gc, cset)("Shrinking old evac reserve to match old_evac_commited: " PROPERFMT,
- PROPERFMTARGS(old_evacuated_committed));
- old_evacuation_reserve = old_evacuated_committed;
- old_generation->set_evacuation_reserve(old_evacuation_reserve);
- }
-
- size_t young_advance_promoted = collection_set->get_live_bytes_in_tenurable_regions();
- size_t young_advance_promoted_reserve_used = (size_t) (ShenandoahPromoEvacWaste * double(young_advance_promoted));
-
- size_t young_evacuated = collection_set->get_live_bytes_in_untenurable_regions();
- size_t young_evacuated_reserve_used = (size_t) (ShenandoahEvacWaste * double(young_evacuated));
-
- size_t total_young_available = young_generation->available_with_reserve() - add_regions_to_old * region_size_bytes;;
- assert(young_evacuated_reserve_used <= total_young_available, "Cannot evacuate (%zu) more than is available in young (%zu)",
- young_evacuated_reserve_used, total_young_available);
- young_generation->set_evacuation_reserve(young_evacuated_reserve_used);
-
- // We have not yet rebuilt the free set. Some of the memory that is thought to be avaiable within old may no
- // longer be available if that memory had been free within regions that were selected for the collection set.
- // Make the necessary adjustments to old_available.
- size_t old_available =
- old_generation->available() + add_regions_to_old * region_size_bytes - collection_set->get_old_available_bytes_collected();
-
- // Now that we've established the collection set, we know how much memory is really required by old-gen for evacuation
- // and promotion reserves. Try shrinking OLD now in case that gives us a bit more runway for mutator allocations during
- // evac and update phases.
- size_t old_consumed = old_evacuated_committed + young_advance_promoted_reserve_used;
-
- if (old_available < old_consumed) {
- // This can happen due to round-off errors when adding the results of truncated integer arithmetic.
- // We've already truncated old_evacuated_committed. Truncate young_advance_promoted_reserve_used here.
-
- assert(young_advance_promoted_reserve_used <= (33 * (old_available - old_evacuated_committed)) / 32,
- "Round-off errors should be less than 3.125%%, committed: %zu, reserved: %zu",
- young_advance_promoted_reserve_used, old_available - old_evacuated_committed);
- if (old_available > old_evacuated_committed) {
- young_advance_promoted_reserve_used = old_available - old_evacuated_committed;
- } else {
- young_advance_promoted_reserve_used = 0;
- old_evacuated_committed = old_available;
- }
- // TODO: reserve for full promotion reserve, not just for advance (preselected) promotion
- old_consumed = old_evacuated_committed + young_advance_promoted_reserve_used;
- }
-
- assert(old_available >= old_consumed, "Cannot consume (%zu) more than is available (%zu)",
- old_consumed, old_available);
- size_t excess_old = old_available - old_consumed;
- size_t unaffiliated_old_regions = old_generation->free_unaffiliated_regions() + add_regions_to_old;
- size_t unaffiliated_old = unaffiliated_old_regions * region_size_bytes;
- assert(unaffiliated_old >= old_evacuated_committed, "Do not evacuate (%zu) more than unaffiliated old (%zu)",
- old_evacuated_committed, unaffiliated_old);
-
- // Make sure old_evac_committed is unaffiliated
- if (old_evacuated_committed > 0) {
- if (unaffiliated_old > old_evacuated_committed) {
- size_t giveaway = unaffiliated_old - old_evacuated_committed;
- size_t giveaway_regions = giveaway / region_size_bytes; // round down
- if (giveaway_regions > 0) {
- excess_old = MIN2(excess_old, giveaway_regions * region_size_bytes);
- } else {
- excess_old = 0;
- }
- } else {
- excess_old = 0;
- }
- }
-
- // If we find that OLD has excess regions, give them back to YOUNG now to reduce likelihood we run out of allocation
- // runway during evacuation and update-refs. We may make further adjustments to balance.
- ssize_t add_regions_to_young = 0;
- if (excess_old > unaffiliated_old) {
- // we can give back unaffiliated_old (all of unaffiliated is excess)
- if (unaffiliated_old_regions > 0) {
- add_regions_to_young = unaffiliated_old_regions;
- }
- } else if (unaffiliated_old_regions > 0) {
- // excess_old < unaffiliated old: we can give back MIN(excess_old/region_size_bytes, unaffiliated_old_regions)
- size_t excess_regions = excess_old / region_size_bytes;
- add_regions_to_young = MIN2(excess_regions, unaffiliated_old_regions);
- }
-
- if (add_regions_to_young > 0) {
- assert(excess_old >= add_regions_to_young * region_size_bytes, "Cannot xfer more than excess old");
- excess_old -= add_regions_to_young * region_size_bytes;
- log_debug(gc, ergo)("Before start of evacuation, total_promotion reserve is young_advance_promoted_reserve: %zu "
- "plus excess: old: %zu", young_advance_promoted_reserve_used, excess_old);
- }
-
- // Add in the excess_old memory to hold unanticipated promotions, if any. If there are more unanticipated
- // promotions than fit in reserved memory, they will be deferred until a future GC pass.
- size_t total_promotion_reserve = young_advance_promoted_reserve_used + excess_old;
-
- old_generation->set_promoted_reserve(total_promotion_reserve);
- old_generation->reset_promoted_expended();
-}
-
-typedef struct {
- ShenandoahHeapRegion* _region;
- size_t _live_data;
-} AgedRegionData;
-
-static int compare_by_aged_live(AgedRegionData a, AgedRegionData b) {
- if (a._live_data < b._live_data)
- return -1;
- else if (a._live_data > b._live_data)
- return 1;
- else return 0;
-}
-
-inline void assert_no_in_place_promotions() {
-#ifdef ASSERT
- class ShenandoahNoInPlacePromotions : public ShenandoahHeapRegionClosure {
- public:
- void heap_region_do(ShenandoahHeapRegion *r) override {
- assert(r->get_top_before_promote() == nullptr,
- "Region %zu should not be ready for in-place promotion", r->index());
- }
- } cl;
- ShenandoahHeap::heap()->heap_region_iterate(&cl);
-#endif
-}
-
-// Preselect for inclusion into the collection set all regions whose age is at or above tenure age and for which the
-// garbage percentage exceeds a dynamically adjusted threshold (known as the old-garbage threshold percentage). We
-// identify these regions by setting the appropriate entry of the collection set's preselected regions array to true.
-// All entries are initialized to false before calling this function.
-//
-// During the subsequent selection of the collection set, we give priority to these promotion set candidates.
-// Without this prioritization, we found that the aged regions tend to be ignored because they typically have
-// much less garbage and much more live data than the recently allocated "eden" regions. When aged regions are
-// repeatedly excluded from the collection set, the amount of live memory within the young generation tends to
-// accumulate and this has the undesirable side effect of causing young-generation collections to require much more
-// CPU and wall-clock time.
-//
-// A second benefit of treating aged regions differently than other regions during collection set selection is
-// that this allows us to more accurately budget memory to hold the results of evacuation. Memory for evacuation
-// of aged regions must be reserved in the old generation. Memory for evacuation of all other regions must be
-// reserved in the young generation.
-size_t ShenandoahGeneration::select_aged_regions(const size_t old_promotion_reserve) {
-
- // There should be no regions configured for subsequent in-place-promotions carried over from the previous cycle.
- assert_no_in_place_promotions();
-
- auto const heap = ShenandoahGenerationalHeap::heap();
- ShenandoahFreeSet* free_set = heap->free_set();
- bool* const candidate_regions_for_promotion_by_copy = heap->collection_set()->preselected_regions();
- ShenandoahMarkingContext* const ctx = heap->marking_context();
-
- const size_t old_garbage_threshold =
- (ShenandoahHeapRegion::region_size_bytes() * heap->old_generation()->heuristics()->get_old_garbage_threshold()) / 100;
-
- const size_t pip_used_threshold = (ShenandoahHeapRegion::region_size_bytes() * ShenandoahGenerationalMinPIPUsage) / 100;
-
- size_t promo_potential = 0;
- size_t candidates = 0;
-
- // Tracks the padding of space above top in regions eligible for promotion in place
- size_t promote_in_place_pad = 0;
-
- // Sort the promotion-eligible regions in order of increasing live-data-bytes so that we can first reclaim regions that require
- // less evacuation effort. This prioritizes garbage first, expanding the allocation pool early before we reclaim regions that
- // have more live data.
- const idx_t num_regions = heap->num_regions();
-
- ResourceMark rm;
- AgedRegionData* sorted_regions = NEW_RESOURCE_ARRAY(AgedRegionData, num_regions);
-
- ShenandoahFreeSet* freeset = heap->free_set();
-
- // Any region that is to be promoted in place needs to be retired from its Collector or Mutator partition.
- idx_t pip_low_collector_idx = freeset->max_regions();
- idx_t pip_high_collector_idx = -1;
- idx_t pip_low_mutator_idx = freeset->max_regions();
- idx_t pip_high_mutator_idx = -1;
- size_t collector_regions_to_pip = 0;
- size_t mutator_regions_to_pip = 0;
-
- size_t pip_mutator_regions = 0;
- size_t pip_collector_regions = 0;
- size_t pip_mutator_bytes = 0;
- size_t pip_collector_bytes = 0;
-
- for (idx_t i = 0; i < num_regions; i++) {
- ShenandoahHeapRegion* const r = heap->get_region(i);
- if (r->is_empty() || !r->has_live() || !r->is_young() || !r->is_regular()) {
- // skip over regions that aren't regular young with some live data
- continue;
- }
- if (heap->is_tenurable(r)) {
- if ((r->garbage() < old_garbage_threshold) && (r->used() > pip_used_threshold)) {
- // We prefer to promote this region in place because it has a small amount of garbage and a large usage.
- HeapWord* tams = ctx->top_at_mark_start(r);
- HeapWord* original_top = r->top();
- if (!heap->is_concurrent_old_mark_in_progress() && tams == original_top) {
- // No allocations from this region have been made during concurrent mark. It meets all the criteria
- // for in-place-promotion. Though we only need the value of top when we fill the end of the region,
- // we use this field to indicate that this region should be promoted in place during the evacuation
- // phase.
- r->save_top_before_promote();
- size_t remnant_bytes = r->free();
- size_t remnant_words = remnant_bytes / HeapWordSize;
- assert(ShenandoahHeap::min_fill_size() <= PLAB::min_size(), "Implementation makes invalid assumptions");
- if (remnant_words >= ShenandoahHeap::min_fill_size()) {
- ShenandoahHeap::fill_with_object(original_top, remnant_words);
- // Fill the remnant memory within this region to assure no allocations prior to promote in place. Otherwise,
- // newly allocated objects will not be parsable when promote in place tries to register them. Furthermore, any
- // new allocations would not necessarily be eligible for promotion. This addresses both issues.
- r->set_top(r->end());
- // The region r is either in the Mutator or Collector partition if remnant_words > heap()->plab_min_size.
- // Otherwise, the region is in the NotFree partition.
- ShenandoahFreeSetPartitionId p = free_set->membership(i);
- if (p == ShenandoahFreeSetPartitionId::Mutator) {
- mutator_regions_to_pip++;
- if (i < pip_low_mutator_idx) {
- pip_low_mutator_idx = i;
- }
- if (i > pip_high_mutator_idx) {
- pip_high_mutator_idx = i;
- }
- pip_mutator_regions++;
- pip_mutator_bytes += remnant_bytes;
- } else if (p == ShenandoahFreeSetPartitionId::Collector) {
- collector_regions_to_pip++;
- if (i < pip_low_collector_idx) {
- pip_low_collector_idx = i;
- }
- if (i > pip_high_collector_idx) {
- pip_high_collector_idx = i;
- }
- pip_collector_regions++;
- pip_collector_bytes += remnant_bytes;
- } else {
- assert((p == ShenandoahFreeSetPartitionId::NotFree) && (remnant_words < heap->plab_min_size()),
- "Should be NotFree if not in Collector or Mutator partitions");
- // In this case, the memory is already counted as used and the region has already been retired. There is
- // no need for further adjustments to used. Further, the remnant memory for this region will not be
- // unallocated or made available to OldCollector after pip.
- remnant_bytes = 0;
- }
- promote_in_place_pad += remnant_bytes;
- free_set->prepare_to_promote_in_place(i, remnant_bytes);
- } else {
- // Since the remnant is so small that this region has already been retired, we don't have to worry about any
- // accidental allocations occurring within this region before the region is promoted in place.
-
- // This region was already not in the Collector or Mutator set, so no need to remove it.
- assert(free_set->membership(i) == ShenandoahFreeSetPartitionId::NotFree, "sanity");
- }
- }
- // Else, we do not promote this region (either in place or by copy) because it has received new allocations.
-
- // During evacuation, we exclude from promotion regions for which age > tenure threshold, garbage < garbage-threshold,
- // used > pip_used_threshold, and get_top_before_promote() != tams
- } else {
- // Record this promotion-eligible candidate region. After sorting and selecting the best candidates below,
- // we may still decide to exclude this promotion-eligible region from the current collection set. If this
- // happens, we will consider this region as part of the anticipated promotion potential for the next GC
- // pass; see further below.
- sorted_regions[candidates]._region = r;
- sorted_regions[candidates++]._live_data = r->get_live_data_bytes();
- }
- } else {
- // We only evacuate & promote objects from regular regions whose garbage() is above old-garbage-threshold.
- // Objects in tenure-worthy regions with less garbage are promoted in place. These take a different path to
- // old-gen. Regions excluded from promotion because their garbage content is too low (causing us to anticipate that
- // the region would be promoted in place) may be eligible for evacuation promotion by the time promotion takes
- // place during a subsequent GC pass because more garbage is found within the region between now and then. This
- // should not happen if we are properly adapting the tenure age. The theory behind adaptive tenuring threshold
- // is to choose the youngest age that demonstrates no "significant" further loss of population since the previous
- // age. If not this, we expect the tenure age to demonstrate linear population decay for at least two population
- // samples, whereas we expect to observe exponential population decay for ages younger than the tenure age.
- //
- // In the case that certain regions which were anticipated to be promoted in place need to be promoted by
- // evacuation, it may be the case that there is not sufficient reserve within old-gen to hold evacuation of
- // these regions. The likely outcome is that these regions will not be selected for evacuation or promotion
- // in the current cycle and we will anticipate that they will be promoted in the next cycle. This will cause
- // us to reserve more old-gen memory so that these objects can be promoted in the subsequent cycle.
- if (heap->is_aging_cycle() && heap->age_census()->is_tenurable(r->age() + 1)) {
- if (r->garbage() >= old_garbage_threshold) {
- promo_potential += r->get_live_data_bytes();
- }
- }
- }
- // Note that we keep going even if one region is excluded from selection.
- // Subsequent regions may be selected if they have smaller live data.
- }
-
- if (pip_mutator_regions + pip_collector_regions > 0) {
- freeset->account_for_pip_regions(pip_mutator_regions, pip_mutator_bytes, pip_collector_regions, pip_collector_bytes);
- }
-
- // Retire any regions that have been selected for promote in place
- if (collector_regions_to_pip > 0) {
- freeset->shrink_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::Collector,
- pip_low_collector_idx, pip_high_collector_idx,
- collector_regions_to_pip);
- }
- if (mutator_regions_to_pip > 0) {
- freeset->shrink_interval_if_range_modifies_either_boundary(ShenandoahFreeSetPartitionId::Mutator,
- pip_low_mutator_idx, pip_high_mutator_idx,
- mutator_regions_to_pip);
- }
-
- // Sort in increasing order according to live data bytes. Note that candidates represents the number of regions
- // that qualify to be promoted by evacuation.
- size_t old_consumed = 0;
- if (candidates > 0) {
- size_t selected_regions = 0;
- size_t selected_live = 0;
- QuickSort::sort(sorted_regions, candidates, compare_by_aged_live);
- for (size_t i = 0; i < candidates; i++) {
- ShenandoahHeapRegion* const region = sorted_regions[i]._region;
- const size_t region_live_data = sorted_regions[i]._live_data;
- const size_t promotion_need = (size_t) (region_live_data * ShenandoahPromoEvacWaste);
- if (old_consumed + promotion_need <= old_promotion_reserve) {
- old_consumed += promotion_need;
- candidate_regions_for_promotion_by_copy[region->index()] = true;
- selected_regions++;
- selected_live += region_live_data;
- } else {
- // We rejected this promotable region from the collection set because we had no room to hold its copy.
- // Add this region to promo potential for next GC.
- promo_potential += region_live_data;
- assert(!candidate_regions_for_promotion_by_copy[region->index()], "Shouldn't be selected");
- }
- // We keep going even if one region is excluded from selection because we need to accumulate all eligible
- // regions that are not preselected into promo_potential
- }
- log_debug(gc, ergo)("Preselected %zu regions containing " PROPERFMT " live data,"
- " consuming: " PROPERFMT " of budgeted: " PROPERFMT,
- selected_regions, PROPERFMTARGS(selected_live), PROPERFMTARGS(old_consumed), PROPERFMTARGS(old_promotion_reserve));
- }
-
- log_info(gc, ergo)("Promotion potential of aged regions with sufficient garbage: " PROPERFMT, PROPERFMTARGS(promo_potential));
-
- heap->old_generation()->set_pad_for_promote_in_place(promote_in_place_pad);
- heap->old_generation()->set_promotion_potential(promo_potential);
- return old_consumed;
-}
-
void ShenandoahGeneration::prepare_regions_and_collection_set(bool concurrent) {
ShenandoahHeap* heap = ShenandoahHeap::heap();
ShenandoahCollectionSet* collection_set = heap->collection_set();
@@ -798,34 +297,7 @@ void ShenandoahGeneration::prepare_regions_and_collection_set(bool concurrent) {
collection_set->clear();
ShenandoahHeapLocker locker(heap->lock());
- if (is_generational) {
- // Seed the collection set with resource area-allocated
- // preselected regions, which are removed when we exit this scope.
- ShenandoahCollectionSetPreselector preselector(collection_set, heap->num_regions());
-
- // Find the amount that will be promoted, regions that will be promoted in
- // place, and preselected older regions that will be promoted by evacuation.
- compute_evacuation_budgets(heap);
-
- // Choose the collection set, including the regions preselected above for promotion into the old generation.
- size_t add_regions_to_old = _heuristics->choose_collection_set(collection_set);
- // Even if collection_set->is_empty(), we want to adjust budgets, making reserves available to mutator.
- adjust_evacuation_budgets(heap, collection_set, add_regions_to_old);
- if (is_global()) {
- // We have just chosen a collection set for a global cycle. The mark bitmap covering old regions is complete, so
- // the remembered set scan can use that to avoid walking into garbage. When the next old mark begins, we will
- // use the mark bitmap to make the old regions parsable by coalescing and filling any unmarked objects. Thus,
- // we prepare for old collections by remembering which regions are old at this time. Note that any objects
- // promoted into old regions will be above TAMS, and so will be considered marked. However, free regions that
- // become old after this point will not be covered correctly by the mark bitmap, so we must be careful not to
- // coalesce those regions. Only the old regions which are not part of the collection set at this point are
- // eligible for coalescing. As implemented now, this has the side effect of possibly initiating mixed-evacuations
- // after a global cycle for old regions that were not included in this collection set.
- heap->old_generation()->prepare_for_mixed_collections_after_global_gc();
- }
- } else {
- _heuristics->choose_collection_set(collection_set);
- }
+ _heuristics->choose_collection_set(collection_set);
}
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp
index d49e3bed5f8..946f2b91520 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahGeneration.hpp
@@ -60,31 +60,6 @@ class ShenandoahGeneration : public CHeapObj, public ShenandoahSpaceInfo {
ShenandoahHeuristics* _heuristics;
private:
- // Compute evacuation budgets prior to choosing collection set.
- void compute_evacuation_budgets(ShenandoahHeap* heap);
-
- // Adjust evacuation budgets after choosing collection set. The argument regions_to_xfer represents regions to be
- // transfered to old based on decisions made in top_off_collection_set()
- void adjust_evacuation_budgets(ShenandoahHeap* heap,
- ShenandoahCollectionSet* collection_set, size_t regions_to_xfer);
-
- // Preselect for possible inclusion into the collection set exactly the most
- // garbage-dense regions, including those that satisfy criteria 1 & 2 below,
- // and whose live bytes will fit within old_available budget:
- // Criterion 1. region age >= tenuring threshold
- // Criterion 2. region garbage percentage > old garbage threshold
- //
- // Identifies regions eligible for promotion in place,
- // being those of at least tenuring_threshold age that have lower garbage
- // density.
- //
- // Updates promotion_potential and pad_for_promote_in_place fields
- // of the heap. Returns bytes of live object memory in the preselected
- // regions, which are marked in the preselected_regions() indicator
- // array of the heap's collection set, which should be initialized
- // to false.
- size_t select_aged_regions(size_t old_promotion_reserve);
-
// Return available assuming that we can allocate no more than capacity bytes within this generation.
size_t available(size_t capacity) const;
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalControlThread.cpp b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalControlThread.cpp
index 018b4898a19..3b57190cc75 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahGenerationalControlThread.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahGenerationalControlThread.cpp
@@ -47,7 +47,7 @@
#include "utilities/events.hpp"
ShenandoahGenerationalControlThread::ShenandoahGenerationalControlThread() :
- _control_lock(Mutex::nosafepoint - 2, "ShenandoahGCRequest_lock", true),
+ _control_lock(CONTROL_LOCK_RANK, "ShenandoahGCRequest_lock", true),
_requested_gc_cause(GCCause::_no_gc),
_requested_generation(nullptr),
_gc_mode(none),
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
index ef99bd98c93..ccfc1c036c2 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.cpp
@@ -2719,18 +2719,6 @@ bool ShenandoahRegionIterator::has_next() const {
return _index < _heap->num_regions();
}
-char ShenandoahHeap::gc_state() const {
- return _gc_state.raw_value();
-}
-
-bool ShenandoahHeap::is_gc_state(GCState state) const {
- // If the global gc state has been changed, but hasn't yet been propagated to all threads, then
- // the global gc state is the correct value. Once the gc state has been synchronized with all threads,
- // _gc_state_changed will be toggled to false and we need to use the thread local state.
- return _gc_state_changed ? _gc_state.is_set(state) : ShenandoahThreadLocalData::is_gc_state(state);
-}
-
-
ShenandoahLiveData* ShenandoahHeap::get_liveness_cache(uint worker_id) {
#ifdef ASSERT
assert(_liveness_cache != nullptr, "sanity");
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp
index 174001170f4..9240091070b 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.hpp
@@ -353,7 +353,7 @@ class ShenandoahHeap : public CollectedHeap {
public:
// This returns the raw value of the singular, global gc state.
- char gc_state() const;
+ inline char gc_state() const;
// Compares the given state against either the global gc state, or the thread local state.
// The global gc state may change on a safepoint and is the correct value to use until
@@ -361,7 +361,7 @@ class ShenandoahHeap : public CollectedHeap {
// compare against the thread local state). The thread local gc state may also be changed
// by a handshake operation, in which case, this function continues using the updated thread
// local value.
- bool is_gc_state(GCState state) const;
+ inline bool is_gc_state(GCState state) const;
// This copies the global gc state into a thread local variable for all threads.
// The thread local gc state is primarily intended to support quick access at barriers.
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahHeap.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahHeap.inline.hpp
index 34c279a1495..e35f116b843 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahHeap.inline.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahHeap.inline.hpp
@@ -452,6 +452,17 @@ inline bool ShenandoahHeap::in_collection_set_loc(void* p) const {
return collection_set()->is_in_loc(p);
}
+inline char ShenandoahHeap::gc_state() const {
+ return _gc_state.raw_value();
+}
+
+inline bool ShenandoahHeap::is_gc_state(GCState state) const {
+ // If the global gc state has been changed, but hasn't yet been propagated to all threads, then
+ // the global gc state is the correct value. Once the gc state has been synchronized with all threads,
+ // _gc_state_changed will be toggled to false and we need to use the thread local state.
+ return _gc_state_changed ? _gc_state.is_set(state) : ShenandoahThreadLocalData::is_gc_state(state);
+}
+
inline bool ShenandoahHeap::is_idle() const {
return _gc_state_changed ? _gc_state.is_clear() : ShenandoahThreadLocalData::gc_state(Thread::current()) == 0;
}
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahMark.inline.hpp b/src/hotspot/share/gc/shenandoah/shenandoahMark.inline.hpp
index 849459157b5..ba24e890769 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahMark.inline.hpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahMark.inline.hpp
@@ -226,8 +226,6 @@ inline void ShenandoahMark::do_chunked_array(ShenandoahObjToScanQueue* q, T* cl,
assert(obj->is_objArray(), "expect object array");
objArrayOop array = objArrayOop(obj);
- assert (ObjArrayMarkingStride > 0, "sanity");
-
// Split out tasks, as suggested in ShenandoahMarkTask docs. Avoid pushing tasks that
// are known to start beyond the array.
while ((1 << pow) > (int)ObjArrayMarkingStride && (chunk*2 < ShenandoahMarkTask::chunk_size())) {
diff --git a/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp b/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp
index 0cc6d4c6ed4..b60f8128d1d 100644
--- a/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp
+++ b/src/hotspot/share/gc/shenandoah/shenandoahVerifier.cpp
@@ -110,15 +110,15 @@ class ShenandoahVerifyOopClosure : public BasicOopIterateClosure {
void do_oop_work(T* p) {
T o = RawAccess<>::oop_load(p);
if (!CompressedOops::is_null(o)) {
- oop obj = CompressedOops::decode_not_null(o);
+ // Basic verification should happen before we touch anything else.
+ // For performance reasons, only fully verify non-marked field values.
+ // We are here when the host object for *p is already marked.
+ oop obj = CompressedOops::decode_raw_not_null(o);
+ verify_oop_at_basic(p, obj);
+
if (is_instance_ref_klass(ShenandoahForwarding::klass(obj))) {
obj = ShenandoahForwarding::get_forwardee(obj);
}
- // Single threaded verification can use faster non-atomic stack and bitmap
- // methods.
- //
- // For performance reasons, only fully verify non-marked field values.
- // We are here when the host object for *p is already marked.
if (in_generation(obj) && _map->par_mark(obj)) {
verify_oop_at(p, obj);
_stack->push(ShenandoahVerifierTask(obj));
@@ -131,7 +131,7 @@ class ShenandoahVerifyOopClosure : public BasicOopIterateClosure {
return _generation->contains(region);
}
- void verify_oop(oop obj) {
+ void verify_oop(oop obj, bool basic = false) {
// Perform consistency checks with gradually decreasing safety level. This guarantees
// that failure report would not try to touch something that was not yet verified to be
// safe to process.
@@ -174,10 +174,14 @@ class ShenandoahVerifyOopClosure : public BasicOopIterateClosure {
}
}
+ check(ShenandoahAsserts::_safe_unknown, obj, obj_reg->is_active(),
+ "Object should be in active region");
+
// ------------ obj is safe at this point --------------
- check(ShenandoahAsserts::_safe_oop, obj, obj_reg->is_active(),
- "Object should be in active region");
+ if (basic) {
+ return;
+ }
switch (_options._verify_liveness) {
case ShenandoahVerifier::_verify_liveness_disable:
@@ -331,6 +335,18 @@ class ShenandoahVerifyOopClosure : public BasicOopIterateClosure {
_interior_loc = nullptr;
}
+ /**
+ * Verify object with known interior reference, with only basic verification.
+ * @param p interior reference where the object is referenced from; can be off-heap
+ * @param obj verified object
+ */
+ template
+ void verify_oop_at_basic(T* p, oop obj) {
+ _interior_loc = p;
+ verify_oop(obj, /* basic = */ true);
+ _interior_loc = nullptr;
+ }
+
/**
* Verify object without known interior reference.
* Useful when picking up the object at known offset in heap,
@@ -1232,7 +1248,9 @@ class ShenandoahVerifyNoForwarded : public BasicOopIterateClosure {
void do_oop_work(T* p) {
T o = RawAccess<>::oop_load(p);
if (!CompressedOops::is_null(o)) {
- oop obj = CompressedOops::decode_not_null(o);
+ oop obj = CompressedOops::decode_raw_not_null(o);
+ ShenandoahAsserts::assert_correct(p, obj, __FILE__, __LINE__);
+
oop fwd = ShenandoahForwarding::get_forwardee_raw_unchecked(obj);
if (obj != fwd) {
ShenandoahAsserts::print_failure(ShenandoahAsserts::_safe_all, obj, p, nullptr,
@@ -1252,7 +1270,9 @@ class ShenandoahVerifyInToSpaceClosure : public BasicOopIterateClosure {
void do_oop_work(T* p) {
T o = RawAccess<>::oop_load(p);
if (!CompressedOops::is_null(o)) {
- oop obj = CompressedOops::decode_not_null(o);
+ oop obj = CompressedOops::decode_raw_not_null(o);
+ ShenandoahAsserts::assert_correct(p, obj, __FILE__, __LINE__);
+
ShenandoahHeap* heap = ShenandoahHeap::heap();
if (!heap->marking_context()->is_marked_or_old(obj)) {
@@ -1306,7 +1326,9 @@ class ShenandoahVerifyRemSetClosure : public BasicOopIterateClosure {
inline void work(T* p) {
T o = RawAccess<>::oop_load(p);
if (!CompressedOops::is_null(o)) {
- oop obj = CompressedOops::decode_not_null(o);
+ oop obj = CompressedOops::decode_raw_not_null(o);
+ ShenandoahAsserts::assert_correct(p, obj, __FILE__, __LINE__);
+
if (_heap->is_in_young(obj) && !_scanner->is_card_dirty((HeapWord*) p)) {
ShenandoahAsserts::print_failure(ShenandoahAsserts::_safe_all, obj, p, nullptr,
_message, "clean card, it should be dirty.", __FILE__, __LINE__);
diff --git a/src/hotspot/share/gc/z/zAddress.inline.hpp b/src/hotspot/share/gc/z/zAddress.inline.hpp
index c8c8ec7ae3a..0b99802729b 100644
--- a/src/hotspot/share/gc/z/zAddress.inline.hpp
+++ b/src/hotspot/share/gc/z/zAddress.inline.hpp
@@ -199,18 +199,18 @@ CREATE_ZOFFSET_OPERATORS(zoffset)
inline uintptr_t untype(zbacking_offset offset) {
const uintptr_t value = static_cast(offset);
- assert(value < ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZAddressOffsetMax);
+ assert(value < ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZBackingOffsetMax);
return value;
}
inline uintptr_t untype(zbacking_offset_end offset) {
const uintptr_t value = static_cast(offset);
- assert(value <= ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZAddressOffsetMax);
+ assert(value <= ZBackingOffsetMax, "Offset out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZBackingOffsetMax);
return value;
}
inline zbacking_offset to_zbacking_offset(uintptr_t value) {
- assert(value < ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZAddressOffsetMax);
+ assert(value < ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " < " PTR_FORMAT ")", value, ZBackingOffsetMax);
return zbacking_offset(value);
}
@@ -227,7 +227,7 @@ inline zbacking_offset_end to_zbacking_offset_end(zbacking_offset start, size_t
}
inline zbacking_offset_end to_zbacking_offset_end(uintptr_t value) {
- assert(value <= ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZAddressOffsetMax);
+ assert(value <= ZBackingOffsetMax, "Value out of bounds (" PTR_FORMAT " <= " PTR_FORMAT ")", value, ZBackingOffsetMax);
return zbacking_offset_end(value);
}
diff --git a/src/hotspot/share/jfr/recorder/jfrRecorder.cpp b/src/hotspot/share/jfr/recorder/jfrRecorder.cpp
index 6a6da0f9b04..061e3feac6f 100644
--- a/src/hotspot/share/jfr/recorder/jfrRecorder.cpp
+++ b/src/hotspot/share/jfr/recorder/jfrRecorder.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, 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
@@ -240,7 +240,7 @@ bool JfrRecorder::on_create_vm_2() {
}
bool JfrRecorder::on_create_vm_3() {
- JVMTI_ONLY( assert(JvmtiEnvBase::get_phase() == JVMTI_PHASE_LIVE, "invalid init sequence"); )
+ JVMTI_ONLY( assert(JvmtiEnvBase::get_phase() == JVMTI_PHASE_LIVE, "invalid init sequence, phase is %d", (int)JvmtiEnvBase::get_phase()); )
return CDSConfig::is_dumping_archive() || launch_command_line_recordings(JavaThread::current());
}
diff --git a/src/hotspot/share/memory/arena.hpp b/src/hotspot/share/memory/arena.hpp
index a8450b5543a..7d88c79ca52 100644
--- a/src/hotspot/share/memory/arena.hpp
+++ b/src/hotspot/share/memory/arena.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2026, 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
@@ -101,6 +101,7 @@ class Chunk {
FN(ra, Resource areas) \
FN(node, C2 Node arena) \
FN(comp, C2 Compile arena) \
+ FN(idealloop, C2 Ideal Loop arena) \
FN(type, C2 Type arena) \
FN(states, C2 Matcher States Arena) \
FN(reglive, C2 Register Allocation Live Arenas) \
diff --git a/src/hotspot/share/memory/metaspace/blockTree.cpp b/src/hotspot/share/memory/metaspace/blockTree.cpp
index 7ad24353c96..bdae317a0b9 100644
--- a/src/hotspot/share/memory/metaspace/blockTree.cpp
+++ b/src/hotspot/share/memory/metaspace/blockTree.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020, 2022 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@@ -39,18 +39,14 @@ const size_t BlockTree::MinWordSize;
#define NODE_FORMAT \
"@" PTR_FORMAT \
": canary " INTPTR_FORMAT \
- ", parent " PTR_FORMAT \
- ", left " PTR_FORMAT \
- ", right " PTR_FORMAT \
+ ", tree " PTR_FORMAT \
", next " PTR_FORMAT \
", size %zu"
#define NODE_FORMAT_ARGS(n) \
p2i(n), \
(n)->_canary, \
- p2i((n)->_parent), \
- p2i((n)->_left), \
- p2i((n)->_right), \
+ p2i(&(n)->_tree_node), \
p2i((n)->_next), \
(n)->_word_size
@@ -74,15 +70,6 @@ const size_t BlockTree::MinWordSize;
#define tree_assert_invalid_node(cond, failure_node) \
tree_assert(cond, "Invalid node: " NODE_FORMAT, NODE_FORMAT_ARGS(failure_node))
-// walkinfo keeps a node plus the size corridor it and its children
-// are supposed to be in.
-struct BlockTree::walkinfo {
- BlockTree::Node* n;
- int depth;
- size_t lim1; // (
- size_t lim2; // )
-};
-
// Helper for verify()
void BlockTree::verify_node_pointer(const Node* n) const {
tree_assert(os::is_readable_pointer(n),
@@ -98,80 +85,32 @@ void BlockTree::verify_node_pointer(const Node* n) const {
void BlockTree::verify() const {
// Traverse the tree and test that all nodes are in the correct order.
-
MemRangeCounter counter;
- if (_root != nullptr) {
-
- ResourceMark rm;
- GrowableArray stack;
-
- walkinfo info;
- info.n = _root;
- info.lim1 = 0;
- info.lim2 = SIZE_MAX;
- info.depth = 0;
- stack.push(info);
+ // Verifies node ordering (n1 < n2 => word_size1 < word_size2),
+ // node validity, and that the tree is balanced and not ill-formed.
+ _tree.verify_self([&](const TreeNode* tree_node) {
+ const Node* n = Node::cast_to_node(tree_node);
- while (stack.length() > 0) {
- info = stack.pop();
- const Node* n = info.n;
+ verify_node_pointer(n);
- verify_node_pointer(n);
+ counter.add(n->_word_size);
- // Assume a (ridiculously large) edge limit to catch cases
- // of badly degenerated or circular trees.
- tree_assert(info.depth < 10000, "too deep (%d)", info.depth);
- counter.add(n->_word_size);
+ tree_assert_invalid_node(n->_word_size >= MinWordSize, n);
+ tree_assert_invalid_node(n->_word_size <= chunklevel::MAX_CHUNK_WORD_SIZE, n);
- if (n == _root) {
- tree_assert_invalid_node(n->_parent == nullptr, n);
- } else {
- tree_assert_invalid_node(n->_parent != nullptr, n);
- }
-
- // check size and ordering
- tree_assert_invalid_node(n->_word_size >= MinWordSize, n);
- tree_assert_invalid_node(n->_word_size <= chunklevel::MAX_CHUNK_WORD_SIZE, n);
- tree_assert_invalid_node(n->_word_size > info.lim1, n);
- tree_assert_invalid_node(n->_word_size < info.lim2, n);
-
- // Check children
- if (n->_left != nullptr) {
- tree_assert_invalid_node(n->_left != n, n);
- tree_assert_invalid_node(n->_left->_parent == n, n);
-
- walkinfo info2;
- info2.n = n->_left;
- info2.lim1 = info.lim1;
- info2.lim2 = n->_word_size;
- info2.depth = info.depth + 1;
- stack.push(info2);
- }
-
- if (n->_right != nullptr) {
- tree_assert_invalid_node(n->_right != n, n);
- tree_assert_invalid_node(n->_right->_parent == n, n);
-
- walkinfo info2;
- info2.n = n->_right;
- info2.lim1 = n->_word_size;
- info2.lim2 = info.lim2;
- info2.depth = info.depth + 1;
- stack.push(info2);
- }
-
- // If node has same-sized siblings check those too.
- const Node* n2 = n->_next;
- while (n2 != nullptr) {
- verify_node_pointer(n2);
- tree_assert_invalid_node(n2 != n, n2); // catch simple circles
- tree_assert_invalid_node(n2->_word_size == n->_word_size, n2);
- counter.add(n2->_word_size);
- n2 = n2->_next;
- }
+ // If node has same-sized siblings check those too.
+ const Node* n2 = n->_next;
+ while (n2 != nullptr) {
+ verify_node_pointer(n2);
+ tree_assert_invalid_node(n2 != n, n2); // catch simple circles
+ tree_assert_invalid_node(n2->_word_size == n->_word_size, n2);
+ counter.add(n2->_word_size);
+ n2 = n2->_next;
}
- }
+
+ return true;
+ });
// At the end, check that counters match
// (which also verifies that we visited every node, or at least
@@ -189,64 +128,34 @@ void BlockTree::print_tree(outputStream* st) const {
// as a quasi list is much clearer to the eye.
// We print the tree depth-first, with stacked nodes below normal ones
// (normal "real" nodes are marked with a leading '+')
- if (_root != nullptr) {
-
- ResourceMark rm;
- GrowableArray stack;
+ if (is_empty()) {
+ st->print_cr("");
+ return;
+ }
- walkinfo info;
- info.n = _root;
- info.depth = 0;
+ _tree.print_on(st, [&](outputStream *st, const TreeNode *tree_node, int depth) {
+ const Node* n = Node::cast_to_node(tree_node);
- stack.push(info);
- while (stack.length() > 0) {
- info = stack.pop();
- const Node* n = info.n;
+ // Print node.
+ st->print("%4d + ", depth);
+ if (os::is_readable_pointer(n)) {
+ st->print_cr(NODE_FORMAT, NODE_FORMAT_ARGS(n));
+ } else {
+ st->print_cr("@" PTR_FORMAT ": unreadable", p2i(n));
+ return;
+ }
- // Print node.
- st->print("%4d + ", info.depth);
- if (os::is_readable_pointer(n)) {
- st->print_cr(NODE_FORMAT, NODE_FORMAT_ARGS(n));
+ // Print same-sized-nodes stacked under this node
+ for (Node* n2 = n->_next; n2 != nullptr; n2 = n2->_next) {
+ st->print_raw(" ");
+ if (os::is_readable_pointer(n2)) {
+ st->print_cr(NODE_FORMAT, NODE_FORMAT_ARGS(n2));
} else {
- st->print_cr("@" PTR_FORMAT ": unreadable (skipping subtree)", p2i(n));
- continue; // don't print this subtree
- }
-
- // Print same-sized-nodes stacked under this node
- for (Node* n2 = n->_next; n2 != nullptr; n2 = n2->_next) {
- st->print_raw(" ");
- if (os::is_readable_pointer(n2)) {
- st->print_cr(NODE_FORMAT, NODE_FORMAT_ARGS(n2));
- } else {
- st->print_cr("@" PTR_FORMAT ": unreadable (skipping rest of chain).", p2i(n2));
- break; // stop printing this chain.
- }
- }
-
- // Handle simple circularities
- if (n == n->_right || n == n->_left || n == n->_next) {
- st->print_cr("@" PTR_FORMAT ": circularity detected.", p2i(n));
- return; // stop printing
- }
-
- // Handle children.
- if (n->_right != nullptr) {
- walkinfo info2;
- info2.n = n->_right;
- info2.depth = info.depth + 1;
- stack.push(info2);
- }
- if (n->_left != nullptr) {
- walkinfo info2;
- info2.n = n->_left;
- info2.depth = info.depth + 1;
- stack.push(info2);
+ st->print_cr("@" PTR_FORMAT ": unreadable (skipping rest of chain).", p2i(n2));
+ break; // stop printing this chain.
}
}
-
- } else {
- st->print_cr("");
- }
+ });
}
#endif // ASSERT
diff --git a/src/hotspot/share/memory/metaspace/blockTree.hpp b/src/hotspot/share/memory/metaspace/blockTree.hpp
index a01f60b166f..e7c1edf9c4f 100644
--- a/src/hotspot/share/memory/metaspace/blockTree.hpp
+++ b/src/hotspot/share/memory/metaspace/blockTree.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2020, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2020, 2026, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2020 SAP SE. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
@@ -32,17 +32,18 @@
#include "memory/metaspace/metablock.hpp"
#include "utilities/debug.hpp"
#include "utilities/globalDefinitions.hpp"
+#include "utilities/rbTree.inline.hpp"
namespace metaspace {
-// BlockTree is a rather simple binary search tree. It is used to
-// manage medium to large free memory blocks.
+// BlockTree is tree built on an intrusive red-black tree.
+// It is used to manage medium to large free memory blocks.
//
// There is no separation between payload (managed blocks) and nodes: the
// memory blocks themselves are the nodes, with the block size being the key.
//
// We store node pointer information in these blocks when storing them. That
-// imposes a minimum size to the managed memory blocks (1 word)
+// imposes a minimum size to the managed memory blocks (1 MinWordSize)
//
// We want to manage many memory blocks of the same size, but we want
// to prevent the tree from blowing up and degenerating into a list. Therefore
@@ -53,9 +54,9 @@ namespace metaspace {
// | 100 |
// +-----+
// / \
-// +-----+
-// | 80 |
-// +-----+
+// +-----+ +-----+
+// | 80 | | 120 |
+// +-----+ +-----+
// / | \
// / +-----+ \
// +-----+ | 80 | +-----+
@@ -65,16 +66,11 @@ namespace metaspace {
// | 80 |
// +-----+
//
-//
-// Todo: This tree is unbalanced. It would be a good fit for a red-black tree.
-// In order to make this a red-black tree, we need an algorithm which can deal
-// with nodes which are their own payload (most red-black tree implementations
-// swap payloads of their nodes at some point, see e.g. j.u.TreeSet).
-// A good example is the Linux kernel rbtree, which is a clean, easy-to-read
-// implementation.
class BlockTree: public CHeapObj {
+ using TreeNode = IntrusiveRBNode;
+
struct Node {
static const intptr_t _canary_value =
@@ -86,29 +82,27 @@ class BlockTree: public CHeapObj {
// in debug.
const intptr_t _canary;
- // Normal tree node stuff...
- // (Note: all null if this is a stacked node)
- Node* _parent;
- Node* _left;
- Node* _right;
+ // Tree node for linking blocks in the intrusive tree.
+ TreeNode _tree_node;
// Blocks with the same size are put in a list with this node as head.
Node* _next;
// Word size of node. Note that size cannot be larger than max metaspace size,
- // so this could be very well a 32bit value (in case we ever make this a balancing
- // tree and need additional space for weighting information).
+ // so this could very well be a 32bit value.
const size_t _word_size;
Node(size_t word_size) :
_canary(_canary_value),
- _parent(nullptr),
- _left(nullptr),
- _right(nullptr),
+ _tree_node{},
_next(nullptr),
_word_size(word_size)
{}
+ static Node* cast_to_node(const TreeNode* tree_node) {
+ return (Node*)((uintptr_t)tree_node - offset_of(Node, _tree_node));
+ }
+
#ifdef ASSERT
bool valid() const {
return _canary == _canary_value &&
@@ -118,8 +112,23 @@ class BlockTree: public CHeapObj {
#endif
};
- // Needed for verify() and print_tree()
- struct walkinfo;
+ struct TreeComparator {
+ static RBTreeOrdering cmp(const size_t a, const TreeNode* b) {
+ const size_t node_word_size = Node::cast_to_node(b)->_word_size;
+
+ if (a < node_word_size) { return RBTreeOrdering::LT; }
+ if (a > node_word_size) { return RBTreeOrdering::GT; }
+ return RBTreeOrdering::EQ;
+ }
+
+ static bool less_than(const TreeNode* a, const TreeNode* b) {
+ const size_t a_word_size = Node::cast_to_node(a)->_word_size;
+ const size_t b_word_size = Node::cast_to_node(b)->_word_size;
+
+ if (a_word_size < b_word_size) { return true; }
+ return false;
+ }
+ };
#ifdef ASSERT
// Run a quick check on a node; upon suspicion dive into a full tree check.
@@ -134,7 +143,7 @@ class BlockTree: public CHeapObj {
private:
- Node* _root;
+ IntrusiveRBTree _tree;
MemRangeCounter _counter;
@@ -143,7 +152,7 @@ class BlockTree: public CHeapObj {
assert(head->_word_size == n->_word_size, "sanity");
n->_next = head->_next;
head->_next = n;
- DEBUG_ONLY(n->_left = n->_right = n->_parent = nullptr;)
+ DEBUG_ONLY(n->_tree_node = TreeNode());
}
// Given a node list starting at head, remove one of the follow up nodes from
@@ -157,183 +166,6 @@ class BlockTree: public CHeapObj {
return n;
}
- // Given a node c and a node p, wire up c as left child of p.
- static void set_left_child(Node* p, Node* c) {
- p->_left = c;
- if (c != nullptr) {
- assert(c->_word_size < p->_word_size, "sanity");
- c->_parent = p;
- }
- }
-
- // Given a node c and a node p, wire up c as right child of p.
- static void set_right_child(Node* p, Node* c) {
- p->_right = c;
- if (c != nullptr) {
- assert(c->_word_size > p->_word_size, "sanity");
- c->_parent = p;
- }
- }
-
- // Given a node n, return its successor in the tree
- // (node with the next-larger size).
- static Node* successor(Node* n) {
- Node* succ = nullptr;
- if (n->_right != nullptr) {
- // If there is a right child, search the left-most
- // child of that child.
- succ = n->_right;
- while (succ->_left != nullptr) {
- succ = succ->_left;
- }
- } else {
- succ = n->_parent;
- Node* n2 = n;
- // As long as I am the right child of my parent, search upward
- while (succ != nullptr && n2 == succ->_right) {
- n2 = succ;
- succ = succ->_parent;
- }
- }
- return succ;
- }
-
- // Given a node, replace it with a replacement node as a child for its parent.
- // If the node is root and has no parent, sets it as root.
- void replace_node_in_parent(Node* child, Node* replace) {
- Node* parent = child->_parent;
- if (parent != nullptr) {
- if (parent->_left == child) { // Child is left child
- set_left_child(parent, replace);
- } else {
- set_right_child(parent, replace);
- }
- } else {
- assert(child == _root, "must be root");
- _root = replace;
- if (replace != nullptr) {
- replace->_parent = nullptr;
- }
- }
- return;
- }
-
- // Given a node n and an insertion point, insert n under insertion point.
- void insert(Node* insertion_point, Node* n) {
- assert(n->_parent == nullptr, "Sanity");
- for (;;) {
- DEBUG_ONLY(check_node(insertion_point);)
- if (n->_word_size == insertion_point->_word_size) {
- add_to_list(n, insertion_point); // parent stays null in this case.
- break;
- } else if (n->_word_size > insertion_point->_word_size) {
- if (insertion_point->_right == nullptr) {
- set_right_child(insertion_point, n);
- break;
- } else {
- insertion_point = insertion_point->_right;
- }
- } else {
- if (insertion_point->_left == nullptr) {
- set_left_child(insertion_point, n);
- break;
- } else {
- insertion_point = insertion_point->_left;
- }
- }
- }
- }
-
- // Given a node and a wish size, search this node and all children for
- // the node closest (equal or larger sized) to the size s.
- Node* find_closest_fit(Node* n, size_t s) {
- Node* best_match = nullptr;
- while (n != nullptr) {
- DEBUG_ONLY(check_node(n);)
- if (n->_word_size >= s) {
- best_match = n;
- if (n->_word_size == s) {
- break; // perfect match or max depth reached
- }
- n = n->_left;
- } else {
- n = n->_right;
- }
- }
- return best_match;
- }
-
- // Given a wish size, search the whole tree for a
- // node closest (equal or larger sized) to the size s.
- Node* find_closest_fit(size_t s) {
- if (_root != nullptr) {
- return find_closest_fit(_root, s);
- }
- return nullptr;
- }
-
- // Given a node n, remove it from the tree and repair tree.
- void remove_node_from_tree(Node* n) {
- assert(n->_next == nullptr, "do not delete a node which has a non-empty list");
-
- if (n->_left == nullptr && n->_right == nullptr) {
- replace_node_in_parent(n, nullptr);
-
- } else if (n->_left == nullptr && n->_right != nullptr) {
- replace_node_in_parent(n, n->_right);
-
- } else if (n->_left != nullptr && n->_right == nullptr) {
- replace_node_in_parent(n, n->_left);
-
- } else {
- // Node has two children.
-
- // 1) Find direct successor (the next larger node).
- Node* succ = successor(n);
-
- // There has to be a successor since n->right was != null...
- assert(succ != nullptr, "must be");
-
- // ... and it should not have a left child since successor
- // is supposed to be the next larger node, so it must be the mostleft node
- // in the sub tree rooted at n->right
- assert(succ->_left == nullptr, "must be");
- assert(succ->_word_size > n->_word_size, "sanity");
-
- Node* successor_parent = succ->_parent;
- Node* successor_right_child = succ->_right;
-
- // Remove successor from its parent.
- if (successor_parent == n) {
-
- // special case: successor is a direct child of n. Has to be the right child then.
- assert(n->_right == succ, "sanity");
-
- // Just replace n with this successor.
- replace_node_in_parent(n, succ);
-
- // Take over n's old left child, too.
- // We keep the successor's right child.
- set_left_child(succ, n->_left);
- } else {
- // If the successors parent is not n, we are deeper in the tree,
- // the successor has to be the left child of its parent.
- assert(successor_parent->_left == succ, "sanity");
-
- // The right child of the successor (if there was one) replaces
- // the successor at its parent's left child.
- set_left_child(successor_parent, succ->_right);
-
- // and the successor replaces n at its parent
- replace_node_in_parent(n, succ);
-
- // and takes over n's old children
- set_left_child(succ, n->_left);
- set_right_child(succ, n->_right);
- }
- }
- }
-
#ifdef ASSERT
void zap_block(MetaBlock block);
// Helper for verify()
@@ -342,7 +174,7 @@ class BlockTree: public CHeapObj {
public:
- BlockTree() : _root(nullptr) {}
+ BlockTree() {}
// Add a memory block to the tree. Its content will be overwritten.
void add_block(MetaBlock block) {
@@ -350,10 +182,12 @@ class BlockTree: public CHeapObj {
const size_t word_size = block.word_size();
assert(word_size >= MinWordSize, "invalid block size %zu", word_size);
Node* n = new(block.base()) Node(word_size);
- if (_root == nullptr) {
- _root = n;
- } else {
- insert(_root, n);
+ IntrusiveRBTree::Cursor cursor = _tree.cursor(word_size);
+ if (cursor.found()) {
+ add_to_list(n, Node::cast_to_node(cursor.node()));
+ }
+ else {
+ _tree.insert_at_cursor(&n->_tree_node, cursor);
}
_counter.add(word_size);
}
@@ -364,9 +198,10 @@ class BlockTree: public CHeapObj {
assert(word_size >= MinWordSize, "invalid block size %zu", word_size);
MetaBlock result;
- Node* n = find_closest_fit(word_size);
+ TreeNode* tree_node = _tree.closest_ge(word_size);
- if (n != nullptr) {
+ if (tree_node != nullptr) {
+ Node* n = Node::cast_to_node(tree_node);
DEBUG_ONLY(check_node(n);)
assert(n->_word_size >= word_size, "sanity");
@@ -377,7 +212,7 @@ class BlockTree: public CHeapObj {
// node into its place in the tree).
n = remove_from_list(n);
} else {
- remove_node_from_tree(n);
+ _tree.remove(tree_node);
}
result = MetaBlock((MetaWord*)n, n->_word_size);
@@ -395,7 +230,7 @@ class BlockTree: public CHeapObj {
// Returns total size, in words, of all elements.
size_t total_size() const { return _counter.total_size(); }
- bool is_empty() const { return _root == nullptr; }
+ bool is_empty() const { return _tree.size() == 0; }
DEBUG_ONLY(void print_tree(outputStream* st) const;)
DEBUG_ONLY(void verify() const;)
diff --git a/src/hotspot/share/nmt/mallocHeader.cpp b/src/hotspot/share/nmt/mallocHeader.cpp
index d88b5c790fb..e74e74fde48 100644
--- a/src/hotspot/share/nmt/mallocHeader.cpp
+++ b/src/hotspot/share/nmt/mallocHeader.cpp
@@ -75,4 +75,4 @@ void MallocHeader::print_block_on_error(outputStream* st, address bad_address, a
// print one hex dump
os::print_hex_dump(st, from1, to2, 1);
}
-}
+}
\ No newline at end of file
diff --git a/src/hotspot/share/nmt/mallocHeader.hpp b/src/hotspot/share/nmt/mallocHeader.hpp
index 45568243ef3..33e288dd8e4 100644
--- a/src/hotspot/share/nmt/mallocHeader.hpp
+++ b/src/hotspot/share/nmt/mallocHeader.hpp
@@ -27,10 +27,18 @@
#define SHARE_NMT_MALLOCHEADER_HPP
#include "nmt/memTag.hpp"
+#include "sanitizers/address.hpp"
#include "utilities/globalDefinitions.hpp"
#include "utilities/macros.hpp"
#include "utilities/nativeCallStack.hpp"
+// With ASAN, we omit NMT block integrity checks since ASAN does a better and faster
+// job of alerting us to memory corruptions
+#if INCLUDE_ASAN
+#undef NMT_BLOCK_INTEGRITY_CHECKS
+#else
+#define NMT_BLOCK_INTEGRITY_CHECKS
+#endif
class outputStream;
/*
@@ -118,6 +126,7 @@ class MallocHeader {
inline static OutTypeParam resolve_checked_impl(InTypeParam memblock);
public:
+ static constexpr size_t footer_size = sizeof(uint16_t);
// Contains all of the necessary data to to deaccount block with NMT.
struct FreeInfo {
const size_t size;
@@ -126,8 +135,9 @@ class MallocHeader {
};
inline MallocHeader(size_t size, MemTag mem_tag, uint32_t mst_marker);
-
- inline static size_t malloc_overhead() { return sizeof(MallocHeader) + sizeof(uint16_t); }
+ inline static size_t malloc_overhead() { return sizeof(MallocHeader) + footer_size; }
+ inline static MallocHeader* kill_block(void* memblock);
+ inline static void revive_block(void* memblock);
inline size_t size() const { return _size; }
inline MemTag mem_tag() const { return _mem_tag; }
inline uint32_t mst_marker() const { return _mst_marker; }
@@ -164,5 +174,4 @@ class MallocHeader {
// This needs to be true on both 64-bit and 32-bit platforms
STATIC_ASSERT(sizeof(MallocHeader) == (sizeof(uint64_t) * 2));
-
-#endif // SHARE_NMT_MALLOCHEADER_HPP
+#endif // SHARE_NMT_MALLOCHEADER_HPP
\ No newline at end of file
diff --git a/src/hotspot/share/nmt/mallocHeader.inline.hpp b/src/hotspot/share/nmt/mallocHeader.inline.hpp
index 0ad0b3ddc81..09ab872c780 100644
--- a/src/hotspot/share/nmt/mallocHeader.inline.hpp
+++ b/src/hotspot/share/nmt/mallocHeader.inline.hpp
@@ -46,9 +46,6 @@ inline MallocHeader::MallocHeader(size_t size, MemTag mem_tag, uint32_t mst_mark
}
inline void MallocHeader::revive() {
- assert(_canary == _header_canary_dead_mark, "must be dead");
- assert(get_footer() == _footer_canary_dead_mark, "must be dead");
- NOT_LP64(assert(_alt_canary == _header_alt_canary_dead_mark, "must be dead"));
_canary = _header_canary_live_mark;
NOT_LP64(_alt_canary = _header_alt_canary_live_mark);
set_footer(_footer_canary_live_mark);
@@ -96,16 +93,18 @@ inline bool MallocHeader::is_valid_malloced_pointer(const void* payload, char* m
template
inline OutTypeParam MallocHeader::resolve_checked_impl(InTypeParam memblock) {
- char msg[256];
- address corruption = nullptr;
- if (!is_valid_malloced_pointer(memblock, msg, sizeof(msg))) {
- fatal("Not a valid malloc pointer: " PTR_FORMAT ": %s", p2i(memblock), msg);
- }
OutTypeParam header_pointer = (OutTypeParam)memblock - 1;
- if (!header_pointer->check_block_integrity(msg, sizeof(msg), &corruption)) {
- header_pointer->print_block_on_error(tty, corruption != nullptr ? corruption : (address)header_pointer, (address)header_pointer);
- fatal("NMT has detected a memory corruption bug. Block at " PTR_FORMAT ": %s", p2i(memblock), msg);
- }
+ #ifdef NMT_BLOCK_INTEGRITY_CHECKS
+ char msg[256];
+ address corruption = nullptr;
+ if (!is_valid_malloced_pointer(memblock, msg, sizeof(msg))) {
+ fatal("Not a valid malloc pointer: " PTR_FORMAT ": %s", p2i(memblock), msg);
+ }
+ if (!header_pointer->check_block_integrity(msg, sizeof(msg), &corruption)) {
+ header_pointer->print_block_on_error(tty, corruption != nullptr ? corruption : (address)header_pointer, (address)header_pointer);
+ fatal("NMT has detected a memory corruption bug. Block at " PTR_FORMAT ": %s", p2i(memblock), msg);
+ }
+ #endif
return header_pointer;
}
@@ -163,4 +162,20 @@ inline bool MallocHeader::check_block_integrity(char* msg, size_t msglen, addres
return true;
}
+MallocHeader* MallocHeader::kill_block(void* memblock) {
+ MallocHeader* header = (MallocHeader*)memblock - 1;
+ ASAN_UNPOISON_MEMORY_REGION(header, sizeof(MallocHeader));
+ ASAN_UNPOISON_MEMORY_REGION(header->footer_address(), footer_size);
+ resolve_checked(memblock);
+ header->mark_block_as_dead();
+ return header;
+}
+
+void MallocHeader::revive_block(void* memblock) {
+ MallocHeader* header = (MallocHeader*)memblock - 1;
+ header->revive();
+ ASAN_POISON_MEMORY_REGION(header->footer_address(), footer_size);
+ ASAN_POISON_MEMORY_REGION(header, sizeof(MallocHeader));
+}
+
#endif // SHARE_NMT_MALLOCHEADER_INLINE_HPP
diff --git a/src/hotspot/share/nmt/mallocTracker.cpp b/src/hotspot/share/nmt/mallocTracker.cpp
index 2cf5034c0bf..532b6f41bd0 100644
--- a/src/hotspot/share/nmt/mallocTracker.cpp
+++ b/src/hotspot/share/nmt/mallocTracker.cpp
@@ -199,7 +199,7 @@ void* MallocTracker::record_malloc(void* malloc_base, size_t size, MemTag mem_ta
assert(header2->mem_tag() == mem_tag, "Wrong memory tag");
}
#endif
-
+ MallocHeader::revive_block(memblock);
return memblock;
}
@@ -207,7 +207,7 @@ void* MallocTracker::record_free_block(void* memblock) {
assert(MemTracker::enabled(), "Sanity");
assert(memblock != nullptr, "precondition");
- MallocHeader* header = MallocHeader::resolve_checked(memblock);
+ MallocHeader* header = MallocHeader::kill_block(memblock);
deaccount(header->free_info());
@@ -218,7 +218,6 @@ void* MallocTracker::record_free_block(void* memblock) {
}
header->mark_block_as_dead();
-
return (void*)header;
}
diff --git a/src/hotspot/share/nmt/mallocTracker.hpp b/src/hotspot/share/nmt/mallocTracker.hpp
index fc03faf7212..e96396ebbcb 100644
--- a/src/hotspot/share/nmt/mallocTracker.hpp
+++ b/src/hotspot/share/nmt/mallocTracker.hpp
@@ -311,15 +311,6 @@ class MallocTracker : AllStatic {
// totally failproof. Only use this during debugging or when you can afford
// signals popping up, e.g. when writing an hs_err file.
static bool print_pointer_information(const void* p, outputStream* st);
-
- static inline MallocHeader* malloc_header(void *memblock) {
- assert(memblock != nullptr, "null pointer");
- return (MallocHeader*)memblock -1;
- }
- static inline const MallocHeader* malloc_header(const void *memblock) {
- assert(memblock != nullptr, "null pointer");
- return (const MallocHeader*)memblock -1;
- }
};
#endif // SHARE_NMT_MALLOCTRACKER_HPP
diff --git a/src/hotspot/share/opto/compile.cpp b/src/hotspot/share/opto/compile.cpp
index eaec1605108..77b7636a150 100644
--- a/src/hotspot/share/opto/compile.cpp
+++ b/src/hotspot/share/opto/compile.cpp
@@ -2098,6 +2098,7 @@ void Compile::inline_boxing_calls(PhaseIterGVN& igvn) {
bool Compile::inline_incrementally_one() {
assert(IncrementalInline, "incremental inlining should be on");
+ assert(_late_inlines.length() > 0, "should have been checked by caller");
TracePhase tp(_t_incrInline_inline);
@@ -2170,6 +2171,21 @@ void Compile::inline_incrementally_cleanup(PhaseIterGVN& igvn) {
print_method(PHASE_INCREMENTAL_INLINE_CLEANUP, 3);
}
+template
+static void shuffle_array(Compile& C, GrowableArray& array) {
+ if (array.length() < 2) {
+ return;
+ }
+ for (uint i = array.length() - 1; i >= 1; i--) {
+ uint j = C.random() % (i + 1);
+ swap(array.at(i), array.at(j));
+ }
+}
+
+void Compile::shuffle_late_inlines() {
+ shuffle_array(*C, _late_inlines);
+}
+
// Perform incremental inlining until bound on number of live nodes is reached
void Compile::inline_incrementally(PhaseIterGVN& igvn) {
TracePhase tp(_t_incrInline);
@@ -2177,6 +2193,10 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
set_inlining_incrementally(true);
uint low_live_nodes = 0;
+ if (StressIncrementalInlining) {
+ shuffle_late_inlines();
+ }
+
while (_late_inlines.length() > 0) {
if (live_nodes() > (uint)LiveNodeCountInliningCutoff) {
if (low_live_nodes < (uint)LiveNodeCountInliningCutoff * 8 / 10) {
@@ -2209,6 +2229,10 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
igvn_worklist()->ensure_empty(); // should be done with igvn
+ if (_late_inlines.length() == 0) {
+ break; // no more progress
+ }
+
while (inline_incrementally_one()) {
assert(!failing_internal() || failure_is_artificial(), "inconsistent");
}
@@ -2219,10 +2243,6 @@ void Compile::inline_incrementally(PhaseIterGVN& igvn) {
print_method(PHASE_INCREMENTAL_INLINE_STEP, 3);
if (failing()) return;
-
- if (_late_inlines.length() == 0) {
- break; // no more progress
- }
}
igvn_worklist()->ensure_empty(); // should be done with igvn
@@ -2249,6 +2269,10 @@ void Compile::process_late_inline_calls_no_inline(PhaseIterGVN& igvn) {
assert(_modified_nodes == nullptr, "not allowed");
assert(_late_inlines.length() > 0, "sanity");
+ if (StressIncrementalInlining) {
+ shuffle_late_inlines();
+ }
+
while (_late_inlines.length() > 0) {
igvn_worklist()->ensure_empty(); // should be done with igvn
@@ -5140,13 +5164,7 @@ void CloneMap::dump(node_idx_t key, outputStream* st) const {
}
void Compile::shuffle_macro_nodes() {
- if (_macro_nodes.length() < 2) {
- return;
- }
- for (uint i = _macro_nodes.length() - 1; i >= 1; i--) {
- uint j = C->random() % (i + 1);
- swap(_macro_nodes.at(i), _macro_nodes.at(j));
- }
+ shuffle_array(*C, _macro_nodes);
}
// Move Allocate nodes to the start of the list
diff --git a/src/hotspot/share/opto/compile.hpp b/src/hotspot/share/opto/compile.hpp
index d9a8ea15724..eb6be669f24 100644
--- a/src/hotspot/share/opto/compile.hpp
+++ b/src/hotspot/share/opto/compile.hpp
@@ -795,6 +795,7 @@ class Compile : public Phase {
void remove_from_merge_stores_igvn(Node* n);
void process_for_merge_stores_igvn(PhaseIterGVN& igvn);
+ void shuffle_late_inlines();
void shuffle_macro_nodes();
void sort_macro_nodes();
@@ -1059,6 +1060,13 @@ class Compile : public Phase {
// Record this CallGenerator for inlining at the end of parsing.
void add_late_inline(CallGenerator* cg) {
_late_inlines.insert_before(_late_inlines_pos, cg);
+ if (StressIncrementalInlining) {
+ assert(_late_inlines_pos < _late_inlines.length(), "unthinkable!");
+ if (_late_inlines.length() - _late_inlines_pos >= 2) {
+ int j = (C->random() % (_late_inlines.length() - _late_inlines_pos)) + _late_inlines_pos;
+ swap(_late_inlines.at(_late_inlines_pos), _late_inlines.at(j));
+ }
+ }
_late_inlines_pos++;
}
diff --git a/src/hotspot/share/opto/escape.cpp b/src/hotspot/share/opto/escape.cpp
index 357c91e8eb5..b46a12fcf89 100644
--- a/src/hotspot/share/opto/escape.cpp
+++ b/src/hotspot/share/opto/escape.cpp
@@ -3511,10 +3511,7 @@ bool ConnectionGraph::is_oop_field(Node* n, int offset, bool* unsafe) {
bt = field->layout_type();
} else {
// Check for unsafe oop field access
- if (n->has_out_with(Op_StoreP, Op_LoadP, Op_StoreN, Op_LoadN) ||
- n->has_out_with(Op_GetAndSetP, Op_GetAndSetN, Op_CompareAndExchangeP, Op_CompareAndExchangeN) ||
- n->has_out_with(Op_CompareAndSwapP, Op_CompareAndSwapN, Op_WeakCompareAndSwapP, Op_WeakCompareAndSwapN) ||
- BarrierSet::barrier_set()->barrier_set_c2()->escape_has_out_with_unsafe_object(n)) {
+ if (has_oop_node_outs(n)) {
bt = T_OBJECT;
(*unsafe) = true;
}
@@ -3530,16 +3527,22 @@ bool ConnectionGraph::is_oop_field(Node* n, int offset, bool* unsafe) {
}
} else if (adr_type->isa_rawptr() || adr_type->isa_klassptr()) {
// Allocation initialization, ThreadLocal field access, unsafe access
- if (n->has_out_with(Op_StoreP, Op_LoadP, Op_StoreN, Op_LoadN) ||
- n->has_out_with(Op_GetAndSetP, Op_GetAndSetN, Op_CompareAndExchangeP, Op_CompareAndExchangeN) ||
- n->has_out_with(Op_CompareAndSwapP, Op_CompareAndSwapN, Op_WeakCompareAndSwapP, Op_WeakCompareAndSwapN) ||
- BarrierSet::barrier_set()->barrier_set_c2()->escape_has_out_with_unsafe_object(n)) {
+ if (has_oop_node_outs(n)) {
bt = T_OBJECT;
}
}
}
// Note: T_NARROWOOP is not classed as a real reference type
- return (is_reference_type(bt) || bt == T_NARROWOOP);
+ bool res = (is_reference_type(bt) || bt == T_NARROWOOP);
+ assert(!has_oop_node_outs(n) || res, "sanity: AddP has oop outs, needs to be treated as oop field");
+ return res;
+}
+
+bool ConnectionGraph::has_oop_node_outs(Node* n) {
+ return n->has_out_with(Op_StoreP, Op_LoadP, Op_StoreN, Op_LoadN) ||
+ n->has_out_with(Op_GetAndSetP, Op_GetAndSetN, Op_CompareAndExchangeP, Op_CompareAndExchangeN) ||
+ n->has_out_with(Op_CompareAndSwapP, Op_CompareAndSwapN, Op_WeakCompareAndSwapP, Op_WeakCompareAndSwapN) ||
+ BarrierSet::barrier_set()->barrier_set_c2()->escape_has_out_with_unsafe_object(n);
}
// Returns unique pointed java object or null.
diff --git a/src/hotspot/share/opto/escape.hpp b/src/hotspot/share/opto/escape.hpp
index 04a9dc82982..dcb832889ec 100644
--- a/src/hotspot/share/opto/escape.hpp
+++ b/src/hotspot/share/opto/escape.hpp
@@ -539,7 +539,8 @@ class ConnectionGraph: public ArenaObj {
}
// Helper functions
- bool is_oop_field(Node* n, int offset, bool* unsafe);
+ bool is_oop_field(Node* n, int offset, bool* unsafe);
+ bool has_oop_node_outs(Node* n);
static Node* find_second_addp(Node* addp, Node* n);
// offset of a field reference
int address_offset(Node* adr, PhaseValues* phase);
diff --git a/src/hotspot/share/opto/loopnode.cpp b/src/hotspot/share/opto/loopnode.cpp
index fab354e3e3d..d68505836d4 100644
--- a/src/hotspot/share/opto/loopnode.cpp
+++ b/src/hotspot/share/opto/loopnode.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2026, 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
@@ -3752,6 +3752,20 @@ void CountedLoopEndNode::dump_spec(outputStream *st) const {
}
#endif
+IdealLoopTree::IdealLoopTree(PhaseIdealLoop* phase, Node* head, Node* tail): _parent(nullptr), _next(nullptr), _child(nullptr),
+ _head(head), _tail(tail),
+ _phase(phase),
+ _local_loop_unroll_limit(0), _local_loop_unroll_factor(0),
+ _body(phase->arena()),
+ _nest(0), _irreducible(0), _has_call(0), _has_sfpt(0), _rce_candidate(0),
+ _has_range_checks(0), _has_range_checks_computed(0),
+ _safepts(nullptr),
+ _required_safept(nullptr),
+ _allow_optimizations(true) {
+ precond(_head != nullptr);
+ precond(_tail != nullptr);
+}
+
//=============================================================================
//------------------------------is_member--------------------------------------
// Is 'l' a member of 'this'?
@@ -5089,8 +5103,8 @@ void PhaseIdealLoop::build_and_optimize() {
// Since nodes do not have a slot for immediate dominator, make
// a persistent side array for that info indexed on node->_idx.
_idom_size = C->unique();
- _idom = NEW_RESOURCE_ARRAY( Node*, _idom_size );
- _dom_depth = NEW_RESOURCE_ARRAY( uint, _idom_size );
+ _idom = NEW_ARENA_ARRAY(&_arena, Node*, _idom_size);
+ _dom_depth = NEW_ARENA_ARRAY(&_arena, uint, _idom_size);
_dom_stk = nullptr; // Allocated on demand in recompute_dom_depth
memset( _dom_depth, 0, _idom_size * sizeof(uint) );
@@ -5691,8 +5705,8 @@ void PhaseIdealLoop::set_idom(Node* d, Node* n, uint dom_depth) {
uint idx = d->_idx;
if (idx >= _idom_size) {
uint newsize = next_power_of_2(idx);
- _idom = REALLOC_RESOURCE_ARRAY( Node*, _idom,_idom_size,newsize);
- _dom_depth = REALLOC_RESOURCE_ARRAY( uint, _dom_depth,_idom_size,newsize);
+ _idom = REALLOC_ARENA_ARRAY(&_arena, Node*, _idom,_idom_size,newsize);
+ _dom_depth = REALLOC_ARENA_ARRAY(&_arena, uint, _dom_depth,_idom_size,newsize);
memset( _dom_depth + _idom_size, 0, (newsize - _idom_size) * sizeof(uint) );
_idom_size = newsize;
}
diff --git a/src/hotspot/share/opto/loopnode.hpp b/src/hotspot/share/opto/loopnode.hpp
index 24976d76a51..5b06f0555ab 100644
--- a/src/hotspot/share/opto/loopnode.hpp
+++ b/src/hotspot/share/opto/loopnode.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2026, 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
@@ -669,21 +669,7 @@ class IdealLoopTree : public ResourceObj {
Node_List* _required_safept; // A inner loop cannot delete these safepts;
bool _allow_optimizations; // Allow loop optimizations
- IdealLoopTree( PhaseIdealLoop* phase, Node *head, Node *tail )
- : _parent(nullptr), _next(nullptr), _child(nullptr),
- _head(head), _tail(tail),
- _phase(phase),
- _local_loop_unroll_limit(0), _local_loop_unroll_factor(0),
- _body(Compile::current()->comp_arena()),
- _nest(0), _irreducible(0), _has_call(0), _has_sfpt(0), _rce_candidate(0),
- _has_range_checks(0), _has_range_checks_computed(0),
- _safepts(nullptr),
- _required_safept(nullptr),
- _allow_optimizations(true)
- {
- precond(_head != nullptr);
- precond(_tail != nullptr);
- }
+ IdealLoopTree(PhaseIdealLoop* phase, Node* head, Node* tail);
// Is 'l' a member of 'this'?
bool is_member(const IdealLoopTree *l) const; // Test for nested membership
@@ -889,6 +875,8 @@ class PhaseIdealLoop : public PhaseTransform {
friend class ShenandoahBarrierC2Support;
friend class AutoNodeBudget;
+ Arena _arena; // For data whose lifetime is a single pass of loop optimizations
+
// Map loop membership for CFG nodes, and ctrl for non-CFG nodes.
//
// Exception: dead CFG nodes may instead have a ctrl/idom forwarding
@@ -1049,6 +1037,8 @@ class PhaseIdealLoop : public PhaseTransform {
PhaseIterGVN &igvn() const { return _igvn; }
+ Arena* arena() { return &_arena; };
+
bool has_node(const Node* n) const {
guarantee(n != nullptr, "No Node.");
return _loop_or_ctrl[n->_idx] != nullptr;
@@ -1223,7 +1213,8 @@ class PhaseIdealLoop : public PhaseTransform {
// Compute the Ideal Node to Loop mapping
PhaseIdealLoop(PhaseIterGVN& igvn, LoopOptsMode mode) :
PhaseTransform(Ideal_Loop),
- _loop_or_ctrl(igvn.C->comp_arena()),
+ _arena(mtCompiler, Arena::Tag::tag_idealloop),
+ _loop_or_ctrl(&_arena),
_igvn(igvn),
_verify_me(nullptr),
_verify_only(false),
@@ -1238,7 +1229,8 @@ class PhaseIdealLoop : public PhaseTransform {
// or only verify that the graph is valid if verify_me is null.
PhaseIdealLoop(PhaseIterGVN& igvn, const PhaseIdealLoop* verify_me = nullptr) :
PhaseTransform(Ideal_Loop),
- _loop_or_ctrl(igvn.C->comp_arena()),
+ _arena(mtCompiler, Arena::Tag::tag_idealloop),
+ _loop_or_ctrl(&_arena),
_igvn(igvn),
_verify_me(verify_me),
_verify_only(verify_me == nullptr),
diff --git a/src/hotspot/share/opto/macro.cpp b/src/hotspot/share/opto/macro.cpp
index 56262d226fc..9470001b2d2 100644
--- a/src/hotspot/share/opto/macro.cpp
+++ b/src/hotspot/share/opto/macro.cpp
@@ -2322,12 +2322,7 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
// No need for a null check on unlock
// Make the merge point
- Node *region;
- Node *mem_phi;
-
- region = new RegionNode(3);
- // create a Phi for the memory state
- mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
+ Node* region = new RegionNode(3);
FastUnlockNode *funlock = new FastUnlockNode( ctrl, obj, box );
funlock = transform_later( funlock )->as_FastUnlock();
@@ -2356,12 +2351,15 @@ void PhaseMacroExpand::expand_unlock_node(UnlockNode *unlock) {
transform_later(region);
_igvn.replace_node(_callprojs.fallthrough_proj, region);
- Node *memproj = transform_later(new ProjNode(call, TypeFunc::Memory) );
- mem_phi->init_req(1, memproj );
- mem_phi->init_req(2, mem);
- transform_later(mem_phi);
-
- _igvn.replace_node(_callprojs.fallthrough_memproj, mem_phi);
+ if (_callprojs.fallthrough_memproj != nullptr) {
+ // create a Phi for the memory state
+ Node* mem_phi = new PhiNode( region, Type::MEMORY, TypeRawPtr::BOTTOM);
+ Node* memproj = transform_later(new ProjNode(call, TypeFunc::Memory));
+ mem_phi->init_req(1, memproj);
+ mem_phi->init_req(2, mem);
+ transform_later(mem_phi);
+ _igvn.replace_node(_callprojs.fallthrough_memproj, mem_phi);
+ }
}
void PhaseMacroExpand::expand_subtypecheck_node(SubTypeCheckNode *check) {
diff --git a/src/hotspot/share/opto/phaseX.cpp b/src/hotspot/share/opto/phaseX.cpp
index 52badca8050..ce24c46590d 100644
--- a/src/hotspot/share/opto/phaseX.cpp
+++ b/src/hotspot/share/opto/phaseX.cpp
@@ -532,6 +532,10 @@ void PhaseValues::init_con_caches() {
memset(_zcons,0,sizeof(_zcons));
}
+PhaseIterGVN* PhaseValues::is_IterGVN() {
+ return (_phase == PhaseValuesType::iter_gvn || _phase == PhaseValuesType::ccp) ? static_cast(this) : nullptr;
+}
+
//--------------------------------find_int_type--------------------------------
const TypeInt* PhaseValues::find_int_type(Node* n) {
if (n == nullptr) return nullptr;
@@ -812,7 +816,7 @@ void PhaseGVN::dump_infinite_loop_info(Node* n, const char* where) {
PhaseIterGVN::PhaseIterGVN(PhaseIterGVN* igvn) : _delay_transform(igvn->_delay_transform),
_worklist(*C->igvn_worklist())
{
- _iterGVN = true;
+ _phase = PhaseValuesType::iter_gvn;
assert(&_worklist == &igvn->_worklist, "sanity");
}
@@ -821,7 +825,7 @@ PhaseIterGVN::PhaseIterGVN(PhaseIterGVN* igvn) : _delay_transform(igvn->_delay_t
PhaseIterGVN::PhaseIterGVN() : _delay_transform(false),
_worklist(*C->igvn_worklist())
{
- _iterGVN = true;
+ _phase = PhaseValuesType::iter_gvn;
uint max;
// Dead nodes in the hash table inherited from GVN were not treated as
@@ -1090,16 +1094,28 @@ void PhaseIterGVN::verify_optimize() {
is_verify_invariants()) {
ResourceMark rm;
Unique_Node_List worklist;
- bool failure = false;
// BFS all nodes, starting at root
worklist.push(C->root());
for (uint j = 0; j < worklist.size(); ++j) {
Node* n = worklist.at(j);
- if (is_verify_Value()) { failure |= verify_Value_for(n); }
- if (is_verify_Ideal()) { failure |= verify_Ideal_for(n, false); }
- if (is_verify_Ideal()) { failure |= verify_Ideal_for(n, true); }
- if (is_verify_Identity()) { failure |= verify_Identity_for(n); }
- if (is_verify_invariants()) { failure |= verify_node_invariants_for(n); }
+ // If we get an assert here, check why the reported node was not processed again in IGVN.
+ // We should either make sure that this node is properly added back to the IGVN worklist
+ // in PhaseIterGVN::add_users_to_worklist to update it again or add an exception
+ // in the verification methods below if that is not possible for some reason (like Load nodes).
+ if (is_verify_Value()) {
+ verify_Value_for(n);
+ }
+ if (is_verify_Ideal()) {
+ verify_Ideal_for(n, false);
+ verify_Ideal_for(n, true);
+ }
+ if (is_verify_Identity()) {
+ verify_Identity_for(n);
+ }
+ if (is_verify_invariants()) {
+ verify_node_invariants_for(n);
+ }
+
// traverse all inputs and outputs
for (uint i = 0; i < n->req(); i++) {
if (n->in(i) != nullptr) {
@@ -1110,11 +1126,6 @@ void PhaseIterGVN::verify_optimize() {
worklist.push(n->fast_out(i));
}
}
- // If we get this assert, check why the reported nodes were not processed again in IGVN.
- // We should either make sure that these nodes are properly added back to the IGVN worklist
- // in PhaseIterGVN::add_users_to_worklist to update them again or add an exception
- // in the verification code above if that is not possible for some reason (like Load nodes).
- assert(!failure, "Missed optimization opportunity/broken graph in PhaseIterGVN");
}
verify_empty_worklist(nullptr);
@@ -1139,18 +1150,18 @@ void PhaseIterGVN::verify_empty_worklist(Node* node) {
assert(false, "igvn worklist must still be empty after verify");
}
-// Check that type(n) == n->Value(), return true if we have a failure.
+// Check that type(n) == n->Value(), asserts if we have a failure.
// We have a list of exceptions, see detailed comments in code.
// (1) Integer "widen" changes, but the range is the same.
// (2) LoadNode performs deep traversals. Load is not notified for changes far away.
// (3) CmpPNode performs deep traversals if it compares oopptr. CmpP is not notified for changes far away.
-bool PhaseIterGVN::verify_Value_for(Node* n, bool strict) {
+void PhaseIterGVN::verify_Value_for(const Node* n, bool strict) {
// If we assert inside type(n), because the type is still a null, then maybe
// the node never went through gvn.transform, which would be a bug.
const Type* told = type(n);
const Type* tnew = n->Value(this);
if (told == tnew) {
- return false;
+ return;
}
// Exception (1)
// Integer "widen" changes, but range is the same.
@@ -1159,7 +1170,7 @@ bool PhaseIterGVN::verify_Value_for(Node* n, bool strict) {
const TypeInteger* t1 = tnew->is_integer(tnew->basic_type());
if (t0->lo_as_long() == t1->lo_as_long() &&
t0->hi_as_long() == t1->hi_as_long()) {
- return false; // ignore integer widen
+ return; // ignore integer widen
}
}
// Exception (2)
@@ -1168,7 +1179,7 @@ bool PhaseIterGVN::verify_Value_for(Node* n, bool strict) {
// MemNode::can_see_stored_value looks up through many memory nodes,
// which means we would need to notify modifications from far up in
// the inputs all the way down to the LoadNode. We don't do that.
- return false;
+ return;
}
// Exception (3)
// CmpPNode performs deep traversals if it compares oopptr. CmpP is not notified for changes far away.
@@ -1184,10 +1195,10 @@ bool PhaseIterGVN::verify_Value_for(Node* n, bool strict) {
// control sub of the allocation. The problems is that sometimes dominates answers
// false conservatively, and later it can determine that it is indeed true. Loops with
// Region heads can lead to giving up, whereas LoopNodes can be skipped easier, and
- // so the traversal becomes more powerful. This is difficult to remidy, we would have
+ // so the traversal becomes more powerful. This is difficult to remedy, we would have
// to notify the CmpP of CFG updates. Luckily, we recompute CmpP::Value during CCP
// after loop-opts, so that should take care of many of these cases.
- return false;
+ return;
}
stringStream ss; // Print as a block without tty lock.
@@ -1201,13 +1212,24 @@ bool PhaseIterGVN::verify_Value_for(Node* n, bool strict) {
tnew->dump_on(&ss);
ss.cr();
tty->print_cr("%s", ss.as_string());
- return true;
+
+ switch (_phase) {
+ case PhaseValuesType::iter_gvn:
+ assert(false, "Missed Value optimization opportunity in PhaseIterGVN for %s",n->Name());
+ break;
+ case PhaseValuesType::ccp:
+ assert(false, "PhaseCCP not at fixpoint: analysis result may be unsound for %s", n->Name());
+ break;
+ default:
+ assert(false, "Unexpected phase");
+ break;
+ }
}
// Check that all Ideal optimizations that could be done were done.
-// Returns true if it found missed optimization opportunities and
-// false otherwise (no missed optimization, or skipped verification).
-bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
+// Asserts if it found missed optimization opportunities or encountered unexpected changes, and
+// returns normally otherwise (no missed optimization, or skipped verification).
+void PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// First, we check a list of exceptions, where we skip verification,
// because there are known cases where Ideal can optimize after IGVN.
// Some may be expected and cannot be fixed, and others should be fixed.
@@ -1221,7 +1243,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xbatch --version
case Op_RangeCheck:
- return false;
+ return;
// IfNode::Ideal does:
// Node* prev_dom = search_identical(dist, igvn);
@@ -1232,7 +1254,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_If:
- return false;
+ return;
// IfNode::simple_subsuming
// Looks for dominating test that subsumes the current test.
@@ -1242,7 +1264,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// runtime/exceptionMsgs/ArrayIndexOutOfBoundsException/ArrayIndexOutOfBoundsExceptionTest.java#id1
// -XX:VerifyIterativeGVN=1110
case Op_CountedLoopEnd:
- return false;
+ return;
// LongCountedLoopEndNode::Ideal
// Probably same issue as above.
@@ -1251,7 +1273,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/predicates/assertion/TestAssertionPredicates.java#NoLoopPredicationXbatch
// -XX:StressLongCountedLoop=2000000 -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
case Op_LongCountedLoopEnd:
- return false;
+ return;
// RegionNode::Ideal does "Skip around the useless IF diamond".
// 245 IfTrue === 244
@@ -1270,7 +1292,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_Region:
- return false;
+ return;
// In AddNode::Ideal, we call "commute", which swaps the inputs so
// that smaller idx are first. Tracking it back, it led me to
@@ -1349,7 +1371,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
case Op_MulHF:
case Op_MaxHF:
case Op_MinHF:
- return false;
+ return;
// In MulNode::Ideal the edges can be swapped to help value numbering:
//
@@ -1373,7 +1395,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/intrinsics/bigInteger/MontgomeryMultiplyTest.java
// -XX:VerifyIterativeGVN=1110
case Op_AndL:
- return false;
+ return;
// SubLNode::Ideal does transform like:
// Convert "c1 - (y+c0)" into "(c1-c0) - y"
@@ -1405,7 +1427,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_SubL:
- return false;
+ return;
// SubINode::Ideal does
// Convert "x - (y+c0)" into "(x-y) - c0" AND
@@ -1417,7 +1439,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// test/hotspot/jtreg/compiler/c2/IVTest.java
// -XX:VerifyIterativeGVN=1110
case Op_SubI:
- return false;
+ return;
// AddNode::IdealIL does transform like:
// Convert x + (con - y) into "(x - y) + con"
@@ -1446,7 +1468,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_AddL:
- return false;
+ return;
// SubTypeCheckNode::Ideal calls SubTypeCheckNode::verify_helper, which does
// Node* cmp = phase->transform(new CmpPNode(subklass, in(SuperKlass)));
@@ -1471,7 +1493,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xbatch --version
case Op_SubTypeCheck:
- return false;
+ return;
// LoopLimitNode::Ideal when stride is constant power-of-2, we can do a lowering
// to other nodes: Conv, Add, Sub, Mul, And ...
@@ -1491,7 +1513,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Fond with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_LoopLimit:
- return false;
+ return;
// PhiNode::Ideal calls split_flow_path, which tries to do this:
// "This optimization tries to find two or more inputs of phi with the same constant
@@ -1514,7 +1536,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_Phi:
- return false;
+ return;
// MemBarNode::Ideal does "Eliminate volatile MemBars for scalar replaced objects".
// For examle "The allocated object does not escape".
@@ -1527,7 +1549,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_MemBarStoreStore:
- return false;
+ return;
// ConvI2LNode::Ideal converts
// 648 AddI === _ 583 645 [[ 661 ]]
@@ -1543,7 +1565,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
case Op_ConvI2L:
- return false;
+ return;
// AddNode::IdealIL can do this transform (and similar other ones):
// Convert "a*b+a*c into a*(b+c)
@@ -1557,7 +1579,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// test/hotspot/jtreg/compiler/loopopts/superword/ReductionPerf.java
// -XX:VerifyIterativeGVN=1110
case Op_AddI:
- return false;
+ return;
// ArrayCopyNode::Ideal
// calls ArrayCopyNode::prepare_array_copy
@@ -1583,7 +1605,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/arraycopy/TestArrayCopyAsLoadsStores.java
// -XX:VerifyIterativeGVN=1110
case Op_ArrayCopy:
- return false;
+ return;
// CastLLNode::Ideal
// calls ConstraintCastNode::optimize_integer_cast -> pushes CastLL through SubL
@@ -1595,7 +1617,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/c2/TestMergeStoresMemorySegment.java#byte-array
// -XX:VerifyIterativeGVN=1110
case Op_CastLL:
- return false;
+ return;
// Similar case happens to CastII
//
@@ -1603,7 +1625,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/c2/TestScalarReplacementMaxLiveNodes.java
// -XX:VerifyIterativeGVN=1110
case Op_CastII:
- return false;
+ return;
// MaxLNode::Ideal
// calls AddNode::Ideal
@@ -1618,7 +1640,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// -XX:VerifyIterativeGVN=1110
case Op_MaxL:
case Op_MinL:
- return false;
+ return;
// OrINode::Ideal
// calls AddNode::Ideal
@@ -1632,7 +1654,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// -XX:VerifyIterativeGVN=1110
case Op_OrI:
case Op_OrL:
- return false;
+ return;
// Bool -> constant folded to 1.
// Issue with notification?
@@ -1641,7 +1663,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/c2/irTests/TestVectorizationMismatchedAccess.java
// -XX:VerifyIterativeGVN=1110
case Op_Bool:
- return false;
+ return;
// LShiftLNode::Ideal
// Looks at pattern: "(x + x) << c0", converts it to "x << (c0 + 1)"
@@ -1651,7 +1673,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/conversions/TestMoveConvI2LOrCastIIThruAddIs.java
// -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
case Op_LShiftL:
- return false;
+ return;
// LShiftINode::Ideal
// pattern: ((x + con1) << con2) -> x << con2 + con1 << con2
@@ -1664,18 +1686,18 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// compiler/escapeAnalysis/Test6689060.java
// -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110 -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
case Op_LShiftI:
- return false;
+ return;
// AddPNode::Ideal seems to do set_req without removing lock first.
// Found with various vector tests tier1-tier3.
case Op_AddP:
- return false;
+ return;
// StrIndexOfNode::Ideal
// Found in tier1-3.
case Op_StrIndexOf:
case Op_StrIndexOfChar:
- return false;
+ return;
// StrEqualsNode::Identity
//
@@ -1684,7 +1706,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// -XX:+UnlockExperimentalVMOptions -XX:LockingMode=1 -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
// Note: The -XX:LockingMode option is not available anymore.
case Op_StrEquals:
- return false;
+ return;
// AryEqNode::Ideal
// Not investigated. Reshapes itself and adds lots of nodes to the worklist.
@@ -1693,22 +1715,22 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// vmTestbase/vm/mlvm/meth/stress/compiler/i2c_c2i/Test.java
// -XX:+UnlockDiagnosticVMOptions -XX:-TieredCompilation -XX:+StressUnstableIfTraps -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
case Op_AryEq:
- return false;
+ return;
// MergeMemNode::Ideal
// Found in tier1-3. Did not investigate further yet.
case Op_MergeMem:
- return false;
+ return;
// URShiftINode::Ideal
// Found in tier1-3. Did not investigate further yet.
case Op_URShiftI:
- return false;
+ return;
// CMoveINode::Ideal
// Found in tier1-3. Did not investigate further yet.
case Op_CMoveI:
- return false;
+ return;
// CmpPNode::Ideal calls isa_const_java_mirror
// and generates new constant nodes, even if no progress is made.
@@ -1719,14 +1741,14 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// java -XX:VerifyIterativeGVN=1110 -Xcomp --version
case Op_CmpP:
- return false;
+ return;
// MinINode::Ideal
// Did not investigate, but there are some patterns that might
// need more notification.
case Op_MinI:
case Op_MaxI: // preemptively removed it as well.
- return false;
+ return;
}
if (n->is_Load()) {
@@ -1742,7 +1764,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// test/hotspot/jtreg/compiler/arraycopy/TestCloneAccess.java
// -XX:VerifyIterativeGVN=1110
- return false;
+ return;
}
if (n->is_Store()) {
@@ -1756,7 +1778,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
//
// Found with:
// java -XX:VerifyIterativeGVN=0100 -Xcomp --version
- return false;
+ return;
}
if (n->is_Vector()) {
@@ -1775,7 +1797,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// compiler/vectorapi/TestMaskedMacroLogicVector.java
// -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110 -XX:+UseParallelGC -XX:+UseNUMA
- return false;
+ return;
}
if (n->is_Region()) {
@@ -1794,7 +1816,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// compiler/eliminateAutobox/TestShortBoxing.java
// -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
- return false;
+ return;
}
if (n->is_CallJava()) {
@@ -1826,13 +1848,19 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
// Found with:
// compiler/loopopts/superword/TestDependencyOffsets.java#vanilla-U
// -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
- return false;
+ return;
}
// The number of nodes shoud not increase.
uint old_unique = C->unique();
// The hash of a node should not change, this would indicate different inputs
uint old_hash = n->hash();
+ // Remove 'n' from hash table in case it gets modified. We want to avoid
+ // hitting the "Need to remove from hash before changing edges" assert if
+ // a change occurs. Instead, we would like to proceed with the optimization,
+ // return and finally hit the assert in PhaseIterGVN::verify_optimize to get
+ // a more meaningful message
+ _table.hash_delete(n);
Node* i = n->Ideal(this, can_reshape);
// If there was no new Idealization, we are probably happy.
if (i == nullptr) {
@@ -1843,7 +1871,7 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
ss.print_cr(" old_unique = %d, unique = %d", old_unique, C->unique());
n->dump_bfs(1, nullptr, "", &ss);
tty->print_cr("%s", ss.as_string());
- return true;
+ assert(false, "Unexpected new unused nodes from applying Ideal optimization on %s", n->Name());
}
if (old_hash != n->hash()) {
@@ -1853,13 +1881,14 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
ss.print_cr(" old_hash = %d, hash = %d", old_hash, n->hash());
n->dump_bfs(1, nullptr, "", &ss);
tty->print_cr("%s", ss.as_string());
- return true;
+ assert(false, "Unexpected hash change from applying Ideal optimization on %s", n->Name());
}
verify_empty_worklist(n);
// Everything is good.
- return false;
+ hash_find_insert(n);
+ return;
}
// We just saw a new Idealization which was not done during IGVN.
@@ -1876,13 +1905,14 @@ bool PhaseIterGVN::verify_Ideal_for(Node* n, bool can_reshape) {
ss.print_cr("The result after Ideal:");
i->dump_bfs(1, nullptr, "", &ss);
tty->print_cr("%s", ss.as_string());
- return true;
+
+ assert(false, "Missed Ideal optimization opportunity in PhaseIterGVN for %s", n->Name());
}
// Check that all Identity optimizations that could be done were done.
-// Returns true if it found missed optimization opportunities and
-// false otherwise (no missed optimization, or skipped verification).
-bool PhaseIterGVN::verify_Identity_for(Node* n) {
+// Asserts if it found missed optimization opportunities, and
+// returns normally otherwise (no missed optimization, or skipped verification).
+void PhaseIterGVN::verify_Identity_for(Node* n) {
// First, we check a list of exceptions, where we skip verification,
// because there are known cases where Ideal can optimize after IGVN.
// Some may be expected and cannot be fixed, and others should be fixed.
@@ -1901,7 +1931,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// Found with:
// java -XX:VerifyIterativeGVN=1000 -Xcomp --version
case Op_SafePoint:
- return false;
+ return;
// MergeMemNode::Identity replaces the MergeMem with its base_memory if it
// does not record any other memory splits.
@@ -1912,7 +1942,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// Found with:
// java -XX:VerifyIterativeGVN=1000 -Xcomp --version
case Op_MergeMem:
- return false;
+ return;
// ConstraintCastNode::Identity finds casts that are the same, except that
// the control is "higher up", i.e. dominates. The call goes via
@@ -1926,7 +1956,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
case Op_CastPP:
case Op_CastII:
case Op_CastLL:
- return false;
+ return;
// Same issue for CheckCastPP, uses ConstraintCastNode::Identity and
// checks dominator, which may be changed, but too far up for notification
@@ -1936,7 +1966,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// compiler/c2/irTests/TestSkeletonPredicates.java
// -XX:VerifyIterativeGVN=1110
case Op_CheckCastPP:
- return false;
+ return;
// In SubNode::Identity, we do:
// Convert "(X+Y) - Y" into X and "(X+Y) - X" into Y
@@ -1954,7 +1984,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// java -XX:VerifyIterativeGVN=1000 -Xcomp --version
case Op_SubI:
case Op_SubL:
- return false;
+ return;
// PhiNode::Identity checks for patterns like:
// r = (x != con) ? x : con;
@@ -1968,7 +1998,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// test/hotspot/jtreg/gc/stress/gcbasher/TestGCBasherWithG1.java
// -XX:VerifyIterativeGVN=1110
case Op_Phi:
- return false;
+ return;
// ConvI2LNode::Identity does
// convert I2L(L2I(x)) => x
@@ -1979,7 +2009,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// compiler/loopopts/superword/TestDependencyOffsets.java#vanilla-A
// -XX:VerifyIterativeGVN=1110
case Op_ConvI2L:
- return false;
+ return;
// MaxNode::find_identity_operation
// Finds patterns like Max(A, Max(A, B)) -> Max(A, B)
@@ -1999,7 +2029,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
case Op_MinHF:
case Op_MaxD:
case Op_MinD:
- return false;
+ return;
// AddINode::Identity
@@ -2013,12 +2043,12 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
case Op_AddI:
case Op_AddL:
- return false;
+ return;
// AbsINode::Identity
// Not investigated yet.
case Op_AbsI:
- return false;
+ return;
}
if (n->is_Load()) {
@@ -2032,7 +2062,7 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
//
// Found with:
// java -XX:VerifyIterativeGVN=1000 -Xcomp --version
- return false;
+ return;
}
if (n->is_Store()) {
@@ -2043,20 +2073,20 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
// Found with:
// applications/ctw/modules/java_base_2.java
// -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -Djava.awt.headless=true -XX:+IgnoreUnrecognizedVMOptions -XX:VerifyIterativeGVN=1110
- return false;
+ return;
}
if (n->is_Vector()) {
// Found with tier1-3. Not investigated yet.
// The observed issue was with AndVNode::Identity
- return false;
+ return;
}
Node* i = n->Identity(this);
// If we cannot find any other Identity, we are happy.
if (i == n) {
verify_empty_worklist(n);
- return false;
+ return;
}
// The verification just found a new Identity that was not found during IGVN.
@@ -2068,11 +2098,12 @@ bool PhaseIterGVN::verify_Identity_for(Node* n) {
ss.print_cr("New node:");
i->dump_bfs(1, nullptr, "", &ss);
tty->print_cr("%s", ss.as_string());
- return true;
+
+ assert(false, "Missed Identity optimization opportunity in PhaseIterGVN for %s", n->Name());
}
// Some other verifications that are not specific to a particular transformation.
-bool PhaseIterGVN::verify_node_invariants_for(const Node* n) {
+void PhaseIterGVN::verify_node_invariants_for(const Node* n) {
if (n->is_AddP()) {
if (!n->as_AddP()->address_input_has_same_base()) {
stringStream ss; // Print as a block without tty lock.
@@ -2080,10 +2111,10 @@ bool PhaseIterGVN::verify_node_invariants_for(const Node* n) {
ss.print_cr("Base pointers must match for AddP chain:");
n->dump_bfs(2, nullptr, "", &ss);
tty->print_cr("%s", ss.as_string());
- return true;
+
+ assert(false, "Broken node invariant for %s", n->Name());
}
}
- return false;
}
#endif
@@ -2794,6 +2825,7 @@ uint PhaseCCP::_total_constants = 0;
PhaseCCP::PhaseCCP( PhaseIterGVN *igvn ) : PhaseIterGVN(igvn) {
NOT_PRODUCT( clear_constants(); )
assert( _worklist.size() == 0, "" );
+ _phase = PhaseValuesType::ccp;
analyze();
}
@@ -2914,17 +2946,18 @@ bool PhaseCCP::needs_revisit(Node* n) const {
// Note for CCP the non-convergence can lead to unsound analysis and mis-compilation.
// Therefore, we are verifying Value convergence strictly.
void PhaseCCP::verify_analyze(Unique_Node_List& worklist_verify) {
- bool failure = false;
while (worklist_verify.size()) {
Node* n = worklist_verify.pop();
- failure |= verify_Value_for(n, /* strict = */ true);
- }
- // If we get this assert, check why the reported nodes were not processed again in CCP.
- // We should either make sure that these nodes are properly added back to the CCP worklist
- // in PhaseCCP::push_child_nodes_to_worklist() to update their type in the same round,
- // or that they are added in PhaseCCP::needs_revisit() so that analysis revisits
- // them at the end of the round.
- assert(!failure, "PhaseCCP not at fixpoint: analysis result may be unsound.");
+
+ // An assert in verify_Value_for means that PhaseCCP is not at fixpoint
+ // and that the analysis result may be unsound.
+ // If this happens, check why the reported nodes were not processed again in CCP.
+ // We should either make sure that these nodes are properly added back to the CCP worklist
+ // in PhaseCCP::push_child_nodes_to_worklist() to update their type in the same round,
+ // or that they are added in PhaseCCP::needs_revisit() so that analysis revisits
+ // them at the end of the round.
+ verify_Value_for(n, true);
+ }
}
#endif
diff --git a/src/hotspot/share/opto/phaseX.hpp b/src/hotspot/share/opto/phaseX.hpp
index 3f75aab8980..ce02f456c00 100644
--- a/src/hotspot/share/opto/phaseX.hpp
+++ b/src/hotspot/share/opto/phaseX.hpp
@@ -224,7 +224,13 @@ class PhaseTransform : public Phase {
// 3) NodeHash table, to find identical nodes (and remove/update the hash of a node on modification).
class PhaseValues : public PhaseTransform {
protected:
- bool _iterGVN;
+ enum class PhaseValuesType {
+ gvn,
+ iter_gvn,
+ ccp
+ };
+
+ PhaseValuesType _phase;
// Hash table for value-numbering. Reference to "C->node_hash()",
NodeHash &_table;
@@ -247,7 +253,7 @@ class PhaseValues : public PhaseTransform {
void init_con_caches();
public:
- PhaseValues() : PhaseTransform(GVN), _iterGVN(false),
+ PhaseValues() : PhaseTransform(GVN), _phase(PhaseValuesType::gvn),
_table(*C->node_hash()), _types(*C->types())
{
NOT_PRODUCT( clear_new_values(); )
@@ -256,7 +262,7 @@ class PhaseValues : public PhaseTransform {
init_con_caches();
}
NOT_PRODUCT(~PhaseValues();)
- PhaseIterGVN* is_IterGVN() { return (_iterGVN) ? (PhaseIterGVN*)this : nullptr; }
+ PhaseIterGVN* is_IterGVN();
// Some Ideal and other transforms delete --> modify --> insert values
bool hash_delete(Node* n) { return _table.hash_delete(n); }
@@ -490,10 +496,10 @@ class PhaseIterGVN : public PhaseGVN {
void optimize();
#ifdef ASSERT
void verify_optimize();
- bool verify_Value_for(Node* n, bool strict = false);
- bool verify_Ideal_for(Node* n, bool can_reshape);
- bool verify_Identity_for(Node* n);
- bool verify_node_invariants_for(const Node* n);
+ void verify_Value_for(const Node* n, bool strict = false);
+ void verify_Ideal_for(Node* n, bool can_reshape);
+ void verify_Identity_for(Node* n);
+ void verify_node_invariants_for(const Node* n);
void verify_empty_worklist(Node* n);
#endif
diff --git a/src/hotspot/share/opto/vector.cpp b/src/hotspot/share/opto/vector.cpp
index cf01b2442e6..f44df7e6da2 100644
--- a/src/hotspot/share/opto/vector.cpp
+++ b/src/hotspot/share/opto/vector.cpp
@@ -326,37 +326,15 @@ Node* PhaseVector::expand_vbox_node_helper(Node* vbox,
return expand_vbox_alloc_node(vbox_alloc, vect, box_type, vect_type);
}
- // Handle the case when both the allocation input and vector input to
- // VectorBoxNode are Phi. This case is generated after the transformation of
- // Phi: Phi (VectorBox1 VectorBox2) => VectorBox (Phi1 Phi2).
- // With this optimization, the relative two allocation inputs of VectorBox1 and
- // VectorBox2 are gathered into Phi1 now. Similarly, the original vector
- // inputs of two VectorBox nodes are in Phi2.
- //
- // See PhiNode::merge_through_phi in cfg.cpp for more details.
- if (vbox->is_Phi() && vect->is_Phi()) {
- assert(vbox->as_Phi()->region() == vect->as_Phi()->region(), "");
+ // Handle the case when the allocation input to VectorBoxNode is a Phi.
+ // This is generated after the transformation in PhiNode::merge_through_phi:
+ // Phi (VectorBox1 VectorBox2) => VectorBox (Phi1 Phi2)
+ // The vector input may also be a Phi (Phi2 above), or it may have been
+ // value-numbered to a single node if all inputs were identical.
+ if (vbox->is_Phi()) {
+ bool same_region = vect->is_Phi() && vbox->as_Phi()->region() == vect->as_Phi()->region();
for (uint i = 1; i < vbox->req(); i++) {
- Node* new_box = expand_vbox_node_helper(vbox->in(i), vect->in(i),
- box_type, vect_type, visited);
- if (!new_box->is_Phi()) {
- C->initial_gvn()->hash_delete(vbox);
- vbox->set_req(i, new_box);
- }
- }
- return C->initial_gvn()->transform(vbox);
- }
-
- // Handle the case when the allocation input to VectorBoxNode is a phi
- // but the vector input is not, which can definitely be the case if the
- // vector input has been value-numbered. It seems to be safe to do by
- // construction because VectorBoxNode and VectorBoxAllocate come in a
- // specific order as a result of expanding an intrinsic call. After that, if
- // any of the inputs to VectorBoxNode are value-numbered they can only
- // move up and are guaranteed to dominate.
- if (vbox->is_Phi() && (vect->is_Vector() || vect->is_LoadVector())) {
- for (uint i = 1; i < vbox->req(); i++) {
- Node* new_box = expand_vbox_node_helper(vbox->in(i), vect,
+ Node* new_box = expand_vbox_node_helper(vbox->in(i), same_region ? vect->in(i) : vect,
box_type, vect_type, visited);
if (!new_box->is_Phi()) {
C->initial_gvn()->hash_delete(vbox);
diff --git a/src/hotspot/share/prims/methodHandles.cpp b/src/hotspot/share/prims/methodHandles.cpp
index c243cae20ab..584f077eddc 100644
--- a/src/hotspot/share/prims/methodHandles.cpp
+++ b/src/hotspot/share/prims/methodHandles.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2008, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2008, 2026, 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
@@ -557,7 +557,7 @@ bool MethodHandles::is_basic_type_signature(Symbol* sig) {
switch (ss.type()) {
case T_OBJECT:
// only java/lang/Object is valid here
- if (strncmp((char*) ss.raw_bytes(), OBJ_SIG, OBJ_SIG_LEN) != 0)
+ if (strncmp((char*) ss.raw_bytes(), OBJ_SIG, ss.raw_length()) != 0)
return false;
break;
case T_VOID:
diff --git a/src/hotspot/share/prims/whitebox.cpp b/src/hotspot/share/prims/whitebox.cpp
index de5bc9ea58f..35e0b83d25f 100644
--- a/src/hotspot/share/prims/whitebox.cpp
+++ b/src/hotspot/share/prims/whitebox.cpp
@@ -578,7 +578,7 @@ WB_END
WB_ENTRY(jboolean, WB_G1InConcurrentMark(JNIEnv* env, jobject o))
if (UseG1GC) {
G1CollectedHeap* g1h = G1CollectedHeap::heap();
- return g1h->concurrent_mark()->cm_thread()->in_progress();
+ return g1h->concurrent_mark()->in_progress();
}
THROW_MSG_0(vmSymbols::java_lang_UnsupportedOperationException(), "WB_G1InConcurrentMark: G1 GC is not enabled");
WB_END
diff --git a/src/hotspot/share/runtime/atomic.hpp b/src/hotspot/share/runtime/atomic.hpp
index f708e9c18ca..894e04eec57 100644
--- a/src/hotspot/share/runtime/atomic.hpp
+++ b/src/hotspot/share/runtime/atomic.hpp
@@ -58,9 +58,10 @@
// ValueType -> T
//
// special functions:
-// explicit constructor(T)
+// constexpr constructor() // See (2) below
+// explicit constexpr constructor(T)
// noncopyable
-// destructor
+// destructor // Trivial
//
// static member functions:
// value_offset_in_bytes() -> int // constexpr
@@ -343,7 +344,8 @@ class AtomicImpl::Atomic
: public SupportsArithmetic
{
public:
- explicit constexpr Atomic(T value = 0) : SupportsArithmetic(value) {}
+ constexpr Atomic() : Atomic(0) {}
+ explicit constexpr Atomic(T value) : SupportsArithmetic(value) {}
NONCOPYABLE(Atomic);
@@ -383,7 +385,8 @@ class AtomicImpl::Atomic
: public CommonCore
{
public:
- explicit constexpr Atomic(T value = 0) : CommonCore(value) {}
+ constexpr Atomic() : Atomic(0) {}
+ explicit constexpr Atomic(T value) : CommonCore(value) {}
NONCOPYABLE(Atomic);
@@ -399,7 +402,8 @@ class AtomicImpl::Atomic
: public SupportsArithmetic
{
public:
- explicit constexpr Atomic(T value = nullptr) : SupportsArithmetic(value) {}
+ constexpr Atomic() : Atomic(nullptr) {}
+ explicit constexpr Atomic(T value) : SupportsArithmetic(value) {}
NONCOPYABLE(Atomic);
diff --git a/src/hotspot/share/runtime/continuation.cpp b/src/hotspot/share/runtime/continuation.cpp
index 935f304a751..0b7e64a3ba6 100644
--- a/src/hotspot/share/runtime/continuation.cpp
+++ b/src/hotspot/share/runtime/continuation.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2018, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2026, 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
@@ -86,7 +86,8 @@ class UnmountBeginMark : public StackObj {
}
}
~UnmountBeginMark() {
- assert(!_current->is_suspended(), "must be");
+ assert(!_current->is_suspended()
+ JVMTI_ONLY(|| (_current->is_vthread_transition_disabler() && _result != freeze_ok)), "must be");
assert(_current->is_in_vthread_transition(), "must be");
if (_result != freeze_ok) {
diff --git a/src/hotspot/share/runtime/objectMonitor.cpp b/src/hotspot/share/runtime/objectMonitor.cpp
index 785ee2af592..144533cd959 100644
--- a/src/hotspot/share/runtime/objectMonitor.cpp
+++ b/src/hotspot/share/runtime/objectMonitor.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2026, 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
@@ -339,15 +339,6 @@ void ObjectMonitor::ExitOnSuspend::operator()(JavaThread* current) {
}
}
-void ObjectMonitor::ClearSuccOnSuspend::operator()(JavaThread* current) {
- if (current->is_suspended()) {
- if (_om->has_successor(current)) {
- _om->clear_successor();
- OrderAccess::fence(); // always do a full fence when successor is cleared
- }
- }
-}
-
#define assert_mark_word_consistency() \
assert(UseObjectMonitorTable || object()->mark() == markWord::encode(this), \
"object mark must match encoded this: mark=" INTPTR_FORMAT \
@@ -500,7 +491,7 @@ bool ObjectMonitor::spin_enter(JavaThread* current) {
return false;
}
-bool ObjectMonitor::enter(JavaThread* current) {
+bool ObjectMonitor::enter(JavaThread* current, bool post_jvmti_events) {
assert(current == JavaThread::current(), "must be");
if (spin_enter(current)) {
@@ -521,15 +512,15 @@ bool ObjectMonitor::enter(JavaThread* current) {
}
// At this point this ObjectMonitor cannot be deflated, finish contended enter
- enter_with_contention_mark(current, contention_mark);
+ enter_with_contention_mark(current, contention_mark, post_jvmti_events);
return true;
}
-void ObjectMonitor::notify_contended_enter(JavaThread* current) {
+void ObjectMonitor::notify_contended_enter(JavaThread* current, bool post_jvmti_events) {
current->set_current_pending_monitor(this);
DTRACE_MONITOR_PROBE(contended__enter, this, object(), current);
- if (JvmtiExport::should_post_monitor_contended_enter()) {
+ if (post_jvmti_events && JvmtiExport::should_post_monitor_contended_enter()) {
JvmtiExport::post_monitor_contended_enter(current, this);
// The current thread does not yet own the monitor and does not
@@ -540,7 +531,7 @@ void ObjectMonitor::notify_contended_enter(JavaThread* current) {
}
}
-void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonitorContentionMark &cm) {
+void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonitorContentionMark &cm, bool post_jvmti_events) {
assert(current == JavaThread::current(), "must be");
assert(!has_owner(current), "must be");
assert(cm._monitor == this, "must be");
@@ -564,7 +555,7 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonito
ContinuationEntry* ce = current->last_continuation();
bool is_virtual = ce != nullptr && ce->is_virtual_thread();
if (is_virtual) {
- notify_contended_enter(current);
+ notify_contended_enter(current, post_jvmti_events);
result = Continuation::try_preempt(current, ce->cont_oop(current));
if (result == freeze_ok) {
bool acquired = vthread_monitor_enter(current);
@@ -573,7 +564,7 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonito
// _entry_list so cancel preemption. We will still go through the preempt stub
// but instead of unmounting we will call thaw to continue execution.
current->set_preemption_cancelled(true);
- if (JvmtiExport::should_post_monitor_contended_entered()) {
+ if (post_jvmti_events && JvmtiExport::should_post_monitor_contended_entered()) {
// We are going to call thaw again after this and finish the VMTS
// transition so no need to do it here. We will post the event there.
current->set_contended_entered_monitor(this);
@@ -610,7 +601,8 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonito
// states will still report that the thread is blocked trying to
// acquire it.
// If there is a suspend request, ExitOnSuspend will exit the OM
- // and set the OM as pending.
+ // and set the OM as pending, the thread will not be reported as
+ // having "-locked" the monitor.
}
if (!eos.exited()) {
// ExitOnSuspend did not exit the OM
@@ -644,7 +636,7 @@ void ObjectMonitor::enter_with_contention_mark(JavaThread* current, ObjectMonito
// spinning we could increment JVMStat counters, etc.
DTRACE_MONITOR_PROBE(contended__entered, this, object(), current);
- if (JvmtiExport::should_post_monitor_contended_entered()) {
+ if (post_jvmti_events && JvmtiExport::should_post_monitor_contended_entered()) {
JvmtiExport::post_monitor_contended_entered(current, this);
// The current thread already owns the monitor and is not going to
@@ -1102,11 +1094,10 @@ void ObjectMonitor::enter_internal(JavaThread* current) {
void ObjectMonitor::reenter_internal(JavaThread* current, ObjectWaiter* currentNode) {
assert(current != nullptr, "invariant");
- assert(current->thread_state() != _thread_blocked, "invariant");
+ assert(current->thread_state() == _thread_blocked, "invariant");
assert(currentNode != nullptr, "invariant");
assert(currentNode->_thread == current, "invariant");
assert(_waiters > 0, "invariant");
- assert_mark_word_consistency();
// If there are unmounted virtual threads ahead in the _entry_list we want
// to do a timed-park instead to alleviate some deadlock cases where one
@@ -1142,22 +1133,15 @@ void ObjectMonitor::reenter_internal(JavaThread* current, ObjectWaiter* currentN
{
OSThreadContendState osts(current->osthread());
-
- assert(current->thread_state() == _thread_in_vm, "invariant");
-
- {
- ClearSuccOnSuspend csos(this);
- ThreadBlockInVMPreprocess tbivs(current, csos, true /* allow_suspend */);
- if (do_timed_parked) {
- current->_ParkEvent->park(recheck_interval);
- // Increase the recheck_interval, but clamp the value.
- recheck_interval *= 8;
- if (recheck_interval > MAX_RECHECK_INTERVAL) {
- recheck_interval = MAX_RECHECK_INTERVAL;
- }
- } else {
- current->_ParkEvent->park();
+ if (do_timed_parked) {
+ current->_ParkEvent->park(recheck_interval);
+ // Increase the recheck_interval, but clamp the value.
+ recheck_interval *= 8;
+ if (recheck_interval > MAX_RECHECK_INTERVAL) {
+ recheck_interval = MAX_RECHECK_INTERVAL;
}
+ } else {
+ current->_ParkEvent->park();
}
}
@@ -1184,7 +1168,6 @@ void ObjectMonitor::reenter_internal(JavaThread* current, ObjectWaiter* currentN
// Current has acquired the lock -- Unlink current from the _entry_list.
assert(has_owner(current), "invariant");
- assert_mark_word_consistency();
unlink_after_acquire(current, currentNode);
if (has_successor(current)) clear_successor();
assert(!has_successor(current), "invariant");
@@ -1883,7 +1866,7 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
// while (!timeout && !interrupted && node.TState == TS_WAIT) park()
int ret = OS_OK;
- bool was_notified = false;
+ bool was_notified = true;
// Need to check interrupt state whilst still _thread_in_vm
bool interrupted = interruptible && current->is_interrupted(false);
@@ -1895,8 +1878,7 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
assert(current->thread_state() == _thread_in_vm, "invariant");
{
- ClearSuccOnSuspend csos(this);
- ThreadBlockInVMPreprocess tbivs(current, csos, true /* allow_suspend */);
+ ThreadBlockInVM tbivm(current, false /* allow_suspend */);
if (interrupted || HAS_PENDING_EXCEPTION) {
// Intentionally empty
} else if (node.TState == ObjectWaiter::TS_WAIT) {
@@ -1928,17 +1910,16 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
if (node.TState == ObjectWaiter::TS_WAIT) {
dequeue_specific_waiter(&node); // unlink from wait_set
node.TState = ObjectWaiter::TS_RUN;
+ was_notified = false;
}
}
-
- // The thread is now either on off-list (TS_RUN),
+ // The thread is now either off-list (TS_RUN),
// or on the entry_list (TS_ENTER).
// The Node's TState variable is stable from the perspective of this thread.
// No other threads will asynchronously modify TState.
guarantee(node.TState != ObjectWaiter::TS_WAIT, "invariant");
OrderAccess::loadload();
if (has_successor(current)) clear_successor();
- was_notified = node.TState == ObjectWaiter::TS_ENTER;
// Reentry phase -- reacquire the monitor.
// re-enter contended monitor after object.wait().
@@ -1947,27 +1928,19 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
// although the raw address of the object may have changed.
// (Don't cache naked oops over safepoints, of course).
- // post monitor waited event. Note that this is past-tense, we are done waiting.
- if (JvmtiExport::should_post_monitor_waited()) {
- JvmtiExport::post_monitor_waited(current, this, ret == OS_TIMEOUT);
-
- if (was_notified && has_successor(current)) {
- // In this part of the monitor wait-notify-reenter protocol it
- // is possible (and normal) for another thread to do a fastpath
- // monitor enter-exit while this thread is still trying to get
- // to the reenter portion of the protocol.
- //
- // The ObjectMonitor was notified and the current thread is
- // the successor which also means that an unpark() has already
- // been done. The JVMTI_EVENT_MONITOR_WAITED event handler can
- // consume the unpark() that was done when the successor was
- // set because the same ParkEvent is shared between Java
- // monitors and JVM/TI RawMonitors (for now).
- //
- // We redo the unpark() to ensure forward progress, i.e., we
- // don't want all pending threads hanging (parked) with none
- // entering the unlocked monitor.
- current->_ParkEvent->unpark();
+ // Post monitor waited event. Note that this is past-tense, we are done waiting.
+ // An event could have been enabled after notification, in this case
+ // a thread will have TS_ENTER state and posting the event may hit a suspension point.
+ // From a debugging perspective, it is more important to have no missing events.
+ if (interruptible && JvmtiExport::should_post_monitor_waited() && node.TState != ObjectWaiter::TS_ENTER) {
+
+ // Process suspend requests now if any, before posting the event.
+ {
+ ThreadBlockInVM tbvm(current, true);
+ }
+ // Re-check the condition as the monitor waited events can be disabled whilst thread was suspended.
+ if (JvmtiExport::should_post_monitor_waited()) {
+ JvmtiExport::post_monitor_waited(current, this, ret == OS_TIMEOUT);
}
}
@@ -1986,8 +1959,30 @@ void ObjectMonitor::wait(jlong millis, bool interruptible, TRAPS) {
NoPreemptMark npm(current);
enter(current);
} else {
+ // This means the thread has been un-parked and added to the entry_list
+ // in notify_internal, i.e. notified while waiting.
guarantee(v == ObjectWaiter::TS_ENTER, "invariant");
- reenter_internal(current, &node);
+ ExitOnSuspend eos(this);
+ {
+ ThreadBlockInVMPreprocess tbivs(current, eos, true /* allow_suspend */);
+ reenter_internal(current, &node);
+ // We can go to a safepoint at the end of this block. If we
+ // do a thread dump during that safepoint, then this thread will show
+ // as having "-locked" the monitor, but the OS and java.lang.Thread
+ // states will still report that the thread is blocked trying to
+ // acquire it.
+ // If there is a suspend request, ExitOnSuspend will exit the OM
+ // and set the OM as pending, the thread will not be reported as
+ // having "-locked" the monitor.
+ }
+ if (eos.exited()) {
+ // ExitOnSuspend exit the OM
+ assert(!has_owner(current), "invariant");
+ guarantee(node.TState == ObjectWaiter::TS_RUN, "invariant");
+ current->set_current_pending_monitor(nullptr);
+ enter(current, false /* post_jvmti_events */);
+ }
+ assert(has_owner(current), "invariant");
node.wait_reenter_end(this);
}
@@ -2041,6 +2036,8 @@ bool ObjectMonitor::notify_internal(JavaThread* current) {
ObjectWaiter* iterator = dequeue_waiter();
if (iterator != nullptr) {
guarantee(iterator->TState == ObjectWaiter::TS_WAIT, "invariant");
+ iterator->_notifier_tid = JFR_THREAD_ID(current);
+ did_notify = true;
if (iterator->is_vthread()) {
oop vthread = iterator->vthread();
@@ -2056,45 +2053,55 @@ bool ObjectMonitor::notify_internal(JavaThread* current) {
old_state == java_lang_VirtualThread::TIMED_WAIT) {
java_lang_VirtualThread::cmpxchg_state(vthread, old_state, java_lang_VirtualThread::BLOCKED);
}
- // Increment counter *before* adding the vthread to the _entry_list.
- // Adding to _entry_list uses Atomic::cmpxchg() which already provides
- // a fence that prevents reordering of the stores.
- inc_unmounted_vthreads();
+ if (!JvmtiExport::should_post_monitor_waited()) {
+ // Increment counter *before* adding the vthread to the _entry_list.
+ // Adding to _entry_list uses Atomic::cmpxchg() which already provides
+ // a fence that prevents reordering of the stores.
+ inc_unmounted_vthreads();
+ add_to_entry_list(current, iterator);
+ } else {
+ iterator->TState = ObjectWaiter::TS_RUN;
+ if (java_lang_VirtualThread::set_onWaitingList(vthread, vthread_list_head())) {
+ ParkEvent* pe = ObjectMonitor::vthread_unparker_ParkEvent();
+ pe->unpark();
+ }
+ }
+ } else {
+ if (!JvmtiExport::should_post_monitor_waited()) {
+ add_to_entry_list(current, iterator);
+ // Read counter *after* adding the thread to the _entry_list.
+ // Adding to _entry_list uses Atomic::cmpxchg() which already provides
+ // a fence that prevents this load from floating up previous store.
+ if (has_unmounted_vthreads()) {
+ // Wake up the thread to alleviate some deadlock cases where the successor
+ // that will be picked up when this thread releases the monitor is an unmounted
+ // virtual thread that cannot run due to having run out of carriers. Upon waking
+ // up, the thread will call reenter_internal() which will use timed-park in case
+ // there is contention and there are still vthreads in the _entry_list.
+ // If the target was interrupted or the wait timed-out at the same time, it could
+ // have reached reenter_internal and read a false value of has_unmounted_vthreads()
+ // before we added it to the _entry_list above. To deal with that case, we set _do_timed_park
+ // which will be read by the target on the next loop iteration in reenter_internal.
+ iterator->_do_timed_park = true;
+ JavaThread* t = iterator->thread();
+ t->_ParkEvent->unpark();
+ }
+ iterator->wait_reenter_begin(this);
+ } else {
+ iterator->TState = ObjectWaiter::TS_RUN;
+ JavaThread* t = iterator->thread();
+ assert(t != nullptr, "");
+ t->_ParkEvent->unpark();
+ }
}
- iterator->_notifier_tid = JFR_THREAD_ID(current);
- did_notify = true;
- add_to_entry_list(current, iterator);
-
// _wait_set_lock protects the wait queue, not the entry_list. We could
// move the add-to-entry_list operation, above, outside the critical section
// protected by _wait_set_lock. In practice that's not useful. With the
- // exception of wait() timeouts and interrupts the monitor owner
+ // exception of wait() timeouts and interrupts the monitor owner
// is the only thread that grabs _wait_set_lock. There's almost no contention
// on _wait_set_lock so it's not profitable to reduce the length of the
// critical section.
-
- if (!iterator->is_vthread()) {
- iterator->wait_reenter_begin(this);
-
- // Read counter *after* adding the thread to the _entry_list.
- // Adding to _entry_list uses Atomic::cmpxchg() which already provides
- // a fence that prevents this load from floating up previous store.
- if (has_unmounted_vthreads()) {
- // Wake up the thread to alleviate some deadlock cases where the successor
- // that will be picked up when this thread releases the monitor is an unmounted
- // virtual thread that cannot run due to having run out of carriers. Upon waking
- // up, the thread will call reenter_internal() which will use timed-park in case
- // there is contention and there are still vthreads in the _entry_list.
- // If the target was interrupted or the wait timed-out at the same time, it could
- // have reached reenter_internal and read a false value of has_unmounted_vthreads()
- // before we added it to the _entry_list above. To deal with that case, we set _do_timed_park
- // which will be read by the target on the next loop iteration in reenter_internal.
- iterator->_do_timed_park = true;
- JavaThread* t = iterator->thread();
- t->_ParkEvent->unpark();
- }
- }
}
return did_notify;
}
@@ -2221,19 +2228,22 @@ bool ObjectMonitor::vthread_wait_reenter(JavaThread* current, ObjectWaiter* node
// The first time we run after being preempted on Object.wait() we
// need to check if we were interrupted or the wait timed-out, and
// in that case remove ourselves from the _wait_set queue.
+ bool was_notified = true;
if (node->TState == ObjectWaiter::TS_WAIT) {
SpinCriticalSection scs(&_wait_set_lock);
if (node->TState == ObjectWaiter::TS_WAIT) {
dequeue_specific_waiter(node); // unlink from wait_set
node->TState = ObjectWaiter::TS_RUN;
+ was_notified = false;
}
}
// If this was an interrupted case, set the _interrupted boolean so that
// once we re-acquire the monitor we know if we need to throw IE or not.
ObjectWaiter::TStates state = node->TState;
- bool was_notified = state == ObjectWaiter::TS_ENTER;
- assert(was_notified || state == ObjectWaiter::TS_RUN, "");
+ assert(was_notified || state == ObjectWaiter::TS_RUN,
+ "was not notified and is not in the right state: state = %s",
+ node->getTStateName(state));
node->_interrupted = node->_interruptible && !was_notified && current->is_interrupted(false);
// Post JFR and JVMTI events. If non-interruptible we are in
@@ -2246,7 +2256,10 @@ bool ObjectMonitor::vthread_wait_reenter(JavaThread* current, ObjectWaiter* node
// Mark that we are at reenter so that we don't call this method again.
node->_at_reenter = true;
- if (!was_notified) {
+ // We check the state rather than was_notified because, when JVMTI
+ // monitor_waited event is enabled, the notifier only unparks the waiter
+ // without adding it to the entry_list.
+ if (state == ObjectWaiter::TS_RUN) {
bool acquired = vthread_monitor_enter(current, node);
if (acquired) {
guarantee(_recursions == 0, "invariant");
@@ -2537,6 +2550,23 @@ ObjectWaiter::ObjectWaiter(JavaThread* current) {
_active = false;
}
+const char* ObjectWaiter::getTStateName(ObjectWaiter::TStates state) {
+ switch (state) {
+ case ObjectWaiter::TS_UNDEF:
+ return "TS_UNDEF";
+ case ObjectWaiter::TS_READY:
+ return "TS_READY";
+ case ObjectWaiter::TS_RUN:
+ return "TS_RUN";
+ case ObjectWaiter::TS_WAIT:
+ return "TS_WAIT";
+ case ObjectWaiter::TS_ENTER:
+ return "TS_ENTER";
+ default:
+ ShouldNotReachHere();
+ }
+}
+
ObjectWaiter::ObjectWaiter(oop vthread, ObjectMonitor* mon) : ObjectWaiter(nullptr) {
assert(oopDesc::is_oop(vthread), "");
_vthread = OopHandle(JavaThread::thread_oop_storage(), vthread);
diff --git a/src/hotspot/share/runtime/objectMonitor.hpp b/src/hotspot/share/runtime/objectMonitor.hpp
index 53b64f1e8a5..574a652f230 100644
--- a/src/hotspot/share/runtime/objectMonitor.hpp
+++ b/src/hotspot/share/runtime/objectMonitor.hpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 1998, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2026, 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
@@ -40,7 +40,6 @@ class ParkEvent;
class BasicLock;
class ContinuationWrapper;
-
class ObjectWaiter : public CHeapObj {
public:
enum TStates : uint8_t { TS_UNDEF, TS_READY, TS_RUN, TS_WAIT, TS_ENTER };
@@ -72,7 +71,7 @@ class ObjectWaiter : public CHeapObj {
oop vthread() const;
void wait_reenter_begin(ObjectMonitor *mon);
void wait_reenter_end(ObjectMonitor *mon);
-
+ const char* getTStateName(TStates state);
void set_bad_pointers() {
#ifdef ASSERT
this->_prev = (ObjectWaiter*) badAddressVal;
@@ -352,7 +351,6 @@ class ObjectMonitor : public CHeapObj {
// returns false and throws IllegalMonitorStateException (IMSE).
bool check_owner(TRAPS);
- private:
class ExitOnSuspend {
protected:
ObjectMonitor* _om;
@@ -362,23 +360,16 @@ class ObjectMonitor : public CHeapObj {
void operator()(JavaThread* current);
bool exited() { return _om_exited; }
};
- class ClearSuccOnSuspend {
- protected:
- ObjectMonitor* _om;
- public:
- ClearSuccOnSuspend(ObjectMonitor* om) : _om(om) {}
- void operator()(JavaThread* current);
- };
bool enter_is_async_deflating();
- void notify_contended_enter(JavaThread *current);
+ void notify_contended_enter(JavaThread *current, bool post_jvmti_events = true);
public:
void enter_for_with_contention_mark(JavaThread* locking_thread, ObjectMonitorContentionMark& contention_mark);
bool enter_for(JavaThread* locking_thread);
- bool enter(JavaThread* current);
+ bool enter(JavaThread* current, bool post_jvmti_events = true);
bool try_enter(JavaThread* current, bool check_for_recursion = true);
bool spin_enter(JavaThread* current);
- void enter_with_contention_mark(JavaThread* current, ObjectMonitorContentionMark& contention_mark);
+ void enter_with_contention_mark(JavaThread* current, ObjectMonitorContentionMark& contention_mark, bool post_jvmti_events = true);
void exit(JavaThread* current, bool not_suspended = true);
bool resume_operation(JavaThread* current, ObjectWaiter* node, ContinuationWrapper& cont);
void wait(jlong millis, bool interruptible, TRAPS);
diff --git a/src/hotspot/share/runtime/os.cpp b/src/hotspot/share/runtime/os.cpp
index 57971897400..3a5a5745095 100644
--- a/src/hotspot/share/runtime/os.cpp
+++ b/src/hotspot/share/runtime/os.cpp
@@ -702,57 +702,50 @@ void* os::realloc(void *memblock, size_t size, MemTag mem_tag, const NativeCallS
if (new_outer_size < size) {
return nullptr;
}
-
- const size_t old_size = MallocTracker::malloc_header(memblock)->size();
-
- // Observe MallocLimit
- if ((size > old_size) && MemTracker::check_exceeds_limit(size - old_size, mem_tag)) {
- return nullptr;
- }
+ MallocHeader* header = MallocHeader::kill_block(memblock);
+ const size_t old_size = header->size();
// Perform integrity checks on and mark the old block as dead *before* calling the real realloc(3) since it
// may invalidate the old block, including its header.
- MallocHeader* header = MallocHeader::resolve_checked(memblock);
assert(mem_tag == header->mem_tag(), "weird NMT type mismatch (new:\"%s\" != old:\"%s\")\n",
NMTUtil::tag_to_name(mem_tag), NMTUtil::tag_to_name(header->mem_tag()));
- const MallocHeader::FreeInfo free_info = header->free_info();
-
- header->mark_block_as_dead();
+ bool within_malloc_limit = !((size > old_size) && MemTracker::check_exceeds_limit(size - old_size, mem_tag));
+ bool success = within_malloc_limit;
+ // Observe MallocLimit
+ if (success) {
+ // If realloc succeeds, the header is freed. Get FreeInfo before that.
+ MallocHeader::FreeInfo free_info = header->free_info();
+ void* const new_outer_ptr = permit_forbidden_function::realloc(header, new_outer_size);
+ success = new_outer_ptr != nullptr;
+ if (success) {
+ // realloc(3) succeeded, variable header now points to invalid memory and we need to deaccount the old block.
+ MemTracker::deaccount(free_info);
+ // After a successful realloc(3), we account the resized block with its new size
+ // to NMT.
+ void* const new_inner_ptr = MemTracker::record_malloc(new_outer_ptr, size, mem_tag, stack);
- // the real realloc
- void* const new_outer_ptr = permit_forbidden_function::realloc(header, new_outer_size);
+#ifdef ASSERT
+ if (ZapCHeap && old_size < size) {
+ // We also zap the newly extended region.
+ ::memset((char*)new_inner_ptr + old_size, uninitBlockPad, size - old_size);
+ }
+#endif
- if (new_outer_ptr == nullptr) {
+ rc = new_inner_ptr;
+ }
+ }
+ if (!success) {
// realloc(3) failed and the block still exists.
// We have however marked it as dead, revert this change.
- header->revive();
+ MallocHeader::revive_block(memblock);
return nullptr;
}
- // realloc(3) succeeded, variable header now points to invalid memory and we need to deaccount the old block.
- MemTracker::deaccount(free_info);
-
- // After a successful realloc(3), we account the resized block with its new size
- // to NMT.
- void* const new_inner_ptr = MemTracker::record_malloc(new_outer_ptr, size, mem_tag, stack);
-
-#ifdef ASSERT
- assert(old_size == free_info.size, "Sanity");
- if (ZapCHeap && old_size < size) {
- // We also zap the newly extended region.
- ::memset((char*)new_inner_ptr + old_size, uninitBlockPad, size - old_size);
- }
-#endif
-
- rc = new_inner_ptr;
-
} else {
-
// NMT disabled.
rc = permit_forbidden_function::realloc(memblock, size);
if (rc == nullptr) {
return nullptr;
}
-
}
DEBUG_ONLY(break_if_ptr_caught(rc);)
diff --git a/src/hotspot/share/runtime/vmStructs.cpp b/src/hotspot/share/runtime/vmStructs.cpp
index 4ecc8f9ca01..f65a3441bf4 100644
--- a/src/hotspot/share/runtime/vmStructs.cpp
+++ b/src/hotspot/share/runtime/vmStructs.cpp
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2000, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2026, 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
@@ -79,6 +79,7 @@
#include "oops/typeArrayOop.hpp"
#include "prims/jvmtiAgentThread.hpp"
#include "runtime/arguments.hpp"
+#include "runtime/atomic.hpp"
#include "runtime/deoptimization.hpp"
#include "runtime/flags/jvmFlag.hpp"
#include "runtime/globals.hpp"
@@ -888,6 +889,7 @@
declare_unsigned_integer_type(unsigned short) \
declare_unsigned_integer_type(jushort) \
declare_unsigned_integer_type(unsigned long) \
+ declare_unsigned_integer_type(Atomic) \
/* The compiler thinks this is a different type than */ \
/* unsigned short on Win32 */ \
declare_unsigned_integer_type(u1) \
@@ -901,6 +903,7 @@
/*****************************/ \
\
declare_toplevel_type(void*) \
+ declare_toplevel_type(Atomic) \
declare_toplevel_type(int*) \
declare_toplevel_type(char*) \
declare_toplevel_type(char**) \
diff --git a/src/hotspot/share/utilities/growableArray.hpp b/src/hotspot/share/utilities/growableArray.hpp
index 1823a2ba861..e300bea6993 100644
--- a/src/hotspot/share/utilities/growableArray.hpp
+++ b/src/hotspot/share/utilities/growableArray.hpp
@@ -493,16 +493,16 @@ class GrowableArrayWithAllocator : public GrowableArrayView {
return false;
}
- // Remove all elements up to the index (exclusive). The order is preserved.
- void remove_till(int idx) {
- remove_range(0, idx);
+ // Remove all elements in the range [0; end). The order is preserved.
+ void remove_till(int end) {
+ remove_range(0, end);
}
- // Remove all elements in the range [start - end). The order is preserved.
+ // Remove all elements in the range [start; end). The order is preserved.
void remove_range(int start, int end) {
assert(0 <= start, "illegal start index %d", start);
- assert(start < end && end <= this->_len,
- "erase called with invalid range (%d, %d) for length %d",
+ assert(start <= end && end <= this->_len,
+ "erase called with invalid range [%d, %d) for length %d",
start, end, this->_len);
for (int i = start, j = end; j < this->length(); i++, j++) {
diff --git a/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM.java b/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM.java
index 1280ccdad74..56a119893a7 100644
--- a/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM.java
+++ b/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM.java
@@ -498,7 +498,7 @@ protected Object checkPrivateKey(byte[] sk) throws InvalidKeyException {
/*
Main internal algorithms from Section 6 of specification
*/
- protected ML_KEM_KeyPair generateKemKeyPair(byte[] kem_d, byte[] kem_z) {
+ protected ML_KEM_KeyPair generateKemKeyPair(byte[] kem_d_z) {
MessageDigest mlKemH;
try {
mlKemH = MessageDigest.getInstance(HASH_H_NAME);
@@ -508,7 +508,8 @@ protected ML_KEM_KeyPair generateKemKeyPair(byte[] kem_d, byte[] kem_z) {
}
//Generate K-PKE keys
- var kPkeKeyPair = generateK_PkeKeyPair(kem_d);
+ //The 1st 32-byte `d` is used in K-PKE key pair generation
+ var kPkeKeyPair = generateK_PkeKeyPair(kem_d_z);
//encaps key = kPke encryption key
byte[] encapsKey = kPkeKeyPair.publicKey.keyBytes;
@@ -527,7 +528,8 @@ protected ML_KEM_KeyPair generateKemKeyPair(byte[] kem_d, byte[] kem_z) {
// This should never happen.
throw new RuntimeException(e);
}
- System.arraycopy(kem_z, 0, decapsKey,
+ // The 2nd 32-byte `z` is copied into decapsKey
+ System.arraycopy(kem_d_z, 32, decapsKey,
kPkePrivateKey.length + encapsKey.length + 32, 32);
return new ML_KEM_KeyPair(
@@ -535,6 +537,12 @@ protected ML_KEM_KeyPair generateKemKeyPair(byte[] kem_d, byte[] kem_z) {
new ML_KEM_DecapsulationKey(decapsKey));
}
+ public byte[] privKeyToPubKey(byte[] decapsKey) {
+ int pkLen = (mlKem_k * ML_KEM_N * 12) / 8 + 32 /* rho */;
+ int skLen = (mlKem_k * ML_KEM_N * 12) / 8;
+ return Arrays.copyOfRange(decapsKey, skLen, skLen + pkLen);
+ }
+
protected ML_KEM_EncapsulateResult encapsulate(
ML_KEM_EncapsulationKey encapsulationKey, byte[] randomMessage) {
MessageDigest mlKemH;
@@ -648,10 +656,12 @@ private K_PKE_KeyPair generateK_PkeKeyPair(byte[] seed) {
throw new RuntimeException(e);
}
- mlKemG.update(seed);
+ // Note: only the 1st 32-byte in the seed is used
+ mlKemG.update(seed, 0, 32);
mlKemG.update((byte)mlKem_k);
var rhoSigma = mlKemG.digest();
+ mlKemG.reset();
var rho = Arrays.copyOfRange(rhoSigma, 0, 32);
var sigma = Arrays.copyOfRange(rhoSigma, 32, 64);
Arrays.fill(rhoSigma, (byte)0);
@@ -1353,22 +1363,16 @@ private static void implKyber12To16Java(byte[] condensed, int index, short[] par
}
}
- // The intrinsic implementations assume that the input and output buffers
- // are such that condensed can be read in 96-byte chunks and
- // parsed can be written in 64 shorts chunks except for the last chunk
- // that can be either 48 or 64 shorts. In other words,
- // if (i - 1) * 64 < parsedLengths <= i * 64 then
- // parsed.length should be either i * 64 or (i-1) * 64 + 48 and
- // condensed.length should be at least index + i * 96.
+ // An intrinsic implementation assumes that the input and output buffers
+ // are such that condensed can be read in chunks of 192 bytes and
+ // parsed can be written in chunks of 128 shorts, so callers should allocate
+ // the condensed and parsed arrays accordingly, see the assert()
private void twelve2Sixteen(byte[] condensed, int index,
short[] parsed, int parsedLength) {
- int i = parsedLength / 64;
- int remainder = parsedLength - i * 64;
- if (remainder != 0) {
- i++;
- }
- assert ((remainder == 0) || (remainder == 48)) &&
- (index + i * 96 <= condensed.length);
+ int n = (parsedLength + 127) / 128;
+ assert ((parsed.length >= n * 128) &&
+ (condensed.length >= index + n * 192));
+
implKyber12To16(condensed, index, parsed, parsedLength);
}
diff --git a/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM_Impls.java b/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM_Impls.java
index 2ce5b3324e7..117f26e6981 100644
--- a/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM_Impls.java
+++ b/src/java.base/share/classes/com/sun/crypto/provider/ML_KEM_Impls.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, 2025, 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
@@ -26,9 +26,12 @@
package com.sun.crypto.provider;
import sun.security.jca.JCAUtil;
+import sun.security.pkcs.NamedPKCS8Key;
import sun.security.provider.NamedKEM;
import sun.security.provider.NamedKeyFactory;
import sun.security.provider.NamedKeyPairGenerator;
+import sun.security.util.KeyChoices;
+import sun.security.x509.NamedX509Key;
import java.security.*;
import java.util.Arrays;
@@ -37,6 +40,20 @@
public final class ML_KEM_Impls {
+ private static final int SEED_LEN = 64;
+
+ public static byte[] seedToExpanded(String pname, byte[] seed) {
+ return new ML_KEM(pname).generateKemKeyPair(seed)
+ .decapsulationKey()
+ .keyBytes();
+ }
+
+ public static NamedX509Key privKeyToPubKey(NamedPKCS8Key npk) {
+ return new NamedX509Key(npk.getAlgorithm(),
+ npk.getParams().getName(),
+ new ML_KEM(npk.getParams().getName()).privKeyToPubKey(npk.getExpanded()));
+ }
+
public sealed static class KPG
extends NamedKeyPairGenerator permits KPG2, KPG3, KPG5 {
@@ -50,25 +67,27 @@ protected KPG(String pname) {
}
@Override
- protected byte[][] implGenerateKeyPair(String name, SecureRandom random) {
- byte[] seed = new byte[32];
+ protected byte[][] implGenerateKeyPair(String pname, SecureRandom random) {
+ byte[] seed = new byte[SEED_LEN];
var r = random != null ? random : JCAUtil.getDefSecureRandom();
r.nextBytes(seed);
- byte[] z = new byte[32];
- r.nextBytes(z);
- ML_KEM mlKem = new ML_KEM(name);
+ ML_KEM mlKem = new ML_KEM(pname);
ML_KEM.ML_KEM_KeyPair kp;
+ kp = mlKem.generateKemKeyPair(seed);
+ var expanded = kp.decapsulationKey().keyBytes();
+
try {
- kp = mlKem.generateKemKeyPair(seed, z);
+ return new byte[][]{
+ kp.encapsulationKey().keyBytes(),
+ KeyChoices.writeToChoice(
+ KeyChoices.getPreferred("mlkem"),
+ seed, expanded),
+ expanded
+ };
} finally {
- Arrays.fill(seed, (byte)0);
- Arrays.fill(z, (byte)0);
+ Arrays.fill(seed, (byte) 0);
}
- return new byte[][] {
- kp.encapsulationKey().keyBytes(),
- kp.decapsulationKey().keyBytes()
- };
}
}
@@ -94,8 +113,39 @@ public sealed static class KF extends NamedKeyFactory permits KF2, KF3, KF5 {
public KF() {
super("ML-KEM", "ML-KEM-512", "ML-KEM-768", "ML-KEM-1024");
}
- public KF(String name) {
- super("ML-KEM", name);
+ public KF(String pname) {
+ super("ML-KEM", pname);
+ }
+
+ @Override
+ protected byte[] implExpand(String pname, byte[] input)
+ throws InvalidKeyException {
+ return KeyChoices.choiceToExpanded(pname, SEED_LEN, input,
+ ML_KEM_Impls::seedToExpanded);
+ }
+
+ @Override
+ protected Key engineTranslateKey(Key key) throws InvalidKeyException {
+ var nk = toNamedKey(key);
+ if (nk instanceof NamedPKCS8Key npk) {
+ var type = KeyChoices.getPreferred("mlkem");
+ if (KeyChoices.typeOfChoice(npk.getRawBytes()) != type) {
+ var encoding = KeyChoices.choiceToChoice(
+ type,
+ npk.getParams().getName(),
+ SEED_LEN, npk.getRawBytes(),
+ ML_KEM_Impls::seedToExpanded);
+ nk = NamedPKCS8Key.internalCreate(
+ npk.getAlgorithm(),
+ npk.getParams().getName(),
+ encoding,
+ npk.getExpanded().clone());
+ if (npk != key) { // npk is neither input or output
+ npk.destroy();
+ }
+ }
+ }
+ return nk;
}
}
@@ -121,15 +171,15 @@ public sealed static class K extends NamedKEM permits K2, K3, K5 {
private static final int SEED_SIZE = 32;
@Override
- protected byte[][] implEncapsulate(String name, byte[] encapsulationKey,
+ protected byte[][] implEncapsulate(String pname, byte[] encapsulationKey,
Object ek, SecureRandom secureRandom) {
byte[] randomBytes = new byte[SEED_SIZE];
var r = secureRandom != null ? secureRandom : JCAUtil.getDefSecureRandom();
r.nextBytes(randomBytes);
- ML_KEM mlKem = new ML_KEM(name);
- ML_KEM.ML_KEM_EncapsulateResult mlKemEncapsulateResult = null;
+ ML_KEM mlKem = new ML_KEM(pname);
+ ML_KEM.ML_KEM_EncapsulateResult mlKemEncapsulateResult;
try {
mlKemEncapsulateResult = mlKem.encapsulate(
new ML_KEM.ML_KEM_EncapsulationKey(
@@ -145,49 +195,49 @@ protected byte[][] implEncapsulate(String name, byte[] encapsulationKey,
}
@Override
- protected byte[] implDecapsulate(String name, byte[] decapsulationKey,
+ protected byte[] implDecapsulate(String pname, byte[] decapsulationKey,
Object dk, byte[] cipherText)
throws DecapsulateException {
- ML_KEM mlKem = new ML_KEM(name);
+ ML_KEM mlKem = new ML_KEM(pname);
var kpkeCipherText = new ML_KEM.K_PKE_CipherText(cipherText);
return mlKem.decapsulate(new ML_KEM.ML_KEM_DecapsulationKey(
decapsulationKey), kpkeCipherText);
}
@Override
- protected int implSecretSize(String name) {
+ protected int implSecretSize(String pname) {
return ML_KEM.SECRET_SIZE;
}
@Override
- protected int implEncapsulationSize(String name) {
- ML_KEM mlKem = new ML_KEM(name);
+ protected int implEncapsulationSize(String pname) {
+ ML_KEM mlKem = new ML_KEM(pname);
return mlKem.getEncapsulationSize();
}
@Override
- protected Object implCheckPublicKey(String name, byte[] pk)
+ protected Object implCheckPublicKey(String pname, byte[] pk)
throws InvalidKeyException {
- ML_KEM mlKem = new ML_KEM(name);
+ ML_KEM mlKem = new ML_KEM(pname);
return mlKem.checkPublicKey(pk);
}
@Override
- protected Object implCheckPrivateKey(String name, byte[] sk)
+ protected Object implCheckPrivateKey(String pname, byte[] sk)
throws InvalidKeyException {
- ML_KEM mlKem = new ML_KEM(name);
+ ML_KEM mlKem = new ML_KEM(pname);
return mlKem.checkPrivateKey(sk);
}
public K() {
- super("ML-KEM", "ML-KEM-512", "ML-KEM-768", "ML-KEM-1024");
+ super("ML-KEM", new KF());
}
- public K(String name) {
- super("ML-KEM", name);
+ public K(String pname) {
+ super("ML-KEM", new KF(pname));
}
}
diff --git a/src/java.base/share/classes/java/io/ProxyingConsole.java b/src/java.base/share/classes/java/io/ProxyingConsole.java
index 5c8da9f51da..10188f3500a 100644
--- a/src/java.base/share/classes/java/io/ProxyingConsole.java
+++ b/src/java.base/share/classes/java/io/ProxyingConsole.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2026, 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,19 +27,32 @@
import java.nio.charset.Charset;
import java.util.Locale;
+import java.util.function.Supplier;
+import jdk.internal.ValueBased;
import jdk.internal.io.JdkConsole;
/**
* Console implementation for internal use. Custom Console delegate may be
* provided with jdk.internal.io.JdkConsoleProvider.
*/
+@ValueBased
final class ProxyingConsole extends Console {
private final JdkConsole delegate;
- private final Object readLock = new Object();
- private final Object writeLock = new Object();
- private volatile Reader reader;
- private volatile PrintWriter printWriter;
+ private final LazyConstant reader =
+ LazyConstant.of(new Supplier<>(){
+ @Override
+ public Reader get() {
+ return new WrappingReader(delegate.reader());
+ }
+ });
+ private final LazyConstant printWriter =
+ LazyConstant.of(new Supplier<>() {
+ @Override
+ public PrintWriter get() {
+ return new WrappingWriter(delegate.writer());
+ }
+ });
ProxyingConsole(JdkConsole delegate) {
this.delegate = delegate;
@@ -50,17 +63,7 @@ final class ProxyingConsole extends Console {
*/
@Override
public PrintWriter writer() {
- PrintWriter printWriter = this.printWriter;
- if (printWriter == null) {
- synchronized (this) {
- printWriter = this.printWriter;
- if (printWriter == null) {
- printWriter = new WrappingWriter(delegate.writer(), writeLock);
- this.printWriter = printWriter;
- }
- }
- }
- return printWriter;
+ return printWriter.get();
}
/**
@@ -68,17 +71,7 @@ public PrintWriter writer() {
*/
@Override
public Reader reader() {
- Reader reader = this.reader;
- if (reader == null) {
- synchronized (this) {
- reader = this.reader;
- if (reader == null) {
- reader = new WrappingReader(delegate.reader(), readLock);
- this.reader = reader;
- }
- }
- }
- return reader;
+ return reader.get();
}
/**
@@ -94,9 +87,7 @@ public Console format(String format, Object ... args) {
*/
@Override
public Console format(Locale locale, String format, Object ... args) {
- synchronized (writeLock) {
- delegate.format(locale, format, args);
- }
+ delegate.format(locale, format, args);
return this;
}
@@ -113,9 +104,7 @@ public Console printf(String format, Object ... args) {
*/
@Override
public Console printf(Locale locale, String format, Object ... args) {
- synchronized (writeLock) {
- delegate.format(locale, format, args);
- }
+ delegate.format(locale, format, args);
return this;
}
@@ -132,11 +121,7 @@ public String readLine(String format, Object ... args) {
*/
@Override
public String readLine(Locale locale, String format, Object ... args) {
- synchronized (writeLock) {
- synchronized (readLock) {
- return delegate.readLine(locale, format, args);
- }
- }
+ return delegate.readLine(locale, format, args);
}
/**
@@ -144,9 +129,7 @@ public String readLine(Locale locale, String format, Object ... args) {
*/
@Override
public String readLine() {
- synchronized (readLock) {
- return delegate.readLine();
- }
+ return delegate.readLine();
}
/**
@@ -162,11 +145,7 @@ public char[] readPassword(String format, Object ... args) {
*/
@Override
public char[] readPassword(Locale locale, String format, Object ... args) {
- synchronized (writeLock) {
- synchronized (readLock) {
- return delegate.readPassword(locale, format, args);
- }
- }
+ return delegate.readPassword(locale, format, args);
}
/**
@@ -174,9 +153,7 @@ public char[] readPassword(Locale locale, String format, Object ... args) {
*/
@Override
public char[] readPassword() {
- synchronized (readLock) {
- return delegate.readPassword();
- }
+ return delegate.readPassword();
}
/**
@@ -197,19 +174,15 @@ public Charset charset() {
private static final class WrappingReader extends Reader {
private final Reader r;
- private final Object lock;
- WrappingReader(Reader r, Object lock) {
- super(lock);
+ WrappingReader(Reader r) {
+ super(r);
this.r = r;
- this.lock = lock;
}
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
- synchronized (lock) {
- return r.read(cbuf, off, len);
- }
+ return r.read(cbuf, off, len);
}
@Override
@@ -219,25 +192,8 @@ public void close() {
}
private static final class WrappingWriter extends PrintWriter {
- private final PrintWriter pw;
- private final Object lock;
-
- public WrappingWriter(PrintWriter pw, Object lock) {
- super(pw, lock);
- this.pw = pw;
- this.lock = lock;
- }
-
- @Override
- public void write(char[] cbuf, int off, int len) {
- synchronized (lock) {
- pw.write(cbuf, off, len);
- }
- }
-
- @Override
- public void flush() {
- pw.flush();
+ public WrappingWriter(PrintWriter pw) {
+ super(pw);
}
@Override
diff --git a/src/java.base/share/classes/java/lang/classfile/attribute/CharacterRangeInfo.java b/src/java.base/share/classes/java/lang/classfile/attribute/CharacterRangeInfo.java
index f6f5f9928bc..e1cc52bfa1d 100644
--- a/src/java.base/share/classes/java/lang/classfile/attribute/CharacterRangeInfo.java
+++ b/src/java.base/share/classes/java/lang/classfile/attribute/CharacterRangeInfo.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2022, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2022, 2026, 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
@@ -124,7 +124,7 @@ public sealed interface CharacterRangeInfo
* {@link CharacterRange#FLAG_BRANCH_TRUE} A condition encoded
* in the branch instruction immediately contained in the code range for
* this item is not inverted towards the corresponding branch condition in
- * the source code. I.e. actual jump occurs if and only if the the source
+ * the source code. I.e. actual jump occurs if and only if the source
* code branch condition evaluates to true. Entries of this type are
* produced only for conditions that are listed in the description of
* CRT_FLOW_CONTROLLER flag. The source range for the entry contains flow
@@ -136,7 +136,7 @@ public sealed interface CharacterRangeInfo
* {@link CharacterRange#FLAG_BRANCH_FALSE} A condition encoded
* in the branch instruction immediately contained in the code range for
* this item is inverted towards the corresponding branch condition in the
- * source code. I.e. actual jump occurs if and only if the the source code
+ * source code. I.e. actual jump occurs if and only if the source code
* branch condition evaluates to false. Entries of this type are produced
* only for conditions that are listed in the description of
* CRT_FLOW_CONTROLLER flag. The source range for the entry contains flow
diff --git a/src/java.base/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java b/src/java.base/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java
index 192b1f7958b..4e6cadc737c 100644
--- a/src/java.base/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java
+++ b/src/java.base/share/classes/java/nio/channels/AsynchronousServerSocketChannel.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2007, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2007, 2026, 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
@@ -208,7 +208,7 @@ public final AsynchronousServerSocketChannel bind(SocketAddress local)
* The {@code backlog} parameter is the maximum number of pending
* connections on the socket. Its exact semantics are implementation specific.
* In particular, an implementation may impose a maximum length or may choose
- * to ignore the parameter altogther. If the {@code backlog} parameter has
+ * to ignore the parameter altogether. If the {@code backlog} parameter has
* the value {@code 0}, or a negative value, then an implementation specific
* default is used.
*
diff --git a/src/java.base/share/classes/java/time/format/DateTimeFormatter.java b/src/java.base/share/classes/java/time/format/DateTimeFormatter.java
index 16d7193c556..9368cf54afd 100644
--- a/src/java.base/share/classes/java/time/format/DateTimeFormatter.java
+++ b/src/java.base/share/classes/java/time/format/DateTimeFormatter.java
@@ -1,5 +1,5 @@
/*
- * Copyright (c) 2012, 2025, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2026, 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
@@ -817,6 +817,7 @@ public static DateTimeFormatter ofLocalizedPattern(String requestedTemplate) {
*
The {@link #ISO_LOCAL_DATE}
* The {@link ZoneOffset#getId() offset ID}. If the offset has seconds then
* they will be handled even though this is not part of the ISO-8601 standard.
+ * The offset parsing is lenient, which allows the minutes and seconds to be optional.
* Parsing is case insensitive.
*