void RemoveUnusedStructField::setBaseLine(const RecordDecl *RD,
const FieldDecl *FD)
{
TheRecordDecl = RD;
TheFieldDecl = FD;
IndexVector *IdxVec = new IndexVector();
unsigned int Idx = FD->getFieldIndex();
IdxVec->push_back(Idx);
RecordDeclToField[RD] = IdxVec;
FieldToIdxVector[FD] = IdxVec;
// IsLastField = (FD->getNextDeclInContext() == NULL);
RecordDecl::field_iterator I = RD->field_begin();
IsFirstField = (FD == (*I));
RecordDecl::field_iterator E = RD->field_end();
for (; I != E; ++I) {
NumFields++;
}
}
// returns the number of race conditions detected (0 or 1 as of now)
int Specialization::verifyUpdateSequenceRaceConditions(LoopInfoSet& loopInfoSet, ArrayUpdatesSequence& arrayUpdates, VariableIdMapping* variableIdMapping) {
int cnt=0;
stringstream ss;
cout<<"STATUS: checking race conditions."<<endl;
cout<<"INFO: number of parallel loops: "<<numParLoops(loopInfoSet,variableIdMapping)<<endl;
VariableIdSet allIterVars;
for(LoopInfoSet::iterator lis=loopInfoSet.begin();lis!=loopInfoSet.end();++lis) {
allIterVars.insert((*lis).iterationVarId);
}
for(LoopInfoSet::iterator lis=loopInfoSet.begin();lis!=loopInfoSet.end();++lis) {
if((*lis).iterationVarType==ITERVAR_PAR) {
VariableId parVariable;
parVariable=(*lis).iterationVarId;
cout<<"INFO: checking parallel loop: "<<variableIdMapping->variableName(parVariable)<<endl;
// race check
// intersect w-set_i = empty
// w-set_i intersect r-set_j = empty, i!=j.
IndexToReadWriteDataMap indexToReadWriteDataMap;
for(ArrayUpdatesSequence::iterator i=arrayUpdates.begin();i!=arrayUpdates.end();++i) {
const EState* estate=(*i).first;
const PState* pstate=estate->pstate();
SgExpression* exp=(*i).second;
IndexVector index;
// use all vars for indexing or only outer+par loop variables
#ifdef USE_ALL_ITER_VARS
for(VariableIdSet::iterator ol=allIterVars.begin();ol!=allIterVars.end();++ol) {
VariableId otherVarId=*ol;
ROSE_ASSERT(otherVarId.isValid());
if(!pstate->varValue(otherVarId).isTop()) {
int otherIntVal=pstate->varValue(otherVarId).getIntValue();
index.push_back(otherIntVal);
}
}
#else
for(VariableIdSet::iterator ol=(*lis).outerLoopsVarIds.begin();ol!=(*lis).outerLoopsVarIds.end();++ol) {
VariableId otherVarId=*ol;
ROSE_ASSERT(otherVarId.isValid());
if(!pstate->varValue(otherVarId).isTop()&&pstate->varValue(otherVarId).isConstInt()) {
int otherIntVal=pstate->varValue(otherVarId).getIntValue();
index.push_back(otherIntVal);
}
}
if(!pstate->varValue(parVariable).isTop()&&pstate->varValue(parVariable).isConstInt()) {
int parIntVal=pstate->varValue(parVariable).getIntValue();
index.push_back(parIntVal);
}
#endif
if((*lis).isInAssociatedLoop(estate)) {
SgExpression* lhs=isSgExpression(SgNodeHelper::getLhs(exp));
SgExpression* rhs=isSgExpression(SgNodeHelper::getRhs(exp));
ROSE_ASSERT(isSgPntrArrRefExp(lhs)||SgNodeHelper::isFloatingPointAssignment(exp));
//cout<<"EXP: "<<exp->unparseToString()<<", lhs:"<<lhs->unparseToString()<<" :: "<<endl;
// read-set
RoseAst rhsast(rhs);
for(RoseAst::iterator j=rhsast.begin();j!=rhsast.end();++j) {
if(SgPntrArrRefExp* useRef=isSgPntrArrRefExp(*j)) {
j.skipChildrenOnForward();
ArrayElementAccessData access(useRef,variableIdMapping);
indexToReadWriteDataMap[index].readArrayAccessSet.insert(access);
} else if(SgVarRefExp* useRef=isSgVarRefExp(*j)) {
ROSE_ASSERT(useRef);
j.skipChildrenOnForward();
VariableId varId=variableIdMapping->variableId(useRef);
indexToReadWriteDataMap[index].readVarIdSet.insert(varId);
} else {
//cout<<"INFO: UpdateExtraction: ignored expression on rhs:"<<(*j)->unparseToString()<<endl;
}
}
if(SgPntrArrRefExp* arr=isSgPntrArrRefExp(lhs)) {
ArrayElementAccessData access(arr,variableIdMapping);
indexToReadWriteDataMap[index].writeArrayAccessSet.insert(access);
} else if(SgVarRefExp* var=isSgVarRefExp(lhs)) {
VariableId varId=variableIdMapping->variableId(var);
indexToReadWriteDataMap[index].writeVarIdSet.insert(varId);
} else {
cerr<<"Error: SSA Numbering: unknown LHS."<<endl;
exit(1);
}
ss<<"UPD"<<cnt<<":"<<pstate->toString(variableIdMapping)<<" : "<<exp->unparseToString()<<endl;
++cnt;
}
} // array sequence iter
// to be utilized later for more detailed output
#if 0
for(IndexToReadWriteDataMap::iterator imap=indexToReadWriteDataMap.begin();
imap!=indexToReadWriteDataMap.end();
++imap) {
// cout<<"DEBUG: INDEX: "<<(*imap).first<<" R-SET: ";
IndexVector index=(*imap).first;
cout<<"DEBUG: INDEX: ";
for(IndexVector::iterator iv=index.begin();iv!=index.end();++iv) {
if(iv!=index.begin())
cout<<",";
cout<<*iv;
}
cout<<" R-SET: ";
for(ArrayElementAccessDataSet::const_iterator i=indexToReadWriteDataMap[index].readArrayAccessSet.begin();i!=indexToReadWriteDataMap[index].readArrayAccessSet.end();++i) {
cout<<(*i).toString(variableIdMapping)<<" ";
}
cout<<endl;
cout<<"DEBUG: INDEX: ";
for(IndexVector::iterator iv=index.begin();iv!=index.end();++iv) {
if(iv!=index.begin())
cout<<",";
cout<<*iv;
}
cout<<" W-SET: ";
for(ArrayElementAccessDataSet::const_iterator i=indexToReadWriteDataMap[index].writeArrayAccessSet.begin();i!=indexToReadWriteDataMap[index].writeArrayAccessSet.end();++i) {
cout<<(*i).toString(variableIdMapping)<<" ";
}
cout<<endl;
cout<<"DEBUG: read-array-access:"<<indexToReadWriteDataMap[index].readArrayAccessSet.size()<<" read-var-access:"<<indexToReadWriteDataMap[index].readVarIdSet.size()<<endl;
cout<<"DEBUG: write-array-access:"<<indexToReadWriteDataMap[index].writeArrayAccessSet.size()<<" write-var-access:"<<indexToReadWriteDataMap[index].writeVarIdSet.size()<<endl;
} // imap
#endif
// perform the check now
// 1) compute vector if index-vectors for each outer-var-vector
// 2) check each index-vector. For each iteration of each par-loop iteration then.
//typedef set<int> ParVariableValueSet;
//ParVariableValueSet parVariableValueSet;
// MAP: par-variable-val -> vector of IndexVectors with this par-variable-val
typedef vector<IndexVector> ThreadVector;
typedef map<IndexVector,ThreadVector > CheckMapType;
CheckMapType checkMap;
for(IndexToReadWriteDataMap::iterator imap=indexToReadWriteDataMap.begin();
imap!=indexToReadWriteDataMap.end();
++imap) {
IndexVector index=(*imap).first;
IndexVector outVarIndex;
// if index.size()==0, it will analyze the loop independet of outer loops
if(index.size()>0) {
ROSE_ASSERT(index.size()>0);
for(size_t iv1=0;iv1<index.size()-1;iv1++) {
outVarIndex.push_back(index[iv1]);
}
ROSE_ASSERT(outVarIndex.size()<index.size());
} else {
// nothing to check
continue;
}
// last index of index of par-variable
//int parVariableValue=index[index.size()-1];
checkMap[outVarIndex].push_back(index);
}
//cout<<"INFO: race condition check-map size: "<<checkMap.size()<<endl;
// perform the check now
for(CheckMapType::iterator miter=checkMap.begin();miter!=checkMap.end();++miter) {
IndexVector outerVarIndexVector=(*miter).first;
ThreadVector threadVectorToCheck=(*miter).second;
//cout<<"DEBUG: to check: "<<threadVectorToCheck.size()<<endl;
for(ThreadVector::iterator tv1=threadVectorToCheck.begin();tv1!=threadVectorToCheck.end();++tv1) {
ArrayElementAccessDataSet wset=indexToReadWriteDataMap[*tv1].writeArrayAccessSet;
for(ThreadVector::iterator tv2=tv1;tv2!=threadVectorToCheck.end();++tv2) {
ThreadVector::iterator tv2b=tv2;
++tv2b;
if(tv2b!=threadVectorToCheck.end()) {
ArrayElementAccessDataSet rset2=indexToReadWriteDataMap[*tv2b].readArrayAccessSet;
ArrayElementAccessDataSet wset2=indexToReadWriteDataMap[*tv2b].writeArrayAccessSet;
// check intersect(rset,wset)
if(accessSetIntersect(wset,rset2)) {
// verification failed
cout<<"INFO: race condition detected (wset1,rset2)."<<endl;
return 1;
}
if(accessSetIntersect(wset,wset2)) {
// verification failed
cout<<"INFO: race condition detected (wset1,wset2)."<<endl;
return 1;
}
}
}
}
}
} // if parallel loop
} // foreach loop
return 0;
}
static void expandLabels(Bundle& bundle, size_t beamSize)
{
auto& outputActivationsVector = bundle["outputActivations"].get<MatrixVector>();
auto& outputActivations = outputActivationsVector.back();
auto& labels = bundle["referenceLabels"].get<LabelVector>();
auto& inputTimesteps = bundle["inputTimesteps"].get<IndexVector>();
size_t characters = outputActivations.size().front();
size_t miniBatchSize = outputActivations.size()[outputActivations.size().size() - 2];
size_t maxTimesteps = outputActivations.size()[outputActivations.size().size() - 1];
size_t originalMiniBatchSize = miniBatchSize / beamSize;
LabelVector expandedLabels;
IndexVector expandedTimesteps;
for(size_t miniBatch = 0; miniBatch < originalMiniBatchSize; ++miniBatch)
{
for(size_t beam = 0; beam < beamSize; ++beam)
{
expandedLabels.push_back(labels[miniBatch]);
expandedTimesteps.push_back(inputTimesteps[miniBatch]);
}
}
labels = std::move(expandedLabels);
inputTimesteps = std::move(expandedTimesteps);
auto referenceActivations = matrix::zeros({characters, miniBatchSize, maxTimesteps},
outputActivations.precision());
for(size_t miniBatch = 0; miniBatch < miniBatchSize; ++miniBatch)
{
for(size_t timestep = 0; timestep < maxTimesteps; ++timestep)
{
if(timestep < labels[miniBatch].size())
{
size_t character = labels[miniBatch][timestep];
assert(character < characters);
referenceActivations(character, miniBatch, timestep) = 1.0;
}
else
{
referenceActivations(characters - 1, miniBatch, timestep) = 1.0;
}
}
}
if(util::isLogEnabled("CTCDecoderLayer::Detail"))
{
util::log("CTCDecoderLayer::Detail") << " reference labels: \n";
for(auto& label : labels)
{
util::log("CTCDecoderLayer::Detail") << " reference label: "
<< util::toString(label) << "\n";
}
util::log("CTCDecoderLayer::Detail") << " reference activations: "
<< referenceActivations.debugString();
}
else
{
util::log("CTCDecoderLayer::Detail") << " reference labels size: "
<< labels.size() << "\n";
util::log("CTCDecoderLayer") << " reference activations size: "
<< outputActivations.shapeString() << "\n";
}
bundle["referenceActivations"] = MatrixVector({referenceActivations});
}