arXiv subjects

Friedhelm Meyer auf der Heide

Publications and source records attributed to Friedhelm Meyer auf der Heide.

At least 19 recordsLinked to original sources

arXiv2023

Server Cloud Scheduling

Consider a set of jobs connected to a directed acyclic task graph with a fixed source and sink. The edges of this graph model precedence constraints and the jobs have to be scheduled with respect to those. We introduce the Server Cloud Scheduling problem, in which the jobs have to be processed either on a single local machine or on one of many cloud machines. Both the source and the sink have to be scheduled on the local machine. For each job, processing times both on the server and in the cloud are given. Furthermore, for each edge in the task graph, a communication delay is included in the input and has to be taken into account if one of the two jobs is scheduled on the server, the other in the cloud. The server can process jobs sequentially, whereas the cloud can serve as many as needed in parallel, but induces costs. We consider both makespan and cost minimization. The main results are an FPTAS with respect for the makespan objective for a fairly general case and strong hardness for the case with unit processing times and delays.

cs.DS↗

arXiv2022

The k-Server with Preferences Problem

The $k$-Server Problem covers plenty of resource allocation scenarios, and several variations have been studied extensively for decades. We present a model generalizing the $k$-Server Problem by preferences of the requests, where the servers are not identical and requests can express which specific servers should serve them. In our model, requests can either be answered by any server (general requests) or by a specific one (specific requests). If only general requests appear, the instance is one of the original $k$-Server Problem, and a lower bound for the competitive ratio of $k$ applies. If only specific requests appear, a solution with a competitive ratio of $1$ becomes trivial. We show that if both kinds of requests appear, the lower bound raises to $2k-1$. We study deterministic online algorithms and present two algorithms for uniform metrics. The first one has a competitive ratio dependent on the frequency of specific requests. It achieves a worst-case competitive ratio of $3k-2$ while it is optimal when only general requests appear or when specific requests dominate the input sequence. The second has a worst-case competitive ratio of $2k+14$. For the first algorithm, we show a lower bound of $3k-2$, while the second algorithm has a lower bound of $2k-1$ when only general requests appear. The two algorithms differ in only one behavioral rule that significantly influences the competitive ratio. We show that there is a trade-off between performing well against instances of the $k$-Server Problem and mixed instances based on the rule. Additionally, no deterministic online algorithm can be optimal for both kinds of instances simultaneously. Regarding non-uniform metrics, we present an adaption of the Double Coverage algorithm for $2$ servers on the line achieving a competitive ratio of $6$, and an adaption of the Work-Function-Algorithm achieving a competitive ratio of $4k$.

cs.DS↗

arXiv2022

A Unifying Approach to Efficient (Near)-Gathering of Disoriented Robots with Limited Visibility

We consider a swarm of $n$ robots in \mathbb{R}^d. The robots are oblivious, disoriented (no common coordinate system/compass), and have limited visibility (observe other robots up to a constant distance). The basic formation task gathering requires that all robots reach the same, not predefined position. In the related near-gathering task, they must reach distinct positions such that every robot sees the entire swarm. In the considered setting, gathering can be solved in $\mathcal{O}(n + Δ^2)$ synchronous rounds both in two and three dimensions, where $Δ$ denotes the initial maximal distance of two robots. In this work, we formalize a key property of efficient gathering protocols and use it to define $λ$-contracting protocols. Any such protocol gathers $n$ robots in the $d$-dimensional space in $\mathcal{O}(Δ^2)$ synchronous rounds. Moreover, we prove a corresponding lower bound stating that any protocol in which robots move to target points inside of the local convex hulls of their neighborhoods -- $λ$-contracting protocols have this property -- requires $Ω(Δ^2)$ rounds to gather all robots. Among others, we prove that the $d$-dimensional generalization of the GtC-protocol is $λ$-contracting. Remarkably, our improved and generalized runtime bound is independent of $n$ and $d$. The independence of $d$ answers an open research question. We also introduce an approach to make any $λ$-contracting protocol collisionfree to solve near-gathering. The resulting protocols maintain the runtime of $Θ(Δ^2)$ and work even in the semi-synchronous model.

cs.DC↗

arXiv2021

The Max-Line-Formation Problem

We consider n robots with limited visibility: each robot can observe other robots only up to a constant distance denoted as the viewing range. The robots operate in discrete rounds that are either fully synchronous (FSync) or semi-synchronized (SSync). Most previously studied formation problems in this setting seek to bring the robots closer together (e.g., Gathering or Chain-Formation). In this work, we introduce the Max-Line-Formation problem, which has a contrary goal: to arrange the robots on a straight line of maximal length. First, we prove that the problem is impossible to solve by robots with a constant sized circular viewing range. The impossibility holds under comparably strong assumptions: robots that agree on both axes of their local coordinate systems in FSync. On the positive side, we show that the problem is solvable by robots with a constant square viewing range, i.e., the robots can observe other robots that lie within a constant-sized square centered at their position. In this case, the robots need to agree on only one axis of their local coordinate systems. We derive two algorithms: the first algorithm considers oblivious robots and converges to the optimal configuration in time $\mathcal{O}(n^2 \cdot \log (n/\varepsilon))$ under the SSync scheduler. The other algorithm makes use of locally visible lights (LUMI). It is designed for the FSync scheduler and can solve the problem exactly in optimal time $Θ(n)$. Afterward, we show that both the algorithmic and the analysis techniques can also be applied to the Gathering and Chain-Formation problem: we introduce an algorithm with a reduced viewing range for Gathering and give new and improved runtime bounds for the Chain-Formation problem.

cs.DC↗

arXiv2021

Gathering a Euclidean Closed Chain of Robots in Linear Time

This work focuses on the following question related to the Gathering problem of $n$ autonomous, mobile robots in the Euclidean plane: Is it possible to solve Gathering of robots that do not agree on any axis of their coordinate systems (disoriented robots) and see other robots only up to a constant distance (limited visibility) in $o(n^2)$ fully synchronous rounds? The best known algorithm that solves Gathering of disoriented robots with limited visibility assuming oblivious robots needs $Θ(n^2)$ rounds [SPAA'11]. The lower bound for this algorithm even holds in a simplified closed chain model, where each robot has exactly two neighbors and the chain connections form a cycle. The only existing algorithms achieving a linear number of rounds for disoriented robots assume robots that are located on a two dimensional grid [IPDPS'16] and [SPAA'16]. Both algorithms make use of locally visible lights (the LUMINOUS model). In this work, we show for the closed chain model, that $n$ disoriented robots with limited visibility in the Euclidean plane can be gathered in $Θ\left(n\right)$ rounds assuming the LUMINOUS model. The lights are used to initiate and perform so-called runs along the chain. For the start of such runs, locally unique robots need to be determined. In contrast to the grid [IPDPS'16], this is not possible in every configuration in the Euclidean plane. Based on the theory of isogonal polygons by Grünbaum, we identify the class of isogonal configurations in which no such locally unique robots can be identified. Our solution combines two algorithms: The first one gathers isogonal configurations; it works without any lights. The second one works for non-isogonal configurations; it identifies locally unique robots to start runs, using a constant number of lights. Interleaving these algorithms solves the Gathering problem in $\mathcal{O}(n)$ rounds.

cs.DC↗

arXiv2020

A Discrete and Continuous Study of the Max-Chain-Formation Problem

Most existing robot formation problems seek a target formation of a certain \emph{minimal} and, thus, efficient structure. Examples include the Gathering and the Chain-Formation problem. In this work, we study formation problems that try to reach a \emph{maximal} structure, supporting for example an efficient coverage in exploration scenarios. A recent example is the NASA Shapeshifter project, which describes how the robots form a relay chain along which gathered data from extraterrestrial cave explorations may be sent to a home base. As a first step towards understanding such maximization tasks, we introduce and study the Max-Chain-Formation problem, where $n$ robots are ordered along a winding, potentially self-intersecting chain and must form a connected, straight line of maximal length connecting its two endpoints. We propose and analyze strategies in a discrete and in a continuous time model. In the discrete case, we give a complete analysis if all robots are initially collinear, showing that the worst-case time to reach an $\varepsilon$-approximation is upper bounded by $\mathcal{O}(n^2 \cdot \log (n/\varepsilon))$ and lower bounded by $Ω(n^2 \cdot~\log (1/\varepsilon))$. If one endpoint of the chain remains stationary, this result can be extended to the non-collinear case. If both endpoints move, we identify a family of instances whose runtime is unbounded. For the continuous model, we give a strategy with an optimal runtime bound of $Θ(n)$. Avoiding an unbounded runtime similar to the discrete case relies crucially on a counter-intuitive aspect of the strategy: slowing down the endpoints while all other robots move at full speed. Surprisingly, we can show that a similar trick does not work in the discrete model.

cs.DC↗

arXiv2020

The Online Multi-Commodity Facility Location Problem

We consider a natural extension to the metric uncapacitated Facility Location Problem (FLP) in which requests ask for different commodities out of a finite set $S$ of commodities. Ravi and Sinha (SODA'04) introduced the model as the Multi-Commodity Facility Location Problem (MFLP) and considered it an offline optimization problem. The model itself is similar to the FLP: i.e., requests are located at points of a finite metric space and the task of an algorithm is to construct facilities and assign requests to facilities while minimizing the construction cost and the sum over all assignment distances. In addition, requests and facilities are heterogeneous; they request or offer multiple commodities out of $S$. A request has to be connected to a set of facilities jointly offering the commodities demanded by it. In comparison to the FLP, an algorithm has to decide not only if and where to place facilities, but also which commodities to offer at each. To the best of our knowledge we are the first to study the problem in its online variant in which requests, their positions and their commodities are not known beforehand but revealed over time. We present results regarding the competitive ratio. On the one hand, we show that heterogeneity influences the competitive ratio by developing a lower bound on the competitive ratio for any randomized online algorithm of $Ω(\sqrt{|S|}+\frac{\log n}{\log\log n})$ that already holds for simple line metrics. Here, $n$ is the number of requests. On the other side, we establish a deterministic $O(\sqrt{|S|}\cdot\log n)$-competitive algorithm and a randomized $O(\sqrt{|S|}\cdot\frac{\log n}{\log\log n})$-competitive algorithm. Further, we show that when considering a more special class of cost functions for the construction cost of a facility, the competitive ratio decreases given by our deterministic algorithm depending on the function.

cs.DS↗

arXiv2020

Local Gathering of Mobile Robots in Three Dimensions

In this work, we initiate the research about the Gathering problem for robots with limited viewing range in the three-dimensional Euclidean space. In the Gathering problem, a set of initially scattered robots is required to gather at the same position. The robots' capabilities are very restricted -- they do not agree on any coordinate system or compass, have a limited viewing range, have no memory of the past and cannot communicate. We study the problem in two different time models, in FSYNC (fully synchronized discrete rounds) and the continuous time model. For FSYNC, we introduce the 3D-Go-To-The-Center-strategy and prove a runtime of $Θ(n^2)$ that matches the currently best runtime bound for the same model in the Euclidean plane [SPAA'11]. Our main result is the generalization of contracting strategies (continuous time) from [Algosensors'17] to three dimensions. In contracting strategies, every robot that is located on the global convex hull of all robots' positions moves with full speed towards the inside of the convex hull. We prove a runtime bound of $O(Δ\cdot n^{3/2})$ for any three-dimensional contracting strategy, where $Δ$ denotes the diameter of the initial configuration. This comes up to a factor of $\sqrt{n}$ close to the lower bound of $Ω(Δ\cdot n)$ which is already true in two dimensions. In general, it might be hard for robots with limited viewing range to decide whether they are located on the global convex hull and which movement maintains the connectivity of the swarm, rendering the design of concrete contracting strategies a challenging task. We prove that the continuous variant of 3D-Go-To-The-Center is contracting and keeps the swarm connected. Moreover, we give a simple design criterion for three-dimensional contracting strategies that maintains the connectivity of the swarm and introduce an exemplary strategy based on this criterion.

cs.CG↗

arXiv2019

Approximating Weighted Completion Time for Order Scheduling with Setup Times

Consider a scheduling problem in which jobs need to be processed on a single machine. Each job has a weight and is composed of several operations belonging to different families. The machine needs to perform a setup between the processing of operations of different families. A job is completed when its latest operation completes and the goal is to minimize the total weighted completion time of all jobs. We study this problem from the perspective of approximability and provide constant factor approximations as well as an inapproximability result. Prior to this work, only the NP-hardness of the unweighted case and the polynomial solvability of a certain special case were known.

cs.DS↗

arXiv2019

Managing Multiple Mobile Resources

We extend the Mobile Server Problem, introduced in SPAA'17, to a model where k identical mobile resources, here named servers, answer requests appearing at points in the Euclidean space. In order to reduce communication costs, the positions of the servers can be adapted by a limited distance m_s per round for each server. The costs are measured similar to the classical Page Migration Problem, i.e., answering a request induces costs proportional to the distance to the nearest server, and moving a server induces costs proportional to the distance multiplied with a weight D. We show that, in our model, no online algorithm can have a constant competitive ratio, i.e., one which is independent of the input length n, even if an augmented moving distance of (1+δ)m_s is allowed for the online algorithm. Therefore we investigate a restriction of the power of the adversary dictating the sequence of requests: We demand locality of requests, i.e., that consecutive requests come from points in the Euclidean space with distance bounded by some constant m_c. We show constant lower bounds on the competitiveness in this setting (independent of n, but dependent on k, m_s and m_c). On the positive side, we present a deterministic online algorithm with bounded competitiveness when augmented moving distance and locality of requests is assumed. Our algorithm simulates any given algorithm for the classical k-Page Migration problem as guidance for its servers and extends it by a greedy move of one server in every round. The resulting competitive ratio is polynomial in the number of servers k, the ratio between m_c and m_s, the inverse of the augmentation factor 1/δand the competitive ratio of the simulated k-Page Migration algorithm.

cs.DS↗

arXiv2019

Rendering of Complex Heterogenous Scenes using Progressive Blue Surfels

We present a technique for rendering highly complex 3D scenes in real-time by generating uniformly distributed points on the scene's visible surfaces. The technique is applicable to a wide range of scene types, like scenes directly based on complex and detailed CAD data consisting of billions of polygons (in contrast to scenes handcrafted solely for visualization). This allows to visualize such scenes smoothly even in VR on a HMD with good image quality, while maintaining the necessary frame-rates. In contrast to other point based rendering methods, we place points in an approximated blue noise distribution only on visible surfaces and store them in a highly GPU efficient data structure, allowing to progressively refine the number of rendered points to maximize the image quality for a given target frame rate. Our evaluation shows that scenes consisting of a high amount of polygons can be rendered with interactive frame rates with good visual quality on standard hardware.

cs.GR↗

arXiv2019

The Mobile Server Problem

We introduce the mobile server problem, inspired by current trends to move computational tasks from cloud structures to multiple devices close to the end user. An example for this are embedded systems in autonomous cars that communicate in order to coordinate their actions. Our model is a variant of the classical Page Migration Problem. More formally, we consider a mobile server holding a data page. The server can move in the Euclidean space (of arbitrary dimension). In every round, requests for data items from the page pop up at arbitrary points in the space. The requests are served, each at a cost of the distance from the requesting point and the server, and the mobile server may move, at a cost $D$ times the distance traveled for some constant $D$. We assume a maximum distance $m$ the server is allowed to move per round. We show that no online algorithm can achieve a competitive ratio independent of the length of the input sequence in this setting. Hence we augment the maximum movement distance of the online algorithms to $(1+δ)$ times the maximum distance of the offline solution. We provide a deterministic algorithm which is simple to describe and works for multiple variants of our problem. The algorithm achieves almost tight competitive ratios independent of the length of the input sequence. Our Algorithm also achieves a constant competitive ratio without resource augmentation in a variant where the distance between two consecutive requests is restricted to a constant smaller than the limit for the server.

cs.DS↗

arXiv2017

A Communication-Efficient Distributed Data Structure for Top-k and k-Select Queries

We consider the scenario of $n$ sensor nodes observing streams of data. The nodes are connected to a central server whose task it is to compute some function over all data items observed by the nodes. In our case, there exists a total order on the data items observed by the nodes. Our goal is to compute the $k$ currently lowest observed values or a value with rank in $[(1-\varepsilon)k,(1+\varepsilon)k]$ with probability $(1-δ)$. We propose solutions for these problems in an extension of the distributed monitoring model where the server can send broadcast messages to all nodes for unit cost. We want to minimize communication over multiple time steps where there are $m$ updates to a node's value in between queries. The result is composed of two main parts, which each may be of independent interest: (1) Protocols which answer Top-k and k-Select queries. These protocols are memoryless in the sense that they gather all information at the time of the request. (2) A dynamic data structure which tracks for every $k$ an element close to $k$. We describe how to combine the two parts to receive a protocol answering the stated queries over multiple time steps. Overall, for Top-$k$ queries we use $O(k + \log m + \log \log n)$ and for $k$-Select queries $O(\frac{1}{\varepsilon^2} \log \frac{1}δ + \log m + \log^2 \log n)$ messages in expectation. These results are shown to be asymptotically tight if $m$ is not too small.

cs.DS↗

arXiv2017

Non-Clairvoyant Scheduling to Minimize Max Flow Time on a Machine with Setup Times

Consider a problem in which $n$ jobs that are classified into $k$ types arrive over time at their release times and are to be scheduled on a single machine so as to minimize the maximum flow time. The machine requires a setup taking $s$ time units whenever it switches from processing jobs of one type to jobs of a different type. We consider the problem as an online problem where each job is only known to the scheduler as soon as it arrives and where the processing time of a job only becomes known upon its completion (non-clairvoyance). We are interested in the potential of simple "greedy-like" algorithms. We analyze a modification of the FIFO strategy and show its competitiveness to be $Θ(\sqrt{n})$, which is optimal for the considered class of algorithms. For $k=2$ types it achieves a constant competitiveness. Our main insight is obtained by an analysis of the smoothed competitiveness. If processing times $p_j$ are independently perturbed to $\hat p_j = (1+X_j)p_j$, we obtain a competitiveness of $O(σ^{-2} \log^2 n)$ when $X_j$ is drawn from a uniform or a (truncated) normal distribution with standard deviation $σ$. The result proves that bad instances are fragile and "practically" one might expect a much better performance than given by the $Ω(\sqrt{n})$-bound.

cs.DS↗

arXiv2017

Gathering Anonymous, Oblivious Robots on a Grid

We consider a swarm of $n$ autonomous mobile robots, distributed on a 2-dimensional grid. A basic task for such a swarm is the gathering process: All robots have to gather at one (not predefined) place. A common local model for extremely simple robots is the following: The robots do not have a common compass, only have a constant viewing radius, are autonomous and indistinguishable, can move at most a constant distance in each step, cannot communicate, are oblivious and do not have flags or states. The only gathering algorithm under this robot model, with known runtime bounds, needs $\mathcal{O}(n^2)$ rounds and works in the Euclidean plane. The underlying time model for the algorithm is the fully synchronous $\mathcal{FSYNC}$ model. On the other side, in the case of the 2-dimensional grid, the only known gathering algorithms for the same time and a similar local model additionally require a constant memory, states and "flags" to communicate these states to neighbors in viewing range. They gather in time $\mathcal{O}(n)$. In this paper we contribute the (to the best of our knowledge) first gathering algorithm on the grid that works under the same simple local model as the above mentioned Euclidean plane strategy, i.e., without memory (oblivious), "flags" and states. We prove its correctness and an $\mathcal{O}(n^2)$ time bound in the fully synchronous $\mathcal{FSYNC}$ time model. This time bound matches the time bound of the best known algorithm for the Euclidean plane mentioned above. We say gathering is done if all robots are located within a $2\times 2$ square, because in $\mathcal{FSYNC}$ such configurations cannot be solved.

cs.DC↗

arXiv2017

Monitoring of Domain-Related Problems in Distributed Data Streams

Consider a network in which $n$ distributed nodes are connected to a single server. Each node continuously observes a data stream consisting of one value per discrete time step. The server has to continuously monitor a given parameter defined over all information available at the distributed nodes. That is, in any time step $t$, it has to compute an output based on all values currently observed across all streams. To do so, nodes can send messages to the server and the server can broadcast messages to the nodes. The objective is the minimisation of communication while allowing the server to compute the desired output. We consider monitoring problems related to the domain $D_t$ defined to be the set of values observed by at least one node at time $t$. We provide randomised algorithms for monitoring $D_t$, (approximations of) the size $|D_t|$ and the frequencies of all members of $D_t$. Besides worst-case bounds, we also obtain improved results when inputs are parameterised according to the similarity of observations between consecutive time steps. This parameterisation allows to exclude inputs with rapid and heavy changes, which usually lead to the worst-case bounds but might be rather artificial in certain scenarios.

cs.DS↗

arXiv2016

Cost-efficient Scheduling on Machines from the Cloud

We consider a scheduling problem where machines need to be rented from the cloud in order to process jobs. There are two types of machines available which can be rented for machine-type dependent prices and for arbitrary durations. However, a machine-type dependent setup time is required before a machine is available for processing. Jobs arrive online over time, have machine-type dependent sizes and have individual deadlines. The objective is to rent machines and schedule jobs so as to meet all deadlines while minimizing the rental cost. Since we observe the slack of jobs to have a fundamental influence on the competitiveness, we study the model when instances are parameterized by their (minimum) slack. An instance is called to have a slack of $β$ if, for all jobs, the difference between the job's release time and the latest point in time at which it needs to be started is at least $β$. While for $β< s$ no finite competitiveness is possible, our main result is an $O(\frac{c}{\varepsilon} + \frac{1}{\varepsilon^3})$-competitive online algorithm for $β= (1+\varepsilon)s$ with $\frac{1}{s} \leq \varepsilon \leq 1$, where $s$ and $c$ denotes the largest setup time and the cost ratio of the machine-types, respectively. It is complemented by a lower bound of $Ω(\frac{c}{\varepsilon})$.

cs.DS↗

arXiv2016

Online Top-k-Position Monitoring of Distributed Data Streams

Consider n nodes connected to a single coordinator. Each node receives an individual online data stream of numbers and, at any point in time, the coordinator has to know the k nodes currently observing the largest values, for a given k between 1 and n. We design and analyze an algorithm that solves this problem while bounding the amount of messages exchanged between the nodes and the coordinator. Our algorithm employs the idea of using filters which, intuitively speaking, leads to few messages to be sent, if the new input is "similar" to the previous ones. The algorithm uses a number of messages that is on expectation by a factor of O((log Δ + k) log n) larger than that of an offline algorithm that sets filters in an optimal way, where Δ is upper bounded by the largest value observed by any node.

cs.DS↗