XrdRmcData Class Reference

#include <XrdRmcData.hh>

Inheritance diagram for XrdRmcData:

Collaboration diagram for XrdRmcData:

Public Member Functions
	XrdRmcData (XrdRmcReal *cP, XrdOucCacheIO *ioP, long long vn, int opts)
bool	Detach (XrdOucCacheIOCD &iocd)
long long	FSize ()
const char *	Path ()
void	Preread ()
void	Preread (aprParms &Parms)
void	Preread (long long Offs, int rLen, int Opts=0)
virtual void	Preread (XrdOucRangeList &rlist)
int	Read (char *Buffer, long long Offset, int Length)
int	Sync ()
int	Trunc (long long Offset)
int	Write (char *Buffer, long long Offset, int Length)
Public Member Functions inherited from XrdOucCacheIO
	XrdOucCacheIO ()
	Construct and Destructor.
virtual int	Fcntl (XrdOucCacheOp::Code opc, const std::string &args, std::string &resp)
virtual int	Fstat (struct stat &sbuff)
virtual const char *	Location (bool refresh=false)
virtual int	pgRead (char *buff, long long offs, int rdlen, std::vector< uint32_t > &csvec, uint64_t opts=0, int *csfix=0)
virtual void	pgRead (XrdOucCacheIOCB &iocb, char *buff, long long offs, int rdlen, std::vector< uint32_t > &csvec, uint64_t opts=0, int *csfix=0)
virtual int	pgWrite (char *buff, long long offs, int wrlen, std::vector< uint32_t > &csvec, uint64_t opts=0, int *csfix=0)
virtual void	pgWrite (XrdOucCacheIOCB &iocb, char *buff, long long offs, int wrlen, std::vector< uint32_t > &csvec, uint64_t opts=0, int *csfix=0)
virtual int	ReadV (const XrdOucIOVec *readV, int rnum)
virtual void	ReadV (XrdOucCacheIOCB &iocb, const XrdOucIOVec *readV, int rnum)
virtual void	Sync (XrdOucCacheIOCB &iocb)
virtual void	Trunc (XrdOucCacheIOCB &iocb, long long offs)
virtual void	Update (XrdOucCacheIO &iocp)
virtual void	Write (XrdOucCacheIOCB &iocb, char *buff, long long offs, int wlen)
virtual int	WriteV (const XrdOucIOVec *writV, int wnum)
virtual void	WriteV (XrdOucCacheIOCB &iocb, const XrdOucIOVec *writV, int wnum)

Static Public Member Functions
static int	setAPR (aprParms &Dest, aprParms &Src, int pSize)

Additional Inherited Members
Static Public Attributes inherited from XrdOucCacheIO
static const uint64_t	forceCS = 0x0000000000000001ULL
static const int	SingleUse = 0x0001
	Mark pages for single use.
Protected Member Functions inherited from XrdOucCacheIO
virtual	~XrdOucCacheIO ()

Detailed Description

Definition at line 42 of file XrdRmcData.hh.

Constructor & Destructor Documentation

XrdRmcData()

XrdRmcData::XrdRmcData	(	XrdRmcReal *	cP,
		XrdOucCacheIO *	ioP,
		long long	vn,
		int	opts )

Definition at line 42 of file XrdRmcData.cc.

                      : pPLock(0), rPLock(0),  wPLock(0),
                        Cache(cP), ioObj(ioP), VNum(vn)
{
// We need to map the cache options to our local options
//
   isFIS = (opts & XrdOucCache::optFIS ?    1 : 0);
   isRW  = (opts & XrdOucCache::optRW  ? okRW : 0);
 
// Copy some values from the cache to our local area for convenience
//
   SegShft  = Cache->SegShft;
   OffMask  = Cache->OffMask;
   SegSize  = Cache->SegSize;
   maxCache = Cache->maxCache;
   Debug    = Cache->Dbg;
 
// Initialize the pre-read area
//
   memset(prRR,  -1, sizeof(prRR) );
   memset(prBeg, -1, sizeof(prBeg));
   memset(prEnd, -1, sizeof(prEnd));
   memset(prOpt,  0, sizeof(prOpt));
 
   prNSS      =-1;
   prRRNow    = 0;
   prStop     = 0;
   prNext     = prFree = 0;
   prActive   = 0;
   prOK       = (Cache->prNum ? 1 : 0);
   prReq.Data = this;
   prAuto     = (prOK ? setAPR(Apr, Cache->aprDefault, SegSize) : 0);
   prPerf     = 0;
   prCalc     = Apr.prRecalc;
 
// Establish serialization options
//
   if (Cache->Options & XrdRmc::ioMTSafe) pPLopt = rPLopt = xs_Shared;
      else pPLopt = rPLopt = xs_Exclusive;
 
// Establish serialization handling (only needed for r/w files)
//
   if (Cache->Options & XrdRmc::Serialized)
      {if (Cache->Options & XrdRmc::ioMTSafe)
          {if (isRW && prOK) pPLock = wPLock = &rwLock;}
          else if     (prOK) rPLock = pPLock = wPLock = &rwLock;
      } else if (!(Cache->Options & XrdRmc::ioMTSafe) || isRW)
                rPLock = pPLock = wPLock = &rwLock;
}

References XrdOucCacheIO::XrdOucCacheIO(), XrdRmc::ioMTSafe, XrdOucCache::optFIS, XrdOucCache::optRW, opts, XrdRmc::Serialized, setAPR(), xs_Exclusive, and xs_Shared.

Here is the call graph for this function:

Member Function Documentation

Detach()

bool XrdRmcData::Detach ( XrdOucCacheIOCD & iocd )

virtual

Detach this CacheIO object from the cache.

Note

This method must be called instead of using the delete operator since CacheIO objects may have multiple outstanding references and actual deletion may need to be deferred.

Parameters

iocd	reference to the detach complete callback object.

Returns

true Deletion can occur immediately. There is no outstanding I/O.

false Deletion must be deferred until it is safe to so from the cache perspective. At which point, the cache will call the DetachDone() method in the passed callback object. No locks may be held with respect to the CacheIO object when this is done to avoid deadlocks.

Implements XrdOucCacheIO.

Definition at line 97 of file XrdRmcData.cc.

{
   int delOK;
 
// We must wait for any pre-reads to stop at this point. TO DO: We really
// should run this in a sperate thread and use the callback mechanism.
//
   DMutex.Lock();
   if (prActive)
      {XrdSysSemaphore prDone(0);
       prStop = &prDone;
       DMutex.UnLock();
       prDone.Wait();
       DMutex.Lock();
      }
 
// Get exclusive control
//
   rwLock.Lock(xs_Exclusive);
 
// We can now detach ourselves from the cache
//
   delOK = Cache->Detach(ioObj);
   DMutex.UnLock();
   rwLock.UnLock(xs_Exclusive);
 
// Check if we should delete ourselves and if so add our stats to the cache
//
   if (delOK)
      {Cache->Statistics.Add(Statistics);
       if (Cache->Lgs)
          {char sBuff[4096];
           snprintf(sBuff, sizeof(sBuff),
                          "Cache: Stats: %lld Read; %lld Get; %lld Pass; "
                          "%lld Write; %lld Put; %lld Hits; %lld Miss; "
                          "%lld pead; %lld HitsPR; %lld MissPR; Path %s\n",
                          Statistics.X.BytesRead, Statistics.X.BytesGet,
                          Statistics.X.BytesPass, Statistics.X.BytesWrite,
                          Statistics.X.BytesPut,
                          Statistics.X.Hits,      Statistics.X.Miss,
                          Statistics.X.BytesPead,
                          Statistics.X.HitsPR,    Statistics.X.MissPR,
                          ioObj->Path());
           std::cerr <<sBuff;
          }
       delete this;
       return true;
      }
// TO DO: We should issue a message here as this will cause a memory leak
//        as we won't try to do the detavh again.
//
   return false;
}

References XrdSysSemaphore::Wait(), and xs_Exclusive.

Here is the call graph for this function:

FSize()

long long XrdRmcData::FSize ( )

inlinevirtual

Obtain size of the file.

Returns

Size of the file in bytes.

Implements XrdOucCacheIO.

Definition at line 49 of file XrdRmcData.hh.

{return (ioObj ? ioObj->FSize() : 0);}

Path()

const char * XrdRmcData::Path ( )

inlinevirtual

Get the path associated with this object.

Returns

Pointer to the path.

Implements XrdOucCacheIO.

Definition at line 51 of file XrdRmcData.hh.

{return ioObj->Path();}

Preread() [1/4]

void XrdRmcData::Preread

(

)

Definition at line 155 of file XrdRmcData.cc.

{
   MrSw EnforceMrSw(pPLock, pPLopt);
   long long segBeg, segEnd;
   int       oVal, pVal = 0, rLen, noIO, bPead = 0, prPages = 0;
   char *cBuff;
 
// Check if we are stopping, if so, ignore this request
//
   DMutex.Lock();
   if (prStop)
      {prActive = 0;
       prStop->Post();
       DMutex.UnLock();
       return;
      }
 
// Do the next pre-read in the queue (it's possible another may get in)
//
do{if ((oVal = prOpt[prNext]))
      {segBeg = prBeg[prNext]; segEnd = prEnd[prNext];
       prOpt[prNext++] = 0;
       if (prNext >= prMax) prNext = 0;
       if (oVal == prSKIP) continue;
       prActive = prRun;
       if (Debug > 1) std::cerr <<"prD: beg " <<(VNum >>XrdRmcReal::Shift) <<' '
                           <<(segEnd-segBeg+1)*SegSize <<'@' <<(segBeg*SegSize)
                           <<" f=" <<int(oVal) <<' ' <<ioObj->Path() <<std::endl;
       DMutex.UnLock();
       oVal = (oVal == prSUSE ? XrdRmcSlot::isSUSE : 0) | XrdRmcSlot::isNew;
       segBeg |= VNum; segEnd |= VNum;
       do {if ((cBuff = Cache->Get(ioObj, segBeg, rLen, noIO)))
              {if (noIO)  pVal = 0;
                  else   {pVal = oVal; bPead += rLen; prPages++;}
              }
          } while(cBuff && Cache->Ref(cBuff, 0, pVal) && segBeg++ < segEnd);
       if (Debug > 1) std::cerr <<"PrD: end " <<(VNum >>XrdRmcReal::Shift)
                           <<' ' <<prPages <<" pgs " <<bPead <<std::endl;
       if (bPead)
          {Statistics.Lock();
           Statistics.X.BytesPead += bPead;
           Statistics.X.MissPR    += prPages;
           Statistics.UnLock();
          }
       DMutex.Lock();
      }
   } while(oVal);
 
// See if we should schedule the next preread or stop
//
   if (prStop)
      {prActive = 0;
       prStop->Post();
      } else if (prOpt[prNext])
                {prActive = prWait;
                 Cache->PreRead(&prReq);
                } else prActive = 0;
 
// All done here
//
   DMutex.UnLock();
}

References XrdRmcSlot::isNew, and XrdRmcSlot::isSUSE.

Referenced by XrdRmcReal::PreRead().

Here is the caller graph for this function:

Preread() [2/4]

void XrdRmcData::Preread ( aprParms & Parms )

virtual

Reimplemented from XrdOucCacheIO.

Definition at line 239 of file XrdRmcData.cc.

{
 
// Establish the new feature set if prereads are enabled
//
   if (prOK)
      {DMutex.Lock();
       prAuto = setAPR(Apr, Parms, SegSize);
       DMutex.UnLock();
      }
}

References setAPR().

Here is the call graph for this function:

Preread() [3/4]

void XrdRmcData::Preread ( long long Offs, int rLen, int Opts = 0 )

virtual

Reimplemented from XrdOucCacheIO.

Definition at line 220 of file XrdRmcData.cc.

{
   int How;
 
// Determine how to place the pages. We do this via assignment to avoid a gcc
// bug that doesn't optimize out static const int's except via assignment.
//
   if (Opts & SingleUse) How = prSUSE;
      else How = prLRU;
 
// Verify that this preread will succeed then schedule it if so
//
   if (prOK && rLen > 0 && Offs > 0
   &&  Offs < XrdRmcReal::MaxFO && (Offs + rLen) < XrdRmcReal::MaxFO) return;
      QueuePR(Offs>>SegShft, rLen, How);
}

References XrdOucCacheIO::SingleUse.

Preread() [4/4]

virtual void XrdOucCacheIO::Preread ( XrdOucRangeList & rlist )

inlinevirtual

Perform an asynchronous vector preread (may be ignored).

Parameters

rlist

a vector of byte ranges to preread.

Reimplemented from XrdOucCacheIO.

Definition at line 317 of file XrdOucCache.hh.

                    {for (auto it = rlist.begin(); it != rlist.end(); it++)
                         Preread(it->offset, it->size);
                    }

Read()

int XrdRmcData::Read ( char * buff, long long offs, int rlen )

virtual

Perform an synchronous read.

Parameters

buff	pointer to the buffer to receive the results. The buffer must remain valid until the callback is invoked.
offs	the offset into the file.
rlen	the number of bytes to read.

Returns

< 0 - Read failed, value is -errno. >=0 - Read succeeded, value is number of bytes read.

Implements XrdOucCacheIO.

Definition at line 337 of file XrdRmcData.cc.

{
   MrSw EnforceMrSw(rPLock, rPLopt);
   XrdOucCacheStats Now;
   char *cBuff, *Dest = Buff;
   long long segOff, segNum = (Offs >> SegShft);
   int noIO, rAmt, rGot, doPR = prAuto, rLeft = rLen;
 
// Verify read length and offset
//
   if (rLen <= 0) return 0;
   if (XrdRmcReal::MaxFO <  Offs || Offs < 0
   ||  XrdRmcReal::MaxFO < (Offs + rLen)) return -EOVERFLOW;
 
// Check for preread request and Determine how to place the pages.
//
   if (!Buff)
      {int How;
       if (rLen > maxCache) How = prSUSE;
          else How = prLRU;
       QueuePR(segNum, rLen, How);
       return 0;
      }
 
// Ignore caching it if it's too large. Use alternate read algorithm.
//
   if (rLen > maxCache) return Read(Now, Buff, Offs, rLen);
 
// We check now whether or not we will try to do a preread later. This is
// advisory at this point so we don't need to obtain any locks to do this.
//
   if (doPR)
      {if (rLen >= Apr.Trigger) doPR = 0;
          else for (noIO = 0; noIO < prRRMax; noIO++)
                   if (prRR[noIO] == segNum) {doPR = 0; break;}
       if (doPR)
          {DMutex.Lock();
           prRR[prRRNow] = segNum;
           prRRNow = (prRRNow+1)%prRRMax;
           DMutex.UnLock();
          }
      }
   if (Debug > 1) std::cerr <<"Rdr: " <<rLen <<'@' <<Offs <<" pr=" <<doPR <<std::endl;
 
// Get the segment pointer, offset and the initial read amount
//
   segNum|= VNum;
   segOff = Offs & OffMask;
   rAmt   = SegSize - segOff;
   if (rAmt > rLen) rAmt = rLen;
 
// Now fault the pages in
//
   while((cBuff = Cache->Get(ioObj, segNum, rGot, noIO)))
        {if (rGot <= segOff + rAmt) rAmt = (rGot <= segOff ? 0 : rGot-segOff);
         if (rAmt) {memcpy(Dest, cBuff+segOff, rAmt);
                    Dest += rAmt; Offs += rAmt; Now.X.BytesGet += rGot;
                   }
         if (noIO) {Now.X.Hits++; if (noIO < 0) Now.X.HitsPR++;}
            else   {Now.X.Miss++; Now.X.BytesRead  += rAmt;}
         if (!(Cache->Ref(cBuff, (isFIS ? rAmt : 0)))) {doPR = 0; break;}
         segNum++; segOff = 0;
         if ((rLeft -= rAmt) <= 0) break;
         rAmt = (rLeft <= SegSize ? rLeft : SegSize);
        }
 
// Update stats
//
   Statistics.Add(Now);
 
// See if a preread needs to be done. We will only do this if no errors occurred
//
   if (doPR && cBuff)
      {EnforceMrSw.UnLock();
       QueuePR(segNum, rLen, prLRU, 1);
      }
 
// All done, if we ended fine, return amount read. If there is no page buffer
// then the cache returned the error in the amount present variable.
//
   if (Debug > 1) std::cerr <<"Rdr: ret " <<(cBuff ? Dest-Buff : rGot) <<" hits "
                       <<Now.X.Hits <<" pr " <<Now.X.HitsPR <<std::endl;
   return (cBuff ? Dest-Buff : rGot);
}

References XrdOucCacheStats::CacheStats::BytesGet, XrdOucCacheStats::CacheStats::BytesRead, XrdOucCacheStats::CacheStats::Hits, XrdOucCacheStats::CacheStats::HitsPR, XrdOucCacheStats::CacheStats::Miss, Read(), and XrdOucCacheStats::X.

Referenced by Read().

Here is the call graph for this function:

Here is the caller graph for this function:

setAPR()

int XrdRmcData::setAPR ( aprParms & Dest, aprParms & Src, int pSize )

static

Definition at line 489 of file XrdRmcData.cc.

{
 
// Copy over the information
//
   Dest = Src;
 
// Fix it up as needed
//
   if (Dest.Trigger  <= 0) Dest.Trigger  = (Dest.minPages ? pSize + 1: 0);
   if (Dest.prRecalc <= 0) Dest.prRecalc = (Dest.prRecalc ? 52428800 : 0);
   if (Dest.minPages <  0) Dest.minPages = 0;
   if (Dest.minPerf  <  0) Dest.minPerf  = 0;
   if (Dest.minPerf  >100) Dest.minPerf  = 100;
 
 
// Indicate whether anything can be preread
//
   return (Dest.minPages > 0 && Dest.Trigger > 1);
}

References XrdOucCacheIO::aprParms::minPages, XrdOucCacheIO::aprParms::minPerf, XrdOucCacheIO::aprParms::prRecalc, and XrdOucCacheIO::aprParms::Trigger.

Referenced by XrdRmcData(), XrdRmcReal::XrdRmcReal(), and Preread().

Here is the caller graph for this function:

Sync()

int XrdRmcData::Sync ( )

inlinevirtual

Perform an synchronous sync() operation.

Returns

<0 - Sync failed, value is -errno. =0 - Sync succeeded.

Implements XrdOucCacheIO.

Definition at line 63 of file XrdRmcData.hh.

{return 0;} // We only support write-through for now

Trunc()

int XrdRmcData::Trunc ( long long offs )

virtual

Perform an synchronous trunc() operation.

Parameters

offs	the size the file is have.

Returns

<0 - Trunc failed, value is -errno. =0 - Trunc succeeded.

Implements XrdOucCacheIO.

Definition at line 514 of file XrdRmcData.cc.

{
   MrSw EnforceMrSw(wPLock, xs_Exclusive);
 
// Verify that we can modify this cache and the trunc offset
//
   if (!isRW) return -EROFS;
   if (Offs > XrdRmcReal::MaxFO || Offs < 0) return -EOVERFLOW;
 
// Get the segment pointer and truncate pages from the cache
//
   Cache->Trunc(ioObj, (Offs >> SegShft) | VNum);
 
// Now just return the result of actually doing the truncate
//
   return ioObj->Trunc(Offs);
}

References xs_Exclusive.

Write()

int XrdRmcData::Write ( char * buff, long long offs, int wlen )

virtual

Perform an synchronous write.

Parameters

buff	pointer to the buffer holding the contents. The buffer must remain valid until the callback is invoked.
offs	the offset into the file.
wlen	the number of bytes to write

Returns

< 0 - Write failed, value is -errno. >=0 - Write succeeded, value is number of bytes written.

Implements XrdOucCacheIO.

Definition at line 536 of file XrdRmcData.cc.

{
   MrSw EnforceMrSw(wPLock, xs_Exclusive);
   XrdOucCacheStats Now;
   char *cBuff, *Src = Buff;
   long long segOff, segNum;
   int noIO, wAmt, rGot, wLeft = wLen;
 
// Verify write length, ability, and buffer
//
   if (wLen <= 0) return 0;
   if (!isRW)     return -EROFS;
   if (!Buff)     return -EINVAL;
   if (XrdRmcReal::MaxFO <  Offs || Offs < 0
   ||  XrdRmcReal::MaxFO < (Offs + wLen)) return -EOVERFLOW;
 
// First step is to write out all the data (write-through for now)
//
   if ((wAmt = ioObj->Write(Buff, Offs, wLen)) != wLen)
      return (wAmt < 0 ? wAmt : -EIO);
   Now.X.BytesWrite = wLen;
 
// Get the segment pointer, offset and the initial write amount
//
   segNum = (Offs >> SegShft) | VNum;
   segOff = Offs & OffMask;
   wAmt   = SegSize - segOff;
   if (wAmt > wLen) wAmt = wLen;
 
// Now update any pages that are actually in the cache
//
do{if (!(cBuff = Cache->Get(0, segNum, rGot, noIO))) Now.X.Miss++;
      else {memcpy(cBuff+segOff, Src, wAmt);
            Now.X.BytesPut += wAmt; Now.X.Hits++;
            if (noIO < 0) Now.X.HitsPR++;
            Cache->Upd(cBuff, wAmt, segOff);
           }
   Src += wAmt;
   if ((wLeft -= wAmt) <= 0) break;
   wAmt = (wLeft <= SegSize ? wLeft : SegSize);
   segNum++; segOff = 0;
  } while(1);
 
// Update stats and return how much we wrote
//
   Statistics.Add(Now);
   return wLen;
}

References XrdOucCacheStats::CacheStats::BytesPut, XrdOucCacheStats::CacheStats::BytesWrite, XrdOucCacheStats::CacheStats::Hits, XrdOucCacheStats::CacheStats::HitsPR, XrdOucCacheStats::CacheStats::Miss, XrdOucCacheStats::X, and xs_Exclusive.

---

The documentation for this class was generated from the following files:

• XrdRmcData.hh
• XrdRmcData.cc