CPUInfo.m

/*
 *	CPU History
 *	Christopher Bowns, 2008
 */
//  CPUInfo.m
//  CPU Usage
//
//  Created by Peter Hosey on 2006-06-21.
//  Copyright 2006 Peter Hosey. All rights reserved.
//
//  Modified by Christopher Bowns, starting 2008-1-1.

// #ifndef NSLOG_DEBUG
// #define NSLOG_DEBUG
// #endif

#import "CPUInfo.h"

#include <sys/types.h>
//sqrtf, ceilf
#include <math.h>
//sysctl and its parameters
#include <sys/sysctl.h>
//errno, strerror
#include <sys/errno.h>
#include <string.h>

@implementation CPUInfo


/*
	Accomplishes:
		inits cpudata, inptr, outptr
		retrieves lastProcessorInfo for refresh method to go to town.
	
	if cannot get processor info, returns nil.
*/
- (CPUInfo *) initWithCapacity:(unsigned)numItems
{
	self = [super init];

	unsigned i, j;

/* from Hosey's CPU Usage.app:
	We could get the number of processors the same way that we get the CPU usage info, but that allocates memory. */
	enum { miblen = 2U };
	int mib[miblen] = { CTL_HW, HW_NCPU };
	size_t sizeOfNumCPUs = sizeof(numCPUs);
	int status = sysctl(mib, miblen,
		   &numCPUs, &sizeOfNumCPUs,
		   NULL, /*newlen*/ 0U);
	if(status != 0) {
		numCPUs = 1; // It's either this, or premature death
		NSLog(@"%s error status, assuming one CPU", _cmd);
	}
	
	size = numItems; // set our size to numItems because that's array length
	
	// Allocate the cpu data matrix
	allcpudata = calloc(numCPUs, sizeof(CPUDataPtr));
	if (allcpudata == NULL) {
		NSLog (@"%s Failed to allocate buffer for CPUInfo", _cmd);
		return (nil);
	}
	for(i = 0; i < numCPUs; i++) {
		allcpudata[i] = calloc(numItems, sizeof(CPUData));
	}
	
	// Set up our data structure ptrs
	inptr = 0;
	outptr = -1;
	
	// set the lastProcessorInfo array so we can get to work when we call refresh:
	natural_t numProcessors_nobodyCares = 0U;
	kern_return_t err = host_processor_info(mach_host_self(),
	                                        PROCESSOR_CPU_LOAD_INFO,
	                                        (natural_t *)&numProcessors_nobodyCares,
	                                        (processor_info_array_t *)&lastProcessorInfo,
	                                        (mach_msg_type_number_t *)&numLastProcessorInfo);
	if(err != KERN_SUCCESS) {
		NSLog(@"%s failed to get cpu statistics", _cmd);
		// if we can't get this info, then we're toast. Exit gracefully.
		return (nil);
	}
	
	for(i = 0U; i < numCPUs; i++)
	{
		CPUDataPtr cpudata = allcpudata[i];
		for (j = 0U; j < numItems; j++)
		{
			cpudata[j].idle = 1.0;
		}
	}


	
	return (self);
}


/*
	Assumptions:
		init has run.
		lastProcessorInfo and numLastProcessorInfo contain valid data from prior refresh of CPU info
	Accomplishes:
		retrieves current data
		calculates avg cpu load over last period
		updates cpudata array with info
		deallocates old numLastProcInfo and lastProcessorInfo and set ptrs to new data
*/
- (void)refresh
{
	processor_cpu_load_info_t processorInfo;
	natural_t numProcessors;
	mach_msg_type_number_t numProcessorInfo;
	unsigned i;

	kern_return_t err = host_processor_info(mach_host_self(),
	                                        PROCESSOR_CPU_LOAD_INFO,
	                                        (natural_t *)&numProcessors,
	                                        (processor_info_array_t *)&processorInfo,
	                                        (mach_msg_type_number_t *)&numProcessorInfo);
	if(err != KERN_SUCCESS) {
		NSLog(@"%s failed to get cpu statistics", _cmd); // Uh oh.
	}

	for(i = 0U; i < numCPUs; ++i) {
		// NB: numCPUs ought to be the same as numProcessors -- otherwise ...?
		assert(numCPUs == numProcessors);
		assert(numProcessorInfo == numProcessors * CPU_STATE_MAX);
		
		CPUDataPtr cpudata = allcpudata[i];
	
		unsigned int inUse, total, user, sys, nice, idle;
			
		user = processorInfo[i].cpu_ticks[CPU_STATE_USER] - lastProcessorInfo[i].cpu_ticks[CPU_STATE_USER];
		sys = processorInfo[i].cpu_ticks[CPU_STATE_SYSTEM] - lastProcessorInfo[i].cpu_ticks[CPU_STATE_SYSTEM];
		nice = processorInfo[i].cpu_ticks[CPU_STATE_NICE] - lastProcessorInfo[i].cpu_ticks[CPU_STATE_NICE];
		idle = processorInfo[i].cpu_ticks[CPU_STATE_IDLE] - lastProcessorInfo[i].cpu_ticks[CPU_STATE_IDLE];

		inUse = user + sys + nice;
		total = inUse + idle;
		
		cpudata[inptr].user = (double)user / (double)total;
		cpudata[inptr].sys = (double)sys / (double)total;
		cpudata[inptr].nice = (double)nice / (double)total;
		cpudata[inptr].idle = (double)idle / (double)total;
		#ifdef NSLOG_DEBUG
		NSLog(@"CPU %d: User: %.2f\n", i, cpudata[inptr].user);
		NSLog(@"CPU %d: Sys: %.2f\n", i, cpudata[inptr].sys);
		NSLog(@"CPU %d: Nice: %.2f\n", i, cpudata[inptr].nice);
		NSLog(@"CPU %d: Idle: %.2f\n", i, cpudata[inptr].idle);
		#endif
	}
	
	// deallocate the last one, since we don't want memory leaks.
	if(lastProcessorInfo) {
		size_t lastProcessorInfoSize = sizeof(integer_t) * numLastProcessorInfo;
		vm_deallocate(mach_task_self(), (vm_address_t)lastProcessorInfo, lastProcessorInfoSize);
	}

	lastProcessorInfo = processorInfo;
	numLastProcessorInfo = numProcessorInfo;
	
	if (++inptr >= size) // advance our data ptr
		inptr = 0;
}


- (void)startForwardIterate
{
	outptr = inptr;
}

- (void)startBackwardIterate
{
	outptr = (inptr - 1 < 0 ? size - 1 : inptr - 1);
}

- (BOOL)getNext:(CPUDataPtr)ptr forCPU:(unsigned)cpu
{
	if (outptr == -1)
		return (FALSE);
	*ptr = allcpudata[cpu][outptr++];
	if (outptr >= size)
		outptr = 0;
	if (outptr == inptr)
		outptr = -1;
	return (TRUE);
}

- (BOOL)getPrev:(CPUDataPtr)ptr forCPU:(unsigned)cpu
{
	if (outptr == -1)
		return (FALSE);
	*ptr = allcpudata[cpu][outptr--];
	if (outptr < 0)
		outptr = size - 1;
	if (outptr == inptr)
		outptr = -1;
	return (TRUE);
}

- (void)getCurrent:(CPUDataPtr)ptr forCPU:(unsigned)cpu
{
	*ptr = allcpudata[cpu][inptr ? inptr - 1 : size - 1];
}


- (void)getLast:(CPUDataPtr)ptr forCPU:(unsigned)cpu
{
	*ptr = allcpudata[cpu][inptr > 1 ? inptr - 2 : size + inptr - 2];
}


- (int)getSize
{
	return (size);
}

- (unsigned)numCPUs { return (numCPUs); }

@end