Style and small bugfixes

Author: Matthew-Whitlock

src/resilience/AutomaticCheckpoint.hpp

@@ -179,7 +179,6 @@ namespace KokkosResilience
   template< typename Context, typename F, typename FilterFunc, typename... T, std::enable_if_t<is_filter_v<FilterFunc>>* = nullptr>
   void checkpoint( Context &ctx, const std::string &label, int iteration, F &&fun, FilterFunc &&filter, Detail::RegInfo<T>... explicit_members)
   {
-    static_assert(is_filter_v<FilterFunc>);
     Detail::checkpoint_impl( ctx, label, iteration, std::forward< F >( fun ), std::forward< FilterFunc >( filter ), explicit_members...);
   }
 

src/resilience/backend/VelocBackend.cpp

@@ -62,14 +62,17 @@ namespace KokkosResilience
     void veloc_internal_error_throw( int e, const char *name, const char *file, int line = 0 )
     {
       std::ostringstream out;
-      out << name << " error: VELOC operation failed";
+      out << name << " error: VELOC operation failed (" << e << ")";
       if ( file )
       {
         out << " " << file << ":" << line;
       }
 
       // TODO: implement exception class
       //Kokkos::Impl::throw_runtime_exception( out.str() );
+      // In the meantime, we'll print at least
+      out << "\n";
+      std::cerr << out.str();
     }
 
     inline void veloc_internal_safe_call( int e, const char *name, const char *file, int line = 0 )
@@ -82,7 +85,7 @@ namespace KokkosResilience
   VeloCMemoryBackend::VeloCMemoryBackend(ContextBase &ctx, MPI_Comm mpi_comm)
       : m_context(&ctx), m_mpi_comm(mpi_comm) {
     const auto &vconf = m_context->config()["backends"]["veloc"]["config"].as< std::string >();
-    veloc_client = veloc::get_client(m_mpi_comm, vconf.c_str());
+    veloc_client = veloc::get_client(m_mpi_comm, vconf);
   }
 
   VeloCMemoryBackend::~VeloCMemoryBackend()
@@ -205,104 +208,99 @@ namespace KokkosResilience
     // No-op, don't do anything
   }
 
-  VeloCFileBackend::VeloCFileBackend(MPIContext<VeloCFileBackend> &,
-                                     MPI_Comm mpi_comm,
-                                     const std::string &veloc_config) {
-    VELOC_SAFE_CALL( VELOC_Init( mpi_comm, veloc_config.c_str()));
+  VeloCFileBackend::VeloCFileBackend(ContextBase& context, MPI_Comm mpi_comm) 
+    : m_context(context), m_mpi_comm(mpi_comm) {
+    const auto &vconf = m_context->config()["backends"]["veloc"]["config"].as< std::string >();
+    veloc_client = veloc::get_client(m_mpi_comm, vconf);
   }
 
   VeloCFileBackend::~VeloCFileBackend()
   {
-    VELOC_Finalize( false );
+    veloc_client->checkpoint_wait();
   }
 
   void
   VeloCFileBackend::checkpoint( const std::string &label, int version,
                                 std::unordered_set<Registration> &members )
   {
     // Wait for previous checkpoint to finish
-    VELOC_SAFE_CALL( VELOC_Checkpoint_wait());
+    VELOC_SAFE_CALL( veloc_client->checkpoint_wait() );
 
     // Start new checkpoint
-    VELOC_SAFE_CALL( VELOC_Checkpoint_begin( label.c_str(), version ));
-
-    char veloc_file_name[VELOC_MAX_NAME];
-
-    bool status = true;
-    try
-    {
-      VELOC_SAFE_CALL( VELOC_Route_file( veloc_file_name, veloc_file_name ) );
+    VELOC_SAFE_CALL( veloc_client->checkpoint_begin( label, version ) );
 
-      std::string   fname( veloc_file_name );
+    bool success = true;
+    try {
+      std::string   fname = veloc_client->route_file(label);
       std::ofstream vfile( fname, std::ios::binary );
 
 #ifdef KR_ENABLE_TRACING
-      auto write_trace = Util::begin_trace< Util::TimingTrace< std::string > >( *m_context, "write" );
+      auto write_trace = Util::begin_trace< Util::TimingTrace< std::string > >(
+        *m_context, "write"
+      );
 #endif
-      for ( auto &&member : members )
-      {
-        status = member->serialize(vfile);
-        if(!status) break;
+      for ( auto& member : members ) {
+        success = member.serialize(vfile);
+        if(!success) break;
       }
 #ifdef KR_ENABLE_TRACING
       write_trace.end();
 #endif
-    }
-    catch ( ... )
-    {
-      status = false;
+    } catch ( const std::exception& e){
+      success = false;
+      std::cerr << "VelocFileBackend::checkpoint error: " + e.what();
+    } catch ( ... ) {
+      success = false;
+      std::cerr << "VelocFileBackend::checkpoint error: (unknown exception type)"
     }
 
-    VELOC_SAFE_CALL( VELOC_Checkpoint_end( status ));
+    VELOC_SAFE_CALL( veloc_client->checkpoint_end(success) );
   }
 
   bool
   VeloCFileBackend::restart_available( const std::string &label, int version )
   {
-    int latest = VELOC_Restart_test( label.c_str(), 0 );
-
     // res is < 0 if no versions available, else it is the latest version
-    return version <= latest;
+    return version <= latest_version(label);
   }
 
   int VeloCFileBackend::latest_version( const std::string &label ) const noexcept
   {
-    return VELOC_Restart_test( label.c_str(), 0 );
+    return veloc_client->restart_test(label, 0);
   }
 
   void VeloCFileBackend::restart( const std::string &label, int version,
                                   std::unordered_set<Registration> &members )
   {
-    VELOC_SAFE_CALL( VELOC_Restart_begin( label.c_str(), version ));
+    VELOC_SAFE_CALL( veloc_client->restart_begin( label, version ));
 
     char veloc_file_name[VELOC_MAX_NAME];
 
-    bool status = true;
-    try
-    {
-      VELOC_SAFE_CALL( VELOC_Route_file( veloc_file_name, veloc_file_name ) );
-      printf( "restore file name: %s\n", veloc_file_name );
-
-      std::string   fname( veloc_file_name );
+    bool success = true;
+    try {
+      std::string   fname = veloc_client->route_file(label);
       std::ifstream vfile( fname, std::ios::binary );
 
 #ifdef KR_ENABLE_TRACING
-      auto read_trace = Util::begin_trace< Util::TimingTrace< std::string > >( *m_context, "read" );
+      auto read_trace = Util::begin_trace< Util::TimingTrace< std::string > >(
+        *m_context, "read"
+      );
 #endif
-      for ( auto &&member : members )
-      {
-        status = member->deserialize(vfile);
-        if(!status) break;
+      for ( auto& member : members ) {
+        success = member.deserialize(vfile);
+        if(!success) break;
       }
 #ifdef KR_ENABLE_TRACING
       read_trace.end();
 #endif
-    }
-    catch ( ... )
-    {
-      status = false;
+    } catch ( const std::exception& e ){
+      success = false;
+      std::cerr << "VelocFileBackend::restart error: " + e.what();
+    } catch ( ... ) {
+      success = false;
+      std::cerr << "VelocFileBackend::checkpoint error: (unknown exception type)"
     }
 
-    VELOC_SAFE_CALL( VELOC_Restart_end( status ));
+    VELOC_SAFE_CALL( veloc_client->restart_end(success) );
   }
 }

src/resilience/backend/VelocBackend.hpp

@@ -128,7 +128,7 @@ namespace KokkosResilience
   {
   public:
 
-    VeloCFileBackend( MPIContext< VeloCFileBackend > &ctx, MPI_Comm mpi_comm, const std::string &veloc_config);
+    VeloCFileBackend( MPIContext< VeloCFileBackend > &ctx, MPI_Comm mpi_comm);
     ~VeloCFileBackend();
 
     void checkpoint( const std::string &label, int version,
@@ -141,6 +141,11 @@ namespace KokkosResilience
                   std::unordered_set<Registration> &members );
 
     void register_hashes( std::unordered_set<Registration> &members ) {} // Do nothing
+    
+    veloc::client_t *veloc_client;
+    
+    ContextBase *m_context;
+    MPI_Comm m_mpi_comm;
   };
 }
 

src/resilience/registration/Custom.hpp

@@ -39,13 +39,14 @@
  * Questions? Contact Christian R. Trott ([email protected])
  */
 
-#ifndef _INC_RESILIENCE_REGISTRATION_CUSTOM_HPP
-#define _INC_RESILIENCE_REGISTRATION_CUSTOM_HPP
+#ifndef INC_RESILIENCE_REGISTRATION_CUSTOM_HPP
+#define INC_RESILIENCE_REGISTRATION_CUSTOM_HPP
 
 #include "Registration.hpp"
 
 namespace KokkosResilience::Detail {
-  struct CustomRegistration : public RegistrationBase {
+  class CustomRegistration : public RegistrationBase {
+  public:
     CustomRegistration() = delete;
     CustomRegistration(serializer_t&& serializer, deserializer_t&& deserializer, const std::string name) : 
         RegistrationBase(name),
@@ -79,4 +80,4 @@ namespace KokkosResilience::Detail {
   };
 }
 
-#endif
+#endif //INC_RESILIENCE_REGISTRATION_CUSTOM_HPP

src/resilience/registration/Registration.cpp

@@ -1,26 +1,38 @@
 #include "Registration.hpp"
 #include <string>
-#include <locale> //isalnum
+#include <locale>
 
 namespace KokkosResilience {
   namespace Detail { 
     std::string sanitized_label(std::string label){
-      //If character not alphanumeric, can only be an underscore.
+      // If character is not alphanumeric, can only be an underscore.
       for(char& c : label){
         if(!std::isalnum(c)) c = '_';
       }
       return label;
     }
 
     size_t label_hash(const std::string& name) {
-      const size_t base = 7;
+      // Hash by summing each character multiplied by some value based on the
+      //  position of the character
+      // To try to make sure the hash for "ab" is different from "ba", we want
+      //  to make our base position-based value larger than the number of
+      //  possible characters. We allow [a-zA-Z0-9_] = 63 characters
+      // We also want to make sure the character*position value is unique for
+      //  all possible characters and positions (as best we can) - so we make
+      //  the position component the ith power of a prime number
+      // C++ hashes are type size_t, but we want these hashes to be compatible
+      //  as IDs for various checkpointing libraries, which are usually integers
+
+      // 67 is first prime number larger than 63
+      const size_t base = 67;
       size_t hash = 0;
       for(size_t i = 0; i < name.length(); i++){
-        hash += static_cast<size_t>((static_cast<size_t>(name[i]) *
-                                     static_cast<size_t>(pow(base, i))
-                                    ) % INT_MAX);
+        float character_val = name[i];
+        float position_val = powf(base, i);
+        hash += static_cast<size_t>( (character_val * position_val) % INT_MAX );
       }
-      return static_cast<size_t>(hash%INT_MAX);
+      return hash % INT_MAX;
     }
 
     RegistrationBase::RegistrationBase(const std::string member_name) :