Date: 2013-07-02T14:45:20+00:00

Actual source code: ALE.cxx
petsc-3.4.2 2013-07-02

      1: #define ALE_ALE_cxx

      3: #include <ALE.hh>

      5: namespace ALE {
      6:   //
      7:   // Package-wide verbosity
      8:   //
      9:   static int verbosity = 0;

     11:   int  getVerbosity() {return ALE::verbosity;};
     12:   void setVerbosity(const int& verbosity) {ALE::verbosity = verbosity;};

     14:   //
     15:   //  Memory handling stuff (ALE_mem.hh).
     16:   //

     18:   // static instance of a standard char allocator;  this is the only allocator used by ALE;
     19:   // it is defined here -- in an .cxx file -- to ensure that exactly one copy exists;
     20:   // its services are presented through a static interface defined in universal_allocator.

     22:   std::allocator<char> _alloc;

     24:   char *universal_allocator::allocate(const universal_allocator::size_type& sz) {
     25:     return _alloc.allocate(sz);
     26:   }

     28:   void universal_allocator::deallocate(char *p, const universal_allocator::size_type& sz) {
     29:     return _alloc.deallocate(p,sz);
     30:   }

     32:   universal_allocator::size_type universal_allocator::max_size() {
     33:     return _alloc.max_size();
     34:   }

     36:   //
     37:   // Error/exception handling helper functions (ALE_exception.hh).
     38:   //

     40:   // A helper function for converting PETSc errors to exception
     41:   // including the function and the line where the error occured.
     42:   void ERROR(PetscErrorCode ierr, const char *func, int line, const char *msg) {
     43:     if(ierr) {
     44:       ostringstream mess;
     45:       mess << func << ": line " << line << ": error " << ierr << ": " << msg << ":\n";
     46:       throw ALE::Exception(mess);
     47:     }
     48:   }// ERROR()

     50:   const char *ERRORMSG(const char *fmt, ...);

     52:   // A helper function for converting MPI errors to exception
     53:   void MPIERROR(PetscErrorCode ierr, const char *func, int line, const char *msg) {
     54:     if(ierr) {
     55:       char mpi_error[MPI_MAX_ERROR_STRING+1];
     56:       int len = MPI_MAX_ERROR_STRING;
     57:       PetscErrorCode ie = MPI_Error_string(ierr, mpi_error, &len);
     58:       ostringstream mess;

     60:       if (!ie) {
     61:         mess << func << ": line " << line << ": error " << ierr << ": " << msg << ": " << mpi_error << "\n";
     62:       } else {
     63:         mess << func << ": line " << line << ": error " << ierr << ": " << msg << ": <unknown error>\n";
     64:       }
     65:       throw ALE::Exception(mess);
     66:     }
     67:   }// MPIERROR()

     69:   // A helper function that allocates and assembles an error message from a format string
     70:   const char *ERRORMSG(const char *fmt, ...) {
     71:     va_list Argp;
     72:     int32_t buf_size = 2*MPI_MAX_ERROR_STRING;
     73:     if(fmt) {
     74:       va_start(Argp, fmt);
     75:       char *msg = (char *)malloc(sizeof(char)*(buf_size+1));
     76: #ifdef PETSC_HAVE_SNPRINTF
     77:       snprintf(msg, buf_size, fmt, Argp);
     78: #else
     79:       sprintf(msg, fmt, Argp);
     80: #endif
     81:       va_end(Argp);
     82:       return msg;
     83:     }
     84:     return fmt;
     85:   }// ERRORMSG()

     87:   //
     88:   // Logging helper functions
     89:   //

     91:   static std::map<std::string, LogStage> _log_stage;  // a map from stage names to stage numbers

     93:   #undef  __FUNCT__
     95:   LogCookie LogCookieRegister(const char *name){
     96:     LogCookie cookie;
     97:     PetscErrorCode PetscClassIdRegister(name, &cookie);
     98:    CHKERROR(ierr, "PetscClassIdRegister failed");
     99:     return cookie;
    100:   }

    102:   #undef  __FUNCT__
    104:   LogStage LogStageRegister(const char *name){
    105:     int stage = 0;
    106:     std::string stage_name(name);
    107:     if(_log_stage.find(stage_name) == _log_stage.end()) {
    108:       // stage by that name not yet registered, so we register it and store its registration number.
    109:       PetscErrorCode PetscLogStageRegister(name, &stage);CHKERROR(ierr, "PetscLogStageRegister failed");
    110:       _log_stage[stage_name] = stage;
    111:     }
    112:     else {
    113:       // stage by that name already registered, so we retrieve its registration number.
    114:       stage = _log_stage[stage_name];
    115:     }
    116:     return stage;
    117:   }

    119:   #undef  __FUNCT__
    121:   void LogStagePush(int s){
    123:     PetscLogStagePush(s);CHKERROR(ierr, "PetscLogStagePush failed");
    124:   }//LogStagePush()

    126:   #undef  __FUNCT__
    128:   void LogStagePop(int s){
    129:     // A future implementation may use 's' to check for the correct order of stage push/pop events.
    131:     PetscLogStagePop();CHKERROR(ierr, "PetscLogStagePop failed");
    132:   }//LogStagePop()

    134:   static std::map<std::string, LogEvent> _log_event;  // a map from event names to event numbers

    136:   #undef  __FUNCT__
    138:   LogEvent LogEventRegister(LogCookie cookie, const char *name) {
    139:     std::string event_name(name);
    140:     LogEvent event = 0;

    142:     if (_log_event.find(event_name) == _log_event.end()) {
    143:       PetscErrorCode PetscLogEventRegister(name, cookie, &event);CHKERROR(ierr, "PetscLogEventRegister failed");
    144:       _log_event[event_name] = event;
    145:     } else {
    146:       // event by that name already registered, so we retrieve its registration number.
    147:       event = _log_event[event_name];
    148:     }
    149:     return event;
    150:   }

    152:   #undef  __FUNCT__
    154:   LogEvent LogEventRegister(const char *name){
    155:     return LogEventRegister(PETSC_SMALLEST_CLASSID, name);
    156:   }

    158:   #undef  __FUNCT__
    160:   void LogEventBegin(LogEvent e){
    162:     PetscLogEventBegin(e, 0, 0, 0, 0);CHKERROR(ierr, "PetscLogEventBegin failed");
    163:   }//LogEventBegin()

    165:   #undef  __FUNCT__
    167:   void LogEventEnd(LogEvent e){
    169:     PetscLogEventEnd(e, 0, 0, 0, 0);CHKERROR(ierr, "PetscLogEventEnd failed");
    170:   }//LogEventEnd()

    172: }

    174: #undef ALE_ALE_cxx