Online Algorithms

The definition of antipower introduced by Fici et al. (ICALP 2016) captures the notion of being the opposite of a power : a sequence of k pairwise distinct blocks of the same length. Recently, Alamro et al. (CPM 2019) defined a string to have an antiperiod if it is a prefix of an antipower, and gave complexity bounds for the offline computation of the minimum antiperiod and all the antiperiods of a word. In this paper, we address the same problems in the online setting. Our solutions rely on new arrays that compactly and incrementally store antiperiods and antipowers as the word grows, obtaining in the process this information for all the word's prefixes. We show how to compute those arrays online in O(n log n) space, O(n log n) time, and o(n ) delay per character, for any constant > 0. Running times are worst-case and hold with high probability. We also discuss more space-efficient solutions returning the correct result with high probability, and small data structures to support random access to those arrays.

The definition of antipower introduced by Fici et al. (ICALP 2016) captures the notion of being the opposite of a power : a sequence of k pairwise distinct blocks of the same length. Recently, Alamro et al. (CPM 2019) defined a string to have an antiperiod if it is a prefix of an antipower, and gave complexity bounds for the offline computation of the minimum antiperiod and all the antiperiods of a word. In this paper, we address the same problems in the online setting. Our solutions rely on new arrays that compactly and incrementally store antiperiods and antipowers as the word grows, obtaining in the process this information for all the word's prefixes. We show how to compute those arrays online in O(n log n) space, O(n log n) time, and o(n ) delay per character, for any constant > 0. Running times are worst-case and hold with high probability. We also discuss more space-efficient solutions returning the correct result with high probability, and small data structures to support random access to those arrays.

The definition of antipower introduced by Fici et al. (ICALP 2016) captures the notion of being the opposite of a power: a sequence of k pairwise distinct blocks of the same length. Recently, Alamro et al. (CPM 2019) defined a string to have an antiperiod if it is a prefix of an antipower, and gave complexity bounds for the offline computation of the minimum antiperiod and all the antiperiods of a word. In this paper, we address the same problems in the online setting. Our solutions rely on new arrays that compactly and incrementally store antiperiods and antipowers as the word grows, obtaining in the process this information for all the word’s prefixes. We show how to compute those arrays online in \(O(n\log n)\) space, \(O(n\log n)\) time, and \(o(n^\epsilon )\) delay per character, for any constant \(\epsilon >0\). Running times are worst-case and hold with high probability. We also discuss more space-efficient solutions returning the correct result with high probability, and ...

Primal-dual is an elegant and powerful method in optimization and in the design of algorithms. The main idea of the method is to construct feasible primal and dual solutions interactively and an algorithm, together with the analysis, are derived naturally from the primal-dual interaction. In this thesis, we present primal-dual approaches as unified techniques in order to study and build connections between the domains of Online Algorithms, Algorithmic Game Theory and Online Learning.

We consider the semi-online multiprocessor scheduling problem with m identical, parallel machines to minimize the makespan, where the jobs arrive in decreasing order of processing times. The famous Longest Processing Time (LPT) algorithm by Graham (1966) [4] for the classical offline multiprocessor scheduling problem schedules the jobs in decreasing order of processing times and has a worst-case bound of 4/3-1/(3m). So far, no algorithm with a better competitive ratio than the LPT algorithm has been given for the semi-online scheduling problem with decreasing processing times. In this note, we present a 5/4competitive algorithm for m ≥ 3 and an algorithm that is the best possible for m = 3, i.e. an algorithm with competitive ratio (1 + √ 37)/6.

March____ 28,_________ aArlington, VA 2221713 uBROPAE V4. MONIoTORING AGENCY NAME &ADDRESS(iI diIaI dSMI C41R.IMS OffiS) 11L SECURITY CLAMS (of tis uopwev-. UNCLASSiFIED IS.. DECL ASSIFCATIONOOWNGRAOING, IS. DISTRIBUTION STATEMENT (ofaiRp~t Ah-Pop"Eu Approved forpfublic release; distibu tion unlimited t7. DiSTRIOU11ON SIATELMINT (of I%. 4betroaU oneti.,.Ex Stock 20. LIdill .1mg from Ropeta IS SUPPLEMENTARY NOTES 19. Key WORDS (Cc-"###e. on #*v.,.. aide of n.....wy and Ideity by black OmSAeJ 0.AS RACT tfooltoe en covers* aid.ei #0 #6e...and identify by Stock aIWmb.. The-cf fcrnm_-re of sequenTiali sext c=n oe enhanced by ihe use off heiistlcshat mo% a elerncnts closer wo .*-c fren: of 1he ;s a hey are found. Previous 3nalyses have c!harame4-4.2'd the performanee cf9.suet heuristics t ~caly I this paper C~ show thatI the hewistis can also be analyzed i the worst-c-ise sense. and DD IJr)1473

We consider the problem of scheduling packets of different lengths via a directed communication link prone to jamming errors. Dynamic packet arrivals and errors are modelled by an adversary. We focus on estimating relative throughput of online scheduling algorithms, that is, the ratio between the throughputs achieved by the algorithm and the best scheduling for the same arrival and error patterns. This framework allows more accurate analysis of performance of online scheduling algorithms, even in worst-case arrival and error scenarios. We design an online algorithm for scheduling packets of arbitrary lengths, achieving optimal relative throughput in (1/3, 1/2] (the exact value depends on packet lengths). In other words, for any arrival and jamming patterns, our solution gives throughput which is no more than c times worse than the best possible scheduling for these patters, where c ∈ [2, 3) is the inverse of relative throughput. Another algorithm we design makes use of additional resources in order to achieve relative throughput 1, that is, it achieves at least as high throughput as the best schedule without such resources, for any arrival and jamming patterns. More precisely, we show that if the algorithm can run with double speed, i.e., with twice higher frequency, then its relative throughput is 1. This demonstrates that throughput of the best online scheduling algorithms scales well with resource augmentation.

Although there are efficient algorithms for many problems in graph theory, there remain intractable problems that require time exponential in the number of vertices. Fortunately, many of these algorithms can be implemented in parallel to reduce the run-time. The emergence of the Beowulf Cluster (the poor man's supercomputer) and more recently, multi- core desktop processors has enabled small institutions, labs and even individuals to solve larger instances of these problems within reasonable time lines. In this paper we test a parallel implementation of a modified version of the Bron-Kerbosch Algorithm for listing the maximal cliques of a graph. We outline the benefits of parallelism, demonstrate some of the software tools available, and discuss problems we encountered.

In this paper, we study online maximization and minimization knapsack problems with limited cuts, in which (1) items are given one by one over time, i.e., after a decision is made on the current item, the next one is given, (2) items are allowed to be cut at most k (≥1) times, and (3) items are allowed to be removed from the knapsack. We obtain the following three results. (i) For the maximization knapsack problem, we propose a (k + 1)/k-competitive online algorithm, and show that it is the best possible, i.e., no online algorithm can have a competitive ratio less than (k + 1)/k. (ii) For the minimization knapsack problem, we show that no online algorithm can have a constant competitive ratio. (iii) We extend the result in (i) to the resource augmentation model, where an online algorithm is allowed to use a knapsack of capacity m (>1), while the optimal algorithm uses a unit capacity knapsack.

We consider the natural extension of the well-known single disk caching problem to the parallel disk I/O model (PDM) [17]. The main challenge is to achieve as much parallelism as possible and avoid I/O bottlenecks. We are given a fast memory (cache) of size M memory blocks along with a request sequence Σ = (b1, b2, ..., bn) where each block bi resides on one of D disks. In each parallel I/O step, at most one block from each disk can be fetched. The task is to serve Σ in the minimum number of parallel I/Os. Thus, each I/O is analogous to a page fault. The difference here is that during each page fault, up to D blocks can be brought into memory, as long as all of the new blocks entering the memory reside on different disks. The problem has a long history [18, 12, 13, 26]. Note that this problem is non-trivial even if all requests in Σ are unique. This restricted version is called read-once. Despite the progress in the offline version [13, 15] and read-once version [12], the general online problem still remained open. Here, we provide comprehensive results with a full general solution for the problem with asymptotically tight competitive ratios. To exploit parallelism, any parallel disk algorithm needs a certain amount of lookahead into future requests. To provide effective caching, an online algorithm must achieve o(D) competitive ratio. We show a lower bound that states, for lookahead L ≤ M , any online algorithm must be Ω(D)competitive. For lookahead L greater than M (1 + 1/), where is a constant, the tight upper bound of O(p M D/L) on competitive ratio is achieved by our algorithm SKEW. The previous algorithm tLRU [26] was O((M D/L) 2/3) competitive and this was also shown to be tight [26] for an LRUbased strategy. We achieve the tight ratio using a fairly * Supported by NSF CCF-0621457, NSF CNS-0541369.

We study online interval coloring problems with bandwidth. We are interested in some variants motivated by bin packing problems. Specifically we consider open-end coloring, cardinality constrained coloring, coloring with vector constraints and finally a combination of both the cardinality and the vector constraints. We construct competitive algorithms for each of the variants. Additionally, we present a lower bound of 24/7 for interval coloring with bandwidth, which holds for all the above models, and improves the current lower bound for the standard interval coloring with bandwidth problem.

It is well known that the Earliest-Deadline-First (EDF) and the Least-Laxity-First (LLF) algorithms are optimal algorithms for the problem of preemptively scheduling jobs that arrive over time on a single machine to minimize maximum lateness (1|r j , pmtn|L max). It was not previously known what other online algorithms are optimal for this problem. As this problem is a fundamental problem in machine scheduling, it deserves a thorough investigation. In this paper, the concept of compound laxity is introduced, and a complete characterization of all optimal online algorithms for this problem is derived.

We study the following on-line model for set-covering: elements of a ground set of size n arrive one-by-one and with any such element ci, arrives also the name of some set Si0 containing ci and covering the most of the uncovered ground set- elements (obviously, these elements have not been yet revealed). For this model we analyze a simple greedy algorithm consisting of taking Si0 into the cover, only if ci is not already covered. We prove that the competitive ratio of this algorithm, that uses only O(log m) space, where m is the size of the set-system, is √ n and that it is asymptotically optimal for the model dealt, since no on-line algorithm can do better than p n/2. We next show that this model can also be used for solving minimum dominating set with competitive ratio bounded above by the square root of the size of the input graph. We also study a slightly simplified, but mo re memory consum- ing, on-line model: any time a ground set-element arrives, the whole sequence of the nam...

We survey results on self-organizing data structures for the search problem and concentrate on two very popular structures: the unsorted linear list, and the binary search tree. For the problem of maintaining unsorted lists, also known as the list update problem, we present results on the competitiveness achieved by deterministic and randomized on-line algorithms. For binary search trees, we present results for both on-line and o-line algorithms. Self-organizing data structures can be used to build very e ective data compression schemes. We summarize theoretical and experimental results.

We consider the problem of online robot navigation in an unfamiliar two-dimensional environment, using comparatively limited sensing information. In particular, the robot has local sensors to detect the proximity of obstacles and permit boundary-following, and is able to determine its current distance and relative bearing to its nal destination (via distance queries). By contrast, most previous algorithms for online navigation have assumed that the robot knows its exact current position. Because determining exact location is prone to error that accumulates over time, the usefulness of such algorithms may be limited. In contrast, distance queries give less information, but the accuracy of each query is independent of the number of queries, which means distance queries can be more robust. We formally de ne our model and give new, e cient navigation algorithms and lower bounds for this setting.

Query optimization that involves expensive predicates have received considerable attention in the database community. Typically, the output to a database query is a set of tuples that satisfy certain conditions, and, with expensive predicates, these conditions may be computationally costly to verify. In the simplest case, when the query looks for the set of tuples that simultaneously satisfy k expensive predicates, the problem reduces to ordering the evaluation of the predicates so as to minimize the time to output the set of tuples comprising the answer to the query. Here, we give a simple and fast deterministic k-approximation algorithm for this problem, and prove that k is the best possible approximation ratio for a deterministic algorithm, even if exponential time algorithms are allowed. We also propose a randomized, polynomial time algorithm with expected approximation ratio 1+ √ 2/2 ≈ 1.707 for k = 2, and prove that 3/2 is the best possible expected approximation ratio for randomized algorithms.

Query optimization that involves expensive predicates has received considerable attention in the database community. Typically, the output to a database query is a set of tuples that satisfy certain conditions, and, with expensive predicates, these conditions may be computationally costly to verify. In the simplest case, when the query looks for the set of tuples that simultaneously satisfy k expensive predicates, the problem reduces to ordering the evaluation of the predicates so as to minimize the time to output the set of tuples comprising the answer to the query. We study different cases of the problem: the sequential case , in which a single processor is available to evaluate the predicates, and the distributed case , in which there are k processors available, each dedicated to a different attribute (column) of the database, and there is no communication cost between the processors. For the sequential case, we give a simple and fast deterministic k -approximation algorithm, and...

We introduce an online version of the multiselection problem, in which q selection queries are requested on an unsorted array of n elements. We provide the first online algorithm that is 1competitive with Kaligosi et al.[ICALP 2005] in terms of comparison complexity. Our algorithm also supports online search queries efficiently. We then extend our algorithm to the dynamic setting, while retaining online functionality, by supporting arbitrary insertions and deletions on the array. Assuming that the insertion of an element is immediately preceded by a search for that element, we show that our dynamic online algorithm performs an optimal number of comparisons, up to lower order terms and an additive O(n) term. For the external memory model, we describe the first online multiselection algorithm that is O(1)-competitive. This result improves upon the work of Sibeyn [Journal of Algorithms 2006] when q > m, where m is the number of blocks that can be stored in main memory. We also extend it to support searches, insertions, and deletions of elements efficiently.

It is shown that the problem of maintaining the topological order of the nodes of a directed acyclic graph while inserting m edges can be solved in O (min{ m 3/2 log n , m 3/2 + n 2 log n }) time, an improvement over the best known result of O ( mn ). In addition, we analyze the complexity of the same algorithm with respect to the treewidth k of the underlying undirected graph. We show that the algorithm runs in time O ( mk log 2 n ) for general k and that it can be implemented to run in O ( n log n ) time on trees, which is optimal. The algorithm also detects cycles in the input.

This paper addresses the problem of traffic grooming in wavelength-division multiplexing (WDM) rings where connection requests arrive online. Each request specifies a pair of nodes that wish to communicate and also the desired bandwidth of this connection. If the request is to be satisfied, it must be allocated to one or more wavelengths with sufficient remaining capacity. We consider three distinct profit models specifying the profit associated with satisfying a connection request. We give results on offline and online algorithms for each of the three profit models. We use the paradigm of competitive analysis to theoretically analyze the quality of our online algorithms. Finally, experimental results are given to provide insight into the performance of these algorithms in practice. Index Terms-Competitive analysis, online algorithms, optical networks, wavelength-division multiplexing (WDM) rings. I. INTRODUCTION W AVELENGTH-DIVISION multiplexing (WDM) partitions the capacity of an optical fiber into separate channels that may be transmitted simultaneously over distinct wavelengths. However, traffic demands are frequently much smaller than the capacity of even a single wavelength. In order to maximize utilization of the network, a large number of traffic streams can be multiplexed or "groomed" onto a smaller number of wavelengths. Rings are among the most widely deployed and studied WDM network topologies. We consider rings in which each node has some number of add-drop multiplexers (ADMs), each tuned to a particular wavelength. A node with an ADM for a particular wavelength can initiate ("add") traffic onto that wavelength and can receive ("drop") traffic on that wavelength. Nodes that do not contain an ADM for a given wavelength can allow traffic on that wavelength to pass through but can neither send nor receive traffic on that wavelength. Substantial work has been reported on traffic grooming for WDM rings for traffic patterns that are known in advance [1], [2]-[4]. The traffic pattern may be static, and described by a Manuscript

Splay and randomized search trees (RSTs) are self‐balancing binary tree structures with little or no space overhead compared to a standard binary search tree (BST). Both trees are intended for use in applications where node accesses are skewed, for example in gathering the distinct words in a large text collection for index construction. We investigate the efficiency of these trees for such vocabulary accumulation. Surprisingly, unmodified splaying and RSTs are on average around 25% slower than using a standard binary tree. We investigate heuristics to limit splay tree reorganization costs and show their effectiveness in practice. In particular, a periodic rotation scheme improves the speed of splaying by 27%, while other proposed heuristics are less effective. We also report the performance of efficient bit‐wise hashing and red–blacktrees for comparison. Copyright © 2001 John Wiley & Sons, Ltd.

Dans cet article, nous considérons l'allocation dynamique (online) d'un très grand nombre de tâches identiques et indépendantes sur une plate-forme maîtres-esclaves. Initialement, plusieurs noeuds maîtres possèdent ou génèrent les tâches qui sont ensuite transférées et traitées par des noeuds esclaves. L'objectif est de maximiser le débit (i.e., le nombre fractionnaire de tâches qui peuventêtre traité en une unité de temps, en régime permanent, par la plateforme). Nous considérons que les communications se déroulent suivant le modèle multi-portà degré borné, dans lequel plusieurs communications peuvent avoir lieu simultanément sous réserve qu'aucune bande passante ne soit dépassée et qu'aucun serveur n'ouvre simultanément un nombre de connections supérieurà son degré maximal. Sous ce modèle, la maximisation du débit correspond au problème Maximum-Throughput-Bounded-Degree (MTBD) qui aété analysé dans [BEDRT08]. Il aété montré que le problème est NP-Complet au sens fort mais qu'une augmentation (additive) de ressources minimale (de 1) sur le degré maximal des serveurs permet de le résoudre en temps polynomial. Dans cet article, nous considérons une extension de MTBDà la situation plus réaliste, dans le contexte des plates-formes de calculà grandeéchelle, dans laquelle les noeuds esclaves rejoignent et quittent dynamiquement la plate-formeà des instants arbitraires (problème online MTBD). Nous montrons tout d'abord qu'aucun algorithme complètementà la volée (c.-à.-d. qui n'autorise pas les déconnections) ne peut conduireà un facteur d'approximation constant, quelle que soit l'augmentation de ressources utilisée. Ensuite, nous montrons qu'il est en fait possible de maintenirà tout instant la solution optimale (avec une augmentation de ressource additive de 1) en ne réalisantà chaque modification de la plate-forme qu'une déconnection et qu'une nouvelle connection par maître.

In this paper, we consider the problem of the online allocation of a very large number of identical tasks on a master-slave platform. Initially, several masters hold or generate tasks that are transfered and processed by slave nodes. The goal is to maximize the overall throughput achieved using this platform, i.e. the (fractional) number of tasks that can be processed within one time unit. We model the communications using the so-called bounded degree multi-port model, in which several communications can be handled by a master node simultaneously, provided that bandwidths limitation are not exceeded and that a given server is not involved in more simultaneous communications than its maximal degree. Under this model, it has been proved in [4] that maximizing the throughput (MTBD problem) is NP-Complete in the strong sense but that a small additive resource augmentation (of 1) on the servers degrees is enough to find in polynomial time a solution that achieves at least the optimal throughput. In this paper, we consider the reasonable setting where the set of slave processors is not known in advance but rather join and leave the system at any time, i.e. the online version of MTBD. We prove that no fully online algorithm (where nodes cannot be disconnected even if they do not leave the system) can achieve a constant approximation ratio, whatever the resource augmentation on servers degrees. Then, we prove that it is possible to maintain the optimal solution at the cost of at most one change per server each time a new node joins and leave the system. At last, we propose several other greedy heuristics to solve the online problem and we compare the performance (in terms of throughput) and the cost (in terms of disconnexions and reconnections) of proposed algorithms through a set of extensive simulation results.

We consider an online version of the conflict-free coloring of a set of points on the line, where each newly inserted point must be assigned a color upon insertion, and at all times the coloring has to be conflict-free, in the sense that in every interval I there is a color that appears exactly once in I. We present deterministic and randomized algorithms for achieving this goal, and analyze their performance, that is, the maximum number of colors that they need to use, as a function of the number n of inserted points. We first show that a natural and simple (deterministic) approach may perform rather poorly, requiring Ω(√ n) colors in the worst case. We then derive two efficient variants of this simple algorithm. The first is deterministic and uses O(log 2 n) colors, and the second is randomized and uses O(log n) colors with high probability. We also show that the O(log 2 n) bound on the number of colors used by our deterministic algorithm is tight on the worst case. We also analyze the performance of the simplest proposed algorithm when the points are inserted in a random order, and present an incomplete analysis that indicates that, with high probability, it uses only O(log n) colors. Finally, we show that in the extension of this problem to two dimensions, where the relevant ranges are disks, n colors may be required in the worst case.

Parallelism plays a significant role in high-performance computing systems, from large clusters of computers to chip-multithreading (CMT) processors. Performance of the parallel systems comes not only from concurrently running more processing hardware but also from utilizing the hardware efficiently. The hardware utilization is strongly influenced by how processors/processes are synchronized in the system to maximize parallelism. Synchronization between concurrent processes usually relies on shared data structures. The data structures that enhance parallelism by allowing processes to access them concurrently are known as concurrent data structures. The thesis aims at developing efficient concurrent data structures and algorithms for synchronization in asynchronous shared-memory multiprocessors. Generally speaking, simple data structures perform well in the absence of contention but perform poorly in high-contention situations. Contrarily, sophisticated data structures that can scale and perform well in the presence of high contention usually suffer unnecessary high latency when there is no contention. Efficient concurrent data structures should be able to adapt their algorithmic complexity to varying contention. This has motivated us to develop fundamental concurrent data structures like trees, multi-word compare-and-swap and locks into reactive ones that timely adapt their size or algorithmic behavior to the contention level in execution environments. While the contention is varying rapidly, the reactive data structures must keep the cost of reaction below its benefit, avoiding unnecessary reaction due to the contention oscillation. This is quite challenging since the information of how the contention will vary in the future is usually not available in multiprogramming multiprocessor environments. To deal with the uncertainty, we have successfully synthesized non-blocking synchronization techniques and advanced on-line algorithmic techniques, in the context of reactive concurrent data structures. On the other hand, we have developed a new optimal on-line algorithm for one-way trading with time-varying exchange-rate bounds. The algorithm extends the set of practical problems that can be transformed to the one-way trading so as to find an optimal solution. In this thesis, the new algorithm demonstrates its applicability by solving the freshness problem in the context of concurrent data structures.

The emergence of systems with non-volatile main memory (NVRAM) increases the need for persistent concurrent objects. Of specific interest are recoverable implementations that, in addition to being robust to crash-failures, are also detectable. Detectability ensures that upon recovery, it is possible to infer whether the failed operation took effect or not and, in the former case, obtain its response. This work presents two recoverable detectable Fetch&Add (FAA) algorithms that are selfimplementations, i.e, use only a fetch&add base object, in addition to read/write registers. The algorithms target two different models for recovery: the global-crash model and the individual-crash model. In both algorithms, operations are wait-free when there are no crashes, but the recovery code may block if there are repeated failures. We also prove that in the individual-crash model, there is no implementation of recoverable and detectable FAA using only read, write and fetch&add primitives in whic...

We present the concept of on-line processing as an effective approach to overcome the data distribution overhead in parallel real-time implementation of low level vision. On-line processing refers to pipelining each input item with the pipeline rate equal to the input arrival rate. We have presented on-line algorithms for four benchmark low level tasks, viz., 2D convolution, 2D rank value filtering, connected component labeling, and hough transform. A two stage pipelined module that allows on-line implementations is described. This module is to function as a coprocessor to nodes in B-HIVE, a loosely coupled multiprocessor for integrated vision, currently under development at NC State University.

In recent years, there has been a lot of interest in Quality of Service (QoS) networks. In regular IP networks, packets are indistinguishable and in case of overload any packet may be dropped. In a commercial environment, it is much more preferable to allow better service to higher-paying customers or customers with critical requirements. The idea of Quality of Service guarantees is that packets are marked with values which indicate their importance. This naturally leads to decision problems at network switches when many packets arrive and overload occurs. In this paper, we give an overview of several models that have been studied in this area from an online perspective. These models differ by restrictions such as bounded delay, bounded size of queue etc. We first present results for a single buffer in Section 1 and then for multiple buffers in Section 2. This paper is not meant as a comprehensive survey of the work in this area. There are many more variations of these problems that have been studied, for instance, multiple output buffers [14]. Our goal was merely to give a taste of this problem area, and we hope you enjoy it.

We consider the on-line load balancing problem where there are m identical machines (servers). Jobs arrive at arbitrary times, where each job has a weight and a duration. A job has to be assigned upon its arrival to exactly one of the machines. The duration of each job becomes known only upon its termination (this is called temporary tasks of unknown durations). Once a job has been assigned to a machine it cannot be reassigned to another machine. The goal is to minimize the maximum over time of the sum (over all machines) of the squares of the loads, instead of the traditional maximum load. Minimizing the sum of the squares is equivalent to minimizing the load vector with respect to the 2 norm. We show that for the 2 norm the greedy algorithm performs within at most 1.493 of the optimum. We show (an asymptotic) lower bound of 1.33 on the competitive ratio of the greedy algorithm. We also show a lower bound of 1.20 on the competitive ratio of any algorithm. We extend our techniques and analyze the competitive ratio of the greedy algorithm with respect to the p norm. We show that the greedy algorithm performs within at most 2 − Ω(1/p) of the optimum. We also show a lower bound of 2 − O(ln p/p) on the competitive ratio of any on-line algorithm.

We consider the problem of scheduling on parallel uniformly related machines, where preemptions are allowed and the machines are controlled by selfish agents. Our goal is to minimize the makespan, whereas the goal of the agents is to maximize their profit. We show that a known algorithm is monotone and can therefore be used to create a truthful mechanism for this problem which achieves the optimal makespan. We extend this result for additional common goal functions.

A generalized paging problem is considered. Each request is expressed as a set of u pages. In order to satisfy the request, at least one of these pages must be in the cache. Therefore, on a page fault, the algorithm must load into the cache at least one page out of the u pages given in the request. The problem arises in systems in which requests can be serviced by various utilities (e.g., a request for a data that lies in various web-pages) and a single utility can service many requests (e.g., a web-page containing various data). The server has the freedom to select the utility that will service the next request and hopefully additional requests in the future. The case u = 1 is simply the classical paging problem, which is known to be polynomially solvable. We show that for any u > 1 the offline problem is NP-hard and hard to approximate if the cache size k is part of the input, but solvable in polynomial time for constant values of k. We consider mainly online algorithms, and design competitive algorithms for arbitrary values of k, u. We study in more detail the cases where u and k are small. We also give an algorithm which uses resource augmentation and which is asymptotically optimal for u = 2.

The problem of scheduling jobs that arrive over time on a single machine is well-studied. We study the preemptive model and the model with restarts. We p rovide lower bounds for deterministic and randomized algorithms for several optimality criteria: weighted and unweighted total completion time, and weighted and unweighted total ow time. By using new techniques, we p rovide the rst lower bounds for several of these problems, and we signi cantly improve the bounds that were known.

We prove an exact lower bound of 2 1 m on the competitive ratio of any deterministic algorithm for load balancing of temporary tasks on m identical machines. We also show a lower bound of 2 1 m for randomized algorithms for small m and 2 2 m+1 for general m. If in addition, we restrict the sequence to polynomial length, then the lower bound for randomized algorithms becomes 2 O(loglog m logm) for general m.

We study a new kind of online bin packing with conflicts, motivated by a problem arising when scheduling jobs on the Grid. In this bin packing problem, the set of items is given at the beginning, together with a set of conflicts on pairs of items. A conflict on a pair of items implies that they cannot be assigned to a common bin. The online scenario is realized as follows. Variable-sized bins arrive one by one, and items need to be assigned to each bin before the next bin arrives. We analyze the online problem as well as semi-online versions of it, which are the variant where the sizes of the arriving bins are monotonically nonincreasing as well as the variant where they are monotonically non-decreasing.

Given a set of m identical bins of size 1, the online input consists of a (potentially, infinite) stream of items in (0, 1]. Each item is to be assigned to a bin upon arrival. The goal is to cover all bins, that is, to reach a situation where a total size of items of at least 1 is assigned to each bin. The cost of an algorithm is the sum of all used items at the moment when the goal is first fulfilled. We consider three variants of the problem, the online problem, where there is no restriction of the input items, and the two semi-online models, where the items arrived sorted by size, that is, either by non-decreasing size or by non-increasing size. The offline problem is considered as well.

Batching has been studied extensively in the offline case, but applications such as manufacturing or TCP acknowledgment often require online solutions. We consider online batching problems, where the order of jobs to be batched is fixed and where we seek to minimize the sum of the completion times of the jobs. We present optimally competitive online algorithms for both s-batch and p-batch problems, and we also derive results for certain naturally occurring special cases, such as the case of unit processing times.

In the variable-sized online bin packing problem, one has to assign items to bins one by one. The bins are drawn from some fixed set of sizes, and the goal is to minimize the sum of the sizes of the bins used. We present new algorithms for this problem and show upper bounds for them which improve on the best previous upper bounds. We also show the first general lower bounds for this problem. The case in which bins of two sizes, 1 and α ∈ (0, 1), are used is studied in detail. This investigation leads us to the discovery of several interesting fractal-like curves.

The relative worst-order ratio is a measure of the quality of online algorithms. In contrast to the competitive ratio, this measure compares two online algorithms directly instead of using an intermediate comparison with an optimal offline algorithm. In this paper, we apply the relative worst-order ratio to online algorithms for several common variants of the bin packing problem. We mainly consider pairs of algorithms that are not distinguished by the competitive ratio and show that the relative worst-order ratio prefers the intuitively better algorithm of each pair.

The following scheduling problem is studied: We are given a set of tasks with release times, deadlines, and profit rates. The objective is to determine a 1-processor preemptive schedule of the given tasks that maximizes the overall profit. In the standard model, each completed task brings profit, while noncompleted tasks do not. In the metered model, a task brings profit proportional to the execution time even if not completed. For the metered task model, we present an efficient offline algorithm and improve both the lower and upper bounds on the competitive ratio of online algorithms. Furthermore, we prove three lower bound results concerning resource augmentation in both models.

We consider load balancing of temporary tasks on m machines in the restricted assignment model. It is known that the best competitive ratio for this problem is ). This bound is not achieved by the greedy algorithm whose competitive ratio is known to be Ω(m 2 3 ). We give an alternative analysis to the greedy algorithm which is better than the known analysis for relatively small values of m. We also show that for a small number of machines, namely m ≤ 5, the greedy algorithm is optimal.

We consider the Unrestricted Bin Packing problem where we have bins of equal size and a sequence of items. The goal is to maximize the number of items that are packed in the bins by an on-line algorithm. We investigate the power of performing admission control on the items, i.e., rejecting items while there is enough space to pack them, versus behaving fairly, i.e., rejecting an item only when there is not enough space to pack it. We show that by performing admission control on the items, we get better performance for various measures compared with the performance achieved on the fair version of the problem. Our main result shows that we can pack 2=3 of the items for sequences in which the optimal can pack all the items.

We introduce a data stream model of computation for Graph Drawing, where a source produces a graph one edge at a time. When an edge is produced, it is immediately drawn and its drawing can not be altered. The drawing has an image persistence, that controls the lifetime of edges. If the persistence is k, an edge remains in the drawing for the time spent by the source to generate k edges, then it fades away. In this model we study the area requirement of planar straight-line grid drawings of trees, with different streaming orders, layout models, and quality criteria. We assess the output quality of the presented algorithms by computing the competitive ratio with respect to the best known offline algorithms.

We consider an online version of the conflict-free coloring of a set of points on the line, where each newly inserted point must be assigned a color upon insertion, and at all times the coloring has to be conflict-free, in the sense that in every interval I there is a color that appears exactly once in I. We present several deterministic and randomized algorithms for achieving this goal, and analyze their performance, that is, the maximum number of colors that they need to use, as a function of the number n of inserted points. We first show that a natural and simple (deterministic) approach may perform rather poorly, requiring Ω(√ n) colors in the worst case. We then derive several efficient algorithms. The first algorithm is randomized and simple to analyze; it requires an expected number of at most O(log 2 n) colors, and produces a coloring which is valid with high probability. The second algorithm is deterministic, and is a variant of the initial simple algorithm; it uses a maximum of Θ(log 2 n) colors. The third algorithm is a randomized variant of the second algorithm; it requires an expected number of at most O(log n log log n) colors and always produces a valid coloring. We also analyze the performance of the simplest proposed algorithm when the points are inserted in a random order, and present an incomplete analysis that indicates that, with high probability, it uses only O(log n) colors. Finally, we show that in the extension of this problem to two dimensions, where the relevant ranges are disks, n colors may be required in the worst case.

We consider online scheduling algorithms in the dynamic speed scaling model, where a processor can scale its speed between 0 and some maximum speed T. The processor uses energy at rate s α when run at speed s, where α > 1 is a constant. Most modern processors use dynamic speed scaling to manage their energy usage. This leads to the problem of designing execution strategies that are both energy efficient, and yet have almost optimum performance. We consider two problems in this model and give essentially optimum possible algorithms for them. In the first problem, jobs with arbitrary sizes and deadlines arrive online and the goal is to maximize the throughput, i.e. the total size of jobs completed successfully. We give an algorithm that is 4-competitive for throughput and O(1)-competitive for the energy used. This improves upon the 14 throughput competitive algorithm of Chan et al. [10]. Our throughput guarantee is optimal as any online algorithm must be at least 4-competitive even if the energy concern is ignored [7]. In the second problem, we consider optimizing the trade-off between the total flow time incurred and the energy consumed by the jobs. We give a 4-competitive algorithm to minimize total flow time plus energy for unweighted unit size jobs, and a (2 + o(1))α/ ln α-competitive algorithm to minimize fractional weighted flow time plus energy. Prior to our work, these guarantees were known only when the processor speed was unbounded (T = ∞) [4].

Optimum o-line algorithms for the list update problem are investigated. The list update problem involves implementing a dictionary of items as a linear list. Several characterizations of optimum algorithms are given; these lead to optimum algorithm which runs in time 2 n (n ? 1)!m, where n is the length of the list and m is the number of requests. The previous best algorithm, an adaptation of a more general algorithm due to Manasse et al. 9], runs in time (n!) 2 m.

We survey results on self-organizing data structures for the search problem and concentrate on two very popular structures: the unsorted linear list, and the binary search tree. For the problem of maintaining unsorted lists, also known as the list update problem, we present results on the competitiveness achieved by deterministic and randomized on-line algorithms. For binary search trees, we present results for both on-line and o-line algorithms. Self-organizing data structures can be used to build very e ective data compression schemes. We summarize theoretical and experimental results.