A MetaCard "top" program for LinuxA "top" program is a very useful thing to have on a multi-tasking operating system like Linux. You can use it to keep track of the CPU and memory usage of all programs running on the system, and to detect and kill runaway processes. But the character-based "top" program that comes with Linux systems could be improved upon. Because it isn't aware of the windowing system, it doesn't go to sleep when the window it is running in is iconified. It would also be nice if you could select a process to kill by clicking on it instead of having top type in its process id.
Fortunately, Linux has a very simple and elegant way to get process information, and so it's easy to develop a graphical application to display this information using a tool like MetaCard. This article will show you how it's done using MetaCard's scripting language MetaTalk. MetaTalk is a Very High Level Language (VHLL) that supports building complete applications with very little effort. The MetaTalk language has a very English-like syntax, but is also very concise. This makes it easy to learn, yet doesn't sacrifice the power and compactness found in other HVLLs like Perl. It is also very readable, and so it's easy for non-expert users to figure out what a script does (which can be much more difficult with languages like Perl).
The /proc pseudo-filesystemEach process that is running on a Linux system has a directory in /proc. In that directory there are several files that contain information on the process. To implement a graphical "top" program, we're most interested in the information in the file "stat", which contains process run time and memory usage information. We'll also use the file named "cmdline" which contains the command line used to start up that process.
Each "stat" file contains a single line of information, with the fields separated by spaces. Details on the format can be found in the "proc" man page. It says that on a Linux 1.2 system, words 14 and 15 are the processes user and system running times, respectively. Word 23 is the process size (in bytes) and word 24 is the number of 4K pages currently in RAM for that process.
There are also files in the /proc system that contain information about the whole system. We'll use the "/proc/stat" file which contains overall system resource usage. We'll need that information to compute the percentage CPU usage for each process.
The procedureEach time the display is to be updated, a program must do the following:
The handler then gets the global system time statistics from the file "/proc/stat" and subtracts the values from the last time the handler was called. The time statistics are then stored in a local variable declared outside the handler, which works like a "static" variable in C: it retains its value like a global, but can only be referred to within the script (i.e., it doesn't pollute the global name space). This variable, like all MetaTalk variables, can be used as an associative array without special declarations. All you have to do is put a string (which can be a number) between the  characters.
Note the expressions of the form
The readfile function used in the updatelist handler is shown in
Listing 2. Like all function handlers,
it starts with the keyword
There is one unusual thing about this function, though. Normally one
The readfile function also has to handle the case where the file specified isn't there (which can happen if the process exits after the "ls" command that gets the directory listing is executed). It also needs to convert nulls (ASCII 0 characters) in the strings to spaces, since some of the files use this character as a delimiter. Note that this requires a scripting language that can handle binary data. MetaTalk has no problem with this, but many other scripting languages would.
The rest of the updatelist handler does steps 2 through 7 in the above recipe. The resulting listing is sorted twice to remedy one of the more annoying characteristics of the character-based top program: the individual processes bounce around the listing unpredictably if they're not using any CPU time. Instead, we'll sort them by process size and then by CPU time which is a more useful way to do it. This is only possible because MetaCard's sort is stable, which means order is preserved on sequential sorts if elements have the same key value.
I snuck in a little bit of object-oriented programming in the
Building a stackBacktracking a little, before you can write a script, you need to create an object to attach the script to. MetaCard applications are composed of one or more stacks, each of which has one or more cards. The metaphor (inherited from HyperCard) is of a stack of index cards, but you can also think of it as being pages in a book, slides in a presentation, or the frames in a movie or video. The stacks are stored as binary files similar to the resource files used on the Mac and Windows. But in addition to object descriptions, data such as the state of buttons and the text in fields is also stored in these files.
The objects are created using MetaCard's IDE (Integrated Development Environment), which you use to create objects and to size and position them. To start building a new application window, choose "New Stack" from the File menu (the first card is created automatically with the stack). Then choose tools from the tool bar and draw the fields and buttons you need. See Figure 1 for a screen snapshot of the MetaCard "top" application.
After creating the stack and the controls in it, you add scripts to the stack, cards, and/or controls. Normally each object has its own script, but I've put all of the handlers for the "top" program in the card script. This means that the mouseUp handler (See Footnote) is a little unusual since it gets called through the message-passing hierarchy: messages not handled by an object can be handled by objects-higher up in the hierarchy. In this case, a handler in the card script handles messages sent to any of the controls on the card.
Writing one big handler instead of a bunch of small ones usually means
that you have to figure out which object the message was originally
sent to. The
MetaCard doesn't have a constraint-based geometry system, so you must write scripts to handle resizing and repositioning controls when a stack window is resized. The resizeStack message handler that does this geometry management is shown in Listing 2. Using the IDE, I set the stack properties such that the stack is not resizable in width, only in height (since you need to be able to see all fields). So this handler only has to resize the main field vertically and reposition the buttons along the bottom edge of the display. This simple 4-statement handler reliably handles the task without triggering the time-consuming trial-and-error phase of development required to get a constraint-based system working correctly.
The complete stack is available for download as top.mc (note that you may have to shift-click or control-click to force the download to be saved into a file). It can be run using the free MetaCard Starter Kit available on the Get MetaCard page.
Performance characteristicsRunning the MetaCard version of top takes about twice as much CPU time as the character-based version (6% vs. 3% on a Pentium 90 running Linux 1.2.13). This is a typical result, since a well written MetaCard script generally runs from 2 to 4 times slower than a comparable C program. Of course, the MetaCard version only took a fraction of time to develop. And because it is so much smaller, it will take far less time and effort to maintain and customize (the character-based top program is written in C and is about 10 times as long). Memory usage for the MetaCard version of "top" is considerably less than the total of the character-based "top" program and the "xterm" and extra "bash" process required to run it.
ConclusionThe real power of this graphical top is that it's easy to modify to suit your needs. You could easily add columns to display some of the other information shown in the character-based top, or change the signal used to kill a process. Since MetaCard has built-in object graphics capabilities, you could even add a graphical display of the resources used by individual processes over time.
|White Papers | High-Level Tools . Calculator . TOP . Comparisons . Strained Carrots|