Exploiting parallelism for faster implementation of Bubble sort algorithm using FPGA

Finite state automata are of fundamental importance in theory as well as applications in computer science. This dissertation presents several parallel algorithms for processing of them, including minimizing the number of states for a given finite state automaton, finding homing sequences for a given finite state automaton, converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. Implementation of some algorithms, as well as their experimental results, are also given. For minimization of deterministic finite automata, we present a parallel algorithm and discuss its implementation on a practical parallel machine using data parallel and message passing paradigms. Its time complexity on a p processor EREW PRAM $(p\\le n)$ for inputs of size n is $O({n\\log\\sp2n\\over p}+\\log n\\ \\log p)$ uniformly on almost all instances. The work done by our algorithm is thus within a factor of $O(\\log n)$ of the best known sequential algorithm. The space used by our algorithm is linear in the input size. The actual resource requirements of our implementations are consistent with these estimates. For finding homing sequences of deterministic finite automata, we present both deterministic and randomized algorithms. Two randomized algorithms of time complexity $O(log\\sp2n)$ are given. One of the randomized algorithms produces a homing sequence of length $O(n\\ log\\sp2n)$ for almost all DFA's with n states. The deterministic algorithm is based on a well known sequential algorithm. The implementation of the deterministic parallel algorithm shows that it can handle randomly generated instances with millions of states, and all DFA's with thousands of states using currently available parallel machines. Finally, we present an efficient parallel algorithm for converting a regular expression into an $\\varepsilon$-free nondeterministic finite automaton. The resulting automaton is natural representation of a regular expression and has some important and practical uses in the document processing area. The time complexity of the algorithm is $O(\\log n)$ and the number of processors used is $O(n\\sp2).$

The aim of this paper is to compare the complexity of three simple sort algorithm; selection sort algorithm, bubble sort algorithm, and insertion sort algorithm. The measurement of the complexity is based on control flow structure and time processing. The control flow structure is illustrated into flowgraph and measured by number of out-degree and number of in-degree. The algorithm is coded in C programming language. The sorting experiment uses four data sets: 100,000 random words, 50,000 random words, 100,000 random integer numbers, and 50,000 random integer numbers to measure the time processing. The result of the measurement explains that the bubble sort algorithm has the complexity more than others.

Sorting Networks on Maxeler Dataflow Supercomputing Systems

In the past, pseudo code guidelines and intricate blackboard visuals were used to teach methods. This makes visualization technology a useful teaching tool for both students and teachers. In this assignment, we developed an algorithm visualizer. A sorting visualizer and a route finder are also provided. This project intends to provide a platform that could be used to understand better these ideas as well as to illustrate the uses of these various methodologies. As a foundation for learning algorithm design and analysis, Dijkstra's, A*, Deep First Search, Broadness First Search, Rapid Sort, Stack Sort, Sorting Algorithm, Bubble Sort, and other fundamental algorithms are commonly used. Google Street view and web searches are only two examples of software that uses these techniques and that we are using on a daily basis. As a consequence, we made an effort to create a tool that makes use of HTML, CSS, Express's, and other tools to graphically depict how these algorithms work. Our objective is to simplify the algorithm such that basic computer science students may comprehend it via a sequence of graphical stages.

In this paper we analyze the algorithms expressed as a system of recurrence equations. The algorithms are called 2*1 output algorithms if two output values of one function (variable identification) are specified by the system of recurrence equations for each index point in the algorithm. The algorithm is in free form if the indexes of these two values are not dependent. Two standard classes are determined by this criteria: the nearest neighbour and the all pair form. For example the sorting algorithm can be expressed in the all pair form i.e., the linear insertion algorithm or in the nearest neighbour form i.e., the bubble sort algorithm. However these algorithms are different in their nature. A procedure to eliminate the computational broadcast for the all pair 2*1output algorithm has been proposed by the authors in [1]. The result obtained by implementing this procedure was a localized form of the algorithm and a system of uniform recurrence equations by eliminating the computational and data broadcast. So he data dependence method can be efficiently used for parallel implementations. The proposed procedure cannot be implemented directly on the nearest neighbour form algorithms. Here we show how the algorithm can be restructured into a form where the computational and data broadcast can be eliminated. These transformations result in localized algorithms. A few examples show how these algorithms can be implemented on processor arrays. For example, the Gentleman Kung triangular array [2] can be used for solving the QR decomposition algorithm for both forms of the algorithm. The implementations differ in the order of the data flow and the processor operation. We show that the implementation of the nearest neighbour algorithm is even better than the standard one.

Electronic circuits: by E. J. Angelo, Jr. 450 pages, diagrams, 6 × 9 in. New York, McGraw-Hill Book Co. Inc., 1958.Price, $9.00.

Research on sorting algorithms is a very core research field in computer science. Today, any advancement in sorting algorithms would lead to less time and space required to perform the sorting task. This paper discusses a newly proposed algorithm—‘ledger-based sorting algorithm’. It is basically an advancement to ‘counting sort’, but not exactly counting sort. The purpose of this paper is to reduce the time and space required for sorting when the numbers given to you belong to a particular range (0–n) and all of them are distinct. This paper also compares the newly proposed algorithm with insertion sort, bubble sort, selection sort, quick sort, merge sort and mainly counting sort through graphical time analysis of these algorithms. The paper especially compares counting sort algorithm with the proposed algorithm in terms of both time and space complexity.

An alternative taxonomy (to that of Knuth and others) of sorting algorithms is proposed. It emerges naturally out of a top-down approach to the derivation of sorting algorithms. Work done in automatic program synthesis has produced interesting results about sorting algorithms that suggest this approach. In particular, all sorts are divided into two categories: hardsplit/easyjoin and easysplit/hardjoin. Quicksort and merge sort, respectively, are the canonical examples in these categories. Insertion sort and selection sort are seen to be instances of merge sort and quicksort, respectively, and sinking sort and bubble sort are in-place versions of insertion sort and selection sort. Such an organization introduces new insights into the connections and symmetries among sorting algorithms, and is based on a higher level, more abstract, and conceptually simple basis. It is proposed as an alternative way of understanding, describing, and teaching sorting algorithms.

A Simple Parallel Algorithm for the Single-Source Shortest Path Problem on Planar Digraphs

Neural networks have proved to be effective in solving a wide range of problems. As problems become more and more demanding, they require larger neural networks, and the time used for learning is consequently greater. Parallel implementations of learning algorithms are therefore vital for a useful application. Implementation, however, strongly depends on the features of the learning algorithm and the underlying hardware architecture. For this experimental work a dynamic problem was chosen which implicates the use of recurrent neural networks and a learning algorithm based on the paradigm of learning automata. Two parallel implementations of the algorithm were applied - one on a computing cluster using MPI and OpenMP libraries and one on a graphics processing unit using the CUDA library. The performance of both parallel implementations justifies the development of parallel algorithms.

Critical to any automated surveillance system is the recognition component. Since the inception of Pattern Recognition & Image processing, researchers across the globe continue to propose newer facial recognition algorithms. Each of these facial algorithms has its own pros and cons. A typical facial recognition algorithm consists of three steps namely: facial detection, feature extraction and recognition. In this paper we discuss serial and parallel implementation of four standard facial recognition algorithms namely, Principal Component Analysis (PCA), Linear Discriminant Analysis (LDA), Independent Component Analysis (ICA) and FISHER Face. Work presented in this paper consists of two sections. In section 1, we discuss serial and parallel implementation of the algorithms. Section 2, presents a comparative performance analysis of the above 4 algorithms. A major challenge in this effort is the ability to explore and exploit concurrency in existing facial recognition algorithms to improve performance. Based on the algorithms performance, we have made few suggestions regarding the suitability of each of these algorithms for different domains/applications. All algorithms are implemented using open source OPENCV and OPENMP libraries.

Bubble sort algorithm and its variants are discussed in detail. Bubble sort algorithm is the slowest one in application; improved bubble sort algorithm is superior to it because of the introduction of flag variant and the forward movement of end index; improved bubble sort algorithm moves the end index more quickly; bidirectional bubble sort algorithm quickly moves the end index forwards and the start index backwards at the same time. In all these algorithms, bidirectional bubble sort algorithm is especially suitable to those sequence parts items of which are already in expected order. Bidirectional bubble sort algorithm is of great significance and has the highest efficiency.

A digital electromagnetic model of electric power system is suggested. The parallel and the sequential algorithms to solve the equation set are described. Implementation of the parallel algorithm on k processors provides more then k times speedup.

SummarySeveral important tasks, including matrix computation, signal processing, sorting, dynamic programming, encryption, and decryption, can be performed by oblivious sequential algorithms. A sequential algorithm is oblivious if an address accessed at each time does not depend on the input data. A bulk execution of a sequential algorithm is to execute it for many independent inputs in turn or in parallel. A number of works have been devoted to design and implement parallel algorithms for a single input. However, none of these works evaluated the bulk execution performance of these algorithms. The first contribution of this paper is to present a time‐optimal implementation for bulk execution of an oblivious sequential algorithm. Our second contribution is to develop a tool, named C2CU, which automatically generates a CUDA C program for a bulk execution of an oblivious sequential algorithm. The C2CU has been used to generate CUDA C programs for the bulk execution of the bitonic sorting, Floyd‐Warshall, and Montgomery modulo multiplication algorithms. Compared to a sequential implementation on a single CPU, the generated CUDA C programs for the above algorithms run, respectively, 199, 54, and 78 times faster.

This paper presents a Parallel Data Mining Platform (PDMP), aiming at rapidly developing parallel data mining applications on cluster system. This platform consists of parallel data mining algorithm library, data warehouse, field knowledge base and platform middleware. The middleware is the kernel of the platform, which comprises data processing component, task manager, data manager, GUI, and so on. Taking advantage of cluster system, the middleware provides a convenient developing environment and effective bottom supports for implementation of parallel data mining algorithms. So far, the parallel data mining algorithm library has possessed several parallel algorithms, such as classification, clustering, association rule mining, sequence pattern mining and so on. With a register mechanism, the parallel data mining algorithm library is easy to be extended by users. Experiment results with the use of the PDMP show that there is a substantial performance improvement due to the cooperation of the middleware and corresponding parallel strategy.