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
	"math/rand"
19
	"testing"
20
	"time"
21

22
	rp "github.com/cubefs/cubefs/blobstore/common/resourcepool"
23
	"github.com/stretchr/testify/require"
24
)
25

26
func TestChanPoolSizeLimited(t *testing.T) {
27
	p := rp.NewChanPool(func() []byte {
28
		return make([]byte, 1)
29
	}, -1)
30
	require.Equal(t, -1, p.Cap())
31

32
	b := make([]byte, 1)
33
	for range [1 << 23]struct{}{} {
34
		p.Put(b)
35
	}
36
	require.Equal(t, 1<<22, p.Idle())
37
}
38

39
func TestChanPoolRelease(t *testing.T) {
40
	rp.SetReleaseInterval(200 * time.Millisecond)
41
	defer rp.SetReleaseInterval(time.Minute * 2)
42

43
	p := rp.NewChanPool(func() []byte {
44
		return make([]byte, 1024)
45
	}, -1)
46

47
	for i := range [1000]struct{}{} {
48
		go func(i int) {
49
			buf, err := p.Get()
50
			require.NoError(t, err)
51
			time.Sleep(1 + time.Millisecond*time.Duration(rand.Intn(2000)))
52
			p.Put(buf)
53
		}(i)
54
	}
55
	time.Sleep(time.Second)
56
}
57

58
func TestChanPoolBase(t *testing.T) {
59
	makeN := 0
60
	p := rp.NewChanPool(func() []byte {
61
		makeN++
62
		return make([]byte, 1024)
63
	}, 2)
64

65
	require.Equal(t, 2, p.Cap())
66
	require.Equal(t, 0, p.Len())
67
	require.Equal(t, 0, p.Idle())
68

69
	_, err := p.Get()
70
	require.NoError(t, err)
71
	_, err = p.Get()
72
	require.NoError(t, err)
73

74
	require.Equal(t, 2, p.Cap())
75
	require.Equal(t, 2, p.Len())
76
	require.Equal(t, 0, p.Idle())
77

78
	buf, err := p.Get()
79
	require.NoError(t, err)
80
	require.Equal(t, 3, makeN)
81

82
	p.Put(buf)
83
	require.Equal(t, 1, p.Idle())
84
	_, err = p.Get()
85
	require.NoError(t, err)
86
	require.Equal(t, 3, makeN)
87
	require.Equal(t, 0, p.Idle())
88
}
89

90
func TestChanPoolNoLimit(t *testing.T) {
91
	{
92
		makeN := 0
93
		p := rp.NewChanPool(func() []byte {
94
			makeN++
95
			return make([]byte, 1024)
96
		}, 0)
97
		require.Equal(t, 0, p.Cap())
98

99
		_, err := p.Get()
100
		require.NoError(t, err)
101
		require.Equal(t, 1, makeN)
102
	}
103
	{
104
		p := rp.NewChanPool(func() []byte {
105
			return make([]byte, 1024)
106
		}, -1)
107
		require.Equal(t, -1, p.Cap())
108
		require.Equal(t, 0, p.Idle())
109

110
		for range [1000]struct{}{} {
111
			buf, err := p.Get()
112
			require.NoError(t, err)
113
			p.Put(buf)
114
		}
115
		require.Equal(t, 1, p.Idle())
116
	}
117
}
118

119
func BenchmarkChanPoolGetPut(b *testing.B) {
120
	benchmarkPoolGetPut(b, func(size, capacity int) rp.Pool {
121
		return rp.NewChanPool(func() []byte {
122
			return make([]byte, size)
123
		}, capacity)
124
	})
125
}
126