The assignment problem in distributed computing

The problem of allocating modules to processors in a distributed system to minimize total costs when the underlying communication graph is a partial k-tree and all costs are linear functions of a real parameter t is considered. It is shown that if the number of processors is fixed, the sequence of optimum assignments that are obtained as t varies from zero to infinity can be constructed in polynomial time. As an auxiliary result, a linear time separator algorithm for k-trees is developed. The implications of the results for parametric versions of the weighted vertex cover, independent set, and 0-1 quadratic programming problems on partial k-trees are discussed. >

The author studies the complexity of the problem of allocating modules to processes in a distributed system to minimize total communication and execution costs. He shows that unless P=NP, there can be no polynomial-time epsilon -approximate algorithm for the problem, nor can there exist a local search algorithm that requires polynomial time per iteration and yields an optimum assignment. Both results hold even if the communication graph is planar and bipartite. On the positive side, it is shown that if the communication graph is a partial k-tree or an almost-tree with parameter k, the module allocation problem can be solved in polynomial time.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The task allocation problem with constant communication

For a given graph G and p pairs (s i, ti), 1≤i≤p, of vertices in G, the edge-disjoint paths problem is to find p pairwise edge-disjoint paths P i, 1≤i≤p, connecting s i and t i. Many combinatorial problems can be efficiently solved for partial k-trees (graphs of treewidth bounded by a fixed integer k), but it has not been known whether the edge-disjoint paths problem can be solved in polynomial time for partial k-trees unless p=O(1). This paper gives two algorithms for the edge-disjoint paths problem on partial k-trees. The first one solves the problem for any partial k-tree G and runs in polynomial time if p=O(log n) and in linear time if p=O(1), where n is the number of vertices in G. The second one solves the problem under some restriction on the location of terminal pairs even if p ≥ log n.Key wordsedge-disjoint pathspartial k-treebounded tree-widthpolynomial-time algorithmedge-coloring

Generalized coloring for tree-like graphs

We consider the problem of scheduling tasks on multiprocessor architectures in the presence of communication delays. Given a set of dependent tasks, the scheduling problem is to allocate the tasks to processors such that the pre-specified precedence constraints among the tasks are obeyed and certain cost-measures (such as the computation time) are minimized. Several cases of the scheduling problem have

The bipartite unconstrained 0–1 quadratic programming problem: Polynomially solvable cases

Distributed computing systems are of current interest due to the advancement of microprocessor technology and computer network. The prime function of effective utilization of distributed system is accurately mapping of task and tasks their scheduling on different processors for reducing their total finish time. Total runtime is taken time for all module with the runtime of tasks and their communication cost among tasks. In Distributed processing system, partitioning of a task into modules and proper allocation of module among processors are more important factor for efficient utilization of resources. In this paper, we discuss allocation of a set of 'm' module of a task to a set of 'n' processors (where m > n) to get an optimal utilization of available processors. We partition the task in different size of module and design an algorithm for allocation of these modules in distributed processing environment. While designing the model Per Bit Processing Rate, Inter Task Communication Cost, Task Size has been taken into consideration. We consider the constraints of minimizing execution cost and their Inter task communication and maximize the overall throughput of the system to be taking as constraints in such a way that allocated load on all the processor is balances. Keyword: Distributed computing, Task Allocation, Module distribution, Execution Cost, Communication Cost, Task Size.

A model is considered for representing recurrent precedence-constrained tasks that are to execute on multiprocessor platforms. A recurrent task is specified as a directed acyclic graph (DAG), a period, and a relative deadline. Each vertex of the DAG represents a sequential job, while the edges of the DAG represent precedence constraints between these jobs. All the jobs of the DAG are released simultaneously and need to complete execution within the specified relative deadline of their release. Each task may release jobs in this manner an unbounded number of times, with successive releases occurring at least the specified period apart. Conditional control structures are also allowed. The scheduling problem is to determine whether a set of such recurrent tasks can be scheduled to always meet all deadlines upon a specified number of identical processors. This problem is shown to be computationally intractable, but amenable to efficient approximate solutions. Earliest Deadline First (EDF) and Deadline Monotonic (DM) are shown to be good approximate global scheduling algorithms. Polynomial and pseudo-polynomial time schedulability tests, of differing effectiveness, are presented for determining whether a given task set can be scheduled by EDF or DM to always meet deadlines on a specified number of processors.

Computing residual connectedness reliability for restricted networks

The problem of counting all H-colorings of a graph G of n vertices is considered. While the problem is, in general, #P-complete, we give linear time algorithms that solve the main variants of this problem when the input graph G is a k-tree or, in the case where G is directed, when the underlying graph of G is a k-tree. Our algorithms remain polynomial even in the case where k = O(log n) or in the case where the size of H is O(n). Our results are easy to implement and imply the existence of polynomial time algorithms for a series of problems on partial k-trees such as core checking and chromatic polynomial computation.

The complexity of the maximum common subgraph problem in partial k-trees is still largely unknown. We consider the restricted case, where the input graphs are k-connected partial k-trees and the common subgraph is required to be k-connected. For biconnected outerplanar graphs this problem is solved and the general problem was reported to be tractable by means of tree decomposition techniques. We discuss key obstacles of tree decompositions arising for common subgraph problems that were ignored by previous algorithms and do not occur in outerplanar graphs. We introduce the concept of potential separators, i.e., separators of a subgraph to be searched that not necessarily are separators of the input graph. We characterize these separators and propose a polynomial time solution for series-parallel graphs based on SP-trees.KeywordsTree decompositionmaximum common subgraphseries-parallel graph

The problem of optimal scheduling n tasks in a parallel processor system is studied. The tasks are malleable, i.e., a task may be executed by several processors simultaneously and the processing speed of a task is a nonlinear function of the number of processors allocated to it. The total number of processors is m and it is an upper bound on the number of processors that can be used by all the tasks simultaneously. It is assumed that the number of processors is sufficient to process all the tasks simultaneously, i.e. n≤m. The objective is to find a task schedule and a processor allocation such that the overall task completion time, i.e. the makespan, is minimized. The problem is motivated by real-life applications of parallel computer systems in scientific computing of highly parallelizable tasks. An O(n) algorithm is presented to solve this problem when all the processing speed functions are convex. If these functions are all concave and the number of tasks is a constant, the problem can be solved in polynomial time. A relaxed problem, in which the number of processors allocated to each task is not required to be integer, can be solved in O(nmax {m,nlog 2 m}) time. It is proved that the minimum makespan values for the original and relaxed problems coincide. For n=2 or n=3, an optimal solution for the relaxed problem can be converted into an optimal solution for the original problem in a constant time.

Species tree estimation from multiple markers is complicated by the fact that gene trees can differ from each other (and from the true species tree) due to several biological processes, one of which is gene duplication and loss. Local search heuristics for two NP-hard optimization problems - minimize gene duplications (MGD) and minimize gene duplications and losses (MGDL) - are popular techniques for estimating species trees in the presence of gene duplication and loss. In this paper, we present an alternative approach to solving MGD and MGDL from rooted gene trees. First, we characterize each tree in terms of its "subtree-bipartitions" (a concept we introduce). Then we show that the MGD species tree is defined by a maximum weight clique in a vertex-weighted graph that can be computed from the subtree-bipartitions of the input gene trees, and the MGDL species tree is defined by a minimum weight clique in a similarly constructed graph. We also show that these optimal cliques can be found in polynomial time in the number of vertices of the graph using a dynamic programming algorithm (similar to that of Hallett and Lagergren(1)), because of the special structure of the graphs. Finally, we show that a constrained version of these problems, where the subtree-bipartitions of the species tree are drawn from the subtree-bipartitions of the input gene trees, can be solved in time that is polynomial in the number of gene trees and taxa. We have implemented our dynamic programming algorithm in a publicly available software tool, available at http://www.cs.utexas.edu/users/phylo/software/dynadup/.

We address in this paper the design and analysis of cost-optimal parallel algorithms for solving the problem of the longest common subsequence. Starting from the standard sequential dynamic programming algorithm which has the structure of a perfect nest of two embedded loops, we make use of a specific three-step parallelization approach consisting in (i) a dependence analysis within the nest ; (ii) the determination of a particular unimodular transformation leading to a new nest whose second loop is parallel ; (iii) the design of two linear time schedulings for the derived parallel algorithm when a given number of processors is available. The first scheduling is fitted to the nest structure while the second is greedy oriented and optimal. The makespans of the two schedulings are explicitly determined. This permits to establish a comparison showing their respective efficiencies.