The /proc/PID/smaps files in modern linuxes provides very detailed information about a processes memory consumption. It particularly includes a way to estimate the effect of copy-on-write. This module implements a Perl interface.

Each one describes a virtual memory area of a certain process. All those areas together describe its complete address space. For the meaning of the items refer to your Linux documentation.

The set of information announced by the kernel depends on its version. Early versions (around Linux 2.6.14) lacked for example Pss, Referenced, Swap, KernelPageSize and MMUPageSize. Linux::Smaps provides an interface to all of the components. It creates accessor methods dynamically depending on what the kernel reveals. The Shared_Clean entry for example mutates to the Linux::Smaps::VMA->shared_clean accessor. Method names are built by simply lowercasing them. The actual set of methods is created when the first smaps file is parsed. Subsequent update or Linux::Smaps->new operations expect exactly the same file format. That means you cannot parse smaps files from different kernel versions by the same perl interpreter.

If a filename is set update() reads that file. Otherwize a file name is constructed from $self->procdir, $self->pid and the name smaps. The constructed file name is not saved in the Linux::Smaps object to allow loops like this:

these methods compute the sums of the corresponding values of all vmas.

size, rss, shared_clean, shared_dirty, private_clean and private_dirty methods are unknown until the first call to Linux::Smaps::update(). They are created on the fly. This is to make the module extendable as new features are added to the smaps file by the kernel. As long as the corresponding smaps file lines match ^(\w+):\s*(\d+) kB$ new accessor methods are created.

At the time of this writing at least one new field (referenced) is on the way but all my kernels still lack it.

$other is assumed to be also a Linux::Smaps instance. 3 arrays are returned. The first one ($new) is a list of vmas that are contained in $self but not in $other. The second one ($diff) contains a list of pairs (2-element arrays) of vmas that differ between $self and $other. The 3rd one ($old) is a list of vmas that are contained in $other but not in $self.

Vmas are identified as corresponding if their vma_start fields match. They are considered different if they differ in one of the following fields: vma_end, r, w, x, mayshare, file_off, dev_major, dev_minor, inode, file_name, shared_clean, shared_diry, private_clean and private_dirty.

size, rss, shared_clean, shared_dirty, private_clean and private_dirty methods are unknown until the first call to Linux::Smaps::update. They are created on the fly. This is to make the module extendable as new features are added to the smaps file by the kernel. As long as the corresponding smaps file lines match ^(\w+):\s*(\d+) kB$ new accessor methods are created.

$x is changed in place. Hence, the overall process size (size and rss) would not grow much. But before the tr operation $x was shared by copy-on-write between the 2 processes. Hence, we see a loss of shared_dirty (only a little more than our 1024 kB string) and almost the same growth of private_dirty.

Exchanging the tr-operation to an assingment of a MB of "b" yields the following figures:

Now we see the overall process size grows a little more than a MB. shared_dirty drops almost a MB and private_dirty adds almost 2 MB. That means perl first constructs a 1 MB string of b. This adds 1 MB to size, rss and private_dirty and then copies it to $x. This takes another MB from shared_dirty and adds it to private_dirty.

The proc filesystem reports a page as shared if it belongs multiple processes and as private if it belongs to only one process. But there is an exception. If a page is currently paged out (that means it is not in core) all its attributes including the reference count are paged out as well. So the reference count cannot be read without paging in the page. In this case a page is neither reported as private nor as shared. It is only included in the process size.

Thus, to exaclty measure which pages are shared among N processes at least one of them must be completely in core. This way all pages that can possibly be shared are in core and their reference counts are accessible.

The mlockall(2) syscall may help in this situation. It locks all pages of a process to main memory:

This snippet in one of the processes locks it to the main memory. If all processes are created from the same parent it is executed best just before the parent starts to fork off children. The memory lock is not inherited by the children. So all private pages of the children are swappable.

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself, either Perl version 5.8.5 or, at your option, any later version of Perl 5 you may have available.