2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2011-2018, The GROMACS development team.
5 * Copyright (c) 2019,2020, by the GROMACS development team, led by
6 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
7 * and including many others, as listed in the AUTHORS file in the
8 * top-level source directory and at http://www.gromacs.org.
10 * GROMACS is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public License
12 * as published by the Free Software Foundation; either version 2.1
13 * of the License, or (at your option) any later version.
15 * GROMACS is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with GROMACS; if not, see
22 * http://www.gnu.org/licenses, or write to the Free Software Foundation,
23 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
25 * If you want to redistribute modifications to GROMACS, please
26 * consider that scientific software is very special. Version
27 * control is crucial - bugs must be traceable. We will be happy to
28 * consider code for inclusion in the official distribution, but
29 * derived work must not be called official GROMACS. Details are found
30 * in the README & COPYING files - if they are missing, get the
31 * official version at http://www.gromacs.org.
33 * To help us fund GROMACS development, we humbly ask that you cite
34 * the research papers on the package. Check out http://www.gromacs.org.
38 * Implements classes and functions in exceptions.h.
40 * \author Teemu Murtola <teemu.murtola@gmail.com>
41 * \ingroup module_utility
45 #include "gromacs/utility/exceptions.h"
55 #include "thread_mpi/system_error.h"
57 #include "gromacs/utility/basenetwork.h"
58 #include "gromacs/utility/fatalerror.h"
59 #include "gromacs/utility/gmxassert.h"
60 #include "gromacs/utility/stringutil.h"
61 #include "gromacs/utility/textwriter.h"
63 #include "errorcodes.h"
64 #include "errorformat.h"
72 IExceptionInfo::~IExceptionInfo() {}
77 std::map<std::type_index, ExceptionInfoPointer> infos_;
80 } // namespace internal
85 /********************************************************************
90 * Error message or error context text item.
92 * Error messages for an exception are represented as a chain of ErrorMessage
93 * objects: the elements at the bottom of the chain (with no children) is the
94 * error message, and other elements are the context strings added.
96 * \ingroup module_utility
102 * Creates an error message object with the specified text.
104 * \param[in] text Text for the message.
106 explicit ErrorMessage(const std::string& text);
108 //! Whether this object is a context string.
109 bool isContext() const { return static_cast<bool>(child_); }
110 //! Returns the text for this object.
111 const std::string& text() const { return text_; }
113 * Returns the child object for a context object.
115 * Must not be called if isContext() returns false.
117 const ErrorMessage& child() const
119 GMX_ASSERT(isContext(), "Attempting to access nonexistent message object");
124 * Creates a new message object with context prepended.
126 * \param[in] context Context string to add.
127 * \returns New error message object that has \p context as its text
128 * and \c this as its child.
129 * \throws std::bad_alloc if out of memory.
131 ErrorMessage prependContext(const std::string& context) const;
135 std::shared_ptr<ErrorMessage> child_;
139 * Stores a reason or the top-most context string of an exception.
141 * \ingroup module_utility
143 typedef ExceptionInfo<struct ExceptionInfoMessage_, ErrorMessage> ExceptionInfoMessage;
145 ErrorMessage::ErrorMessage(const std::string& text) : text_(text)
147 size_t length = text_.find_last_not_of(" \n");
148 if (length == std::string::npos)
150 length = text_.length() - 1;
152 text_.resize(length + 1);
155 ErrorMessage ErrorMessage::prependContext(const std::string& context) const
157 ErrorMessage newMessage(context);
158 newMessage.child_ = std::make_shared<ErrorMessage>(*this);
163 * Stores list of nested exceptions for Gromacs exceptions.
165 * \ingroup module_utility
167 typedef ExceptionInfo<struct ExceptionInfoNestedExceptions_, internal::NestedExceptionList> ExceptionInfoNestedExceptions;
171 /********************************************************************
175 GromacsException::GromacsException(const ExceptionInitializer& details) :
176 data_(new internal::ExceptionData)
178 setInfo(ExceptionInfoMessage(ErrorMessage(details.reason_)));
179 if (details.hasNestedExceptions())
181 setInfo(ExceptionInfoNestedExceptions(details.nested_));
185 const char* GromacsException::what() const noexcept
187 const ErrorMessage* msg = getInfo<ExceptionInfoMessage>();
190 return "No reason provided";
192 while (msg->isContext())
196 return msg->text().c_str();
199 void GromacsException::prependContext(const std::string& context)
201 const ErrorMessage* msg = getInfo<ExceptionInfoMessage>();
202 GMX_RELEASE_ASSERT(msg != nullptr, "Message should always be set");
203 setInfo(ExceptionInfoMessage(msg->prependContext(context)));
206 const internal::IExceptionInfo* GromacsException::getInfo(const std::type_index& index) const
208 auto iter = data_->infos_.find(index);
209 if (iter != data_->infos_.end())
211 return iter->second.get();
216 void GromacsException::setInfo(const std::type_index& index, internal::ExceptionInfoPointer&& item)
218 data_->infos_[index] = std::move(item);
221 /********************************************************************
222 * Derived exception classes
225 int FileIOError::errorCode() const
230 int InvalidInputError::errorCode() const
232 return eeInvalidInput;
235 int InconsistentInputError::errorCode() const
237 return eeInconsistentInput;
240 int ToleranceError::errorCode() const
245 int SimulationInstabilityError::errorCode() const
247 return eeInstability;
250 int InternalError::errorCode() const
252 return eeInternalError;
255 int APIError::errorCode() const
260 int RangeError::errorCode() const
265 int NotImplementedError::errorCode() const
267 return eeNotImplemented;
270 int ParallelConsistencyError::errorCode() const
272 return eeParallelConsistency;
275 int ModularSimulatorError::errorCode() const
277 return eeModularSimulator;
281 /********************************************************************
288 //! \addtogroup module_utility
292 * Abstracts actual output from the other logic in exception formatting.
294 * Object that implements this interface is passed to
295 * formatExceptionMessageInternal(), and is responsible for composing the
296 * output. This allows using the same implementation of interpreting the
297 * exceptions while still supporting output to different formats (e.g., to a
298 * string or to \c stderr).
303 virtual ~IMessageWriter() {}
306 * Writes a single line of text into the output.
308 * \param[in] text Text to write on the line.
309 * \param[in] indent Suggested number of spaces to indent the line.
311 virtual void writeLine(const char* text, int indent) = 0;
313 * Writes information about a system error (errno-based).
315 * \param[in] errorNumber errno value
316 * \param[in] funcName Name of the system call (can be NULL).
317 * \param[in] indent Suggested number of spaces to indent the output.
319 virtual void writeErrNoInfo(int errorNumber, const char* funcName, int indent) = 0;
323 * Exception information writer for cases where exceptions should be avoided.
325 * Formats the messages into the provided FILE handle without checking for
326 * errors in std::fprintf() calls.
328 class MessageWriterFileNoThrow : public IMessageWriter
331 //! Initializes a writer that writes to the given file handle.
332 explicit MessageWriterFileNoThrow(FILE* fp) : fp_(fp) {}
334 void writeLine(const char* text, int indent) override
336 internal::printFatalErrorMessageLine(fp_, text, indent);
338 void writeErrNoInfo(int errorNumber, const char* funcName, int indent) override
340 std::fprintf(fp_, "%*sReason: %s\n", indent, "", std::strerror(errorNumber));
341 if (funcName != nullptr)
343 std::fprintf(fp_, "%*s(call to %s() returned error code %d)\n", indent, "", funcName, errorNumber);
352 * Exception information writer to format into a TextOutputStream.
354 class MessageWriterTextWriter : public IMessageWriter
357 //! Initializes a writer that writes to the given stream.
358 explicit MessageWriterTextWriter(TextWriter* writer) : writer_(writer) {}
360 void writeLine(const char* text, int indent) override
362 writer_->wrapperSettings().setIndent(indent);
363 writer_->writeLine(text);
365 void writeErrNoInfo(int errorNumber, const char* funcName, int indent) override
367 writer_->wrapperSettings().setIndent(indent);
368 writer_->writeLine(formatString("Reason: %s", std::strerror(errorNumber)));
369 if (funcName != nullptr)
371 writer_->writeLine(formatString("(call to %s() returned error code %d)", funcName, errorNumber));
380 * Exception information writer to format into an std::string.
382 class MessageWriterString : public IMessageWriter
385 //! Post-processes the output string to not end in a line feed.
386 void removeTerminatingLineFeed()
388 if (!result_.empty())
390 result_.erase(result_.size() - 1);
393 //! Returns the constructed string.
394 const std::string& result() const { return result_; }
396 void writeLine(const char* text, int indent) override
398 result_.append(indent, ' ');
399 result_.append(text);
400 result_.append("\n");
402 void writeErrNoInfo(int errorNumber, const char* funcName, int indent) override
404 writeLine(formatString("Reason: %s", std::strerror(errorNumber)).c_str(), indent);
405 if (funcName != nullptr)
407 writeLine(formatString("(call to %s() returned error code %d)", funcName, errorNumber).c_str(),
417 * Prints error information for an exception object.
419 * \param[in] writer Writer to write out the information.
420 * \param[in] ex Exception object to print.
421 * \param[in] indent Indentation for the information.
423 * If the exception contains nested exceptions, information from them is
424 * recursively printed.
426 * Does not throw unless the writer throws.
428 void formatExceptionMessageInternal(IMessageWriter* writer, const std::exception& ex, int indent)
430 const GromacsException* gmxEx = dynamic_cast<const GromacsException*>(&ex);
431 if (gmxEx != nullptr)
433 // TODO: Add an option to print location information for the tests
435 // std::string result;
436 // if (filePtr != NULL && linePtr != NULL)
438 // result = formatString("%s:%d: %s\n", *filePtr, *linePtr,
439 // funcPtr != NULL ? *funcPtr : "");
442 bool bAnythingWritten = false;
443 // TODO: Remove duplicate context if present in multiple nested exceptions.
444 const ErrorMessage* msg = gmxEx->getInfo<ExceptionInfoMessage>();
447 while (msg != nullptr && msg->isContext())
449 writer->writeLine(msg->text().c_str(), indent * 2);
453 if (msg != nullptr && !msg->text().empty())
455 writer->writeLine(msg->text().c_str(), indent * 2);
456 bAnythingWritten = true;
461 writer->writeLine(ex.what(), indent * 2);
462 bAnythingWritten = true;
465 const int* errorNumber = gmxEx->getInfo<ExceptionInfoErrno>();
466 if (errorNumber != nullptr && *errorNumber != 0)
468 const char* const* funcName = gmxEx->getInfo<ExceptionInfoApiFunction>();
469 writer->writeErrNoInfo(
470 *errorNumber, funcName != nullptr ? *funcName : nullptr, (indent + 1) * 2);
471 bAnythingWritten = true;
474 const internal::NestedExceptionList* nested = gmxEx->getInfo<ExceptionInfoNestedExceptions>();
475 if (nested != nullptr)
477 internal::NestedExceptionList::const_iterator ni;
478 for (ni = nested->begin(); ni != nested->end(); ++ni)
482 std::rethrow_exception(*ni);
484 catch (const std::exception& nestedEx)
486 const int newIndent = indent + (bAnythingWritten ? 1 : 0);
487 formatExceptionMessageInternal(writer, nestedEx, newIndent);
494 writer->writeLine(ex.what(), indent * 2);
502 void printFatalErrorMessage(FILE* fp, const std::exception& ex)
504 const char* title = "Unknown exception";
505 bool bPrintType = false;
506 const GromacsException* gmxEx = dynamic_cast<const GromacsException*>(&ex);
507 // TODO: Treat more of the standard exceptions
508 if (gmxEx != nullptr)
510 title = getErrorCodeString(gmxEx->errorCode());
512 else if (dynamic_cast<const tMPI::system_error*>(&ex) != nullptr)
514 title = "System error in thread synchronization";
516 else if (dynamic_cast<const std::bad_alloc*>(&ex) != nullptr)
518 title = "Memory allocation failed";
520 else if (dynamic_cast<const std::logic_error*>(&ex) != nullptr)
522 title = "Standard library logic error (bug)";
525 else if (dynamic_cast<const std::runtime_error*>(&ex) != nullptr)
527 title = "Standard library runtime error (possible bug)";
534 const char* func = nullptr;
535 const char* file = nullptr;
537 if (gmxEx != nullptr)
539 const ThrowLocation* loc = gmxEx->getInfo<ExceptionInfoLocation>();
547 internal::printFatalErrorHeader(fp, title, func, file, line);
550 std::fprintf(fp, "(exception type: %s)\n", typeid(ex).name());
552 MessageWriterFileNoThrow writer(fp);
553 formatExceptionMessageInternal(&writer, ex, 0);
554 internal::printFatalErrorFooter(fp);
557 std::string formatExceptionMessageToString(const std::exception& ex)
559 MessageWriterString writer;
560 formatExceptionMessageInternal(&writer, ex, 0);
561 writer.removeTerminatingLineFeed();
562 return writer.result();
565 void formatExceptionMessageToFile(FILE* fp, const std::exception& ex)
567 MessageWriterFileNoThrow writer(fp);
568 formatExceptionMessageInternal(&writer, ex, 0);
571 void formatExceptionMessageToWriter(TextWriter* writer, const std::exception& ex)
573 MessageWriterTextWriter messageWriter(writer);
574 formatExceptionMessageInternal(&messageWriter, ex, 0);
577 int processExceptionAtExit(const std::exception& /*ex*/)
580 // If we have more than one rank (whether real MPI or thread-MPI),
581 // we cannot currently know whether just one rank or all ranks
582 // actually threw the error, so we need to exit here.
583 // Returning would mean graceful cleanup, which is not possible if
584 // some code is still executing on other ranks/threads.
585 if (gmx_node_num() > 1)
587 gmx_exit_on_fatal_error(ExitType_Abort, returnCode);
592 void processExceptionAsFatalError(const std::exception& ex)
594 printFatalErrorMessage(stderr, ex);
595 gmx_exit_on_fatal_error(ExitType_Abort, 1);