mirror of
https://github.com/ClusterCockpit/cc-metric-store.git
synced 2024-11-10 05:07:25 +01:00
503 lines
12 KiB
Go
503 lines
12 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"log"
|
|
"math"
|
|
"testing"
|
|
)
|
|
|
|
var testMetrics [][]Metric = [][]Metric{
|
|
{{"flops", 100.5}, {"mem_bw", 2088.67}},
|
|
{{"flops", 180.5}, {"mem_bw", 4078.32}, {"mem_capacity", 1020}},
|
|
{{"flops", 980.5}, {"mem_bw", 9078.32}, {"mem_capacity", 5010}},
|
|
{{"flops", 940.5}, {"mem_bw", 9278.32}, {"mem_capacity", 6010}},
|
|
{{"flops", 930.5}, {"mem_bw", 9378.32}, {"mem_capacity", 7010}},
|
|
{{"flops", 980.5}, {"mem_bw", 9478.32}, {"mem_capacity", 8010}},
|
|
{{"flops", 980.5}, {"mem_bw", 9478.32}, {"mem_capacity", 8010}},
|
|
{{"flops", 980.5}, {"mem_bw", 9478.32}, {"mem_capacity", 8010}},
|
|
{{"flops", 970.5}, {"mem_bw", 9178.32}, {"mem_capacity", 2010}},
|
|
{{"flops", 970.5}, {"mem_bw", 9178.32}, {"mem_capacity", 2010}}}
|
|
|
|
var testMetricsAlt [][]Metric = [][]Metric{
|
|
{{"flops", 120.5}, {"mem_bw", 2080.67}},
|
|
{{"flops", 130.5}, {"mem_bw", 4071.32}, {"mem_capacity", 1120}},
|
|
{{"flops", 940.5}, {"mem_bw", 9072.32}, {"mem_capacity", 5210}},
|
|
{{"flops", 950.5}, {"mem_bw", 9273.32}, {"mem_capacity", 6310}},
|
|
{{"flops", 960.5}, {"mem_bw", 9374.32}, {"mem_capacity", 7410}},
|
|
{{"flops", 970.5}, {"mem_bw", 9475.32}, {"mem_capacity", 8510}},
|
|
{{"flops", 990.5}, {"mem_bw", 9476.32}, {"mem_capacity", 8610}},
|
|
{{"flops", 910.5}, {"mem_bw", 9477.32}, {"mem_capacity", 8710}},
|
|
{{"flops", 920.5}, {"mem_bw", 9178.32}, {"mem_capacity", 2810}},
|
|
{{"flops", 930.5}, {"mem_bw", 9179.32}, {"mem_capacity", 2910}}}
|
|
|
|
func dumpStoreBuffer(s *storeBuffer) {
|
|
log.Printf("Start TS %d\n", s.start)
|
|
ctr := 0
|
|
|
|
for _, val := range s.store {
|
|
fmt.Printf("%f\t", val)
|
|
ctr++
|
|
|
|
if ctr == 10 {
|
|
fmt.Printf("\n")
|
|
ctr = 0
|
|
}
|
|
}
|
|
}
|
|
|
|
func printMemStore(m *MemoryStore) {
|
|
log.Println("########################")
|
|
log.Printf("Frequency %d, Metrics %d Slots %d\n",
|
|
m.frequency, m.numMetrics, m.numSlots)
|
|
log.Println("##Offsets")
|
|
for key, val := range m.offsets {
|
|
log.Printf("\t%s = %d\n", key, val)
|
|
}
|
|
log.Println("##Containers")
|
|
for key, c := range m.containers {
|
|
log.Printf("ID %s\n", key)
|
|
log.Println("###current")
|
|
dumpStoreBuffer(c.current)
|
|
log.Println("###next")
|
|
dumpStoreBuffer(c.next)
|
|
}
|
|
log.Println("########################")
|
|
}
|
|
|
|
//############################
|
|
//#### Whitebox tests ########
|
|
//############################
|
|
func TestAddMetricSimple(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
// printMemStore(m)
|
|
|
|
m.AddMetrics(key, 1584022800, testMetrics[0])
|
|
m.AddMetrics(key, 1584022890, testMetrics[1])
|
|
|
|
want := testMetrics[0][0].Value
|
|
got := m.containers[key].current.store[0]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
|
|
want = testMetrics[1][2].Value
|
|
got = m.containers[key].current.store[21]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
// printMemStore(m)
|
|
}
|
|
|
|
func TestAddMetricReplace(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
// printMemStore(m)
|
|
|
|
m.AddMetrics(key, 1584022800, testMetrics[0])
|
|
m.AddMetrics(key, 1584022800, testMetrics[1])
|
|
|
|
want := testMetrics[1][0].Value
|
|
got := m.containers[key].current.store[0]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
|
|
m.AddMetrics(key, 1584022850, testMetrics[0])
|
|
want = testMetrics[0][0].Value
|
|
got = m.containers[key].current.store[0]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
|
|
m.AddMetrics(key, 1584022860, testMetrics[1])
|
|
want = testMetrics[0][0].Value
|
|
got = m.containers[key].current.store[0]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
// printMemStore(m)
|
|
}
|
|
|
|
func TestAddMetricSwitch(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
// printMemStore(m)
|
|
|
|
m.AddMetrics(key, 1584023000, testMetrics[0])
|
|
m.AddMetrics(key, 1584023580, testMetrics[1])
|
|
|
|
want := testMetrics[1][2].Value
|
|
got := m.containers[key].current.store[29]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
|
|
m.AddMetrics(key, 1584023600, testMetrics[2])
|
|
want = testMetrics[2][2].Value
|
|
got = m.containers[key].current.store[20]
|
|
if got != want {
|
|
t.Errorf("Want %f got %f\n", want, got)
|
|
}
|
|
|
|
// printMemStore(m)
|
|
}
|
|
|
|
//############################
|
|
//#### Blackbox tests ########
|
|
//############################
|
|
|
|
func TestAddMetricOutOfBounds(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 30, 60)
|
|
|
|
err := m.AddMetrics(key, 1584023000, testMetrics[0])
|
|
if err != nil {
|
|
t.Errorf("Got error 1584023000\n")
|
|
}
|
|
err = m.AddMetrics(key, 1584026600, testMetrics[0])
|
|
if err == nil {
|
|
t.Errorf("Got no error 1584026600\n")
|
|
}
|
|
err = m.AddMetrics(key, 1584021580, testMetrics[1])
|
|
if err == nil {
|
|
t.Errorf("Got no error 1584021580\n")
|
|
}
|
|
err = m.AddMetrics(key, 1584024580, testMetrics[1])
|
|
if err != nil {
|
|
t.Errorf("Got error 1584024580\n")
|
|
}
|
|
err = m.AddMetrics(key, 1584091580, testMetrics[1])
|
|
if err == nil {
|
|
t.Errorf("Got no error 1584091580\n")
|
|
}
|
|
err = m.AddMetrics(key, 1584024780, testMetrics[0])
|
|
if err != nil {
|
|
t.Errorf("Got error 1584024780\n")
|
|
}
|
|
}
|
|
|
|
func TestGetMetricPlainCurrent(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023000, 1584023560)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 9 {
|
|
t.Errorf("Want 9. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
if val[8] != 970.5 {
|
|
t.Errorf("Want 970.5 Got %f\n", val[9])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricPlainNext(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023000, 1584023560)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 9 {
|
|
t.Errorf("Want 9. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
if val[8] != 970.5 {
|
|
t.Errorf("Want 970.5 Got %f\n", val[9])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricGap(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*120), testMetrics[i])
|
|
}
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023000, 1584023600)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 10 {
|
|
t.Errorf("Want 10. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
if !math.IsNaN(val[1]) {
|
|
t.Errorf("Want NaN Got %f\n", val[1])
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
|
|
// fmt.Println(val)
|
|
}
|
|
|
|
func TestGetMetricSplit(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023200, 1584023860)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023200 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 11 {
|
|
t.Errorf("Want 11. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 940.5 {
|
|
t.Errorf("Want 940.5 Got %f\n", val[0])
|
|
}
|
|
if val[10] != 950.5 {
|
|
t.Errorf("Want 950.5 Got %f\n", val[0])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricExceedNext(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584022800, 1584023400)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 6 {
|
|
t.Errorf("Want 6. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
if val[5] != 980.5 {
|
|
t.Errorf("Want 980.5 Got %f\n", val[5])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricExceedNextSplit(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584022800, 1584023900)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 15 {
|
|
t.Errorf("Want 14. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 100.5 Got %f\n", val[0])
|
|
}
|
|
if val[14] != 960.5 {
|
|
t.Errorf("Want 960.5 Got %f\n", val[13])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricExceedCurrent(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023800, 1584027900)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023800 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 7 {
|
|
t.Errorf("Want 6. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 950.5 {
|
|
t.Errorf("Want 950.5 Got %f\n", val[0])
|
|
}
|
|
if val[6] != 930.5 {
|
|
t.Errorf("Want 930.5 Got %f\n", val[5])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricExceedCurrentSplit(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584023120, 1584027900)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023120 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 18 {
|
|
t.Errorf("Want 18. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 980.5 {
|
|
t.Errorf("Want 950.5 Got %f\n", val[0])
|
|
}
|
|
if val[17] != 930.5 {
|
|
t.Errorf("Want 930.5 Got %f\n", val[17])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricExceedBoth(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
val, tsFrom, err := m.GetMetric(key, "flops", 1584022800, 1584027900)
|
|
|
|
if err != nil {
|
|
t.Errorf("Got error\n")
|
|
}
|
|
if tsFrom != 1584023000 {
|
|
t.Errorf("Start ts differs: %d\n", tsFrom)
|
|
}
|
|
if len(val) != 20 {
|
|
t.Errorf("Want 20. Got %d\n", len(val))
|
|
}
|
|
if val[0] != 100.5 {
|
|
t.Errorf("Want 950.5 Got %f\n", val[0])
|
|
}
|
|
if val[19] != 930.5 {
|
|
t.Errorf("Want 930.5 Got %f\n", val[17])
|
|
}
|
|
}
|
|
|
|
func TestGetMetricOutUpper(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
_, _, err := m.GetMetric(key, "flops", 1584032800, 1584037900)
|
|
|
|
if err == nil {
|
|
t.Errorf("Got no error\n")
|
|
}
|
|
}
|
|
|
|
func TestGetMetricOutLower(t *testing.T) {
|
|
key := "m1220"
|
|
m := newMemoryStore([]string{"flops", "mem_bw", "mem_capacity"}, 10, 60)
|
|
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023000+i*60), testMetrics[i])
|
|
}
|
|
for i := 0; i < len(testMetrics); i++ {
|
|
m.AddMetrics(key, int64(1584023600+i*60), testMetricsAlt[i])
|
|
}
|
|
|
|
// printMemStore(m)
|
|
|
|
_, _, err := m.GetMetric(key, "flops", 1584002800, 1584007900)
|
|
|
|
if err == nil {
|
|
t.Errorf("Got no error\n")
|
|
}
|
|
}
|