| /******************************************************************************* | |
| * Copyright (c) 2010 University of Illinois at Urbana-Champaign and others. | |
| * All rights reserved. This program and the accompanying materials | |
| * are made available under the terms of the Eclipse Public License v1.0 | |
| * which accompanies this distribution, and is available at | |
| * http://www.eclipse.org/legal/epl-v10.html | |
| * | |
| * Contributors: | |
| * UIUC - Initial API and implementation | |
| *******************************************************************************/ | |
| package org.eclipse.photran.internal.core.refactoring; | |
| import java.util.List; | |
| import org.eclipse.core.runtime.CoreException; | |
| import org.eclipse.core.runtime.IProgressMonitor; | |
| import org.eclipse.core.runtime.OperationCanceledException; | |
| import org.eclipse.ltk.core.refactoring.RefactoringStatus; | |
| import org.eclipse.photran.internal.core.analysis.binding.Definition; | |
| import org.eclipse.photran.internal.core.analysis.binding.ScopingNode; | |
| import org.eclipse.photran.internal.core.analysis.loops.ASTProperLoopConstructNode; | |
| import org.eclipse.photran.internal.core.analysis.loops.ASTVisitorWithLoops; | |
| import org.eclipse.photran.internal.core.analysis.loops.LoopReplacer; | |
| import org.eclipse.photran.internal.core.lexer.Terminal; | |
| import org.eclipse.photran.internal.core.lexer.Token; | |
| import org.eclipse.photran.internal.core.parser.ASTIntConstNode; | |
| import org.eclipse.photran.internal.core.parser.ASTVisitor; | |
| import org.eclipse.photran.internal.core.parser.IASTListNode; | |
| import org.eclipse.photran.internal.core.parser.IASTNode; | |
| import org.eclipse.photran.internal.core.parser.IExecutionPartConstruct; | |
| import org.eclipse.photran.internal.core.parser.IExpr; | |
| import org.eclipse.photran.internal.core.refactoring.infrastructure.FortranEditorRefactoring; | |
| import org.eclipse.photran.internal.core.reindenter.Reindenter; | |
| import org.eclipse.photran.internal.core.reindenter.Reindenter.Strategy; | |
| import org.eclipse.rephraserengine.core.refactorings.UserInputString; | |
| /** | |
| * Loop refactoring to take a nested loop and change the data accesses to a tiled form. | |
| * @author Ashley Kasza | |
| */ | |
| public class TileLoopRefactoring extends FortranEditorRefactoring | |
| { | |
| private ASTProperLoopConstructNode doLoop; | |
| private ASTProperLoopConstructNode secondDoLoop; | |
| private String newFirstIndexVar; | |
| private String newSecondIndexVar; | |
| private int tilingSize; | |
| private int tilingOffset; | |
| private boolean hasLoopDependency; | |
| @Override | |
| protected void doCheckInitialConditions(RefactoringStatus status, IProgressMonitor pm) | |
| throws PreconditionFailure | |
| { | |
| ensureProjectHasRefactoringEnabled(status); | |
| LoopReplacer.replaceAllLoopsIn(this.astOfFileInEditor.getRoot()); | |
| doLoop = getLoopNode(this.astOfFileInEditor, this.selectedRegionInEditor); | |
| // fail if no do loop was selected | |
| if (doLoop == null) | |
| { | |
| fail(Messages.ReverseLoopRefactoring_SelectDoLoop); | |
| } | |
| secondDoLoop = findSecondDoLoop(doLoop); | |
| if(secondDoLoop == null){ | |
| fail(Messages.ReverseLoopRefactoring_SelectDoLoop); | |
| } | |
| //check for nested loops. | |
| if(findNumberOfLoops() != 1){ | |
| fail(Messages.TileLoopRefactoring_SelectLoopWithOnlyOneNestedLoop); | |
| } | |
| newFirstIndexVar = findNewIndexVariableName(doLoop, doLoop.getIndexVariable().getText()); | |
| newSecondIndexVar = findNewIndexVariableName(secondDoLoop, secondDoLoop.getIndexVariable().getText()); | |
| if(newFirstIndexVar == null || newSecondIndexVar == null){ | |
| fail(Messages.TileLoopRefactoring_UnableToCreateNewIndex); | |
| } | |
| try{ | |
| if(doLoop.getStepInt() != 1 || secondDoLoop.getStepInt() != 1){ | |
| fail(Messages.TileLoopRefactoring_CantTileLoopsWithStep); | |
| } | |
| }catch(NumberFormatException e){ | |
| fail(Messages.TileLoopRefactoring_CantTileLoopsWithStep); | |
| } | |
| } | |
| private ASTProperLoopConstructNode findSecondDoLoop(ASTProperLoopConstructNode firstLoop){ | |
| IASTListNode<IExecutionPartConstruct> firstBody = firstLoop.getBody(); | |
| return firstBody.findFirst(ASTProperLoopConstructNode.class); | |
| } | |
| private String findNewIndexVariableName(ASTProperLoopConstructNode nodeInScope, String indexVar){ | |
| boolean canUse; | |
| String newIndexVar = indexVar; | |
| for (int i = 1; i <= 10; i++) | |
| { | |
| canUse = true; | |
| ScopingNode scope = ScopingNode.getLocalScope(nodeInScope); | |
| List<Definition> defList = scope.getAllDefinitions(); | |
| for (Definition d : defList) | |
| { | |
| if (d != null && d.getCanonicalizedName().equals(newIndexVar.toLowerCase())) | |
| { | |
| newIndexVar = indexVar + Integer.toString(i); | |
| canUse = false; | |
| } | |
| } | |
| if (canUse == true) | |
| { | |
| return newIndexVar; | |
| } | |
| } | |
| return null; | |
| } | |
| private int findNumberOfLoops(){ | |
| int loopCount = 0; | |
| IASTListNode<IExecutionPartConstruct> doLoopBody = doLoop.getBody(); | |
| for(int i = 0; i < doLoopBody.size(); i++){ | |
| if(doLoopBody.get(i) instanceof ASTProperLoopConstructNode){ | |
| loopCount++; | |
| } | |
| } | |
| return loopCount; | |
| } | |
| @Override | |
| protected void doCheckFinalConditions(RefactoringStatus status, IProgressMonitor pm) | |
| throws PreconditionFailure | |
| { | |
| // no final conditions | |
| if(tilingSize <= 0){ | |
| fail(Messages.TileLoopRefactoring_InvalidTileSize); | |
| } | |
| if(tilingOffset <0){ | |
| fail(Messages.TileLoopRefactoring_InvalidTilingOffset); | |
| } | |
| } | |
| @Override | |
| protected void doCreateChange(IProgressMonitor pm) throws CoreException, | |
| OperationCanceledException | |
| { | |
| ScopingNode scope = ScopingNode.getLocalScope(doLoop); | |
| hasLoopDependency = false; | |
| findIndexVariableInHeader(secondDoLoop.getLoopHeader(), doLoop.getIndexVariable().getText()); | |
| declareNewLoopVariables(scope); | |
| @SuppressWarnings("unused") | |
| ASTProperLoopConstructNode node = loopTilingTransformation(); | |
| //parseLiteralDoLoop(node.toString()); | |
| //scope = ScopingNode.getLocalScope(node); | |
| //Reindenter.reindent(loopTilingTransformation(), this.astOfFileInEditor, Strategy.REINDENT_EACH_LINE); | |
| Reindenter.reindent(scope.getBody(), this.astOfFileInEditor, Strategy.REINDENT_EACH_LINE); | |
| this.addChangeFromModifiedAST(this.fileInEditor, pm); | |
| vpg.releaseAST(this.fileInEditor); | |
| } | |
| private void findIndexVariableInHeader(IASTNode node, final String indexVariable){ | |
| node.accept(new ASTVisitorWithLoops() | |
| { | |
| @Override public void visitToken(Token token) | |
| { | |
| if(token.getTerminal() == Terminal.T_IDENT && (token.getText()).equalsIgnoreCase(indexVariable)){ | |
| hasLoopDependency = true; | |
| } | |
| } | |
| }); | |
| //hasLoopDependency = false; | |
| } | |
| @SuppressWarnings({ "unchecked", "rawtypes" }) | |
| private ASTProperLoopConstructNode loopTilingTransformation(){ | |
| ASTProperLoopConstructNode firstElementLoop = constructNewElementLoop(doLoop, newFirstIndexVar); //inner loop | |
| ASTProperLoopConstructNode firstTileLoop = createNewTileLoop(doLoop, newFirstIndexVar); | |
| ASTProperLoopConstructNode secondElementLoop = constructNewElementLoop(secondDoLoop, newSecondIndexVar); | |
| ASTProperLoopConstructNode secondTileLoop = createNewTileLoop(secondDoLoop, newSecondIndexVar); | |
| if(hasLoopDependency){ | |
| replaceBound(secondTileLoop.getLowerBoundIExpr(), doLoop.getLowerBoundIExpr().toString(), firstTileLoop.getIndexVariable().getText(), true); | |
| replaceBound(secondTileLoop.getUpperBoundIExpr(), doLoop.getUpperBoundIExpr().toString(), firstTileLoop.getIndexVariable().getText(), false); | |
| } | |
| IASTListNode body; | |
| body = secondElementLoop.getBody(); | |
| body.add(secondDoLoop.getBody()); | |
| body = firstElementLoop.getBody(); | |
| body.add(secondElementLoop); | |
| body = secondTileLoop.getBody(); | |
| body.add(firstElementLoop); | |
| body = firstTileLoop.getBody(); | |
| body.add(secondTileLoop); | |
| doLoop.replaceWith(firstTileLoop); | |
| return firstTileLoop; | |
| } | |
| private void replaceBound(IExpr expr, String replace1, String replace2, boolean isLb){ | |
| if(!(expr instanceof ASTIntConstNode)) | |
| { | |
| IExpr dummyBound = (IExpr)(expr.clone()); | |
| IExpr dummyBound2 = (IExpr)(expr.clone()); | |
| replaceFirstLoopIndexVariable(dummyBound, doLoop.getIndexVariable().getText(), replace1); | |
| replaceFirstLoopIndexVariable(dummyBound2, doLoop.getIndexVariable().getText(), replace2); | |
| if(!(dummyBound.toString().equals(dummyBound2.toString()))){ | |
| String replacementBound; | |
| if(isLb == true) | |
| replacementBound = String.format("max(%s,%s)", dummyBound.toString(), dummyBound2.toString()); //$NON-NLS-1$ | |
| else | |
| replacementBound = String.format("min(%s,%s)", dummyBound.toString(), dummyBound2.toString()); //$NON-NLS-1$ | |
| expr.replaceWith(replacementBound); | |
| } | |
| } | |
| } | |
| private void replaceFirstLoopIndexVariable(IASTNode node, final String indexVar, final String replacement) | |
| { | |
| node.accept(new ASTVisitor() | |
| { | |
| @Override public void visitToken(Token token) | |
| { | |
| if(token.getTerminal() == Terminal.T_IDENT && token.getText().equalsIgnoreCase(indexVar)){ | |
| token.replaceWith(replacement); | |
| } | |
| } | |
| }); | |
| } | |
| @SuppressWarnings("unchecked") | |
| private void declareNewLoopVariables(ScopingNode scope){ | |
| //ScopingNode scope = ScopingNode.getLocalScope(doLoop); | |
| IASTListNode<IASTNode> scopeBody = (IASTListNode<IASTNode>)scope.getOrCreateBody(); | |
| String declarationString = "integer :: " + newFirstIndexVar + ", " + newSecondIndexVar; //$NON-NLS-1$ //$NON-NLS-2$ | |
| int insertionIndex = findIndexToInsertTypeDeclaration(scopeBody); | |
| scopeBody.add(insertionIndex, parseLiteralStatement(declarationString)); | |
| } | |
| private ASTProperLoopConstructNode createNewTileLoop(ASTProperLoopConstructNode inputLoop, String newIndexVar){ | |
| String newLb = getNewBoundsString(inputLoop.getLowerBoundIExpr()); | |
| String newUb = getNewBoundsString(inputLoop.getUpperBoundIExpr()); | |
| String loopHeader = String.format("do %s=%s,%s,%s\nend do\n", newIndexVar, //$NON-NLS-1$ | |
| newLb, newUb,tilingSize); | |
| return parseLiteralDoLoop(loopHeader); | |
| } | |
| private String getNewBoundsString(IExpr expr){ | |
| if(expr instanceof ASTIntConstNode){ | |
| int loopBoundInt = Integer.parseInt(expr.toString()); | |
| int newBound = (int)Math.floor((double)(loopBoundInt-tilingOffset)/tilingSize); | |
| newBound = (newBound * tilingSize)+tilingOffset; | |
| return Integer.toString(newBound); | |
| }else{ | |
| //interchangeWithIdentifier = true; | |
| return String.format("floor(real(%s-%s)/%s)*%s+%s",expr.toString(), Integer.toString(tilingOffset), Integer.toString(tilingSize), //$NON-NLS-1$ | |
| Integer.toString(tilingSize), Integer.toString(tilingOffset)); | |
| } | |
| } | |
| private ASTProperLoopConstructNode constructNewElementLoop(ASTProperLoopConstructNode inputLoop, String newIndexVar){ | |
| String elementLoopLb = String.format("max(%s,%s)", inputLoop.getLowerBoundIExpr().toString(), newIndexVar);//$NON-NLS-1$ | |
| String elementLoopUb = String.format("min(%s,%s+%s)", inputLoop.getUpperBoundIExpr().toString(), newIndexVar, (tilingSize-1));//$NON-NLS-1$ | |
| String elementLoopFull = String.format("do %s=%s,%s\n end do\n", inputLoop.getIndexVariable().getText(), elementLoopLb, elementLoopUb); //$NON-NLS-1$ | |
| ASTProperLoopConstructNode newNode = parseLiteralDoLoop(elementLoopFull); | |
| return newNode; | |
| } | |
| @UserInputString(label = "Enter tile size ", defaultValueMethod= "getSuggestedTilingSize") | |
| public void setLoopTilingStepNumber(String input) | |
| { | |
| tilingSize = Integer.parseInt(input); | |
| } | |
| public String getSuggestedTilingSize() | |
| { | |
| return "1"; //$NON-NLS-1$ | |
| } | |
| @UserInputString(label = "Enter tile offset ", defaultValueMethod = "getSuggestedTilingOffset") | |
| public void setLoopTilingOffsetNumber(String input) | |
| { | |
| tilingOffset = Integer.parseInt(input); | |
| } | |
| public String getSuggestedTilingOffset() | |
| { | |
| return "1"; //$NON-NLS-1$ | |
| } | |
| @Override | |
| public String getName() | |
| { | |
| return Messages.TileLoopRefactoring_LoopTilingName; | |
| } | |
| } |