jikesrvm.github.io/UserGuide/ExperimentalGuidelines.html at master · JikesRVM/jikesrvm.github.io · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
---
layout: default
---
<?xml version="1.0" encoding="utf8" ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!--http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd-->
<html xmlns="http://www.w3.org/1999/xhtml"
>
<head><title>6 Experimental Guidelines</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf8" />
<meta name="generator" content="TeX4ht (https://tug.org/tex4ht/)" />
<meta name="originator" content="TeX4ht (https://tug.org/tex4ht/)" />
<!-- xhtml,charset=utf8,2,html -->
<meta name="src" content="index.tex" />
<link rel="stylesheet" type="text/css" href="index.css" />
</head><body
>
<!--l. 2--><div class="crosslinks"><p class="noindent"></p></div>
<h2 class="chapterHead"><span class="titlemark">Chapter 6</span><br /><a
 id="x8-640006"></a>Experimental Guidelines</h2>
<!--l. 5--><p class="noindent" >This section provides some tips on collecting performance numbers with Jikes
RVM.
</p>
<h3 class="sectionHead"><span class="titlemark">6.1   </span> <a
 id="x8-650006.1"></a>Which boot image should I use?</h3>
<!--l. 9--><p class="noindent" >To make a long story short the best performing conﬁguration of Jikes RVM will
almost always be <span class="obeylines-h"><span class="verb"><span
class="cmtt-10">production</span></span></span>. Unless you really know what you are doing,
don’t use any other conﬁguration to do a performance evaluation of Jikes
RVM.
</p><!--l. 11--><p class="noindent" >Any boot image you use for performance evaluation must have the following
characteristics for the results to be meaningful: </p>
     <ul class="itemize1">
     <li class="itemize"><span class="obeylines-h"><span class="verb"><span
class="cmtt-10">config.assertions=none</span></span></span>.  Unless  this  is  set,  the  runtime  system  and
     optimizing compiler will perform fairly extensive assertion checking. This
     introduces signiﬁcant runtime overhead. By convention, a conﬁguration
     with the <span class="obeylines-h"><span class="verb"><span
class="cmtt-10">Fast</span></span></span> preﬁx disables assertion checking.
     </li>
     <li class="itemize"><span class="obeylines-h"><span class="verb"><span
class="cmtt-10">config.bootimage.compiler=opt</span></span></span>. Unless this is set, the boot image will
     be compiled with the baseline compiler and virtual machine performance
     will be abysmal. Jikes RVM has been designed under the assumption that
     aggressive inlining and optimization will be applied to the VM source code.</li></ul>
<!--l. 19--><p class="noindent" >
</p>
<h3 class="sectionHead"><span class="titlemark">6.2   </span> <a
 id="x8-660006.2"></a>Compiler Replay</h3>
<!--l. 21--><p class="noindent" >The compiler-replay methodology is deterministic and eliminates memory allocation
and mutator variations due to non-deterministic application of the adaptive compiler.
We need this latter methodology because the non-determinism of the adaptive
compilation system makes it a diﬃcult platform for detailed performance studies. For
example, we cannot determine if a variation is due to the system change
being studied or just a diﬀerent application of the adaptive compiler. The
information we record and use are hot methods and blocks information. We also
record dynamic call graph with calling frequency on each edge for inlining
decisions.
</p><!--l. 23--><p class="noindent" ><span
class="cmti-10">Note that in December 2011, compiler replay was signiﬁcantly improved. The notes</span>
<span
class="cmti-10">below apply to the post December 2011 version of replay.</span>
</p><!--l. 25--><p class="noindent" >Here is how to use it:
</p><!--l. 27--><p class="noindent" >
</p>
<h4 class="subsectionHead"><span class="titlemark">6.2.1   </span> <a
 id="x8-670006.2.1"></a>Generate Advice</h4>


<!--l. 29--><p class="noindent" >There are three kinds of advice used by the replay system, each is workload-speciﬁc
(ie you should generate advice ﬁles for each benchmark): </p>
     <ul class="itemize1">
     <li class="itemize"><span
class="cmbx-10">Compilation advice (.ca ﬁle). </span>This advice records for every compiled
     method which compiler (base or opt) and if opt, at which optimization
     level it should be compiled. Replay compilation will not work without a
     compilation advice ﬁle.
     </li>
     <li class="itemize"><span
class="cmbx-10">Edge counts (.ec ﬁle). </span>This advice captures edge counts generated by
     the  execution  of  baseline-compiled  code.  Edge  counts  are  used  by  the
     compiler to understand which edges in the control ﬂow graph are hot. At
     the time of writing, edge counts were measured as contributing about 2%
     to the bottom line in terms of performance (average of DaCapo, jvm98
     and jbb)
     </li>
     <li class="itemize"><span
class="cmbx-10">Dynamic callgraph (.dc ﬁle). </span>This advice captures the dynamic call
     graph, which allows the compiler to understand the frequency with which
     particular call chains occur. This is particularly useful in guiding inlining
     decisions. At the time of writing the call graph contributes about 8% to
     the bottom line in terms of performance.</li></ul>
<!--l. 37--><p class="noindent" >One way to gather advice is to execute the benchmark multiple times under
controlled settings, producing proﬁles at each execution. Then establish the fastest
execution among the set of runs, and choose the proﬁles associated with that
execution as the advice ﬁles. A common methodology is to invoke each benchmark 20
times (ie take the best invocation from a set of 20 trials), and in each invocation, run
10 iterations of the benchmark (ie the advice will then capture the warmed-up,
steady state of the benchmark). For more advanced methodologies, please refer to
current research papers on this topic.
</p><!--l. 39--><p class="noindent" >When generating the advice, you will need to use the following command line
arguments (typically use all six arguments, so that all three advice ﬁles are generated
at each invocation):
</p>
<!--l. 41-->
<br />
    <div class="caption"
><span class="id">6cAp1x8-670006.2.1:
    </span><span
class="content">For
    adaptive
    compilation
    proﬁle</span></div><!--tex4ht:label?: x8-670006.2 --><div class="lstlisting" id="listing-41"><span class="label"><a
 id="x8-67001r1"></a></span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">enable_advice_generation</span><span
class="cmtt-10">=</span><span
class="cmtt-10">true</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">cafo</span><span
class="cmtt-10">=</span><span
class="cmtt-10">my_compiler_advice_file</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ca</span>
</div>
<!--l. 45-->
<br />
    <div class="caption"
><span class="id">6cAp2x8-670006.2.1:
    </span><span
class="content">For
    edge


    count
    proﬁle</span></div><!--tex4ht:label?: x8-670006.2 --><div class="lstlisting" id="listing-42"><span class="label"><a
 id="x8-67002r1"></a></span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">base</span><span
class="cmtt-10">:</span><span
class="cmtt-10">profile_edge_counters</span><span
class="cmtt-10">=</span><span
class="cmtt-10">true</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">base</span><span
class="cmtt-10">:</span><span
class="cmtt-10">profile_edge_counter_file</span><span
class="cmtt-10">=</span><span
class="cmtt-10">my_edge_counter_file</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ec</span>
</div>
<!--l. 49-->
<br />
    <div class="caption"
><span class="id">6cAp3x8-670006.2.1:
    </span><span
class="content">For
    dynamic
    call
    graph
    proﬁle</span></div><!--tex4ht:label?: x8-670006.2 --><div class="lstlisting" id="listing-43"><span class="label"><a
 id="x8-67003r1"></a></span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">dcfo</span><span
class="cmtt-10">=</span><span
class="cmtt-10">my_dynamic_call_graph_file</span><span
class="cmtt-10">.</span><span
class="cmtt-10">dc</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">final_report_level</span><span
class="cmtt-10">=2</span>
</div>
<!--l. 55--><p class="noindent" >
</p>
<h4 class="subsectionHead"><span class="titlemark">6.2.2   </span> <a
 id="x8-680006.2.2"></a>Executing with advice</h4>
<!--l. 57--><p class="noindent" >The basic model is simple. At a nominated time in the execution of a program,
all methods speciﬁed in the .ca advice ﬁle will be (re)compiled with the
compiler and optimization level nominated in the advice ﬁle. Broadly, there
are two ways of initiating bulk compilation: a) by calling the method
<span
class="cmtt-10">org.jikesrvm.adaptive.recompilation.BulkCompile.compileAllMethods()</span>
during execution, and b) by using the <span
class="cmtt-10">-X:aos:enable</span><span
class="cmtt-10">_precompile=true </span>ﬂag at the
command line to trigger bulk compilation at boot time. A standard methodology is
to use a benchmark harness call back mechanism to call <span
class="cmtt-10">compileAllMethods()</span>
at the end of the ﬁrst iteration of the benchmark. At the time of writing
this gave performance roughly 2% faster than the 10th iteration of regular
adaptive compilation. Because precompilation occurs early, the compiler
has less information about the classes, and in consequence the performance
of precompilation is about 9% slower than the 10th iteration of adaptive
compilation.
</p><!--l. 59--><p class="noindent" >For <span
class="cmbx-10">’warmup’ replay </span>(where <span
class="cmtt-10">org.jikesrvm.adaptive.recompilation.BulkCompile.compileAllMethods()</span>
is called at the end of the ﬁrst iteration):
</p>
<!--l. 61-->
<div class="lstlisting" id="listing-44"><span class="label"><a
 id="x8-68001r1"></a></span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">initial_compiler</span><span
class="cmtt-10">=</span><span
class="cmtt-10">base</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">enable_bulk_compile</span><span
class="cmtt-10">=</span><span
class="cmtt-10">true</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">enable_recompilation</span><span
class="cmtt-10">=</span><span
class="cmtt-10">false</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">cafi</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ca</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">vm</span><span
class="cmtt-10">:</span><span
class="cmtt-10">edgeCounterFile</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ec</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">dcfi</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">dc</span>
</div>
<!--l. 65--><p class="noindent" >For <span
class="cmbx-10">precompile replay </span>(where bulk compilation occurs at boot time):
</p>
<!--l. 67-->
<div class="lstlisting" id="listing-45"><span class="label"><a
 id="x8-68002r1"></a></span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">initial_compiler</span><span
class="cmtt-10">=</span><span
class="cmtt-10">base</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">enable_precompile</span><span
class="cmtt-10">=</span><span
class="cmtt-10">true</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">enable_recompilation</span><span
class="cmtt-10">=</span><span
class="cmtt-10">false</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">cafi</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ca</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">vm</span><span
class="cmtt-10">:</span><span
class="cmtt-10">edgeCounterFile</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">ec</span><span
class="cmtt-10"> </span><span
class="cmtt-10">-</span><span
class="cmtt-10">X</span><span
class="cmtt-10">:</span><span
class="cmtt-10">aos</span><span
class="cmtt-10">:</span><span
class="cmtt-10">dcfi</span><span
class="cmtt-10">=</span><span
class="cmtt-10">benchmark</span><span
class="cmtt-10">.</span><span
class="cmtt-10">dc</span>
</div>


<!--l. 73--><p class="noindent" >
</p>
<h4 class="subsectionHead"><span class="titlemark">6.2.3   </span> <a
 id="x8-690006.2.3"></a>Verbosity</h4>
<!--l. 75--><p class="noindent" >You can alter the verbosity of the replay behavior with the ﬂag
<span
class="cmtt-10">-X:aos:bulk</span><span
class="cmtt-10">_compilation</span><span
class="cmtt-10">_verbosity</span>, which by default (0) is silent, but
will produce more information about the recompilation with values of 1 or
2.
</p><!--l. 81--><p class="noindent" >
</p>
<h3 class="sectionHead"><span class="titlemark">6.3   </span> <a
 id="x8-700006.3"></a>Measuring GC performance</h3>
<!--l. 83--><p class="noindent" >MMTk includes a statistics subsystem and a harness mechanism for measuring its
performance. If you are using the DaCapo benchmarks, the MMTk harness
can be invoked using the ’-c MMTkCallback’ command line option, but for
other benchmarks you will need to invoke the harness by calling the static
methods
</p>
<!--l. 85-->
<div class="lstlisting" id="listing-46"><span class="label"><a
 id="x8-70001r1"></a></span><span
class="cmtt-10">org</span><span
class="cmtt-10">.</span><span
class="cmtt-10">mmtk</span><span
class="cmtt-10">.</span><span
class="cmtt-10">plan</span><span
class="cmtt-10">.</span><span
class="cmtt-10">Plan</span><span
class="cmtt-10">.</span><span
class="cmtt-10">harnessBegin</span><span
class="cmtt-10">()</span><span
class="cmtt-10"> </span><br /><span class="label"><a
 id="x8-70002r2"></a></span><span
class="cmtt-10">org</span><span
class="cmtt-10">.</span><span
class="cmtt-10">mmtk</span><span
class="cmtt-10">.</span><span
class="cmtt-10">plan</span><span
class="cmtt-10">.</span><span
class="cmtt-10">Plan</span><span
class="cmtt-10">.</span><span
class="cmtt-10">harnessEnd</span><span
class="cmtt-10">()</span>
</div>
<!--l. 90--><p class="noindent" >at the appropriate places. Other command line switches that aﬀect the collection of
statistics are
</p>
<div class="table">


<!--l. 92--><p class="noindent" ></p><hr class="float" /><div class="float"
>


<div class="tabular"> <table id="TBL-8" class="tabular"

><colgroup id="TBL-8-1g"><col
id="TBL-8-1" /><col
id="TBL-8-2" /></colgroup><tr
 style="vertical-align:baseline;" id="TBL-8-1-"><td  style="white-space:normal; text-align:left;" id="TBL-8-1-1"
class="td11"><!--l. 95--><p class="noindent" >Option                                </p></td><td  style="white-space:normal; text-align:left;" id="TBL-8-1-2"
class="td11"><!--l. 95--><p class="noindent" >Description                                          </p></td>
</tr><tr
 style="vertical-align:baseline;" id="TBL-8-2-"><td  style="white-space:normal; text-align:left;" id="TBL-8-2-1"
class="td11"><!--l. 96--><p class="noindent" >-X:gc:printPhaseStats=true      </p></td><td  style="white-space:normal; text-align:left;" id="TBL-8-2-2"
class="td11"><!--l. 96--><p class="noindent" >Print statistics for each mutator/gc phase
during the run                                      </p></td>
</tr><tr
 style="vertical-align:baseline;" id="TBL-8-3-"><td  style="white-space:normal; text-align:left;" id="TBL-8-3-1"
class="td11"><!--l. 97--><p class="noindent" >-X:gc:xmlStats=true               </p></td><td  style="white-space:normal; text-align:left;" id="TBL-8-3-2"
class="td11"><!--l. 97--><p class="noindent" >Print  statistics  in  an  XML  format  (as
opposed to human-readable format)          </p></td>
</tr><tr
 style="vertical-align:baseline;" id="TBL-8-4-"><td  style="white-space:normal; text-align:left;" id="TBL-8-4-1"
class="td11"><!--l. 98--><p class="noindent" >-X:gc:verbose                         </p></td><td  style="white-space:normal; text-align:left;" id="TBL-8-4-2"
class="td11"><!--l. 98--><p class="noindent" >This is incompatible with MMTk’s statistics
system.                                               </p></td>
</tr><tr
 style="vertical-align:baseline;" id="TBL-8-5-"><td  style="white-space:normal; text-align:left;" id="TBL-8-5-1"
class="td11"><!--l. 99--><p class="noindent" >-X:gc:variableSizeHeap=false    </p></td><td  style="white-space:normal; text-align:left;" id="TBL-8-5-2"
class="td11"><!--l. 99--><p class="noindent" >Disable dynamic resizing of the heap         </p></td>
</tr><tr
 style="vertical-align:baseline;" id="TBL-8-6-"><td  style="white-space:normal; text-align:left;" id="TBL-8-6-1"
class="td11">                           </td></tr></table></div>


</div><hr class="endfloat" />
</div>
<!--l. 104--><p class="noindent" >Unless you are speciﬁcally researching ﬂexible heap sizes, it is best to run
benchmarks in a ﬁxed size heap, using a range of heap sizes to produce a curve that
reﬂects the space-time tradeoﬀ. Using replay compilation and measuring the
second iteration of a benchmark is a good way to produce results with low
noise.
</p><!--l. 106--><p class="noindent" >There is an active debate among memory management and VM researchers
about how best to measure performance, and this section is not meant to
dictate or advocate any particular position, simply to describe one particular
methodology.
</p>
<h3 class="sectionHead"><span class="titlemark">6.4   </span> <a
 id="x8-710006.4"></a>Jikes RVM is really slow! What am I doing wrong?</h3>
<!--l. 113--><p class="noindent" >Perhaps you are not seeing stellar Jikes<sup class="textsuperscript"><span
class="cmr-9">TM</span></sup> RVM performance. If Jikes RVM as
described above is not competitive product JVMs, we recommend you test your
installation with the DaCapo benchmarks. We expect Jikes RVM performance to be
very close to Sun’s HotSpot 1.5 server running the DaCapo benchmarks. Of course,
running DaCapo well does not guarantee that Jikes RVM runs all codes
well.
</p><!--l. 115--><p class="noindent" >Some kinds of code will not run fast on Jikes RVM. Known issues include:
     </p><ol  class="enumerate1" >
     <li
  class="enumerate" id="x8-71002x1">Jikes RVM start-up may be slow compared to the some product JVMs.
     </li>
     <li
  class="enumerate" id="x8-71004x2">Remember                                                                            that
     the non-adaptive conﬁgurations (<span
class="cmtt-10">-X:aos:enable</span><span
class="cmtt-10">_recompilation=false</span>
     <span
class="cmtt-10">-X:aos:initial</span><span
class="cmtt-10">_compiler=opt</span>)  opt-compile  <span
class="cmti-10">every  </span>method  the  ﬁrst
     time  it  executes.  With  aggressive  optimization  levels,  opt-compiling
     will severely slow down the ﬁrst execution of each method. For many
     benchmarks,  it  is  possible  to  test  the  quality  of  generated  code  by
     either running for several iterations and ignoring the ﬁrst, or by building
     a  warm-up  period  into  the  code.  The  SPEC  benchmarks  already  use
     these strategies. The adaptive conﬁguration does not have this problem;
     however, we cannot stipulate that the adaptive system will compete with
     the product on short-running codes of a few seconds.
     </li>
     <li
  class="enumerate" id="x8-71006x3">Performance on tight loops may suﬀer. The Jikes RVM mechanism for safe
     points (thread preemption for garbage collection, on-stack-replacement,
     proﬁling, etc) relies on the insertion of a yield test on every back edge.
     This will hurt tight loops, including many simple microbenchmarks. We
     should someday alleviate this problem by strip-mining and hoisting the
     yield point out of hot loops, or implementing a safe point mechanism that
     does not require an explicit check.
     </li>
     <li
  class="enumerate" id="x8-71008x4">The load balancing in the system is naive and unfair. This can hurt some
     styles of codes, including bulk-synchronous parallel programs.</li></ol>


<!--l. 123--><p class="noindent" >The Jikes RVM developers wish to ensure that Jikes RVM delivers competitive
performance. If you can isolate reproducible performance problems, please let us
know.
</p><!--l. 127--><p class="noindent" >
</p>
<h3 class="sectionHead"><span class="titlemark">6.5   </span> <a
 id="x8-720006.5"></a>Stability of Jikes RVM</h3>
<!--l. 129--><p class="noindent" >Jikes RVM is not as stable as commercial JVMs such as HotSpot or J9.
Design your evaluation systems (e.g. scripts) so that they can deal with
crashes and deadlocks/livelocks. The latter can be dealt with by running Jikes
RVM with a timelimit. For example, if you are using Linux and shell scripts,
you can use the <a
href="http://devel.ringlet.net/sysutils/timelimit/" >timelimit</a> program to terminate the Jikes RVM after a set
time.


</p>
<!--l. 2--><div class="crosslinks"><p class="noindent"></p></div>
<!--l. 2--><p class="noindent" ><a
 id="tailExperimentalGuidelines.html"></a></p>
</body></html>