XrdCmsRRQ Class Reference

#include <XrdCmsRRQ.hh>

Collaboration diagram for XrdCmsRRQ:

Classes
struct	Info

Public Member Functions
	XrdCmsRRQ ()
	~XrdCmsRRQ ()
short	Add (short Snum, XrdCmsRRQInfo *ip)
void	Del (short Snum, const void *Key)
int	Init (int Tint=0, int Tdly=0)
int	Ready (int Snum, const void *Key, SMask_t mask1, SMask_t mask2)
void *	Respond ()
void	Statistics (Info &Data)
void *	TimeOut ()

Detailed Description

Definition at line 104 of file XrdCmsRRQ.hh.

Constructor & Destructor Documentation

XrdCmsRRQ()

XrdCmsRRQ::XrdCmsRRQ ( )

inline

Definition at line 148 of file XrdCmsRRQ.hh.

                  : isWaiting(0), isReady(0),
                    luFast(0),    luSlow(0),  rdFast(0), rdSlow(0),
                    Tslice(178),  Tdelay(5),  myClock(0) {}

~XrdCmsRRQ()

XrdCmsRRQ::~XrdCmsRRQ ( )

inline

Definition at line 151 of file XrdCmsRRQ.hh.

{}

Member Function Documentation

Add()

short XrdCmsRRQ::Add	(	short	Snum,
		XrdCmsRRQInfo *	ip )

Definition at line 76 of file XrdCmsRRQ.cc.

{
// EPNAME("RRQ Add");
   XrdCmsRRQSlot *sp;
 
// Obtain a slot and fill it in
//
   if (!(sp = XrdCmsRRQSlot::Alloc(Info))) return 0;
// DEBUG("adding slot " <<sp->slotNum);
 
// If a slot number given, check if it's the right slot and it is still queued.
// If so, piggy-back this request to existing one and make a fast exit
//
   myMutex.Lock(); Stats.Add2Q++;
   if (Snum && Slot[Snum].Info.Key == Info->Key && Slot[Snum].Expire)
      {if (Info->isLU)
          {sp->LkUp = Slot[Snum].LkUp;
           Slot[Snum].LkUp = sp;
          } else {
           sp->Cont = Slot[Snum].Cont;
           Slot[Snum].Cont = sp;
          }
       Stats.PBack++;
       myMutex.UnLock();
       return Snum;
      }
 
// Queue this slot to the pending response queue and tell the timeout scheduler
//
   sp->Expire = myClock+1;
   if (waitQ.Singleton()) isWaiting.Post();
   waitQ.Prev()->Insert(&sp->Link);
   myMutex.UnLock();
   return sp->slotNum;
}

Del()

void XrdCmsRRQ::Del	(	short	Snum,
		const void *	Key )

Definition at line 116 of file XrdCmsRRQ.cc.

{
     Ready(Snum, Key, 0, 0);
}

References Ready().

Here is the call graph for this function:

Init()

int XrdCmsRRQ::Init	(	int	Tint = 0,
		int	Tdly = 0 )

Definition at line 125 of file XrdCmsRRQ.cc.

{
   int rc;
   pthread_t tid;
 
// Set values
//
   if (Tint) Tslice = Tint;
   if (Tdly) Tdelay = Tdly;
   Stats.Reset();
 
// Fill out the response structure
//
   dataResp.Hdr.streamid = 0;
   dataResp.Hdr.rrCode   = kYR_data;
   dataResp.Hdr.modifier = 0;
   dataResp.Hdr.datalen  = 0;
   dataResp.Val          = 0;
 
// Fill out the data i/o vector
//
   data_iov[0].iov_base = (char *)&dataResp;
   data_iov[0].iov_len  = sizeof(dataResp);
   data_iov[1].iov_base = databuff;;
 
// Fill out the response structure
//
   redrResp.Hdr.streamid = 0;
   redrResp.Hdr.rrCode   = kYR_redirect;
   redrResp.Hdr.modifier = 0;
   redrResp.Hdr.datalen  = 0;
   redrResp.Val          = 0;
 
// Fill out the redirect i/o vector
//
   redr_iov[0].iov_base = (char *)&redrResp;
   redr_iov[0].iov_len  = sizeof(redrResp);
   redr_iov[1].iov_base = hostbuff;;
 
// Fill out the wait info
//
   waitResp.Hdr.streamid = 0;
   waitResp.Hdr.rrCode   = kYR_wait;
   waitResp.Hdr.modifier = 0;
   waitResp.Hdr.datalen  = htons(static_cast<unsigned short>(sizeof(waitResp.Val)));
   waitResp.Val          = htonl(Tdelay);
 
// Start the responder thread
//
   if ((rc = XrdSysThread::Run(&tid, XrdCmsRRQ_StartRespond, (void *)0,
                               0, "Request Responder")))
      {Say.Emsg("Config", rc, "create request responder thread");
       return 1;
      }
 
// Start the timeout thread
//
   if ((rc = XrdSysThread::Run(&tid, XrdCmsRRQ_StartTimeOut, (void *)0,
                               0, "Request Timeout")))
      {Say.Emsg("Config", rc, "create request timeout thread");
       return 1;
      }
 
// All done
//
   return 0;
}

References XrdCms::kYR_data, XrdCms::kYR_redirect, XrdCms::kYR_wait, XrdSysThread::Run(), XrdCms::Say, XrdCmsRRQ_StartRespond(), and XrdCmsRRQ_StartTimeOut().

Here is the call graph for this function:

Ready()

int XrdCmsRRQ::Ready	(	int	Snum,
		const void *	Key,
		SMask_t	mask1,
		SMask_t	mask2 )

Definition at line 197 of file XrdCmsRRQ.cc.

{
// EPNAME("RRQ Ready");
   XrdCmsRRQSlot *sp;
 
// Check if it's the right slot and it is still queued.
//
   myMutex.Lock();
   sp = &Slot[Snum];
   if (sp->Info.Key != Key || !sp->Expire)
      {myMutex.UnLock();
//     DEBUG("slot " <<Snum <<" no longer valid");
       return 1;
      }
 
// Update the arguments. The first is the running node mask and the second is
// a fixed differentiation mask. Accumulate the 1st but replace the 2nd.
//
   sp->Arg1 |= mask1; sp->Arg2 = mask2;
   Stats.Resp++;
 
// Check if we should still hold on to this slot because the number of actual
// responders is less than the number needed.
//
   if (sp->Info.actR < sp->Info.minR)
      {sp->Info.actR++; Stats.Multi++;
       myMutex.UnLock();
       return 0;
      }
 
// Move the element from the waiting queue to the ready queue
//
   sp->Link.Remove();
   if (readyQ.Singleton()) isReady.Post();
   readyQ.Prev()->Insert(&sp->Link);
   myMutex.UnLock();
// DEBUG("readied slot " <<Snum <<" mask " <<mask);
   return 1;
}

References XrdCmsRRQInfo::actR, XrdCmsRRQInfo::Key, XrdCmsRRQInfo::minR, and XrdOucDLlist< T >::Remove().

Referenced by Del().

Here is the call graph for this function:

Here is the caller graph for this function:

Respond()

void * XrdCmsRRQ::Respond

(

)

Definition at line 241 of file XrdCmsRRQ.cc.

{
// EPNAME("RRQ Respond");
   XrdCmsRRQSlot *sp;
 
// In an endless loop, process all ready elements
//
   do {isReady.Wait();     // DEBUG("responder awoken");
   do {myMutex.Lock();
       Stats.rdFast += rdFast; Stats.rdSlow += rdSlow;
       Stats.luFast += luFast; Stats.luSlow += luSlow;
       if (readyQ.Singleton()) {myMutex.UnLock(); break;}
       sp = readyQ.Next()->Item(); sp->Link.Remove(); sp->Expire = 0;
       myMutex.UnLock();
 
    // A locate request can be pggy-backed on a select request and vice-versa
    // We separate the two queues here as each has a different response.
    //
       if (sp->Info.isLU)
          {if (sp->Cont)
              {sp->Cont->Arg1 = sp->Arg1;
               sendRedResp(sp->Cont);
              }
           sendLocResp(sp);
          } else {
           if (sp->LkUp)
              {sp->LkUp->Arg1 = sp->Arg1; sp->LkUp->Arg2 = sp->Arg2;
               sendLocResp(sp->LkUp);
              }
           sendRedResp(sp);
          }
       sp->Recycle();
      } while(1);
      } while(1);
 
// Keep the compiler happy
//
   return (void *)0;
}

References XrdCmsRRQInfo::isLU, and XrdOucDLlist< T >::Remove().

Here is the call graph for this function:

Statistics()

void XrdCmsRRQ::Statistics ( Info & Data )

inline

Definition at line 144 of file XrdCmsRRQ.hh.

{myMutex.Lock(); Data = Stats; myMutex.UnLock();}

TimeOut()

void * XrdCmsRRQ::TimeOut

(

)

Definition at line 398 of file XrdCmsRRQ.cc.

{
// EPNAME("RRQ TimeOut");
   XrdCmsRRQSlot *sp;
 
// We measure millisecond intervals to timeout waiting requests. We used to zero
// out arg1/2 to force expiration, but they would be zero anyway if no responses
// occurred. Now with qdn we need to leave them alone as we may have deferred
// a fast dispatch because we were waiting for more than one responder.
//
   while(1)
        {isWaiting.Wait();
         myMutex.Lock();
         while(1)
              {myClock++;
               myMutex.UnLock();
               XrdSysTimer::Wait(Tslice);
               myMutex.Lock();
               while((sp=waitQ.Next()->Item()) && sp->Expire < myClock)
                    {sp->Link.Remove();
                     if (readyQ.Singleton()) isReady.Post();
//                   sp->Arg1 = 0; sp->Arg2 = 0;
//                   DEBUG("expired slot " <<sp->slotNum);
                     readyQ.Prev()->Insert(&sp->Link);
                    }
               if (waitQ.Singleton()) break;
              }
         myMutex.UnLock();
        }
 
// Keep the compiler happy
//
   return (void *)0;
}

References XrdOucDLlist< T >::Remove(), and XrdSysTimer::Wait().

Here is the call graph for this function:

---

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

• XrdCmsRRQ.hh
• XrdCmsRRQ.cc