#ifndef __XRDCMSRRQ_HH__
#define __XRDCMSRRQ_HH__
/******************************************************************************/
/* */
/* X r d C m s R R Q . h h */
/* */
/* (c) 2007 by the Board of Trustees of the Leland Stanford, Jr., University */
/* All Rights Reserved */
/* Produced by Andrew Hanushevsky for Stanford University under contract */
/* DE-AC02-76-SFO0515 with the Department of Energy */
/* */
/* 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 . */
/* */
/* 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. */
/******************************************************************************/
#include
#include "XProtocol/XPtypes.hh"
#include "XProtocol/YProtocol.hh"
#include "XrdCms/XrdCmsTypes.hh"
#include "XrdOuc/XrdOucDLlist.hh"
#include "XrdSys/XrdSysPthread.hh"
/******************************************************************************/
/* X r d C m s R R Q I n f o */
/******************************************************************************/
class XrdCmsRRQInfo
{
public:
void *Key; // Key link, which is the cache line address
kXR_unt32 ID; // Response link, which is the request ID
int Rinst; // Redirector instance
short Rnum; // Redirector number (RTable slot number)
char isRW; // True if r/w access wanted
char isLU; // True if locate response wanted
char minR; // Minimum number of responses for fast redispatch
char actR; // Actual number of responses
char lsLU; // Lookup options
char ifOP; // XrdNetIF::ifType to return (cast as char)
SMask_t rwVec; // R/W servers for corresponding path (if isLU is true)
XrdCmsRRQInfo() : isLU(0), ifOP(0) {}
XrdCmsRRQInfo(int rinst, short rnum, kXR_unt32 id, int minQ=0)
: Key(0), ID(id), Rinst(rinst), Rnum(rnum),
isRW(0), isLU(0), minR(minQ), actR(0), lsLU(0), ifOP(0),
rwVec(0) {}
~XrdCmsRRQInfo() {}
};
/******************************************************************************/
/* X r d C m s R R Q S l o t */
/******************************************************************************/
class XrdCmsRRQSlot
{
friend class XrdCmsRRQ;
static XrdCmsRRQSlot *Alloc(XrdCmsRRQInfo *Info);
void Recycle();
XrdCmsRRQSlot();
~XrdCmsRRQSlot() {}
private:
static XrdSysMutex myMutex;
static XrdCmsRRQSlot *freeSlot;
static short initSlot;
XrdOucDLlist Link;
XrdCmsRRQSlot *Cont;
XrdCmsRRQSlot *LkUp;
XrdCmsRRQInfo Info;
SMask_t Arg1;
SMask_t Arg2;
unsigned int Expire;
int slotNum;
};
/******************************************************************************/
/* X r d C m s R R Q */
/******************************************************************************/
class XrdCmsRRQ
{
public:
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();
struct Info
{
Info()
{Reset();}
void Reset()
{Add2Q = 0;
PBack = 0;
Resp = 0;
Multi = 0;
luFast = 0;
luSlow = 0;
rdFast = 0;
rdSlow = 0;
}
long long Add2Q; // Number added to queue
long long PBack; // Number that we could piggy-back
long long Resp; // Number of reponses for a waiting request
long long Multi; // Number of multiple response fielded
long long luFast; // Fast lookups
long long luSlow; // Slow lookups
long long rdFast; // Fast redirects
long long rdSlow; // Slow redirects
};
void Statistics(Info &Data) {myMutex.Lock(); Data = Stats; myMutex.UnLock();}
void *TimeOut();
XrdCmsRRQ() : isWaiting(0), isReady(0),
luFast(0), luSlow(0), rdFast(0), rdSlow(0),
Tslice(178), Tdelay(5), myClock(0) {}
~XrdCmsRRQ() {}
private:
void sendLocResp(XrdCmsRRQSlot *lP);
void sendLwtResp(XrdCmsRRQSlot *rP);
void sendRedResp(XrdCmsRRQSlot *rP);
static const int numSlots = 1024;
XrdSysMutex myMutex;
XrdSysSemaphore isWaiting;
XrdSysSemaphore isReady;
XrdCmsRRQSlot Slot[numSlots];
XrdOucDLlist waitQ;
XrdOucDLlist readyQ; // Redirect/Locate ready queue
static const int iov_cnt = 2;
struct iovec data_iov[iov_cnt];
struct iovec redr_iov[iov_cnt];
XrdCms::CmsResponse dataResp;
XrdCms::CmsResponse redrResp;
XrdCms::CmsResponse waitResp;
union {char hostbuff[288];
char databuff[XrdCms::CmsLocateRequest::RHLen
*STMax];
};
Info Stats;
int luFast;
int luSlow;
int rdFast;
int rdSlow;
int Tslice;
int Tdelay;
unsigned int myClock;
};
namespace XrdCms
{
extern XrdCmsRRQ RRQ;
}
#endif