githubmirror/numactl

numamon.c
331 строка7 KB
Andi Kleen
Import numactl 0.9.9
23 июл 2014, 20:26
23 июл 2014, 20:26fdd0296
/* Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.

   numamon is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public
   License as published by the Free Software Foundation; version
   2.

   numamon is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   General Public License for more details.

   You should find a copy of v2 of the GNU General Public License somewhere
   on your Linux system; if not, write to the Free Software Foundation, 
   Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 

   Display some numa statistics collected by the CPU.
   Opteron specific. Also not reliable because the counters
   are not quite correct in hardware.  */

#define _LARGE_FILE_SOURCE 1
#define _GNU_SOURCE 1
#include <string.h>
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <dirent.h>
#include <getopt.h>
#include <stdarg.h>
#include <stdlib.h>
#include <sys/fcntl.h>

enum { LOCALLOCAL = 0, LOCALREMOTE = 1, REMOTELOCAL = 2 }; 
static int mem[] = { [LOCALLOCAL] = 0xa8, [LOCALREMOTE] = 0x98, [REMOTELOCAL] = 0x68 };
static int io[] = {  [LOCALLOCAL] = 0xa4, [LOCALREMOTE] = 0x94, [REMOTELOCAL] = 0x64 }; 
static int *masks = mem;

#define err(x) perror(x),exit(1)

#define PERFEVTSEL0 0xc0010000
#define PERFEVTSEL1 0xc0010001
#define PERFEVTSEL2 0xc0010002
#define PERFEVTSEL3 0xc0010003

#define PERFCTR0 0xc0010004
#define PERFCTR1 0xc0010005
#define PERFCTR2 0xc0010006
#define PERFCTR3 0xc0010007

#define EVENT 0xe9
#define PERFEVTSEL_EN (1 << 22)
#define PERFEVTSEL_OS (1 << 17)
#define PERFEVTSEL_USR (1 << 16)

#define BASE (EVENT | PERFEVTSEL_EN | PERFEVTSEL_OS | PERFEVTSEL_USR)

#define MAXCPU 8

int force = 0;
int msrfd[MAXCPU];
int delay;
int absolute;
char *cfilter; 
int verbose;

void usage(void);

void Vprintf(char *fmt, ...)
{
	va_list ap;
	va_start(ap,fmt);
	if (verbose)
		vfprintf(stderr,fmt,ap);
	va_end(ap);
}

unsigned long long rdmsr(int cpu, unsigned long msr) 
{ 
	unsigned long long val; 
	if (pread(msrfd[cpu], &val, 8, msr) != 8) {
		fprintf(stderr, "rdmsr of %lx failed: %s\n", msr, strerror(errno));  
		exit(1);
	}
	return val;
} 

void wrmsr(int cpu, unsigned long msr, unsigned long long value)
{ 
	if (pwrite(msrfd[cpu], &value, 8, msr) != 8) { 
		fprintf(stderr, "wdmsr of %lx failed: %s\n", msr, strerror(errno));  
		exit(1);
	} 
} 

int cpufilter(int cpu) 
{ 
	long num; 
	char *end;
	char *s;
	
	if (!cfilter)
		return 1;	
	for (s = cfilter;;) { 
		num = strtoul(s, &end, 0); 
		if (end == s) 
			usage(); 
		if (cpu == num)
			return 1;
		if (*end == ',') 
			s = end+1;
		else if (*end == 0) 
			break;
		else
			usage(); 
	}
	return 0;
} 

void checkcounter(int cpu, int clear)
{ 
	int i;
	for (i = 1; i < 4; i++) { 
		int clear_this = clear;
		unsigned long long evtsel = rdmsr(cpu, PERFEVTSEL0 + i); 
		Vprintf("%d: %x %Lx\n", cpu, PERFEVTSEL0 + i, evtsel);
		if (!(evtsel & PERFEVTSEL_EN)) { 
			Vprintf("reinit %d\n", cpu);  
			wrmsr(cpu, PERFEVTSEL0 + i, BASE | masks[i - 1]); 
			clear_this = 1;
		} else if (evtsel == (BASE | (masks[i-1] << 8))) { 
			/* everything fine */ 
		} else if (force) { 
			Vprintf("reinit force %d\n", cpu); 
			wrmsr(cpu, PERFEVTSEL0 + i, BASE | (masks[i - 1] << 8)); 
			clear_this = 1;
		} else {
			fprintf(stderr, "perfctr %d cpu %d already used with %Lx\n",
				i, cpu, evtsel); 
			fprintf(stderr, "Consider using -f if you know what you're doing.\n");
			exit(1);
		}
		if (clear_this) { 
			Vprintf("clearing %d\n", cpu);
			wrmsr(cpu, PERFCTR0 + i, 0); 
		}
	} 
} 

void setup(int clear)
{ 
	DIR *dir; 
	struct dirent *d;
	int numcpus = 0;

	memset(msrfd, -1, sizeof(msrfd)); 
	dir = opendir("/dev/cpu");
	if (!dir) 
		err("cannot open /dev/cpu"); 
	while ((d = readdir(dir)) != NULL) { 
		char buf[64];
		char *end; 
		long cpunum = strtoul(d->d_name, &end, 0); 
		if (*end != 0) 
			continue; 
		if (cpunum > MAXCPU) {
			fprintf(stderr, "too many cpus %ld %s\n", cpunum, d->d_name); 
			continue;
		}
		if (!cpufilter(cpunum))
			continue; 
		snprintf(buf, 63, "/dev/cpu/%ld/msr", cpunum);
		msrfd[cpunum] = open64(buf, O_RDWR); 
		if (msrfd[cpunum] < 0)
			continue;
		numcpus++;
		checkcounter(cpunum, clear); 
	} 
	closedir(dir);		
	if (numcpus == 0) {
		fprintf(stderr, "No CPU found using MSR driver.\n"); 
		exit(1);
	}
} 

void printf_padded(int pad, char *fmt, ...)
{
	char buf[pad + 1]; 
	va_list ap;
	va_start(ap, fmt);
	vsnprintf(buf, pad, fmt, ap); 
	printf("%-*s", pad, buf); 
	va_end(ap);
}

void print_header(void)
{
	printf_padded(4, "CPU "); 
	printf_padded(16, "LOCAL"); 
	printf_padded(16, "LOCAL->REMOTE"); 
	printf_padded(16, "REMOTE->LOCAL"); 
	putchar('\n');
}

void print_cpu(int cpu)
{ 
	int i;
	static unsigned long long lastval[4]; 
	printf_padded(4, "%d", cpu);
	for (i = 1; i < 4; i++) { 
		unsigned long long val = rdmsr(cpu, PERFCTR0 + i);
		if (absolute) 
			printf_padded(16, "%Lu", val); 
		else
			printf_padded(16, "%Lu", val - lastval[i]);		
		lastval[i] = val;
	} 
	putchar('\n');
} 

void dumpall(void)
{
	int cnt = 0;
	int cpu;
	print_header();
	for (;;) { 
		for (cpu = 0; cpu < MAXCPU; ++cpu) { 
			if (msrfd[cpu] < 0) 
				continue;
			print_cpu(cpu);
		}
		if (!delay) 
			break;
		sleep(delay);
		if (++cnt > 40) { 
			cnt = 0;
			print_header();
		}
	} 		
} 

void checkk8(void)
{ 
	char *line = NULL;
	size_t size = 0;
	int bad = 0;
	FILE *f = fopen("/proc/cpuinfo", "r");
	if (!f) 
		return;	
	while (getline(&line, &size, f) > 0) { 
		if (!strncmp("vendor_id", line, 9)) { 
			if (!strstr(line, "AMD"))
				bad++; 
		} 
		if (!strncmp("cpu family", line, 10)) { 
			char *s = line + strcspn(line,":");
			int family;
			if (*s == ':') ++s;
			family = strtoul(s, NULL, 0); 
			if (family != 15)
				bad++;
		} 
	} 
	if (bad) {
		printf("not a opteron cpu\n"); 
		exit(1);
	}
	free(line);
	fclose(f);
} 

void usage(void)
{
	fprintf(stderr, "usage: numamon [args] [delay]\n"); 
	fprintf(stderr, "       -f forcibly overwrite counters\n");
	fprintf(stderr, "       -i count IO (default memory)\n"); 	
	fprintf(stderr, "       -a print absolute counter values (with delay)\n");
	fprintf(stderr, "       -s setup counters and exit\n"); 	
	fprintf(stderr, "       -c clear counters and exit\n"); 	
	fprintf(stderr, "       -m Print memory traffic (default)\n"); 	
	fprintf(stderr, "       -C cpu{,cpu} only print for cpus\n"); 
	fprintf(stderr, "       -v Be verbose\n");
	exit(1);
} 

int main(int ac, char **av) 
{ 
	int opt;
	checkk8(); 
	while ((opt = getopt(ac,av,"ifscmaC:v")) != -1) { 
		switch (opt) { 
		case 'f': 
			force = 1; 
			break;
		case 'c': 
			setup(1);
			exit(0); 
		case 's': 
			setup(0); 
			exit(0); 
		case 'm':
			masks = mem;
			break;
		case 'i':
			masks = io;
			break;
		case 'a':
			absolute = 1;
			break;
		case 'C':
			cfilter = optarg;
			break;
		case 'v':
			verbose = 1;
			break;
		default: 
			usage();
		}
	} 
	if (av[optind]) { 
		char *end; 
		delay = strtoul(av[optind], &end, 10); 
		if (*end) 
			usage(); 
		if (av[optind+1])
			usage();
	} 

	setup(0); 
	dumpall();
	return 0;
}