src/gromacs/utility/exceptions.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2011,2012,2013,2014, by the GROMACS development team, led by
   5  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   6  * and including many others, as listed in the AUTHORS file in the
   7  * top-level source directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 /*! \internal \file
  36  * \brief
  37  * Implements classes and functions in exceptions.h.
  38  *
  39  * \author Teemu Murtola <teemu.murtola@gmail.com>
  40  * \ingroup module_utility
  41  */
  42 #include "exceptions.h"
  43
  44 #ifdef HAVE_CONFIG_H
  45 #include "config.h"
  46 #endif
  47
  48 #include <cstring>
  49
  50 #include <new>
  51 #include <stdexcept>
  52 #include <typeinfo>
  53
  54 #include <boost/exception/get_error_info.hpp>
  55 #include <boost/shared_ptr.hpp>
  56
  57 #include "thread_mpi/system_error.h"
  58
  59 #include "gromacs/legacyheaders/network.h"
  60
  61 #include "gromacs/utility/errorcodes.h"
  62 #include "gromacs/utility/gmxassert.h"
  63 #include "gromacs/utility/stringutil.h"
  64
  65 #include "errorformat.h"
  66
  67 namespace gmx
  68 {
  69
  70 namespace
  71 {
  72
  73 /********************************************************************
  74  * ErrorMessage
  75  */
  76
  77 /*! \brief
  78  * Error message or error context text item.
  79  *
  80  * Error messages for an exception are represented as a chain of ErrorMessage
  81  * objects: the elements at the bottom of the chain (with no children) is the
  82  * error message, and other elements are the context strings added.
  83  *
  84  * \ingroup module_utility
  85  */
  86 class ErrorMessage
  87 {
  88     public:
  89         /*! \brief
  90          * Creates an error message object with the specified text.
  91          *
  92          * \param[in] text  Text for the message.
  93          */
  94         explicit ErrorMessage(const std::string &text);
  95
  96         //! Whether this object is a context string.
  97         bool isContext() const { return static_cast<bool>(child_); }
  98         //! Returns the text for this object.
  99         const std::string &text() const { return text_; }
 100         /*! \brief
 101          * Returns the child object for a context object.
 102          *
 103          * Must not be called if isContext() returns false.
 104          */
 105         const ErrorMessage &child() const
 106         {
 107             GMX_ASSERT(isContext(),
 108                        "Attempting to access nonexistent message object");
 109             return *child_;
 110         }
 111
 112         /*! \brief
 113          * Creates a new message object with context prepended.
 114          *
 115          * \param[in] context  Context string to add.
 116          * \returns   New error message object that has \p context as its text
 117          *      and \c this as its child.
 118          * \throws    std::bad_alloc if out of memory.
 119          */
 120         ErrorMessage prependContext(const std::string &context) const;
 121
 122     private:
 123         std::string                     text_;
 124         boost::shared_ptr<ErrorMessage> child_;
 125 };
 126
 127 /*! \internal \brief
 128  * Stores a reason or the top-most context string of an exception.
 129  *
 130  * \ingroup module_utility
 131  */
 132 typedef boost::error_info<struct errinfo_message_, ErrorMessage>
 133     errinfo_message;
 134
 135 ErrorMessage::ErrorMessage(const std::string &text)
 136     : text_(text)
 137 {
 138     size_t length = text_.find_last_not_of(" \n");
 139     if (length == std::string::npos)
 140     {
 141         length = text_.length() - 1;
 142     }
 143     text_.resize(length + 1);
 144 }
 145
 146 ErrorMessage
 147 ErrorMessage::prependContext(const std::string &context) const
 148 {
 149     ErrorMessage newMessage(context);
 150     newMessage.child_.reset(new ErrorMessage(*this));
 151     return newMessage;
 152 }
 153
 154 /*! \brief
 155  * Stores list of nested exceptions for Gromacs exceptions.
 156  *
 157  * \ingroup module_utility
 158  */
 159 typedef boost::error_info<struct errinfo_message_, internal::NestedExceptionList>
 160     errinfo_nested_exceptions;
 161
 162 }   // namespace
 163
 164 /********************************************************************
 165  * GromacsException
 166  */
 167
 168 GromacsException::GromacsException(const ExceptionInitializer &details)
 169 {
 170     *this << errinfo_message(ErrorMessage(details.reason_));
 171     if (details.hasNestedExceptions())
 172     {
 173         *this << errinfo_nested_exceptions(details.nested_);
 174     }
 175 }
 176
 177 const char *GromacsException::what() const throw()
 178 {
 179     const ErrorMessage *msg = boost::get_error_info<errinfo_message>(*this);
 180     while (msg != NULL && msg->isContext())
 181     {
 182         msg = &msg->child();
 183     }
 184     return msg != NULL ? msg->text().c_str() : "No reason provided";
 185 }
 186
 187 void GromacsException::prependContext(const std::string &context)
 188 {
 189     const ErrorMessage *msg = boost::get_error_info<errinfo_message>(*this);
 190     GMX_RELEASE_ASSERT(msg != NULL, "Message should always be set");
 191     *this << errinfo_message(msg->prependContext(context));
 192 }
 193
 194 /********************************************************************
 195  * Derived exception classes
 196  */
 197
 198 int FileIOError::errorCode() const
 199 {
 200     return eeFileIO;
 201 }
 202
 203 int InvalidInputError::errorCode() const
 204 {
 205     return eeInvalidInput;
 206 }
 207
 208 int InconsistentInputError::errorCode() const
 209 {
 210     return eeInconsistentInput;
 211 }
 212
 213 int SimulationInstabilityError::errorCode() const
 214 {
 215     return eeInstability;
 216 }
 217
 218 int InternalError::errorCode() const
 219 {
 220     return eeInternalError;
 221 }
 222
 223 int APIError::errorCode() const
 224 {
 225     return eeAPIError;
 226 }
 227
 228 int NotImplementedError::errorCode() const
 229 {
 230     return eeNotImplemented;
 231 }
 232
 233
 234 /********************************************************************
 235  * Global functions
 236  */
 237
 238 namespace
 239 {
 240
 241 //! \addtogroup module_utility
 242 //! \{
 243
 244 /*! \brief
 245  * Abstracts actual output from the other logic in exception formatting.
 246  *
 247  * Object that implements this interface is passed to
 248  * formatExceptionMessageInternal(), and is responsible for composing the
 249  * output.  This allows using the same implementation of interpreting the
 250  * exceptions while still supporting output to different formats (e.g., to a
 251  * string or to \c stderr).
 252  */
 253 class MessageWriterInterface
 254 {
 255     public:
 256         virtual ~MessageWriterInterface() {}
 257
 258         /*! \brief
 259          * Writes a single line of text into the output.
 260          *
 261          * \param[in] text    Text to write on the line.
 262          * \param[in] indent  Suggested number of spaces to indent the line.
 263          */
 264         virtual void writeLine(const char *text, int indent) = 0;
 265         /*! \brief
 266          * Writes information about a system error (errno-based).
 267          *
 268          * \param[in] errorNumber  errno value
 269          * \param[in] funcName     Name of the system call (can be NULL).
 270          * \param[in] indent       Suggested number of spaces to indent the output.
 271          */
 272         virtual void writeErrNoInfo(int errorNumber, const char *funcName,
 273                                     int indent) = 0;
 274 };
 275
 276 /*! \brief
 277  * Exception information writer for cases where exceptions should be avoided.
 278  *
 279  * Formats the messages into the provided FILE handle without checking for
 280  * errors in std::fprintf() calls.
 281  */
 282 class MessageWriterFileNoThrow : public MessageWriterInterface
 283 {
 284     public:
 285         //! Initializes a writer that writes to the given file handle.
 286         explicit MessageWriterFileNoThrow(FILE *fp) : fp_(fp) {}
 287
 288         virtual void writeLine(const char *text, int indent)
 289         {
 290             internal::printFatalErrorMessageLine(fp_, text, indent);
 291         }
 292         virtual void writeErrNoInfo(int errorNumber, const char *funcName,
 293                                     int indent)
 294         {
 295             std::fprintf(fp_, "%*sReason: %s\n", indent, "",
 296                          std::strerror(errorNumber));
 297             if (funcName != NULL)
 298             {
 299                 std::fprintf(fp_, "%*s(call to %s() returned error code %d)\n",
 300                              indent, "", funcName, errorNumber);
 301             }
 302         }
 303
 304     private:
 305         FILE                   *fp_;
 306 };
 307
 308 /*! \brief
 309  * Exception information writer to format into an std::string.
 310  */
 311 class MessageWriterString : public MessageWriterInterface
 312 {
 313     public:
 314         //! Post-processes the output string to not end in a line feed.
 315         void removeTerminatingLineFeed()
 316         {
 317             if (result_.size() > 0U)
 318             {
 319                 result_.erase(result_.size() - 1);
 320             }
 321         }
 322         //! Returns the constructed string.
 323         const std::string &result() const { return result_; }
 324
 325         virtual void writeLine(const char *text, int indent)
 326         {
 327             result_.append(indent, ' ');
 328             result_.append(text);
 329             result_.append("\n");
 330         }
 331         virtual void writeErrNoInfo(int errorNumber, const char *funcName,
 332                                     int indent)
 333         {
 334             writeLine(formatString("Reason: %s", std::strerror(errorNumber)).c_str(),
 335                       indent);
 336             if (funcName != NULL)
 337             {
 338                 writeLine(formatString("(call to %s() returned error code %d)",
 339                                        funcName, errorNumber).c_str(),
 340                           indent);
 341             }
 342         }
 343
 344     private:
 345         std::string             result_;
 346 };
 347
 348 /*! \brief
 349  * Prints error information for an exception object.
 350  *
 351  * \param[in] writer  Writer to write out the information.
 352  * \param[in] ex      Exception object to print.
 353  * \param[in] indent  Indentation for the information.
 354  *
 355  * If the exception contains nested exceptions, information from them is
 356  * recursively printed.
 357  *
 358  * Does not throw unless the writer throws.
 359  */
 360 void formatExceptionMessageInternal(MessageWriterInterface *writer,
 361                                     const std::exception &ex, int indent)
 362 {
 363     const boost::exception *boostEx = dynamic_cast<const boost::exception *>(&ex);
 364     if (boostEx != NULL)
 365     {
 366         // TODO: Add an option to print this information for the tests
 367         // const char *const *funcPtr =
 368         //     boost::get_error_info<boost::throw_function>(*boostEx);
 369         // const char *const *filePtr =
 370         //     boost::get_error_info<boost::throw_file>(*boostEx);
 371         // const int         *linePtr =
 372         //     boost::get_error_info<boost::throw_line>(*boostEx);
 373
 374         // std::string        result;
 375         // if (filePtr != NULL && linePtr != NULL)
 376         // {
 377         //     result = formatString("%s:%d: %s\n", *filePtr, *linePtr,
 378         //                           funcPtr != NULL ? *funcPtr : "");
 379         // }
 380
 381         // TODO: Remove duplicate context if present in multiple nested exceptions.
 382         const ErrorMessage *msg = boost::get_error_info<errinfo_message>(*boostEx);
 383         if (msg != NULL)
 384         {
 385             while (msg != NULL && msg->isContext())
 386             {
 387                 writer->writeLine(msg->text().c_str(), indent*2);
 388                 ++indent;
 389                 msg = &msg->child();
 390             }
 391             if (msg != NULL && !msg->text().empty())
 392             {
 393                 writer->writeLine(msg->text().c_str(), indent*2);
 394             }
 395         }
 396         else
 397         {
 398             writer->writeLine(ex.what(), indent*2);
 399         }
 400
 401         const int *errorNumber
 402             = boost::get_error_info<boost::errinfo_errno>(*boostEx);
 403         if (errorNumber != NULL)
 404         {
 405             const char * const *funcName
 406                 = boost::get_error_info<boost::errinfo_api_function>(*boostEx);
 407             writer->writeErrNoInfo(*errorNumber,
 408                                    funcName != NULL ? *funcName : NULL,
 409                                    (indent+1)*2);
 410         }
 411
 412         // TODO: Treat also boost::nested_exception (not currently used, though)
 413
 414         const internal::NestedExceptionList *nested
 415             = boost::get_error_info<errinfo_nested_exceptions>(*boostEx);
 416         if (nested != NULL)
 417         {
 418             internal::NestedExceptionList::const_iterator ni;
 419             for (ni = nested->begin(); ni != nested->end(); ++ni)
 420             {
 421                 try
 422                 {
 423                     rethrow_exception(*ni);
 424                 }
 425                 catch (const std::exception &nestedEx)
 426                 {
 427                     formatExceptionMessageInternal(writer, nestedEx, indent + 1);
 428                 }
 429             }
 430         }
 431     }
 432     else
 433     {
 434         writer->writeLine(ex.what(), indent*2);
 435     }
 436 }
 437
 438 //! \}
 439
 440 }   // namespace
 441
 442 void printFatalErrorMessage(FILE *fp, const std::exception &ex)
 443 {
 444     const char             *title      = "Unknown exception";
 445     bool                    bPrintType = false;
 446     const GromacsException *gmxEx      = dynamic_cast<const GromacsException *>(&ex);
 447     // TODO: Treat more of the standard exceptions
 448     if (gmxEx != NULL)
 449     {
 450         title = getErrorCodeString(gmxEx->errorCode());
 451     }
 452     else if (dynamic_cast<const tMPI::system_error *>(&ex) != NULL)
 453     {
 454         title = "System error in thread synchronization";
 455     }
 456     else if (dynamic_cast<const std::bad_alloc *>(&ex) != NULL)
 457     {
 458         title = "Memory allocation failed";
 459     }
 460     else if (dynamic_cast<const std::logic_error *>(&ex) != NULL)
 461     {
 462         title      = "Standard library logic error (bug)";
 463         bPrintType = true;
 464     }
 465     else if (dynamic_cast<const std::runtime_error *>(&ex) != NULL)
 466     {
 467         title      = "Standard library runtime error (possible bug)";
 468         bPrintType = true;
 469     }
 470     else
 471     {
 472         bPrintType = true;
 473     }
 474     // We can't call get_error_info directly on ex since our internal boost
 475     // needs to be compiled with BOOST_NO_RTTI. So we do the dynamic_cast
 476     // here instead.
 477     const char *const      *funcPtr = NULL;
 478     const char *const      *filePtr = NULL;
 479     const int              *linePtr = NULL;
 480     const boost::exception *boostEx = dynamic_cast<const boost::exception *>(&ex);
 481     if (boostEx != NULL)
 482     {
 483         funcPtr = boost::get_error_info<boost::throw_function>(*boostEx);
 484         filePtr = boost::get_error_info<boost::throw_file>(*boostEx);
 485         linePtr = boost::get_error_info<boost::throw_line>(*boostEx);
 486     }
 487     internal::printFatalErrorHeader(fp, title,
 488                                     funcPtr != NULL ? *funcPtr : NULL,
 489                                     filePtr != NULL ? *filePtr : NULL,
 490                                     linePtr != NULL ? *linePtr : 0);
 491     if (bPrintType)
 492     {
 493         std::fprintf(fp, "(exception type: %s)\n", typeid(ex).name());
 494     }
 495     MessageWriterFileNoThrow writer(fp);
 496     formatExceptionMessageInternal(&writer, ex, 0);
 497     internal::printFatalErrorFooter(fp);
 498 }
 499
 500 std::string formatExceptionMessageToString(const std::exception &ex)
 501 {
 502     MessageWriterString writer;
 503     formatExceptionMessageInternal(&writer, ex, 0);
 504     writer.removeTerminatingLineFeed();
 505     return writer.result();
 506 }
 507
 508 void formatExceptionMessageToFile(FILE *fp, const std::exception &ex)
 509 {
 510     MessageWriterFileNoThrow writer(fp);
 511     formatExceptionMessageInternal(&writer, ex, 0);
 512 }
 513
 514 int processExceptionAtExit(const std::exception & /*ex*/)
 515 {
 516     int returnCode = 1;
 517 #ifdef GMX_LIB_MPI
 518     // TODO: Consider moving the output done in gmx_abort() into the message
 519     // printing routine above, so that this could become a simple MPI_Abort().
 520     gmx_abort(gmx_node_rank(), gmx_node_num(), returnCode);
 521 #endif
 522     return returnCode;
 523 }
 524
 525 } // namespace gmx