CompiledSimCompiler Class Reference

#include <CompiledSimCompiler.hh>

Collaboration diagram for CompiledSimCompiler:

Public Member Functions
	CompiledSimCompiler ()
virtual	~CompiledSimCompiler ()
int	compileDirectory (const std::string &dirName, const std::string &flags="", bool verbose=false) const
int	compileFile (const std::string &path, const std::string &flags="", const std::string &outputExtension=".o", bool verbose=false) const
int	compileToSO (const std::string &path, const std::string &flags="", bool verbose=false) const

Static Public Attributes
static const char *	COMPILED_SIM_CPP_FLAGS
	cpp flags used for compiled simulation More...
static const char *	COMPILED_SIM_SO_FLAGS = " -shared -fpic "
	flags used when compiling .so files More...

Private Member Functions
	CompiledSimCompiler (const CompiledSimCompiler &)
	Copying not allowed. More...
CompiledSimCompiler &	operator= (const CompiledSimCompiler &)
	Assignment not allowed. More...

Private Attributes
int	threadCount_
	Number of threads to use while compiling through a Makefile. More...
std::string	compiler_
	The compiler to use. More...
std::string	globalCompileFlags_
	Global compile flags (from env variable) More...

Detailed Description

A class for compiling the dynamic libraries used by the compiled simulator

Definition at line 41 of file CompiledSimCompiler.hh.

Constructor & Destructor Documentation

CompiledSimCompiler() [1/2]

CompiledSimCompiler::CompiledSimCompiler

(

)

The constructor

Definition at line 79 of file CompiledSimCompiler.cc.

                                         {
    
    // Get number of threads
    threadCount_ = 3;
    std::string USER_THREAD_COUNT = 
        Environment::environmentVariable("TTASIM_COMPILER_THREADS");
    if (USER_THREAD_COUNT != "") {
        threadCount_ = Conversion::toInt(string(USER_THREAD_COUNT));
    }
    
    // Get compiler
    compiler_ = "g++";
    std::string USER_COMPILER = 
        Environment::environmentVariable("TTASIM_COMPILER");
    if (USER_COMPILER != "") {
        compiler_ = string(USER_COMPILER);
    }
    
    // Get global compile flags
    globalCompileFlags_ = " -O0 ";
    std::string fl = 
        Environment::environmentVariable("TTASIM_COMPILER_FLAGS");
    if (fl != "")
        globalCompileFlags_ = std::string(fl);
}

References compiler_, Environment::environmentVariable(), globalCompileFlags_, threadCount_, and Conversion::toInt().

Here is the call graph for this function:

~CompiledSimCompiler()

CompiledSimCompiler::~CompiledSimCompiler ( )

virtual

The destructor

Definition at line 108 of file CompiledSimCompiler.cc.

                                          {
}

CompiledSimCompiler() [2/2]

CompiledSimCompiler::CompiledSimCompiler ( const CompiledSimCompiler &  )

private

Copying not allowed.

Member Function Documentation

compileDirectory()

int CompiledSimCompiler::compileDirectory	(	const std::string &	dirName,
		const std::string &	flags = "",
		bool	verbose = false
	)		const

Compiles a directory with given flags using a pre-generated makefile

In case environment variable TTASIM_COMPILER is set, it is used to compile the simulation code, otherwise 'gcc' is used. The count of compiler threads is read from TTASIM_COMPILER_THREADS, and defaults to 3.

Parameters

dirName	a source directory containing the .cpp files and the Makefile
flags	additional compile flags given by the user. for instance, "-O3"
verbose	Print information of the compilation progress.

Returns

Return value given by system(). 0 on success. !=0 on failure

Definition at line 125 of file CompiledSimCompiler.cc.

                        {
 
    string command = 
        "make -sC " + dirName + " CC=\"" + compiler_ + "\" opt_flags=\"" +
        globalCompileFlags_ + " " + flags + " \" -j" +
        Conversion::toString(threadCount_);
 
    if (verbose) {
        Application::logStream()
            << "Compiling the simulation engine with command " 
            << command << endl;
    }
 
    time_t startTime = std::time(NULL);
    int retval = system(command.c_str());
    time_t endTime = std::time(NULL);
 
    time_t elapsed = endTime - startTime;
 
    if (verbose) {
        Application::logStream()
            << "Compiling the simulation engine with opt. switches '"
            << globalCompileFlags_ << " " << flags 
            << "' took " << elapsed / 60 << "m " << (elapsed % 60) << "s " 
            << endl;
    }
 
    return retval;
}

References compiler_, globalCompileFlags_, Application::logStream(), threadCount_, and Conversion::toString().

Referenced by CompiledSimController::reset().

Here is the call graph for this function:

compileFile()

int CompiledSimCompiler::compileFile	(	const std::string &	path,
		const std::string &	flags = "",
		const std::string &	outputExtension = ".o",
		bool	verbose = false
	)		const

Compiles a single C++ file using the set flags

Parameters

path	Path to the file
flags	custom flags to be used for compiling
outputExtension	extension to append to the filename. default is ".o"
verbose	Print information of the compilation progress.

Returns

Return value given by system() call. 0 on success. !=0 on failure

Definition at line 168 of file CompiledSimCompiler.cc.

                        {
 
    std::string directory = FileSystem::directoryOfPath(path);
    std::string fileNameBody = FileSystem::fileNameBody(path);
    std::string fileName = FileSystem::fileOfPath(path);   
    std::string DS = FileSystem::DIRECTORY_SEPARATOR;
    
    // Get includes
    vector<string> includePaths = Environment::includeDirPaths();
    string includes;
    for (vector<string>::const_iterator it = includePaths.begin(); 
        it != includePaths.end(); ++it) {
        includes += "-I" + *it + " ";
    }
 
    if (verbose) {
        Application::logStream() << "Compiling simulation file " 
            << path << endl;
    }
    
    string command = compiler_ + " " + includes + COMPILED_SIM_CPP_FLAGS
        + globalCompileFlags_ + " " + flags + " " 
        + path + " -o " + directory + DS + fileNameBody + outputExtension;
    
    return system(command.c_str());
}

References COMPILED_SIM_CPP_FLAGS, compiler_, FileSystem::DIRECTORY_SEPARATOR, FileSystem::directoryOfPath(), DS, FileSystem::fileNameBody(), FileSystem::fileOfPath(), globalCompileFlags_, Environment::includeDirPaths(), and Application::logStream().

Referenced by compileToSO(), and CompiledSimController::reset().

Here is the call graph for this function:

compileToSO()

int CompiledSimCompiler::compileToSO	(	const std::string &	path,
		const std::string &	flags = "",
		bool	verbose = false
	)		const

Compiles a single C++ file to a shared library (.so)

Used for generating .so files in dynamic compiled simulation

Parameters

path	Path to the file
flags	custom flags to be used for compiling
verbose	Print information of the compilation progress.

Returns

Return value given by system() call. 0 on success. !=0 on failure

Definition at line 210 of file CompiledSimCompiler.cc.

                        {
 
    return compileFile(path, COMPILED_SIM_SO_FLAGS + flags, ".so", verbose);
}

References COMPILED_SIM_SO_FLAGS, and compileFile().

Referenced by CompiledSimulation::compileAndLoadFunction(), and CompiledSimController::reset().

Here is the call graph for this function:

operator=()

CompiledSimCompiler& CompiledSimCompiler::operator= ( const CompiledSimCompiler &  )

private

Assignment not allowed.

Member Data Documentation

COMPILED_SIM_CPP_FLAGS

const char * CompiledSimCompiler::COMPILED_SIM_CPP_FLAGS

static

Initial value:

= " -fpic -std=c++11 "
 
 
    " -fno-working-directory "
    "-fno-enforce-eh-specs "
 
    "-fno-rtti -DNDEBUG "

cpp flags used for compiled simulation

Definition at line 63 of file CompiledSimCompiler.hh.

Referenced by compileFile(), and CompiledSimCodeGenerator::generateMakefile().

COMPILED_SIM_SO_FLAGS

const char * CompiledSimCompiler::COMPILED_SIM_SO_FLAGS = " -shared -fpic "

static

flags used when compiling .so files

Definition at line 66 of file CompiledSimCompiler.hh.

Referenced by compileToSO(), and CompiledSimCodeGenerator::generateMakefile().

compiler_

std::string CompiledSimCompiler::compiler_

private

The compiler to use.

Definition at line 77 of file CompiledSimCompiler.hh.

Referenced by compileDirectory(), CompiledSimCompiler(), and compileFile().

globalCompileFlags_

std::string CompiledSimCompiler::globalCompileFlags_

private

Global compile flags (from env variable)

Definition at line 79 of file CompiledSimCompiler.hh.

Referenced by compileDirectory(), CompiledSimCompiler(), and compileFile().

threadCount_

int CompiledSimCompiler::threadCount_

private

Number of threads to use while compiling through a Makefile.

Definition at line 75 of file CompiledSimCompiler.hh.

Referenced by compileDirectory(), and CompiledSimCompiler().

---

The documentation for this class was generated from the following files:

• CompiledSimCompiler.hh
• CompiledSimCompiler.cc