A MetaCard "top" program for Linux

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-filesystem

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 procedure

• 1) read the "stat" file in the /proc directory
• 2) find all of the subdirectories in the /proc directory
• 3) read the "stat" and "cmdline" files in each of these directories
• 4) compute the CPU time for the process by subtracting from the last time
• 5) save the current CPU usage
• 6) convert the CPU usage into a percentage of total usage
• 7) build the list of processes and display it
• 8) schedule a time to redo the update

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 word x of y. These are called "chunk" expressions and are a very powerful feature of MetaTalk. With them you can access elements of a string individually without having to split up the whole string into an array first. Also note that you can add words together without having to explicitly convert them into numbers first. This saves development time, and makes scripts smaller than they would be in lower-level languages.

The readfile function used in the updatelist handler is shown in Listing 2. Like all function handlers, it starts with the keyword function and is used in expressions just like MetaCard built-in functions.

There is one unusual thing about this function, though. Normally one would use read from file x until eof in MetaCard. This is because when you specify eof as the terminating condition, MetaCard speeds things up by getting the file size and reading the whole file with a single system call. But this doesn't work for /proc files since the stat() system call returns that they're all 0 bytes long, even though they contain data! So, we must force MetaCard to read the file a byte at a time by specifying empty as the terminating condition.

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.

Finally the updatelist handler uses the send command to schedule a call back to itself in a few seconds and stores the id of the timer send creates in a variable. This local variable can be used to cancel the timer using the cancel function. For example, when the application is iconified, we want to stop the processing (See Listing 3).

I snuck in a little bit of object-oriented programming in the send command. The message is sent to me, which is the object whose script is currently executing. The time interval is specified as the updateinterval of me. This object has a custom property named updateinterval that is persistent, which means it's saved whenever the object is saved. That's why you don't see any initialization of this property in these listings: it's data stored with the stack, not code.

Building a stack

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 target function supplies this information. Like me, the target function returns an object that you can get the properties of or send messages to. This mouseUp handler also shows off the MetaCard switch control structure:

• The "Kill Process" case is executed when the user clicks on the "Kill Process" button. This section gets the PID of the process from the selected line in field and uses the MetaTalk kill command to kill it.
• The "Set Update Interval.." section prompts the user for the new updateinterval value using the ask dialog, verifies that the value is a number and tells the user that it must be if it isn't. The ask and answer dialogs are built-into MetaCard and are quick and easy ways to get simple responses from the user. If the new data checks out OK, the handler cancels the current timer and then calls the "updatelist" handler to restart it.
• The "toplist" case will be executed when the user clicks on a line in the main field. This case enables the "Kill Process" button and suppresses updates for 5 seconds, allowing the user time to kill the process before the selection is cleared when the field is next updated.

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 characteristics

Conclusion