Optimizing the evidence for linkage by permuting marker order

We developed a new marker-reordering algorithm to find the best order of fine-mapping markers for multipoint linkage analysis. The algorithm searches for the best order of fine-mapping markers such that the sum of the squared differences in identity-by-descent distribution between neighboring markers is minimized. To test this algorithm, we examined its effect on the evidence for linkage in the simulated and the Collaborative Studies on Genetics of Alcoholism (COGA) data. We found enhanced evidence for linkage with the reordered map at the true location in the simulated data (p-value decreased from 1.16 × 10(-9 )to 9.70 × 10(-10)). Analysis of the White population from the COGA data with the reordered map for alcohol dependence led to a significant change of the linkage signal (p = 0.0365 decreased to p = 0.0039) on chromosome 1 between marker D1S1592 and D1S1598. Our results suggest that reordering fine-mapping markers in candidate regions when the genetic map is uncertain can be a critical step when considering a dense map

Expected performance of m-solution backtracking

This paper derives upper bounds on the expected number of search tree nodes visited during an m-solution backtracking search, a search which terminates after some preselected number m problem solutions are found. The search behavior is assumed to have a general probabilistic structure. The results are stated in terms of node expansion and contraction. A visited search tree node is said to be expanding if the mean number of its children visited by the search exceeds 1 and is contracting otherwise. It is shown that if every node expands, or if every node contracts, then the number of search tree nodes visited by a search has an upper bound which is linear in the depth of the tree, in the mean number of children a node has, and in the number of solutions sought. Also derived are bounds linear in the depth of the tree in some situations where an upper portion of the tree contracts (expands), while the lower portion expands (contracts). While previous analyses of 1-solution backtracking have concluded that the expected performance is always linear in the tree depth, the model allows superlinear expected performance

Instruction Re-Selection for Iterative Modulo Scheduling on High Performance Multi-Issue DSPs

An iterative modulo scheduling is very important for compilers targeting high performance multi-issue digital signal processors. This is because these processors are often severely limited by idle state functional units and thus the reduced idle units can have a positively significant impact on their performance. However, complex instructions, which are used in most recent DSPs such as mac, usually increase data dependence complexity, and such complex dependencies that exist in signal processing applications often restrict modulo scheduling freedom and therefore, become a limiting factor of the iterative modulo scheduler. In this work, we propose a technique that efficiently reselects instructions of an application loop code considering dependence complexity, which directly resolve the dependence constraint. That is specifically featured for accelerating software pipelining performance by minimizing length of intrinsic cyclic dependencies. To take advantage of this feature, few existing compilers support a loop unrolling based dependence relaxing technique, but only use them for some limited cases. This is mainly because the loop unrolling typically occurs an overhead of huge code size increment, and the iterative modulo scheduling with relaxed dependence techniques for general cases is an NP-hard problem that necessitates complex assignments of registers and functional units. Our technique uses a heuristic to efficiently handle this problem in pre-stage of iterative modulo scheduling without loop unrolling

THE RAY-METHOD: THEORETICAL BACKGROUND AND COMPUTATIONAL RESULTS

In our talk we present an algorithm for determining initial bound for the Branch and Bound (B&B) method. The idea of the algorithm is based on the use of the "ray" introduced in the "ray-method" developed for solving integer programming problems [13], [14]. Instead of solving a common integer programming problem we use the main idea of the ray-method to find an integer feasible solution of integer linear programming (ILP) problem along the ray as close to optimal solution of relaxation problem, as possible. Objective value obtained in this way may be used as an initial bound for B&B method. The algorithm has been implemented in the frame of educational package WinGULF [3] for linear and linear-fractional programming and has been tested on various ILP problems. Then inspired by the results obtained we implemented the method using the so-called callable library of CPLEX package by IBM. omputational experiments with the algorithm proposed show that such preprocessing procedure in many cases results an integer feasible solution very close to the solution of relaxation problem. Initial bound for branch and bound method determined in this way often can significantly decrease the size of the binary tree to be searched and in this manner can improve performance of the B&B method

Determining Initial Bound by "Ray-method" in Branch and Bound Procedure

In this paper we present an algorithm for determining initial bound for the Branch and Bound (B&B) method. The idea of this algorithm is based on the use of "ray" as introduced in the "ray-method" developed for solving integer linear programming problems [11], [12]. Instead of solving an integer programming problem we use the main idea of the ray-method to find an integer feasible solution of an integer linear programming problem along the ray as close to an optimal solution of the relaxation problem as possible. The objective value obtained in this manner may be used as an initial bound for the B&B method. It is well known that getting a "good bound" as soon as possible can often significantly increase the performance of the B&B method

A simulation tool for the performance evaluation of parallel branch and bound algorithms

Parallel computation offers a challenging opportunity to speed up the time consuming enumerative procedures that are necessary to solve hard combinatorial problems. Theoretical analysis of such a parallel branch and bound algorithm is very hard and empirical analysis is not straightforward because the performance of a parallel algorithm cannot be evaluated simply by executing the algorithm on a few parallel systems. Among the difficulties encountered are the noise produced by other users on the system, the limited variation in parallelism (the number of processors in the system is strictly bounded) and the waste of resources involved: most of the time, the outcomes of all computations are already known and the only issue of interest is when these outcomes are produced. We will describe a way to simulate the execution of parallel branch and bound algorithms on arbitrary parallel systems in such a way that the memory and cpu requirements are very reasonable. The use of simulation has only minor consequences for the formulation of the algorithm

Simulation and close-to-optimal algorithm for the static load balancing of a network of heterogeneous processors

A close-to-optimal linear programming-based algorithm for the static load balancing of a network of heterogeneous processors is described and implemented. Experimental results suggest that the amount of time required by the implementation of the algorithm to balance the loads of the servers as a function of the number of servers has polynomial complexity