Ravi V. Shankar

Solving Part-Type Selection and Operation Allocation Problems in an FMS: An Approach Using Constraints-Based Fast Simulated Annealing Algorithm

Production planning of a flexible manufacturing system (FMS) is plagued by two interrelated problems, namely 1) part-type selection and 2) operation allocation on machines. The combination of these problems is termed a machine loading problem, which is treated as a strongly NP-hard problem. In this paper, the machine loading problem has been modeled by taking into account objective functions and several constraints related to the flexibility of machines, availability of machining time, tool slots, etc. Minimization of system unbalance (SU), maximization of system throughput (TH), and the combination of SU and TH are the three objectives of this paper, whereas two main constraints to be satisfied are related to time and tool slots available on machines. Solutions for such problems even for a moderate number of part types and machines are marked by excessive computational complexities and thus entail the application of some random search optimization techniques to resolve the same. In this paper, a new algorithm termed as constraints-based fast simulated annealing (SA) is proposed to address a well-known machine loading problem available in the literature. The proposed algorithm enjoys the merits of simple SA and simple genetic algorithm and is designed to be free from some of their drawbacks. The enticing feature of the algorithm is that it provides more opportunity to escape from the local minimum. The application of the algorithm is tested on standard data sets, and superiority of the same is witnessed. Intensive experimentations were carried out to evaluate the effectiveness of the proposed algorithm, and the efficacy of the same is authenticated by efficiently testing the performance of algorithm over well-known functions

Many-to-many personalized communication with bounded traffic

This paper presents solutions for the problem of many-to-many personalized communication, with bounded incoming and outgoing traffic, on a distributed memory parallel machine. We present a two-stage algorithm that decomposes the many-to-many communication with possibly high variance in message size into two communications with low message size variance. The algorithm is deterministic and takes time 2t/spl mu/(+lower order terms) when t/spl ges/0(p/sup 2/+p/spl tau///spl mu/) Here t is the maximum outgoing or incoming traffic at any processor, /spl tau/ is the startup overhead and /spl mu/ is the inverse of the data transfer rate. Optimality is achieved when the traffic is large, a condition that is usually satisfied in practice on coarse-grained architectures. The algorithm was implemented on the Connection Machine CM-5. The implementation used the low latency communication primitives (active messages) available on the CM-5, but the algorithm as such is architecture-independent. An alternate single-stage algorithm using distributed random scheduling for the CM-5 was implemented and the performance of the two algorithms were compared.<<ETX>>

A data parallel algorithm for solving the region growing problem on the connection machine

Abstract Region growing is a general technique for image segmentation, where image characteristics are used to group adjacent pixels together to form regions. This paper presents a parallel algorithm for solving the region growing problem based on the split-and-merge approach, and uses it to test and compare various parallel architectures and programming models. The implementations were done on the Connection Machine, models CM-2 and CM-5, in the data parallel and message passing programming models. Randomization was introduced in breaking ties during merging to increase the degree of parallelism, and only one- and two-dimensional arrays of data were used in the implementations.

Random Data Accesses on a Coarse-Grained Parallel Machine II. One-to-Many and Many-to-One Mappings

This paper describes deterministic communication-efficient algorithms for performing random data accesses with hot spots on a coarse-grained parallel machine. The general random access read-write operations with hot spots can be completed inC?n/p(+ lower order terms) time and is optimal and scalable providedn?p3+p2?/? (nis the number of elements distributed acrosspprocessors, ? is the start-up overhead and 1/? is the data transfer rate).Cis a small constant between 3 and 4 for the random access write operation, slightly higher for the random access read operation. Monotonic random access reads/writes can be completed with smaller constants and are optimal for smallernas well. A companion paper 26] deals with the problem of performing dynamic permutations.

Hypercube algorithms for operations on quadtrees

Abstract This paper describes parallel algorithms for the following operations on quadtrees—boolean operations (union, intersection, complement), collapsing a quadtree, and neighbor finding in an image represented by a quadtree. The architecture assumed in this paper is a hypercube with one processing element (PE) per hypercube node. It is assumed that the architecture is SIMD, i.e. all PEs work under the control of a single control unit.

Solving the Region Growing Problem on the Connection Machine

This paper presents a parallel algorithm for solving the region growing problem based on the split and merge approach. The algorithm was implemented on the CM-2 and the CM-5 in the data parallel and message passing models. The performance of these implementations is examined and compared.

Three-dimensional object recognition on the connection machine

Abstract A scheme for recognition of three-dimensional objects, using the vertex-pair feature, is described. Coarse-to-fine histogramming on an n -dimensional grid is used to compute the best affine transformation between the model and the scene. Transform equations are derived and performance results for an implementation on a fine-grained data parallel machine, the Connection Machine, are presented.

Pose determination using vertex-pairs on the Connection Machine

A model-matching scheme for three-dimensional object recognition on a fine-grained data parallel machine is described. The feature that is used for model matching is the vertex pair, introduced by J.L. Mundy et al. (1987). The transformation between the features in the three-dimensional model and the two-dimensional scene is described by an affine transformation, which is an approximation to the perspective transformation. Coarse-to-fine histogramming on an n-dimensional grid is used to compute the best transformation between the model and the scene. Performance results for an implementation on the Connection Machine are presented.<<ETX>>

Random Data Accesses on a Coarse-Grained Parallel Machine I. One-to-One Mappings

This paper describes deterministic communication-efficient algorithms for performing dynamic permutations on a coarse-grained parallel machine. Our analysis shows that the general permutation operation can be completed inC?n/p(+ lower order terms) time and is optimal and scalable providedn?p3+p2?/? (nis the size of the permutation or the number of elements distributed across thepprocessors, ? is the start-up overhead, and 1/? is the data transfer rate).Cis a small constant typically between 2 and 3 for write permutations, slightly higher for read permutations. Modifications to exploit locality of access are presented. Special classes of permutations that are optimal for smaller sizes are also described. A companion paper 22] deals with the problem of random data accesses with hot spots.

Parallel Vision Algorithms Using Sparse Array Representations

Abstract Sparse arrays are arrays in which the number of non-zero elements is a small fraction of the total number of array elements. Parallel algorithms are presented using sparse representations for arrays. It is shown that adopting such a representation not only reduces the processor/space requirement, but also provides efficient load balancing at no increase in time complexity. New parallel primitives needed to work with such a representation are defined. Sample algorithms from the areas of image processing and computer vision are presented. Alternative schemes for dealing with arrays containing large contiguous blocks of elements with identical array values are considered. The parallel architecture considered is a strict SIMD hypercube, and the applicability of the results presented to other architectures is described.