XrdXrootdMonFile Class Reference

#include <XrdXrootdMonFile.hh>

Inheritance diagram for XrdXrootdMonFile:

Collaboration diagram for XrdXrootdMonFile:

Public Member Functions
	XrdXrootdMonFile ()
	~XrdXrootdMonFile ()
void	DoIt ()

Static Public Member Functions
static void	Close (XrdXrootdFileStats *fsP, bool isDisc=false)
static void	Defaults (int intv, int opts, int iocnt, int fbsz)
static void	Disc (unsigned int usrID)
static bool	Init ()
static void	Open (XrdXrootdFileStats *fsP, const char *Path, unsigned int uDID, bool isRW)

Detailed Description

Definition at line 42 of file XrdXrootdMonFile.hh.

Constructor & Destructor Documentation

XrdXrootdMonFile()

XrdXrootdMonFile::XrdXrootdMonFile ( )

inline

Definition at line 59 of file XrdXrootdMonFile.hh.

: XrdJob("monitor fstat") {}

References XrdJob::XrdJob().

Referenced by Init().

Here is the call graph for this function:

Here is the caller graph for this function:

~XrdXrootdMonFile()

XrdXrootdMonFile::~XrdXrootdMonFile ( )

inline

Definition at line 60 of file XrdXrootdMonFile.hh.

{}

Member Function Documentation

Close()

void XrdXrootdMonFile::Close ( XrdXrootdFileStats * fsP, bool isDisc = false )

static

Definition at line 111 of file XrdXrootdMonFile.cc.

{
   XrdXrootdMonFileCLS cRec;
   char *cP;
   int iEnt, iMap, iSlot;
 
// If this object was registered for I/O reporting, deregister it. Then mark
// it as closed on the f-stream.
//
   if (fsP->MonEnt != -1 && fsP->MonEnt != noSlot)
      {iEnt  = fsP->MonEnt & 0xffff;
       iMap  = iEnt >> XrdXrootdMonFMap::fmShft;
       iSlot = iEnt &  XrdXrootdMonFMap::fmMask;
       fmMutex.Lock();
       if (fmMap[iMap].Free(iSlot)) fmUse[iMap]--;
       if (iMap == fmHWM) while(fmHWM >= 0 && !fmUse[fmHWM]) fmHWM--;
       fmMutex.UnLock();
      }
   fsP->MonEnt = -1;
 
// Insert a close record header (mostly precomputed)
//
   cRec.Hdr.recType = XrdXrootdMonFileHdr::isClose;
   cRec.Hdr.recFlag = crecFlag;
   if (isDisc) cRec.Hdr.recFlag |= XrdXrootdMonFileHdr::forced;
   cRec.Hdr.recSize = crecNLen;
   cRec.Hdr.fileID  = fsP->FileID;
 
// Insert the I/O bytes
//
   cRec.Xfr.read  = htonll(fsP->xfr.read);
   cRec.Xfr.readv = htonll(fsP->xfr.readv);
   cRec.Xfr.write = htonll(fsP->xfr.write);
 
// Insert ops if so wanted
//
   if (fsOPS)
      {cRec.Ops.read  = htonl (fsP->ops.read);
       if (fsP->ops.read)
          {cRec.Ops.rdMin = htonl (fsP->ops.rdMin);
           cRec.Ops.rdMax = htonl (fsP->ops.rdMax);
          } else {
           cRec.Ops.rdMin = cRec.Ops.rdMax = 0;
          }
       cRec.Ops.readv = htonl (fsP->ops.readv);
       cRec.Ops.rsegs = htonll(fsP->ops.rsegs);
       if (fsP->ops.readv)
          {cRec.Ops.rsMin = htons (fsP->ops.rsMin);
           cRec.Ops.rsMax = htons (fsP->ops.rsMax);
           cRec.Ops.rvMin = htonl (fsP->ops.rvMin);
           cRec.Ops.rvMax = htonl (fsP->ops.rvMax);
          } else {
           cRec.Ops.rsMin = cRec.Ops.rsMax = 0;
           cRec.Ops.rvMin = cRec.Ops.rvMax = 0;
          }
       cRec.Ops.write = htonl (fsP->ops.write);
       if (fsP->ops.write)
          {cRec.Ops.wrMin = htonl (fsP->ops.wrMin);
           cRec.Ops.wrMax = htonl (fsP->ops.wrMax);
          } else {
           cRec.Ops.wrMin = cRec.Ops.wrMax = 0;
          }
      }
 
// Record sum of squares if so needed
//
   if (fsSSQ)
      {XrdXrootdMonDouble xval;
       xval.dreal           = fsP->ssq.read;
       cRec.Ssq.read.dlong  = htonll(xval.dlong);
       xval.dreal           = fsP->ssq.readv;
       cRec.Ssq.readv.dlong = htonll(xval.dlong);
       xval.dreal           = fsP->ssq.rsegs;
       cRec.Ssq.rsegs.dlong = htonll(xval.dlong);
       xval.dreal           = fsP->ssq.write;
       cRec.Ssq.write.dlong = htonll(xval.dlong);
      }
 
// Get a pointer to the next slot (the buffer gets locked)
//
   cP = GetSlot(crecSize);
   memcpy(cP, &cRec, crecSize);
   bfMutex.UnLock();
}

References XrdXrootdMonDouble::dlong, XrdXrootdMonDouble::dreal, XrdXrootdFileStats::FileID, XrdXrootdMonFMap::fmMask, XrdXrootdMonFMap::fmShft, XrdXrootdMonFileHdr::forced, XrdXrootdMonFileCLS::Hdr, XrdXrootdMonFileHdr::isClose, XrdXrootdFileStats::MonEnt, XrdXrootdMonFileCLS::Ops, XrdXrootdFileStats::ops, XrdXrootdMonStatOPS::rdMax, XrdXrootdMonStatOPS::rdMin, XrdXrootdMonStatOPS::read, XrdXrootdMonStatSSQ::read, XrdXrootdMonStatXFR::read, XrdXrootdMonStatOPS::readv, XrdXrootdMonStatSSQ::readv, XrdXrootdMonStatXFR::readv, XrdXrootdMonFileHdr::recFlag, XrdXrootdMonFileHdr::recSize, XrdXrootdMonFileHdr::recType, XrdXrootdMonStatOPS::rsegs, XrdXrootdMonStatSSQ::rsegs, XrdXrootdMonStatOPS::rsMax, XrdXrootdMonStatOPS::rsMin, XrdXrootdMonStatOPS::rvMax, XrdXrootdMonStatOPS::rvMin, XrdXrootdMonFileCLS::Ssq, XrdXrootdFileStats::ssq, XrdXrootdMonStatOPS::write, XrdXrootdMonStatSSQ::write, XrdXrootdMonStatXFR::write, XrdXrootdMonStatOPS::wrMax, XrdXrootdMonStatOPS::wrMin, XrdXrootdMonFileCLS::Xfr, and XrdXrootdFileStats::xfr.

Referenced by XrdXrootdFileTable::Del(), and XrdXrootdFileTable::Recycle().

Here is the caller graph for this function:

Defaults()

void XrdXrootdMonFile::Defaults ( int intv, int opts, int iocnt, int fbsz )

static

Definition at line 200 of file XrdXrootdMonFile.cc.

{
 
// Set the reporting interval and I/O counter
//
   repTime = intv;
   xfrCnt  = xfrcnt;
   xfrRem  = xfrcnt;
 
// Set the buffer size. The configuration accepts 1024 to 65535 bytes, but the
// buffer goes out as one datagram, so limit it to the largest UDP payload.
//
   fBsz = (fbsz <= 0 ? 65472
                     : std::clamp(fbsz, 1024, XrdXrootdMonitor::maxDgram));
 
// Expand out the options
//
   fsXFR  = (opts &  XROOTD_MON_FSXFR) != 0;
   fsLFN  = (opts &  XROOTD_MON_FSLFN) != 0;
   fsOPS  = (opts & (XROOTD_MON_FSOPS  | XROOTD_MON_FSSSQ)) != 0;
   fsSSQ  = (opts &  XROOTD_MON_FSSSQ) != 0;
 
// Set monitoring level
//
        if (fsSSQ) fsLVL = XrdXrootdFileStats::monSsq;
   else if (fsOPS) fsLVL = XrdXrootdFileStats::monOps;
   else if (intv)  fsLVL = XrdXrootdFileStats::monOn;
   else            fsLVL = XrdXrootdFileStats::monOff;
}

References XrdXrootdMonitor::maxDgram, XrdXrootdFileStats::monOff, XrdXrootdFileStats::monOn, XrdXrootdFileStats::monOps, XrdXrootdFileStats::monSsq, opts, XROOTD_MON_FSLFN, XROOTD_MON_FSOPS, XROOTD_MON_FSSSQ, and XROOTD_MON_FSXFR.

Referenced by XrdXrootdMonitor::Defaults().

Here is the caller graph for this function:

Disc()

void XrdXrootdMonFile::Disc ( unsigned int usrID )

static

Definition at line 234 of file XrdXrootdMonFile.cc.

{
   static short drecSize = htons(sizeof(XrdXrootdMonFileDSC));
   XrdXrootdMonFileDSC *dP;
 
// Get a pointer to the next slot (the buffer gets locked)
//
   dP = (XrdXrootdMonFileDSC *)GetSlot(sizeof(XrdXrootdMonFileDSC));
 
// Fill out the record. It's pretty simple
//
   dP->Hdr.recType = XrdXrootdMonFileHdr::isDisc;
   dP->Hdr.recFlag = 0;
   dP->Hdr.recSize = drecSize;
   dP->Hdr.userID  = usrID;
   bfMutex.UnLock();
}

References XrdXrootdMonFileDSC::Hdr, XrdXrootdMonFileHdr::isDisc, XrdXrootdMonFileHdr::recFlag, XrdXrootdMonFileHdr::recSize, and XrdXrootdMonFileHdr::recType.

Referenced by XrdXrootdProtocol::Recycle().

Here is the caller graph for this function:

DoIt()

void XrdXrootdMonFile::DoIt ( )

virtual

Implements XrdJob.

Definition at line 256 of file XrdXrootdMonFile.cc.

{
 
// First check if we need to report all the I/O stats
//
   xfrRem--;
   if (!xfrRem) DoXFR();
 
// Check if we should flush the buffer
//
   bfMutex.Lock();
   if (repNext) Flush();
   bfMutex.UnLock();
 
// Reschedule ourselves
//
   XrdXrootdMonInfo::Sched->Schedule((XrdJob *)this, time(0)+repTime);
}

References XrdJob::XrdJob(), and XrdXrootdMonInfo::Sched.

Here is the call graph for this function:

Init()

bool XrdXrootdMonFile::Init ( )

static

Definition at line 351 of file XrdXrootdMonFile.cc.

{
   XrdXrootdMonFile *mfP;
   int alignment, pagsz = getpagesize();
 
// Allocate a socket buffer
//
   alignment = (fBsz < pagsz ? 1024 : pagsz);
   if (posix_memalign((void **)&repBuff, alignment, fBsz))
      {XrdXrootdMonInfo::eDest->Emsg("MonFile", "Unable to allocate monitor buffer.");
       return false;
      }
 
// Set the header (always present)
//
   repHdr = (XrdXrootdMonHeader *)repBuff;
   repHdr->code = XROOTD_MON_MAPFSTA;
   repHdr->pseq = 0;
   repHdr->stod = XrdXrootdMonInfo::startTime;
 
// Set the time record (always present)
//
   repTOD   = (XrdXrootdMonFileTOD *)(repBuff + sizeof(XrdXrootdMonHeader));
   repTOD->Hdr.recType = XrdXrootdMonFileHdr::isTime;
   repTOD->Hdr.recFlag = XrdXrootdMonFileHdr::hasSID;
   repTOD->Hdr.recSize = htons(sizeof(XrdXrootdMonFileTOD));
   repTOD->sID = static_cast<kXR_int64>(XrdXrootdMonInfo::mySID);
 
// Establish first real record in the buffer (always fixed)
//
   repFirst = repBuff+sizeof(XrdXrootdMonHeader)+sizeof(XrdXrootdMonFileTOD);
 
// Calculate the end nut the next slot always starts with a null pointer
//
   repLast = repBuff+fBsz-1;
   repNext = 0;
 
// Compute the longest lfn that an open record can carry, not counting its
// null byte. The record must fit an empty buffer, and its size must fit the
// 16-bit recSize field. Records are a multiple of 8 bytes long, so use the
// largest multiple of 8 that fits. The fixed part is minRecSz plus the user
// dictid. Defaults() keeps fBsz at 1024 or more, so this is always positive.
//
   int maxSlot = repLast - repFirst;
   if (maxSlot > 32767) maxSlot = 32767;
   maxText = (maxSlot & ~7) - (minRecSz + (int)sizeof(kXR_unt32)) - 1;
 
// Calculate the close record size and the initial flags
//
   crecSize = sizeof(XrdXrootdMonFileHdr) + sizeof(XrdXrootdMonStatXFR);
   if (fsSSQ || fsOPS)
      {crecSize += sizeof(XrdXrootdMonStatOPS);
       crecFlag = XrdXrootdMonFileHdr::hasOPS;
      } else crecFlag = 0;
   if (fsSSQ)
      {crecSize += sizeof(XrdXrootdMonStatSSQ);
       crecFlag |= XrdXrootdMonFileHdr::hasSSQ;
      }
   crecNLen = htons(static_cast<short>(crecSize));
 
// Preformat the i/o record
//
   xfrRec.Hdr.recType = XrdXrootdMonFileHdr::isXfr;
   xfrRec.Hdr.recFlag = 0;
   xfrRec.Hdr.recSize = htons(static_cast<short>(sizeof(xfrRec)));
 
// Calculate the tod record size
//
   trecNLen = htons(static_cast<short>(sizeof(XrdXrootdMonFileTOD)));
 
// Allocate an instance of ourselves so we can schedule ourselves
//
   mfP = new XrdXrootdMonFile();
 
// Schedule an the flushes
//
   XrdXrootdMonInfo::Sched->Schedule((XrdJob *)mfP, time(0)+repTime);
   return true;
}

References XrdJob::XrdJob(), XrdXrootdMonFile(), XrdXrootdMonInfo::eDest, XrdXrootdMonFileHdr::hasOPS, XrdXrootdMonFileHdr::hasSID, XrdXrootdMonFileHdr::hasSSQ, XrdXrootdMonFileHdr::isTime, XrdXrootdMonFileHdr::isXfr, XrdXrootdMonInfo::mySID, XrdXrootdMonInfo::Sched, XrdXrootdMonInfo::startTime, and XROOTD_MON_MAPFSTA.

Referenced by XrdXrootdMonitor::Init().

Here is the call graph for this function:

Here is the caller graph for this function:

Open()

void XrdXrootdMonFile::Open ( XrdXrootdFileStats * fsP, const char * Path, unsigned int uDID, bool isRW )

static

Definition at line 501 of file XrdXrootdMonFile.cc.

{
   XrdXrootdMonFileOPN *oP;
   int i = 0, sNum = -1, rLen, tLen = 0;
 
// Assign the path a dictionary id if not assigned via file monitoring
//
   if (fsP->FileID == 0) fsP->FileID = XrdXrootdMonitor::GetDictID();
 
// Add this open to the map table if we are doing I/O stats.
//
   if (fsXFR)
      {fmMutex.Lock();
       for (i = 0; i < mapUse; i++)
           if (fmUse[i] < XrdXrootdMonFMap::fmSize)
              {if ((sNum = fmMap[i].Insert(fsP)) >= 0)
                  {fmUse[i]++;
                   if (i > fmHWM) fmHWM = i;
                   break;
                  }
              }
       fmMutex.UnLock();
      }
 
// Generate the cookie (real or virtual) to find the entry in the map table.
// If the file has no entry (no xfr option, or the map is full), use noSlot.
// Supply the monitoring options for efficiency.
//
   fsP->MonEnt = (sNum < 0 ? noSlot
                           : (sNum | (i << XrdXrootdMonFMap::fmShft)) & 0xffff);
   fsP->monLvl = fsLVL;
   fsP->xfrXeq = 0;
 
// Compute the size of this record
//
   rLen = minRecSz;
   if (fsLFN)
      {tLen  = strlen(Path);
       if (tLen > maxText) tLen = maxText;
       rLen  = (rLen + sizeof(kXR_unt32) + tLen + 1 + 7) & ~7;
      }
 
// Get a pointer to the next slot (the buffer gets locked)
//
   oP = (XrdXrootdMonFileOPN *)GetSlot(rLen);
 
// Fill out the record
//
   oP->Hdr.recType = XrdXrootdMonFileHdr::isOpen;
   oP->Hdr.recFlag = (isRW ?  XrdXrootdMonFileHdr::hasRW : 0);
   oP->Hdr.recSize = htons(static_cast<short>(rLen));
   oP->Hdr.fileID  = fsP->FileID;
   oP->fsz         = htonll(fsP->fSize);
 
// Append user and path if so wanted (sizes have been verified).
// The lfn is null padded up to the end of the record.
//
   if (fsLFN)
      {oP->Hdr.recFlag |= XrdXrootdMonFileHdr::hasLFN;
       oP->ufn.user = uDID;
       XrdXrootdMonitor::CopyText(oP->ufn.lfn, rLen - minRecSz - sizeof(kXR_unt32), Path, tLen);
      }
   bfMutex.UnLock();
}

References XrdXrootdMonitor::CopyText(), XrdXrootdFileStats::FileID, XrdXrootdMonFMap::fmShft, XrdXrootdMonFMap::fmSize, XrdXrootdFileStats::fSize, XrdXrootdMonFileOPN::fsz, XrdXrootdMonitor::GetDictID(), XrdXrootdMonFileHdr::hasLFN, XrdXrootdMonFileHdr::hasRW, XrdXrootdMonFileOPN::Hdr, XrdXrootdMonFileHdr::isOpen, XrdXrootdMonFileLFN::lfn, XrdXrootdFileStats::MonEnt, XrdXrootdFileStats::monLvl, Path, XrdXrootdMonFileHdr::recFlag, XrdXrootdMonFileHdr::recSize, XrdXrootdMonFileHdr::recType, XrdXrootdMonFileOPN::ufn, XrdXrootdMonFileLFN::user, and XrdXrootdFileStats::xfrXeq.

Here is the call graph for this function:

---

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

• XrdXrootdMonFile.hh
• XrdXrootdMonFile.cc