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 }

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

Definition at line 50 of file G4MPImanager.hh.

       { // MPI tag
    kTAG_G4COMMAND = 100,
    kTAG_G4STATUS = 200,
    kTAG_G4SEED = 300,
    kTAG_DATA = 1000
  };

Constructor & Destructor Documentation

G4MPImanager::G4MPImanager

(

)

Definition at line 68 of file G4MPImanager.cc.

References Initialize().

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

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

Definition at line 78 of file G4MPImanager.cc.

References Initialize().

  : 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);
}

G4MPImanager::~G4MPImanager

(

)

Definition at line 89 of file G4MPImanager.cc.

References Finalize().

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

  delete status_;
  delete messenger_;
  delete session_;

  COMM_G4COMMAND_.Free();

  MPI::Finalize();
}

Member Function Documentation

G4String G4MPImanager::BcastCommand

(

const G4String &

command

)

Definition at line 416 of file G4MPImanager.cc.

References kRANK_MASTER, and kTAG_G4COMMAND.

{
  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.

References G4UIcommand::ConvertToString(), G4cout, G4endl, G4RunManager::GetRunManager(), and G4UImanager::GetUIpointer().

{
#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
  }
}

G4bool G4MPImanager::CheckThreadStatus

(

)

Definition at line 325 of file G4MPImanager.cc.

References kRANK_MASTER, and kTAG_G4STATUS.

Referenced by ExecuteBeamOnThread(), and ShowStatus().

{
  unsigned buff;
  unsigned qstatus = 0;

  if( is_master_ ) {
    qstatus = unsigned(thread_id_);
    // 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 = unsigned(thread_id_);
    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;
}

void G4MPImanager::DistributeSeeds

(

)

Definition at line 287 of file G4MPImanager.cc.

References CLHEP::HepRandom::setTheSeed().

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

void G4MPImanager::ExecuteBeamOnThread

(

const G4String &

command

)

Definition at line 385 of file G4MPImanager.cc.

References CheckThreadStatus(), test::cmdstr, FatalException, G4cout, G4endl, and G4Exception().

{
  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.");
  }
}

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.

References fCommandSucceeded, fIllegalApplicationState, G4cerr, G4endl, and G4UImanager::GetUIpointer().

{
  // 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;
}

const G4String & G4MPImanager::GetInitFileName ( ) const

inline

Definition at line 199 of file G4MPImanager.hh.

Referenced by G4MPIsession::SessionStart().

{
  return init_file_name_;

}

const G4String & G4MPImanager::GetMacroFileName ( ) const

inline

Definition at line 210 of file G4MPImanager.hh.

Referenced by G4MPIsession::SessionStart().

{
  return macro_file_name_;
}

G4MPImanager * G4MPImanager::GetManager ( )

static

Definition at line 103 of file G4MPImanager.cc.

References FatalException, and G4Exception().

Referenced by G4MPIrandomSeedGenerator::CheckDoubleCount(), G4VMPIsession::G4VMPIsession(), and G4MPIrandomSeedGenerator::GenerateSeeds().

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

G4double G4MPImanager::GetMasterWeight ( ) const

inline

Definition at line 223 of file G4MPImanager.hh.

Referenced by G4MPImessenger::GetCurrentValue().

{
  return master_weight_;
}

G4MPIsession * G4MPImanager::GetMPIsession ( ) const

inline

Definition at line 153 of file G4MPImanager.hh.

{
  return session_;
}

G4int G4MPImanager::GetRank ( ) const

inline

Definition at line 173 of file G4MPImanager.hh.

{
  return rank_;
}

G4VMPIseedGenerator * G4MPImanager::GetSeedGenerator ( ) const

inline

Definition at line 228 of file G4MPImanager.hh.

{
  return seed_generator_;
}

G4int G4MPImanager::GetSize ( ) const

inline

Definition at line 178 of file G4MPImanager.hh.

{
  return size_;
}

G4int G4MPImanager::GetVerbose ( ) const

inline

Definition at line 158 of file G4MPImanager.hh.

Referenced by G4MPImessenger::GetCurrentValue().

{
  return verbose_;
}

G4bool G4MPImanager::IsBatchMode ( ) const

inline

Definition at line 205 of file G4MPImanager.hh.

{
  return qbatchmode_;
}

G4bool G4MPImanager::IsInitMacro ( ) const

inline

Definition at line 193 of file G4MPImanager.hh.

{
  return qinitmacro_;

}

G4bool G4MPImanager::IsMaster ( ) const

inline

Definition at line 183 of file G4MPImanager.hh.

{
  return is_master_;
}

G4bool G4MPImanager::IsSlave ( ) const

inline

Definition at line 188 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.

Referenced by ShowStatus().

{
  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;
    }
  }
}

void G4MPImanager::SetMasterWeight ( G4double  aweight )

inline

Definition at line 215 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.

References CLHEP::HepRandom::setTheSeed().

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

void G4MPImanager::SetVerbose ( G4int  iverbose )

inline

Definition at line 163 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.

References G4cout, and G4endl.

{
  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.

References G4cout, G4endl, CLHEP::HepRandom::getTheSeed(), kRANK_MASTER, and kTAG_G4SEED.

{
  G4long buff;

  if ( is_master_ ) {
    // print master
    G4cout << "* rank= " << rank_
           << " seed= " << CLHEP::HepRandom::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 = CLHEP::HepRandom::getTheSeed();
    COMM_G4COMMAND_.Send(&buff, 1, MPI::LONG, kRANK_MASTER, kTAG_G4SEED);
  }
}

void G4MPImanager::ShowStatus

(

)

Definition at line 238 of file G4MPImanager.cc.

References CheckThreadStatus(), G4cout, G4endl, G4FFGEnumerations::INT, G4MPIstatus::kNSIZE, kRANK_MASTER, kTAG_G4STATUS, and Print().

{
  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);
  }
}

void G4MPImanager::WaitBeamOn

(

)

Definition at line 511 of file G4MPImanager.cc.

References G4FFGEnumerations::INT, kRANK_MASTER, and kTAG_G4STATUS.

{
  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:

• G4MPImanager.hh
• G4MPImanager.cc