XrdFileCacheInfo.hh

Go to the documentation of this file.

#ifndef __XRDFILECACHE_INFO_HH__
#define __XRDFILECACHE_INFO_HH__
//----------------------------------------------------------------------------------
// Copyright (c) 2014 by Board of Trustees of the Leland Stanford, Jr., University
// Author: Alja Mrak-Tadel, Matevz  Tadel, Brian Bockelman
//----------------------------------------------------------------------------------
// XRootD is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// XRootD is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with XRootD.  If not, see <http://www.gnu.org/licenses/>.
//----------------------------------------------------------------------------------
 
#include <stdio.h>
#include <time.h>
#include <assert.h>
#include <vector>
 
#include "XrdSys/XrdSysPthread.hh"
#include "XrdCl/XrdClConstants.hh"
#include "XrdCl/XrdClDefaultEnv.hh"
 
class XrdOssDF;
class XrdCksCalc;
class XrdSysTrace;
 
 
namespace XrdCl
{
class Log;
}
 
namespace XrdFileCache
{
class Stats;
 
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
 
class Info
{
public:
   // !Access statistics
   struct AStat
   {
      time_t    AttachTime;       
      time_t    DetachTime;       
      long long BytesDisk;        
      long long BytesRam;         
      long long BytesMissed;      
 
      AStat() : AttachTime(0), DetachTime(0), BytesDisk(0), BytesRam(0), BytesMissed(0) {}
   };
 
   struct Store {
      int                m_version;                
      long long          m_bufferSize;             
      long long          m_fileSize;               
      unsigned char     *m_buff_synced;            
      char               m_cksum[16];              
      time_t             m_creationTime;           
      size_t             m_accessCnt;              
      std::vector<AStat> m_astats;                 
 
      Store () : m_version(1), m_bufferSize(-1), m_fileSize(0), m_buff_synced(0),m_creationTime(0), m_accessCnt(0) {}
   };
 
 
   //------------------------------------------------------------------------
   //------------------------------------------------------------------------
   Info(XrdSysTrace* trace, bool prefetchBuffer = false);
 
   //------------------------------------------------------------------------
   //------------------------------------------------------------------------
   ~Info();
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void SetBitWritten(int i);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool TestBitWritten(int i) const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool TestBitPrefetch(int i) const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void SetBitPrefetch(int i);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void SetBitSynced(int i);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void SetAllBitsSynced();
 
   void SetBufferSize(long long);
   
   void SetFileSize(long long);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void ResizeBits(int n);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool Read(XrdOssDF* fp, const std::string &fname = "<unknown>");
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool Write(XrdOssDF* fp, const std::string &fname = "<unknown>");
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void DisableDownloadStatus();
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void ResetAllAccessStats();
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void WriteIOStatAttach();
 
   //---------------------------------------------------------------------
   void WriteIOStat(Stats& s);
 
  //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void WriteIOStatDetach(Stats& s);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void WriteIOStatSingle(long long bytes_disk);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void WriteIOStatSingle(long long bytes_disk, time_t att, time_t dtc);
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool IsAnythingEmptyInRng(int firstIdx, int lastIdx) const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int GetSizeInBytes() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int GetSizeInBits() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   long long GetFileSize() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool GetLatestDetachTime(time_t& t) const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   long long GetBufferSize() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   bool IsComplete() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int GetNDownloadedBlocks() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   long long GetNDownloadedBytes() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int GetLastDownloadedBlock() const;
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   long long GetExpectedDataFileSize() const;
 
  //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void UpdateDownloadCompleteStatus();
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   size_t GetAccessCnt() { return m_store.m_accessCnt; }
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   int GetVersion() { return m_store.m_version; }
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   const Store& RefStoredData() const { return m_store; }
 
   //---------------------------------------------------------------------
   //---------------------------------------------------------------------
   void GetCksum( unsigned char* buff, char* digest);
 
   const static char*   m_infoExtension;
   const static char*   m_traceID;
   const static int     m_defaultVersion;
   const static size_t  m_maxNumAccess;
 
   XrdSysTrace* GetTrace() const {return m_trace; }
 
   static size_t GetMaxNumAccess() { return m_maxNumAccess; }
 
protected:
   XrdSysTrace*   m_trace;
 
   Store          m_store;
   bool           m_hasPrefetchBuffer;       
   unsigned char *m_buff_written;            
   unsigned char *m_buff_prefetch;           
 
   int  m_sizeInBits;                        
   bool m_complete;                          
 
private:
   inline unsigned char cfiBIT(int n) const { return 1 << n; }
 
   // split reading for V1
   bool ReadV1(XrdOssDF* fp, const std::string &fname);
   XrdCksCalc*   m_cksCalc;
};
 
//------------------------------------------------------------------------------
 
inline bool Info::TestBitWritten(int i) const
{
   const int cn = i/8;
   assert(cn < GetSizeInBytes());
 
   const int off = i - cn*8;
   return (m_buff_written[cn] & cfiBIT(off)) != 0;
}
 
inline void Info::SetBitWritten(int i)
{
   const int cn = i/8;
   assert(cn < GetSizeInBytes());
 
   const int off = i - cn*8;
   m_buff_written[cn] |= cfiBIT(off);
}
 
inline void Info::SetBitPrefetch(int i)
{
   if (!m_buff_prefetch) return;
      
   const int cn = i/8;
   assert(cn < GetSizeInBytes());
 
   const int off = i - cn*8;
   m_buff_prefetch[cn] |= cfiBIT(off);
}
 
inline bool Info::TestBitPrefetch(int i) const
{
   if (!m_buff_prefetch) return false;
 
   const int cn = i/8;
   assert(cn < GetSizeInBytes());
 
   const int off = i - cn*8;
   return (m_buff_prefetch[cn] & cfiBIT(off)) != 0;
}
 
inline void Info::SetBitSynced(int i)
{
   const int cn = i/8;
   assert(cn < GetSizeInBytes());
 
   const int off = i - cn*8;
   m_store.m_buff_synced[cn] |= cfiBIT(off);
}
 
//------------------------------------------------------------------------------
 
inline int Info::GetNDownloadedBlocks() const
{
   int cntd = 0;
   for (int i = 0; i < m_sizeInBits; ++i)
      if (TestBitWritten(i)) cntd++;
 
   return cntd;
}
 
inline long long Info::GetNDownloadedBytes() const
{
   return m_store.m_bufferSize * GetNDownloadedBlocks();
}
 
inline int Info::GetLastDownloadedBlock() const
{
   for (int i = m_sizeInBits - 1; i >= 0; --i)
      if (TestBitWritten(i)) return i;
 
   return -1;
}
 
inline long long Info::GetExpectedDataFileSize() const
{
   int last_block = GetLastDownloadedBlock();
   if (last_block == m_sizeInBits - 1)
      return m_store.m_fileSize;
   else
      return (last_block + 1) * m_store.m_bufferSize;
}
 
inline int Info::GetSizeInBytes() const
{
   if (m_sizeInBits)
      return ((m_sizeInBits - 1)/8 + 1);
   else
      return 0;
}
 
inline int Info::GetSizeInBits() const
{
   return m_sizeInBits;
}
 
inline long long Info::GetFileSize() const
{
   return m_store.m_fileSize;
}
 
inline bool Info::IsComplete() const
{
   return m_complete;
}
 
inline bool Info::IsAnythingEmptyInRng(int firstIdx, int lastIdx) const
{
   // TODO rewrite to use full byte comparisons outside of edges ?
   // Also, it is always called with fisrtsdx = 0, lastIdx = m_sizeInBits.
   for (int i = firstIdx; i < lastIdx; ++i)
      if (! TestBitWritten(i)) return true;
 
   return false;
}
 
inline void Info::UpdateDownloadCompleteStatus()
{
   m_complete = ! IsAnythingEmptyInRng(0, m_sizeInBits);
}
 
inline long long Info::GetBufferSize() const
{
   return m_store.m_bufferSize;
}
 
}
#endif