Time plays a crucial role in the performance of computing systems. The
accurate modelling of logical devices, and of their physical implementations,
requires an appropriate representation of time and of all properties that
depend on this notion. The need for a proper model, particularly acute in the
design of clockless delay-insensitive (DI) circuits, leads one to reconsider
the classical descriptions of time and of the resulting order and causal
relations satisfied by logical operations.

Cellular Automata(CA) is a discrete computing model which provides simple,
flexible and efficient platform for simulating complicated systems and
performing complex computation based on the neighborhoods information. CA
consists of two components 1) a set of cells and 2) a set of rules .
Programmable Cellular Automata(PCA) employs some control signals on a Cellular
Automata(CA) structure.

Group management is a fundamental building block of today's Internet
applications. Mailing lists, chat systems, collaborative document edition but
also online social networks such as Facebook and Twitter use group management
systems. In many cases, group security is required in the sense that access to
data is restricted to group members only. Some applications also require
privacy by keeping group members anonymous and unlinkable. Group management
systems routinely rely on a central authority that manages and controls the
infrastructure and data of the system.

It is not an easy task to securely maintain all essential data where it has
the need in many applications for clients in cloud. To maintain our data in
cloud, it may not be fully trustworthy because client doesn't have copy of all
stored data. But any authors don't tell us data integrity through its user and
CSP level by comparison before and after the data update in cloud. So we have
to establish new proposed system for this using our data reading protocol
algorithm to check the integrity of data before and after the data insertion in
cloud.

High fidelity simulation of large-sized complex networks can be realized on a
distributed computing platform that leverages the combined resources of
multiple processors or machines. In a discrete event driven simulation, the
assignment of logical processes (LPs) to machines is a critical step that
affects the computational and communication burden on the machines, which in
turn affects the simulation execution time of the experiment. We study a
network partitioning game wherein each node (LP) acts as a selfish player.

In our work we present two parallel algorithms and their lock-free
implementations using a popular GPU environment Nvidia CUDA. The first
algorithm is the push-relabel method for the flow problem in grid graphs. The
second is the cost scaling algorithm for the assignment problem in complete
bipartite graphs.

This paper addresses the consensus problem in homonymous distributed systems
where processes are prone to crash failures and have no initial knowledge of
the system membership ("homonymous" means that several processes may have the
same identifier). New classes of failure detectors suited to these systems are
first defined. Among them, the classes H\Omega\ and H\Sigma\ are introduced
that are the homonymous counterparts of the classes \Omega\ and \Sigma,
respectively.

This paper proposes a simple and scalable web-based model for grid resource
discovery for the Internet. The resource discovery model contains the metadata
and resource finder web services. The information of resource finder web
services is kept in the repositories that are distributed in the application
layer of Internet. The resource finder web services will be discovered by
sending queries to the repositories in a similar way as the DNS protocol. The
underlying technology for implementation of the two architectures of this model
is introduced.

Exascale systems, expected to emerge by the end of the next decade, will
require the exploitation of billion-way parallelism at multiple hierarchical
levels in order to achieve the desired sustained performance. The task of
assessing future machine performance is approached by identifying the factors
which currently challenge the scalability of parallel applications.

Virtualization has become commonplace in modern data centers, often referred
as "computing clouds". The capability of virtual machine live migration brings
benefits such as improved performance, manageability and fault tolerance, while
allowing workload movement with a short service downtime. However, service
levels of applications are likely to be negatively affected during a live
migration. For this reason, a better understanding of its effects on system
performance is desirable.

The continuously increasing amount of digital data generated by today's
society asks for better storage solutions.

Clustering problems have numerous applications and are becoming more
challenging as the size of the data increases. In this paper, we consider
designing clustering algorithms that can be used in MapReduce, the most popular
programming environment for processing large datasets. We focus on the
practical and popular clustering problems, $k$-center and $k$-median. We
develop fast clustering algorithms with constant factor approximation
guarantees.

We consider the problems of deterministic broadcasting and gossiping in
completely unknown ad-hoc radio networks. We assume that nothing is known to
the nodes about the topology or even the size of the network, $n$, except that
$n > 1$. Protocols for vanilla model, when $n$ is known, may be run for
increasingly larger estimates $2^i$ on the size of the network, but one cannot
determine when such a protocol should terminate. Thus, to carry this design
paradigm, successful completion or in-completion of the process should be
detected, and this knowledge circulated in the network.

We study the problem of cooperative localization of a large network of nodes
in integer-coordinated unit disk graphs, a simplified but useful version of
general random graph. Exploiting the property that the radius $r$ sets clear
cut on the connectivity of two nodes, we propose an essential philosophy that
"no connectivity is also useful information just like the information being
connected" in unit disk graphs.

Wireless sensor networks (WSNs) are usually utilized to perform decision
fusion of event detection. Current decision fusion schemes are based on binary
valued decision and do not consider bursty contextcapture. However, bursty
context and multi-valued data are important characteristics of WSNs. One on
hand, the local decisions from sensors usually have bursty and contextual
characteristics. Fusion center must capture the bursty context information from
the sensors.

We compare the solvability of the Consensus and Broadcast problems in
synchronous communication networks in which the delivery of messages is not
reliable. The failure model is the mobile omission faults model. During each
round, some messages can be lost and the set of possible simultaneous losses is
the same for each round. We investigate these problems for the first time for
arbitrary sets of possible failures. Previously, these sets were defined by
bounding the numbers of failures.

At present there are a number of barriers to creating an energy efficient
workload scheduler for a Private Cloud based data center. Firstly, the
relationship between different workloads and power consumption must be
investigated. Secondly, current hardware-based solutions to providing energy
usage statistics are unsuitable in warehouse scale data centers where low cost
and scalability are desirable properties.

As a result of the phenomenal proliferation of modern mobile Internet-enabled
devices and the widespread utilization of wireless and cellular data networks,
mobile users are increasingly requiring services tailored to their current
context. High-level context information is typically obtained from context
services that aggregate raw context information sensed by various sensors and
mobile devices.

InfiniBand is a switched fabric interconnect. The InfiniBand specification
does not define an API. However the OFED package, libibverbs, has become the
default API on Linux and Solaris systems. Sparse documentation exists for the
verbs API. The simplest InfiniBand program provided by OFED, ibv_rc_pingpong,
is about 800 lines long. The semantics of using the verbs API for this program
is not obvious to the first time reader. This paper will dissect the
ibv_rc_pingpong program in an attempt to make clear to users how to interact
with verbs.

Exploiting the performance of today's microprocessors requires intimate
knowledge of the microarchitecture as well as an awareness of the ever-growing
complexity in thread and cache topology. LIKWID is a set of command line
utilities that addresses four key problems: Probing the thread and cache
topology of a shared-memory node, enforcing thread-core affinity on a program,
measuring performance counter metrics, and microbenchmarking for reliable upper
performance bounds.

Cloud computing is rapidly emerging as a new paradigm for delivering IT
services as utlity-oriented services on subscription-basis. The rapid
development of applications and their deployment in Cloud computing
environments in efficient manner is a complex task.

Many-core architectures of the future are likely to have distributed memory
organizations and need fine grained concurrency management to be used
effectively. The Self-adaptive Virtual Processor (SVP) is an abstract
concurrent programming model which can provide this, but the model and its
current implementations assume a single address space shared memory.

We consider the problem of maximizing the throughput of Byzantine consensus,
when communication links have finite capacity. Byzantine consensus is a
classical problem in distributed computing. In existing literature, the
communication links are implicitly assumed to have infinite capacity. The
problem changes significantly when the capacity of links is finite. We define
the throughput and capacity of consensus, and identify upper bound of
achievable consensus throughput.

Load balancing across a networked environment is a monotonous job. Moreover,
if the job to be distributed is a constraint satisfying one, the distribution
of load demands core intelligence. This paper proposes parallel processing
through Global Evaluation Function by means of randomly initialized agents for
solving Constraint Satisfaction Problems.

This paper analyzes the cache miss cost of algorithms when scheduled using
randomized work stealing (RWS) in a parallel environment, taking into account
the effects of false sharing.

First, prior analyses (due to Acar et al.) are extended to incorporate false
sharing. However, to control the possible delays due to false sharing, some
restrictions on the algorithms seem necessary. Accordingly, the class of
Hierarchical Tree algorithms is introduced and their performance analyzed.

The crux of software transactional memory (STM) is to combine an easy-to-use
programming interface with an efficient utilization of the concurrent computing
abilities provided by modern machines. But does this combination come with an
inherent cost? We evaluate the cost of concurrency by measuring the amount of
expensive synchronization that must be employed in an STM implementation that
ensures positive concurrency, i.e., allows for concurrent transaction
processing in some executions. We consider two popular progress conditions:
progressiveness and permissiveness.

Cloud providers, like Amazon, offer their data centers' computational and
storage capacities for lease to paying customers. High electricity consumption,
associated with running a data center, not only reflects on its carbon
footprint, but also increases the costs of running the data center itself. This
paper addresses the problem of maximizing the revenues of Cloud providers by
trimming down their electricity costs. As a solution allocation policies which
are based on the dynamic powering servers on and off are introduced and
evaluated.

Application-layer multicast implements the multicast functionality at the
application layer. The main goal of application-layer multicast is to construct
and maintain efficient distribution structures between endhosts. In this paper
we focus on the implementation of an application-layer multicast network using
PlanetLab. We observe that the total time required to measure network latency
over TCP is influenced dramatically by the TCP connection time.

Ant Colony Optimisation (ACO) is an effective population-based meta-heuristic
for the solution of a wide variety of problems. As a population-based
algorithm, its computation is intrinsically massively parallel, and it is
there- fore theoretically well-suited for implementation on Graphics Processing
Units (GPUs). The ACO algorithm comprises two main stages: Tour construction
and Pheromone update. The former has been previously implemented on the GPU,
using a task-based parallelism approach. However, up until now, the latter has
always been implemented on the CPU.

The general description of infrastructure and content of SciShop.ru computer
simulation center is given. This resource is a new form of knowledge generation
and remote education using modern Cloud Computing technologies.

The current trend of multicore architectures on shared memory systems
underscores the need of parallelism. While there are some programming model to
express parallelism, thread programming model has become a standard to support
these system such as OpenMP, and POSIX threads. MPI (Message Passing Interface)
which remains the dominant model used in high-performance computing today faces
this challenge.

Studies on the large scale peer-to-peer (P2P) network like Gnutella have
shown the presence of large number of free riders. Moreover, the open and
decentralized nature of P2P network is exploited by malicious users who
distribute unauthentic or harmful contents. Despite the existence of a number
of trust management schemes in the literature for combating against free riding
and distribution of malicious files, these mechanisms are not scalable due to
their high computational, communication and storage overhead.

Aggregation is an important building block of modern distributed
applications, allowing the determination of meaningful properties (e.g. network
size, total storage capacity, average load, majorities, etc.) that are used to
direct the execution of the system. However, the majority of the existing
aggregation algorithms exhibit relevant dependability issues, when prospecting
their use in real application environments. In this paper, we reveal some
dependability issues of aggregation algorithms based on iterative averaging
techniques, giving some directions to solve them.

We present and analyze a simple and general scheme to build a churn
(fault)-tolerant structured Peer-to-Peer (P2P) network. Our scheme shows how to
``convert" a static network into a dynamic distributed hash table(DHT)-based
P2P network such that all the good properties of the static network are
guaranteed with high probability (w.h.p). Applying our scheme to a
cube-connected cycles network, for example, yields a $O(\log N)$ degree
connected network, in which every search succeeds in $O(\log N)$ hops w.h.p.,
using $O(\log N)$ messages, where $N$ is the expected stable network size.

Internet of Things (IoT) and B3G/4G communication are promoting the pervasive
mobile services with its advanced features. However, security problems are also
baffled the development. This paper proposes a trust model to protect the
user's security. The billing or trust operator works as an agent to provide a
trust authentication for all the service providers. The services are classified
by sensitive value calculation. With the value, the user's trustiness for
corresponding service can be obtained.

It is an increasingly important issue to reduce the energy consumption of
computing systems. In this paper, we consider partition based energy-aware
scheduling of periodic real-time tasks on multicore processors. The scheduling
exploits dynamic voltage scaling (DVS) and core sleep scheduling to reduce both
dynamic and leakage energy consumption. If the overhead of core state switching
is non-negligible, however, the performance of this scheduling strategy in
terms of energy efficiency might degrade.

This paper describes and analyzes a hierarchical gossip algorithm for solving
the distributed average consensus problem in wireless sensor networks. The
network is recursively partitioned into subnetworks. Initially, nodes at the
finest scale gossip to compute local averages. Then, using geographic routing
to enable gossip between nodes that are not directly connected, these local
averages are progressively fused up the hierarchy until the global average is
computed.

In this paper, we continue our development of algorithms used for topological
network discovery. We present native P system versions of two fundamental
problems in graph theory: finding the maximum number of edge- and node-disjoint
paths between a source node and target node. We start from the standard
depth-first-search maximum flow algorithms, but our approach is totally
distributed, when initially no structural information is available and each P
system cell has to even learn its immediate neighbors.

Cloud-computing shares a common pool of resources across customers at a scale
that is orders of magnitude larger than traditional multi-user systems.
Constituent physical compute servers are allocated multiple "virtual machines"
(VM) to serve simultaneously. Each VM user should ideally be unaffected by
others' demand. Naturally, this environment produces new challenges for the
service providers in meeting customer expectations while extracting an
efficient utilization from server resources. We study a new cloud service
metric that measures prolonged latency or delay suffered by customers.

In Distributed Interactive Applications (DIA) such as multiplayer games,
where many participants are involved in a same game session and communicate
through a network, they may have an inconsistent view of the virtual world
because of the communication delays across the network. This issue becomes even
more challenging when communicating through a cellular network while executing
the DIA client on a mobile terminal. Consistency maintenance algorithms may be
used to obtain a uniform view of the virtual world.

We study the {edge-coloring} problem in the message-passing model of
distributed computing. This is one of the most fundamental and well-studied
problems in this area. Currently, the best-known deterministic algorithms for
(2Delta -1)-edge-coloring requires O(Delta) + log-star n time \cite{PR01},
where Delta is the maximum degree of the input graph.

Electing leader is a vital issue not only in distributed computing but also
in communication network [1, 2, 3, 4, 5], centralized mutual exclusion
algorithm [6, 7], centralized control IPC, etc. A leader is required to make
synchronization between different processes. And different election algorithms
are used to elect a coordinator among the available processes in the system
such a way that there will be only one coordinator at any time. Bully election
algorithm is one of the classical and well-known approaches in coordinator
election process.

While sharing resources the efficiency is substantially degraded as a result
of the scarceness of availability of the requested resources in a multiclient
support manner. These resources are often aggravated by many factors like the
temporal constraints for availability or node flooding by the requested
replicated file chunks. Thus replicated file chunks should be efficiently
disseminated in order to enable resource availability on-demand by the mobile
users.

Mobile applications are becoming increasingly ubiquitous and provide ever
richer functionality on mobile devices. At the same time, such devices often
enjoy strong connectivity with more powerful machines ranging from laptops and
desktops to commercial clouds. This paper presents the design and
implementation of CloneCloud, a system that automatically transforms mobile
applications to benefit from the cloud.

Component frameworks are complex systems that rely on many layers of
abstraction to function properly. One essential requirement is a consistent
means of describing each individual component and how it relates to both other
components and the whole framework. As component frameworks are designed to be
flexible by nature, the description method should be simultaneously powerful,
lead to efficient code, and be easy to use, so that new users can quickly adapt
their own code to work with the framework.

Managing cloud services is a fundamental challenge in todays virtualized
environments. These challenges equally face both providers and consumers of
cloud services. The issue becomes even more challenging in virtualized
environments that support mobile clouds. Cloud computing platforms such as
Amazon EC2 provide customers with flexible, on demand resources at low cost.
However, they fail to provide seamless infrastructure management and monitoring
capabilities that many customers may need.

We present a new record on computing specific bits of Pi, the mathematical
constant, and discuss performing such computations on Apache Hadoop clusters.
The specific bits represented in hexadecimal are 0E6C1294 AED40403 F56D2D76
4026265B CA98511D 0FCFFAA1 0F4D28B1 BB5392B8. These 256 bits end at the
2,000,000,000,000,252nd bit position, which doubles the previous known record.
The position of the first bit is 1,999,999,999,999,997 and the value of the two
quadrillionth bit is 0. The computation is carried out by a MapReduce program
called DistBbp.

We present MPWide, a platform independent communication library for
performing message passing between computers. Our library allows coupling of
several local MPI applications through a long distance network and is
specifically optimized for such communications. The implementation is
deliberately kept light-weight, platform independent and the library can be
installed and used without administrative privileges.

Cloud computing promises a radical shift in the provisioning of computing
resource within the enterprise. This paper describes the challenges that
decision makers face when assessing the feasibility of the adoption of cloud
computing in their organisations, and describes our Cloud Adoption Toolkit,
which has been developed to support this process. The toolkit provides a
framework to support decision makers in identifying their concerns, and
matching these concerns to appropriate tools/techniques that can be used to
address them.

This paper considers parallel Gr\"obner bases algorithms on distributed
memory parallel computers with multi-core compute nodes. We summarize three
different Gr\"obner bases implementations: shared memory parallel, pure
distributed memory parallel and distributed memory combined with shared memory
parallelism. The last algorithm, called distributed hybrid, uses only one
control communication channel between the master node and the worker nodes and
keeps polynomials in shared memory on a node.

Implementing a component-based system in a distributed way so that it ensures
some global constraints is a challenging problem. We consider here abstract
specifications consisting of a composition of components and a controller given
in the form of a set of interactions and a priority order amongst them. In the
context of distributed systems, such a controller must be executed in a
distributed fashion while still respecting the global constraints imposed by
interactions and priorities.

As energy proportional computing has extended the success of DVFS (Dynamic
voltage and frequency scaling) to the entire system, DVFS control algorithms
will play a key role in reducing server clusters' power consumption. The focus
of this paper is to provide accurate cluster-level DVFS control for power
saving in a server cluster. To achieve this goal, we propose a request tracing
approach that online classifies the major causal path patterns and monitors
their performance data as a guide for accurate DVFS control.

Consider an asynchronous network in a shared-memory environment consisting of
n nodes. Assume that up to f of the nodes might be Byzantine (n > 12f), where
the adversary is full-information and dynamic (sometimes called adaptive). In
addition, the non-Byzantine nodes may undergo transient failures. Nodes advance
in atomic steps, which consist of reading all registers, performing some
calculation and writing to all registers.

The focus of this work is on the analysis of transmit beamforming schemes
with a low-rate feedback link in wireless sensor/relay networks, where nodes in
the network need to implement beamforming in a distributed manner.
Specifically, the problem of distributed phase alignment is considered, where
neither the transmitters nor the receiver has perfect channel state
information, but there is a low-rate feedback link from the receiver to the
transmitters. In this setting, a framework is proposed for systematically
analyzing the performance of distributed beamforming schemes.

This paper presents a simple local medium access control protocol, called
\textsc{Jade}, for multi-hop wireless networks with a single channel that is
provably robust against adaptive adversarial jamming. The wireless network is
modeled as a unit disk graph on a set of nodes distributed arbitrarily in the
plane. In addition to these nodes, there are adversarial jammers that know the
protocol and its entire history and that are allowed to jam the wireless
channel at any node for an arbitrary $(1-\epsilon)$-fraction of the time steps,
where $0<\epsilon<1$ is an arbitrary constant.

Gradecast is a simple three-round algorithm presented by Feldman and Micali.
The current work presents a very simple algorithm that utilized Gradecast to
achieve Byzantine agreement. Two small variations of the presented algorithm
lead to improved algorithms for solving the Approximate agreement problem and
the Multi-consensus problem.

An optimal approximate agreement algorithm was presented by Fekete, which
supports up to 1/4 n Byzantine nodes and has message complexity of O(n^k),
where n is the number of nodes and k is the number of rounds.

As known, physical circuits, e.g. integrated circuits or power system, work
in a distributed manner, but these circuits could not be easily simulated in a
distributed way. This is mainly because that the dynamical system of physical
circuits is nonlinear and the linearized system of physical circuits is
non-symmetrical. This paper proposes a simple and natural strategy to simulate
the physical circuit in parallel, by mimicking the internal wires or
interconnects inside the circuits by distributed numerical algorithm.

In this paper we describe an architecture which: Permits the deployment and
execution of components in appropriate geographical locations. Provides
security mechanisms that prevent misuse of the architecture. Supports a
programming model that is familiar to application programmers. Permits
installed components to share data. Permits the deployed components to
communicate via communication channels. Provides evolution mechanisms
permitting the dynamic rearrangement of inter-connection topologies the
components that they connect.

Random ring-based overlay networks have been used to study the small world
phenomenon and model fault-tolerant peer-to-peer systems (Kleinberg, 2006). It
has been shown that when each of $n$ nodes has $\ell = O(\log n)$ links,
assigning contacts according to an inverse power-law distance distribution
allows greedy routing to perform in $O(\log^2 n / \ell)$ steps (Aspnes et al.
2002). In this paper, we generalize this result by showing the same upper bound
holds when nodes are assigned a random number of links according to an
arbitrary distribution with mean $\ell$.

Pervasive services may be defined as services that are available "to any
client (anytime, anywhere)". Here we focus on the software and network
infrastructure required to support pervasive contextual services operating over
a wide area. One of the key requirements is a matching service capable of
as-similating and filtering information from various sources and determining
matches relevant to those services.

We propose a framework for the deployment and subsequent autonomic management
of component-based distributed applications. An initial deployment goal is
specified using a declarative constraint language, expressing constraints over
aspects such as component-host mappings and component interconnection topology.
A constraint solver is used to find a configuration that satisfies the goal,
and the configuration is deployed automatically. The deployed application is
instrumented to allow subsequent autonomic management.

Concurrent garbage collectors are notoriously difficult to implement
correctly. Previous approaches to the issue of producing correct collectors
have mainly been based on posit-and-prove verification or on the application of
domain-specific templates and transformations. We show how to derive the upper
reaches of a family of concurrent garbage collectors by refinement from a
formal specification, emphasizing the application of domain-independent design
theories and transformations.

We present our approach for deploying and managing distributed
component-based applications. A Desired State Description (DSD), written in a
high-level declarative language, specifies requirements for a distributed
application. Our infrastructure accepts a DSD as input, and from it
automatically configures and deploys the distributed application. Subsequent
violations of the original requirements are detected and, where possible,
automatically rectified by reconfiguration and redeployment of the necessary
application components.

We describe an approach to modelling a Byzantine tolerant distributed
algorithm as a family of related finite state machines, generated from a single
meta-model. Various artefacts are generated from each state machine, including
diagrams and source-level protocol implementations. The approach allows a state
machine formulation to be applied to problems for which it would not otherwise
be suitable, increasing confidence in correctness.

Bandwidth-starved multicore chips have become ubiquitous. It is well known
that the performance of stencil codes can be improved by temporal blocking,
lessening the pressure on the memory interface. We introduce a new pipelined
approach that makes explicit use of shared caches in multicore environments and
minimizes synchronization and boundary overhead. Benchmark results are
presented for three current x86-based microprocessors, showing clearly that our
optimization works best on designs with high-speed shared caches and low memory
bandwidth per core.

In this paper, a method for efficient scheduling to obtain optimum job
throughput in a distributed campus grid environment is presented; Traditional
job schedulers determine job scheduling using user and job resource attributes.
User attributes are related to current usage, historical usage, user priority
and project access. Job resource attributes mainly comprise of soft
requirements (compilers, libraries) and hard requirements like memory, storage
and interconnect. A job scheduler dispatches jobs to a resource if a job's hard
and soft requirements are met by a resource.

Cloud Data Servers is the novel approach for providing secure service to
e-business .Millions of users are surfing the Cloud for various purposes,
therefore they need highly safe and persistent services. Usually hackers target
particular Operating Systems or a Particular Controller. Inspiteof several
ongoing researches Conventional Web Servers and its Intrusion Detection System
might not be able to detect such attacks. So we implement a Cloud Data Server
with Session Controller Architecture using Redundancy and Disconnected Data
Access Mechanism.

A simple method for improving cache efficiency of serial and parallel
explicit finite procedure with application to casting solidification simulation
over three-dimensional complex geometries is presented. The method is based on
division of the global data to smaller blocks and treating each block
independently from others at each time step. A novel parallel finite element
algorithm for non-overlapped element-base decomposed domain is presented for
implementation of serial and parallel version of the presented method. Effect
of mesh reordering on the efficiency is also investigated.

This paper presents the overall design of a multi-agent framework for tuning
the performance of an application executing in a distributed environment. The
multi-agent framework provides services like resource brokering, analyzing
performance monitoring data, local tuning and also rescheduling in case of any
performance problem on a specific resource provider. The paper also briefly
describes the implementation of some part of the framework. In particular, job
migration on the basis of performance monitoring data is particularly
highlighted in this paper.

Efficiency and simplicity of random algorithms have made them a lucrative
alternative for solving complex problems in the domain of communication
networks. This paper presents a random algorithm for handling the routing
problem in Mobile Ad hoc Networks [MANETS].The performance of most existing
routing protocols for MANETS degrades in terms of packet delay and congestion
caused as the number of mobile nodes increases beyond a certain level or their
speed passes a certain level.

The condition of $t$-resilience stipulates that an $n$-process program is
only obliged to make progress when at least $n-t$ processes are correct. Put
another way, the \emph{live sets}, the collection of process sets such that
progress is required if all the processes in one of these sets are correct, are
all sets with at least $n-t$ processes. In this paper we study what happens
when the live sets are any arbitrary collection of sets $\L$.

Computational Grid is enormous environments with heterogeneous resources and
stable infrastructures among other Internet-based computing systems. However,
the managing of resources in such systems has its special problems. Scheduler
systems need to get last information about participant nodes from information
centers for the purpose of firmly job scheduling. In this paper, we focus on
online updating resource information centers with processed and provided data
based on the assumed hierarchical model.

Tree-based protocols are ubiquitous in distributed systems. They are
flexible, they perform generally well, and, in static conditions, their
analysis is mostly simple. Under churn, however, node joins and failures can
have complex global effects on the tree overlays, making analysis surprisingly
subtle. To our knowledge, few prior analytic results for performance estimation
of tree based protocols under churn are currently known. We study a simple
Bellman-Ford-like protocol which performs network size estimation over a
tree-shaped overlay.

Exploiting the performance of today's processors requires, apart from an
intimate knowledge of the microarchitecture, taking into account the influence
of an ever-growing complexity in thread and cache topology. LIKWID is a
collection of small command line applications that support inexperienced as
well as seasoned programmers in developing and running software in an efficient
way. The development of LIKWID is targeted on providing access to
performance-oriented tooling in a transparent and easy manner.

We propose different implementations of the sparse matrix--dense vector
multiplication (\spmv{}) for finite fields and rings $\Zb/m\Zb$. We take
advantage of graphic card processors (GPU) and multi-core architectures. Our
aim is to improve the speed of \spmv{} in the \linbox library, and henceforth
the speed of its black box algorithms. Besides, we use this and a new
parallelization of the sigma-basis algorithm in a parallel block Wiedemann rank
implementation over finite fields.

This paper focuses on data structures for multi-core reachability, which is a
key component in model checking algorithms and other verification methods. A
cornerstone of an efficient solution is the storage of visited states. In
related work, static partitioning of the state space was combined with
thread-local storage and resulted in reasonable speedups, but left open whether
improvements are possible.

P2P overlays provide a framework for building distributed applications
consisting of few to many resources with features including self-configuration,
scalability, and resilience to node failures. Such systems have been
successfully adopted in large-scale services for content delivery networks,
file sharing, and data storage. In small-scale systems, they can be useful to
address privacy concerns and for network applications that lack dedicated
servers. The bootstrap problem, finding an existing peer in the overlay,
remains a challenge to enabling these services for small-scale P2P systems.

After decades of engineering development and infrastructural investment,
Internet connections have become commodity product in many countries, and
Internet scale "cloud computing" has started to compete with traditional
software business through its technological advantages and economy of scale.
Cloud computing is a promising enabling technology of Internet ware Cloud
Computing is termed as the next big thing in the modern corporate world.

The basic idea behind Cloud computing is that resource providers offer
elastic resources to end users. In this paper, we intend to answer one key
question to the success of Cloud computing: in Cloud, can small or medium-scale
scientific computing communities benefit from the economies of scale?

Modern large-scale date centres, such as those used for cloud computing
service provision, are becoming ever-larger as the operators of those data
centres seek to maximise the benefits from economies of scale. With these
increases in size comes a growth in system complexity, which is usually
problematic. There is an increased desire for automated "self-star"
configuration, management, and failure-recovery of the data-centre
infrastructure, but many traditional techniques scale much worse than linearly
as the number of nodes to be managed increases.

This paper presents two conceptually simple methods for parallelizing a
Parallel Tempering Monte Carlo simulation in a distributed volunteer computing
context, where computers belonging to the general public are used. The first
method uses conventional multi-threading. The second method uses CUDA, a
graphics card computing system. Parallel Tempering is described, and challenges
such as parallel random number generation and mapping of Monte Carlo chains to
different threads are explained.

This paper defines a class of labeled stratified order structures that
characterizes exactly the notion of combined traces (i.e., comtraces) proposed
by Janicki and Koutny in 1995. Our main technical contributions are the
representation theorems showing that comtrace quotient monoid, combined
dependency graph (Kleijn and Koutny 2008) and our labeled stratified order
structure characterization are three different and yet equivalent ways to
represent comtraces.

The study of high-dimensional differential equations is challenging and
difficult due to the analytical and computational intractability. Here, we
significantly improve the speed of waveform relaxation (WR), a method to
simulate high-dimensional differential-algebraic equations. This new method
termed adaptive waveform relaxation (AWR) is tested on a communication network
example. Further we analyze different heuristics for computing graph partitions
tailored to adaptive waveform relaxation.

Minimizing waiting time for tasks waiting in the queue for execution is one
of the important scheduling cri-teria which took a wide area in scheduling
preemptive tasks. In this paper we present Changeable Time Quan-tum (CTQ)
approach combined with the round-robin algorithm, we try to adjust the time
quantum according to the burst times of the tasks in the ready queue.

Computing as you know it is about to change, your applications and documents
are going to move from the desktop into the cloud. I'm talking about cloud
computing, where applications and files are hosted on a "cloud" consisting of
thousands of computers and servers, all linked together and accessible via the
Internet. With cloud computing, everything you do is now web based instead of
being desktop based. You can access all your programs and documents from any
computer that's connected to the Internet. How will cloud computing change the
way you work?

Cloud computing promises a radical shift in the provisioning of computing
resource within enterprise.

Intensive experiences show and confirm that grid environments can be
considered as the most promising way to solve several kinds of problems
relating either to cooperative work especially where involved collaborators are
dispersed geographically or to some very greedy applications which require
enough power of computing or/and storage. Such environments can be classified
into two categories; first, dedicated grids where the federated computers are
solely devoted to a specific work through its end.

We consider the problem of developing an efficient multi-threaded
implementation of the matrix-vector multiplication algorithm for sparse
matrices with structural symmetry. Matrices are stored using the compressed
sparse row-column format (CSRC), designed for profiting from the symmetric
non-zero pattern observed in global finite element matrices. Unlike classical
compressed storage formats, performing the sparse matrix-vector product using
the CSRC requires thread-safe access to the destination vector. To avoid race
conditions, we have implemented two partitioning strategies.

Previous work shows request tracing systems help understand and debug the
performance problems of multi-tier services. However, for large-scale data
centers, more than hundreds of thousands of service instances provide online
service at the same time. Previous work such as white-box or black box tracing
systems will produce large amount of log data, which would be correlated into
large quantities of causal paths for performance debugging. In this paper, we
propose an innovative algorithm to eliminate valueless logs of multitiers
services.

As more and more multi-tier services are developed from commercial components
or heterogeneous middleware without the source code available, both developers
and administrators need a precise request tracing tool to help understand and
debug performance problems of large concurrent services of black boxes.
Previous work fails to resolve this issue in several ways: they either accept
the imprecision of probabilistic correlation methods, or rely on knowledge of
protocols to isolate requests in pursuit of tracing accuracy.

We consider how underused computing resources within an enterprise may be
harnessed to improve utilization and create an elastic computing
infrastructure. Most current cloud provision involves a data center model, in
which clusters of machines are dedicated to running cloud infrastructure
software. We propose an additional model, the ad hoc cloud, in which
infrastructure software is distributed over resources harvested from machines
already in existence within an enterprise.

We present and evaluate GPU Bucket Sort, a parallel deterministic sample sort
algorithm for many-core GPUs. Our method is considerably faster than Thrust
Merge (Satish et.al., Proc. IPDPS 2009), the best comparison-based sorting
algorithm for GPUs, and it is as fast as the new randomized sample sort for
GPUs by Leischner et.al. (to appear in Proc. IPDPS 2010). Our deterministic
sample sort has the advantage that bucket sizes are guaranteed and therefore
its running time does not have the input data dependent fluctuations that can
occur for randomized sample sort.

For a large organization, different departments often maintain dedicated
cluster systems for different workloads, for example parallel batch jobs or Web
services. In this paper, we design and implement an innovative cloud computing
system software, Phoenix Cloud, to consolidate heterogeneous workloads of the
same organization on cloud computing platforms. For Phoenix Cloud, we propose
cooperative resource provision and management polices for the affiliated
departments of a large organization to share cluster systems.

Outlier detection in data streams has gained wide importance presently due to
the increasing cases of fraud in various applications of data streams. The
techniques for outlier detection have been divided into either statistics
based, distance based, density based or deviation based. Till now, most of the
work in the field of fraud detection was distance based but it is incompetent
from computational point of view. In this paper we introduced a new clustering
based approach, which divides the stream in chunks and clusters each chunk
using kmedian into variable number of clusters.

We consider a Mobile Ad-hoc NETwork (MANET) formed by n agents that move at
speed V according to the Manhattan Random-Way Point model over a square region
of side length L. The resulting stationary (agent) spatial probability
distribution is far to be uniform: the average density over the "central zone"
is asymptotically higher than that over the "suburb". Agents exchange data iff
they are at distance at most R within each other.

This paper considers N mobile nodes that move together in the vicinity of
each other, whose initial poses as well as subsequent movements must be
accurately tracked in real time with the assist of M(>=3) reference nodes. By
engaging the neighboring mobile nodes in a simple but effective cooperation,
and by exploiting both the time-of-arrival (TOA) information (between mobile
nodes and reference nodes) and the received-signal-strength (RSS) information
(between mobile nodes), an effective new localization strategy, termed
cooperative TOA and RSS (COTAR), is developed.

In this paper, we demonstrate, both theoretically and by numerical examples,
that adding a local prediction component to the update rule can significantly
improve the convergence rate of distributed averaging algorithms. We focus on
the case where the local predictor is a linear combination of the node's two
previous values (i.e., two memory taps), and our update rule computes a
combination of the predictor and the usual weighted linear combination of
values received from neighbouring nodes.

The purpose of this paper is to show how existing scientific software can be
parallelized using a separate thin layer of Python code where all parallel
communication is implemented. We provide specific examples on such layers of
code, and these examples may act as templates for parallelizing a wide set of
serial scientific codes. The use of Python for parallelization is motivated by
the fact that the language is well suited for reusing existing serial codes
programmed in other languages.

A local algorithm is a distributed algorithm that completes after a constant
number of synchronous communication rounds. We present local approximation
algorithms for the minimum dominating set problem and the maximum matching
problem in 2-coloured and weakly 2-coloured graphs. In a weakly 2-coloured
graph, both problems admit a local algorithm with the approximation factor
$(\Delta+1)/2$, where $\Delta$ is the maximum degree of the graph. We also give
a matching lower bound proving that there is no local algorithm with a better
approximation factor for either of these problems.

This paper deals with generating of an optimized route for multiple Vehicle
routing Problems (mVRP). We used a methodology of clustering the given cities
depending upon the number of vehicles and each cluster is allotted to a
vehicle. k- Means clustering algorithm has been used for easy clustering of the
cities. In this way the mVRP has been converted into VRP which is simple in
computation compared to mVRP. After clustering, an optimized route is generated
for each vehicle in its allotted cluster.

With a goal of supporting the timely and cost-effective analysis of Terabyte
datasets on commodity components, we present and evaluate StoreTorrent, a
simple distributed filesystem with integrated fault tolerance for efficient
handling of small data records. Our contributions include an application-OS
pipelining technique and metadata structure to increase small write and read
performance by a factor of 1-10, and the use of peer-to-peer communication of
replica-location indexes to avoid transferring data during parallel analysis
even in a degraded state.

This thesis introduces PEMS2, an improvement to PEMS (Parallel External
Memory System). PEMS executes Bulk-Synchronous Parallel (BSP) algorithms in an
External Memory (EM) context, enabling computation with very large data sets
which exceed the size of main memory. Many parallel algorithms have been
designed and implemented for Bulk-Synchronous Parallel models of computation.
Such algorithms generally assume that the entire data set is stored in main
memory at once.

Cloud computing represents a shift away from computing as a product that is
purchased, to computing as a service that is delivered to consumers over the
internet from large-scale data centers - or "clouds". This paper discusses some
of the research challenges for cloud computing from an enterprise or
organizational perspective, and puts them in context by reviewing the existing
body of literature in cloud computing.

In present study, in order to improve the performance and reduce the amount
of power which is dissipated in heterogeneous multicore processors, the ability
of detecting the program execution phases is investigated. The programs
execution intervals have been classified in different phases based on their
throughput and the utilization of the cores. The results of implementing the
phase detection technique are investigated on a single core processor and also
on a multicore processor.

Integer factorization is a very hard computational problem. Currently no
efficient algorithm for integer factorization is publicly known. However, this
is an important problem on which it relies the security of many real world
cryptographic systems.

I present an implementation of a fast factorization algorithm on MapReduce.
MapReduce is a programming model for high performance applications developed
originally at Google. The quadratic sieve algorithm is split into the different
MapReduce phases and compared against a standard implementation.

Previous studies have reported that common dense linear algebra operations do
not achieve speed up by using multiple geographical sites of a computational
grid. Because such operations are the building blocks of most scientific
applications, conventional supercomputers are still strongly predominant in
high-performance computing and the use of grids for speeding up large-scale
scientific problems is limited to applications exhibiting parallelism at a
higher level.

Coordination in distributed environments, like Grids, involves selecting the
most appropriate services, resources or compositions to carry out the planned
activities. Such functionalities appear at various levels of the infrastructure
and in various means forming a blurry domain, where it is hard to see how the
participating components are related and what their relevant properties are. In
this paper we focus on a subset of these problems: resource brokering in Grid
middleware.

Many clustering schemes have been proposed for ad hoc networks. A systematic
classification of these clustering schemes enables one to better understand and
make improvements. In mobile ad hoc networks, the movement of the network nodes
may quickly change the topology resulting in the increase of the overhead
message in topology maintenance. Protocols try to keep the number of nodes in a
cluster around a pre-defined threshold to facilitate the optimal operation of
the medium access control protocol.

This chapter presents: (i) a layered peer-to-peer Cloud provisioning
architecture; (ii) a summary of the current state-of-the-art in Cloud
provisioning with particular emphasis on service discovery and load-balancing;
(iii) a classification of the existing peer-to-peer network management model
with focus on extending the DHTs for indexing and managing complex provisioning
information; and (iv) the design and implementation of novel, extensible
software fabric (Cloud peer) that combines public/private clouds, overlay
networking and structured peer-to-peer indexing techniques for supporting
s

This tutorial presents a recipe for the construction of a compute cluster for
processing large volumes of data, using cheap, easily available personal
computer hardware (Intel/AMD based PCs) and freely available open source
software (Ubuntu Linux, Apache Hadoop).