1#!/usr/bin/perl
2# This is a POC for reading the text representation of trace output related to
3# page reclaim. It makes an attempt to extract some high-level information on
4# what is going on. The accuracy of the parser may vary
5#
6# Example usage: trace-vmscan-postprocess.pl < /sys/kernel/debug/tracing/trace_pipe
7# other options
8#   --read-procstat	If the trace lacks process info, get it from /proc
9#   --ignore-pid	Aggregate processes of the same name together
10#
11# Copyright (c) IBM Corporation 2009
12# Author: Mel Gorman <mel@csn.ul.ie>
13use strict;
14use Getopt::Long;
15
16# Tracepoint events
17use constant MM_VMSCAN_DIRECT_RECLAIM_BEGIN	=> 1;
18use constant MM_VMSCAN_DIRECT_RECLAIM_END	=> 2;
19use constant MM_VMSCAN_KSWAPD_WAKE		=> 3;
20use constant MM_VMSCAN_KSWAPD_SLEEP		=> 4;
21use constant MM_VMSCAN_LRU_SHRINK_ACTIVE	=> 5;
22use constant MM_VMSCAN_LRU_SHRINK_INACTIVE	=> 6;
23use constant MM_VMSCAN_LRU_ISOLATE		=> 7;
24use constant MM_VMSCAN_WRITEPAGE_FILE_SYNC	=> 8;
25use constant MM_VMSCAN_WRITEPAGE_ANON_SYNC	=> 9;
26use constant MM_VMSCAN_WRITEPAGE_FILE_ASYNC	=> 10;
27use constant MM_VMSCAN_WRITEPAGE_ANON_ASYNC	=> 11;
28use constant MM_VMSCAN_WRITEPAGE_ASYNC		=> 12;
29use constant EVENT_UNKNOWN			=> 13;
30
31# Per-order events
32use constant MM_VMSCAN_DIRECT_RECLAIM_BEGIN_PERORDER => 11;
33use constant MM_VMSCAN_WAKEUP_KSWAPD_PERORDER 	=> 12;
34use constant MM_VMSCAN_KSWAPD_WAKE_PERORDER	=> 13;
35use constant HIGH_KSWAPD_REWAKEUP_PERORDER	=> 14;
36
37# Constants used to track state
38use constant STATE_DIRECT_BEGIN 		=> 15;
39use constant STATE_DIRECT_ORDER 		=> 16;
40use constant STATE_KSWAPD_BEGIN			=> 17;
41use constant STATE_KSWAPD_ORDER			=> 18;
42
43# High-level events extrapolated from tracepoints
44use constant HIGH_DIRECT_RECLAIM_LATENCY	=> 19;
45use constant HIGH_KSWAPD_LATENCY		=> 20;
46use constant HIGH_KSWAPD_REWAKEUP		=> 21;
47use constant HIGH_NR_SCANNED			=> 22;
48use constant HIGH_NR_TAKEN			=> 23;
49use constant HIGH_NR_RECLAIMED			=> 24;
50use constant HIGH_NR_FILE_SCANNED		=> 25;
51use constant HIGH_NR_ANON_SCANNED		=> 26;
52use constant HIGH_NR_FILE_RECLAIMED		=> 27;
53use constant HIGH_NR_ANON_RECLAIMED		=> 28;
54
55my %perprocesspid;
56my %perprocess;
57my %last_procmap;
58my $opt_ignorepid;
59my $opt_read_procstat;
60
61my $total_wakeup_kswapd;
62my ($total_direct_reclaim, $total_direct_nr_scanned);
63my ($total_direct_nr_file_scanned, $total_direct_nr_anon_scanned);
64my ($total_direct_latency, $total_kswapd_latency);
65my ($total_direct_nr_reclaimed);
66my ($total_direct_nr_file_reclaimed, $total_direct_nr_anon_reclaimed);
67my ($total_direct_writepage_file_sync, $total_direct_writepage_file_async);
68my ($total_direct_writepage_anon_sync, $total_direct_writepage_anon_async);
69my ($total_kswapd_nr_scanned, $total_kswapd_wake);
70my ($total_kswapd_nr_file_scanned, $total_kswapd_nr_anon_scanned);
71my ($total_kswapd_writepage_file_sync, $total_kswapd_writepage_file_async);
72my ($total_kswapd_writepage_anon_sync, $total_kswapd_writepage_anon_async);
73my ($total_kswapd_nr_reclaimed);
74my ($total_kswapd_nr_file_reclaimed, $total_kswapd_nr_anon_reclaimed);
75
76# Catch sigint and exit on request
77my $sigint_report = 0;
78my $sigint_exit = 0;
79my $sigint_pending = 0;
80my $sigint_received = 0;
81sub sigint_handler {
82	my $current_time = time;
83	if ($current_time - 2 > $sigint_received) {
84		print "SIGINT received, report pending. Hit ctrl-c again to exit\n";
85		$sigint_report = 1;
86	} else {
87		if (!$sigint_exit) {
88			print "Second SIGINT received quickly, exiting\n";
89		}
90		$sigint_exit++;
91	}
92
93	if ($sigint_exit > 3) {
94		print "Many SIGINTs received, exiting now without report\n";
95		exit;
96	}
97
98	$sigint_received = $current_time;
99	$sigint_pending = 1;
100}
101$SIG{INT} = "sigint_handler";
102
103# Parse command line options
104GetOptions(
105	'ignore-pid'	 =>	\$opt_ignorepid,
106	'read-procstat'	 =>	\$opt_read_procstat,
107);
108
109# Defaults for dynamically discovered regex's
110my $regex_direct_begin_default = 'order=([0-9]*) may_writepage=([0-9]*) gfp_flags=([A-Z_|]*)';
111my $regex_direct_end_default = 'nr_reclaimed=([0-9]*)';
112my $regex_kswapd_wake_default = 'nid=([0-9]*) order=([0-9]*)';
113my $regex_kswapd_sleep_default = 'nid=([0-9]*)';
114my $regex_wakeup_kswapd_default = 'nid=([0-9]*) zid=([0-9]*) order=([0-9]*) gfp_flags=([A-Z_|]*)';
115my $regex_lru_isolate_default = 'isolate_mode=([0-9]*) classzone_idx=([0-9]*) order=([0-9]*) nr_requested=([0-9]*) nr_scanned=([0-9]*) nr_skipped=([0-9]*) nr_taken=([0-9]*) lru=([a-z_]*)';
116my $regex_lru_shrink_inactive_default = 'nid=([0-9]*) nr_scanned=([0-9]*) nr_reclaimed=([0-9]*) nr_dirty=([0-9]*) nr_writeback=([0-9]*) nr_congested=([0-9]*) nr_immediate=([0-9]*) nr_activate_anon=([0-9]*) nr_activate_file=([0-9]*) nr_ref_keep=([0-9]*) nr_unmap_fail=([0-9]*) priority=([0-9]*) flags=([A-Z_|]*)';
117my $regex_lru_shrink_active_default = 'lru=([A-Z_]*) nr_scanned=([0-9]*) nr_rotated=([0-9]*) priority=([0-9]*)';
118my $regex_writepage_default = 'page=([0-9a-f]*) pfn=([0-9]*) flags=([A-Z_|]*)';
119
120# Dyanically discovered regex
121my $regex_direct_begin;
122my $regex_direct_end;
123my $regex_kswapd_wake;
124my $regex_kswapd_sleep;
125my $regex_wakeup_kswapd;
126my $regex_lru_isolate;
127my $regex_lru_shrink_inactive;
128my $regex_lru_shrink_active;
129my $regex_writepage;
130
131# Static regex used. Specified like this for readability and for use with /o
132#                      (process_pid)     (cpus      )   ( time  )   (tpoint    ) (details)
133my $regex_traceevent = '\s*([a-zA-Z0-9-]*)\s*(\[[0-9]*\])(\s*[dX.][Nnp.][Hhs.][0-9a-fA-F.]*|)\s*([0-9.]*):\s*([a-zA-Z_]*):\s*(.*)';
134my $regex_statname = '[-0-9]*\s\((.*)\).*';
135my $regex_statppid = '[-0-9]*\s\(.*\)\s[A-Za-z]\s([0-9]*).*';
136
137sub generate_traceevent_regex {
138	my $event = shift;
139	my $default = shift;
140	my $regex;
141
142	# Read the event format or use the default
143	if (!open (FORMAT, "/sys/kernel/debug/tracing/events/$event/format")) {
144		print("WARNING: Event $event format string not found\n");
145		return $default;
146	} else {
147		my $line;
148		while (!eof(FORMAT)) {
149			$line = <FORMAT>;
150			$line =~ s/, REC->.*//;
151			if ($line =~ /^print fmt:\s"(.*)".*/) {
152				$regex = $1;
153				$regex =~ s/%s/\([0-9a-zA-Z|_]*\)/g;
154				$regex =~ s/%p/\([0-9a-f]*\)/g;
155				$regex =~ s/%d/\([-0-9]*\)/g;
156				$regex =~ s/%ld/\([-0-9]*\)/g;
157				$regex =~ s/%lu/\([0-9]*\)/g;
158			}
159		}
160	}
161
162	# Can't handle the print_flags stuff but in the context of this
163	# script, it really doesn't matter
164	$regex =~ s/\(REC.*\) \? __print_flags.*//;
165
166	# Verify fields are in the right order
167	my $tuple;
168	foreach $tuple (split /\s/, $regex) {
169		my ($key, $value) = split(/=/, $tuple);
170		my $expected = shift;
171		if ($key ne $expected) {
172			print("WARNING: Format not as expected for event $event '$key' != '$expected'\n");
173			$regex =~ s/$key=\((.*)\)/$key=$1/;
174		}
175	}
176
177	if (defined shift) {
178		die("Fewer fields than expected in format");
179	}
180
181	return $regex;
182}
183
184$regex_direct_begin = generate_traceevent_regex(
185			"vmscan/mm_vmscan_direct_reclaim_begin",
186			$regex_direct_begin_default,
187			"order", "may_writepage",
188			"gfp_flags");
189$regex_direct_end = generate_traceevent_regex(
190			"vmscan/mm_vmscan_direct_reclaim_end",
191			$regex_direct_end_default,
192			"nr_reclaimed");
193$regex_kswapd_wake = generate_traceevent_regex(
194			"vmscan/mm_vmscan_kswapd_wake",
195			$regex_kswapd_wake_default,
196			"nid", "order");
197$regex_kswapd_sleep = generate_traceevent_regex(
198			"vmscan/mm_vmscan_kswapd_sleep",
199			$regex_kswapd_sleep_default,
200			"nid");
201$regex_wakeup_kswapd = generate_traceevent_regex(
202			"vmscan/mm_vmscan_wakeup_kswapd",
203			$regex_wakeup_kswapd_default,
204			"nid", "zid", "order", "gfp_flags");
205$regex_lru_isolate = generate_traceevent_regex(
206			"vmscan/mm_vmscan_lru_isolate",
207			$regex_lru_isolate_default,
208			"isolate_mode", "classzone_idx", "order",
209			"nr_requested", "nr_scanned", "nr_skipped", "nr_taken",
210			"lru");
211$regex_lru_shrink_inactive = generate_traceevent_regex(
212			"vmscan/mm_vmscan_lru_shrink_inactive",
213			$regex_lru_shrink_inactive_default,
214			"nid", "nr_scanned", "nr_reclaimed", "nr_dirty", "nr_writeback",
215			"nr_congested", "nr_immediate", "nr_activate_anon",
216			"nr_activate_file", "nr_ref_keep",
217			"nr_unmap_fail", "priority", "flags");
218$regex_lru_shrink_active = generate_traceevent_regex(
219			"vmscan/mm_vmscan_lru_shrink_active",
220			$regex_lru_shrink_active_default,
221			"nid", "zid",
222			"lru",
223			"nr_scanned", "nr_rotated", "priority");
224$regex_writepage = generate_traceevent_regex(
225			"vmscan/mm_vmscan_writepage",
226			$regex_writepage_default,
227			"page", "pfn", "flags");
228
229sub read_statline($) {
230	my $pid = $_[0];
231	my $statline;
232
233	if (open(STAT, "/proc/$pid/stat")) {
234		$statline = <STAT>;
235		close(STAT);
236	}
237
238	if ($statline eq '') {
239		$statline = "-1 (UNKNOWN_PROCESS_NAME) R 0";
240	}
241
242	return $statline;
243}
244
245sub guess_process_pid($$) {
246	my $pid = $_[0];
247	my $statline = $_[1];
248
249	if ($pid == 0) {
250		return "swapper-0";
251	}
252
253	if ($statline !~ /$regex_statname/o) {
254		die("Failed to math stat line for process name :: $statline");
255	}
256	return "$1-$pid";
257}
258
259# Convert sec.usec timestamp format
260sub timestamp_to_ms($) {
261	my $timestamp = $_[0];
262
263	my ($sec, $usec) = split (/\./, $timestamp);
264	return ($sec * 1000) + ($usec / 1000);
265}
266
267sub process_events {
268	my $traceevent;
269	my $process_pid;
270	my $cpus;
271	my $timestamp;
272	my $tracepoint;
273	my $details;
274	my $statline;
275
276	# Read each line of the event log
277EVENT_PROCESS:
278	while ($traceevent = <STDIN>) {
279		if ($traceevent =~ /$regex_traceevent/o) {
280			$process_pid = $1;
281			$timestamp = $4;
282			$tracepoint = $5;
283
284			$process_pid =~ /(.*)-([0-9]*)$/;
285			my $process = $1;
286			my $pid = $2;
287
288			if ($process eq "") {
289				$process = $last_procmap{$pid};
290				$process_pid = "$process-$pid";
291			}
292			$last_procmap{$pid} = $process;
293
294			if ($opt_read_procstat) {
295				$statline = read_statline($pid);
296				if ($opt_read_procstat && $process eq '') {
297					$process_pid = guess_process_pid($pid, $statline);
298				}
299			}
300		} else {
301			next;
302		}
303
304		# Perl Switch() sucks majorly
305		if ($tracepoint eq "mm_vmscan_direct_reclaim_begin") {
306			$timestamp = timestamp_to_ms($timestamp);
307			$perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN}++;
308			$perprocesspid{$process_pid}->{STATE_DIRECT_BEGIN} = $timestamp;
309
310			$details = $6;
311			if ($details !~ /$regex_direct_begin/o) {
312				print "WARNING: Failed to parse mm_vmscan_direct_reclaim_begin as expected\n";
313				print "         $details\n";
314				print "         $regex_direct_begin\n";
315				next;
316			}
317			my $order = $1;
318			$perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN_PERORDER}[$order]++;
319			$perprocesspid{$process_pid}->{STATE_DIRECT_ORDER} = $order;
320		} elsif ($tracepoint eq "mm_vmscan_direct_reclaim_end") {
321			# Count the event itself
322			my $index = $perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_END};
323			$perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_END}++;
324
325			# Record how long direct reclaim took this time
326			if (defined $perprocesspid{$process_pid}->{STATE_DIRECT_BEGIN}) {
327				$timestamp = timestamp_to_ms($timestamp);
328				my $order = $perprocesspid{$process_pid}->{STATE_DIRECT_ORDER};
329				my $latency = ($timestamp - $perprocesspid{$process_pid}->{STATE_DIRECT_BEGIN});
330				$perprocesspid{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index] = "$order-$latency";
331			}
332		} elsif ($tracepoint eq "mm_vmscan_kswapd_wake") {
333			$details = $6;
334			if ($details !~ /$regex_kswapd_wake/o) {
335				print "WARNING: Failed to parse mm_vmscan_kswapd_wake as expected\n";
336				print "         $details\n";
337				print "         $regex_kswapd_wake\n";
338				next;
339			}
340
341			my $order = $2;
342			$perprocesspid{$process_pid}->{STATE_KSWAPD_ORDER} = $order;
343			if (!$perprocesspid{$process_pid}->{STATE_KSWAPD_BEGIN}) {
344				$timestamp = timestamp_to_ms($timestamp);
345				$perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE}++;
346				$perprocesspid{$process_pid}->{STATE_KSWAPD_BEGIN} = $timestamp;
347				$perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE_PERORDER}[$order]++;
348			} else {
349				$perprocesspid{$process_pid}->{HIGH_KSWAPD_REWAKEUP}++;
350				$perprocesspid{$process_pid}->{HIGH_KSWAPD_REWAKEUP_PERORDER}[$order]++;
351			}
352		} elsif ($tracepoint eq "mm_vmscan_kswapd_sleep") {
353
354			# Count the event itself
355			my $index = $perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_SLEEP};
356			$perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_SLEEP}++;
357
358			# Record how long kswapd was awake
359			$timestamp = timestamp_to_ms($timestamp);
360			my $order = $perprocesspid{$process_pid}->{STATE_KSWAPD_ORDER};
361			my $latency = ($timestamp - $perprocesspid{$process_pid}->{STATE_KSWAPD_BEGIN});
362			$perprocesspid{$process_pid}->{HIGH_KSWAPD_LATENCY}[$index] = "$order-$latency";
363			$perprocesspid{$process_pid}->{STATE_KSWAPD_BEGIN} = 0;
364		} elsif ($tracepoint eq "mm_vmscan_wakeup_kswapd") {
365			$perprocesspid{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD}++;
366
367			$details = $6;
368			if ($details !~ /$regex_wakeup_kswapd/o) {
369				print "WARNING: Failed to parse mm_vmscan_wakeup_kswapd as expected\n";
370				print "         $details\n";
371				print "         $regex_wakeup_kswapd\n";
372				next;
373			}
374			my $order = $3;
375			$perprocesspid{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD_PERORDER}[$order]++;
376		} elsif ($tracepoint eq "mm_vmscan_lru_isolate") {
377			$details = $6;
378			if ($details !~ /$regex_lru_isolate/o) {
379				print "WARNING: Failed to parse mm_vmscan_lru_isolate as expected\n";
380				print "         $details\n";
381				print "         $regex_lru_isolate/o\n";
382				next;
383			}
384			my $isolate_mode = $1;
385			my $nr_scanned = $5;
386			my $file = $8;
387
388			# To closer match vmstat scanning statistics, only count isolate_both
389			# and isolate_inactive as scanning. isolate_active is rotation
390			# isolate_inactive == 1
391			# isolate_active   == 2
392			# isolate_both     == 3
393			if ($isolate_mode != 2) {
394				$perprocesspid{$process_pid}->{HIGH_NR_SCANNED} += $nr_scanned;
395				if ($file =~ /_file/) {
396					$perprocesspid{$process_pid}->{HIGH_NR_FILE_SCANNED} += $nr_scanned;
397				} else {
398					$perprocesspid{$process_pid}->{HIGH_NR_ANON_SCANNED} += $nr_scanned;
399				}
400			}
401		} elsif ($tracepoint eq "mm_vmscan_lru_shrink_inactive") {
402			$details = $6;
403			if ($details !~ /$regex_lru_shrink_inactive/o) {
404				print "WARNING: Failed to parse mm_vmscan_lru_shrink_inactive as expected\n";
405				print "         $details\n";
406				print "         $regex_lru_shrink_inactive/o\n";
407				next;
408			}
409
410			my $nr_reclaimed = $3;
411			my $flags = $13;
412			my $file = 0;
413			if ($flags =~ /RECLAIM_WB_FILE/) {
414				$file = 1;
415			}
416			$perprocesspid{$process_pid}->{HIGH_NR_RECLAIMED} += $nr_reclaimed;
417			if ($file) {
418				$perprocesspid{$process_pid}->{HIGH_NR_FILE_RECLAIMED} += $nr_reclaimed;
419			} else {
420				$perprocesspid{$process_pid}->{HIGH_NR_ANON_RECLAIMED} += $nr_reclaimed;
421			}
422		} elsif ($tracepoint eq "mm_vmscan_writepage") {
423			$details = $6;
424			if ($details !~ /$regex_writepage/o) {
425				print "WARNING: Failed to parse mm_vmscan_writepage as expected\n";
426				print "         $details\n";
427				print "         $regex_writepage\n";
428				next;
429			}
430
431			my $flags = $3;
432			my $file = 0;
433			my $sync_io = 0;
434			if ($flags =~ /RECLAIM_WB_FILE/) {
435				$file = 1;
436			}
437			if ($flags =~ /RECLAIM_WB_SYNC/) {
438				$sync_io = 1;
439			}
440			if ($sync_io) {
441				if ($file) {
442					$perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC}++;
443				} else {
444					$perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC}++;
445				}
446			} else {
447				if ($file) {
448					$perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC}++;
449				} else {
450					$perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC}++;
451				}
452			}
453		} else {
454			$perprocesspid{$process_pid}->{EVENT_UNKNOWN}++;
455		}
456
457		if ($sigint_pending) {
458			last EVENT_PROCESS;
459		}
460	}
461}
462
463sub dump_stats {
464	my $hashref = shift;
465	my %stats = %$hashref;
466
467	# Dump per-process stats
468	my $process_pid;
469	my $max_strlen = 0;
470
471	# Get the maximum process name
472	foreach $process_pid (keys %perprocesspid) {
473		my $len = length($process_pid);
474		if ($len > $max_strlen) {
475			$max_strlen = $len;
476		}
477	}
478	$max_strlen += 2;
479
480	# Work out latencies
481	printf("\n") if !$opt_ignorepid;
482	printf("Reclaim latencies expressed as order-latency_in_ms\n") if !$opt_ignorepid;
483	foreach $process_pid (keys %stats) {
484
485		if (!$stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[0] &&
486				!$stats{$process_pid}->{HIGH_KSWAPD_LATENCY}[0]) {
487			next;
488		}
489
490		printf "%-" . $max_strlen . "s ", $process_pid if !$opt_ignorepid;
491		my $index = 0;
492		while (defined $stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index] ||
493			defined $stats{$process_pid}->{HIGH_KSWAPD_LATENCY}[$index]) {
494
495			if ($stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index]) {
496				printf("%s ", $stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index]) if !$opt_ignorepid;
497				my ($dummy, $latency) = split(/-/, $stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index]);
498				$total_direct_latency += $latency;
499			} else {
500				printf("%s ", $stats{$process_pid}->{HIGH_KSWAPD_LATENCY}[$index]) if !$opt_ignorepid;
501				my ($dummy, $latency) = split(/-/, $stats{$process_pid}->{HIGH_KSWAPD_LATENCY}[$index]);
502				$total_kswapd_latency += $latency;
503			}
504			$index++;
505		}
506		print "\n" if !$opt_ignorepid;
507	}
508
509	# Print out process activity
510	printf("\n");
511	printf("%-" . $max_strlen . "s %8s %10s   %8s %8s  %8s %8s %8s %8s\n", "Process", "Direct",  "Wokeup", "Pages",   "Pages",   "Pages",   "Pages",     "Time");
512	printf("%-" . $max_strlen . "s %8s %10s   %8s %8s  %8s %8s %8s %8s\n", "details", "Rclms",   "Kswapd", "Scanned", "Rclmed",  "Sync-IO", "ASync-IO",  "Stalled");
513	foreach $process_pid (keys %stats) {
514
515		if (!$stats{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN}) {
516			next;
517		}
518
519		$total_direct_reclaim += $stats{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN};
520		$total_wakeup_kswapd += $stats{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD};
521		$total_direct_nr_scanned += $stats{$process_pid}->{HIGH_NR_SCANNED};
522		$total_direct_nr_file_scanned += $stats{$process_pid}->{HIGH_NR_FILE_SCANNED};
523		$total_direct_nr_anon_scanned += $stats{$process_pid}->{HIGH_NR_ANON_SCANNED};
524		$total_direct_nr_reclaimed += $stats{$process_pid}->{HIGH_NR_RECLAIMED};
525		$total_direct_nr_file_reclaimed += $stats{$process_pid}->{HIGH_NR_FILE_RECLAIMED};
526		$total_direct_nr_anon_reclaimed += $stats{$process_pid}->{HIGH_NR_ANON_RECLAIMED};
527		$total_direct_writepage_file_sync += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC};
528		$total_direct_writepage_anon_sync += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC};
529		$total_direct_writepage_file_async += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC};
530
531		$total_direct_writepage_anon_async += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC};
532
533		my $index = 0;
534		my $this_reclaim_delay = 0;
535		while (defined $stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index]) {
536			 my ($dummy, $latency) = split(/-/, $stats{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$index]);
537			$this_reclaim_delay += $latency;
538			$index++;
539		}
540
541		printf("%-" . $max_strlen . "s %8d %10d   %8u %8u  %8u %8u %8.3f",
542			$process_pid,
543			$stats{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN},
544			$stats{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD},
545			$stats{$process_pid}->{HIGH_NR_SCANNED},
546			$stats{$process_pid}->{HIGH_NR_FILE_SCANNED},
547			$stats{$process_pid}->{HIGH_NR_ANON_SCANNED},
548			$stats{$process_pid}->{HIGH_NR_RECLAIMED},
549			$stats{$process_pid}->{HIGH_NR_FILE_RECLAIMED},
550			$stats{$process_pid}->{HIGH_NR_ANON_RECLAIMED},
551			$stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC} + $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC},
552			$stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC} + $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC},
553			$this_reclaim_delay / 1000);
554
555		if ($stats{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN}) {
556			print "      ";
557			for (my $order = 0; $order < 20; $order++) {
558				my $count = $stats{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN_PERORDER}[$order];
559				if ($count != 0) {
560					print "direct-$order=$count ";
561				}
562			}
563		}
564		if ($stats{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD}) {
565			print "      ";
566			for (my $order = 0; $order < 20; $order++) {
567				my $count = $stats{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD_PERORDER}[$order];
568				if ($count != 0) {
569					print "wakeup-$order=$count ";
570				}
571			}
572		}
573
574		print "\n";
575	}
576
577	# Print out kswapd activity
578	printf("\n");
579	printf("%-" . $max_strlen . "s %8s %10s   %8s   %8s %8s %8s\n", "Kswapd",   "Kswapd",  "Order",     "Pages",   "Pages",   "Pages",  "Pages");
580	printf("%-" . $max_strlen . "s %8s %10s   %8s   %8s %8s %8s\n", "Instance", "Wakeups", "Re-wakeup", "Scanned", "Rclmed",  "Sync-IO", "ASync-IO");
581	foreach $process_pid (keys %stats) {
582
583		if (!$stats{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE}) {
584			next;
585		}
586
587		$total_kswapd_wake += $stats{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE};
588		$total_kswapd_nr_scanned += $stats{$process_pid}->{HIGH_NR_SCANNED};
589		$total_kswapd_nr_file_scanned += $stats{$process_pid}->{HIGH_NR_FILE_SCANNED};
590		$total_kswapd_nr_anon_scanned += $stats{$process_pid}->{HIGH_NR_ANON_SCANNED};
591		$total_kswapd_nr_reclaimed += $stats{$process_pid}->{HIGH_NR_RECLAIMED};
592		$total_kswapd_nr_file_reclaimed += $stats{$process_pid}->{HIGH_NR_FILE_RECLAIMED};
593		$total_kswapd_nr_anon_reclaimed += $stats{$process_pid}->{HIGH_NR_ANON_RECLAIMED};
594		$total_kswapd_writepage_file_sync += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC};
595		$total_kswapd_writepage_anon_sync += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC};
596		$total_kswapd_writepage_file_async += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC};
597		$total_kswapd_writepage_anon_async += $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC};
598
599		printf("%-" . $max_strlen . "s %8d %10d   %8u %8u  %8i %8u",
600			$process_pid,
601			$stats{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE},
602			$stats{$process_pid}->{HIGH_KSWAPD_REWAKEUP},
603			$stats{$process_pid}->{HIGH_NR_SCANNED},
604			$stats{$process_pid}->{HIGH_NR_FILE_SCANNED},
605			$stats{$process_pid}->{HIGH_NR_ANON_SCANNED},
606			$stats{$process_pid}->{HIGH_NR_RECLAIMED},
607			$stats{$process_pid}->{HIGH_NR_FILE_RECLAIMED},
608			$stats{$process_pid}->{HIGH_NR_ANON_RECLAIMED},
609			$stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC} + $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC},
610			$stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC} + $stats{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC});
611
612		if ($stats{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE}) {
613			print "      ";
614			for (my $order = 0; $order < 20; $order++) {
615				my $count = $stats{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE_PERORDER}[$order];
616				if ($count != 0) {
617					print "wake-$order=$count ";
618				}
619			}
620		}
621		if ($stats{$process_pid}->{HIGH_KSWAPD_REWAKEUP}) {
622			print "      ";
623			for (my $order = 0; $order < 20; $order++) {
624				my $count = $stats{$process_pid}->{HIGH_KSWAPD_REWAKEUP_PERORDER}[$order];
625				if ($count != 0) {
626					print "rewake-$order=$count ";
627				}
628			}
629		}
630		printf("\n");
631	}
632
633	# Print out summaries
634	$total_direct_latency /= 1000;
635	$total_kswapd_latency /= 1000;
636	print "\nSummary\n";
637	print "Direct reclaims:     			$total_direct_reclaim\n";
638	print "Direct reclaim pages scanned:		$total_direct_nr_scanned\n";
639	print "Direct reclaim file pages scanned:	$total_direct_nr_file_scanned\n";
640	print "Direct reclaim anon pages scanned:	$total_direct_nr_anon_scanned\n";
641	print "Direct reclaim pages reclaimed:		$total_direct_nr_reclaimed\n";
642	print "Direct reclaim file pages reclaimed:	$total_direct_nr_file_reclaimed\n";
643	print "Direct reclaim anon pages reclaimed:	$total_direct_nr_anon_reclaimed\n";
644	print "Direct reclaim write file sync I/O:	$total_direct_writepage_file_sync\n";
645	print "Direct reclaim write anon sync I/O:	$total_direct_writepage_anon_sync\n";
646	print "Direct reclaim write file async I/O:	$total_direct_writepage_file_async\n";
647	print "Direct reclaim write anon async I/O:	$total_direct_writepage_anon_async\n";
648	print "Wake kswapd requests:			$total_wakeup_kswapd\n";
649	printf "Time stalled direct reclaim: 		%-1.2f seconds\n", $total_direct_latency;
650	print "\n";
651	print "Kswapd wakeups:				$total_kswapd_wake\n";
652	print "Kswapd pages scanned:			$total_kswapd_nr_scanned\n";
653	print "Kswapd file pages scanned:		$total_kswapd_nr_file_scanned\n";
654	print "Kswapd anon pages scanned:		$total_kswapd_nr_anon_scanned\n";
655	print "Kswapd pages reclaimed:			$total_kswapd_nr_reclaimed\n";
656	print "Kswapd file pages reclaimed:		$total_kswapd_nr_file_reclaimed\n";
657	print "Kswapd anon pages reclaimed:		$total_kswapd_nr_anon_reclaimed\n";
658	print "Kswapd reclaim write file sync I/O:	$total_kswapd_writepage_file_sync\n";
659	print "Kswapd reclaim write anon sync I/O:	$total_kswapd_writepage_anon_sync\n";
660	print "Kswapd reclaim write file async I/O:	$total_kswapd_writepage_file_async\n";
661	print "Kswapd reclaim write anon async I/O:	$total_kswapd_writepage_anon_async\n";
662	printf "Time kswapd awake:			%-1.2f seconds\n", $total_kswapd_latency;
663}
664
665sub aggregate_perprocesspid() {
666	my $process_pid;
667	my $process;
668	undef %perprocess;
669
670	foreach $process_pid (keys %perprocesspid) {
671		$process = $process_pid;
672		$process =~ s/-([0-9])*$//;
673		if ($process eq '') {
674			$process = "NO_PROCESS_NAME";
675		}
676
677		$perprocess{$process}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN} += $perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN};
678		$perprocess{$process}->{MM_VMSCAN_KSWAPD_WAKE} += $perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE};
679		$perprocess{$process}->{MM_VMSCAN_WAKEUP_KSWAPD} += $perprocesspid{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD};
680		$perprocess{$process}->{HIGH_KSWAPD_REWAKEUP} += $perprocesspid{$process_pid}->{HIGH_KSWAPD_REWAKEUP};
681		$perprocess{$process}->{HIGH_NR_SCANNED} += $perprocesspid{$process_pid}->{HIGH_NR_SCANNED};
682		$perprocess{$process}->{HIGH_NR_FILE_SCANNED} += $perprocesspid{$process_pid}->{HIGH_NR_FILE_SCANNED};
683		$perprocess{$process}->{HIGH_NR_ANON_SCANNED} += $perprocesspid{$process_pid}->{HIGH_NR_ANON_SCANNED};
684		$perprocess{$process}->{HIGH_NR_RECLAIMED} += $perprocesspid{$process_pid}->{HIGH_NR_RECLAIMED};
685		$perprocess{$process}->{HIGH_NR_FILE_RECLAIMED} += $perprocesspid{$process_pid}->{HIGH_NR_FILE_RECLAIMED};
686		$perprocess{$process}->{HIGH_NR_ANON_RECLAIMED} += $perprocesspid{$process_pid}->{HIGH_NR_ANON_RECLAIMED};
687		$perprocess{$process}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC} += $perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_SYNC};
688		$perprocess{$process}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC} += $perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_SYNC};
689		$perprocess{$process}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC} += $perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_FILE_ASYNC};
690		$perprocess{$process}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC} += $perprocesspid{$process_pid}->{MM_VMSCAN_WRITEPAGE_ANON_ASYNC};
691
692		for (my $order = 0; $order < 20; $order++) {
693			$perprocess{$process}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN_PERORDER}[$order] += $perprocesspid{$process_pid}->{MM_VMSCAN_DIRECT_RECLAIM_BEGIN_PERORDER}[$order];
694			$perprocess{$process}->{MM_VMSCAN_WAKEUP_KSWAPD_PERORDER}[$order] += $perprocesspid{$process_pid}->{MM_VMSCAN_WAKEUP_KSWAPD_PERORDER}[$order];
695			$perprocess{$process}->{MM_VMSCAN_KSWAPD_WAKE_PERORDER}[$order] += $perprocesspid{$process_pid}->{MM_VMSCAN_KSWAPD_WAKE_PERORDER}[$order];
696
697		}
698
699		# Aggregate direct reclaim latencies
700		my $wr_index = $perprocess{$process}->{MM_VMSCAN_DIRECT_RECLAIM_END};
701		my $rd_index = 0;
702		while (defined $perprocesspid{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$rd_index]) {
703			$perprocess{$process}->{HIGH_DIRECT_RECLAIM_LATENCY}[$wr_index] = $perprocesspid{$process_pid}->{HIGH_DIRECT_RECLAIM_LATENCY}[$rd_index];
704			$rd_index++;
705			$wr_index++;
706		}
707		$perprocess{$process}->{MM_VMSCAN_DIRECT_RECLAIM_END} = $wr_index;
708
709		# Aggregate kswapd latencies
710		my $wr_index = $perprocess{$process}->{MM_VMSCAN_KSWAPD_SLEEP};
711		my $rd_index = 0;
712		while (defined $perprocesspid{$process_pid}->{HIGH_KSWAPD_LATENCY}[$rd_index]) {
713			$perprocess{$process}->{HIGH_KSWAPD_LATENCY}[$wr_index] = $perprocesspid{$process_pid}->{HIGH_KSWAPD_LATENCY}[$rd_index];
714			$rd_index++;
715			$wr_index++;
716		}
717		$perprocess{$process}->{MM_VMSCAN_DIRECT_RECLAIM_END} = $wr_index;
718	}
719}
720
721sub report() {
722	if (!$opt_ignorepid) {
723		dump_stats(\%perprocesspid);
724	} else {
725		aggregate_perprocesspid();
726		dump_stats(\%perprocess);
727	}
728}
729
730# Process events or signals until neither is available
731sub signal_loop() {
732	my $sigint_processed;
733	do {
734		$sigint_processed = 0;
735		process_events();
736
737		# Handle pending signals if any
738		if ($sigint_pending) {
739			my $current_time = time;
740
741			if ($sigint_exit) {
742				print "Received exit signal\n";
743				$sigint_pending = 0;
744			}
745			if ($sigint_report) {
746				if ($current_time >= $sigint_received + 2) {
747					report();
748					$sigint_report = 0;
749					$sigint_pending = 0;
750					$sigint_processed = 1;
751				}
752			}
753		}
754	} while ($sigint_pending || $sigint_processed);
755}
756
757signal_loop();
758report();
759