Free entryway benches software for linux

The Open CORBA Benchmarking Suite measures several basic performance aspects of various CORBA brokers.
The suite produces an XML output that can be submitted to a searchable database of broker performance data and browsed in a graphical form. The suite is portable to a number of platforms and brokers.
For C++ brokers
Enter the "C++" directory. Then enter the subdirectory of that directory that corresponds to the broker of your choice. Check the README file there for further instructions, usually you will use "make" to compile the benchmark.
For Java brokers
Enter the "Java" and then the "build" directory. Then enter the subdirectory of that directory that corresponds to the broker of your choice. Check the README file there for further instructions, usually you will use "ant" to compile the benchmark "ant run" to execute the benchmark.
Understanding results
The results do not get printed until the benchmark is finished, which can take from 2 to 4 hours depending on the platform. The best way to view the results is to capture them to a file and view them graphically at http://nenya.ms.mff.cuni.cz/~bench.
Enhancements:
- Support for system information on Linux 2.6 kernels.
- Slight extensions to the documentation.
- Support for some recent brokers on Solaris (VisiBroker 6.0, omniORB 4.0.5, JacORB 2.2.1).
- Support for some recent brokers on Linux (omniORB 4.0.5, JacORB 2.2.1, JDK 1.5.0, TAO 1.4.3).

dkftpbench application is an FTP benchmark program inspired by SPECweb99. The result of the benchmark is a number-of-simultaneous-users rating; after running the benchmark properly, you have a good idea how many simultaneous dialup clients a server can support. The target bandwidth per client is set at 28.8 kilobits/second to model dialup users; this is important for servers on the real Internet, which often serve thousands of clients on only 10 MBits/sec of bandwidth.
The final result of the benchmark is "the number of simultaneous 28.8 kilobits/second dialup users". To estimate this number, the benchmark starts up a new simulated user as soon as the last one has finished connecting. It stops increasing the number of users when one fails to connect, fails to maintain the desired bandwidth, or the limit specified by the -n option is reached. It runs the simulated users until the amount of time specified by the -t option has elapsed since the last simulated user birth or death; the final score is the number of users still alive at the end.
Main features:
- Compiles and runs on Linux, FreeBSD, and Solaris (or did, last I tried)
- fetches many files in parallel
- waits for each connect to finish (and then a bit) before starting next one; slows down to < 1 connect/second when it reaches 75% of desired number of users. This spreads out user activity more evenly.
- checks bandwidth continuously during each file fetch, stops adding users if any fetch too slow
- throttles each fetch to use only the specified bandwidth
- search for the max number of supported users
- Displays verbose error message when any user fails
- Aborts if it detects the client system running out of resources
- Aborts if connecting to the server takes > 5 seconds
- Aborts if it takes longer than 5 seconds to get first packet of a file
- Uses new Poller class for scalability; you can specify which Poller to use on the commandline
- Supports slow datarates (before, it only handles rates above 80kbits/sec on some systems)
- Lets you set how picky it is about datarates (before, its must be faster than threshold was fixed at 3/4 the target bandwidth)
- Supports alternative readiness notification methods like O_ASYNC and O_ONESIGFD
- Provided both as a standalone executable, and as a Corba object. (Thanks to http://corbaconf.kiev.ua/ for the Corba autoconf macros.
- Switches to BINARY mode after login. (The client API lets you choose; edit robouser.cc to skip the START_TYPE state if you want to use ASCII.)
Example:
After unpacking the sources, configure them for your system with the command
./configure
This will generate Makefile from Makefile.in.
To make sure the sources arrived intact and work properly on your system, type
make check
It will build all unit tests, and fail if any unit test fails. You must be connected to the Internet, as this will try to download a file from ftp.uu.net.
To build the system tuning tool dklimits, type
make dklimits
Run it on both the client and the server machine; make sure that the number of files it can open is about three times the desired number of users, and that the number of ports it can bind is higher than the desired number of users. You should not be running X Windows or any other programs on the client and server machines when running the benchmark.
To build the benchmark, type
make
This produces the executable dkftpbench, the tuning program dklimits, and a bunch of unit tests (executables with names ending in _test) that you can ignore for now.
Heres a simple use of dkftpbench:
./dkftpbench -n1 -hftp.uu.net -t15 -v
This tells bench to simulate one user fetching the default file from ftp.uu.net repeatedly, and stop after fifteen seconds. The program produces this output:
Option values:
-hftp.uu.net host name of ftp server
-P21 port number of ftp server
-n1 number of users
-t15 length of run (in seconds)
-b3600 desired bandwidth (in bytes per second)
-uanonymous user name
-probouser@ user password
-fusenet/rec.juggling/juggling.FAQ.Z file to fetch
-m1500 bytes per packet
-v1 verbosity
1 users
User0: fetching 22708 bytes took 6.530000 seconds, 3477 bytes per second
User0: fetching 22708 bytes took 6.530000 seconds, 3477 bytes per second
Test over. 1 users left standing.

OpticalRayTracer is a free Linux utility that analyzes systems of lenses, it is Xwindows GUI-based.

It uses optical principles and a virtual optical bench to predict the behavior of many kinds of ordinary and exotic lens types. OpticalRayTracer includes an advanced, easy-to-use interface that allows the user to rearrange the optical configuration by simply dragging lenses around using the mouse.

OpticalRayTracer fully analyzes lens optical properties, incuding refraction and dispersion. The dispersion display uses color-coded light beams, as shown above, to simplify interpretation of the results.

Educators take note: OpticalRayTracer has significant educational potential in the teaching of basic optical principles, and it has some entertaining and game-like behaviors to hold the students attention.

OpticalRayTracer includes a detailed tutorial/help file to assist the user in getting started in this interesting activity.

Installation:

Put it in any convenient location.
$ tar -xjf raytracer.tar.bz2
$ cd raytracer.dist
$ ./auto_install.sh
If you dont want the automatic installation or you want to fine-tune the process, instead of running "auto_install.sh", after the unpacking step above, do this:
$ make -f Makefile.cvs dist
$ ./configure
$ make
$ sudo make install
Obviously you may want to modify some of these steps to suit your platform.

OpenLink ODBC Bench is an open-source ODBC Benchmarking tool providing real-time comparative benchmarking for ODBC Drivers, Database Engines, and Operating Systems combinations.

The Benchmarks in this application are loosely based on the TPC-A and TPC-C standard benchmarks, with modifications to specifically test the performance of an ODBC Driver and/or Database Engine in a client/server environment.

The benchmark results can be automatically stored to an ODBC Datasource or XML file for further analysis and comparisons to be made.

ODBC-Bench is licensed under the terms of the GNU General Public License version 2.

FunkLoad project is a functional and load web tester, written in Python, whose main use cases are:
- Functional testing of web projects, and thus regression testing as well.
- Performance testing: by loading the web application and monitoring your servers it helps you to pinpoint bottlenecks, giving a detailed report of performance measurement.
- Load testing tool to expose bugs that do not surface in cursory testing, like volume testing or longevity testing.
- Stress testing tool to overwhelm the web application resources and test the application recoverability.
- Writing web agents by scripting any web repetitive task, like checking if a site is alive.
Main features:
- Functional test are pure Python scripts using the pyUnit framework like normal unit test. Python enable complex scenarios to handle real world applications.
- Truly emulates a web browser (single-threaded) using Richard Jones webunit:
- basic authentication support
- cookies support
- fetching css, javascript and images
- emulating a browser cache
- file upload and multipart/form-data submission
- https support
- Advanced test runner with many command-line options:
- set the target server url
- display the fetched page in real time in your browser
- debug mode
- green/red color mode
- Turn a functional test into a load test: just by invoking the bench runner you can identify scalability and performance problems.
- Detailed bench reports in ReST or HTML (and PDF via ps2pdf) containing:
- bench configuration
- tests, pages, requests stats and charts.
- 5 slowest requests
- servers cpu usage, load average, memory/swap usage and network traffic charts.
- http error summary list
- Easy test customization using a configuration file or command line options.
- Easy test creation using TestMaker / maxq recorder, so you can use your web browser and produce a FunkLoad test automatically.
- Provides web assertion helpers.
- Provides a funkload.CPSTestCase to ease Zope and Nuxeo CPS testing.
- Easy to install and use, see examples in the demo folder.
Enhancements:
- This release fixes some HTTP encoding and reporting bugs, it also brings support for Python 2.5.

GPIB::hpe3631a is a Perl-GPIB module for HPE3631A power supply.

SYNOPSIS

use GPIB::hpe3631a;

$g->GPIB::hpe3631a->new("name");
$g->output(1); # Outputs on
$g->output(0); # Outputs off
$v = $g->output; # Read output state

$g->track(1); # P25V and N25V track voltage
$g->track(0); # stop tracking
$v = $g->track; # Get tracking state

$t = $g->display;
$g->display("String");

($voltage, $current) = $g->measure(P6V) # P6V, P25V, or N25V
($voltage, $current) = $g->get(P6V) # P6V, P25V, or N25V
$g->set(P6V, $voltage, $current) # P6V, P25V, or N25V

GPIB::hpe3631a privides control for the HPE3631E bench power supply. This module works with both GPIB and serial interface modules as defined by the /etc/pgpib.conf configuration.
$g->display with no parameter returns the contents of the display. $g->display("string") sets the display to the specified string. Note the the device can only display a limited set of characters, probably best to stick with upper case captions.

$g->measure(P6V) returns a two element list representing the voltage and current at the specified output.

$g->get(P6V) returns a two element list of the voltage and current limits for te specified output.
$g->set(P6V, $v, $c) sets the current limits for the specified output.

Text::EP3::Verilog Perl module contains a verilog extension for the EP3 preprocessor.

SYNOPSIS

use Text::EP3;
use Text::EP3::Verilog;

This module is an EP3 extension for the Verilog Hardware Description Language.

The signal directive

@signal key definition Take a list of signals and generate signal lists in the differing formats that Verilog uses. This is accomplished by formatting a list of new defines and then calling the EP3 define method For example, the following command:

@signal KEY a[3:0], b, c[width:0], etc.

will cause the following to be done:

Define KEY with the list as it appears (can be used in further signal defs)
Define KEY{SIG} with the signal list (can be used in port lists)
e.g. replace KEY{SIG} with a[3:0], b, c[width:0]
Define KEY{EVENT} with the reg list (To be used in event lists)
e.g. replace KEY{EVENT} with a or b or c
Define KEY{IN} with the input list (you supply the first input and the trailing ;
e.g. replace KEY{INPUT} with [3:0] a;ninput b;ninput[width:0] c
or ... make the line
input KEY{INPUT}; become ..
input [3:0] a;
input b;
input [width:0] c;
Define KEY{OUT} with the output list (output [] sig).
e.g. like KEY{IN}
Define KEY{INOUT} with the inout list (inout [] sig).
e.g. like KEY{IN}
Define KEY{WIRE} with the wire list (wire [] sig).
e.g. like KEY{IN}
Define KEY{REG} with the reg list (reg [] sig).
e.g. like KEY{IN}
Define KEY{DSP} with the printf list (sig=%0[b|x] depending on width).
e.g. replace KEY{DSP} with a=%0x, b=%0b, c=%0x
This can be used in the $display task
$display("KEY{DSP}",KEY{SIG});

If the module and the test bench default is set up properly, the user needs only enter the signals in one place in the module file. This section can be included conditionally (e.g. @include "file" PORT) in the test bench and the signals can be automatically generated in the correct format in whichever header they are used. This means that a user can produce a module and its test bench by simply filling in the port list, the behavioral code, and the stimulus (which is of course, the real work). All of the signal header crud can be taken care of automagically.

The step directive

@step number [command] The step directive is useful to save verbage in test benches. @step 5 command; generates the following code:

repeat 5 @ (posedge tclk); command;

The posdege can be changed to or negedge (or whatever) using the edgetype directive. The tclk can be changed using the edgename directive.

The edgename directive

@edgename name The edgename directive allows the user to change the name used in the step directive. The default is tclk.

The edgetype directive

@edgetype type The edgetype directive allows the user to change the type used in the step directive. The default is posedge.

The denum directive

@denum key, key, [value], key, ... denum works like the ep3 enum, except that it generates verilog define statements. It also replaces KEY anywhere in the text with `KEY so that the verilog defines will work. (e.g. @denum orange, blue, green will generate:

`define orange 0
`define blue 0
`define green 0
@define orange `orange
@define blue `blue
@define green `green

Signs is a tool for logic synthesis and gate level simulation. Signss project main features include synthesis of RTL-style VHDL circuit descriptions and a dynamic graphical netlist viewer.
Supported formats include VHDL, ISCAS, and limited support for BLIF, Verilog, and EDIF netlists. Various true value and fault simulators and a combinational ATPG are included for circuit testing.
Aside from GUI mode, Signs has a pure command line mode and is fully scriptable in JavaScript and Ruby.
Main features:
- Written in Java, therefore platform-independent
- Aims to be VHDL93 compliant, at the moment a VHDL Subset is supported
- (Limited) support for non-synthesizable VHDL code, useful for testbenches
- Synthesis of RTL-style sequential VHDL process descriptions according to IEEE Std 1076.6
- Dynamic graphical netlist viewer supporting annotations (signal/gate names, signal values provided by simulators, faults)
- VHDL netlist output to file
- Input and output of netlists in ISCAS benchmark format
- Gate level true value simulators: event-based (any circuit), bit-parallel (combinational circuits only)
- Fault simulators: PPSFP, simple single faultsim
- Input and output of pattern lists in WGL format
- ATPG for combinational circuits: Implication-Graph based, PODEM
- Limited support for Verilog and EDIF netlists
- Fully scriptable in Rhino: JavaScript for Java and JRuby
- Pure command-line mode available besides GUI mode
- Integrated environment including source code and netlist structure tree views, build system, compilers and editors with syntax highlighting
Enhancements:
- While the release focus is clearly on bugfixes, there are also some feature improvements, such as enhanced test bench support and improved netlist and simulator views.
- The VHDL compiler has support for subprograms now and elaboration of big designs is much faster because of improved context handling.
- Internally, the intermediate representation layer was cleaned up, so intermediate objects form a proper tree now.