A Beowulf cluster is a computer
cluster of what are normally identical,
commodity-grade computers networked
into a small local area network with
libraries and programs installed which
allow processing to be shared among
them.
The result is a high-performance parallel
computing cluster from
inexpensive personal
computer hardware.
Cluster means ,a group of similar
objects growing closely together.
The name Beowulf originally referred to
a specific computer built in 1994
by Thomas Sterling and Donald
Becker at NASA.
The name "Beowulf" comes from the
main character in the Old English epic
poem Beowulf.
The Borg, a 52-node Beowulf cluster
Development of Beowulf cluster
Beowulf is a multi-
computer architecture which can be used
for parallel computations.
Beowulf is a multi-
computer architecture which can be used
for parallel computations.
It is a system built using commodity
hardware components, like any PC
capable of running a Unix-like operating
system, with standard Ethernet
adapters,
Difference between beowulf cluster and
cluster of workstations (cow)
One of the main differences between
Beowulf and a Cluster of
Workstations (COW) is that Beowulf
behaves more like a single machine
rather than many workstations. In most
cases client nodes do not have
keyboards or monitors, and are accessed
only via remote login or possibly serial
terminal.
Beowulf nodes can be thought of as a
CPU + memory package which can be
plugged into the cluster, just like a CPU
or memory module can be plugged into
a motherboard.
Overview of Beowulf
Beowulf is not a special software
package, new network topology, or the
latest kernel hack.
Beowulf is a technology of clustering
computers to form a parallel, virtual
supercomputer.
Although there are many software
packages such as kernel modifications,
PVM and MPI libraries, and
configuration tools which make the
Beowulf architecture faster, easier to
configure, and much more usable.
one can build a Beowulf class machine
using a standard Linux distribution
without any additional software.
If you have two networked computers
which share at least the /home file
system , and trust each other to execute
remote shells (rsh),
Structure

Cluster layout:
Parallel Virtual Machine (PVM) is
a software tool for parallel networking
of computers. It is designed to allow a network of
heterogeneous Unix and/or Windows machines to
be used as a single distributed parallel processor.
Thus large computational problems can be solved
more cost effectively by using the aggregate power
and memory of many computers. The software is
very portable; the source code, available free
through netlib, has been compiled on everything
from laptops to Crays.[2]
PVM enables users to exploit their existing
computer hardware to solve much larger problems
at less additional cost. PVM has been used as an
educational tool to teach parallel programming but
has also been used to solve important practical
problems.[2] It was developed by the University of
Tennessee, Oak Ridge National
Laboratory and Emory University. The first
version was written at ORNL in 1989, and after
being rewritten by University of Tennessee,
version 2 was released in March 1991. Version 3
was released in March 1993, and supported fault
tolerance and better portability.
PVM was a step towards modern trends
in distributed processing and grid computing but
has, since the mid-1990s, largely been supplanted
by the much more successful MPI standard for
message passing on parallel machines. PVM is free
software, released under both the BSD License and
the GNU General Public License.
PVM is a software system that enables a collection
of heterogeneous computers to be used as a
coherent and flexible concurrent computational
resource, or a "parallel virtual machine".
The individual computers may be shared- or local-
memory multiprocessors, vector supercomputers,
specialized graphics engines,
or scalar workstations and PCs, that may be
interconnected by a variety of networks, such
as Ethernet or FDDI.
PVM consists of a run-time environment and
library for message-passing, task and resource
management, and fault notification. While PVM
will not automatically make a commercial software
package run faster, it does provide a powerful set
of functions for manually parallelizing an existing
source program, or for writing new
parallel/distributed programs.
The PVM software must be specifically installed
on every machine that is to be used in a given
"virtual machine". There is no "automatic"
installation of executables onto remote machines in
PVM, although simply copying
the pvm3/lib and pvm3/bin directories to
another similar machine (and
setting $PVM_ROOT and $PVM_ARCH ) is
sufficient for running PVM
programs. Compiling or building PVM programs
requires the full PVM installation.
User programs written in C, C++, or Fortran can
access PVM through provided library routines.
PVM also supports broadcasting (PVM_bcast)
which sends to all processes in a group
and multicasting (PVM_mcast) which sends to a
specific list of processes.
Message Passing Interface (MPI) is a
standardized and portable message-passing system
designed by a group of researchers from academia
and industry to function on a wide variety
of parallel computing architectures. The standard
defines the syntax and semantics of a core of
library routines useful to a wide range of users
writing portable message-passing programs
in C, C++, and Fortran. There are several well-
tested and efficient implementations of MPI, many
of which are open-source or in the public domain.
These fostered the development of a parallel
software industry, and encouraged development of
portable and scalable large-scale parallel
applications.
The MPI interface is meant to provide essential
virtual topology, synchronization, and
communication functionality between a set of
processes (that have been mapped to
nodes/servers/computer instances) in a language-
independent way, with language-specific syntax
(bindings), plus a few language-specific features.
MPI programs always work with processes, but
programmers commonly refer to the processes as
processors. Typically, for maximum performance,
each CPU (or core in a multi-core machine) will be
assigned just a single process. This assignment
happens at runtime through the agent that starts the
MPI program, normally called mpirun or mpiexec.
MPI library functions include, but are not limited
to, point-to-point rendezvous-type send/receive
operations, choosing between a Cartesian or graph-
like logical process topology, exchanging data
between process pairs (send/receive operations),
combining partial results of computations (gather
and reduce operations), synchronizing nodes
(barrier operation) as well as obtaining network-
related information such as the number of
processes in the computing session, current
processor identity that a process is mapped to,
neighboring processes accessible in a logical
topology, and so on. Point-to-point operations
come in synchronous, asynchronous, buffered,
and ready forms, to allow both relatively stronger
and weaker semantics for the synchronization
aspects of a rendezvous-send. Many
outstanding[clarification needed] operations are possible in
asynchronous mode, in most implementations.
MPI-1 and MPI-2 both enable implementations
that overlap communication and computation, but
practice and theory differ. MPI also
specifies thread safe interfaces, which
have cohesion and coupling strategies that help
avoid hidden state within the interface. It is
relatively easy to write multithreaded point-to-
point MPI code, and some implementations
support such code. Multithreaded collective
communication is best accomplished with multiple
copies of Communicators,