XrdSsiRRTable< T > Class Template Reference

#include <XrdSsiRRTable.hh>

Collaboration diagram for XrdSsiRRTable< T >:

Public Member Functions
	XrdSsiRRTable ()
	~XrdSsiRRTable ()
XrdSsiRRTableItem< T >	Add (T *item, uint64_t itemID)
void	Clear ()
bool	DeferFinalize (T *item, uint64_t itemID)
void	DeferredFinalizeDone (T *item, uint64_t itemID)
void	Del (uint64_t itemID)
void	DelFinalize (XrdSsiRRTableItem< T > &&r)
XrdSsiRRTableItem< T >	LookUp (uint64_t itemID)
int	Num ()
void	Release (T *item, uint64_t itemID)
void	Reset ()

Detailed Description

template<class T>
class XrdSsiRRTable< T >

Definition at line 85 of file XrdSsiRRTable.hh.

Constructor & Destructor Documentation

XrdSsiRRTable()

template<class T>

XrdSsiRRTable< T >::XrdSsiRRTable ( )

inline

Definition at line 240 of file XrdSsiRRTable.hh.

: baseKey(0), wCond(0), nDef(0) {}

~XrdSsiRRTable()

template<class T>

XrdSsiRRTable< T >::~XrdSsiRRTable ( )

inline

Definition at line 242 of file XrdSsiRRTable.hh.

{Reset();}

References Reset().

Here is the call graph for this function:

Member Function Documentation

Add()

template<class T>

XrdSsiRRTableItem< T > XrdSsiRRTable< T >::Add ( T * item, uint64_t itemID )

inline

Definition at line 91 of file XrdSsiRRTable.hh.

         {XrdSsiMutexMon lck(rrtMutex);
          if ((baseItem.item && baseKey == itemID)
          || theMap.count(itemID))
             {return XrdSsiRRTableItem<T>();}
          if (baseItem.item == 0)
             {baseItem.Init(item, 2);
              baseKey = itemID;
              return XrdSsiRRTableItem(item, this, itemID);
             }
          theMap[itemID].Init(item, 2);
          return XrdSsiRRTableItem(item, this, itemID);
         }

Clear()

template<class T>

void XrdSsiRRTable< T >::Clear ( )

inline

Definition at line 105 of file XrdSsiRRTable.hh.

{rrtMutex.Lock(); theMap.clear(); baseItem.item = 0; rrtMutex.UnLock();}

DeferFinalize()

template<class T>

bool XrdSsiRRTable< T >::DeferFinalize ( T * item, uint64_t itemID )

inline

Definition at line 112 of file XrdSsiRRTable.hh.

            {XrdSsiMutexMon lck(rrtMutex);
             if (baseItem.item && baseKey == itemID)
                {if (baseItem.item != item) return false;
                 baseItem.deferedFinalize = true;
                 return true;
                }
             typename std::map<uint64_t,ItemInfo>::iterator it = theMap.find(itemID);
             if (it == theMap.end()) return false;
             ItemInfo &info = it->second;
             if (info.item != item) return false;
             info.deferedFinalize = true;
             return true;
            }

DeferredFinalizeDone()

template<class T>

void XrdSsiRRTable< T >::DeferredFinalizeDone ( T * item, uint64_t itemID )

inline

Definition at line 129 of file XrdSsiRRTable.hh.

            {XrdSsiMutexMon lck(rrtMutex);
             wCond.Lock();
             nDef--;
             wCond.Broadcast();
             wCond.UnLock();
             if (baseItem.item && baseKey == itemID)
             {
               if (baseItem.item != item) return;
               baseItem.item = 0;
               return;
             }
             typename std::map<uint64_t,ItemInfo>::iterator it = theMap.find(itemID);
             if (it == theMap.end()) return;
             ItemInfo &info = it->second;
             if (info.item != item) return;
             theMap.erase(it);
            }

Referenced by Reset().

Here is the caller graph for this function:

Del()

template<class T>

void XrdSsiRRTable< T >::Del ( uint64_t itemID )

inline

Definition at line 151 of file XrdSsiRRTable.hh.

{Decr(itemID, true);}

DelFinalize()

template<class T>

void XrdSsiRRTable< T >::DelFinalize ( XrdSsiRRTableItem< T > && r )

inline

Definition at line 155 of file XrdSsiRRTable.hh.

            {if (!r) return;
             uint64_t itemID = r.reqID();
             T* item = r.release();
             Decr(itemID, true, item, true, 1);
             XrdSsiMutexMon lck(rrtMutex);
             while((baseItem.item && baseKey == itemID) ||
                    theMap.count(itemID))
                {wCond.Lock();
                 lck.UnLock();
                 do { wCond.Wait(); } while(nDef>0);
                 wCond.UnLock();
                 lck.Lock(&rrtMutex);
                }
            }

References XrdSsiMutexMon::Lock(), and XrdSsiMutexMon::UnLock().

Here is the call graph for this function:

LookUp()

template<class T>

XrdSsiRRTableItem< T > XrdSsiRRTable< T >::LookUp ( uint64_t itemID )

inline

Definition at line 177 of file XrdSsiRRTable.hh.

            {XrdSsiMutexMon lck(rrtMutex);
             if (baseItem.item && baseKey == itemID)
                {if (baseItem.deleted) return XrdSsiRRTableItem<T>();
                 baseItem.refcount++;
                 return XrdSsiRRTableItem(baseItem.item, this, itemID);
                }
             typename std::map<uint64_t,ItemInfo>::iterator it = theMap.find(itemID);
             if (it == theMap.end()) return XrdSsiRRTableItem<T>();
             ItemInfo &info = it->second;
             if (info.deleted) return XrdSsiRRTableItem<T>();
             info.refcount++;
             return XrdSsiRRTableItem(info.item, this, itemID);
            }

Num()

template<class T>

int XrdSsiRRTable< T >::Num ( )

inline

Definition at line 192 of file XrdSsiRRTable.hh.

{return theMap.size() + (baseItem.item ? 1 : 0);}

Release()

template<class T>

void XrdSsiRRTable< T >::Release ( T * item, uint64_t itemID )

inline

Definition at line 171 of file XrdSsiRRTable.hh.

{Decr(itemID, false, item, false, 1);}

Reset()

template<class T>

void XrdSsiRRTable< T >::Reset ( )

inline

Definition at line 197 of file XrdSsiRRTable.hh.

         {XrdSsiMutexMon lck(rrtMutex);
          std::vector<std::pair<T*,uint64_t>> tofin;
          if (baseItem.item && baseItem.refcount > 0)
             {if (!baseItem.deleted)
                {baseItem.deleted = true;
                 baseItem.refcount--;
                 baseItem.deferedFinalize = true;
                }
              if (baseItem.refcount <= 0)
                {tofin.push_back(std::make_pair(baseItem.item,baseKey));}
             }
          for(auto it=theMap.begin(); it!=theMap.end(); ++it)
            {ItemInfo &info = it->second;
             if (info.refcount <= 0) continue;
             if (!info.deleted)
               {info.deleted = true;
                info.refcount--;
                info.deferedFinalize=true;
               }
             if (info.refcount <= 0) tofin.push_back(std::make_pair(info.item,it->first));
            }
          lck.UnLock();
          for(auto &fpair : tofin)
            {T* f=fpair.first;
             uint64_t itemID=fpair.second;
             wCond.Lock();
             nDef++;
             wCond.UnLock();
             f->Finalize();
             DeferredFinalizeDone(f, itemID);
            }
 
          lck.Lock(&rrtMutex);
          while(baseItem.item || theMap.size() != 0)
            {wCond.Lock();
             lck.UnLock();
             do { wCond.Wait(); } while(nDef>0);
             wCond.UnLock();
             lck.Lock(&rrtMutex);
            }
         }

References DeferredFinalizeDone(), XrdSsiMutexMon::Lock(), and XrdSsiMutexMon::UnLock().

Referenced by ~XrdSsiRRTable().

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• XrdSsiRRTable.hh