Environment Class Reference

Environment for the program. More...

#include <environment.h>

Collaboration diagram for Environment:

Public Member Functions
	Environment (int, char **)
	~Environment ()
	Destructor. More...
MInt	run ()
	Runs the Environment, makes the Application run. More...
MInt	end ()
	Ends the Environment. More...

Static Public Attributes
static MInt	m_argc
	Reads the name of the property-file and creates a new Application. More...
static MChar **	m_argv

Private Member Functions
void	parseCommandline ()
	Reads out the options that where used by the program call. More...

Static Private Member Functions
static void	printStartupInformation ()
	Print startup summary of MAIA. More...

Private Attributes
Application *	mApplication
Scratch *	mScratch
MString	m_propertyFileInput = "properties.toml"

Detailed Description

Date

begin: 03.01.20 change 00.00.00

Definition at line 21 of file environment.h.

Constructor & Destructor Documentation

Environment()

Environment::Environment	(	int	,
		char **
	)

~Environment()

Environment::~Environment

(

)

Definition at line 142 of file environment.cpp.

                          {
  m_log << Scratch::printSelf();
  delete mScratch;
  if(mApplication != nullptr) delete mApplication;
}

Member Function Documentation

end()

MInt Environment::end

(

)

Definition at line 179 of file environment.cpp.

                      {
  TRACE();
 
#ifdef MAIA_WRITE_ACCESS_PROPERTIES_FILE
  Context::writePropertiesHumanReadable();
#endif
  return 0;
}

parseCommandline()

void Environment::parseCommandline ( )

private

Definition at line 190 of file environment.cpp.

                                   {
  TRACE();
 
#if defined(MAIA_MS_COMPILER) || defined(_SX)
#pragma message("WARNING: Not implemented!")
#else
  opterr = 0;
  while(true) {
    int c = 0;
    DIR* directory = nullptr;
    string inputDirectory;
    string outputDirectory;
    int option_index = 0;
    static option long_options[] = {
        {"debug", 1, 0, 'd'},   {"help", 0, 0, 'h'},     {"input", 1, 0, 'i'},      {"output", 1, 0, 'o'},
        {"version", 0, 0, 'v'}, {"compiler", 0, 0, 'c'}, {"build-type", 0, 0, 'b'}, {0, 0, 0, 0}};
 
    c = getopt_long(m_argc, m_argv, "d:hi:o:p:vcb", long_options, &option_index);
    if(c == -1) {
      break;
    }
 
    switch(c) {
      case 0:
        cout << "option " << long_options[option_index].name << endl;
        if(optarg != nullptr) cout << "with arg " << optarg << endl;
        cout << endl;
        break;
 
      case 'd':
        if(atoi(optarg) < 2 * MDebug::m_maxLevel && atoi(optarg) >= MDebug::m_minLevel) {
          SET_DEBUG_LEVEL((MDebugLevel)atoi(optarg));
          if(globalDomainId() == 0) {
            cout << "SET DEBUG LEVEL TO: " << atoi(optarg) << endl;
          }
          m_log << "SET DEBUG LEVEL TO: " << atoi(optarg) << endl;
          DEBUG("Environment::parseCommandline: option -d " << atoi(optarg), MAIA_DEBUG_IO);
        } else {
          cerr << "Error: debug level out of range!" << endl;
          cerr << "Specified debug level is " << atoi(optarg) << ", but must be in the range of " << endl;
          cerr << 2 * MDebug::m_minLevel << " <= debug level <= " << 2 * MDebug::m_maxLevel << endl;
          cerr << "Debug level is unchanged" << endl;
          return;
        }
        break;
 
      case 'h':
        cout << "usage: " << m_argv[0] << " [-h] [-b] [-c] [--debug LEVEL] [--input DIRECTORY] "
             << "[--output DIRECTORY] [-v] [PROPERTY_FILE]" << endl
             << endl
             << "positional arguments:" << endl
             << "  PROPERTY_FILE            name of property file to use (default: '" << m_propertyFileInput << "')\n"
             << endl
             << "optional arguments:\n"
             << "  -b, --build-type         show build type that was used\n"
             << "  -c, --compiler           show used compiler\n"
             << "  -d, --debug LEVEL        use specified debug level\n"
             << "  -h, --help               this help screen\n"
             << "  -i, --input DIRECTORY    specified directory is used for all "
                "input files\n"
             << "  -o, --output DIRECTORY   specified directory is used for all "
                "output files\n"
             << "  -v, --version            show MAIA version\n"
             << endl;
        m_log.close();
        maia_res.close();
        MPI_Finalize();
        exit(0);
        break;
 
      case 'i':
        directory = opendir(optarg);
        if(directory != nullptr) {
          closedir(directory);
          inputDirectory.append(optarg);
          DEBUG("Environment::parseCommandline: option -i " << optarg, MAIA_DEBUG_IO);
        } else {
          stringstream errorMessage;
          errorMessage << " error opening inputDirectory \"" << optarg << "\"!" << endl;
          mTerm(1, AT_, errorMessage.str());
        }
        break;
 
      case 'o':
        directory = opendir(optarg);
        if(directory != nullptr) {
          closedir(directory);
          outputDirectory.append(optarg);
          DEBUG("Environment::parseCommandline: option -o " << optarg, MAIA_DEBUG_IO);
        } else {
          stringstream errorMessage;
          errorMessage << "Error opening outputDirectory \"" << optarg << "\"!";
          mTerm(1, AT_, errorMessage.str());
        }
        break;
 
      case 'v':
// Show version and quit
#ifndef MAIA_VERSION_STRING
#define MAIA_VERSION_STRING unknown
#endif
        cout << XSTRINGIFY(MAIA_VERSION_STRING) << endl;
        m_log.close();
        maia_res.close();
        MPI_Finalize();
        exit(0);
        break;
 
      case 'c':
// Show used compiler and quit
#ifndef MAIA_COMPILER_STRING
#define MAIA_COMPILER_STRING unknown
#endif
        cout << XSTRINGIFY(MAIA_COMPILER_STRING) << endl;
        m_log.close();
        maia_res.close();
        MPI_Finalize();
        exit(0);
        break;
 
      case 'b':
// Show used build type and quit
#ifndef MAIA_BUILD_TYPE_STRING
#define MAIA_BUILD_TYPE_STRING unknown
#endif
        cout << XSTRINGIFY(MAIA_BUILD_TYPE_STRING) << endl;
        m_log.close();
        maia_res.close();
        MPI_Finalize();
        exit(0);
        break;
 
      case '?':
        break;
 
      default:
        cerr << "Environment::parseCommandline: Error getopt returned "
                "unkown option code \""
             << c << "\"" << endl;
    }
  }
 
  // Obtain command line argument for property file
  if(optind < m_argc) {
    m_propertyFileInput = m_argv[optind];
  }
  // On domain 0, check if file is readable
  if(globalDomainId() == 0 && !ifstream(m_propertyFileInput)) {
    TERMM(1, "property file '" + m_propertyFileInput + "' not readable");
  }
#endif
}

printStartupInformation()

void Environment::printStartupInformation ( )

staticprivate

Author

Michael Schlottke-Lakemper (mic) mic@a.nosp@m.ia.r.nosp@m.wth-a.nosp@m.ache.nosp@m.n.de

Date

2016-09-19

This method prints some information to stdout that may be useful for debugging purposes later (and to identify which stdout logs belong to which MAIA run).

Definition at line 352 of file environment.cpp.

                                          {
  // Define buffer size
  const MInt bufferSize = 1024;
 
  // Get current hostname
  array<char, bufferSize> host_{};
  gethostname(&host_[0], bufferSize - 1);
  host_[bufferSize - 1] = '\0';
  const MString host(&host_[0]);
 
  // Get current username
  MString user = "(unknown user)";
#if defined(MAIA_MS_COMPILER)
  constexpr MInt INFO_BUFFER_SIZE = 32767;
  TCHAR infoBuf[INFO_BUFFER_SIZE];
  DWORD bufCharCount = INFO_BUFFER_SIZE;
  if(GetUserName(infoBuf, &bufCharCount)) {
    user = infoBuf;
  }
#else
  passwd* p;
  p = getpwuid(getuid());
  if(p) {
    user = MString(p->pw_name);
  }
#endif
 
  // Get current directory
  array<char, bufferSize> dir_{};
#if defined(MAIA_MS_COMPILER)
  _getcwd(&dir_[0], bufferSize - 1);
#else
  if(getcwd(&dir_[0], bufferSize - 1) == nullptr) {
    TERM(-1);
  }
#endif
  dir_[bufferSize - 1] = '\0';
  const MString dir(&dir_[0]);
 
  // Get current execution command and command line arguments
  const MString executable(m_argv[0]);
  stringstream ss;
  if(m_argc > 1) {
    ss << MString(m_argv[0]);
    for(MInt n = 1; n < m_argc; n++) {
      ss << " " << MString(m_argv[n]);
    }
  } else {
    ss << "(none)";
  }
  const MString args(ss.str());
 
  // Create start timestamp
  array<char, bufferSize> dateString_{};
  time_t rawTime = 0;
 
  // Get the current time and write it to rawTime
  time(&rawTime);
 
  // Convert to time struct
  tm* timeInfo = localtime(&rawTime);
 
  // Format time to string and save to buffer
  strftime(&dateString_[0], bufferSize, "%Y-%m-%d %H:%M:%S", timeInfo);
 
  // Store date as real string
  const MString dateString(&dateString_[0]);
 
  // Print startup information
  cout << "      _____ ______    ________   ___   ________                             \n"
          " ____|\\   _ \\  _   \\ |\\   __  \\ |\\  \\ |\\   __  \\ ___                   \n"
          "  ___\\ \\  \\\\\\__\\ \\  \\\\ \\  \\|\\  \\\\ \\  \\\\ \\  \\|\\  \\ ___    \n"
          "   ___\\ \\  \\\\|__| \\  \\\\ \\   __  \\\\ \\  \\\\ \\   __  \\ ___         \n"
          "    ___\\ \\  \\    \\ \\  \\\\ \\  \\ \\  \\\\ \\  \\\\ \\  \\ \\  \\ ___    \n"
          "     ___\\ \\__\\    \\ \\__\\\\ \\__\\ \\__\\\\ \\__\\\\ \\__\\ \\__\\ ___    \n"
          "      ___\\|__|     \\|__| \\|__|\\|__| \\|__| \\|__|\\|__| ____               \n"
          "\n";
  cout << "Start time:            " << dateString << "\n"
       << "Number of ranks:       " << globalNoDomains() << "\n"
#ifdef _OPENMP
       << "Number of OMP threads: " << omp_get_max_threads() << "\n"
#endif
       << "Host (of rank 0):      " << host << "\n"
       << "Working directory:     " << dir << "\n"
       << "User:                  " << user << "\n"
       << "Executable:            " << executable << "\n"
       << "Command line args:     " << args << "\n"
       << endl;
}

run()

MInt Environment::run

(

)

Definition at line 149 of file environment.cpp.

                      {
  Profile runProfile("Environment::run");
 
  Context::communicateProperties();
  Context::initializationProcessFinished();
 
  TRACE();
 
  MBool flowSolver = false;
  flowSolver = Context::getBasicProperty<MBool>("flowSolver", AT_, &flowSolver);
 
  // Return here if flow solver is not enabled.
  if(!flowSolver) {
    return 0;
  }
 
  MInt nDim = read_nDim();
 
  if(nDim == 2) {
    mApplication->run<2>();
  } else if(nDim == 3) {
    mApplication->run<3>();
  } else {
    mTerm(1, AT_, "Invalid value of nDim!");
  }
 
  return 0;
}

Member Data Documentation

m_argc

MInt Environment::m_argc

static

Definition at line 28 of file environment.h.

m_argv

MChar ** Environment::m_argv

static

Definition at line 29 of file environment.h.

m_propertyFileInput

MString Environment::m_propertyFileInput = "properties.toml"

private

Definition at line 38 of file environment.h.

mApplication

Application* Environment::mApplication

private

Definition at line 33 of file environment.h.

mScratch

Scratch* Environment::mScratch

private

Definition at line 34 of file environment.h.

---

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

• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/environment.h
• /home/gitlab-runner/scratch/builds/oxpnswJ6/1/aia/m-AIA/m-AIA/src/environment.cpp