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:
- High Speed (a cluster of for example 20 computers gives speedup
of 20 times)
- High availability (Nothing breaks even some machines goes down in
the cluster)
Key features for Aorta:
- Scalable (Just add computers when the demand for more cpu power increases)
- Simplicity (No setup/config ,just start the aorta worker on each
machine)
- Existing systems can easily be clustred/loadbalanced using 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.
ExampleTasklet.java
|
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.
}
|
NOTE:
|
ALGORITM
A LAN consisting of 1-256 computers all running AORTA workers and all of them using the same multicast
address for brodcasting jobs.
0)
All non employed workers scans the multicast address for Tasks and tries to fetch a job as soon
as it "pops up".
1)
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.
2)
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)
3)
When both local and remote computions are finished , local.Merge(remote) is done , and
the respone object is sent back to our MASTER.
TASKLET FAQ
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.
GUI
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.
PINGER SAMPLE
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.
IMAGE TASKLET SAMPLE
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.
FUTURE
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)