1 /*
2 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23 package jit.escape.LockCoarsening;
24
25 import nsk.share.TestFailure;
26
27 class LockCoarsening {
28 // JVM option '-XX:+EliminateLocks' specified
29 public static boolean eliminateLocks = false;
30 // Number of chances Thread 2 has to acquire the lock
31 public static int numChances = 16;
32
33 // Signals to Threads_2 that Thread_1 started execuition
34 public static volatile boolean start;
35 // Signals to Thread_2 to stop execution
36 public static volatile boolean done;
37 // Thread_2 has acquired the lock
38 public static volatile boolean acquiredLock;
39 // Actually running the test
40 public static volatile boolean realrun;
41 // Thread 2 'acquire lock chance' number
42 public static volatile int currentChance;
43
44 static Thread_2 t2;
45
46 public static void main(String[] args) {
47 parseArgs(args);
48
49 Thread.currentThread().getThreadGroup().setMaxPriority(Thread.MAX_PRIORITY);
50
51 currentChance = 1;
52
53 do {
54 System.out.println("Chance " + currentChance + ":");
55
56 Thread_1 t1 = new Thread_1();
57 t1.getThreadGroup().setMaxPriority(Thread.MAX_PRIORITY);
58 t1.setPriority(Thread.MIN_PRIORITY);
59 t1.start();
60
61 try {
62 t1.join();
63 } catch (InterruptedException e) {
64 }
65
66 System.out.println();
67
68 // if thread 2 hasn't acquired lock and we are not eliminating them, give it one more try...
69 } while (!eliminateLocks && !acquiredLock && ++currentChance <= numChances);
70
71 System.out.println("Thread 2 has acquired lock: " + acquiredLock);
72
73 boolean failed = false;
74
75 if (!eliminateLocks) {
76 if (!acquiredLock) {
77 failed = true;
78
79 throw new TestFailure("acquiredLock == false, though, '-XX:-EliminateLocks' specified");
80 }
81 } else {
82 if (acquiredLock) {
83 failed = true;
84
85 throw new TestFailure("acquiredLock == true, though, '-XX:+EliminateLocks' specified");
86 }
87 }
88
89 if (!failed)
90 System.out.println("TEST PASSED");
91 else
92 throw new TestFailure("TEST FAILED");
93 }
94
95 private static void parseArgs(String[] args) {
96 eliminateLocks = false;
97
98 for (int i = 0; i < args.length; ++i) {
99 String arg = args[i];
100 String val;
101
102 if (arg.equals("-eliminateLocks")) {
103 eliminateLocks = true;
104 } else if (arg.equals("-numChances")) {
105 if (++i >= args.length)
106 throw new TestFailure("'numChances' parameter requires an integer value");
107 val = args[i];
108 try {
109 numChances = Integer.parseInt(val);
110 } catch (NumberFormatException e) {
111 throw new TestFailure("invalid value for 'numChances'");
112 }
113 } else {
114 System.out.println("Invalid argument: " + args);
115
116 }
117 }
118 }
119
120 /**
121 * Thread that enters synchronized parts which are subject of
122 * lock coarsening
123 */
124 public static class Thread_1 extends Thread {
125 public void run() {
126 Dummy lock = new Dummy();
127
128 // An ugly-terrible hack to force JIT to compile Thread_1.doit():
129 // 1: call method from a static method of another class within a loop
130 System.out.println("**** Compilation warm-up *****");
131 realrun = false;
132 Helper.callMethod(this, lock);
133
134 // 2: call method normally
135 System.out.println("**** Starting real run ****");
136 realrun = true;
137 this.doit(lock);
138 }
139
140 public final void doit(Dummy _lock) {
141 Dummy lock = new Dummy();
142
143 start = false;
144 done = false;
145 acquiredLock = false;
146
147 /*Thread_2*/
148 t2 = new Thread_2(lock);
149 t2.getThreadGroup().setMaxPriority(Thread.MAX_PRIORITY);
150 t2.setPriority(Thread.MAX_PRIORITY);
151 t2.start();
152
153 //waiting for the Thread_2 to invoke lock.wait()
154 while (t2.getState() != Thread.State.WAITING) { }
155 start = true;
156
157 // The following code is subject to lock coarsening if eliminateLocks == true
158 {
159 synchronized (lock) {
160 lock.foo();
161 }
162
163 synchronized (lock) {
164 lock.foo();
165 }
166
167 synchronized (lock) {
168 lock.foo();
169 }
170
171 synchronized (lock) {
172 lock.foo();
173 }
174
175 synchronized (lock) {
176 lock.foo();
177 }
178
179 synchronized (lock) {
180 lock.foo();
181 }
182
183 synchronized (lock) {
184 lock.foo();
185 }
186
187 synchronized (lock) {
188 lock.foo();
189 }
190
191 synchronized (lock) {
192 lock.foo();
193 }
194
195 synchronized (lock) {
196 lock.foo();
197 }
198
199 synchronized (lock) {
200 lock.foo();
201 }
202
203 synchronized (lock) {
204 lock.foo();
205 }
206
207 synchronized (lock) {
208 lock.foo();
209 }
210
211 synchronized (lock) {
212 lock.foo();
213 }
214
215 synchronized (lock) {
216 lock.foo();
217 }
218
219 synchronized (lock) {
220 lock.foo();
221 }
222
223 synchronized (lock) {
224 lock.foo();
225 }
226
227 synchronized (lock) {
228 lock.foo();
229 }
230
231 synchronized (lock) {
232 lock.foo();
233 }
234
235 synchronized (lock) {
236 lock.foo();
237 }
238
239 synchronized (lock) {
240 lock.foo();
241 }
242
243 synchronized (lock) {
244 lock.foo();
245 }
246
247 synchronized (lock) {
248 lock.foo();
249 }
250
251 synchronized (lock) {
252 lock.foo();
253 }
254
255 synchronized (lock) {
256 lock.foo();
257 }
258
259 synchronized (lock) {
260 lock.foo();
261 }
262
263 synchronized (lock) {
264 lock.foo();
265 }
266
267 synchronized (lock) {
268 lock.foo();
269 }
270
271 synchronized (lock) {
272 lock.foo();
273 }
274
275 synchronized (lock) {
276 lock.foo();
277 }
278
279 synchronized (lock) {
280 lock.foo();
281 }
282
283 synchronized (lock) {
284 lock.foo();
285 }
286
287 synchronized (lock) {
288 lock.foo();
289 }
290
291 synchronized (lock) {
292 lock.foo();
293 }
294
295 synchronized (lock) {
296 lock.foo();
297 }
298
299 synchronized (lock) {
300 lock.foo();
301 }
302
303 synchronized (lock) {
304 lock.foo();
305 }
306
307 synchronized (lock) {
308 lock.foo();
309 }
310
311 synchronized (lock) {
312 lock.foo();
313 }
314
315 synchronized (lock) {
316 lock.foo();
317 }
318
319 synchronized (lock) {
320 lock.foo();
321 }
322
323 synchronized (lock) {
324 lock.foo();
325 }
326
327 synchronized (lock) {
328 lock.foo();
329 }
330
331 synchronized (lock) {
332 lock.foo();
333 }
334
335 synchronized (lock) {
336 lock.foo();
337 }
338
339 synchronized (lock) {
340 lock.foo();
341 }
342
343 synchronized (lock) {
344 lock.foo();
345 }
346
347 synchronized (lock) {
348 lock.foo();
349 }
350
351 synchronized (lock) {
352 lock.foo();
353 }
354
355 synchronized (lock) {
356 lock.foo();
357 }
358
359 synchronized (lock) {
360 lock.foo();
361 }
362
363 synchronized (lock) {
364 lock.foo();
365 }
366
367 synchronized (lock) {
368 lock.foo();
369 }
370
371 synchronized (lock) {
372 lock.foo();
373 }
374
375 synchronized (lock) {
376 lock.foo();
377 }
378
379 synchronized (lock) {
380 lock.foo();
381 }
382
383 synchronized (lock) {
384 lock.foo();
385 }
386
387 synchronized (lock) {
388 lock.foo();
389 }
390
391 synchronized (lock) {
392 lock.foo();
393 }
394
395 synchronized (lock) {
396 lock.foo();
397 }
398
399 synchronized (lock) {
400 lock.foo();
401 }
402
403 synchronized (lock) {
404 lock.foo();
405 }
406
407 synchronized (lock) {
408 lock.foo();
409 }
410
411 synchronized (lock) {
412 lock.foo();
413 }
414
415 synchronized (lock) {
416 lock.foo();
417 }
418
419 synchronized (lock) {
420 lock.foo();
421 }
422
423 synchronized (lock) {
424 lock.foo();
425 }
426
427 synchronized (lock) {
428 lock.foo();
429 }
430
431 synchronized (lock) {
432 lock.foo();
433 }
434
435 synchronized (lock) {
436 lock.foo();
437 }
438
439 synchronized (lock) {
440 lock.foo();
441 }
442
443 synchronized (lock) {
444 lock.foo();
445 }
446
447 synchronized (lock) {
448 lock.foo();
449 }
450
451 synchronized (lock) {
452 lock.foo();
453 }
454
455 synchronized (lock) {
456 lock.foo();
457 }
458
459 synchronized (lock) {
460 lock.foo();
461 }
462
463 synchronized (lock) {
464 lock.foo();
465 }
466
467 synchronized (lock) {
468 lock.foo();
469 }
470
471 synchronized (lock) {
472 lock.foo();
473 }
474
475 synchronized (lock) {
476 lock.foo();
477 }
478
479 synchronized (lock) {
480 lock.foo();
481 }
482
483 synchronized (lock) {
484 lock.foo();
485 }
486
487 synchronized (lock) {
488 lock.foo();
489 }
490
491 synchronized (lock) {
492 lock.foo();
493 }
494
495 synchronized (lock) {
496 lock.foo();
497 }
498
499 synchronized (lock) {
500 lock.foo();
501 }
502
503 synchronized (lock) {
504 lock.foo();
505 }
506
507 synchronized (lock) {
508 lock.foo();
509 }
510
511 synchronized (lock) {
512 lock.foo();
513 }
514
515 synchronized (lock) {
516 lock.foo();
517 }
518
519 synchronized (lock) {
520 lock.foo();
521 }
522
523 synchronized (lock) {
524 lock.foo();
525 }
526
527 synchronized (lock) {
528 lock.foo();
529 }
530
531 synchronized (lock) {
532 lock.foo();
533 }
534
535 synchronized (lock) {
536 lock.foo();
537 }
538
539 synchronized (lock) {
540 lock.foo();
541 }
542
543 synchronized (lock) {
544 lock.foo();
545 }
546
547 synchronized (lock) {
548 lock.foo();
549 }
550
551 synchronized (lock) {
552 lock.foo();
553 }
554
555 synchronized (lock) {
556 lock.foo();
557 }
558
559 synchronized (lock) {
560 lock.foo();
561 }
562
563 synchronized (lock) {
564 lock.foo();
565 }
566
567 synchronized (lock) {
568 lock.foo();
569 }
570
571 synchronized (lock) {
572 lock.foo();
573 }
574
575 synchronized (lock) {
576 lock.foo();
577 }
578
579 synchronized (lock) {
580 lock.foo();
581 }
582
583 synchronized (lock) {
584 lock.foo();
585 }
586
587 synchronized (lock) {
588 lock.foo();
589 }
590
591 synchronized (lock) {
592 lock.foo();
593 }
594
595 synchronized (lock) {
596 lock.foo();
597 }
598
599 synchronized (lock) {
600 lock.foo();
601 }
602
603 synchronized (lock) {
604 lock.foo();
605 }
606
607 synchronized (lock) {
608 lock.foo();
609 }
610
611 synchronized (lock) {
612 lock.foo();
613 }
614
615 synchronized (lock) {
616 lock.foo();
617 }
618
619 synchronized (lock) {
620 lock.foo();
621 }
622
623 synchronized (lock) {
624 lock.foo();
625 }
626
627 synchronized (lock) {
628 lock.foo();
629 }
630
631 synchronized (lock) {
632 lock.foo();
633 }
634
635 synchronized (lock) {
636 lock.foo();
637 }
638
639 synchronized (lock) {
640 lock.foo();
641 }
642
643 synchronized (lock) {
644 lock.foo();
645 }
646
647 synchronized (lock) {
648 lock.foo();
649 }
650
651 synchronized (lock) {
652 lock.foo();
653 }
654
655 synchronized (lock) {
656 lock.foo();
657 }
658
659 synchronized (lock) {
660 lock.foo();
661 }
662
663 synchronized (lock) {
664 lock.foo();
665 }
666
667 synchronized (lock) {
668 lock.foo();
669 }
670
671 synchronized (lock) {
672 lock.foo();
673 }
674
675 synchronized (lock) {
676 lock.foo();
677 }
678
679 synchronized (lock) {
680 lock.foo();
681 }
682
683 synchronized (lock) {
684 lock.foo();
685 }
686
687 synchronized (lock) {
688 lock.foo();
689 }
690
691 synchronized (lock) {
692 lock.foo();
693 }
694
695 synchronized (lock) {
696 lock.foo();
697 }
698
699 synchronized (lock) {
700 lock.foo();
701 }
702
703 synchronized (lock) {
704 lock.foo();
705 }
706
707 synchronized (lock) {
708 lock.foo();
709 }
710
711 synchronized (lock) {
712 lock.foo();
713 }
714
715 synchronized (lock) {
716 lock.foo();
717 }
718
719 synchronized (lock) {
720 lock.foo();
721 }
722
723 synchronized (lock) {
724 lock.foo();
725 }
726
727 synchronized (lock) {
728 lock.foo();
729 }
730
731 synchronized (lock) {
732 lock.foo();
733 }
734
735 synchronized (lock) {
736 lock.foo();
737 }
738
739 synchronized (lock) {
740 lock.foo();
741 }
742
743 synchronized (lock) {
744 lock.foo();
745 }
746
747 synchronized (lock) {
748 lock.foo();
749 }
750
751 synchronized (lock) {
752 lock.foo();
753 }
754
755 synchronized (lock) {
756 lock.foo();
757 }
758
759 synchronized (lock) {
760 lock.foo();
761 }
762
763 synchronized (lock) {
764 lock.foo();
765 }
766
767 synchronized (lock) {
768 lock.foo();
769 }
770
771 synchronized (lock) {
772 lock.foo();
773 }
774
775 synchronized (lock) {
776 lock.foo();
777 }
778
779 synchronized (lock) {
780 lock.foo();
781 }
782
783 synchronized (lock) {
784 lock.foo();
785 }
786
787 synchronized (lock) {
788 lock.foo();
789 }
790
791 synchronized (lock) {
792 lock.foo();
793 }
794
795 synchronized (lock) {
796 lock.foo();
797 }
798
799 synchronized (lock) {
800 lock.foo();
801 }
802
803 synchronized (lock) {
804 lock.foo();
805 }
806
807 synchronized (lock) {
808 lock.foo();
809 }
810
811 synchronized (lock) {
812 lock.foo();
813 }
814
815 synchronized (lock) {
816 lock.foo();
817 }
818
819 synchronized (lock) {
820 lock.foo();
821 }
822
823 synchronized (lock) {
824 lock.foo();
825 }
826
827 synchronized (lock) {
828 lock.foo();
829 }
830
831 synchronized (lock) {
832 lock.foo();
833 }
834
835 synchronized (lock) {
836 lock.foo();
837 }
838
839 synchronized (lock) {
840 lock.foo();
841 }
842
843 synchronized (lock) {
844 lock.foo();
845 }
846
847 synchronized (lock) {
848 lock.foo();
849 }
850
851 synchronized (lock) {
852 lock.foo();
853 }
854
855 synchronized (lock) {
856 lock.foo();
857 }
858
859 synchronized (lock) {
860 lock.foo();
861 }
862
863 synchronized (lock) {
864 lock.foo();
865 }
866
867 synchronized (lock) {
868 lock.foo();
869 }
870
871 synchronized (lock) {
872 lock.foo();
873 }
874
875 synchronized (lock) {
876 lock.foo();
877 }
878
879 synchronized (lock) {
880 lock.foo();
881 }
882
883 synchronized (lock) {
884 lock.foo();
885 }
886
887 synchronized (lock) {
888 lock.foo();
889 }
890
891 synchronized (lock) {
892 lock.foo();
893 }
894
895 synchronized (lock) {
896 lock.foo();
897 }
898
899 synchronized (lock) {
900 lock.foo();
901 }
902
903 synchronized (lock) {
904 lock.foo();
905 }
906
907 synchronized (lock) {
908 lock.foo();
909 }
910
911 synchronized (lock) {
912 lock.foo();
913 }
914
915 synchronized (lock) {
916 lock.foo();
917 }
918
919 synchronized (lock) {
920 lock.foo();
921 }
922
923 synchronized (lock) {
924 lock.foo();
925 }
926
927 synchronized (lock) {
928 lock.foo();
929 }
930
931 synchronized (lock) {
932 lock.foo();
933 }
934
935 synchronized (lock) {
936 lock.foo();
937 }
938
939 synchronized (lock) {
940 lock.foo();
941 }
942
943 synchronized (lock) {
944 lock.foo();
945 }
946
947 synchronized (lock) {
948 lock.foo();
949 }
950
951 synchronized (lock) {
952 lock.foo();
953 }
954
955 synchronized (lock) {
956 lock.foo();
957 }
958
959 synchronized (lock) {
960 lock.foo();
961 }
962
963 synchronized (lock) {
964 lock.foo();
965 }
966
967 synchronized (lock) {
968 lock.foo();
969 }
970
971 synchronized (lock) {
972 lock.foo();
973 }
974
975 synchronized (lock) {
976 lock.foo();
977 }
978
979 synchronized (lock) {
980 lock.foo();
981 }
982
983 synchronized (lock) {
984 lock.foo();
985 }
986
987 synchronized (lock) {
988 lock.foo();
989 }
990
991 synchronized (lock) {
992 lock.foo();
993 }
994
995 synchronized (lock) {
996 lock.foo();
997 }
998
999 synchronized (lock) {
1000 lock.foo();
1001 }
1002
1003 synchronized (lock) {
1004 lock.foo();
1005 }
1006
1007 synchronized (lock) {
1008 lock.foo();
1009 }
1010
1011 synchronized (lock) {
1012 lock.foo();
1013 }
1014
1015 synchronized (lock) {
1016 lock.foo();
1017 }
1018
1019 synchronized (lock) {
1020 lock.foo();
1021 }
1022
1023 synchronized (lock) {
1024 lock.foo();
1025 }
1026
1027 synchronized (lock) {
1028 lock.foo();
1029 }
1030
1031 synchronized (lock) {
1032 lock.foo();
1033 }
1034
1035 synchronized (lock) {
1036 lock.foo();
1037 }
1038
1039 synchronized (lock) {
1040 lock.foo();
1041 }
1042
1043 synchronized (lock) {
1044 lock.foo();
1045 }
1046
1047 synchronized (lock) {
1048 lock.foo();
1049 }
1050
1051 synchronized (lock) {
1052 lock.foo();
1053 }
1054
1055 synchronized (lock) {
1056 lock.foo();
1057 }
1058
1059 synchronized (lock) {
1060 lock.foo();
1061 }
1062
1063 synchronized (lock) {
1064 lock.foo();
1065 }
1066
1067 synchronized (lock) {
1068 lock.foo();
1069 }
1070
1071 synchronized (lock) {
1072 lock.foo();
1073 }
1074
1075 synchronized (lock) {
1076 lock.foo();
1077 }
1078
1079 synchronized (lock) {
1080 lock.foo();
1081 }
1082
1083 synchronized (lock) {
1084 lock.foo();
1085 }
1086
1087 synchronized (lock) {
1088 lock.foo();
1089 }
1090
1091 synchronized (lock) {
1092 lock.foo();
1093 }
1094
1095 synchronized (lock) {
1096 lock.foo();
1097 }
1098
1099 synchronized (lock) {
1100 lock.foo();
1101 }
1102
1103 synchronized (lock) {
1104 lock.foo();
1105 }
1106
1107 synchronized (lock) {
1108 lock.foo();
1109 }
1110
1111 synchronized (lock) {
1112 lock.foo();
1113 }
1114
1115 synchronized (lock) {
1116 lock.foo();
1117 }
1118
1119 synchronized (lock) {
1120 lock.foo();
1121 }
1122
1123 synchronized (lock) {
1124 lock.foo();
1125 }
1126
1127 synchronized (lock) {
1128 lock.foo();
1129 }
1130
1131 synchronized (lock) {
1132 lock.foo();
1133 }
1134
1135 synchronized (lock) {
1136 lock.foo();
1137 }
1138
1139 synchronized (lock) {
1140 lock.foo();
1141 }
1142
1143 synchronized (lock) {
1144 lock.foo();
1145 }
1146
1147 synchronized (lock) {
1148 lock.foo();
1149 }
1150
1151 synchronized (lock) {
1152 lock.foo();
1153 }
1154
1155 synchronized (lock) {
1156 lock.foo();
1157 }
1158
1159 synchronized (lock) {
1160 lock.foo();
1161 }
1162
1163 synchronized (lock) {
1164 lock.foo();
1165 }
1166
1167 synchronized (lock) {
1168 lock.foo();
1169 }
1170
1171 synchronized (lock) {
1172 lock.foo();
1173 }
1174
1175 synchronized (lock) {
1176 lock.foo();
1177 }
1178
1179 synchronized (lock) {
1180 lock.foo();
1181 }
1182
1183 synchronized (lock) {
1184 lock.foo();
1185 }
1186
1187 synchronized (lock) {
1188 lock.foo();
1189 }
1190
1191 synchronized (lock) {
1192 lock.foo();
1193 }
1194
1195 synchronized (lock) {
1196 lock.foo();
1197 }
1198
1199 synchronized (lock) {
1200 lock.foo();
1201 }
1202
1203 synchronized (lock) {
1204 lock.foo();
1205 }
1206
1207 synchronized (lock) {
1208 lock.foo();
1209 }
1210
1211 synchronized (lock) {
1212 lock.foo();
1213 }
1214
1215 synchronized (lock) {
1216 lock.foo();
1217 }
1218
1219 synchronized (lock) {
1220 lock.foo();
1221 }
1222
1223 synchronized (lock) {
1224 lock.foo();
1225 }
1226
1227 synchronized (lock) {
1228 lock.foo();
1229 }
1230
1231 synchronized (lock) {
1232 lock.foo();
1233 }
1234
1235 synchronized (lock) {
1236 lock.foo();
1237 }
1238
1239 synchronized (lock) {
1240 lock.foo();
1241 }
1242
1243 synchronized (lock) {
1244 lock.foo();
1245 }
1246
1247 synchronized (lock) {
1248 lock.foo();
1249 }
1250
1251 synchronized (lock) {
1252 lock.foo();
1253 }
1254
1255 synchronized (lock) {
1256 lock.foo();
1257 }
1258
1259 synchronized (lock) {
1260 lock.foo();
1261 }
1262
1263 synchronized (lock) {
1264 lock.foo();
1265 }
1266
1267 synchronized (lock) {
1268 lock.foo();
1269 }
1270
1271 synchronized (lock) {
1272 lock.foo();
1273 }
1274
1275 synchronized (lock) {
1276 lock.foo();
1277 }
1278
1279 synchronized (lock) {
1280 lock.foo();
1281 }
1282
1283 synchronized (lock) {
1284 lock.foo();
1285 }
1286
1287 synchronized (lock) {
1288 lock.foo();
1289 }
1290
1291 synchronized (lock) {
1292 lock.foo();
1293 }
1294
1295 synchronized (lock) {
1296 lock.foo();
1297 }
1298
1299 synchronized (lock) {
1300 lock.foo();
1301 }
1302
1303 synchronized (lock) {
1304 lock.foo();
1305 }
1306
1307 synchronized (lock) {
1308 lock.foo();
1309 }
1310
1311 synchronized (lock) {
1312 lock.foo();
1313 }
1314
1315 synchronized (lock) {
1316 lock.foo();
1317 }
1318
1319 synchronized (lock) {
1320 lock.foo();
1321 }
1322
1323 synchronized (lock) {
1324 lock.foo();
1325 }
1326
1327 synchronized (lock) {
1328 lock.foo();
1329 }
1330
1331 synchronized (lock) {
1332 lock.foo();
1333 }
1334
1335 synchronized (lock) {
1336 lock.foo();
1337 }
1338
1339 synchronized (lock) {
1340 lock.foo();
1341 }
1342
1343 synchronized (lock) {
1344 lock.foo();
1345 }
1346
1347 synchronized (lock) {
1348 lock.foo();
1349 }
1350
1351 synchronized (lock) {
1352 lock.foo();
1353 }
1354
1355 // Footer
1356 synchronized (lock) {
1357 lock.foo();
1358
1359 done = true;
1360
1361 lock.notify();
1362 }
1363 }
1364 try {
1365 t2.join();
1366 } catch (InterruptedException e) {
1367 }
1368 }
1369 }
1370
1371 /**
1372 * Thread that tries to acquire lock during lock coarsening.
1373 * If it unable to do it then lock coarsening occurred.
1374 */
1375 private static class Thread_2 extends Thread {
1376 private Dummy lock;
1377
1378 public Thread_2(Dummy lock) {
1379 this.lock = lock;
1380 }
1381
1382 public void run() {
1383 Dummy lock = this.lock;
1384
1385 synchronized (lock) {
1386 if (!done) {
1387 while (!start) {
1388 try {
1389 lock.wait();
1390 } catch (InterruptedException e) {
1391 System.out.println("Interrupted!");
1392 }
1393 }
1394
1395 if (!done) {
1396 done = true;
1397
1398 acquiredLock = true;
1399
1400 if (realrun) {
1401 System.out.println("Acquired lock at " + lock.counter + " iteration of " + currentChance + " chance");
1402 } else if (eliminateLocks) {
1403 //forcibly stop warm-up as we see that lock coarsening occurs
1404 Helper.allowExec = true;
1405 }
1406
1407 }
1408 }
1409 }
1410 }
1411 }
1412
1413 /**
1414 * Helper class to make method Thread_1.doit() be compiled.
1415 */
1416 public static class Helper {
1417 public static volatile boolean allowExec = false;
1418 private static int iterations = 10000;
1419
1420 public static void callMethod(Thread_1 t, Dummy lock) {
1421 for (int i = 0; i < iterations; ++i) {
1422 t.doit(lock);
1423 if (allowExec)
1424 break;
1425 }
1426 }
1427 }
1428
1429 /**
1430 * Class to count number of synchronized statement.
1431 * If test fails Dummy.counter shows iteration when lock coarsening did not happen
1432 */
1433 public static class Dummy {
1434 public volatile int counter = 0;
1435
1436 public void foo() {
1437 if (done)
1438 return;
1439
1440 while (t2.getState() != Thread.State.BLOCKED && t2.getState() != Thread.State.WAITING) {
1441 this.notifyAll();
1442
1443 Thread.yield();
1444 }
1445
1446 this.notifyAll();
1447
1448 while (t2.getState() != Thread.State.BLOCKED) {
1449 Thread.yield();
1450 }
1451
1452 ++counter;
1453
1454 Thread.yield();
1455 Thread.yield();
1456 Thread.yield();
1457 Thread.yield();
1458 Thread.yield();
1459 Thread.yield();
1460 Thread.yield();
1461 Thread.yield();
1462 Thread.yield();
1463 Thread.yield();
1464 Thread.yield();
1465 Thread.yield();
1466 Thread.yield();
1467 Thread.yield();
1468 Thread.yield();
1469 Thread.yield();
1470 Thread.yield();
1471 Thread.yield();
1472 Thread.yield();
1473 Thread.yield();
1474 }
1475 }
1476 }