StencilEvaluation_InheritedAttribute
StencilEvaluationTraversal::evaluateInheritedAttribute (SgNode* astNode, StencilEvaluation_InheritedAttribute inheritedAttribute )
{
#if 0
printf ("In evaluateInheritedAttribute(): astNode = %p = %s \n",astNode,astNode->class_name().c_str());
#endif
bool foundPairShiftDoubleConstructor = false;
// This is for stencil specifications using vectors of points to represent offsets (not finished).
// bool foundVariableDeclarationForStencilInput = false;
double stencilCoeficientValue = 0.0;
// StencilOffsetFSM offset;
StencilOffsetFSM* stencilOffsetFSM = NULL;
// We want to interogate the SgAssignInitializer, but we need to generality in the refactored function to use any SgInitializer (e.g. SgConstructorInitializer, etc.).
SgInitializedName* initializedName = detectVariableDeclarationOfSpecificType (astNode,"Point");
if (initializedName != NULL)
{
// This is the code that is specific to the DSL (e.g. the semantics of getZeros() and getUnitv() functions).
// So this may be the limit of what can be refactored to common DSL support code.
// Or I can maybe do a second pass at atempting to refactor more code later.
string name = initializedName->get_name();
SgInitializer* initializer = initializedName->get_initptr();
SgAssignInitializer* assignInitializer = isSgAssignInitializer(initializer);
if (assignInitializer != NULL)
{
SgExpression* exp = assignInitializer->get_operand();
ROSE_ASSERT(exp != NULL);
SgFunctionCallExp* functionCallExp = isSgFunctionCallExp(exp);
if (functionCallExp != NULL)
{
SgFunctionRefExp* functionRefExp = isSgFunctionRefExp(functionCallExp->get_function());
if (functionRefExp != NULL)
{
SgFunctionSymbol* functionSymbol = functionRefExp->get_symbol();
ROSE_ASSERT(functionSymbol != NULL);
string functionName = functionSymbol->get_name();
#if 0
printf ("functionName = %s \n",functionName.c_str());
#endif
if (functionName == "getZeros")
{
// We leverage the semantics of known functions used to initialize "Point" objects ("getZeros" initialized the Point object to be all zeros).
// In a stencil this will be the center point from which all other points will have non-zero offsets.
// For a common centered difference discretization this will be the center point of the stencil.
#if 0
printf ("Identified and interpreting the semantics of getZeros() function \n");
#endif
stencilOffsetFSM = new StencilOffsetFSM(0,0,0);
ROSE_ASSERT(stencilOffsetFSM != NULL);
}
if (functionName == "getUnitv")
{
// We leverage the semantics of known functions used to initialize "Point" objects
// ("getUnitv" initializes the Point object to be a unit vector for a specific input dimention).
// In a stencil this will be an ofset from the center point.
#if 0
printf ("Identified and interpreting the semantics of getUnitv() function \n");
#endif
// Need to get the dimention argument.
SgExprListExp* argumentList = functionCallExp->get_args();
ROSE_ASSERT(argumentList != NULL);
// This function has a single argument.
ROSE_ASSERT(argumentList->get_expressions().size() == 1);
SgExpression* functionArg = argumentList->get_expressions()[0];
ROSE_ASSERT(functionArg != NULL);
SgIntVal* intVal = isSgIntVal(functionArg);
// ROSE_ASSERT(intVal != NULL);
if (intVal != NULL)
{
int value = intVal->get_value();
#if 0
printf ("value = %d \n",value);
#endif
switch(value)
{
case 0: stencilOffsetFSM = new StencilOffsetFSM(1,0,0); break;
case 1: stencilOffsetFSM = new StencilOffsetFSM(0,1,0); break;
case 2: stencilOffsetFSM = new StencilOffsetFSM(0,0,1); break;
default:
{
printf ("Error: default reached in switch: value = %d (for be value of 0, 1, or 2) \n",value);
ROSE_ASSERT(false);
}
}
ROSE_ASSERT(stencilOffsetFSM != NULL);
// End of test for intVal != NULL
}
else
{
#if 0
printf ("functionArg = %p = %s \n",functionArg,functionArg->class_name().c_str());
#endif
}
}
// ROSE_ASSERT(stencilOffsetFSM != NULL);
}
}
}
if (stencilOffsetFSM != NULL)
{
// Put the FSM into the map.
#if 0
printf ("Put the stencilOffsetFSM = %p into the StencilOffsetMap using key = %s \n",stencilOffsetFSM,name.c_str());
#endif
ROSE_ASSERT(StencilOffsetMap.find(name) == StencilOffsetMap.end());
// We have a choice of syntax to add the element to the map.
// StencilOffsetMap.insert(pair<string,StencilOffsetFSM*>(name,stencilOffsetFSM));
StencilOffsetMap[name] = stencilOffsetFSM;
}
// new StencilOffsetFSM();
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
// Recognize member function calls on "Point" objects so that we can trigger events on those associated finite state machines.
bool isTemplateClass = false;
bool isTemplateFunctionInstantiation = false;
SgInitializedName* initializedNameUsedToCallMemberFunction = NULL;
SgFunctionCallExp* functionCallExp = detectMemberFunctionOfSpecificClassType(astNode,initializedNameUsedToCallMemberFunction,"Point",isTemplateClass,"operator*=",isTemplateFunctionInstantiation);
if (functionCallExp != NULL)
{
// This is the DSL specific part (capturing the semantics of operator*= with specific integer values).
// The name of the variable off of which the member function is called (variable has type "Point").
ROSE_ASSERT(initializedNameUsedToCallMemberFunction != NULL);
string name = initializedNameUsedToCallMemberFunction->get_name();
// Need to get the dimention argument.
SgExprListExp* argumentList = functionCallExp->get_args();
ROSE_ASSERT(argumentList != NULL);
// This function has a single argument.
ROSE_ASSERT(argumentList->get_expressions().size() == 1);
SgExpression* functionArg = argumentList->get_expressions()[0];
ROSE_ASSERT(functionArg != NULL);
SgIntVal* intVal = isSgIntVal(functionArg);
bool usingUnaryMinus = false;
if (intVal == NULL)
{
SgMinusOp* minusOp = isSgMinusOp(functionArg);
if (minusOp != NULL)
{
#if 0
printf ("Using SgMinusOp on stencil constant \n");
#endif
usingUnaryMinus = true;
intVal = isSgIntVal(minusOp->get_operand());
}
}
ROSE_ASSERT(intVal != NULL);
int value = intVal->get_value();
if (usingUnaryMinus == true)
{
value *= -1;
}
#if 0
printf ("value = %d \n",value);
#endif
// Look up the stencil offset finite state machine
ROSE_ASSERT(StencilOffsetMap.find(name) != StencilOffsetMap.end());
StencilOffsetFSM* stencilOffsetFSM = StencilOffsetMap[name];
ROSE_ASSERT(stencilOffsetFSM != NULL);
#if 0
printf ("We have found the StencilOffsetFSM associated with the StencilOffset named %s \n",name.c_str());
#endif
#if 0
stencilOffsetFSM->display("before multiply event");
#endif
if (value == -1)
{
// Execute the event on the finte state machine to accumulate the state.
stencilOffsetFSM->operator*=(-1);
}
else
{
printf ("Error: constant value other than -1 are not supported \n");
ROSE_ASSERT(false);
}
#if 0
stencilOffsetFSM->display("after multiply event");
#endif
}
// Detection of "pair<Shift,double>(xdir,ident)" defined as an event in the stencil finite machine model.
// Actually, it is the Stencil that is create using the "pair<Shift,double>(xdir,ident)" that should be the
// event so we first detect the SgConstructorInitializer. There is not other code similar to this which
// has to test for the template arguments, so this has not yet refactored into the dslSupport.C file.
// I will do this later since this is general support that could be resused in other DSL compilers.
SgConstructorInitializer* constructorInitializer = isSgConstructorInitializer(astNode);
if (constructorInitializer != NULL)
{
// DQ (10/20/2014): This can sometimes be NULL.
// ROSE_ASSERT(constructorInitializer->get_class_decl() != NULL);
SgClassDeclaration* classDeclaration = constructorInitializer->get_class_decl();
// ROSE_ASSERT(classDeclaration != NULL);
if (classDeclaration != NULL)
{
#if 0
printf ("constructorInitializer = %p class name = %s \n",constructorInitializer,classDeclaration->get_name().str());
#endif
SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(classDeclaration);
// ROSE_ASSERT(templateInstantiationDecl != NULL);
#if 0
if (templateInstantiationDecl != NULL)
{
printf ("constructorInitializer = %p name = %s template name = %s \n",constructorInitializer,templateInstantiationDecl->get_name().str(),templateInstantiationDecl->get_templateName().str());
}
#endif
// if (classDeclaration->get_name() == "pair")
if (templateInstantiationDecl != NULL && templateInstantiationDecl->get_templateName() == "pair")
{
// Look at the template parameters.
#if 0
printf ("Found template instantiation for pair \n");
#endif
SgTemplateArgumentPtrList & templateArgs = templateInstantiationDecl->get_templateArguments();
if (templateArgs.size() == 2)
{
// Now look at the template arguments and check that they represent the pattern that we are looking for in the AST.
// It is not clear now flexible we should be, at present shift/coeficent pairs must be specified exactly one way.
SgType* type_0 = templateArgs[0]->get_type();
SgType* type_1 = templateArgs[1]->get_type();
if ( type_0 != NULL && type_1 != NULL)
{
SgClassType* classType_0 = isSgClassType(type_0);
// ROSE_ASSERT(classType_0 != NULL);
if (classType_0 != NULL)
{
SgClassDeclaration* classDeclarationType_0 = isSgClassDeclaration(classType_0->get_declaration());
ROSE_ASSERT(classDeclarationType_0 != NULL);
#if 0
printf ("templateArgs[0]->get_name() = %s \n",classDeclarationType_0->get_name().str());
printf ("templateArgs[1]->get_type()->class_name() = %s \n",type_1->class_name().c_str());
#endif
bool foundShiftExpression = false;
bool foundStencilCoeficient = false;
// We might want to be more flexiable about the type of the 2nd parameter (allow SgTypeFloat, SgTypeComplex, etc.).
if (classDeclarationType_0->get_name() == "Shift" && type_1->variant() == V_SgTypeDouble)
{
// Found a pair<Shift,double> input for a stencil.
#if 0
printf ("##### Found a pair<Shift,double>() input for a stencil input \n");
#endif
// *****************************************************************************************************
// Look at the first parameter to the pair<Shift,double>() constructor.
// *****************************************************************************************************
SgExpression* stencilOffset = constructorInitializer->get_args()->get_expressions()[0];
ROSE_ASSERT(stencilOffset != NULL);
#if 0
printf ("stencilOffset = %p = %s \n",stencilOffset,stencilOffset->class_name().c_str());
#endif
SgConstructorInitializer* stencilOffsetConstructorInitializer = isSgConstructorInitializer(stencilOffset);
if (stencilOffsetConstructorInitializer != NULL)
{
// This is the case of a Shift being constructed implicitly from a Point (doing so more directly would be easier to make sense of in the AST).
#if 0
printf ("!!!!! Looking for the stencil offset \n");
#endif
ROSE_ASSERT(stencilOffsetConstructorInitializer->get_class_decl() != NULL);
SgClassDeclaration* stencilOffsetClassDeclaration = stencilOffsetConstructorInitializer->get_class_decl();
ROSE_ASSERT(stencilOffsetClassDeclaration != NULL);
#if 0
printf ("stencilOffsetConstructorInitializer = %p class name = %s \n",stencilOffsetConstructorInitializer,stencilOffsetClassDeclaration->get_name().str());
printf ("stencilOffsetConstructorInitializer = %p class = %p = %s \n",stencilOffsetConstructorInitializer,stencilOffsetClassDeclaration,stencilOffsetClassDeclaration->class_name().c_str());
#endif
// This should not be a template instantiation (the Shift is defined to be a noo-template class declaration, not a template class declaration).
SgTemplateInstantiationDecl* stencilOffsetTemplateInstantiationDecl = isSgTemplateInstantiationDecl(stencilOffsetClassDeclaration);
ROSE_ASSERT(stencilOffsetTemplateInstantiationDecl == NULL);
if (stencilOffsetClassDeclaration != NULL && stencilOffsetClassDeclaration->get_name() == "Shift")
{
// Now we know that the type associated with the first template parameter is associated with the class "Shift".
// But we need so also now what the first parametr is associate with the constructor initializer, since it will
// be the name of the variable used to interprete the stencil offset (and the name of the variable will be the
// key into the map of finite machine models used to accumulate the state of the stencil offsets that we accumulate
// to build the stencil.
// Now we need the value of the input (computed using it's fine state machine).
SgExpression* inputToShiftConstructor = stencilOffsetConstructorInitializer->get_args()->get_expressions()[0];
ROSE_ASSERT(inputToShiftConstructor != NULL);
SgConstructorInitializer* inputToShiftConstructorInitializer = isSgConstructorInitializer(inputToShiftConstructor);
if (stencilOffsetConstructorInitializer != NULL)
{
SgExpression* inputToPointConstructor = inputToShiftConstructorInitializer->get_args()->get_expressions()[0];
ROSE_ASSERT(inputToPointConstructor != NULL);
// This should be a SgVarRefExp (if we strictly follow the stencil specification rules (which are not written down yet).
SgVarRefExp* inputToPointVarRefExp = isSgVarRefExp(inputToPointConstructor);
if (inputToPointVarRefExp != NULL)
{
#if 0
printf ("Found varRefExp in bottom of chain of constructors \n");
#endif
SgVariableSymbol* variableSymbolForOffset = isSgVariableSymbol(inputToPointVarRefExp->get_symbol());
ROSE_ASSERT(variableSymbolForOffset != NULL);
SgInitializedName* initializedNameForOffset = variableSymbolForOffset->get_declaration();
ROSE_ASSERT(initializedNameForOffset != NULL);
SgInitializer* initializer = initializedNameForOffset->get_initptr();
ROSE_ASSERT(initializer != NULL);
#if 0
printf ("Found initializedName: name = %s in bottom of chain of constructors: initializer = %p = %s \n",initializedNameForOffset->get_name().str(),initializer,initializer->class_name().c_str());
#endif
// Record the name to be used as a key into the map of "StencilOffset" finite state machines.
SgAssignInitializer* assignInitializer = isSgAssignInitializer(initializer);
ROSE_ASSERT(assignInitializer != NULL);
string name = initializedNameForOffset->get_name();
// Look up the current state in the finite state machine for the "Point".
// Check that this is a previously defined stencil offset.
ROSE_ASSERT(StencilOffsetMap.find(name) != StencilOffsetMap.end());
// StencilOffsetFSM* stencilOffsetFSM = StencilOffsetMap[name];
stencilOffsetFSM = StencilOffsetMap[name];
ROSE_ASSERT(stencilOffsetFSM != NULL);
#if 0
printf ("We have found the StencilOffsetFSM associated with the StencilOffset named %s \n",name.c_str());
#endif
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
else
{
printf ("What is this expression: inputToPointConstructor = %p = %s \n",inputToPointConstructor,inputToPointConstructor->class_name().c_str());
ROSE_ASSERT(false);
}
}
#if 0
printf ("Found Shift type \n");
#endif
foundShiftExpression = true;
}
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
else
{
// This case for the specification of a Shift in the first argument is not yet supported (need an example of this).
printf ("This case of using a shift is not a part of what is supported \n");
}
// *****************************************************************************************************
// Look at the second parameter to the pair<Shift,double>(first_parameter,second_parameter) constructor.
// *****************************************************************************************************
SgExpression* stencilCoeficent = constructorInitializer->get_args()->get_expressions()[1];
ROSE_ASSERT(stencilCoeficent != NULL);
SgVarRefExp* stencilCoeficentVarRefExp = isSgVarRefExp(stencilCoeficent);
if (stencilCoeficentVarRefExp != NULL)
{
// Handle the case where this is a constant SgVarRefExp and the value is available in the declaration.
SgVariableSymbol* variableSymbolForConstant = isSgVariableSymbol(stencilCoeficentVarRefExp->get_symbol());
ROSE_ASSERT(variableSymbolForConstant != NULL);
SgInitializedName* initializedNameForConstant = variableSymbolForConstant->get_declaration();
ROSE_ASSERT(initializedNameForConstant != NULL);
SgInitializer* initializer = initializedNameForConstant->get_initptr();
ROSE_ASSERT(initializer != NULL);
SgAssignInitializer* assignInitializer = isSgAssignInitializer(initializer);
ROSE_ASSERT(assignInitializer != NULL);
SgValueExp* valueExp = isSgValueExp(assignInitializer->get_operand());
bool usingUnaryMinus = false;
// ROSE_ASSERT(valueExp != NULL);
if (valueExp == NULL)
{
SgExpression* operand = assignInitializer->get_operand();
SgMinusOp* minusOp = isSgMinusOp(operand);
if (minusOp != NULL)
{
#if 0
printf ("Using SgMinusOp on stencil constant \n");
#endif
usingUnaryMinus = true;
valueExp = isSgValueExp(minusOp->get_operand());
}
}
SgDoubleVal* doubleVal = isSgDoubleVal(valueExp);
// ROSE_ASSERT(doubleVal != NULL);
double value = 0.0;
if (doubleVal == NULL)
{
// Call JP's function to evaluate the constant expression.
ROSE_ASSERT(valueExp == NULL);
ROSE_ASSERT(stencilCoeficent != NULL);
DSL_Support::const_numeric_expr_t const_expression = DSL_Support::evaluateConstNumericExpression(stencilCoeficent);
if (const_expression.hasValue_ == true)
{
ROSE_ASSERT(const_expression.isIntOnly_ == false);
value = const_expression.value_;
printf ("const expression evaluated to value = %4.2f \n",value);
}
else
{
printf ("constnat value expression could not be evaluated to a constant \n");
ROSE_ASSERT(false);
}
}
else
{
#if 1
printf ("SgDoubleVal value = %f \n",doubleVal->get_value());
#endif
value = (usingUnaryMinus == false) ? doubleVal->get_value() : -(doubleVal->get_value());
}
#if 1
printf ("Stencil coeficient = %f \n",value);
#endif
foundStencilCoeficient = true;
stencilCoeficientValue = value;
}
else
{
// When we turn on constant folding in the frontend we eveluate directly to a SgDoubleVal.
SgDoubleVal* doubleVal = isSgDoubleVal(stencilCoeficent);
if (doubleVal != NULL)
{
ROSE_ASSERT(doubleVal != NULL);
#if 0
printf ("SgDoubleVal value = %f \n",doubleVal->get_value());
#endif
double value = doubleVal->get_value();
#if 0
printf ("Stencil coeficient = %f \n",value);
#endif
foundStencilCoeficient = true;
stencilCoeficientValue = value;
}
else
{
printf ("Error: second parameter in pair for stencil is not a SgVarRefExp (might be explicit value not yet supported) \n");
printf (" --- stencilCoeficent = %p = %s \n",stencilCoeficent,stencilCoeficent->class_name().c_str());
ROSE_ASSERT(false);
}
}
}
#if 0
printf ("foundShiftExpression = %s \n",foundShiftExpression ? "true" : "false");
printf ("foundStencilCoeficient = %s \n",foundStencilCoeficient ? "true" : "false");
#endif
if (foundShiftExpression == true && foundStencilCoeficient == true)
{
#if 0
printf ("Found pair<Shift,double>() constructor expression! \n");
#endif
foundPairShiftDoubleConstructor = true;
}
// End of test for classType_0 != NULL
}
}
}
}
else
{
#if 0
printf ("This is not a SgConstructorInitializer for the pair templated class \n");
#endif
}
// End of test for classDeclaration != NULL
}
}
#if 0
printf ("foundPairShiftDoubleConstructor = %s \n",foundPairShiftDoubleConstructor ? "true" : "false");
#endif
if (foundPairShiftDoubleConstructor == true)
{
// This is the recognition of an event for one of the finite state machines we implement to evaluate the stencil at compile time.
#if 0
printf ("In evaluateInheritedAttribute(): found pair<Shift,double>() constructor expression! \n");
printf (" --- stencilOffsetFSM = %p \n",stencilOffsetFSM);
printf (" --- stencilCoeficientValue = %f \n",stencilCoeficientValue);
#endif
ROSE_ASSERT(stencilOffsetFSM != NULL);
inheritedAttribute.stencilOffsetFSM = stencilOffsetFSM;
inheritedAttribute.stencilCoeficientValue = stencilCoeficientValue;
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
// Construct the return attribute from the modified input attribute.
return StencilEvaluation_InheritedAttribute(inheritedAttribute);
}
StencilEvaluation_SynthesizedAttribute
StencilEvaluationTraversal::evaluateSynthesizedAttribute (SgNode* astNode, StencilEvaluation_InheritedAttribute inheritedAttribute, SubTreeSynthesizedAttributes synthesizedAttributeList )
{
StencilEvaluation_SynthesizedAttribute return_synthesizedAttribute;
#if 0
printf ("In StencilEvaluationTraversal::evaluateSynthesizedAttribute(): astNode = %p = %s \n",astNode,astNode->class_name().c_str());
#endif
bool foundStencilOffsetFSM = false;
SgConstructorInitializer* constructorInitializer = isSgConstructorInitializer(astNode);
if (constructorInitializer != NULL && inheritedAttribute.stencilOffsetFSM != NULL)
{
#if 0
printf ("Found pair<Shift,double>(x,y): set then in the synthesizedAttribute: astNode = %p = %s \n",astNode,astNode->class_name().c_str());
#endif
return_synthesizedAttribute.stencilOffsetFSM = inheritedAttribute.stencilOffsetFSM;
return_synthesizedAttribute.stencilCoeficientValue = inheritedAttribute.stencilCoeficientValue;
#if 0
printf ("return_synthesizedAttribute.stencilCoeficientValue = %f \n",return_synthesizedAttribute.stencilCoeficientValue);
#endif
foundStencilOffsetFSM = true;
}
// There should only be a single child set with a pair<Shift,double>(x,y) object.
for (size_t i = 0; i < synthesizedAttributeList.size(); i++)
{
if (synthesizedAttributeList[i].stencilOffsetFSM != NULL)
{
// Check that the return_synthesizedAttribute.stencilOffsetFSM has not already been set.
// This could happend if we allows nesting of pair<Shift,double>(x,y) within itself (not allowed).
#if 0
printf ("synthesizedAttributeList[i].stencilOffsetFSM != NULL \n");
#endif
// ROSE_ASSERT(foundStencilOffsetFSM == false);
if (foundStencilOffsetFSM == false)
{
#if 0
printf ("foundStencilOffsetFSM == false \n");
#endif
// ROSE_ASSERT(return_synthesizedAttribute.stencilOffsetFSM == NULL);
if (return_synthesizedAttribute.stencilOffsetFSM == NULL)
{
#if 0
printf ("return_synthesizedAttribute.stencilOffsetFSM != NULL \n");
#endif
return_synthesizedAttribute.stencilOffsetFSM = synthesizedAttributeList[i].stencilOffsetFSM;
return_synthesizedAttribute.stencilCoeficientValue = synthesizedAttributeList[i].stencilCoeficientValue;
}
foundStencilOffsetFSM = true;
}
}
}
// This allows us to find the variables of type vector<Point> and vector<double> used as an alternative way
// to specify a stencil (using the Stencil constructor that takes these variables as input arguments).
// It relies upon a previous traversal to have identified the inputs to Stencil constructor.
// This support is incomplete while I focus on the alternative approach to the specification of the stencil
// using intremental union of a stencil with a pair<Shift,double>() template instantiation.
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(astNode);
if (variableDeclaration != NULL)
{
// Get the SgInitializedName from the SgVariableDeclaration.
SgInitializedName* initializedName = SageInterface::getFirstInitializedName(variableDeclaration);
#if 0
printf ("In evaluateInheritedAttribute(): case SgInitializedName from variable declaration: initializedName = %p name = %s \n",initializedName,initializedName->get_name().str());
#endif
bool foundStencilDeclaration = false;
if (find(stencilInputInitializedNameList.begin(),stencilInputInitializedNameList.end(),initializedName) != stencilInputInitializedNameList.end())
{
#if 0
printf ("Found declaration associated with stencil input: initializedName = %p = %s name = %s \n",initializedName,initializedName->class_name().c_str(),initializedName->get_name().str());
#endif
// Build the finite state machine for the stencil and add it to the map using the name (in SgInitializedName) as a key.
// For now we assume that the stencil specification is using the default construction.
if (initializedName->get_initptr() != NULL)
{
printf ("FIXME: This declaration of a stencil appears to have constrcutor arguments (this not the default constuctor as interprest below). \n");
#if 0
ROSE_ASSERT(false);
#endif
}
foundStencilDeclaration = true;
}
else
{
// Verify that this is a Stencil declaration.
SgClassType* classType = isSgClassType(initializedName->get_type());
if (classType != NULL)
{
// Check if this is associated with a template instantiation.
SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(classType->get_declaration());
if (templateInstantiationDecl != NULL)
{
#if 0
printf ("case SgTemplateInstaiationDecl: class name = %s \n",classType->get_name().str());
printf ("case SgTemplateInstaiationDecl: templateInstantiationDecl->get_templateName() = %s \n",templateInstantiationDecl->get_templateName().str());
#endif
if (templateInstantiationDecl->get_templateName() == "Stencil")
{
#if 0
printf ("This is verified to be associated with the Stencil template class \n");
#endif
foundStencilDeclaration = true;
}
}
}
}
if (foundStencilDeclaration == true)
{
string name = initializedName->get_name();
ROSE_ASSERT(stencilMap.find(name) == stencilMap.end());
// stencilMap[name] = new StencilFSM();
StencilFSM* stencilFSM = new StencilFSM();
ROSE_ASSERT(stencilFSM != NULL);
stencilMap[name] = stencilFSM;
ROSE_ASSERT(stencilMap.find(name) != stencilMap.end());
#if 0
printf ("Added StencilFSM to stencilMap using name = %s \n",name.c_str());
#endif
#if 0
printf ("Trigger an event on the stencilFSM ========================== %p \n",stencilFSM);
printf (" --- Use the return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM);
#endif
if (return_synthesizedAttribute.stencilOffsetFSM != NULL)
{
// Trigger the event to add the stencil offset to the stencil.
// Trigger the event on the finite state machine using the elements saved in the synthesized attribute.
StencilFSM stencil_rhs (*(return_synthesizedAttribute.stencilOffsetFSM),return_synthesizedAttribute.stencilCoeficientValue);
// This reproduces the same semantics in our finite state machine as the Stencil class's operator+()
// in the stencil specification. but this permits use to accumulate the state at compile time.
stencilFSM->operator+(stencil_rhs);
// We have now used these values so avoid letting then be used again.
return_synthesizedAttribute.stencilOffsetFSM = NULL;
return_synthesizedAttribute.stencilCoeficientValue = 0.0;
}
#if 0
stencilFSM->display("after FSM stencil default construction plus union event: StencilEvaluationTraversal::evaluateSynthesizedAttribute()");
#endif
#if 0
printf ("Exiting as a test! \n");
ROSE_ASSERT(false);
#endif
}
}
// Recognize member function calls on "Stencil" objects so that we can trigger events on those associated finite state machines.
bool isTemplateClass = true;
bool isTemplateFunctionInstantiation = true;
SgInitializedName* initializedNameUsedToCallMemberFunction = NULL;
SgFunctionCallExp* functionCallExp = detectMemberFunctionOfSpecificClassType(astNode,initializedNameUsedToCallMemberFunction,"Stencil",isTemplateClass,"operator+",isTemplateFunctionInstantiation);
if (return_synthesizedAttribute.stencilOffsetFSM != NULL && functionCallExp != NULL)
{
// This is the DSL specific part of the synthesized attribute evaluation.
ROSE_ASSERT(initializedNameUsedToCallMemberFunction != NULL);
string name = initializedNameUsedToCallMemberFunction->get_name();
#if 0
printf ("This is verified to be the operator+ member function of the Stencil templated class (so this corresponds to an event in the Stencil finite state machine) \n");
printf (" --- stencil object name = %s \n",name.c_str());
#endif
// Lookup the stencil FSM in the map of stencil FSMs using the name as the key.
ROSE_ASSERT(stencilMap.find(name) != stencilMap.end());
StencilFSM* stencilFSM = stencilMap[name];
ROSE_ASSERT(stencilFSM != NULL);
#if 0
printf ("Trigger an event on the stencilFSM ========================== %p \n",stencilFSM);
printf (" --- Use the return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM);
#endif
// Make sure we have the input parameter for the stencil's finite state machine.
ROSE_ASSERT(return_synthesizedAttribute.stencilOffsetFSM != NULL);
// Trigger the event on the finite state machine using the elements saved in the synthesized attribute.
StencilFSM stencil_rhs (*(return_synthesizedAttribute.stencilOffsetFSM),return_synthesizedAttribute.stencilCoeficientValue);
// This reproduces the same semantics in our finite state machine as the Stencil class's operator+()
// in the stencil specification. but this permits use to accumulate the state at compile time.
stencilFSM->operator+(stencil_rhs);
// We have now used these values so avoid letting then be used again.
return_synthesizedAttribute.stencilOffsetFSM = NULL;
return_synthesizedAttribute.stencilCoeficientValue = 0.0;
#if 0
stencilFSM->display("after FSM stencil union event: StencilEvaluationTraversal::evaluateSynthesizedAttribute()");
#endif
}
#if 0
printf ("Leaving StencilEvaluationTraversal::evaluateSynthesizedAttribute(): return_synthesizedAttribute.stencilOffsetFSM = %p \n",return_synthesizedAttribute.stencilOffsetFSM);
#endif
#if 0
printf ("Leaving StencilEvaluationTraversal::evaluateSynthesizedAttribute(): return_synthesizedAttribute.stencilCoeficientValue = %f \n",return_synthesizedAttribute.stencilCoeficientValue);
#endif
return return_synthesizedAttribute;
}
Detection_InheritedAttribute
DetectionTraversal::evaluateInheritedAttribute (SgNode* astNode, Detection_InheritedAttribute inheritedAttribute )
{
#if 0
printf ("In DetectionTraversal::evaluateInheritedAttribute(): astNode = %p = %s \n",astNode,astNode->class_name().c_str());
#endif
// DQ (2/3/2016): Recognize IR nodes that are representative of target DSL abstractions.
bool foundTargetDslAbstraction = DSL_Support::isDslAbstraction(astNode);
#if 1
printf ("In DetectionTraversal::evaluateInheritedAttribute(): astNode = %p = %s: foundTargetDslAbstraction = %s \n",astNode,astNode->class_name().c_str(),foundTargetDslAbstraction ? "true" : "false");
#endif
#if 0
// OLD CODE (represented by DSL_Support::isDslAbstraction() function).
// Detection of stencil declaration and stencil operator.
// Where the stencil specification is using std::vectors as parameters to the constructor, we have to first
// find the stencil declaration and read the associated SgVarRefExp to get the variable names used.
// Then a finite state machine can be constructed for each of the input variables so that we can
// interpret the state when the stencil operator is constructed.
SgVariableDeclaration* variableDeclaration = isSgVariableDeclaration(astNode);
if (variableDeclaration != NULL)
{
// Get the SgInitializedName from the SgVariableDeclaration.
SgInitializedName* initializedName = SageInterface::getFirstInitializedName(variableDeclaration);
SgType* base_type = initializedName->get_type()->findBaseType();
ROSE_ASSERT(base_type != NULL);
// SgClassType* classType = isSgClassType(initializedName->get_type());
SgClassType* classType = isSgClassType(base_type);
if (classType != NULL)
{
#if 1
printf ("In DetectionTraversal::evaluateInheritedAttribute(): case SgClassType: class name = %s \n",classType->get_name().str());
#endif
// Check if this is associated with a template instantiation.
SgTemplateInstantiationDecl* templateInstantiationDecl = isSgTemplateInstantiationDecl(classType->get_declaration());
if (templateInstantiationDecl != NULL)
{
#if 1
printf ("case SgTemplateInstaiationDecl: class name = %s \n",classType->get_name().str());
printf ("case SgTemplateInstaiationDecl: templateInstantiationDecl->get_templateName() = %s \n",templateInstantiationDecl->get_templateName().str());
#endif
// inheritedAttribute.set_StencilDeclaration(templateInstantiationDecl->get_templateName() == "Stencil");
// inheritedAttribute.set_StencilOperatorDeclaration(templateInstantiationDecl->get_templateName() == "StencilOperator");
if (templateInstantiationDecl->get_templateName() == "Stencil")
{
// DQ (2/8/2015): Ignore compiler generated IR nodes (from template instantiations, etc.).
// Note that simpleCNS.cpp generates one of these from it's use of the tuple template and associated template instantations.
// DQ: Test the DSL support.
ROSE_ASSERT(isMatchingClassType(classType,"Stencil",true) == true);
checkAndResetToMakeConsistantCompilerGenerated(initializedName);
if (initializedName->isCompilerGenerated() == false)
{
// Save the SgInitializedName associated with the stencil.
// stencilInitializedNameList.push_back(initializedName);
// inheritedAttribute.set_StencilDeclaration(true);
// foundStencilVariable = true;
#if 1
printf ("Detected Stencil<> typed variable: initializedName = %p name = %s \n",initializedName,initializedName->get_name().str());
// printf (" --- stencilInitializedNameList.size() = %zu \n",stencilInitializedNameList.size());
#endif
#if 1
initializedName->get_file_info()->display("In DetectionTraversal::evaluateInheritedAttribute(): initializedName : debug");
#endif
#if 0
Stencil_Attribute* dslAttribute = new Stencil_Attribute();
#if 1
printf ("Adding (Stencil) dslAttribute = %p \n",dslAttribute);
#endif
ROSE_ASSERT(dslAttribute != NULL);
// virtual void addNewAttribute (std::string s, AstAttribute *a);
initializedName->addNewAttribute(StencilVariable,dslAttribute);
#endif
}
}
}
SgClassDeclaration* classDeclaration = isSgClassDeclaration(classType->get_declaration());
if (classDeclaration != NULL)
{
if (classDeclaration->get_name() == "Point")
{
// Save the SgInitializedName associated with the Point type.
#if 0
printf ("Detected Point<> typed variable: initializedName = %p name = %s \n",initializedName,initializedName->get_name().str());
#endif
checkAndResetToMakeConsistantCompilerGenerated(initializedName);
if (initializedName->isCompilerGenerated() == false)
{
// pointInitializedNameList.push_back(initializedName);
#if 0
Point_Attribute* dslAttribute = new Point_Attribute();
printf ("Adding (Point) dslAttribute = %p \n",dslAttribute);
ROSE_ASSERT(dslAttribute != NULL);
// virtual void addNewAttribute (std::string s, AstAttribute *a);
initializedName->addNewAttribute(PointVariable,dslAttribute);
#endif
}
}
}
}
}
#endif
#if 1
printf ("Leaving DetectionTraversal::evaluateInheritedAttribute(): astNode = %p = %s \n",astNode,astNode->class_name().c_str());
#endif
// Construct the return attribute from the modified input attribute.
return Detection_InheritedAttribute(inheritedAttribute);
}