Line data    Source code

       1              : #include "Communicate/LogEntry.h"
       2              : 
       3              : namespace ippl {
       4              : 
       5           24 :     void serializeString(std::vector<char>& buffer, const std::string& str) {
       6           24 :         size_t length = str.size();
       7           24 :         serializeBasicType(buffer, length);  // First, serialize the length of the string
       8           24 :         buffer.insert(buffer.end(), str.begin(), str.end());  // Then, serialize the string itself
       9           24 :     }
      10              : 
      11           12 :     std::string deserializeString(const std::vector<char>& buffer, size_t& offset) {
      12              :         size_t length =
      13           12 :             deserializeBasicType<size_t>(buffer, offset);  // Get the length of the string
      14            0 :         std::string str(buffer.begin() + offset,
      15           12 :                         buffer.begin() + offset + length);  // Extract the string
      16           12 :         offset += length;
      17           12 :         return str;
      18              :     }
      19              : 
      20            4 :     std::vector<char> LogEntry::serialize() const {
      21            4 :         std::vector<char> buffer;
      22              : 
      23            4 :         serializeString(buffer, methodName);
      24            4 :         serializeBasicType(buffer, usedSize);
      25            4 :         serializeBasicType(buffer, freeSize);
      26            4 :         serializeString(buffer, memorySpace);
      27            4 :         serializeBasicType(buffer, rank);
      28              : 
      29              :         // Serialize the timestamp (as duration since epoch)
      30            4 :         auto duration = timestamp.time_since_epoch().count();
      31            4 :         serializeBasicType(buffer, duration);
      32              : 
      33            4 :         size_t mapSize = parameters.size();
      34            4 :         serializeBasicType(buffer, mapSize);
      35           12 :         for (const auto& pair : parameters) {
      36            8 :             serializeString(buffer, pair.first);
      37            8 :             serializeString(buffer, pair.second);
      38              :         }
      39              : 
      40            4 :         return buffer;
      41            0 :     }
      42              : 
      43            2 :     LogEntry LogEntry::deserialize(const std::vector<char>& buffer, size_t offset) {
      44            2 :         LogEntry entry;
      45            2 :         size_t current_pos = offset;
      46              : 
      47            2 :         entry.methodName  = deserializeString(buffer, current_pos);
      48            2 :         entry.usedSize    = deserializeBasicType<size_t>(buffer, current_pos);
      49            2 :         entry.freeSize    = deserializeBasicType<size_t>(buffer, current_pos);
      50            2 :         entry.memorySpace = deserializeString(buffer, current_pos);
      51            2 :         entry.rank        = deserializeBasicType<int>(buffer, current_pos);
      52              : 
      53            2 :         auto duration   = deserializeBasicType<long long>(buffer, current_pos);
      54            2 :         entry.timestamp = std::chrono::time_point<std::chrono::high_resolution_clock>(
      55            2 :             std::chrono::high_resolution_clock::duration(duration));
      56              : 
      57            2 :         size_t mapSize = deserializeBasicType<size_t>(buffer, current_pos);
      58            6 :         for (size_t i = 0; i < mapSize; ++i) {
      59            4 :             std::string key       = deserializeString(buffer, current_pos);
      60            4 :             std::string value     = deserializeString(buffer, current_pos);
      61            4 :             entry.parameters[key] = value;
      62            4 :         }
      63              : 
      64            2 :         return entry;
      65            0 :     }
      66              : 
      67              : }  // namespace ippl