• • Supercomputer Center of Galicia J. I. López Cabido, P. González Gómez
  • Group of Self-performance Systems, Escola Politécnica Superior de Ferrol
  • University of A Coruña R. Luaces, J. A. Becerra, R. J. Duro

Many of the computational problems that researches come across can only be solved by using complex computer systems. It often happens that the resolution of problems is not possible due to the high cost of these equipments. Parallel technologies illustrate this situation: an user may have a problem which can be easily solved when applied to a high nimber of processors (hundreds or thousands); however, the user can't normally have access to a machine with those features.

We can consider two kind of problems: those in which there is a great amount of communication among different processors and therefore they need a communication architecture dedicated to optimize these communications, and those situations in which communication among different processors is very low or inexistent. In the first case, the problem can only be solved in a conventional parallel machine. It is in the second case that a platform like the one used by the Galician Virtual Supercomputer (SVG) makes sense.

The SVG project is based on the idea of using the big amount of computers of this community, taking advantage of the moments in which users are not working with them. Due to the power that these computers (maily PC's) have nowadays, the enormous computer potential is easily detected, and it is always interesting and appealing to deal with this kind of projects.

Today, different technologies to achieve this goal are available, and the project could be dealt with in different ways. In fact, if a user has an account in different machines, s/he can already use the outlines of parallel programming to join the efforts of the different machines. There are also several initiatives that take advantage of the thousands and millions of computers connected through the Internet, among which we can find the one used by the famous SETI@home project. The aim of CESGA is to provide a simple and well defined mechanism to get to this kind of experiences. The project is carried out jointly between CESGA  and the Group of Self-performance Systems (GSA) of the University of A Coruña. CESGA's task is to define and set up a virtual computer platform, while GSA will try to apply them to a specific problem.

CESGA works as follows: some users offer their machines under a calendar previously fixed. For example, a user loans their PC in the nights. A monitor program is installed in the user's computer. The program constantly watches the activation condition following the scheduled plan and the user's load in such a way that if the user starts working with the computer, the SVG would automatically stop using it. The information about the state of all the nodes associated to the SVG is given by a central resource manager. The user apllication running in SVC would reach a point in which it would have to work at many nodes, and it would ask SVG for the execution of a program fragmentation in certain nodes. The central administrator, basing on the availaility of the nodes at that moment, would deliver the different executions correspondingly.

The structure of the Galician Virtual Supercomputer (image 1) can be divided into four differenciated components which replicate themselves when needed for the application and accordding to the resources available in a certain moment.

(1) Entrance Point: it is a machine with an active java process that allows the user to insert their programs (divided into fragments) and all the parameters needed. The entrance point sends the fragments given by the user to a Pool, and it distributes and executes the nodes. From the Entrance Point, the user can consult the state of their processes.

(2) Pool: It distributes the fragments given by the user among the resources provided by the Node Server. The Pool receives from the Entrance Points the processes that need to be executed, asking for the nesessary resources.  

The Pool also communicates with the nodes by sending the fragments that need to be executed and asking the nodes for information about the state of the processes. Furthermore, the Pool administrates security copies, redundancy and migrations of fragments.

(3) Node Server: it has a database containig all the nodes ready to execute code fragments in a certain moment. Its functions are to administrate new registrations and cancellations, authentications, etc. It communicates with the Pool to provide it with resources and to notify of possible modifications. 

(4) Nodes: They execute the code fragments. There is an activity monitor in each node which indicates the Node Server the moments when it is ready to execute fragments. When the node joins the SVG, this daemon starts the Java virtual machine and the SVG Java interface in the node. Each node has also a SVG Java interface whose function is to receive and execute the fragments sent by the Pool, and to administrate the communications with the Pool.

Except for the Node Server and the Activity Monitors, all of the SVG components were programmed in Java. They were developed in C to minimize the impact in the use of resources of the computers loaned as SVG nodes. Moreover, a protocol of  internal communications between the Node Server and the Pool was defined so that the setting up of the processes could be done correctly.

The processes that want to take advantage of SVG's capacities will have to be splitted into fragments programmed in Java. The user himself will have to make this fragmentation , since no one knows better the kind of application that needs to be executed.

All the communications of the SVG Java components are based on RMI (Remote Method Invocation). This way, if we want to invocate remote methods, we just need to know the hostname and the IP address of the machine. The other communications ( between the Pool andthe Node Server and the Node Server and the Nodes) is carried out by Sockets.

APPLICATION

The first application, once in the SVG, contains a kind of processes that require huge computer resources (though, intrinsically, they are very easy to distribute): optimization processes and evolutionary design. This type of algorithms are meant to use selection, cross and mutation operators to explore, in parallel, the space of solutions to a problem in an efficient manner, starting frm different points. They shoul also come to an optimus (or, at least, acceptable) solution.

This kind of processes are easily distributed for, in many case, evaluating is a much more expensive computational process than the rest of the tasks. Moreover, this evaluation is made independently. The autonomous robot controller that was installed is a good example for this. In order to evaluate this kind of controllers, it is necessary to install a simulated robot inside a realist simulation environment , and to execute it during the robot's life.

The preliminar results are rather encouraging, for the controllers were received in a very efficient way. Indeed, in these processes, the speed up pro supplied by SVG is almost linear, and since it can take advantage of a great amount of machines, the time of operation in a workstation can be reduced.