David Scot Taylor

Progressive merge join: a generic and non-blocking sort-based join algorithm

This chapter presents a generic technique called progressive merge join (PMJ) that eliminates the blocking behavior of sort-based join algorithms. The basic idea behind PMJ is to have the join produce results, as early as the external mergesort generates initial runs. Many state-of-the-art join techniques require the input relations to be almost fully sorted before the actual join processing starts. Thus, these techniques start producing first results only after a considerable time has passed. This blocking behavior is a serious problem when consequent operators have to stop processing in order to wait for first results of the join. Furthermore, this behavior is not acceptable if the result of the join is visualized or/and requires user interaction. These are typical scenarios for data mining applications. The off-time of existing techniques even increases with growing problem sizes.

Tight bounds for 2-dimensional indexing schemes

We study the trade-off between storage redundancy and access overhead for range queries, using the framework of [6]. We show that the Fibonacci workload of size n, which is the regular 2-dimensional grid rotated by the golden ratio, does not admit an indexing scheme with access overhead less than the block size B (the worst possible access overhead), even for storage redundancy as high as clogn, for some constant c. We also show that this bound is tight (up to a constant factor) by providing an indexing scheme with storage redundancy O(logn) and constant access overhead, for any 2-dimensional workload. We extend the lower bound to random point sets and show that if the maximum storage redundancy is less than cloglogn, the access overhead is 13, Finally, we explore the relation between indexability and fractal (Hausdorff) dimension of point sets.

Approximation Algorithms for Clustering to Minimize the Sum of Diameters

We consider the problem of partitioning the n nodes of a complete edge weighted graph into k clusters so as to minimize the sum of the diameters of the clusters. Since the problem is NP-complete, our focus is on the development of good approximation algorithms. When edge weights satisfy the triangle inequality, we present the first approximation algorithm for the problem. The approximation algorithm yields a solution which has no more than O(k) clusters such that the sum of cluster diameters is within a factor O(ln (n/k)) of the optimal value using exactly k clusters. Our approach also permits a tradeoff among the constant terms hidden by the two big-O terms and the running time. For any fixed k, we present an approximation algorithm that produces k clusters whose total diameter is at most twice the optimal value. When the distances are not required to satisfy the triangle inequality, we show that, unless P = NP, for any ρ ≥ 1, there is no polynomial time approximation algorithm that can provide a performance guarantee of ρ even when the number of clusters is fixed at 3. We also present some results for the problem of minimizing the sum of cluster radii.

Server Placements, Roman Domination and other Dominating Set Variants

Dominating sets in their many variations model a wealth of optimization problems like facility location or distributed file sharing. For instance, when a request can occur at any node in a graph and requires a server at that node, a minimum dominating set represents a minimum set of servers that serve an arbitrary single request by moving a server along at most one edge. This paper studies domination problems for two requests. For the problem of placing a minimum number of servers such that two requests at different nodes can be served with two different servers (called win-win), we present a logarithmic approximation, and we prove that nothing better is possible. We show that the same is true for Roman domination, the well studied problem variant that asks for each vertex to either possess its own server or to have a neighbor with two servers. Still the same is true if each idle server can move along one edge while the first of both requests is being served. For planar graphs, we propose a PTAS for Roman domination (and show that nothing better exists), and we get a constant approximation for win-win.

On producing join results early

Support for exploratory interaction with databases in applications such as data mining requires that the first few results of an operation be available as quickly as possible. We study the algorithmic side of what can and what cannot be achieved for processing join operations. We develop strategies that modify the strict two-phase processing of the sort-merge paradigm, intermingling join steps with selected merge phases of the sort. We propose an algorithm that produces early join results for a broad class of join problems, including many not addressed well by hash-based algorithms. Our algorithm has no significant increase in the number of I/O operations needed to complete the join compared to standard sort-merge algorithms.

The CNN Problem and Other k-Server Variants

We study several interesting variants of the k-server problem. In the cnn problem, one server services requests in the Euclidean plane. The difference from the k-server problem is that the server does not have to move to a request, but it has only to move to a point that lies in the same horizontal or vertical line with the request. This, for example, models the problem faced by a crew of a certain news network trying to shoot scenes on the streets of Manhattan from a distance; the crew has only to be on a matching street or avenue. The CNN problem contains as special cases two important problems: the bridge problem, also known as the cow-path problem, and the weighted 2-server problem in which the 2 servers may have different speeds. We show that any deterministic on-line algorithm has competitive ratio at least 6+√17. We also show that some successful algorithms for the k-server problem fail to be competitive. In particular, we show that no natural lazy memoryless randomized algorithm can be competitive. The CNN problem also motivates another variant of the k-server problem, in which servers can move simultaneously, and we wish to minimize the time spent waiting for service. This is equivalent to the regular k-server problem under the L∞ norm for movement costs. We give a 1/2k(k + 1) upper bound for the competitive ratio on trees.

The CNN problem and other k -server variants

We study several interesting variants of the k-server problem. In the CNN problem, one server services requests in the Euclidean plane. The difference from the k-server problem is that the server does not have to move to a request, but it has only to move to a point that lies in the same horizontal or vertical line with the request. This, for example, models the problem faced by a crew of a certain News Network trying to shoot scenes on the streets of Manhattan from a distance; for any event at an intersection, the crew has only to be on a matching street or avenue. The CNN problem contains as special cases two important problems: the BRIDGE problem, also known as the cow-path problem, and the weighted 2-server problem in which the 2 servers may have different speeds. We show that any deterministic online algorithm has competitive ratio at least 6 + √17. We also show that some successful algorithms for the k-server problem fail to be competitive. In particular, no memoryless randomized algorithm can be competitive.We also consider another variant of the k-server problem, in which servers can move simultaneously, and we wish to minimize the time spent waiting for service. This is equivalent to the regular k-server problem under the L∞ norm for movement costs. We give a ½ k(k + 1) upper bound for the competitive ratio on trees.

On the Complexity of Train Assignment Problems

We consider a problem faced by train companies: How can trains be assigned to satisfy scheduled routes in a cost efficient way? Currently, many railway companies create solutions by hand, a timeconsuming task which is too slow for interaction with the schedule creators. Further, it is difficult to measure how efficient the manual solutions are. We consider several variants of the problem. For some, we give efficient methods to solve them optimally, while for others, we prove hardness results and propose approximation algorithms.

Predictive vs. passive animation learning tools

We investigate the effectiveness of a predictive interaction animation tool for understanding graph algorithms. We compare performance improvement of students after they have used two different animation tools for the given algorithms, when one of the tools forces a more active, predictive approach while the other is a more traditional animation. Results show significant improvement in performance after students use the predictive tool.

Progressive Merge Join

This chapter presents a generic technique called progressive merge join (PMJ) that eliminates the blocking behavior of sort-based join algorithms. The basic idea behind PMJ is to have the join produce results, as early as the external mergesort generates initial runs. Many state-of-the-art join techniques require the input relations to be almost fully sorted before the actual join processing starts. Thus, these techniques start producing first results only after a considerable time has passed. This blocking behavior is a serious problem when consequent operators have to stop processing in order to wait for first results of the join. Furthermore, this behavior is not acceptable if the result of the join is visualized or/and requires user interaction. These are typical scenarios for data mining applications. The off-time of existing techniques even increases with growing problem sizes.