Re: [PATCH] Rewrite numastat to also show per-node process stats

[Cliff Wickman <cpw@sgi.com>]

Hi Bill,

Thanks.  This numastat works fine in my tests.
It is included in numactl-2.0.8-rc6.tar.gz 
at ftp://oss.sgi.com/www/projects/libnuma/download/

To all on linux-numa:

This makes 22 patches since release 2.0.7 in April of 2011. 
It's way past due to release this as version 2.0.8.

I will do that very soon, unless any of you have found any reason not to. 

Thx.
-Cliff

On Sun, Oct 07, 2012 at 01:36:06AM -0400, Bill Gray wrote:
>
> This patch rewrites Andi's numastat perl script as a C program to add  
> features
> to show per-node statistics for processes as well as the system as a  
> whole. By
> default, the new version is strictly compatible with the old version.  The
> behavior changes if any command line options or program arguments are  
> used, as
> described in the new man page.  This provides a convenient way to  
> monitor the
> NUMA node distribution of memory for various sets of processes. For  
> example, to
> check on KVM guests, one might run it like this:
>
> # ./numastat -c qemu
>
> Per-node process memory usage (in MBs)
> PID              Node 0 Node 1 Node 2 Node 3 Node 4 Node 5 Node 6 Node 7  
> Total
> ---------------  ------ ------ ------ ------ ------ ------ ------ ------  
> -----
> 7054 (qemu-kvm)       2      1      0   1391      0      0      0      0  
>  1395
> 7174 (qemu-kvm)       2      1      0      1      0      0   1404      0  
>  1409
> 7294 (qemu-kvm)       2      1   1389      1      0      0      0      0  
>  1394
> 7406 (qemu-kvm)       2      1      0      1      0   1391      0      0  
>  1395
> 7530 (qemu-kvm)       2   1401      0      1      0      0      0      0  
>  1405
> 7638 (qemu-kvm)       2      1      0      1   1404      0      0      0  
>  1409
> 7742 (qemu-kvm)       2      1      0      1      0      0      0   1392  
>  1397
> 7858 (qemu-kvm)    1396      1      0      1      0      0      0      0  
>  1398
> ---------------  ------ ------ ------ ------ ------ ------ ------ ------  
> -----
> Total              1413   1407   1391   1395   1407   1392   1405   1392  
> 11202
>
> - numastat.8: is rewritten
> - numastat: is replaced by numastat.c
> - Makefile: is modified to compile numastat.c and to clean numastat
>
> Signed-off-by: Bill Gray <bgray@redhat.com>
>
>
>  Makefile   |    6
>  numastat   |   91 ---
>  numastat.8 |  213 +++++---
>  numastat.c | 1548  
> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>  4 files changed, 1695 insertions(+), 163 deletions(-)
>
>
> diff -ruN numactl-2.0.8-rc5.orig/Makefile numactl-2.0.8-rc5.new/Makefile
> --- numactl-2.0.8-rc5.orig/Makefile	2012-08-23 15:50:37.000000000 -0400
> +++ numactl-2.0.8-rc5.new/Makefile	2012-09-06 13:58:40.056795146 -0400
> @@ -32,7 +32,7 @@
>  	      test/mbind_mig_pages test/migrate_pages \
>  	      migratepages migspeed migspeed.o libnuma.a \
>  	      test/move_pages test/realloc_test sysfs.o affinity.o \
> -	      test/node-parse rtnetlink.o test/A
> +	      test/node-parse rtnetlink.o test/A numastat
>  SOURCES := bitops.c libnuma.c distance.c memhog.c numactl.c numademo.c \
>  	numamon.c shm.c stream_lib.c stream_main.c syscall.c util.c mt.c \
>  	clearcache.c test/*.c affinity.c sysfs.c rtnetlink.c
> @@ -45,10 +45,12 @@
>       test/tshared stream test/mynode test/pagesize test/ftok  
> test/prefered \
>       test/randmap test/nodemap test/distance test/tbitmap  
> test/move_pages \
>       test/mbind_mig_pages test/migrate_pages test/realloc_test libnuma.a \
> -     test/node-parse
> +     test/node-parse numastat
>
>  numactl: numactl.o util.o shm.o bitops.o libnuma.so
>
> +numastat: CFLAGS += -std=gnu99
> +
>  migratepages: migratepages.c util.o bitops.o libnuma.so
>
>  migspeed: LDLIBS += -lrt
> diff -ruN numactl-2.0.8-rc5.orig/numastat numactl-2.0.8-rc5.new/numastat
> --- numactl-2.0.8-rc5.orig/numastat	2012-08-23 15:50:37.000000000 -0400
> +++ numactl-2.0.8-rc5.new/numastat	1969-12-31 19:00:00.000000000 -0500
> @@ -1,91 +0,0 @@
> -#!/usr/bin/perl
> -# Print numa statistics for all nodes
> -# Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
> -#
> -# numastat 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.
> -#
> -# numastat 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 */
> -#
> -# Example: NUMASTAT_WIDTH=80 watch -n1 numastat
> -#
> -
> -# output width
> -$WIDTH=80;
> -if (defined($ENV{'NUMASTAT_WIDTH'})) {
> -	$WIDTH=$ENV{'NUMASTAT_WIDTH'};
> -} else {
> -	use POSIX;
> -	if (POSIX::isatty(fileno(STDOUT))) {
> -		if (open(R, "resize |")) {
> -			while (<R>) {
> -				$WIDTH=$1 if /COLUMNS=(\d+)/;
> -			}	
> -			close R;
> -		}
> -	} else {
> -		# don't split it up for easier parsing
> -		$WIDTH=10000000;
> -	}
> -}
> -$WIDTH = 32 if $WIDTH < 32;
> -
> -if (! -d "/sys/devices/system/node" ) {
> -	print STDERR "sysfs not mounted or system not NUMA aware\n";
> -	exit 1;
> -}
> -
> -%stat = ();
> -$title = "";
> -$mode = 0;
> -opendir(NODES, "/sys/devices/system/node") || exit 1;
> -foreach $nd (readdir(NODES)) {
> -	next unless $nd =~ /node(\d+)/;
> -	# On newer kernels, readdir may enumerate the 'node(\d+) subdirs
> -	# in opposite order from older kernels--e.g., node{0,1,2,...}
> -	# as opposed to node{N,N-1,N-2,...}.  Accomodate this by
> -	# switching to new mode so that the stats get emitted in
> -	# the same order.
> -        #print "readdir(NODES) returns $nd\n";
> -	if (!$title && $nd =~ /node0/) {
> -		$mode = 1;
> -	}
> -	open(STAT, "/sys/devices/system/node/$nd/numastat") ||
> -			die "cannot open $nd: $!\n";
> -	if (! $mode) {
> -		$title = sprintf("%16s",$nd) . $title;
> -	} else {
> -		$title = $title . sprintf("%16s",$nd);
> -	}
> -	@fields = ();
> -	while (<STAT>) {
> -		($name, $val) = split;
> -		if (! $mode) {
> -			$stat{$name} = sprintf("%16u", $val) . $stat{$name};
> -		} else {
> -			$stat{$name} = $stat{$name} . sprintf("%16u", $val);
> -		}
> -		push(@fields, $name);
> -	}
> -	close STAT;
> -}
> -closedir NODES;
> -
> -$numfields = int(($WIDTH - 16) / 16);
> -$l = 16 * $numfields;
> -for ($i = 0; $i < length($title); $i += $l) {
> -	print "\n" if $i > 0;
> -	printf "%16s%s\n","",substr($title,$i,$l);
> -	foreach (@fields) {
> -		printf "%-16s%s\n",$_,substr($stat{$_},$i,$l);
> -	}
> -}
> diff -ruN numactl-2.0.8-rc5.orig/numastat.8 numactl-2.0.8-rc5.new/numastat.8
> --- numactl-2.0.8-rc5.orig/numastat.8	2012-08-23 15:50:37.000000000 -0400
> +++ numactl-2.0.8-rc5.new/numastat.8	2012-10-07 00:05:46.676484265 -0400
> @@ -1,82 +1,155 @@
> -.\" t
> -.\" Copyright 2004 Andi Kleen, SuSE Labs.
> -.\"
> -.\" Permission is granted to make and distribute verbatim copies of this
> -.\" manual provided the copyright notice and this permission notice are
> -.\" preserved on all copies.
> -.\"
> -.\" Permission is granted to copy and distribute modified versions of this
> -.\" manual under the conditions for verbatim copying, provided that the
> -.\" entire resulting derived work is distributed under the terms of a
> -.\" permission notice identical to this one.
> -.\"
> -.\" Since the Linux kernel and libraries are constantly changing, this
> -.\" manual page may be incorrect or out-of-date.  The author(s) assume no
> -.\" responsibility for errors or omissions, or for damages resulting from
> -.\" the use of the information contained herein.
> -.\"
> -.\" Formatted or processed versions of this manual, if unaccompanied by
> -.\" the source, must acknowledge the copyright and authors of this work.
> -.TH NUMACTL 8 "Nov 2004" "SuSE Labs" "Linux Administrator's Manual"
> -.SH NAME
> -numastat \- Print statistics about NUMA memory allocation
> -.SH SYNOPSIS
> -numastat
> -.SH DESCRIPTION
> +.TH "numastat" "8" "1.0.0" "Bill Gray" "Administration"
> +.SH "numastat"
> +.LP
> +\fBnumastat\fP \- Show per-NUMA-node memory statistics for processes  
> and the operating system
> +.SH "SYNTAX"
> +.LP
> +\fBnumastat\fP
> +.br
> +.LP
> +\fBnumastat\fP [\fI\-V\fP]
> +.br
> +.LP
> +\fBnumastat\fP [\fI\<PID>|<pattern>...\fP]
> +.br
> +.LP
> +\fBnumastat\fP [\fI\-c\fP] [\fI\-m\fP] [\fI\-n\fP] [\fI\-p  
> <PID>|<pattern>\fP] [\fI\-s[<node>]\fP] [\fI\-v\fP] [\fI\-z\fP]  
> [\fI\<PID>|<pattern>...\fP]
> +.br
> +.SH "DESCRIPTION"
> +.LP
>  .B numastat
> -displays NUMA allocations statistics from the kernel memory allocator.
> -Each process has NUMA policies that specifies on which node pages
> -are allocated. See
> -.I set_mempolicy(2)
> -or
> -.I numactl(8)
> -on details of the available policies.
> -The numastat counters keep track on what nodes memory is finally allocated.
> -
> -The counters are separated for each node. Each count event is the  
> allocation
> -of a page of memory.
> -
> +with no command options or arguments at all, displays per-node NUMA hit and
> +miss system statistics from the kernel memory allocator.  This default
> +\fBnumastat\fP behavior is strictly compatible with the previous  
> long-standing
> +\fBnumastat\fP perl script, written by Andi Kleen.  The default  
> \fBnumastat\fP
> +statistics shows per-node numbers (in units of pages of memory) in  
> these categories:
> +.LP
>  .B numa_hit
> -is the number of allocations where an allocation was intended for
> -that node and succeeded there.
> -
> +is memory successfully allocated on this node as intended.
> +.LP
>  .B numa_miss
> -shows how often an allocation was intended for this node, but ended up
> -on another node due to low memory.
> -
> +is memory allocated on this node despite the process preferring some  
> different node. Each
> +.I numa_miss
> +has a
> +.I numa_foreign
> +on another node.
> +.LP
>  .B numa_foreign
> -is the number of allocations that were intended for another node,
> -but ended up on this node.  Each
> +is memory intended for this node, but actually allocated on some  
> different node.  Each
>  .I numa_foreign
> -event has a
> +has a
>  .I numa_miss
>  on another node.
> -
> +.LP
>  .B interleave_hit
> -is the number of interleave policy allocations that were intended for a
> -specific node and succeeded there.
> -
> +is interleaved memory successfully allocated on this node as intended.
> +.LP
>  .B local_node
> -is incremented when a process running on the node allocated
> -memory on the same node.
> -
> +is memory allocated on this node while a process was running on it.
> +.LP
>  .B other_node
> -is incremented when a process running on another node allocated memory  
> on that node.
> -.SH SEE ALSO
> -.I numactl(8)
> -.I set_mempolicy(2)
> -.I numa(3)
> +is memory allocated on this node while a process was running on some  
> other node.
> +.LP
> +Any supplied options or arguments with the \fBnumastat\fP command will
> +significantly change both the content and the format of the display.  
> Specified
> +options will cause display units to change to megabytes of memory, and will
> +change other specific behaviors of \fBnumastat\fP as described below.
> +.SH "OPTIONS"
> +.LP
> +.TP
> +\fB\-c\fR
> +Minimize table display width by dynamically shrinking column widths  
> based on
> +data contents.  With this option, amounts of memory will be rounded to the
> +nearest megabyte (rather than the usual display with two decimal places).
> +Column width and inter-column spacing will be somewhat unpredictable  
> with this
> +option, but the more dense display will be very useful on systems with many
> +NUMA nodes.
> +.TP
> +\fB\-m\fR
> +Show the meminfo-like system-wide memory usage information.  This option
> +produces a per-node breakdown of memory usage information similar to  
> that found
> +in /proc/meminfo.
> +.TP
> +\fB\-n\fR
> +Show the original \fBnumastat\fP statistics info.  This will show the same
> +information as the default \fBnumastat\fP behavior but the units will  
> be megabytes of
> +memory, and there will be other formatting and layout changes versus the
> +original \fBnumastat\fP behavior.
> +.TP
> +\fB\-p\fR <\fBPID\fP> or <\fBpattern\fP>
> +Show per-node memory allocation information for the specified PID or  
> pattern.
> +If the \-p argument is only digits, it is assumed to be a numerical  
> PID.  If
> +the argument characters are not only digits, it is assumed to be a text
> +fragment pattern to search for in process command lines.  For example,
> +\fBnumastat -p qemu\fP will attempt to find and show information for  
> processes
> +with "qemu" in the command line.  Any command line arguments remaining  
> after
> +\fBnumastat\fP option flag processing is completed, are assumed to be
> +additional <\fBPID\fP> or <\fBpattern\fP> process specifiers.  In this  
> sense,
> +the \fB\-p\fP option flag is optional: \fBnumastat qemu\fP is equivalent to
> +\fBnumastat -p qemu\fP
> +.TP
> +\fB\-s[<node>]\fR
> +Sort the table data in descending order before displaying it, so the  
> biggest
> +memory consumers are listed first.  With no specified <node>, the table  
> will be
> +sorted by the total column.  If the optional <node> argument is  
> supplied, the
> +data will be sorted by the <node> column.  Note that <node> must follow the
> +\fB\-s\fP immediately with no intermediate white space (e.g., \fBnumastat
> +\-s2\fP).
> +.TP
> +\fB\-v\fR
> +Make some reports more verbose.  In particular, process information for
> +multiple processes will display detailed information for each process.
> +Normally when per-node information for multiple processes is displayed,  
> only
> +the total lines are shown.
> +.TP
> +\fB\-V\fR
> +Display \fBnumastat\fP version information and exit.
> +.TP
> +\fB\-z\fR
> +Skip display of table rows and columns of only zero valuess.  This can  
> be used
> +to greatly reduce the amount of uninteresting zero data on systems with  
> many
> +NUMA nodes.  Note that when rows or columns of zeros are still  
> displayed with
> +this option, that probably means there is at least one value in the row or
> +column that is actually non-zero, but rounded to zero for display.
>  .SH NOTES
> -numastat output is only available on NUMA systems.
> -
> -numastat assumes the output terminal has a width of 80 characters
> -and tries to format the output accordingly.
> -.SH EXAMPLES
> -.I watch -n1 numastat
> +\fBnumastat\fP attempts to fold each table display so it will be  
> conveniently
> +readable on the output terminal.  Normally a terminal width of 80  
> characters is
> +assumed.  When the \fBresize\fP command is available, \fBnumastat\fP  
> attempts
> +to dynamically determine and fine tune the output tty width from  
> \fBresize\fP
> +output.  If \fBnumastat\fP output is not to a tty, very long output  
> lines can
> +be produced, depending on how many NUMA nodes are present.  In all cases,
> +output width can be explicitly specified via the \fBNUMASTAT_WIDTH\fP
> +environment variable.  For example, \fBNUMASTAT_WIDTH=100  numastat\fP.  
>   On
> +systems with many NUMA nodes, \fBnumastat \-c \-z ....\fP can be very  
> helpful
> +to selectively reduce the amount of displayed information.
> +.SH "ENVIRONMENT VARIABLES"
> +.LP
> +.TP
> +NUMASTAT_WIDTH
> +.SH "FILES"
> +.LP
> +\fI/proc/*/numa_maps\fP
> +.br
> +\fI/sys/devices/system/node/node*/meminfo\fP
> +.br
> +\fI/sys/devices/system/node/node*/numastat\fP
> +.SH "EXAMPLES"
> +.I numastat \-c \-z \-m \-n
> +.br
> +.I numastat \-czs libvirt kvm qemu
> +.br
> +.I watch \-n1 numastat
>  .br
> -.I watch -n1 --differences=accumulative numastat
> -.SH FILES
> -/sys/devices/system/node/node*/numastat
> -.SH BUGS
> -The output formatting on machines with a large number of nodes
> -could be improved.
> +.I watch \-n1 \-\-differences=cumulative numastat
> +.SH "AUTHORS"
> +.LP
> +The original \fBnumastat\fP perl script was written circa 2003 by Andi  
> Kleen
> +<andi.kleen@intel.com>.  The current \fBnumastat\fP program was written  
> in 2012
> +by Bill Gray <bgray@redhat.com> to be compatible by default with the  
> original,
> +and to add options to display per-node system memory usage and per-node  
> process
> +memory allocation.
> +.SH "SEE ALSO"
> +.LP
> +.BR numactl (8),
> +.BR set_mempolicy( 2),
> +.BR numa (3)
> diff -ruN numactl-2.0.8-rc5.orig/numastat.c numactl-2.0.8-rc5.new/numastat.c
> --- numactl-2.0.8-rc5.orig/numastat.c	1969-12-31 19:00:00.000000000 -0500
> +++ numactl-2.0.8-rc5.new/numastat.c	2012-09-06 22:48:18.704586776 -0400
> @@ -0,0 +1,1548 @@
> +/*
> +
> +numastat - NUMA monitoring tool to show per-node usage of memory
> +Copyright (C) 2012 Bill Gray (bgray@redhat.com), Red Hat Inc
> +
> +numastat is free software; you can redistribute it and/or modify it  
> under the
> +terms of the GNU Lesser General Public License as published by the Free
> +Software Foundation; version 2.1.
> +
> +numastat 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 Lesser General Public License for more  
> details.
> +
> +You should find a copy of v2.1 of the GNU Lesser 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
> +
> +*/
> +
> +
> +/*
> +
> +Historical note: From approximately 2003 to 2012, numastat was a perl  
> script
> +written by Andi Kleen to display the  
> /sys/devices/system/node/node<N>/numastat
> +statistics. In 2012, numastat was rewritten as a C program by Red Hat to
> +display per-node memory data for applications and the system in general,
> +while also remaining strictly compatible by default with the original  
> numastat.
> +A copy of the original numastat perl script is included for reference  
> at the
> +end of this file.
> +
> +*/
> +
> +
> +// Compile with: gcc -O -std=gnu99 -Wall -o numastat numastat.c
> +
> +
> +#define __USE_MISC
> +#include <ctype.h>
> +#include <dirent.h>
> +#include <errno.h>
> +#include <getopt.h>
> +#include <stdint.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <string.h>
> +#include <sys/types.h>
> +#include <unistd.h>
> +
> +
> +#define STRINGIZE(s) #s
> +#define STRINGIFY(s) STRINGIZE(s)
> +
> +#define KILOBYTE (1024)
> +#define MEGABYTE (1024 * 1024)
> +
> +#define BUF_SIZE 2048
> +#define SMALL_BUF_SIZE 128
> +
> +
> +// Don't assume nodes are sequential or contiguous.
> +// Need to discover and map node numbers.
> +
> +int *node_ix_map = NULL;
> +char **node_header;
> +
> +
> +// Structure to organize memory info from /proc/<PID>/numa_maps for a  
> specific
> +// process, or from /sys/devices/system/node/node?/meminfo for system-wide
> +// data. Tables are defined below for each process and for system-wide  
> data.
> +
> +typedef struct meminfo {
> +	int index;
> +	char *token;
> +	char *label;
> +} meminfo_t, *meminfo_p;
> +
> +#define PROCESS_HUGE_INDEX    0
> +#define PROCESS_PRIVATE_INDEX 3
> +
> +meminfo_t process_meminfo[] = {
> +	{ PROCESS_HUGE_INDEX,  "huge", "Huge" },
> +	{        1,            "heap", "Heap" },
> +	{        2,            "stack", "Stack" },
> +	{ PROCESS_PRIVATE_INDEX, "N", "Private" }
> +};
> +
> +#define PROCESS_MEMINFO_ROWS (sizeof(process_meminfo) /  
> sizeof(process_meminfo[0]))
> +
> +meminfo_t numastat_meminfo[] = {
> +	{ 0, "numa_hit", "Numa_Hit" },
> +	{ 1, "numa_miss", "Numa_Miss" },
> +	{ 2, "numa_foreign", "Numa_Foreign" },
> +	{ 3, "interleave_hit", "Interleave_Hit" },
> +	{ 4, "local_node", "Local_Node" },
> +	{ 5, "other_node", "Other_Node" },
> +};
> +
> +#define NUMASTAT_MEMINFO_ROWS (sizeof(numastat_meminfo) /  
> sizeof(numastat_meminfo[0]))
> +
> +meminfo_t system_meminfo[] = {
> +	{  0, "MemTotal", "MemTotal" },
> +	{  1, "MemFree", "MemFree" },
> +	{  2, "MemUsed", "MemUsed" },
> +	{  3, "HighTotal", "HighTotal" },
> +	{  4, "HighFree", "HighFree" },
> +	{  5, "LowTotal", "LowTotal" },
> +	{  6, "LowFree", "LowFree" },
> +	{  7, "Active", "Active" },
> +	{  8, "Inactive", "Inactive" },
> +	{  9, "Active(anon)", "Active(anon)" },
> +	{ 10, "Inactive(anon)", "Inactive(anon)" },
> +	{ 11, "Active(file)", "Active(file)" },
> +	{ 12, "Inactive(file)", "Inactive(file)" },
> +	{ 13, "Unevictable", "Unevictable" },
> +	{ 14, "Mlocked", "Mlocked" },
> +	{ 15, "Dirty", "Dirty" },
> +	{ 16, "Writeback", "Writeback" },
> +	{ 17, "FilePages", "FilePages" },
> +	{ 18, "Mapped", "Mapped" },
> +	{ 19, "AnonPages", "AnonPages" },
> +	{ 20, "Shmem", "Shmem" },
> +	{ 21, "KernelStack", "KernelStack" },
> +	{ 22, "PageTables", "PageTables" },
> +	{ 23, "NFS_Unstable", "NFS_Unstable" },
> +	{ 24, "Bounce", "Bounce" },
> +	{ 25, "WritebackTmp", "WritebackTmp" },
> +	{ 26, "Slab", "Slab" },
> +	{ 27, "SReclaimable", "SReclaimable" },
> +	{ 28, "SUnreclaim", "SUnreclaim" },
> +	{ 29, "AnonHugePages", "AnonHugePages" },
> +	{ 30, "HugePages_Total", "HugePages_Total" },
> +	{ 31, "HugePages_Free", "HugePages_Free" },
> +	{ 32, "HugePages_Surp", "HugePages_Surp" }
> +};
> +
> +#define SYSTEM_MEMINFO_ROWS (sizeof(system_meminfo) /  
> sizeof(system_meminfo[0]))
> +
> +
> +
> +
> +
> +
> +// To allow re-ordering the meminfo memory categories in system_meminfo and
> +// numastat_meminfo relative to order in /proc, etc., a simple hash  
> index is
> +// used to look up the meminfo categories. The allocated hash table  
> size must
> +// be bigger than necessary to reduce collisions (and because these  
> specific
> +// hash algorithms depend on having some unused buckets.
> +
> +#define HASH_TABLE_SIZE 151
> +int hash_collisions = 0;
> +
> +struct hash_entry {
> +	char *name;
> +	int index;
> +} hash_table[HASH_TABLE_SIZE];
> +
> +
> +void init_hash_table() {
> +	memset(hash_table, 0, sizeof(hash_table));
> +}
> +
> +
> +int hash_ix(char *s) {
> +	unsigned int h = 17;
> +	while (*s) {
> +		// h * 33 + *s++
> +		h = ((h << 5) + h) + *s++;
> +	}
> +	return (h % HASH_TABLE_SIZE);
> +}
> +
> +
> +int hash_lookup(char *s) {
> +	int ix = hash_ix(s);
> +	while (hash_table[ix].name) {	// Assumes big table with blank entries
> +		if (!strcmp(s, hash_table[ix].name)) {
> +			return hash_table[ix].index;	// found it
> +		}
> +		ix += 1;
> +		if (ix >= HASH_TABLE_SIZE) {
> +			ix = 0;
> +		}
> +	}
> +	return -1;
> +}
> +
> +
> +int hash_insert(char *s, int i) {
> +	int ix = hash_ix(s);
> +	while (hash_table[ix].name) {	// assumes no duplicate entries
> +		hash_collisions += 1;
> +		ix += 1;
> +		if (ix >= HASH_TABLE_SIZE) {
> +			ix = 0;
> +		}
> +	}
> +	hash_table[ix].name = s;
> +	hash_table[ix].index = i;
> +	return ix;
> +}
> +
> +
> +
> +
> +
> +
> +// To decouple details of table display (e.g. column width, line  
> folding for
> +// display screen width, et cetera) from acquiring the data and  
> populating the
> +// tables, this semi-general table handling code is used.  There are  
> various
> +// routines to set table attributes, assign and test some cell contents,
> +// initialize and actually display the table.
> +
> +#define CELL_TYPE_NULL     0
> +#define CELL_TYPE_LONG     1
> +#define CELL_TYPE_DOUBLE   2
> +#define CELL_TYPE_STRING   3
> +#define CELL_TYPE_CHAR8    4
> +#define CELL_TYPE_REPCHAR  5
> +
> +#define CELL_FLAG_FREEABLE (1 << 0)
> +#define CELL_FLAG_ROWSPAN  (1 << 1)
> +#define CELL_FLAG_COLSPAN  (1 << 2)
> +
> +#define COL_JUSTIFY_LEFT       (1 << 0)
> +#define COL_JUSTIFY_RIGHT      (1 << 1)
> +#define COL_JUSTIFY_CENTER     3
> +#define COL_JUSTIFY_MASK       0x3
> +#define COL_FLAG_SEEN_DATA     (1 << 2)
> +#define COL_FLAG_NON_ZERO_DATA (1 << 3)
> +#define COL_FLAG_ALWAYS_SHOW   (1 << 4)
> +
> +#define ROW_FLAG_SEEN_DATA     COL_FLAG_SEEN_DATA
> +#define ROW_FLAG_NON_ZERO_DATA COL_FLAG_NON_ZERO_DATA
> +#define ROW_FLAG_ALWAYS_SHOW   COL_FLAG_ALWAYS_SHOW
> +
> +typedef struct cell {
> +	uint32_t type;
> +	uint32_t flags;
> +	union {
> +		char *s;
> +		double d;
> +		int64_t l;
> +		char c[8];
> +	};
> +} cell_t, *cell_p;
> +
> +typedef struct vtab {
> +	int header_rows;
> +	int header_cols;
> +	int data_rows;
> +	int data_cols;
> +	cell_p cell;
> +	int *row_ix_map;
> +	uint8_t *row_flags;
> +	uint8_t *col_flags;
> +	uint8_t *col_width;
> +	uint8_t *col_decimal_places;
> +} vtab_t, *vtab_p;
> +
> +#define ALL_TABLE_ROWS (table->header_rows + table->data_rows)
> +#define ALL_TABLE_COLS (table->header_cols + table->data_cols)
> +#define GET_CELL_PTR(row, col) (&table->cell[(row * ALL_TABLE_COLS) + col])
> +
> +#define USUAL_GUTTER_WIDTH 1
> +
> +
> +void set_row_flag(vtab_p table, int row, int flag) {
> +	table->row_flags[row] |= (uint8_t)flag;
> +}
> +
> +void set_col_flag(vtab_p table, int col, int flag) {
> +	table->col_flags[col] |= (uint8_t)flag;
> +}
> +
> +void clear_row_flag(vtab_p table, int row, int flag) {
> +	table->row_flags[row] &= (uint8_t)~flag;
> +}
> +
> +void clear_col_flag(vtab_p table, int col, int flag) {
> +	table->col_flags[col] &= (uint8_t)~flag;
> +}
> +
> +int test_row_flag(vtab_p table, int row, int flag) {
> +	return ((table->row_flags[row] & (uint8_t)flag) != 0);
> +}
> +
> +int test_col_flag(vtab_p table, int col, int flag) {
> +	return ((table->col_flags[col] & (uint8_t)flag) != 0);
> +}
> +
> +
> +void set_col_justification(vtab_p table, int col, int justify) {
> +	table->col_flags[col] &= (uint8_t)~COL_JUSTIFY_MASK;
> +	table->col_flags[col] |= (uint8_t)(justify & COL_JUSTIFY_MASK);
> +}
> +
> +
> +void set_col_width(vtab_p table, int col, uint8_t width) {
> +	if (width >= SMALL_BUF_SIZE) {
> +		width = SMALL_BUF_SIZE - 1;
> +	}
> +	table->col_width[col] = width;
> +}
> +
> +
> +void set_col_decimal_places(vtab_p table, int col, uint8_t places) {
> +	table->col_decimal_places[col] = places;
> +}
> +
> +
> +void set_cell_flag(vtab_p table, int row, int col, int flag) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->flags |= (uint32_t)flag;
> +}
> +
> +
> +void clear_cell_flag(vtab_p table, int row, int col, int flag) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->flags &= (uint32_t)~flag;
> +}
> +
> +
> +int test_cell_flag(vtab_p table, int row, int col, int flag) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	return ((c_ptr->flags & (uint32_t)flag) != 0);
> +}
> +
> +
> +void string_assign(vtab_p table, int row, int col, char *s) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_STRING;
> +	c_ptr->s = s;
> +}
> +
> +
> +void repchar_assign(vtab_p table, int row, int col, char c) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_REPCHAR;
> +	c_ptr->c[0] = c;
> +}
> +
> +
> +void double_assign(vtab_p table, int row, int col, double d) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_DOUBLE;
> +	c_ptr->d = d;
> +}
> +
> +
> +void long_assign(vtab_p table, int row, int col, int64_t l) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_LONG;
> +	c_ptr->l = l;
> +}
> +
> +
> +void double_addto(vtab_p table, int row, int col, double d) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_DOUBLE;
> +	c_ptr->d += d;
> +}
> +
> +
> +void long_addto(vtab_p table, int row, int col, int64_t l) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	c_ptr->type = CELL_TYPE_LONG;
> +	c_ptr->l += l;
> +}
> +
> +
> +void clear_assign(vtab_p table, int row, int col) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	memset(c_ptr, 0, sizeof(cell_t));
> +}
> +
> +
> +void zero_table_data(vtab_p table, int type) {
> +	// Sets data area of table to zeros of specified type
> +	for (int row = table->header_rows; (row < ALL_TABLE_ROWS); row++) {
> +		for (int col = table->header_cols; (col < ALL_TABLE_COLS); col++) {
> +			cell_p c_ptr = GET_CELL_PTR(row, col);
> +			memset(c_ptr, 0, sizeof(cell_t));
> +			c_ptr->type = type;
> +		}
> +	}
> +}
> +
> +
> +void sort_rows_descending_by_col(vtab_p table, int start_row, int  
> stop_row, int col) {
> +	// Rearrange row_ix_map[] indices so the rows will be in
> +	// descending order by the value in the specified column
> +	for (int ix = start_row; (ix <= stop_row); ix++) {
> +		int biggest_ix = ix;
> +		cell_p biggest_ix_c_ptr = GET_CELL_PTR(table->row_ix_map[ix], col);
> +		for (int iy = ix + 1; (iy <= stop_row); iy++) {
> +			cell_p iy_c_ptr = GET_CELL_PTR(table->row_ix_map[iy], col);
> +			if (biggest_ix_c_ptr->d < iy_c_ptr->d) {
> +				biggest_ix_c_ptr = iy_c_ptr;
> +				biggest_ix = iy;
> +			}
> +		}
> +		if (biggest_ix != ix) {
> +			int tmp = table->row_ix_map[ix];
> +			table->row_ix_map[ix] = table->row_ix_map[biggest_ix];
> +			table->row_ix_map[biggest_ix] = tmp;
> +		}
> +	}
> +}
> +
> +
> +void span(vtab_p table, int first_row, int first_col, int last_row, int  
> last_col) {
> +	// FIXME: implement row / col spannnig someday?
> +}
> +
> +
> +void init_table(vtab_p table, int header_rows, int header_cols, int  
> data_rows, int data_cols) {
> +	// init table sizes
> +	table->header_rows = header_rows;
> +	table->header_cols = header_cols;
> +	table->data_rows = data_rows;
> +	table->data_cols = data_cols;
> +	// allocate memory for all the cells
> +	int alloc_size = ALL_TABLE_ROWS * ALL_TABLE_COLS * sizeof(cell_t);
> +	table->cell = malloc(alloc_size);
> +	if (table->cell == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	memset(table->cell, 0, alloc_size);
> +	// allocate memory for the row map vector
> +	alloc_size = ALL_TABLE_ROWS * sizeof(int);
> +	table->row_ix_map = malloc(alloc_size);
> +	if (table->row_ix_map == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
> +		table->row_ix_map[row] = row;
> +	}
> +	// allocate memory for the row flags vector
> +	alloc_size = ALL_TABLE_ROWS * sizeof(uint8_t);
> +	table->row_flags = malloc(alloc_size);
> +	if (table->row_flags == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	memset(table->row_flags, 0, alloc_size);
> +	// allocate memory for the column flags vector
> +	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
> +	table->col_flags = malloc(alloc_size);
> +	if (table->col_flags == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	memset(table->col_flags, 0, alloc_size);
> +	// allocate memory for the column width vector
> +	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
> +	table->col_width = malloc(alloc_size);
> +	if (table->col_width == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	memset(table->col_width, 0, alloc_size);
> +	// allocate memory for the column precision vector
> +	alloc_size = ALL_TABLE_COLS * sizeof(uint8_t);
> +	table->col_decimal_places = malloc(alloc_size);
> +	if (table->col_decimal_places == NULL) {
> +		perror("malloc failed line: " STRINGIFY(__LINE__));
> +		exit(EXIT_FAILURE);
> +	}
> +	memset(table->col_decimal_places, 0, alloc_size);
> +}
> +
> +
> +void free_cell(vtab_p table, int row, int col) {
> +	cell_p c_ptr = GET_CELL_PTR(row, col);
> +	if ((c_ptr->type == CELL_TYPE_STRING)
> +	    && (c_ptr->flags & CELL_FLAG_FREEABLE)
> +	    && (c_ptr->s != NULL)) {
> +		free(c_ptr->s);
> +	}
> +	memset(c_ptr, 0, sizeof(cell_t));
> +}
> +
> +
> +void free_table(vtab_p table) {
> +	if (table->cell != NULL) {
> +		for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
> +			for (int col = 0; (col < ALL_TABLE_COLS); col++) {
> +				free_cell(table, row, col);
> +			}
> +		}
> +		free(table->cell);
> +	}
> +	if (table->row_ix_map != NULL) {
> +		free(table->row_ix_map);
> +	}
> +	if (table->row_flags != NULL) {
> +		free(table->row_flags);
> +	}
> +	if (table->col_flags != NULL) {
> +		free(table->col_flags);
> +	}
> +	if (table->col_width != NULL) {
> +		free(table->col_width);
> +	}
> +	if (table->col_decimal_places != NULL) {
> +		free(table->col_decimal_places);
> +	}
> +}
> +
> +
> +char *fmt_cell_data(cell_p c_ptr, int max_width, int decimal_places) {
> +	// Returns pointer to a static buffer, expecting caller to
> +	// immediately use or copy the contents before calling again.
> +	int rep_width = max_width - USUAL_GUTTER_WIDTH;
> +	static char buf[SMALL_BUF_SIZE];
> +	switch (c_ptr->type) {
> +	case CELL_TYPE_NULL:
> +		buf[0] = '\0';
> +		break;
> +	case CELL_TYPE_LONG:
> +		snprintf(buf, SMALL_BUF_SIZE, "%ld", c_ptr->l);
> +		break;
> +	case CELL_TYPE_DOUBLE:
> +		snprintf(buf, SMALL_BUF_SIZE, "%.*f", decimal_places, c_ptr->d);
> +		break;
> +	case CELL_TYPE_STRING:
> +		snprintf(buf, SMALL_BUF_SIZE, "%s", c_ptr->s);
> +		break;
> +	case CELL_TYPE_CHAR8:
> +		strncpy(buf, c_ptr->c, 8);
> +		buf[8] = '\0';
> +		break;
> +	case CELL_TYPE_REPCHAR:
> +		memset(buf, c_ptr->c[0], rep_width);
> +		buf[rep_width] = '\0';
> +		break;
> +	default:
> +		strcpy(buf, "Unknown");
> +		break;
> +	}
> +	buf[max_width] = '\0';
> +	return buf;
> +}
> +
> +
> +void auto_set_col_width(vtab_p table, int col, int min_width, int  
> max_width) {
> +	int width = min_width;
> +	for (int row = 0; (row < ALL_TABLE_ROWS); row++) {
> +		cell_p c_ptr = GET_CELL_PTR(row, col);
> +		if (c_ptr->type == CELL_TYPE_REPCHAR) {
> +			continue;
> +		}
> +		char *p = fmt_cell_data(c_ptr, max_width,  
> (int)(table->col_decimal_places[col]));
> +		int l = strlen(p);
> +		if (width < l) {
> +			width = l;
> +		}
> +	}
> +	width += USUAL_GUTTER_WIDTH;
> +	if (width > max_width) {
> +		width = max_width;
> +	}
> +	table->col_width[col] = (uint8_t)width;
> +}
> +
> +
> +void display_justified_cell(cell_p c_ptr, int row_flags, int col_flags,  
> int width, int decimal_places) {
> +	char *p = fmt_cell_data(c_ptr, width, decimal_places);
> +	int l = strlen(p);
> +	char buf[SMALL_BUF_SIZE];
> +	switch (col_flags & COL_JUSTIFY_MASK) {
> +	case COL_JUSTIFY_LEFT:
> +		memcpy(buf, p, l);
> +		if (l < width) {
> +			memset(&buf[l], ' ', width - l);
> +		}
> +		break;
> +	case COL_JUSTIFY_RIGHT:
> +		if (l < width) {
> +			memset(buf, ' ', width - l);
> +		}
> +		memcpy(&buf[width - l], p, l);
> +		break;
> +	case COL_JUSTIFY_CENTER:
> +	default:
> +		memset(buf, ' ', width);
> +		memcpy(&buf[(width - l + 1) / 2], p, l);
> +		break;
> +	}
> +	buf[width] = '\0';
> +	printf("%s", buf);
> +}
> +
> +
> +void display_table(vtab_p table,
> +		      int screen_width,
> +		      int show_unseen_rows,
> +		      int show_unseen_cols,
> +		      int show_zero_rows,
> +		      int show_zero_cols)
> +{
> +	// Set row and column flags according to whether data in rows and cols
> +	// has been assigned, and is currently non-zero.
> +	int some_seen_data = 0;
> +	int some_non_zero_data = 0;
> +	for (int row = table->header_rows; (row < ALL_TABLE_ROWS); row++) {
> +		for (int col = table->header_cols; (col < ALL_TABLE_COLS); col++) {
> +			cell_p c_ptr = GET_CELL_PTR(row, col);
> +			// Currently, "seen data" includes not only numeric data, but also
> +			// any strings, etc -- anything non-NULL (other than rephcars).
> +			if ((c_ptr->type != CELL_TYPE_NULL) && (c_ptr->type !=  
> CELL_TYPE_REPCHAR)) {
> +				some_seen_data = 1;
> +				set_row_flag(table, row, ROW_FLAG_SEEN_DATA);
> +				set_col_flag(table, col, COL_FLAG_SEEN_DATA);
> +				// Currently, "non-zero data" includes not only numeric data,
> +				// but also any strings, etc -- anything non-zero (other than
> +				// repchars, which are already excluded above).  So, note a
> +				// valid non-NULL pointer to an empty string would still be
> +				// counted as non-zero data.
> +				if (c_ptr->l != (int64_t)0) {
> +					some_non_zero_data = 1;
> +					set_row_flag(table, row, ROW_FLAG_NON_ZERO_DATA);
> +					set_col_flag(table, col, COL_FLAG_NON_ZERO_DATA);
> +				}
> +			}
> +		}
> +	}
> +	if (!some_seen_data) {
> +		printf("Table has no data.\n");
> +		return;
> +	}
> +	if (!some_non_zero_data && !show_zero_rows && !show_zero_cols) {
> +		printf("Table has no non-zero data.\n");
> +		return;
> +	}
> +	// Start with first data column and try to display table,
> +	// folding lines as necessary per screen_width
> +	int col = -1;
> +	int data_col = table->header_cols;
> +	while (data_col < ALL_TABLE_COLS) {
> +		// Skip data columns until we have one to display
> +		if ((!test_col_flag(table, data_col, COL_FLAG_ALWAYS_SHOW)) &&
> +		    (((!show_unseen_cols) && (!test_col_flag(table, data_col,  
> COL_FLAG_SEEN_DATA))) ||
> +		     ((!show_zero_cols)   && (!test_col_flag(table, data_col,  
> COL_FLAG_NON_ZERO_DATA))))) {
> +			data_col += 1;
> +			continue;
> +		}
> +		// Display blank line between table sections
> +		if (col > 0) {
> +			printf("\n");
> +		}
> +		// For each row, display as many columns as possible
> +		for (int row_ix = 0; (row_ix < ALL_TABLE_ROWS); row_ix++) {
> +			int row = table->row_ix_map[row_ix];
> +			// If past the header rows, conditionally skip rows
> +			if ((row >= table->header_rows) && (!test_row_flag(table, row,  
> ROW_FLAG_ALWAYS_SHOW))) {
> +				// Optionally skip row if no data seen or if all zeros
> +				if (((!show_unseen_rows) && (!test_row_flag(table, row,  
> ROW_FLAG_SEEN_DATA))) ||
> +				    ((!show_zero_rows)   && (!test_row_flag(table, row,  
> ROW_FLAG_NON_ZERO_DATA)))) {
> +					continue;
> +				}
> +			}
> +			// Begin a new row...
> +			int cur_line_width = 0;
> +			// All lines start with the left header columns
> +			for (col = 0; (col < table->header_cols); col++) {
> +				display_justified_cell(GET_CELL_PTR(row, col),
> +						       (int)(table->row_flags[row]),
> +						       (int)(table->col_flags[col]),
> +						       (int)(table->col_width[col]),
> +						       (int)(table->col_decimal_places[col]));
> +				cur_line_width += (int)(table->col_width[col]);
> +			}
> +			// Reset column index to starting data column for each new row
> +			col = data_col;
> +			// Try to display as many data columns as possible in every section
> +			for (;;) {
> +				// See if we should print this column
> +				if (test_col_flag(table, col, COL_FLAG_ALWAYS_SHOW) ||
> +				    (((show_unseen_cols) || (test_col_flag(table, col,  
> COL_FLAG_SEEN_DATA))) &&
> +				     ((show_zero_cols)   || (test_col_flag(table, col,  
> COL_FLAG_NON_ZERO_DATA))))) {
> +					display_justified_cell(GET_CELL_PTR(row, col),
> +							       (int)(table->row_flags[row]),
> +							       (int)(table->col_flags[col]),
> +							       (int)(table->col_width[col]),
> +							       (int)(table->col_decimal_places[col]));
> +					cur_line_width += (int)(table->col_width[col]);
> +				}
> +				col += 1;
> +				// End the line if no more columns or next column would exceed  
> screen width
> +				if ((col >= ALL_TABLE_COLS) ||
> +				    ((cur_line_width + (int)(table->col_width[col])) > screen_width)) {
> +					break;
> +				}
> +			}
> +			printf("\n");
> +		}
> +		// Remember next starting data column for next section
> +		data_col = col;
> +	}
> +}
> +
> +
> +
> +
> +
> +
> +int verbose = 0;
> +int num_pids = 0;
> +int num_nodes = 0;
> +int screen_width = 0;
> +int show_zero_data = 1;
> +int compress_display = 0;
> +int sort_table = 0;
> +int sort_table_node = -1;
> +int compatibility_mode = 0;
> +int pid_array_max_pids = 0;
> +int *pid_array = NULL;
> +char *prog_name = NULL;
> +double page_size_in_bytes = 0;
> +double huge_page_size_in_bytes = 0;
> +
> +
> +void display_version_and_exit() {
> +	char *version_string = "20120821";
> +	printf("%s version: %s: %s\n", prog_name, version_string, __DATE__);
> +	exit(EXIT_SUCCESS);
> +}
> +
> +
> +void display_usage_and_exit() {
> +	fprintf(stderr, "Usage: %s [-c] [-m] [-n] [-p <PID>|<pattern>]  
> [-s[<node>]] [-v] [-V] [-z] [ <PID>|<pattern>... ]\n", prog_name);
> +	fprintf(stderr, "-c to minimize column widths\n");
> +	fprintf(stderr, "-m to show meminfo-like system-wide memory usage\n");
> +	fprintf(stderr, "-n to show the numastat statistics info\n");
> +	fprintf(stderr, "-p <PID>|<pattern> to show process info\n");
> +	fprintf(stderr, "-s[<node>] to sort data by total column or <node>\n");
> +	fprintf(stderr, "-v to make some reports more verbose\n");
> +	fprintf(stderr, "-V to show the %s code version\n", prog_name);
> +	fprintf(stderr, "-z to skip rows and columns of zeros\n");
> +	exit(EXIT_FAILURE);
> +}
> +
> +
> +int get_screen_width() {
> +	int width = 80;
> +	char *p = getenv("NUMASTAT_WIDTH");
> +	if (p != NULL) {
> +		width = atoi(p);
> +		if ((width < 1) || (width > 10000000)) {
> +			width = 80;
> +		}
> +	} else if (isatty(fileno(stdout))) {
> +		FILE *fs = popen("resize 2>/dev/null", "r");
> +		if (fs != NULL) {
> +			char columns[72];
> +			fgets(columns, sizeof(columns), fs);
> +			pclose(fs);
> +			if (strncmp(columns, "COLUMNS=", 8) == 0) {
> +				width = atoi(&columns[8]);
> +				if ((width < 1) || (width > 10000000)) {
> +					width = 80;
> +				}
> +			}
> +		}
> +	} else {
> +		// Not a tty, so allow a really long line
> +		width = 10000000;
> +	}
> +	if (width < 32) {
> +		width = 32;
> +	}
> +	return width;
> +}
> +
> +
> +char *command_name_for_pid(int pid) {
> +	// Get the PID command name field from /proc/PID/status file.  Return
> +	// pointer to a static buffer, expecting caller to immediately copy  
> result.
> +	static char buf[SMALL_BUF_SIZE];
> +	char fname[64];
> +	snprintf(fname, sizeof(fname), "/proc/%d/status", pid);
> +	FILE *fs = fopen(fname, "r");
> +	if (!fs) {
> +		return NULL;
> +	} else {
> +		while (fgets(buf, SMALL_BUF_SIZE, fs)) {
> +			if (strstr(buf, "Name:") == buf) {
> +				char *p = &buf[5];
> +				while (isspace(*p)) {
> +					p++;
> +				}
> +				if (p[strlen(p) - 1] == '\n') {
> +					p[strlen(p) - 1] = '\0';
> +				}
> +				fclose(fs);
> +				return p;
> +			}
> +		}
> +		fclose(fs);
> +	}
> +	return NULL;
> +}
> +
> +
> +void show_info_from_system_file(char *file, meminfo_p meminfo, int  
> meminfo_rows, int tok_offset) {
> +	// Setup and init table
> +	vtab_t table;
> +	int header_rows = 2 - compatibility_mode;
> +	int header_cols = 1;
> +	// Add an extra data column for a total column
> +	init_table(&table, header_rows, header_cols, meminfo_rows, num_nodes + 1);
> +	int total_col_ix = header_cols + num_nodes;
> +	// Insert token mapping in hash table and assign left header column  
> label for each row in table
> +	init_hash_table();
> +	for (int row = 0; (row < meminfo_rows); row++) {
> +		hash_insert(meminfo[row].token, meminfo[row].index);
> +		if (compatibility_mode) {
> +			string_assign(&table, (header_rows + row), 0, meminfo[row].token);
> +		} else {
> +			string_assign(&table, (header_rows + row), 0, meminfo[row].label);
> +		}
> +	}
> +	// printf("There are %d table hash collisions.\n", hash_collisions);
> +	// Set left header column width and left justify it
> +	set_col_width(&table, 0, 16);
> +	set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
> +	// Open /sys/devices/system/node/node?/<file> for each node and store data
> +	// in table.  If not compatibility_mode, do approximately first third of
> +	// this loop also for (node_ix == num_nodes) to get "Total" column header.
> +	for (int node_ix = 0; (node_ix < (num_nodes + (1 -  
> compatibility_mode))); node_ix++) {
> +		int col = header_cols + node_ix;
> +		// Assign header row label and horizontal line for this column...
> +		string_assign(&table, 0, col, node_header[node_ix]);
> +		if (!compatibility_mode) {
> +			repchar_assign(&table, 1, col, '-');
> +			int decimal_places = 2;
> +			if (compress_display) {
> +				decimal_places = 0;
> +			}
> +			set_col_decimal_places(&table, col, decimal_places);
> +		}
> +		// Set column width and right justify data
> +		set_col_width(&table, col, 16);
> +		set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
> +		if (node_ix == num_nodes) {
> +			break;
> +		}
> +		// Open /sys/.../node<N>/numstast file for this node...
> +		char buf[SMALL_BUF_SIZE];
> +		char fname[64];
> +		snprintf(fname, sizeof(fname), "/sys/devices/system/node/node%d/%s",  
> node_ix_map[node_ix], file);
> +		FILE *fs = fopen(fname, "r");
> +		if (!fs) {
> +			sprintf(buf, "cannot open %s", fname);
> +			perror(buf);
> +			exit(EXIT_FAILURE);
> +		}
> +		// Get table values for this node...
> +		while (fgets(buf, SMALL_BUF_SIZE, fs)) {
> +			char *tok[64];
> +			int tokens = 0;
> +			const char *delimiters = " \t\r\n:";
> +			char *p = strtok(buf, delimiters);
> +			if (p == NULL) {
> +				continue;	// Skip blank lines;
> +			}
> +			while (p) {
> +				tok[tokens++] = p;
> +				p = strtok(NULL, delimiters);
> +			}
> +			// example line from numastat file: "numa_miss 16463"
> +			// example line from meminfo  file: "Node 3 Inactive:  210680 kB"
> +			int index = hash_lookup(tok[0 + tok_offset]);
> +			if (index < 0) {
> +				printf("Token %s not in hash table.\n", tok[0]);
> +			} else {
> +				double value = (double)atol(tok[1 + tok_offset]);
> +				if (!compatibility_mode) {
> +					double multiplier = 1.0;
> +					if (tokens < 5) {
> +						multiplier = page_size_in_bytes;
> +					} else if (!strncmp("HugePages", tok[2], 9)) {
> +						multiplier = huge_page_size_in_bytes;
> +					} else if (!strncmp("kB", tok[4], 2)) {
> +						multiplier = KILOBYTE;
> +					}
> +					value *= multiplier;
> +					value /= (double)MEGABYTE;
> +				}
> +				double_assign(&table, header_rows + index, col, value);
> +				double_addto(&table, header_rows + index, total_col_ix, value);
> +			}
> +		}
> +		fclose(fs);
> +	}
> +	// Crompress display column widths, if requested
> +	if (compress_display) {
> +		for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
> +			auto_set_col_width(&table, col, 4, 16);
> +		}
> +	}
> +	// Optionally sort the table data
> +	if (sort_table) {
> +		int sort_col;
> +		if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
> +			sort_col = total_col_ix;
> +		} else {
> +			sort_col = header_cols + node_ix_map[sort_table_node];
> +		}
> +		sort_rows_descending_by_col(&table, header_rows, header_rows +  
> meminfo_rows - 1, sort_col);
> +	}
> +	// Actually display the table now, doing line-folding as necessary
> +	display_table(&table, screen_width, 0, 0, show_zero_data, show_zero_data);
> +	free_table(&table);
> +}
> +
> +
> +void show_numastat_info() {
> +	if (!compatibility_mode) {
> +		printf("\nPer-node numastat info (in MBs):\n");
> +	}
> +	show_info_from_system_file("numastat", numastat_meminfo,  
> NUMASTAT_MEMINFO_ROWS, 0);
> +}
> +
> +
> +void show_system_info() {
> +	printf("\nPer-node system memory usage (in MBs):\n");
> +	show_info_from_system_file("meminfo", system_meminfo,  
> SYSTEM_MEMINFO_ROWS, 2);
> +}
> +
> +
> +void show_process_info() {
> +	vtab_t table;
> +	int header_rows = 2;
> +	int header_cols = 1;
> +	int data_rows;
> +	int show_sub_categories = (verbose || (num_pids == 1));
> +	if (show_sub_categories) {
> +		data_rows = PROCESS_MEMINFO_ROWS;
> +	} else {
> +		data_rows = num_pids;
> +	}
> +	// Add two extra rows for a horizontal rule followed by a total row
> +	// Add one extra data column for a total column
> +	init_table(&table, header_rows, header_cols, data_rows + 2, num_nodes  
> + 1);
> +	int total_col_ix = header_cols + num_nodes;
> +	int total_row_ix = header_rows + data_rows + 1;
> +	string_assign(&table, total_row_ix, 0, "Total");
> +	if (show_sub_categories) {
> +		// Assign left header column label for each row in table
> +		for (int row = 0; (row < PROCESS_MEMINFO_ROWS); row++) {
> +			string_assign(&table, (header_rows + row), 0,  
> process_meminfo[row].label);
> +		}
> +	} else {
> +		string_assign(&table, 0, 0, "PID");
> +		repchar_assign(&table, 1, 0, '-');
> +		printf("\nPer-node process memory usage (in MBs)\n");
> +	}
> +	// Set left header column width and left justify it
> +	set_col_width(&table, 0, 16);
> +	set_col_justification(&table, 0, COL_JUSTIFY_LEFT);
> +	// Set up "Node <N>" column headers over data columns, plus "Total" column
> +	for (int node_ix = 0; (node_ix <= num_nodes); node_ix++) {
> +		int col = header_cols + node_ix;
> +		// Assign header row label and horizontal line for this column...
> +		string_assign(&table, 0, col, node_header[node_ix]);
> +		repchar_assign(&table, 1, col, '-');
> +		// Set column width, decimal places, and right justify data
> +		set_col_width(&table, col, 16);
> +		int decimal_places = 2;
> +		if (compress_display) {
> +			decimal_places = 0;
> +		}
> +		set_col_decimal_places(&table, col, decimal_places);
> +		set_col_justification(&table, col, COL_JUSTIFY_RIGHT);
> +	}
> +	// Initialize data in table to all zeros
> +	zero_table_data(&table, CELL_TYPE_DOUBLE);
> +	// If (show_sub_categories), show individual process tables for each PID,
> +	// Otherwise show one big table of process total lines from all the PIDs.
> +	for (int pid_ix = 0; (pid_ix < num_pids); pid_ix++) {
> +		int pid = pid_array[pid_ix];
> +		if (show_sub_categories) {
> +			printf("\nPer-node process memory usage (in MBs) for PID %d (%s)\n",  
> pid, command_name_for_pid(pid));
> +			if (pid_ix > 0) {
> +				// Re-initialize show_sub_categories table, because we re-use it  
> for each PID.
> +				zero_table_data(&table, CELL_TYPE_DOUBLE);
> +			}
> +		} else {
> +			// Put this row's "PID (cmd)" label in left header column for this  
> PID total row
> +			char tmp_buf[64];
> +			snprintf(tmp_buf, sizeof(tmp_buf), "%d (%s)", pid,  
> command_name_for_pid(pid));
> +			char *p = strdup(tmp_buf);
> +			if (p == NULL) {
> +				perror("malloc failed line: " STRINGIFY(__LINE__));
> +				exit(EXIT_FAILURE);
> +			}
> +			string_assign(&table, header_rows + pid_ix, 0, p);
> +			set_cell_flag(&table, header_rows + pid_ix, 0, CELL_FLAG_FREEABLE);
> +		}
> +		// Open numa_map for this PID to get per-node data
> +		char fname[64];
> +		snprintf(fname, sizeof(fname), "/proc/%d/numa_maps", pid);
> +		char buf[BUF_SIZE];
> +		FILE *fs = fopen(fname, "r");
> +		if (!fs) {
> +			sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
> +			perror(buf);
> +			continue;
> +		}
> +		// Add up sub-category memory used from each node.  Must go line by line
> +		// through the numa_map figuring out which category memory, node, and the
> +		// amount.
> +		while (fgets(buf, BUF_SIZE, fs)) {
> +			int category = PROCESS_PRIVATE_INDEX;	// init category to the  
> catch-all...
> +			const char *delimiters = " \t\r\n";
> +			char *p = strtok(buf, delimiters);
> +			while (p) {
> +				// If the memory category for this line is still the catch-all
> +				// (i.e.  private), then see if the current token is a special
> +				// keyword for a specific memory sub-category.
> +				if (category == PROCESS_PRIVATE_INDEX) {
> +					for (int ix = 0; (ix < PROCESS_PRIVATE_INDEX); ix++) {
> +						if (!strncmp(p, process_meminfo[ix].token,  
> strlen(process_meminfo[ix].token))) {
> +							category = ix;
> +							break;
> +						}
> +					}
> +				}
> +				// If the current token is a per-node pages quantity, parse the
> +				// node number and accumulate the number of pages in the specific
> +				// category (and also add to the total).
> +				if (p[0] == 'N') {
> +					int node_num = (int)strtol(&p[1], &p, 10);
> +					if (p[0] != '=') {
> +						perror("node value parse error");
> +						exit(EXIT_FAILURE);
> +					}
> +					double value = (double)strtol(&p[1], &p, 10);
> +					double multiplier = page_size_in_bytes;
> +					if (category == PROCESS_HUGE_INDEX) {
> +						multiplier = huge_page_size_in_bytes;
> +					}
> +					value *= multiplier;
> +					value /= (double)MEGABYTE;
> +					// Add value to data cell, total_col, and total_row
> +					int tmp_row;
> +					if (show_sub_categories) {
> +						tmp_row = header_rows + category;
> +					} else {
> +						tmp_row = header_rows + pid_ix;
> +					}
> +					int tmp_col = header_cols + node_num;
> +					double_addto(&table, tmp_row, tmp_col, value);
> +					double_addto(&table, tmp_row, total_col_ix, value);
> +					double_addto(&table, total_row_ix, tmp_col, value);
> +					double_addto(&table, total_row_ix, total_col_ix, value);
> +				}
> +				// Get next token on the line
> +				p = strtok(NULL, delimiters);
> +			}
> +		}
> +		// Currently, a non-root user can open some numa_map files successfully
> +		// without error, but can't actually read the contents -- despite the
> +		// 444 file permissions.  So, use ferror() to check here to see if we
> +		// actually got a read error, and if so, alert the user so they know
> +		// not to trust the zero in the table.
> +		if (ferror(fs)) {
> +			sprintf(buf, "Can't read /proc/%d/numa_maps", pid);
> +			perror(buf);
> +		}
> +		fclose(fs);
> +		// If showing individual tables, or we just added the last total line,
> +		// prepare the table for display and display it...
> +		if ((show_sub_categories) || (pid_ix + 1 == num_pids)) {
> +			// Crompress display column widths, if requested
> +			if (compress_display) {
> +				for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
> +					auto_set_col_width(&table, col, 4, 16);
> +				}
> +			} else {
> +				// Since not compressing the display, allow the left header
> +				// column to be wider.  Otherwise, sometimes process command
> +				// name instance numbers can be truncated in an annoying way.
> +				auto_set_col_width(&table, 0, 16, 24);
> +			}
> +			// Put dashes above Total line...
> +			set_row_flag(&table, total_row_ix - 1, COL_FLAG_ALWAYS_SHOW);
> +			for (int col = 0; (col < header_cols + num_nodes + 1); col++) {
> +				repchar_assign(&table, total_row_ix - 1, col, '-');
> +			}
> +			// Optionally sort the table data
> +			if (sort_table) {
> +				int sort_col;
> +				if ((sort_table_node < 0) || (sort_table_node >= num_nodes)) {
> +					sort_col = total_col_ix;
> +				} else {
> +					sort_col = header_cols + node_ix_map[sort_table_node];
> +				}
> +				sort_rows_descending_by_col(&table, header_rows, header_rows +  
> data_rows - 1, sort_col);
> +			}
> +			// Actually show the table
> +			display_table(&table, screen_width, 0, 0, show_zero_data,  
> show_zero_data);
> +		}
> +	}			// END OF FOR_EACH-PID loop
> +	free_table(&table);
> +}				// show_process_info()
> +
> +
> +int node_and_digits(const struct dirent *dptr) {
> +	char *p = (char *)(dptr->d_name);
> +	if (*p++ != 'n') return 0;
> +	if (*p++ != 'o') return 0;
> +	if (*p++ != 'd') return 0;
> +	if (*p++ != 'e') return 0;
> +	do {
> +		if (!isdigit(*p++)) return 0;
> +	} while (*p != '\0');
> +	return 1;
> +}
> +
> +
> +void init_node_ix_map_and_header(int compatibility_mode) {
> +	// Count directory names of the form: /sys/devices/system/node/node<N>
> +	struct dirent **namelist;
> +	num_nodes = scandir("/sys/devices/system/node", &namelist,  
> node_and_digits, NULL);
> +	if (num_nodes < 1) {
> +		if (compatibility_mode) {
> +			perror("sysfs not mounted or system not NUMA aware");
> +		} else {
> +			perror("Couldn't open /sys/devices/system/node");
> +		}
> +		exit(EXIT_FAILURE);
> +	} else {
> +		node_ix_map = malloc(num_nodes * sizeof(int));
> +		if (node_ix_map == NULL) {
> +			perror("malloc failed line: " STRINGIFY(__LINE__));
> +			exit(EXIT_FAILURE);
> +		}
> +		// For each "node<N>" filename present, save <N> in node_ix_map
> +		for (int ix = 0; (ix < num_nodes); ix++) {
> +			node_ix_map[ix] = atoi(&namelist[ix]->d_name[4]);
> +			free(namelist[ix]);
> +		}
> +		free(namelist);
> +		// Now, sort the node map in increasing order. Use a simplistic sort
> +		// since we expect a relatively short (and maybe pre-ordered) list.
> +		for (int ix = 0; (ix < num_nodes); ix++) {
> +			int smallest_ix = ix;
> +			for (int iy = ix + 1; (iy < num_nodes); iy++) {
> +				if (node_ix_map[smallest_ix] > node_ix_map[iy]) {
> +					smallest_ix = iy;
> +				}
> +			}
> +			if (smallest_ix != ix) {
> +				int tmp = node_ix_map[ix];
> +				node_ix_map[ix] = node_ix_map[smallest_ix];
> +				node_ix_map[smallest_ix] = tmp;
> +			}
> +		}
> +		// Construct vector of "Node <N>" and "Total" column headers. Allocate
> +		// one for each NUMA node, plus one on the end for the "Total" column
> +		node_header = malloc((num_nodes + 1) * sizeof(char *));
> +		if (node_header == NULL) {
> +			perror("malloc failed line: " STRINGIFY(__LINE__));
> +			exit(EXIT_FAILURE);
> +		}
> +		for (int node_ix = 0; (node_ix <= num_nodes); node_ix++) {
> +			char node_label[64];
> +			if (node_ix == num_nodes) {
> +				strcpy(node_label, "Total");
> +			} else if (compatibility_mode) {
> +				snprintf(node_label, sizeof(node_label), "node%d",  
> node_ix_map[node_ix]);
> +			} else {
> +				snprintf(node_label, sizeof(node_label), "Node %d",  
> node_ix_map[node_ix]);
> +			}
> +			char *s = strdup(node_label);
> +			if (s == NULL) {
> +				perror("malloc failed line: " STRINGIFY(__LINE__));
> +				exit(EXIT_FAILURE);
> +			}
> +			node_header[node_ix] = s;
> +		}
> +	}
> +}
> +
> +
> +void free_node_ix_map_and_header() {
> +	if (node_ix_map != NULL) {
> +		free(node_ix_map);
> +		node_ix_map = NULL;
> +	}
> +	if (node_header != NULL) {
> +		for (int ix = 0; (ix <= num_nodes); ix++) {
> +			free(node_header[ix]);
> +		}
> +		free(node_header);
> +		node_header = NULL;
> +	}
> +}
> +
> +
> +double get_huge_page_size_in_bytes() {
> +	double huge_page_size = 0;;
> +	FILE *fs = fopen("/proc/meminfo", "r");
> +	if (!fs) {
> +		perror("Can't open /proc/meminfo");
> +		exit(EXIT_FAILURE);
> +	}
> +	char buf[SMALL_BUF_SIZE];
> +	while (fgets(buf, SMALL_BUF_SIZE, fs)) {
> +		if (!strncmp("Hugepagesize", buf, 12)) {
> +			char *p = &buf[12];
> +			while ((!isdigit(*p)) && (p < buf + SMALL_BUF_SIZE)) {
> +				p++;
> +			}
> +			huge_page_size = strtod(p, NULL);
> +			break;
> +		}
> +	}
> +	fclose(fs);
> +	return huge_page_size * KILOBYTE;
> +}
> +
> +
> +int all_digits(char *p) {
> +	if (p == NULL) {
> +		return 0;
> +	}
> +	while (*p != '\0') {
> +		if (!isdigit(*p++)) return 0;
> +	}
> +	return 1;
> +}
> +
> +
> +int starts_with_digit(const struct dirent *dptr) {
> +	return (isdigit(dptr->d_name[0]));
> +}
> +
> +
> +void add_pid_to_list(int pid) {
> +	if (num_pids < pid_array_max_pids) {
> +		pid_array[num_pids++] = pid;
> +	} else {
> +		if (pid_array_max_pids == 0) {
> +			pid_array_max_pids = 32;
> +		}
> +		int *tmp_int_ptr = realloc(pid_array, 2 * pid_array_max_pids *  
> sizeof(int));
> +		if (tmp_int_ptr == NULL) {
> +			char buf[SMALL_BUF_SIZE];
> +			sprintf(buf, "Too many PIDs, skipping %d", pid);
> +			perror(buf);
> +		} else {
> +			pid_array = tmp_int_ptr;
> +			pid_array_max_pids *= 2;
> +			pid_array[num_pids++] = pid;
> +		}
> +	}
> +}
> +
> +
> +int ascending(const void *p1, const void *p2) {
> +	return *(int *)p1 - *(int *) p2;
> +}
> +
> +void sort_pids_and_remove_duplicates() {
> +	if (num_pids > 1) {
> +		qsort(pid_array, num_pids, sizeof(int), ascending);
> +		int ix1 = 0;
> +		for (int ix2 = 1; (ix2 < num_pids); ix2++) {
> +			if (pid_array[ix2] == pid_array[ix1]) {
> +				continue;
> +			}
> +			ix1 += 1;
> +			if (ix2 > ix1) {
> +				pid_array[ix1] = pid_array[ix2];
> +			}
> +		}
> +		num_pids = ix1 + 1;
> +	}
> +}
> +
> +
> +void add_pids_from_pattern_search(char *pattern) {
> +	// Search all /proc/<PID>/cmdline files and /proc/<PID>/status:Name fields
> +	// for matching patterns.  Show the memory details for matching PIDs.
> +	int num_matches_found = 0;
> +	struct dirent **namelist;
> +	int files = scandir("/proc", &namelist, starts_with_digit, NULL);
> +	if (files < 0) {
> +		perror("Couldn't open /proc");
> +	}
> +	for (int ix = 0; (ix < files); ix++) {
> +		char buf[BUF_SIZE];
> +		// First get Name field from status file
> +		int pid = atoi(namelist[ix]->d_name);
> +		char *p = command_name_for_pid(pid);
> +		if (p) {
> +			strcpy(buf, p);
> +		} else {
> +			buf[0] = '\0';
> +		}
> +		// Next copy cmdline file contents onto end of buffer.  Do it a
> +		// character at a time to convert nulls to spaces.
> +		char fname[64];
> +		snprintf(fname, sizeof(fname), "/proc/%s/cmdline", namelist[ix]->d_name);
> +		FILE *fs = fopen(fname, "r");
> +		if (fs) {
> +			p = buf;
> +			while (*p != '\0') {
> +				p++;
> +			}
> +			*p++ = ' ';
> +			int c;
> +			while (((c = fgetc(fs)) != EOF) && (p < buf + BUF_SIZE - 1)) {
> +				if (c == '\0') {
> +					c = ' ';
> +				}
> +				*p++ = c;
> +			}
> +			*p++ = '\0';
> +			fclose(fs);
> +		}
> +		if (strstr(buf, pattern)) {
> +			if (pid != getpid()) {
> +				add_pid_to_list(pid);
> +				num_matches_found += 1;
> +			}
> +		}
> +		free(namelist[ix]);
> +	}
> +	free(namelist);
> +	if (num_matches_found == 0) {
> +		printf("Found no processes containing pattern: \"%s\"\n", pattern);
> +	}
> +}
> +
> +
> +int main(int argc, char **argv) {
> +	prog_name = argv[0];
> +	int show_the_system_info = 0;
> +	int show_the_numastat_info = 0;
> +	static struct option long_options[] = {
> +		{"help", 0, 0, '?'},
> +		{0, 0, 0, 0}
> +	};
> +	int long_option_index = 0;
> +	int opt;
> +	while ((opt = getopt_long(argc, argv, "cmnp:s::vVz?", long_options,  
> &long_option_index)) != -1) {
> +		switch (opt) {
> +		case 0:
> +			printf("Unexpected long option %s",  
> long_options[long_option_index].name);
> +			if (optarg) {
> +				printf(" with arg %s", optarg);
> +			}
> +			printf("\n");
> +			display_usage_and_exit();
> +			break;
> +		case 'c':
> +			compress_display = 1;
> +			break;
> +		case 'm':
> +			show_the_system_info = 1;
> +			break;
> +		case 'n':
> +			show_the_numastat_info = 1;
> +			break;
> +		case 'p':
> +			if ((optarg) && (all_digits(optarg))) {
> +				add_pid_to_list(atoi(optarg));
> +			} else {
> +				add_pids_from_pattern_search(optarg);
> +			}
> +			break;
> +		case 's':
> +			sort_table = 1;
> +			if ((optarg) && (all_digits(optarg))) {
> +				sort_table_node = atoi(optarg);
> +			}
> +			break;
> +		case 'v':
> +			verbose = 1;
> +			break;
> +		case 'V':
> +			display_version_and_exit();
> +			break;
> +		case 'z':
> +			show_zero_data = 0;
> +			break;
> +		default:
> +		case '?':
> +			display_usage_and_exit();
> +			break;
> +		}
> +	}
> +	// Figure out the display width, which is used to format the tables
> +	// and limit the output columns per row
> +	screen_width = get_screen_width();
> +	// Any remaining arguments are assumed to be additional process specifiers
> +	while (optind < argc) {
> +		if (all_digits(argv[optind])) {
> +			add_pid_to_list(atoi(argv[optind]));
> +		} else {
> +			add_pids_from_pattern_search(argv[optind]);
> +		}
> +		optind += 1;
> +	}
> +	// If there are no program options or arguments, be extremely compatible
> +	// with the old numastat perl script (which is included at the end of this
> +	// file for reference)
> +	compatibility_mode = (argc == 1);
> +	init_node_ix_map_and_header(compatibility_mode);	// enumarate the NUMA  
> nodes
> +	if (compatibility_mode) {
> +		show_numastat_info();
> +		free_node_ix_map_and_header();
> +		exit(EXIT_SUCCESS);
> +	}
> +	// Figure out page sizes
> +	page_size_in_bytes = (double)sysconf(_SC_PAGESIZE);
> +	huge_page_size_in_bytes = get_huge_page_size_in_bytes();
> +	// Display the info for the process specifiers
> +	if (num_pids > 0) {
> +		sort_pids_and_remove_duplicates();
> +		show_process_info();
> +	}
> +	if (pid_array != NULL) {
> +		free(pid_array);
> +	}
> +	// Display the system-wide memory usage info
> +	if (show_the_system_info) {
> +		show_system_info();
> +	}
> +	// Display the numastat statistics info
> +	if ((show_the_numastat_info) || ((num_pids == 0) &&  
> (!show_the_system_info))) {
> +		show_numastat_info();
> +	}
> +	free_node_ix_map_and_header();
> +	exit(EXIT_SUCCESS);
> +}
> +
> +
> +
> +
> +
> +
> +#if 0
> +/*
> +
> +
> +#!/usr/bin/perl
> +# Print numa statistics for all nodes
> +# Copyright (C) 2003,2004 Andi Kleen, SuSE Labs.
> +#
> +# numastat 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.
> +#
> +# numastat 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
> +#
> +# Example: NUMASTAT_WIDTH=80 watch -n1 numastat
> +#
> +
> +# output width
> +$WIDTH=80;
> +if (defined($ENV{'NUMASTAT_WIDTH'})) {
> +	$WIDTH=$ENV{'NUMASTAT_WIDTH'};
> +} else {
> +	use POSIX;
> +	if (POSIX::isatty(fileno(STDOUT))) {
> +		if (open(R, "resize |")) {
> +			while (<R>) {
> +				$WIDTH=$1 if /COLUMNS=(\d+)/;
> +			}	
> +			close R;
> +		}
> +	} else {
> +		# don't split it up for easier parsing
> +		$WIDTH=10000000;
> +	}
> +}
> +$WIDTH = 32 if $WIDTH < 32;
> +
> +if (! -d "/sys/devices/system/node" ) {
> +	print STDERR "sysfs not mounted or system not NUMA aware\n";
> +	exit 1;
> +}
> +
> +%stat = ();
> +$title = "";
> +$mode = 0;
> +opendir(NODES, "/sys/devices/system/node") || exit 1;
> +foreach $nd (readdir(NODES)) {
> +	next unless $nd =~ /node(\d+)/;
> +	# On newer kernels, readdir may enumerate the 'node(\d+) subdirs
> +	# in opposite order from older kernels--e.g., node{0,1,2,...}
> +	# as opposed to node{N,N-1,N-2,...}.  Accomodate this by
> +	# switching to new mode so that the stats get emitted in
> +	# the same order.
> +        #print "readdir(NODES) returns $nd\n";
> +	if (!$title && $nd =~ /node0/) {
> +		$mode = 1;
> +	}
> +	open(STAT, "/sys/devices/system/node/$nd/numastat") ||
> +			die "cannot open $nd: $!\n";
> +	if (! $mode) {
> +		$title = sprintf("%16s",$nd) . $title;
> +	} else {
> +		$title = $title . sprintf("%16s",$nd);
> +	}
> +	@fields = ();
> +	while (<STAT>) {
> +		($name, $val) = split;
> +		if (! $mode) {
> +			$stat{$name} = sprintf("%16u", $val) . $stat{$name};
> +		} else {
> +			$stat{$name} = $stat{$name} . sprintf("%16u", $val);
> +		}
> +		push(@fields, $name);
> +	}
> +	close STAT;
> +}
> +closedir NODES;
> +
> +$numfields = int(($WIDTH - 16) / 16);
> +$l = 16 * $numfields;
> +for ($i = 0; $i < length($title); $i += $l) {
> +	print "\n" if $i > 0;
> +	printf "%16s%s\n","",substr($title,$i,$l);
> +	foreach (@fields) {
> +		printf "%-16s%s\n",$_,substr($stat{$_},$i,$l);
> +	}
> +}
> +
> +
> +*/
> +#endif

-- 
Cliff Wickman
SGI
cpw@sgi.com
(651) 683-3824