status-im
/
go-watchdog
mirror of https://github.com/status-im/go-watchdog.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
go-watchdog/adaptive_test.go

29 lines
603 B
Go
Raw Normal View History

major rewrite of go-watchdog. This commit introduces a major rewrite of go-watchdog. * HeapDriven and SystemDriven are now distinct run modes. * WIP ProcessDriven that uses cgroups. * Policies are now stateless, pure and greatly simplified. * Policies now return the next utilization at which GC should run. The watchdog enforces that value differently depending on the run mode. * The heap-driven run mode adjusts GOGC dynamically. This places the responsibility on the Go runtime to honour the trigger point, and results in more robust logic that is not vulnerable to very quick bursts within sampling periods. * The heap-driven run mode is no longer polling (interval-driven). Instead, it relies entirely on GC signals. * The Silence and Emergency features of the watermark policy have been removed. If utilization is above the last watermark, the policy will request immediate GC. * Races removed.
2020-12-04 13:08:00 +00:00
package watchdog
import (
"testing"
"github.com/raulk/clock"
"github.com/stretchr/testify/require"
)
func TestAdaptivePolicy(t *testing.T) {
clk := clock.NewMock()
Clock = clk
implement automatic heapdumps when usage is above threshold. A heapdump will be captured when the usage trespasses the threshold. Staying above the threshold won't trigger another heapdump. If the usage goes down, then back up, that is considered another "episode" to be captured in a heapdump. This feature is driven by three parameters: * HeapdumpDir: the directory where the watchdog will write the heapdump. It will be created if it doesn't exist upon initialization. An error when creating the dir will not prevent heapdog initialization; it will just disable the heapdump capture feature. If zero-valued, the feature is disabled. Heapdumps will be written to path: <HeapdumpDir>/<RFC3339Nano formatted timestamp>.heap. * HeapdumpMaxCaptures: sets the maximum amount of heapdumps a process will generate. This limits the amount of episodes that will be captured, in case the utilization climbs repeatedly over the threshold. By default, it is 10. * HeapdumpThreshold: sets the utilization threshold that will trigger a heap dump to be taken automatically. A zero value disables this feature. By default, it is disabled.
2021-01-19 19:38:46 +00:00
p, err := NewAdaptivePolicy(0.5)(limit64MiB)
major rewrite of go-watchdog. This commit introduces a major rewrite of go-watchdog. * HeapDriven and SystemDriven are now distinct run modes. * WIP ProcessDriven that uses cgroups. * Policies are now stateless, pure and greatly simplified. * Policies now return the next utilization at which GC should run. The watchdog enforces that value differently depending on the run mode. * The heap-driven run mode adjusts GOGC dynamically. This places the responsibility on the Go runtime to honour the trigger point, and results in more robust logic that is not vulnerable to very quick bursts within sampling periods. * The heap-driven run mode is no longer polling (interval-driven). Instead, it relies entirely on GC signals. * The Silence and Emergency features of the watermark policy have been removed. If utilization is above the last watermark, the policy will request immediate GC. * Races removed.
2020-12-04 13:08:00 +00:00
require.NoError(t, err)
// at zero; next = 50%.
remove 'immediate' flag in policies.
2020-12-09 15:35:23 +00:00
next := p.Evaluate(UtilizationSystem, 0)
implement automatic heapdumps when usage is above threshold. A heapdump will be captured when the usage trespasses the threshold. Staying above the threshold won't trigger another heapdump. If the usage goes down, then back up, that is considered another "episode" to be captured in a heapdump. This feature is driven by three parameters: * HeapdumpDir: the directory where the watchdog will write the heapdump. It will be created if it doesn't exist upon initialization. An error when creating the dir will not prevent heapdog initialization; it will just disable the heapdump capture feature. If zero-valued, the feature is disabled. Heapdumps will be written to path: <HeapdumpDir>/<RFC3339Nano formatted timestamp>.heap. * HeapdumpMaxCaptures: sets the maximum amount of heapdumps a process will generate. This limits the amount of episodes that will be captured, in case the utilization climbs repeatedly over the threshold. By default, it is 10. * HeapdumpThreshold: sets the utilization threshold that will trigger a heap dump to be taken automatically. A zero value disables this feature. By default, it is disabled.
2021-01-19 19:38:46 +00:00
require.EqualValues(t, limit64MiB/2, next)
major rewrite of go-watchdog. This commit introduces a major rewrite of go-watchdog. * HeapDriven and SystemDriven are now distinct run modes. * WIP ProcessDriven that uses cgroups. * Policies are now stateless, pure and greatly simplified. * Policies now return the next utilization at which GC should run. The watchdog enforces that value differently depending on the run mode. * The heap-driven run mode adjusts GOGC dynamically. This places the responsibility on the Go runtime to honour the trigger point, and results in more robust logic that is not vulnerable to very quick bursts within sampling periods. * The heap-driven run mode is no longer polling (interval-driven). Instead, it relies entirely on GC signals. * The Silence and Emergency features of the watermark policy have been removed. If utilization is above the last watermark, the policy will request immediate GC. * Races removed.
2020-12-04 13:08:00 +00:00
// at half; next = 75%.
implement automatic heapdumps when usage is above threshold. A heapdump will be captured when the usage trespasses the threshold. Staying above the threshold won't trigger another heapdump. If the usage goes down, then back up, that is considered another "episode" to be captured in a heapdump. This feature is driven by three parameters: * HeapdumpDir: the directory where the watchdog will write the heapdump. It will be created if it doesn't exist upon initialization. An error when creating the dir will not prevent heapdog initialization; it will just disable the heapdump capture feature. If zero-valued, the feature is disabled. Heapdumps will be written to path: <HeapdumpDir>/<RFC3339Nano formatted timestamp>.heap. * HeapdumpMaxCaptures: sets the maximum amount of heapdumps a process will generate. This limits the amount of episodes that will be captured, in case the utilization climbs repeatedly over the threshold. By default, it is 10. * HeapdumpThreshold: sets the utilization threshold that will trigger a heap dump to be taken automatically. A zero value disables this feature. By default, it is disabled.
2021-01-19 19:38:46 +00:00
next = p.Evaluate(UtilizationSystem, limit64MiB/2)
require.EqualValues(t, 3*(limit64MiB/4), next)
major rewrite of go-watchdog. This commit introduces a major rewrite of go-watchdog. * HeapDriven and SystemDriven are now distinct run modes. * WIP ProcessDriven that uses cgroups. * Policies are now stateless, pure and greatly simplified. * Policies now return the next utilization at which GC should run. The watchdog enforces that value differently depending on the run mode. * The heap-driven run mode adjusts GOGC dynamically. This places the responsibility on the Go runtime to honour the trigger point, and results in more robust logic that is not vulnerable to very quick bursts within sampling periods. * The heap-driven run mode is no longer polling (interval-driven). Instead, it relies entirely on GC signals. * The Silence and Emergency features of the watermark policy have been removed. If utilization is above the last watermark, the policy will request immediate GC. * Races removed.
2020-12-04 13:08:00 +00:00
fix sed replace that overreached.
2021-01-20 10:41:55 +00:00
// at limit.
implement automatic heapdumps when usage is above threshold. A heapdump will be captured when the usage trespasses the threshold. Staying above the threshold won't trigger another heapdump. If the usage goes down, then back up, that is considered another "episode" to be captured in a heapdump. This feature is driven by three parameters: * HeapdumpDir: the directory where the watchdog will write the heapdump. It will be created if it doesn't exist upon initialization. An error when creating the dir will not prevent heapdog initialization; it will just disable the heapdump capture feature. If zero-valued, the feature is disabled. Heapdumps will be written to path: <HeapdumpDir>/<RFC3339Nano formatted timestamp>.heap. * HeapdumpMaxCaptures: sets the maximum amount of heapdumps a process will generate. This limits the amount of episodes that will be captured, in case the utilization climbs repeatedly over the threshold. By default, it is 10. * HeapdumpThreshold: sets the utilization threshold that will trigger a heap dump to be taken automatically. A zero value disables this feature. By default, it is disabled.
2021-01-19 19:38:46 +00:00
next = p.Evaluate(UtilizationSystem, limit64MiB)
require.EqualValues(t, limit64MiB, next)
major rewrite of go-watchdog. This commit introduces a major rewrite of go-watchdog. * HeapDriven and SystemDriven are now distinct run modes. * WIP ProcessDriven that uses cgroups. * Policies are now stateless, pure and greatly simplified. * Policies now return the next utilization at which GC should run. The watchdog enforces that value differently depending on the run mode. * The heap-driven run mode adjusts GOGC dynamically. This places the responsibility on the Go runtime to honour the trigger point, and results in more robust logic that is not vulnerable to very quick bursts within sampling periods. * The heap-driven run mode is no longer polling (interval-driven). Instead, it relies entirely on GC signals. * The Silence and Emergency features of the watermark policy have been removed. If utilization is above the last watermark, the policy will request immediate GC. * Races removed.
2020-12-04 13:08:00 +00:00
}