Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3c1032bfd0c00ccea056f4afbc667b77d91bb01b
SAPFOR/projects/dvm_svn/fdvm/trunk/sageExample/SwapFors.cpp
Alexander 3c1032bfd0 moved to dvm_svn
2025-03-25 21:09:33 +03:00

1566 lines
31 KiB
C++
Raw Blame History

#include <cstdio>
#include <cstring>
#include <fstream>
#include <iostream>
#include <cstdlib>
#define IN_ANAL_
#include "dvm.h"
#undef IN_ANAL_
#include "aks_structs.h"
char *fin_name = 0;
SgFile *current_file;
#define DEBUG true
#define DEBUG_LV2 false
#define DEBUG_LV3 false
#if 0
std::ostream &out = std::cout;
#else
std::ofstream out("log_swap.txt");
#endif
using namespace std;
void PrintVars(SgExpression *node, int LR, int d)
{
if (LR == 0)
out << "variant LHS " << node->variant() << " d = " << d << endl;
else
out << "variant RHS " << node->variant() << " d = " << d << endl;
if (node->lhs())
PrintVars(node->lhs(), 0, d + 1);
if(node->rhs())
PrintVars(node->rhs(), 1, d + 1);
}
SageSymbols* SearchVarRef(SgExpression *expr, SageSymbols *smbl)
{
SageSymbols *newS;
if(expr->variant() == VAR_REF)
{
SageSymbols *tempS = smbl;
bool flag = true;
while(tempS)
{
if(expr->symbol() == tempS->symb)
{
flag = !flag;
break;
}
tempS = tempS->next;
}
if(flag)
{
newS = new SageSymbols();
newS->symb = expr->symbol();
newS->len = -1;
newS->next = smbl;
}
else
newS = smbl;
}
else
newS = smbl;
SgExpression *L = expr->lhs();
SgExpression *R = expr->rhs();
if(L)
newS = SearchVarRef(L,newS);
if(R)
newS = SearchVarRef(R,newS);
return newS;
}
bool CheckSpecOp(SgExpression *expr, int Op)
{
if(expr)
{
if(expr->variant() == Op)
return false;
else
return CheckSpecOp(expr->lhs(),Op) && CheckSpecOp(expr->rhs(),Op);
}
else
return true;
}
bool CheckExpr(SgExpression *expr)
{
if(expr)
{
switch(expr->variant())
{
case MULT_OP:
return CheckSpecOp(expr->lhs(), VAR_REF) || CheckSpecOp(expr->rhs(), VAR_REF);
case MOD_OP:
return CheckSpecOp(expr->lhs(), VAR_REF) && CheckSpecOp(expr->rhs(), VAR_REF);
case ARRAY_REF:
return false;
default:
return CheckExpr(expr->lhs()) && CheckExpr(expr->rhs());
}
}
else
return true;
}
int CountExpr(SgExpression *, int);
int GetConstRef(SgExpression *expr)
{
SgExpression *temp;
SgConstantSymb *sc = isSgConstantSymb(expr->symbol());
temp = &(sc->constantValue()->copy());
return CountExpr(temp, 0);
}
int CountExpr(SgExpression *expr, int rewrite)
{
switch(expr->variant())
{
case VAR_REF:
return rewrite;
case CONST_REF:
return GetConstRef(expr);
case INT_VAL:
return expr->valueInteger();
case ADD_OP:
return CountExpr(expr->lhs(),rewrite) + CountExpr(expr->rhs(),rewrite);
case MULT_OP:
return CountExpr(expr->lhs(),rewrite) * CountExpr(expr->rhs(),rewrite);
case SUBT_OP:
return CountExpr(expr->lhs(),rewrite) - CountExpr(expr->rhs(),rewrite);
case MOD_OP:
return CountExpr(expr->lhs(),rewrite) % CountExpr(expr->rhs(),rewrite);
case MINUS_OP:
return -CountExpr(expr->lhs(),rewrite);
case DIV_OP:
return CountExpr(expr->lhs(),rewrite) / CountExpr(expr->rhs(),rewrite);
case DDOT:
{
int L = 1;
int R = 1;
if(expr->lhs())
L = CountExpr(expr->lhs(), 0);
if(expr->rhs())
R = CountExpr(expr->rhs(), 0);
return abs(L - R);
}
case STAR_RANGE:
if(DEBUG)
out << " Error: unknown operator * in expr" << endl;
return 1;
case NULL:
if(DEBUG)
out << " unknown expr with NULL-end" << endl;
break;
default:
if(DEBUG)
out << " unknown operand with variant: " << expr->variant()<< endl;
break;
}
return -1;
}
int CountLen(SgExpression *expr, int step)
{
int ret_val = 0;
int a = CountExpr(expr,0);
int b = CountExpr(expr,step);
ret_val = abs(a - b);
return ret_val;
}
SageArrayIdxs* AnalizeRef(SgExpression *expr, SageArrayIdxs *arr, int step)
{
SgExpression *count = expr;
int p = 0;
while(count)
{
p++;
count = count->rhs();
}
arr->dim = p;
arr->symb = new SageSymbols*[p];
p = 0;
while(expr)
{
SageSymbols *allSymb = new SageSymbols();
allSymb->symb = NULL;
allSymb->next = NULL;
allSymb->len = 0;
allSymb = SearchVarRef(expr->lhs(),allSymb);
arr->symb[p] = allSymb;
if(allSymb->next)
if(allSymb->next->symb == NULL && CheckExpr(expr->lhs()))
{
arr->symb[p]->len = CountLen(expr->lhs(), step);
arr->symb[p]->next = NULL;
}
else
{
while (allSymb->next->len != 0)
allSymb = allSymb->next;
allSymb->next = NULL;
}
expr = expr->rhs();
p++;
}
return arr;
}
SageArrayIdxs* AnalizeAssignStat(SgExpression *expr, SageArrayIdxs *retval, int read_write, int step)
{
switch(expr->variant())
{
case ARRAY_REF:
{
SageArrayIdxs *outRef = new SageArrayIdxs();
outRef->array_expr = expr;
outRef = AnalizeRef(expr->lhs(),outRef,step);
outRef->next = NULL;
outRef->read_write = read_write;
retval->next = outRef;
return retval->next;
break;
}
default:
break;
}
SgExpression *R = expr->rhs();
SgExpression *L = expr->lhs();
if(R)
{
retval = AnalizeAssignStat(R, retval, read_write, step);
}
if(L)
{
retval = AnalizeAssignStat(L, retval, read_write, step);
}
return retval;
}
void PrintStr(SageArrayIdxs *p)
{
out << p->dim << endl;
}
SageArrayIdxs* Analize(SgForStmt *loop, int count)
{
SageArrayIdxs *q = new SageArrayIdxs();
SageArrayIdxs *AllRef = q;
int step = 1;
if(loop->step())
{
step = loop->step()->valueInteger();
}
SgStatement *finish = loop->childList1(count - 1);
SgStatement *temp = loop->childList1(0);
while(true)
{
switch(temp->variant())
{
case ASSIGN_STAT:
if(DEBUG)
out << " ASSIGN_STAT in line: " << temp->lineNumber() << " ";
q = AnalizeAssignStat(temp->expr(0),q,0, step);
q = AnalizeAssignStat(temp->expr(1),q,1, step);
if(DEBUG)
out << " success" << endl;
break;
case IF_NODE:
if(DEBUG)
out << " IF_NODE condition in line: " << temp->lineNumber() << " ";
q = AnalizeAssignStat(temp->expr(0),q,1, step);
if(DEBUG)
out << " success" << endl;
case ELSEIF_NODE:
if(DEBUG)
out << " ELSEIF_NODE condition in line: " << temp->lineNumber() << " ";
q = AnalizeAssignStat(temp->expr(0),q,1, step);
if(DEBUG)
out << " success" << endl;
break;
case ARITHIF_NODE:
if(DEBUG)
out << " ARITHIF_NODE condition in line: " << temp->lineNumber() << " ";
q = AnalizeAssignStat(temp->expr(0),q,1, step);
if(DEBUG)
out << " success" << endl;
break;
case LOGIF_NODE:
if(DEBUG)
out << " LOGIF_NODE condition in line: " << temp->lineNumber() << " ";
q = AnalizeAssignStat(temp->expr(0),q,1, step);
if(DEBUG)
out << " success" << endl;
break;
case PROC_STAT:
{
if(DEBUG)
out << " PROC_STAT in line: " << temp->lineNumber() << " ";
SgExpression *ex = temp->expr(0);
while (ex)
{
q = AnalizeAssignStat(ex->lhs(),q,1, step);
ex = ex->rhs();
}
if(DEBUG)
out << " success" << endl;
break;
}
default:
/*if(DEBUG)
out << " unknown op in line: " << temp->lineNumber() << " " << temp->variant() << endl;*/
break;
}
if (temp == finish)
break;
temp = temp->lexNext();
}
return AllRef->next;
}
void SwapFors( SgForStmt *first, SgForStmt *second)
{
SgExpression *oldStart;
SgExpression *oldfin;
SgExpression *oldStep;
SgSymbol *oldSymb;
SgValueExp *one = new SgValueExp(1);
oldStart = first->start();
oldfin = first->end();
oldStep = first->step();
first->setStart(*second->start());
first->setEnd(*second->end());
if(second->step())
first->setStep(*second->step());
else
first->setStep(*one);
second->setStart(*oldStart);
second->setEnd(*oldfin);
if(oldStep)
second->setStep(*oldStep);
else
second->setStep(*one);
oldSymb = first->symbol();
first->setDoName(*second->symbol());
second->setDoName(*oldSymb);
}
int AnalizeLoopNest(SgForStmt *stmt, int d)
{
int ret_val = d;
int ch_list = stmt->numberOfChildrenList1();
if(ch_list == 1)
{
if (isSgForStmt(stmt->childList1(0)))
{
ret_val = AnalizeLoopNest(isSgForStmt(stmt->childList1(0)), ret_val + 1);
}
}
else if(ch_list == 2)
{
if (isSgForStmt(stmt->childList1(0)) && stmt->childList1(1)->variant() == CONTROL_END)
{
ret_val = AnalizeLoopNest(isSgForStmt(stmt->childList1(0)), ret_val + 1);
}
}
return ret_val;
}
void SearchInnerFor(SgForStmt *in, int dep, SageStOp *parent)
{
SgStatement *temp;
SgForStmt *loop;
SageStOp *FirstNode;
SageStOp *p;
bool flag = true;
for(int i = 0; i < in->numberOfChildrenList1(); ++i)
{
SageStOp *find = new SageStOp();
temp = in->childList1(i);
if (loop = isSgForStmt(temp))
{
loop->convertLoop();
parent->count_inner_loops++;
find->depth = dep;
find->line_code = loop->lineNumber();
find->loop_op = loop;
find->numChList1 = loop->numberOfChildrenList1();
find->numChList2 = loop->numberOfChildrenList2();
find->count_inner_loops = 0;
find->inner_loops = NULL;
find->LoopNest = AnalizeLoopNest(loop,1);
if (flag)
{
FirstNode = find;
p = find;
flag = !flag;
}
else
{
p->next = find;
p = find;
}
if(DEBUG)
{
for(int k = 0; k < dep; k ++)
out << " ";
out << "found loop in " << loop->lineNumber() << " line with " << loop->numberOfChildrenList1() << " inner ops\n";
}
SearchInnerFor(loop, dep + 1, find);
}
}
if (parent->count_inner_loops != 0)
{
parent->inner_loops = FirstNode;
}
else
{
parent->inner_loops = NULL;
}
}
SageStOp* ForSearch(SgStatement *start)
{
SgForStmt *loop;
SgStatement *op = start;
int count_of_parent = 0;
SageStOp *AllForLoops;
SageStOp *q = NULL;
while(op)
{
SageStOp *p = new SageStOp();
if(loop = isSgForStmt(op))
{
loop->convertLoop();
count_of_parent++;
p->depth = 0;
p->count_inner_loops = 0;
p->line_code = loop->lineNumber();
p->loop_op = loop;
p->numChList1 = loop->numberOfChildrenList1();
p->numChList2 = loop->numberOfChildrenList2();
p->LoopNest = AnalizeLoopNest(loop,1);
if (q == NULL)
{
AllForLoops = p;
q = p;
}
else
{
q->next = p;
q = p;
}
if(DEBUG)
out << "found parent loop in " << loop->lineNumber() << " line with " << loop->numberOfChildrenList1() << " inner ops\n";
SearchInnerFor(loop, 1, p);
op = loop->childList1(loop->numberOfChildrenList1() - 1);
}
op = op->lexNext();
}
return AllForLoops;
}
bool EqualSageSymbols(SageSymbols *first, SageSymbols *second)
{
SageSymbols *q = first;
SageSymbols *p = second;
int count_f = 0;
int count_s = 0;
bool ret_val = false;
while (q)
{
count_f++;
q = q->next;
}
while (p)
{
count_s++;
p = p->next;
}
if(count_f == count_s)
{
q = first;
p = second;
ret_val = true;
for (int i = 0; i < count_f; ++i)
{
if(p->symb && q->symb)
{
if(p->symb->id() != q->symb->id())
{
ret_val = false;
break;
}
}
else
{
ret_val = false;
break;
}
p = p->next;
q = q->next;
}
}
return ret_val;
}
bool CheckExist(SageSymbols *templateParallel, SageSymbols *oneElem)
{
bool ret_val = false;
SageSymbols *q = templateParallel;
while (q)
{
if(oneElem->symb != NULL)
if (oneElem->symb->id() == q->symb->id())
{
ret_val = true;
break;
}
q = q->next;
}
return ret_val;
}
bool CheckExist(Templates *t, SageSymbols *oneElem)
{
bool ret_val = false;
Templates *q = t;
while (q)
{
if (EqualSageSymbols(q->first,oneElem))
{
q->count++;
ret_val = true;
break;
}
q = q->next;
}
return ret_val;
}
SageSymbols* CreateNeededOrder(SageSymbols *templateParallel, SageSymbols *ArrayOrder)
{
int templ = 0;
int arr = 0;
SageSymbols *q = templateParallel;
SageSymbols *ret_val;
while (q)
{
templ++;
q = q->next;
}
q = ArrayOrder;
while (q)
{
arr++;
q = q->next;
}
q = new SageSymbols();
SageSymbols *temp = ArrayOrder;
ret_val = q;
for(int i = 0; i < arr; ++i)
{
if(CheckExist(templateParallel,temp))
{
q->next = new SageSymbols();
q = q->next;
q->len = temp->len;
q->symb = temp->symb;
q->next = NULL;
}
temp = temp->next;
}
return ret_val->next;
}
SageSymbols* CheckOrder(SageSymbols *templateParallel, SageSymbols *ArrayOrder)
{
SageSymbols *q_t = templateParallel;
SageSymbols *q_a = ArrayOrder;
SageSymbols *neededOrder = new SageSymbols();
neededOrder->len = 0;
neededOrder->next = NULL;
neededOrder->symb = NULL;
int find_idx = 0;
int all_idx = 0;
while (q_t)
{
all_idx++;
q_t = q_t->next;
}
while (q_a)
{
q_t = templateParallel;
while (q_t)
{
if(q_a->symb)
if (q_a->symb->id() == q_t->symb->id())
find_idx++;
q_t = q_t->next;
}
q_a = q_a->next;
}
if(find_idx != all_idx)
neededOrder->len = -1;
else
{
q_t = templateParallel;
q_a = ArrayOrder;
while (q_a)
{
if(q_a->symb)
if (q_a->symb->id() == q_t->symb->id())
{
if (q_t->next)
q_t = q_t->next;
else
{
q_t = NULL;
break;
}
}
q_a = q_a->next;
}
if (q_t == NULL)
neededOrder->len = 1;
else
{
delete neededOrder;
neededOrder = CreateNeededOrder(templateParallel, ArrayOrder);
neededOrder->len = 0;
}
}
return neededOrder;
}
int compare (const void * first, const void * second)
{
SageSymbols *p = (SageSymbols*)first;
SageSymbols *q = (SageSymbols*)second;
if(p->len > q->len)
return -1;
else if(p->len < q->len)
return 1;
else
return 0;
}
SageSymbols* CreateOrderForArray( SageSymbols **Idxs, int count, int *dims)
{
bool flag = true;
SageSymbols *retval = NULL;
// check for null var idxs in Array Ref
/*for(int i = 0; i < count; ++i)
{
if(!Idxs[i]->symb)
{
for (int k = 0; k < count; ++k)
{
if(Idxs[k]->symb)
cerr << Idxs[k]->symb->identifier() << " ";
else
cerr << " NULL ";
}
cerr << endl;
flag = false;
break;
}
}*/
if (flag)
{
int k = dims[0];
SageSymbols *sortArr = new SageSymbols[count];
for(int i = 1; i < count; ++i)
{
Idxs[i]->len = Idxs[i]->len * k;
k *= dims[i];
}
for(int i = 0; i < count; ++i)
{
sortArr[i] = *Idxs[i];
}
qsort(sortArr, count, sizeof(SageSymbols),compare);
SageSymbols *p = new SageSymbols();
retval = p;
for(int i = 0; i < count; ++i)
{
SageSymbols *q = new SageSymbols();
q->len = sortArr[i].len;
q->next = NULL;
q->symb = sortArr[i].symb;
p->next = q;
p = q;
}
retval = retval->next;
}
return retval;
}
int* GetIdxOfArrRef(SgExpression *expr)
{
int *ret_idx = NULL;
int dim;
SgArrayType *arrayt;
if(arrayt = isSgArrayType(expr->symbol()->type()))
{
dim = arrayt->dimension();
if (DEBUG_LV3)
out << " dim = " << dim << endl;
ret_idx = new int[dim];
for(int i = 0; i < dim; i++)
{
if(arrayt->sizeInDim(i))
if (arrayt->sizeInDim(i)->variant() == STAR_RANGE)
{
if (DEBUG)
out << " Warning: array in place " << i << " has * dimention size - replaced by 100 dim" << endl;
ret_idx[i] = 100;
continue;
}
ret_idx[i] = CountExpr(arrayt->sizeInDim(i), 0);
if(ret_idx[i] == 0)
{
if (DEBUG)
out << " unknown value in dimention in place " << i << " with variant " << arrayt->sizeInDim(i)->variant() << endl;
delete []ret_idx;
ret_idx = NULL;
break;
}
if (DEBUG_LV3)
out << " size in " << i << " dim is " << ret_idx[i] << endl;
}
}
else
{
out << "unknown type is " << expr->symbol()->variant() << endl;
}
return ret_idx;
}
void PrintFindTemplates(Templates *t, bool flag)
{
if (flag)
{
while(t)
{
if(t->first)
{
out << " template ( ";
SageSymbols*p = t->first;
while(p)
{
if(p->symb)
out << p->symb->identifier() << " ";
else
out << " NULL ";
p = p->next;
}
out << "): ";
if (t->read_write == 1)
out << "read = " << t->count << " write = " << t->count_write_read << endl;
else
out << "write = " << t->count << " read = " << t->count_write_read << endl;
}
else
{
if (t->read_write == 1)
out << " unknown template: read = " << t->count << " write = " << t->count_write_read << endl;
else
out << " unknown template: write = " << t->count << " read = " << t->count_write_read << endl;
}
t = t->next;
}
}
else
{
if(t->read_write == 0)
{
while(t)
{
if(t->first)
{
out << " write template ( ";
SageSymbols*p = t->first;
while(p)
{
if(p->symb)
out << p->symb->identifier()<< " ";
else
out << " NULL ";
p = p->next;
}
out << ") = " << t->count << endl;
}
else
{
out << " write unknown " << t->count << endl;
}
t = t->next;
}
}
else
{
while(t)
{
if(t->first)
{
out << " read template ( ";
SageSymbols*p = t->first;
while(p)
{
if(p->symb)
out << p->symb->identifier()<< " ";
else
out << " NULL ";
p = p->next;
}
out << ") = " << t->count << endl;
}
else
{
out << " read unknown " << t->count << endl;
}
t = t->next;
}
}
}
}
Templates* CopyAllTempl(Templates* copy_t)
{
Templates *t = copy_t;
Templates *p = new Templates();
Templates *ret;
ret = p;
while(t)
{
p->next = new Templates();
p = p->next;
p->count = t->count;
p->first = t->first;
p->count_write_read = t->count_write_read;
p->read_write = t->read_write;
t = t->next;
}
return ret->next;
}
Templates* mergeTemplates(Templates *first,Templates *second)
{
Templates *fQ = CopyAllTempl(first);
Templates *sQ = CopyAllTempl(second);
Templates *retval = new Templates();
Templates *temp;
retval->count = fQ->count;
retval->first = fQ->first;
retval->read_write = fQ->read_write;
retval->next = new Templates();
retval->count_write_read = sQ->count;
temp = retval->next;
fQ = fQ->next;
sQ = sQ->next;
temp->count = fQ->count;
temp->first = fQ->first;
temp->read_write = fQ->read_write;
temp->count_write_read = sQ->count;
fQ = fQ->next;
sQ = sQ->next;
Templates *t = fQ;
while(t)
{
temp->next = new Templates();
temp = temp->next;
temp->count = t->count;
temp->first = t->first;
temp->read_write = t->read_write;
temp->count_write_read = 0;
Templates *m = sQ;
Templates *del_m = sQ;
bool f = FALSE;
while(m)
{
if (EqualSageSymbols(t->first,m->first))
{
temp->count_write_read = m->count;
if(f)
del_m->next = m->next;
else
sQ = NULL;
break;
}
if (f)
del_m = del_m->next;
else
f = TRUE;
m = m->next;
}
t = t->next;
}
while(sQ)
{
temp->next = new Templates();
temp = temp->next;
temp->count = sQ->count;
temp->first = sQ->first;
temp->read_write = sQ->read_write;
temp->count_write_read = 0;
sQ = sQ->next;
}
temp->next = NULL;
return retval;
}
bool SwapIfNeed(Templates *merge, SgForStmt *loop, SgExpression *DVM_par)
{
bool swap_ret = false;
int count_swap_op = 0;
Templates *swap = NULL;
Templates *t = merge->next->next;
int max = merge->count + merge->count_write_read;
while(t)
{
if(max < t->count + t->count_write_read)
{
max = t->count + t->count_write_read;
swap = t;
}
t = t->next;
}
if (swap != NULL)
{
swap_ret = true;
out << " need swap for ( ";
for(SageSymbols *t = swap->first;t != NULL; t = t->next)
{
out << t->symb->identifier() << " ";
}
out << ") template\n";
SageSymbols *t = swap->first;
SgExpression *e = DVM_par;
int count = 0;
while(t)
{
e->lhs()->setSymbol(t->symb);
e = e->rhs();
t = t->next;
count++;
}
SgForStmt **swapFor = new SgForStmt*[count];
SgForStmt *forL = loop;
count = 0;
while(forL)
{
t = swap->first;
while(t)
{
if(forL->symbol()->id() == t->symb->id())
{
swapFor[count] = forL;
count++;
break;
}
t = t->next;
}
forL = isSgForStmt(forL->getNextLoop());
}
t = swap->first;
for (int i = 0; i < count; ++i)
{
if(swapFor[i]->symbol()->id() != t->symb->id())
{
int s = i + 1;
for( ;s < count ;s++)
{
if(swapFor[s]->symbol()->id() == t->symb->id())
break;
}
SwapFors(swapFor[i], swapFor[s]);
}
t = t->next;
}
}
else
{
out << " not swap need " << endl;
}
return swap_ret;
}
bool SwapIfNeed(Templates *read, Templates *write, SgForStmt *loop, SgExpression *DVM_par)
{
bool swap_ret = false;
int count_read = 0;
int count_write = 0;
Templates *swapR = NULL;
Templates *swapW = NULL;
Templates *t = read->next->next;
int max = read->count;
while(t)
{
if(max < t->count)
{
max = t->count;
swapR = t;
}
t = t->next;
}
if(max < write->count)
{
max = write->count;
swapR = NULL;
}
t = write->next->next;
while(t)
{
if(max < t->count)
{
max = t->count;
swapW = t;
}
t = t->next;
}
if (swapR != NULL)
{
swap_ret = true;
out << " need swap for read " << endl;
SageSymbols *t = swapR->first;
SgExpression *e = DVM_par;
int count = 0;
while(t)
{
e->lhs()->setSymbol(t->symb);
e = e->rhs();
t = t->next;
count++;
}
SgForStmt **swapFor = new SgForStmt*[count];
SgForStmt *forL = loop;
count = 0;
while(forL)
{
t = swapR->first;
while(t)
{
if(forL->symbol()->id() == t->symb->id())
{
swapFor[count] = forL;
count++;
break;
}
t = t->next;
}
forL = isSgForStmt(forL->getNextLoop());
}
t = swapR->first;
for (int i = 0; i < count; ++i)
{
if(swapFor[i]->symbol()->id() != t->symb->id())
{
int s = i + 1;
for( ;s < count ;s++)
{
if(swapFor[s]->symbol()->id() == t->symb->id())
break;
}
SwapFors(swapFor[i], swapFor[s]);
}
t = t->next;
}
}
else if (swapW != NULL)
{
swap_ret = true;
out << " need swap for write " << endl;
SageSymbols *t = swapW->first;
SgExpression *e = DVM_par;
int count = 0;
while(t)
{
e->lhs()->setSymbol(t->symb);
e = e->rhs();
t = t->next;
count++;
}
SgForStmt **swapFor = new SgForStmt*[count];
SgForStmt *forL = loop;
count = 0;
while(forL)
{
t = swapW->first;
while(t)
{
if(forL->symbol()->id() == t->symb->id())
{
swapFor[count] = forL;
count++;
break;
}
t = t->next;
}
forL = isSgForStmt(forL->getNextLoop());
}
t = swapW->first;
for (int i = 0; i < count; ++i)
{
if(swapFor[i]->symbol()->id() != t->symb->id())
{
int s = i + 1;
for( ;s < count; s++)
{
if(swapFor[s]->symbol()->id() == t->symb->id())
break;
}
SwapFors(swapFor[i], swapFor[s]);
}
t = t->next;
}
}
else
{
out << " not swap need " << endl;
}
return swap_ret;
}
int allSwaps = 0;
void AnalizeAllFors(SageStOp *first)
{
for (SageStOp *p = first; p != NULL; p = p->next)
{
if (p->LoopNest > 1)
{
SgStatement *temp = p->loop_op->lexPrev();
if (temp->variant() == DVM_PARALLEL_ON_DIR)
{
// create template from parallel directive
SageSymbols *templateParalell;
SageSymbols *p_t = new SageSymbols();
templateParalell = p_t;
SgExpression *first = temp->expr(2);
while(first)
{
SageSymbols *q = new SageSymbols();
q->len = -1;
q->next = NULL;
q->symb = first->lhs()->symbol();
p_t->next = q;
p_t = q;
first = first->rhs();
}
//p_t = templateParalell;
templateParalell = templateParalell->next;
//p_t->next = NULL;
//delete p_t;
Templates *R_temp = new Templates();
Templates *W_temp = new Templates();
Templates *ReadOper = R_temp;
Templates *WriteOper = W_temp;
ReadOper->count = 0;
ReadOper->first = templateParalell;
ReadOper->next = new Templates();
ReadOper->read_write = 1;
ReadOper->next->count = 0;
ReadOper->next->first = NULL;
ReadOper->next->next = NULL;
ReadOper->next->read_write = 1;
ReadOper->count_write_read = 0;
WriteOper->count = 0;
WriteOper->first = templateParalell;
WriteOper->next = new Templates();
WriteOper->read_write = 0;
WriteOper->next->first = NULL;
WriteOper->next->next = NULL;
WriteOper->next->read_write = 0;
WriteOper->count_write_read = 0;
R_temp = R_temp->next;
W_temp = W_temp->next;
SageStOp *q = p;
for(int i = 0; i < p->LoopNest - 1; ++i)
{
q = q->inner_loops;
}
out << " \nAnalize LoopNest in line " << p->loop_op->lineNumber() << endl;
SageArrayIdxs *AllArrayRefInLoop;
AllArrayRefInLoop = Analize(q->loop_op,q->numChList1);
if(DEBUG_LV2)
out << " Analize func OK\n";
while (AllArrayRefInLoop)
{
bool flag;
if(AllArrayRefInLoop->dim)
flag = true;
else
flag = false;
for(int i = 0; i < AllArrayRefInLoop->dim; ++i)
{
//out << " len " << AllArrayRefInLoop->symb[i]->len << " for idx " << AllArrayRefInLoop->symb[i]->symb->identifier();
if (AllArrayRefInLoop->symb[i]->len == -1)
{
flag = !flag;
break;
}
}
if (flag)
{
SageSymbols *params, *neededOrder;
bool flag_null = false;
if(DEBUG_LV2)
out << "before GetIdxOfArrRef func\n";
int *dims = GetIdxOfArrRef(AllArrayRefInLoop->array_expr);
if(DEBUG_LV2)
out << "after GetIdxOfArrRef func\n before CreateOrderForArray func\n";
if (dims)
{
params = CreateOrderForArray(AllArrayRefInLoop->symb, AllArrayRefInLoop->dim, dims);
if(DEBUG_LV2)
out << "after CreateOrderForArray func\n before CheckOrder func\n";
if (params)
{
neededOrder = CheckOrder(templateParalell,params);
if(DEBUG_LV2)
out << "after CheckOrder func\n";
}
else
flag_null = true;
}
else
flag_null = true;
if(flag_null)
{
neededOrder = new SageSymbols();
neededOrder->len = -1;
neededOrder->next = NULL;
neededOrder->symb = NULL;
}
//out << " :rez = " << neededOrder->len;
switch(neededOrder->len)
{
case 0:
if(AllArrayRefInLoop->read_write)
{
if(!CheckExist(ReadOper, neededOrder))
{
R_temp->next = new Templates();
R_temp = R_temp->next;
R_temp->count = 1;
R_temp->first = neededOrder;
R_temp->next = NULL;
R_temp->read_write = 1;
R_temp->count_write_read = 0;
}
}
else
if(!CheckExist(WriteOper, neededOrder))
{
W_temp->next = new Templates();
W_temp = W_temp->next;
W_temp->count = 1;
W_temp->first = neededOrder;
W_temp->next = NULL;
W_temp->read_write = 0;
W_temp->count_write_read = 0;
}
break;
case 1:
if(AllArrayRefInLoop->read_write)
ReadOper->count++;
else
WriteOper->count++;
break;
case -1:
if(AllArrayRefInLoop->read_write)
ReadOper->next->count++;
else
WriteOper->next->count++;
break;
default:
if(DEBUG)
out << " unknown case in switch-template\n";
break;
}
}
else
{
if(AllArrayRefInLoop->read_write)
ReadOper->next->count++;
else
WriteOper->next->count++;
}
//out << endl;
AllArrayRefInLoop = AllArrayRefInLoop->next;
}
Templates *MerT = mergeTemplates(ReadOper, WriteOper);
if(DEBUG)
{
PrintFindTemplates(MerT, true);
//PrintFindTemplates(ReadOper, false);
//PrintFindTemplates(WriteOper, false);
}
if(DEBUG_LV2)
out << " before SwapIfNeed func\n";
if(SwapIfNeed(MerT, p->loop_op, temp->expr(2)))
allSwaps++;
if(DEBUG_LV2)
out << " after SwapIfNeed func\n";
}
}
if (p->inner_loops != NULL)
{
AnalizeAllFors(p->inner_loops);
}
}
}
void Print(SageStOp *first)
{
for (SageStOp *p = first; p != NULL; p = p->next)
{
out << "for in line " << p->line_code << " has " << p->LoopNest << " LoopNest\n";
//out << " count " << p->count_inner_loops << endl;
if (p->inner_loops != NULL)
{
Print(p->inner_loops);
}
}
}
SgExpression* findDirect(SgExpression *inExpr, int DIR)
{
SgExpression *temp = NULL;
if (inExpr)
{
if (inExpr->variant() == DIR)
{
return inExpr;
}
else
{
if (inExpr->lhs())
temp = findDirect(inExpr->lhs(), DIR);
if(inExpr->rhs() && temp == NULL)
temp = findDirect(inExpr->rhs(), DIR);
}
}
return temp;
}
void GlobalAnalizeFunctionOfSwapFors(SageStOp *AllFors)
{
AnalizeAllFors(AllFors);
cerr << " ALL Swaps = " << allSwaps << endl;
}
SageArrayIdxs* GetIdxInParDir(SgExpression *on, SgExpression *across)
{
SageArrayIdxs *ret = new SageArrayIdxs();
ret->next = NULL;
ret->array_expr = NULL;
ret->read_write = -1;
ret->dim = 0;
SgExpression *temp = on;
while (temp)
{
ret->dim++;
temp = temp->rhs();
}
ret->symb = new SageSymbols*[ret->dim];
temp = on;
for (int i = 0; i < ret->dim; ++i)
{
ret->symb[i] = new SageSymbols();
ret->symb[i]->symb = temp->lhs()->symbol();
ret->symb[i]->across_left = 0;
ret->symb[i]->across_right = 0;
ret->symb[i]->next = NULL;
temp = temp->rhs();
}
while (across)
{
SgExpression *t = across->lhs();
int dim = 0;
if(t->variant() == ARRAY_REF)
t = t->lhs();
else if(t->variant() == ARRAY_OP)
t = t->lhs()->lhs();
else
{
if(DEBUG)
out << "!!! unknown vatiant in ACROSS dir: " << t->variant() << endl;
}
while (t)
{
ret->symb[dim]->across_left = MAX(ret->symb[dim]->across_left, t->lhs()->lhs()->valueInteger());
ret->symb[dim]->across_right = MAX(ret->symb[dim]->across_right, t->lhs()->rhs()->valueInteger());
dim ++;
t = t->rhs();
}
across = across->rhs();
}
return ret;
}
void GlobalAnalizeFunction(SgFile *file)
{
out << endl << fin_name << endl;
SgStatement *op = file->firstStatement();
SageStOp *AllFors = ForSearch(file->firstStatement()->lexNext());
int par_loops = 0;
for(SageStOp *p = AllFors; p != NULL; p = p->next)
{
par_loops++;
}
if(DEBUG)
{
out << "\n ***** FOUND ***** " << par_loops << " parent fors\n\n";
//Print(AllFors);
}
GlobalAnalizeFunctionOfSwapFors(AllFors);
}
char* OnlyName(char *filename)
{
char *basename;
int i;
basename = new char[strlen(filename) + 4];
strcpy (basename,filename);
for (i = strlen(filename) - 1 ; i >= 0 ; --i)
{
if ( basename[i] == '.' )
{
basename[i] ='\0';
break;
}
}
return(basename);
}
int main(int argc, char *argv[])
{
FILE *fout;
char fout_name[80];
char *db_name = NULL;
char *proj_name = "dvm.proj";
int i,n, i_file;
SgFile *file;
argv ++;
if(argc > 1)
{
proj_name = *argv;
db_name = OnlyName(proj_name);
}
SgProject project(proj_name);
fin_name = new char[80];
n = project.numberOfFiles();
cerr << "number of files in project " << n << endl;
fin_name = project.fileName(n - 1);
// looking through the file list of project (second time)
for(i = n - 1; i >= 0; --i)
{
file = &(project.file(i));
current_file = file; // global variable
i_file = i;
fin_name = project.fileName(i);
cerr << "Analyzing: " << fin_name << endl;
GlobalAnalizeFunction(file);
sprintf(fout_name,"%s.f",OnlyName(fin_name));
file->saveDepFile(strcat(OnlyName(fin_name),".dep"));
cerr << "Saving in file: " << strcat(OnlyName(fin_name),".dep") << endl;
//unparsing into file
if(DEBUG_LV2)
{
if((fout = fopen(fout_name,"w")) == NULL)
{
cerr << "Can't open file " << fout_name << " for write\n";
return 1;
}
cerr << "Unparsing: " << fout_name << endl;
file->unparse(fout);
if((fclose(fout)) < 0)
{
cerr << "Could not close " << fout_name << endl;
return 1;
}
}
}
cerr << "All work done successfully!\n";
getchar();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink