System Models For Distributed and Cloud Computing
System Models For Distributed and Cloud Computing
System Models For Distributed and Cloud Computing
Unlike the cluster or grid, a P2P network does not use dedicated
interconnection network.
Clouds
A Cloud is a pool of virtualized computer resources. A cloud can
host a variety of different workloads, including batch-style
backend jobs and interactive and user-facing applications.
In
Loose
CORBA Stack
RMI Stack
IDL
Java
interface
WSDL
CORBA Services
RMI
Registry
UDDI
CORBA
Stubs/Skeletons
RMI
Stubs/Skelet
ons
SOAP Message
CDR binary
encoding
Java native
encoding serialization
IIOP
JRMP
HTTP
JVM
.NET/Apache Axis
TCP/IP/DataLink/Physical
Performance Metrics:
CPU speed: MHz or GHz, SPEC benchmarks like SPECINT
Network Bandwidth: Mbps or Gbps
System throughput: MIPS, TFlops (tera floating-point operations
per second), TPS (transactions per second), IOPS (IO operations
per second)
Other metrics: Response time, network latency, system availability
Scalability:
Scalability is the ability of a system to handle growing amount of
Scalability
Scale Vertically
To scale vertically (or scale up) means to add resources to a single
node in a system, typically involving the addition of CPUs or
memory to a single computer.
Tradeoffs
There are tradeoffs between the two models. Larger numbers of
computers means increased management complexity, as well as a
more complex programming model and issues such as throughput
and latency between nodes.
Also, some applications do not lend themselves to a distributed
computing model.
In the past, the price difference between the two models has
favored "scale up" computing for those applications that fit its
paradigm, but recent advances in virtualization technology have
blurred that advantage, since deploying a new virtual
system/server over a hypervisor is almost always less expensive
than actually buying and installing a real one.
Scalability
One form of scalability for parallel and distributed systems is:
Size Scalability
This refers to achieving higher performance or more functionality by
increasing the machine size. Size in this case refers to adding
processors, cache, memory, storage, or I/O channels.
Scale Horizontally and Vertically
Methods of adding more resources for a particular application fall into
two broad categories:
Scale Horizontally
To scale horizontally (or scale out) means to add more nodes to a
system, such as adding a new computer to a distributed software
application. An example might be scaling out from one Web server
system to three.
The scale-out model has created an increased demand for shared
data storage with very high I/O performance, especially where
processing of large amounts of data is required.
Amdahls Law
It is typically cheaper to add a new node to a system in order to
achieve improved performance than to perform performance tuning
to improve the capacity that each node can handle. But this approach
can have diminishing returns as indicated by Amdahls Law.
Consider the execution of a given program on a uniprocessor
workstation with a total execution time of T minutes. Now, lets say
that the program has been parallelized or partitioned for parallel
execution on a cluster of many processing nodes.
Assume that a fraction of the code must be executed sequentially,
called the sequential block. Therefore, (1 - ) of the code can be
compiled for parallel execution by n processors. The total execution
time of program is calculated by:
T + (1 - ) T / n
where the first term is the sequential execution time on a single
processor and the second term is the parallel execution time on n
processing nodes.
All system or communication overhead is ignored here. The I/O and
exception handling time is also not included in the speedup analysis.
Amdahls Law
Amdahls Law states that the Speedup Factor of using the nprocessor system over the use of a single processor is expressed by
Speedup = S = T / [ T + (1 - ) T / n]
= 1 / [ + (1 - ) / n]
The maximum speedup of n is achievable only when = 0, i.e. the
entire program is parallelizable.
As the cluster becomes sufficiently large, i.e. n , then S 1 / ,
an upper bound on the speedup S. This upper bound is
independent of the cluster size, n. The sequential bottleneck is the
portion of the code that cannot be parallelized.
Example, = 0.25 and so (1 0.25) = 0.75 then the maximum
speedup, S = 4 even if one uses hundreds of processors.
Amdahls Law teaches us that we should make the sequential
bottleneck as small as possible. Increasing the cluster size alone
may not result in a good speedup in this case.
Amdahls Law
System Efficiency
System Efficiency, E = S / n = 1 / [ n + (1 - ) ]
System efficiency can be rather low if the cluster size is very large.
Example: To execute a program on a cluster with n = 4, = 0.25 and so
(1 0.25) = 0.75,
E = 1 / [0.25 * 4 + 0.75] = 0.57 or 57%
Now if we have 256 nodes (i.e. n = 256)
E = 1 / [0.25 * 256 + 0.75] = 0.015 or 1.5%
This is because only a few processors (4, as in the previous case) are
kept busy, while the majority of the processors (or nodes) are left idling.
points of failure that bring down the entire system must be avoided
when designing distributed systems.