com.aparapi.internal.model

Class MethodModel

java.lang.Object

com.aparapi.internal.model.MethodModel

public class MethodModel
extends Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	MethodModel.FakeLocalVariableTableEntry

Method Summary

Modifier and Type	Method and Description
void	buildBranchGraphs(Map<Integer,Instruction> pcMap) Here we connect the branch nodes to the instruction that they branch to.
void	checkForRecursion(Set<MethodModel> transitiveCalledMethods)
Map<Integer,Instruction>	createListOfInstructions() Create a linked list of instructions (from pcHead to pcTail).
void	deoptimizeReverseBranches() Javac optimizes some branches to avoid goto->goto, branch->goto etc.
ClassModel.ConstantPool.FieldEntry	getAccessorVariableFieldEntry()
Set<MethodModel>	getCalledMethods()
ClassModel.ConstantPool	getConstantPool()
Instruction	getExprHead()
ClassModel.LocalVariableInfo	getLocalVariable(int _pc, int _index)
ClassModel.LocalVariableTableEntry<ClassModel.LocalVariableInfo>	getLocalVariableTableEntry()
ClassModel.ClassModelMethod	getMethod()
List<InstructionSet.MethodCall>	getMethodCalls()
String	getName()
Instruction	getPCHead()
String	getReturnType()
String	getSimpleName()
boolean	isGetter()
boolean	isNoCL()
boolean	isPrivateMemoryGetter()
boolean	isSetter()
boolean	methodUsesPutfield()
boolean	requiresByteAddressableStorePragma()
boolean	requiresDoublePragma()
void	setRequiredPragmas(Instruction instruction) Look at each instruction for use of long/double or byte writes which require pragmas to be used in the OpenCL source
String	toString()
void	txFormDups(ExpressionList _expressionList, Instruction _instruction) DUP family of instructions break our stack unwind model (whereby we treat instructions like the oeprands they create/consume).

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Method Detail

isGetter

public boolean isGetter()

isSetter

public boolean isSetter()

methodUsesPutfield

public boolean methodUsesPutfield()

isNoCL

public boolean isNoCL()

isPrivateMemoryGetter

public boolean isPrivateMemoryGetter()

getMethod

public ClassModel.ClassModelMethod getMethod()

getAccessorVariableFieldEntry

public ClassModel.ConstantPool.FieldEntry getAccessorVariableFieldEntry()

getCalledMethods

public Set<MethodModel> getCalledMethods()

checkForRecursion

public void checkForRecursion(Set<MethodModel> transitiveCalledMethods)
                       throws AparapiException

Throws:

AparapiException

setRequiredPragmas

public void setRequiredPragmas(Instruction instruction)

Look at each instruction for use of long/double or byte writes which require pragmas to be used in the OpenCL source

requiresDoublePragma

public boolean requiresDoublePragma()

requiresByteAddressableStorePragma

public boolean requiresByteAddressableStorePragma()

createListOfInstructions

public Map<Integer,Instruction> createListOfInstructions()
                                                  throws ClassParseException

Create a linked list of instructions (from pcHead to pcTail). Returns a map of int (pc) to Instruction which to allow us to quickly get from a bytecode offset to the appropriate instruction. Note that not all int values from 0 to code.length values will map to a valid instruction, if pcMap.get(n) == null then this implies that 'n' is not the start of an instruction So either pcMap.get(i)== null or pcMap.get(i).getThisPC()==i

Returns:

Map the returned pc to Instruction map

Throws:

ClassParseException

buildBranchGraphs

public void buildBranchGraphs(Map<Integer,Instruction> pcMap)

Here we connect the branch nodes to the instruction that they branch to.

Each branch node contains a 'target' field indended to reference the node that the branch targets. Each instruction also contain four seperate lists of branch nodes that reference it. These lists hold forwardConditional, forwardUnconditional, reverseConditional and revereseUnconditional branches that reference it.

So assuming that we had a branch node at pc offset 100 which represented 'goto 200'.

Following this call the branch node at pc offset 100 will have a 'target' field which actually references the instruction at pc offset 200, and the instruction at pc offset 200 will have the branch node (at 100) added to it's forwardUnconditional list.

See Also:

InstructionSet.Branch#getTarget()

deoptimizeReverseBranches

public void deoptimizeReverseBranches()

Javac optimizes some branches to avoid goto->goto, branch->goto etc. This method specifically deals with reverse branches which are the result of such optimisations.

txFormDups

public void txFormDups(ExpressionList _expressionList,
                       Instruction _instruction)
                throws ClassParseException

DUP family of instructions break our stack unwind model (whereby we treat instructions like the oeprands they create/consume).

Here we replace DUP style instructions with a 'mock' instruction which 'clones' the effect of the instruction. This would be invalid to execute but is useful to replace the DUP with a 'pattern' which it simulates. This allows us to later apply transforms to represent the original code.

An example might be the bytecode for the following sequence.

    results[10]++; 
         return
 

Which results in the following bytecode

      0:   aload_0       // reference through 'this' to get 
      1:   getfield      // field 'results' which is an array of int
      4:   bipush  10    // push the array index
      6:   dup2          // dreaded dup2 we'll come back here
      7:   iaload        // ignore for the moment.
      8:   iconst_1
      9:   iadd
      10:  iastore
      11:  return
 

First we need to know what the stack will look like before the dup2 is encountered. Using our folding technique we represent the first two instructions inside ()

           getfield (aload_0     // result in the array field reference on stack
           bipush  10            // the array index
           dup2                  // dreaded dup2 we'll come back here
 

The dup2 essentially copies the top two elements on the stack. So we emulate this by replacing the dup2 with clones of the instructions which would reinstate the same stack state.

So after the dup2 transform we end up with:-

          getfield (aload_0)     // result in the array field reference on stack
          bipush  10             // the array index
          {getfield (aload_0)}   // result in the array field reference on stack
          {bipush 10}            // the array index
 

So carrying on lets look at the iaload which consumes two operands (the index and the array field reference) and creates one (the result of an array access)

          getfield (aload_0)     // result in the array field reference on stack
          bipush  10             // the array index
          {getfield (aload_0)}   // result in the array field reference on stack
          {bipush  10}           // the array index
          iaload 
 

So we now have

          getfield (aload_0)                        // result in the array field reference on stack
          bipush  10                                // the array index
          iaload ({getfield(aload_0), {bipush 10})  // results in the array element on the stack
          iconst
          iadd
 

And if you are following along the iadd will fold the previous two stack entries essentially pushing the result of results[10]+1 on the stack.

          getfield (aload_0)                                        // result in the array field reference on stack
          bipush  10                                                // the array index
          iadd (iaload ({getfield(aload_0), {bipush 10}, iconst_1)  // push of results[10]+1 
 

Then the final istore instruction which consumes 3 stack operands (the field array reference, the index and the value to assign).

Which results in

 
          istore (getfield (aload_0), bipush 10,  iadd (iaload ({getfield(aload_0), {bipush 10}, iconst_1)) // results[10] = results[10+1]
 

Where results[10] = results[10+1] is the long-hand form of the results[10]++ and will be transformed by one of the 'inc' transforms to the more familiar form a little later.

Parameters:

_expressionList -

_instruction -

Throws:

ClassParseException

getLocalVariableTableEntry

public ClassModel.LocalVariableTableEntry<ClassModel.LocalVariableInfo> getLocalVariableTableEntry()

getConstantPool

public ClassModel.ConstantPool getConstantPool()

getLocalVariable

public ClassModel.LocalVariableInfo getLocalVariable(int _pc,
                                                     int _index)

getSimpleName

public String getSimpleName()

getName

public String getName()

getReturnType

public String getReturnType()

getMethodCalls

public List<InstructionSet.MethodCall> getMethodCalls()

getPCHead

public Instruction getPCHead()

getExprHead

public Instruction getExprHead()

toString

public String toString()

Overrides:

toString in class Object