func (s *CPUStat) Collect() {
// collect CPU stats for All cpus aggregated
var cpuinfo C.host_cpu_load_info_data_t
count := C.mach_msg_type_number_t(C.HOST_CPU_LOAD_INFO_COUNT)
host := C.mach_host_self()
ret := C.host_statistics(C.host_t(host), C.HOST_CPU_LOAD_INFO,
C.host_info_t(unsafe.Pointer(&cpuinfo)), &count)
if ret != C.KERN_SUCCESS {
return
}
s.All.User.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_USER]))
s.All.UserLowPrio.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_NICE]))
s.All.System.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_SYSTEM]))
s.All.Idle.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_IDLE]))
s.All.Total.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_USER]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_SYSTEM]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_NICE]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_IDLE]))
}
func (h Host) LoadInfo() *LoadInfo {
host_load_info := new(LoadInfo)
count := C.mach_msg_type_number_t(C.HOST_LOAD_INFO_COUNT)
if C.host_statistics(C.host_t(h), C.HOST_LOAD_INFO, (*C.integer_t)(unsafe.Pointer(host_load_info)), &count) != 0 {
return nil
}
return host_load_info
}
func (h Host) VmInfo() (*VmInfo, os.Error) {
vmstat := new(C.vm_statistics_data_t)
nummsg := C.mach_msg_type_number_t(C.HOST_VM_INFO_COUNT)
ret := C.host_statistics(C.host_t(h), C.HOST_VM_INFO, (*C.integer_t)(unsafe.Pointer(vmstat)), &nummsg)
if ret != 0 {
return nil, fmt.Errorf("host_statistics: %s", C.mach_error_string(C.mach_error_t(ret)))
}
return &VmInfo{uint64(vmstat.pageins), uint64(vmstat.pageouts)}, nil
}
func (h Host) BasicInfo() *BasicInfo {
host_info := new(BasicInfo)
count := C.mach_msg_type_number_t(C.HOST_BASIC_INFO_COUNT)
if C.host_info(C.host_t(h), C.HOST_BASIC_INFO, (*C.integer_t)(unsafe.Pointer(host_info)), &count) != 0 {
return nil
}
return host_info
}
func writeMemory(thread *Thread, addr uintptr, data []byte) (int, error) {
if len(data) == 0 {
return 0, nil
}
var (
vm_data = unsafe.Pointer(&data[0])
vm_addr = C.mach_vm_address_t(addr)
length = C.mach_msg_type_number_t(len(data))
)
if ret := C.write_memory(thread.dbp.os.task, vm_addr, vm_data, length); ret < 0 {
return 0, fmt.Errorf("could not write memory")
}
return len(data), nil
}
func cpuTimeTotal() int {
selfHost := C.mach_host_self()
hostInfo := C.malloc(C.size_t(C.HOST_CPU_LOAD_INFO_COUNT))
count := C.mach_msg_type_number_t(C.HOST_CPU_LOAD_INFO_COUNT)
err := C.host_statistics(C.host_t(selfHost), C.HOST_CPU_LOAD_INFO, C.host_info_t(hostInfo), &count)
defer C.free(hostInfo)
if err != C.kern_return_t(C.KERN_SUCCESS) {
return 0
}
return -1
}
// Collect populates various cpu performance statistics - use MACH interface
func (s *CPUStat) Collect() {
// collect CPU stats for All cpus aggregated
var cpuinfo C.host_cpu_load_info_data_t
var hostinfo C.host_basic_info_data_t
cpuloadnumber := C.mach_msg_type_number_t(C.HOST_CPU_LOAD_INFO_COUNT)
hostnumber := C.mach_msg_type_number_t(C.HOST_BASIC_INFO_COUNT)
host := C.mach_host_self()
ret := C.host_statistics(C.host_t(host), C.HOST_CPU_LOAD_INFO,
C.host_info_t(unsafe.Pointer(&cpuinfo)), &cpuloadnumber)
if ret != C.KERN_SUCCESS {
return
}
ret = C.host_info(C.host_t(host), C.HOST_BASIC_INFO,
C.host_info_t(unsafe.Pointer(&hostinfo)), &hostnumber)
if ret != C.KERN_SUCCESS {
return
}
s.All.User.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_USER]))
s.All.UserLowPrio.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_NICE]))
s.All.System.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_SYSTEM]))
s.All.Idle.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_IDLE]))
s.All.Total.Set(uint64(cpuinfo.cpu_ticks[C.CPU_STATE_USER]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_SYSTEM]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_NICE]) +
uint64(cpuinfo.cpu_ticks[C.CPU_STATE_IDLE]))
s.All.UsageCount.Set(s.All.Usage())
s.All.UserSpaceCount.Set(s.All.UserSpace())
s.All.KernelCount.Set(s.All.Kernel())
s.All.TotalCount.Set(float64(hostinfo.logical_cpu_max))
}
func (t *Thread) readMemory(addr uintptr, size int) ([]byte, error) {
if size == 0 {
return nil, nil
}
var (
buf = make([]byte, size)
vmData = unsafe.Pointer(&buf[0])
vmAddr = C.mach_vm_address_t(addr)
length = C.mach_msg_type_number_t(size)
)
ret := C.read_memory(t.dbp.os.task, vmAddr, vmData, length)
if ret < 0 {
return nil, fmt.Errorf("could not read memory")
}
return buf, nil
}
// Collect uses mach interface to populate various memory usage
// metrics
func (s *MemStat) Collect() {
var meminfo C.vm_statistics64_data_t
count := C.mach_msg_type_number_t(C.HOST_VM_INFO64_COUNT)
host := C.mach_host_self()
ret := C.host_statistics64(C.host_t(host), C.HOST_VM_INFO64,
C.host_info_t(unsafe.Pointer(&meminfo)), &count)
if ret != C.KERN_SUCCESS {
return
}
s.RawFree.Set(float64(meminfo.free_count) * float64(s.Pagesize))
s.Active.Set(float64(meminfo.active_count) * float64(s.Pagesize))
s.Inactive.Set(float64(meminfo.inactive_count) * float64(s.Pagesize))
s.Wired.Set(float64(meminfo.wire_count) * float64(s.Pagesize))
s.Purgeable.Set(float64(meminfo.purgeable_count) * float64(s.Pagesize))
s.RawTotal.Set(float64(C.get_phys_memory()))
}
// VirtualMemory returns VirtualmemoryStat.
func VirtualMemory() (*VirtualMemoryStat, error) {
count := C.mach_msg_type_number_t(C.HOST_VM_INFO_COUNT)
var vmstat C.vm_statistics_data_t
status := C.host_statistics(C.host_t(C.mach_host_self()),
C.HOST_VM_INFO,
C.host_info_t(unsafe.Pointer(&vmstat)),
&count)
if status != C.KERN_SUCCESS {
return nil, fmt.Errorf("host_statistics error=%d", status)
}
pageSize := uint64(syscall.Getpagesize())
total, err := getHwMemsize()
if err != nil {
return nil, err
}
totalCount := C.natural_t(total / pageSize)
availableCount := vmstat.inactive_count + vmstat.free_count
usedPercent := 100 * float64(totalCount-availableCount) / float64(totalCount)
usedCount := totalCount - availableCount
return &VirtualMemoryStat{
Total: total,
Available: pageSize * uint64(availableCount),
Used: pageSize * uint64(usedCount),
UsedPercent: usedPercent,
Free: pageSize * uint64(vmstat.free_count),
Active: pageSize * uint64(vmstat.active_count),
Inactive: pageSize * uint64(vmstat.inactive_count),
Wired: pageSize * uint64(vmstat.wire_count),
}, nil
}
