Tracing for HDF5

Author: anokfireball

CMakeLists.txt

@@ -440,7 +440,7 @@ endif()
 if(openPMD_HAVE_LOGGING)
     add_library(openPMD::thirdparty::spdlog INTERFACE IMPORTED)
     if(openPMD_USE_INTERNAL_SPDLOG)
-        target_include_directories(openPMD::thirdparty::spdlog SYSTEM INTERFACE
+        target_include_directories(openPMD PUBLIC
                 $<BUILD_INTERFACE:${openPMD_SOURCE_DIR}/share/openPMD/thirdParty/spdlog/include>
                 )
         message(STATUS "spdlog: Using INTERNAL version 1.3.1")

include/openPMD/auxiliary/Logging.hpp

@@ -0,0 +1,94 @@
+/* Copyright 2019 Fabian Koller
+ *
+ * This file is part of openPMD-api.
+ *
+ * openPMD-api is free software: you can redistribute it and/or modify
+ * it under the terms of of either the GNU General Public License or
+ * the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * openPMD-api is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License and the GNU Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * and the GNU Lesser General Public License along with openPMD-api.
+ * If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#if openPMD_HAVE_LOGGING
+#   include <spdlog/spdlog.h>
+#endif
+
+namespace openPMD
+{
+namespace auxiliary
+{
+namespace log
+{
+
+enum class Level
+{
+    TRACE,
+    DEBUG,
+    INFO,
+    WARN,
+    ERROR,
+    CRITICAL,
+    OFF
+}; // Level
+
+#if openPMD_HAVE_LOGGING
+static void
+set_level(Level level)
+{
+    switch( level ) {
+        case Level::TRACE:
+            spdlog::set_level(spdlog::level::trace);
+            return;
+        case Level::DEBUG:
+            spdlog::set_level(spdlog::level::debug);
+            return;
+        case Level::INFO:
+            spdlog::set_level(spdlog::level::info);
+            return;
+        case Level::WARN:
+            spdlog::set_level(spdlog::level::warn);
+            return;
+        case Level::ERROR:
+            spdlog::set_level(spdlog::level::err);
+            return;
+        case Level::CRITICAL:
+            spdlog::set_level(spdlog::level::critical);
+            return;
+        case Level::OFF:
+            spdlog::set_level(spdlog::level::off);
+            return;
+        default:
+            throw std::runtime_error("Logging level not supported!");
+    }
+}
+#   define LOG_SET_LEVEL(LEVEL) { set_level((LEVEL)); }
+#   define LOG_TRACE(...) { spdlog::trace(__VA_ARGS__); }
+#   define LOG_DEBUG(...) { spdlog::debug(__VA_ARGS__); }
+#   define LOG_INFO(...) { spdlog::info(__VA_ARGS__); }
+#   define LOG_WARN(...) { spdlog::warn(__VA_ARGS__); }
+#   define LOG_ERROR(...) { spdlog::error(__VA_ARGS__); }
+#   define LOG_CRITICAL(...) { spdlog::critical(__VA_ARGS__); }
+#else
+#   define NOOP do{ (void)sizeof(void); } while( 0 )
+#   define LOG_SET_LEVEL(LEVEL) NOOP
+#   define LOG_TRACE(...) NOOP
+#   define LOG_DEBUG(...) NOOP
+#   define LOG_INFO(...) NOOP
+#   define LOG_WARN(...) NOOP
+#   define LOG_ERROR(...) NOOP
+#   define LOG_CRITICAL(...) NOOP
+#endif
+} // log
+} // auxiliary
+} // openPMD

include/openPMD/auxiliary/StringManip.hpp

@@ -165,21 +165,43 @@ strip(std::string s, std::vector< char > to_remove)
     return s;
 }
 
+template< typename T >
 inline std::string
-join(std::vector< std::string > const& vs, std::string const& delimiter)
+join(std::vector< T > const& vt, std::string const& delimiter)
 {
-    switch( vs.size() )
+    switch( vt.size() )
     {
         case 0:
             return "";
         case 1:
-            return vs[0];
+            return std::to_string(vt[0]);
         default:
             std::ostringstream ss;
-            std::copy(vs.begin(),
-                      vs.end() - 1,
+            std::transform(vt.begin(),
+                           vt.end() - 1,
+                           std::ostream_iterator< std::string >(ss, delimiter.c_str()),
+                           [](T const& t) -> std::string { return std::to_string(t); });
+            ss << std::to_string(*(vt.end() - 1));
+            return ss.str();
+    }
+}
+
+template< >
+inline std::string
+join< std::string >(std::vector< std::string > const& vt, std::string const& delimiter)
+{
+    switch( vt.size() )
+    {
+        case 0:
+            return "";
+        case 1:
+            return vt[0];
+        default:
+            std::ostringstream ss;
+            std::copy(vt.begin(),
+                      vt.end() - 1,
                       std::ostream_iterator< std::string >(ss, delimiter.c_str()));
-            ss << *(vs.end() - 1);
+            ss << *(vt.end() - 1);
             return ss.str();
     }
 }

include/openPMD/openPMD.hpp

@@ -44,6 +44,7 @@
 
 #include "openPMD/IO/AccessType.hpp"
 
+#include "openPMD/auxiliary/Logging.hpp"
 #include "openPMD/auxiliary/OutOfRangeMsg.hpp"
 #include "openPMD/auxiliary/ShareRaw.hpp"
 #include "openPMD/auxiliary/Variant.hpp"

src/IO/AbstractIOHandlerHelper.cpp

@@ -17,7 +17,8 @@
  * You should have received a copy of the GNU General Public License
  * and the GNU Lesser General Public License along with openPMD-api.
  * If not, see <http://www.gnu.org/licenses/>.
- */ 
+ */
+#include "openPMD/auxiliary/Logging.hpp"
 #include "openPMD/IO/AbstractIOHandlerHelper.hpp"
 #include "openPMD/IO/DummyIOHandler.hpp"
 #include "openPMD/IO/ADIOS/ADIOS1IOHandler.hpp"
@@ -41,17 +42,20 @@ namespace openPMD
         switch( format )
         {
             case Format::HDF5:
+                LOG_DEBUG("Creating parallel HDF5 IOHandler");
                 return std::make_shared< ParallelHDF5IOHandler >(path, accessTypeBackend, comm);
             case Format::ADIOS1:
+                LOG_DEBUG("Creating parallel ADIOS1 IOHandler");
 #   if openPMD_HAVE_ADIOS1
                 return std::make_shared< ParallelADIOS1IOHandler >(path, accessTypeBackend, comm);
 #   else
                 throw std::runtime_error("openPMD-api built without ADIOS1 support");
-                return std::make_shared< DummyIOHandler >(path, accessTypeBackend);
 #   endif
             case Format::ADIOS2:
+                LOG_DEBUG("Creating parallel ADIOS2 IOHandler");
                 throw std::runtime_error("ADIOS2 backend not yet implemented");
             default:
+                LOG_DEBUG("Creating parallel dummy IOHandler");
                 return std::make_shared< DummyIOHandler >(path, accessTypeBackend);
         }
     }
@@ -66,19 +70,23 @@ namespace openPMD
         switch( format )
         {
             case Format::HDF5:
+                LOG_DEBUG("Creating serial HDF5 IOHandler");
                 return std::make_shared< HDF5IOHandler >(path, accessType);
             case Format::ADIOS1:
+                LOG_DEBUG("Creating serial ADIOS1 IOHandler");
 #   if openPMD_HAVE_ADIOS1
                 return std::make_shared< ADIOS1IOHandler >(path, accessType);
 #   else
                 throw std::runtime_error("openPMD-api built without ADIOS1 support");
-                return std::make_shared< DummyIOHandler >(path, accessType);
 #   endif
             case Format::ADIOS2:
+                LOG_DEBUG("Creating serial ADIOS1 IOHandler");
                 throw std::runtime_error("ADIOS2 backend not yet implemented");
             case Format::JSON:
+                LOG_DEBUG("Creating serial ADIOS1 IOHandler");
                 return std::make_shared< JSONIOHandler >(path, accessType);
             default:
+                LOG_DEBUG("Creating serial dummy IOHandler");
                 return std::make_shared< DummyIOHandler >(path, accessType);
         }
     }