2121* questions.
2222*/
2323
24-
25-
2624/*
2725 * @test
2826 * @summary Fuzz tests for java.lang.Continuation
4543// * @run main/othervm/timeout=300 -XX:+UseContinuationLazyCopy -XX:-UseContinuationChunks -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. Fuzz
4644// * @run main/othervm/timeout=300 -XX:+UseContinuationLazyCopy -XX:+UseContinuationChunks -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. Fuzz
4745
46+ // * @run main/othervm/timeout=3000 -XX:StartFlightRecording=filename=test.jfr,settings=profile -XX:+UseContinuationLazyCopy -XX:-UseContinuationChunks -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xbootclasspath/a:. Fuzz
47+
4848// Anything excluded or not compileonly is not compiled; see CompilerOracle::should_exclude
4949
5050// @run driver jdk.test.lib.FileInstaller compilerDirectives.json compilerDirectives.json
5151// -XX:CompilerDirectivesFile=compilerDirectives.json
5252
53- import java .lang .invoke .MethodHandle ;
54- import java .lang .invoke .MethodHandles ;
55- import java .lang .invoke .MethodType ;
56- import java .lang .reflect .InvocationTargetException ;
57- import java .lang .reflect .Method ;
58- import java .lang .reflect .Modifier ;
53+ import java .lang .invoke .*;
54+ import java .lang .reflect .*;
5955import java .lang .StackWalker .StackFrame ;
6056import java .io .IOException ;
61- import java .nio .file .Files ;
62- import java .nio .file .Path ;
63- import java .util .ArrayList ;
64- import java .util .Arrays ;
65- import java .util .EnumMap ;
66- import java .util .EnumSet ;
67- import java .util .List ;
68- import java .util .Map ;
69- import java .util .Objects ;
70- import java .util .Random ;
71- import java .util .Set ;
72- import java .util .HashSet ;
57+ import java .nio .file .*;
58+ import java .util .*;
7359import java .util .stream .Collectors ;
7460import java .util .stream .Stream ;
7561import static java .lang .Math .max ;
8066import sun .hotspot .WhiteBox ;
8167
8268public class Fuzz implements Runnable {
83- static final boolean VERIFY_STACK = true ; // could add significant time
69+ static final boolean VERIFY_STACK = false ; // could add significant time
70+ static final boolean FILE = true ;
8471 static final boolean RANDOM = false ;
8572 static final boolean VERBOSE = false ;
8673
87- public static void main (String [] args ) {
88- for (int compileLevel : new int []{4 })
89- for (boolean compileRun : new boolean []{true })
90- test (compileLevel , compileRun );
91- }
92-
93- private static boolean COMPILE_RUN ;
94- private static int COMPILE_LEVEL ;
95-
96- static void test (int compileLevel , boolean compileRun ) {
97- resetCompilation ();
98- COMPILE_LEVEL = compileLevel ;
99- COMPILE_RUN = compileRun ;
74+ static final String FILENAME = "fuzz.dat" ;
75+ static final Path TEST_DIR = Path .of (System .getProperty ("test.src" , "." ));
10076
101- testFile ();
102- if (RANDOM )
103- testRandom ();
104- }
105-
106- static void testFile () {
107- System .out .println ("-- FILE --" );
108- try {
109- testStream (file (Path .of (System .getProperty ("test.src" , "." )).resolve ("fuzz.dat" )));
110- } catch (IOException e ) { throw new RuntimeException (e ); }
111- }
112-
113- static void testRandom () {
114- long seed = 1L ; // System.currentTimeMillis();
115- System .out .println ("-- RANDOM (seed: " + seed + ") --" );
116- testStream (random (new Random (seed )).limit (50 ));
77+ public static void main (String [] args ) {
78+ warmup ();
79+ for (int compileLevel : new int []{4 }) {
80+ for (boolean compileRun : new boolean []{true }) {
81+ COMPILE_LEVEL = compileLevel ;
82+ COMPILE_RUN = compileRun ;
83+ resetCompilation ();
84+ runTests ();
85+ }
86+ }
11787 }
11888
119- static Stream <Op []> file (Path file ) throws IOException {
120- return Files .lines (file ).map (String ::trim ).filter (s -> !s .isBlank () && !s .startsWith ("#" )).map (Fuzz ::parse );
89+ static void runTests () {
90+ if (FILE ) testFile (FILENAME );
91+ if (RANDOM ) testRandom (System .currentTimeMillis (), 50 );
12192 }
12293
123- static Stream <Op []> random (Random rnd ) {
124- var g = new Generator (rnd );
125- return Stream .iterate (0 , x ->x +1 ).map (__ -> g .generate ());
126- }
94+ static void testStream (Stream <Op []> traces ) { traces .forEach (Fuzz ::testTrace ); }
12795
128- static void testStream (Stream <Op []> traces ) {
129- traces .forEach (Fuzz ::testTrace );
130- }
96+ static final int RETRIES = 4 ;
13197
13298 static void testTrace (Op [] trace ) {
13399 System .out .println ();
@@ -144,9 +110,9 @@ static void testTrace(Op[] trace) {
144110 int yields = fuzz .test ();
145111 time (start , "Test (" + yields + " yields)" );
146112
147- if (!fuzz .checkCompilation ("AFTER" )) {
148- if (retry ++ < 2 ) {
149- System .out .println ("RETRYING" );
113+ if (!fuzz .checkCompilation ()) {
114+ if (retry ++ < RETRIES ) {
115+ System .out .println ("RETRYING " + retry );
150116 continue ;
151117 }
152118 }
@@ -180,7 +146,7 @@ enum Op {
180146 static final Op [] ARRAY = new Op [0 ];
181147 }
182148
183- ///// Trace Gnereation
149+ ///// Trace Generation
184150
185151 static class Generator {
186152 public Op [] generate () {
@@ -219,6 +185,33 @@ public Op[] generate() {
219185 private int plusOrMinus (int n ) { return rnd .nextInt (2 *n + 1 ) - n ; }
220186 }
221187
188+ static Stream <Op []> random (Random rnd ) {
189+ var g = new Generator (rnd );
190+ return Stream .iterate (0 , x ->x +1 ).map (__ -> g .generate ());
191+ }
192+
193+ static void testRandom (long seed , int number ) {
194+ System .out .println ("-- RANDOM (seed: " + seed + ") --" );
195+ testStream (random (new Random (seed )).limit (number ));
196+ }
197+
198+ //// File
199+
200+ static void testFile (String fileName ) {
201+ System .out .println ("-- FILE (" + FILENAME + ") --" );
202+ try {
203+ testStream (file (TEST_DIR .resolve (fileName )));
204+ } catch (IOException e ) { throw new RuntimeException (e ); }
205+ }
206+
207+ static Stream <Op []> file (Path file ) throws IOException {
208+ return Files .lines (file ).map (String ::trim ).filter (s -> !s .isBlank () && !s .startsWith ("#" )).map (Fuzz ::parse );
209+ }
210+
211+ static Op [] parse (String line ) {
212+ return Arrays .stream (line .split (", " )).map (s -> Enum .valueOf (Op .class , s ))
213+ .collect (Collectors .toList ()).toArray (Op .ARRAY );
214+ }
222215
223216 ////////////////////////////////////////
224217
@@ -254,12 +247,14 @@ int test() {
254247 int count = 0 ;
255248 try {
256249 while (true ) {
250+ var start = time ();
257251 cont .run ();
258252 if (cont .isDone ()) break ;
259253
260254 assert !shouldThrow ();
261255 verifyStack (cont );
262256 count ++;
257+ time (start , "Iteration" );
263258 }
264259 verifyResult (result );
265260 } catch (FuzzException e ) {
@@ -346,6 +341,7 @@ boolean shouldThrow() {
346341 switch (trace [i ]) {
347342 case CALL_I_CTCH , CALL_C_CTCH -> { return false ; }
348343 case THROW -> { return true ; }
344+ default -> {}
349345 }
350346 }
351347 return false ;
@@ -360,24 +356,28 @@ void captureStack() {
360356
361357 void verifyStack () {
362358 if (!VERIFY_STACK ) return ;
359+ var start = time ();
363360 verifyStack (backtrace );
364361 verifyStack (backtrace , StackWalkerHelper .toStackTraceElement (fbacktrace ));
365362 verifyStack (fbacktrace , lfbacktrace );
366363
367364 verifyStack (backtrace , Thread .currentThread ().getStackTrace ());
368365 verifyStack (fbacktrace , StackWalkerHelper .getStackFrames (SCOPE ));
369366 verifyStack (lfbacktrace , StackWalkerHelper .getLiveStackFrames (SCOPE ));
367+ time (start , "Verify stack" );
370368 }
371369
372370 void verifyStack (Continuation cont ) {
373371 if (!VERIFY_STACK ) return ;
372+ var start = time ();
374373 verifyStack (backtrace );
375374 verifyStack (backtrace , StackWalkerHelper .toStackTraceElement (fbacktrace ));
376375 verifyStack (fbacktrace , lfbacktrace );
377376
378377 verifyStack (backtrace , cont .getStackTrace ());
379378 verifyStack (fbacktrace , StackWalkerHelper .getStackFrames (cont ));
380379 verifyStack (lfbacktrace , StackWalkerHelper .getLiveStackFrames (cont ));
380+ time (start , "Verify continuation stack" );
381381 }
382382
383383 static boolean isStackCaptureMechanism (Object sf ) {
@@ -452,7 +452,25 @@ static String sfToString(Object f) {
452452 return f instanceof StackFrame ? StackWalkerHelper .frameToString ((StackFrame )f ) : Objects .toString (f );
453453 }
454454
455- ////// Static Helpers
455+ ////// Compilation
456+
457+ private static boolean COMPILE_RUN ;
458+ private static int COMPILE_LEVEL ;
459+
460+ static final int WARMUP_ITERS = 15_000 ;
461+ static final Op [] WARMUP_TRACE = {Op .MH_C_INT , Op .MH_C_MANY , Op .REF_C_INT , Op .REF_C_MANY , Op .CALL_C_INT };
462+
463+ static void warmup () {
464+ final long start = time ();
465+ warmup (WARMUP_TRACE , WARMUP_ITERS ); // generate (for reflection) and compile method handles
466+ time (start , "Warmup" );
467+ }
468+
469+ static void warmup (Op [] trace , int times ) {
470+ for (int i =0 ; i <times ; i ++) {
471+ new Fuzz (trace ).run ();
472+ }
473+ }
456474
457475 static void resetCompilation () {
458476 Set <Method > compile = Op .COMPILED .stream ().map (Fuzz ::method ).collect (Collectors .toCollection (HashSet ::new ));
@@ -502,13 +520,34 @@ static void compile() {
502520 time (start , "Compile" );
503521 }
504522
505- boolean checkCompilation (String message ) {
523+ boolean checkContinuationCompilation () {
524+ for (Method m : Continuation .class .getDeclaredMethods ()) {
525+ if (!WB .isMethodCompiled (m )) {
526+ if (!Modifier .isNative (m .getModifiers ())
527+ && (m .getName ().startsWith ("enter" )
528+ || m .getName ().startsWith ("yield" ))) {
529+ return false ;
530+ }
531+ }
532+ }
533+ return true ;
534+ }
535+
536+ boolean checkCompilation () {
537+ boolean res = true ;
538+
539+ if (!checkContinuationCompilation ()) {
540+ res = false ;
541+ System .out .println ("CHANGED CONTINUATION COMPILATION" );
542+ }
543+
506544 Op [] newTrace = Arrays .copyOf (trace , trace .length );
507- boolean res = checkCompilation (newTrace );
508- if (! res ) {
509- System .out .println ("CHANGED COMPILATION " + message );
545+ if (! checkCompilation (newTrace )) {
546+ res = false ;
547+ System .out .println ("CHANGED COMPILATION" );
510548 printTrace (newTrace );
511549 }
550+
512551 return res ;
513552 }
514553
@@ -523,6 +562,8 @@ static boolean checkCompilation(Op[] trace) {
523562 return ok ;
524563 }
525564
565+ //// Static Helpers
566+
526567 static void rethrow (Throwable t ) {
527568 if (t instanceof Error ) throw (Error )t ;
528569 if (t instanceof RuntimeException ) throw (RuntimeException )t ;
@@ -537,12 +578,7 @@ static <T> T[] arrayType(T[] array) {
537578
538579 static String write (Op [] trace ) {
539580 return Arrays .stream (trace ).map (Object ::toString ).collect (Collectors .joining (", " ));
540- }
541-
542- static Op [] parse (String line ) {
543- return Arrays .stream (line .split (", " )).map (s -> Enum .valueOf (Op .class , s ))
544- .collect (Collectors .toList ()).toArray (Op .ARRAY );
545- }
581+ }
546582
547583 static Method method (Op op ) { return method .get (op ); }
548584 static MethodHandle handle (Op op ) { return handle .get (op ); }
0 commit comments