forked
Sponsored Links
Sponsored Links
Secleted [ 0 ] software to compare
Results 1 - 15 of about 233
fork 1.0
fork allows you to run a number of processes in parallel. more>>
fork allows you to run a number of processes in parallel.
fork is a simple Perl script to run a number of processes in parallel. Use it to spread the load of CPU-intensive jobs over multiple processors, or to parallelise jobs that have to wait for the network, such as downloads and backups.
What is it good for?
Two things, really: for speeding up batch processing by using all the CPUs in your system, and for running tasks in parallel that have external dependancies, such as network resources.
In the first case you can speed things up by a factor of the number of CPUs available; in the second case you can reduce the running time of all tasks to that of the slowest task.
<<lessfork is a simple Perl script to run a number of processes in parallel. Use it to spread the load of CPU-intensive jobs over multiple processors, or to parallelise jobs that have to wait for the network, such as downloads and backups.
What is it good for?
Two things, really: for speeding up batch processing by using all the CPUs in your system, and for running tasks in parallel that have external dependancies, such as network resources.
In the first case you can speed things up by a factor of the number of CPUs available; in the second case you can reduce the running time of all tasks to that of the slowest task.
Download (0.001MB)
Added: 2007-01-20 License: Public Domain Price:
1011 downloads
Proc::Fork 0.3
Proc::Fork is a simple, intuitive interface to the fork() system call. more>>
Proc::Fork is a simple, intuitive interface to the fork() system call.
SYNOPSIS
use Proc::Fork;
child {
# child code goes here.
}
parent {
my $child_pid = shift;
# parent code goes here.
waitpid $child_pid, 0;
}
retry {
my $attempts = shift;
# what to do if if fork() fails:
# return true to try again, false to abort
return if $attempts > 5;
sleep 1, return 1;
}
error {
# Error-handling code goes here
# (fork() failed and the retry block returned false)
};
# Note the semicolon at the end! Necessary in most cases
This module provides an intuitive, Perl-ish way to write forking programs by letting you use blocks to illustrate which code section executes in which fork. The code for the parent, child, retry handler and error handler are grouped together in a "fork block". The clauses may appear in any order, but they must be consecutive (without any other statements in between).
The semicolon after the last clause is mandatory, unless the last clause is at the end of the enclosing block or file.
All four clauses need not be specified. If the retry clause is omitted, only one fork will be attempted. If the error clause is omitted the program will die with a simple message if it cant retry. If the parent or child clause is omitted, the respective (parent or child) process will start execution after the final clause. So if one or the other only has to do some simple action, you need only specify that one. For example:
# spawn off a child process to do some simple processing
child {
exec /bin/ls, -l;
die "Couldnt exec ls: $!n";
};
# Parent will continue execution from here
# ...
If the code in any of the clauses does not die or exit, it will continue execution after the fork block.
<<lessSYNOPSIS
use Proc::Fork;
child {
# child code goes here.
}
parent {
my $child_pid = shift;
# parent code goes here.
waitpid $child_pid, 0;
}
retry {
my $attempts = shift;
# what to do if if fork() fails:
# return true to try again, false to abort
return if $attempts > 5;
sleep 1, return 1;
}
error {
# Error-handling code goes here
# (fork() failed and the retry block returned false)
};
# Note the semicolon at the end! Necessary in most cases
This module provides an intuitive, Perl-ish way to write forking programs by letting you use blocks to illustrate which code section executes in which fork. The code for the parent, child, retry handler and error handler are grouped together in a "fork block". The clauses may appear in any order, but they must be consecutive (without any other statements in between).
The semicolon after the last clause is mandatory, unless the last clause is at the end of the enclosing block or file.
All four clauses need not be specified. If the retry clause is omitted, only one fork will be attempted. If the error clause is omitted the program will die with a simple message if it cant retry. If the parent or child clause is omitted, the respective (parent or child) process will start execution after the final clause. So if one or the other only has to do some simple action, you need only specify that one. For example:
# spawn off a child process to do some simple processing
child {
exec /bin/ls, -l;
die "Couldnt exec ls: $!n";
};
# Parent will continue execution from here
# ...
If the code in any of the clauses does not die or exit, it will continue execution after the fork block.
Download (0.007MB)
Added: 2007-01-22 License: Perl Artistic License Price:
1005 downloads
vkeyd 0.9
vkeyd is a Linux daemon, forked from ikeyd, used to change volumes from keyboard hotkeys outside of X. more>>
vkeyd is a Linux daemon, forked from ikeyd, used to change volumes from keyboard hotkeys outside of X, or if the keyboard has been captured, as happens with SDL applications.
<<less Download (0.090MB)
Added: 2006-07-25 License: GPL (GNU General Public License) Price:
682 downloads
Proc::Forking 1.38
Proc::Forking is a Perl module that provides a set of tool to fork and daemonize. more>>
Proc::Forking is a Perl module that provides a set of tool to fork and daemonize.
SYNOPSIS
#!/usr/bin/perl
use strict;
use Proc::Forking;
use Data::Dumper;
use Time::HiRes qw(usleep); # to allow micro sleep
my $f = Proc::Forking->new();
$SIG{ KILL } = $SIG{ TERM } = $SIG{ INT } = sub { $f->killall_childs;sleep 1; exit },
$f->daemonize(
## uid => 1000,
## gid => 1000,
## home => "/tmp",
pid_file => "/tmp/master.pid"
);
open( STDOUT, ">>/tmp/master.log" );
my $nbr = 0;
my $timemout;
while ( 1 )
{
if ( $nbr < 20 )
{
my $extra = "other parameter";
my ( $status, $pid, $error ) = $f->fork_child(
function => &func,
name => "new_name.##",
args => [ "hello SOMEONE", 3, $extra ],
pid_file => "/tmp/fork.##.pid",
uid => 1000,
gid => 1000,
home => "/tmp",
max_load => 5,
max_mem => 185000000,
expiration => 10,
# expiration_auto => 1,
);
if ( $status == 4 ) # if the load become to high
{
print "Max load reached, do a little napn";
usleep( 100000 );
next;
}
elsif ( $status ) # if another kind of error
{
print "PID=$pidt error=$errorn";
print Dumper( $f->list_names() );
print Dumper( $f->list_pids() );
}
}
$nbr = $f->pid_nbr;
my ( $n, @dp, @dn ) = $f->expirate;
if ( $n )
{
print Dumper( @dp );
}
print "free=n";
usleep( 100000 ); # always a good idea to put a small sleep to allow task swapper to gain some free resources
}
sub func
{
my $ref = shift;
my @args = @$ref;
my ( $data, $time_out, $sockC ) = @args;
$SIG{ USR1 } = sub { open my $log, ">>/tmp/log.s"; print $log "signal USR1 receivedn"; close $log; };
if ( !$time_out )
{
$time_out = 3;
}
open my $FF, ">>/tmp/loglist";
print $FF $$, " start time =", $^T;
close $FF;
for ( 1 .. 4 )
{
open my $fh, ">>/tmp/log";
if ( defined $fh )
{
print $fh "TMOUT = $time_out " . time . " PID=$$ cwd=" . Cwd::cwd() . " name =$0n";
$fh->close;
}
sleep $time_out + rand( 5 );
}
}
<<lessSYNOPSIS
#!/usr/bin/perl
use strict;
use Proc::Forking;
use Data::Dumper;
use Time::HiRes qw(usleep); # to allow micro sleep
my $f = Proc::Forking->new();
$SIG{ KILL } = $SIG{ TERM } = $SIG{ INT } = sub { $f->killall_childs;sleep 1; exit },
$f->daemonize(
## uid => 1000,
## gid => 1000,
## home => "/tmp",
pid_file => "/tmp/master.pid"
);
open( STDOUT, ">>/tmp/master.log" );
my $nbr = 0;
my $timemout;
while ( 1 )
{
if ( $nbr < 20 )
{
my $extra = "other parameter";
my ( $status, $pid, $error ) = $f->fork_child(
function => &func,
name => "new_name.##",
args => [ "hello SOMEONE", 3, $extra ],
pid_file => "/tmp/fork.##.pid",
uid => 1000,
gid => 1000,
home => "/tmp",
max_load => 5,
max_mem => 185000000,
expiration => 10,
# expiration_auto => 1,
);
if ( $status == 4 ) # if the load become to high
{
print "Max load reached, do a little napn";
usleep( 100000 );
next;
}
elsif ( $status ) # if another kind of error
{
print "PID=$pidt error=$errorn";
print Dumper( $f->list_names() );
print Dumper( $f->list_pids() );
}
}
$nbr = $f->pid_nbr;
my ( $n, @dp, @dn ) = $f->expirate;
if ( $n )
{
print Dumper( @dp );
}
print "free=n";
usleep( 100000 ); # always a good idea to put a small sleep to allow task swapper to gain some free resources
}
sub func
{
my $ref = shift;
my @args = @$ref;
my ( $data, $time_out, $sockC ) = @args;
$SIG{ USR1 } = sub { open my $log, ">>/tmp/log.s"; print $log "signal USR1 receivedn"; close $log; };
if ( !$time_out )
{
$time_out = 3;
}
open my $FF, ">>/tmp/loglist";
print $FF $$, " start time =", $^T;
close $FF;
for ( 1 .. 4 )
{
open my $fh, ">>/tmp/log";
if ( defined $fh )
{
print $fh "TMOUT = $time_out " . time . " PID=$$ cwd=" . Cwd::cwd() . " name =$0n";
$fh->close;
}
sleep $time_out + rand( 5 );
}
}
Download (0.011MB)
Added: 2007-03-06 License: Perl Artistic License Price:
962 downloads
wmforkplop 0.9.3
wmforkplop is a mixture between wmhdplop and the great wmtop. more>>
wmforkplop is yet another dockapp for WindowMaker, or any windowmanager/desktop environment that handles dockapps (KDE has a dockbar extension, and gnome swallows).
The project is a mixture between wmhdplop and the great wmtop: wmforkplop monitors your processes by sending visual stimuli to your cortex each time your kernel forks or kills a process. Try to compile a kernel and enjoy the wmforkplop show!
Main features:
- theoritical portability that still has to be demonstrated.
- useless animation reflecting forking activity.
- wmtop-like feature (displays the top cpu consuming processes)
- a "process browser" with a license to kill.
- many unreadable information written in a tiny font.
Enhancements:
- This release fixes the infamous bug where incorrect process names were displayed.
<<lessThe project is a mixture between wmhdplop and the great wmtop: wmforkplop monitors your processes by sending visual stimuli to your cortex each time your kernel forks or kills a process. Try to compile a kernel and enjoy the wmforkplop show!
Main features:
- theoritical portability that still has to be demonstrated.
- useless animation reflecting forking activity.
- wmtop-like feature (displays the top cpu consuming processes)
- a "process browser" with a license to kill.
- many unreadable information written in a tiny font.
Enhancements:
- This release fixes the infamous bug where incorrect process names were displayed.
Download (0.21MB)
Added: 2006-12-03 License: GPL (GNU General Public License) Price:
1055 downloads
DB Designer Fork 1.3
DB Designer Fork is a fork of the fabFORCE DBDesigner 4. more>>
DB Designer Fork is a fork of the fabFORCE DBDesigner 4. DBDesigner is a visual database design system that integrates entity relationship design and database creation.
The project generates SQL scripts for Oracle, SQL Server, MySQL, and FireBird.
<<lessThe project generates SQL scripts for Oracle, SQL Server, MySQL, and FireBird.
Download (11MB)
Added: 2007-05-11 License: GPL (GNU General Public License) Price:
923 downloads
MirrorMed 1.0 RC2
MirrorMed is a friendly fork of ClearHealth. more>>
MirrorMed is a friendly fork of ClearHealth. MirrorMed project uses the same codebase with slower releases, further testing, and additional forms, reports, and other small improvements. As with ClearHealth, MirrorMed also borrows from FreeMed and OpenEMR.
Installation:
The installation of mirrormed is now accomplished through a graphical installer.
Untar the mirrormed tgz file into your web directory and rename it to "mirrormed". Then point your browser to the mirrormed directory.
The installer will check your dependancies, what directory permissions need to be changed, create the configuration files and install the database.
Enhancements:
- Changes allow for the correct printing of the HCFA 1500 (CMS 1500) medical billing form.
<<lessInstallation:
The installation of mirrormed is now accomplished through a graphical installer.
Untar the mirrormed tgz file into your web directory and rename it to "mirrormed". Then point your browser to the mirrormed directory.
The installer will check your dependancies, what directory permissions need to be changed, create the configuration files and install the database.
Enhancements:
- Changes allow for the correct printing of the HCFA 1500 (CMS 1500) medical billing form.
Download (7.0MB)
Added: 2005-12-28 License: GPL (GNU General Public License) Price:
1395 downloads
Benchmark::Forking 0.99
Benchmark::Forking is a Perl module to run benchmarks in separate processes. more>>
Benchmark::Forking is a Perl module to run benchmarks in separate processes.
SYNOPSIS
use Benchmark::Forking qw( timethis timethese cmpthese );
timethis ($count, "code");
timethese($count, {
Name1 => sub { ...code1... },
Name2 => sub { ...code2... },
});
cmpthese($count, {
Name1 => sub { ...code1... },
Name2 => sub { ...code2... },
});
Benchmark::Forking->enabled(0); # Stop using forking feature
...
Benchmark::Forking->enabled(1); # Begin using forking again
The Benchmark::Forking module changes the behavior of the standard Benchmark module, running each piece of code to be timed in a separate forked process. Because each child exits after running its timing loop, the computations it performs cant propogate back to affect subsequent test cases.
This can make benchmark comparisons more accurate, because the separate test cases are mostly isolated from side-effects caused by the others. Benchmark scripts typically dont depend on those side-effects, so in most cases you can simply use or require this module at the top of your existing code without having to change anything else. (A few key exceptions are noted in "BUGS".)
<<lessSYNOPSIS
use Benchmark::Forking qw( timethis timethese cmpthese );
timethis ($count, "code");
timethese($count, {
Name1 => sub { ...code1... },
Name2 => sub { ...code2... },
});
cmpthese($count, {
Name1 => sub { ...code1... },
Name2 => sub { ...code2... },
});
Benchmark::Forking->enabled(0); # Stop using forking feature
...
Benchmark::Forking->enabled(1); # Begin using forking again
The Benchmark::Forking module changes the behavior of the standard Benchmark module, running each piece of code to be timed in a separate forked process. Because each child exits after running its timing loop, the computations it performs cant propogate back to affect subsequent test cases.
This can make benchmark comparisons more accurate, because the separate test cases are mostly isolated from side-effects caused by the others. Benchmark scripts typically dont depend on those side-effects, so in most cases you can simply use or require this module at the top of your existing code without having to change anything else. (A few key exceptions are noted in "BUGS".)
Download (0.006MB)
Added: 2007-04-30 License: Perl Artistic License Price:
907 downloads
Fork JavaScript 0.1.0
Fork JavaScript project is a general purpose, namespaced JavaScript library with Ajax, Events, DOM manipulation. more>>
Fork JavaScript project is a general purpose, namespaced JavaScript library with Ajax, Events, DOM manipulation. There are a few bonus lines of code specifically for use with Ruby on Rails but Fork can be happily used outside of Rails also.
Main features:
- an aspiration for the highest quality code
- author documentation
- documented limitations (all libs have them but dont report them)
- in-browser unit/integration tests
- tested in a wide set of browsers.
- functions to help create gracefully degrading web pages
- namespaced code
- does not augment JavaScript built-in prototypes
- does not add a layer of sugar on top of JavaScript to make writing JavaScript like writing in another language
- minimizable with jsmin and includes already minimized versions
- MIT License
- plugin for tight integration with Ruby on Rails
Why?
There are many JavaScript libraries out there. Why add another one to the list? To create a quality library with a liberal license.
I like Ruby on Rails. The Rails default Prototype JavaScript library does not suit many development situations and contains code that makes developing for a wide selection of browsers difficult or impossible. Prototype has some great ideas in its mix but the implementation quality has been questioned many times. Prototype has influenced many JavaScript libraries and some of Prototypes best ideas have also influenced the Fork API.
Because Fork is a namespaced library, you may be able to use both Fork and Prototype simultaneously as you transition from one to the other.
I like the Yahoo! UI library. Of the JavaScript libraries Ive used it has the best API. The YUI library has many valuable nuggets of information about browser bugs and workarounds. The approach of YUI suits browser scripting well.
However there are more than a few places in the code where Im left scratching my head and thinking "why did they do that?" Probably that is how every developer looks at another developers code. The YUI API is the starting point for much of the Fork API.
Most libraries seem to develop too quickly. I like the general debian attitude of careful growth because the browser execution environment is wildly varied and deserves a certain degree of conservatism in the JavaScript we send to it.
<<lessMain features:
- an aspiration for the highest quality code
- author documentation
- documented limitations (all libs have them but dont report them)
- in-browser unit/integration tests
- tested in a wide set of browsers.
- functions to help create gracefully degrading web pages
- namespaced code
- does not augment JavaScript built-in prototypes
- does not add a layer of sugar on top of JavaScript to make writing JavaScript like writing in another language
- minimizable with jsmin and includes already minimized versions
- MIT License
- plugin for tight integration with Ruby on Rails
Why?
There are many JavaScript libraries out there. Why add another one to the list? To create a quality library with a liberal license.
I like Ruby on Rails. The Rails default Prototype JavaScript library does not suit many development situations and contains code that makes developing for a wide selection of browsers difficult or impossible. Prototype has some great ideas in its mix but the implementation quality has been questioned many times. Prototype has influenced many JavaScript libraries and some of Prototypes best ideas have also influenced the Fork API.
Because Fork is a namespaced library, you may be able to use both Fork and Prototype simultaneously as you transition from one to the other.
I like the Yahoo! UI library. Of the JavaScript libraries Ive used it has the best API. The YUI library has many valuable nuggets of information about browser bugs and workarounds. The approach of YUI suits browser scripting well.
However there are more than a few places in the code where Im left scratching my head and thinking "why did they do that?" Probably that is how every developer looks at another developers code. The YUI API is the starting point for much of the Fork API.
Most libraries seem to develop too quickly. I like the general debian attitude of careful growth because the browser execution environment is wildly varied and deserves a certain degree of conservatism in the JavaScript we send to it.
Download (MB)
Added: 2007-01-24 License: MIT/X Consortium License Price:
1005 downloads
OutKafe 5.2.0
OutKafe project is a complete internet cafe management suite. more>>
OutKafe project is a complete internet cafe management suite.
OutKafe (formerly ZybaCafe) is a next-generation free and open-source internet cafe management suite. OutKafe was forked from ZybaCafe by the original developers to be a 100% free and open-source project. The first 5.0.0 release is based on the last 4.x ZybaCafe release with some bugfixes and rebranding. The next phase of the project will replace all the closed-source parts of ZybaCafe including the windows client with GPLd replacements.
OutKafe comprises a server-side administration suite, as well as clients to manage time-control on machines. The standard version uses postgresql as an RDBMS but porting it to other database systems should not be very difficult.
OutKafe has a powerful plugin architecture allowing for easy extensibility and integration with other tools such as accounting packages and CRM systems.
Enhancements:
- A powerful theme system for the login screens was added.
- Multilingual support was added through gettext.
- Afrikaans and Portuguese translations are already available.
- Several critical bugs were fixed.
- The Windows client is no longer considered beta.
<<lessOutKafe (formerly ZybaCafe) is a next-generation free and open-source internet cafe management suite. OutKafe was forked from ZybaCafe by the original developers to be a 100% free and open-source project. The first 5.0.0 release is based on the last 4.x ZybaCafe release with some bugfixes and rebranding. The next phase of the project will replace all the closed-source parts of ZybaCafe including the windows client with GPLd replacements.
OutKafe comprises a server-side administration suite, as well as clients to manage time-control on machines. The standard version uses postgresql as an RDBMS but porting it to other database systems should not be very difficult.
OutKafe has a powerful plugin architecture allowing for easy extensibility and integration with other tools such as accounting packages and CRM systems.
Enhancements:
- A powerful theme system for the login screens was added.
- Multilingual support was added through gettext.
- Afrikaans and Portuguese translations are already available.
- Several critical bugs were fixed.
- The Windows client is no longer considered beta.
Download (4.9MB)
Added: 2007-08-03 License: GPL (GNU General Public License) Price:
820 downloads
Test::MultiFork 0.6
Test::MultiFork is a test suite that has support for multi-process programs. more>>
Test::MultiFork is a test suite that has support for multi-process programs.
SYNOPSIS
use Test::MultiFork;
($name, $letter, $number) = procname([new name])
lockcommon()
@oldvalues = getcommon()
setcommon(@newvalues)
unlockcommon()
use Test::MultiFork qw(groupwait setgroup dofork stderr bail_on_bad_plan)
groupwait([$tag])
$oldgroup = setgroup([$newgroup])
dofork(fork_specification)
This test module is to support creating test suites for programs and modules that run as multiple processes and do mostly blocking I/O.
Test::MultiFork handles the forking so that it can set up each child to coordinate the output. The output from each child fork is redirected to the parent. Each fork produces normal test output -- possibly using normal test modules like Test::Simple. The output is collected and rewritten by the parent process.
Each child fork has a letter and number designation. The forks are created by dofork(). Dofork takes a specifiction on the form: ([a-z](d*))+. That is to say, one or more lower-case letters, each optionally followd by a number. The number says how many children to fork for that letter (default one). The specifier ab2c3 means have one a child (numbered 1); two b children (numbered 1, 2); and three c children (numbered 1, 2, 3).
To aid in writing tests, Test::MultiFork will pass data between the child processes. The data is test-writer defined.
<<lessSYNOPSIS
use Test::MultiFork;
($name, $letter, $number) = procname([new name])
lockcommon()
@oldvalues = getcommon()
setcommon(@newvalues)
unlockcommon()
use Test::MultiFork qw(groupwait setgroup dofork stderr bail_on_bad_plan)
groupwait([$tag])
$oldgroup = setgroup([$newgroup])
dofork(fork_specification)
This test module is to support creating test suites for programs and modules that run as multiple processes and do mostly blocking I/O.
Test::MultiFork handles the forking so that it can set up each child to coordinate the output. The output from each child fork is redirected to the parent. Each fork produces normal test output -- possibly using normal test modules like Test::Simple. The output is collected and rewritten by the parent process.
Each child fork has a letter and number designation. The forks are created by dofork(). Dofork takes a specifiction on the form: ([a-z](d*))+. That is to say, one or more lower-case letters, each optionally followd by a number. The number says how many children to fork for that letter (default one). The specifier ab2c3 means have one a child (numbered 1); two b children (numbered 1, 2); and three c children (numbered 1, 2, 3).
To aid in writing tests, Test::MultiFork will pass data between the child processes. The data is test-writer defined.
Download (0.010MB)
Added: 2007-05-04 License: Perl Artistic License Price:
903 downloads
mooseekd 0.02
mooseekd is a partial fork of Museek+, containing only the standalone daemon needed to connect to the Soulseek P2P network. more>>
mooseekd project is a partial fork of Museek+, containing only the standalone daemon needed to connect to the Soulseek P2P network. Naming has been changed so as not to clash with an existing Museek+/museekd installation.
The goal of the fork is to provide a means of having only the daemon installed, without the dependencies on libxml++/glibmm, leaving it with only GLib (using GMarkup instead of libxml++) as a major dependency.
<<lessThe goal of the fork is to provide a means of having only the daemon installed, without the dependencies on libxml++/glibmm, leaving it with only GLib (using GMarkup instead of libxml++) as a major dependency.
Download (0.46MB)
Added: 2006-07-29 License: GPL (GNU General Public License) Price:
1182 downloads
Parallel::ForkManager 0.7.5
Parallel::ForkManager is a simple parallel processing fork manager. more>>
Parallel::ForkManager is a simple parallel processing fork manager.
SYNOPSIS
use Parallel::ForkManager;
$pm = new Parallel::ForkManager($MAX_PROCESSES);
foreach $data (@all_data) {
# Forks and returns the pid for the child:
my $pid = $pm->start and next;
... do some work with $data in the child process ...
$pm->finish; # Terminates the child process
}
This module is intended for use in operations that can be done in parallel where the number of processes to be forked off should be limited. Typical use is a downloader which will be retrieving hundreds/thousands of files.
<<lessSYNOPSIS
use Parallel::ForkManager;
$pm = new Parallel::ForkManager($MAX_PROCESSES);
foreach $data (@all_data) {
# Forks and returns the pid for the child:
my $pid = $pm->start and next;
... do some work with $data in the child process ...
$pm->finish; # Terminates the child process
}
This module is intended for use in operations that can be done in parallel where the number of processes to be forked off should be limited. Typical use is a downloader which will be retrieving hundreds/thousands of files.
Download (0.006MB)
Added: 2007-04-18 License: Perl Artistic License Price:
931 downloads
fio 1.17
fio is an I/O tool meant to be used both for benchmark and stress/hardware verification. more>>
fio is an I/O tool meant to be used both for benchmark and stress/hardware verification.
fio project has support for 4 different types of I/O engines (sync, mmap, libaio, posixaio), I/O priorities (for newer Linux kernels), rate I/O, forked or threaded jobs, and much more. It can work on block devices as well as files.
fio accepts job descriptions in a simple-to-understand text format. Several example job files are included. fio displays all sorts of I/O performance information, such as completion and submission latencies (avg/mean/deviation), bandwidth stats, cpu and disk utilization, and more.
Options:
$ fio
-s IO is sequential
-b block size in KiB for each io
-t < sec > Runtime in seconds
-r For random io, sequence must be repeatable
-R < on > If one thread fails to meet rate, quit all
-o < on > Use direct IO is 1, buffered if 0
-l Generate per-job latency logs
-w Generate per-job bandwidth logs
-f < file > Read < file > for job descriptions
Examples using a job file:
A sample job file doing the same as above would look like this:
[read_file]
rw=0
bs=4096
[write_file]
rw=1
bs=16384
And fio would be invoked as:
$ fio -o1 -s -f file_with_above
The second example would look like this:
[rf1]
rw=0
prio=6
[rf2]
rw=0
prio=3
[rf3]
rw=0
prio=0
direct=1
And fio would be invoked as:
$ fio -o0 -s -b4096 -f file_with_above
global is a reserved keyword. When used as the filename, it sets the default options for the threads following that section. It is possible to have more than one global section in the file, as it only affects subsequent jobs.
Enhancements:
- Support for replaying blktrace logs, full splice support (network and normal), adaptive latency histograms, many data verification improvements and additions, and many bugfixes and improvements.
<<lessfio project has support for 4 different types of I/O engines (sync, mmap, libaio, posixaio), I/O priorities (for newer Linux kernels), rate I/O, forked or threaded jobs, and much more. It can work on block devices as well as files.
fio accepts job descriptions in a simple-to-understand text format. Several example job files are included. fio displays all sorts of I/O performance information, such as completion and submission latencies (avg/mean/deviation), bandwidth stats, cpu and disk utilization, and more.
Options:
$ fio
-s IO is sequential
-b block size in KiB for each io
-t < sec > Runtime in seconds
-r For random io, sequence must be repeatable
-R < on > If one thread fails to meet rate, quit all
-o < on > Use direct IO is 1, buffered if 0
-l Generate per-job latency logs
-w Generate per-job bandwidth logs
-f < file > Read < file > for job descriptions
Examples using a job file:
A sample job file doing the same as above would look like this:
[read_file]
rw=0
bs=4096
[write_file]
rw=1
bs=16384
And fio would be invoked as:
$ fio -o1 -s -f file_with_above
The second example would look like this:
[rf1]
rw=0
prio=6
[rf2]
rw=0
prio=3
[rf3]
rw=0
prio=0
direct=1
And fio would be invoked as:
$ fio -o0 -s -b4096 -f file_with_above
global is a reserved keyword. When used as the filename, it sets the default options for the threads following that section. It is possible to have more than one global section in the file, as it only affects subsequent jobs.
Enhancements:
- Support for replaying blktrace logs, full splice support (network and normal), adaptive latency histograms, many data verification improvements and additions, and many bugfixes and improvements.
Download (1.0MB)
Added: 2007-08-14 License: GPL (GNU General Public License) Price:
802 downloads
mod_ecgi
mod_cgi turns CGI program into a dynamically loaded library (.so) and runs it without forking. more>>
mod_cgi is an Apache module that turns a CGI program into a dynamically loaded library (.so) and runs it without forking. Gives the simplicity and portability of CGI without the overhead.
There is no documentation, beyond the source code comments. It will build cleanly with Apache 1.3b6+, and youll need some configuration: e.g.
AddHandler mod_ecgi .so
or
AddType x-embedded-cgi .so
As I said, see the source file.
Theres also a small harness for CGI programs, to get round the way many sloppy CGIs never return but call exit() instead. Its not absolutely necessary, but for most purposes youll want it.
<<lessThere is no documentation, beyond the source code comments. It will build cleanly with Apache 1.3b6+, and youll need some configuration: e.g.
AddHandler mod_ecgi .so
or
AddType x-embedded-cgi .so
As I said, see the source file.
Theres also a small harness for CGI programs, to get round the way many sloppy CGIs never return but call exit() instead. Its not absolutely necessary, but for most purposes youll want it.
Download (0.008MB)
Added: 2006-05-18 License: The Apache License Price:
1254 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 forked 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
