Branch data     Line data    Source code

       1                 :             : #ifndef IPPL_LOGGING_BUFFER_HANDLER_HPP
       2                 :             : #define IPPL_LOGGING_BUFFER_HANDLER_HPP
       3                 :             : 
       4                 :             : #include <iostream>
       5                 :             : #include <mpi.h>
       6                 :             : 
       7                 :             : namespace ippl {
       8                 :             : 
       9                 :             :     template <typename MemorySpace>
      10                 :           4 :     LoggingBufferHandler<MemorySpace>::LoggingBufferHandler(
      11                 :             :         std::shared_ptr<BufferHandler<MemorySpace>> handler, int rank)
      12                 :           4 :         : handler_m(std::move(handler))
      13                 :           8 :         , rank_m(rank) {}
      14                 :             : 
      15                 :             :     template <typename MemorySpace>
      16                 :        2778 :     LoggingBufferHandler<MemorySpace>::LoggingBufferHandler() {
      17         [ +  - ]:        2778 :         handler_m = std::make_shared<DefaultBufferHandler<MemorySpace>>();
      18         [ +  - ]:        2778 :         MPI_Comm_rank(MPI_COMM_WORLD, &rank_m);
      19                 :        2778 :     }
      20                 :             : 
      21                 :             :     template <typename MemorySpace>
      22                 :             :     typename LoggingBufferHandler<MemorySpace>::buffer_type
      23                 :           6 :     LoggingBufferHandler<MemorySpace>::getBuffer(size_type size, double overallocation) {
      24                 :           6 :         auto buffer = handler_m->getBuffer(size, overallocation);
      25   [ +  -  +  -  :          36 :         logMethod("getBuffer", {{"size", std::to_string(size)},
          +  -  +  +  -  
                      - ]
      26                 :           6 :                                 {"overallocation", std::to_string(overallocation)}});
      27                 :           6 :         return buffer;
      28   [ +  -  +  -  :           6 :     }
          +  -  +  -  -  
                -  -  - ]
      29                 :             : 
      30                 :             :     template <typename MemorySpace>
      31                 :           1 :     void LoggingBufferHandler<MemorySpace>::freeBuffer(buffer_type buffer) {
      32         [ +  - ]:           1 :         handler_m->freeBuffer(buffer);
      33   [ +  -  +  - ]:           3 :         logMethod("freeBuffer", {});
      34                 :           1 :     }
      35                 :             : 
      36                 :             :     template <typename MemorySpace>
      37                 :           1 :     void LoggingBufferHandler<MemorySpace>::freeAllBuffers() {
      38                 :           1 :         handler_m->freeAllBuffers();
      39   [ +  -  +  - ]:           3 :         logMethod("freeAllBuffers", {});
      40                 :           1 :     }
      41                 :             : 
      42                 :             :     template <typename MemorySpace>
      43                 :         658 :     void LoggingBufferHandler<MemorySpace>::deleteAllBuffers() {
      44                 :         658 :         handler_m->deleteAllBuffers();
      45   [ +  -  +  - ]:        1974 :         logMethod("deleteAllBuffers", {});
      46                 :         658 :     }
      47                 :             : 
      48                 :             :     template <typename MemorySpace>
      49                 :             :     typename LoggingBufferHandler<MemorySpace>::size_type
      50                 :           0 :     LoggingBufferHandler<MemorySpace>::getUsedSize() const {
      51                 :           0 :         return handler_m->getUsedSize();
      52                 :             :     }
      53                 :             : 
      54                 :             :     template <typename MemorySpace>
      55                 :             :     typename LoggingBufferHandler<MemorySpace>::size_type
      56                 :           0 :     LoggingBufferHandler<MemorySpace>::getFreeSize() const {
      57                 :           0 :         return handler_m->getFreeSize();
      58                 :             :     }
      59                 :             : 
      60                 :             :     template <typename MemorySpace>
      61                 :           4 :     const std::vector<LogEntry>& LoggingBufferHandler<MemorySpace>::getLogs() const {
      62                 :           4 :         return logEntries_m;
      63                 :             :     }
      64                 :             : 
      65                 :             :     template <typename MemorySpace>
      66                 :         666 :     void LoggingBufferHandler<MemorySpace>::logMethod(
      67                 :             :         const std::string& methodName, const std::map<std::string, std::string>& parameters) {
      68         [ +  - ]:        1332 :         logEntries_m.push_back({methodName, parameters, handler_m->getUsedSize(),
      69         [ +  - ]:         666 :                                 handler_m->getFreeSize(), MemorySpace::name(), rank_m,
      70                 :         666 :                                 std::chrono::high_resolution_clock::now()});
      71   [ +  -  +  -  :        3330 :     }
          +  -  +  -  -  
             -  -  -  -  
                      - ]
      72                 :             : 
      73                 :             : }  // namespace ippl
      74                 :             : 
      75                 :             : #endif