Darwin中OSRef和OSHashTable类的使用

最新推荐文章于 2017-12-04 13:53:18 发布

Arno_Wang

最新推荐文章于 2017-12-04 13:53:18 发布

阅读量894

点赞数 3

文章标签： Darwin EasyDarwin OSRef OSHashTable

本文链接：https://blog.csdn.net/wq5866280/article/details/50435974

版权

//哈希表被设计成模版类的形式

template<class T, class K>

class OSHashTable {

public:

OSHashTable( UInt32 size ) //构造函数

{

fHashTable = new ( T*[size] );//初始化大小

Assert( fHashTable );

memset( fHashTable, 0, sizeof(T*) * size );//设置初始值

fSize = size;

/*下面的代码决定用哪种方式为哈希表的键值计算索引；

如果哈希表的大小不是2的幂，只好采用对fSize求余的方法；

否则可以直接用掩码的方式，这种方式相对速度更快*/

fMask = fSize - 1;

if((fMask & fSize) != 0)//判断是不是2的幂，确定使用何种哈希函数（ComputeIndex）

fMask = 0;

fNumEntries = 0;

}

~OSHashTable() //析构

{

delete [] fHashTable;

}

voidAdd( T* entry ) { //加入元素，有标记代码可以看出，此处解决冲突的方式采用了链地址法

Assert( entry->fNextHashEntry == NULL );

Kkey( entry );

UInt32 theIndex = ComputeIndex( key.GetHashKey() );

entry->fNextHashEntry = fHashTable[theIndex ];

fHashTable[ theIndex ] = entry;

fNumEntries++;

}

voidRemove( T* entry )//移除元素

{

Kkey( entry );

UInt32 theIndex = ComputeIndex( key.GetHashKey() );

T*elem = fHashTable[ theIndex ];

T*last = NULL;

while (elem && elem != entry) {

last = elem;

elem = elem->fNextHashEntry;

}

if( elem ) // sometimes remove is called 2x ( swap, then un register )

{

Assert(elem);

if (last)

last->fNextHashEntry = elem->fNextHashEntry;

else

fHashTable[ theIndex ] =elem->fNextHashEntry;

elem->fNextHashEntry = NULL;

fNumEntries--;

}

T* Map(K* key ) //查找对象

{

UInt32 theIndex = ComputeIndex( key->GetHashKey() );

T*elem = fHashTable[ theIndex ];

while (elem) {

K elemKey( elem );

if (elemKey == *key)

break;

elem = elem->fNextHashEntry;

}

return elem;

}

UInt64GetNumEntries() { return fNumEntries; }

UInt32GetTableSize() { return fSize; }

T*GetTableEntry( int i ) { return fHashTable[i]; }

private:

T**fHashTable;

UInt32fSize;

UInt32fMask;

UInt64fNumEntries;

UInt32 ComputeIndex(UInt32 hashKey )

{

if (fMask)

return( hashKey & fMask );//掩码方式

else

return( hashKey % fSize );// 除留取余法

}

};

//实现了一个hash表迭代器的功能

template<class T, class K>

class OSHashTableIter {

public:

OSHashTableIter( OSHashTable<T,K>* table )

{

fHashTable = table;

First();

}

voidFirst()

{

for(fIndex = 0; fIndex < fHashTable->GetTableSize(); fIndex++) {

fCurrent = fHashTable->GetTableEntry( fIndex );

if (fCurrent)

break;

}

voidNext()

{

fCurrent = fCurrent->fNextHashEntry;

if(!fCurrent) {

for (fIndex = fIndex + 1; fIndex < fHashTable->GetTableSize();fIndex++) {

fCurrent =fHashTable->GetTableEntry( fIndex );

if (fCurrent)

break;

}

Bool16IsDone()

{

return( fCurrent == NULL );

}

T*GetCurrent() { return fCurrent; }

private:

OSHashTable<T,K>* fHashTable;

T*fCurrent;

UInt32fIndex;

class OSRefKey;
class OSRefTableUtils
{
   private:
       static UInt32  HashString(StrPtrLen* inString);   
       friend class OSRef;
       friend class OSRefKey;
};
class OSRef
{
    public:
       OSRef() :   fObjectP(NULL),fRefCount(0), fNextHashEntry(NULL)
           {    
           }
       OSRef(const StrPtrLen &inString, void* inObjectP)
                                : fRefCount(0),fNextHashEntry(NULL)
                                    {   Set(inString, inObjectP); }
       ~OSRef() {}
        void Set(const StrPtrLen& inString,void* inObjectP)
           {     
               fString = inString; fObjectP = inObjectP;
               fHashValue = OSRefTableUtils::HashString(&fString);
           }
       void**  GetObjectPtr()  { return &fObjectP; }
       void*   GetObject()     { return fObjectP; }
       UInt32  GetRefCount()   { return fRefCount; }
       StrPtrLen *GetString()  { return&fString; }
   private:
       //value
       void*   fObjectP;
       //key
       StrPtrLen   fString;
       //refcounting
        UInt32  fRefCount;
#if DEBUG
       Bool16  fInATable;
       Bool16  fSwapCalled;
#endif
       OSCond  fCond;//to block threadswaiting for this ref.
       UInt32              fHashValue;
       OSRef*             fNextHashEntry;
        friend class OSRefKey;
       friend class OSHashTable<OSRef, OSRefKey>;
       friend class OSHashTableIter<OSRef, OSRefKey>;
       friend class OSRefTable;
};
class OSRefKey
{
public:
   //CONSTRUCTOR / DESTRUCTOR:
   OSRefKey(StrPtrLen* inStringP)
       :   fStringP(inStringP)
         {fHashValue = OSRefTableUtils::HashString(inStringP); }
   ~OSRefKey() {}
   //ACCESSORS:
   StrPtrLen*  GetString()         { return fStringP; }
private:
   //PRIVATE ACCESSORS:   
   SInt32      GetHashKey()        { return fHashValue; }
    //thesefunctions are only used by the hash table itself. This constructor
    //willbreak the "Set" functions.
   OSRefKey(OSRef *elem) : fStringP(&elem->fString),
                           fHashValue(elem->fHashValue) {}                  
    friendint operator ==(const OSRefKey &key1, const OSRefKey &key2)
    {
        if(key1.fStringP->Equal(*key2.fStringP))
           return true;
       return false;
    }
    //data:
   StrPtrLen *fStringP;
   UInt32  fHashValue;
    friendclass OSHashTable<OSRef, OSRefKey>;
};
typedef OSHashTable<OSRef, OSRefKey>OSRefHashTable;
typedef OSHashTableIter<OSRef, OSRefKey>OSRefHashTableIter;
class OSRefTable
{
    public:
       enum
        {
           kDefaultTableSize = 1193 //UInt32
        };
       //tableSize doesn't indicate the max number of Refs that can be added
       //(it's unlimited), but is rather just how big to make the hash table
       OSRefTable(UInt32 tableSize = kDefaultTableSize) : fTable(tableSize),fMutex() {}
       ~OSRefTable() {}
       //Allows access to the mutex in case you need to lock the table down
       //between operations
       OSMutex*    GetMutex()      { return &fMutex; }
       OSRefHashTable* GetHashTable() { return &fTable; 
       //Registers a Ref in the table. Once the Ref is in, clients may resolve
       //the ref by using its string ID. You must setup the Ref before passingit
       //in here, ie., setup the string and object pointers
       //This function will succeed unless the string identifier is not unique,
       //in which case it will return QTSS_DupName
        //This function is atomic wrt this reftable.
       OS_Error        Register(OSRef*ref);
        //RegisterOrResolve
        //If the ID of the input ref is unique, this function is equivalent to
        //Register, and returns NULL.
        // If there is a duplicate ID already inthe map, this funcion
        //leave it, resolves it, and returns it.
       OSRef*             RegisterOrResolve(OSRef* inRef);
       //This function may block. You can only remove a Ref from the table
       //when the refCount drops to the level specified. If several threadshave
       //the ref currently, the calling thread will wait until the otherthreads
       //stop using the ref (by calling Release, below)
       //This function is atomic wrt this ref table.
       void        UnRegister(OSRef* ref,UInt32 refCount = 0);
        //Same as UnRegister, but guarenteed not to block. Will return
        //true if ref was sucessfully unregistered, false otherwise
       Bool16      TryUnRegister(OSRef*ref, UInt32 refCount = 0);
       //Resolve. This function uses the provided key string to identify andgrab
       //the Ref keyed by that string. Once the Ref is resolved, it is safe touse
       //(it cannot be removed from the Ref table) until you call Release.Because
       //of that, you MUST call release in a timely manner, and be aware ofpotential
       //deadlocks because you now own a resource being contended over.
       //This function is atomic wrt this ref table.
       OSRef*     Resolve(StrPtrLen*  inString);
       //Release. Release a Ref, and drops its refCount. After calling this,the
       //Ref is no longer safe to use, as it may be removed from the ref table.
        void       Release(OSRef*  inRef);
        //Swap. This atomically removes any existing Ref in the table with the new
        //ref's ID, and replaces it with this new Ref. If there is no matching Ref
        //already in the table, this function does nothing.
        //
        //Be aware that this creates a situation where clients may have a Ref resolved
        //that is no longer in the table. The old Ref must STILL be UnRegisterednormally.
        //Once Swap completes sucessfully, clients that call resolve on the ID will get
        //the new OSRef object.
       void        Swap(OSRef* newRef);
       UInt32      GetNumRefsInTable() {UInt64 result =  fTable.GetNumEntries();Assert(result < kUInt32_Max); return (UInt32) result; }
   private:
       //all this object needs to do its job is an atomic hashtable
       OSRefHashTable  fTable;
       OSMutex         fMutex;
};
class OSRefReleaser
{
    public:
       OSRefReleaser(OSRefTable* inTable, OSRef* inRef) : fOSRefTable(inTable),fOSRef(inRef) {}
       ~OSRefReleaser() { fOSRefTable->Release(fOSRef); }
       OSRef*          GetRef() { returnfOSRef; }
   private:
       OSRefTable*     fOSRefTable;
       OSRef*          fOSRef;
};

};

引用表头文件定义，详细的代码请参考源码，此处只结合实例讲解几个主要的函数

//结合实例说明常用的方法

服务器网络模型中有个很重要的类EventContext, EventContext.h中包含EventContext类和EventThread类的定义

每一个EventContext类中都有一个引用对象，如下图

在每次执行RequestEvent函数时，就会执行以下代码（EventContext.cpp182行）

if (!compare_and_store(8192, WM_USER,&sUniqueID))

fUniqueID = (PointerSizedInt)atomic_add(&sUniqueID, 1); //获取一个唯一标识

fRef.Set(fUniqueIDStr, this);//对引用对象赋值

void Set(const StrPtrLen&inString, void* inObjectP)

{

fString = inString; fObjectP =inObjectP;

fHashValue =OSRefTableUtils::HashString(&fString);

}

fString作为索引，fObjectP保存对象，fHashValue根据索引计算出一个hash值

fEventThread->fRefTable.Register(&fRef);//把这个引用对象加入到EventThread中的引用表中（其实就是hash表），fRefTable是OSRefTable类的实例，而类中操作的表是OSRefHashTable类型（typedef OSHashTable<OSRef, OSRefKey>OSRefHashTable;）

OS_ErrorOSRefTable::Register(OSRef* inRef)

{

if (inRef == NULL)

return EPERM;

OSMutexLocker locker(&fMutex);

if (inRef->fString.Ptr == NULL || inRef->fString.Len == 0)

{ return EPERM;

}

// Check for a duplicate. In this function, if there is a duplicate,

// return an error, don't resolve the duplicate

OSRefKey key(&inRef->fString);

OSRef* duplicateRef = fTable.Map(&key);//查找有没有重复的，没有则加入到hash表中