ArticlePublisher preview available

An Adversarial Model for Scheduling with Testing

Authors:
Christoph Dürr at Sorbonne University
Christoph Dürr
Thomas Erlebach at Durham Univeristy
Thomas Erlebach
  • Durham Univeristy
Nicole Megow
Nicole Megow
Nicole Megow
  • This person is not on ResearchGate, or hasn't claimed this research yet.
Julie Meissner at Technische Universität Berlin
Julie Meissner
Read publisher preview
Download citation
To read the full-text of this research, you can request a copy directly from the authors.

Abstract and Figures

We introduce a novel adversarial model for scheduling with explorable uncertainty. In this model, the processing time of a job can potentially be reduced (by an a priori unknown amount) by testing the job. Testing a job j takes one unit of time and may reduce its processing time from the given upper limit pˉj\bar{p}_j (which is the time taken to execute the job if it is not tested) to any value between 0 and pˉj\bar{p}_j. This setting is motivated e.g., by applications where a code optimizer can be run on a job before executing it. We consider the objective of minimizing the sum of completion times on a single machine. All jobs are available from the start, but the reduction in their processing times as a result of testing is unknown, making this an online problem that is amenable to competitive analysis. The need to balance the time spent on tests and the time spent on job executions adds a novel flavor to the problem. We give the first and nearly tight lower and upper bounds on the competitive ratio for deterministic and randomized algorithms. We also show that minimizing the makespan is a considerably easier problem for which we give optimal deterministic and randomized online algorithms.
Typical schedule produced by an algorithm. White boxes represent tests and grey boxes represent job executions. The completion time of a job is depicted by a thick bar. Test and execution of a job might be separated. A job of length 0 completes immediately after its test
Typical schedule produced by an algorithm. White boxes represent tests and grey boxes represent job executions. The completion time of a job is depicted by a thick bar. Test and execution of a job might be separated. A job of length 0 completes immediately after its test
… 
a The execution of the last long executed job jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} is followed by the test of a delayed job jd\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_d$$\end{document}; b increasing pjl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l}$$\end{document} increases the cost of the algorithm; c if the execution of jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} moves after the test of jd\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_d$$\end{document}, the increase in cost is even larger
a The execution of the last long executed job jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} is followed by the test of a delayed job jd\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_d$$\end{document}; b increasing pjl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l}$$\end{document} increases the cost of the algorithm; c if the execution of jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} moves after the test of jd\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_d$$\end{document}, the increase in cost is even larger
… 
a The execution of the last long executed job jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} is followed by the test of a short job; b increasing pjl′\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l'}$$\end{document} and decreasing pjl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l}$$\end{document} increases the cost of the algorithm; c if the execution of jl′\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l'$$\end{document} moves after the test of a delayed long job, the increase in cost is even larger
a The execution of the last long executed job jl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l$$\end{document} is followed by the test of a short job; b increasing pjl′\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l'}$$\end{document} and decreasing pjl\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{j_l}$$\end{document} increases the cost of the algorithm; c if the execution of jl′\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$j_l'$$\end{document} moves after the test of a delayed long job, the increase in cost is even larger
… 
Structure of schedules produced by Beat and Opt
Structure of schedules produced by Beat and Opt
… 
The schedule produced by UTE and the optimal schedule
+8
The schedule produced by UTE and the optimal schedule
… 
Figures - available from: Algorithmica
This content is subject to copyright. Terms and conditions apply.
A preview of this full-text is provided by Springer Nature.
Learn more
Content available from Algorithmica
This content is subject to copyright. Terms and conditions apply.
Vol:.(1234567890)
Algorithmica (2020) 82:3630–3675
https://doi.org/10.1007/s00453-020-00742-2
1 3
An Adversarial Model forScheduling withTesting
ChristophDürr1 · ThomasErlebach2 · NicoleMegow3 · JulieMeißner4
Received: 3 June 2019 / Accepted: 22 June 2020 / Published online: 10 July 2020
© Springer Science+Business Media, LLC, part of Springer Nature 2020
Abstract
We introduce a novel adversarial model for scheduling with explorable uncertainty.
In this model, the processing time of a job can potentially be reduced (by an a priori
unknown amount) by testing the job. Testing a job j takes one unit of time and may
reduce its processing time from the given upper limit
pj
(which is the time taken
to execute the job if it is not tested) to any value between 0 and
pj
. This setting is
motivated e.g., by applications where a code optimizer can be run on a job before
executing it. We consider the objective of minimizing the sum of completion times
on a single machine. All jobs are available from the start, but the reduction in their
processing times as a result of testing is unknown, making this an online problem
that is amenable to competitive analysis. The need to balance the time spent on tests
and the time spent on job executions adds a novel flavor to the problem. We give
the first and nearly tight lower and upper bounds on the competitive ratio for deter-
ministic and randomized algorithms. We also show that minimizing the makespan
is a considerably easier problem for which we give optimal deterministic and rand-
omized online algorithms.
Keywords Explorable uncertainty· Competitive analysis· Lower bounds·
Scheduling
This research was carried out in the framework of M
atheon
supported by Einstein Foundation
Berlin, the German Science Foundation (DFG) under contract ME 3825/1 and Bayerisch-
Französisches Hochschulzentrum (BFHZ). Further support was provided by EPSRC Grant EP/
S033483/1 and the ANR Grant ANR-18-CE25-0008. The second author was supported by a study
leave granted by University of Leicester during the early stages of the research. A preliminary
version of this paper appeared in The 9th Innovations in Theoretical Computer Science Conference
(ITCS), January 2018 [16].
* Christoph Dürr
Christoph.Durr@LIP6.fr
Extended author information available on the last page of the article
Content courtesy of Springer Nature, terms of use apply. Rights reserved.
... The challenge lies in deciding which jobs to test and the order of testing/processing jobs. The online problem was first introduced with unit testing time [6,7] and later generalized to variable testing times [1]. For this general setting, the upper bounds of the competitive ratio are shown to be 4 and 3.3794 for deterministic and randomized online algorithms [1]; while the lower bounds for unit testing time stands [6,7], which are 1.8546 (deterministic) and 1.6257 (randomized). ...
... The online problem was first introduced with unit testing time [6,7] and later generalized to variable testing times [1]. For this general setting, the upper bounds of the competitive ratio are shown to be 4 and 3.3794 for deterministic and randomized online algorithms [1]; while the lower bounds for unit testing time stands [6,7], which are 1.8546 (deterministic) and 1.6257 (randomized). We continue the study on variable testing times setting. ...
... On the other hand, the optimal offline algorithm knows in advance each p j even before testing. Therefore, the optimal strategy is to test job j if and only if t j + p j ≤ u j and execute the shortest job first, where the processing time of a job j is min{t j + p j , u j } [1,6,7]. However, since the online algorithm only learns about p j after testing j, the challenge to the online algorithm is to decide which jobs to test and the order of tasks that could be testing, execution, or execution-untested. ...
The Power of Amortization on Scheduling with Explorable Uncertainty
Preprint
Full-text available
  • Mar 2025
In this work, we study a scheduling problem with explorable uncertainty. Each job comes with an upper limit of its processing time, which could be potentially reduced by testing the job, which also takes time. The objective is to schedule all jobs on a single machine with a minimum total completion time. The challenge lies in deciding which jobs to test and the order of testing/processing jobs. The online problem was first introduced with unit testing time and later generalized to variable testing times. For this general setting, the upper bounds of the competitive ratio are shown to be 4 and 3.3794 for deterministic and randomized online algorithms; while the lower bounds for unit testing time stands, which are 1.8546 (deterministic) and 1.6257 (randomized). We continue the study on variable testing times setting. We first enhance the analysis framework and improve the competitive ratio of the deterministic algorithm from 4 to 1+2≈2.41431+\sqrt{2} \approx 2.4143. Using the new analysis framework, we propose a new deterministic algorithm that further improves the competitive ratio to 2.316513. The new framework also enables us to develop a randomized algorithm improving the expected competitive ratio from 3.3794 to 2.152271.
View
... Levi et al. [8] considered a setting where the weight and processing time of a job follow a known joint probability distribution, a job can be tested to reveal its weight and processing time, and the goal is to find a scheduling policy that minimizes the expectation of the weighted sum of completion times. Dürr et al. [4] introduced an adversarial setting of scheduling with testing where each job j is given with an upper bound u j on its processing time. The scheduler can either execute the job untested (with processing time u j ), or test it first to reveal its actual processing time p j ≤ u j and then execute it with processing time p j . ...
... For minimizing the sum of completion times on a single machine in our setting with obligatory tests, obtaining a 2-competitive algorithm is straightforward: Treating each job (test plus processing part) as a single entity with unknown processing time and applying the Round Robin (RR) algorithm (which executes all unfinished jobs simultaneously at the same rate) gives a 2-competitive preemptive schedule [10], and in our setting this algorithm can be made non-preemptive without any increase in job completion times: At any time, among all tests or processing parts currently available for execution, it is known which of them will complete first in the preemptive schedule, and hence that test or processing part can be chosen to be executed non-preemptively first (the same observation has been made previously for the setting with optional tests [4,9,5]). Our aim is therefore to design algorithms that are better than 2-competitive. ...
... For the setting with unit test times, we consider an adaptation of the Threshold algorithm by Dürr et al. [4] to the setting with obligatory tests: When the test of a job reveals a processing time smaller than a threshold y, the algorithm executes the processing part of the job immediately; otherwise, the execution of the processing part is deferred to the end of the schedule, where all the processing parts that have been deferred are executed in SPT (shortest processing time) order. We show that the algorithm is 1.585-competitive (and this analysis is tight for the algorithm). ...
Scheduling with Obligatory Tests
Preprint
  • Jun 2024
Motivated by settings such as medical treatments or aircraft maintenance, we consider a scheduling problem with jobs that consist of two operations, a test and a processing part. The time required to execute the test is known in advance while the time required to execute the processing part becomes known only upon completion of the test. We use competitive analysis to study algorithms for minimizing the sum of completion times for n given jobs on a single machine. As our main result, we prove using a novel analysis technique that the natural 1-SORT algorithm has competitive ratio at most 1.861. For the special case of uniform test times, we show that a simple threshold-based algorithm has competitive ratio at most 1.585. We also prove a lower bound that shows that no deterministic algorithm can be better than 2\sqrt{2}-competitive even in the case of uniform test times.
View
... Scheduling with Testing or Resources. Scheduling with testing under explorable uncertainty to bridge online and robust optimization was introduced by [6] and extended to various scheduling models [2,3,7]. These problems were initially motivated by code optimization, where jobs (programs) are either executed directly or pre-processed to reduce running time. ...
Multiplicative assignment with upgrades
Preprint
Full-text available
  • Apr 2025
We study a problem related to submodular function optimization and the exact matching problem for which we show a rather peculiar status: its natural LP-relaxation can have fractional optimal vertices, but there is always also an optimal integral vertex, which we can also compute in polynomial time. More specifically, we consider the multiplicative assignment problem with upgrades in which we are given a set of customers and suppliers and we seek to assign each customer to a different supplier. Each customer has a demand and each supplier has a regular and an upgraded cost for each unit demand provided to the respective assigned client. Our goal is to upgrade at most k suppliers and to compute an assignment in order to minimize the total resulting cost. This can be cast as the problem to compute an optimal matching in a bipartite graph with the additional constraint that we must select k edges from a certain group of edges, similar to selecting k red edges in the exact matching problem. Also, selecting the suppliers to be upgraded corresponds to maximizing a submodular set function under a cardinality constraint. Our result yields an efficient LP-based algorithm to solve our problem optimally. In addition, we provide also a purely strongly polynomial-time algorithm for it. As an application, we obtain exact algorithms for the upgrading variant of the problem to schedule jobs on identical or uniformly related machines in order to minimize their sum of completion times, i.e., where we may upgrade up to k jobs to reduce their respective processing times.
View
... Kill-and-restart strategies can thus be regarded as online algorithms for non-preemptive scheduling with the possibility to invest time in order to obtain some information. In that sense, the considered model resembles that of explorable uncertainty [43][44][45]. In order to allow for any reasonable competitiveness results, it must be ensured in both models that testing/probing provides some benefit to the algorithm other than information gain. ...
Competitive kill-and-restart and preemptive strategies for non-clairvoyant scheduling
Article
Full-text available
  • Jul 2024
We study kill-and-restart and preemptive strategies for the fundamental scheduling problem of minimizing the sum of weighted completion times on a single machine in the non-clairvoyant setting. First, we show a lower bound of 3 for any deterministic non-clairvoyant kill-and-restart strategy. Then, we give for any b>1b > 1 b > 1 a tight analysis for the natural b -scaling kill-and-restart strategy as well as for a randomized variant of it. In particular, we show a competitive ratio of (1+33)≈6.197(1+3\sqrt{3})\approx 6.197 ( 1 + 3 3 ) ≈ 6.197 for the deterministic and of ≈3.032\approx 3.032 ≈ 3.032 for the randomized strategy, by making use of the largest eigenvalue of a Toeplitz matrix. In addition, we show that the preemptive Weighted Shortest Elapsed Time First (WSETF) rule is 2-competitive when jobs are released online, matching the lower bound for the unit weight case with trivial release dates for any non-clairvoyant algorithm. Using this result as well as the competitiveness of round-robin for multiple machines, we prove performance guarantees smaller than 10 for adaptions of the b -scaling strategy to online release dates and unweighted jobs on identical parallel machines.
View
... Query-competitive algorithms are often associated with the field of 'explorable uncertainty'. Most previous work considers queries revealing an originally uncertain value [3,7,9,18,19,21, 25,10], while in this work we query a preference. ...
Competitive Query Minimization for Stable Matching with One-Sided Uncertainty
Preprint
  • Jul 2024
We study the two-sided stable matching problem with one-sided uncertainty for two sets of agents A and B, with equal cardinality. Initially, the preference lists of the agents in A are given but the preferences of the agents in B are unknown. An algorithm can make queries to reveal information about the preferences of the agents in B. We examine three query models: comparison queries, interviews, and set queries. Using competitive analysis, our aim is to design algorithms that minimize the number of queries required to solve the problem of finding a stable matching or verifying that a given matching is stable (or stable and optimal for the agents of one side). We present various upper and lower bounds on the best possible competitive ratio as well as results regarding the complexity of the offline problem of determining the optimal query set given full information.
View
Load Balancing with Job-Size Testing: Performance Improvement or Degradation?
Article
  • Mar 2024
In the context of decision making under explorable uncertainty, scheduling with testing is a powerful technique used in the management of computer systems to improve performance via better job-dispatching decisions. Upon job arrival, a scheduler may run some testing algorithm against the job to extract some information about its structure, e.g., its size, and properly classify it. The acquisition of such knowledge comes with a cost because the testing algorithm delays the dispatching decisions, though this is under control. In this paper, we analyze the impact of such extra cost in a load balancing setting by investigating the following questions: does it really pay off to test jobs? If so, under which conditions? Under mild assumptions connecting the information extracted by the testing algorithm in relationship with its running time, we show that whether scheduling with testing brings a performance degradation or improvement strongly depends on the traffic conditions, system size and the coefficient of variation of job sizes. Thus, the general answer to the above questions is non-trivial and some care should be considered when deploying a testing policy. Our results are achieved by proposing a load balancing model for scheduling with testing that we analyze in two limiting regimes. When the number of servers grows to infinity in proportion to the network demand, we show that job-size testing actually degrades performance unless short jobs can be predicted reliably almost instantaneously and the network load is sufficiently high. When the coefficient of variation of job sizes grows to infinity, we construct testing policies inducing an arbitrarily large performance gain with respect to running jobs untested.
View
View
View
View
View
Risk averse single machine scheduling - complexity and approximation
Article
Full-text available
  • Oct 2019
  • J SCHEDULING
In this paper a class of single machine scheduling problems is considered. It is assumed that job processing times and due dates can be uncertain and they are specified in the form of discrete scenario set. A probability distribution in the scenario set is known. In order to choose a schedule some risk criteria such as the value at risk (VaR) an conditional value at risk (CVaR) are used. Various positive and negative complexity results are provided for basic single machine scheduling problems. In this paper new complexity results are shown and some known complexity results are strengthen.
View
Ignorance Is Almost Bliss: Near-Optimal Stochastic Matching with Few Queries
Article
  • Jan 2020
We study the stochastic matching problem with the goal of finding a maximum matching in a graph whose edges are unknown but can be accessed via queries. This is a special case of stochastic k-cycle packing, in which the problem is to find a maximum packing of cycles, each of which exists with some probability. We provide polynomial-time adaptive and nonadaptive algorithms that provably yield a near-optimal solution, using a number of edge queries that is linear in the number of vertices. We are especially interested in kidney exchange, with which pairs of patients with end-stage renal failure and their willing but incompatible donors participate in a mechanism that performs compatibility tests between patients and donors and swaps the donors of some patients so that a large number of patients receive compatible kidneys. Because of the significant cost of performing compatibility tests, currently, kidney exchange programs perform at most one compatibility test per patient. Our theoretical results applied to kidney exchange show that, by increasing the number of compatibility tests performed per patient from one to a larger constant, we effectively get the full benefit of exhaustive testing at a fraction of the cost. We show, on both generated and real data from the UNOS nationwide kidney exchange, that even a small number of nonadaptive edge queries per vertex results in large gains in expected successful matches.
View
The Stochastic Matching Problem with (Very) Few Queries
Article
  • Sep 2019
Motivated by an application in kidney exchange, we study the following stochastic matching problem: We are given a graph G(V, E) (not necessarily bipartite), where each edge in E is realized with some constant probability p > 0, and the goal is to find a maximum matching in the realized graph. An algorithm in this setting is allowed to make queries to edges in E to determine whether or not they are realized. We design an adaptive algorithm for this problem that, for any graph G, computes a (1−ϵ)-approximate maximum matching in the realized graph Gp with high probability, while making O (log (1/ϵ p)/ϵ p) queries per vertex, where the edges to query are chosen adaptively in O (log (1/ϵ p)/ϵ p) rounds. We further present a non-adaptive algorithm that makes O (log (1/ϵ p)/ϵ p) queries per vertex and computes a (1/2−ϵ)-approximate maximum matching in Gp with high probability. Both our adaptive and non-adaptive algorithms achieve the same approximation factor as the previous best algorithms of Blum et al. (EC 2015) for this problem, while requiring an exponentially smaller number of per-vertex queries (and rounds of adaptive queries for the adaptive algorithm). Our results settle an open problem raised by Blum et al. by achieving only a polynomial dependency on both ϵ and p. Moreover, the approximation guarantee of our algorithms is instance-wise as opposed to only being competitive in expectation as is the case for Blum et al. This is of particular relevance to the key application of stochastic matching in kidney exchange. We obtain our results via two main techniques—namely, matching-covers and vertex sparsification—that may be of independent interest.
View
The Markovian Price of Information
Chapter
  • Apr 2019
  • Lect Notes Comput Sci
Suppose there are n Markov chains and we need to pay a per-step price to advance them. The “destination” states of the Markov chains contain rewards; however, we can only get rewards for a subset of them that satisfy a combinatorial constraint, e.g., at most k of them, or they are acyclic in an underlying graph. What strategy should we choose to advance the Markov chains if our goal is to maximize the total reward minus the total price that we pay? In this paper we introduce a Markovian price of information model to capture settings such as the above, where the input parameters of a combinatorial optimization problem are given via Markov chains. We design optimal/approximation algorithms that jointly optimize the value of the combinatorial problem and the total paid price. We also study robustness of our algorithms to the distribution parameters and how to handle the commitment constraint. Our work brings together two classical lines of investigation: getting optimal strategies for Markovian multi-armed bandits, and getting exact and approximation algorithms for discrete optimization problems using combinatorial as well as linear-programming relaxation ideas.
View
Stochastic packing integer programs with few queries
Article
  • Mar 2019
We consider a stochastic variant of the packing-type integer linear programming problem, which contains random variables in the objective vector. We are allowed to reveal each entry of the objective vector by conducting a query, and the task is to find a good solution by conducting a small number of queries. We propose a general framework of adaptive and non-adaptive algorithms for this problem, and provide a unified methodology for analyzing the performance of those algorithms. We also demonstrate our framework by applying it to a variety of stochastic combinatorial optimization problems such as matching, matroid, and stable set problems.
View
View
Automated Algorithm Selection: Survey and Perspectives
Article
  • Nov 2018
It has long been observed that for practically any computational problem that has been intensely studied, different instances are best solved using different algorithms. This is particularly pronounced for computationally hard problems, where in most cases, no single algorithm defines the state of the art; instead, there is a set of algorithms with complementary strengths. This performance complementarity can be exploited in various ways, one of which is based on the idea of selecting, from a set of given algorithms, for each problem instance to be solved the one expected to perform best. The task of automatically selecting an algorithm from a given set is known as the per-instance algorithm selection problem and has been intensely studied over the past 15 years, leading to major improvements in the state of the art in solving a growing number of discrete combinatorial problems, including propositional satisfiability and AI planning. Per-instance algorithm selection also shows much promise for boosting performance in solving continuous and mixed discrete/continuous optimisation problems. This survey provides an overview of research in automated algorithm selection, ranging from early and seminal works to recent and promising application areas. Different from earlier work, it covers applications to discrete and continuous problems, and discusses algorithm selection in context with conceptually related approaches, such as algorithm configuration, scheduling, or portfolio selection. Since informative and cheaply computable problem instance features provide the basis for effective per-instance algorithm selection systems, we also provide an overview of such features for discrete and continuous problems. Finally, we provide perspectives on future work in the area and discuss a number of open research challenges.
View
Scheduling with Testing
Article
  • May 2018
We study a new class of scheduling problems that capture common settings in service environments, in which one has to serve a collection of jobs that have a priori uncertain attributes (e.g., processing times and priorities) and the service provider has to decide how to dynamically allocate resources (e.g., people, equipment, and time) between testing (diagnosing) jobs to learn more about their respective uncertain attributes and processing jobs. The former could inform future decisions, but could delay the service time for other jobs, while the latter directly advances the processing of the jobs but requires making decisions under uncertainty. Through novel analysis we obtain surprising structural results of optimal policies that provide operational managerial insights, efficient optimal and near-optimal algorithms, and quantification of the value of testing. We believe that our approach will lead to further research to explore this important practical trade-off. The online appendix is available at https://doi.org/10.1287/mnsc.2017.2973 . This paper was accepted by Yinyu Ye, optimization.
View
Improvements and Generalizations of Stochastic Knapsack and Markovian Bandits Approximation Algorithms
Article
  • Feb 2018
We study the multi-armed bandit problem with arms which are Markov chains with rewards. In the finite-horizon setting, the celebrated Gittins indices do not apply, and the exact solution is intractable. We provide approximation algorithms for the general model of Markov decision processes with nonunit transition times. When preemption is allowed, we provide (1/2-ϵ)-approximation, along with an example showing this is tight. When preemption isn't allowed, we provide a 1-12-approximation, which improves to a 4-27-approximation when transition times are unity. Our model captures the Markovian Bandits model of Gupta et al., the Stochastic Knapsack model of Dean et al., and the Budgeted Learning model of Guha and Munagala. Our algorithms improve existing results in all three areas. In our analysis, we encounter and overcome to our knowledge a new obstacle: An algorithm that provably exists via analytical arguments, but cannot be found in polynomial time.
View
View