We give here some ideas, which might be suitable for semester/diploma thesis at a university or technical school. Realizing them will help the project, and we are ready to support you in doing these tasks. However, you will need a tutor assigned by the university. You can expect your work to be used by a little community of about 10 people and your documentation made available through sourceforge. If you think some of these tasks might be for you, or if you have another interesting idea, contact the gpu mailing list. All tasks need knowledge described here.

• Navtex decoder

Interface a world receiver to the sound card of your computer. Tune on 518 or 490 kHz. Try to decode the Navtex messages, and broadcast them to the GPU network, so that they appear in real time on the screensaver. For live Navtex messages see here.

• Distributed PovRay

GPU already includes a Terragen extension to render videos on the GPU cluster. An almost equal concept could be used to generate PovRay movies. The PovRay homepage is here. Your task should be to create a plugin wrapper like earthsim, and a frontend close to terragen_frontend dedicated to the PovRay program. Some more details on how the terragen extension works is here. For this idea, good Delphi knowledge and knowledge of Povray scripting language has to be achieved. The Internet Movie Project already distributes Povray computations. However, they still use the client/server approach.

• XML statistics

The Network Mapper is able to generate statistics in .xml and .html format. Generated statistics are a view of the current cluster and include total speed and memory, speed and memory for teams, countries and individual users. An HTML example is here with the corresponding XML. Using the collected xml files for each day and your favourite programming language, you should write a parser to create graphs of speed and memory for the entire cluster, teams and users over several months. Good XML understanding required. Some graphics skills to generate 2D stats graphs required. An example of manually generated graphs for the GPU cluster is here. Daily cluster statistics beginning from November 04 is available on request.

• Core Wars

In Corewars, assembler warriors fight a death match inside an arena of 8000 bytes. To kill each other, warriors throw deadly non-executable instructions on the adversary. Warriors are able to split execution in up to 64 threads. They move inside the arena using two instruction loops. Warriors should evolve using some genetic algorithm. We already have some serial code in Delphi here (evolution by nanobit, virtual machine copyed by dm from a magazine). Goal is to get the serial code inside the GPU framework and let warriors evolve with some genetic algorithm. Delphi knowledege, interest in evolutionary algos, interest in old fashioned Redcode assembler are a must.

• Distributed Clock Synchronization (Done)

Write a plugin that sends each minute the clock time when the secons are 0. A frontend should then collect measuraments done by the network. Using this information, the frontend takes some average of the data and sets the new averaged time as system time. Perform some analysis on how the entire network converges to the same time. Knowledge of Delphi and how the GPU framework works required.

This task was implemented in universaltime.dll by Rene Tegel.

• Delphi MPI

MPI is a standard for clusters where the size of involved computers is fixed (p processors partecipate from the beginning to the end). Task is to think how to integrate the Delphi MPI system inside GPU.

• TPastella as connection layer with Distributed Hash Tables

  Help GPU developers getting right TPastella by nanobit as new connection layer for GPU to solve the scalability issues plaguing GPU right now. TPastella is part of the Visual Synapse project and can be found under /lib/synapse

• Weather monitoring

On the market, you can find complex weather stations. Write a driver which can interface the computer to the weather station, then a plugin/frontend for distribute the results over the GPU network.

• Open Tsunami Alert System with earthquake sensors

Following this idea of Charles R. Martin study if something similar is possible on the GPU framework. Try to implement the idea and think of simple extensions for self built earthquake sensors (in your house with wooden floor and full loaded book shelter) and cheap weather stations already available on the market. Through GPU which would connect such sensors around the globe, it might be possible to tell the difference between your neighbour closing the door and a micro earthquake. Eventually, it might be even possible to model an earthquake wave. Just dreaming...

An earthquake sensor was build and connected by Rene Tegel. More info is here.

• Near Earth Object Detection

Help GPU developers to get the ORSA framework by Pasquale Tricarico inside GPU. The code allows prediction of asteroid orbits with integrators with precision up to the 15 order of the Taylor series. Some code is already available under /lib/liborsa. On the GPU application, choose from menu Frontends->Orbit Reconstruction to see what was already done.

• Java Frontend

Write a simple java frontend that sends and receives jobs to and from GPU. Use the UDP/IP communication channel of GPU to perform the task. Average Java knowledge required. A non working example is under src/frontend/java_example. In this example, there might be some incompatibility with the UDP sockets.

• C++ frontend (Done)

Done by Edgar Sartori. Source is under /src/frontend/simplest_c_example.

• Plugin (DLL) in C (Done)

GPU is compiled with DLLs which are C compatible (zero terminated strings are used instead of Delphi Strings). Write a simple DLL in C that can be loaded and correctly used by GPU. C skills required.

Source code for this plugin is under /src/dllbuilding/c_example.

• >Your idea<

Using the GPU infrastructure (e.g. by using the GPU client and the File Distributor, develop your own plugin/frontend which crunches data and produces some meaningful results. We will be happy to help you in developing, testing and crunching.