func benchmarkVariesInterval(d *helpers.DockerHelper) {
alive := d.GetContainerNum(false)
dead := d.GetContainerNum(true) - alive
containerIDs := d.GetContainerIDs()
cfg := variesIntervalConfig
listIntervals := cfg["list interval"].([]time.Duration)
listPeriod := cfg["list period"].(time.Duration)
func() {
defer d.LogError()
helpers.LogTitle("list_all")
helpers.LogEVar(map[string]interface{}{
"#alive": alive,
"#dead": dead,
"all": true,
"period": listPeriod,
})
helpers.LogLabels("interval")
for _, curInterval := range listIntervals {
latencies := d.DoListContainerBenchmark(curInterval, listPeriod, true)
helpers.LogResult(latencies, helpers.Itoas(int(curInterval/time.Millisecond))...)
}
}()
func() {
defer d.LogError()
helpers.LogTitle("list_alive")
helpers.LogEVar(map[string]interface{}{
"#alive": alive,
"#dead": dead,
"all": false,
"period": listPeriod,
})
helpers.LogLabels("interval")
for _, curInterval := range listIntervals {
latencies := d.DoListContainerBenchmark(curInterval, listPeriod, false)
helpers.LogResult(latencies, helpers.Itoas(int(curInterval/time.Millisecond))...)
}
}()
func() {
defer d.LogError()
inspectIntervals := cfg["inspect interval"].([]time.Duration)
inspectPeriod := cfg["inspect period"].(time.Duration)
helpers.LogTitle("inspect")
helpers.LogEVar(map[string]interface{}{
"#alive": alive,
"#dead": dead,
"period": inspectPeriod,
})
helpers.LogLabels("interval")
for _, curInterval := range inspectIntervals {
latencies := d.DoInspectContainerBenchmark(curInterval, inspectPeriod, containerIDs)
helpers.LogResult(latencies, helpers.Itoas(int(curInterval/time.Millisecond))...)
}
}()
}
func benchmarkContainerStart(d *helpers.DockerHelper) {
cfg := containerOpConfig
period := cfg["period"].(time.Duration)
routine := cfg["routine"].(int)
func() {
defer d.LogError()
helpers.LogTitle("container_op")
helpers.LogEVar(map[string]interface{}{
"period": period,
"routine": routine,
})
helpers.LogLabels("qps", "cps")
for _, q := range cfg["qps"].([]float64) {
start := time.Now()
latencies := d.DoParallelContainerStartBenchmark(q, period, routine)
cps := float64(len(latencies)) / time.Now().Sub(start).Seconds()
helpers.LogResult(latencies, helpers.Ftoas(q, cps)...)
start = time.Now()
latencies = d.DoParallelContainerStopBenchmark(q, routine)
cps = float64(len(latencies)) / time.Now().Sub(start).Seconds()
helpers.LogResult(latencies, helpers.Ftoas(q, cps)...)
}
}()
}
func benchmarkVariesContainerNumber(client *docker.Client) {
cfg := variesContainerNumConfig
deadContainers := cfg["dead"].([]int)
aliveContainers := cfg["alive"].([]int)
period := cfg["period"].(time.Duration)
interval := cfg["interval"].(time.Duration)
dead := deadContainers[0]
alive := aliveContainers[0]
ids := append(helpers.CreateDeadContainers(client, dead), helpers.CreateAliveContainers(client, alive)...)
helpers.LogTitle("varies_container")
helpers.LogEVar(map[string]interface{}{
"period": period,
"interval": interval,
})
helpers.LogLabels("#dead", "#alive", "#total")
for i, num := range append(deadContainers, aliveContainers...) {
if i < len(deadContainers) {
// Create more dead containers
ids = append(ids, helpers.CreateDeadContainers(client, num-dead)...)
dead = num
} else {
// Create more alive containers
ids = append(ids, helpers.CreateAliveContainers(client, num-alive)...)
alive = num
}
total := dead + alive
latencies := helpers.DoListContainerBenchmark(client, interval, period, true)
helpers.LogResult(latencies, helpers.Itoas(dead, alive, total)...)
latencies = helpers.DoListContainerBenchmark(client, interval, period, false)
helpers.LogResult(latencies, helpers.Itoas(dead, alive, total)...)
latencies = helpers.DoInspectContainerBenchmark(client, interval, period, ids)
helpers.LogResult(latencies, helpers.Itoas(dead, alive, total)...)
}
}
func benchmarkVariesRoutineNumber(d *helpers.DockerHelper) {
alive := d.GetContainerNum(false)
dead := d.GetContainerNum(true) - alive
containerIDs := d.GetContainerIDs()
cfg := variesRoutineNumConfig
routines := cfg["routines"].([]int)
period := cfg["period"].(time.Duration)
func() {
defer d.LogError()
listInterval := cfg["list interval"].(time.Duration)
helpers.LogTitle("list_all")
helpers.LogEVar(map[string]interface{}{
"#alive": alive,
"#dead": dead,
"all": true,
"interval": listInterval,
"period": period,
})
helpers.LogLabels("#routines")
for _, curRoutineNumber := range routines {
latencies := d.DoParallelListContainerBenchmark(listInterval, period, curRoutineNumber, true)
helpers.LogResult(latencies, helpers.Itoas(curRoutineNumber)...)
}
}()
func() {
defer d.LogError()
inspectInterval := cfg["inspect interval"].(time.Duration)
helpers.LogTitle("inspect")
helpers.LogEVar(map[string]interface{}{
"#alive": alive,
"#dead": dead,
"interval": inspectInterval,
"period": period,
})
helpers.LogLabels("#routines")
for _, curRoutineNumber := range routines {
latencies := d.DoParallelInspectContainerBenchmark(inspectInterval, period, curRoutineNumber, containerIDs)
helpers.LogResult(latencies, helpers.Itoas(curRoutineNumber)...)
}
}()
}