kvstore_bench_test.go

Documentation: go.etcd.io/etcd/server/v3/mvcc

     1  // Copyright 2015 The etcd Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package mvcc
    16  
    17  import (
    18  	"context"
    19  	"testing"
    20  
    21  	"github.com/stretchr/testify/assert"
    22  	"go.etcd.io/etcd/pkg/v3/traceutil"
    23  	"go.etcd.io/etcd/server/v3/etcdserver/cindex"
    24  	"go.etcd.io/etcd/server/v3/lease"
    25  	betesting "go.etcd.io/etcd/server/v3/mvcc/backend/testing"
    26  
    27  	"go.uber.org/zap"
    28  )
    29  
    30  func BenchmarkStorePut(b *testing.B) {
    31  	be, tmpPath := betesting.NewDefaultTmpBackend(b)
    32  	s := NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
    33  	defer cleanup(s, be, tmpPath)
    34  
    35  	// arbitrary number of bytes
    36  	bytesN := 64
    37  	keys := createBytesSlice(bytesN, b.N)
    38  	vals := createBytesSlice(bytesN, b.N)
    39  
    40  	b.ResetTimer()
    41  	for i := 0; i < b.N; i++ {
    42  		s.Put(keys[i], vals[i], lease.NoLease)
    43  	}
    44  }
    45  
    46  func BenchmarkStoreRangeKey1(b *testing.B)   { benchmarkStoreRange(b, 1) }
    47  func BenchmarkStoreRangeKey100(b *testing.B) { benchmarkStoreRange(b, 100) }
    48  
    49  func benchmarkStoreRange(b *testing.B, n int) {
    50  	be, tmpPath := betesting.NewDefaultTmpBackend(b)
    51  	s := NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
    52  	defer cleanup(s, be, tmpPath)
    53  
    54  	// 64 byte key/val
    55  	keys, val := createBytesSlice(64, n), createBytesSlice(64, 1)
    56  	for i := range keys {
    57  		s.Put(keys[i], val[0], lease.NoLease)
    58  	}
    59  	// Force into boltdb tx instead of backend read tx.
    60  	s.Commit()
    61  
    62  	var begin, end []byte
    63  	if n == 1 {
    64  		begin, end = keys[0], nil
    65  	} else {
    66  		begin, end = []byte{}, []byte{}
    67  	}
    68  
    69  	b.ReportAllocs()
    70  	b.ResetTimer()
    71  	for i := 0; i < b.N; i++ {
    72  		s.Range(context.TODO(), begin, end, RangeOptions{})
    73  	}
    74  }
    75  
    76  func BenchmarkConsistentIndex(b *testing.B) {
    77  	be, _ := betesting.NewDefaultTmpBackend(b)
    78  	ci := cindex.NewConsistentIndex(be)
    79  	defer betesting.Close(b, be)
    80  
    81  	// This will force the index to be reread from scratch on each call.
    82  	ci.SetConsistentIndex(0, 0)
    83  
    84  	tx := be.BatchTx()
    85  	tx.Lock()
    86  	cindex.UnsafeCreateMetaBucket(tx)
    87  	ci.UnsafeSave(tx)
    88  	tx.Unlock()
    89  
    90  	b.ReportAllocs()
    91  	b.ResetTimer()
    92  	for i := 0; i < b.N; i++ {
    93  		ci.ConsistentIndex()
    94  	}
    95  }
    96  
    97  // BenchmarkStorePutUpdate is same as above, but instead updates single key
    98  func BenchmarkStorePutUpdate(b *testing.B) {
    99  	be, tmpPath := betesting.NewDefaultTmpBackend(b)
   100  	s := NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
   101  	defer cleanup(s, be, tmpPath)
   102  
   103  	// arbitrary number of bytes
   104  	keys := createBytesSlice(64, 1)
   105  	vals := createBytesSlice(1024, 1)
   106  
   107  	b.ResetTimer()
   108  	for i := 0; i < b.N; i++ {
   109  		s.Put(keys[0], vals[0], lease.NoLease)
   110  	}
   111  }
   112  
   113  // BenchmarkStoreTxnPut benchmarks the Put operation
   114  // with transaction begin and end, where transaction involves
   115  // some synchronization operations, such as mutex locking.
   116  func BenchmarkStoreTxnPut(b *testing.B) {
   117  	be, tmpPath := betesting.NewDefaultTmpBackend(b)
   118  	s := NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
   119  	defer cleanup(s, be, tmpPath)
   120  
   121  	// arbitrary number of bytes
   122  	bytesN := 64
   123  	keys := createBytesSlice(bytesN, b.N)
   124  	vals := createBytesSlice(bytesN, b.N)
   125  
   126  	b.ResetTimer()
   127  	b.ReportAllocs()
   128  	for i := 0; i < b.N; i++ {
   129  		txn := s.Write(traceutil.TODO())
   130  		txn.Put(keys[i], vals[i], lease.NoLease)
   131  		txn.End()
   132  	}
   133  }
   134  
   135  // benchmarkStoreRestore benchmarks the restore operation
   136  func benchmarkStoreRestore(revsPerKey int, b *testing.B) {
   137  	be, tmpPath := betesting.NewDefaultTmpBackend(b)
   138  	s := NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
   139  	// use closure to capture 's' to pick up the reassignment
   140  	defer func() { cleanup(s, be, tmpPath) }()
   141  
   142  	// arbitrary number of bytes
   143  	bytesN := 64
   144  	keys := createBytesSlice(bytesN, b.N)
   145  	vals := createBytesSlice(bytesN, b.N)
   146  
   147  	for i := 0; i < b.N; i++ {
   148  		for j := 0; j < revsPerKey; j++ {
   149  			txn := s.Write(traceutil.TODO())
   150  			txn.Put(keys[i], vals[i], lease.NoLease)
   151  			txn.End()
   152  		}
   153  	}
   154  	assert.NoError(b, s.Close())
   155  
   156  	b.ReportAllocs()
   157  	b.ResetTimer()
   158  	s = NewStore(zap.NewExample(), be, &lease.FakeLessor{}, StoreConfig{})
   159  }
   160  
   161  func BenchmarkStoreRestoreRevs1(b *testing.B) {
   162  	benchmarkStoreRestore(1, b)
   163  }
   164  
   165  func BenchmarkStoreRestoreRevs10(b *testing.B) {
   166  	benchmarkStoreRestore(10, b)
   167  }
   168  
   169  func BenchmarkStoreRestoreRevs20(b *testing.B) {
   170  	benchmarkStoreRestore(20, b)
   171  }
   172
View as plain text