infernap12/jdk
1
0
Fork 0
mirror of https://github.com/openjdk/jdk.git synced 2026-01-28 03:58:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

8349358: [JMH] Cannot access class jdk.internal.vm.ContinuationScope

Browse Source 
Reviewed-by: alanb
This commit is contained in:
SendaoYan 2025-03-06 07:00:44 +00:00
parent e82031ec1a
commit 5c552a9d64
3 changed files with 0 additions and 505 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

149
test/micro/org/openjdk/bench/loom/obsolete/FreezeAndThaw.java
View File

@ -1,149 +0,0 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.openjdk.bench.loom.obsolete;
import jdk.internal.vm.Continuation;
import jdk.internal.vm.ContinuationScope;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class FreezeAndThaw {
static final ContinuationScope SCOPE = new ContinuationScope() { };
static class Arg {
volatile int field;
}
/**
* A recursive task that optionally yields when the stack gets to a specific
* depth. If continued after yielding, it runs to completion.
*/
static class Yielder implements Runnable {
private final int paramCount;
private final int maxDepth;
private final boolean yieldAtLimit;
private Yielder(int paramCount, int maxDepth, boolean yieldAtLimit) {
if (paramCount < 1 || paramCount > 3)
throw new IllegalArgumentException();
this.paramCount = paramCount;
this.maxDepth = maxDepth;
this.yieldAtLimit = yieldAtLimit;
}
@Override
public void run() {
switch (paramCount) {
case 1: run1(maxDepth); break;
case 2: run2(maxDepth, new Arg()); break;
case 3: run3(maxDepth, new Arg(), new Arg()); break;
default: throw new Error("should not happen");
}
}
private void run1(int depth) {
if (depth > 0) {
run1(depth - 1);
} if (depth == 0) {
if (yieldAtLimit) Continuation.yield(SCOPE);
}
}
private void run2(int depth, Arg arg2) {
if (depth > 0) {
run2(depth - 1, arg2);
} if (depth == 0) {
if (yieldAtLimit) Continuation.yield(SCOPE);
} else {
// never executed
arg2.field = 0;
}
}
private void run3(int depth, Arg arg2, Arg arg3) {
if (depth > 0) {
run3(depth - 1, arg2, arg3);
} if (depth == 0) {
if (yieldAtLimit) {
Continuation.yield(SCOPE);
}
} else {
// never executed
arg2.field = 0;
arg3.field = 0;
}
}
static Continuation continuation(int paramCount, int maxDepth,
boolean yieldAtLimit) {
Runnable task = new Yielder(paramCount, maxDepth, yieldAtLimit);
return new Continuation(SCOPE, task);
}
}
@Param({"1", "2", "3"})
public int paramCount;
@Param({"5", "10", "20", "100"})
public int stackDepth;
Continuation cont;
Continuation cont0;
@Setup(Level.Invocation)
public void setup() {
// System.out.println("pc = " + paramCount + " sd = " + stackDepth);
cont = Yielder.continuation(paramCount, stackDepth, true);
cont0 = Yielder.continuation(paramCount, stackDepth, false);
}
/**
* Creates and runs a continuation that yields at a given stack depth.
*/
@Benchmark
public void baseline() {
// Continuation cont0 = Yielder.continuation(paramCount, stackDepth, false);
cont0.run();
assert cont0.isDone();
}
/**
* Creates and runs a continuation that yields at a given stack depth.
*/
@Benchmark
public void yieldAndContinue() {
// Continuation cont = Yielder.continuation(paramCount, stackDepth, true);
cont.run();
assert !cont.isDone();
cont.run();
assert cont.isDone();
}
}

252
test/micro/org/openjdk/bench/loom/obsolete/OneShot.java
View File

@ -1,252 +0,0 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.openjdk.bench.loom.obsolete;
import jdk.internal.vm.Continuation;
import jdk.internal.vm.ContinuationScope;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class OneShot {
static final ContinuationScope SCOPE = new ContinuationScope() { };
static class Arg {
volatile int field;
}
/**
* A recursive task that optionally yields when the stack gets to a specific
* depth. If continued after yielding, it runs to completion.
*/
static class Yielder implements Runnable {
private final int paramCount;
private final int maxDepth;
private final boolean yieldAtLimit;
private Yielder(int paramCount, int maxDepth, boolean yieldAtLimit) {
if (paramCount < 1 || paramCount > 3)
throw new IllegalArgumentException();
this.paramCount = paramCount;
this.maxDepth = maxDepth;
this.yieldAtLimit = yieldAtLimit;
}
@Override
public void run() {
switch (paramCount) {
case 1: run1(maxDepth); break;
case 2: run2(maxDepth, new Arg()); break;
case 3: run3(maxDepth, new Arg(), new Arg()); break;
default: throw new Error("should not happen");
}
}
private void run1(int depth) {
if (depth > 0) {
run1(depth - 1);
} if (depth == 0) {
if (yieldAtLimit) Continuation.yield(SCOPE);
}
}
private void run2(int depth, Arg arg2) {
if (depth > 0) {
run2(depth - 1, arg2);
} if (depth == 0) {
if (yieldAtLimit) Continuation.yield(SCOPE);
} else {
// never executed
arg2.field = 0;
}
}
private void run3(int depth, Arg arg2, Arg arg3) {
if (depth > 0) {
run3(depth - 1, arg2, arg3);
} if (depth == 0) {
if (yieldAtLimit) Continuation.yield(SCOPE);
} else {
// never executed
arg2.field = 0;
arg3.field = 0;
}
}
static Continuation continuation(int paramCount, int maxDepth,
boolean yieldAtLimit) {
Runnable task = new Yielder(paramCount, maxDepth, yieldAtLimit);
return new Continuation(SCOPE, task);
}
}
/**
* A recursive task that optionally yields before and/or after each call.
*/
static class Stepper implements Runnable {
private final int paramCount;
private final int maxDepth;
private final boolean yieldBefore;
private final boolean yieldAfter;
private Stepper(int paramCount,
int maxDepth,
boolean yieldBefore,
boolean yieldAfter) {
this.paramCount = paramCount;
this.maxDepth = maxDepth;
this.yieldBefore = yieldBefore;
this.yieldAfter = yieldAfter;
}
public void run() {
switch (paramCount) {
case 1: run1(maxDepth); break;
case 2: run2(maxDepth, new Arg()); break;
case 3: run3(maxDepth, new Arg(), new Arg()); break;
default: throw new Error("should not happen");
}
}
private void run1(int depth) {
if (depth > 0) {
if (yieldBefore) Continuation.yield(SCOPE);
run1(depth - 1);
if (yieldAfter) Continuation.yield(SCOPE);
}
}
private void run2(int depth, Arg arg2) {
if (depth > 0) {
if (yieldBefore) Continuation.yield(SCOPE);
run2(depth - 1, arg2);
if (yieldAfter) Continuation.yield(SCOPE);
} else if (depth < 0) {
// never executed
arg2.field = 0;
}
}
private void run3(int depth, Arg arg2, Arg arg3) {
if (depth > 0) {
if (yieldBefore) Continuation.yield(SCOPE);
run3(depth - 1, arg2, arg3);
if (yieldAfter) Continuation.yield(SCOPE);
} else if (depth < 0) {
// never executed
arg2.field = 0;
arg3.field = 0;
}
}
static Continuation continuation(int paramCount, int maxDepth,
boolean yieldBefore, boolean yieldAfter) {
Runnable task = new Stepper(paramCount, maxDepth, yieldBefore, yieldAfter);
return new Continuation(SCOPE, task);
}
}
@Param({"1", "2", "3"})
public int paramCount;
@Param({"5", "10", "20", "100"})
public int stackDepth;
/**
* Creates and run continuation that does not yield.
*/
@Benchmark
public void noYield() {
Continuation cont = Yielder.continuation(paramCount, stackDepth, false);
cont.run();
if (!cont.isDone())
throw new RuntimeException("continuation not done???");
}
/**
* Creates and runs a continuation that yields at a given stack depth.
*/
@Benchmark
public void yield() {
Continuation cont = Yielder.continuation(paramCount, stackDepth, true);
cont.run();
if (cont.isDone())
throw new RuntimeException("continuation done???");
}
/**
* Creates and runs a continuation that yields at a given stack depth, it is
* then continued to run to completion.
*/
@Benchmark
public void yieldThenContinue() {
Continuation cont = Yielder.continuation(paramCount, stackDepth, true);
cont.run();
cont.run(); // continue
if (!cont.isDone())
throw new RuntimeException("continuation not done???");
}
/**
* Creates and runs a continuation to the given stack depth, yielding before
* each call.
*/
@Benchmark
public void yieldBeforeEachCall() {
Continuation cont = Stepper.continuation(paramCount, stackDepth, true, false);
while (!cont.isDone()) {
cont.run();
}
}
/**
* Creates and runs a continuation to the given stack depth, yielding after
* each call.
*/
@Benchmark
public void yieldAfterEachCall() {
Continuation cont = Stepper.continuation(paramCount, stackDepth, false, true);
while (!cont.isDone()) {
cont.run();
}
}
/**
* Creates and runs a continuation to the given stack depth, yielding before
* and after each call.
*/
@Benchmark
public void yieldBeforeAndAfterEachCall() {
Continuation cont = Stepper.continuation(paramCount, stackDepth, true, true);
while (!cont.isDone()) {
cont.run();
}
}
}

104
test/micro/org/openjdk/bench/loom/obsolete/Oscillation.java
View File

@ -1,104 +0,0 @@
/*
* Copyright (c) 2018, 2022, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package org.openjdk.bench.loom.obsolete;
import jdk.internal.vm.Continuation;
import jdk.internal.vm.ContinuationScope;
import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.*;
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
public class Oscillation {
static final ContinuationScope SCOPE = new ContinuationScope() { };
/**
* A task that oscillates between a minimum and maximum stack depth, yielding
* at the maximum stack until continued.
*/
static class Wave implements Runnable {
private final int min;
private final int max;
private enum Mode { GROW, SHRINK }
private Mode mode;
Wave(int min, int max) {
if (min < 0)
throw new IllegalArgumentException("negative min");
if (max <= min)
throw new IllegalArgumentException("max must be greater than min");
this.min = min;
this.max = max;
this.mode = Mode.GROW;
}
private void run(int depth) {
if (depth == max) {
Continuation.yield(SCOPE);
mode = Mode.SHRINK;
} else if (depth == min) {
while (true) {
mode = Mode.GROW;
run(depth + 1);
}
} else if (mode == Mode.GROW) {
run(depth + 1);
}
}
@Override
public void run() {
run(0);
}
}
@Param({"2", "3", "4"})
public int minDepth;
@Param({"5", "6", "7", "8"})
public int maxDepth;
@Param({"10", "100", "1000"})
public int repeat;
/**
* Creates and runs a continuation that oscillates between a minimum and
* maximum stack depth, yielding at the maximum stack until continued.
*
* Useful to measure freeze and thaw, also to compare full stack vs. lazy copy.
*/
@Benchmark
public void oscillate() {
Continuation cont = new Continuation(SCOPE, new Wave(minDepth, maxDepth));
for (int i=0; i<repeat; i++) {
cont.run();
}
}
}