Free jaguar idle pulley software for linux

Growler is a C++-based distributed object and event architecture. It is written in C++, and supports serialization of C++ objects as part of its Remote Method Invocation, Event Channels, and in its Interface Definition Language.

Its primary application has been in support of interactive, distributed and collaborative visualization, computational steering, and concurrent visualization.

IDL example:

Growler has an Interface Definition Language (IDL) for generating stub/skeletion code for distributed communications. Growlers IDL is one of its most unique features. The interface definition language for Growler is called PIDL: The Parsifal Interface Definition Language.

Here are some example PIDL files:

This eventchannel definition is used for distributing field data from a live fvGCM run:

%cinclude < lib/buffer.h >
%cinclude < lib/vector.h >
%cinclude < lib/array.h >
%cinclude < lib/utility.h >

enum { DataVectorPort = 10100 };

typedef lib::Array< uint32_t,3 > dimarray;

struct MetaData {
int32_t lat, lon;
uint32_t nymd, nhms;
uint32_t pdt;
uint32_t nsteps;
uint32_t stride;
std::vector fields;
}

eventport DataVectorChannel
{
metadata(MetaData mdat) state;
datavec[16](lib::Vector< float > dv);
}

This is the cpumon.pidl specification used by NodeMon for distributing cpu statistics:
%import < nodemon/nodemon.pidl >
%cinclude < lib/vector.h >

/*
* About /proc/stat:
*

The very first "cpu" line aggregates the numbers in all of the other "cpuN"
lines. These numbers identify the amount of time the CPU has spent performing different kinds of work. Time units are in USER_HZ (typically hundredths of a second). The meanings of the columns are as follows, from left to right:

- user: normal processes executing in user mode
- nice: niced processes executing in user mode
- system: processes executing in kernel mode
- idle: twiddling thumbs
- iowait: waiting for I/O to complete
- irq: servicing interrupts
- softirq: servicing softirqs
*/

struct CPUData {
uint32_t v[7]; // the seven columns
}

// CPUDataVector: array of cpu data rows from /proc/stat
typedef std::vector< CPUData > CPUDataVector;

typedef std::vector< uint32_t > CPUSetVector;
typedef std::vector< std::string > CPUSetNameVector;

eventport CPUMonChannel
{
cpu_data(CPUDataVector) nonqueued;
cpuset_data(CPUSetVector) state;
cpuset_names(CPUSetNameVector) state;
}

port CPUMon : nodemon::NodeMonAgent
{
CPUMonChannel_ptr getMonChannel(out uint32_t cpucount);
}

Satellite can track many remote machines with dynamic IP addresses in situations where public DNS services are inappropriate. Satellite can log and alert an admin immediately when a site comes online or needs attention.
The Satellite archive also includes an RPM spec file. RPM users can build a binary package ready to install by running:
rpm -tb satellite-1.0.2.tar.gz
You will find the binary rpm under /usr/src/rpm/RPMS/i386 or /usr/src/redhat/RPMS/i386.
Reasons for Satellite
Public DNS services are often used to track clients with changing IP addresses, but DNS solutions suffer from several problems:
Failure
Public DNS servers regularly fail due to overloading and system administration problems.
No notification
There is no notification when a system goes online. Instead you must poll DNS regularly to see when a system comes online.
Latency
Updating can take from several minutes to several hours before the change is made public. On systems with small idle timeouts it is often impossible to find the current IP address via DNS.
No history
Public DNS services only keep track of the current address and dont record past times or changes in a central location.
Enhancements:
- Minor code improvements. -e no longer searches PATH.
- --with-port removed. Default now found from /etc/services.
- Documentation updates

Group Shell is a tool to aggregate several remote shells into one. It is used to launch an interactive remote shell on many machines at once. Group Shell is written in Python and requires Python ≥ 2.4.

There is a control shell accessible with Ctrl-C that is used to list some information about the current remote shells. It also allows common terminal manipulations like sending a Ctrl-C, Ctrl-Z, Ctrl-D …

The prompt shows the number of listening shells and the number of active shell. A shell is said to be listening if its prompt has returned and it is accepting commands, active shells are those whose connection is still alive. Shells can be individually enabled and disabled.

Here is the transcript of a sample session:

[g ~/gsh]$ ./gsh.py machine{0-9}

[10/10]> date

machine4: ven nov 10 23:26:36 CET 2006
machine7: ven nov 10 23:26:36 CET 2006
machine3: ven nov 10 23:26:36 CET 2006
machine5: ven nov 10 23:26:36 CET 2006
machine9: ven nov 10 23:26:36 CET 2006
machine0: ven nov 10 23:26:36 CET 2006
machine2: ven nov 10 23:26:36 CET 2006
machine1: ven nov 10 23:26:37 CET 2006
machine6: ven nov 10 23:26:37 CET 2006
machine8: ven nov 10 23:26:37 CET 2006
[10/10]>
Now, Ctrl-C is pressed, it triggers the control shell.
(Cmd) help

Documented commands (type help < topic >):

EOF enable list send_eof set_print_first
continue get_print_first quit send_sigint unset_print_first
disable help reconnect send_sigtstp

(Cmd) list
machine0 fd:3 r:3 w:0 active:True enabled:True idle
machine1 fd:4 r:3 w:0 active:True enabled:True idle
machine2 fd:5 r:3 w:0 active:True enabled:True idle
machine3 fd:6 r:3 w:0 active:True enabled:True idle
machine4 fd:7 r:3 w:0 active:True enabled:True idle
machine5 fd:8 r:3 w:0 active:True enabled:True idle
machine6 fd:9 r:3 w:0 active:True enabled:True idle
machine7 fd:10 r:3 w:0 active:True enabled:True idle
machine8 fd:11 r:3 w:0 active:True enabled:True idle
machine9 fd:12 r:3 w:0 active:True enabled:True idle

10 active shells, 0 dead shells, total: 10
(Cmd) quit
[g ~/gsh]$

Parallel::Pvm is a Perl extension for the Parallel Virtual Machine (PVM) Message Passing System.

SYNOPSIS

use Parallel::Pvm;

The PVM message passing system enables a programmer to configure a group of (possibly heterogenous) computers connected by a network into a parallel virtual machine. The system was developed by the University of Tennessee, Oak Ridge National Laboratory and Emory University.

Using PVM, applications can be developed which spawns parallel processes onto nodes in the virtual machine to perform specific tasks. These parallel tasks can also periodically exchange information using a set of message passing functions developed for the system.

PVM applications have mostly been developed in the scientific and engineering fields. However applications for real-time and client/server systems can also be developed. PVM simply provides a convenient way for managing parallel tasks and communications without need for rexec or socket level programming.

As a utility, PVM enables an organisation to leverage on the computers already available for parallel processing. Parallel applications can be started during non-peak hours to utilise idle CPU cycles. Or dedicated workstation clusters connected via a high performance network like ATM can be used for high performance computing.

It is recommended that you read the PVM manual pages and the book "PVM: Parallel Virtual Machine, A userss guide and tutorial for networked parallel computing". Both the PVM system and the book can be obtained from the HTTP address http://www.epm.ornl.gov/pvm.

For the rest of this document we will provide a tutorial introduction to developing PVM applications using perl. The interface for some of the PVM functions have been changed of course to give it a more perl-like feel.
Remember think perl think parallel! Good Luck!

GXemul is a machine emulator Im developing in my spare time.
GXemul project emulates processors and surrounding hardware components, in some cases well enough to allow unmodified "guest" operating systems to run inside the emulator as if they were running on a real machine.
MIPS:
- Several machine types are emulated well enough to run guest operating systems. NetBSD, OpenBSD, Linux, and even obscure things such as Ultrix and Sprite can run, to various degrees.
ARM:
- CATS is emulated well enough to run NetBSD and OpenBSD as guest OSes.
PowerPC:
- NetBSD/prep can run (experimental).
The emulator can be used for:
- experimenting with operating systems which you have not tried yet, or operating systems for hardware which you might not have access to,
- running guest operating systems for historical purposes, e.g. Ultrix or Sprite,
developing portable software, when you want yet another target platform to try to compile your software on (you can use GXemul to run a guest OS and compile your software inside that OS),
- development of new firmware or operating system code (but then you need to be aware of some limitations),
- educational purposes...
Enhancements:
- NetBSD/pmppc can now run in the emulator (with root on NFS).
- For ARM emulation (with NetBSD/cats, OpenBSD/cats, NetBSD/evbarm, or NetBSD/netwinder as the guest OS), the emulator does not use 100% of the hosts CPU if the guest OS is idle.

Barrage is a rather violent action game with the objective to kill and destroy as many targets as possible within 3 minutes. You control a gun that may either fire small or large grenades at soldiers, jeeps and tanks.

Targets are fast paced and require careful aiming as it takes half a second to reload the gun. Additionally you have to keep an eye on your ammo and reload in time. Useful to kill some minutes of idle time.

And yes, the graphics look similiar to Command&Conquer but they are self-pixeled. I just used a screenshot of C&C as sketch. And no, none of the sounds are taken from C&C. I created all of them by myself except for the fonts which come from Karl Bartel.

GnoTime provides a to-do list organizer and project timer.
GnoTime is a to-do list tracker and project timer with a built-in invoice generator. It allows users to keep track of how much time they have spent working on particular tasks, maintain a diary of that work, and create invoices with task-specific billing fees and rates.
Main features:
- Multiple To-Do Lists that can be sorted by the priority/importance of the tasks in the list. The to-do items can be organized into categories, arranged in a hierarchical way. This makes it easy to maintain both business and personal items in the list, or handle many different projects, while keeping them separate from each other.
- A pair of Diary/Journal areas that can be used to keep long and detailed notes and diary entries. The project description area allows a multi-paragraph description or status to be typed in. The diary area allows day-to-day notes to be associated with a set of timestamps, so that one has a record of what one did on any given day.
- A Running Timer, with time totals, for each project/task. One starts the timer by clicking on a task: it will measure the amount of time that you are in front of the computer. If it detects that the keyboard/mouse are idle, it will stop the clock. If the clock stays stopped too long, it will nag you to start it up again. You can view time totals by day, week, month or year.
- A Billing Status dialog for each diary entry. You can mark any given diary entry as bill-able/non-bill-able, paid or pending, and set the billing rate. Each project can also be marked up with a set of project-planning information: planed start, end and due dates, hours to finish, percent-complete. This is in addition to assigning an urgency/importance to each project, as well as a status (completed/in-progress not-started/canceled).
- A half-dozen different HTML Reports that can slice and dice your lists. Theres a Journal report that shows all of the diary entries for one given project. Theres an Invoice report that summarizes the time spent on each entry, and computes a dollar amount for it. Theres a Status Report that prints the title of each project, together with the paragraph-long descriptions of each. Theres a ToDo report, which prints only the project title, the importance/urgency, and the completed/in-progress/not-started status. The Daily report summarizes the total time spent on a day-by-day basis, and lists each of the projects that were worked on in a given day. Each of these reports can be customized. And, because theyre HTML, you can even publish them as web pages. (Yes, Ive thought of using GnoTime as a weblog management/publishing tool).
Enhancements:
- Build against QOF version 0.6.0, if available.
- Fix issue where yelp doesnt display an entry for gnotime when browsing because it doesnt recognize the entry
- Fix sourceforge bug [ 799077 ] projects blanked when first time user tries to sort
- fix broken leap-year calculation, leading to bugs sourceforge bugs [ 983408 ] and [ 1114205 ]
- Fix crash due to hoverhelp timer popping after a report window is closed.
- Change activity report to display date/time in two distinct html table columns (prettier alignment)
- Bug fix: sourceforge bug report fixed [ 877193 ] toolbar wont go to/stay in text-only mode
- Bug fix: editing time brings up wrong report
- fedora .spec file is out of date and rpm cannot build rpm
- Fix bug involving copy of old gnotime files to a new machine on which gnotime has never been run before.
- Fix sourceforge bug [ 1276458 ] "Empty" appears in diary entry
- Apply sourceforge patch 1176719 Extensible fix for gtkhtml3 building
- Apply 1171394 Adds separate timeout for "No Project" dialog
- Apply sourceforge patch 085911 Add "-" value for status field
- Apply sourceforge patch 074658 Add wordwrapping to diary entry boxes
- Apply sourceforge patch 1074458 Fix a crash when invoking help
- Apply sourceforge patch 1038701 Fix to Activity item in popup menu
- Apply sourceforge patch 1027582 Build system update for qof inclusion
- Fix idle time so that it works with Linux 2.6 kernel /proc/interrupts
- use %e to see the estimated sizing of a project in the logfiles
- Apply new pt_BR translation from Goedson Teixeira Paixao
- Fix for Debian Bug #250776, change widget visibility in the edit interval dialog

The Distributed Hardware Evolution Project allows the distribution of a genetic algorithm evolving hardware designs across the Internet by setting up an island on each clients PC which will evolve during idle time. Individuals from these islands will migrate between each other as they compete for survival.

All source code is available at Sourceforge under the projects named JaGa, DistrIT, and IslandEv. The source code is generalizable to any genetic algorithm or distributed processing task.