lauchParallelThread_impl.h File Reference

#include <iostream>
#include <fstream>
#include <sstream>
#include "phoenix_vector_split.h"
#include "lauchParallelThread.h"

Include dependency graph for lauchParallelThread_impl.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
template<typename T, typename _Callable, typename... _Args>
void	lauchParallelThread (const std::vector< T > &listInputPTabModelFile, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Lauch the callable function __f on nbThread threads with __args to be passed to each thread.
template<typename T, typename _Callable, typename... _Args>
void	lauchParallelThread (std::vector< T > &listInputPTabModelFile, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Lauch the callable function __f on nbThread threads with __args to be passed to each thread.
template<typename _Callable, typename... _Args>
bool	lauchParallelThreadLog (const PPath &baseOutputName, const PPath &fileSuffix, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Launch the callable function __f on nbThread threads with __args to be passed to each thread.
template<typename _Callable, typename... _Args>
bool	lauchParallelThreadLog (const PPath &logFile, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Lauch the callable function __f on nbThread threads with __args to be passed to each thread.
template<typename _Callable, typename... _Args>
bool	lauchParallelThreadLog (const std::vector< PPath > &listInputPTabModelFile, const PPath &baseOutputName, const PPath &fileSuffix, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Lauch the callable function __f on nbThread threads with __args to be passed to each thread.
template<typename _Callable, typename... _Args>
bool	lauchParallelThreadLog (const std::vector< PPath > &listInputPTabModelFile, const PPath &logFile, long unsigned int nbThread, _Callable &&__f, _Args &&... __args)
	Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Function Documentation

lauchParallelThread() [1/2]

template<typename T, typename _Callable, typename... _Args>

void lauchParallelThread	(	const std::vector< T > &	listInputPTabModelFile,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

listInputPTabModelFile	: list of all files to be processed by the threads, this list will be split between each thread
nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
__f	: function to be lauched on each thread (function with prototype void f(const std::vector<PPath>& listFile, __args); )
__args	: extra arguments to be passed to the function __f (optional arguments) This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f

Definition at line 27 of file lauchParallelThread_impl.h.

                                                                                                                                     {
        if(nbThread == 0lu){return;}
        if(nbThread == 1lu){
                __f(listInputPTabModelFile, __args...);
                return;
        }
        std::vector<std::vector<T> > listInputFilePerThread;
        phoenix_vector_split(listInputFilePerThread, listInputPTabModelFile, nbThread);
        nbThread = listInputFilePerThread.size();       //In case we need less thread than required
        std::vector<std::thread> tabThread;
        tabThread.resize(nbThread);
        for(long unsigned int i(0lu); i < nbThread; ++i){
                tabThread[i] = std::thread(__f, listInputFilePerThread[i], __args...);
        }
        for(long unsigned int i(0lu); i < nbThread; ++i){
                tabThread[i].join();
        }
}

Referenced by phoenix_program_callParallel().

Here is the caller graph for this function:

lauchParallelThread() [2/2]

template<typename T, typename _Callable, typename... _Args>

void lauchParallelThread	(	std::vector< T > &	listInputPTabModelFile,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

[out]	listInputPTabModelFile	: list of all files to be processed by the threads, this list will be split between each thread
	nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
	__f	: function to be lauched on each thread (function with prototype void f(const std::vector<PPath>& listFile, __args); )
	__args	: extra arguments to be passed to the function __f (optional arguments) This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f

Definition at line 55 of file lauchParallelThread_impl.h.

                                                                                                                               {
        if(nbThread == 0lu){return;}
        if(nbThread == 1lu){
                __f(listInputPTabModelFile, __args...);
                return;
        }
        std::vector<std::vector<T> > listInputFilePerThread;
        phoenix_vector_split(listInputFilePerThread, listInputPTabModelFile, nbThread);
        nbThread = listInputFilePerThread.size();       //In case we need less thread than required
        std::vector<std::thread> tabThread;
        tabThread.resize(nbThread);
        for(long unsigned int i(0lu); i < nbThread; ++i){
                tabThread[i] = std::thread(__f, std::ref(listInputFilePerThread[i]), __args...);
        }
        for(long unsigned int i(0lu); i < nbThread; ++i){
                tabThread[i].join();
        }
}

lauchParallelThreadLog() [1/4]

template<typename _Callable, typename... _Args>

bool lauchParallelThreadLog	(	const PPath &	baseOutputName,
		const PPath &	fileSuffix,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Launch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

baseOutputName	: base of the log file output name
fileSuffix	: suffix of the log file output name (can be anything such as file extention)
nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
__f	: function to be lauched on each thread (function with prototype void f(std::ofstream & fs, __args); )
__args	: extra arguments to be passed to the function __f (optional arguments)

Returns

true if all output file where opened with success, false otherwise This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f Each thread will have a std::ofstream to write a separate file

Definition at line 167 of file lauchParallelThread_impl.h.

{
        if(nbThread == 0lu){return true;}
        if(nbThread == 1lu){
                std::ofstream fs;
                fs.open(baseOutputName + fileSuffix);
                if(fs.is_open()){
                        __f(fs, __args...);
                        fs.close();
                        return true;
                }else{
                        std::cerr << "lauchParallelThreadLog : cannot open file '"<<baseOutputName << fileSuffix<<"'" << std::endl;
                        return false;
                }
        }
        bool b(true);
        std::vector<std::ofstream> vecFs;
        vecFs.resize(nbThread);
        std::vector<std::thread> tabThread;
        tabThread.resize(nbThread);
        for(long unsigned int i(0lu); i < nbThread; ++i){
                std::stringstream fileName;
                fileName << baseOutputName << "_"<< i << fileSuffix;
                std::ofstream & fs = vecFs[i];
                fs.open(fileName.str());
                if(fs.is_open()){
                        tabThread[i] = std::thread(__f, std::ref(fs), __args...);
                }else{
                        std::cerr << "lauchParallelThreadLog : thread("<<i<<") cannot open file '"<<fileName.str()<<"'" << std::endl;
                        b &= false;
                }
        }
        for(long unsigned int i(0lu); i < nbThread; ++i){
                if(vecFs[i].is_open()){
                        tabThread[i].join();
                        vecFs[i].close();
                }
        }
        return b;
}

lauchParallelThreadLog() [2/4]

template<typename _Callable, typename... _Args>

bool lauchParallelThreadLog	(	const PPath &	logFile,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

logFile	: log file output name
nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
__f	: function to be lauched on each thread (function with prototype void f(std::ofstream & fs, __args); )
__args	: extra arguments to be passed to the function __f (optional arguments)

Returns

true if all output file where opened with success, false otherwise This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f Each thread will have a std::ofstream to write a separate file

Definition at line 220 of file lauchParallelThread_impl.h.

{
        PString extention(logFile.getExtension()), baseLogFileName(logFile.eraseExtension());
        if(extention != ""){extention = "." + extention;}
        return lauchParallelThreadLog(baseLogFileName, extention, nbThread, __f, __args...);
}

References lauchParallelThreadLog().

Here is the call graph for this function:

lauchParallelThreadLog() [3/4]

template<typename _Callable, typename... _Args>

bool lauchParallelThreadLog	(	const std::vector< PPath > &	listInputPTabModelFile,
		const PPath &	baseOutputName,
		const PPath &	fileSuffix,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

listInputPTabModelFile	: list of all files to be processed by the threads, this list will be split between each thread
baseOutputName	: base of the log file output name
fileSuffix	: suffix of the log file output name (can be anything such as file extention)
nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
__f	: function to be lauched on each thread (function with prototype void f(std::ofstream & fs, const std::vector<PPath>& listFile, __args); )
__args	: extra arguments to be passed to the function __f (optional arguments)

Returns

true if all output file where opened with success, false otherwise This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f Each thread will have a std::ofstream to write a separate file

Definition at line 87 of file lauchParallelThread_impl.h.

{
        if(nbThread == 0lu){return true;}
        if(nbThread == 1lu){
                std::ofstream fs;
                fs.open(baseOutputName + fileSuffix);
                if(fs.is_open()){
                        __f(fs, listInputPTabModelFile, __args...);
                        fs.close();
                        return true;
                }else{
                        std::cerr << "lauchParallelThreadLog : cannot open file '"<<baseOutputName << fileSuffix<<"'" << std::endl;
                        return false;
                }
        }
        std::vector<std::vector<PPath> > listInputFilePerThread;
        phoenix_vector_split(listInputFilePerThread, listInputPTabModelFile, nbThread);
        nbThread = listInputFilePerThread.size();       //In case we need less thread than required
        bool b(true);
        std::vector<std::ofstream> vecFs;
        vecFs.resize(nbThread);
        std::vector<std::thread> tabThread;
        tabThread.resize(nbThread);
        for(long unsigned int i(0lu); i < nbThread; ++i){
                std::stringstream fileName;
                fileName << baseOutputName << "_"<< i << fileSuffix;
                std::ofstream & fs = vecFs[i];
                fs.open(fileName.str());
                if(fs.is_open()){
                        tabThread[i] = std::thread(__f, std::ref(fs), listInputFilePerThread[i], __args...);
                }else{
                        std::cerr << "lauchParallelThreadLog : thread("<<i<<") cannot open file '"<<fileName.str()<<"'" << std::endl;
                        b &= false;
                }
        }
        for(long unsigned int i(0lu); i < nbThread; ++i){
                if(vecFs[i].is_open()){
                        tabThread[i].join();
                        vecFs[i].close();
                }
        }
        return b;
}

Referenced by lauchParallelThreadLog(), and lauchParallelThreadLog().

Here is the caller graph for this function:

lauchParallelThreadLog() [4/4]

template<typename _Callable, typename... _Args>

bool lauchParallelThreadLog	(	const std::vector< PPath > &	listInputPTabModelFile,
		const PPath &	logFile,
		long unsigned int	nbThread,
		_Callable &&	__f,
		_Args &&...	__args )

Lauch the callable function __f on nbThread threads with __args to be passed to each thread.

Parameters

listInputPTabModelFile	: list of all files to be processed by the threads, this list will be split between each thread
logFile	: log file output name
nbThread	: number of thread to lauch, if 0 : use every able cores (never upper than PLIB_SYSTEM_NB_CORE, number of thread on the current system)
__f	: function to be lauched on each thread (function with prototype void f(std::ofstream & fs, const std::vector<PPath>& listFile, __args); )
__args	: extra arguments to be passed to the function __f (optional arguments)

Returns

true if all output file where opened with success, false otherwise This function needs to be used with –std=c++11 compilation option Note : nbThread == 0 avoid the execution of the function __f Each thread will have a std::ofstream to write a separate file

Definition at line 145 of file lauchParallelThread_impl.h.

{
        PString extention(logFile.getExtension()), baseLogFileName(logFile.eraseExtension());
        if(extention != ""){extention = "." + extention;}
        return lauchParallelThreadLog(listInputPTabModelFile, baseLogFileName, extention, nbThread, __f, __args...);
}

References lauchParallelThreadLog().

Here is the call graph for this function: