backend_proxy_loader.cpp

Go to the documentation of this file.

/***************************************
        Auteur : Pierre Aubert
        Mail : pierre.aubert@lapp.in2p3.fr
        Licence : CeCILL-C
****************************************/
 
#include "backend.h"
#include "backend_proxy_loader.h"


PString cpp_backendProxyLoaderHeader(const PString & libraryName, const PString & className){
        PString body(cpp_licenceSaveStr());
        PString baseMacro("__" + className.toUpper() + "_H__");
        body += "#ifndef " + baseMacro + "\n";
        body += "#define " + baseMacro + "\n\n";
        body += "#include <string>\n\n\n";
        body += "///@brief Class which loads automatically the right sub-library of "+libraryName+"\n";
        body += "class "+className+"{\n";
        body += "\tpublic:\n";
        body += "\t\t"+className+"();\n";
        body += "\t\tvirtual ~"+className+"();\n";
        body += "\t\t\n";
        body += "\t\tbool load(const std::string & libName);\n";
        body += "\t\tbool parseArchFile(const std::string & archfileName);\n";
        body += "\t\tbool isOpen() const;\n";
        body += "\t\tvoid close();\n";
        body += "\t\t\n";
        body += "\t\tvoid updateFunction();\n";
        body += "\tprivate:\n";
        body += "\t\tvoid initialisation"+className+"();\n";
        body += "\t\t\n";
        body += "\t\t///Handle of the library we load\n";
        body += "\t\tvoid* p_handle;\n";
        body += "};\n\n";
        body += "#endif\n\n";
        return body;
}


PString cpp_backendProxyLoaderConstructorSource(const PString & className, const PString & defaultLib){
        PString body("");
        body += "///Default constructor of "+className+"\n";
        body += className+"::"+className+"(){\n";
        body += "\tinitialisation"+className+"();\n";
        body += "\tstd::cout << \""+className+"::"+className+"() : check current architecture\" << std::endl;\n";
        body += "\t//First get the /proc/cpuinfo file\n";
        body += "\tif(!parseArchFile(\"/proc/cpuinfo\")){\n";
        body += "\t\t//No library found, let's load the default library\n";
        body += "\t\tload(\""+defaultLib+"\");\n";
        body += "\t}\n";
        body += "\tupdateFunction();\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderDesonstructorSource(const PString & className){
        PString body("");
        body += "///Destructor of "+className+"\n";
        body += ""+className+"::~"+className+"(){\n";
        body += "\tclose();\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderLoadSource(const PString & className){
        PString body("");
        body += "///Load the given library\n";
        body += "/**\t@param libName : name of the library to be loaded\n";
        body += "* \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "bool "+className+"::load(const std::string & libName){\n";
        body += "\tif(libName == \"\"){return false;}\n";
        body += "\tp_handle = dlopen(libName.c_str(), RTLD_LAZY);\n";
        body += "\tstd::cout << \""+className+"::load : loading library '\"<<libName<<\"'\" << std::endl;\n";
        body += "\tif(p_handle == NULL){\n";
        body += "\t\tfprintf(stderr, \""+className+"::load : %s\\n\", dlerror());\n";
        body += "\t\treturn false;\n";
        body += "\t}\n";
        body += "\tdlerror();    //Erase an exsiting error\n";
        body += "\treturn true;\n";
        body += "}\n\n";
        return body;
}
 


PString cpp_backendProxyLoaderParseArchFileSource(const PVecArchLib & vecArchLib, const PString & className, const PPath & libDir){
        PString body("");
        body += "///Parse the given architecture file\n";
        body += "/**\t@param archfileName : name of the architecture file to be loaded\n";
        body += "* \t@return true on success, false otherwise\n";
        body += "*/\n";
        body += "bool "+className+"::parseArchFile(const std::string & archfileName){\n";
        body += "\tFILE * fp = fopen(archfileName.c_str(), \"r\");\n";
        body += "\tif(fp == NULL){\n";
        body += "\t\tstd::cerr << \"Cannot open file '\" << archfileName << \"'\" << std::endl;\n";
        body += "\t\treturn false;\n";
        body += "\t}\n";
        
        body += "\tstd::string bufferAllFile(\"\");\n";
        body += "\tint buffer;\n";
        body += "\twhile(!feof(fp)){\n";
        body += "\t\tbuffer = fgetc(fp);\n";
        body += "\t\tif(buffer != EOF) bufferAllFile += (char)buffer;\n";
        body += "\t\telse break;\n";
        body += "\t}\n";
        body += "\tif(bufferAllFile == \"\"){\n";
        body += "\t\tstd::cerr << \"Empty file '\" << archfileName << \"'\" << std::endl;\n";
        body += "\t\treturn false;\n\t}\n";
        body += "\tconst char * procCpuInfo = bufferAllFile.c_str();\n";
        //The following method does not work with text file for some reason
//      body += "\t//Let's get the file size\n";
//      body += "\tfseek(fp, 0, SEEK_END);\n";
//      body += "\tsize_t fileSize(ftell(fp));\n";
//      body += "\tfseek(fp, 0, SEEK_SET);\n";
//      body += "\tif(fileSize == 0lu){\n";
//      body += "\t\tstd::cerr << \"Empty file '\" << archfileName << \"'\" << std::endl;\n";
//      body += "\t\treturn false;\n";
//      body += "\t}\n";
//      body += "\t//Now we can alloate the table to get the file content\n";
//      body += "\tchar * procCpuInfo = new char[fileSize];\n";
//      body += "\t//And load the file\n";
//      body += "\tif(fread(procCpuInfo, sizeof(char), fileSize, fp) != fileSize){\n";
//      body += "\t\tstd::cerr << \"Cannot read file '\" << archfileName << \"'\" << std::endl;\n";
//      body += "\t\treturn false;\n\t}\n";
        
        body += "\t//Let's check the avalaible architectures\n";
        body += "\tbool isLibFound(true);\n";
        PString strElse("\t"), libraryFullDirectory("");
        if(libDir != ""){
                libraryFullDirectory = libDir + "/";
        }
        for(PVecArchLib::const_reverse_iterator it(vecArchLib.rbegin()); it != vecArchLib.rend(); ++it){
                body += strElse + "if(strstr(procCpuInfo, \""+it->getArchitecture()+"\") != NULL){\n";
                PPath libName(libraryFullDirectory + it->getName().getFileName());
                body += "\t\tload(\""+libName+"\");\n";
                body += "\t}";
                strElse = "else ";
        }
        body += "else{\n\t\tisLibFound = false;\n\t}\n";
        body += "\n";
        body += "\tfclose(fp);\n";
//      body += "\tdelete [] procCpuInfo;\n";
        body += "\treturn isLibFound;\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderIsOpenSource(const PString & className){
        PString body("");
        body += "///Say if the current library is opened or not\n";
        body += "/**\t@return true if the current library is opened, false otherwise\n";
        body += "*/\n";
        body += "bool "+className+"::isOpen() const{\n";
        body += "\treturn p_handle != NULL;\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderCloseSource(const PString & className){
        PString body("");
        body += "///Close the current library\n";
        body += "void "+className+"::close(){\n";
        body += "\tif(isOpen()){\n";
        body += "\t\tdlclose(p_handle);\n";
        body += "\t}\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderUpdateSource(const PString & className, const PVecSource & vecSource){
        PString body("");
        body += "///Update the functions to be used\n";
        body += "void "+className+"::updateFunction(){\n";
        body += "\tif(!isOpen()){exit(-1);return;}\n";
        body += "\t//Then set all the function pointers\n";
        for(PVecSource::const_iterator it(vecSource.begin()); it != vecSource.end(); ++it){
                body += "\t"+getUpdateFunction(it->getName())+"(p_handle);\n";
        }
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderInitialisationSource(const PString & className){
        PString body("");
        body += "///Initialisation function of the class "+className+"\n";
        body += "void "+className+"::initialisation"+className+"(){\n";
        body += "\tp_handle = NULL;\n";
        body += "}\n\n";
        return body;
}


PString cpp_backendProxyLoaderSource(const PVecSource & vecSource, const PVecArchLib & vecArchLib,
                                        const PString & className, const PString & libDir)
{
        PString body(cpp_licenceSaveStr());
        body += "#include <stdio.h>\n";
        body += "#include <stdlib.h>\n";
        body += "#include <dlfcn.h>\n";
        body += "#include <string.h>\n\n";
        
        for(PVecSource::const_iterator it(vecSource.begin()); it != vecSource.end(); ++it){
                body += "#include \""+it->getName()+".h\"\n";
        }
        body += "\n#include \""+className+".h\"\n\n";
        body += "///Variable which will load automatically the right library by respect to the given architecture\n";
        body += className + " PROXY_LOADER;\n\n";
        PString defaultLib(getLibraryFile(vecArchLib).getFileName());
        body += cpp_backendProxyLoaderConstructorSource(className, defaultLib);
        body += cpp_backendProxyLoaderDesonstructorSource(className);
        body += cpp_backendProxyLoaderLoadSource(className);
        body += cpp_backendProxyLoaderParseArchFileSource(vecArchLib, className, libDir);
        body += cpp_backendProxyLoaderIsOpenSource(className);
        body += cpp_backendProxyLoaderCloseSource(className);
        body += cpp_backendProxyLoaderUpdateSource(className, vecSource);
        body += cpp_backendProxyLoaderInitialisationSource(className);
        return body;
}


bool cpp_backend_proxy(const PVecSource & vecSource, const PString & libraryName, const PVecArchLib & vecArchLib, const PPath & libDir, const PPath & outputDir){
        PString className(PString(libraryName + "ProxyLoader").firstToUpper());
        PString headerSrc(cpp_backendProxyLoaderHeader(libraryName, className));
        PString sourceSrc(cpp_backendProxyLoaderSource(vecSource, vecArchLib, className, libDir));
        PPath outputHeaderFile(outputDir + "/" + className + ".h");
        PPath outputSourceFile(outputDir + "/" + className + ".cpp");
        if(!outputHeaderFile.saveFileContent(headerSrc)){
                std::cerr << "cpp_backend : cannot save header file '"<<outputHeaderFile<<"'" << std::endl;
                return false;
        }
        if(!outputSourceFile.saveFileContent(sourceSrc)){
                std::cerr << "cpp_backend : cannot save source file '"<<outputSourceFile<<"'" << std::endl;
                return false;
        }
        return true;
}