Free extreme performance software for linux

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.

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.

Test::Extreme is a perlish unit testing framework.

SYNOPSIS

# In ModuleOne.pm combine unit tests with code

package ModuleOne;
use Test::Extreme;
sub foo { return 23 };
sub test_foo { assert_equals foo, 23 }

# at the end of the module

run_tests ModuleOne if $0 =~ /ModuleOne.pm$/;

# To run the tests in this module on the command line type

perl ModuleOne.pm

# If you have tests in several modules (say in ModuleOne.pm,
# ModuleTwo.pm and ModuleThree.pm, create test.pl containing
# precisely the following:

use ModuleOne;
use ModuleTwo;
use ModuleThree;

run_tests ModuleOne, ModuleTwo, ModuleThree,

# Then run these tests on the command line with

perl test.pl

# If you prefer to get Perls classic "ok/not ok" output use
# replace run_tests with run_tests_as_script in all of the
# above

# Also take a look at Test/Extreme.pm which includes its own
# unit tests for how to instrument a module with unit tests

Test::Extreme is a perlish port of the xUnit testing
framework. It is in the spirit of JUnit, the unit testing
framework for Java, by Kent Beck and Erich Gamma. Instead of
porting the implementation of JUnit we have ported its spirit
to Perl.

The target market for this module is perlish people
everywhere who value laziness above all else.

Test::Extreme is especially written so that it can be easily
and concisely used from Perl programs without turning them
into Java and without inducing object-oriented nightmares in
innocent Perl programmers. It has a shallow learning curve.
The goal is to adopt the unit testing idea minus the OO
cruft, and to make the world a better place by promoting the
virtues of laziness, impatience and hubris.

You test a given unit (a script, a module, whatever) by using
Test::Extreme, which exports the following routines into your
namespace:

assert $x - $x is true
assert_true $x - $x is true
assert_false $x - $x is not true
assert_passed - the last eval did not die ($@ eq "")
assert_failed - the last eval caused a die ($@ ne "")
assert_some $x - $x is true
assert_none - $x is false
assert_equals $x, $y - recursively tests arrayrefs, hashrefs
and strings to ensure they have the same
contents
assert_contains $string, $list
- $list contains $string assert_subset
$element_list, $list - $element_list is
a subset of $list (both are arrayrefs)
assert_is_array $x - $x is an arrayref
assert_is_hash $x - $x is a hashref
assert_is_string $x - $x is a scalar
assert_size N, $list - the arrayref contains N elements
assert_keys [k1, k2], $hash
- $hash contains k1, k2 as keys

run_tests_as_script - run all tests in package main and emit
Perls classic "ok/not ok" style output

run_tests_as_script NS1, NS2, ...
- run all tests in package main, NS1,
NS2, and so on and emit Perls classic
"ok/not ok" style output

run_tests - run all tests in package main

run_tests NS1, NS2, ...
- run all tests in package main, NS1,
NS2, and so on

For an example on how to use these assert take a look at
Test/Extreme.pm which includes it own unit tests and
illustrates different ways of using these asserts.

The function run_tests finds all functions that start with
the word test (preceded by zero or more underscores) and runs
them one at a time. It looks in the main namespace by
default and also looks in any namespaces passed to it as
arguments.

Running the tests generates a status line (a "." for every
successful test run, or an "F" for any failed test run), a
summary result line ("OK" or "FAILURES!!!") and zero or more
lines containing detailed error messages for any failed
tests.

To get Perls classic "ok/not ok" style output (which is
useful for writing test scripts) use run_tests_as_script
instead of run_tests.

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.

EnterTrack project is a Web-based artifact tracking/management system.

EnterTrack provides large organizations with complete tracking of artifacts (artifacts can be problems, bugs, requests, projects, etc.), group collaboration for artifact management, and status reports for high-level performance metrics.

onesixtyone is an efficient SNMP scanner which utilizes a sweep technique to achieve extreme performance. The SNMP protocol is a stateless, datagram oriented protocol. An SNMP scanner is a program that sends SNMP requests to multiple IP addresses, trying different community strings and waiting for a reply. Unfortunately SNMP servers dont respond to requests with invalid community strings and the underlying UDP protocol does not reliably report closed UDP ports. This means that no response from the probed IP address can mean either of the following:
machine unreachable
SNMP server not running
invalid community string
the response datagram has not yet arrived
The approach taken by most SNMP scanners is to send the request, wait for n seconds and assume that the community string is invalid. If only 1 of every hundred scanned IP addresses responds to the SNMP request, the scanner will spend 99*n seconds waiting for replies that will never come.
Thats why traditional SNMP scanners are very inefficient.
onesixtyone takes a different approach to SNMP scanning. It takes advantage of the fact that SNMP is a connectionless protocol and sends all SNMP requests as fast as it can. Then the scanner waits for responses to come back and logs them, in a fashion similar to Nmap ping sweeps. By default onesixtyone waits for 10 milliseconds between sending packets, which is adequate for 100Mbs switched networks. The user can adjust this value via the -w command line option. If set to 0, the scanner will send packets as fast as the kernel would accept them, which may lead to packet drop.
Running onesixtyone on a class B network (switched 100Mbs with 1Gbs backbone) with -w 10 gives us a performance of 3 seconds per class C, with no dropped packets. All 65536 IP addresses were scanned in less than 13 minutes.
onesixtyone sends a request for the system.sysDescr.0 value, which is present on almost all SNMP enabled devices. This returned value gives us a description of the system software running on the device. Here is an excert of a log file:
192.168.120.92 [1234] HP ETHERNET MULTI-ENVIRONMENT,ROM A.05.03,JETDIRECT,JD24,EEPROM A.05.05
130.160.108.146 [public] Hardware: x86 Family 15 Model 0 Stepping 10 AT/AT
COMPATIBLE - Software: Windows 2000 Version 5.0 (Build 2195 Uniprocessor Free)
192.168.112.64 [public] Power Macintosh, hardware type 406; MacOS 9.0; OpenTransport 2.5.2
192.168.104.254 [public] Novell NetWare 4.11 August 22, 1996
192.168.112.83 [public] Macintosh Quadra 650, System Software 7.1
192.168.244.210 [public] RICOH Aficio 850 / RICOH Network Printer D model
192.168.240.39 [public] Cisco Systems WS-C5000
192.168.244.103 [public] HPJ3210A AdvanceStack 10BT Switching Hub Management Module, ROM A.01.02, EEPROM A.01.01, HW A.01.00
Enhancements:
- fixed version number and added a Makefile

MeDs Movie Manager is a simple to use, yet customizable, movie manager. MeDs Movie Manager project gets the movies info from IMDb, and episode info from tv.com.
Main features:
- Unlimited size movie list
- Add, Edit, Delete database functions
- Episode functionality for series
- Quick movie filter
- Advanced search options
- List functionality
- Multi-add function (Search directories for files)
- Obtain AVI / OGM / MPEG and DVD (ifo) file info
- Automatic download of movie info from IMDb (Proxy support)
- Automatic download of episode info from tv.com (Proxy support)
- Import function (3 modes - Simple text, excel and extreme movie manager database (Tested with v4.5)
- Export to HTML (2 modes - full and simple)
- Customizable movie additional info
- Customizable database queries for statistics
- GIF, PNG and JPG cover support
- Changeable layout (Look And Feels)