Use vm_stat command on darwin to get memory

This has the benefit of allowing us to also grab the cached memory so
that we can get an "available" measurement

mem/mem_darwin.go

@@ -20,45 +20,89 @@ func getPageSize() (uint64, error) {
 	if err != nil {
 		return 0, err
 	}
-
 	return p, nil
 }
 
+// Runs vm_stat and returns Free and inactive pages
+func getVmStat(pagesize uint64, vms *VirtualMemoryStat) error {
+	out, err := exec.Command("vm_stat").Output()
+	if err != nil {
+		return err
+	}
+	return parseVmStat(string(out), pagesize, vms)
+}
+
+func parseVmStat(out string, pagesize uint64, vms *VirtualMemoryStat) error {
+	var err error
+
+	lines := strings.Split(out, "\n")
+	for _, line := range lines {
+		fields := strings.Split(line, ":")
+		if len(fields) < 2 {
+			continue
+		}
+		key := strings.TrimSpace(fields[0])
+		value := strings.Trim(fields[1], " .")
+		switch key {
+		case "Pages free":
+			free, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Free = free * pagesize
+		case "Pages inactive":
+			inactive, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Cached += inactive * pagesize
+			vms.Inactive = inactive * pagesize
+		case "Pages active":
+			active, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Active = active * pagesize
+		case "Pages wired down":
+			wired, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Wired = wired * pagesize
+		case "Pages purgeable":
+			purgeable, e := strconv.ParseUint(value, 10, 64)
+			if e != nil {
+				err = e
+			}
+			vms.Cached += purgeable * pagesize
+		}
+	}
+	return err
+}
+
 // VirtualMemory returns VirtualmemoryStat.
 func VirtualMemory() (*VirtualMemoryStat, error) {
+	ret := &VirtualMemoryStat{}
+
 	p, err := getPageSize()
 	if err != nil {
 		return nil, err
 	}
-
-	total, err := common.DoSysctrl("hw.memsize")
+	t, err := common.DoSysctrl("hw.memsize")
 	if err != nil {
 		return nil, err
 	}
-	free, err := common.DoSysctrl("vm.page_free_count")
+	total, err := strconv.ParseUint(t[0], 10, 64)
 	if err != nil {
 		return nil, err
 	}
-	parsed := make([]uint64, 0, 7)
-	vv := []string{
-		total[0],
-		free[0],
-	}
-	for _, target := range vv {
-		t, err := strconv.ParseUint(target, 10, 64)
-		if err != nil {
-			return nil, err
-		}
-		parsed = append(parsed, t)
-	}
-
-	ret := &VirtualMemoryStat{
-		Total: parsed[0],
-		Free:  parsed[1] * p,
+	err = getVmStat(p, ret)
+	if err != nil {
+		return nil, err
 	}
 
-	// TODO: platform independent (worked freebsd?)
-	ret.Available = ret.Free + ret.Buffers + ret.Cached
+	ret.Available = ret.Free + ret.Cached
+	ret.Total = total
 
 	ret.Used = ret.Total - ret.Free
 	ret.UsedPercent = float64(ret.Total-ret.Available) / float64(ret.Total) * 100.0

mem/mem_darwin_test.go

+// +build darwin
+
+package mem
+
+import (
+	"testing"
+)
+
+var vm_stat_out = `
+Mach Virtual Memory Statistics: (page size of 4096 bytes)
+Pages free:                              105885.
+Pages active:                            725641.
+Pages inactive:                          449242.
+Pages speculative:                         6155.
+Pages throttled:                              0.
+Pages wired down:                        560835.
+Pages purgeable:                         128967.
+"Translation faults":                 622528839.
+Pages copy-on-write:                   17697839.
+Pages zero filled:                    311034413.
+Pages reactivated:                      4705104.
+Pages purged:                           5605610.
+File-backed pages:                       349192.
+Anonymous pages:                         831846.
+Pages stored in compressor:              876507.
+Pages occupied by compressor:            249167.
+Decompressions:                         4555025.
+Compressions:                           7524729.
+Pageins:                               40532443.
+Pageouts:                                126496.
+Swapins:                                2988073.
+Swapouts:                               3283599.
+`
+
+func TestParseVmStat(t *testing.T) {
+	ret := &VirtualMemoryStat{}
+	err := parseVmStat(vm_stat_out, 4096, ret)
+
+	if err != nil {
+		t.Errorf("Expected no error, got %s\n", err.Error())
+	}
+
+	if ret.Free != uint64(105885*4096) {
+		t.Errorf("Free pages, actual: %d, expected: %d", ret.Free,
+			105885*4096)
+	}
+
+	if ret.Inactive != uint64(449242*4096) {
+		t.Errorf("Inactive pages, actual: %d, expected: %d", ret.Inactive,
+			449242*4096)
+	}
+
+	if ret.Active != uint64(725641*4096) {
+		t.Errorf("Active pages, actual: %d, expected: %d", ret.Active,
+			725641*4096)
+	}
+
+	if ret.Wired != uint64(560835*4096) {
+		t.Errorf("Wired pages, actual: %d, expected: %d", ret.Wired,
+			560835*4096)
+	}
+
+	if ret.Cached != uint64(128967*4096+449242.*4096) {
+		t.Errorf("Cached pages, actual: %d, expected: %d", ret.Cached,
+			128967*4096+449242.*4096)
+	}
+}