TrueCloudLab/frostfs-node
20
1
Fork 27
Code Issues 101 Pull requests 5 Projects Releases 1 Activity Actions

timer: Remove unused OnDelta() method
Some checks failed
Tests and linters / Run gofumpt (pull_request) Successful in 2m19s
Details
Vulncheck / Vulncheck (pull_request) Successful in 2m19s
Details
DCO action / DCO (pull_request) Failing after 2m31s
Details
Pre-commit hooks / Pre-commit (pull_request) Successful in 2m51s
Details
Tests and linters / gopls check (pull_request) Successful in 3m28s
Details
Build / Build Components (pull_request) Successful in 3m31s
Details
Tests and linters / Staticcheck (pull_request) Successful in 3m42s
Details
Tests and linters / Lint (pull_request) Successful in 4m34s
Details
Tests and linters / Tests (pull_request) Successful in 6m52s
Details
Tests and linters / Tests with -race (pull_request) Successful in 6m55s
Details

Browse source 
Signed-off-by: Evgenii Stratonikov <e.stratonikov@yadro.com>
This commit is contained in:
Evgenii Stratonikov 2024-11-20 10:43:38 +03:00
parent 9f4ce600ac
commit 006401fc3e
Signed by: fyrchik
SSH key fingerprint: SHA256:m/TTwCzjnRkXgnzEx9X92ccxy1CcVeinOgDb3NPWWmg
2 changed files with 17 additions and 196 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

71
pkg/morph/timer/block.go
View file

@ -15,41 +15,19 @@ type BlockTickHandler func()
// It can tick the blocks and perform certain actions
// on block time intervals.
type BlockTimer struct {
rolledBack bool
mtx sync.Mutex
dur BlockMeter
baseDur uint32
mul, div uint32
cur, tgt uint32
last uint32
h BlockTickHandler
ps []BlockTimer
once bool
deltaCfg
}
// DeltaOption is an option of delta-interval handler.
type DeltaOption func(*deltaCfg)
type deltaCfg struct {
pulse bool
}
// WithPulse returns option to call delta-interval handler multiple times.
func WithPulse() DeltaOption {
return func(c *deltaCfg) {
c.pulse = true
}
}
// StaticBlockMeter returns BlockMeters that always returns (d, nil).
@ -65,12 +43,7 @@ func StaticBlockMeter(d uint32) BlockMeter {
func NewBlockTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
return &BlockTimer{
dur: dur,
mul: 1,
div: 1,
h: h,
deltaCfg: deltaCfg{
pulse: true,
},
}
}
@ -80,37 +53,11 @@ func NewBlockTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
func NewOneTickTimer(dur BlockMeter, h BlockTickHandler) *BlockTimer {
return &BlockTimer{
dur: dur,
mul: 1,
div: 1,
h: h,
once: true,
}
}
// OnDelta registers handler which is executed on (mul / div * BlockMeter()) block
// after basic interval reset.
//
// If WithPulse option is provided, handler is executed (mul / div * BlockMeter()) block
// during base interval.
func (t *BlockTimer) OnDelta(mul, div uint32, h BlockTickHandler, opts ...DeltaOption) {
c := deltaCfg{
pulse: false,
}
for i := range opts {
opts[i](&c)
}
t.ps = append(t.ps, BlockTimer{
mul: mul,
div: div,
h: h,
once: t.once,
deltaCfg: c,
})
}
// Reset resets previous ticks of the BlockTimer.
//
// Returns BlockMeter's error upon occurrence.
@ -124,29 +71,18 @@ func (t *BlockTimer) Reset() error {
t.resetWithBaseInterval(d)
for i := range t.ps {
t.ps[i].resetWithBaseInterval(d)
}
t.mtx.Unlock()
return nil
}
func (t *BlockTimer) resetWithBaseInterval(d uint32) {
t.rolledBack = false
t.baseDur = d
t.reset()
}
func (t *BlockTimer) reset() {
mul, div := t.mul, t.div
if !t.pulse && t.rolledBack && mul < div {
mul, div = 1, 1
}
delta := mul * t.baseDur / div
delta := t.baseDur
if delta == 0 {
delta = 1
}
@ -180,12 +116,7 @@ func (t *BlockTimer) tick(h uint32) {
if !t.once {
t.cur = 0
t.rolledBack = true
t.reset()
}
}
for i := range t.ps {
t.ps[i].tick(h)
}
}

142
pkg/morph/timer/block_test.go
View file

@ -63,85 +63,6 @@ func TestBlockTimer(t *testing.T) {
tickN(bt, intervalNum*blockDur)
require.Equal(t, intervalNum, uint32(baseCallCounter))
// add half-interval handler
halfCallCounter := uint32(0)
bt.OnDelta(1, 2, func() {
halfCallCounter++
})
// add double interval handler
doubleCallCounter := uint32(0)
bt.OnDelta(2, 1, func() {
doubleCallCounter++
})
require.NoError(t, bt.Reset())
baseCallCounter = 0
intervalNum = 20
tickN(bt, intervalNum*blockDur)
require.Equal(t, intervalNum, uint32(halfCallCounter))
require.Equal(t, intervalNum, uint32(baseCallCounter))
require.Equal(t, intervalNum/2, uint32(doubleCallCounter))
}
func TestDeltaPulse(t *testing.T) {
blockDur := uint32(9)
baseCallCounter := uint32(0)
bt := timer.NewBlockTimer(timer.StaticBlockMeter(blockDur), func() {
baseCallCounter++
})
deltaCallCounter := uint32(0)
div := uint32(3)
bt.OnDelta(1, div, func() {
deltaCallCounter++
}, timer.WithPulse())
require.NoError(t, bt.Reset())
intervalNum := uint32(7)
tickN(bt, intervalNum*blockDur)
require.Equal(t, intervalNum, uint32(baseCallCounter))
require.Equal(t, intervalNum*div, uint32(deltaCallCounter))
}
func TestDeltaReset(t *testing.T) {
blockDur := uint32(6)
baseCallCounter := 0
bt := timer.NewBlockTimer(timer.StaticBlockMeter(blockDur), func() {
baseCallCounter++
})
detlaCallCounter := 0
bt.OnDelta(1, 3, func() {
detlaCallCounter++
})
require.NoError(t, bt.Reset())
tickN(bt, 6)
require.Equal(t, 1, baseCallCounter)
require.Equal(t, 1, detlaCallCounter)
require.NoError(t, bt.Reset())
tickN(bt, 3)
require.Equal(t, 2, detlaCallCounter)
}
func TestNewOneTickTimer(t *testing.T) {
@ -168,82 +89,51 @@ func TestNewOneTickTimer(t *testing.T) {
tickN(bt, 10)
require.Equal(t, 1, baseCallCounter)
})
t.Run("delta without pulse", func(t *testing.T) {
blockDur = uint32(10)
baseCallCounter = 0
bt = timer.NewOneTickTimer(timer.StaticBlockMeter(blockDur), func() {
baseCallCounter++
})
detlaCallCounter := 0
bt.OnDelta(1, 10, func() {
detlaCallCounter++
})
require.NoError(t, bt.Reset())
tickN(bt, 10)
require.Equal(t, 1, baseCallCounter)
require.Equal(t, 1, detlaCallCounter)
tickN(bt, 10) // 10 more ticks must not affect counters
require.Equal(t, 1, baseCallCounter)
require.Equal(t, 1, detlaCallCounter)
})
}
func TestBlockTimer_TickSameHeight(t *testing.T) {
var baseCounter, deltaCounter int
var baseCounter int
blockDur := uint32(2)
bt := timer.NewBlockTimer(
func() (uint32, error) { return blockDur, nil },
func() { baseCounter++ })
bt.OnDelta(2, 1, func() {
deltaCounter++
})
require.NoError(t, bt.Reset())
check := func(t *testing.T, h uint32, base, delta int) {
check := func(t *testing.T, h uint32, base int) {
for range 2 * int(blockDur) {
bt.Tick(h)
require.Equal(t, base, baseCounter)
require.Equal(t, delta, deltaCounter)
}
}
check(t, 1, 0, 0)
check(t, 2, 1, 0)
check(t, 3, 1, 0)
check(t, 4, 2, 1)
check(t, 1, 0)
check(t, 2, 1)
check(t, 3, 1)
check(t, 4, 2)
t.Run("works the same way after `Reset()`", func(t *testing.T) {
t.Run("same block duration", func(t *testing.T) {
require.NoError(t, bt.Reset())
baseCounter = 0
deltaCounter = 0
check(t, 1, 0, 0)
check(t, 2, 1, 0)
check(t, 3, 1, 0)
check(t, 4, 2, 1)
check(t, 1, 0)
check(t, 2, 1)
check(t, 3, 1)
check(t, 4, 2)
})
t.Run("different block duration", func(t *testing.T) {
blockDur = 3
require.NoError(t, bt.Reset())
baseCounter = 0
deltaCounter = 0
check(t, 1, 0, 0)
check(t, 2, 0, 0)
check(t, 3, 1, 0)
check(t, 4, 1, 0)
check(t, 5, 1, 0)
check(t, 6, 2, 1)
check(t, 1, 0)
check(t, 2, 0)
check(t, 3, 1)
check(t, 4, 1)
check(t, 5, 1)
check(t, 6, 2)
})
})
}