github.com/rohankumardubey/proxyfs@v0.0.0-20210108201508-653efa9ab00e/inode/benchmark_test.go (about)

     1  package inode
     2  
     3  import (
     4  	"strconv"
     5  	"testing"
     6  
     7  	"github.com/swiftstack/ProxyFS/utils"
     8  )
     9  
    10  func writeBenchmarkHelper(b *testing.B, byteSize uint64) {
    11  	testVolumeHandle, _ := FetchVolumeHandle("TestVolume")
    12  	fileInodeNumber, _ := testVolumeHandle.CreateFile(PosixModePerm, 0, 0)
    13  	buffer := make([]byte, 4096)
    14  	b.ResetTimer()
    15  	for i := 0; i < b.N; i++ {
    16  		testVolumeHandle.Write(fileInodeNumber, 0, buffer, nil)
    17  	}
    18  }
    19  
    20  func Benchmark4KiBWrite(b *testing.B) {
    21  	writeBenchmarkHelper(b, 4*1024)
    22  }
    23  
    24  func Benchmark8KiBWrite(b *testing.B) {
    25  	writeBenchmarkHelper(b, 8*1024)
    26  }
    27  
    28  func Benchmark16KiBWrite(b *testing.B) {
    29  	writeBenchmarkHelper(b, 16*1024)
    30  }
    31  
    32  func Benchmark32KiBWrite(b *testing.B) {
    33  	writeBenchmarkHelper(b, 32*1024)
    34  }
    35  
    36  func Benchmark64KiBWrite(b *testing.B) {
    37  	writeBenchmarkHelper(b, 64*1024)
    38  }
    39  
    40  func readBenchmarkHelper(b *testing.B, byteSize uint64) {
    41  	testVolumeHandle, _ := FetchVolumeHandle("TestVolume")
    42  	fileInodeNumber, _ := testVolumeHandle.CreateFile(PosixModePerm, 0, 0)
    43  	buffer := make([]byte, byteSize)
    44  	testVolumeHandle.Write(fileInodeNumber, 0, buffer, nil)
    45  	b.ResetTimer()
    46  	for i := 0; i < b.N; i++ {
    47  		testVolumeHandle.Read(fileInodeNumber, 0, byteSize, nil)
    48  	}
    49  }
    50  
    51  func BenchmarkRead4KiB(b *testing.B) {
    52  	readBenchmarkHelper(b, 4*1024)
    53  }
    54  
    55  func BenchmarkRead8KiB(b *testing.B) {
    56  	readBenchmarkHelper(b, 8*1024)
    57  }
    58  
    59  func BenchmarkRead16KiB(b *testing.B) {
    60  	readBenchmarkHelper(b, 16*1024)
    61  }
    62  
    63  func BenchmarkRead32KiB(b *testing.B) {
    64  	readBenchmarkHelper(b, 32*1024)
    65  }
    66  
    67  func BenchmarkRead64KiB(b *testing.B) {
    68  	readBenchmarkHelper(b, 64*1024)
    69  }
    70  
    71  func getReadPlanBenchmarkHelper(b *testing.B, byteSize uint64) {
    72  	testVolumeHandle, _ := FetchVolumeHandle("TestVolume")
    73  	fileInodeNumber, _ := testVolumeHandle.CreateFile(PosixModePerm, 0, 0)
    74  	buffer := make([]byte, byteSize)
    75  	testVolumeHandle.Write(fileInodeNumber, 0, buffer, nil)
    76  	var zero uint64
    77  	b.ResetTimer()
    78  	for i := 0; i < b.N; i++ {
    79  		testVolumeHandle.GetReadPlan(fileInodeNumber, &zero, &byteSize)
    80  	}
    81  }
    82  
    83  func BenchmarkGetReadPlan4KiB(b *testing.B) {
    84  	getReadPlanBenchmarkHelper(b, 4*1024)
    85  }
    86  
    87  func BenchmarkGetReadPlan8KiB(b *testing.B) {
    88  	getReadPlanBenchmarkHelper(b, 8*1024)
    89  }
    90  
    91  func BenchmarkGetReadPlan16KiB(b *testing.B) {
    92  	getReadPlanBenchmarkHelper(b, 16*1024)
    93  }
    94  
    95  func BenchmarkGetReadPlan32KiB(b *testing.B) {
    96  	getReadPlanBenchmarkHelper(b, 32*1024)
    97  }
    98  
    99  func BenchmarkGetReadPlan64KiB(b *testing.B) {
   100  	getReadPlanBenchmarkHelper(b, 64*1024)
   101  }
   102  
   103  func readCacheBenchmarkHelper(b *testing.B, byteSize uint64) {
   104  	testVolumeHandle, _ := FetchVolumeHandle("TestVolume")
   105  	fileInodeNumber, _ := testVolumeHandle.CreateFile(PosixModePerm, 0, 0)
   106  	buffer := make([]byte, byteSize)
   107  	testVolumeHandle.Write(fileInodeNumber, 0, buffer, nil)
   108  	testVolumeHandle.Flush(fileInodeNumber, false)
   109  	var zero uint64
   110  	zero = 0
   111  	readPlan, _ := testVolumeHandle.GetReadPlan(fileInodeNumber, &zero, &byteSize)
   112  	testVolumeHandle.Read(fileInodeNumber, 0, byteSize, nil)
   113  	// at this point, the read cache should be populated
   114  
   115  	// let's get the log segment number
   116  	_, _, objectName, _ := utils.PathToAcctContObj(readPlan[0].ObjectPath)
   117  	logSegmentNumber, _ := strconv.ParseUint(objectName, 16, 64)
   118  
   119  	volume := testVolumeHandle.(*volumeStruct)
   120  
   121  	b.ResetTimer()
   122  	for i := 0; i < b.N; i++ {
   123  		buf := []byte{}
   124  		readCacheKey := readCacheKeyStruct{volumeName: "TestVolume", logSegmentNumber: logSegmentNumber, cacheLineTag: 0}
   125  		volume.volumeGroup.Lock()
   126  		readCacheElement, _ := volume.volumeGroup.readCache[readCacheKey]
   127  		cacheLine := readCacheElement.cacheLine
   128  		buf = append(buf, cacheLine[:byteSize]...)
   129  		volume.volumeGroup.Unlock()
   130  	}
   131  }
   132  
   133  func BenchmarkReadCache4KiB(b *testing.B) {
   134  	readCacheBenchmarkHelper(b, 4*1024)
   135  }
   136  
   137  func BenchmarkReadCache8KiB(b *testing.B) {
   138  	readCacheBenchmarkHelper(b, 8*1024)
   139  }
   140  
   141  func BenchmarkReadCache16KiB(b *testing.B) {
   142  	readCacheBenchmarkHelper(b, 16*1024)
   143  }
   144  
   145  func BenchmarkReadCache32KiB(b *testing.B) {
   146  	readCacheBenchmarkHelper(b, 32*1024)
   147  }
   148  
   149  func BenchmarkReadCache64KiB(b *testing.B) {
   150  	readCacheBenchmarkHelper(b, 64*1024)
   151  }