XrdClientReadCache.hh

Go to the documentation of this file.

#ifndef XRD_READCACHE_H
#define XRD_READCACHE_H
/******************************************************************************/
/*                                                                            */
/*               X r d C l i e n t R e a d C a c h e . h h                    */
/*                                                                            */
/* Author: Fabrizio Furano (INFN Padova, 2006)                                */
/*                                                                            */
/* This file is part of the XRootD software suite.                            */
/*                                                                            */
/* 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 Lesser General Public       */
/* License for more details.                                                  */
/*                                                                            */
/* You should have received a copy of the GNU Lesser General Public License   */
/* along with XRootD in a file called COPYING.LESSER (LGPL license) and file  */
/* COPYING (GPL license).  If not, see <http://www.gnu.org/licenses/>.        */
/*                                                                            */
/* The copyright holder's institutional names and contributor's names may not */
/* be used to endorse or promote products derived from this software without  */
/* specific prior written permission of the institution or contributor.       */
/******************************************************************************/
 
//                                                                      //
// Classes to handle cache reading and cache placeholders               //
//                                                                      //
 
#include "XrdSys/XrdSysHeaders.hh"
#include "XrdClient/XrdClientInputBuffer.hh"
#include "XrdClient/XrdClientMessage.hh"
#include "XrdClient/XrdClientVector.hh"
#include "XrdClient/XrdClientConst.hh"
 
//
// XrdClientReadCacheItem
//
// An item is nothing more than an interval of bytes taken from a file.
// Extremes are included.
// Since a cache object is to be associated to a single instance
// of TXNetFile, we do not have to keep here any filehandle
//
 
class XrdClientReadCacheItem {
private:
    // A placeholder block is a "fake block" used to mark outstanding data
    bool             fIsPlaceholder;  
 
    long long        fBeginOffset;    // Offset of the first byte of data
    void             *fData;
    long long        fEndOffset;      // Offset of the last byte of data
    long             fTimestampTicks; // timestamp updated each time it's referenced
 
public:
    XrdClientReadCacheItem(const void *buffer, long long begin_offs, 
                           long long end_offs, long long ticksnow,
                           bool placeholder=false);
    ~XrdClientReadCacheItem();
 
    inline long long BeginOffset() { return fBeginOffset; }
    inline long long EndOffset() { return fEndOffset; }
 
    // Is this obj contained in the given interval (which is going to be inserted) ?
    inline bool   ContainedInInterval(long long begin_offs, long long end_offs) {
        return ( (end_offs >= begin_offs) &&
                 (fBeginOffset >= begin_offs) &&
                 (fEndOffset <= end_offs) );
    }
 
    // Does this obj contain the given interval (which is going to be requested) ?
    inline bool   ContainsInterval(long long begin_offs, long long end_offs) {
        return ( (end_offs > begin_offs) &&
                 (fBeginOffset <= begin_offs) && (fEndOffset >= end_offs) );
    }
 
    // Are the two intervals intersecting in some way?
    inline bool  IntersectInterval(long long begin_offs, long long end_offs) {
      if ( ContainsOffset( begin_offs ) || ContainsOffset( end_offs ) ) return true;
      if ( (fBeginOffset >= begin_offs) && (fBeginOffset <= end_offs) ) return true;
      return false;
    }
 
 
    inline bool ContainsOffset(long long offs) {
        return (fBeginOffset <= offs) && (fEndOffset >= offs);
    }
 
    void *GetData() { return fData; }
    
    // Get the requested interval, if possible
    inline bool   GetInterval(const void *buffer, long long begin_offs, 
                              long long end_offs) {
        if (!ContainsInterval(begin_offs, end_offs))
            return FALSE;
        memcpy((void *)buffer, ((char *)fData)+(begin_offs - fBeginOffset),
               end_offs - begin_offs + 1);
        return TRUE;
    }
 
    // Get as many bytes as possible, starting from the beginning of the given
    // interval
    inline long   GetPartialInterval(const void *buffer, long long begin_offs,
                                     long long end_offs) {
 
        long long b = -1, e, l;
 
        if (begin_offs > end_offs) return 0;
 
        // Try to set the starting point, if contained in the given interval
        if ( (begin_offs >= fBeginOffset) &&
             (begin_offs <= fEndOffset) )
            b = begin_offs;
 
        if (b < 0) return 0;
 
        // The starting point is in the interval. Let's get the minimum endpoint
        e = xrdmin(end_offs, fEndOffset);
 
        l = e - b + 1;
 
        if (buffer && fData)
            memcpy((void *)buffer, ((char *)fData)+(b - fBeginOffset), l);
 
        return l;
    }
 
    inline long long GetTimestampTicks() { return(fTimestampTicks); }
 
    inline bool IsPlaceholder() { return fIsPlaceholder; }
 
    long Size() { return (fEndOffset - fBeginOffset + 1); }
 
    inline void     Touch(long long ticksnow) { fTimestampTicks = ticksnow; }
 
    bool Pinned;
};
 
//
// XrdClientReadCache
//
// The content of the cache. Not cache blocks, but
// variable length Items
//
typedef XrdClientVector<XrdClientReadCacheItem *> ItemVect;
 
// A cache interval, extremes included
struct XrdClientCacheInterval {
    long long beginoffs;
    long long endoffs;
};
 
typedef XrdClientVector<XrdClientCacheInterval> XrdClientIntvList;
 
class XrdClientReadCache {
private:
 
    long long       fBytesHit;         // Total number of bytes read with a cache hit
    long long       fBytesSubmitted;   // Total number of bytes inserted
    float           fBytesUsefulness;
    ItemVect        fItems;
    long long       fMaxCacheSize;
    long long       fMissCount;        // Counter of the cache misses
    float           fMissRate;            // Miss rate
    XrdSysRecMutex  fMutex;
    long long       fReadsCounter;     // Counter of all the attempted reads (hit or miss)
    int             fBlkRemPolicy;     // The algorithm used to remove "old" chunks
    long long       fTimestampTickCounter;        // Aging mechanism yuk!
    long long       fTotalByteCount;
 
    long long       GetTimestampTick();
    bool            MakeFreeSpace(long long bytes);
 
    bool            RemoveItem();
    bool            RemoveLRUItem();
    bool            RemoveFirstItem();
 
    inline void     UpdatePerfCounters() {
        if (fReadsCounter > 0)
            fMissRate = (float)fMissCount / fReadsCounter;
        if (fBytesSubmitted > 0)
            fBytesUsefulness = (float)fBytesHit / fBytesSubmitted;
    }
 
    int             FindInsertionApprox(long long begin_offs);
    int             FindInsertionApprox_rec(int startidx, int endidx,
                                        long long begin_offs);
public:
 
    // The algos available for the removal of "old" blocks
    enum {
      kRmBlk_LRU = 0,
      kRmBlk_LeastOffs,
      kRmBlk_FIFO
    };
 
    XrdClientReadCache();
    ~XrdClientReadCache();
  
    long          GetDataIfPresent(const void *buffer, long long begin_offs,
                                   long long end_offs, bool PerfCalc,
                                   XrdClientIntvList &missingblks, long &outstandingblks);
 
  void                       GetInfo(
                                          // The actual cache size
                                          int &size,
 
                                          // The number of bytes submitted since the beginning
                                          long long &bytessubmitted,
 
                                          // The number of bytes found in the cache (estimate)
                                          long long &byteshit,
 
                                          // The number of reads which did not find their data
                                          // (estimate)
                                          long long &misscount,
 
                                          // miss/totalreads ratio (estimate)
                                          float &missrate,
 
                                          // number of read requests towards the cache
                                          long long &readreqcnt,
 
                                          // ratio between bytes found / bytes submitted
                                          float &bytesusefulness
                                     );
 
    inline long long GetTotalByteCount() {
        XrdSysMutexHelper m(fMutex);
        return fTotalByteCount;
    }
 
    void PutPlaceholder(long long begin_offs, long long end_offs);
 
    inline void     PrintPerfCounters() {
        XrdSysMutexHelper m(fMutex);
 
        cout << "Low level caching info:" << endl;
        cout << " StallsRate=" << fMissRate << endl;
        cout << " StallsCount=" << fMissCount << endl;
        cout << " ReadsCounter=" << fReadsCounter << endl;
        cout << " BytesUsefulness=" << fBytesUsefulness << endl;
        cout << " BytesSubmitted=" << fBytesSubmitted << " BytesHit=" << 
           fBytesHit << endl << endl;
    }
 
 
    void            PrintCache();
 
    void            SubmitXMessage(XrdClientMessage *xmsg, long long begin_offs,
                                   long long end_offs);
 
    bool            SubmitRawData(const void *buffer, long long begin_offs,
                                  long long end_offs, bool pinned=false);
 
    void            RemoveItems(bool leavepinned=true);
    void            RemoveItems(long long begin_offs, long long end_offs, bool remove_overlapped = false);
    void            RemovePlaceholders();
 
 
    void            SetSize(int sz) {
      fMaxCacheSize = sz;
    }
 
    void            SetBlkRemovalPolicy(int p) {
      fBlkRemPolicy = p;
    }
 
    void UnPinCacheBlk(long long begin_offs, long long end_offs);
    void *FindBlk(long long begin_offs, long long end_offs);
 
    // To check if a block dimension will fit into the cache
    inline bool   WillFit(long long bc) {
        XrdSysMutexHelper m(fMutex);
        return (bc < fMaxCacheSize);
    }
 
};
#endif