Free performance monitoring tools software for linux

Cimon is Perl program wich monitors the load (memory and CPU) on Cisco routers using SNMP, and generates graphics with statistics using rrdtool. Its good for information about your routers health.

It monitors and displays the cpu 5 minutes utilization in percents and free+used Processor memory. The I/O memory(usualy 2 MB) or Fast on high end routers is being monitored too, but there isnt graphic for it. Cimon is good source for information about your routers health. From version 0.2 cimon can do ip accounting using the cisco ip accounting feature.
The logfiles that it generates as the rrd files needed for the graphics are fully compatible with those produced by sasacct (SASs accounting statistics). So you can use its cgi interface also its posibility to generate graphics on demand or on a user defined interval (via crontab and -g option).

Remote Monitoring Agent (RMA in short) is an auxiliary application for HostMonitor. Enterprise license for Advanced Host Monitor already includes license for 10 installations of the agent. Holders of a Lite, Standard or Professional licenses may buy an additional license for Remote Monitoring Agent separately.
HostMonitor 4.0+ can monitor remote networks using Remote Monitoring Agents (RMA). RMA is small application that accepts requests from HostMonitor, performs test and provides information about test result back to HostMonitor.
Why you may need RMA? Here are just several reasons:
RMA increases security of the network. When you have to run the tests such as CPU Usage test or Performance Counters tests on a remote Windows system, HostMonitor must be able to log in to that system with administrators privileges. Instead you may now use an agent installed on that remote system. In this case HostMonitor will not have to log on to that system at all. HostMonitor needs just one TCP port to communicate with the RMA agent (by default it uses #1055 port, however you may set an agent to use any other port).
Remote Monitoring Agent is also a very useful tool when you have to monitor two (or many) separated networks (connected through Internet). In this case installing just one instance of RMA behind the firewall in network "A" will allow to monitor entire network "A" using the HostMonitor located in the network "B" with just one open TCP port.
RMA decreases the network traffic. E.g. frequent use of "File Integrity" or "Compare Files" tests in an array of remote systems may apply significant load on the network. The more and the bigger files you test the more traffic increase you get. RMA runs locally and sends only the test results to the HostMonitor thus decreasing the amount of network traffic.
Remote Monitoring Agent simplifies network administration. You no longer need to share local drives/folders to perform tests such as File Integrity, Folder/File Size, File Availability, Count Files, etc
RMA for Linux / BSD / Solaris allows you to perform tests that HostMonitor cannot perform. For example HostMonitor cannot monitor processes that are running on Linux systems. RMA can do that.
Main features:
- All traffic between Remote Monitoring Agents and HostMonitor is encrypted.
- It is possible to customize the list of enabled tests for each of the agents (e.g. living only Count Files and UNC tests only).
- You can restrict incoming TCP connections with the list of acceptable addresses.
- With RMA Manager you may configure, restart and even upgrade agent(s) remotely.

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.

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.

PAPI aims to provide the tool designer and application engineer with a consistent interface and methodology for use of the performance counter hardware found in most major microprocessors.
PAPI enables software engineers to see, in near real time, the relation between software performance and processor events.
The Performance API (PAPI) project specifies a standard application programming interface (API) for accessing hardware performance counters available on most modern microprocessors.
These counters exist as a small set of registers that count Events, occurrences of specific signals related to the processors function. Monitoring these events facilitates correlation between the structure of source/object code and the efficiency of the mapping of that code to the underlying architecture.
This correlation has a variety of uses in performance analysis including hand tuning, compiler optimization, debugging, benchmarking, monitoring and performance modeling. In addition, it is hoped that this information will prove useful in the development of new compilation technology as well as in steering architectural development towards alleviating commonly occurring bottlenecks in high performance computing.
PAPI provides two interfaces to the underlying counter hardware; a simple, high level interface for the acquisition of simple measurements and a fully programmable, low level interface directed towards users with more sophisticated needs.
The low level PAPI interface deals with hardware events in groups called EventSets. EventSets reflect how the counters are most frequently used, such as taking simultaneous measurements of different hardware events and relating them to one another.
For example, relating cycles to memory references or flops to level 1 cache misses can indicate poor locality and memory management. In addition, EventSets allow a highly efficient implementation which translates to more detailed and accurate measurements.
EventSets are fully programmable and have features such as guaranteed thread safety, writing of counter values, multiplexing and notification on threshold crossing, as well as processor specific features. The high level interface simply provides the ability to start, stop and read specific events, one at a time.
PAPI provides portability across different platforms. It uses the same routines with similar argument lists to control and access the counters for every architecture. As part of PAPI, we have predefined a set of events that we feel represents the lowest common denominator of every good counter implementation.
Our intent is that the same source code will count similar and possibly comparable events when run on different platforms. If the programmer chooses to use this set of standardized events, then the source code need not be changed and only a fresh compilation and link is necessary. However, should the developer wish to access machine specific events, the low level API provides access to all available events and counting modes.
If an event or feature does not exist on the current platform, PAPI returns an appropriate error code. This significantly reduces the porting effort of code using PAPI because the semantics of each call to PAPI remains the same, just the argument lists need updating. In addition to the standard set, each PAPI implementation supports all native events through the ability to directly accept platform specific counter numbers. Definitions for most, if not all of these, are included as conditional macros in the header file. In this way, PAPI avoids having inefficient code to translate all events for all platforms into a uniform representation and back again.
This translation is only done for the relatively few events defined in the standardized set. Some processors like those in the POWER series have counter groups. They enable access to specific groups of counters, instead of individual events. This presents a serious portability problem, thus PAPI abstracts hardware counters from their groups with a packed naming scheme. Each counter control value or event is made up of the counter group number and the number of the specific counter in that group.
PAPI can be divided into two layers of software. The upper layer consists of the API and machine independent support functions. The lower layer defines and exports a machine independent interface to machine dependent functions and data structures. These functions access the substrate, which may consist of the operating system, a kernel extension or assembly functions to directly access the processors registers.
PAPI tries to use the most efficient and flexible of the three, depending on what is available. Naturally, the functionality of the upper layers heavily depends on that provided by the substrate. In cases where the substrates do not provide highly desirable features, PAPI attempts to emulate them as described below.
PAPI makes sure the underlying operating system or library guards against overflow of counter values.
Each counter can potentially be incremented multiple times in a single clock cycle. This combined with increasing clock speeds and the small precision of some of the physical counters means that overflow is likely to occur.
One of the more advanced features of PAPI is to provide a portable implementation of asynchronous notification when counters exceed a user specified value.
This functionality provides the basis for PAPIs SVR4 compatible profiling calls, that generate an accurate histogram of performance interrupts based on hardware metrics, not on time. Such functionality provides the basis for all line level performance analysis software, from the antiquated days of AT&Ts prof to SGIs SpeedShop. Thus for any architecture with even the most rudimentary access to hardware performance counters, PAPI provides the foundation for a truly portable, source level, performance analysis tool based on real processor statistics.
Enhancements:
- The API was extended to decouple abstraction layers from hardware support and to provide initial support for different types of performance counters.

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.

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.

Monitoring API project is a multi-user programming interface designed to simplify the development of network monitoring software and allows users to express their monitoring needs in a device-independent way.
The main abstraction provided by MAPI is the network flow. Although flows have been used before in network monitoring systems, MAPI gives flows a first-class status. Applications that uses MAPI can specify what flows or flow statistics they are interested in by applying functions to flows.
A MAPI function can be a BPF filter, string search, packet counter or more advanced like a NetFlow generator. These function will automatically run in hardware if there is support for it on the hardware being used.
MAPI currently supports the following hardware:
- Normal NICs through libpcap
- DAG cards without co-processor
- SCAMPI adapter
Enhancements:
- This release includes support for distributed monitoring, several new MAPI functions, demo applications, and a lot of bugfixes.