src/main/java/org/apache/sysml/parser/ForStatementBlock.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 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.runtime.instructions.cp.BooleanObject;
 import org.apache.sysml.runtime.instructions.cp.DoubleObject;


 public class ForStatementBlock extends StatementBlock
 {

 	protected Hop _fromHops        = null;
 	protected Hop _toHops          = null;
 	protected Hop _incrementHops   = null;

 	protected Lop _fromLops        = null;
 	protected Lop _toLops          = null;
 	protected Lop _incrementLops   = null;

 	protected boolean _requiresFromRecompile      = false;
 	protected boolean _requiresToRecompile        = false;
 	protected boolean _requiresIncrementRecompile = false;


 	public IterablePredicate getIterPredicate(){
 		return ((ForStatement)_statements.get(0)).getIterablePredicate();
 	}

 	@Override
 	public VariableSet validate(DMLProgram dmlProg, VariableSet ids, HashMap<String,ConstIdentifier> constVars, boolean conditional)
 		throws LanguageException, ParseException, IOException
 	{
 		if (_statements.size() > 1){
 			raiseValidateError("ForStatementBlock should have only 1 statement (for statement)", conditional);
 		}
 		ForStatement fs = (ForStatement) _statements.get(0);
 		IterablePredicate predicate = fs.getIterablePredicate();

 		// Record original size information before loop for ALL variables
 		// Will compare size / type info for these after loop completes
 		// Replace variables with changed size with unknown value
 		VariableSet origVarsBeforeBody = new VariableSet();
 		for (String key : ids.getVariableNames()){
 			DataIdentifier origId = ids.getVariable(key);
 			DataIdentifier copyId = new DataIdentifier(origId);
 			origVarsBeforeBody.addVariable(key, copyId);
 		}

 		//////////////////////////////////////////////////////////////////////////////
 		// FIRST PASS: process the predicate / statement blocks in the body of the for statement
 		///////////////////////////////////////////////////////////////////////////////

 		//remove updated vars from constants
 		for( String var : _updated.getVariableNames() )
 			if( constVars.containsKey( var ) )
 				constVars.remove( var );

 		predicate.validateExpression(ids.getVariables(), constVars, conditional);
 		ArrayList<StatementBlock> body = fs.getBody();

 		//perform constant propagation for ( from, to, incr )
 		//(e.g., useful for reducing false positives in parfor dependency analysis)
 		performConstantPropagation(constVars);

 		//validate body
 		_dmlProg = dmlProg;
 		for(StatementBlock sb : body)
 		{
 			ids = sb.validate(dmlProg, ids, constVars, true);
 			constVars = sb.getConstOut();
 		}

 		if (!body.isEmpty()){
 			_constVarsIn.putAll(body.get(0).getConstIn());
 			_constVarsOut.putAll(body.get(body.size()-1).getConstOut());
 		}

 		// for each updated variable
 		boolean revalidationRequired = false;
 		for (String key : _updated.getVariableNames())
 		{
 			DataIdentifier startVersion = origVarsBeforeBody.getVariable(key);
 			DataIdentifier endVersion   = ids.getVariable(key);

 			if (startVersion != null && endVersion != null)
 			{
 				//handle data type change (reject)
 				if (!startVersion.getOutput().getDataType().equals(endVersion.getOutput().getDataType())){
 					raiseValidateError("ForStatementBlock has unsupported conditional data type change of variable '"+key+"' in loop body.", conditional);
 				}

 				//handle size change
 				long startVersionDim1 	= (startVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)startVersion).getOrigDim1() : startVersion.getDim1();
 				long endVersionDim1		= (endVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)endVersion).getOrigDim1() : endVersion.getDim1();
 				long startVersionDim2 	= (startVersion instanceof IndexedIdentifier)   ? ((IndexedIdentifier)startVersion).getOrigDim2() : startVersion.getDim2();
 				long endVersionDim2		= (endVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)endVersion).getOrigDim2() : endVersion.getDim2();

 				boolean sizeUnchanged = ((startVersionDim1 == endVersionDim1) &&
 						                 (startVersionDim2 == endVersionDim2) );

 				//handle sparsity change
 				//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
 				//long startVersionNNZ 	= startVersion.getNnz();
 				//long endVersionNNZ    = endVersion.getNnz();
 				//boolean nnzUnchanged  = (startVersionNNZ == endVersionNNZ);
 				boolean nnzUnchanged = false;

 				// IF size has changed --
 				if (!sizeUnchanged || !nnzUnchanged){
 					revalidationRequired = true;
 					DataIdentifier recVersion = new DataIdentifier(endVersion);
 					if(!sizeUnchanged)
 						recVersion.setDimensions(-1, -1);
 					if(!nnzUnchanged)
 						recVersion.setNnz(-1);
 					origVarsBeforeBody.addVariable(key, recVersion);
 				}
 			}
 		}

 		// revalidation is required -- size was updated for at least 1 variable
 		if (revalidationRequired){

 			// update ids to the reconciled values
 			ids = origVarsBeforeBody;

 			//////////////////////////////////////////////////////////////////////////////
 			// SECOND PASS: process the predicate / statement blocks in the body of the for statement
 			///////////////////////////////////////////////////////////////////////////////

 			//remove updated vars from constants
 			for( String var : _updated.getVariableNames() )
 				if( constVars.containsKey( var ) )
 					constVars.remove( var );

 			//perform constant propagation for ( from, to, incr )
 			//(e.g., useful for reducing false positives in parfor dependency analysis)
 			performConstantPropagation(constVars);

 			predicate.validateExpression(ids.getVariables(), constVars, conditional);
 			body = fs.getBody();

 			//validate body
 			_dmlProg = dmlProg;
 			for(StatementBlock sb : body)
 			{
 				ids = sb.validate(dmlProg, ids, constVars, true);
 				constVars = sb.getConstOut();
 			}
 			if (!body.isEmpty()){
 				_constVarsIn.putAll(body.get(0).getConstIn());
 				_constVarsOut.putAll(body.get(body.size()-1).getConstOut());
 			}
 		}

 		return ids;
 	}

 	public VariableSet initializeforwardLV(VariableSet activeInPassed) throws LanguageException {

 		ForStatement fstmt = (ForStatement)_statements.get(0);
 		if (_statements.size() > 1){
 			LOG.error(_statements.get(0).printErrorLocation() + "ForStatementBlock should have only 1 statement (for statement)");
 			throw new LanguageException(_statements.get(0).printErrorLocation() + "ForStatementBlock should have only 1 statement (for statement)");
 		}

 		_read = new VariableSet();
 		_read.addVariables(fstmt.getIterablePredicate().variablesRead());
 		_updated.addVariables(fstmt.getIterablePredicate().variablesUpdated());

 		_gen = new VariableSet();
 		_gen.addVariables(fstmt.getIterablePredicate().variablesRead());

 		// add the iterVar from iterable predicate to kill set
 		_kill.addVariables(fstmt.getIterablePredicate().variablesUpdated());

 		VariableSet current = new VariableSet();
 		current.addVariables(activeInPassed);
 		current.addVariables(_updated);


 		for( StatementBlock sb : fstmt.getBody())
 		{
 			current = sb.initializeforwardLV(current);

 			// for each generated variable in this block, check variable not killed
 			// in prior statement block in while stmt 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 (!_kill.getVariableNames().contains(varName)){
 					_gen.addVariable(varName, sb._gen.getVariable(varName));
 				}
 			}

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

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

 		// 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 (!activeInPassed.containsVariable(varName)) {
 				_warnSet.addVariable(varName, _updated.getVariable(varName));
 			}
 		}

 		// activeOut includes variables from passed live in and updated in the while body
 		_liveOut = new VariableSet();
 		_liveOut.addVariables(current);
 		_liveOut.addVariables(_updated);
 		return _liveOut;
 	}

 	public VariableSet initializebackwardLV(VariableSet loPassed) throws LanguageException{

 		ForStatement fstmt = (ForStatement)_statements.get(0);

 		VariableSet lo = new VariableSet();
 		lo.addVariables(loPassed);

 		// calls analyze for each statement block in while stmt body
 		int numBlocks = fstmt.getBody().size();
 		for (int i = numBlocks - 1; i >= 0; i--){
 			lo = fstmt.getBody().get(i).analyze(lo);
 		}

 		VariableSet loReturn = new VariableSet();
 		loReturn.addVariables(lo);
 		return loReturn;

 	}

 	public ArrayList<Hop> get_hops() throws HopsException {

 		if (_hops != null && !_hops.isEmpty()){
 			LOG.error(this.printBlockErrorLocation() + "there should be no HOPs associated with the ForStatementBlock");
 			throw new HopsException(this.printBlockErrorLocation() + "there should be no HOPs associated with the ForStatementBlock");
 		}

 		return _hops;
 	}

 	public void setFromHops(Hop hops) { _fromHops = hops; }
 	public void setToHops(Hop hops) { _toHops = hops; }
 	public void setIncrementHops(Hop hops) { _incrementHops = hops; }

 	public Hop getFromHops()      { return _fromHops; }
 	public Hop getToHops()        { return _toHops; }
 	public Hop getIncrementHops() { return _incrementHops; }

 	public void setFromLops(Lop lops) {
 		_fromLops = lops;
 	}
 	public void setToLops(Lop lops) { _toLops = lops; }
 	public void setIncrementLops(Lop lops) { _incrementLops = lops; }

 	public Lop getFromLops()      { return _fromLops; }
 	public Lop getToLops()        { return _toLops; }
 	public Lop getIncrementLops() { return _incrementLops; }


 	public VariableSet analyze(VariableSet loPassed) throws LanguageException{

 		VariableSet predVars = new VariableSet();
 		IterablePredicate ip = ((ForStatement)_statements.get(0)).getIterablePredicate();

 		predVars.addVariables(ip.variablesRead());
 		predVars.addVariables(ip.variablesUpdated());

 		VariableSet candidateLO = new VariableSet();
 		candidateLO.addVariables(loPassed);
 		candidateLO.addVariables(_gen);
 		candidateLO.addVariables(predVars);

 		VariableSet origLiveOut = new VariableSet();
 		origLiveOut.addVariables(_liveOut);
 		origLiveOut.addVariables(predVars);
 		origLiveOut.addVariables(_gen);

 		_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()) {
 			if( !ip.getIterVar().getName().equals( varName)  )
 				LOG.warn(_warnSet.getVariable(varName).printWarningLocation() + "Initialization of " + varName + " depends on for execution");
 		}

 		// Cannot remove kill variables
 		_liveIn = new VariableSet();
 		_liveIn.addVariables(_liveOut);
 		_liveIn.addVariables(_gen);

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

 		return liveInReturn;
 	}


 	public void performConstantPropagation(HashMap<String, ConstIdentifier> currConstVars)
 		throws LanguageException
 	{
 		IterablePredicate ip = getIterPredicate();

 		// handle replacement in from expression
 		Expression replacementExpr = replaceConstantVar(ip.getFromExpr(), currConstVars);
 		if (replacementExpr != null)
 			ip.setFromExpr(replacementExpr);

 		// handle replacement in to expression
 		replacementExpr = replaceConstantVar(ip.getToExpr(), currConstVars);
 		if (replacementExpr != null)
 			ip.setToExpr(replacementExpr);

 		// handle replacement in increment expression
 		replacementExpr = replaceConstantVar(ip.getIncrementExpr(), currConstVars);
 		if (replacementExpr != null)
 			ip.setIncrementExpr(replacementExpr);
 	}

 	private Expression replaceConstantVar(Expression expr, HashMap<String, ConstIdentifier> currConstVars)
 	{
 		Expression ret = null;

 		if (expr instanceof DataIdentifier && !(expr instanceof IndexedIdentifier))
 		{
 			// check if the DataIdentifier variable is a ConstIdentifier
 			String identifierName = ((DataIdentifier)expr).getName();
 			if (currConstVars.containsKey(identifierName))
 			{
 				ConstIdentifier constValue = currConstVars.get(identifierName);
 				//AUTO CASTING (using runtime operations for consistency)
 				switch( constValue.getValueType() )
 				{
 					case DOUBLE:
 						ret = new IntIdentifier(new DoubleObject(((DoubleIdentifier)constValue).getValue()).getLongValue(),
 								expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
 								expr.getEndLine(), expr.getEndColumn());
 						break;
 					case INT:
 						ret = new IntIdentifier((IntIdentifier)constValue,
 								expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
 								expr.getEndLine(), expr.getEndColumn());
 						break;
 					case BOOLEAN:
 						ret = new IntIdentifier(new BooleanObject(((BooleanIdentifier)constValue).getValue()).getLongValue(),
 								expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
 								expr.getEndLine(), expr.getEndColumn());
 						break;

 					default:
 						//do nothing
 				}
 			}
 		}
 		else
 		{
 			//do nothing, cannot replace full expression
 			ret = expr;
 		}

 		return ret;
 	}

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

 	public void updatePredicateRecompilationFlags()
 		throws HopsException
 	{
 		if( ConfigurationManager.isDynamicRecompilation() ) {
 			_requiresFromRecompile = Recompiler.requiresRecompilation(getFromHops());
 			_requiresToRecompile = Recompiler.requiresRecompilation(getToHops());
 			_requiresIncrementRecompile = Recompiler.requiresRecompilation(getIncrementHops());
 		}
 	}

 	public boolean requiresFromRecompilation()
 	{
 		return _requiresFromRecompile;
 	}

 	public boolean requiresToRecompilation()
 	{
 		return _requiresToRecompile;
 	}

 	public boolean requiresIncrementRecompilation()
 	{
 		return _requiresIncrementRecompile;
 	}

 }
	/*
	* 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 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.runtime.instructions.cp.BooleanObject;
	import org.apache.sysml.runtime.instructions.cp.DoubleObject;


	public class ForStatementBlock extends StatementBlock
	{

	protected Hop _fromHops = null;
	protected Hop _toHops = null;
	protected Hop _incrementHops = null;

	protected Lop _fromLops = null;
	protected Lop _toLops = null;
	protected Lop _incrementLops = null;

	protected boolean _requiresFromRecompile = false;
	protected boolean _requiresToRecompile = false;
	protected boolean _requiresIncrementRecompile = false;


	public IterablePredicate getIterPredicate(){
	return ((ForStatement)_statements.get(0)).getIterablePredicate();
	}

	@Override
	public VariableSet validate(DMLProgram dmlProg, VariableSet ids, HashMap<String,ConstIdentifier> constVars, boolean conditional)
	throws LanguageException, ParseException, IOException
	{
	if (_statements.size() > 1){
	raiseValidateError("ForStatementBlock should have only 1 statement (for statement)", conditional);
	}
	ForStatement fs = (ForStatement) _statements.get(0);
	IterablePredicate predicate = fs.getIterablePredicate();

	// Record original size information before loop for ALL variables
	// Will compare size / type info for these after loop completes
	// Replace variables with changed size with unknown value
	VariableSet origVarsBeforeBody = new VariableSet();
	for (String key : ids.getVariableNames()){
	DataIdentifier origId = ids.getVariable(key);
	DataIdentifier copyId = new DataIdentifier(origId);
	origVarsBeforeBody.addVariable(key, copyId);
	}

	//////////////////////////////////////////////////////////////////////////////
	// FIRST PASS: process the predicate / statement blocks in the body of the for statement
	///////////////////////////////////////////////////////////////////////////////

	//remove updated vars from constants
	for( String var : _updated.getVariableNames() )
	if( constVars.containsKey( var ) )
	constVars.remove( var );

	predicate.validateExpression(ids.getVariables(), constVars, conditional);
	ArrayList<StatementBlock> body = fs.getBody();

	//perform constant propagation for ( from, to, incr )
	//(e.g., useful for reducing false positives in parfor dependency analysis)
	performConstantPropagation(constVars);

	//validate body
	_dmlProg = dmlProg;
	for(StatementBlock sb : body)
	{
	ids = sb.validate(dmlProg, ids, constVars, true);
	constVars = sb.getConstOut();
	}

	if (!body.isEmpty()){
	_constVarsIn.putAll(body.get(0).getConstIn());
	_constVarsOut.putAll(body.get(body.size()-1).getConstOut());
	}

	// for each updated variable
	boolean revalidationRequired = false;
	for (String key : _updated.getVariableNames())
	{
	DataIdentifier startVersion = origVarsBeforeBody.getVariable(key);
	DataIdentifier endVersion = ids.getVariable(key);

	if (startVersion != null && endVersion != null)
	{
	//handle data type change (reject)
	if (!startVersion.getOutput().getDataType().equals(endVersion.getOutput().getDataType())){
	raiseValidateError("ForStatementBlock has unsupported conditional data type change of variable '"+key+"' in loop body.", conditional);
	}

	//handle size change
	long startVersionDim1 = (startVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)startVersion).getOrigDim1() : startVersion.getDim1();
	long endVersionDim1 = (endVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)endVersion).getOrigDim1() : endVersion.getDim1();
	long startVersionDim2 = (startVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)startVersion).getOrigDim2() : startVersion.getDim2();
	long endVersionDim2 = (endVersion instanceof IndexedIdentifier) ? ((IndexedIdentifier)endVersion).getOrigDim2() : endVersion.getDim2();

	boolean sizeUnchanged = ((startVersionDim1 == endVersionDim1) &&
	(startVersionDim2 == endVersionDim2) );

	//handle sparsity change
	//NOTE: nnz not propagated via validate, and hence, we conservatively assume that nnz have been changed.
	//long startVersionNNZ = startVersion.getNnz();
	//long endVersionNNZ = endVersion.getNnz();
	//boolean nnzUnchanged = (startVersionNNZ == endVersionNNZ);
	boolean nnzUnchanged = false;

	// IF size has changed --
	if (!sizeUnchanged \|\| !nnzUnchanged){
	revalidationRequired = true;
	DataIdentifier recVersion = new DataIdentifier(endVersion);
	if(!sizeUnchanged)
	recVersion.setDimensions(-1, -1);
	if(!nnzUnchanged)
	recVersion.setNnz(-1);
	origVarsBeforeBody.addVariable(key, recVersion);
	}
	}
	}

	// revalidation is required -- size was updated for at least 1 variable
	if (revalidationRequired){

	// update ids to the reconciled values
	ids = origVarsBeforeBody;

	//////////////////////////////////////////////////////////////////////////////
	// SECOND PASS: process the predicate / statement blocks in the body of the for statement
	///////////////////////////////////////////////////////////////////////////////

	//remove updated vars from constants
	for( String var : _updated.getVariableNames() )
	if( constVars.containsKey( var ) )
	constVars.remove( var );

	//perform constant propagation for ( from, to, incr )
	//(e.g., useful for reducing false positives in parfor dependency analysis)
	performConstantPropagation(constVars);

	predicate.validateExpression(ids.getVariables(), constVars, conditional);
	body = fs.getBody();

	//validate body
	_dmlProg = dmlProg;
	for(StatementBlock sb : body)
	{
	ids = sb.validate(dmlProg, ids, constVars, true);
	constVars = sb.getConstOut();
	}
	if (!body.isEmpty()){
	_constVarsIn.putAll(body.get(0).getConstIn());
	_constVarsOut.putAll(body.get(body.size()-1).getConstOut());
	}
	}

	return ids;
	}

	public VariableSet initializeforwardLV(VariableSet activeInPassed) throws LanguageException {

	ForStatement fstmt = (ForStatement)_statements.get(0);
	if (_statements.size() > 1){
	LOG.error(_statements.get(0).printErrorLocation() + "ForStatementBlock should have only 1 statement (for statement)");
	throw new LanguageException(_statements.get(0).printErrorLocation() + "ForStatementBlock should have only 1 statement (for statement)");
	}

	_read = new VariableSet();
	_read.addVariables(fstmt.getIterablePredicate().variablesRead());
	_updated.addVariables(fstmt.getIterablePredicate().variablesUpdated());

	_gen = new VariableSet();
	_gen.addVariables(fstmt.getIterablePredicate().variablesRead());

	// add the iterVar from iterable predicate to kill set
	_kill.addVariables(fstmt.getIterablePredicate().variablesUpdated());

	VariableSet current = new VariableSet();
	current.addVariables(activeInPassed);
	current.addVariables(_updated);


	for( StatementBlock sb : fstmt.getBody())
	{
	current = sb.initializeforwardLV(current);

	// for each generated variable in this block, check variable not killed
	// in prior statement block in while stmt 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 (!_kill.getVariableNames().contains(varName)){
	_gen.addVariable(varName, sb._gen.getVariable(varName));
	}
	}

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

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

	// 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 (!activeInPassed.containsVariable(varName)) {
	_warnSet.addVariable(varName, _updated.getVariable(varName));
	}
	}

	// activeOut includes variables from passed live in and updated in the while body
	_liveOut = new VariableSet();
	_liveOut.addVariables(current);
	_liveOut.addVariables(_updated);
	return _liveOut;
	}

	public VariableSet initializebackwardLV(VariableSet loPassed) throws LanguageException{

	ForStatement fstmt = (ForStatement)_statements.get(0);

	VariableSet lo = new VariableSet();
	lo.addVariables(loPassed);

	// calls analyze for each statement block in while stmt body
	int numBlocks = fstmt.getBody().size();
	for (int i = numBlocks - 1; i >= 0; i--){
	lo = fstmt.getBody().get(i).analyze(lo);
	}

	VariableSet loReturn = new VariableSet();
	loReturn.addVariables(lo);
	return loReturn;

	}

	public ArrayList<Hop> get_hops() throws HopsException {

	if (_hops != null && !_hops.isEmpty()){
	LOG.error(this.printBlockErrorLocation() + "there should be no HOPs associated with the ForStatementBlock");
	throw new HopsException(this.printBlockErrorLocation() + "there should be no HOPs associated with the ForStatementBlock");
	}

	return _hops;
	}

	public void setFromHops(Hop hops) { _fromHops = hops; }
	public void setToHops(Hop hops) { _toHops = hops; }
	public void setIncrementHops(Hop hops) { _incrementHops = hops; }

	public Hop getFromHops() { return _fromHops; }
	public Hop getToHops() { return _toHops; }
	public Hop getIncrementHops() { return _incrementHops; }

	public void setFromLops(Lop lops) {
	_fromLops = lops;
	}
	public void setToLops(Lop lops) { _toLops = lops; }
	public void setIncrementLops(Lop lops) { _incrementLops = lops; }

	public Lop getFromLops() { return _fromLops; }
	public Lop getToLops() { return _toLops; }
	public Lop getIncrementLops() { return _incrementLops; }



	public VariableSet analyze(VariableSet loPassed) throws LanguageException{

	VariableSet predVars = new VariableSet();
	IterablePredicate ip = ((ForStatement)_statements.get(0)).getIterablePredicate();

	predVars.addVariables(ip.variablesRead());
	predVars.addVariables(ip.variablesUpdated());

	VariableSet candidateLO = new VariableSet();
	candidateLO.addVariables(loPassed);
	candidateLO.addVariables(_gen);
	candidateLO.addVariables(predVars);

	VariableSet origLiveOut = new VariableSet();
	origLiveOut.addVariables(_liveOut);
	origLiveOut.addVariables(predVars);
	origLiveOut.addVariables(_gen);

	_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()) {
	if( !ip.getIterVar().getName().equals( varName) )
	LOG.warn(_warnSet.getVariable(varName).printWarningLocation() + "Initialization of " + varName + " depends on for execution");
	}

	// Cannot remove kill variables
	_liveIn = new VariableSet();
	_liveIn.addVariables(_liveOut);
	_liveIn.addVariables(_gen);

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

	return liveInReturn;
	}


	public void performConstantPropagation(HashMap<String, ConstIdentifier> currConstVars)
	throws LanguageException
	{
	IterablePredicate ip = getIterPredicate();

	// handle replacement in from expression
	Expression replacementExpr = replaceConstantVar(ip.getFromExpr(), currConstVars);
	if (replacementExpr != null)
	ip.setFromExpr(replacementExpr);

	// handle replacement in to expression
	replacementExpr = replaceConstantVar(ip.getToExpr(), currConstVars);
	if (replacementExpr != null)
	ip.setToExpr(replacementExpr);

	// handle replacement in increment expression
	replacementExpr = replaceConstantVar(ip.getIncrementExpr(), currConstVars);
	if (replacementExpr != null)
	ip.setIncrementExpr(replacementExpr);
	}

	private Expression replaceConstantVar(Expression expr, HashMap<String, ConstIdentifier> currConstVars)
	{
	Expression ret = null;

	if (expr instanceof DataIdentifier && !(expr instanceof IndexedIdentifier))
	{
	// check if the DataIdentifier variable is a ConstIdentifier
	String identifierName = ((DataIdentifier)expr).getName();
	if (currConstVars.containsKey(identifierName))
	{
	ConstIdentifier constValue = currConstVars.get(identifierName);
	//AUTO CASTING (using runtime operations for consistency)
	switch( constValue.getValueType() )
	{
	case DOUBLE:
	ret = new IntIdentifier(new DoubleObject(((DoubleIdentifier)constValue).getValue()).getLongValue(),
	expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
	expr.getEndLine(), expr.getEndColumn());
	break;
	case INT:
	ret = new IntIdentifier((IntIdentifier)constValue,
	expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
	expr.getEndLine(), expr.getEndColumn());
	break;
	case BOOLEAN:
	ret = new IntIdentifier(new BooleanObject(((BooleanIdentifier)constValue).getValue()).getLongValue(),
	expr.getFilename(), expr.getBeginLine(), expr.getBeginColumn(),
	expr.getEndLine(), expr.getEndColumn());
	break;

	default:
	//do nothing
	}
	}
	}
	else
	{
	//do nothing, cannot replace full expression
	ret = expr;
	}

	return ret;
	}

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

	public void updatePredicateRecompilationFlags()
	throws HopsException
	{
	if( ConfigurationManager.isDynamicRecompilation() ) {
	_requiresFromRecompile = Recompiler.requiresRecompilation(getFromHops());
	_requiresToRecompile = Recompiler.requiresRecompilation(getToHops());
	_requiresIncrementRecompile = Recompiler.requiresRecompilation(getIncrementHops());
	}
	}

	public boolean requiresFromRecompilation()
	{
	return _requiresFromRecompile;
	}

	public boolean requiresToRecompilation()
	{
	return _requiresToRecompile;
	}

	public boolean requiresIncrementRecompilation()
	{
	return _requiresIncrementRecompile;
	}

	}