G4MPImanager Class Reference

#include <G4MPImanager.hh>

Public Types
enum	{ kRANK_MASTER = 0 }
enum	{   kTAG_G4COMMAND = 100, kTAG_G4STATUS = 200, kTAG_G4SEED = 300, kTAG_DATA = 1000,   kTAG_HISTO = 1001, kTAG_RUN = 1002, kTAG_CMDSCR = 1003 }

Public Member Functions
	G4MPImanager ()
	G4MPImanager (int argc, char **argv)
	~G4MPImanager ()
G4MPIsession *	GetMPIsession () const
G4int	GetVerbose () const
void	SetVerbose (G4int iverbose)
G4int	GetSize () const
G4int	GetRank () const
G4bool	IsMaster () const
G4bool	IsSlave () const
G4bool	IsInitMacro () const
const G4String &	GetInitFileName () const
G4bool	IsBatchMode () const
const G4String &	GetMacroFileName () const
void	SetMasterWeight (G4double aweight)
G4double	GetMasterWeight () const
G4VMPIseedGenerator *	GetSeedGenerator () const
G4String	BcastCommand (const G4String &command)
void	ShowStatus ()
void	ShowSeeds ()
void	SetSeed (G4int inode, G4long seed)
void	WaitBeamOn ()
void	DistributeSeeds ()
void	ExecuteMacroFile (const G4String &fname, G4bool qbatch=false)
G4bool	CheckThreadStatus ()
void	ExecuteThreadCommand (const G4String &command)
void	ExecuteBeamOnThread (const G4String &command)
void	JoinBeamOnThread ()
void	BeamOn (G4int nevent, G4bool qdivide=true)
void	Print (const G4String &message)
void	ShowHelp () const

Static Public Member Functions
static G4MPImanager *	GetManager ()

Detailed Description

Definition at line 45 of file G4MPImanager.hh.

Member Enumeration Documentation

anonymous enum

Enumerator
kRANK_MASTER

Definition at line 48 of file G4MPImanager.hh.

{ kRANK_MASTER = 0 };

anonymous enum

Enumerator
kTAG_G4COMMAND
kTAG_G4STATUS
kTAG_G4SEED
kTAG_DATA
kTAG_HISTO
kTAG_RUN
kTAG_CMDSCR

Definition at line 50 of file G4MPImanager.hh.

       { // MPI tag
    kTAG_G4COMMAND = 100,
    kTAG_G4STATUS = 200,
    kTAG_G4SEED = 300,
    kTAG_DATA = 1000,
    kTAG_HISTO = 1001,
    kTAG_RUN = 1002,
    kTAG_CMDSCR = 1003
  };

Constructor & Destructor Documentation

G4MPImanager::G4MPImanager

(

)

Definition at line 68 of file G4MPImanager.cc.

  : verbose_(0), qfcout_(false), qinitmacro_(false), qbatchmode_(false),
    thread_id_(0), master_weight_(1.)
{
  //MPI::Init();
  MPI::Init_thread(MPI::THREAD_SERIALIZED);
  Initialize();
}

Here is the call graph for this function:

G4MPImanager::G4MPImanager	(	int	argc,
		char **	argv
	)

Definition at line 78 of file G4MPImanager.cc.

  : verbose_(0), qfcout_(false), qinitmacro_(false), qbatchmode_(false),
    thread_id_(0), master_weight_(1.)
{
  //MPI::Init(argc, argv);
  MPI::Init_thread(argc, argv, MPI::THREAD_SERIALIZED);
  Initialize();
  ParseArguments(argc, argv);
}

Here is the call graph for this function:

G4MPImanager::~G4MPImanager

(

)

Definition at line 89 of file G4MPImanager.cc.

{
  if( is_slave_ && qfcout_ ) fscout_.close();

  delete status_;
  delete messenger_;
  delete session_;

  COMM_G4COMMAND_.Free();

  MPI::Finalize();
}

Here is the call graph for this function:

Member Function Documentation

G4String G4MPImanager::BcastCommand

(

const G4String &

command

)

Definition at line 416 of file G4MPImanager.cc.

{
  enum { kBUFF_SIZE = 512 };
  static char sbuff[kBUFF_SIZE];
  command.copy(sbuff, kBUFF_SIZE);
  G4int len = command.size();
  sbuff[len] ='\0';   // no boundary check

  // "command" is not yet fixed in slaves at this time.

  // waiting message exhausts CPU in LAM!
  //COMM_G4COMMAND_.Bcast(sbuff, ssize, MPI::CHAR, RANK_MASTER);

  // another implementation
  if( is_master_ ) {
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Send(sbuff, kBUFF_SIZE, MPI::CHAR,
                           islave, kTAG_G4COMMAND);
    }
  } else {
    // try non-blocking receive
    MPI::Request request= COMM_G4COMMAND_.Irecv(sbuff, kBUFF_SIZE, MPI::CHAR,
                                                kRANK_MASTER, kTAG_G4COMMAND);
    // polling...
    while(! request.Test()) {
      ::Wait(1000);
    }
  }

  return G4String(sbuff);
}

void G4MPImanager::BeamOn	(	G4int	nevent,
		G4bool	qdivide = true
	)

Definition at line 460 of file G4MPImanager.cc.

{
#ifndef G4MULTITHREADED
  G4RunManager* runManager = G4RunManager::GetRunManager();
#endif

  if ( qdivide ) { // events are divided
    G4double ntot = master_weight_ + size_ - 1.;
    G4int nproc = G4int(nevent/ntot);
    G4int nproc0 = nevent - nproc*(size_-1);

    if ( verbose_ > 0 && is_master_ ) {
      G4cout << "#events in master=" << nproc0 << " / "
             << "#events in slave="  << nproc << G4endl;
    }

    status_-> StartTimer(); // start timer

#ifdef G4MULTITHREADED
    G4String str_nevt;
    if ( is_master_ ) str_nevt = G4UIcommand::ConvertToString(nproc0);
    else str_nevt = G4UIcommand::ConvertToString(nproc);
    G4UImanager* UI = G4UImanager::GetUIpointer();
    UI-> ApplyCommand("/run/beamOn " + str_nevt);
#else
    if ( is_master_ ) runManager-> BeamOn(nproc0);
    else runManager-> BeamOn(nproc);
#endif

    status_-> StopTimer(); // stop timer

  } else { // same events are generated in each node (for test use)
    if( verbose_ > 0 && is_master_ ) {
      G4cout << "#events in master=" << nevent << " / "
             << "#events in slave="  << nevent << G4endl;
    }
    status_-> StartTimer(); // start timer

#ifdef G4MULTITHREADED
    G4String str_nevt = G4UIcommand::ConvertToString(nevent);
    G4UImanager* UI = G4UImanager::GetUIpointer();
    UI-> ApplyCommand("/run/beamOn " + str_nevt);
#else
    runManager-> BeamOn(nevent);
#endif

    status_-> StopTimer(); // stop timer
  }
}

Here is the call graph for this function:

G4bool G4MPImanager::CheckThreadStatus

(

)

Definition at line 325 of file G4MPImanager.cc.

{
  unsigned buff;
  unsigned qstatus = 0;

  if( is_master_ ) {
    qstatus = (thread_id_ != 0);
    // get slave status
    for ( G4int islave = 1; islave < size_; islave++ ) {
      MPI::Request request = COMM_G4COMMAND_.Irecv(&buff, 1, MPI::UNSIGNED,
                                                  islave, kTAG_G4STATUS);
      while( ! request.Test() ) {
        ::Wait(1000);
      }
      qstatus |= buff;
    }
  } else {
    buff = (thread_id_ !=0);
    COMM_G4COMMAND_.Send(&buff, 1, MPI::UNSIGNED, kRANK_MASTER, kTAG_G4STATUS);
  }

  // broadcast
  buff = qstatus; // for master
  COMM_G4COMMAND_.Bcast(&buff, 1, MPI::UNSIGNED, kRANK_MASTER);
  qstatus = buff; // for slave

  if ( qstatus != 0 ) return true;
  else return false;
}

Here is the caller graph for this function:

void G4MPImanager::DistributeSeeds

(

)

Definition at line 287 of file G4MPImanager.cc.

{
  std::vector<G4long> seed_list = seed_generator_-> GetSeedList();
  G4Random::setTheSeed(seed_list[rank_]);
}

void G4MPImanager::ExecuteBeamOnThread

(

const G4String &

command

)

Definition at line 385 of file G4MPImanager.cc.

{
  G4bool threadStatus = CheckThreadStatus();

  if (threadStatus) {
    if ( is_master_ ) {
      G4cout << "G4MPIsession:: beamOn is still running." << G4endl;
    }
  } else { // ok
    static G4String cmdstr;
    cmdstr = command;
    G4int rc = pthread_create(&thread_id_, 0,
                              (Func_t)thread_ExecuteThreadCommand,
                              (void*)&cmdstr);
    if (rc != 0)
      G4Exception("G4MPImanager::ExecuteBeamOnThread()",
                  "MPI003", FatalException,
                  "Failed to create a beamOn thread.");
  }
}

Here is the call graph for this function:

void G4MPImanager::ExecuteMacroFile	(	const G4String &	fname,
		G4bool	qbatch = false
	)

Definition at line 449 of file G4MPImanager.cc.

{
  G4bool currentmode = qbatchmode_;
  qbatchmode_ = true;
  G4MPIbatch* batchSession = new G4MPIbatch(fname, qbatch);
  batchSession-> SessionStart();
  delete batchSession;
  qbatchmode_ = currentmode;
}

void G4MPImanager::ExecuteThreadCommand

(

const G4String &

command

)

Definition at line 356 of file G4MPImanager.cc.

{
  // this method is a thread function.
  G4UImanager* UI = G4UImanager::GetUIpointer();
  G4int rc = UI-> ApplyCommand(command);

  G4int commandStatus = rc - (rc%100);

  switch( commandStatus ) {
  case fCommandSucceeded:
    break;
  case fIllegalApplicationState:
    G4cerr << "illegal application state -- command refused" << G4endl;
    break;
  default:
    G4cerr << "command refused (" << commandStatus << ")" << G4endl;
    break;
  }

  // thread is joined
  if ( thread_id_ ) {
    pthread_join(thread_id_, 0);
    thread_id_ = 0;
  }

  return;
}

Here is the call graph for this function:

const G4String & G4MPImanager::GetInitFileName ( ) const

inline

Definition at line 203 of file G4MPImanager.hh.

{
  return init_file_name_;

}

Here is the caller graph for this function:

const G4String & G4MPImanager::GetMacroFileName ( ) const

inline

Definition at line 214 of file G4MPImanager.hh.

{
  return macro_file_name_;
}

Here is the caller graph for this function:

G4MPImanager * G4MPImanager::GetManager ( )

static

Definition at line 103 of file G4MPImanager.cc.

{
  if ( g4mpi_ == NULL ) {
    G4Exception("G4MPImanager::GetManager()", "MPI001",
                FatalException, "G4MPImanager is not instantiated.");
  }
  return g4mpi_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4MPImanager::GetMasterWeight ( ) const

inline

Definition at line 227 of file G4MPImanager.hh.

{
  return master_weight_;
}

Here is the caller graph for this function:

G4MPIsession * G4MPImanager::GetMPIsession ( ) const

inline

Definition at line 157 of file G4MPImanager.hh.

{
  return session_;
}

G4int G4MPImanager::GetRank ( ) const

inline

Definition at line 177 of file G4MPImanager.hh.

{
  return rank_;
}

G4VMPIseedGenerator * G4MPImanager::GetSeedGenerator ( ) const

inline

Definition at line 232 of file G4MPImanager.hh.

{
  return seed_generator_;
}

G4int G4MPImanager::GetSize ( ) const

inline

Definition at line 182 of file G4MPImanager.hh.

{
  return size_;
}

G4int G4MPImanager::GetVerbose ( ) const

inline

Definition at line 162 of file G4MPImanager.hh.

{
  return verbose_;
}

Here is the caller graph for this function:

G4bool G4MPImanager::IsBatchMode ( ) const

inline

Definition at line 209 of file G4MPImanager.hh.

{
  return qbatchmode_;
}

G4bool G4MPImanager::IsInitMacro ( ) const

inline

Definition at line 197 of file G4MPImanager.hh.

{
  return qinitmacro_;

}

G4bool G4MPImanager::IsMaster ( ) const

inline

Definition at line 187 of file G4MPImanager.hh.

{
  return is_master_;
}

G4bool G4MPImanager::IsSlave ( ) const

inline

Definition at line 192 of file G4MPImanager.hh.

{
  return is_slave_;
}

void G4MPImanager::JoinBeamOnThread

(

)

Definition at line 407 of file G4MPImanager.cc.

{
  if ( thread_id_ ) {
    pthread_join(thread_id_, 0);
    thread_id_ = 0;
  }
}

void G4MPImanager::Print

(

const G4String &

message

)

Definition at line 532 of file G4MPImanager.cc.

{
  if ( is_master_ ){
    std::cout << message << std::flush;
  } else {
    if ( qfcout_ ) { // output to a file
      fscout_ << message << std::flush;
    } else { // output to stdout
      std::cout << rank_ << ":" << message << std::flush;
    }
  }
}

Here is the caller graph for this function:

void G4MPImanager::SetMasterWeight ( G4double  aweight )

inline

Definition at line 219 of file G4MPImanager.hh.

{
  master_weight_ = aweight;

  if( aweight < 0. ) master_weight_ = 0.;
  if( aweight > 1. ) master_weight_ = 1.;
}

void G4MPImanager::SetSeed	(	G4int	inode,
		G4long	seed
	)

Definition at line 317 of file G4MPImanager.cc.

{
  if( rank_ == inode ) {
    CLHEP::HepRandom::setTheSeed(seed);
  }
}

Here is the call graph for this function:

void G4MPImanager::SetVerbose ( G4int  iverbose )

inline

Definition at line 167 of file G4MPImanager.hh.

{
  G4int lv = iverbose;
  if( iverbose > 1 ) lv = 1;
  if( iverbose < 0 ) lv = 0;

  verbose_ = lv;
  return;
}

void G4MPImanager::ShowHelp

(

)

const

Definition at line 546 of file G4MPImanager.cc.

{
  if (is_slave_ ) return;

  G4cout << "Geant4 MPI interface" << G4endl;
  G4cout << "usage:" << G4endl;
  G4cout << "<app> [options] [macro file]"
         << G4endl << G4endl;
  G4cout << "   -h, --help              show this message."
         << G4endl;
  G4cout << "   -v, --verbose           show verbose message"
         << G4endl;
  G4cout << "   -i, --init=FNAME        set an init macro file"
         << G4endl;
  G4cout << "   -o, --ofile[=FNAME]     set slave output to a flie"
         << G4endl;
  G4cout << G4endl;
}

void G4MPImanager::ShowSeeds

(

)

Definition at line 294 of file G4MPImanager.cc.

{
  G4long buff;

  if ( is_master_ ) {
    // print master
    G4cout << "* rank= " << rank_
           << " seed= " << G4Random::getTheSeed()
           << G4endl;
    // receive from each slave
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Recv(&buff, 1, MPI::LONG, islave, kTAG_G4SEED);
      G4cout << "* rank= " << islave
             << " seed= " << buff
             << G4endl;
    }
  } else { // slaves
    buff = G4Random::getTheSeed();
    COMM_G4COMMAND_.Send(&buff, 1, MPI::LONG, kRANK_MASTER, kTAG_G4SEED);
  }
}

void G4MPImanager::ShowStatus

(

)

Definition at line 238 of file G4MPImanager.cc.

{
  G4int buff[G4MPIstatus::kNSIZE];

  UpdateStatus();
  G4bool gstatus = CheckThreadStatus();

  if ( is_master_ ) {
    status_-> Print();  // for maser itself

    G4int nev = status_-> GetEventID();
    G4int nevtp = status_-> GetNEventToBeProcessed();
    G4double cputime = status_-> GetCPUTime();

    // receive from each slave
    for ( G4int islave = 1; islave < size_; islave++ ) {
      COMM_G4COMMAND_.Recv(buff, G4MPIstatus::kNSIZE, MPI::INT,
                          islave, kTAG_G4STATUS);
      status_-> UnPack(buff);
      status_-> Print();

      // aggregation
      nev += status_-> GetEventID();
      nevtp += status_-> GetNEventToBeProcessed();
      cputime += status_-> GetCPUTime();
    }

    G4String strStatus;
    if ( gstatus ) {
      strStatus = "Run";
    } else {
      strStatus = "Idle";
    }

    G4cout << "-------------------------------------------------------"
           << G4endl
           << "* #ranks= " << size_
           << "   event= " << nev << "/" << nevtp
           << " state= " << strStatus
           << " time= " << cputime << "s"
           << G4endl;
  } else {
    status_-> Pack(buff);
    COMM_G4COMMAND_.Send(buff, G4MPIstatus::kNSIZE, MPI::INT,
                         kRANK_MASTER, kTAG_G4STATUS);
  }
}

Here is the call graph for this function:

void G4MPImanager::WaitBeamOn

(

)

Definition at line 511 of file G4MPImanager.cc.

{
  G4int buff = 0;
  if ( qbatchmode_ ) {  // valid only in batch mode
    if ( is_master_ ) {
      // receive from each slave
      for (G4int islave = 1; islave < size_; islave++) {
        MPI::Request request = COMM_G4COMMAND_.Irecv(&buff, 1, MPI::INT,
                                                     islave, kTAG_G4STATUS);
        while(! request.Test()) {
           ::Wait(1000);
        }
      }
    } else {
      buff = 1;
      COMM_G4COMMAND_.Send(&buff, 1, MPI::INT, kRANK_MASTER, kTAG_G4STATUS);
    }
  }
}

---

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

• source/geant4.10.03.p02/examples/extended/parallel/MPI/source/include/G4MPImanager.hh
• source/geant4.10.03.p02/examples/extended/parallel/MPI/source/src/G4MPImanager.cc