github.com/peterbourgon/diskv@v2.0.1+incompatible/speed_test.go (about)

     1  package diskv
     2  
     3  import (
     4  	"fmt"
     5  	"math/rand"
     6  	"testing"
     7  )
     8  
     9  func shuffle(keys []string) {
    10  	ints := rand.Perm(len(keys))
    11  	for i := range keys {
    12  		keys[i], keys[ints[i]] = keys[ints[i]], keys[i]
    13  	}
    14  }
    15  
    16  func genValue(size int) []byte {
    17  	v := make([]byte, size)
    18  	for i := 0; i < size; i++ {
    19  		v[i] = uint8((rand.Int() % 26) + 97) // a-z
    20  	}
    21  	return v
    22  }
    23  
    24  const (
    25  	keyCount = 1000
    26  )
    27  
    28  func genKeys() []string {
    29  	keys := make([]string, keyCount)
    30  	for i := 0; i < keyCount; i++ {
    31  		keys[i] = fmt.Sprintf("%d", i)
    32  	}
    33  	return keys
    34  }
    35  
    36  func (d *Diskv) load(keys []string, val []byte) {
    37  	for _, key := range keys {
    38  		d.Write(key, val)
    39  	}
    40  }
    41  
    42  func benchRead(b *testing.B, size, cachesz int) {
    43  	b.StopTimer()
    44  	d := New(Options{
    45  		BasePath:     "speed-test",
    46  		Transform:    func(string) []string { return []string{} },
    47  		CacheSizeMax: uint64(cachesz),
    48  	})
    49  	defer d.EraseAll()
    50  
    51  	keys := genKeys()
    52  	value := genValue(size)
    53  	d.load(keys, value)
    54  	shuffle(keys)
    55  	b.SetBytes(int64(size))
    56  
    57  	b.StartTimer()
    58  	for i := 0; i < b.N; i++ {
    59  		_, _ = d.Read(keys[i%len(keys)])
    60  	}
    61  	b.StopTimer()
    62  }
    63  
    64  func benchWrite(b *testing.B, size int, withIndex bool) {
    65  	b.StopTimer()
    66  
    67  	options := Options{
    68  		BasePath:     "speed-test",
    69  		Transform:    func(string) []string { return []string{} },
    70  		CacheSizeMax: 0,
    71  	}
    72  	if withIndex {
    73  		options.Index = &BTreeIndex{}
    74  		options.IndexLess = strLess
    75  	}
    76  
    77  	d := New(options)
    78  	defer d.EraseAll()
    79  	keys := genKeys()
    80  	value := genValue(size)
    81  	shuffle(keys)
    82  	b.SetBytes(int64(size))
    83  
    84  	b.StartTimer()
    85  	for i := 0; i < b.N; i++ {
    86  		d.Write(keys[i%len(keys)], value)
    87  	}
    88  	b.StopTimer()
    89  }
    90  
    91  func BenchmarkWrite__32B_NoIndex(b *testing.B) {
    92  	benchWrite(b, 32, false)
    93  }
    94  
    95  func BenchmarkWrite__1KB_NoIndex(b *testing.B) {
    96  	benchWrite(b, 1024, false)
    97  }
    98  
    99  func BenchmarkWrite__4KB_NoIndex(b *testing.B) {
   100  	benchWrite(b, 4096, false)
   101  }
   102  
   103  func BenchmarkWrite_10KB_NoIndex(b *testing.B) {
   104  	benchWrite(b, 10240, false)
   105  }
   106  
   107  func BenchmarkWrite__32B_WithIndex(b *testing.B) {
   108  	benchWrite(b, 32, true)
   109  }
   110  
   111  func BenchmarkWrite__1KB_WithIndex(b *testing.B) {
   112  	benchWrite(b, 1024, true)
   113  }
   114  
   115  func BenchmarkWrite__4KB_WithIndex(b *testing.B) {
   116  	benchWrite(b, 4096, true)
   117  }
   118  
   119  func BenchmarkWrite_10KB_WithIndex(b *testing.B) {
   120  	benchWrite(b, 10240, true)
   121  }
   122  
   123  func BenchmarkRead__32B_NoCache(b *testing.B) {
   124  	benchRead(b, 32, 0)
   125  }
   126  
   127  func BenchmarkRead__1KB_NoCache(b *testing.B) {
   128  	benchRead(b, 1024, 0)
   129  }
   130  
   131  func BenchmarkRead__4KB_NoCache(b *testing.B) {
   132  	benchRead(b, 4096, 0)
   133  }
   134  
   135  func BenchmarkRead_10KB_NoCache(b *testing.B) {
   136  	benchRead(b, 10240, 0)
   137  }
   138  
   139  func BenchmarkRead__32B_WithCache(b *testing.B) {
   140  	benchRead(b, 32, keyCount*32*2)
   141  }
   142  
   143  func BenchmarkRead__1KB_WithCache(b *testing.B) {
   144  	benchRead(b, 1024, keyCount*1024*2)
   145  }
   146  
   147  func BenchmarkRead__4KB_WithCache(b *testing.B) {
   148  	benchRead(b, 4096, keyCount*4096*2)
   149  }
   150  
   151  func BenchmarkRead_10KB_WithCache(b *testing.B) {
   152  	benchRead(b, 10240, keyCount*4096*2)
   153  }