Free swap software for linux

Atop project is an ASCII full-screen performance monitor, similar to the top command.
At regular intervals, it shows system-level activity related to the CPU, memory, swap, disks and network layers, and it shows for every active process the CPU utilization in system and user mode, the virtual and resident memory growth, priority, username, state, and exit code.
The process level activity is also shown for processes which finished during the last interval, to get a complete overview about the consumers of things such as CPU time.
Atop only shows the active system-resources and processes, and only shows the deviations since the previous interval.
Enhancements:
- A new command, atopsar, has been added to generate detailed system activity reports (similar to the UNIX command sar) using the compressed logfiles as written by atop.
- These reports can also be generated for the current situation by specifying an interval for atopsar on the command line.

xen-tools project is a collection of scripts which allow you to manipulate virtual images for the Xen virtualization software.
With the tools installed, you may create new instances of Debian, complete with networking, OpenSSH, and user accounts, with one simple command. Images may also be easily updated, listed, or deleted.
Main features:
- Create new Xen instances of Debian Sarge, in minutes. (xen-create-image)
- Duplicate an existing image, whilst updating the networking information. (xen-duplicate-image)
- List all existing images with their networking details (xen-list-images)
- Delete previously created instances. (xen-delete-image)
- Update the images youve created with apt-get, without booting them. (xen-update-image)
Creating A New Image:
The script will contains a full manual written using the perl documentation system, perldoc, which you can read by executing:
xen-create-image --manual
This manual describes the operation of the script, and the supported options. (Each of the available options may be setup in a configuration file for ease of use.)
As a very simple example the following command willcreate an image using DHCP to obtain its networking information. The primary disk will 2Gb with 128Mb memory and swap:
xen-create-image --hostname=vm01 --dir=/home/xen
--size=2Gb --swap=128Mb --memory=128Mb --dhcp
If you wish to give the instance a static IP address then provide the information with the following flags:
--ip
The IP address to give the instance.
--gateway
The IP address of the gateway machine.
--broadcast
The broadcast address to use.
--network
The network the image is upon.
--netmask
The netmask to use.
Enhancements:
- This release supports the installation of RPM-based distributions via the external rinse tool, which is more reliable than the rpmstrap utility.
- New guests will now have a random MAC address generated by default, to avoid issues with udev, and several other minor bugfixes were applied.

PawPaw is a forth-like language except that it allows top-down development.
There are several stacks. As you would expect there is a data stack, a return stack. But there is also a control structure stack.
Include files are implemented with the # token, which is followed by the filename to include (up to 19 levels).
Here is a list of the words that are implemented so far:
EXIT calls exit(0) to end the interpreter.
+L add longs
.L print long
+ int add
. int print
: define a new word
niy print that a word (string arg) is not implemented, exit the interpret loop early.
; end a definition
"word" edit calls the Kwrite editor on the source file name corresponding to word.
(note the name of the file is a hex string followed by .pp)
size var name define a variable.
value const name define a constant
@C fetch from a character var
!C store to a char var
@S fetch from a short var
!S store to a short var
@ integer fetch
! integer store
- int subtract
- int multiply
% int modulus
/ int divide
& integer and
| integer or
^ integer exclusive or
~ 1s complement integer
> integer shift right
> < >= L convert int to long
L->I convert long to int
@L fetch long
!L store long
-L long subtract
*L long multiply
%L long modulus
&L long and
|L long or
^L long eor
~L ones complement long
L shift long right by int arg
L =L !=L ==L long relationals
dup int dup
dupL long dup
drop int drop
dropL long drop
rot int rot
rotL long rot
swap int swap
swapL long swap
pick int pick
pickL long pick by int arg
[]! subscripted store
/* ... */ comment
"word" compile compile a definition file
"xxx" "yyy" add_dep add a dependency for yyy to word xxx file.
control structure
if (expr) then true-part else false-part fi
or
if (expr) then true-part fi
while expr do body od
until expr do body od
Enhancements:
- Autoloading was fixed.

Common Media Input Layer (CMIL) is an C++ OO framework designed to improve the state of cross-platform input handling in games and other similar applications.
CMIL was created out of the belief that the methods used in most media APIs perform input handling in a confusing, difficult, inflexible fashion. CMILs goal is to address this issue by establishing a flexible, easy to use, human readible, OO abstraction layer. This layer specifically allows for media and input device abstraction.
Main features:
- easiliy build complex input sequences, including timed inputs, which do not impose restrictive notions of what is and isnt a moderator on the user
- custom input device configurations, IE: Users can swap input device configurations on the fly and create their own representation of a custom device using the framework facilities

GKrellM application is a GTK-based stacked monitor program that charts SMP CPUs, disks, load, active net interfaces, and internet connections.
There are also builtin monitors for memory and swap, file systems with mount/umount feature, mailbox checking including POP3 and IMAP, clock/calendar, laptop battery, sensors (temperatures, voltages, and fans), and uptime.
It has LEDs for the net monitors and an on/off button and online timer for PPP. There is a GUI popup for configuration, plugin extensions can be installed, and many themes are available. It also features a client/server monitoring capability.
Main features:
- Hostname/systemname display.
- Clock/calendar.
- SMP CPU monitor that can chart individual CPUs and/or a composite CPU.
- Temperature, fan, and voltage sensor monitors if supported by the kernel and the mainboard hardware (Linux requires lm_sensors to be installed).
- Each sensor monitor has a configurable alarm and warning.
- Process monitor with a chart for load and forks and a display of number of current processes and users.
- Disk monitor that can chart individual disks or a composite disk.
- Internet monitor (http, ftp, ...) that displays current tcp port connections and charts historical port hits for over two days.
- Net interface monitors with charts for all routed net interfaces. Data rx/tx LEDs and a timer button that can be linked to a ppp or isdn net interface and displays on line time.
- Memory and swap space usage meters, and a swap page in/out chart.
- File system meters which show capacity/free space and can mount/umount.
- A mailbox monitor which can launch a mail reader, a mail fetch/check program, and a sound notify command. Builtin new mail message checking for mbox, maildir, MH, POP3, and IMAP mailboxes.
- APM laptop battery meter with a configurable alarm and warning for low battery time left.
- Uptime display.
- Multiple monitors managed by a single process to reduce system load.
- Charts have auto scaling or fixed scaling modes.
- Commands can be configured to run when monitor labels are clicked.
- gkrellm can run in client mode and collect data from a gkrellmd server running on a remote machine.
- Both gkrellm and the gkrellmd server are plugin capable so special interest monitors can be coded.

Phasi project is another tool for system info written in PHP, with graphical report displaying several devices info, show memory status , SWAP use , and mounted disk partitions.
Main features:
- CPU Info
- Devices info
- Memory Status
- SWAP Status
- Disk partitions

PDL::Ops Perl module contains fundamental mathematical operators.

This module provides the functions used by PDL to overload the basic mathematical operators (+ - / * etc.) and functions (sin sqrt etc.)

It also includes the function log10, which should be a perl function so that we can overload it!

Matrix multiplication (the operator x) is handled by the module PDL::Primitive.

$doc
$c = $name $a, $b, 0; # explicit call with trailing 0
$c = $a $op $b; # overloaded call
$a->inplace->$name($b,0); # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the binary $optxt operator. Note that when calling this function explicitly you need to supply a third argument that should generally be zero (see first example). This restriction is expected to go away in future releases. EOD } # sub: biop()

#simple binary functions sub bifunc { my ($name,$func,$swap,$doc,%extra) = @_; my $funcov = ref $func eq ARRAY ? $func->[1] : $func; my $isop=0; if ($funcov =~ s/^op//) { $isop = 1; } my $funcovp = protect_chars $funcov; $func = $func->[0] if ref $func eq ARRAY; if ($swap) { $extra{HdrCode} .= 1, NoBadifNaN => 1, Pars => a(); b(); [o]c();, OtherPars => int swap, Inplace => [ a ], # quick and dirty solution to get ->inplace do its job Code => "$c() = $func($a(),$b());", BadCode => if ( $ISBAD(a()) || $ISBAD(b()) ) $SETBAD(c()); else . "n $c() = $func($a(),$b());n", CopyBadStatusCode => if ( $BADFLAGCACHE() ) { if ( a == c && $ISPDLSTATEGOOD(a) ) { PDL->propogate_badflag( c, 1 ); /* have inplace op AND badflag has changed */ } $SETPDLSTATEBAD(c); }, %extra, Doc => $name($b,0); # explicit function call
$ovcall
$a->inplace->$name($b,0); # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the binary $funcovp function. Note that when calling this function explicitly you need to supply a third argument that should generally be zero (see first example). This restriction is expected to go away in future releases. EOD } # sub: bifunc()

# simple unary functions and operators sub ufunc { my ($name,$func,$doc,%extra) = @_; my $funcov = ref $func eq ARRAY ? $func->[1] : $func; my $funcovp = protect_chars $funcov; $func = $func->[0] if ref $func eq ARRAY;
# handle exceptions

my $badcode = $ISBAD(a());
if ( exists $extra{Exception} ) {
# $badcode .= " || $extra{Exception}";
# print "Warning: ignored exception for $namen";
delete $exists{Exception};
}

# do not have to worry about propogation of the badflag when
# inplace since only input piddle is a, hence its badflag
# wont change
# UNLESS an exception occurs...
pp_def($name,
Pars => a(); [o]b(),
HandleBad => 1,
NoBadifNaN => 1,
Inplace => 1,
Code =>
"$b() = $func($a());",
BadCode =>
if ( . $badcode . )
$SETBAD(b());
else . "n $b() = $func($a());n",
%extra,
Doc => inplace->$name; # modify $a inplace

It can be made to work inplace with the $a->inplace syntax. This function is used to overload the unary $funcovp operator/function. EOD } # sub: ufunc()
######################################################################
# we trap some illegal operations here -- see the Exception option # note, for the ufunc()s, the checks do not work too well # for unsigned integer types (ie < 0) # # XXX needs thinking about # - have to integrate into Code section as well (so # 12/pdl(2,4,0,3) is trapped and flagged bad) # --> complicated # - perhaps could use type %{ %} ? # # ==> currently have commented out the exception code, since # want to see if can use NaN/Inf for bad values # (would solve many problems for F,D types) # # there is an issue over how we handle comparison operators # - see Primitive/primitive.pd/zcover() for more discussion #
## arithmetic ops # no swap biop(plus,+,0,add two piddles); biop(mult,*,0,multiply two piddles);

# all those need swapping biop(minus,-,1,subtract two piddles); biop(divide,/,1,divide two piddles, Exception => $b() == 0 );
## note: divide should perhaps trap division by zero as well
## comparison ops # need swapping biop(gt,>,1,the binary > (greater than) operation); biop(lt,,1,leftshift a$ by $b,GenericTypes => $T); biop(or2,|,0,binary or of two piddles,GenericTypes => $T); biop(and2,&,0,binary and of two piddles,GenericTypes => $T); biop(xor,^,0,binary exclusive or of two piddles,GenericTypes => $T);
# really an ufunc ufunc(bitnot,~,unary bit negation,GenericTypes => $T);
# some standard binary functions bifunc(power,[pow,op**],1,raise piddle $a to the power b,GenericTypes => [D]); bifunc(atan2,atan2,1,elementwise atan2 of two piddles,GenericTypes => [D]); bifunc(modulo,[MOD,op%],1,elementwise modulo operation); bifunc(spaceship,[SPACE,op],1,elementwise ~ operation);

# some standard unary functions ufunc(sqrt,sqrt,elementwise square root, Exception => $a() < 0 ); ufunc(abs,[ABS,abs],elementwise absolute value,GenericTypes => [D,F,S,L]); ufunc(sin,sin,the sin function); ufunc(cos,cos,the cos function); ufunc(not,!,the elementwise not operation); ufunc(exp,exp,the exponential function,GenericTypes => [D]); ufunc(log,log,the natural logarithm,GenericTypes => [D], Exception => $a() [D], Exception => $a() sub PDL::log10 { my $x = shift; if ( ! UNIVERSAL::isa($x,"PDL") ) { return log($x) / log(10); } my $y; if ( $x->is_inplace ) { $x->set_inplace(0); $y = $x; } elsif( ref($x) eq "PDL"){ #PDL Objects, use nullcreate: $y = PDL->nullcreate($x); }else{ #PDL-Derived Object, use copy: (Consistent with # Auto-creation docs in Objects.pod) $y = $x->copy; } &PDL::_log10_int( $x, $y ); return $y; }; );

# note: the extra code that adding HandleBad => 1 creates is # unneeded here. Things could be made clever enough to work this out, # but its very low priority. # It does add doc information though, and lets people know its been # looked at for bad value support # DJB adds: not completely sure about this now that I have added code # to avoid a valgrind-reported error (see the CacheBadFlagInit rule # in PP.pm) # # Cant this be handled in Core.pm when .= is overloaded ? # pp_def( assgn, # HandleBad => 1, Pars => a(); [o]b();, Code => $b() = $a();, # BadCode => # if ( $ISBAD(a()) ) { $SETBAD(b()); } else { $b() = $a(); }, Doc => Plain numerical assignment. This is used to implement the ".=" operator, ); # pp_def assgn

#pp_export_nothing();

pp_done();