vitess.io/vitess@v0.16.2/go/pools/rp_bench_test.go (about)

     1  /*
     2  Copyright 2022 The Vitess Authors.
     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      http://www.apache.org/licenses/LICENSE-2.0
     7  Unless required by applicable law or agreed to in writing, software
     8  distributed under the License is distributed on an "AS IS" BASIS,
     9  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    10  See the License for the specific language governing permissions and
    11  limitations under the License.
    12  */
    13  
    14  package pools
    15  
    16  import (
    17  	"context"
    18  	"fmt"
    19  	"testing"
    20  )
    21  
    22  func BenchmarkGetPut(b *testing.B) {
    23  	testResourceFactory := func(context.Context) (Resource, error) {
    24  		return &TestResource{}, nil
    25  	}
    26  	for _, size := range []int{64, 128, 512} {
    27  		for _, parallelism := range []int{1, 8, 32, 128} {
    28  			rName := fmt.Sprintf("x%d-cap%d", parallelism, size)
    29  			b.Run(rName, func(b *testing.B) {
    30  				pool := NewResourcePool(testResourceFactory, size, size, 0, 0, nil, nil, 0)
    31  				defer pool.Close()
    32  
    33  				b.ReportAllocs()
    34  				b.SetParallelism(parallelism)
    35  				b.RunParallel(func(pb *testing.PB) {
    36  					var ctx = context.Background()
    37  					for pb.Next() {
    38  						if conn, err := pool.Get(ctx, nil); err != nil {
    39  							b.Error(err)
    40  						} else {
    41  							pool.Put(conn)
    42  						}
    43  					}
    44  				})
    45  			})
    46  		}
    47  	}
    48  }
    49  
    50  func BenchmarkGetPutWithSettings(b *testing.B) {
    51  	testResourceFactory := func(context.Context) (Resource, error) {
    52  		return &TestResource{}, nil
    53  	}
    54  	setting := &Setting{query: "set a=1, b=2, c=3"}
    55  	for _, size := range []int{64, 128, 512} {
    56  		for _, parallelism := range []int{1, 8, 32, 128} {
    57  			rName := fmt.Sprintf("x%d-cap%d", parallelism, size)
    58  			b.Run(rName, func(b *testing.B) {
    59  				pool := NewResourcePool(testResourceFactory, size, size, 0, 0, nil, nil, 0)
    60  				defer pool.Close()
    61  
    62  				b.ReportAllocs()
    63  				b.SetParallelism(parallelism)
    64  				b.RunParallel(func(pb *testing.PB) {
    65  					var ctx = context.Background()
    66  					for pb.Next() {
    67  						if conn, err := pool.Get(ctx, setting); err != nil {
    68  							b.Error(err)
    69  						} else {
    70  							pool.Put(conn)
    71  						}
    72  					}
    73  				})
    74  			})
    75  		}
    76  	}
    77  }
    78  
    79  func BenchmarkGetPutMixed(b *testing.B) {
    80  	testResourceFactory := func(context.Context) (Resource, error) {
    81  		return &TestResource{}, nil
    82  	}
    83  	settings := []*Setting{nil, {query: "set a=1, b=2, c=3"}}
    84  	for _, size := range []int{64, 128, 512} {
    85  		for _, parallelism := range []int{1, 8, 32, 128} {
    86  			rName := fmt.Sprintf("x%d-cap%d", parallelism, size)
    87  			b.Run(rName, func(b *testing.B) {
    88  				pool := NewResourcePool(testResourceFactory, size, size, 0, 0, nil, nil, 0)
    89  				defer pool.Close()
    90  
    91  				b.ReportAllocs()
    92  				b.SetParallelism(parallelism)
    93  				b.RunParallel(func(pb *testing.PB) {
    94  					var ctx = context.Background()
    95  					i := 0
    96  					for pb.Next() {
    97  						if conn, err := pool.Get(ctx, settings[i]); err != nil {
    98  							b.Error(err)
    99  						} else {
   100  							pool.Put(conn)
   101  						}
   102  						i = (i + 1) % 2
   103  					}
   104  				})
   105  			})
   106  		}
   107  	}
   108  }
   109  
   110  func BenchmarkGetPutMixedMulti(b *testing.B) {
   111  	testResourceFactory := func(context.Context) (Resource, error) {
   112  		return &TestResource{}, nil
   113  	}
   114  	settings := []*Setting{nil, {query: "set a=1"}, {query: "set a=1, b=2"}, {query: "set c=1, d=2, e=3"}, {query: "set x=1, y=2, z=3"}}
   115  	for _, size := range []int{64, 128, 512} {
   116  		for _, parallelism := range []int{1, 8, 32, 128} {
   117  			rName := fmt.Sprintf("x%d-cap%d", parallelism, size)
   118  			b.Run(rName, func(b *testing.B) {
   119  				pool := NewResourcePool(testResourceFactory, size, size, 0, 0, nil, nil, 0)
   120  				defer pool.Close()
   121  
   122  				b.ReportAllocs()
   123  				b.SetParallelism(parallelism)
   124  				b.RunParallel(func(pb *testing.PB) {
   125  					var ctx = context.Background()
   126  					i := 0
   127  					for pb.Next() {
   128  						if conn, err := pool.Get(ctx, settings[i]); err != nil {
   129  							b.Error(err)
   130  						} else {
   131  							pool.Put(conn)
   132  						}
   133  						i = (i + 1) % 5
   134  					}
   135  				})
   136  			})
   137  		}
   138  	}
   139  }