Free freenas performance 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.

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.

Now theres Java performance on Linux thats as fast as on Windows! IBM developerWorks has released IBMs latest Java port for Linux, the Java 1.1.8 Developer Kit for Linux. This new version, available for free, is a stable, high-performance implementation of Java on Linux.

The Bioinformatics Benchmark System is an attempt to build a reasonable testing framework, tests, and data, to enable end users and vendors to probe the performance of their systems.

What we are trying to do is to create a framework for testing, and a core set of tests that all may download and use to probe specific elements of systems performance.

Moreover, the source to these tests are available under GPL, and are hosted on Bioinformatics.org and Scalable Informatics LLC The idea is to enable end users, consumers, systems developers, and others to easily build and use meaningful tests for measurement and tuning reasons.

Joe Landman from Scalable Informatics LLC conceived the idea and wrote the original codes. We are looking for additional benchmark code suggestions, tests, data sets, etc.

Current baseline tests are several NCBI BLAST runs, several HMMer runs, and a variety of others. We plan to include ClustalW, X!Tandem, various chemistry, dynamics, and related tests, as well as several others.

Tests such as LINPACK or HPL simply do not provide meaningful performance indicators or predictive models for high performance informatics. Unfortunately, nor do a number of more recent and focused tests.

This is a problem as LINPACK and HPL specifically test the performance on various matrix operations, where you have effectively regular memory access patterns, and specific mathematical operations.

These codes are most useful for comparison to codes with heavy floating point operations, and interleaved memory traffic. These codes were not designed for comprehensive systems benchmarking, where disk I/O, memory latency, and other factors all contribute to the performance issues.

The best tests are the ones that are most similar to the codes you will run on the machine. The tests themselves should be reasonable approximations to a real execution of your code, using real data. You may need to pare it back in order to get realistic run times.

You should have a reasonable subset of data sizes. A single test does not tell you how your system scales, and one of the reasons for the existance of this test is specifically to allow you to test the performance while you increase various aspects of the workload.

You rarely get a quiescent system in a cluster, so we would recommend that you try to run in as realistic an operating environment as possible. A baseline in a quiescent system is fine, but it may set your expectations unreasonably.
top

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.

YAZ Proxy application is highly configurable and can be used in a number of different applications, ranging from debugging Z39.50-based applications and protecting overworked servers, to improving the performance of stateless WWW/Z39.50 gateways.
Main features:
- Configurable logging
- SRU/SRW server function, to allow any Z39.50 server to also support the ZiNG protocols
- Load balancing across multiple backend servers
- Session-sharing and pre-initialization to improve performance in servers with expensive session initialization
- Configurable request filtering, to keep bad requests from reaching the server
- XML support -- MARC records can be converted to MARCXML, and XSLT-transformations allow the proxy to support arbitrary retrieval schemas in XML
- Load governor function limits requests from aggressive batch-mode clients
- Efficient multiplexing software enables small memory footprint and very high performance
NOTE: The YAZ Proxy, a complete application, is available under the GPL license. Other licensing terms are available to commercial vendors upon request.