New basic convenience functions

Author: Matthew-Whitlock

include/fenix.h

@@ -300,6 +300,9 @@ Fenix_Rank_role Fenix_get_role();
 //!@brief Returns the error value from Fenix_Init or the latest recovery
 int Fenix_get_error();
 
+//!@brief Returns the number of spare ranks currently available to Fenix
+int Fenix_get_nspare();
+
 /**
  * @brief Get the list of ranks that failed in the most recent failure.
  * @param[out] fail_list Set to a list of failed ranks.

include/fenix.hpp

@@ -60,6 +60,8 @@
 
 #include <mpi.h>
 #include <functional>
+#include <vector>
+#include <optional>
 #include "fenix.h"
 #include "fenix_exception.hpp"
 #include "fenix_data_subset.hpp"
@@ -116,12 +118,21 @@ Fenix_Rank_role role();
 //!@brief Overload of #Fenix_get_error
 int error();
 
+//!@brief Overload of #Fenix_get_nspare
+int nspare();
+
 //!@brief Overload of #Fenix_Callback_register
 int callback_register(std::function<void(MPI_Comm, int)> callback);
 
 //@!brief Overload of #Fenix_Callback_pop
 int callback_pop();
 
+/**
+ * @brief Get the failed ranks from the most recent recovery
+ * @return vector of failed ranks
+ */
+std::vector<int> fail_list();
+
 //!@brief Overload of #Fenix_Process_detect_failures
 int detect_failures(bool recover = true);
 
@@ -183,6 +194,18 @@ int commit(int group_id, int* time_stamp = nullptr);
 //@!brief overload of #Fenix_Data_commit
 int commit_barrier(int group_id, int* time_stamp = nullptr);
 
+/**
+ * @brief get the members of a group
+ * @return vector of member IDs of each member in group_id if group exists
+ */
+std::optional<std::vector<int>> group_members(int group_id);
+
+/**
+ * @brief get the snapshots of a group
+ * @return vector of timestamps of each snapshot in group_id if group exists
+ */
+std::optional<std::vector<int>> group_snapshots(int group_id);
+
 //@!brief Overload of #Fenix_Data_snapshot_delete
 int snapshot_delete(int group_id, int timestamp);
 

include/fenix_data_group.hpp

@@ -84,6 +84,7 @@ struct fenix_group_t {
     int policy_name;
     std::map<int, fenix_member_entry_t> members;
 
+    std::vector<int> get_member_ids();
     //Search for id, returning {-1, nullptr} if not found.
     Fenix::Data::member_iterator search_member(int id);
     //As search_member, but print an error message if id not found.
@@ -105,6 +106,7 @@ struct fenix_group_t {
     virtual int member_restore_from_rank(int member_id, void* target_bugger, int max, int timestamp, int source_rank) = 0;
     virtual int get_number_of_snapshots(int* num) = 0;
     virtual int get_snapshot_at_position(int position, int* timestamp) = 0;
+    virtual std::vector<int> get_snapshots() = 0;
     virtual int reinit(int* flag) = 0;
     virtual int member_get_attribute(fenix_member_entry_t* mentry, int name, void* value, int* flag, int sourcerank) = 0;
     virtual int member_set_attribute(fenix_member_entry_t* mentry, int name, void* value, int* flag) = 0;

include/fenix_data_policy_in_memory_raid.hpp

@@ -226,6 +226,7 @@ struct Group : public fenix_group_t {
 
   int get_number_of_snapshots(int* number_of_snapshots) override;
   int get_snapshot_at_position(int position, int* timestamp) override;
+  std::vector<int> get_snapshots();
 
   int reinit(int* flag) override;
 };

src/fenix.cpp

@@ -261,6 +261,10 @@ int Fenix_get_error(){
     return error();
 }
 
+int Fenix_get_nspare(){
+    return nspare();
+}
+
 namespace Fenix {
 
 void init(const Args::FenixInitArgs args){
@@ -282,6 +286,10 @@ int error(){
     return fenix.repair_result;
 }
 
+int nspare(){
+    return fenix.spare_ranks;
+}
+
 int callback_register(std::function<void(MPI_Comm, int)> callback){
     return __fenix_callback_register(callback);
 }
@@ -290,6 +298,11 @@ int callback_pop() {
     return __fenix_callback_pop();
 }
 
+std::vector<int> fail_list(){
+    if(fenix.fail_world_size == 0) return {};
+    return {fenix.fail_world, fenix.fail_world+fenix.fail_world_size};
+}
+
 int detect_failures(bool recover){
     return __fenix_detect_failures(recover);
 }

src/fenix_data_group.cpp

@@ -92,6 +92,15 @@ member_iterator fenix_group_t::find_member(int id){
   return it;
 }
 
+std::vector<int> fenix_group_t::get_member_ids(){
+  std::vector<int> ret;
+  ret.reserve(members.size());
+  for(const auto& [k, v] : members){
+    ret.push_back(k);
+  }
+  return ret;
+}
+
 fenix_data_recovery_t * __fenix_data_recovery_init() {
   fenix_data_recovery_t *data_recovery = (fenix_data_recovery_t *)
           s_calloc(1, sizeof(fenix_data_recovery_t));

src/fenix_data_policy_in_memory_raid.cpp

@@ -796,6 +796,10 @@ int Group::get_snapshot_at_position(int idx, int* snapshot){
    return FENIX_SUCCESS;
 }
 
+std::vector<int> Group::get_snapshots(){
+  return {timestamps.begin(), timestamps.end()};
+}
+
 int Group::member_restore(
    int member_id, void* target_buffer, int max_count, int ts,
    DataSubset& data_found

src/fenix_data_recovery.cpp

@@ -556,6 +556,18 @@ int __fenix_get_member_at_position(int group_id, int *member_id, int position) {
   return FENIX_SUCCESS;
 }
 
+std::optional<std::vector<int>> group_members(int group_id){
+  auto [group_index, group] = find_group(group_id);
+  if(!group) return {};
+  return group->get_member_ids();
+}
+
+std::optional<std::vector<int>> group_snapshots(int group_id){
+  auto [group_index, group] = find_group(group_id);
+  if(!group) return {};
+  return group->get_snapshots();
+}
+
 /**
  * @brief
  * @param group_id