/*******************************************************************
* Function: ArrayIndexAnalysis::findAllMatrixIndexSymbols
* Purpose : Find all indices used in the current function
* Initial : Nurudeen A. Lameed on July 21, 2009
********************************************************************
Revisions and bug fixes:
*/
void ArrayIndexAnalysis::findAllMatrixIndexSymbols(const StmtSequence* pFuncBody)
{
// get the sequence of statements
const StmtSequence::StmtVector& stmts = pFuncBody->getStatements();
// look for statements with a parameterized expression
for (StmtSequence::StmtVector::const_iterator it = stmts.begin(),
iEnd = stmts.end(); it != iEnd; ++it)
{
Statement* pStmt = *it;
switch( pStmt->getStmtType() )
{
case Statement::ASSIGN:
{
AssignStmt* aStmt = dynamic_cast<AssignStmt*>(pStmt);
Expression::ExprVector lhs = aStmt->getLeftExprs();
for (size_t i=0, size = lhs.size(); i < size; ++i)
{
fillSets(lhs[i]);
}
fillSets(aStmt->getRightExpr());
}
break;
case Statement::EXPR:
{
ExprStmt* eStmt = dynamic_cast<ExprStmt*>(pStmt);
fillSets(eStmt->getExpression());
}
break;
case Statement::IF_ELSE:
{
// convert into an if type
IfElseStmt* ifstmt = (IfElseStmt*)pStmt;
// get all symbols
findAllMatrixIndexSymbols(ifstmt->getIfBlock());
findAllMatrixIndexSymbols(ifstmt->getElseBlock());
}
break;
case Statement::LOOP:
{
LoopStmt* lstmt = (LoopStmt*)pStmt;
// loop initialization
StmtSequence* initSeq = lstmt->getInitSeq();
findAllMatrixIndexSymbols(initSeq);
// loop test
StmtSequence* testSeq = lstmt->getTestSeq();
findAllMatrixIndexSymbols(testSeq);
// loop body
StmtSequence* sBodySeq = lstmt->getBodySeq();
findAllMatrixIndexSymbols(sBodySeq);
// loop increment statement
StmtSequence* incrSeq = lstmt->getIncrSeq();
findAllMatrixIndexSymbols(incrSeq);
}
default:
{
}
}
}
}
/*******************************************************************
* Function: ArrayIndexAnalysis::fillSets
* Purpose : Fill data structures for the flow analysis
* Initial : Nurudeen A. Lameed on July 21, 2009
********************************************************************
Revisions and bug fixes:
*/
void ArrayIndexAnalysis::fillSets(const Expression *expr)
{
// what kind of expression?
switch (expr->getExprType())
{
case Expression::PARAM:
{
const ParamExpr* paramExpr = dynamic_cast<const ParamExpr*>(expr);
// matrix/array symbol
SymbolExpr* mSymbol = paramExpr->getSymExpr();
// assume for now, all parameterized expression symbols are matrices ...
// collect in one place all array/matrices symbols
allMatrixSymbols.insert(mSymbol);
const Expression::ExprVector& args = paramExpr->getArguments();
// insert the indexes
for (size_t j = 0, size = args.size(); j < size; ++j)
{
if ( args[j]->getExprType() == Expression::SYMBOL ||
args[j]->getExprType() == Expression::INT_CONST )
{
IndexKey iKey = {args[j], j};
if (!isIndex(iKey))
{
// new matrix, insert it.
Expression::SymbolSet s;
s.insert(mSymbol);
indexMatMap[iKey] = s;
}
else
{
indexMatMap[iKey].insert(mSymbol);
}
}
}
}
break;
case Expression::BINARY_OP:
{
const BinaryOpExpr* bOp = dynamic_cast<const BinaryOpExpr*>(expr);
fillSets(bOp->getLeftExpr());
fillSets(bOp->getRightExpr());
}
break;
case Expression::UNARY_OP:
{
const UnaryOpExpr* uOp = dynamic_cast<const UnaryOpExpr*>(expr);
fillSets(uOp->getOperand());
}
break;
default: // do nothing
{
}
}
}
void ImporterManager::readFile() {
if (format.parse()) {
initializeImporters();
while (!sepReader.eof()&&!intReader.eof()&&!doubleReader.eof()&&!longReader.eof()&&!floatReader.eof()) {
switch (format.grabTksAt(tokenpos)) {
case -2:
sepReader.read();
tokenpos = (tokenpos + 1) % tokensize;
break;
case -1:
{
searchColumSeparator();
uint64_t tp = sepReader.tell();
intReader.seek(tp);
doubleReader.seek(tp);
longReader.seek(tp);
floatReader.seek(tp);
tokenpos = (tokenpos + 1) % tokensize;
break;
}
case 0:
{
importers[importer]->addTerm();
uint64_t tp = intReader.tell();
sepReader.seek(tp);
doubleReader.seek(tp);
longReader.seek(tp);
floatReader.seek(tp);
tokenpos = (tokenpos + 1) % tokensize;
importer = (importer + 1) % maxImporters;
break;
}
case 1:
{
importers[importer]->addTerm();
uint64_t tp = doubleReader.tell();
intReader.seek(tp);
sepReader.seek(tp);
longReader.seek(tp);
floatReader.seek(tp);
tokenpos = (tokenpos + 1) % tokensize;
importer = (importer + 1) % maxImporters;
break;
}
case 2:
{
importers[importer]->addTerm();
uint64_t tp = longReader.tell();
intReader.seek(tp);
doubleReader.seek(tp);
sepReader.seek(tp);
floatReader.seek(tp);
tokenpos = (tokenpos + 1) % tokensize;
importer = (importer + 1) % maxImporters;
break;
}
case 3:
{
importers[importer]->addTerm();
uint64_t tp = floatReader.tell();
intReader.seek(tp);
doubleReader.seek(tp);
longReader.seek(tp);
sepReader.seek(tp);
tokenpos = (tokenpos + 1) % tokensize;
importer = (importer + 1) % maxImporters;
break;
}
}
}
}
fillSets();
closeReaders();
clearImporters();
}
