Rename some options for better encapsulation, add minor conveniences

Author: Matthew-Whitlock

include/fenix.h

@@ -145,23 +145,23 @@ typedef enum {
  */
 typedef enum {
     //!Return to Fenix_Init via longjmp (default)
-    JUMP,
+    FENIX_RESUME_JUMP,
     //!Return the error code inline
-    RETURN,
+    FENIX_RESUME_RETURN,
     //!Throw a Fenix::CommException
-    THROW
+    FENIX_RESUME_THROW
 } Fenix_Resume_mode;
 
 /**
  * @brief Options for dealing with 'unhandled' errors, e.g. invalid rank IDs
  */
 typedef enum {
     //!Ignore unhandled errors
-    SILENT,
+    FENIX_UNHANDLED_SILENT,
     //!Print error and continue without handling
-    PRINT,
+    FENIX_UNHANDLED_PRINT,
     //!Print error and abort Fenix's world (default)
-    ABORT
+    FENIX_UNHANDLED_ABORT
 } Fenix_Unhandled_mode;
 
 /**
@@ -363,6 +363,8 @@ int Fenix_Finalize();
 #define FENIX_DATA_POLICY_IN_MEMORY_RAID     13
 #define FENIX_DATA_POLICY_IMR                FENIX_DATA_POLICY_IN_MEMORY_RAID
 
+#define FENIX_TIME_STAMP_IGNORE NULL
+
 /**
  * @unimplemented As MPI_Request, but for Fenix asynchronous data recovery calls
  */
@@ -393,6 +395,7 @@ extern const Fenix_Data_subset  FENIX_DATA_SUBSET_FULL;
 //!@brief A standin for checkpointing/recovering none of the available data in a member.
 extern const Fenix_Data_subset  FENIX_DATA_SUBSET_EMPTY;
 
+extern Fenix_Data_subset* FENIX_DATA_SUBSET_IGNORE;
 
 /**
  * @brief Create a Data Group

include/fenix.hpp

@@ -75,18 +75,33 @@ int Fenix_Callback_register(std::function<void(MPI_Comm, int)> callback);
 
 namespace Fenix {
 
+using Role = Fenix_Rank_role;
+constexpr Role INITIAL_RANK   = FENIX_ROLE_INITIAL_RANK;
+constexpr Role RECOVERED_RANK = FENIX_ROLE_RECOVERED_RANK;
+constexpr Role SURVIVOR_RANK  = FENIX_ROLE_SURVIVOR_RANK;
+
+using ResumeMode = Fenix_Resume_mode;
+constexpr ResumeMode JUMP   = FENIX_RESUME_JUMP;
+constexpr ResumeMode RETURN = FENIX_RESUME_RETURN;
+constexpr ResumeMode THROW  = FENIX_RESUME_THROW;
+
+using UnhandledMode = Fenix_Unhandled_mode;
+constexpr UnhandledMode SILENT = FENIX_UNHANDLED_SILENT;
+constexpr UnhandledMode PRINT  = FENIX_UNHANDLED_PRINT;
+constexpr UnhandledMode ABORT  = FENIX_UNHANDLED_ABORT;
+
 namespace Args {
 struct FenixInitArgs {
-    int* role                           = nullptr;
-    MPI_Comm in_comm                    = MPI_COMM_WORLD;
-    MPI_Comm* out_comm                  = nullptr;
-    int* argc                           = nullptr;
-    char*** argv                        = nullptr;
-    int spares                          = 0;
-    int spawn                           = 0;
-    Fenix_Resume_mode resume_mode       = THROW;
-    Fenix_Unhandled_mode unhandled_mode = ABORT;
-    int* err                            = nullptr;
+    int* role                    = nullptr;
+    MPI_Comm in_comm             = MPI_COMM_WORLD;
+    MPI_Comm* out_comm           = nullptr;
+    int* argc                    = nullptr;
+    char*** argv                 = nullptr;
+    int spares                   = 0;
+    int spawn                    = 0;
+    ResumeMode resume_mode       = THROW;
+    UnhandledMode unhandled_mode = ABORT;
+    int* err                     = nullptr;
 };
 }
 
@@ -99,8 +114,9 @@ void throw_exception();
 
 namespace Fenix::Data {
 
-extern const DataSubset FENIX_SUBSET_FULL;
-extern const DataSubset FENIX_SUBSET_EMPTY;
+extern const DataSubset SUBSET_FULL;
+extern const DataSubset SUBSET_EMPTY;
+extern DataSubset SUBSET_IGNORE;
 
 //!@brief Overload of #Fenix_Data_member_store
 int member_store(int group_id, int member_id, const DataSubset& subset);
@@ -122,13 +138,13 @@ int member_istorev(
 
 //!@brief Overload of #Fenix_Data_member_restore
 int member_restore(
-    int group_id, int member_id, void *target_buffer, int max_count,
+    int group_id, int member_id, void *target_buffer, int max_length,
     int time_stamp, DataSubset& data_found
 );
 
 //!@brief Overload of #Fenix_Data_member_lrestore
 int member_lrestore(
-    int group_id, int member_id, void *target_buffer, int max_count,
+    int group_id, int member_id, void *target_buffer, int max_length,
     int time_stamp, DataSubset& data_found
 );
 

include/fenix_ext.hpp

@@ -60,18 +60,21 @@
 #include <mpi.h>
 #include <vector>
 #include "fenix.h"
+#include "fenix.hpp"
 #include "fenix_opt.hpp"
 #include "fenix_process_recovery.hpp"
 #include "fenix_data_group.hpp"
 
+namespace Fenix {
+
 typedef struct {
     int num_inital_ranks;        // Keeps the global MPI rank ID at Fenix_init
     int num_survivor_ranks = 0;  // Keeps the global information on the number of survived MPI ranks after failure
     int num_recovered_ranks = 0; // Keeps the number of spare ranks brought into MPI communicator recovery
     int spare_ranks;             // Spare ranks entered by user to repair failed ranks
 
-    int resume_mode = Fenix_Resume_mode::JUMP;
-    int unhandled_mode = Fenix_Unhandled_mode::ABORT;
+    ResumeMode resume_mode = JUMP;
+    UnhandledMode unhandled_mode = ABORT;
     int ignore_errs = false;       // Temporarily ignore all errors & recovery
     int spawn_policy;             // Indicate dynamic process spawning
     jmp_buf *recover_environment; // Calling environment to fill the jmp_buf structure
@@ -107,5 +110,7 @@ typedef struct {
     Fenix::Data::fenix_data_recovery_t *data_recovery;   // Global pointer for Fenix Data Recovery Data Structure
 } fenix_t;
 
-extern fenix_t fenix;
+}
+
+extern Fenix::fenix_t fenix;
 #endif // __FENIX_EXT_H__

src/fenix.cpp

@@ -65,12 +65,14 @@ using namespace Fenix;
 using namespace Fenix::Data;
 
 namespace Fenix::Data {
-const DataSubset FENIX_SUBSET_FULL = {{0, Fenix::DataSubset::MAX}};
-const DataSubset FENIX_SUBSET_EMPTY = {};
+const DataSubset SUBSET_FULL = {{0, Fenix::DataSubset::MAX}};
+const DataSubset SUBSET_EMPTY = {};
+DataSubset SUBSET_IGNORE = SUBSET_EMPTY;
 }
 
 const Fenix_Data_subset  FENIX_DATA_SUBSET_FULL = { new DataSubset(DataSubset::MAX) };
 const Fenix_Data_subset  FENIX_DATA_SUBSET_EMPTY = { new DataSubset() };
+Fenix_Data_subset* FENIX_DATA_SUBSET_IGNORE = NULL;
 
 int Fenix_Callback_register(std::function<void(MPI_Comm, int)> callback){
     return __fenix_callback_register(callback);

src/globals.cpp renamed to src/fenix_ext.cpp

@@ -12,7 +12,7 @@
 //
 //
 //
-// Copyright (C) 2018 Rutgers University and Sandia Corporation
+// Copyright (C) 2016 Rutgers University and Sandia Corporation
 //
 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
 // the U.S. Government retains certain rights in this software.
@@ -44,8 +44,8 @@
 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 //
-// Author Marc Gamell, Eric Valenzuela, Keita Teranishi, Manish Parashar
-//        Michael Heroux, and Matthew Whitlock
+// Author Marc Gamell, Eric Valenzuela, Keita Teranishi, Manish Parashar,
+//        Rob Van der Wijngaart, Michael Heroux, and Matthew Whitlock
 //
 // Questions? Contact Keita Teranishi (knteran@sandia.gov) and
 //                    Marc Gamell (mgamell@cac.rutgers.edu)
@@ -56,6 +56,4 @@
 
 #include "fenix_ext.hpp"
 
-fenix_t fenix = {
-    .fenix_init_flag = 0
-};
+Fenix::fenix_t fenix;

src/fenix_process_recovery.cpp

@@ -193,22 +193,22 @@ int fenix_preinit(const Args::FenixInitArgs& args, jmp_buf* jump_env){
 
 Fenix_Resume_mode get_resume_mode(const std::string_view& name){
     if (name == "JUMP") {
-        return Fenix_Resume_mode::JUMP;
+        return Fenix::JUMP;
     } else if (name == "RETURN") {
-        return Fenix_Resume_mode::RETURN;
+        return Fenix::RETURN;
     } else if (name == "THROW") {
-        return Fenix_Resume_mode::THROW;
+        return Fenix::THROW;
     }
     fatal_print("Unsupported FENIX_RESUME_MODE %s", name.data());
 }
 
 Fenix_Unhandled_mode get_unhandled_mode(const std::string_view& name){
     if (name == "SILENT") {
-        return Fenix_Unhandled_mode::SILENT;
+        return Fenix::SILENT;
     } else if (name == "PRINT") {
-        return Fenix_Unhandled_mode::PRINT;
+        return Fenix::PRINT;
     } else if (name == "ABORT") {
-        return Fenix_Unhandled_mode::ABORT;
+        return Fenix::ABORT;
     }
     fatal_print("Unsupported FENIX_UNHANDLED_MODE %s", name.data());
 }