For example, to run class
foo with source code in file
% javac foo.java % rvm foo
The general syntax is
rvm [rvm options...] class [args...]
You may choose from a myriad of options for the
rvm command-line. Options fall into two categories: standard and non-standard. Non-standard options are preceded by "
Static inlining heuristic: Upper bound on callee size
Static inlining heuristic: Upper bound on depth of inlining
Static inlining heuristic: Always inline callees of this size or smaller
Static inlining heuristic: If root method is already this big, then only inline trivial methods
Adaptive inlining heuristic: Upper bound on callee size
Adaptive inlining heuristc: Minimum fraction of callsite distribution for guarded inlining of a callee
Input file of edge counter profile data
Selection of guard mechanism for inlined virtual calls that cannot be statically bound
Selection of strictness level for floating point computations
Exclude methods from being opt compiled
Unroll loops. Duplicates the loop body 2^n times.
How many extra instructions will we insert in order to remove a conditional branch?
How many rounds of redundant load elimination will we attempt?
Read allocation advice attributes for all classes from this file
How to compute block and edge frequencies?
Selection of spilling heuristic
Cumulative threshold which defines the set of infrequent basic blocks
Threshold at which a conditional branch is considered to be skewed
Only print IR compiled above this level
Should the adaptive system recompile hot methods?
Do we need to generate advice file?
Should the adaptive system precompile all methods given in the advice file before the user thread is started?
Should the adaptive system use the pseudo-adaptive system that solely relies on the advice file?
Should profile data be gathered and reported at the end of the run?
Should we use adaptive feedback-directed inlining?
Should AOS exit when the controller clock reaches early_exit_value?
Should AOS promote baseline-compiled methods to opt?
Should recompilation be done on a background thread or on next invocation?
Insert instrumentation in opt recompiled code to count yieldpoints executed?
Insert intrusive method counters in opt recompiled code?
Insert counters on all instructions in opt recompiled code?
Enable easy insertion of (debugging) counters in opt recompiled code.
Report stats related to timer interrupts and AOS listeners on exit.
Disable the ability for an app to request all methods to be recompiled.
How many timer ticks of method samples to take before reporting method hotness to controller.
Selection of initial compiler.
Selection of mechanism for identifying methods for optimizing recompilation.
What triggers us to take a method sample?
What triggers us to take a method sample?
Name of log file.
Name of advice file.
Name of dynamic call graph file.
Name of compiler DNA file (no name ==> use default DNA). Discussed in a comment at the head of VM_CompilerDNA.java.
File containing information about the methods to Opt compile.
File containing information about the hot call sites.
Control amount of event logging (larger ==> more).
Control amount of info reported on exit (larger ==> more).
After how many clock ticks should we decay.
What factor should we decay call graph edges hotness by.
After how many timer interrupts do we update the weights in the dynamic call graph?
Initial edge weight of call graph is set to ai_seed_multiplier * (1/ai_control_point).
Name of offline inline plan to be read and used for inlining.
Value of controller clock at which AOS should exit if early_exit is true.
Invocation count at which a baseline compiled method should be recompiled.
Opt level for recompilation in invocation count based system.
What is the sample interval for counter-based sampling.
What percentage of the total weight of the dcg demarcates warm/hot edges.
The maximum optimization level to enable.
Virtual Machine Non-Standard Command-Line Options
Time all compilations and report on exit.
Time all compilation sub-phases and report on exit.
Stack traces to consist of VM and application frames.
Dump a stack trace (via VM.syswrite) upon exit.
More detailed tracing then -verbose:class.
Exit when non-fatal errors are detected; used for regression testing.
If we get deeper than this in one of the System Trouble functions, try to die.
Timer interrupt scheduling quantum in ms.
Scheduling quantum = interruptQuantum * schedulingMultiplier.
Trace actions taken by thread scheduling.
Trace every nth time a stack trace is created.
Input file of edge counter profile data.
How many CBS call samples (Prologue/Epilogue) should we take per time tick.
Stride between each CBS call sample (Prologue/Epilogue) within a sampling window.
How many CBS method samples (any yieldpoint) should we take per time tick.
Stride between each CBS method sample (any yieldpoint) within a sampling window.
Count, and report, the number of thread state transitions. This works better on IA32 than on PPC at the moment.
Force all threads to run on one CPU. The argument specifies which CPU (starting from 0).
Running Jikes RVM with valgrind
To run a Jikes RVM build with valgrind, use the
-wrap flag to invoke valgrind, eg
rvm -wrap "path/to/valgrind --smc-check=all <valgrind-options>" <jikesrvm-options> ...
this will insert the invocation of valgrind at the appropriate place for it to operate on Jikes RVM proper rather than a wrapper script.