9442074
Generalized Latin squares II
Abstract This paper is a continuation of a study on a new class of combinatorial structures called generalized Latin squares or 〈k,l〉-Latin squares. Here, we study the existence question of perfect 〈k,l〉-Latin squares. The main result is an existence theorem for the case M = 2, where M is the multiplicity of the generalized Latin squares. Specifically, we show that for given positive integers N, k = ip, l = iq, where i = gcd(k,l), there exists a perfect 〈k,l〉-Latin square of order N with M = 2 if and only if (i) N = 4k, (ii) pq(p + q)| N, and (iii) q|2.
31888135
An automatic seal imprint verification approach
The automatic verification of seal imprints is a difficult pattern recognition problem and has a lot of applications in the oriental countries. Several approaches have been proposed in the past 10 years, but all of them were hard to implement in practice because of their drawbacks in the adaptability, reliability and practicality. In this paper, a new automatic seal imprint verification approach is presented. Due to the efficient and accurate registration method, a set of effective features and the elaborate implementations, this approach has satisfied most practical requirements and has been used for a practical check verification system in a Chinese bank.
8438496
Permutation Routing in All-Optical Product Networks
In this paper we study permutation routing techniques for all-optical networks. Firstly, we show some lower bounds on the number of wavelengths needed for implementing any permutation on an all-optical network in terms of bisection of the network. Secondly, we study permutation routing on product networks by giving a lower bound on the number of wavelengths needed, and presenting permutation routing algorithms for the wavelength non-conversion and conversion models, respectively. Finally, we investigate permutation routing on a cube-connected-cycles network by showing that the number of wavelengths needed for implementing any permutation in one round is [2 log n], which improves on a previously known general result for bounded degree graphs by a factor of O(log 3 n) for this special case.
45976743
Improved lightpath (wavelength) routing in large WDM networks
We address the problem of efficient circuit switching in wide area networks. The solution provided is based on finding optimal routes for lightpaths and semilightpaths. A lightpath is a fully optical transmission path, while a semilightpath is a transmission path constructed by chaining several lightpaths together, using wavelength conversion at their junctions. The problem thus is to find an optimal lightpath/semilightpath in the network in terms of the cost of wavelength conversion and the cost of using the wavelengths on links. We first present fast, efficient algorithms both for the general problem and for a natural restricted version. The new algorithms outperform earlier work, providing time improvements amounting to an almost linear time factor in most cases. Also, all our algorithms can be implemented on the network in a distributed way.
34776029
Embedding between 2-D meshes of the same size
It is shown how to embed an x/sub 1/ /spl times/ 1/sub 1/ mesh M/sub 1/ into an s/sub 2/ /spl times/ t/sub 2/ mesh M/sub 2/, where s/sub 1/ /spl times/ t/sub 2/, s/sub 1/ < t/sub i/ (i = 1,2) such that the dilation is minimized. It is assumed that load = 1 and expansion = 1. For each case there is shown a lower bound on the dilation and a corresponding embedding method. The dilations by these embedding algorithms either match a lower bound or are very close to a lower bound.<<ETX>>
44324303
Equivalent permutation capabilities between time division optical omega network and non-optical extra stage omega network
Since optical networks must support crosstalk-free (CF) connections, regular N/spl times/N multistage interconnection networks (MINs) cannot be directly used to provide connections between N inputs and N outputs. A solution is to use a 2N/spl times/2N Cube-Type MIN to provide the N/spl times/N connections. C. Qiao (1993) proposed a time domain approach that divides the N optical inputs into several groups such that CF connections can be provided by an N/spl times/N regular MIN in several time slots, one for each group. The set of N-permutations realizable in two slots is defined as class /spl theta/. Qiao proved that the size of /spl theta/ is larger than the size of class /spl Omega/, where /spl Omega/ consists of all N-permutations passible through a regular N/spl times/N Omega network. The paper first presents an optimal O(NlgN) time algorithm for identifying whether a given permutation belongs to class /spl theta/ or not. From this algorithm, the paper proves an interesting fact that the class /spl theta/ is identical to the class /spl Omega/+1 which represents the set of N-permutations admissible by a non-optical N/spl times/N one-extra stage Omega network.
10424667
Miss Rate Prediction Across Program Inputs and Cache Configurations
Improving cache performance requires understanding cache behavior. However, measuring cache performance for one or two data input sets provides little insight into how cache behavior varies across all data input sets and all cache configurations. This paper uses locality analysis to generate a parameterized model of program cache behavior. Given a cache size and associativity, this model predicts the miss rate for arbitrary data input set sizes. This model also identifies critical data input sizes where cache behavior exhibits marked changes. Experiments show this technique is within 2 percent of the hit rate for set associative caches on a set of floating-point and integer programs using array and pointer-based data structures. Building on the new model, this paper presents an interactive visualization tool that uses a three-dimensional plot to show miss rate changes across program data sizes and cache sizes and its use in evaluating compiler transformations. Other uses of this visualization tool include assisting machine and benchmark-set design. The tool can be accessed on the Web at http://www.cs.rochester.edu/research/locality
6045910
Parallelization of Utility Programs Based on Behavior Phase Analysis
With the fast development of multi-core processors, automatic parallelization becomes increasingly important. In this work, we focus on the parallelization of utility programs, a class of commonly used applications including compilers, transcoding utilities, file compressions, and databases. They take a series of requests as inputs and serve them one by one. Their high input dependence poses a challenge to parallelization. 
 
We use active profiling to find behavior phase boundaries and then automatically detect run-time dependences through profiling. Using a unified framework, we manually parallelize programs at phase boundaries. We show that for two programs, the technique enables parallelization at large granularity, which may span many loops and subroutines. The parallelized programs show significant speedup on multi-processor machines.
9894542
Reliability optimization of distributed access networks with constrained total cost
In this paper, we study the system reliability optimization of distributed access networks subject to a constraint on the total cost. We first formulate the cost-constrained system reliability optimization problem as a searching process in a combinatorial tree, which enumerates all the possible solutions to the problem. Because the calculation of each possible solution for the reliability problem is extremely time-consuming, a novel algorithm, the Shrinking & Searching Algorithm (SSA), is proposed to speed up the searching process. SSA jointly considers the upper bound of the system reliability for each branch in the combinatorial tree, and the cost constraint on the possible solutions. It avoids most of the redundant calculations in the searching process by gradually shrinking the difference between lower & upper bounds of the length of a path in the corresponding combinatorial tree, which represents a feasible solution. Case study & simulation results are presented to demonstrate the performance of the SSA.
6253791
Array regrouping and structure splitting using whole-program reference affinity
While the memory of most machines is organized as a hierarchy, program data are laid out in a uniform address space. This paper defines a model of reference affinity, which measures how close a group of data are accessed together in a reference trace. It proves that the model gives a hierarchical partition of program data. At the top is the set of all data with the weakest affinity. At the bottom is each data element with the strongest affinity. Based on the theoretical model, the paper presents k-distance analysis, a practical test for the hierarchical affinity of source-level data. When used for array regrouping and structure splitting, k-distance analysis consistently outperforms data organizations given by the programmer, compiler analysis, frequency profiling, statistical clustering, and all other methods we have tried.
735556
Lightweight reference affinity analysis
Previous studies have shown that array regrouping and structure splitting significantly improve data locality. The most effective technique relies on profiling every access to every data element. The high overhead impedes its adoption in a general compiler, In this paper, we show that for array regrouping in scientific programs, the overhead is not needed since the same benefit can be obtained by pure program analysis.We present an interprocedural analysis technique for array regrouping. For each global array, the analysis summarizes the access pattern by access-frequency vectors and then groups arrays with similar vectors. The analysis is context sensitive, so it tracks the exact array access. For each loop or function call, it uses two methods to estimate the frequency of the execution. The first is symbolic analysis in the compiler. The second is lightweight profiling of the code. The same interprocedural analysis is used to cumulate the overall execution frequency by considering the calling context. We implemented a prototype of both the compiler and the profiling analysis in the IBM® compiler, evaluated array regrouping on the entire set of SPEC CPU2000 FORTRAN benchmarks, and compared different analysis methods. The pure compiler-based array regrouping improves the performance for the majority of programs, leaving little room for improvement by code or data profiling.