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.

As more and more service providers choose Cloud platforms, a resource
provider needs to provision runtime environments (REs) for heterogeneous
workloads in different scenarios. Previous work fails to resolve this issue in
several ways: (1) it fails to pay attention to diverse RE requirements, and
does not enable creating coordinated REs on demand; (2) few work investigates
coordinated resource provisioning for heterogeneous workloads.

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.

In this paper, we explore the limits of graphics processors (GPUs) for
general purpose parallel computing by studying problems that require highly
irregular data access patterns: parallel graph algorithms for list ranking and
connected components. Such graph problems represent a worst case scenario for
coalescing parallel memory accesses on GPUs which is critical for good GPU
performance. Our experimental study indicates that PRAM algorithms are a good
starting point for developing efficient parallel GPU methods but require
non-trivial modifications to ensure good GPU performance.

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 is the latest effort in delivering computing resources as a
service. It 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 centres - or "clouds". Whilst cloud computing is
gaining growing popularity in the IT industry, academia appeared to be lagging
behind the rapid developments in this field.

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).

We describe how we have used simultaneously ${\cal O}(10^3)$ nodes of the
EGEE Grid, accumulating ca. 300 CPU-years in 2-3 months, to determine an
important property of Quantum Chromodynamics. We explain how Grid resources
were exploited efficiently and with ease, using user-level overlay based on
Ganga and DIANE tools above standard Grid software stack. Application-specific
scheduling and resource selection based on simple but powerful heuristics
allowed to improve efficiency of the processing to obtain desired scientific
results by a specified deadline.

With increasing complexity of tourism business models and tasks, there is a
clear need of the next generation e-Tourism infrastructure to support flexible
automation, integration, computation, storage, and collaboration. Currently
several enabling technologies such as semantic Web, Web service, agent and grid
computing have been applied in the different e-Tourism applications, however
there is no a unified framework to be able to integrate all of them.

We focus on the problem of performing random walks efficiently in a
distributed network. Given bandwidth constraints, the goal is to minimize the
number of rounds required to obtain a random walk sample on an undirected
network. Despite the widespread use of random walks in distributed computing,
most algorithms that compute a random walk sample of length $\ell$ naively,
i.e., in $O(\ell)$ rounds.

In this paper we investigate performance of global communications in a
particular parallel code. The code simulates dynamics of expansion of premixed
spherical flames using an asymptotic model of Sivashinsky type and a spectral
numerical algorithm. As a result, the code heavily relies on global all-to-all
interprocessor communications implementing transposition of the distributed
data array in which numerical solution to the problem is stored.

Distributed abstract programs are a novel class of distributed optimization
problems where (i) the number of variables is much smaller than the number of
constraints and (ii) each constraint is associated to a network node. Abstract
optimization programs are a generalization of linear programs that captures
numerous geometric optimization problems.

The ScotGrid distributed Tier-2 now provides more that 4MSI2K and 500TB for
LHC computing, which is spread across three sites at Durham, Edinburgh and
Glasgow. Tier-2 sites have a dual role to play in the computing models of the
LHC VOs. Firstly, their CPU resources are used for the generation of Monte
Carlo event data. Secondly, the end user analysis data is distributed across
the grid to the site's storage system and held on disk ready for processing by
physicists' analysis jobs.

The increasing use of model-based tools enables further use of formal
verification techniques in the context of distributed real-time systems. To
avoid state explosion, it is necessary to construct verification models that
focus on the aspects under consideration.

In this correspondence, we present an algorithm for distributed sensor
localization with noisy distance measurements (DILAND) that extends and makes
the DLRE more robust. DLRE is a distributed sensor localization algorithm in
$\mathbb{R}^m$ $(m\geq1)$ introduced in \cite{usman_loctsp:08}. DILAND operates
when (i) the communication among the sensors is noisy; (ii) the communication
links in the network may fail with a non-zero probability; and (iii) the
measurements performed to compute distances among the sensors are corrupted
with noise.

In this paper, we explore a unified treatment of the difficulty of reaching a
decision in constrained distributed computing environments in which there is a
lack of global coordination or knowledge. We show a general impossibility
result for a broad class of decision protocols. Importantly, our impossibility
result holds, in particular, for "asynchronous, distributed, historyless
computation", in which each computational node's selection of actions only
depends on the current actions of other nodes, even under the assumption that
no node can be faulty.

Failure detection is a fundamental building block for ensuring fault
tolerance in large scale distributed systems. There are lots of approaches and
implementations in failure detectors. Providing flexible failure detection in
off-the-shelf distributed systems is difficult. In this paper we present an
innovative solution to this problem. Our approach is based on adaptive,
decentralized failure detectors, capable of working asynchronous and
independent on the application flow.

Arguably, the original paradigm for computation was Logic Programming broadly
conceived as "deducing computational steps from existing information."

The idea has a long development that went through many twists in which
important questions turned out to have surprising answers, including the
following:

* How much of concurrent computation is reducible to deduction?

* Are the laws of thought consistent?

* Is "rapid recovery" a more viable policy than "inconsistency denial"?

Load balancing is the process of improving the Performance of a parallel and
distributed system through is distribution of load among the processors [1-2].
Most of the previous work in load balancing and distributed decision making in
general, do not effectively take into account the uncertainty and inconsistency
in state information but in fuzzy logic, we have advantage of using crisps
inputs.

A general class of unidirectional transforms is presented that can be
computed in a distributed manner along an arbitrary routing tree. Additionally,
we provide a set of conditions under which these transforms are invertible.
These transforms can be computed as data is routed towards the collection (or
sink) node in the tree and exploit data correlation between nodes in the tree.
Moreover, when used in wireless sensor networks, these transforms can also
leverage data received at nodes via broadcast wireless communications.

This paper presents greedy gossip with eavesdropping (GGE), a novel
randomized gossip algorithm for distributed computation of the average
consensus problem. In gossip algorithms, nodes in the network randomly
communicate with their neighbors and exchange information iteratively. The
algorithms are simple and decentralized, making them attractive for wireless
network applications. In general, gossip algorithms are robust to unreliable
wireless conditions and time varying network topologies. In this paper we
introduce GGE and demonstrate that greedy updates lead to rapid convergence.

Grid environment is a service oriented infrastructure in which many
heterogeneous resources participate to provide the high performance
computation. One of the bug issues in the grid environment is the vagueness and
uncertainty between advertised resources and requested resources. Furthermore,
in an environment such as grid dynamicity is considered as a crucial issue
which must be dealt with. Classical rough set have been used to deal with the
uncertainty and vagueness. But it can just be used on the static systems and
can not support dynamicity in a system.