Package org.jruby.ir

Class IRManager

java.lang.Object

org.jruby.ir.IRManager

public class IRManager
extends Object

Field Summary

Fields

Modifier and Type	Field	Description
private static final int	CLOSURE_PREFIX_CACHE_SIZE
private final String[]	closurePrefixCache
private final List<CompilerPass>	compilerPasses
private final RubyInstanceConfig	config
private final CompilerPass	deadCodeEliminationPass
static final String	DEFAULT_BUILD_PASSES
static final String	DEFAULT_INLINING_COMPILER_PASSES
static final String	DEFAULT_JIT_PASSES
private final CompilerPassListener	defaultListener
private int	dummyMetaClassCount
private final Boolean	fals
private static final int	FIXNUM_CACHE_HALF_SIZE
private final Fixnum[]	fixnums
private final List<CompilerPass>	inliningCompilerPasses
private InstructionsListener	instrsListener
static final boolean	IR_INLINER
static final int	IR_INLINER_THRESHOLD
static final boolean	IR_INLINER_VERBOSE
private IRScopeListener	irScopeListener
private final List<CompilerPass>	jitPasses
private LineNumberInstr[]	lineNumbers
final ToggleBacktraceInstr	needsBacktrace
final ToggleBacktraceInstr	needsNoBacktrace
private final Nil	nil
private final IRModuleBody	object
private static final ByteList	OBJECT
private final CompilerPass	optimizeDelegationPass
private final CompilerPass	optimizeDynScopesPass
private final Set<CompilerPassListener>	passListeners
private final ReceiveSelfInstr	receiveSelfInstr
final Ruby	runtime
static final String	SAFE_COMPILER_PASSES
private final List<CompilerPass>	safePasses
private final StandardError	standardError
private TemporaryLocalVariable[]	temporaryLocalVariables
private final Boolean	tru

Constructor Summary

Constructors

Constructor	Description
IRManager(Ruby runtime, RubyInstanceConfig config)

Method Summary

Modifier and Type	Method	Description
void	addListener(InstructionsListener listener)
void	addListener(IRScopeListener listener)
void	addListener(CompilerPassListener listener)
String	getClosurePrefix(int closureId)
List<CompilerPass>	getCompilerPasses(IRScope scope)
Boolean	getFalse()
List<CompilerPass>	getInliningCompilerPasses(IRScope scope)
RubyInstanceConfig	getInstanceConfig()
InstructionsListener	getInstructionsListener()
IRScopeListener	getIRScopeListener()
List<CompilerPass>	getJITPasses(IRScope scope)
Set<CompilerPassListener>	getListeners()
RubySymbol	getMetaClassName()
Nil	getNil()
IRModuleBody	getObject()
ReceiveSelfInstr	getReceiveSelfInstr()
Ruby	getRuntime()
List<CompilerPass>	getSafePasses(IRScope scope)
StandardError	getStandardError()
Boolean	getTrue()
protected LineNumberInstr[]	growLineNumbersPool(int index)
protected TemporaryLocalVariable[]	growTemporaryVariablePool(int index)
IRMethod	loadInternalMethod(ThreadContext context, IRubyObject self, String method)
ToggleBacktraceInstr	needsBacktrace(boolean needsIt)
Fixnum	newFixnum(long value)
LineNumberInstr	newLineNumber(int line)
TemporaryLocalVariable	newTemporaryLocalVariable(int index)	Temporary local variables are immutable and always start from a low index value and increment up to a higher index value per scope.
protected void	optimizeIfSimpleScope(FullInterpreterContext fic)	For scopes that don't require a dynamic scope we can run DCE and some other passes which cannot be stymied by escaped bindings.
private Node	parse(ThreadContext context, FileResource file, String fileName)
void	removeListener(InstructionsListener listener)
void	removeListener(IRScopeListener listener)
void	removeListener(CompilerPassListener listener)
CompilerPassScheduler	schedulePasses()
static CompilerPassScheduler	schedulePasses(List<CompilerPass> passes)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details

SAFE_COMPILER_PASSES

public static final String SAFE_COMPILER_PASSES

See Also:

• Constant Field Values

DEFAULT_BUILD_PASSES

public static final String DEFAULT_BUILD_PASSES

See Also:

• Constant Field Values

DEFAULT_JIT_PASSES

public static final String DEFAULT_JIT_PASSES

See Also:

• Constant Field Values

DEFAULT_INLINING_COMPILER_PASSES

public static final String DEFAULT_INLINING_COMPILER_PASSES

See Also:

• Constant Field Values

IR_INLINER

public static final boolean IR_INLINER

IR_INLINER_THRESHOLD

public static final int IR_INLINER_THRESHOLD

IR_INLINER_VERBOSE

public static final boolean IR_INLINER_VERBOSE

deadCodeEliminationPass

private final CompilerPass deadCodeEliminationPass

optimizeDynScopesPass

private final CompilerPass optimizeDynScopesPass

optimizeDelegationPass

private final CompilerPass optimizeDelegationPass

OBJECT

private static final ByteList OBJECT

dummyMetaClassCount

private int dummyMetaClassCount

object

private final IRModuleBody object

nil

private final Nil nil

tru

private final Boolean tru

fals

private final Boolean fals

standardError

private final StandardError standardError

needsBacktrace

public final ToggleBacktraceInstr needsBacktrace

needsNoBacktrace

public final ToggleBacktraceInstr needsNoBacktrace

passListeners

private final Set<CompilerPassListener> passListeners

defaultListener

private final CompilerPassListener defaultListener

instrsListener

private InstructionsListener instrsListener

irScopeListener

private IRScopeListener irScopeListener

compilerPasses

private final List<CompilerPass> compilerPasses

inliningCompilerPasses

private final List<CompilerPass> inliningCompilerPasses

jitPasses

private final List<CompilerPass> jitPasses

safePasses

private final List<CompilerPass> safePasses

config

private final RubyInstanceConfig config

runtime

public final Ruby runtime

CLOSURE_PREFIX_CACHE_SIZE

private static final int CLOSURE_PREFIX_CACHE_SIZE

See Also:

• Constant Field Values

closurePrefixCache

private final String[] closurePrefixCache

FIXNUM_CACHE_HALF_SIZE

private static final int FIXNUM_CACHE_HALF_SIZE

See Also:

• Constant Field Values

fixnums

private final Fixnum[] fixnums

receiveSelfInstr

private final ReceiveSelfInstr receiveSelfInstr

lineNumbers

private LineNumberInstr[] lineNumbers

temporaryLocalVariables

private TemporaryLocalVariable[] temporaryLocalVariables

Constructor Details

IRManager

public IRManager(Ruby runtime,
 RubyInstanceConfig config)

Method Details

getRuntime

public Ruby getRuntime()

getNil

public Nil getNil()

getStandardError

public StandardError getStandardError()

getTrue

public Boolean getTrue()

getFalse

public Boolean getFalse()

getObject

public IRModuleBody getObject()

needsBacktrace

public ToggleBacktraceInstr needsBacktrace(boolean needsIt)

schedulePasses

public CompilerPassScheduler schedulePasses()

schedulePasses

public static CompilerPassScheduler schedulePasses(List<CompilerPass> passes)

getCompilerPasses

public List<CompilerPass> getCompilerPasses(IRScope scope)

getInliningCompilerPasses

public List<CompilerPass> getInliningCompilerPasses(IRScope scope)

getJITPasses

public List<CompilerPass> getJITPasses(IRScope scope)

getSafePasses

public List<CompilerPass> getSafePasses(IRScope scope)

getListeners

public Set<CompilerPassListener> getListeners()

getInstructionsListener

public InstructionsListener getInstructionsListener()

getIRScopeListener

public IRScopeListener getIRScopeListener()

addListener

public void addListener(CompilerPassListener listener)

removeListener

public void removeListener(CompilerPassListener listener)

addListener

public void addListener(InstructionsListener listener)

removeListener

public void removeListener(InstructionsListener listener)

addListener

public void addListener(IRScopeListener listener)

getClosurePrefix

public String getClosurePrefix(int closureId)

newFixnum

public Fixnum newFixnum(long value)

newLineNumber

public LineNumberInstr newLineNumber(int line)

getReceiveSelfInstr

public ReceiveSelfInstr getReceiveSelfInstr()

growLineNumbersPool

protected LineNumberInstr[] growLineNumbersPool(int index)

removeListener

public void removeListener(IRScopeListener listener)

getMetaClassName

public RubySymbol getMetaClassName()

growTemporaryVariablePool

protected TemporaryLocalVariable[] growTemporaryVariablePool(int index)

newTemporaryLocalVariable

public TemporaryLocalVariable newTemporaryLocalVariable(int index)

Temporary local variables are immutable and always start from a low index value and increment up to a higher index value per scope. So we can share these and store the ones in a simple list. If hard pinning is ever an issue we can periodically evict the list and start over at the cost of more live objects but this list cache reduces a simple empty Rails app console from over 140K instances to about 1200 instances.

optimizeIfSimpleScope

protected void optimizeIfSimpleScope(FullInterpreterContext fic)

For scopes that don't require a dynamic scope we can run DCE and some other passes which cannot be stymied by escaped bindings.

getInstanceConfig

public RubyInstanceConfig getInstanceConfig()

loadInternalMethod

public IRMethod loadInternalMethod(ThreadContext context,
 IRubyObject self,
 String method)

parse

private Node parse(ThreadContext context,
 FileResource file,
 String fileName)
            throws IOException

Throws:

IOException