mod-xhtml-neg-cvs Mailing List for XHTML negotiation module (Page 3)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Update of /cvsroot/mod-xhtml-neg/mod_xhtml_neg
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv30125

Modified Files:
	Doxyfile Makefile mod_xhtml_neg.c 
Added Files:
	lookupa.c lookupa.h 
Log Message:
Use a better hashing algorithm for generating using ETag suffix.

--- NEW FILE: lookupa.c ---
/*
--------------------------------------------------------------------
lookupa.c, by Bob Jenkins, December 1996.  Same as lookup2.c
Use this code however you wish.  Public Domain.  No warranty.
Source is http://burtleburtle.net/bob/c/lookupa.c
--------------------------------------------------------------------
*/

#ifndef LOOKUPA
#include "lookupa.h"
#endif

/*
--------------------------------------------------------------------
mix -- mix 3 32-bit values reversibly.
For every delta with one or two bit set, and the deltas of all three
  high bits or all three low bits, whether the original value of a,b,c
  is almost all zero or is uniformly distributed,
* If mix() is run forward or backward, at least 32 bits in a,b,c
  have at least 1/4 probability of changing.
* If mix() is run forward, every bit of c will change between 1/3 and
  2/3 of the time.  (Well, 22/100 and 78/100 for some 2-bit deltas.)
mix() was built out of 36 single-cycle latency instructions in a 
  structure that could supported 2x parallelism, like so:
      a -= b; 
      a -= c; x = (c>>13);
      b -= c; a ^= x;
      b -= a; x = (a<<8);
      c -= a; b ^= x;
      c -= b; x = (b>>13);
      ...
  Unfortunately, superscalar Pentiums and Sparcs can't take advantage 
  of that parallelism.  They've also turned some of those single-cycle
  latency instructions into multi-cycle latency instructions.  Still,
  this is the fastest good hash I could find.  There were about 2^^68
  to choose from.  I only looked at a billion or so.
--------------------------------------------------------------------
*/
#define mix(a,b,c) \
{ \
  a -= b; a -= c; a ^= (c>>13); \
  b -= c; b -= a; b ^= (a<<8); \
  c -= a; c -= b; c ^= (b>>13); \
  a -= b; a -= c; a ^= (c>>12);  \
  b -= c; b -= a; b ^= (a<<16); \
  c -= a; c -= b; c ^= (b>>5); \
  a -= b; a -= c; a ^= (c>>3);  \
  b -= c; b -= a; b ^= (a<<10); \
  c -= a; c -= b; c ^= (b>>15); \
}

/*
--------------------------------------------------------------------
lookup() -- hash a variable-length key into a 32-bit value
  k     : the key (the unaligned variable-length array of bytes)
  len   : the length of the key, counting by bytes
  level : can be any 4-byte value
Returns a 32-bit value.  Every bit of the key affects every bit of
the return value.  Every 1-bit and 2-bit delta achieves avalanche.
About 6len+35 instructions.

The best hash table sizes are powers of 2.  There is no need to do
mod a prime (mod is sooo slow!).  If you need less than 32 bits,
use a bitmask.  For example, if you need only 10 bits, do
  h = (h & hashmask(10));
In which case, the hash table should have hashsize(10) elements.

If you are hashing n strings (ub1 **)k, do it like this:
  for (i=0, h=0; i<n; ++i) h = lookup( k[i], len[i], h);

By Bob Jenkins, 1996.  bob...@bu....  You may use this
code any way you wish, private, educational, or commercial.

See http://burtleburtle.net/bob/hash/evahash.html
Use for hash table lookup, or anything where one collision in 2^32 is
acceptable.  Do NOT use for cryptographic purposes.
--------------------------------------------------------------------
*/

ub4 lookup( register ub1 *k, register ub4 length, register ub4 level )
{
   register ub4 a,b,c,len;

   /* Set up the internal state */
   len = length;
   a = b = 0x9e3779b9;  /* the golden ratio; an arbitrary value */
   c = level;           /* the previous hash value */

   /*---------------------------------------- handle most of the key */
   while (len >= 12)
   {
      a += (k[0] +((ub4)k[1]<<8) +((ub4)k[2]<<16) +((ub4)k[3]<<24));
      b += (k[4] +((ub4)k[5]<<8) +((ub4)k[6]<<16) +((ub4)k[7]<<24));
      c += (k[8] +((ub4)k[9]<<8) +((ub4)k[10]<<16)+((ub4)k[11]<<24));
      mix(a,b,c);
      k += 12; len -= 12;
   }

   /*------------------------------------- handle the last 11 bytes */
   c += length;
   switch(len)              /* all the case statements fall through */
   {
   case 11: c+=((ub4)k[10]<<24);
   case 10: c+=((ub4)k[9]<<16);
   case 9 : c+=((ub4)k[8]<<8);
      /* the first byte of c is reserved for the length */
   case 8 : b+=((ub4)k[7]<<24);
   case 7 : b+=((ub4)k[6]<<16);
   case 6 : b+=((ub4)k[5]<<8);
   case 5 : b+=k[4];
   case 4 : a+=((ub4)k[3]<<24);
   case 3 : a+=((ub4)k[2]<<16);
   case 2 : a+=((ub4)k[1]<<8);
   case 1 : a+=k[0];
     /* case 0: nothing left to add */
   }
   mix(a,b,c);
   /*-------------------------------------------- report the result */
   return c;
}

/*
--------------------------------------------------------------------
mixc -- mixc 8 4-bit values as quickly and thoroughly as possible.
Repeating mix() three times achieves avalanche.
Repeating mix() four times eliminates all funnels and all
  characteristics stronger than 2^{-11}.
--------------------------------------------------------------------
*/
#define mixc(a,b,c,d,e,f,g,h) \
{ \
   a^=b<<11; d+=a; b+=c; \
   b^=c>>2;  e+=b; c+=d; \
   c^=d<<8;  f+=c; d+=e; \
   d^=e>>16; g+=d; e+=f; \
   e^=f<<10; h+=e; f+=g; \
   f^=g>>4;  a+=f; g+=h; \
   g^=h<<8;  b+=g; h+=a; \
   h^=a>>9;  c+=h; a+=b; \
}

/*
--------------------------------------------------------------------
checksum() -- hash a variable-length key into a 256-bit value
  k     : the key (the unaligned variable-length array of bytes)
  len   : the length of the key, counting by bytes
  state : an array of CHECKSTATE 4-byte values (256 bits)
The state is the checksum.  Every bit of the key affects every bit of
the state.  There are no funnels.  About 112+6.875len instructions.

If you are hashing n strings (ub1 **)k, do it like this:
  for (i=0; i<8; ++i) state[i] = 0x9e3779b9;
  for (i=0, h=0; i<n; ++i) checksum( k[i], len[i], state);

(c) Bob Jenkins, 1996.  bob...@bu....  You may use this
code any way you wish, private, educational, or commercial, as long
as this whole comment accompanies it.

See http://burtleburtle.net/bob/hash/evahash.html
Use to detect changes between revisions of documents, assuming nobody
is trying to cause collisions.  Do NOT use for cryptography.
--------------------------------------------------------------------
*/
void checksum( register ub1 *k, register ub4 len, register ub4 *state )
{
   register ub4 a,b,c,d,e,f,g,h,length;

   /* Use the length and level; add in the golden ratio. */
   length = len;
   a=state[0]; b=state[1]; c=state[2]; d=state[3];
   e=state[4]; f=state[5]; g=state[6]; h=state[7];

   /*---------------------------------------- handle most of the key */
   while (len >= 32)
   {
      a += (k[0] +(k[1]<<8) +(k[2]<<16) +(k[3]<<24));
      b += (k[4] +(k[5]<<8) +(k[6]<<16) +(k[7]<<24));
      c += (k[8] +(k[9]<<8) +(k[10]<<16)+(k[11]<<24));
      d += (k[12]+(k[13]<<8)+(k[14]<<16)+(k[15]<<24));
      e += (k[16]+(k[17]<<8)+(k[18]<<16)+(k[19]<<24));
      f += (k[20]+(k[21]<<8)+(k[22]<<16)+(k[23]<<24));
      g += (k[24]+(k[25]<<8)+(k[26]<<16)+(k[27]<<24));
      h += (k[28]+(k[29]<<8)+(k[30]<<16)+(k[31]<<24));
      mixc(a,b,c,d,e,f,g,h);
      mixc(a,b,c,d,e,f,g,h);
      mixc(a,b,c,d,e,f,g,h);
      mixc(a,b,c,d,e,f,g,h);
      k += 32; len -= 32;
   }

   /*------------------------------------- handle the last 31 bytes */
   h += length;
   switch(len)
   {
   case 31: h+=(k[30]<<24);
   case 30: h+=(k[29]<<16);
   case 29: h+=(k[28]<<8);
   case 28: g+=(k[27]<<24);
   case 27: g+=(k[26]<<16);
   case 26: g+=(k[25]<<8);
   case 25: g+=k[24];
   case 24: f+=(k[23]<<24);
   case 23: f+=(k[22]<<16);
   case 22: f+=(k[21]<<8);
   case 21: f+=k[20];
   case 20: e+=(k[19]<<24);
   case 19: e+=(k[18]<<16);
   case 18: e+=(k[17]<<8);
   case 17: e+=k[16];
   case 16: d+=(k[15]<<24);
   case 15: d+=(k[14]<<16);
   case 14: d+=(k[13]<<8);
   case 13: d+=k[12];
   case 12: c+=(k[11]<<24);
   case 11: c+=(k[10]<<16);
   case 10: c+=(k[9]<<8);
   case 9 : c+=k[8];
   case 8 : b+=(k[7]<<24);
   case 7 : b+=(k[6]<<16);
   case 6 : b+=(k[5]<<8);
   case 5 : b+=k[4];
   case 4 : a+=(k[3]<<24);
   case 3 : a+=(k[2]<<16);
   case 2 : a+=(k[1]<<8);
   case 1 : a+=k[0];
   }
   mixc(a,b,c,d,e,f,g,h);
   mixc(a,b,c,d,e,f,g,h);
   mixc(a,b,c,d,e,f,g,h);
   mixc(a,b,c,d,e,f,g,h);

   /*-------------------------------------------- report the result */
   state[0]=a; state[1]=b; state[2]=c; state[3]=d;
   state[4]=e; state[5]=f; state[6]=g; state[7]=h;
}

--- NEW FILE: lookupa.h ---
/*
------------------------------------------------------------------------------
By Bob Jenkins, September 1996.
lookupa.h, a hash function for table lookup, same function as lookup.c.
Use this code in any way you wish.  Public Domain.  It has no warranty.
Source is http://burtleburtle.net/bob/c/lookupa.h
------------------------------------------------------------------------------
*/

#ifndef LOOKUPA
#define LOOKUPA

typedef unsigned long int  ub4;
typedef unsigned      char ub1;

#define CHECKSTATE 8
#define hashsize(n) ((ub4)1<<(n))
#define hashmask(n) (hashsize(n)-1)

ub4  lookup(ub1 *k, ub4 length, ub4 level);
void checksum(ub1 *k, ub4 length, ub4 *state);

#endif /* LOOKUPA */

Index: Doxyfile
===================================================================
RCS file: /cvsroot/mod-xhtml-neg/mod_xhtml_neg/Doxyfile,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** Doxyfile	25 Mar 2004 10:20:37 -0000	1.2
--- Doxyfile	30 Mar 2004 10:35:46 -0000	1.3
***************
*** 24,28 ****
  # if some version control system is used.

! PROJECT_NUMBER         =  0.92

  # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 
--- 24,28 ----
  # if some version control system is used.

! PROJECT_NUMBER         =  0.93

  # The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) 

Index: Makefile
===================================================================
RCS file: /cvsroot/mod-xhtml-neg/mod_xhtml_neg/Makefile,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -C2 -d -r1.1.1.1 -r1.2
*** Makefile	4 Mar 2004 08:50:15 -0000	1.1.1.1
--- Makefile	30 Mar 2004 10:35:46 -0000	1.2
***************
*** 4,8 ****

  build:
! 	$(APXS) -Wc,-Wall,-O3,-fomit-frame-pointer,-pipe -c mod_xhtml_neg.c -o mod_xhtml_neg.so

  install:
--- 4,8 ----

  build:
! 	$(APXS) -Wc,-Wall,-O3,-fomit-frame-pointer,-pipe -c mod_xhtml_neg.c lookupa.c -o mod_xhtml_neg.so

  install:

Index: mod_xhtml_neg.c
===================================================================
RCS file: /cvsroot/mod-xhtml-neg/mod_xhtml_neg/mod_xhtml_neg.c,v
retrieving revision 1.29
retrieving revision 1.30
diff -C2 -d -r1.29 -r1.30
*** mod_xhtml_neg.c	28 Mar 2004 05:57:05 -0000	1.29
--- mod_xhtml_neg.c	30 Mar 2004 10:35:46 -0000	1.30
***************
*** 77,81 ****
   * @author Nicholas Cull <ru...@us...>
   * @date 1 March 2004
!  * @version 0.92
   *
   * @history
--- 77,81 ----
   * @author Nicholas Cull <ru...@us...>
   * @date 1 March 2004
!  * @version 0.93
   *
   * @history
***************
*** 86,89 ****
--- 86,90 ----
   * 0.9 ETag handled correctly for different content types. \n
   * 0.92 Pick up the AddDefaultCharset directive from the Apache core \n
+  * 0.93 Use a better hash function for ETag uniqueness \n
   *
   * @directive
***************
*** 118,121 ****
--- 119,123 ----
  #include "http_protocol.h"
  #include "http_log.h"
+ #include "lookupa.h"

  /** Read/write flags used when opening the log file. */
***************
*** 610,620 ****
   * Make a simple hash code for the given accept_rec structure. This allows
   * us to generate unique Etags for accepted content-types. The Etag
!  * consists of two simple values, the length of the interesting data,
!  * and a simple hash of each character. These are then represented as
!  * two hyphen separated, zero padded hexadecimal numbers.
   *
   * The data that we use to generate the hash is the content-type and charset,
   * concatenated as one long string.
   *
   * @param p a memory pool from which we can allocate temporary memory for this
   * request
--- 612,624 ----
   * Make a simple hash code for the given accept_rec structure. This allows
   * us to generate unique Etags for accepted content-types. The Etag
!  * consists of a hash of each character. This is then represented as a
!  * zero padded hexadecimal number.
   *
   * The data that we use to generate the hash is the content-type and charset,
   * concatenated as one long string.
   *
+  * The hash function is a hash in the public domain by By Bob Jenkins. See
+  * lookupa.c or http://burtleburtle.net/bob/hash/doobs.html for details.
+  *
   * @param p a memory pool from which we can allocate temporary memory for this
   * request
***************
*** 631,647 ****
      int len, i;

!     data = ap_pstrcat( p, rec->name, rec->charset, NULL );
      len = mod_xhtml_strlen( data );
!     hash = 7;
! 
!     /* Note that we use a multiplier of 128 rather than 256 since HTTP
!      * headers are only guaranteed 7-bit US-ASCII safe.
!      */
!     for( i = 0; i < len; i++ ) {
!         hash = hash * 128 + data[ i ];
!     }

!     rec->hashcode = ap_psprintf(p, "\"%02x-%08lx\"",
!                                len, (unsigned long) hash);
  }

--- 635,643 ----
      int len, i;

!     data = ap_pstrcat( p, rec->name, ";", rec->charset, NULL );
      len = mod_xhtml_strlen( data );
!     hash = lookup( data, len, 0 );

!     rec->hashcode = ap_psprintf(p, "\"%08lx\"", (unsigned long) hash);
  }

2004	Jan	Feb	Mar (51)	Apr (37)	May	Jun (4)	Jul	Aug	Sep	Oct	Nov	Dec
2008	Jan (3)	Feb	Mar	Apr	May	Jun	Jul	Aug	Sep	Oct	Nov	Dec

mod-xhtml-neg-cvs Mailing List for XHTML negotiation module (Page 3)

mod-xhtml-neg-cvs — CVS commit message are automatically sent to this list.