mirror of
https://github.com/torvalds/linux.git
synced 2024-11-30 16:11:38 +00:00
perf/core improvements and fixes:
. Add IO mode into timechart command (Stanislav Fomichev) Signed-off-by: Jiri Olsa <jolsa@kernel.org> -----BEGIN PGP SIGNATURE----- Version: GnuPG v1 iQIcBAABAgAGBQJTvv4yAAoJEPZqUSBWB3s9NMAP/RPYdzw4Sj6IlVxpaChzDUBo AXfx8F9u2STSsiY93+UvcHMQcW+xbv7zXMDxZaLdxb6VmsRy6at30RbCNjNK0X1S XVlnKLdB4QS1Mouiewit6F149XcDsEsexpv4hi5wlpyMEW9dsG6zzxruZQhR1bvX aKOkPmt7uFnl+nVKB9/qn9RvAnn2bDP8Atd3mvSUMZQrX+0xC70FNnGsBBWU4FL+ O/Au0BtFg2cPPsYFTJiX3nVZfyM23Bf25zZmuNJTSR020zCX0fKeGIE4nUsuRRbY r3jBfykUKgrD+1152JxXoW1THw4QxwqJbUtQeZHouRqRXXThUw/0nq0Q+E33y6l+ nJ8q7E5Zvz+Y5fXZezU5gccQg+j8h1Ni/ped3qvapFgJ//kvY1sNMWRBcTB1o8hR 6vQd+MlNMao5P6tq3v8YegBHmUVVDKgUkf7eqH+po6KVIM2slr8wc09VcBggkYXu vlFfhYsSwEZ+uH6/4fFl1uqUsRkxs3ZcOnpgEyhFp6niJR2nBOD3a5BBIyCi5roh Y1kzyZzU8NEpYtCmmVtKDZqAFJGwAtoXJh4BzJgfa3vCF9T8aPgcjryLQpHYa4Fx 3mLjQ54b8TPSSyZH5JNW1SyFOCaI9y3jnaXAUSsTTjhD3ocqx+0MaAZ52YGjXWkm v0qrzEc/pSpGylddjxEE =dPmy -----END PGP SIGNATURE----- Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/jolsa/perf into perf/core Pull perf/core improvements and fixes from Jiri Olsa: * Add IO mode into timechart command (Stanislav Fomichev) Signed-off-by: Jiri Olsa <jolsa@kernel.org> Signed-off-by: Ingo Molnar <mingo@kernel.org>
This commit is contained in:
Ingo Molnar
commit
ff2ebe46e1
@ -15,10 +15,20 @@ DESCRIPTION
|
||||
There are two variants of perf timechart:
|
||||
|
||||
'perf timechart record <command>' to record the system level events
|
||||
of an arbitrary workload.
|
||||
of an arbitrary workload. By default timechart records only scheduler
|
||||
and CPU events (task switches, running times, CPU power states, etc),
|
||||
but it's possible to record IO (disk, network) activity using -I argument.
|
||||
|
||||
'perf timechart' to turn a trace into a Scalable Vector Graphics file,
|
||||
that can be viewed with popular SVG viewers such as 'Inkscape'.
|
||||
that can be viewed with popular SVG viewers such as 'Inkscape'. Depending
|
||||
on the events in the perf.data file, timechart will contain scheduler/cpu
|
||||
events or IO events.
|
||||
|
||||
In IO mode, every bar has two charts: upper and lower.
|
||||
Upper bar shows incoming events (disk reads, ingress network packets).
|
||||
Lower bar shows outgoing events (disk writes, egress network packets).
|
||||
There are also poll bars which show how much time application spent
|
||||
in poll/epoll/select syscalls.
|
||||
|
||||
TIMECHART OPTIONS
|
||||
-----------------
|
||||
@ -54,6 +64,19 @@ TIMECHART OPTIONS
|
||||
duration or tasks with given name. If number is given it's interpreted
|
||||
as number of nanoseconds. If non-numeric string is given it's
|
||||
interpreted as task name.
|
||||
--io-skip-eagain::
|
||||
Don't draw EAGAIN IO events.
|
||||
--io-min-time=<nsecs>::
|
||||
Draw small events as if they lasted min-time. Useful when you need
|
||||
to see very small and fast IO. It's possible to specify ms or us
|
||||
suffix to specify time in milliseconds or microseconds.
|
||||
Default value is 1ms.
|
||||
--io-merge-dist=<nsecs>::
|
||||
Merge events that are merge-dist nanoseconds apart.
|
||||
Reduces number of figures on the SVG and makes it more render-friendly.
|
||||
It's possible to specify ms or us suffix to specify time in
|
||||
milliseconds or microseconds.
|
||||
Default value is 1us.
|
||||
|
||||
RECORD OPTIONS
|
||||
--------------
|
||||
@ -63,6 +86,9 @@ RECORD OPTIONS
|
||||
-T::
|
||||
--tasks-only::
|
||||
Record only tasks-related events
|
||||
-I::
|
||||
--io-only::
|
||||
Record only io-related events
|
||||
-g::
|
||||
--callchain::
|
||||
Do call-graph (stack chain/backtrace) recording
|
||||
@ -87,6 +113,14 @@ Record system-wide timechart:
|
||||
|
||||
$ perf timechart --highlight gcc
|
||||
|
||||
Record system-wide IO events:
|
||||
|
||||
$ perf timechart record -I
|
||||
|
||||
then generate timechart:
|
||||
|
||||
$ perf timechart
|
||||
|
||||
SEE ALSO
|
||||
--------
|
||||
linkperf:perf-record[1]
|
||||
|
||||
@ -60,10 +60,17 @@ struct timechart {
|
||||
tasks_only,
|
||||
with_backtrace,
|
||||
topology;
|
||||
/* IO related settings */
|
||||
u64 io_events;
|
||||
bool io_only,
|
||||
skip_eagain;
|
||||
u64 min_time,
|
||||
merge_dist;
|
||||
};
|
||||
|
||||
struct per_pidcomm;
|
||||
struct cpu_sample;
|
||||
struct io_sample;
|
||||
|
||||
/*
|
||||
* Datastructure layout:
|
||||
@ -84,6 +91,7 @@ struct per_pid {
|
||||
u64 start_time;
|
||||
u64 end_time;
|
||||
u64 total_time;
|
||||
u64 total_bytes;
|
||||
int display;
|
||||
|
||||
struct per_pidcomm *all;
|
||||
@ -97,6 +105,8 @@ struct per_pidcomm {
|
||||
u64 start_time;
|
||||
u64 end_time;
|
||||
u64 total_time;
|
||||
u64 max_bytes;
|
||||
u64 total_bytes;
|
||||
|
||||
int Y;
|
||||
int display;
|
||||
@ -107,6 +117,7 @@ struct per_pidcomm {
|
||||
char *comm;
|
||||
|
||||
struct cpu_sample *samples;
|
||||
struct io_sample *io_samples;
|
||||
};
|
||||
|
||||
struct sample_wrapper {
|
||||
@ -131,6 +142,27 @@ struct cpu_sample {
|
||||
const char *backtrace;
|
||||
};
|
||||
|
||||
enum {
|
||||
IOTYPE_READ,
|
||||
IOTYPE_WRITE,
|
||||
IOTYPE_SYNC,
|
||||
IOTYPE_TX,
|
||||
IOTYPE_RX,
|
||||
IOTYPE_POLL,
|
||||
};
|
||||
|
||||
struct io_sample {
|
||||
struct io_sample *next;
|
||||
|
||||
u64 start_time;
|
||||
u64 end_time;
|
||||
u64 bytes;
|
||||
int type;
|
||||
int fd;
|
||||
int err;
|
||||
int merges;
|
||||
};
|
||||
|
||||
#define CSTATE 1
|
||||
#define PSTATE 2
|
||||
|
||||
@ -213,7 +245,7 @@ static void pid_fork(struct timechart *tchart, int pid, int ppid, u64 timestamp)
|
||||
pid_set_comm(tchart, pid, pp->current->comm);
|
||||
|
||||
p->start_time = timestamp;
|
||||
if (p->current) {
|
||||
if (p->current && !p->current->start_time) {
|
||||
p->current->start_time = timestamp;
|
||||
p->current->state_since = timestamp;
|
||||
}
|
||||
@ -682,6 +714,249 @@ static void end_sample_processing(struct timechart *tchart)
|
||||
}
|
||||
}
|
||||
|
||||
static int pid_begin_io_sample(struct timechart *tchart, int pid, int type,
|
||||
u64 start, int fd)
|
||||
{
|
||||
struct per_pid *p = find_create_pid(tchart, pid);
|
||||
struct per_pidcomm *c = p->current;
|
||||
struct io_sample *sample;
|
||||
struct io_sample *prev;
|
||||
|
||||
if (!c) {
|
||||
c = zalloc(sizeof(*c));
|
||||
if (!c)
|
||||
return -ENOMEM;
|
||||
p->current = c;
|
||||
c->next = p->all;
|
||||
p->all = c;
|
||||
}
|
||||
|
||||
prev = c->io_samples;
|
||||
|
||||
if (prev && prev->start_time && !prev->end_time) {
|
||||
pr_warning("Skip invalid start event: "
|
||||
"previous event already started!\n");
|
||||
|
||||
/* remove previous event that has been started,
|
||||
* we are not sure we will ever get an end for it */
|
||||
c->io_samples = prev->next;
|
||||
free(prev);
|
||||
return 0;
|
||||
}
|
||||
|
||||
sample = zalloc(sizeof(*sample));
|
||||
if (!sample)
|
||||
return -ENOMEM;
|
||||
sample->start_time = start;
|
||||
sample->type = type;
|
||||
sample->fd = fd;
|
||||
sample->next = c->io_samples;
|
||||
c->io_samples = sample;
|
||||
|
||||
if (c->start_time == 0 || c->start_time > start)
|
||||
c->start_time = start;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int pid_end_io_sample(struct timechart *tchart, int pid, int type,
|
||||
u64 end, long ret)
|
||||
{
|
||||
struct per_pid *p = find_create_pid(tchart, pid);
|
||||
struct per_pidcomm *c = p->current;
|
||||
struct io_sample *sample, *prev;
|
||||
|
||||
if (!c) {
|
||||
pr_warning("Invalid pidcomm!\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
sample = c->io_samples;
|
||||
|
||||
if (!sample) /* skip partially captured events */
|
||||
return 0;
|
||||
|
||||
if (sample->end_time) {
|
||||
pr_warning("Skip invalid end event: "
|
||||
"previous event already ended!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (sample->type != type) {
|
||||
pr_warning("Skip invalid end event: invalid event type!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
sample->end_time = end;
|
||||
prev = sample->next;
|
||||
|
||||
/* we want to be able to see small and fast transfers, so make them
|
||||
* at least min_time long, but don't overlap them */
|
||||
if (sample->end_time - sample->start_time < tchart->min_time)
|
||||
sample->end_time = sample->start_time + tchart->min_time;
|
||||
if (prev && sample->start_time < prev->end_time) {
|
||||
if (prev->err) /* try to make errors more visible */
|
||||
sample->start_time = prev->end_time;
|
||||
else
|
||||
prev->end_time = sample->start_time;
|
||||
}
|
||||
|
||||
if (ret < 0) {
|
||||
sample->err = ret;
|
||||
} else if (type == IOTYPE_READ || type == IOTYPE_WRITE ||
|
||||
type == IOTYPE_TX || type == IOTYPE_RX) {
|
||||
|
||||
if ((u64)ret > c->max_bytes)
|
||||
c->max_bytes = ret;
|
||||
|
||||
c->total_bytes += ret;
|
||||
p->total_bytes += ret;
|
||||
sample->bytes = ret;
|
||||
}
|
||||
|
||||
/* merge two requests to make svg smaller and render-friendly */
|
||||
if (prev &&
|
||||
prev->type == sample->type &&
|
||||
prev->err == sample->err &&
|
||||
prev->fd == sample->fd &&
|
||||
prev->end_time + tchart->merge_dist >= sample->start_time) {
|
||||
|
||||
sample->bytes += prev->bytes;
|
||||
sample->merges += prev->merges + 1;
|
||||
|
||||
sample->start_time = prev->start_time;
|
||||
sample->next = prev->next;
|
||||
free(prev);
|
||||
|
||||
if (!sample->err && sample->bytes > c->max_bytes)
|
||||
c->max_bytes = sample->bytes;
|
||||
}
|
||||
|
||||
tchart->io_events++;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_read(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_READ,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_read(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_READ,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_write(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_WRITE,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_write(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_WRITE,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_sync(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_SYNC,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_sync(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_SYNC,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_tx(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_TX,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_tx(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_TX,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_rx(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_RX,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_rx(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_RX,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
static int
|
||||
process_enter_poll(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long fd = perf_evsel__intval(evsel, sample, "fd");
|
||||
return pid_begin_io_sample(tchart, sample->tid, IOTYPE_POLL,
|
||||
sample->time, fd);
|
||||
}
|
||||
|
||||
static int
|
||||
process_exit_poll(struct timechart *tchart,
|
||||
struct perf_evsel *evsel,
|
||||
struct perf_sample *sample)
|
||||
{
|
||||
long ret = perf_evsel__intval(evsel, sample, "ret");
|
||||
return pid_end_io_sample(tchart, sample->tid, IOTYPE_POLL,
|
||||
sample->time, ret);
|
||||
}
|
||||
|
||||
/*
|
||||
* Sort the pid datastructure
|
||||
*/
|
||||
@ -852,6 +1127,121 @@ static void draw_cpu_usage(struct timechart *tchart)
|
||||
}
|
||||
}
|
||||
|
||||
static void draw_io_bars(struct timechart *tchart)
|
||||
{
|
||||
const char *suf;
|
||||
double bytes;
|
||||
char comm[256];
|
||||
struct per_pid *p;
|
||||
struct per_pidcomm *c;
|
||||
struct io_sample *sample;
|
||||
int Y = 1;
|
||||
|
||||
p = tchart->all_data;
|
||||
while (p) {
|
||||
c = p->all;
|
||||
while (c) {
|
||||
if (!c->display) {
|
||||
c->Y = 0;
|
||||
c = c->next;
|
||||
continue;
|
||||
}
|
||||
|
||||
svg_box(Y, c->start_time, c->end_time, "process3");
|
||||
sample = c->io_samples;
|
||||
for (sample = c->io_samples; sample; sample = sample->next) {
|
||||
double h = (double)sample->bytes / c->max_bytes;
|
||||
|
||||
if (tchart->skip_eagain &&
|
||||
sample->err == -EAGAIN)
|
||||
continue;
|
||||
|
||||
if (sample->err)
|
||||
h = 1;
|
||||
|
||||
if (sample->type == IOTYPE_SYNC)
|
||||
svg_fbox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
1,
|
||||
sample->err ? "error" : "sync",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
else if (sample->type == IOTYPE_POLL)
|
||||
svg_fbox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
1,
|
||||
sample->err ? "error" : "poll",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
else if (sample->type == IOTYPE_READ)
|
||||
svg_ubox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
h,
|
||||
sample->err ? "error" : "disk",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
else if (sample->type == IOTYPE_WRITE)
|
||||
svg_lbox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
h,
|
||||
sample->err ? "error" : "disk",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
else if (sample->type == IOTYPE_RX)
|
||||
svg_ubox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
h,
|
||||
sample->err ? "error" : "net",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
else if (sample->type == IOTYPE_TX)
|
||||
svg_lbox(Y,
|
||||
sample->start_time,
|
||||
sample->end_time,
|
||||
h,
|
||||
sample->err ? "error" : "net",
|
||||
sample->fd,
|
||||
sample->err,
|
||||
sample->merges);
|
||||
}
|
||||
|
||||
suf = "";
|
||||
bytes = c->total_bytes;
|
||||
if (bytes > 1024) {
|
||||
bytes = bytes / 1024;
|
||||
suf = "K";
|
||||
}
|
||||
if (bytes > 1024) {
|
||||
bytes = bytes / 1024;
|
||||
suf = "M";
|
||||
}
|
||||
if (bytes > 1024) {
|
||||
bytes = bytes / 1024;
|
||||
suf = "G";
|
||||
}
|
||||
|
||||
|
||||
sprintf(comm, "%s:%i (%3.1f %sbytes)", c->comm ?: "", p->pid, bytes, suf);
|
||||
svg_text(Y, c->start_time, comm);
|
||||
|
||||
c->Y = Y;
|
||||
Y++;
|
||||
c = c->next;
|
||||
}
|
||||
p = p->next;
|
||||
}
|
||||
}
|
||||
|
||||
static void draw_process_bars(struct timechart *tchart)
|
||||
{
|
||||
struct per_pid *p;
|
||||
@ -987,9 +1377,6 @@ static int determine_display_tasks(struct timechart *tchart, u64 threshold)
|
||||
struct per_pidcomm *c;
|
||||
int count = 0;
|
||||
|
||||
if (process_filter)
|
||||
return determine_display_tasks_filtered(tchart);
|
||||
|
||||
p = tchart->all_data;
|
||||
while (p) {
|
||||
p->display = 0;
|
||||
@ -1025,15 +1412,46 @@ static int determine_display_tasks(struct timechart *tchart, u64 threshold)
|
||||
return count;
|
||||
}
|
||||
|
||||
static int determine_display_io_tasks(struct timechart *timechart, u64 threshold)
|
||||
{
|
||||
struct per_pid *p;
|
||||
struct per_pidcomm *c;
|
||||
int count = 0;
|
||||
|
||||
p = timechart->all_data;
|
||||
while (p) {
|
||||
/* no exit marker, task kept running to the end */
|
||||
if (p->end_time == 0)
|
||||
p->end_time = timechart->last_time;
|
||||
|
||||
c = p->all;
|
||||
|
||||
while (c) {
|
||||
c->display = 0;
|
||||
|
||||
if (c->total_bytes >= threshold) {
|
||||
c->display = 1;
|
||||
count++;
|
||||
}
|
||||
|
||||
if (c->end_time == 0)
|
||||
c->end_time = timechart->last_time;
|
||||
|
||||
c = c->next;
|
||||
}
|
||||
p = p->next;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
#define BYTES_THRESH (1 * 1024 * 1024)
|
||||
#define TIME_THRESH 10000000
|
||||
|
||||
static void write_svg_file(struct timechart *tchart, const char *filename)
|
||||
{
|
||||
u64 i;
|
||||
int count;
|
||||
int thresh = TIME_THRESH;
|
||||
int thresh = tchart->io_events ? BYTES_THRESH : TIME_THRESH;
|
||||
|
||||
if (tchart->power_only)
|
||||
tchart->proc_num = 0;
|
||||
@ -1041,28 +1459,43 @@ static void write_svg_file(struct timechart *tchart, const char *filename)
|
||||
/* We'd like to show at least proc_num tasks;
|
||||
* be less picky if we have fewer */
|
||||
do {
|
||||
count = determine_display_tasks(tchart, thresh);
|
||||
if (process_filter)
|
||||
count = determine_display_tasks_filtered(tchart);
|
||||
else if (tchart->io_events)
|
||||
count = determine_display_io_tasks(tchart, thresh);
|
||||
else
|
||||
count = determine_display_tasks(tchart, thresh);
|
||||
thresh /= 10;
|
||||
} while (!process_filter && thresh && count < tchart->proc_num);
|
||||
|
||||
if (!tchart->proc_num)
|
||||
count = 0;
|
||||
|
||||
open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
|
||||
if (tchart->io_events) {
|
||||
open_svg(filename, 0, count, tchart->first_time, tchart->last_time);
|
||||
|
||||
svg_time_grid();
|
||||
svg_legenda();
|
||||
svg_time_grid(0.5);
|
||||
svg_io_legenda();
|
||||
|
||||
for (i = 0; i < tchart->numcpus; i++)
|
||||
svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
|
||||
draw_io_bars(tchart);
|
||||
} else {
|
||||
open_svg(filename, tchart->numcpus, count, tchart->first_time, tchart->last_time);
|
||||
|
||||
draw_cpu_usage(tchart);
|
||||
if (tchart->proc_num)
|
||||
draw_process_bars(tchart);
|
||||
if (!tchart->tasks_only)
|
||||
draw_c_p_states(tchart);
|
||||
if (tchart->proc_num)
|
||||
draw_wakeups(tchart);
|
||||
svg_time_grid(0);
|
||||
|
||||
svg_legenda();
|
||||
|
||||
for (i = 0; i < tchart->numcpus; i++)
|
||||
svg_cpu_box(i, tchart->max_freq, tchart->turbo_frequency);
|
||||
|
||||
draw_cpu_usage(tchart);
|
||||
if (tchart->proc_num)
|
||||
draw_process_bars(tchart);
|
||||
if (!tchart->tasks_only)
|
||||
draw_c_p_states(tchart);
|
||||
if (tchart->proc_num)
|
||||
draw_wakeups(tchart);
|
||||
}
|
||||
|
||||
svg_close();
|
||||
}
|
||||
@ -1110,6 +1543,56 @@ static int __cmd_timechart(struct timechart *tchart, const char *output_name)
|
||||
{ "power:power_end", process_sample_power_end },
|
||||
{ "power:power_frequency", process_sample_power_frequency },
|
||||
#endif
|
||||
|
||||
{ "syscalls:sys_enter_read", process_enter_read },
|
||||
{ "syscalls:sys_enter_pread64", process_enter_read },
|
||||
{ "syscalls:sys_enter_readv", process_enter_read },
|
||||
{ "syscalls:sys_enter_preadv", process_enter_read },
|
||||
{ "syscalls:sys_enter_write", process_enter_write },
|
||||
{ "syscalls:sys_enter_pwrite64", process_enter_write },
|
||||
{ "syscalls:sys_enter_writev", process_enter_write },
|
||||
{ "syscalls:sys_enter_pwritev", process_enter_write },
|
||||
{ "syscalls:sys_enter_sync", process_enter_sync },
|
||||
{ "syscalls:sys_enter_sync_file_range", process_enter_sync },
|
||||
{ "syscalls:sys_enter_fsync", process_enter_sync },
|
||||
{ "syscalls:sys_enter_msync", process_enter_sync },
|
||||
{ "syscalls:sys_enter_recvfrom", process_enter_rx },
|
||||
{ "syscalls:sys_enter_recvmmsg", process_enter_rx },
|
||||
{ "syscalls:sys_enter_recvmsg", process_enter_rx },
|
||||
{ "syscalls:sys_enter_sendto", process_enter_tx },
|
||||
{ "syscalls:sys_enter_sendmsg", process_enter_tx },
|
||||
{ "syscalls:sys_enter_sendmmsg", process_enter_tx },
|
||||
{ "syscalls:sys_enter_epoll_pwait", process_enter_poll },
|
||||
{ "syscalls:sys_enter_epoll_wait", process_enter_poll },
|
||||
{ "syscalls:sys_enter_poll", process_enter_poll },
|
||||
{ "syscalls:sys_enter_ppoll", process_enter_poll },
|
||||
{ "syscalls:sys_enter_pselect6", process_enter_poll },
|
||||
{ "syscalls:sys_enter_select", process_enter_poll },
|
||||
|
||||
{ "syscalls:sys_exit_read", process_exit_read },
|
||||
{ "syscalls:sys_exit_pread64", process_exit_read },
|
||||
{ "syscalls:sys_exit_readv", process_exit_read },
|
||||
{ "syscalls:sys_exit_preadv", process_exit_read },
|
||||
{ "syscalls:sys_exit_write", process_exit_write },
|
||||
{ "syscalls:sys_exit_pwrite64", process_exit_write },
|
||||
{ "syscalls:sys_exit_writev", process_exit_write },
|
||||
{ "syscalls:sys_exit_pwritev", process_exit_write },
|
||||
{ "syscalls:sys_exit_sync", process_exit_sync },
|
||||
{ "syscalls:sys_exit_sync_file_range", process_exit_sync },
|
||||
{ "syscalls:sys_exit_fsync", process_exit_sync },
|
||||
{ "syscalls:sys_exit_msync", process_exit_sync },
|
||||
{ "syscalls:sys_exit_recvfrom", process_exit_rx },
|
||||
{ "syscalls:sys_exit_recvmmsg", process_exit_rx },
|
||||
{ "syscalls:sys_exit_recvmsg", process_exit_rx },
|
||||
{ "syscalls:sys_exit_sendto", process_exit_tx },
|
||||
{ "syscalls:sys_exit_sendmsg", process_exit_tx },
|
||||
{ "syscalls:sys_exit_sendmmsg", process_exit_tx },
|
||||
{ "syscalls:sys_exit_epoll_pwait", process_exit_poll },
|
||||
{ "syscalls:sys_exit_epoll_wait", process_exit_poll },
|
||||
{ "syscalls:sys_exit_poll", process_exit_poll },
|
||||
{ "syscalls:sys_exit_ppoll", process_exit_poll },
|
||||
{ "syscalls:sys_exit_pselect6", process_exit_poll },
|
||||
{ "syscalls:sys_exit_select", process_exit_poll },
|
||||
};
|
||||
struct perf_data_file file = {
|
||||
.path = input_name,
|
||||
@ -1154,6 +1637,139 @@ out_delete:
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int timechart__io_record(int argc, const char **argv)
|
||||
{
|
||||
unsigned int rec_argc, i;
|
||||
const char **rec_argv;
|
||||
const char **p;
|
||||
char *filter = NULL;
|
||||
|
||||
const char * const common_args[] = {
|
||||
"record", "-a", "-R", "-c", "1",
|
||||
};
|
||||
unsigned int common_args_nr = ARRAY_SIZE(common_args);
|
||||
|
||||
const char * const disk_events[] = {
|
||||
"syscalls:sys_enter_read",
|
||||
"syscalls:sys_enter_pread64",
|
||||
"syscalls:sys_enter_readv",
|
||||
"syscalls:sys_enter_preadv",
|
||||
"syscalls:sys_enter_write",
|
||||
"syscalls:sys_enter_pwrite64",
|
||||
"syscalls:sys_enter_writev",
|
||||
"syscalls:sys_enter_pwritev",
|
||||
"syscalls:sys_enter_sync",
|
||||
"syscalls:sys_enter_sync_file_range",
|
||||
"syscalls:sys_enter_fsync",
|
||||
"syscalls:sys_enter_msync",
|
||||
|
||||
"syscalls:sys_exit_read",
|
||||
"syscalls:sys_exit_pread64",
|
||||
"syscalls:sys_exit_readv",
|
||||
"syscalls:sys_exit_preadv",
|
||||
"syscalls:sys_exit_write",
|
||||
"syscalls:sys_exit_pwrite64",
|
||||
"syscalls:sys_exit_writev",
|
||||
"syscalls:sys_exit_pwritev",
|
||||
"syscalls:sys_exit_sync",
|
||||
"syscalls:sys_exit_sync_file_range",
|
||||
"syscalls:sys_exit_fsync",
|
||||
"syscalls:sys_exit_msync",
|
||||
};
|
||||
unsigned int disk_events_nr = ARRAY_SIZE(disk_events);
|
||||
|
||||
const char * const net_events[] = {
|
||||
"syscalls:sys_enter_recvfrom",
|
||||
"syscalls:sys_enter_recvmmsg",
|
||||
"syscalls:sys_enter_recvmsg",
|
||||
"syscalls:sys_enter_sendto",
|
||||
"syscalls:sys_enter_sendmsg",
|
||||
"syscalls:sys_enter_sendmmsg",
|
||||
|
||||
"syscalls:sys_exit_recvfrom",
|
||||
"syscalls:sys_exit_recvmmsg",
|
||||
"syscalls:sys_exit_recvmsg",
|
||||
"syscalls:sys_exit_sendto",
|
||||
"syscalls:sys_exit_sendmsg",
|
||||
"syscalls:sys_exit_sendmmsg",
|
||||
};
|
||||
unsigned int net_events_nr = ARRAY_SIZE(net_events);
|
||||
|
||||
const char * const poll_events[] = {
|
||||
"syscalls:sys_enter_epoll_pwait",
|
||||
"syscalls:sys_enter_epoll_wait",
|
||||
"syscalls:sys_enter_poll",
|
||||
"syscalls:sys_enter_ppoll",
|
||||
"syscalls:sys_enter_pselect6",
|
||||
"syscalls:sys_enter_select",
|
||||
|
||||
"syscalls:sys_exit_epoll_pwait",
|
||||
"syscalls:sys_exit_epoll_wait",
|
||||
"syscalls:sys_exit_poll",
|
||||
"syscalls:sys_exit_ppoll",
|
||||
"syscalls:sys_exit_pselect6",
|
||||
"syscalls:sys_exit_select",
|
||||
};
|
||||
unsigned int poll_events_nr = ARRAY_SIZE(poll_events);
|
||||
|
||||
rec_argc = common_args_nr +
|
||||
disk_events_nr * 4 +
|
||||
net_events_nr * 4 +
|
||||
poll_events_nr * 4 +
|
||||
argc;
|
||||
rec_argv = calloc(rec_argc + 1, sizeof(char *));
|
||||
|
||||
if (rec_argv == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
if (asprintf(&filter, "common_pid != %d", getpid()) < 0)
|
||||
return -ENOMEM;
|
||||
|
||||
p = rec_argv;
|
||||
for (i = 0; i < common_args_nr; i++)
|
||||
*p++ = strdup(common_args[i]);
|
||||
|
||||
for (i = 0; i < disk_events_nr; i++) {
|
||||
if (!is_valid_tracepoint(disk_events[i])) {
|
||||
rec_argc -= 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
*p++ = "-e";
|
||||
*p++ = strdup(disk_events[i]);
|
||||
*p++ = "--filter";
|
||||
*p++ = filter;
|
||||
}
|
||||
for (i = 0; i < net_events_nr; i++) {
|
||||
if (!is_valid_tracepoint(net_events[i])) {
|
||||
rec_argc -= 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
*p++ = "-e";
|
||||
*p++ = strdup(net_events[i]);
|
||||
*p++ = "--filter";
|
||||
*p++ = filter;
|
||||
}
|
||||
for (i = 0; i < poll_events_nr; i++) {
|
||||
if (!is_valid_tracepoint(poll_events[i])) {
|
||||
rec_argc -= 4;
|
||||
continue;
|
||||
}
|
||||
|
||||
*p++ = "-e";
|
||||
*p++ = strdup(poll_events[i]);
|
||||
*p++ = "--filter";
|
||||
*p++ = filter;
|
||||
}
|
||||
|
||||
for (i = 0; i < (unsigned int)argc; i++)
|
||||
*p++ = argv[i];
|
||||
|
||||
return cmd_record(rec_argc, rec_argv, NULL);
|
||||
}
|
||||
|
||||
|
||||
static int timechart__record(struct timechart *tchart, int argc, const char **argv)
|
||||
{
|
||||
unsigned int rec_argc, i, j;
|
||||
@ -1270,6 +1886,30 @@ parse_highlight(const struct option *opt __maybe_unused, const char *arg,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int
|
||||
parse_time(const struct option *opt, const char *arg, int __maybe_unused unset)
|
||||
{
|
||||
char unit = 'n';
|
||||
u64 *value = opt->value;
|
||||
|
||||
if (sscanf(arg, "%" PRIu64 "%cs", value, &unit) > 0) {
|
||||
switch (unit) {
|
||||
case 'm':
|
||||
*value *= 1000000;
|
||||
break;
|
||||
case 'u':
|
||||
*value *= 1000;
|
||||
break;
|
||||
case 'n':
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cmd_timechart(int argc, const char **argv,
|
||||
const char *prefix __maybe_unused)
|
||||
{
|
||||
@ -1282,6 +1922,8 @@ int cmd_timechart(int argc, const char **argv,
|
||||
.ordered_samples = true,
|
||||
},
|
||||
.proc_num = 15,
|
||||
.min_time = 1000000,
|
||||
.merge_dist = 1000,
|
||||
};
|
||||
const char *output_name = "output.svg";
|
||||
const struct option timechart_options[] = {
|
||||
@ -1303,6 +1945,14 @@ int cmd_timechart(int argc, const char **argv,
|
||||
"min. number of tasks to print"),
|
||||
OPT_BOOLEAN('t', "topology", &tchart.topology,
|
||||
"sort CPUs according to topology"),
|
||||
OPT_BOOLEAN(0, "io-skip-eagain", &tchart.skip_eagain,
|
||||
"skip EAGAIN errors"),
|
||||
OPT_CALLBACK(0, "io-min-time", &tchart.min_time, "time",
|
||||
"all IO faster than min-time will visually appear longer",
|
||||
parse_time),
|
||||
OPT_CALLBACK(0, "io-merge-dist", &tchart.merge_dist, "time",
|
||||
"merge events that are merge-dist us apart",
|
||||
parse_time),
|
||||
OPT_END()
|
||||
};
|
||||
const char * const timechart_usage[] = {
|
||||
@ -1314,6 +1964,8 @@ int cmd_timechart(int argc, const char **argv,
|
||||
OPT_BOOLEAN('P', "power-only", &tchart.power_only, "output power data only"),
|
||||
OPT_BOOLEAN('T', "tasks-only", &tchart.tasks_only,
|
||||
"output processes data only"),
|
||||
OPT_BOOLEAN('I', "io-only", &tchart.io_only,
|
||||
"record only IO data"),
|
||||
OPT_BOOLEAN('g', "callchain", &tchart.with_backtrace, "record callchain"),
|
||||
OPT_END()
|
||||
};
|
||||
@ -1340,7 +1992,10 @@ int cmd_timechart(int argc, const char **argv,
|
||||
return -1;
|
||||
}
|
||||
|
||||
return timechart__record(&tchart, argc, argv);
|
||||
if (tchart.io_only)
|
||||
return timechart__io_record(argc, argv);
|
||||
else
|
||||
return timechart__record(&tchart, argc, argv);
|
||||
} else if (argc)
|
||||
usage_with_options(timechart_usage, timechart_options);
|
||||
|
||||
|
||||
@ -30,6 +30,7 @@ static u64 turbo_frequency, max_freq;
|
||||
|
||||
#define SLOT_MULT 30.0
|
||||
#define SLOT_HEIGHT 25.0
|
||||
#define SLOT_HALF (SLOT_HEIGHT / 2)
|
||||
|
||||
int svg_page_width = 1000;
|
||||
u64 svg_highlight;
|
||||
@ -114,8 +115,14 @@ void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
|
||||
fprintf(svgfile, " rect { stroke-width: 1; }\n");
|
||||
fprintf(svgfile, " rect.process { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:1; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.process2 { fill:rgb(180,180,180); fill-opacity:0.9; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.process3 { fill:rgb(180,180,180); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.sample { fill:rgb( 0, 0,255); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.sample_hi{ fill:rgb(255,128, 0); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.error { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.net { fill:rgb( 0,128, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.disk { fill:rgb( 0, 0,255); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.sync { fill:rgb(128,128, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.poll { fill:rgb( 0,128,128); fill-opacity:0.2; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.blocked { fill:rgb(255, 0, 0); fill-opacity:0.5; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.waiting { fill:rgb(224,214, 0); fill-opacity:0.8; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
fprintf(svgfile, " rect.WAITING { fill:rgb(255,214, 48); fill-opacity:0.6; stroke-width:0; stroke:rgb( 0, 0, 0); } \n");
|
||||
@ -132,12 +139,81 @@ void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end)
|
||||
fprintf(svgfile, " ]]>\n </style>\n</defs>\n");
|
||||
}
|
||||
|
||||
static double normalize_height(double height)
|
||||
{
|
||||
if (height < 0.25)
|
||||
return 0.25;
|
||||
else if (height < 0.50)
|
||||
return 0.50;
|
||||
else if (height < 0.75)
|
||||
return 0.75;
|
||||
else
|
||||
return 0.100;
|
||||
}
|
||||
|
||||
void svg_ubox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
|
||||
{
|
||||
double w = time2pixels(end) - time2pixels(start);
|
||||
height = normalize_height(height);
|
||||
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<g>\n");
|
||||
fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(start),
|
||||
w,
|
||||
Yslot * SLOT_MULT,
|
||||
SLOT_HALF * height,
|
||||
type);
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
|
||||
void svg_lbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
|
||||
{
|
||||
double w = time2pixels(end) - time2pixels(start);
|
||||
height = normalize_height(height);
|
||||
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<g>\n");
|
||||
fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(start),
|
||||
w,
|
||||
Yslot * SLOT_MULT + SLOT_HEIGHT - SLOT_HALF * height,
|
||||
SLOT_HALF * height,
|
||||
type);
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
|
||||
void svg_fbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges)
|
||||
{
|
||||
double w = time2pixels(end) - time2pixels(start);
|
||||
height = normalize_height(height);
|
||||
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<g>\n");
|
||||
fprintf(svgfile, "<title>fd=%d error=%d merges=%d</title>\n", fd, err, merges);
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(start),
|
||||
w,
|
||||
Yslot * SLOT_MULT + SLOT_HEIGHT - SLOT_HEIGHT * height,
|
||||
SLOT_HEIGHT * height,
|
||||
type);
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
|
||||
void svg_box(int Yslot, u64 start, u64 end, const char *type)
|
||||
{
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT, type);
|
||||
}
|
||||
|
||||
@ -174,7 +250,7 @@ void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
|
||||
cpu, time_to_string(end - start));
|
||||
if (backtrace)
|
||||
fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
|
||||
fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"%s\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(start), time2pixels(end)-time2pixels(start), Yslot * SLOT_MULT, SLOT_HEIGHT,
|
||||
type);
|
||||
|
||||
@ -186,7 +262,7 @@ void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
|
||||
text_size = round_text_size(text_size);
|
||||
|
||||
if (text_size > MIN_TEXT_SIZE)
|
||||
fprintf(svgfile, "<text x=\"%1.8f\" y=\"%1.8f\" font-size=\"%1.8fpt\">%i</text>\n",
|
||||
fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"%.8fpt\">%i</text>\n",
|
||||
time2pixels(start), Yslot * SLOT_MULT + SLOT_HEIGHT - 1, text_size, cpu + 1);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -202,10 +278,10 @@ static char *time_to_string(u64 duration)
|
||||
return text;
|
||||
|
||||
if (duration < 1000 * 1000) { /* less than 1 msec */
|
||||
sprintf(text, "%4.1f us", duration / 1000.0);
|
||||
sprintf(text, "%.1f us", duration / 1000.0);
|
||||
return text;
|
||||
}
|
||||
sprintf(text, "%4.1f ms", duration / 1000.0 / 1000);
|
||||
sprintf(text, "%.1f ms", duration / 1000.0 / 1000);
|
||||
|
||||
return text;
|
||||
}
|
||||
@ -233,14 +309,14 @@ void svg_waiting(int Yslot, int cpu, u64 start, u64 end, const char *backtrace)
|
||||
|
||||
font_size = round_text_size(font_size);
|
||||
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\">\n", time2pixels(start), Yslot * SLOT_MULT);
|
||||
fprintf(svgfile, "<title>#%d waiting %s</title>\n", cpu, time_to_string(end - start));
|
||||
if (backtrace)
|
||||
fprintf(svgfile, "<desc>Waiting on:\n%s</desc>\n", backtrace);
|
||||
fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"0\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(end)-time2pixels(start), SLOT_HEIGHT, style);
|
||||
if (font_size > MIN_TEXT_SIZE)
|
||||
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%1.8fpt\"> %s</text>\n",
|
||||
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%.8fpt\"> %s</text>\n",
|
||||
font_size, text);
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
@ -289,16 +365,16 @@ void svg_cpu_box(int cpu, u64 __max_freq, u64 __turbo_freq)
|
||||
|
||||
fprintf(svgfile, "<g>\n");
|
||||
|
||||
fprintf(svgfile, "<rect x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\" class=\"cpu\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\" class=\"cpu\"/>\n",
|
||||
time2pixels(first_time),
|
||||
time2pixels(last_time)-time2pixels(first_time),
|
||||
cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
|
||||
|
||||
sprintf(cpu_string, "CPU %i", (int)cpu);
|
||||
fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
|
||||
fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\">%s</text>\n",
|
||||
10+time2pixels(first_time), cpu2y(cpu) + SLOT_HEIGHT/2, cpu_string);
|
||||
|
||||
fprintf(svgfile, "<text transform=\"translate(%4.8f,%4.8f)\" font-size=\"1.25pt\">%s</text>\n",
|
||||
fprintf(svgfile, "<text transform=\"translate(%.8f,%.8f)\" font-size=\"1.25pt\">%s</text>\n",
|
||||
10+time2pixels(first_time), cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - 4, cpu_model());
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -319,11 +395,11 @@ void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const c
|
||||
else
|
||||
type = "sample";
|
||||
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\">\n", time2pixels(start), cpu2y(cpu));
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\">\n", time2pixels(start), cpu2y(cpu));
|
||||
fprintf(svgfile, "<title>%d %s running %s</title>\n", pid, name, time_to_string(end - start));
|
||||
if (backtrace)
|
||||
fprintf(svgfile, "<desc>Switched because:\n%s</desc>\n", backtrace);
|
||||
fprintf(svgfile, "<rect x=\"0\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"0\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
time2pixels(end)-time2pixels(start), SLOT_MULT+SLOT_HEIGHT, type);
|
||||
width = time2pixels(end)-time2pixels(start);
|
||||
if (width > 6)
|
||||
@ -332,7 +408,7 @@ void svg_process(int cpu, u64 start, u64 end, int pid, const char *name, const c
|
||||
width = round_text_size(width);
|
||||
|
||||
if (width > MIN_TEXT_SIZE)
|
||||
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%3.8fpt\">%s</text>\n",
|
||||
fprintf(svgfile, "<text transform=\"rotate(90)\" font-size=\"%.8fpt\">%s</text>\n",
|
||||
width, name);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -353,7 +429,7 @@ void svg_cstate(int cpu, u64 start, u64 end, int type)
|
||||
type = 6;
|
||||
sprintf(style, "c%i", type);
|
||||
|
||||
fprintf(svgfile, "<rect class=\"%s\" x=\"%4.8f\" width=\"%4.8f\" y=\"%4.1f\" height=\"%4.1f\"/>\n",
|
||||
fprintf(svgfile, "<rect class=\"%s\" x=\"%.8f\" width=\"%.8f\" y=\"%.1f\" height=\"%.1f\"/>\n",
|
||||
style,
|
||||
time2pixels(start), time2pixels(end)-time2pixels(start),
|
||||
cpu2y(cpu), SLOT_MULT+SLOT_HEIGHT);
|
||||
@ -365,7 +441,7 @@ void svg_cstate(int cpu, u64 start, u64 end, int type)
|
||||
width = round_text_size(width);
|
||||
|
||||
if (width > MIN_TEXT_SIZE)
|
||||
fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"%3.8fpt\">C%i</text>\n",
|
||||
fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"%.8fpt\">C%i</text>\n",
|
||||
time2pixels(start), cpu2y(cpu)+width, width, type);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -407,9 +483,9 @@ void svg_pstate(int cpu, u64 start, u64 end, u64 freq)
|
||||
if (max_freq)
|
||||
height = freq * 1.0 / max_freq * (SLOT_HEIGHT + SLOT_MULT);
|
||||
height = 1 + cpu2y(cpu) + SLOT_MULT + SLOT_HEIGHT - height;
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" x2=\"%4.8f\" y1=\"%4.1f\" y2=\"%4.1f\" class=\"pstate\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" x2=\"%.8f\" y1=\"%.1f\" y2=\"%.1f\" class=\"pstate\"/>\n",
|
||||
time2pixels(start), time2pixels(end), height, height);
|
||||
fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\" font-size=\"0.25pt\">%s</text>\n",
|
||||
fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\" font-size=\"0.25pt\">%s</text>\n",
|
||||
time2pixels(start), height+0.9, HzToHuman(freq));
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -435,32 +511,32 @@ void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc
|
||||
|
||||
if (row1 < row2) {
|
||||
if (row1) {
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
|
||||
if (desc2)
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
|
||||
time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT + SLOT_HEIGHT/48, desc2);
|
||||
}
|
||||
if (row2) {
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row2 * SLOT_MULT);
|
||||
if (desc1)
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s ></text></g>\n",
|
||||
time2pixels(start), row2 * SLOT_MULT - SLOT_MULT/32, desc1);
|
||||
}
|
||||
} else {
|
||||
if (row2) {
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/32);
|
||||
if (desc1)
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
|
||||
time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT + SLOT_MULT/48, desc1);
|
||||
}
|
||||
if (row1) {
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row1 * SLOT_MULT - SLOT_MULT/32, time2pixels(start), row1 * SLOT_MULT);
|
||||
if (desc2)
|
||||
fprintf(svgfile, "<g transform=\"translate(%4.8f,%4.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
|
||||
fprintf(svgfile, "<g transform=\"translate(%.8f,%.8f)\"><text transform=\"rotate(90)\" font-size=\"0.02pt\">%s <</text></g>\n",
|
||||
time2pixels(start), row1 * SLOT_MULT - SLOT_HEIGHT/32, desc2);
|
||||
}
|
||||
}
|
||||
@ -468,7 +544,7 @@ void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc
|
||||
if (row2 > row1)
|
||||
height += SLOT_HEIGHT;
|
||||
if (row1)
|
||||
fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
|
||||
fprintf(svgfile, "<circle cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
|
||||
time2pixels(start), height);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -488,16 +564,16 @@ void svg_wakeline(u64 start, int row1, int row2, const char *backtrace)
|
||||
fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
|
||||
|
||||
if (row1 < row2)
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row1 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row2 * SLOT_MULT);
|
||||
else
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%4.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%.2f\" style=\"stroke:rgb(32,255,32);stroke-width:0.009\"/>\n",
|
||||
time2pixels(start), row2 * SLOT_MULT + SLOT_HEIGHT, time2pixels(start), row1 * SLOT_MULT);
|
||||
|
||||
height = row1 * SLOT_MULT;
|
||||
if (row2 > row1)
|
||||
height += SLOT_HEIGHT;
|
||||
fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
|
||||
fprintf(svgfile, "<circle cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\" style=\"fill:rgb(32,255,32)\"/>\n",
|
||||
time2pixels(start), height);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -515,9 +591,9 @@ void svg_interrupt(u64 start, int row, const char *backtrace)
|
||||
if (backtrace)
|
||||
fprintf(svgfile, "<desc>%s</desc>\n", backtrace);
|
||||
|
||||
fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
|
||||
fprintf(svgfile, "<circle cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
|
||||
time2pixels(start), row * SLOT_MULT);
|
||||
fprintf(svgfile, "<circle cx=\"%4.8f\" cy=\"%4.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
|
||||
fprintf(svgfile, "<circle cx=\"%.8f\" cy=\"%.2f\" r = \"0.01\" style=\"fill:rgb(255,128,128)\"/>\n",
|
||||
time2pixels(start), row * SLOT_MULT + SLOT_HEIGHT);
|
||||
|
||||
fprintf(svgfile, "</g>\n");
|
||||
@ -528,7 +604,7 @@ void svg_text(int Yslot, u64 start, const char *text)
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<text x=\"%4.8f\" y=\"%4.8f\">%s</text>\n",
|
||||
fprintf(svgfile, "<text x=\"%.8f\" y=\"%.8f\">%s</text>\n",
|
||||
time2pixels(start), Yslot * SLOT_MULT+SLOT_HEIGHT/2, text);
|
||||
}
|
||||
|
||||
@ -537,12 +613,26 @@ static void svg_legenda_box(int X, const char *text, const char *style)
|
||||
double boxsize;
|
||||
boxsize = SLOT_HEIGHT / 2;
|
||||
|
||||
fprintf(svgfile, "<rect x=\"%i\" width=\"%4.8f\" y=\"0\" height=\"%4.1f\" class=\"%s\"/>\n",
|
||||
fprintf(svgfile, "<rect x=\"%i\" width=\"%.8f\" y=\"0\" height=\"%.1f\" class=\"%s\"/>\n",
|
||||
X, boxsize, boxsize, style);
|
||||
fprintf(svgfile, "<text transform=\"translate(%4.8f, %4.8f)\" font-size=\"%4.8fpt\">%s</text>\n",
|
||||
fprintf(svgfile, "<text transform=\"translate(%.8f, %.8f)\" font-size=\"%.8fpt\">%s</text>\n",
|
||||
X + boxsize + 5, boxsize, 0.8 * boxsize, text);
|
||||
}
|
||||
|
||||
void svg_io_legenda(void)
|
||||
{
|
||||
if (!svgfile)
|
||||
return;
|
||||
|
||||
fprintf(svgfile, "<g>\n");
|
||||
svg_legenda_box(0, "Disk", "disk");
|
||||
svg_legenda_box(100, "Network", "net");
|
||||
svg_legenda_box(200, "Sync", "sync");
|
||||
svg_legenda_box(300, "Poll", "poll");
|
||||
svg_legenda_box(400, "Error", "error");
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
|
||||
void svg_legenda(void)
|
||||
{
|
||||
if (!svgfile)
|
||||
@ -559,7 +649,7 @@ void svg_legenda(void)
|
||||
fprintf(svgfile, "</g>\n");
|
||||
}
|
||||
|
||||
void svg_time_grid(void)
|
||||
void svg_time_grid(double min_thickness)
|
||||
{
|
||||
u64 i;
|
||||
|
||||
@ -579,8 +669,10 @@ void svg_time_grid(void)
|
||||
color = 128;
|
||||
}
|
||||
|
||||
fprintf(svgfile, "<line x1=\"%4.8f\" y1=\"%4.2f\" x2=\"%4.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%1.3f\"/>\n",
|
||||
time2pixels(i), SLOT_MULT/2, time2pixels(i), total_height, color, color, color, thickness);
|
||||
if (thickness >= min_thickness)
|
||||
fprintf(svgfile, "<line x1=\"%.8f\" y1=\"%.2f\" x2=\"%.8f\" y2=\"%" PRIu64 "\" style=\"stroke:rgb(%i,%i,%i);stroke-width:%.3f\"/>\n",
|
||||
time2pixels(i), SLOT_MULT/2, time2pixels(i),
|
||||
total_height, color, color, color, thickness);
|
||||
|
||||
i += 10000000;
|
||||
}
|
||||
|
||||
@ -4,6 +4,9 @@
|
||||
#include <linux/types.h>
|
||||
|
||||
extern void open_svg(const char *filename, int cpus, int rows, u64 start, u64 end);
|
||||
extern void svg_ubox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
|
||||
extern void svg_lbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
|
||||
extern void svg_fbox(int Yslot, u64 start, u64 end, double height, const char *type, int fd, int err, int merges);
|
||||
extern void svg_box(int Yslot, u64 start, u64 end, const char *type);
|
||||
extern void svg_blocked(int Yslot, int cpu, u64 start, u64 end, const char *backtrace);
|
||||
extern void svg_running(int Yslot, int cpu, u64 start, u64 end, const char *backtrace);
|
||||
@ -16,7 +19,8 @@ extern void svg_cstate(int cpu, u64 start, u64 end, int type);
|
||||
extern void svg_pstate(int cpu, u64 start, u64 end, u64 freq);
|
||||
|
||||
|
||||
extern void svg_time_grid(void);
|
||||
extern void svg_time_grid(double min_thickness);
|
||||
extern void svg_io_legenda(void);
|
||||
extern void svg_legenda(void);
|
||||
extern void svg_wakeline(u64 start, int row1, int row2, const char *backtrace);
|
||||
extern void svg_partial_wakeline(u64 start, int row1, char *desc1, int row2, char *desc2, const char *backtrace);
|
||||
|
||||
Loading…
Reference in New Issue
Block a user