src/main/java/org/apache/sysml/parser/IfStatementBlock.java - systemds - Git at Google

 /*
  * Licensed to the Apache Software Foundation (ASF) under one
  * or more contributor license agreements.  See the NOTICE file
  * distributed with this work for additional information
  * regarding copyright ownership.  The ASF licenses this file
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
  *
  *   http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied.  See the License for the
  * specific language governing permissions and limitations
  * under the License.
  */

 package org.apache.sysml.parser;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map.Entry;

 import org.apache.sysml.conf.ConfigurationManager;
 import org.apache.sysml.hops.Hop;
 import org.apache.sysml.hops.HopsException;
 import org.apache.sysml.hops.recompile.Recompiler;
 import org.apache.sysml.lops.Lop;
 import org.apache.sysml.parser.Expression.DataType;


 public class IfStatementBlock extends StatementBlock
 {

 	private Hop _predicateHops;
 	private Lop _predicateLops = null;
 	private boolean _requiresPredicateRecompile = false;

 	@Override
 	public VariableSet validate(DMLProgram dmlProg, VariableSet ids, HashMap<String,ConstIdentifier> constVars, boolean conditional)
 		throws LanguageException, ParseException, IOException
 	{
 		if (_statements.size() > 1){
 			raiseValidateError("IfStatementBlock should only have 1 statement (IfStatement)", conditional);
 		}

 		IfStatement ifstmt = (IfStatement) _statements.get(0);

 		//validate conditional predicate (incl constant propagation)
 		Expression pred = ifstmt.getConditionalPredicate().getPredicate();
 		pred.validateExpression(ids.getVariables(), constVars, conditional);
 		if( pred instanceof DataIdentifier && constVars.containsKey( ((DataIdentifier)pred).getName()) ) {
 			ifstmt.getConditionalPredicate().setPredicate(constVars.get(((DataIdentifier)pred).getName()));
 		}

 		HashMap<String,ConstIdentifier> constVarsIfCopy = new HashMap<String,ConstIdentifier>(constVars);
 		HashMap<String,ConstIdentifier> constVarsElseCopy = new HashMap<String,ConstIdentifier> (constVars);

 		VariableSet idsIfCopy 	= new VariableSet(ids);
 		VariableSet idsElseCopy = new VariableSet(ids);
 		VariableSet	idsOrigCopy = new VariableSet(ids);

 		// handle if stmt body
 		_dmlProg = dmlProg;
 		ArrayList<StatementBlock> ifBody = ifstmt.getIfBody();
 		for(StatementBlock sb : ifBody){ //conditional exec
 			idsIfCopy = sb.validate(dmlProg, idsIfCopy, constVarsIfCopy, true);
 			constVarsIfCopy = sb.getConstOut();
 		}

 		// handle else stmt body
 		ArrayList<StatementBlock> elseBody = ifstmt.getElseBody();
 		for(StatementBlock sb : elseBody){ //conditional exec
 			idsElseCopy = sb.validate(dmlProg,idsElseCopy, constVarsElseCopy, true);
 			constVarsElseCopy = sb.getConstOut();
 		}


 		/////////////////////////////////////////////////////////////////////////////////
 		//  check data type and value type are same for updated variables in both
 		//	if statement and else statement
 		//  (reject conditional data type change)
 		/////////////////////////////////////////////////////////////////////////////////
 		for (String updatedVar : this._updated.getVariableNames()){
 			DataIdentifier origVersion  = idsOrigCopy.getVariable(updatedVar);
 			DataIdentifier ifVersion 	= idsIfCopy.getVariable(updatedVar);
 			DataIdentifier elseVersion  = idsElseCopy.getVariable(updatedVar);

 			//data type handling: reject conditional data type change
 			if( ifVersion != null && elseVersion != null ) //both branches exist
 			{
 				if (!ifVersion.getOutput().getDataType().equals(elseVersion.getOutput().getDataType())){
 					raiseValidateError("IfStatementBlock has unsupported conditional data type change of variable '"+updatedVar+"' in if/else branch.", conditional);
 				}
 			}
 			else if( origVersion !=null ) //only if branch exists
 			{
 				if (!ifVersion.getOutput().getDataType().equals(origVersion.getOutput().getDataType())){
 					raiseValidateError("IfStatementBlock has unsupported conditional data type change of variable '"+updatedVar+"' in if branch.", conditional);
 				}
 			}

 			//value type handling
 			if (ifVersion != null && elseVersion != null && !ifVersion.getOutput().getValueType().equals(elseVersion.getOutput().getValueType())){
 				LOG.warn(elseVersion.printWarningLocation() + "Variable " + elseVersion.getName() + " defined with different value type in if and else clause.");
 			}
 		}

 		// handle constant variable propagation -- (IF UNION ELSE) MINUS updated vars

 		//////////////////////////////////////////////////////////////////////////////////
 		// handle constant variables
 		// 1) (IF UNION ELSE) MINUS updated const vars
 		// 2) reconcile updated const vars
 		// 		a) IF updated const variables have same value and datatype in both if / else branch, THEN set updated size to updated size
 		//		b) ELSE leave out of reconciled set
 		/////////////////////////////////////////////////////////////////////////////////

 		HashMap<String,ConstIdentifier> recConstVars = new HashMap<String,ConstIdentifier>();

 		// STEP 1:  (IF UNION ELSE) MINUS updated vars
 		for (Entry<String,ConstIdentifier> e : constVarsIfCopy.entrySet() ){
 			String varName = e.getKey();
 			if (!_updated.containsVariable(varName))
 				recConstVars.put(varName, e.getValue());
 		}
 		for (Entry<String,ConstIdentifier> e : constVarsElseCopy.entrySet() ){
 			String varName = e.getKey();
 			if (!_updated.containsVariable(varName))
 				recConstVars.put(varName, e.getValue());
 		}


 		// STEP 2: check that updated const values have in both if / else branches
 		//		a) same data type,
 		//		b) same value type (SCALAR),
 		//		c) same value
 		for (String updatedVar : _updated.getVariableNames()){
 			DataIdentifier ifVersion 	= idsIfCopy.getVariable(updatedVar);
 			DataIdentifier elseVersion  = idsElseCopy.getVariable(updatedVar);

 			if (ifVersion != null && elseVersion != null
 					&& ifVersion.getOutput().getDataType().equals(DataType.SCALAR)
 					&& elseVersion.getOutput().getDataType().equals(DataType.SCALAR)
 					&& ifVersion.getOutput().getValueType().equals(elseVersion.getOutput().getValueType()))
 			{
 				ConstIdentifier ifConstVersion   = constVarsIfCopy.get(updatedVar);
 				ConstIdentifier elseConstVersion = constVarsElseCopy.get(updatedVar);
 				// IntIdentifier
 				if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof IntIdentifier && elseConstVersion instanceof IntIdentifier){
 					if ( ((IntIdentifier)ifConstVersion).getValue() == ((IntIdentifier) elseConstVersion).getValue() )
 						recConstVars.put(updatedVar, ifConstVersion);
 				}
 				// DoubleIdentifier
 				else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof DoubleIdentifier && elseConstVersion instanceof DoubleIdentifier){
 					if ( ((DoubleIdentifier)ifConstVersion).getValue() == ((DoubleIdentifier) elseConstVersion).getValue() )
 						recConstVars.put(updatedVar, ifConstVersion);
 				}
 				// Boolean
 				else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof BooleanIdentifier && elseConstVersion instanceof BooleanIdentifier){
 					if ( ((BooleanIdentifier)ifConstVersion).getValue() == ((BooleanIdentifier) elseConstVersion).getValue() )
 						recConstVars.put(updatedVar, ifConstVersion);
 				}

 				// String
 				else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof StringIdentifier && elseConstVersion instanceof StringIdentifier){
 					if ( ((StringIdentifier)ifConstVersion).getValue().equals(((StringIdentifier) elseConstVersion).getValue()) )
 						recConstVars.put(updatedVar, ifConstVersion);
 				}
 			}
 		}

 		//////////////////////////////////////////////////////////////////////////////////
 		// handle DataIdentifier variables
 		// 1) (IF UNION ELSE) MINUS updated vars
 		// 2) reconcile size updated variables
 		// 		a) IF updated variables have same size in both if / else branch, THEN set updated size to updated size
 		//		b) ELSE  set size updated to (-1,-1)
 		// 3) add updated vars to reconciled set
 		/////////////////////////////////////////////////////////////////////////////////

 		// STEP 1:  (IF UNION ELSE) MINUS updated vars
 		VariableSet recVars = new VariableSet();

 		for (String varName : idsIfCopy.getVariableNames()){
 			if (!_updated.containsVariable(varName))
 				recVars.addVariable(varName,idsIfCopy.getVariable(varName));
 		}
 		for (String varName : idsElseCopy.getVariableNames()){
 			if (!_updated.containsVariable(varName))
 				recVars.addVariable(varName,idsElseCopy.getVariable(varName));
 		}

 		// STEP 2: reconcile size of updated variables
 		for (String updatedVar : _updated.getVariableNames()){
 			DataIdentifier ifVersion 	= idsIfCopy.getVariable(updatedVar);
 			DataIdentifier elseVersion  = idsElseCopy.getVariable(updatedVar);
 			DataIdentifier origVersion = idsOrigCopy.getVariable(updatedVar);

 			if (ifVersion != null && elseVersion != null) {
 				long updatedDim1 = -1, updatedDim2 = -1;
 				long updatedNnz = -1;

 				long ifVersionDim1 		= (ifVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)ifVersion).getOrigDim1() : ifVersion.getDim1();
 				long elseVersionDim1	= (elseVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)elseVersion).getOrigDim1() : elseVersion.getDim1();

 				long ifVersionDim2 		= (ifVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)ifVersion).getOrigDim2() : ifVersion.getDim2();
 				long elseVersionDim2	= (elseVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)elseVersion).getOrigDim2() : elseVersion.getDim2();

 				if( ifVersionDim1 == elseVersionDim1 ){
 					updatedDim1 = ifVersionDim1;
 				}
 				if( ifVersionDim2 == elseVersionDim2 ){
 					updatedDim2 = ifVersionDim2;
 				}


 				//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
 				//if( ifVersion.getNnz() == elseVersion.getNnz() ){
 				//	updatedNnz = ifVersion.getNnz();
 				//}

 				// add reconsiled version (deep copy of ifVersion, cast as DataIdentifier)
 				DataIdentifier recVersion = new DataIdentifier(ifVersion);
 				recVersion.setDimensions(updatedDim1, updatedDim2);
 				recVersion.setNnz(updatedNnz);
 				recVars.addVariable(updatedVar, recVersion);
 			}
 			else {
 				// CASE: defined only if branch
 				DataIdentifier recVersion = null;
 				if (ifVersion != null){
 					// add reconciled version (deep copy of ifVersion, cast as DataIdentifier)
 					recVersion = new DataIdentifier(ifVersion);
 					recVars.addVariable(updatedVar, recVersion);
 				}
 				// CASE: defined only else branch
 				else if (elseVersion != null){
 					// add reconciled version (deep copy of elseVersion, cast as DataIdentifier)
 					recVersion = new DataIdentifier(elseVersion);
 					recVars.addVariable(updatedVar, recVersion);
 				}
 				// CASE: updated, but not in either if or else branch
 				else {
 					// add reconciled version (deep copy of elseVersion, cast as DataIdentifier)
 					recVersion = new DataIdentifier(_updated.getVariable(updatedVar));
 					recVars.addVariable(updatedVar, recVersion);
 				}


 				long updatedDim1 = -1, updatedDim2 = -1;
 				long updatedNnz = -1;

 				if( origVersion != null ) {
 					long origVersionDim1 = (origVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)origVersion).getOrigDim1() : origVersion.getDim1();
 					long recVersionDim1	 = recVersion.getDim1(); //always DataIdentifier (see above)
 					long origVersionDim2 = (origVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)origVersion).getOrigDim2() : origVersion.getDim2();
 					long recVersionDim2	 = recVersion.getDim2(); //always DataIdentifier (see above)

 					if( origVersionDim1 == recVersionDim1 ){
 						updatedDim1 = origVersionDim1;
 					}
 					if( origVersionDim2 == recVersionDim2 ){
 						updatedDim2 = origVersionDim2;
 					}
 					//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
 					//if( origVersion.getNnz() == recVersion.getNnz() ){
 					//	updatedNnz = recVersion.getNnz();
 					//}
 				}

 				recVersion.setDimensions(updatedDim1, updatedDim2);
 				recVersion.setNnz(updatedNnz);
 			}
 		}

 		// propagate updated variables
 		VariableSet allIdVars = new VariableSet(recVars);

 		_constVarsIn.putAll(constVars);
 		_constVarsOut.putAll(recConstVars);

 		return allIdVars;
 	}

 	@Override
 	public VariableSet initializeforwardLV(VariableSet activeInPassed)
 		throws LanguageException
 	{
 		IfStatement ifstmt = (IfStatement)_statements.get(0);
 		if (_statements.size() > 1){
 			LOG.error(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
 			throw new LanguageException(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
 		}
 		_read = new VariableSet();
 		_gen = new VariableSet();
 		_kill = new VariableSet();
 		_warnSet = new VariableSet();

 		///////////////////////////////////////////////////////////////////////
 		// HANDLE PREDICATE
 		///////////////////////////////////////////////////////////////////////
 		_read.addVariables(ifstmt.getConditionalPredicate().variablesRead());
 		_updated.addVariables(ifstmt.getConditionalPredicate().variablesUpdated());
 		_gen.addVariables(ifstmt.getConditionalPredicate().variablesRead());

 		///////////////////////////////////////////////////////////////////////
 		//  IF STATEMENT
 		///////////////////////////////////////////////////////////////////////

 		// initialize forward for each statement block in if body
 		VariableSet ifCurrent = new VariableSet(activeInPassed);
 		VariableSet genIfBody = new VariableSet();
 		VariableSet killIfBody = new VariableSet();
 		VariableSet updatedIfBody = new VariableSet();
 		VariableSet readIfBody = new VariableSet();

 		for (StatementBlock sb : ifstmt.getIfBody())
 		{
 			ifCurrent = sb.initializeforwardLV(ifCurrent);

 			// for each generated variable in this block, check variable not killed
 			// (assigned value) in prior statement block in ifstmt blody
 			for (String varName : sb._gen.getVariableNames()){

 				// IF the variable is NOT set in the while loop PRIOR to this stmt block,
 				// THEN needs to be generated
 				if (!killIfBody.getVariableNames().contains(varName)){
 					genIfBody.addVariable(varName, sb._gen.getVariable(varName));
 				}
 			}

 			readIfBody.addVariables(sb._read);
 			updatedIfBody.addVariables(sb._updated);

 			// only add kill variables for statement blocks guaranteed to execute
 			if (!(sb instanceof WhileStatementBlock) && !(sb instanceof ForStatementBlock) ){
 				killIfBody.addVariables(sb._kill);
 			}
 		}

 		///////////////////////////////////////////////////////////////////////
 		//  ELSE STATEMENT
 		///////////////////////////////////////////////////////////////////////

 		// initialize forward for each statement block in if body
 		VariableSet elseCurrent = new VariableSet(activeInPassed);
 		VariableSet genElseBody = new VariableSet();
 		VariableSet killElseBody = new VariableSet();
 		VariableSet updatedElseBody = new VariableSet();
 		VariableSet readElseBody = new VariableSet();

 		// initialize forward for each statement block in else body
 		for (StatementBlock sb : ifstmt.getElseBody())
 		{
 			elseCurrent = sb.initializeforwardLV(elseCurrent);

 			// for each generated variable in this block, check variable not killed
 			// (assigned value) in prior statement block in ifstmt blody
 			for (String varName : sb._gen.getVariableNames()){

 				// IF the variable is NOT set in the while loop PRIOR to this stmt block,
 				// THEN needs to be generated
 				if (!killElseBody.getVariableNames().contains(varName)){
 					genElseBody.addVariable(varName, sb._gen.getVariable(varName));
 				}
 			}

 			readElseBody.addVariables(sb._read);
 			updatedElseBody.addVariables(sb._updated);

 			// only add kill variables for statement blocks guaranteed to execute
 			if (!(sb instanceof WhileStatementBlock) && !(sb instanceof ForStatementBlock) ){
 				killElseBody.addVariables(sb._kill);
 			}
 		}

 		///////////////////////////////////////////////////////////////////////
 		// PERFORM RECONCILIATION
 		///////////////////////////////////////////////////////////////////////

 		// "conservative" read -- union of read sets for if and else path
 		_read.addVariables(readIfBody);
 		_read.addVariables(readElseBody);

 		// "conservative" update -- union of updated
 		_updated.addVariables(updatedIfBody);
 		_updated.addVariables(updatedElseBody);

 		// "conservative" gen -- union of gen
 		_gen.addVariables(genIfBody);
 		_gen.addVariables(genElseBody);

 		// "conservative" kill -- kill set is intersection of if-kill and else-kill
 		for ( String varName : killIfBody.getVariableNames()){
 			if (killElseBody.containsVariable(varName)){
 				_kill.addVariable(varName, killIfBody.getVariable(varName));
 			}
 		}

 		// set preliminary "warn" set -- variables that if used later may cause runtime error
 		// if the loop is not executed
 		// warnSet = (updated MINUS (updatedIfBody INTERSECT updatedElseBody)) MINUS current
 		for (String varName : _updated.getVariableNames()){
 			if (!((updatedIfBody.containsVariable(varName) && updatedElseBody.containsVariable(varName))
 					|| activeInPassed.containsVariable(varName))) {
 				_warnSet.addVariable(varName, _updated.getVariable(varName));
 			}
 		}


 		// set activeOut to (if body current UNION else body current) UNION updated
 		_liveOut = new VariableSet();
 		_liveOut.addVariables(ifCurrent);
 		_liveOut.addVariables(elseCurrent);
 		_liveOut.addVariables(_updated);
 		return _liveOut;
 	}

 	@Override
 	public VariableSet initializebackwardLV(VariableSet loPassed)
 		throws LanguageException
 	{
 		IfStatement ifstmt = (IfStatement)_statements.get(0);
 		if (_statements.size() > 1){
 			LOG.error(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
 			throw new LanguageException(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
 		}

 		VariableSet currentLiveOutIf = new VariableSet(loPassed);
 		VariableSet currentLiveOutElse = new VariableSet(loPassed);

 		int numBlocks = ifstmt.getIfBody().size();
 		for (int i = numBlocks - 1; i >= 0; i--){
 			currentLiveOutIf = ifstmt.getIfBody().get(i).analyze(currentLiveOutIf);
 		}

 		numBlocks = ifstmt.getElseBody().size();
 		for (int i = numBlocks - 1; i >= 0; i--){
 			currentLiveOutElse = ifstmt.getElseBody().get(i).analyze(currentLiveOutElse);
 		}

 		// Any variable defined in either if-body or else-body is available for later use
 		VariableSet bothPathsLiveOut = new VariableSet();
 		bothPathsLiveOut.addVariables(currentLiveOutIf);
 		bothPathsLiveOut.addVariables(currentLiveOutElse);

 		return bothPathsLiveOut;

 	}

 	public void setPredicateHops(Hop hops) {
 		_predicateHops = hops;
 	}

 	public ArrayList<Hop> get_hops() throws HopsException{

 		if (_hops != null && _hops.size() > 0){
 			LOG.error(this.printBlockErrorLocation() + "error there should be no HOPs in IfStatementBlock");
 			throw new HopsException(this.printBlockErrorLocation() + "error there should be no HOPs in IfStatementBlock");
 		}

 		return _hops;
 	}

 	public Hop getPredicateHops(){
 		return _predicateHops;
 	}

 	public Lop get_predicateLops() {
 		return _predicateLops;
 	}

 	public void set_predicateLops(Lop predicateLops) {
 		_predicateLops = predicateLops;
 	}

 	public VariableSet analyze(VariableSet loPassed) throws LanguageException{

 		VariableSet predVars = ((IfStatement)_statements.get(0)).getConditionalPredicate().variablesRead();
 		predVars.addVariables(((IfStatement)_statements.get(0)).getConditionalPredicate().variablesUpdated());

 	 	VariableSet candidateLO = new VariableSet(loPassed);
 	 	VariableSet origLiveOut = new VariableSet(_liveOut);

 	 	_liveOut = new VariableSet();
 	 	for (String name : candidateLO.getVariableNames()){
 	 		if (origLiveOut.containsVariable(name)){
 	 			_liveOut.addVariable(name, candidateLO.getVariable(name));
 	 		}
 	 	}

 		initializebackwardLV(_liveOut);

 		// set final warnSet: remove variables NOT in live out
 		VariableSet finalWarnSet = new VariableSet();
 		for (String varName : _warnSet.getVariableNames()){
 			if (_liveOut.containsVariable(varName)){
 				finalWarnSet.addVariable(varName,_warnSet.getVariable(varName));
 			}
 		}
 		_warnSet = finalWarnSet;

 		// for now just print the warn set
 		for (String varName : _warnSet.getVariableNames()){
 			LOG.warn(_warnSet.getVariable(varName).printWarningLocation() + "Initialization of " + varName + " depends on if-else execution");
 		}

 		//data flow equation: liveout = gen \cup (liveout - kill)
 		_liveIn = new VariableSet();
 		_liveIn.addVariables(_liveOut);
 		_liveIn.removeVariables(_kill);
 		_liveIn.addVariables(_gen);

 		VariableSet liveInReturn = new VariableSet();
 		liveInReturn.addVariables(_liveIn);
 		return liveInReturn;
 	}


 	/////////
 	// materialized hops recompilation flags
 	////

 	public void updatePredicateRecompilationFlag()
 		throws HopsException
 	{
 		_requiresPredicateRecompile =  ConfigurationManager.isDynamicRecompilation()
 			                           && Recompiler.requiresRecompilation(getPredicateHops());
 	}

 	public boolean requiresPredicateRecompilation()
 	{
 		return _requiresPredicateRecompile;
 	}
 }
	/*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*/

	package org.apache.sysml.parser;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Map.Entry;

	import org.apache.sysml.conf.ConfigurationManager;
	import org.apache.sysml.hops.Hop;
	import org.apache.sysml.hops.HopsException;
	import org.apache.sysml.hops.recompile.Recompiler;
	import org.apache.sysml.lops.Lop;
	import org.apache.sysml.parser.Expression.DataType;


	public class IfStatementBlock extends StatementBlock
	{

	private Hop _predicateHops;
	private Lop _predicateLops = null;
	private boolean _requiresPredicateRecompile = false;

	@Override
	public VariableSet validate(DMLProgram dmlProg, VariableSet ids, HashMap<String,ConstIdentifier> constVars, boolean conditional)
	throws LanguageException, ParseException, IOException
	{
	if (_statements.size() > 1){
	raiseValidateError("IfStatementBlock should only have 1 statement (IfStatement)", conditional);
	}

	IfStatement ifstmt = (IfStatement) _statements.get(0);

	//validate conditional predicate (incl constant propagation)
	Expression pred = ifstmt.getConditionalPredicate().getPredicate();
	pred.validateExpression(ids.getVariables(), constVars, conditional);
	if( pred instanceof DataIdentifier && constVars.containsKey( ((DataIdentifier)pred).getName()) ) {
	ifstmt.getConditionalPredicate().setPredicate(constVars.get(((DataIdentifier)pred).getName()));
	}

	HashMap<String,ConstIdentifier> constVarsIfCopy = new HashMap<String,ConstIdentifier>(constVars);
	HashMap<String,ConstIdentifier> constVarsElseCopy = new HashMap<String,ConstIdentifier> (constVars);

	VariableSet idsIfCopy = new VariableSet(ids);
	VariableSet idsElseCopy = new VariableSet(ids);
	VariableSet idsOrigCopy = new VariableSet(ids);

	// handle if stmt body
	_dmlProg = dmlProg;
	ArrayList<StatementBlock> ifBody = ifstmt.getIfBody();
	for(StatementBlock sb : ifBody){ //conditional exec
	idsIfCopy = sb.validate(dmlProg, idsIfCopy, constVarsIfCopy, true);
	constVarsIfCopy = sb.getConstOut();
	}

	// handle else stmt body
	ArrayList<StatementBlock> elseBody = ifstmt.getElseBody();
	for(StatementBlock sb : elseBody){ //conditional exec
	idsElseCopy = sb.validate(dmlProg,idsElseCopy, constVarsElseCopy, true);
	constVarsElseCopy = sb.getConstOut();
	}


	/////////////////////////////////////////////////////////////////////////////////
	// check data type and value type are same for updated variables in both
	// if statement and else statement
	// (reject conditional data type change)
	/////////////////////////////////////////////////////////////////////////////////
	for (String updatedVar : this._updated.getVariableNames()){
	DataIdentifier origVersion = idsOrigCopy.getVariable(updatedVar);
	DataIdentifier ifVersion = idsIfCopy.getVariable(updatedVar);
	DataIdentifier elseVersion = idsElseCopy.getVariable(updatedVar);

	//data type handling: reject conditional data type change
	if( ifVersion != null && elseVersion != null ) //both branches exist
	{
	if (!ifVersion.getOutput().getDataType().equals(elseVersion.getOutput().getDataType())){
	raiseValidateError("IfStatementBlock has unsupported conditional data type change of variable '"+updatedVar+"' in if/else branch.", conditional);
	}
	}
	else if( origVersion !=null ) //only if branch exists
	{
	if (!ifVersion.getOutput().getDataType().equals(origVersion.getOutput().getDataType())){
	raiseValidateError("IfStatementBlock has unsupported conditional data type change of variable '"+updatedVar+"' in if branch.", conditional);
	}
	}

	//value type handling
	if (ifVersion != null && elseVersion != null && !ifVersion.getOutput().getValueType().equals(elseVersion.getOutput().getValueType())){
	LOG.warn(elseVersion.printWarningLocation() + "Variable " + elseVersion.getName() + " defined with different value type in if and else clause.");
	}
	}

	// handle constant variable propagation -- (IF UNION ELSE) MINUS updated vars

	//////////////////////////////////////////////////////////////////////////////////
	// handle constant variables
	// 1) (IF UNION ELSE) MINUS updated const vars
	// 2) reconcile updated const vars
	// a) IF updated const variables have same value and datatype in both if / else branch, THEN set updated size to updated size
	// b) ELSE leave out of reconciled set
	/////////////////////////////////////////////////////////////////////////////////

	HashMap<String,ConstIdentifier> recConstVars = new HashMap<String,ConstIdentifier>();

	// STEP 1: (IF UNION ELSE) MINUS updated vars
	for (Entry<String,ConstIdentifier> e : constVarsIfCopy.entrySet() ){
	String varName = e.getKey();
	if (!_updated.containsVariable(varName))
	recConstVars.put(varName, e.getValue());
	}
	for (Entry<String,ConstIdentifier> e : constVarsElseCopy.entrySet() ){
	String varName = e.getKey();
	if (!_updated.containsVariable(varName))
	recConstVars.put(varName, e.getValue());
	}


	// STEP 2: check that updated const values have in both if / else branches
	// a) same data type,
	// b) same value type (SCALAR),
	// c) same value
	for (String updatedVar : _updated.getVariableNames()){
	DataIdentifier ifVersion = idsIfCopy.getVariable(updatedVar);
	DataIdentifier elseVersion = idsElseCopy.getVariable(updatedVar);

	if (ifVersion != null && elseVersion != null
	&& ifVersion.getOutput().getDataType().equals(DataType.SCALAR)
	&& elseVersion.getOutput().getDataType().equals(DataType.SCALAR)
	&& ifVersion.getOutput().getValueType().equals(elseVersion.getOutput().getValueType()))
	{
	ConstIdentifier ifConstVersion = constVarsIfCopy.get(updatedVar);
	ConstIdentifier elseConstVersion = constVarsElseCopy.get(updatedVar);
	// IntIdentifier
	if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof IntIdentifier && elseConstVersion instanceof IntIdentifier){
	if ( ((IntIdentifier)ifConstVersion).getValue() == ((IntIdentifier) elseConstVersion).getValue() )
	recConstVars.put(updatedVar, ifConstVersion);
	}
	// DoubleIdentifier
	else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof DoubleIdentifier && elseConstVersion instanceof DoubleIdentifier){
	if ( ((DoubleIdentifier)ifConstVersion).getValue() == ((DoubleIdentifier) elseConstVersion).getValue() )
	recConstVars.put(updatedVar, ifConstVersion);
	}
	// Boolean
	else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof BooleanIdentifier && elseConstVersion instanceof BooleanIdentifier){
	if ( ((BooleanIdentifier)ifConstVersion).getValue() == ((BooleanIdentifier) elseConstVersion).getValue() )
	recConstVars.put(updatedVar, ifConstVersion);
	}

	// String
	else if (ifConstVersion != null && elseConstVersion != null && ifConstVersion instanceof StringIdentifier && elseConstVersion instanceof StringIdentifier){
	if ( ((StringIdentifier)ifConstVersion).getValue().equals(((StringIdentifier) elseConstVersion).getValue()) )
	recConstVars.put(updatedVar, ifConstVersion);
	}
	}
	}

	//////////////////////////////////////////////////////////////////////////////////
	// handle DataIdentifier variables
	// 1) (IF UNION ELSE) MINUS updated vars
	// 2) reconcile size updated variables
	// a) IF updated variables have same size in both if / else branch, THEN set updated size to updated size
	// b) ELSE set size updated to (-1,-1)
	// 3) add updated vars to reconciled set
	/////////////////////////////////////////////////////////////////////////////////

	// STEP 1: (IF UNION ELSE) MINUS updated vars
	VariableSet recVars = new VariableSet();

	for (String varName : idsIfCopy.getVariableNames()){
	if (!_updated.containsVariable(varName))
	recVars.addVariable(varName,idsIfCopy.getVariable(varName));
	}
	for (String varName : idsElseCopy.getVariableNames()){
	if (!_updated.containsVariable(varName))
	recVars.addVariable(varName,idsElseCopy.getVariable(varName));
	}

	// STEP 2: reconcile size of updated variables
	for (String updatedVar : _updated.getVariableNames()){
	DataIdentifier ifVersion = idsIfCopy.getVariable(updatedVar);
	DataIdentifier elseVersion = idsElseCopy.getVariable(updatedVar);
	DataIdentifier origVersion = idsOrigCopy.getVariable(updatedVar);

	if (ifVersion != null && elseVersion != null) {
	long updatedDim1 = -1, updatedDim2 = -1;
	long updatedNnz = -1;

	long ifVersionDim1 = (ifVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)ifVersion).getOrigDim1() : ifVersion.getDim1();
	long elseVersionDim1 = (elseVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)elseVersion).getOrigDim1() : elseVersion.getDim1();

	long ifVersionDim2 = (ifVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)ifVersion).getOrigDim2() : ifVersion.getDim2();
	long elseVersionDim2 = (elseVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)elseVersion).getOrigDim2() : elseVersion.getDim2();

	if( ifVersionDim1 == elseVersionDim1 ){
	updatedDim1 = ifVersionDim1;
	}
	if( ifVersionDim2 == elseVersionDim2 ){
	updatedDim2 = ifVersionDim2;
	}


	//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
	//if( ifVersion.getNnz() == elseVersion.getNnz() ){
	// updatedNnz = ifVersion.getNnz();
	//}

	// add reconsiled version (deep copy of ifVersion, cast as DataIdentifier)
	DataIdentifier recVersion = new DataIdentifier(ifVersion);
	recVersion.setDimensions(updatedDim1, updatedDim2);
	recVersion.setNnz(updatedNnz);
	recVars.addVariable(updatedVar, recVersion);
	}
	else {
	// CASE: defined only if branch
	DataIdentifier recVersion = null;
	if (ifVersion != null){
	// add reconciled version (deep copy of ifVersion, cast as DataIdentifier)
	recVersion = new DataIdentifier(ifVersion);
	recVars.addVariable(updatedVar, recVersion);
	}
	// CASE: defined only else branch
	else if (elseVersion != null){
	// add reconciled version (deep copy of elseVersion, cast as DataIdentifier)
	recVersion = new DataIdentifier(elseVersion);
	recVars.addVariable(updatedVar, recVersion);
	}
	// CASE: updated, but not in either if or else branch
	else {
	// add reconciled version (deep copy of elseVersion, cast as DataIdentifier)
	recVersion = new DataIdentifier(_updated.getVariable(updatedVar));
	recVars.addVariable(updatedVar, recVersion);
	}


	long updatedDim1 = -1, updatedDim2 = -1;
	long updatedNnz = -1;

	if( origVersion != null ) {
	long origVersionDim1 = (origVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)origVersion).getOrigDim1() : origVersion.getDim1();
	long recVersionDim1 = recVersion.getDim1(); //always DataIdentifier (see above)
	long origVersionDim2 = (origVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)origVersion).getOrigDim2() : origVersion.getDim2();
	long recVersionDim2 = recVersion.getDim2(); //always DataIdentifier (see above)

	if( origVersionDim1 == recVersionDim1 ){
	updatedDim1 = origVersionDim1;
	}
	if( origVersionDim2 == recVersionDim2 ){
	updatedDim2 = origVersionDim2;
	}
	//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
	//if( origVersion.getNnz() == recVersion.getNnz() ){
	// updatedNnz = recVersion.getNnz();
	//}
	}

	recVersion.setDimensions(updatedDim1, updatedDim2);
	recVersion.setNnz(updatedNnz);
	}
	}

	// propagate updated variables
	VariableSet allIdVars = new VariableSet(recVars);

	_constVarsIn.putAll(constVars);
	_constVarsOut.putAll(recConstVars);

	return allIdVars;
	}

	@Override
	public VariableSet initializeforwardLV(VariableSet activeInPassed)
	throws LanguageException
	{
	IfStatement ifstmt = (IfStatement)_statements.get(0);
	if (_statements.size() > 1){
	LOG.error(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
	throw new LanguageException(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
	}
	_read = new VariableSet();
	_gen = new VariableSet();
	_kill = new VariableSet();
	_warnSet = new VariableSet();

	///////////////////////////////////////////////////////////////////////
	// HANDLE PREDICATE
	///////////////////////////////////////////////////////////////////////
	_read.addVariables(ifstmt.getConditionalPredicate().variablesRead());
	_updated.addVariables(ifstmt.getConditionalPredicate().variablesUpdated());
	_gen.addVariables(ifstmt.getConditionalPredicate().variablesRead());

	///////////////////////////////////////////////////////////////////////
	// IF STATEMENT
	///////////////////////////////////////////////////////////////////////

	// initialize forward for each statement block in if body
	VariableSet ifCurrent = new VariableSet(activeInPassed);
	VariableSet genIfBody = new VariableSet();
	VariableSet killIfBody = new VariableSet();
	VariableSet updatedIfBody = new VariableSet();
	VariableSet readIfBody = new VariableSet();

	for (StatementBlock sb : ifstmt.getIfBody())
	{
	ifCurrent = sb.initializeforwardLV(ifCurrent);

	// for each generated variable in this block, check variable not killed
	// (assigned value) in prior statement block in ifstmt blody
	for (String varName : sb._gen.getVariableNames()){

	// IF the variable is NOT set in the while loop PRIOR to this stmt block,
	// THEN needs to be generated
	if (!killIfBody.getVariableNames().contains(varName)){
	genIfBody.addVariable(varName, sb._gen.getVariable(varName));
	}
	}

	readIfBody.addVariables(sb._read);
	updatedIfBody.addVariables(sb._updated);

	// only add kill variables for statement blocks guaranteed to execute
	if (!(sb instanceof WhileStatementBlock) && !(sb instanceof ForStatementBlock) ){
	killIfBody.addVariables(sb._kill);
	}
	}

	///////////////////////////////////////////////////////////////////////
	// ELSE STATEMENT
	///////////////////////////////////////////////////////////////////////

	// initialize forward for each statement block in if body
	VariableSet elseCurrent = new VariableSet(activeInPassed);
	VariableSet genElseBody = new VariableSet();
	VariableSet killElseBody = new VariableSet();
	VariableSet updatedElseBody = new VariableSet();
	VariableSet readElseBody = new VariableSet();

	// initialize forward for each statement block in else body
	for (StatementBlock sb : ifstmt.getElseBody())
	{
	elseCurrent = sb.initializeforwardLV(elseCurrent);

	// for each generated variable in this block, check variable not killed
	// (assigned value) in prior statement block in ifstmt blody
	for (String varName : sb._gen.getVariableNames()){

	// IF the variable is NOT set in the while loop PRIOR to this stmt block,
	// THEN needs to be generated
	if (!killElseBody.getVariableNames().contains(varName)){
	genElseBody.addVariable(varName, sb._gen.getVariable(varName));
	}
	}

	readElseBody.addVariables(sb._read);
	updatedElseBody.addVariables(sb._updated);

	// only add kill variables for statement blocks guaranteed to execute
	if (!(sb instanceof WhileStatementBlock) && !(sb instanceof ForStatementBlock) ){
	killElseBody.addVariables(sb._kill);
	}
	}

	///////////////////////////////////////////////////////////////////////
	// PERFORM RECONCILIATION
	///////////////////////////////////////////////////////////////////////

	// "conservative" read -- union of read sets for if and else path
	_read.addVariables(readIfBody);
	_read.addVariables(readElseBody);

	// "conservative" update -- union of updated
	_updated.addVariables(updatedIfBody);
	_updated.addVariables(updatedElseBody);

	// "conservative" gen -- union of gen
	_gen.addVariables(genIfBody);
	_gen.addVariables(genElseBody);

	// "conservative" kill -- kill set is intersection of if-kill and else-kill
	for ( String varName : killIfBody.getVariableNames()){
	if (killElseBody.containsVariable(varName)){
	_kill.addVariable(varName, killIfBody.getVariable(varName));
	}
	}

	// set preliminary "warn" set -- variables that if used later may cause runtime error
	// if the loop is not executed
	// warnSet = (updated MINUS (updatedIfBody INTERSECT updatedElseBody)) MINUS current
	for (String varName : _updated.getVariableNames()){
	if (!((updatedIfBody.containsVariable(varName) && updatedElseBody.containsVariable(varName))
	\|\| activeInPassed.containsVariable(varName))) {
	_warnSet.addVariable(varName, _updated.getVariable(varName));
	}
	}


	// set activeOut to (if body current UNION else body current) UNION updated
	_liveOut = new VariableSet();
	_liveOut.addVariables(ifCurrent);
	_liveOut.addVariables(elseCurrent);
	_liveOut.addVariables(_updated);
	return _liveOut;
	}

	@Override
	public VariableSet initializebackwardLV(VariableSet loPassed)
	throws LanguageException
	{
	IfStatement ifstmt = (IfStatement)_statements.get(0);
	if (_statements.size() > 1){
	LOG.error(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
	throw new LanguageException(ifstmt.printErrorLocation() + "IfStatementBlock should have only 1 statement (if statement)");
	}

	VariableSet currentLiveOutIf = new VariableSet(loPassed);
	VariableSet currentLiveOutElse = new VariableSet(loPassed);

	int numBlocks = ifstmt.getIfBody().size();
	for (int i = numBlocks - 1; i >= 0; i--){
	currentLiveOutIf = ifstmt.getIfBody().get(i).analyze(currentLiveOutIf);
	}

	numBlocks = ifstmt.getElseBody().size();
	for (int i = numBlocks - 1; i >= 0; i--){
	currentLiveOutElse = ifstmt.getElseBody().get(i).analyze(currentLiveOutElse);
	}

	// Any variable defined in either if-body or else-body is available for later use
	VariableSet bothPathsLiveOut = new VariableSet();
	bothPathsLiveOut.addVariables(currentLiveOutIf);
	bothPathsLiveOut.addVariables(currentLiveOutElse);

	return bothPathsLiveOut;

	}

	public void setPredicateHops(Hop hops) {
	_predicateHops = hops;
	}

	public ArrayList<Hop> get_hops() throws HopsException{

	if (_hops != null && _hops.size() > 0){
	LOG.error(this.printBlockErrorLocation() + "error there should be no HOPs in IfStatementBlock");
	throw new HopsException(this.printBlockErrorLocation() + "error there should be no HOPs in IfStatementBlock");
	}

	return _hops;
	}

	public Hop getPredicateHops(){
	return _predicateHops;
	}

	public Lop get_predicateLops() {
	return _predicateLops;
	}

	public void set_predicateLops(Lop predicateLops) {
	_predicateLops = predicateLops;
	}

	public VariableSet analyze(VariableSet loPassed) throws LanguageException{

	VariableSet predVars = ((IfStatement)_statements.get(0)).getConditionalPredicate().variablesRead();
	predVars.addVariables(((IfStatement)_statements.get(0)).getConditionalPredicate().variablesUpdated());

	VariableSet candidateLO = new VariableSet(loPassed);
	VariableSet origLiveOut = new VariableSet(_liveOut);

	_liveOut = new VariableSet();
	for (String name : candidateLO.getVariableNames()){
	if (origLiveOut.containsVariable(name)){
	_liveOut.addVariable(name, candidateLO.getVariable(name));
	}
	}

	initializebackwardLV(_liveOut);

	// set final warnSet: remove variables NOT in live out
	VariableSet finalWarnSet = new VariableSet();
	for (String varName : _warnSet.getVariableNames()){
	if (_liveOut.containsVariable(varName)){
	finalWarnSet.addVariable(varName,_warnSet.getVariable(varName));
	}
	}
	_warnSet = finalWarnSet;

	// for now just print the warn set
	for (String varName : _warnSet.getVariableNames()){
	LOG.warn(_warnSet.getVariable(varName).printWarningLocation() + "Initialization of " + varName + " depends on if-else execution");
	}

	//data flow equation: liveout = gen \cup (liveout - kill)
	_liveIn = new VariableSet();
	_liveIn.addVariables(_liveOut);
	_liveIn.removeVariables(_kill);
	_liveIn.addVariables(_gen);

	VariableSet liveInReturn = new VariableSet();
	liveInReturn.addVariables(_liveIn);
	return liveInReturn;
	}


	/////////
	// materialized hops recompilation flags
	////

	public void updatePredicateRecompilationFlag()
	throws HopsException
	{
	_requiresPredicateRecompile = ConfigurationManager.isDynamicRecompilation()
	&& Recompiler.requiresRecompilation(getPredicateHops());
	}

	public boolean requiresPredicateRecompilation()
	{
	return _requiresPredicateRecompile;
	}
	}