Scheduling of data-intensive workloads in a brokered virtualized environment

Providing performance predictability guarantees is increasingly important in cloud platforms, especially for data-intensive applications, for which performance depends greatly on the available rates of data transfer between the various computing/storage hosts underlying the virtualized resources assigned to the application. With the increased prevalence of brokerage services in cloud platforms, there is a need for resource management solutions that consider the brokered nature of these workloads, as well as the special demands of their intra-dependent components. In this paper, we present an offline mechanism for scheduling batches of brokered data-intensive workloads, which can be extended to an online setting. The objective of the mechanism is to decide on a packing of the workloads in a batch that minimizes the broker's incurred costs, Moreover, considering the brokered nature of such workloads, we define a payment model that provides incentives to these workloads to be scheduled as part of a batch, which we analyze theoretically. Finally, we evaluate the proposed scheduling algorithm, and exemplify the fairness of the payment model in practical settings via trace-based experiments

Lookahead scheduling in a real-time context: Models, algorithms, and analysis

Our research considers job scheduling, a special type of resource assignment problem. For example, at a cross-docking facility trucks must be assigned to doors where they will be unloaded. The cargo on each truck has various destinations within the facility, and the unloading time for a truck is dependent on the distance from the assigned door to these destinations. The goal is to assign the trucks to doors while minimizing the amount of time to unload all trucks.;We study scheduling algorithms for problems like the cross-docking example that are different from traditional algorithms in two ways. First, we utilize real-time, where the algorithm executes at the same time as when the jobs are handled. Because the time used by the algorithm to make decisions cannot be used to complete a job, these decisions must be made quickly Second, our algorithms utilize lookahead, or partial knowledge of jobs that will arrive in the future.;The three goals of this research were to demonstrate that lookahead algorithms can be implemented effectively in a real-time context, to measure the amount of improvement gained by utilizing lookahead, and to explore the conditions in which lookahead is beneficial.;We present a model suitable for representing problems that include lookahead in a real-time context. Using this model, we develop lookahead algorithms for two important job scheduling systems and argue that these algorithms make decisions efficiently. We then study the performance of lookahead algorithms using mathematical analysis and simulation.;Our results provide a detailed picture of the behavior of lookahead algorithms in a real-time context. Our analytical study shows that lookahead algorithms produce schedules that are significantly better than those without lookahead. We also found that utilizing Lookahead-1, or knowledge of the next arriving job, produces substantial improvement while requiring the least effort to design. When more lookahead information is used, the solutions are better, but the amount of improvement is not significantly larger than a Lookahead-1 algorithm. Further, algorithms utilizing more lookahead are more complex to design, implement, and analyze. We conclude that Lookahead-1 algorithms are the best balance between improvement and design effort

Online Optimization with Lookahead

The main contributions of this thesis consist of the development of a systematic groundwork for comprehensive performance evaluation of algorithms in online optimization with lookahead and the subsequent validation of the presented approaches in theoretical analysis and computational experiments

Algorithms incorporating concurrency and caching

Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2009.Cataloged from PDF version of thesis.Includes bibliographical references (p. 189-203).This thesis describes provably good algorithms for modern large-scale computer systems, including today's multicores. Designing efficient algorithms for these systems involves overcoming many challenges, including concurrency (dealing with parallel accesses to the same data) and caching (achieving good memory performance.) This thesis includes two parallel algorithms that focus on testing for atomicity violations in a parallel fork-join program. These algorithms augment a parallel program with a data structure that answers queries about the program's structure, on the fly. Specifically, one data structure, called SP-ordered-bags, maintains the series-parallel relationships among threads, which is vital for uncovering race conditions (bugs) in the program. Another data structure, called XConflict, aids in detecting conflicts in a transactional-memory system with nested parallel transactions. For a program with work T and span To, maintaining either data structure adds an overhead of PT, to the running time of the parallel program when executed on P processors using an efficient scheduler, yielding a total runtime of O(T1/P + PTo). For each of these data structures, queries can be answered in 0(1) time. This thesis also introduces the compressed sparse rows (CSB) storage format for sparse matrices, which allows both Ax and ATx to be computed efficiently in parallel, where A is an n x n sparse matrix with nnz > n nonzeros and x is a dense n-vector. The parallel multiplication algorithm uses e(nnz) work and ... span, yielding a parallelism of ... , which is amply high for virtually any large matrix.(cont.) Also addressing concurrency, this thesis considers two scheduling problems. The first scheduling problem, motivated by transactional memory, considers randomized backoff when jobs have different lengths. I give an analysis showing that binary exponential backoff achieves makespan V2e(6v 1- i ) with high probability, where V is the total length of all n contending jobs. This bound is significantly larger than when jobs are all the same size. A variant of exponential backoff, however, achieves makespan of ... with high probability. I also present the size-hashed backoff protocol, specifically designed for jobs having different lengths, that achieves makespan ... with high probability. The second scheduling problem considers scheduling n unit-length jobs on m unrelated machines, where each job may fail probabilistically. Specifically, an input consists of a set of n jobs, a directed acyclic graph G describing the precedence constraints among jobs, and a failure probability qij for each job j and machine i. The goal is to find a schedule that minimizes the expected makespan. I give an O(log log(min {m, n}))-approximation for the case of independent jobs (when there are no precedence constraints) and an O(log(n + m) log log(min {m, n}))-approximation algorithm when precedence constraints form disjoint chains. This chain algorithm can be extended into one that supports precedence constraints that are trees, which worsens the approximation by another log(n) factor. To address caching, this thesis includes several new variants of cache-oblivious dynamic dictionaries.(cont.) A cache-oblivious dictionary fills the same niche as a classic B-tree, but it does so without tuning for particular memory parameters. Thus, cache-oblivious dictionaries optimize for all levels of a multilevel hierarchy and are more portable than traditional B-trees. I describe how to add concurrency to several previously existing cache-oblivious dictionaries. I also describe two new data structures that achieve significantly cheaper insertions with a small overhead on searches. The cache-oblivious lookahead array (COLA) supports insertions/deletions and searches in O((1/B) log N) and O(log N) memory transfers, respectively, where B is the block size, M is the memory size, and N is the number of elements in the data structure. The xDict supports these operations in O((1/1B E1-) logB(N/M)) and O((1/)0logB(N/M)) memory transfers, respectively, where 0 < E < 1 is a tunable parameter. Also on caching, this thesis answers the question: what is the worst possible page-replacement strategy? The goal of this whimsical chapter is to devise an online strategy that achieves the highest possible fraction of page faults / cache misses as compared to the worst offline strategy. I show that there is no deterministic strategy that is competitive with the worst offline. I also give a randomized strategy based on the most recently used heuristic and show that it is the worst possible pagereplacement policy. On a more serious note, I also show that direct mapping is, in some sense, a worst possible page-replacement policy. Finally, this thesis includes a new algorithm, following a new approach, for the problem of maintaining a topological ordering of a dag as edges are dynamically inserted.(cont.) The main result included here is an O(n2 log n) algorithm for maintaining a topological ordering in the presence of up to m < n(n - 1)/2 edge insertions. In contrast, the previously best algorithm has a total running time of O(min { m3/ 2, n5/2 }). Although these algorithms are not parallel and do not exhibit particularly good locality, some of the data structural techniques employed in my solution are similar to others in this thesis.by Jeremy T. Fineman.Ph.D

PRODUCTION SEQUENCING AND STABILITY ANALYSIS OF A JUST-IN-TIME SYSTEM WITH SEQUENCE DEPENDENT SETUPS

Just-In-Time (JIT) production systems is a popular area for researchers but real-world issues such as sequence dependent setups are often overlooked. This research investigates an approach for determining stability and an approach for mixed product sequencing in production systems with sequence dependent setups and buffer thresholds which signal replenishment of a given buffer. Production systems in this research operate under JIT pull production principles by producing only when demand exists and idle when no demand exists. In the first approach, an iterative method is presented to determine stability for a multi-product production system that operates with replenishment signals and may have sequence dependent setups. In this method, a network of nodes representing machine states and arcs representing the buffer inventory levels is used to find a stable trajectory for the production system via an iterative procedure. The method determines suitable buffer levels for the production system that ensure that a trajectory originating from any point within a buffer region will always map to a point contained on another buffer region for all future mappings. This iterative method for determining the stability of a production system was implemented using an algorithm to calculate the buffer inventory regions for all arcs in a given arc-node network. The algorithm showed favorable results for two and three product systems in which sequence dependent setups may exist. In the second approach, a product sequencing algorithm determines a product sequence for a production system based on system parameters – setup times, buffer levels, usage rates, production rates, etc. The algorithm selects a product by evaluating the goodness of each product that has reached the replenishment threshold at the current time. The algorithm also incorporates a lookahead function that calculates the goodness for some time interval into the future. The lookahead function considers all branches of the tree of potential sequences to prevent the sequence from travelling down a dead-end branch in which the system will be unable to avoid a depleted buffer. The sequencing algorithm allows the user to weight the five terms of the goodness equations (current and lookahead) to control the behavior of the sequence

SOLO: Search Online, Learn Offline for Combinatorial Optimization Problems

We study combinatorial problems with real world applications such as machine scheduling, routing, and assignment. We propose a method that combines Reinforcement Learning (RL) and planning. This method can equally be applied to both the offline, as well as online, variants of the combinatorial problem, in which the problem components (e.g., jobs in scheduling problems) are not known in advance, but rather arrive during the decision-making process. Our solution is quite generic, scalable, and leverages distributional knowledge of the problem parameters. We frame the solution process as an MDP, and take a Deep Q-Learning approach wherein states are represented as graphs, thereby allowing our trained policies to deal with arbitrary changes in a principled manner. Though learned policies work well in expectation, small deviations can have substantial negative effects in combinatorial settings. We mitigate these drawbacks by employing our graph-convolutional policies as non-optimal heuristics in a compatible search algorithm, Monte Carlo Tree Search, to significantly improve overall performance. We demonstrate our method on two problems: Machine Scheduling and Capacitated Vehicle Routing. We show that our method outperforms custom-tailored mathematical solvers, state of the art learning-based algorithms, and common heuristics, both in computation time and performance

Energy Efficient Scheduling Methods for Computational Grids and Clouds, Journal of Telecommunications and Information Technology, 2017, nr 1

This paper presents an overview of techniques developed to improve energy efficiency of grid and cloud computing. Power consumption models and energy usage proles are presented together with energy efficiency measuring methods. Modeling of computing dynamics is discussed from the viewpoint of system identication theory, indicating basic experiment design problems and challenges. Novel approaches to cluster and network-wide energy usage optimization are surveyed, including multi-level power and software control systems, energy-aware task scheduling, resource allocation algorithms and frameworks for backbone networks management. Software-development techniques and tools are also presented as a new promising way to reduce power consumption at the computing node level. Finally, energy-aware control mechanisms are presented. In addition, this paper introduces the example of batch scheduler based on ETC matrix approach

Online problems and two-player games : algorithms and analysis

In this thesis we study three problems that are adversarial in nature. Such problems can be viewed as a game between an algorithm and an adversary, where the adversary always tries to force the algorithm into worst-case scenarios during its execution. Many real world problems with inherent uncertainty or lack of information fit into this model. For instance, it includes the vast field of online problems where the input is only partially available and an adversary reveals the complete input gradually over time (online fashion). The algorithm has to perform efficiently under this uncertainty. In contrast to the online setting, in an offline setting, the complete input is available in the beginning. The first problem that we investigate is a classical online scheduling problem where a sequence of jobs that arrive online have to be assigned to a set of identical machines with the objective of minimizing the maximum load. We study a natural generalization of this problem where we allow migration of already scheduled jobs to other machines upon the arrival of a new job, thus bridging the gap between online and offline setting. Already for a small amount of migration, our result compares with the best results to date in both online and offline settings. From the point of view of sensitivity analysis, our results imply that, only small changes are to be made to the current schedule to accommodate a new job, if we are satisfied with near optimal solution. The other online problem that we study is the well-known metrical task systems problem. We present a probabilistic analysis of the well-known text book algorithm called the work function algorithm. Besides average-case analysis we also present smoothed analysis, which is a notion introduced recently as a hybrid between worst-case and average-case analysis. Our analysis reveals that the performance of this algorithm is much better than worst-case for a large class of inputs. This motivates us to support smoothed analysis as an alternative model for evaluating the performance of online algorithms. The third problem that we investigate is a pursuit-evasion game: an algorithm (the pursuer) has to find/catch an adversary that is \u27hiding\u27; in a graph where both players can travel in the graph. This problem belongs to the rich field of search games and it addresses the question of how long it takes for the pursuer to find the evader in a given graph that, for example, corresponds to a computer network or a geographic terrain. Such game models are also used to design efficient communication protocols. We present improved results against adversaries with varying power and also present tight lower bounds.In der vorliegenden Arbeit beschäftigen wir uns mit drei Problemen, welche als eine Art Spiel zwischen einem Algorithmus und seinem Gegenspieler interpretiert werden können. In diesem Spiel versucht der Gegenspieler, den Algorithmus während seiner Ausführung in sein Worst-Case Verhalten zu zwingen. Eine Vielzahl von praxisrelevanten Problemen, in denen nicht von Beginn an die volle Information über die Eingabeinstanz zur Verfügung steht, lassen sich als derartige Spiele modellieren. Zu dieser Klasse von Problemen gehören z. B. auch online Probleme, in denen der Gegenspieler die Eingabeinstanz für den Algorithmus online, d. h. während der Ausführung des Algorithmus, spezifiziert. Das Ziel des Algorithmus ist es, auf dieser so spezifizierten Instanz möglichst effizient zu sein. Im Gegensatz zum online Szenario kennt der Algorithmus im offline Szenario die gesamte Eingabeinstanz gleich von Beginn an. Im online Szenario wird die Effizienz eines (online) Algorithmus anhand seines Competitive Ratio gemessen. Ein Algorithmus ist c-competitive, wenn die Kosten, die der Algorithmus auf einer beliebigen online Eingabe verursacht, maximal einen Faktor c von den Kosten eines optimalen (offline) Algorithmus, der die gesamte Eingabe kennt, entfernt ist. Das erste Problem, dass wir betrachten, ist ein klassisches Scheduling Problem, in dem Jobs online eintreffen und auf identischen parallelen Maschinen verteilt werden müssen. Das Ziel ist es, die maximale Maschinenlast zu minimieren. Das zweite online Problem, dass wir betrachten, ist das Metrical Task System Problem. Als drittes Problem analysieren wir ein "Katz-und-Maus-Spiel\u27;: eine Katze (der Algorithmus) und eine Maus (der Gegenspieler) befinden sich in einem Graphen und die Katze versucht, die Maus zu fangen