Line data    Source code

       1           1 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : /// \file
       5             : /// Defines Parallel::printf for writing to stdout
       6             : 
       7             : #pragma once
       8             : 
       9             : #include <cstddef>
      10             : #include <cstdio>
      11             : #include <iomanip>
      12             : #include <limits>
      13             : #include <sstream>
      14             : #include <string>
      15             : #include <type_traits>
      16             : #include <utility>
      17             : #include <vector>
      18             : 
      19             : #include "Utilities/ErrorHandling/FloatingPointExceptions.hpp"
      20             : #include "Utilities/Requires.hpp"
      21             : #include "Utilities/TypeTraits/IsStreamable.hpp"
      22             : 
      23             : /// \cond
      24             : namespace PUP {
      25             : class er;
      26             : }  // namespace PUP
      27             : /// \endcond
      28             : 
      29             : #include "Parallel/Printf/Printf.decl.h"
      30             : 
      31             : namespace Parallel {
      32             : namespace detail {
      33             : /*!
      34             :  * Fundamentals and pointers are already printable so there is no conversion
      35             :  * to a std::string necessary.
      36             :  */
      37             : template <typename T,
      38             :           Requires<std::is_fundamental<std::decay_t<
      39             :                        std::remove_pointer_t<std::decay_t<T>>>>::value or
      40             :                    std::is_pointer<T>::value or
      41             :                    std::is_pointer<std::decay_t<T>>::value> = nullptr>
      42             : inline constexpr T stream_object_to_string(T&& t) {
      43             :   return t;
      44             : }
      45             : 
      46             : /*!
      47             :  * Stream an object of type `T` into a std::stringstream and return it as a
      48             :  * std::string so that it is printable by calling `.c_str()` on it.
      49             :  * We need a 2-phase call so that the std::string doesn't go out of scope before
      50             :  * the C-style string is passed to printf.
      51             :  */
      52             : template <typename T,
      53             :           Requires<std::is_class<std::decay_t<T>>::value or
      54             :                    std::is_enum<std::decay_t<T>>::value> = nullptr>
      55             : inline std::string stream_object_to_string(T&& t) {
      56             :   using ::operator<<;
      57             :   static_assert(tt::is_streamable<std::stringstream, T>::value,
      58             :                 "Cannot stream type and therefore it cannot be printed. Please "
      59             :                 "define a stream operator for the type.");
      60             :   std::stringstream ss;
      61             :   ss << std::setprecision(std::numeric_limits<double>::digits10 + 4)
      62             :      << std::scientific << t;
      63             :   return ss.str();
      64             : }
      65             : 
      66             : /*!
      67             :  * Fundamentals are already printable, so nothing to do.
      68             :  */
      69             : template <typename T,
      70             :           Requires<std::is_fundamental<std::decay_t<
      71             :               std::remove_pointer_t<std::decay_t<T>>>>::value> = nullptr>
      72             : inline constexpr T get_printable_type(T&& t) {
      73             :   return t;
      74             : }
      75             : 
      76             : /*!
      77             :  * Get the pointer of the std::string so it can be passed to CkPrintf which
      78             :  * only works on fundamentals
      79             :  */
      80             : inline const typename std::string::value_type* get_printable_type(
      81             :     const std::string& t) {
      82             :   return t.c_str();
      83             : }
      84             : 
      85             : void send_message(bool error, const std::vector<char>& message);
      86             : void send_message_to_file(const std::string& file,
      87             :                           const std::vector<char>& message);
      88             : 
      89             : template <typename... Ts>
      90             : inline std::vector<char> allocate_message(const char* const format, Ts&&... t) {
      91             : #pragma GCC diagnostic push
      92             : #pragma GCC diagnostic ignored "-Wformat-nonliteral"
      93             : #pragma GCC diagnostic ignored "-Wformat-security"
      94             :   // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
      95             :   const auto length = static_cast<size_t>(snprintf(nullptr, 0, format, t...));
      96             :   std::vector<char> message(length + 1);  // +1 for the null byte
      97             :   // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-array-to-pointer-decay)
      98             :   snprintf(message.data(), message.size(), format, t...);
      99             : #pragma GCC diagnostic pop
     100             :   return message;
     101             : }
     102             : 
     103             : template <typename... Args>
     104             : inline std::vector<char> format_message(const std::string& format,
     105             :                                         Args&&... args) {
     106             :   const ScopedFpeState disable_fpes(false);
     107             :   return allocate_message(
     108             :       format.c_str(),
     109             :       get_printable_type(stream_object_to_string(std::forward<Args>(args)))...);
     110             : }
     111             : }  // namespace detail
     112             : 
     113             : /*!
     114             :  * \ingroup ParallelGroup
     115             :  * \brief Print an atomic message to stdout with C printf usage.
     116             :  *
     117             :  * Similar to Python, you can print any object that's streamable by passing it
     118             :  * in as an argument and using the formatter "%s". For example,
     119             :  * \code
     120             :  * std::vector<double> a{0.8, 73, 9.8};
     121             :  * Parallel::printf("%s\n", a);
     122             :  * \endcode
     123             :  */
     124             : template <typename... Args>
     125           1 : inline void printf(const std::string& format, Args&&... args) {
     126             :   detail::send_message(
     127             :       false, detail::format_message(format, std::forward<Args>(args)...));
     128             : }
     129             : 
     130             : /*!
     131             :  * \ingroup ParallelGroup
     132             :  * \brief Print an atomic message to stderr with C printf usage.
     133             :  *
     134             :  * See Parallel::printf for details.
     135             :  */
     136             : template <typename... Args>
     137           1 : inline void printf_error(const std::string& format, Args&&... args) {
     138             :   detail::send_message(
     139             :       true, detail::format_message(format, std::forward<Args>(args)...));
     140             : }
     141             : 
     142             : /*!
     143             :  * \ingroup ParallelGroup
     144             :  * \brief Print an atomic message to a file with C printf usage.
     145             :  *
     146             :  * See Parallel::printf for details.
     147             :  */
     148             : template <typename... Args>
     149           1 : inline void fprintf(const std::string& file, const std::string& format,
     150             :                     Args&&... args) {
     151             :   detail::send_message_to_file(
     152             :       file, detail::format_message(format, std::forward<Args>(args)...));
     153             : }
     154             : 
     155             : /// Chare outputting all Parallel::printf results.
     156           1 : class PrinterChare : public CBase_PrinterChare {
     157             :  public:
     158           0 :   PrinterChare() = default;
     159           0 :   explicit PrinterChare(CkMigrateMessage* /*msg*/) {}
     160             : 
     161             :   /// Prints a message to stdout or stderr.
     162           1 :   static void print(bool error, const std::vector<char>& message);
     163             : 
     164             :   /// Prints a message to a file.
     165           1 :   static void print_to_file(const std::string& file,
     166             :                             const std::vector<char>& message);
     167             : 
     168           0 :   static void register_with_charm();
     169             : 
     170           0 :   void pup(PUP::er& /*p*/) override {}
     171             : };
     172             : 
     173             : // Charm readonly variables set in Main.
     174             : // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     175           0 : extern CProxy_PrinterChare printer_chare;
     176             : // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
     177           0 : extern bool printer_chare_is_set;
     178             : }  // namespace Parallel