TLauncherMulti.h

Go to the documentation of this file.

 
// Copyright (C) 2013-2024 CEA/DES
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published
// by the Free Software Foundation, either version 3 of the License, or any
// later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
// $Id$
// $Author$
// $Date$
// $Revision$
// $State$
 
#ifndef TLAUNCHERMULTI_H
#define TLAUNCHERMULTI_H
 
#include <string>
#include <list>
#include <sys/types.h>
#include <unistd.h>
 
// Uranie
#include "Launcher.h"
#include "TCode.h"
#include "TCluster.h"
#include "TSlurmCluster.h"
#include "TLSFCluster.h"
#include "TSGECluster.h"
#include "TLocalHostCluster.h"
#include "TLoadLevelerCluster.h"
 
#include <iostream>
#include <sstream>
#include <fstream>
 
using std::cout;
using std::endl;
using std::list;
using std::string;
using std::istringstream;
 
namespace URANIE
{
namespace Launcher
{
 
struct job
{
    pid_t pid;
    list<string> hostlist;
    int testnumber;
};
 
class TLauncherMulti: public TNamed
{
public:
    //enum EDistrib { kUnknown, kLSB, kSLURM, kMPI, kPBS, kSGE };
private:
    //EDistrib    _edistrib;         ///< The type of distribution
    TCluster *_edistrib;
    Bool_t _blog;                  
    Bool_t _bemptyMasterNode;     //Boolean for strategy of parallel runs
    Bool_t _bmultidump;     //Boolean for strategy of parallel runs    
    TString _sworkingDirectory;  
 
    int njobs_;              // Number of job to run
 
    TString exe_;          // Binary to execute
    int procsperjob_;        // Number of procs per job
 
    int nb_avail_procs_;             // Number of available procs
    int nb_total_procs_;     //Number of procs allocated by the system
    int delay_; //number of seconds for temporisation between first and last proc
    list<string> hostslist_; // List of available procs
 
    list<job> runningjobs_;  // List of running jobs
 
    pid_t _masterpid;          
 
public:
    TLauncherMulti();
    TLauncherMulti(const char* name, const char* title, Option_t *option,
                   Bool_t emptyMasterNode, Int_t delay, bool dumpmulti=false);
    ~TLauncherMulti();
 
    void createHostsList(Option_t *option);
    void defineJob(const char* exe, int njobs, int nprocs);
 
    void waitForProcs();
 
    void createJob(int iteration);
    void run(TCode* code, Option_t *option);
 
    void waitAll();
 
    inline int getJobsNumber()
    {
        return njobs_;
    }
    inline int getAvailableProcs()
    {
        return nb_avail_procs_;
    }
 
    inline void setWorkingDir(TString sdir)
    {
        _sworkingDirectory = sdir;
    }
 
    void mergeAll(const int niteration);
    void display();//TString str, TString cut, TString opt);
 
    //---------------------------------------------
    void setLog()
    {
        _blog = kTRUE;
    }
    void unsetLog()
    {
        _blog = kFALSE;
    }
    void changeLog()
    {
        _blog = _blog ? kFALSE : kTRUE;
    }
    Bool_t getLog()
    {
        return _blog;
    }
    virtual void printLog(Option_t *option = "");
 
    ClassDef(URANIE::Launcher::TLauncherMulti, ID_LAUNCHER)
    // Classe TLauncherMulti
};
 
} // Fin du namespace Launcher
} // Fin du namespace URANIE
#endif