jasder
/
runc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Make all cgroup stats output int64s instead of float64. 

Docker-DCO-1.1-Signed-off-by: Victor Marmol <vmarmol@google.com> (github: vmarmol)
This commit is contained in:
Victor Marmol 2014-05-22 20:50:51 +00:00
parent ed1c71fa15
commit 6521880a83
15 changed files with 72 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
cgroups/fs/apply_raw.go
View File

@ -26,7 +26,7 @@ var (
type subsystem interface { type subsystem interface {
Set(*data) error Set(*data) error
Remove(*data) error Remove(*data) error
Stats(*data) (map[string]float64, error) Stats(*data) (map[string]int64, error)
} }
type data struct { type data struct {
@ -74,7 +74,7 @@ func Apply(c *cgroups.Cgroup, pid int) (cgroups.ActiveCgroup, error) {
return d, nil return d, nil
} }
func GetStats(c *cgroups.Cgroup, subsystem string, pid int) (map[string]float64, error) { func GetStats(c *cgroups.Cgroup, subsystem string, pid int) (map[string]int64, error) {
cgroupRoot, err := cgroups.FindCgroupMountpoint("cpu") cgroupRoot, err := cgroups.FindCgroupMountpoint("cpu")
if err != nil { if err != nil {
return nil, err return nil, err

8
cgroups/fs/blkio.go
View File

@ -57,9 +57,9 @@ examples:
8:0 Total 0 8:0 Total 0
Total 0 Total 0
*/ */
func (s *blkioGroup) Stats(d *data) (map[string]float64, error) { func (s *blkioGroup) Stats(d *data) (map[string]int64, error) {
var ( var (
paramData = make(map[string]float64) paramData = make(map[string]int64)
params = []string{ params = []string{
"io_service_bytes_recursive", "io_service_bytes_recursive",
"io_serviced_recursive", "io_serviced_recursive",
@ -91,7 +91,7 @@ func (s *blkioGroup) Stats(d *data) (map[string]float64, error) {
fields := strings.Fields(sc.Text()) fields := strings.Fields(sc.Text())
switch len(fields) { switch len(fields) {
case 3: case 3:
v, err := strconv.ParseFloat(fields[2], 64) v, err := strconv.ParseInt(fields[2], 10, 64)
if err != nil { if err != nil {
return nil, err return nil, err
} }
@ -106,7 +106,7 @@ func (s *blkioGroup) Stats(d *data) (map[string]float64, error) {
return paramData, nil return paramData, nil
} }
func (s *blkioGroup) getSectors(path string) (string, float64, error) { func (s *blkioGroup) getSectors(path string) (string, int64, error) {
f, err := os.Open(filepath.Join(path, "blkio.sectors_recursive")) f, err := os.Open(filepath.Join(path, "blkio.sectors_recursive"))
if err != nil { if err != nil {
return "", 0, err return "", 0, err

34
cgroups/fs/blkio_test.go
View File

@ -43,29 +43,29 @@ func TestBlkioStats(t *testing.T) {
} }
// Verify expected stats. // Verify expected stats.
expectedStats := map[string]float64{ expectedStats := map[string]int64{
"blkio.sectors_recursive:8:0": 1024.0, "blkio.sectors_recursive:8:0": 1024,
// Serviced bytes. // Serviced bytes.
"io_service_bytes_recursive:8:0:Read": 100.0, "io_service_bytes_recursive:8:0:Read": 100,
"io_service_bytes_recursive:8:0:Write": 400.0, "io_service_bytes_recursive:8:0:Write": 400,
"io_service_bytes_recursive:8:0:Sync": 200.0, "io_service_bytes_recursive:8:0:Sync": 200,
"io_service_bytes_recursive:8:0:Async": 300.0, "io_service_bytes_recursive:8:0:Async": 300,
"io_service_bytes_recursive:8:0:Total": 500.0, "io_service_bytes_recursive:8:0:Total": 500,
// Serviced requests. // Serviced requests.
"io_serviced_recursive:8:0:Read": 10.0, "io_serviced_recursive:8:0:Read": 10,
"io_serviced_recursive:8:0:Write": 40.0, "io_serviced_recursive:8:0:Write": 40,
"io_serviced_recursive:8:0:Sync": 20.0, "io_serviced_recursive:8:0:Sync": 20,
"io_serviced_recursive:8:0:Async": 30.0, "io_serviced_recursive:8:0:Async": 30,
"io_serviced_recursive:8:0:Total": 50.0, "io_serviced_recursive:8:0:Total": 50,
// Queued requests. // Queued requests.
"io_queued_recursive:8:0:Read": 1.0, "io_queued_recursive:8:0:Read": 1,
"io_queued_recursive:8:0:Write": 4.0, "io_queued_recursive:8:0:Write": 4,
"io_queued_recursive:8:0:Sync": 2.0, "io_queued_recursive:8:0:Sync": 2,
"io_queued_recursive:8:0:Async": 3.0, "io_queued_recursive:8:0:Async": 3,
"io_queued_recursive:8:0:Total": 5.0, "io_queued_recursive:8:0:Total": 5,
} }
expectStats(t, expectedStats, stats) expectStats(t, expectedStats, stats)
} }

4
cgroups/fs/cpu.go
View File

@ -39,8 +39,8 @@ func (s *cpuGroup) Remove(d *data) error {
return removePath(d.path("cpu")) return removePath(d.path("cpu"))
} }
func (s *cpuGroup) Stats(d *data) (map[string]float64, error) { func (s *cpuGroup) Stats(d *data) (map[string]int64, error) {
paramData := make(map[string]float64) paramData := make(map[string]int64)
path, err := d.path("cpu") path, err := d.path("cpu")
if err != nil { if err != nil {
return nil, err return nil, err

8
cgroups/fs/cpu_test.go
View File

@ -20,10 +20,10 @@ func TestCpuStats(t *testing.T) {
t.Fatal(err) t.Fatal(err)
} }
expected_stats := map[string]float64{ expected_stats := map[string]int64{
"nr_periods": 2000.0, "nr_periods": 2000,
"nr_throttled": 200.0, "nr_throttled": 200,
"throttled_time": 42424242424.0, "throttled_time": 42424242424,
} }
expectStats(t, expected_stats, stats) expectStats(t, expected_stats, stats)
} }

43
cgroups/fs/cpuacct.go
View File

@ -15,8 +15,8 @@ import (
) )
var ( var (
cpuCount = float64(runtime.NumCPU()) cpuCount = int64(runtime.NumCPU())
clockTicks = float64(system.GetClockTicks()) clockTicks = int64(system.GetClockTicks())
) )
type cpuacctGroup struct { type cpuacctGroup struct {
@ -34,11 +34,11 @@ func (s *cpuacctGroup) Remove(d *data) error {
return removePath(d.path("cpuacct")) return removePath(d.path("cpuacct"))
} }
func (s *cpuacctGroup) Stats(d *data) (map[string]float64, error) { func (s *cpuacctGroup) Stats(d *data) (map[string]int64, error) {
var ( var (
startCpu, lastCpu, startSystem, lastSystem, startUsage, lastUsage float64 startCpu, lastCpu, startSystem, lastSystem, startUsage, lastUsage int64
percentage float64 percentage int64
paramData = make(map[string]float64) paramData = make(map[string]int64)
) )
path, err := d.path("cpuacct") path, err := d.path("cpuacct")
if startCpu, err = s.getCpuUsage(d, path); err != nil { if startCpu, err = s.getCpuUsage(d, path); err != nil {
@ -48,7 +48,7 @@ func (s *cpuacctGroup) Stats(d *data) (map[string]float64, error) {
return nil, err return nil, err
} }
startUsageTime := time.Now() startUsageTime := time.Now()
if startUsage, err = getCgroupParamFloat64(path, "cpuacct.usage"); err != nil { if startUsage, err = getCgroupParamInt(path, "cpuacct.usage"); err != nil {
return nil, err return nil, err
} }
// sample for 100ms // sample for 100ms
@ -60,7 +60,7 @@ func (s *cpuacctGroup) Stats(d *data) (map[string]float64, error) {
return nil, err return nil, err
} }
usageSampleDuration := time.Since(startUsageTime) usageSampleDuration := time.Since(startUsageTime)
if lastUsage, err = getCgroupParamFloat64(path, "cpuacct.usage"); err != nil { if lastUsage, err = getCgroupParamInt(path, "cpuacct.usage"); err != nil {
return nil, err return nil, err
} }
@ -77,19 +77,12 @@ func (s *cpuacctGroup) Stats(d *data) (map[string]float64, error) {
paramData["percentage"] = percentage paramData["percentage"] = percentage
// Delta usage is in nanoseconds of CPU time so get the usage (in cores) over the sample time. // Delta usage is in nanoseconds of CPU time so get the usage (in cores) over the sample time.
paramData["usage"] = deltaUsage / float64(usageSampleDuration.Nanoseconds()) paramData["usage"] = deltaUsage / usageSampleDuration.Nanoseconds()
return paramData, nil return paramData, nil
} }
func (s *cpuacctGroup) getProcStarttime(d *data) (float64, error) { // TODO(vmarmol): Use cgroups stats.
rawStart, err := system.GetProcessStartTime(d.pid) func (s *cpuacctGroup) getSystemCpuUsage(d *data) (int64, error) {
if err != nil {
return 0, err
}
return strconv.ParseFloat(rawStart, 64)
}
func (s *cpuacctGroup) getSystemCpuUsage(d *data) (float64, error) {
f, err := os.Open("/proc/stat") f, err := os.Open("/proc/stat")
if err != nil { if err != nil {
@ -106,11 +99,11 @@ func (s *cpuacctGroup) getSystemCpuUsage(d *data) (float64, error) {
return 0, fmt.Errorf("invalid number of cpu fields") return 0, fmt.Errorf("invalid number of cpu fields")
} }
var total float64 var total int64
for _, i := range parts[1:8] { for _, i := range parts[1:8] {
v, err := strconv.ParseFloat(i, 64) v, err := strconv.ParseInt(i, 10, 64)
if err != nil { if err != nil {
return 0.0, fmt.Errorf("Unable to convert value %s to float: %s", i, err) return 0.0, fmt.Errorf("Unable to convert value %s to int: %s", i, err)
} }
total += v total += v
} }
@ -122,11 +115,11 @@ func (s *cpuacctGroup) getSystemCpuUsage(d *data) (float64, error) {
return 0, fmt.Errorf("invalid stat format") return 0, fmt.Errorf("invalid stat format")
} }
func (s *cpuacctGroup) getCpuUsage(d *data, path string) (float64, error) { func (s *cpuacctGroup) getCpuUsage(d *data, path string) (int64, error) {
cpuTotal := 0.0 cpuTotal := int64(0)
f, err := os.Open(filepath.Join(path, "cpuacct.stat")) f, err := os.Open(filepath.Join(path, "cpuacct.stat"))
if err != nil { if err != nil {
return 0.0, err return 0, err
} }
defer f.Close() defer f.Close()
@ -134,7 +127,7 @@ func (s *cpuacctGroup) getCpuUsage(d *data, path string) (float64, error) {
for sc.Scan() { for sc.Scan() {
_, v, err := getCgroupParamKeyValue(sc.Text()) _, v, err := getCgroupParamKeyValue(sc.Text())
if err != nil { if err != nil {
return 0.0, err return 0, err
} }
// set the raw data in map // set the raw data in map
cpuTotal += v cpuTotal += v

2
cgroups/fs/cpuset.go
View File

@ -38,7 +38,7 @@ func (s *cpusetGroup) Remove(d *data) error {
return removePath(d.path("cpuset")) return removePath(d.path("cpuset"))
} }
func (s *cpusetGroup) Stats(d *data) (map[string]float64, error) { func (s *cpusetGroup) Stats(d *data) (map[string]int64, error) {
return nil, ErrNotSupportStat return nil, ErrNotSupportStat
} }

2
cgroups/fs/devices.go
View File

@ -55,6 +55,6 @@ func (s *devicesGroup) Remove(d *data) error {
return removePath(d.path("devices")) return removePath(d.path("devices"))
} }
func (s *devicesGroup) Stats(d *data) (map[string]float64, error) { func (s *devicesGroup) Stats(d *data) (map[string]int64, error) {
return nil, ErrNotSupportStat return nil, ErrNotSupportStat
} }

7
cgroups/fs/freezer.go
View File

@ -35,9 +35,9 @@ func (s *freezerGroup) Remove(d *data) error {
return removePath(d.path("freezer")) return removePath(d.path("freezer"))
} }
func (s *freezerGroup) Stats(d *data) (map[string]float64, error) { func (s *freezerGroup) Stats(d *data) (map[string]int64, error) {
var ( var (
paramData = make(map[string]float64) paramData = make(map[string]int64)
params = []string{ params = []string{
"parent_freezing", "parent_freezing",
"self_freezing", "self_freezing",
@ -50,6 +50,7 @@ func (s *freezerGroup) Stats(d *data) (map[string]float64, error) {
return nil, err return nil, err
} }
// TODO(vmarmol): This currently outputs nothing since the output is a string, fix.
for _, param := range params { for _, param := range params {
f, err := os.Open(filepath.Join(path, fmt.Sprintf("freezer.%s", param))) f, err := os.Open(filepath.Join(path, fmt.Sprintf("freezer.%s", param)))
if err != nil { if err != nil {
@ -62,7 +63,7 @@ func (s *freezerGroup) Stats(d *data) (map[string]float64, error) {
return nil, err return nil, err
} }
v, err := strconv.ParseFloat(strings.TrimSuffix(string(data), "\n"), 64) v, err := strconv.ParseInt(strings.TrimSuffix(string(data), "\n"), 10, 64)
if err != nil { if err != nil {
return nil, err return nil, err
} }

6
cgroups/fs/memory.go
View File

@ -50,8 +50,8 @@ func (s *memoryGroup) Remove(d *data) error {
return removePath(d.path("memory")) return removePath(d.path("memory"))
} }
func (s *memoryGroup) Stats(d *data) (map[string]float64, error) { func (s *memoryGroup) Stats(d *data) (map[string]int64, error) {
paramData := make(map[string]float64) paramData := make(map[string]int64)
path, err := d.path("memory") path, err := d.path("memory")
if err != nil { if err != nil {
return nil, err return nil, err
@ -79,7 +79,7 @@ func (s *memoryGroup) Stats(d *data) (map[string]float64, error) {
"max_usage_in_bytes", "max_usage_in_bytes",
} }
for _, param := range params { for _, param := range params {
value, err := getCgroupParamFloat64(path, fmt.Sprintf("memory.%s", param)) value, err := getCgroupParamInt(path, fmt.Sprintf("memory.%s", param))
if err != nil { if err != nil {
return nil, err return nil, err
} }

2
cgroups/fs/memory_test.go
View File

@ -25,7 +25,7 @@ func TestMemoryStats(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
expectedStats := map[string]float64{"cache": 512.0, "rss": 1024.0, "usage_in_bytes": 2048.0, "max_usage_in_bytes": 4096.0} expectedStats := map[string]int64{"cache": 512, "rss": 1024, "usage_in_bytes": 2048, "max_usage_in_bytes": 4096}
expectStats(t, expectedStats, stats) expectStats(t, expectedStats, stats)
} }

2
cgroups/fs/perf_event.go
View File

@ -19,6 +19,6 @@ func (s *perfEventGroup) Remove(d *data) error {
return removePath(d.path("perf_event")) return removePath(d.path("perf_event"))
} }
func (s *perfEventGroup) Stats(d *data) (map[string]float64, error) { func (s *perfEventGroup) Stats(d *data) (map[string]int64, error) {
return nil, ErrNotSupportStat return nil, ErrNotSupportStat
} }

2
cgroups/fs/test_util.go
View File

@ -61,7 +61,7 @@ func (c *cgroupTestUtil) writeFileContents(fileContents map[string]string) {
} }
// Expect the specified stats. // Expect the specified stats.
func expectStats(t *testing.T, expected, actual map[string]float64) { func expectStats(t *testing.T, expected, actual map[string]int64) {
for stat, expectedValue := range expected { for stat, expectedValue := range expected {
actualValue, ok := actual[stat] actualValue, ok := actual[stat]
if !ok { if !ok {

16
cgroups/fs/utils.go
View File

@ -16,25 +16,25 @@ var (
// Parses a cgroup param and returns as name, value // Parses a cgroup param and returns as name, value
// i.e. "io_service_bytes 1234" will return as io_service_bytes, 1234 // i.e. "io_service_bytes 1234" will return as io_service_bytes, 1234
func getCgroupParamKeyValue(t string) (string, float64, error) { func getCgroupParamKeyValue(t string) (string, int64, error) {
parts := strings.Fields(t) parts := strings.Fields(t)
switch len(parts) { switch len(parts) {
case 2: case 2:
value, err := strconv.ParseFloat(parts[1], 64) value, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil { if err != nil {
return "", 0.0, fmt.Errorf("Unable to convert param value to float: %s", err) return "", 0, fmt.Errorf("Unable to convert param value to int: %s", err)
} }
return parts[0], value, nil return parts[0], value, nil
default: default:
return "", 0.0, ErrNotValidFormat return "", 0, ErrNotValidFormat
} }
} }
// Gets a single float64 value from the specified cgroup file. // Gets a single int64 value from the specified cgroup file.
func getCgroupParamFloat64(cgroupPath, cgroupFile string) (float64, error) { func getCgroupParamInt(cgroupPath, cgroupFile string) (int64, error) {
contents, err := ioutil.ReadFile(filepath.Join(cgroupPath, cgroupFile)) contents, err := ioutil.ReadFile(filepath.Join(cgroupPath, cgroupFile))
if err != nil { if err != nil {
return -1.0, err return -1, err
} }
return strconv.ParseFloat(strings.TrimSpace(string(contents)), 64) return strconv.ParseInt(strings.TrimSpace(string(contents)), 10, 64)
} }

10
cgroups/fs/utils_test.go
View File

@ -13,7 +13,7 @@ const (
floatString = "2048" floatString = "2048"
) )
func TestGetCgroupParamsFloat64(t *testing.T) { func TestGetCgroupParamsInt(t *testing.T) {
// Setup tempdir. // Setup tempdir.
tempDir, err := ioutil.TempDir("", "cgroup_utils_test") tempDir, err := ioutil.TempDir("", "cgroup_utils_test")
if err != nil { if err != nil {
@ -27,7 +27,7 @@ func TestGetCgroupParamsFloat64(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
value, err := getCgroupParamFloat64(tempDir, cgroupFile) value, err := getCgroupParamInt(tempDir, cgroupFile)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} else if value != floatValue { } else if value != floatValue {
@ -39,7 +39,7 @@ func TestGetCgroupParamsFloat64(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
value, err = getCgroupParamFloat64(tempDir, cgroupFile) value, err = getCgroupParamInt(tempDir, cgroupFile)
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} else if value != floatValue { } else if value != floatValue {
@ -51,7 +51,7 @@ func TestGetCgroupParamsFloat64(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
_, err = getCgroupParamFloat64(tempDir, cgroupFile) _, err = getCgroupParamInt(tempDir, cgroupFile)
if err == nil { if err == nil {
t.Fatal("Expecting error, got none") t.Fatal("Expecting error, got none")
} }
@ -61,7 +61,7 @@ func TestGetCgroupParamsFloat64(t *testing.T) {
if err != nil { if err != nil {
t.Fatal(err) t.Fatal(err)
} }
_, err = getCgroupParamFloat64(tempDir, cgroupFile) _, err = getCgroupParamInt(tempDir, cgroupFile)
if err == nil { if err == nil {
t.Fatal("Expecting error, got none") t.Fatal("Expecting error, got none")
} }