241,235 research outputs found
Towards native higher-order remote procedure calls
We present a new abstract machine, called DCESH, which mod-els the execution of higher-order programs running in distributed architectures. DCESH implements a native general remote higher-order function call across node boundaries. It is a modernised ver-sion of SECD enriched with specialised communication features required for implementing the remote procedure call mechanism. The key correctness result is that the termination behaviour of the remote procedure call is indistinguishable (bisimilar) to that of a local call. The correctness proofs and the requisite definitions for DCESH and other related abstract machines are formalised using Agda. We also formalise a generic transactional mechanism for transparently handling failure in DCESHs. We use the DCESH as a target architecture for compiling a conventional call-by-value functional language ("Floskel") whic
Dynamic Algorithms for the Massively Parallel Computation Model
The Massive Parallel Computing (MPC) model gained popularity during the last
decade and it is now seen as the standard model for processing large scale
data. One significant shortcoming of the model is that it assumes to work on
static datasets while, in practice, real-world datasets evolve continuously. To
overcome this issue, in this paper we initiate the study of dynamic algorithms
in the MPC model.
We first discuss the main requirements for a dynamic parallel model and we
show how to adapt the classic MPC model to capture them. Then we analyze the
connection between classic dynamic algorithms and dynamic algorithms in the MPC
model. Finally, we provide new efficient dynamic MPC algorithms for a variety
of fundamental graph problems, including connectivity, minimum spanning tree
and matching.Comment: Accepted to the 31st ACM Symposium on Parallelism in Algorithms and
Architectures (SPAA 2019
Pregelix: Big(ger) Graph Analytics on A Dataflow Engine
There is a growing need for distributed graph processing systems that are
capable of gracefully scaling to very large graph datasets. Unfortunately, this
challenge has not been easily met due to the intense memory pressure imposed by
process-centric, message passing designs that many graph processing systems
follow. Pregelix is a new open source distributed graph processing system that
is based on an iterative dataflow design that is better tuned to handle both
in-memory and out-of-core workloads. As such, Pregelix offers improved
performance characteristics and scaling properties over current open source
systems (e.g., we have seen up to 15x speedup compared to Apache Giraph and up
to 35x speedup compared to distributed GraphLab), and makes more effective use
of available machine resources to support Big(ger) Graph Analytics
An EPTAS for machine scheduling with bag-constraints
Machine scheduling is a fundamental optimization problem in computer science.
The task of scheduling a set of jobs on a given number of machines and
minimizing the makespan is well studied and among other results, we know that
EPTAS's for machine scheduling on identical machines exist. Das and Wiese
initiated the research on a generalization of makespan minimization, that
includes so called bag-constraints. In this variation of machine scheduling the
given set of jobs is partitioned into subsets, so called bags. Given this
partition a schedule is only considered feasible when on any machine there is
at most one job from each bag.
Das and Wiese showed that this variant of machine scheduling admits a PTAS.
We will improve on this result by giving the first EPTAS for the machine
scheduling problem with bag-constraints. We achieve this result by using new
insights on this problem and restrictions given by the bag-constraints. We show
that, to gain an approximate solution, we can relax the bag-constraints and
ignore some of the restrictions. Our EPTAS uses a new instance transformation
that will allow us to schedule large and small jobs independently of each other
for a majority of bags. We also show that it is sufficient to respect the
bag-constraint only among a constant number of bags, when scheduling large
jobs. With these observations our algorithm will allow for some conflicts when
computing a schedule and we show how to repair the schedule in polynomial-time
by swapping certain jobs around
- …