16,903 research outputs found
Optimal Placement Algorithms for Virtual Machines
Cloud computing provides a computing platform for the users to meet their
demands in an efficient, cost-effective way. Virtualization technologies are
used in the clouds to aid the efficient usage of hardware. Virtual machines
(VMs) are utilized to satisfy the user needs and are placed on physical
machines (PMs) of the cloud for effective usage of hardware resources and
electricity in the cloud. Optimizing the number of PMs used helps in cutting
down the power consumption by a substantial amount.
In this paper, we present an optimal technique to map virtual machines to
physical machines (nodes) such that the number of required nodes is minimized.
We provide two approaches based on linear programming and quadratic programming
techniques that significantly improve over the existing theoretical bounds and
efficiently solve the problem of virtual machine (VM) placement in data
centers
Scheduling Parallel Jobs with Linear Speedup
We consider a scheduling problem where a set of jobs is distributed over parallel machines. The processing time of any job is dependent on the usage of a scarce renewable resource, e.g., personnel. An amount of k units of that resource can be allocated to the jobs at any time, and the more of that resource is allocated to a job, the smaller its processing time. The dependence of processing times on the amount of resources is linear for any job. The objective is to find a resource allocation and a schedule that minimizes the makespan. Utilizing an integer quadratic programming relaxation, we show how to obtain a (3+e)-approximation algorithm for that problem, for any e>0. This generalizes and improves previous results, respectively. Our approach relies on a fully polynomial time approximation scheme to solve the quadratic programming relaxation. This result is interesting in itself, because the underlying quadratic program is NP-hard to solve in general. We also briefly discuss variants of the problem and derive lower bounds.operations research and management science;
Timely-Throughput Optimal Coded Computing over Cloud Networks
In modern distributed computing systems, unpredictable and unreliable
infrastructures result in high variability of computing resources. Meanwhile,
there is significantly increasing demand for timely and event-driven services
with deadline constraints. Motivated by measurements over Amazon EC2 clusters,
we consider a two-state Markov model for variability of computing speed in
cloud networks. In this model, each worker can be either in a good state or a
bad state in terms of the computation speed, and the transition between these
states is modeled as a Markov chain which is unknown to the scheduler. We then
consider a Coded Computing framework, in which the data is possibly encoded and
stored at the worker nodes in order to provide robustness against nodes that
may be in a bad state. With timely computation requests submitted to the system
with computation deadlines, our goal is to design the optimal computation-load
allocation scheme and the optimal data encoding scheme that maximize the timely
computation throughput (i.e, the average number of computation tasks that are
accomplished before their deadline). Our main result is the development of a
dynamic computation strategy called Lagrange Estimate-and Allocate (LEA)
strategy, which achieves the optimal timely computation throughput. It is shown
that compared to the static allocation strategy, LEA increases the timely
computation throughput by 1.4X - 17.5X in various scenarios via simulations and
by 1.27X - 6.5X in experiments over Amazon EC2 clustersComment: to appear in MobiHoc 201
A Tutorial on Clique Problems in Communications and Signal Processing
Since its first use by Euler on the problem of the seven bridges of
K\"onigsberg, graph theory has shown excellent abilities in solving and
unveiling the properties of multiple discrete optimization problems. The study
of the structure of some integer programs reveals equivalence with graph theory
problems making a large body of the literature readily available for solving
and characterizing the complexity of these problems. This tutorial presents a
framework for utilizing a particular graph theory problem, known as the clique
problem, for solving communications and signal processing problems. In
particular, the paper aims to illustrate the structural properties of integer
programs that can be formulated as clique problems through multiple examples in
communications and signal processing. To that end, the first part of the
tutorial provides various optimal and heuristic solutions for the maximum
clique, maximum weight clique, and -clique problems. The tutorial, further,
illustrates the use of the clique formulation through numerous contemporary
examples in communications and signal processing, mainly in maximum access for
non-orthogonal multiple access networks, throughput maximization using index
and instantly decodable network coding, collision-free radio frequency
identification networks, and resource allocation in cloud-radio access
networks. Finally, the tutorial sheds light on the recent advances of such
applications, and provides technical insights on ways of dealing with mixed
discrete-continuous optimization problems
Feedback Allocation For OFDMA Systems With Slow Frequency-domain Scheduling
We study the problem of allocating limited feedback resources across multiple
users in an orthogonal-frequency-division-multiple-access downlink system with
slow frequency-domain scheduling. Many flavors of slow frequency-domain
scheduling (e.g., persistent scheduling, semi-persistent scheduling), that
adapt user-sub-band assignments on a slower time-scale, are being considered in
standards such as 3GPP Long-Term Evolution. In this paper, we develop a
feedback allocation algorithm that operates in conjunction with any arbitrary
slow frequency-domain scheduler with the goal of improving the throughput of
the system. Given a user-sub-band assignment chosen by the scheduler, the
feedback allocation algorithm involves solving a weighted sum-rate maximization
at each (slow) scheduling instant. We first develop an optimal
dynamic-programming-based algorithm to solve the feedback allocation problem
with pseudo-polynomial complexity in the number of users and in the total
feedback bit budget. We then propose two approximation algorithms with
complexity further reduced, for scenarios where the problem exhibits additional
structure.Comment: Accepted to IEEE Transactions on Signal Processin
Reclaiming the energy of a schedule: models and algorithms
We consider a task graph to be executed on a set of processors. We assume
that the mapping is given, say by an ordered list of tasks to execute on each
processor, and we aim at optimizing the energy consumption while enforcing a
prescribed bound on the execution time. While it is not possible to change the
allocation of a task, it is possible to change its speed. Rather than using a
local approach such as backfilling, we consider the problem as a whole and
study the impact of several speed variation models on its complexity. For
continuous speeds, we give a closed-form formula for trees and series-parallel
graphs, and we cast the problem into a geometric programming problem for
general directed acyclic graphs. We show that the classical dynamic voltage and
frequency scaling (DVFS) model with discrete modes leads to a NP-complete
problem, even if the modes are regularly distributed (an important particular
case in practice, which we analyze as the incremental model). On the contrary,
the VDD-hopping model leads to a polynomial solution. Finally, we provide an
approximation algorithm for the incremental model, which we extend for the
general DVFS model.Comment: A two-page extended abstract of this work appeared as a short
presentation in SPAA'2011, while the long version has been accepted for
publication in "Concurrency and Computation: Practice and Experience
- …