github.com/scottcagno/storage@v1.8.0/pkg/swal/wal_bench_test.go (about)

     1  package swal
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/scottcagno/storage/pkg/lsmt/binary"
     6  	"os"
     7  	"testing"
     8  )
     9  
    10  func makeEntry(i int) *binary.Entry {
    11  	return &binary.Entry{
    12  		Key:   []byte(fmt.Sprintf("key-%06d", i)),
    13  		Value: []byte(fmt.Sprintf("value-%08d", i)),
    14  	}
    15  }
    16  
    17  func walWrite(b *testing.B, wal *SWAL, count int) []int64 {
    18  
    19  	// offsets
    20  	var offsets []int64
    21  
    22  	// write data
    23  	for i := 0; i < count; i++ {
    24  		n, err := wal.Write(makeEntry(i))
    25  		if err != nil {
    26  			b.Errorf("write: %v\n", err)
    27  		}
    28  		b.StopTimer()
    29  		offsets = append(offsets, n)
    30  		b.StartTimer()
    31  	}
    32  	b.StopTimer()
    33  	// return offsets
    34  	return offsets
    35  }
    36  
    37  func walRead(b *testing.B, wal *SWAL) {
    38  
    39  	// used to "catch" value
    40  	var vv interface{}
    41  
    42  	// read data
    43  	err := wal.Scan(func(e *binary.Entry) bool {
    44  		vv = e
    45  		_ = vv
    46  		return e != nil
    47  	})
    48  	if err != nil {
    49  		b.Errorf("read: %v\n", err)
    50  	}
    51  }
    52  
    53  func setup(b *testing.B) *SWAL {
    54  
    55  	// open
    56  	wal, err := OpenSWAL(conf)
    57  	if err != nil {
    58  		b.Errorf("open: %v\n", err)
    59  	}
    60  
    61  	// return wal
    62  	return wal
    63  }
    64  
    65  func teardown(b *testing.B, wal *SWAL, shouldClean bool) {
    66  
    67  	// close
    68  	err := wal.Close()
    69  	if err != nil {
    70  		b.Errorf("close: %v\n", err)
    71  	}
    72  
    73  	// check cleanup
    74  	if shouldClean {
    75  		err = os.RemoveAll(wal.conf.BasePath)
    76  		if err != nil {
    77  			b.Fatalf("got error: %v\n", err)
    78  		}
    79  	}
    80  }
    81  
    82  func Bench_WAL_Write(b *testing.B, wal *SWAL, count int) {
    83  
    84  	// reset measurements
    85  	reset(b)
    86  
    87  	// test write
    88  	for i := 0; i < b.N; i++ {
    89  		b.Run("lsmTreeWrite", func(b *testing.B) {
    90  			walWrite(b, wal, count)
    91  		})
    92  	}
    93  }
    94  
    95  func Bench_WAL_Read(b *testing.B, wal *SWAL) {
    96  
    97  	// reset measurements
    98  	reset(b)
    99  
   100  	// test read
   101  	for i := 0; i < b.N; i++ {
   102  		b.Run("lsmTreeRead", func(b *testing.B) {
   103  			walRead(b, wal)
   104  		})
   105  	}
   106  }
   107  
   108  func BenchmarkWAL(b *testing.B) {
   109  
   110  	// count
   111  	count := 10
   112  
   113  	// setup (OPEN DB)
   114  	wal := setup(b)
   115  
   116  	// writing
   117  	Bench_WAL_Write(b, wal, count)
   118  
   119  	// reading
   120  	Bench_WAL_Read(b, wal)
   121  
   122  	// teardown (CLOSE DB)
   123  	teardown(b, wal, true)
   124  }
   125  
   126  func reset(b *testing.B) {
   127  	b.ResetTimer()
   128  	b.ReportAllocs()
   129  }