Aorta is loadbalanced and clustring P2P application. It executes Tasklets (which has the ability to split them selves into sub tasks executed in parallel). A typical cluster contains of a LAN with 1-256 computers , each and one of them running aorta.A Tasklet can be of any type ranging from Genomic DNA Alignment,encoding mp3's / ogg vorbis to render web pages for highspeed /heavy loaded web sites (I'm currently creating a Tasklet that can execute Portles , for Jetspeed/Ibm-Portlal server). Even if Aorta is 100% java you can make functions calls to 'C/C++" , or applications like Matlab etc. 

You should use Aorta whenever you need:
Key features for Aorta:
Below is an example Tasklet , it doesn't do any thing but should give you a hint that it is EXTREMLY easy to code Tasklets. You need only to implement 3 methods.
package musli.aorta.plugins;

public class ExampleTasklet extends Tasklet {

    public  boolean calc() { }  // The actual execution is made here.
    public  Tasklet split(Benchmark rate) {} // This one splits the Tasklet into a sub-Task that Aorta delegates away to another JVM.
    public  boolean merge(Tasklet task) {}  // This on puts the pieces togheter again.




A LAN consisting of 1-256 computers all running AORTA workers and all of them using the same multicast address for brodcasting jobs.

All non employed workers scans the multicast address for Tasks and tries to fetch a job as soon as it "pops up".

When a worker suceeds to get an task it starts with split it using Tasklet.Split() and then it post/delegates the rest to multicast address and lets a remote JVM solve this part.

Process the local part using Tasklet.Calc(). (The remote part is delegated and hopfully an remote JVM is solving it)
NOTE: Our worker is now both a master/slave

NOTE: The local Tasklet.Calc() is spawned into a thread och when it is ready to Worker client is considerd to be ready for the next task (Altough the remote part is still not ready , but the merge is considern a non heavy part, even for a divide-conquier like Merge sort)

When both local and remote computions are finished , local.Merge(remote) is done , and the respone object is sent back to our MASTER.

A Tasklet has a corresponding GUI part ,this is used for initializing the tasklet with its parameters. In an server enviroment you proberbly go without GUI (thus the Tasklet is initialized from an external event like a http request or simular
Currently only tailrecursive tasklets are supported , but we are working on an more general engine , that supports "DataFlow-Components" and FEM Tasklets or other types that are not invented yet.

The Userinterface is divided in 3 parts.
1) At the bottom the available Tasklet (creator part) in your system are listed , one for each "tab". This screenshot show the Ping and Image Tasklets
2) To the left you can see the broadcasted "Tasks" that currently needs to be solved by worker. (the multicast IP)
3) To the right you se the History of executed Tasklet (that has beed executed locally at this Aorta-worker. The latest is shown at the top. Some Tasklets show progres about the currently execution. The long number is the id for the specific Task.


The screenshot below is of execution of the "Pinger" Tasklet ,that was initialized with 1363 mflops (java flops). You can se in the Tasklet history list the different IP addresses. In this case I started aorta on 3 Sun-bBlade solaris machines , and as you can the original task was divided 18 times before returned in one piece to the original worker who initiated the Tasklet.
The whole process tok about 3 seconds.


The screenshot below shows the ImageTasklet in action (as an example picture I grabbed my old pet dog called Cheesdoodle , that recently was stolen in Copenhagen) The picture task is sent to the multicast-IP as a Tasklet and 1 aorta-worker grabs it and splits it if is's to "big" (demands to many FLOPS for the local aorta-worker). The splitted part is sent out to the multicast-IP and hopefully some other aorta-worker will grab that part and try to solve it (and in turn split it and delegate).

Tasklet state is before its being sent out in the cluster , thus the colors are not yet recalculated (that is what the ImageTask does ,nothing fancy , just showing the idea of an Tasklet)

The screnshot below shows the result after pressing "start".As you can see the colours has been rescaled and in the history you can se the aorta-workers that has been involved.


1 Runnable over the whole internet.
-Using XEQ tunneling a very nice jvm-2-jvm function tunneling library
-Using suns framework JXTA containing everything needed for an massive internet version.
2 Generalize Aorta to handle more than Tasklets (tail-recursive).
-Component Tasklet ,for Dataflow algoritms.
-Shared memory Tasklets for FEM problems like this IMPACT project.

Currently these Tasklets are beeing developed (by varius people)
* Knights problem  (Tom)
* RSA Brute force attack  (Jake)
* web-portal rendrering ,for web-services using portlets (Ludder)
* Random -walk simulation  (Phd Heinrich)
* Genomic DNA Alignment algoritms (Fadi) Needleman-Wunsch/ Smith-Waterman
* Sorter (Gretsam)


DOWNLOAD HERE , if you want to look at the source or run it with your own jvm.

You can also start aorta by clicking here . It will try to use javawebstart on your machine , you need to give aorta access to your machine by clicking "yes" when the dialog pops up.

NOTE: For linux you need to activate multicast (eth can be  lo för linux kernel 2.4 and newer)
prompt>route add -net netmask dev eth0

The project itself are hosted in sourceforge here Logo