| /********************************************************************** |
| * Copyright (c) 2007 IBM Corporation. |
| * 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: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| |
| package org.eclipse.ptp.pldt.mpi.analysis.analysis; |
| |
| import java.util.ArrayList; |
| import java.util.Enumeration; |
| import java.util.Hashtable; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Stack; |
| |
| import org.eclipse.cdt.core.dom.ast.ASTVisitor; |
| import org.eclipse.cdt.core.dom.ast.IASTArraySubscriptExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTBreakStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTCaseStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTCastExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTCompoundStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTConditionalExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTContinueStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTDeclaration; |
| import org.eclipse.cdt.core.dom.ast.IASTDeclarationStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTDeclarator; |
| import org.eclipse.cdt.core.dom.ast.IASTDefaultStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTDoStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTExpressionList; |
| import org.eclipse.cdt.core.dom.ast.IASTExpressionStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTFieldReference; |
| import org.eclipse.cdt.core.dom.ast.IASTForStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTFunctionCallExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition; |
| import org.eclipse.cdt.core.dom.ast.IASTGotoStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTIdExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTIfStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTInitializer; |
| import org.eclipse.cdt.core.dom.ast.IASTInitializerExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTInitializerList; |
| import org.eclipse.cdt.core.dom.ast.IASTLabelStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTLiteralExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTNode; |
| import org.eclipse.cdt.core.dom.ast.IASTNullStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTProblemStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTReturnStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTSimpleDeclaration; |
| import org.eclipse.cdt.core.dom.ast.IASTStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTSwitchStatement; |
| import org.eclipse.cdt.core.dom.ast.IASTTypeIdExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTUnaryExpression; |
| import org.eclipse.cdt.core.dom.ast.IASTWhileStatement; |
| import org.eclipse.cdt.internal.core.dom.parser.IASTAmbiguousExpression; |
| import org.eclipse.cdt.internal.core.dom.parser.IASTAmbiguousStatement; |
| import org.eclipse.ptp.pldt.mpi.analysis.analysis.BarrierExpression.BarrierExpressionOP; |
| import org.eclipse.ptp.pldt.mpi.analysis.cdt.graphs.ICallGraph; |
| import org.eclipse.ptp.pldt.mpi.analysis.cdt.graphs.ICallGraphNode; |
| |
| public class MPIBarrierExprModified extends ASTVisitor { |
| protected BarrierTable bTable_; |
| protected ICallGraph cg_; |
| /** One stack for each communicator */ |
| protected Hashtable<String,Stack<BarrierExpression>> stacks_; |
| private static final boolean traceOn=false; |
| |
| protected MPICallGraphNode currentNode_; |
| |
| /** |
| * switch statement may be nested |
| */ |
| protected int depth = 0; |
| |
| /** |
| * This field is used to recognize the associated case body. The idea is |
| * the case body should have the same parent with the "case" statement. |
| * One element in this stack is shared by all cases (and default) in one |
| * switch statement. This is possible because of the tree structure. |
| */ |
| protected Stack<IASTNode> caseParent = null; |
| |
| /** |
| * This field is used to record whether the current case has "break" |
| * statement. Same as above, one element is shared by all cases and default |
| * in a switch statement. |
| */ |
| protected Stack<Boolean> withBreak = null; |
| |
| /** |
| * Each bucket in this hashtable is a List, hashed by communicator. |
| * The List records the current barrier |
| * expression for each case statement in the current (nested)switch statement. |
| * So: Hashtable(for each communicator) --> |
| * Stack(for each nested switch statement) --> |
| * ArrayList(for each case body) --> |
| * Tuple(caseStatement, CaseBarrierExpr) |
| */ |
| protected Hashtable<String,Stack<List>> caseBE = null; |
| |
| public MPIBarrierExprModified(BarrierTable btable, ICallGraph cg){ |
| bTable_ = btable; |
| cg_ = cg; |
| } |
| |
| private void init(){ |
| stacks_ = new Hashtable<String,Stack<BarrierExpression>>(); |
| for(Enumeration<String> e = bTable_.getTable().keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| stacks_.put(comm, new Stack<BarrierExpression>()); |
| } |
| |
| depth = 0; |
| caseParent = new Stack<IASTNode>(); |
| withBreak = new Stack<Boolean>(); |
| caseBE = new Hashtable<String,Stack<List>>(); |
| for(Enumeration<String> e = bTable_.getTable().keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| caseBE.put(comm, new Stack<List>()); |
| } |
| } |
| |
| |
| public void run(){ |
| if(bTable_.isEmpty()) return; |
| this.shouldVisitExpressions = true; |
| this.shouldVisitStatements = true; |
| this.shouldVisitDeclarations = true; |
| for(ICallGraphNode n = cg_.botEntry(); n != null; n = n.botNext()){ |
| currentNode_ = (MPICallGraphNode)n; |
| if(!currentNode_.marked) continue; |
| if(!currentNode_.barrierRelated()) continue; |
| //System.out.println("Barrier related function " + currentNode_.getFuncName()); |
| init(); |
| IASTFunctionDefinition func = currentNode_.getFuncDef(); |
| func.accept(this); |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| BarrierExpression be = sk.pop(); |
| if(traceOn)System.out.println(currentNode_.getFuncName() + "(" + comm + "): " + be.prettyPrinter()); //$NON-NLS-1$ //$NON-NLS-2$ |
| if(traceOn)System.out.println(" "); //$NON-NLS-1$ |
| currentNode_.setBarrierExpr(comm, be); |
| } |
| } |
| if(traceOn)System.out.println("Total number of nodes: " + BarrierExpression.count_node); //$NON-NLS-1$ |
| } |
| |
| public int visit(IASTStatement stmt){ |
| if(stmt instanceof IASTSwitchStatement){ |
| for(Enumeration<Stack<List>> e = caseBE.elements(); e.hasMoreElements();){ |
| Stack<List> caseBEsk = e.nextElement(); |
| caseBEsk.push(new ArrayList<Object>()); |
| } |
| withBreak.push(new Boolean(false)); |
| depth ++; |
| } |
| return PROCESS_CONTINUE; |
| } |
| |
| public int leave(IASTStatement stmt){ |
| BarrierExpression be = null; |
| BarrierExpression operand1 = null; |
| BarrierExpression operand2 = null; |
| BarrierExpression condBE = null; |
| |
| if(stmt instanceof IASTAmbiguousStatement){ |
| |
| } |
| else if(stmt instanceof IASTBreakStatement){ |
| IASTBreakStatement bkStmt = (IASTBreakStatement)stmt; |
| if(inCaseStmt(bkStmt)){ |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<List> caseBEsk = caseBE.get(comm); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| List list = caseBEsk.peek(); |
| for(int i=1; i<list.size(); i+=2){ |
| CaseBarrierExpr cbe = (CaseBarrierExpr)list.get(i); |
| cbe.close(); |
| } |
| } |
| } |
| else{ |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| } |
| else if(stmt instanceof IASTCaseStatement){ |
| IASTCaseStatement caseStmt = (IASTCaseStatement)stmt; |
| /* Override the old parent if it exists */ |
| if(!caseParent.empty()) caseParent.pop(); |
| caseParent.push(caseStmt.getParent()); |
| |
| for(Enumeration e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = (String)e.nextElement(); |
| Stack<List> caseBEsk = caseBE.get(comm); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| List list = caseBEsk.peek(); |
| list.add(caseStmt); |
| list.add(new CaseBarrierExpr(be, caseStmt.getExpression())); |
| } |
| |
| /* Toggle the withBreak sign of the previous case */ |
| if(!withBreak.empty()) withBreak.pop(); |
| withBreak.push(new Boolean(false)); |
| } |
| else if(stmt instanceof IASTCompoundStatement){ |
| IASTCompoundStatement cmpStmt = (IASTCompoundStatement)stmt; |
| IASTStatement [] s = cmpStmt.getStatements(); |
| if(s.length == 0) return PROCESS_CONTINUE; |
| |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| /* The concatenate operator is left-associative */ |
| int count = 0; |
| int i; |
| BarrierExpression[] BElist = new BarrierExpression[s.length]; |
| for(i=0; i<s.length; i++){ |
| if(s[i] == null) continue; |
| BElist[count] = sk.pop(); |
| count ++; |
| } |
| operand1 = BElist[count-1]; |
| for (i = count-2; i >= 0; i-- ) { |
| operand2 = BElist[i]; |
| be = BarrierExpression.concatBE(operand1, operand2); |
| operand1 = be; |
| } |
| sk.push(operand1); |
| fixSwitch(comm, cmpStmt, operand1); |
| } |
| } |
| else if(stmt instanceof IASTContinueStatement){ |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| else if(stmt instanceof IASTDeclarationStatement){ |
| boolean initialized = false; |
| IASTDeclarationStatement declStmt = (IASTDeclarationStatement)stmt; |
| IASTDeclaration decl = declStmt.getDeclaration(); |
| if(decl instanceof IASTSimpleDeclaration){ |
| IASTSimpleDeclaration simpleDecl = (IASTSimpleDeclaration)decl; |
| IASTDeclarator[] declarators = simpleDecl.getDeclarators(); |
| for(int i=0; i<declarators.length; i++){ |
| IASTInitializer init = declarators[i].getInitializer(); |
| if(init != null){ |
| initialized = true; |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = getInitializerBE(sk, init); |
| sk.push(be); |
| } |
| } |
| } |
| } |
| if(!initialized){ |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| } |
| else if(stmt instanceof IASTDefaultStatement){ |
| /* DefaultStatement = CaseStatement + BreakStatement */ |
| IASTDefaultStatement dfStmt = (IASTDefaultStatement)stmt; |
| /* Override the old parent if it exists */ |
| if(!caseParent.empty()) caseParent.pop(); |
| caseParent.push(dfStmt.getParent()); |
| |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<List> caseBEsk = caseBE.get(comm); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| List list = caseBEsk.peek(); |
| list.add(dfStmt); |
| list.add(new CaseBarrierExpr(be, null)); |
| } |
| } |
| else if(stmt instanceof IASTDoStatement){ |
| IASTDoStatement doStmt = (IASTDoStatement)stmt; |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| /* condition */ |
| if(doStmt.getCondition() != null) |
| condBE = (BarrierExpression)sk.pop(); |
| else |
| condBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* loop body */ |
| if(doStmt.getBody() != null) |
| operand1 = (BarrierExpression)sk.pop(); |
| else |
| operand1 = new BarrierExpression(BarrierExpression.BE_bot); |
| /* BE = body . cond. (body . cond)* */ |
| be = BarrierExpression.concatBE(operand1, condBE, |
| BarrierExpression.repeatBE( |
| BarrierExpression.concatBE(operand1, condBE), |
| doStmt.getCondition(), stmt)); |
| sk.push(be); |
| fixSwitch(comm, stmt, be); |
| } |
| } |
| else if(stmt instanceof IASTExpressionStatement){ |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = sk.pop(); |
| sk.push(be); |
| fixSwitch(comm, stmt, be); |
| } |
| } |
| else if(stmt instanceof IASTForStatement){ |
| IASTForStatement forStmt = (IASTForStatement)stmt; |
| BarrierExpression initBE = null; |
| BarrierExpression iterBE = null; |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| /* loop body */ |
| if(forStmt.getBody() != null) |
| operand1 = sk.pop(); |
| else |
| operand1 = new BarrierExpression(BarrierExpression.BE_bot); |
| /* iterator */ |
| if(forStmt.getIterationExpression() != null) |
| iterBE = sk.pop(); |
| else |
| iterBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* condition */ |
| if(forStmt.getConditionExpression() != null) |
| condBE = sk.pop(); |
| else |
| condBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* initializer */ |
| if(forStmt.getInitializerStatement() != null) |
| initBE = sk.pop(); |
| else |
| initBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* BE = init . cond. (body . iter . cond)* */ |
| be = BarrierExpression.concatBE(initBE, condBE, |
| BarrierExpression.repeatBE( |
| BarrierExpression.concatBE(operand1, iterBE, condBE), |
| forStmt.getConditionExpression(), stmt)); |
| sk.push(be); |
| fixSwitch(comm, stmt, be); |
| } |
| } |
| else if(stmt instanceof IASTGotoStatement){ |
| /* TODO */ |
| } |
| else if(stmt instanceof IASTIfStatement){ |
| IASTIfStatement ifStmt = (IASTIfStatement)stmt; |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| /* else clause */ |
| if(ifStmt.getElseClause() != null) |
| operand2 = sk.pop(); |
| else |
| operand2 = new BarrierExpression(BarrierExpression.BE_bot); |
| /* then clause */ |
| if(ifStmt.getThenClause() != null) |
| operand1 = sk.pop(); |
| else |
| operand1 = new BarrierExpression(BarrierExpression.BE_bot); |
| /* condition*/ |
| if(ifStmt.getConditionExpression() != null) |
| condBE = sk.pop(); |
| else |
| condBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* BE = cond. (then | else) */ |
| be = BarrierExpression.concatBE(condBE, |
| BarrierExpression.branchBE(operand1, operand2, |
| ifStmt.getConditionExpression(), stmt)); |
| sk.push(be); |
| fixSwitch(comm, stmt, be); |
| } |
| } |
| else if(stmt instanceof IASTLabelStatement){ |
| /* TODO */ |
| } |
| else if(stmt instanceof IASTNullStatement){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| else if(stmt instanceof IASTProblemStatement){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| else if(stmt instanceof IASTReturnStatement){ |
| IASTReturnStatement rStmt = (IASTReturnStatement)stmt; |
| if(rStmt.getReturnValue() == null){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } else { |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| be = sk.pop(); |
| sk.push(be); |
| if(!withBreak.empty()){ |
| withBreak.pop(); |
| withBreak.push(new Boolean(true)); |
| } |
| fixSwitch(comm, rStmt, be); |
| } |
| } |
| } |
| else if(stmt instanceof IASTSwitchStatement){ |
| IASTSwitchStatement swStmt = (IASTSwitchStatement)stmt; |
| for(Enumeration<String> e = caseBE.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<List> caseBEsk = caseBE.get(comm); |
| List list = caseBEsk.pop(); |
| CaseBarrierExpr cbe = (CaseBarrierExpr)list.get(1); |
| operand1 = (BarrierExpression)cbe.getBE(); |
| for(int i=3; i<list.size(); i+=2){ |
| cbe = (CaseBarrierExpr)list.get(i); |
| operand2 = (BarrierExpression)cbe.getBE(); |
| be = BarrierExpression.branchBE(operand1, operand2, |
| swStmt.getControllerExpression(), stmt); |
| operand1 = be; |
| } |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| sk.pop(); |
| sk.push(operand1); |
| } |
| withBreak.pop(); |
| caseParent.pop(); |
| depth --; |
| } |
| else if(stmt instanceof IASTWhileStatement){ |
| IASTWhileStatement whStmt = (IASTWhileStatement)stmt; |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| /* loop body */ |
| if(whStmt.getBody() != null) |
| operand1 = sk.pop(); |
| else |
| operand1 = new BarrierExpression(BarrierExpression.BE_bot); |
| /* condition */ |
| if(whStmt.getCondition() != null) |
| condBE = sk.pop(); |
| else |
| condBE = new BarrierExpression(BarrierExpression.BE_bot); |
| /* BE = cond . (body . cond)* */ |
| be = BarrierExpression.concatBE(condBE, |
| BarrierExpression.repeatBE( |
| BarrierExpression.concatBE(operand1, condBE), |
| whStmt.getCondition(), stmt)); |
| sk.push(be); |
| fixSwitch(comm, stmt, be); |
| } |
| } |
| |
| return PROCESS_CONTINUE; |
| } |
| |
| /** |
| * If the current statement is a case body |
| */ |
| private void fixSwitch(String key, IASTStatement stmt, BarrierExpression BE){ |
| if(depth <= 0) return; |
| if(stmt.getParent() == caseParent.peek()){ |
| Stack<List> caseBEsk = caseBE.get(key); |
| List list = caseBEsk.peek(); |
| boolean flag = ((Boolean)withBreak.peek()).booleanValue(); |
| for(int i = 1; i<list.size(); i+=2){ |
| CaseBarrierExpr cbe = (CaseBarrierExpr)list.get(i); |
| if(flag) |
| cbe.addFinalBEElement(BE); |
| else |
| cbe.addBEElement(BE); |
| } |
| } |
| } |
| |
| private boolean inCaseStmt(IASTBreakStatement stmt){ |
| IASTNode parent = stmt.getParent(); |
| while(parent != null){ |
| if(parent instanceof IASTForStatement || |
| parent instanceof IASTDoStatement || |
| parent instanceof IASTWhileStatement) |
| return false; |
| else if(parent instanceof IASTSwitchStatement) |
| return true; |
| else if(parent instanceof IASTFunctionDefinition) |
| return false; |
| else |
| parent = parent.getParent(); |
| } |
| return false; |
| } |
| |
| private BarrierExpression getInitializerBE(Stack sk, IASTInitializer init){ |
| BarrierExpression BE = null; |
| if(init instanceof IASTInitializerExpression){ |
| BE = (BarrierExpression)sk.pop(); |
| } |
| else if(init instanceof IASTInitializerList){ |
| IASTInitializerList list = (IASTInitializerList)init; |
| IASTInitializer[] inits = list.getInitializers(); |
| for(int j = 0; j<inits.length; j++){ |
| if(BE == null) |
| BE = getInitializerBE(sk, inits[j]); |
| else |
| BE = BarrierExpression.concatBE(BE, |
| getInitializerBE(sk, inits[j])); |
| } |
| } |
| return BE; |
| } |
| |
| /* |
| * An expression which doesn't have any "expression" |
| * field is a terminal. |
| */ |
| public int leave(IASTExpression expr){ |
| BarrierExpression be = null; |
| BarrierExpression operand1 = null; |
| BarrierExpression operand2 = null; |
| BarrierExpression operand3 = null; |
| |
| if(expr instanceof IASTAmbiguousExpression){ |
| /* nothing */ |
| } |
| else if(expr instanceof IASTArraySubscriptExpression){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| operand2 = sk.pop(); //subscript |
| operand1 = sk.pop(); //array |
| be = BarrierExpression.concatBE(operand1, operand2); |
| sk.push(be); |
| } |
| } |
| else if(expr instanceof IASTBinaryExpression){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| operand2 = sk.pop(); |
| operand1 = sk.pop(); |
| be = BarrierExpression.concatBE(operand1, operand2); |
| sk.push(be); |
| } |
| } |
| else if(expr instanceof IASTCastExpression){ |
| /* Has only one operator, leave it there */ |
| } |
| else if(expr instanceof IASTConditionalExpression){ |
| IASTConditionalExpression cExpr = (IASTConditionalExpression)expr; |
| IASTNode parent = expr.getParent(); |
| while(! (parent instanceof IASTStatement) ) |
| parent = parent.getParent(); |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| operand2 = sk.pop(); /* negative */ |
| operand1 = sk.pop(); /* positive */ |
| operand3 = sk.pop(); /* condition */ |
| /* E = C ( P | N ) */ |
| be = BarrierExpression.concatBE(operand3, |
| BarrierExpression.branchBE(operand1, operand2, |
| cExpr.getLogicalConditionExpression(), |
| (IASTStatement)parent)); |
| sk.push(be); |
| } |
| } |
| else if(expr instanceof IASTExpressionList){ |
| IASTExpressionList exprList = (IASTExpressionList)expr; |
| IASTExpression[] exps = exprList.getExpressions(); |
| if(exps.length == 0) return PROCESS_CONTINUE; |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| int count = 0; |
| int i; |
| BarrierExpression[] BElist = new BarrierExpression[exps.length]; |
| for(i=0; i<exps.length; i++){ |
| if(exps[i] == null) continue; |
| BElist[count] = sk.pop(); |
| count ++; |
| } |
| operand1 = BElist[count-1]; |
| for (i = count-2; i >= 0; i-- ) { |
| operand2 = BElist[i]; |
| be = BarrierExpression.concatBE(operand1, operand2); |
| operand1 = be; |
| } |
| sk.push(operand1); |
| } |
| } |
| else if(expr instanceof IASTFieldReference){ |
| /* |
| for(Enumeration e = stacks_.elements(); e.hasMoreElements();){ |
| Stack sk = (Stack)e.nextElement(); |
| operand2 = (BarrierExpression)sk.pop(); //name |
| operand1 = (BarrierExpression)sk.pop(); //owner |
| be = BarrierExpression.concatBE(operand1, operand2); |
| sk.push(be); |
| } |
| */ |
| } |
| else if(expr instanceof IASTFunctionCallExpression){ |
| IASTFunctionCallExpression fExpr = (IASTFunctionCallExpression)expr; |
| IASTExpression funcname = fExpr.getFunctionNameExpression(); |
| IASTExpression parameter = fExpr.getParameterExpression(); |
| String signature = funcname.getRawSignature(); |
| int id = bTable_.isBarrier(fExpr); |
| if(id != -1){ /* barrier */ |
| be = new BarrierExpression(id); |
| String comm = bTable_.getComm(id); |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String commkey = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(commkey); |
| if(parameter != null) sk.pop(); //parameter |
| sk.pop(); //functionName |
| if(commkey.equals(comm)) sk.push(be); |
| else sk.push(new BarrierExpression(BarrierExpression.BE_bot)); |
| } |
| } |
| else{ |
| MPICallGraphNode node = (MPICallGraphNode)cg_.getNode(currentNode_.getFileName(), signature); |
| if(node != null && node.barrierRelated()){ |
| /* a function (directly or indirectly) with barriers */ |
| for(Enumeration<String> e = stacks_.keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| Stack<BarrierExpression> sk = stacks_.get(comm); |
| BarrierExpression funcBE = node.getBarrierExpr().get(comm); |
| if(parameter != null) sk.pop(); //parameter |
| sk.pop(); //functionName |
| if(node == currentNode_){ //recursive functions |
| be = new BarrierExpression(node.getFuncName()); |
| } |
| else if(funcBE.isBot()){ |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| } |
| else{ |
| be = new BarrierExpression(signature); |
| } |
| sk.push(be); |
| } |
| } else { //not a barrier related function |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| if(parameter != null) sk.pop(); //parameter |
| sk.pop(); //functionName |
| sk.push(be); |
| } |
| } |
| } |
| } |
| else if(expr instanceof IASTIdExpression){ //terminal |
| //System.out.println(((IASTIdExpression)expr).getName().toString()); |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| else if(expr instanceof IASTLiteralExpression){ //terminal |
| //System.out.println(((IASTLiteralExpression)expr).toString()); |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| /* |
| else if(expr instanceof IASTProblemExpression){ |
| System.out.println("IASTProblemExpression"); |
| } |
| */ |
| else if(expr instanceof IASTTypeIdExpression){ |
| for(Enumeration<Stack<BarrierExpression>> e = stacks_.elements(); e.hasMoreElements();){ |
| Stack<BarrierExpression> sk = e.nextElement(); |
| be = new BarrierExpression(BarrierExpression.BE_bot); |
| sk.push(be); |
| } |
| } |
| else if(expr instanceof IASTUnaryExpression){ |
| /* has only one operand, leave it there */ |
| } |
| /* |
| else if(expr instanceof ICASTTypeIdInitializerExpression){ |
| System.out.println("ICASTTypeIdInitializerExpression"); |
| } |
| */ |
| return PROCESS_CONTINUE; |
| } |
| |
| class CaseBarrierExpr{ |
| protected BarrierExpression BE; |
| protected boolean closed; |
| protected IASTExpression cond; |
| |
| CaseBarrierExpr(BarrierExpression be, IASTExpression cond){ |
| BE = be; |
| closed = false; |
| this.cond = cond; |
| } |
| |
| public void close() { closed = true; } |
| public BarrierExpression getBE() {return BE;} |
| public IASTExpression getCond() {return cond;} |
| |
| public void addBEElement(BarrierExpression be){ |
| if(closed) return; |
| if(BE == null){ |
| BE = be; |
| } else { |
| BE = BarrierExpression.concatBE(BE, be); |
| } |
| } |
| |
| public void addFinalBEElement(BarrierExpression be){ |
| addBEElement(be); |
| close(); |
| } |
| } |
| |
| protected void checkBarrierRecursion(){ |
| for(Iterator<List<ICallGraphNode>> i=cg_.getCycles().iterator(); i.hasNext();){ |
| List<ICallGraphNode> cycle = i.next(); |
| boolean barrierRelated = false; |
| for(Iterator<ICallGraphNode> ii = cycle.iterator(); ii.hasNext();){ |
| MPICallGraphNode node = (MPICallGraphNode)ii.next(); |
| if(node.barrierRelated){ |
| barrierRelated = true; |
| break; |
| } |
| } |
| if(!barrierRelated) continue; |
| if(cycle.size() > 1){ |
| System.out.println("Multi-Function barrier related cycles"); //$NON-NLS-1$ |
| return; |
| } |
| currentNode_ = (MPICallGraphNode)cycle.get(0); |
| for(Enumeration<String> e = currentNode_.getBarrierExpr().keys(); e.hasMoreElements();){ |
| String comm = e.nextElement(); |
| BarrierExpression BE = currentNode_.getBarrierExpr().get(comm); |
| if(recursion(BE) == recursionError){ |
| System.out.println("Recursion Error in " + comm); //$NON-NLS-1$ |
| } |
| } |
| |
| } |
| } |
| |
| protected final int recursionCorrect = 0; |
| protected final int recursionError = 1; |
| protected final int noRecursion = 2; |
| |
| protected int recursion(BarrierExpression BE){ |
| System.out.println(BE.prettyPrinter()); |
| BarrierExpressionOP OP = BE.getOP(); |
| if(OP == null){ |
| if(BE.isFunc()){ //function call |
| String funcName = BE.getFuncName(); |
| MPICallGraphNode fnode = (MPICallGraphNode)cg_.getNode(currentNode_.getFileName(), funcName); |
| if(fnode == currentNode_) |
| return recursionCorrect; |
| else |
| return noRecursion; |
| } |
| else |
| return noRecursion; |
| } |
| else if(OP.getOperator() == BarrierExpressionOP.op_concat){ |
| int v1 = recursion(BE.getOP1()); |
| int v2 = recursion(BE.getOP2()); |
| if(v1 == recursionError || v2 == recursionError) |
| return recursionError; |
| else if(v1 == recursionCorrect || v2 == recursionCorrect) |
| return recursionCorrect; |
| else |
| return noRecursion; |
| |
| } |
| else if(OP.getOperator() == BarrierExpressionOP.op_branch){ |
| int v1 = recursion(BE.getOP1()); |
| int v2 = recursion(BE.getOP2()); |
| if(v1 == noRecursion && v2 == noRecursion) |
| return noRecursion; |
| else |
| return recursionError; |
| } |
| else { //BarrierExpressionOP.op_repeat |
| return recursion(BE.getOP1()); |
| |
| } |
| } |
| |
| |
| } |
| |
