Free performance monitor software for linux

Performance Co-Pilot (PCP) is a framework and services to support system-level performance monitoring and performance management.
The services offered by PCP are especially attractive for those tackling harder system-level performance problems. For example this may involve a transient performance degradation, or correlating end-user quality of service with platform activity, or diagnosing some complex interaction between resource demands on a single system, or management of performance on large systems with lots of "moving parts".
The distributed PCP architecture makes it especially useful for those seeking centralized monitoring of distributed processing (e.g. in a cluster or webserver farm environment), especially where a large number hosts are involved.
Main features:
- A single API for accessing the performance data that hides details of where the data comes from and how it was captured and imported into the PCP framework.
- A client-server architecture allows multiple clients to monitor the same host, and a single client to monitor multiple hosts (e.g. in a Beowulf cluster). This enables centralized monitoring of distributed processing.
- Integrated archive logging and replay so a client application can use the same API to process real-time data from a host or historical data from an archive.
- The framework supports APIs and configuration file formats that enable the scope of performance monitoring to be extended at all levels.
- An "plugin" framework (libraries, APIs, agents and daemon) to collect performance data from multiple sources on a single host, e.g. from the hardware, the kernel, the service layers, the application libraries, and the applications themselves.
- Libraries and sample implementations encourage the development of new "plugins" (or agents) to capture and export the performance data that matters in your application environment, along side the other generic performance data.
- An endian-safe transport layer for moving performance metrics between the collector and the monitoring applications over TCP/IP. This means an IRIX desktop with PCP can monitor one or more Linux systems with the Open Source release of PCP installed.
- A Linux agent that exports a broad range of performance data from most kernels circa 2.0.36 (RedHat 5.2) or later. This includes coverage of activity in the areas of: CPU, disk, memory, swapping, network, NFS, RPC, filesystems and all the per-process statistics.
- Other agents export performance data from:
- Web server activity logs
- arbitrary application-level tracing (via a PCP trace library)
- Cisco routers
- sendmail
- the mail queue
- the PCP infrastructure itself
- Assorted simple monitoring tools that use the PCP APIs to retrieve and display either arbitrary performance metrics, or specific groups of metrics (as in pmstat a cluster-aware vmstat lookalike).
- The PCP inference engine supports automated monitoring through a rule-based language and interpreter that performs user-defined actions when rule predicates are found to be true.

pcpViewer is a 3D viewer of data gathered through the excellent "Performance Co-Pilot" library.

You can see usage of CPU time, net devices, memory, hard drives, and virtually any data exported by the pcp library and daemon.

I first started this "pet project" as a 3D xosview replacement (thanks for inspiration), so one of the goal is to get the same level of responsiveness as xosview.

Camera Monitor is a little tray system icon that notifies you when your Webcam is on. The project is designed for the GNOME desktop, but will work as well on KDE and XFCE.
Camera Monitor is released under the terms of the GNU General Public License.
Installation:
tar xzf laptoptemp-0.2.tar.gz
cd cameramonitor-0.1
./configure
sudo make install
Enhancements:
- Added support for libnotify
- Ported to new gtk.StatusIcon
- Updated preferences panel
- Updated about information
- Removed notification on bad previous exit
- Added option to preferences for autostarting cameramonitor every session

Aazmat Monitor is a SuperKaramba system monitoring widget.

It was adapted to meet office theme and added a few new monitors all of them are built into there own theme file so you can place them were you like.

HPL is a software package that solves a (random) dense linear system in double precision (64 bits) arithmetic on distributed-memory computers. It can thus be regarded as a portable as well as freely available implementation of the High Performance Computing Linpack Benchmark.

The algorithm used by HPL can be summarized by the following keywords: Two-dimensional block-cyclic data distribution - Right-looking variant of the LU factorization with row partial pivoting featuring multiple look-ahead depths - Recursive panel factorization with pivot search and column broadcast combined - Various virtual panel broadcast topologies - bandwidth reducing swap-broadcast algorithm - backward substitution with look-ahead of depth 1.

The HPL package provides a testing and timing program to quantify the accuracy of the obtained solution as well as the time it took to compute it. The best performance achievable by this software on your system depends on a large variety of factors.

Nonetheless, with some restrictive assumptions on the interconnection network, the algorithm described here and its attached implementation are scalable in the sense that their parallel efficiency is maintained constant with respect to the per processor memory usage.

The HPL software package requires the availibility on your system of an implementation of the Message Passing Interface MPI (1.1 compliant). An implementation of either the Basic Linear Algebra Subprograms BLAS or the Vector Signal Image Processing Library VSIPL is also needed. Machine-specific as well as generic implementations of MPI, the BLAS and VSIPL are available for a large variety of systems.

NAT Monitor is a tool to monitor hosts bandwidth usage in a Linux-NAT network.

A daemon collects data and clients display them (currently a GTK app with graph and a text version). It detects new hosts, saves up to 12 hours of data, and has a nice summary statistic.

Skipole Network Monitor project is a simple network monitor with built in web server.

It allows the user to input host IP addresses, it then pings these hosts every five minutes and displays their status via a built-in web server, on port 8000.

So calling http://your_pc_address:8000 will display pages showing green, yellow or red host or group symbols.

Each host is pinged four times every five minutes, and symbols are displayed as:

green : if three or four pings are successfull
yellow : if only one or two are successfull
red : if all four fail

As well as hosts, group symbols are displayed, and can be opened to show hosts, or sub-groups nested within. The operator can create groups, and sub-groups via the gui.