759 research outputs found
Optimal processor assignment for pipeline computations
The availability of large scale multitasked parallel architectures introduces the following processor assignment problem for pipelined computations. Given a set of tasks and their precedence constraints, along with their experimentally determined individual responses times for different processor sizes, find an assignment of processor to tasks. Two objectives are of interest: minimal response given a throughput requirement, and maximal throughput given a response time requirement. These assignment problems differ considerably from the classical mapping problem in which several tasks share a processor; instead, it is assumed that a large number of processors are to be assigned to a relatively small number of tasks. Efficient assignment algorithms were developed for different classes of task structures. For a p processor system and a series parallel precedence graph with n constituent tasks, an O(np2) algorithm is provided that finds the optimal assignment for the response time optimization problem; it was found that the assignment optimizing the constrained throughput in O(np2log p) time. Special cases of linear, independent, and tree graphs are also considered
Recommended from our members
A mapping strategy for MIMD computers
In this paper, a heuristic mapping approach which maps parallel programs, described by precedence graphs, to MIMD architectures, described by system graphs, is presented. The complete execution time of a parallel program is used as a measure, and the concept of critical edges is utilized as the heuristic to guide the search for a better initial assignment and subsequent refinement. An important feature is the use of a termination condition of the refinement process. This is based on deriving a lower bound on the total execution time of the mapped program. When this has been reached, no further refinement steps are necessary. The algorithms have been implemented and applied to the mapping of random problem graphs to various system topologies, including hypercubes, meshes, and random graphs. The results show reductions in execution times of the mapped programs of up to 77 percent over random mapping
Spatio-temporal Edge Service Placement: A Bandit Learning Approach
Shared edge computing platforms deployed at the radio access network are
expected to significantly improve quality of service delivered by Application
Service Providers (ASPs) in a flexible and economic way. However, placing edge
service in every possible edge site by an ASP is practically infeasible due to
the ASP's prohibitive budget requirement. In this paper, we investigate the
edge service placement problem of an ASP under a limited budget, where the ASP
dynamically rents computing/storage resources in edge sites to host its
applications in close proximity to end users. Since the benefit of placing edge
service in a specific site is usually unknown to the ASP a priori, optimal
placement decisions must be made while learning this benefit. We pose this
problem as a novel combinatorial contextual bandit learning problem. It is
"combinatorial" because only a limited number of edge sites can be rented to
provide the edge service given the ASP's budget. It is "contextual" because we
utilize user context information to enable finer-grained learning and decision
making. To solve this problem and optimize the edge computing performance, we
propose SEEN, a Spatial-temporal Edge sErvice placemeNt algorithm. Furthermore,
SEEN is extended to scenarios with overlapping service coverage by
incorporating a disjunctively constrained knapsack problem. In both cases, we
prove that our algorithm achieves a sublinear regret bound when it is compared
to an oracle algorithm that knows the exact benefit information. Simulations
are carried out on a real-world dataset, whose results show that SEEN
significantly outperforms benchmark solutions
Edge Computing in the Dark: Leveraging Contextual-Combinatorial Bandit and Coded Computing
With recent advancements in edge computing capabilities, there has been a
significant increase in utilizing the edge cloud for event-driven and
time-sensitive computations. However, large-scale edge computing networks can
suffer substantially from unpredictable and unreliable computing resources
which can result in high variability of service quality. Thus, it is crucial to
design efficient task scheduling policies that guarantee quality of service and
the timeliness of computation queries. In this paper, we study the problem of
computation offloading over unknown edge cloud networks with a sequence of
timely computation jobs. Motivated by the MapReduce computation paradigm, we
assume each computation job can be partitioned to smaller Map functions that
are processed at the edge, and the Reduce function is computed at the user
after the Map results are collected from the edge nodes. We model the service
quality (success probability of returning result back to the user within
deadline) of each edge device as function of context (collection of factors
that affect edge devices). The user decides the computations to offload to each
device with the goal of receiving a recoverable set of computation results in
the given deadline. Our goal is to design an efficient edge computing policy in
the dark without the knowledge of the context or computation capabilities of
each device. By leveraging the \emph{coded computing} framework in order to
tackle failures or stragglers in computation, we formulate this problem using
contextual-combinatorial multi-armed bandits (CC-MAB), and aim to maximize the
cumulative expected reward. We propose an online learning policy called
\emph{online coded edge computing policy}, which provably achieves
asymptotically-optimal performance in terms of regret loss compared with the
optimal offline policy for the proposed CC-MAB problem
Quasirandom Load Balancing
We propose a simple distributed algorithm for balancing indivisible tokens on
graphs. The algorithm is completely deterministic, though it tries to imitate
(and enhance) a random algorithm by keeping the accumulated rounding errors as
small as possible.
Our new algorithm surprisingly closely approximates the idealized process
(where the tokens are divisible) on important network topologies. On
d-dimensional torus graphs with n nodes it deviates from the idealized process
only by an additive constant. In contrast to that, the randomized rounding
approach of Friedrich and Sauerwald (2009) can deviate up to Omega(polylog(n))
and the deterministic algorithm of Rabani, Sinclair and Wanka (1998) has a
deviation of Omega(n^{1/d}). This makes our quasirandom algorithm the first
known algorithm for this setting which is optimal both in time and achieved
smoothness. We further show that also on the hypercube our algorithm has a
smaller deviation from the idealized process than the previous algorithms.Comment: 25 page
- …