Search

Abstract The existence of a wide variety of computing devices with very different properties makes essential the development of software that is not only portable among them, but which also adapts to the properties of each platform. In this paper, we present the Heterogeneous Butterfly Processing Library (HBPL), which provides optimized portable kernels for problems of small sizes that allow using orthogonal transform algorithms such as the FFT and DCT on different accelerators and regular CPUs. Our library is implemented on the OpenCL standard, which provides portability on a large number of platforms. Furthermore, high performance is achieved on a wide range of devices by exploiting run-time code generation and metaprogramming guided by a parametrization strategy. An exhaustive evaluation on different platforms shows that our proposal obtains competitive or better performance than related libraries. Highlights • We present HBPL, a portable OpenCL-based library for FFT and DCT using kernels. • HBPL provides an analytical model for the search for the best implementations. • The model can pinpoint the best implementation or restrict the search to minutes. • HBPL shows better performance and portability than clFFT on GPU's, the most related library. • We provide the first portable implementation of the DCT we know of. [ABSTRACT FROM AUTHOR]

Abstract: This paper presents parallel algorithms for recognizing chordal_planar graphs and planar -trees. Both the algorithms run in time using processors on a concurrent-read and concurrent-write (CRCW), parallel random access machine (PRAM) model, where n and m are, respectively, the number of nodes and edges in the graph.The novelty of our chordal_planar graph recognition algorithm lies in that it is based on an elegant structural characterization of chordal_planar graphs proposed in this paper. Moreover, it is simpler than separately testing chordality and planarity. Our planar k-trees recognition algorithm is based on a new characterization of k-trees presented in this paper. [Copyright &y& Elsevier]

Abstract: In this paper, a heuristic dynamic scheduling scheme for parallel real-time jobs executing on a heterogeneous cluster is presented. In our system model, parallel real-time jobs, which are modeled by directed acyclic graphs, arrive at a heterogeneous cluster following a Poisson process. A job is said to be feasible if all its tasks meet their respective deadlines. The scheduling algorithm proposed in this paper takes reliability measures into account, thereby enhancing the reliability of heterogeneous clusters without any additional hardware cost. To make scheduling results more realistic and precise, we incorporate scheduling and dispatching times into the proposed scheduling approach. An admission control mechanism is in place so that parallel real-time jobs whose deadlines cannot be guaranteed are rejected by the system. For experimental performance study, we have considered a real world application as well as synthetic workloads. Simulation results show that compared with existing scheduling algorithms in the literature, our scheduling algorithm reduces reliability cost by up to 71.4% (with an average of 63.7%) while improving schedulability over a spectrum of workload and system parameters. Furthermore, results suggest that shortening scheduling times leads to a higher guarantee ratio. Hence, if parallel scheduling algorithms are applied to shorten scheduling times, the performance of heterogeneous clusters will be further enhanced. [Copyright &y& Elsevier]

Recently, Lombardi, Quitté and Yengui have given a Gröbner-free algorithm which computes the V -saturation of any finitely generated submodule of V [ X ] n , where V is a valuation domain. The goal of this paper is to clarify this algorithm, to give precise complexity bounds, and a complete submodule membership test for the saturation. As application, we give precise degree bounds on syzygies over V [ X ] . [ABSTRACT FROM AUTHOR]

Abstract: Power efficiency investigation has been required in each level of a High Performance Computing (HPC) system because of the increasing computation demands of scientific and engineering applications. Focusing on handling the critical design constraints in the software level that run beyond a parallel system composed of huge numbers of power-hungry components, we optimize HPC program design in order to achieve the best possible power performance on the target hardware platform. The power performance of a CUDA Processing Element (PE) is determined by both hardware factors including power features of each component including with CPU, GPU, main memory and PCI buses, and their interconnection architecture; and software factors including algorithm design and the character of executable instructions performed on it. In this paper, approaches to model and evaluate the power consumption of large scale SIMD computation by CUDA PEs on multi-core and GPU platforms are introduced. The model allows obtaining design characteristic values at the early programming stage, thus benefitting programmers by providing the necessary environment information for choosing the best power-efficient alternative. Based on the model, CPU Dynamic frequency scaling (DFS) can be applied on CUDA PE architecture that adjusts CPU frequency to enhance power efficiency of the entire PE without compromising its computing performance. The power model and power efficiency improvements of the new designs have been validated by measuring the new programs on the real GPU multiprocessing system. [Copyright &y& Elsevier]

Abstract: High-performance stream processing is critical in many sense-and-respond application domains—from environmental monitoring to algorithmic trading. In this paper, we focus on language and runtime support for improving the performance of sense-and-respond applications in processing data from high-rate live streams. The central tenets of this work are the programming model, the workload splitting mechanisms, the code generation framework, and the underlying System S middleware and Spade programming model. We demonstrate considerable scalability behavior coupled with low processing latency in a real-world financial trading application. [Copyright &y& Elsevier]

Abstract: This paper proposes a semi-supervised learning method for semantic relation extraction between named entities. Given a small amount of labeled data, it benefits much from a large amount of unlabeled data by first bootstrapping a moderate number of weighted support vectors from all the available data through a co-training procedure on top of support vector machines (SVM) with feature projection and then applying a label propagation (LP) algorithm via the bootstrapped support vectors and the remaining hard unlabeled instances after SVM bootstrapping to classify unseen instances. Evaluation on the ACE RDC corpora shows that our method can integrate the advantages of both SVM bootstrapping and label propagation. It shows that our LP algorithm via the bootstrapped support vectors and hard unlabeled instances significantly outperforms the normal LP algorithm via all the available data without SVM bootstrapping. Moreover, our LP algorithm can significantly reduce the computational burden, especially when a large amount of labeled and unlabeled data is taken into consideration. [Copyright &y& Elsevier]

Abstract: In this paper, we consider how to optimize I/O server placement in order to improve parallel I/O performance in switch-based clusters. The significant advances in cluster networks in recent years have made it practical to connect tens of thousands of hosts via networks that have enormous and scalable total capacity, and in which communications between a host and any other host incur the same cost. The same cost property frees users from consideration of network contention and allows them to concentrate on load-balancing issues. We formulate the server placement problem on a cluster that has the same cost property as a weighted bipartite matching with the goal of balancing the workload on the I/O nodes. To find an optimal solution to this problem, we propose an algorithm, called Load Balance Matching (LBM), where is the number of compute nodes and is the number of I/O servers. We also investigate server placement for general clusters in which multiple same-cost subclusters are interconnected to form a large cluster. This class of clusters typically adopt irregular topologies that allow the construction of scalable systems with an incremental expansion capability. Also, due to the limited bandwidth on network links between subclusters, network link contention is a major concern when distributing servers over the entire network. We show that finding an optimal placement strategy for general clusters with the goal of minimizing link contention is computationally intractable. To resolve this problem, we propose a hierarchical strategy that places servers in two steps. First, to minimize link contention, we decide which subcluster each server should be assigned to. We propose a tree-based heuristic algorithm, called Load Balance Traversing (LBT), to solve this problem. In the second step, the LBM algorithm decides the location of each server within a subcluster. Our simulation results demonstrate that LBT achieves a significant improvement in parallel I/O performance over four other algorithms, and is near-optimal in some cases. [Copyright &y& Elsevier]

Abstract: This paper presents two new randomized distributed algorithms for the generation of acyclic orientations upon anonymous distributed systems of arbitrary topology. Both algorithms, called Alg-Neighbors and Alg-Edges, make use of biased and unbiased dice having faces, and are analyzed in terms of correctness, expected time complexity and rate of convergence. First, the Alg-Neighbors algorithm is presented as a generalization of the Calabrese/França algorithm for dice (or coins) with 2 faces. It is proved that a convenient biasing function applied to all dice changes the expected time complexity from sub-exponential, i.e., (for unbiased dice with faces), to , where is the number of the system’s nodes. Next, it is shown that the Alg-Edges algorithm is able to produce acyclic orientations in steps with high probability, where denotes the total number of edges. Finally, a speed of convergence versus quality of acyclic orientation generation (associated number of colors) tradeoff is identified between Alg-Neighbors and Alg-Edges algorithms. Computational experiments were carried out in order to provide a more accurate description of the behavior of both algorithms. [Copyright &y& Elsevier]

Abstract: The aim of this paper is to study multidimensional continued fraction algorithm over the field of formal power series. In the case of the Brun algorithm by using its homogenous version, we prove that it converges. [Copyright &y& Elsevier]

Abstract: In this paper we analyze O''Hara''s partition bijection. We present three type of results. First, we show that O''Hara''s bijection can be viewed geometrically as a certain scissor congruence type result. Second, we obtain a number of new complexity bounds, proving that O''Hara''s bijection is efficient in several special cases and mildly exponential in general. Finally, we prove that for identities with finite support, the map of the O''Hara''s bijection can be computed in polynomial time, i.e. much more efficiently than by O''Hara''s construction. [Copyright &y& Elsevier]

Abstract: This paper investigates both the precision and the model checking efficiency of abstract models designed to preserve branching time logics w.r.t. a 3-valued semantics. Current abstract models use ordinary transitions to over approximate the concrete transitions, while they use hyper transitions to under approximate the concrete transitions. In this work, we refer to precision measured w.r.t. the choice of abstract states, independently of the formalism used to describe abstract models. We show that current abstract models do not allow maximal precision. We suggest a new class of models and a construction of an abstract model which is most precise w.r.t. any choice of abstract states. As before, the construction of such models might involve an exponential blowup, which is inherent by the use of hyper transitions. We therefore suggest an efficient algorithm in which the abstract model is constructed during model checking, by need. Our algorithm achieves maximal precision w.r.t. the given property while remaining quadratic in the number of abstract states. To complete the picture, we incorporate it into an abstraction-refinement framework. [Copyright &y& Elsevier]

Abstract: This paper presents an algorithm for fast sorting of large lists using modern GPUs. The method achieves high speed by efficiently utilizing the parallelism of the GPU throughout the whole algorithm. Initially, GPU-based bucketsort or quicksort splits the list into enough sublists then to be sorted in parallel using merge-sort. The algorithm is of complexity , and for lists of 8 M elements and using a single Geforce 8800 GTS-512, it is 2.5 times as fast as the bitonic sort algorithms, with standard complexity of , which for a long time was considered to be the fastest for GPU sorting. It is 6 times faster than single CPU quicksort, and 10% faster than the recent GPU-based radix sort. Finally, the algorithm is further parallelized to utilize two graphics cards, resulting in yet another 1.8 times speedup. [Copyright &y& Elsevier]

Abstract: The Singular Value Decomposition (SVD) is a vital problem that finds a place in numerous application domains in science and engineering. As an example, SVDs are used in processing voluminous datasets. Many sequential and parallel algorithms have been proposed to compute SVDs. The best known sequential algorithms take cubic time. This amount of time may not be acceptable especially when the data size is large. Thus parallel algorithms are desirable. In this paper, we present a novel technique for the parallel computation of SVDs. This technique yields impressive speedups. We discuss implementation of our technique on parallel models of computing such as the mesh and the PRAM. We also present an experimental evaluation of our technique. [Copyright &y& Elsevier]

Abstract: In this paper, we investigate a robust information clustering (RIC) algorithm incorporating spatial information for breast mass detection in digitized mammograms. The detection system employs RIC algorithm based on the raw region of interest (ROI) extracted from global mammogram by two steps of adaptive thresholding. Pixels on the fuzzy margin of a mass and noisy data were identified by RIC through the minimax optimization of mutual information. The memberships of the identified pixels (outliers) were recalculated by incorporating spatial distance information that takes into account of the influence of a neighborhood of 3×3 window. The algorithm is robust in the sense that both peak and valley of image intensity histogram are estimated and the pixels corresponding to valley in the histogram are clustered adaptively to image content. The purpose of the detection system is to locate the suspicious regions of mass candidates in the mammograms which will be further examined by other diagnostic techniques or by radiologists. The proposed method has been verified with 60 mammograms in the MiniMIAS database. The experimental results show that the detection system has a sensitivity of 90.7% at 2.57 false positives (FPs) per image. [Copyright &y& Elsevier]

Abstract: A coloring of a tree is convex if the vertices that pertain to any color induce a connected subtree; a partial coloring (which assigns colors to some of the vertices) is convex if it can be completed to a convex (total) coloring. Convex coloring of trees arises in areas such as phylogenetics, linguistics, etc., e.g., a perfect phylogenetic tree is one in which the states of each character induce a convex coloring of the tree. Research on perfect phylogeny is usually focused on finding a tree so that few predetermined partial colorings of its vertices are convex. When a coloring of a tree is not convex, it is desirable to know “how far” it is from a convex one. In [S. Moran, S. Snir, Convex recoloring of strings and trees: Definitions, hardness results and algorithms, in: WADS, 2005, pp. 218–232; J. Comput. System Sci., submitted for publication], a natural measure for this distance, called the recoloring distance was defined: the minimal number of color changes at the vertices needed to make the coloring convex. This can be viewed as minimizing the number of “exceptional vertices” w.r.t. a closest convex coloring. The problem was proved to be NP-hard even for colored strings. In this paper we continue the work of [S. Moran, S. Snir, Convex recoloring of strings and trees: Definitions, hardness results and algorithms, in: WADS, 2005, pp. 218–232; J. Comput. System Sci., submitted for publication], and present a 2-approximation algorithm of convex recoloring of strings whose running time , where c is the number of colors and n is the size of the input, and an 3-approximation algorithm for convex recoloring of trees. [Copyright &y& Elsevier]

Abstract: In this paper, we propose a solution to the problem of capturing an intruder in a product network. This solution is derived based on the assumption of existing algorithms for basic member graphs of a graph product. In this problem, a team of cleaner agents are responsible for capturing a hostile intruder in the network. While the agents can move in the network one hop at a time, the intruder is assumed to be arbitrarily fast in a way that it can traverse any number of nodes contiguously as far as no agents reside in those nodes. Here, we consider a version of the problem where each agent can replicate new agents. Thus, the algorithm starts with a single agent and new agents are created on demand. We propose a novel method for deriving intrusion capturing algorithms based on the abstract idea of spanning search trees. Later, we utilize this method for deriving capturing algorithms for Cartesian product graphs. [Copyright &y& Elsevier]

Abstract: In this paper, we present an time algorithm for finding shortest paths in an n-node planar graph with real weights. This can be compared to the best previous strongly polynomial time algorithm developed by Lipton, Rose, and Tarjan in 1978 which runs in time, and the best polynomial time algorithm developed by Henzinger, Klein, Subramanian, and Rao in 1994 which runs in time. We also present significantly improved data structures for reporting distances between pairs of nodes and algorithms for updating the data structures when edge weights change. [Copyright &y& Elsevier]

Abstract: Masking is one of the efficient and easily implemented countermeasures to protect cryptographic algorithms in such resource limited environments as smart-cards from differential power analysis as well as simple power analysis that were first introduced by Kocher et al. in 1999. To defend differential power analysis attacks, Akkar and Giraud presented a Transformed Masking Method and applied it to DES implementation in 2001. Unfortunately, in 2003, Akkar and Goubin showed a superposition attack that actually is a high-order differential power analysis attack on Akkar and Giraud’s DES implementation using Transformed Masking Method, and finally they presented a DES implementation using their proposed Unique Masking Method to defend any order differential power analysis attacks, which was later improved by Akkar, Bévan and Goubin in 2004. In this paper, by exploiting a new artifice to classify the electric consumption curves, we show that Akkar, Bévan and Goubin’s improved DES implementation using Unique Masking Method is still vulnerable to a high-order differential power analysis attack. Besides, we find it is also vulnerable to a superposition attack. We also present four new differential power analysis attacks on Akkar and Giraud’s DES implementation using Transformed Masking Method. [Copyright &y& Elsevier]

Abstract: Consider a network of processors modeled by an n-vertex graph . Assume that the communication in the network is synchronous, i.e., occurs in discrete “rounds,” and in every round every processor is allowed to pick one of its neighbors, and to send it a message. The telephone k-multicast problem requires to compute a schedule with minimal number of rounds that delivers a message from a given single processor, that generates the message, to all the processors of a given set , , whereas the processors of may be left uninformed. The case is called broadcast problem. Several approximation algorithms with a polylogarithmic ratio were suggested for these problems, and the upper bound on their approximation threshold stands currently on and , respectively. In this paper we devise an -approximation algorithm for the k-multicast problem, and, consequently, an -approximation algorithm for the broadcast problem. Even stronger than that, whenever an instance of the k-multicast problem admits a schedule of length , our algorithm guarantees an approximation ratio of . As is always at least , the ratio of follows. In addition, whenever for some constant , we obtain a constant -approximation ratio for the problem. Our results have implications for network design. The poise of a spanning tree is the sum of its depth and maximum degree [R. Ravi, Rapid rumor ramification: Approximating the minimum broadcast time, in: Proceedings of the IEEE Symposium on Foundations of Computer Science, FOCS ''94, 1994, pp. 202–213]. We improve the approximation algorithm [A. Bar-Noy, S. Guha, J. Naor, B. Schieber, Multicasting in heterogeneous networks, SIAM J. Comput. 30 (2) (2000) 347–358] for the poise problem to , and obtain an improved bicriteria approximation for the depth-degree problem. We also derive results concerning the edge-dependent heterogeneous k-multicast problem. [Copyright &y& Elsevier]

Abstract: This paper discusses the probe complexity of randomized algorithms and the deterministic average case probe complexity for some classes of nondominated coteries, including majority, crumbling walls, tree, wheel and hierarchical quorum systems, and presents upper and lower bounds for the probe complexity of quorum systems in these classes. [Copyright &y& Elsevier]

Abstract: In this paper, we present an out of order quantifier elimination algorithm for a class of Quantified Linear Programs (QLPs) called Standard Quantified Linear Programs (SQLPs). QLPs in general and SQLPs in particular are extremely useful constraint logic programming structures that find wide applicability in the modeling of real-time schedulability specifications; see Subramani [Subramani, K., 2005a. A comprehensive framework for specifying clairvoyance, constraints and periodicity in real-time scheduling. The Computer Journal 48 (3), 259–272]. Consequently any algorithmic advance in their solution has a strong practical impact. Prior to this work, the only known approaches to the solution of QLPs involved sequential variable elimination; see Subramani [Subramani, K., 2003b. An analysis of quantified linear programs. In: Calude, C.S. et al. (Eds.), Proceedings of the 4th International Conference on Discrete Mathematics and Theoretical Computer Science. DMTCS. In: Lecture Notes in Computer Science, vol. 2731. Springer-Verlag, pp. 265–277]. In the sequential approach, the innermost quantified variable is eliminated first, followed by the variable which then becomes the innermost quantified variable and so on, until we are left with a single variable from which the satisfiability of the original formula is easily deduced. This approach is applicable in both discrete and continuous domains; however, it is to be noted that the logic demanding the sequential approach requires that the variables are discrete-valued. To the best of our knowledge, the necessity for sequential elimination over continuous-valued variables has not been investigated in the literature. The techniques used in the development of our elimination algorithm may find applications in domains such as classical logic and finite model theory. The final aspect of our research concerns the structure-preserving nature of the algorithm that we introduce here; in general, it is not known whether discrete domains admit such elimination procedures. [Copyright &y& Elsevier]

Abstract: Boosting algorithms are procedures that “boost” low-accuracy weak learning algorithms to achieve arbitrarily high accuracy. Over the past decade boosting has been widely used in practice and has become a major research topic in computational learning theory. In this paper we study boosting in the presence of random classification noise, giving both positive and negative results. We show that a modified version of a boosting algorithm due to Mansour and McAllester (J. Comput. System Sci. 64(1) (2002) 103) can achieve accuracy arbitrarily close to the noise rate. We also give a matching lower bound by showing that no efficient black-box boosting algorithm can boost accuracy beyond the noise rate (assuming that one-way functions exist). Finally, we consider a variant of the standard scenario for boosting in which the “weak learner” satisfies a slightly stronger condition than the usual weak learning guarantee. We give an efficient algorithm in this framework which can boost to arbitrarily high accuracy in the presence of classification noise. [Copyright &y& Elsevier]

Abstract: In this paper we present a generic algorithm for factoring polynomials over global fields . As efficient implementations of that algorithm for number fields and function fields differ substantially, these cases will be treated separately. Complexity issues and implementations will be discussed in part II which also contains illustrative examples. [Copyright &y& Elsevier]

Abstract: In this paper, we give a homotopy classification of continuous maps between two simply connected four manifolds and design an algorithm and program to give explicit computations. Some calculations for self-maps of a rational surface and manifolds of type are given as examples. [Copyright &y& Elsevier]

In this paper, we present a computation offloading scheme on handheld devices. This scheme partitions an ordinary program into a client–server distributed program, such that the client code runs on the handheld device and the server code runs on the server. Our partition analysis and program transformation guarantee correct distributed execution under all possible execution contexts. We give a polynomial time algorithm to find the optimal program partition for given program input data. We use an option-clustering approach to handle different program partitions for different program execution options. Experimental results show significant improvement of performance and energy consumption on an HP IPAQ handheld device through computation offloading. [Copyright &y& Elsevier]