string_nhash_8 converts 4 bytes from string to a integer.
These 4 bytes could be at any location. The location may or may not be aligned
to 4 byte (integer size) boundary.  On x86, unaligned access by default is
allowed, but on sparc, it results in SIGBUG. On sparc architecture
-xmemalign=1i can be used to compile this file but it would deteriorate the
performance.

Here is the suggested fix (use memcpy to make sure unaligned access works
fine):

--- APC-3.0.19/apc_cache.c.ORIG Sat Dec 20 22:00:47 2008
+++ APC-3.0.19/apc_cache.c      Sat Dec 20 21:59:49 2008
@@ -69,7 +69,9 @@
     register const unsigned int *e  = (const unsigned int *)(s + len - (len % sizeof(unsigned int)));
 
     for(;iv<e;iv++) {
-        h += *iv;
+        register unsigned int h1 = 0;
+        memcpy(&h1, iv, sizeof(unsigned int));
+        h += h1;
         h = (h << 7) | (h >> ((8*sizeof(unsigned int)) - 7));
     }
     s = (const char *)iv;
-------------------------------------------------------------

I could have used something like :

     int aligned = iv % sizeof(unsigned int);
     for(;iv<e;iv++) {
         if(aligned) {
             h += *iv;
         } else
             register unsigned int h1 = 0;
             memcpy(&h1, iv, sizeof(unsigned int));
             h += h1;
         }
         h = (h << 7) | (h >> ((8*sizeof(unsigned int)) - 7));
     }

I believe, adding a branch instruction for aligned case won't gain us much
performance.

aligned calculation was wrong. I wanted to write :
     int aligned = (iv % sizeof(unsigned int)) == 0;
...

I'd rather write something like

switch(len & (sizeof(unsigned int*)-1)) {
   case 8:
   case 7:
... 
   case 0:
   default:
}

len = len & sizeof(unsigned int*);

and write out fall-through cases for that, than write a branch-loop.

Could you test this one, I think on a little endian platform it should perform identical to the older one.

/* {{{ string_nhash_8 */
static unsigned int string_nhash_8(const char *s, size_t len)
{
	const unsigned int wsize = sizeof(unsigned int);
    register unsigned int h = 0;
	const char * ev = s + len;
	register unsigned t = 0;

	switch(len % wsize) {
			case 0: do { 
					h = (h << 7) | (h >> (8*wsize - 7));
					t = (t << 4) | *(s++);
			case 7: t = (t << 4) | *(s++);
			case 6:	t = (t << 4) | *(s++);
			case 5:	t = (t << 4) | *(s++);
			case 4:	t = (t << 4) | *(s++);
			case 3:	t = (t << 4) | *(s++);
			case 2:	t = (t << 4) | *(s++);
			case 1:	t = (t << 4) | *(s++);

			h += t;
			t = 0;
			} while(s < ev);
	};

    h ^= (h >> 13);
    h ^= (h >> 7);

    return h;
}
/* }}} */

Hi gopal,
  As your switch and do-while loop's begin/end mismatches so I am unable to understand your logic.
case 1 to case 7 are inside while loop while case 0 is outside so it is confusing.

Hi Gopal,
   I tried to experiment with your code. I now understand little better. For case 0, case statement will fall back 8 times and goes out of string boundary. E.g I debugged the case for
string_nhash_8("abcd", 4). It executed the following line 8 times which is incorrect.
 t = (t << 4) | *(s++);


Breakpoint 1, string_nhash_8x (s=0x400eab "abcd", len=4) at stringnhash.c:150
150		const unsigned int wsize = sizeof(unsigned int);
Missing separate debuginfos, use: debuginfo-install glibc.x86_64
(gdb) n
151	    register unsigned int h = 0;
(gdb) n
152		const char * ev = s + len;
(gdb) n
153		register unsigned t = 0;
(gdb) n
155		switch(len % wsize) {
(gdb) n
157						h = (h << 7) | (h >> (8*wsize - 7));
(gdb) n
158						t = (t << 4) | *(s++);
(gdb) n
159				case 7: t = (t << 4) | *(s++);
(gdb) n
160				case 6:	t = (t << 4) | *(s++);
(gdb) n
161				case 5:	t = (t << 4) | *(s++);
(gdb) n
162				case 4:	t = (t << 4) | *(s++);
(gdb) n
163				case 3:	t = (t << 4) | *(s++);
(gdb) n
164				case 2:	t = (t << 4) | *(s++);
(gdb) n
165				case 1:	t = (t << 4) | *(s++);
(gdb) p s
$1 = 0x400eb2 "\003;\\"
(gdb) n
167				h += t;

yeah, I wrote that code on a 64 bit box. Ideally it should have an #ifdef for wsize or just hard code wsize = 8.

Though after a lot of thought, I think we'll just switch that hash func over to the zend_hash_inline function, rather than maintain our own hash.

Changed string_nhash_8 to (unsigned int)(zend_inline_hash_func)

http://news.php.net/php.pecl.cvs/11978
http://news.php.net/php.pecl.cvs/11979

What's kept me lazy till now was the test case :)