First step in a PC cluster development with openMosix

JAVIER BILBAO GORKA GARATE

Department of Applied Mathematics
University of the Basque Country
School of Engineering, Alda. Urkijo, s/n 48013 - Bilbao
SPAIN

Abstract: - It is possible to make high calculation capacity machines by the interconnection of equipments with
high speed networks. This kind of systems is called distributed systems and nowadays they are the most used
technology in order to resolve problems that require high calculation capacity. Thus, computer clusters are
being developed. Clustering allows multiple computers to work together to solve common computing
problems. In this paper, one of the different types of clusters is presented, openMosix. The work also evaluates
the cluster by two case studies, where the execution time of the solved problems is improved.

Key-Words: - pc cluster, parallel computation, efficiency, Linux

1 Introduction It is possible that delay times exist in one of the

The great advance in the computer technology in the
last years has allowed the development of
computers with calculation capacities that were
inconceivable some years ago.
On the other hand, and in a parallel way to the
advance in computers, communication nets have
been developed spectacularly. Nowadays, it is usual
in universities to have high speed nets in order to
interconnect devices, and it allows to transfer a very
high amount of information among them in a short
period of time.
The necessity of developing efficient machines
with high calculation capacities is demanded by
different areas, such as oceanography, astrophysics,
aerodynamic calculation, meteorological
calculations, human genome analysis, finite element
analysis, medical pictures treatment, creation of
films, animations, and computer graphics.
With the aim of face up to these necessities, a
great investigation effort has been inverted in the
design of high calculation capacity machines. At the
beginning, the called multiprocessors came up, that
consist of computational machines that have a high
number of processors. This multiprocessor machines
deal with each problem with the philosophy divide
and conquer:
Each processor runs its own sequence of
instructions.
Each processor works in a different part of
the problem.
All processors communicate with each
other.
processors if it needs the result of some operation
that is carried out by other processor.
Programs that are run in this type of computers
should be optimized in order to exist the minimum
dependence among the different processors.
Otherwise, calculation capacity will be missed.
These systems supply a high calculation capacity
but they are very expensive and they are not easily
scalable. So, it seems that it should not be very
suitable to invert a high amount of money in
machines that will decrease their calculation
capacity as time goes on. Actually, they do not
decrease their capacity, but the problems to be
resolved are more and more complex and they need
a higher calculation power.
The increase of the above mentioned
technologies, computers and high speed networks,
with the development of efficient software tools to
the distributed calculation, have allowed to resolve
this problem of scalability by means of the computer
clusters.
It is possible to make high calculation capacity
machines by the interconnection of equipments, not
necessary powerful, with high speed networks. This
kind of systems is called distributed systems and
nowadays they are the most used technology in
order to resolve problems that require high
calculation capacity.
Financially, the difference between
supercomputers and computer clusters is very high.
The cost per Gflop (1 million of millions of
operations in float point per second) of one
supercomputer is estimated about 10,000 dollars,
and certain clusters have achieved a cost per Gflop
around 650 dollars.
2 Clustering
In general, clustering is a technology or a set of
technologies that allow multiple computers to work
together to solve common computing problems. The
computing problems in question can be anything
from complex CPU-intensive scientific
computations to a horde of miscellaneous processes
with no underlying commonality.
At the beginning, clusters were developed in
order to resolve problems of supercomputation, but
nowadays it is not their only use. The increase of the
use of the web technology has caused the
implementation of clusters in different servers with
the aim of service to a high number of clients.
Services such as web servers, email, e-commerce, or
high performance data bases have been to
implement this type of technology.
A cluster system may be considered as being
made up of four major components, two hardware
and two software. The two hardware components
are the nodes that perform the work and the network
that interconnects the nodes to form a single system.
The two software components are the collection of
tools used to develop user parallel application
programs and the software environment for
managing the parallel resources of the cluster [3].
Clusters of computers can be classified in two
groups: high availability clusters (such as web
servers) and high performance clusters
(supercomputation) [1].
2.1 System level or kernel clusters
System level clusters or kernel clusters are that
where the cluster is form at operating system level.
There is not necessary to specify the parallelism in
the applications or tasks because the parallelism is
implicit [2] [7], and they may be classified inside
the high performance clusters.
It is the own operating system what takes care of
the distribution among the different nodes of the
processes that are being run. Nevertheless, by means
of system calls, the execution of a certain process
can be specified in an explicit way to make in one
given node.
An example of this type of clusters are the called
openMosix clusters. This kind of clusters are
developed in Unix operating system.
3 openMosix
openMosix is a project that allows the
implementation of SSI (Single System Image)
clusters in order to can be managed as symmetric
multiprocessors (SMP).
openMosix appeared in 1999 from the Mosix
project and uses Linux.
Fig. 1. Logo of openMosix project
Unlike other similar projects such as VMS of
Digital, Sysplex of IBM or Mosix, openMosix is
developed with GPL license, whereas the previous
projects are owners.
openMosix is a Linux kernel extension for
single-system image clustering. This kernel
extension turns a network of ordinary computers
into a supercomputer for Linux applications.
Once you have installed openMosix, the nodes in
the cluster start talking to one another and the
cluster adapts itself to the workload. Processes
originating from any one node, if that node is too
busy compared to others, can migrate to any other
node. openMosix continuously attempts to optimize
the resource allocation.
So, openMosix is presented as a kernel patch for
Linux, creating a reliable, fast and cost-efficient SSI
clustering platform that is linearly scalable and
adaptive. Moreover, with openMosix' Auto
Discovery, a new node can be added while the
cluster is running and the cluster will automatically
begin to use the new resources.
The recognition among the different nodes of the
cluster can be dynamic or static, and it uses oMFS
(openMosix File System) file system in order to
access to the hard disk in remote nodes.
When applications are developed to solve
problems in these kind of systems, fork and
forget philosophy is used. It consists of the
division of the application in various processes by
means of the call to the system fork() that allows to
create a son process. This son process may be run in
a different node to that created it.
There is no need to program applications
specifically for openMosix. Since all openMosix
extensions are inside the kernel, every Linux
application automatically and transparently benefits
from the distributed computing concept of
openMosix. The cluster behaves much as does a
Symmetric Multi-Processor, but this solution scales
to well over a thousand nodes which can themselves
be SMPs.
Probably the best-known type of Linux-based
cluster is the Beowulf cluster [9]. Beowulf clusters
are scalable performance clusters based on
commodity hardware, on a private system network,
with open source software (Linux) infrastructure. In
order for these systems to be able to pool their
computing resources, special cluster-enabled
applications must be written using clustering
libraries. The most popular clustering libraries are
PVM and MPI; both are very mature and work very
well. By using PVM or MPI, programmers can
design applications that can span across an entire
cluster's computing resources rather than being
confined to the resources of a single machine. For
many applications, PVM and MPI allow computing
problems to be solved at a rate that scales almost
linearly in relation to the number of machines in the
cluster.
The really advantage about openMosix is that it
can turn a bunch of Linux machines into something
like a large virtual SMP system. However, there are
a few differences. First, on a "real" SMP system,
two or more CPUs can exchange data very quickly;
but with openMosix, the speed at which nodes can
communicate with one another is determined by the
speed of your LAN. Using Gigabit Ethernet or some
other kind of high-bandwidth networking
technology will allow you increase the effectiveness
of your openMosix cluster [9].
On the other hand, openMosix provides a
number of benefits over traditional multiprocessor
systems. With openMosix, you can create clusters
consisting of tens or even hundreds of nodes using
inexpensive PC hardware. In contrast, SMP systems
that contain large numbers of processors can be
prohibitively expensive, depending on your budget.
For many applications, openMosix will give you
more than a traditional supercomputer or
mainframe. And of course, there's no reason why
you can not run OpenMosix on a bunch of high-end
multi-processor systems. It is even possible to use
openMosix together with existing MPI or PVM
programs in order further optimize the performance
of your cluster-aware applications.
openMosix, like an SMP system, cannot execute
a single process on multiple physical CPUs at the
same time. This means that openMosix will not be
able to speed up a single process such as Mozilla,
except to migrate it to a node where it can execute
most efficiently. In addition, openMosix does not
currently offer support for allowing multiple
cooperating threads to be separated from one
another.
openMosix will allow for extremely scalable
parallel execution at the process level.
openMosix can migrate most standard Linux
processes between nodes with no problem. If an
application forks many child processes, each of
which performs work, then openMosix will be able
to migrate each one of these processes to an
appropriate node in the cluster. You can take
advantage of this ability even if a particular
application is not designed to use multiple sub-
processes that can be migrated independently. For
example, if you wanted to compress 12 digital audio
tracks using your cluster, you could simply start all
12 audio encoding processes simultaneously. After a
few seconds, openMosix would migrate each
process to an appropriate node in your cluster. If
you happened to have a 12-node cluster, your audio
encoding job would complete nearly 12 times faster
than it would have otherwise. If the number of
processes that you plan to run simultaneously is
greater than the number of nodes in your cluster,
multiprocessing provides options to experience
additional performance gains.
4 Cluster evaluation
Some case studies have been implemented for
performance evaluation of the cluster. In this paper
we will present two of these cases: for loops and
file compression from .wav to .mp3.
2.1 For loops
For a case study, a program which has two for
nested loops was used. Both of loops were of high
index, concretely, the first index was 1000000 (one
million) and the second one 100, that is to say, the
loops repeated one million times and one hundred
times respectively.
For performance the evaluation ten executions
have implemented in parallel, launching each of
them in background.
In the same way, it would also possible that the
own program would launch n processes, doing n
times the call to the system fork(). This system
creates a son process that it is possible to assign the
execution of the two for loops to. The result is the
same in both cases.
These processes have been run in a 100 MHz
Pentium computer, and the execution time was 2
minutes 9 seconds.
When the same operation is performed in a
cluster of two computers, the previous 100 MHz
Pentium and one 500 MHz Pentium III, the do
execution time was 48 seconds. time bladeenc -quit -quiet $i -256 -copy -crc&
done

140 The command time before a program launching

120 causes that, at the end of running this program, the
100 execution time of the process is shown in the screen.
80 Pentium 100 When this process has been carried out by only
60 one Pentium IV computer, it has taken 14 minutes 5
40
Cluster
seconds. But when the process has been
20
implemented by a cluster of 4 Pentium IV
0
Pentium 100 Cluster computers, the execution time has been 10 minutes
26 seconds:
Fig. 2. Execution time for a simple cluster and a 100
MHz Pentium to solve for loops
900
The same evaluation was implemented with four 800
Pentium IV computers with 512 Mb of RAM. One 700
of these computers executed the task in 35.446 600
seconds, and the cluster (the four Pentium IV 500
Pentium IV
computers) took 19.674 seconds for the same 400
Cluster
operation. 300
200
100
40
0
35 Pentium IV Cluster
30
25
Pentium IV Fig. 4. Execution time for a cluster of four
20
computers and one Pentium IV to file compression
15 Cluster
10
5
This last implementation has been monitorized
0
by means of the openMosixview software. In the
Pentium IV Cluster next figure how various processes have migrated to
the rest of the nodes of the cluster is shown:
Fig. 3. Execution time for a cluster of four
computers and one Pentium IV to solve for loops

2.2 File compression

In order to do this probe, the .wav files of a music
CD were dumped to the hard disk.
After that, the compression process was
implemented by means of a free software,
BladeEnc.
The process has been programmed to do the
compression of all .wav files of the CD in parallel,
that is to say, each .wav file has been treated by an
execution process of the BladeEnc software.
To do this task, the next shell script has been
done:

#!/bin/bash Fig. 5. Monitorization of the working nodes when

the processes are migrating among the nodes of the
for i in `ls *wav`; cluster
 The cluster took approximately 4 minutes less to [4] R. M. Yaez, Introduccin a las tecnologas
carry out the operation, however, the time difference clustering
between only one computer and the cluster (with 4 [5] D. Santo, El proyecto de cluster SSI openMosix
computers) is increased when the number of files [6] E. Plaza, Cluster heterogneo de computadoras
that have to be compressed is also increased. In the [7] M. Colomer, Clustering con openMosix
same way, if the number of files to compress is very [8] T. Sterling, Beowulf cluster computing with
low, it is just possible that the execution time of the Linux, MIT Press, Cambridge, 2001
cluster is higher than the time of the only computer. [9] D. Robbins, openMosix, http://www.intel.com
The reason is that the task of compressing files [10] LAM/MPI Users Guide. http://www.lam-
requires a constant access to the hard disk, when the mpi.org
previous task (for loops) only requires mathematical
calculations.
Therefore, when the compression is implemented
by the cluster, there is a constant direct access to the
hard disk of the computer that launched the
processes to the other nodes of the cluster. And
although openMosix has a oMFS file system that
allows any node of the cluster to access to the file
system of the other nodes, this access time is higher
than the time that a computer needs to access to its
own hard disk.

5 Conclusion
This paper presents a development of a computer
cluster based on openMosix. openMosix is a project
that allows the implementation of SSI clusters in
order to can be managed as symmetric
multiprocessors.
Some evaluations have been implemented with the
aim of comparing the resolution of a problem both
in an only computer and in a cluster. All results of
these evaluations show that the execution time
necessary to solve the problem is always lower
when a cluster is used.

Acknowledgements

This work was supported by the Aula Iberdrola of

the School of Engineering of Bilbao and the
Iberdrola S.A. Spanish utility in the academic year
2003-04.
We are also grateful to Maria Alonso and Jon
Viguera for their collaboration in the presented
evaluations.

References:
[1] M. Cataln i Cot, Manual para Clustering con
openMosix
[2] O. Pino, R. F. Arroyo, F. J. Nievas, Los clusters
como plataforma de procesamiento paralelo
[3] M. A. Perez, Arquitecturas paralelas