Changeset 706:4ffbc9f1e922 in freeDiameter for libfdproto/lists.c

Timestamp:

Feb 9, 2011, 3:26:58 PM (13 years ago)

Author:

Sebastien Decugis <sdecugis@nict.go.jp>

Branch:

default

Phase:

public

Message:

Large UNTESTED commit with the following changes:

• Improved DiameterIdentity? handling (esp. interationalization issues), and improve efficiency of some string operations in peers, sessions, and dictionary modules (closes #7)
• Cleanup in the session module to free only unreferenced sessions (#16)
• Removed fd_cpu_flush_cache(), replaced by more robust alternatives.
• Improved peer state machine algorithm to counter SCTP multistream race condition.

File:

• libfdproto/lists.c (modified) (1 diff)

libfdproto/lists.c

@@ -163 +163 @@
 
 
-/********************************************************************************************************/
-/* Hash function -- credits to Austin Appleby, thank you ^^ */
-/* See http://murmurhash.googlepages.com for more information on this function */
-
-/* the strings are NOT always aligned properly (ex: received in RADIUS message), so we use the aligned MurmurHash2 function as needed */
-#define _HASH_MIX(h,k,m) { k *= m; k ^= k >> r; k *= m; h *= m; h ^= k; }
-uint32_t fd_hash ( char * string, size_t len )
-{
-        uint32_t hash = len;
-        char * data = string;
-        
-        const unsigned int m = 0x5bd1e995;
-        const int r = 24;
-        int align = (long)string & 3;
-        
-        if (!align || (len < 4)) {
-                
-                /* In case data is aligned, MurmurHash2 function */
-                while(len >= 4)
-                {
-                        /* Mix 4 bytes at a time into the hash */
-                        uint32_t k = *(uint32_t *)data; /* We don't care about the byte order */
-
-                        _HASH_MIX(hash, k, m);
-
-                        data += 4;
-                        len -= 4;
-                }
-
-                /* Handle the last few bytes of the input */
-                switch(len) {
-                        case 3: hash ^= data[2] << 16;
-                        case 2: hash ^= data[1] << 8;
-                        case 1: hash ^= data[0];
-                                hash *= m;
-                }
-                
-        } else {
-                /* Unaligned data, use alignment-safe slower version */
-                
-                /* Pre-load the temp registers */
-                uint32_t t = 0, d = 0;
-                switch(align)
-                {
-                        case 1: t |= data[2] << 16;
-                        case 2: t |= data[1] << 8;
-                        case 3: t |= data[0];
-                }
-                t <<= (8 * align);
-
-                data += 4-align;
-                len -= 4-align;
-                
-                /* From this point, "data" can be read by chunks of 4 bytes */
-                
-                int sl = 8 * (4-align);
-                int sr = 8 * align;
-
-                /* Mix */
-                while(len >= 4)
-                {
-                        uint32_t k;
-                        
-                        d = *(unsigned int *)data;
-                        k = (t >> sr) | (d << sl);
-
-                        _HASH_MIX(hash, k, m);
-
-                        t = d;
-
-                        data += 4;
-                        len -= 4;
-                }
-
-                /* Handle leftover data in temp registers */
-                d = 0;
-                if(len >= align)
-                {
-                        uint32_t k;
-                        
-                        switch(align)
-                        {
-                        case 3: d |= data[2] << 16;
-                        case 2: d |= data[1] << 8;
-                        case 1: d |= data[0];
-                        }
-
-                        k = (t >> sr) | (d << sl);
-                        _HASH_MIX(hash, k, m);
-
-                        data += align;
-                        len -= align;
-
-                        /* Handle tail bytes */
-
-                        switch(len)
-                        {
-                        case 3: hash ^= data[2] << 16;
-                        case 2: hash ^= data[1] << 8;
-                        case 1: hash ^= data[0];
-                                        hash *= m;
-                        };
-                }
-                else
-                {
-                        switch(len)
-                        {
-                        case 3: d |= data[2] << 16;
-                        case 2: d |= data[1] << 8;
-                        case 1: d |= data[0];
-                        case 0: hash ^= (t >> sr) | (d << sl);
-                                        hash *= m;
-                        }
-                }
-
-
-        }
-
-        /* Do a few final mixes of the hash to ensure the last few
-           bytes are well-incorporated. */
-        hash ^= hash >> 13;
-        hash *= m;
-        hash ^= hash >> 15;
-
-        return hash;
-}