high performance
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 2309
High Performance Linpack 1.0a
High Performance Linpack is a highly parallel, high performance benchmarking tool. more>>
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.
<<lessThe 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.
Download (0.50MB)
Added: 2005-04-11 License: BSD License Price:
1682 downloads
Felix Programming Language 1.1.1
Felix Programming Language is a high performance, statically typed scripting language. more>>
Felix is an advanced Algol like procedural programming language with a strong functional subsystem. It features ML style typing, first class functions, pattern matching, garabge collection, polymorphism, and has built in support for high performance microthreading, regular expressions and context free parsing.
The system provides a scripting harness so the language can be used like other scripting languages, but underneath it generates native code to obtain high performance.
A key feature of the system is that it uses the C++ object model, and provides an advanced binding sublanguage to support integration with C++ at both the source and object levels, both for embedding C++ data types and functions into Felix, and for embedding Felix into exitsing C++ architectures.
The Felix compiler is written in Objective Caml, and generates ISO C++ which should compile on any platform.
<<lessThe system provides a scripting harness so the language can be used like other scripting languages, but underneath it generates native code to obtain high performance.
A key feature of the system is that it uses the C++ object model, and provides an advanced binding sublanguage to support integration with C++ at both the source and object levels, both for embedding C++ data types and functions into Felix, and for embedding Felix into exitsing C++ architectures.
The Felix compiler is written in Objective Caml, and generates ISO C++ which should compile on any platform.
Download (1.2MB)
Added: 2005-09-27 License: Freely Distributable Price:
1487 downloads
Bioinformatics Benchmark System 3
Bioinformatics Benchmark System is a bioinformatics benchmark system for platform performance measurement. more>>
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
<<lessWhat 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
Download (5.0MB)
Added: 2005-08-12 License: GPL (GNU General Public License) Price:
1533 downloads
Performance Application Programming Interface 3.9.0
Performance Application Programming Interface is an API for a CPU performance counter. more>>
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.
<<lessPAPI 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.
Download (2.9MB)
Added: 2007-04-23 License: BSD License Price:
925 downloads
libgnomecanvas 2.19.2
libgnomecanvas package contains the GNOME canvas libraries. more>>
libgnomecanvas package contains the GNOME canvas libraries. GNOME canvas is an engine for structured graphics that offers a rich imaging model, high performance rendering, and a powerful, high-level API.
It offers a choice of two rendering back-ends, one based on Xlib for extremely fast display, and another based on Libart, a sophisticated, antialiased, alpha-compositing engine.
Applications have a choice between the Xlib imaging model or a superset of the PostScript imaging model, depending on the level of graphic sophistication required.
<<lessIt offers a choice of two rendering back-ends, one based on Xlib for extremely fast display, and another based on Libart, a sophisticated, antialiased, alpha-compositing engine.
Applications have a choice between the Xlib imaging model or a superset of the PostScript imaging model, depending on the level of graphic sophistication required.
Download (0.75MB)
Added: 2007-08-15 License: GPL (GNU General Public License) Price:
800 downloads
Developer Kit for Linux 1.18
A stable, high-performance implementation of Java on Linux. more>>
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.
<<less Download (10000k)
Added: 2009-04-25 License: Freeware Price: $0.00
181 downloads
high-resolution-timer 1.0
high-resolution-timer is a library with Java and C++ wrappers to implement high resolution timers. more>>
high-resolution-timer is a library with Java and C++ wrappers to implement high . These timers can be used, for example, to count the ticks when doing performance analysis.
high-resolution-timer exploits the system dependent timers/clocks and provides a timer-like interface to the same. The attached file has build scripts for Linux and Solaris. There is also a Java wrapper over the library, which uses JNI to use the timer interfaces.
Enhancements:
- The library is a basic approach to design a base for the performance library.
- It has not yet taken into consideration the details of library preloads, etc.
- At load time, the library initializes itself with the timer with the least avg resolution.
- At unload time, the library cleans up by freeing any allocated memory.
- The library provides a getErrorMessage function to let the user know the detailed report of the error.
- The library exports start / stop JNI wrappers .
<<lesshigh-resolution-timer exploits the system dependent timers/clocks and provides a timer-like interface to the same. The attached file has build scripts for Linux and Solaris. There is also a Java wrapper over the library, which uses JNI to use the timer interfaces.
Enhancements:
- The library is a basic approach to design a base for the performance library.
- It has not yet taken into consideration the details of library preloads, etc.
- At load time, the library initializes itself with the timer with the least avg resolution.
- At unload time, the library cleans up by freeing any allocated memory.
- The library provides a getErrorMessage function to let the user know the detailed report of the error.
- The library exports start / stop JNI wrappers .
Download (0.024MB)
Added: 2007-05-07 License: LGPL (GNU Lesser General Public License) Price:
905 downloads
High Visibility Calculator 0.0.9
High Visibility Calculator is a high visibility calculator for people with disabilities. more>>
High Visibility Calculator is a high visibility calculator for people with disabilities.
Large buttons with bold text are easy to push for people with motor control or vision problems.
<<lessLarge buttons with bold text are easy to push for people with motor control or vision problems.
Download (0.014MB)
Added: 2006-11-06 License: GPL (GNU General Public License) Price:
1083 downloads
XtekRouter Free 1.0
XtekRouter Free is the perfect solution to create a linux router. more>> XtekRouter Free is the perfect solution to create a linux router for your home or small office network.
* Extremeply Reliable
* High-Performance
* Easy to Install
* Multi-user
* Easy Web Interface
You can:
* Control your network using XtekRouter web interface
* Add/Remove access accounts
* Add/Remove network clients
* Port forward
* Traceroute
* Ping
* Export database
This version is limited to 10 clients.<<less
Download (10.6KB)
Added: 2009-04-03 License: Freeware Price: Free
203 downloads
Oracle::Sqlldr 0.13
Oracle::Sqlldr is a Perl wrapper around Oracles sqlldr utility. more>>
Oracle::Sqlldr is a Perl wrapper around Oracles sqlldr utility.
SYNOPSIS
use Oracle::Sqlldr;
my $sqlldr = Oracle::Sqlldr->new(); # get new sqlldr object
Oracle::Sqlldr is an object-oriented class that provides a convenient Perl wrapper around Oracles sqlldr utility.
SQL*Loader (sqlldr) is the utility to use for high performance data loading from a text file into a an Oracle database.
Version restrictions:
- No WIN32 support
- No fixed format record support
- Assumes table owner and user to load data as are the same
- No support for parameter file
<<lessSYNOPSIS
use Oracle::Sqlldr;
my $sqlldr = Oracle::Sqlldr->new(); # get new sqlldr object
Oracle::Sqlldr is an object-oriented class that provides a convenient Perl wrapper around Oracles sqlldr utility.
SQL*Loader (sqlldr) is the utility to use for high performance data loading from a text file into a an Oracle database.
Version restrictions:
- No WIN32 support
- No fixed format record support
- Assumes table owner and user to load data as are the same
- No support for parameter file
Download (0.007MB)
Added: 2006-06-30 License: Perl Artistic License Price:
1231 downloads
Los Alamos Message Passing Interface 1.5.16 RC1
Los Alamos Message Passing Interface is an implementation of the Message Passing Interface (MPI). more>>
Los Alamos Message Passing Interface is an implementation of the Message Passing Interface (MPI) motivated by a growing need for fault tolerance at the software level in large high-performance computing (HPC) systems.
This need is caused by the vast number of components present in modern HPC systems, particularly clusters. The individual components -- processors, memory modules, network interface cards (NICs), etc. -- are typically manufactured to tolerances adequate for small or desktop systems.
When aggregated into a large HPC system, however, system-wide error rates may be too great to successfully complete a long application run. For example, a network device may have an error rate which is perfectly acceptable for a desktop system, but not in a cluster of thousands of nodes, which must run error free for many hours or even days to complete a scientific calculation.
LA-MPI has two primary goals: network fault tolerance and high performance.
Network fault tolerance is acheived by implementing a highly efficient checksum/retransmission protocol. The integrity of delivered data is (optionally) verified at the user-level using a checksum or CRC. Data that is corrupt (or never delivered) is retransmitted.
As for high performance, LA-MPIs lightweight checksum/retransmission protocol allows us to achieve low latency messaging. Furthermore, the flexible approach taken to the use of redundant data paths in a network-device-rich system leads to high network bandwidth since different messages and/or message-fragments can be sent in parallel along different paths. Also, since LA-MPI is developed for use on the the large systems at Los Alamos National Laboratory we have verified that LA-MPI is scalable to over 3,500 processes.
An alternative solution to the network fault tolerance problem is to use the TCP/IP protocol. We believe, however, that this protocol -- developed to handle unreliable, inhomogeneous and oversubscribed networks -- performs poorly and is overly complex for HPC system messaging, and that LA-MPIs lightweight checksum/retransmission protocol is a more appropriate choice.
Main features:
- Standard compliant (MPI version 1.2 integrated with ROMIO for MPI-IO)
- Highly portable
- Open source (LGPL)
- Thread safe
- Optimized for SMP systems, including NUMA architectures
- Network fault tolerant (data integrity checked at user level)
- Message-fragment striping across multiple network devices
Enhancements:
- Namespace conflicts have been fixed.
- Error detection and handling of fragments has been improved.
- Bugs in memory barriers and spinlocks for x86 and x86_64 architectures have been fixed.
- Profiling and backtracing support have been added.
- Asynchronous I/O has been disabled by default as a workaround for problems with some filesystems.
- Minor timeout bugs have been fixed.
<<lessThis need is caused by the vast number of components present in modern HPC systems, particularly clusters. The individual components -- processors, memory modules, network interface cards (NICs), etc. -- are typically manufactured to tolerances adequate for small or desktop systems.
When aggregated into a large HPC system, however, system-wide error rates may be too great to successfully complete a long application run. For example, a network device may have an error rate which is perfectly acceptable for a desktop system, but not in a cluster of thousands of nodes, which must run error free for many hours or even days to complete a scientific calculation.
LA-MPI has two primary goals: network fault tolerance and high performance.
Network fault tolerance is acheived by implementing a highly efficient checksum/retransmission protocol. The integrity of delivered data is (optionally) verified at the user-level using a checksum or CRC. Data that is corrupt (or never delivered) is retransmitted.
As for high performance, LA-MPIs lightweight checksum/retransmission protocol allows us to achieve low latency messaging. Furthermore, the flexible approach taken to the use of redundant data paths in a network-device-rich system leads to high network bandwidth since different messages and/or message-fragments can be sent in parallel along different paths. Also, since LA-MPI is developed for use on the the large systems at Los Alamos National Laboratory we have verified that LA-MPI is scalable to over 3,500 processes.
An alternative solution to the network fault tolerance problem is to use the TCP/IP protocol. We believe, however, that this protocol -- developed to handle unreliable, inhomogeneous and oversubscribed networks -- performs poorly and is overly complex for HPC system messaging, and that LA-MPIs lightweight checksum/retransmission protocol is a more appropriate choice.
Main features:
- Standard compliant (MPI version 1.2 integrated with ROMIO for MPI-IO)
- Highly portable
- Open source (LGPL)
- Thread safe
- Optimized for SMP systems, including NUMA architectures
- Network fault tolerant (data integrity checked at user level)
- Message-fragment striping across multiple network devices
Enhancements:
- Namespace conflicts have been fixed.
- Error detection and handling of fragments has been improved.
- Bugs in memory barriers and spinlocks for x86 and x86_64 architectures have been fixed.
- Profiling and backtracing support have been added.
- Asynchronous I/O has been disabled by default as a workaround for problems with some filesystems.
- Minor timeout bugs have been fixed.
Download (1.3MB)
Added: 2006-08-26 License: LGPL (GNU Lesser General Public License) Price:
1155 downloads
Yoper 3.0 (Blacksand)
Yoper is a high performance operating system which has been carefully optimized for PCs with either i686 or higher processor. more>>
Yoper is a high performance operating system which has been carefully optimized for PCs with either i686 or higher processor types.
The binaries that come with Yoper have been built from scratch using the original sources combined with the some of the best features from other Open Source Linux distributions (distros).
However, Yoper is not like general purpose distros such as Redhat or Mandrake. It is a high performance Desktop OS. It is compact.
Yoper Linux resides on 1 cd-rom. In fact, Yoper is also one of the most standards-based environments in the Linux community! You will find hardware performance as good or better than that of any commercial OS.
Enhancements:
- The Yoper team is proud to announce the long-awaited stable release of Yoper Linux 3.0, codename Titanium. This release ships with kernel 2.6.21.1, including the Con Kolivas patch set and SD scheduler, X.Org 7.2, KDE 3.5.7, KOffice 1.6.3, Firefox 2.0.0.4 and a vast range of other cutting-edge desktop packages. This release will be followed by a bug-fix release in about 4 weeks time. It will only contain simple application updates and bug fixes.
<<lessThe binaries that come with Yoper have been built from scratch using the original sources combined with the some of the best features from other Open Source Linux distributions (distros).
However, Yoper is not like general purpose distros such as Redhat or Mandrake. It is a high performance Desktop OS. It is compact.
Yoper Linux resides on 1 cd-rom. In fact, Yoper is also one of the most standards-based environments in the Linux community! You will find hardware performance as good or better than that of any commercial OS.
Enhancements:
- The Yoper team is proud to announce the long-awaited stable release of Yoper Linux 3.0, codename Titanium. This release ships with kernel 2.6.21.1, including the Con Kolivas patch set and SD scheduler, X.Org 7.2, KDE 3.5.7, KOffice 1.6.3, Firefox 2.0.0.4 and a vast range of other cutting-edge desktop packages. This release will be followed by a bug-fix release in about 4 weeks time. It will only contain simple application updates and bug fixes.
Download (690MB)
Added: 2007-06-17 License: GPL (GNU General Public License) Price:
874 downloads
Irrlicht Engine 1.3.1
The Irrlicht Engine is a high performance real-time 3D engine written and usable in C++, and also available for .NET languages. more>>
The Irrlicht Engine is an open source high performance realtime 3D engine written and usable in C++ and also available for .NET languages.
Irrlicht Engine is completely cross-platform, using D3D, OpenGL and its own software renderer, and has all of the state-of-the-art features which can be found in commercial 3d engines.
Weve got a huge active community, and there are lots of projects in development that use the engine.
You can find enhancements for Irrlicht all over the web, like alternative terrain renderers, portal renderers, exporters, world layers, tutorials, editors, language bindings for java, perl, ruby, basic, python, lua, and so on. And best of all: Its completely free.
Main features:
- High performance realtime 3D rendering using Direct3D and OpenGL [more]
- Platform independent. Runs on Windows95, 98, NT, 2000, XP and Linux.[more]
- Huge built-in and extensible material library with vertex and pixel shader support [more].
- Seamless indoor and outdoor mixing through highly customizeable scene mangagment. [more]
- Character animation system with skeletal and morph target animation. [more]
- Particle effects, billboards, light maps, environment mapping, stencil buffer shadows, and lots of other special effects. [more]
- .NET language binding which makes the engine available to all .NET languages like C#, VisualBasic, and Delphi.NET.
- Platform and driver independent fast software renderer included. It features z-buffer, gouraud shading, alpha-blending and transparency, fast 2D drawing.
- Powerful, customizeable and easy to use 2D GUI System with Buttons, Lists, Edit boxes, ..
- 2D drawing functions like alpha blending, color key based blitting, font drawing and mixing 3D with 2D graphics.
- Clean, easy to understand and well documentated API with lots of examples and tutorials.
- Written in pure C++ and totally object orientated.
- Direct import of common mesh file formats: Maya (.obj), 3DStudio (.3ds), COLLADA (.dae), DeleD (.dmf), Milkshape (.ms3d), Quake 3 levels (.bsp), Quake2 models (.md2), Microsoft DirectX (.X)... [more]
- Direct import of Textures: Windows Bitmap (.bmp), Portable Network Graphics (.png), Adobe Photoshop (.psd), JPEG File Interchange Format (.jpg), Truevision Targa (.tga), ZSoft Painbrush (.pcx)... [more]
- Fast and easy collision detection and response.
- Optimized fast 3D math and container template libraries.
- Directly reading from (compressed) archives. (.zip)
- Integrated fast XML parser.
- Unicode support for easy localisation.
- Works with Microsofts VisualStudio6.0?, VisualStudio.NET 7.0-8.0?, Metrowerks Codewarrior, and Bloodshed Dev-C++ with g++3.2-4.0.
- The engine is open source and totally free. You can debug it, fix bugs and even change things you do not like. And you do not have to publish your changes: The engine is licensed under the zlib licence, not the GPL or the LGPL.
<<lessIrrlicht Engine is completely cross-platform, using D3D, OpenGL and its own software renderer, and has all of the state-of-the-art features which can be found in commercial 3d engines.
Weve got a huge active community, and there are lots of projects in development that use the engine.
You can find enhancements for Irrlicht all over the web, like alternative terrain renderers, portal renderers, exporters, world layers, tutorials, editors, language bindings for java, perl, ruby, basic, python, lua, and so on. And best of all: Its completely free.
Main features:
- High performance realtime 3D rendering using Direct3D and OpenGL [more]
- Platform independent. Runs on Windows95, 98, NT, 2000, XP and Linux.[more]
- Huge built-in and extensible material library with vertex and pixel shader support [more].
- Seamless indoor and outdoor mixing through highly customizeable scene mangagment. [more]
- Character animation system with skeletal and morph target animation. [more]
- Particle effects, billboards, light maps, environment mapping, stencil buffer shadows, and lots of other special effects. [more]
- .NET language binding which makes the engine available to all .NET languages like C#, VisualBasic, and Delphi.NET.
- Platform and driver independent fast software renderer included. It features z-buffer, gouraud shading, alpha-blending and transparency, fast 2D drawing.
- Powerful, customizeable and easy to use 2D GUI System with Buttons, Lists, Edit boxes, ..
- 2D drawing functions like alpha blending, color key based blitting, font drawing and mixing 3D with 2D graphics.
- Clean, easy to understand and well documentated API with lots of examples and tutorials.
- Written in pure C++ and totally object orientated.
- Direct import of common mesh file formats: Maya (.obj), 3DStudio (.3ds), COLLADA (.dae), DeleD (.dmf), Milkshape (.ms3d), Quake 3 levels (.bsp), Quake2 models (.md2), Microsoft DirectX (.X)... [more]
- Direct import of Textures: Windows Bitmap (.bmp), Portable Network Graphics (.png), Adobe Photoshop (.psd), JPEG File Interchange Format (.jpg), Truevision Targa (.tga), ZSoft Painbrush (.pcx)... [more]
- Fast and easy collision detection and response.
- Optimized fast 3D math and container template libraries.
- Directly reading from (compressed) archives. (.zip)
- Integrated fast XML parser.
- Unicode support for easy localisation.
- Works with Microsofts VisualStudio6.0?, VisualStudio.NET 7.0-8.0?, Metrowerks Codewarrior, and Bloodshed Dev-C++ with g++3.2-4.0.
- The engine is open source and totally free. You can debug it, fix bugs and even change things you do not like. And you do not have to publish your changes: The engine is licensed under the zlib licence, not the GPL or the LGPL.
Download (16.4MB)
Added: 2007-06-20 License: GPL (GNU General Public License) Price:
864 downloads
Bauk HTTP server 2.0.5
Bauk HTTP server project is a high-performance Web server. more>>
Bauk HTTP server project is a high-performance Web server. Bauks advanced architecture and unique design provide high performance and many original features, ie. ability to serve unlimited number of Virtual Hosts/simultaneous HTTP connections per single server process without performance loss.
Full installation requires only a single directory of UNIX file system used as a working directory for Bauk executable. Configuration process is simple and performed by adjustment of Bauk configuration script.
Main features:
- Full HTTP/1.1 and CGI/1.1 standard compliance
- HTTP authentication, Basic method, auth script per Virtual Host
- Unlimited number of Virtual Hosts without performance loss
- Virtual Host aliases
- Unlimited number of simultaneous HTTP connections per single Bauk process with no performance loss (Special Edition)
- Persistent (Keep-Alive) connections
- URL Path; define URL and path with type of access; ie. read, write, browse, execute, require HTTP authentication, etc.
- OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE methods of HTTP request defined by HTTP/1.1, configurable per URL Path
- Content negotiation by client language and charset
- Configurable MIME types
- Configurable HTTP headers by MIME type
- Configurable HTML error documents / CGI executables
- Directory browsing; view content of directories with HTML links
- Execution of CGI programs/scripts
- SUID/SGID for CGI execution
- Chroot for CGI execution; chroot CGI to Virtual Hosts home
- 3 security layers for CGI execution: by URL limit to X-only ie. CGI dir; for RX-URL imply X-only for X-able files; impose X-only by file extension ie. CGI executables wrongly placed and no X flag
- Quotas for CGI execution; number of simultaneous CGI processes, execution priority, max execution time (duration), max CPU time, memory, filesize
- Quotas of network traffic in/out per Virtual Host (I/O speed limit)
- Quotas of connections per Virtual Host
- Quotas of connections per client IP number
- Access restriction by IP address; forbid and allow-only
- Access restriction by valid HTTP referrer
- Configurable HTTP-log format and location for Virtual Hosts
- Configurable singleprocess or multiprocess architecture
- Chroot for Bauk server process
- Full configurability; virtually all Bauk features are configurable by simple configuration script adjustment
- Easy configuration by script language; built-in configuration script interpreter with preprocessor, file-inclusion, block and single-line comments, two data types, variables, arithmetic operations and built-in functions
- Easy administration
- Flexibility
VLAJKOS INVISIBLE LICENSE (VIL):
This sofware is protected by VIL and the license states:
Youre welcome to use this software. Remember the rightful author if youre using any parts/unique components of Bauk software.
Enhancements:
- This release includes various feature enhancements
- improved PHP, Perl, Gawk
- Tcl interpreter connectors
- additions to the documentation.
<<lessFull installation requires only a single directory of UNIX file system used as a working directory for Bauk executable. Configuration process is simple and performed by adjustment of Bauk configuration script.
Main features:
- Full HTTP/1.1 and CGI/1.1 standard compliance
- HTTP authentication, Basic method, auth script per Virtual Host
- Unlimited number of Virtual Hosts without performance loss
- Virtual Host aliases
- Unlimited number of simultaneous HTTP connections per single Bauk process with no performance loss (Special Edition)
- Persistent (Keep-Alive) connections
- URL Path; define URL and path with type of access; ie. read, write, browse, execute, require HTTP authentication, etc.
- OPTIONS, GET, HEAD, POST, PUT, DELETE, TRACE methods of HTTP request defined by HTTP/1.1, configurable per URL Path
- Content negotiation by client language and charset
- Configurable MIME types
- Configurable HTTP headers by MIME type
- Configurable HTML error documents / CGI executables
- Directory browsing; view content of directories with HTML links
- Execution of CGI programs/scripts
- SUID/SGID for CGI execution
- Chroot for CGI execution; chroot CGI to Virtual Hosts home
- 3 security layers for CGI execution: by URL limit to X-only ie. CGI dir; for RX-URL imply X-only for X-able files; impose X-only by file extension ie. CGI executables wrongly placed and no X flag
- Quotas for CGI execution; number of simultaneous CGI processes, execution priority, max execution time (duration), max CPU time, memory, filesize
- Quotas of network traffic in/out per Virtual Host (I/O speed limit)
- Quotas of connections per Virtual Host
- Quotas of connections per client IP number
- Access restriction by IP address; forbid and allow-only
- Access restriction by valid HTTP referrer
- Configurable HTTP-log format and location for Virtual Hosts
- Configurable singleprocess or multiprocess architecture
- Chroot for Bauk server process
- Full configurability; virtually all Bauk features are configurable by simple configuration script adjustment
- Easy configuration by script language; built-in configuration script interpreter with preprocessor, file-inclusion, block and single-line comments, two data types, variables, arithmetic operations and built-in functions
- Easy administration
- Flexibility
VLAJKOS INVISIBLE LICENSE (VIL):
This sofware is protected by VIL and the license states:
Youre welcome to use this software. Remember the rightful author if youre using any parts/unique components of Bauk software.
Enhancements:
- This release includes various feature enhancements
- improved PHP, Perl, Gawk
- Tcl interpreter connectors
- additions to the documentation.
Download (0.22MB)
Added: 2007-01-20 License: Other/Proprietary License Price:
1008 downloads
PowerDNS daemon 2.9.21
PowerDNS daemon is an advanced high performance authoritative nameserver. more>>
PowerDNS daemon Nameserver is a advanced, modern and high performance authoritative-only nameserver.
It is written from scratch and conforms to all relevant DNS standards documents. Furthermore, PowerDNS interfaces with almost any database.
The PowerDNS Nameserver utilizes, a flexible backend architecture can access DNS information from any data source. This includes file formats, Bind zone files, relational databases or LDAP directories.
If you have specific needs for your DNS infrastructure then you can use the Backend Developers Kit to write the glue between PowerDNS and your data or logic.
There is one master database that is replicated to two slave databases. The slave databases are read-only and are updated immediately when the master database changes.
For sites that do not yet have an existing database infrastructure we recommend the MySQL database. MySQL is very easy to setup and handles replication well.
If your nameservers are located on different physical networks then you immediately take advantage of the distributed nature of DNS. Questions will be load balanced on your array of servers. If a server is down then one of the other servers is queried.
PowerDNS is by default configured to serve all information directly from a database, which results in unmatched maintainability of your DNS information.
PowerDNS has developed a complete suite of technologies surrounding Internet Naming and email. Internet Naming is at the core of all online activities and is involved in each and every transaction on the net. Email remains the killer application of the Internet.
Enhancements:
- This release fixes many issues, unifies the PowerDNS Recursor and Authoritative DNS infrastructure (reducing code size by 2,000 lines), significantly improves the "BIND" compatibility mode (making real life zone loading up to 30 times faster than the original BIND), addresses many corner cases, reworks the TCP backend for improved stability, and makes 64 bit packages available.
<<lessIt is written from scratch and conforms to all relevant DNS standards documents. Furthermore, PowerDNS interfaces with almost any database.
The PowerDNS Nameserver utilizes, a flexible backend architecture can access DNS information from any data source. This includes file formats, Bind zone files, relational databases or LDAP directories.
If you have specific needs for your DNS infrastructure then you can use the Backend Developers Kit to write the glue between PowerDNS and your data or logic.
There is one master database that is replicated to two slave databases. The slave databases are read-only and are updated immediately when the master database changes.
For sites that do not yet have an existing database infrastructure we recommend the MySQL database. MySQL is very easy to setup and handles replication well.
If your nameservers are located on different physical networks then you immediately take advantage of the distributed nature of DNS. Questions will be load balanced on your array of servers. If a server is down then one of the other servers is queried.
PowerDNS is by default configured to serve all information directly from a database, which results in unmatched maintainability of your DNS information.
PowerDNS has developed a complete suite of technologies surrounding Internet Naming and email. Internet Naming is at the core of all online activities and is involved in each and every transaction on the net. Email remains the killer application of the Internet.
Enhancements:
- This release fixes many issues, unifies the PowerDNS Recursor and Authoritative DNS infrastructure (reducing code size by 2,000 lines), significantly improves the "BIND" compatibility mode (making real life zone loading up to 30 times faster than the original BIND), addresses many corner cases, reworks the TCP backend for improved stability, and makes 64 bit packages available.
Download (2.77MB)
Added: 2007-04-21 License: GPL (GNU General Public License) Price:
916 downloads
Secleted [ 0 ] software to compare
Copyright Notice:
Software piracy is theft, Using crack, password, serial numbers, registration codes, key generators is illegal and prevent future software development. The above high performance search only lists software in full, demo and trial versions for free download. Download links are directly from our mirror sites or publisher sites, torrent files or links from rapidshare.com, yousendit.com or megaupload.com are not allowed
