github.com/coocood/badger@v1.5.1-0.20200528065104-c02ac3616d04/cache/z/rtutil_test.go (about)

     1  package z
     2  
     3  import (
     4  	"crypto/rand"
     5  	"hash/fnv"
     6  	"testing"
     7  
     8  	"github.com/dgryski/go-farm"
     9  )
    10  
    11  func BenchmarkMemHash(b *testing.B) {
    12  	buf := make([]byte, 64)
    13  	rand.Read(buf)
    14  	for i := 0; i < b.N; i++ {
    15  		MemHash(buf)
    16  	}
    17  }
    18  
    19  func BenchmarkSip(b *testing.B) {
    20  	buf := make([]byte, 64)
    21  	rand.Read(buf)
    22  	for i := 0; i < b.N; i++ {
    23  		SipHash(buf)
    24  	}
    25  }
    26  
    27  func BenchmarkFarm(b *testing.B) {
    28  	buf := make([]byte, 64)
    29  	rand.Read(buf)
    30  	for i := 0; i < b.N; i++ {
    31  		farm.Fingerprint64(buf)
    32  	}
    33  }
    34  
    35  func BenchmarkFnv(b *testing.B) {
    36  	buf := make([]byte, 64)
    37  	rand.Read(buf)
    38  	f := fnv.New64a()
    39  	for i := 0; i < b.N; i++ {
    40  		f.Write(buf)
    41  		f.Sum64()
    42  		f.Reset()
    43  	}
    44  }
    45  
    46  func SipHash(p []byte) (l, h uint64) {
    47  	// Initialization.
    48  	v0 := uint64(8317987320269560794) // k0 ^ 0x736f6d6570736575
    49  	v1 := uint64(7237128889637516672) // k1 ^ 0x646f72616e646f6d
    50  	v2 := uint64(7816392314733513934) // k0 ^ 0x6c7967656e657261
    51  	v3 := uint64(8387220255325274014) // k1 ^ 0x7465646279746573
    52  	t := uint64(len(p)) << 56
    53  
    54  	// Compression.
    55  	for len(p) >= 8 {
    56  
    57  		m := uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
    58  			uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
    59  
    60  		v3 ^= m
    61  
    62  		// Round 1.
    63  		v0 += v1
    64  		v1 = v1<<13 | v1>>51
    65  		v1 ^= v0
    66  		v0 = v0<<32 | v0>>32
    67  
    68  		v2 += v3
    69  		v3 = v3<<16 | v3>>48
    70  		v3 ^= v2
    71  
    72  		v0 += v3
    73  		v3 = v3<<21 | v3>>43
    74  		v3 ^= v0
    75  
    76  		v2 += v1
    77  		v1 = v1<<17 | v1>>47
    78  		v1 ^= v2
    79  		v2 = v2<<32 | v2>>32
    80  
    81  		// Round 2.
    82  		v0 += v1
    83  		v1 = v1<<13 | v1>>51
    84  		v1 ^= v0
    85  		v0 = v0<<32 | v0>>32
    86  
    87  		v2 += v3
    88  		v3 = v3<<16 | v3>>48
    89  		v3 ^= v2
    90  
    91  		v0 += v3
    92  		v3 = v3<<21 | v3>>43
    93  		v3 ^= v0
    94  
    95  		v2 += v1
    96  		v1 = v1<<17 | v1>>47
    97  		v1 ^= v2
    98  		v2 = v2<<32 | v2>>32
    99  
   100  		v0 ^= m
   101  		p = p[8:]
   102  	}
   103  
   104  	// Compress last block.
   105  	switch len(p) {
   106  	case 7:
   107  		t |= uint64(p[6]) << 48
   108  		fallthrough
   109  	case 6:
   110  		t |= uint64(p[5]) << 40
   111  		fallthrough
   112  	case 5:
   113  		t |= uint64(p[4]) << 32
   114  		fallthrough
   115  	case 4:
   116  		t |= uint64(p[3]) << 24
   117  		fallthrough
   118  	case 3:
   119  		t |= uint64(p[2]) << 16
   120  		fallthrough
   121  	case 2:
   122  		t |= uint64(p[1]) << 8
   123  		fallthrough
   124  	case 1:
   125  		t |= uint64(p[0])
   126  	}
   127  
   128  	v3 ^= t
   129  
   130  	// Round 1.
   131  	v0 += v1
   132  	v1 = v1<<13 | v1>>51
   133  	v1 ^= v0
   134  	v0 = v0<<32 | v0>>32
   135  
   136  	v2 += v3
   137  	v3 = v3<<16 | v3>>48
   138  	v3 ^= v2
   139  
   140  	v0 += v3
   141  	v3 = v3<<21 | v3>>43
   142  	v3 ^= v0
   143  
   144  	v2 += v1
   145  	v1 = v1<<17 | v1>>47
   146  	v1 ^= v2
   147  	v2 = v2<<32 | v2>>32
   148  
   149  	// Round 2.
   150  	v0 += v1
   151  	v1 = v1<<13 | v1>>51
   152  	v1 ^= v0
   153  	v0 = v0<<32 | v0>>32
   154  
   155  	v2 += v3
   156  	v3 = v3<<16 | v3>>48
   157  	v3 ^= v2
   158  
   159  	v0 += v3
   160  	v3 = v3<<21 | v3>>43
   161  	v3 ^= v0
   162  
   163  	v2 += v1
   164  	v1 = v1<<17 | v1>>47
   165  	v1 ^= v2
   166  	v2 = v2<<32 | v2>>32
   167  
   168  	v0 ^= t
   169  
   170  	// Finalization.
   171  	v2 ^= 0xff
   172  
   173  	// Round 1.
   174  	v0 += v1
   175  	v1 = v1<<13 | v1>>51
   176  	v1 ^= v0
   177  	v0 = v0<<32 | v0>>32
   178  
   179  	v2 += v3
   180  	v3 = v3<<16 | v3>>48
   181  	v3 ^= v2
   182  
   183  	v0 += v3
   184  	v3 = v3<<21 | v3>>43
   185  	v3 ^= v0
   186  
   187  	v2 += v1
   188  	v1 = v1<<17 | v1>>47
   189  	v1 ^= v2
   190  	v2 = v2<<32 | v2>>32
   191  
   192  	// Round 2.
   193  	v0 += v1
   194  	v1 = v1<<13 | v1>>51
   195  	v1 ^= v0
   196  	v0 = v0<<32 | v0>>32
   197  
   198  	v2 += v3
   199  	v3 = v3<<16 | v3>>48
   200  	v3 ^= v2
   201  
   202  	v0 += v3
   203  	v3 = v3<<21 | v3>>43
   204  	v3 ^= v0
   205  
   206  	v2 += v1
   207  	v1 = v1<<17 | v1>>47
   208  	v1 ^= v2
   209  	v2 = v2<<32 | v2>>32
   210  
   211  	// Round 3.
   212  	v0 += v1
   213  	v1 = v1<<13 | v1>>51
   214  	v1 ^= v0
   215  	v0 = v0<<32 | v0>>32
   216  
   217  	v2 += v3
   218  	v3 = v3<<16 | v3>>48
   219  	v3 ^= v2
   220  
   221  	v0 += v3
   222  	v3 = v3<<21 | v3>>43
   223  	v3 ^= v0
   224  
   225  	v2 += v1
   226  	v1 = v1<<17 | v1>>47
   227  	v1 ^= v2
   228  	v2 = v2<<32 | v2>>32
   229  
   230  	// Round 4.
   231  	v0 += v1
   232  	v1 = v1<<13 | v1>>51
   233  	v1 ^= v0
   234  	v0 = v0<<32 | v0>>32
   235  
   236  	v2 += v3
   237  	v3 = v3<<16 | v3>>48
   238  	v3 ^= v2
   239  
   240  	v0 += v3
   241  	v3 = v3<<21 | v3>>43
   242  	v3 ^= v0
   243  
   244  	v2 += v1
   245  	v1 = v1<<17 | v1>>47
   246  	v1 ^= v2
   247  	v2 = v2<<32 | v2>>32
   248  
   249  	// return v0 ^ v1 ^ v2 ^ v3
   250  
   251  	hash := v0 ^ v1 ^ v2 ^ v3
   252  	h = hash >> 1
   253  	l = hash << 1 >> 1
   254  	return l, h
   255  
   256  }
   257  func BenchmarkNanoTime(b *testing.B) {
   258  	for i := 0; i < b.N; i++ {
   259  		NanoTime()
   260  	}
   261  }
   262  
   263  func BenchmarkCPUTicks(b *testing.B) {
   264  	for i := 0; i < b.N; i++ {
   265  		CPUTicks()
   266  	}
   267  }
   268  
   269  func BenchmarkFastRand(b *testing.B) {
   270  	for i := 0; i < b.N; i++ {
   271  		FastRand()
   272  	}
   273  }