Event indexing is now performed using a small struct eventID rather than a string for performance. Added unit test for eventID.

Chimbuko now uses boost. configure script now checks for boost installation
Configure now properly fails if ADIOS2 is not specified

Author: giltirn

configure.ac

@@ -93,6 +93,8 @@ if test "x$with_adios2" != "x"; then
    else
 	   AC_MSG_NOTICE([Detected ADIOS 2.6+])
    fi
+else
+	AC_MSG_FAILURE(["ADIOS2 install path must be specified with --with-adios2"])	
 fi
 
 #Choose network
@@ -141,6 +143,14 @@ fi
 AC_ARG_WITH([perf-metric], AS_HELP_STRING([--with-perf-metric], [Specify use of performance metrics]),[PS_FLAGS+=" -D_PERF_METRIC"],[])
 
 
+#Check for boost
+AC_ARG_WITH([boost], AS_HELP_STRING([--with-boost], [Specify Boost install directory]),[],[])
+if test "x$with_boost" != "x"; then
+   CPPFLAGS+=" -I$with_boost/include"
+   LIBS+=" -L$with_boost/lib"
+fi
+AC_CHECK_HEADERS([boost/math/distributions/normal.hpp], [],    [AC_MSG_ERROR(Boost library is required)])
+
 
 AC_CONFIG_HEADERS([chimbuko_config.h])
 AC_SUBST([PS_FLAGS])

include/chimbuko/ad/ADEvent.hpp

@@ -74,7 +74,7 @@ namespace chimbuko {
    * @brief A type that stores some information about an event whose data may have been deleted
    */
   struct EventInfo{
-    std::string id;
+    eventID id;
     EventDataType type;
     unsigned long ts;
 
@@ -110,7 +110,7 @@ namespace chimbuko {
       case EventDataType::COUNT:
 	os << "COUNT, "; break;
       }
-      os << id << ", " << ts << "}";
+      os << id.toString() << ", " << ts << "}";
       return os.str();
     }
 
@@ -212,13 +212,13 @@ namespace chimbuko {
      *
      * throws a runtime error if the call is not present in the call-list
      */
-    CallListIterator_t getCallData(const std::string &event_id) const;     
+    CallListIterator_t getCallData(const eventID &event_id) const;     
 
     /**
      * @brief Get a pair of iterators marking the start and one-past-the-end of a window of size (up to) win_size events
      *        on either size around the given event occurring on the same thread
      */
-    std::pair<CallListIterator_t, CallListIterator_t> getCallWindowStartEnd(const std::string &event_id, const int win_size) const;
+    std::pair<CallListIterator_t, CallListIterator_t> getCallWindowStartEnd(const eventID &event_id, const int win_size) const;
 
     /**
      * @brief clear 
@@ -354,7 +354,7 @@ namespace chimbuko {
      *
      * Completed calls are removed from this list every IO step by calls to trimCallList
      */
-    std::unordered_map<std::string, CallListIterator_t> m_callIDMap;
+    std::unordered_map<eventID, CallListIterator_t> m_callIDMap;
 
 
     /**
@@ -368,7 +368,7 @@ namespace chimbuko {
     /**
      * @brief Map of event index to the number of unmatched correlation IDs
      */
-    std::unordered_map<std::string,size_t> m_unmatchedCorrelationID_count; 
+    std::unordered_map<eventID,size_t> m_unmatchedCorrelationID_count; 
 
     /**
      * @brief verbose

include/chimbuko/ad/ADParser.hpp

@@ -299,7 +299,7 @@ namespace chimbuko {
      * @brief Create an Event_t instance from the data at the provided pointer and run simple validation
      * @param log_error If true a recoverable error will be logged for invalid events
      */
-    std::pair<Event_t,bool> createAndValidateEvent(const unsigned long * data, EventDataType t, size_t idx, std::string id, bool log_error = true) const;
+    std::pair<Event_t,bool> createAndValidateEvent(const unsigned long * data, EventDataType t, size_t idx, const eventID &id, bool log_error = true) const;
 
 
 

include/chimbuko/ad/ExecData.hpp

@@ -1,5 +1,6 @@
 #pragma once
-#include "chimbuko/ad/ADDefine.hpp"
+#include <chimbuko/ad/ADDefine.hpp>
+#include <chimbuko/ad/utils.hpp>
 #include <iostream>
 #include <string>
 #include <vector>
@@ -26,9 +27,9 @@ class Event_t {
      * @param data pointer to raw performance event vector
      * @param t event type
      * @param idx event index
-     * @param id event (string) id
+     * @param id event id
      */
-    Event_t(const unsigned long * data, EventDataType t, size_t idx, std::string id="event_id") 
+   Event_t(const unsigned long * data, EventDataType t, size_t idx, const eventID &id = eventID()) 
         : m_data(data), m_t(t), m_id(id), m_idx(idx) {}
     /**
      * @brief Destroy the Event_t object
@@ -45,7 +46,7 @@ class Event_t {
     /**
      * @brief return event id
      */
-    std::string id() const { return m_id; }
+    const eventID &id() const { return m_id; }
     /**
      * @brief return event index, typically the index of the event in the input array for the timestep on which it was spawned
      */
@@ -141,7 +142,7 @@ class Event_t {
 private:
     const unsigned long * m_data;   /**< pointer to raw performance trace data vector */
     EventDataType m_t;              /**< event type */
-    std::string m_id;               /**< event id */
+    eventID m_id;               /**< event id */
     size_t m_idx;                   /**< event index */
 };
 
@@ -172,7 +173,7 @@ class CommData_t {
      * @param ev constant reference to a Event_t object
      * @param commType communication type (e.g. SEND/RECV)
      */
-    CommData_t(const Event_t& ev, std::string commType);
+    CommData_t(const Event_t& ev, const std::string &commType);
     /**
      * @brief Destroy the CommData_t object
      * 
@@ -206,12 +207,12 @@ class CommData_t {
      * 
      * @param key execution id
      */
-    void set_exec_key(std::string key) { m_execkey = key; }
+    void set_exec_key(const eventID &key) { m_execkey = key; }
 
     /**
      * @brief Get the execution key id. This is equal to the "id" string associated with a parent ExecData_t object
      */
-    const std::string & get_exec_key() const { return m_execkey; }
+    const eventID & get_exec_key() const { return m_execkey; }
 
     /**
      * @brief compare two communication data
@@ -239,7 +240,7 @@ class CommData_t {
         m_bytes,                        /**< communication data size in bytes */
         m_tag;                          /**< communication tag */
     unsigned long m_ts;                 /**< communication timestamp */
-    std::string m_execkey;              /**< execution key (or id) where this communication event occurs */
+    eventID m_execkey;              /**< execution key (or id) where this communication event occurs */
 };
 
 
@@ -306,12 +307,12 @@ class CommData_t {
      * 
      * @param key execution id
      */
-    void set_exec_key(std::string key) { m_execkey = key; }
+    void set_exec_key(const eventID &key) { m_execkey = key; }
 
     /**
      * @brief Get the execution key id. This is equal to the "id" string associated with a parent ExecData_t object
      */
-    const std::string & get_exec_key() const { return m_execkey; }
+    const eventID & get_exec_key() const { return m_execkey; }
 
     private:
     std::string m_countername;             /**< counter name */
@@ -322,7 +323,7 @@ class CommData_t {
       m_cid,                          /**< counted id */
       m_value,                        /**< counter value */
       m_ts;                           /**< counter timestamp */
-    std::string m_execkey;              /**< execution key (or id) where this counter event occurs */
+     eventID m_execkey;              /**< execution key (or id) where this counter event occurs */
   };
 
 
@@ -355,7 +356,7 @@ class ExecData_t {
     /**
      * @brief Get the id of this execution data
      */
-    const std::string &get_id() const { return m_id; }
+    const eventID &get_id() const { return m_id; }
     /**
      * @brief Get the function name of this execution data
      */
@@ -405,7 +406,7 @@ class ExecData_t {
     /**
      * @brief Get the parent function id of this execution data
      */
-    std::string get_parent() const { return m_parent; }
+    const eventID & get_parent() const { return m_parent; }
     /**
      * @brief Get a list of communication data occured in this execution data
      */
@@ -441,7 +442,7 @@ class ExecData_t {
      * 
      * @param parent the parent execution id
      */
-    void set_parent(std::string parent) { m_parent = parent; }
+    void set_parent(const eventID &parent) { m_parent = parent; }
     /**
      * @brief Set the function name of this execution
      * 
@@ -521,7 +522,7 @@ class ExecData_t {
     /**
      * @brief Set the partner event linked by a GPU correlation ID
      */
-    void set_GPU_correlationID_partner(const std::string event_id){ m_gpu_correlation_id_partner.push_back(event_id); }
+    void set_GPU_correlationID_partner(const eventID &event_id){ m_gpu_correlation_id_partner.push_back(event_id); }
 
     /**
      * @brief Return true if this event has been matched to a partner event by a GPU correlation ID
@@ -539,10 +540,10 @@ class ExecData_t {
      *
      * Throws error if index out of range
      */  
-    const std::string & get_GPU_correlationID_partner(const size_t i) const;
+    const eventID & get_GPU_correlationID_partner(const size_t i) const;
 
 private:
-    std::string m_id;                    /**< execution id */                           
+    eventID m_id;                        /**< execution id */                           
     std::string m_funcname;              /**< function name */
     unsigned long 
         m_pid,                           /**< program id */
@@ -555,13 +556,13 @@ class ExecData_t {
         m_runtime,                       /**< inclusive running time (i.e. including time of child calls) */
         m_exclusive;                     /**< exclusive running time (i.e. excluding time of child calls) */
     int m_label;                         /**< 1 for normal, -1 for abnormal execution */
-    std::string m_parent;                /**< parent execution */
+    eventID m_parent;                    /**< parent execution */
     unsigned long m_n_children;          /**< the number of childrent executions */
     unsigned long m_n_messages;          /**< the number of messages */
     std::deque<CommData_t> m_messages;  /**< a vector of all messages */
     std::deque<CounterData_t> m_counters; /**< a vector of all counters */
     bool m_can_delete; /**< Flag indicating that the event is deletable by the garbage collection */
-    std::vector<std::string> m_gpu_correlation_id_partner;  /**< The event ids partner events linked by a correlation ID, either the launching CPU event or the GPU kernel event */
+    std::vector<eventID> m_gpu_correlation_id_partner;  /**< The event ids partner events linked by a correlation ID, either the launching CPU event or the GPU kernel event */
 };
 
 

include/chimbuko/ad/utils.hpp

@@ -1,5 +1,8 @@
 #pragma once
 
+#include<functional>
+#include<boost/functional/hash.hpp>
+
 namespace chimbuko{
   /**
    * @brief Return a random character
@@ -12,7 +15,7 @@ namespace chimbuko{
    * WARNING: this is slow, apparently
    */
   std::string generate_hex(const unsigned int len);
-  
+ 
   /*
    * @brief Generate an event_id string of form ${rank}:${step}:${idx}
    */
@@ -24,6 +27,36 @@ namespace chimbuko{
   std::string generate_event_id(int rank, int step, size_t idx, unsigned long eid);
 
 
+  /**
+   * @brief A class representing a unique descriptor for an event
+   */
+  struct eventID{
+    int rank; /**< Process rank of event */
+    int step; /**< IO step in which event occurred */
+    long idx; /**< Index of event within the IO step */
+
+    eventID(): rank(0),step(0),idx(0){}
+    eventID(const int rank, const int step, const long idx): rank(rank), step(step), idx(idx){}
+
+    /**
+     * @brief Return an event representing the special "root" event
+     */
+    inline static eventID root(){ return eventID(-1,-1,-1); }
+
+    /**
+     * @brief Is this event the special root event?
+     */
+    inline bool isRoot() const{ return rank == -1 && step == -1 && idx == -1; }
+
+    inline bool operator==(const eventID &r) const{ return r.rank == rank && r.step == step && r.idx == idx; }
+    inline bool operator!=(const eventID &r) const{ return r.rank != rank || r.step != step || r.idx != idx; }    
+    
+    /**
+     * @brief Return a string representing the event of the form "${rank}:${step}:${idx}" or "root" for the special root event
+     */
+    inline std::string toString() const{ return isRoot() ? "root" : generate_event_id(rank, step, idx); }
+  };
+
   /*
    * @brief Get the IP of the hierarchical pserver endpoint that this rank should connect to. Ports are offset round-robin by the MPI rank of the process
    * @param base_ip The base IP of the server
@@ -33,3 +66,19 @@ namespace chimbuko{
   std::string getHPserverIP(const std::string &base_ip, const int hpserver_nthr, const int rank);
 };
 
+namespace std{
+  /**
+   * @brief Specialize std::hash for eventID type
+   */
+  template <>
+  struct hash<chimbuko::eventID>
+  {
+    inline std::size_t operator()(const chimbuko::eventID& k) const{
+      std::size_t hash = 0;
+      boost::hash_combine(hash, k.rank);
+      boost::hash_combine(hash, k.step);
+      boost::hash_combine(hash, k.idx);
+      return hash;
+    }
+  };
+};

include/chimbuko/util/hash.hpp

@@ -1,20 +1,18 @@
 #pragma once
 
 #include<array>
+#include<boost/functional/hash.hpp>
 
 namespace chimbuko{
-
   /**
    * @brief Hash function for std::array
    */
   template<typename T, size_t N>
   struct ArrayHasher {
     std::size_t operator()(const std::array<T, N>& a) const{
       std::size_t h = 0;
-      
-      for (auto e : a) {
-	h ^= std::hash<T>{}(e)  + 0x9e3779b9 + (h << 6) + (h >> 2); 
-      }
+      for (auto e : a)
+	boost::hash_combine(h, e);
       return h;
     }   
   };