XrdStatistics.h

Go to the documentation of this file.

#ifndef __XRD_STATISTICS_SERVICE_H_
#define __XRD_STATISTICS_SERVICE_H_
 
#include "Utilities/StorageFactory/interface/IOTypes.h"
#include "FWCore/Utilities/interface/propagate_const.h"
 
#include <atomic>
#include <chrono>
#include <map>
#include <memory>
#include <mutex>
#include <vector>
 
namespace edm {
  class ParameterSet;
  class ActivityRegistry;
  class ConfigurationDescriptions;
 
  namespace service {
    class CondorStatusService;
  }
}  // namespace edm
 
namespace XrdAdaptor {
 
  class ClientRequest;
  class XrdReadStatistics;
  class XrdSiteStatistics;
 
  /* NOTE: All member information is kept in the XrdSiteStatisticsInformation singleton,
 * _not_ within the service itself.  This is because we need to be able to use the
 * singleton on non-CMSSW-created threads.  Services are only available to threads
 * created by CMSSW.
 */
  class XrdStatisticsService {
  public:
    XrdStatisticsService(const edm::ParameterSet &iPS, edm::ActivityRegistry &iRegistry);
 
    void postEndJob();
 
    void fillDescriptions(edm::ConfigurationDescriptions &descriptions);
 
    struct CondorIOStats {
      uint64_t bytesRead{0};
      std::chrono::nanoseconds transferTime{0};
    };
 
    // Provide an update of per-site transfer statistics to the CondorStatusService.
    // Returns a mapping of "site name" to transfer statistics.  The "site name" is
    // as self-identified by the Xrootd host; may not necessarily match up with the
    // "CMS site name".
    std::vector<std::pair<std::string, CondorIOStats>> condorUpdate();
  };
 
  class XrdSiteStatisticsInformation {
    friend class XrdStatisticsService;
 
  public:
    static XrdSiteStatisticsInformation *getInstance();
 
    std::shared_ptr<XrdSiteStatistics> getStatisticsForSite(std::string const &site);
 
  private:
    static void createInstance();
 
    static std::atomic<XrdSiteStatisticsInformation *> m_instance;
    std::mutex m_mutex;
    std::vector<edm::propagate_const<std::shared_ptr<XrdSiteStatistics>>> m_sites;
  };
 
  class XrdSiteStatistics {
    friend class XrdReadStatistics;
 
  public:
    XrdSiteStatistics(std::string const &site);
    XrdSiteStatistics(const XrdSiteStatistics &) = delete;
    XrdSiteStatistics &operator=(const XrdSiteStatistics &) = delete;
 
    std::string const &site() const { return m_site; }
 
    // Note that, while this function is thread-safe, the numbers are only consistent if no other
    // thread is reading data.
    void recomputeProperties(std::map<std::string, std::string> &props);
 
    static std::shared_ptr<XrdReadStatistics> startRead(std::shared_ptr<XrdSiteStatistics> parent,
                                                        std::shared_ptr<ClientRequest> req);
 
    void finishRead(XrdReadStatistics const &);
 
    uint64_t getTotalBytes() const { return m_readvSize + m_readSize; }
    std::chrono::nanoseconds getTotalReadTime() {
      return std::chrono::nanoseconds(m_readvNS) + std::chrono::nanoseconds(m_readNS);
    }
 
  private:
    const std::string m_site = "Unknown";
 
    std::atomic<unsigned> m_readvCount;
    std::atomic<unsigned> m_chunkCount;
    std::atomic<uint64_t> m_readvSize;
    std::atomic<uint64_t> m_readvNS;
    std::atomic<unsigned> m_readCount;
    std::atomic<uint64_t> m_readSize;
    std::atomic<uint64_t> m_readNS;
  };
 
  class XrdReadStatistics {
    friend class XrdSiteStatistics;
 
  public:
    ~XrdReadStatistics() { m_parent->finishRead(*this); }
    XrdReadStatistics(const XrdReadStatistics &) = delete;
    XrdReadStatistics &operator=(const XrdReadStatistics &) = delete;
 
  private:
    XrdReadStatistics(std::shared_ptr<XrdSiteStatistics> parent, IOSize size, size_t count);
 
    uint64_t elapsedNS() const;
    int readCount() const { return m_count; }
    int size() const { return m_size; }
 
    size_t m_size;
    IOSize m_count;
    edm::propagate_const<std::shared_ptr<XrdSiteStatistics>> m_parent;
    std::chrono::time_point<std::chrono::high_resolution_clock> m_start;
  };
 
}  // namespace XrdAdaptor
 
#endif