You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
316 lines
6.0 KiB
316 lines
6.0 KiB
/*
|
|
* Copyright (C) 2012 Fusion-io
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public
|
|
* License v2 as published by the Free Software Foundation.
|
|
*
|
|
* This program 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 have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <inttypes.h>
|
|
#include <string.h>
|
|
#include <asm/types.h>
|
|
#include <errno.h>
|
|
#include <sys/mman.h>
|
|
#include <time.h>
|
|
#include <math.h>
|
|
|
|
#include "plot.h"
|
|
#include "blkparse.h"
|
|
#include "list.h"
|
|
#include "tracers.h"
|
|
#include "mpstat.h"
|
|
|
|
char line[1024];
|
|
int line_len = 1024;
|
|
|
|
static char record_header[] = "CPU %usr %nice %sys %iowait %irq %soft %steal %guest %idle\n";
|
|
static char record_header_v2[] = "CPU %usr %nice %sys %iowait %irq %soft %steal %guest %gnice %idle\n";
|
|
|
|
int record_header_len = sizeof(record_header);
|
|
int record_header_v2_len = sizeof(record_header_v2);
|
|
|
|
static int past_eof(struct trace *trace, char *cur)
|
|
{
|
|
if (cur >= trace->mpstat_start + trace->mpstat_len)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
int next_mpstat_line(struct trace *trace)
|
|
{
|
|
char *next;
|
|
char *cur = trace->mpstat_cur;
|
|
|
|
next = strchr(cur, '\n');
|
|
if (!next)
|
|
return 1;
|
|
next++;
|
|
if (past_eof(trace, next))
|
|
return 1;
|
|
trace->mpstat_cur = next;
|
|
return 0;
|
|
}
|
|
|
|
char *next_mpstat(struct trace *trace)
|
|
{
|
|
char *cur;
|
|
|
|
cur = strstr(trace->mpstat_cur, record_header);
|
|
if (cur) {
|
|
cur += record_header_len;
|
|
} else {
|
|
cur = strstr(trace->mpstat_cur, record_header_v2);
|
|
if (cur)
|
|
cur += record_header_v2_len;
|
|
}
|
|
if (!cur)
|
|
return NULL;
|
|
|
|
if (past_eof(trace, cur))
|
|
return NULL;
|
|
trace->mpstat_cur = cur;
|
|
return cur;
|
|
}
|
|
|
|
char *first_mpstat(struct trace *trace)
|
|
{
|
|
char *cur = trace->mpstat_cur;
|
|
|
|
trace->mpstat_cur = trace->mpstat_start;
|
|
|
|
cur = next_mpstat(trace);
|
|
if (!cur)
|
|
return NULL;
|
|
return cur;
|
|
}
|
|
|
|
static void find_last_mpstat_time(struct trace *trace)
|
|
{
|
|
int num_mpstats = 0;
|
|
char *cur;
|
|
|
|
first_mpstat(trace);
|
|
|
|
cur = first_mpstat(trace);
|
|
while (cur) {
|
|
num_mpstats++;
|
|
cur = next_mpstat(trace);
|
|
}
|
|
first_mpstat(trace);
|
|
trace->mpstat_seconds = num_mpstats;
|
|
}
|
|
|
|
static int guess_mpstat_cpus(struct trace *trace)
|
|
{
|
|
char *cur;
|
|
int ret;
|
|
int count = 0;
|
|
|
|
cur = first_mpstat(trace);
|
|
if (!cur)
|
|
return 0;
|
|
|
|
while (1) {
|
|
ret = next_mpstat_line(trace);
|
|
if (ret)
|
|
break;
|
|
|
|
cur = trace->mpstat_cur;
|
|
count++;
|
|
|
|
if (!cur)
|
|
break;
|
|
|
|
if (cur[0] == '\n')
|
|
break;
|
|
}
|
|
trace->mpstat_num_cpus = count - 1;
|
|
return 0;
|
|
}
|
|
|
|
static int count_mpstat_cpus(struct trace *trace)
|
|
{
|
|
char *cur = trace->mpstat_start;
|
|
char *cpu;
|
|
char *record;
|
|
int len; char *line;
|
|
|
|
first_mpstat(trace);
|
|
cpu = strstr(cur, " CPU)");
|
|
if (!cpu)
|
|
return guess_mpstat_cpus(trace);
|
|
|
|
line = strndup(cur, cpu - cur);
|
|
|
|
record = strrchr(line, '(');
|
|
if (!record) {
|
|
free(line);
|
|
return 0;
|
|
}
|
|
record++;
|
|
|
|
len = line + strlen(line) - record;
|
|
|
|
cur = strndup(record, len);
|
|
trace->mpstat_num_cpus = atoi(cur);
|
|
first_mpstat(trace);
|
|
free(line);
|
|
|
|
return trace->mpstat_num_cpus;
|
|
}
|
|
|
|
static char *guess_filename(char *trace_name)
|
|
{
|
|
struct stat st;
|
|
int ret;
|
|
char *cur;
|
|
char *tmp;
|
|
|
|
snprintf(line, line_len, "%s.mpstat", trace_name);
|
|
ret = stat(line, &st);
|
|
if (ret == 0)
|
|
return trace_name;
|
|
|
|
cur = strrchr(trace_name, '.');
|
|
if (!cur) {
|
|
return trace_name;
|
|
}
|
|
|
|
tmp = strndup(trace_name, cur - trace_name);
|
|
snprintf(line, line_len, "%s.mpstat", tmp);
|
|
ret = stat(line, &st);
|
|
if (ret == 0)
|
|
return tmp;
|
|
|
|
free(tmp);
|
|
return trace_name;
|
|
}
|
|
|
|
int read_mpstat(struct trace *trace, char *trace_name)
|
|
{
|
|
int fd;
|
|
struct stat st;
|
|
int ret;
|
|
char *p;
|
|
|
|
if (record_header_len == 0) {
|
|
record_header_len = strlen(record_header);
|
|
}
|
|
|
|
snprintf(line, line_len, "%s.mpstat", guess_filename(trace_name));
|
|
fd = open(line, O_RDONLY);
|
|
if (fd < 0)
|
|
return 0;
|
|
|
|
ret = fstat(fd, &st);
|
|
if (ret < 0) {
|
|
fprintf(stderr, "stat failed on %s err %s\n", line, strerror(errno));
|
|
goto fail_fd;
|
|
}
|
|
p = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
|
|
if (p == MAP_FAILED) {
|
|
fprintf(stderr, "Unable to mmap trace file %s, err %s\n", line, strerror(errno));
|
|
goto fail_fd;
|
|
}
|
|
trace->mpstat_start = p;
|
|
trace->mpstat_len = st.st_size;
|
|
trace->mpstat_cur = p;
|
|
trace->mpstat_fd = fd;
|
|
find_last_mpstat_time(trace);
|
|
count_mpstat_cpus(trace);
|
|
|
|
first_mpstat(trace);
|
|
|
|
return 0;
|
|
|
|
fail_fd:
|
|
close(fd);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* 09:56:26 AM CPU %usr %nice %sys %iowait %irq %soft %steal %guest %idle
|
|
*
|
|
* or
|
|
*
|
|
* 10:18:51 AM CPU %usr %nice %sys %iowait %irq %soft %steal %guest %gnice %idle
|
|
*
|
|
*
|
|
* this reads just one line in the mpstat
|
|
*/
|
|
int read_mpstat_event(struct trace *trace, double *user,
|
|
double *sys, double *iowait, double *irq,
|
|
double *soft)
|
|
{
|
|
char *cur = trace->mpstat_cur;
|
|
char *nptr;
|
|
double val;
|
|
|
|
/* jump past the date and CPU number */
|
|
cur += 16;
|
|
if (past_eof(trace, cur))
|
|
return 1;
|
|
|
|
/* usr time */
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
*user = val;
|
|
|
|
/* nice time, pitch this one */
|
|
cur = nptr;
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
|
|
/* system time */
|
|
cur = nptr;
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
*sys = val;
|
|
|
|
cur = nptr;
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
*iowait = val;
|
|
|
|
cur = nptr;
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
*irq = val;
|
|
|
|
cur = nptr;
|
|
val = strtod(cur, &nptr);
|
|
if (val == 0 && cur == nptr)
|
|
return 1;
|
|
*soft = val;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int add_mpstat_gld(int time, double sys, struct graph_line_data *gld)
|
|
{
|
|
gld->data[time].sum = sys;
|
|
gld->data[time].count = 1;
|
|
return 0;
|
|
|
|
}
|