BackEnd.C File Reference

#include "BackEnd.h"
#include "ProcessorPrivate.h"
#include "common.h"
#include "Node.h"
#include "memusage.h"
#include <new>
#include "Lattice.h"
#include "ComputeMoa.h"
#include "ComputeMsmMsa.h"
#include "main.decl.h"
#include "main.h"
#include "BOCgroup.h"
#include "WorkDistrib.decl.h"
#include "ProxyMgr.decl.h"
#include "PatchMgr.decl.h"
#include "DataExchanger.decl.h"
#include "ReductionMgr.decl.h"
#include "CollectionMgr.decl.h"
#include "CollectionMaster.decl.h"
#include "CollectionMgr.h"
#include "CollectionMaster.h"
#include "BroadcastMgr.decl.h"
#include "LdbCoordinator.decl.h"
#include "Sync.decl.h"
#include "PatchData.decl.h"
#include "GlobalGPUMgr.decl.h"
#include "SynchronousCollectives.decl.h"
#include <tcl.h>

Go to the source code of this file.

Functions
void	_initCharm (int, char **)
	CkpvStaticDeclare (int, exitSchedHndlr)
void	exit_sched (void *msg)
static void	register_exit_sched (void)
void	NAMD_new_handler ()
void	topo_getargs (char **)
void	cuda_getargs (char **)
void	cuda_affinity_initialize ()
void	mic_getargs (char **)
void	all_init (int argc, char **argv)
void	after_backend_init (int argc, char **argv)
void	master_init (int argc, char **argv)
void	slave_init (int argc, char **argv)

Variables
float	cpuTime_start
float	wallTime_start
char *	gNAMDBinaryName = NULL

Function Documentation

_initCharm()

void _initCharm	(	int	,
		char **
	)

Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by The Board of Trustees of the University of Illinois. All rights reserved.

Referenced by all_init().

after_backend_init()

void after_backend_init	(	int	argc,
		char **	argv
	)

Definition at line 55 of file mainfunc.C.

References CHDIR, CWDSIZE, endi(), ScriptTcl::eval(), BackEnd::exit(), GETCWD, iINFO(), iout, ScriptTcl::load(), NAMD_die(), NAMD_err(), Node::Object(), PATHSEP, PATHSEPSTR, ScriptTcl::run(), PatchData::script, Node::setScript(), and ScriptTcl::tclmain().

Referenced by main(), and slave_init().

                                              {
#define CWDSIZE 1024
  char origcwd_buf[CWDSIZE];
  char currentdir_buf[CWDSIZE];

  ScriptTcl *script = new ScriptTcl;
  Node::Object()->setScript(script);
  // Node is a group that contains common pointers across many PEs, 
  // since script is not shared among nodes, into the nodegroup it goes

#ifdef NODEGROUP_FORCE_REGISTER
  CProxy_PatchData cpdata(CkpvAccess(BOCclass_group).patchData);
  PatchData* patchData = cpdata.ckLocalBranch();
  patchData->script =script;
#endif

  for(argc = 0; argv[argc]; ++argc);
  if ( argc < 2 ) {
#if defined(WIN32) && !defined(__CYGWIN__)
    CkPrintf("\nFATAL ERROR: No simulation config file specified on command line.\n");
    CkPrintf("\nNOTE: NAMD has no graphical interface and must be run from a command line.\n");
    int nsleep = 10;
    CkPrintf("\nSleeping %d seconds before exiting...\n", nsleep);
    fflush(stdout);
    sleep(nsleep);
    CkPrintf("\n");
#endif
    NAMD_die("No simulation config file specified on command line.");
  }
  char *origcwd = GETCWD(origcwd_buf,CWDSIZE);
  if ( ! origcwd ) NAMD_err("getcwd");
#ifdef NAMD_TCL
  for(int i = 1; i < argc; ++i) {
  if ( strstr(argv[i],"--") == argv[i] ) {
    char buf[1024];
    if ( i + 1 == argc ) {
      sprintf(buf, "missing argument for command line option %s", argv[i]);
      NAMD_die(buf);
    }
    if ( ! strcmp(argv[i],"--tclmain") ) {
      // pass all remaining arguments to script
      iout << iINFO << "Command-line argument is";
      for ( int j=i; j<argc; ++j ) { iout << " " << argv[j]; }
      iout << "\n" << endi;
      script->tclmain(argc-i-1,argv+i+1);
      BackEnd::exit();
      return;
    }
    sprintf(buf, "%s %s", argv[i]+2, argv[i+1]);
    iout << iINFO << "Command-line argument is --" << buf << "\n" << endi;
    script->eval(buf);
    ++i;
    continue;
  }
  char *confFile = argv[i];
#else
  char *confFile = argv[argc-1];
#endif
  iout << iINFO << "Configuration file is " << confFile << "\n" << endi;

  char *currentdir=confFile;
  char *tmp;
  char tmpcurdir[3];
  for(tmp=confFile;*tmp;++tmp); // find final null
  for( ; tmp != confFile && *tmp != PATHSEP; --tmp); // find last '/'
#if defined(WIN32) && !defined(__CYGWIN__)
  if (tmp == confFile) {
    // in case this is under cygwin, search for '/' as well
    for(tmp=confFile;*tmp;++tmp); // find final null
    for( ; tmp != confFile && *tmp != '/'; --tmp); // find last '/'
  }
#endif
  if ( CHDIR(origcwd) ) NAMD_err(origcwd);
  if ( tmp != confFile )
  {
    *tmp = 0; confFile = tmp + 1;
    if ( CHDIR(currentdir) ) NAMD_err(currentdir);
    struct stat statBuf;
    if (stat(confFile, &statBuf)) {
      char buf[1024];
      sprintf(buf,"Unable to access config file %s%c%s",currentdir,PATHSEP,confFile);
      NAMD_die(buf);
    }
    iout << iINFO << "Changed directory to " << currentdir << "\n" << endi;
    currentdir = GETCWD(currentdir_buf,CWDSIZE);
    if ( ! currentdir ) NAMD_err("getcwd after chdir");
  }
  else{
      if ( *tmp == PATHSEP ){ // config file in / is odd, but it might happen
          if ( CHDIR(PATHSEPSTR) ) NAMD_err(PATHSEPSTR);
          struct stat statBuf;
          if (stat(confFile, &statBuf)) {
            char buf[1024];
            sprintf(buf,"Unable to access config file %s",confFile);
            NAMD_die(buf);
          }
      }else{ // just a config file name, so the path is the current working path
          struct stat statBuf;
          if (stat(confFile, &statBuf)) {
            char buf[1024];
            if ( confFile[0] == '-' || confFile[0] == '+' ) {
              sprintf(buf,"Unknown command-line option %s",confFile);
            } else {
              sprintf(buf,"Unable to access config file %s",confFile);
            }
            NAMD_die(buf);
          }
          tmpcurdir[0] = '.';
          tmpcurdir[1] = PATHSEP;
          tmpcurdir[2] = 0;
          currentdir = tmpcurdir;
          iout << iINFO << "Working in the current directory " << origcwd << "\n" << endi;
      }
  }

#ifdef MEM_OPT_VERSION
    int dirlen = strlen(currentdir);
    gWorkDir = new char[dirlen+1];
    gWorkDir[dirlen]=0;
    memcpy(gWorkDir, currentdir, dirlen);
#endif

  currentdir = NULL;

#ifdef NAMD_TCL
  script->load(confFile);
#else
  script->run(confFile);
#endif

#ifdef NAMD_TCL
}
  script->run();
#endif

  BackEnd::exit();
}

all_init()

void all_init	(	int	argc,
		char **	argv
	)

Definition at line 102 of file BackEnd.C.

References _initCharm(), cuda_affinity_initialize(), cuda_getargs(), mic_getargs(), NAMD_new_handler(), ProcessorPrivateInit(), register_exit_sched(), and topo_getargs().

Referenced by master_init(), and slave_init().

{
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
  _set_new_handler(NAMD_new_handler);
#else
  std::set_new_handler(NAMD_new_handler);
#endif
  ProcessorPrivateInit();
  register_exit_sched();
  CmiGetArgFlag(argv, "+idlepoll");  // remove +idlepoll if it's still there
  topo_getargs(argv);
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  cuda_getargs(argv);
  argc = CmiGetArgc(argv);
#endif
#ifdef NAMD_MIC
  CmiGetArgFlag(argv, "+idlepoll");  // remove +idlepoll if it's still there
  mic_getargs(argv);
  argc = CmiGetArgc(argv);
#endif
#ifdef NAMD_AVXTILES
  avxTilesCommandLineDisable = CmiGetArgFlag(argv, "+notiles");
#endif
  
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  // launch CUDA runtime threads before affinity is set by _initCharm
  // _initCharm contains a node barrier so there is no race here
  if(CmiMyRank()==0){
    cuda_affinity_initialize();
  }
#endif

  _initCharm(argc, argv);  // message main Chare

//#if 0  // moved to WorkDistrib
//#ifdef NAMD_CUDA
//  if ( CkMyPe() < CkNumPes() ) cuda_initialize();
//#endif
//#ifdef NAMD_MIC
//  if ( CkMyPe() < CkNumPes() ) mic_initialize();
//#endif
//#endif
}

CkpvStaticDeclare()

CkpvStaticDeclare	(	int	,
		exitSchedHndlr
	)

cuda_affinity_initialize()

void cuda_affinity_initialize

(

)

Definition at line 55 of file CudaUtils.C.

Referenced by all_init().

                                {
  int devcnt = 0;
  cudaError_t err = cudaGetDeviceCount(&devcnt);
  if ( devcnt == 1 ) {  // only one device so it must be ours
    int *dummy;
    if ( err == cudaSuccess ) err = cudaSetDevice(0);
    if ( err == cudaSuccess ) err = cudaSetDeviceFlags(cudaDeviceMapHost);
    if ( err == cudaSuccess ) err = cudaMalloc(&dummy, 4);
  }
  if ( err != cudaSuccess ) {
    char host[128];
    gethostname(host, 128);  host[127] = 0;
    fprintf(stderr,"CUDA initialization error on %s: %s\n", host, cudaGetErrorString(err));
  }
}

cuda_getargs()

void cuda_getargs

(

char **

)

Definition at line 69 of file DeviceCUDA.C.

References cuda_args, cuda_args_t::devicelist, cuda_args_t::devicesperreplica, cuda_args_t::globaldevice, cuda_args_t::ignoresharing, cuda_args_t::mergegrids, NAMD_die(), cuda_args_t::nomergegrids, cuda_args_t::nostreaming, cuda_args_t::pmedevice, cuda_args_t::pmePes, and cuda_args_t::usedevicelist.

Referenced by all_init().

                               {
  cuda_args.devicelist = 0;
  cuda_args.usedevicelist = CmiGetArgStringDesc(argv, "+devices", &cuda_args.devicelist,
                "comma-delimited list of CUDA device numbers such as 0,2,1,2");
  cuda_args.devicesperreplica = 0;
  CmiGetArgInt(argv, "+devicesperreplica", &cuda_args.devicesperreplica);
  if ( cuda_args.devicesperreplica < 0 ) NAMD_die("Devices per replica must be positive\n");
  cuda_args.ignoresharing = CmiGetArgFlag(argv, "+ignoresharing");
  cuda_args.mergegrids = CmiGetArgFlag(argv, "+mergegrids");
  cuda_args.nomergegrids = CmiGetArgFlag(argv, "+nomergegrids");
  if ( cuda_args.mergegrids && cuda_args.nomergegrids ) NAMD_die("Do not specify both +mergegrids and +nomergegrids");
  cuda_args.nostreaming = CmiGetArgFlag(argv, "+nostreaming");
#ifdef NODEGROUP_FORCE_REGISTER
  CmiGetArgInt(argv, "+pmedevice", &cuda_args.pmedevice);
  CmiGetArgInt(argv, "+pmepes", &cuda_args.pmePes);
  cuda_args.globaldevice = -1;
  CmiGetArgInt(argv, "+globaldevice", &cuda_args.globaldevice);
#endif
}

exit_sched()

void exit_sched

(

void *

msg

)

Definition at line 58 of file BackEnd.C.

Referenced by register_exit_sched().

{
  //  CmiPrintf("Exiting scheduler on %d\n",CmiMyPe());
  CsdExitScheduler();
}

master_init()

void master_init	(	int	argc,
		char **	argv
	)

Definition at line 170 of file BackEnd.C.

References all_init(), BOCgroup::broadcastMgr, BOCgroup::collectionMgr, BOCgroup::computeCUDAMgr, BOCgroup::computeExtMgr, BOCgroup::computeFmmSerialMgr, BOCgroup::computeGBISserMgr, BOCgroup::computeLjPmeSerialMgr, BOCgroup::computeMgr, BOCgroup::computeMsmMgr, BOCgroup::computeMsmMsaMgr, BOCgroup::computeMsmSerialMgr, BOCgroup::computePmeCUDAMgr, BOCgroup::computeQMMgr, cpuTime_start, BOCgroup::dataExchanger, BOCgroup::globalGPUMgr, GroupInitMsg::group, BOCgroup::ioMgr, BOCgroup::ldbCoordinator, SlaveInitMsg::master, BOCgroup::multicastMgr, BOCgroup::nodePmeMgr, BOCgroup::patchData, BOCgroup::patchMgr, BOCgroup::proxyMgr, BOCgroup::reductionMgr, BOCgroup::sync, BOCgroup::synchronousCollectives, wallTime_start, and BOCgroup::workDistrib.

Referenced by BackEnd::init(), and slave_init().

                                       {
  cpuTime_start = CmiCpuTimer();
  wallTime_start = CmiWallTimer();
  if ( CmiMyPe() ) {
    all_init(argc, argv);
    CsdScheduler(-1);
    ConverseExit();  // should never return
  }

  all_init(argc, argv);

  // Create branch-office chares
  BOCgroup group;
  group.workDistrib = CProxy_WorkDistrib::ckNew();
  group.proxyMgr = CProxy_ProxyMgr::ckNew();
  group.patchMgr = CProxy_PatchMgr::ckNew();
  group.computeMgr = CProxy_ComputeMgr::ckNew();
  group.reductionMgr = CProxy_ReductionMgr::ckNew();
  // group.computePmeMgr set in constructor during startup
  group.nodePmeMgr = CProxy_NodePmeMgr::ckNew();
#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  group.patchData = CProxy_PatchData::ckNew();
  group.computePmeCUDAMgr = CProxy_ComputePmeCUDAMgr::ckNew();
  group.computeCUDAMgr = CProxy_ComputeCUDAMgr::ckNew();
#endif
#ifdef OPENATOM_VERSION
  group.computeMoaMgr = CProxy_ComputeMoaMgr::ckNew();
#endif // OPENATOM_VERSION
  group.computeExtMgr = CProxy_ComputeExtMgr::ckNew();
  group.computeQMMgr = CProxy_ComputeQMMgr::ckNew();
  group.computeGBISserMgr = CProxy_ComputeGBISserMgr::ckNew();
  group.computeFmmSerialMgr = CProxy_ComputeFmmSerialMgr::ckNew();
  group.computeMsmSerialMgr = CProxy_ComputeMsmSerialMgr::ckNew();
  group.computeLjPmeSerialMgr = CProxy_ComputeLjPmeSerialMgr::ckNew();
#ifdef CHARM_HAS_MSA
  group.computeMsmMsaMgr = CProxy_ComputeMsmMsaMgr::ckNew();
#endif
  group.computeMsmMgr = CProxy_ComputeMsmMgr::ckNew();
  // Charm CkMulticast library module
  group.multicastMgr = CProxy_CkMulticastMgr::ckNew();
#ifdef MEM_OPT_VERSION
  group.ioMgr=CProxy_ParallelIOMgr::ckNew();
#endif

  group.sync = CProxy_Sync::ckNew();

  #ifdef USE_NODEPATCHMGR
  group.nodeProxyMgr = CProxy_NodeProxyMgr::ckNew();
  #endif

#if defined(NAMD_CUDA) || defined(NAMD_HIP)
  group.globalGPUMgr = CProxy_GlobalGPUMgr::ckNew();
  group.synchronousCollectives = CProxy_SynchronousCollectives::ckNew();
#endif

#if     CMK_SMP && USE_CKLOOP
  group.ckLoop = CkLoop_Init();
#endif

  CkChareID collectionMaster = CProxy_CollectionMaster::ckNew(0);
  SlaveInitMsg *initmsg7 = new SlaveInitMsg;
  initmsg7->master = collectionMaster;
  group.collectionMgr = CProxy_CollectionMgr::ckNew(initmsg7);

  group.broadcastMgr = CProxy_BroadcastMgr::ckNew();
  group.ldbCoordinator = CProxy_LdbCoordinator::ckNew();

  group.dataExchanger = CProxy_DataExchanger::ckNew();

  GroupInitMsg *msg = new GroupInitMsg;
  msg->group = group;
  CkGroupID node = CProxy_Node::ckNew(msg);

  CkStartQD(CkCallback(CkIndex_Node::exitScheduler(), CkMyPe(), node));
  CsdScheduler(-1);
}

mic_getargs()

void mic_getargs

(

char **

)

Referenced by all_init().

NAMD_new_handler()

void NAMD_new_handler

(

)

Definition at line 80 of file BackEnd.C.

References NAMD_die().

Referenced by all_init().

                        {
#endif
  char tmp[100];
  sprintf(tmp,"Memory allocation failed on processor %d.",CmiMyPe());
  NAMD_die(tmp);
#if defined(WIN32) && !defined(__CYGWIN__) && !defined(__MINGW_H)
  return 0;
#endif
}

register_exit_sched()

static void register_exit_sched ( void  )

static

Definition at line 64 of file BackEnd.C.

References exit_sched().

Referenced by all_init().

{
  CkpvInitialize(int,exitSchedHndlr);
  CkpvAccess(exitSchedHndlr) = CmiRegisterHandler((CmiHandler)exit_sched);
}

slave_init()

void slave_init	(	int	argc,
		char **	argv
	)

Definition at line 150 of file BackEnd.C.

References after_backend_init(), all_init(), and master_init().

Referenced by BackEnd::init().

{
#if CMK_SMP
  //the original main thread could now be a comm thread
  //and a slave thread could now be the main thread,
  //so we have to do the master initialization here
  if(CmiMyRank()==0){
    master_init(argc, argv);
    if(CmiMyPe()==0)
      after_backend_init(argc, argv);
    return;
  }
#endif

  all_init(argc, argv);

  if (CkMyRank() < CkMyNodeSize())      // skip the communication thread
    CsdScheduler(-1);
}

topo_getargs()

void topo_getargs

(

char **

)

Definition at line 93 of file WorkDistrib.C.

References build_ordering(), and randtopo.

Referenced by all_init().

                               {
  randtopo = CmiGetArgFlag(argv, "+randtopo");
  if ( CkMyPe() >= CkNumPes() ) return;
#if CCD_COND_FN_EXISTS
  CcdCallOnCondition(CcdTOPOLOGY_AVAIL, (CcdCondFn)build_ordering, (void*)0);
#else
  CcdCallOnCondition(CcdTOPOLOGY_AVAIL, (CcdVoidFn)build_ordering, (void*)0);
#endif
}

Variable Documentation

cpuTime_start

float cpuTime_start

Definition at line 53 of file BackEnd.C.

Referenced by BackEnd::exit(), and master_init().

gNAMDBinaryName

char* gNAMDBinaryName = NULL

Definition at line 247 of file BackEnd.C.

Referenced by BackEnd::init(), and Node::outputPatchComputeMaps().

wallTime_start

float wallTime_start

Definition at line 54 of file BackEnd.C.

Referenced by BackEnd::exit(), and master_init().