cubefs

1
// Copyright 2022 The CubeFS 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
12
// implied. See the License for the specific language governing
13
// permissions and limitations under the License.
14

15
package resourcepool_test
16

17
import (
18
	"context"
19
	"fmt"
20
	"runtime"
21
	"testing"
22

23
	"github.com/stretchr/testify/require"
24

25
	rp "github.com/cubefs/cubefs/blobstore/common/resourcepool"
26
	"github.com/cubefs/cubefs/blobstore/util/task"
27
)
28

29
func TestPoolBase(t *testing.T) {
30
	p := rp.NewPool(func() interface{} {
31
		return 1
32
	}, 2)
33

34
	require.Equal(t, 2, p.Cap())
35
	require.Equal(t, 0, p.Len())
36
	require.Equal(t, 2, p.Idle())
37

38
	_, err := p.Get()
39
	require.NoError(t, err)
40
	_, err = p.Get()
41
	require.NoError(t, err)
42

43
	require.Equal(t, 2, p.Len())
44
	require.Equal(t, 0, p.Idle())
45

46
	_, err = p.Get()
47
	require.Equal(t, rp.ErrPoolLimit, err)
48
	_, err = p.Get()
49
	require.Equal(t, rp.ErrPoolLimit, err)
50

51
	p.Put(1)
52
	_, err = p.Get()
53
	require.NoError(t, err)
54
}
55

56
func TestPoolNoLimit(t *testing.T) {
57
	{
58
		p := rp.NewPool(func() interface{} {
59
			return 1
60
		}, 0)
61
		require.Equal(t, 0, p.Cap())
62
		require.Equal(t, 0, p.Len())
63
		require.Equal(t, 0, p.Idle())
64

65
		_, err := p.Get()
66
		require.ErrorIs(t, rp.ErrPoolLimit, err)
67
	}
68
	{
69
		p := rp.NewPool(func() interface{} {
70
			return 1
71
		}, -10)
72
		require.Equal(t, -10, p.Cap())
73
		require.Equal(t, 0, p.Len())
74
		require.Equal(t, -1, p.Idle())
75

76
		tasks := make([]func() error, 0, 10000)
77
		for range [10000]struct{}{} {
78
			tasks = append(tasks, func() error {
79
				_, err := p.Get()
80
				return err
81
			})
82
		}
83

84
		err := task.Run(context.Background(), tasks...)
85
		require.NoError(t, err)
86
	}
87
}
88

89
func BenchmarkPoolGetPut(b *testing.B) {
90
	benchmarkPoolGetPut(b, func(size, capacity int) rp.Pool {
91
		return rp.NewPool(func() interface{} {
92
			return make([]byte, size)
93
		}, capacity)
94
	})
95
}
96

97
func benchmarkPoolGetPut(b *testing.B, newPool func(zize, capacity int) rp.Pool) {
98
	const kb = 1 << 10
99
	const mb = 1 << 20
100

101
	cases := []struct {
102
		size int
103
	}{
104
		{kb * 2},
105
		{kb * 64},
106
		{kb * 512},
107
		{mb},
108
		{mb * 2},
109
		{mb * 4},
110
	}
111

112
	for _, cs := range cases {
113
		runtime.GC()
114
		b.ResetTimer()
115
		b.Run(fmt.Sprintf("%s-%s", humman(cs.size), "unlimited"), func(b *testing.B) {
116
			pool := newPool(cs.size, -1)
117
			b.ResetTimer()
118
			for ii := 0; ii <= b.N; ii++ {
119
				if val, err := pool.Get(); err == nil {
120
					pool.Put(val)
121
				}
122
			}
123
		})
124

125
		b.ResetTimer()
126
		b.Run(fmt.Sprintf("%s-%s", humman(cs.size), "with_1m"), func(b *testing.B) {
127
			pool := newPool(cs.size, 1000000)
128
			b.ResetTimer()
129
			for ii := 0; ii <= b.N; ii++ {
130
				if val, err := pool.Get(); err == nil {
131
					pool.Put(val)
132
				}
133
			}
134
		})
135

136
		b.ResetTimer()
137
		b.Run(fmt.Sprintf("%s-%s", humman(cs.size), "make"), func(b *testing.B) {
138
			b.ResetTimer()
139
			for ii := 0; ii <= b.N; ii++ {
140
				_ = make([]byte, cs.size)
141
			}
142
		})
143
	}
144
}
145