StateManager.hpp

Go to the documentation of this file.

#if !defined(__STATEMANAGER_HPP)
#define __STATEMANAGER_HPP

#include <string>
#include <map>

#include "rose.h"

#include "rose2xaif_config.hpp"
#include "util/Types.hpp"
#include "util/Utils.hpp"
#include "util/LogicException.hpp"
#if 0
#include "xaif/SoapXAIFInterface.hpp"
#endif

#define VALUE_TYPE "ValType"
#define GRAD_TYPE "GradType"

#define INACTIVE_DOUBLE_TYPE "InactiveDouble"
#define INACTIVE_FLOAT_TYPE "InactiveFloat"

#define ACTIVE_FUNCTIONS_S "ACTIVE_FUNCTIONS"
#define INACTIVE_FUNCTIONS_S "INACTIVE_FUNCTIONS"
#define INTRINSIC_FUNCTIONS_S "INTRINSIC_FUNCTIONS"
#define ACTIVE_VARIABLE_S "ACTIVE_VARIABLES"
#define DEFINES_S "DEFINES"
#define UNINLINE_INCLUDES_S "UNINLINE_INCLUDES"
#define GENERAL_S "GENERAL"
#define UNEXPANDED_MACROS_S "UNEXPANDED_MACROS"

#define SYSTEM_S "SYSTEM"
#define MODULES_S "MODULES"
#define IGNORE_FUNCTIONS_S "IGNORE_FUNCTIONS"
#define NO_PREFIX_FUNCTIONS_S "NO_PREFIX_FUNCTIONS"
#define SOURCE_FILES_S "SOURCE_FILES"
#define INTRINSIC_CONTROL_S "INTRINSIC_CONTROL"
#define STANDARD_INCLUDES_S "STANDARD_INCLUDES"
#define INACTIVE_TYPES_S "INACTIVE_TYPES"
#define INACTIVE_VARIABLES_S "INACTIVE_VARIABLES"

#define INCLUDE_STR "INCLUDE"
#define DERIV_TYPE_STR "DERIV_TYPE"

#define STRUCTURE_TYPE_STR "structure"
#define CLASS_TYPE_STR "class"

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

namespace rose2xaif {

typedef std::map<std::string, std::string> StringMap;
typedef std::map<std::string, StringMap> InitManager;
typedef std::map<std::string, StringPairList> InitManagerList;

/*
 const char * optv[] = {
 "v:verbose <number>",
 "m:module <string",
 NULL
 };
 */

enum{R_ONLY, CN_ONLY, CN_PP, CN_XB_PP};

class StateManager
{

 // Singleton object management:
 public:
 static StateManager*
 getInstance(const char* argv0 = "rose2xaif.exe");

 protected:
 StateManager(const std::string& argv0 = "rose2xaif.exe");

 private:
 static StateManager * p_instance;
 unsigned int debugLevel;
 std::string msgContext;
 bool quiet;
 bool openMPflag;
 bool sparsehandlingflag;
 bool admmflag;
 std::string differentiationMode;
 bool myStaticAnnotationsFlag;
 bool myNeedClassInitializationHeaderFlag;

 public:
 // Data
 int flags;
 int nDerivOrder;

 std::string prefix;
 std::string varPrefix;
 std::string classPrefix;
 std::string typePrefix;
 std::string funcPrefix;
 std::string mapModel;
 std::string headerFileName; // main generated header
 std::string defaultInitFile; // default control file
 std::string archInitFile; // architecture-specific init file
 std::string baseDir; // Rose2XAIF installation directory
 std::string arch; // architecture
 int comment_group_size;

 static StringList activeVarNames;
 static StringList inactiveVarNames;
 static StringList activeFuncNames;
 static StringList inactiveFuncNames;
 static StringList noPrefixFuncNames;
 static StringList intrinsicNames;
 static StringList uninlinedIncludeNames;
 static StringList inactiveTypeNames;
 static StringList inactiveBasicTypeNames;
 static StringList inactiveStructureTypeNames;
 static StringList inactiveClassTypeNames;
 static StringList standardIncludeNames;
 static StringList includeDirs;
 static StringList controlFiles;
 static StringList initFileList;
 static StringList tempFileNames;
 static StringList roseOptions;
 static StringList xaifBoosterOptions;


 std::string strMacroDefinesLine;
 std::string strIntrinsicMode;

 std::string gstrUnexpandedMacros;
 std::string strGuard;
 
 //Sparse options set to differentiate between SparsLinC and no grad SparsLinC
 std::string sparsederivtypename;
 std::string sparsederivtypefunctionprefix;
 std::string sparseincludeheader;
 bool naryflag;
 int max_axpy;
 bool adolcflag;


 static const char* ourValWrapperName;
 static const char* ourDerivWrapperName;

 /*
 * Stores the list of ADOLC external functions to be differentiated
 */
 std::list<std::string> ADOLCExternalFunctionNames;
 private:
 // XAIF
 std::string xaifSchemaLocation;
 std::string xaifInlinableIntrinsicsFile;
 std::string xaifNonInlinableIntrinsicsFile;
 std::string xaifModule;
 std::string templateFileName;
 // Miscellaneous
 bool leaveTempFiles;
 int workflow;

 //SHK - This flag keep track of the filename option.
 bool inputFileTypeIsC; // True is the input file name is .c/.C and false otherwise.
 public:
 SgFile * myTemplateSgFile_p;
 public:
 ~StateManager()
 {
 }

 void init(int flags, StringList& derivNames, std::string mapModel,
 std::string headerFile, StringList& defines,
 StringList& dirs, /*StringList& controlScripts,*/ int derivOrder);

 InitManager initManager;
 InitManagerList initManagerList;
 // Flags
 enum
 {
 SAGE_SRC_F, //start with Sage++ parser output
 CPLUSPLUS_F, //generating C++
 USE_GCC_F, //use gcc preprocessor
 NO_INLINE_USER_INCLUDE_F, //do not inline user include file
 LEAVE_SCRATCH_FILES_F,
 OPTIMIZE_F,
 NO_MAIN_FILE_F,
 MPI_F,
 LEAVE_RAW_FILE_F,
 NO_HEADER_F,
 NO_INACTIVE_FUNC_DEF_F,
 USE_GC_F,
 ADJOINT_F,
 USE_GUARD_F,
 ENUM_FIX_F,
 POINTER_F,
 SPARSE_F,
 SCALAR_GRAD_F
 };

 int isFlag(int f) const
 {
 return flags & (1 << f);
 }

 void setFlag(int f)
 {
 flags |= (1 << f);
 }

 /* Get the value for a given section and key */
 std::string getString(const char *sectionName, std::string key);

 /* Collect names of all active functions specified in the init files.
 The names of intrinsic functions are added here also. */
 static StringList&
 getActiveFuncNames();
 static bool isActiveFuncName(std::string str);

 /* Collect names of all active functions specified in the init files.
 The names of intrinsic functions are added here also. */
 static StringList&
 getInactiveFuncNames();

 /* Checks whether the typename is in the list of inactive typename lists.
 */
 static bool isInactiveFuncName(std::string str);
 static bool isInactiveFuncName(const char* str)
 {
 return isInactiveFuncName(std::string(str));
 }

 /* Collect names of all active variables specified in the init files. */
 static StringList&
 getActiveVarNames();

 /* Collect names of all active variables specified in the init files. */
 static StringList&
 getInactiveVarNames();


 /* Checks whether the function name is in the list of intrinsic
 lists. */
 static bool isIntrinsicName(std::string str);
 static void addIntrinsicName(std::string str);

 /* Collect the function names that are not to be changed */
 static StringList&
 getNoPrefixFuncNames();
 
 /* Checks whether the funcname is in the list of NoPrefix funcname lists.
 */
 static bool isNoPrefixFuncName(std::string psz);


 /* Collect the names of user include files that should not be inlined. */
 static StringList&
 getUninlinedIncludeNames();

 /* Collect the names of inactive types. Also add default
 inactive float types. */
 static StringList&
 getInactiveTypeNames();
 
 /* Checks whether the typename is in the list of inactive typename lists.
 */
 static bool isInactiveTypeName(const char* psz);

 /* Checks whether the typename should be followed into.
 */
 static bool isNoFollowTypeName(const char* psz);

 /* We collect the names of user include files which are "standard"
 (e.g., mpi.h). These names are also added to the no-inline list. */
 static StringList&
 getStandardIncludeNames();

 /* Collect all the include directories. */
 static StringList&
 getIncludeDirs();

 /*Check if any of the includes is a substring of fname*/
 bool isFromIncludeDirs(std::string fname);
 
 /* Collect all control file names. */
 static StringList&
 getControlFiles();
 
 /* Build a line that defines macros to be sent to the C preprocessor
 and returns it. */
 std::string getMacroDefinesLine()
 {
 return strMacroDefinesLine;
 }

 /* Get the mapping model */
 enum
 {
 MAP_COUPLED, MAP_ASSOC
 };

 std::string getHeaderFileName();

 /* Get the default value for the derivative order */
 int getDerivOrder() const;
 /* Set the derivative order */
 void setDerivOrder(int derivOrder)
 {
 nDerivOrder = derivOrder;
 }

 const char*
 getPrefix()
 {
 return prefix.c_str();
 }
 const char*
 getVarPrefix()
 {
 return varPrefix.c_str();
 }
 const char*
 getClassPrefix()
 {
 return classPrefix.c_str();
 }
 const char*
 getTypePrefix()
 {
 return typePrefix.c_str();
 }
 const char*
 getFuncPrefix()
 {
 return funcPrefix.c_str();
 }
 int getCommentGroup()
 {
 return comment_group_size;
 }

 void
 setPrefix(std::string val)
 {
 prefix = val;
 }
 void
 setVarPrefix(std::string val)
 {
 varPrefix = val;
 }
 void
 setClassPrefix(std::string val)
 {
 classPrefix = val;
 }
 void
 setTypePrefix(std::string val)
 {
 typePrefix = val;
 }
 void
 setFuncPrefix(std::string val)
 {
 funcPrefix = val;
 }
 void setCommentGroup(int val)
 {
 comment_group_size = val;
 }

 void load(std::string initFilename);

 std::string getDifferentiationMode() const
 {
 return differentiationMode;
 }
 void setDifferentiationMode(std::string a_differentiationMode)
 {
 differentiationMode = a_differentiationMode;
 }

 /* Context for diagnostic messages */
 std::string getContext()
 {
 return msgContext;
 }
 void setContext(std::string context)
 {
 msgContext = std::string(context);
 }

 /* Generate disclaimer that will be prepended to all Rose2XAIF-generated code */
 std::string getDisclaimer();

 /* Generate a header file with dense AXPY definitions */
 void generateDenseAXPYHeader();

 /* Generate a header file with sparse AXPY definitions */
 void generateSparseAXPYHeader();

 /* Get/set quiet flag */
 void setQuiet(bool v)
 {
 quiet = v;
 }
 bool isQuiet()
 {
 return quiet;
 }
 unsigned int getDebugLevel() const
 {
 return debugLevel;
 }
 void setDebugLevel(unsigned int a_debugLevel)
 {
 debugLevel = a_debugLevel;
 }
 void setTemplate(SgFile *templateptr) {
 if (myTemplateSgFile_p) {
 THROW_LOGICEXCEPTION_MACRO("StateManager::setTemplate: already set");
 }
 myTemplateSgFile_p = templateptr;
 }
 SgFile * getTemplate() {
 if (!myTemplateSgFile_p) {
 THROW_LOGICEXCEPTION_MACRO("StateManager::getTemplate: not set");
 }
 return myTemplateSgFile_p;
 }
 void setTemplateFileName(std::string file)
 {
 templateFileName = file;
 }
 std::string getTemplateFile()
 {
 return templateFileName;
 }
 std::string getDifferentiationModule()
 {
 return xaifModule;
 }
 void setDifferentiationModule(std::string module)
 {
 xaifModule = module;
 }
 std::string getXaifSchemaLocation()
 {
 return xaifSchemaLocation;
 }
 void setXaifSchemaLocation(std::string location)
 {
 xaifSchemaLocation = location;
 }
 void setXaifInlinableIntrinsicsFile(std::string file)
 {
 xaifInlinableIntrinsicsFile = file;
 }
 std::string getXaifInlinableIntrinsicsFileName()
 {
 return xaifInlinableIntrinsicsFile;;
 }
 void setXaifNonInlinableIntrinsicsFile(std::string file)
 {
 xaifNonInlinableIntrinsicsFile = file;
 }
 std::string getXaifNonInlinableIntrinsicsFileName()
 {
 return xaifNonInlinableIntrinsicsFile;;
 }
 StringList& getXaifBoosterOptions()
 {
 return xaifBoosterOptions;
 }
 void setXaifBoosterOptions(StringList val)
 {
 xaifBoosterOptions = val;
 }
 StringList& getRoseOptions()
 {
 return roseOptions;
 }
 void setRoseOptions(StringList val)
 {
 roseOptions = val;
 }
 bool getInputFileTypeIsC()
 {
 return inputFileTypeIsC;
 }
 void setInputFileTypeIsC(bool flag)
 {
 inputFileTypeIsC = flag;
 }
 int getWorkflow()
 {
 return workflow;
 }
 void setWorkflow(int val)
 {
 workflow = val;
 }

 bool getOpenMPFlag()
 {
 return openMPflag;
 }
 void setOpenMPFlag(bool flag)
 {
 openMPflag = flag;
 }
 bool getSparseHandlingFlag()
 {
 return sparsehandlingflag;
 }
 void setSparseHandlingFlag(bool flag)
 {
 sparsehandlingflag = flag;
 }
 void setNeedClassInitializationHeaderFlag(bool flag){
 myNeedClassInitializationHeaderFlag = flag;
 }
 bool getNeedClassInitializationHeaderFlag(){
 return myNeedClassInitializationHeaderFlag;
 }
 bool getAdmmFlag()
 {
 return admmflag;
 }
 void setAdmmFlag(bool flag)
 {
 admmflag = flag;
 }

 std::list<SgStatement*> markedStatements;

#ifdef AD_FORTRAN_SPECIFIC 
 static SgType* makeActiveSgTypeP(SgFile* aFileP);
#endif
 void setStaticAnnotations() {
 myStaticAnnotationsFlag=true;
 }
 bool staticAnnotations() {
 return myStaticAnnotationsFlag;
 }

 /*
 * Generates the header file for ADOL-C input external functions
 */
 void generateRegistrationFunctionsHeader();
 /*
 * Generates the source file for ADOL-C input external functions
 */
 void generateRegistrationFunctionsSource();
 /*
 * Generates the function string for the original function call wrapper
 */
 std::string getZosfString(std::string functionname);
 /*
 * Generates the function string for scalar mode driver
 */
 std::string getFosfString(std::string functionname);
 /*
 * Generates the function string for vector mode driver
 */
 std::string getFovfString(std::string functionname);
 /*
 * Generates the function string for registering the driver functions
 */
 std::string getRegistrationFunctionString(std::string functionname);

};

} // namespace rose2xaif

#endif /* __STATEMANAGER_HPP */