Implementation Of Sort Research Articles

A Novel and Simple Spike Sorting Implementation

Monitoring the activity of multiple, individual neurons that fire spikes in the vicinity of an electrode, namely perform a Spike Sorting (SS) procedure, comprises one of the most important tools for contemporary neuroscience in order to reverse-engineer the brain. As recording electrodes' technology rabidly evolves by integrating thousands of electrodes in a confined spatial setting, the algorithms that are used to monitor individual neurons from recorded signals have to become even more reliable and computationally efficient. In this work, we propose a novel framework of the SS approach in which a single-step processing of the raw (unfiltered) extracellular signal is sufficient for both the detection and sorting of the activity of individual neurons. Despite its simplicity, the proposed approach exhibits comparable performance with state-of-the-art approaches, especially for spike detection in noisy signals, and paves the way for a new family of SS algorithms with the potential for multi-recording, fast, on-chip implementations.

Implementation of Sorting Algorithms with CUDA: An Empirical Study

Sorting algorithms have been studied for more than 3 decades now. The aim of this paper is to implement some of the sorting algorithms using the CUDA language in a GPU environment provided by the Nvidia graphics cards. This empirical study is done for comparing the performance of the sorting algorithms in a run-time environment provided by the GPUs and the CUDA programming language. This study considers the implementation of bubble sort, insertion sort, quicksort, selection sort and shell sort algorithms. It is shown that there is a significant amount of speed-up in using CUDA and the Nvidia architecture instead of a sequential code running on standard architectures.

Parallel Quick Sort using Thread Pool Pattern

Sorting algorithms, their implementations and their applications in modern computing necessitates improvements for sorting large data sets quickly and efficiently. This paper will analyze the performance of a multi-threaded quick sort implemented using the thread pool pattern. The analysis will be done by comparing the time required to sort various data sets and their memory constraints, against the native sorting implementations of the Dual Pivot Quicksort and Merge Sort using the Fork-Join framework in the Oracle Java 8 programming language. Analysis is done of the effect of different number of processor (cores) of the test machine, as well as the performance barrier due to the initial time taken to create “p” threads, p being the number of processors. This paper also analyzes the limitations of the inbuilt Java method Arrays.parallelSort() and how the proposed system overcomes this problem. Finally, it also discuss possible improvements to the proposed system to further improve its performance.

The Case for Absolute Ligand Discrimination: Modeling Information Processing and Decision by Immune T Cells

Some cells have to take decision based on the quality of surroundings ligands, almost irrespective of their quantity, a problem we name "absolute discrimination". An example of absolute discrimination is recognition of not-self by immune T Cells. We show how the problem of absolute discrimination can be solved by a process called "adaptive sorting". We review several implementations of adaptive sorting, as well as its generic properties such as antagonism. We show how kinetic proofreading with negative feedback implements an approximate version of adaptive sorting in the immune context. Finally, we revisit the decision problem at the cell population level, showing how phenotypic variability and feedbacks between population and single cells are crucial for proper decision.

Continuous cell sorting in a flow based on single cell resonance Raman spectra.

Single cell Raman spectroscopy measures a spectral fingerprint of the biochemistry of cells, and provides a powerful method for label-free detection of living cells without the involvement of a chemical labelling strategy. However, as the intrinsic Raman signals of cells are inherently weak, there is a significant challenge in discriminating and isolating cells in a flowing stream. Here we report an integrated Raman-microfluidic system for continuous sorting of a stream of cyanobacteria, Synechocystis sp. PCC6803. These carotenoid-containing microorganisms provide an elegant model system enabling us to determine the sorting accuracy using the subtly different resonance Raman spectra of microorganism cultured in a (12)C or (13)C carbon source. Central to the implementation of continuous flow sorting is the use of "pressure dividers" that eliminate fluctuations in flow in the detection region. This has enabled us to stabilise the flow profile sufficiently to allow automated operation with synchronisation of Raman acquisition, real-time classification and sorting at flow rates of ca. <100 μm s(-1), without the need to "trap" the cells. We demonstrate the flexibility of this approach in sorting mixed cell populations with the ability to achieve 96.3% purity of the selected cells at a speed of 0.5 Hz.

Engineering Parallel String Sorting

We discuss how string sorting algorithms can be parallelized on modern multi-core shared memory machines. As a synthesis of the best sequential string sorting algorithms and successful parallel sorting algorithms for atomic objects, we first propose string sample sort. The algorithm makes effective use of the memory hierarchy, uses additional word level parallelism, and largely avoids branch mispredictions. Then we focus on NUMA architectures, and develop parallel multiway LCP-merge and -mergesort to reduce the number of random memory accesses to remote nodes. Additionally, we parallelize variants of multikey quicksort and radix sort that are also useful in certain situations. As base-case sorter for LCP-aware string sorting we describe sequential LCP-insertion sort which calculates the LCP array and accelerates its insertions using it. Comprehensive experiments on five current multi-core platforms are then reported and discussed. The experiments show that our parallel string sorting implementations scale very well on real-world inputs and modern machines.

SIMD- and cache-friendly algorithm for sorting an array of structures

This paper describes our new algorithm for sorting an array of structures by efficiently exploiting the SIMD instructions and cache memory of today's processors. Recently, multiway mergesort implemented with SIMD instructions has been used as a high-performance in-memory sorting algorithm for sorting integer values. For sorting an array of structures with SIMD instructions, a frequently used approach is to first pack the key and index for each record into an integer value, sort the key-index pairs using SIMD instructions, then rearrange the records based on the sorted key-index pairs. This approach can efficiently exploit SIMD instructions because it sorts the key-index pairs while packed into integer values; hence, it can use existing high-performance sorting implementations of the SIMD-based multiway mergesort for integers. However, this approach has frequent cache misses in the final rearranging phase due to its random and scattered memory accesses so that this phase limits both single-thread performance and scalability with multiple cores. Our approach is also based on multiway mergesort, but it can avoid costly random accesses for rearranging the records while still efficiently exploiting the SIMD instructions. Our results showed that our approach exhibited up to 2.1x better single-thread performance than the key-index approach implemented with SIMD instructions when sorting 512M 16-byte records on one core. Our approach also yielded better performance when we used multiple cores. Compared to an optimized radix sort, our vectorized multiway mergesort achieved better performance when the each record is large. Our vectorized multiway mergesort also yielded higher scalability with multiple cores than the radix sort.

Symbol-Decision Successive Cancellation List Decoder for Polar Codes

Polar codes are of great interests because they provably achieve the capacity of both discrete and continuous memoryless channels while having an explicit construction. Most existing decoding algorithms of polar codes are based on bit-wise hard or soft decisions. In this paper, we propose symbol-decision successive cancellation (SC) and successive cancellation list (SCL) decoders for polar codes, which use symbol-wise hard or soft decisions for higher throughput or better error performance. First, we propose to use a recursive channel combination to calculate symbol-wise channel transition probabilities, which lead to symbol decisions. Our proposed recursive channel combination also has a lower complexity than simply combining bit-wise channel transition probabilities. The similarity between our proposed method and Arikan's channel transformations also helps to share hardware resources between calculating bit- and symbol-wise channel transition probabilities. Second, a two-stage list pruning network is proposed to provide a trade-off between the error performance and the complexity of the symbol-decision SCL decoder. Third, since memory is a significant part of SCL decoders, we propose a pre-computation memory-saving technique to reduce memory requirement of an SCL decoder. Finally, to evaluate the throughput advantage of our symbol-decision decoders, we design an architecture based on a semi-parallel successive cancellation list decoder. In this architecture, different symbol sizes, sorting implementations, and message scheduling schemes are considered. Our synthesis results show that in terms of area efficiency, our symbol-decision SCL decoders outperform both bit- and symbol-decision SCL decoders.

Impact of CT attenuation correction method on quantitative respiratory-correlated (4D) PET/CT imaging.

Respiratory-correlated positron emission tomography (PET/CT) 4D PET/CT is used to mitigate errors from respiratory motion; however, the optimal CT attenuation correction (CTAC) method for 4D PET/CT is unknown. The authors performed a phantom study to evaluate the quantitative performance of CTAC methods for 4D PET/CT in the ground truth setting. A programmable respiratory motion phantom with a custom movable insert designed to emulate a lung lesion and lung tissue was used for this study. The insert was driven by one of five waveforms: two sinusoidal waveforms or three patient-specific respiratory waveforms. 3DPET and 4DPET images of the phantom under motion were acquired and reconstructed with six CTAC methods: helical breath-hold (3DHEL), helical free-breathing (3DMOT), 4D phase-averaged (4DAVG), 4D maximum intensity projection (4DMIP), 4D phase-matched (4DMATCH), and 4D end-exhale (4DEXH) CTAC. Recovery of SUV(max), SUV(mean), SUV(peak), and segmented tumor volume was evaluated as RC(max), RC(mean), RC(peak), and RC(vol), representing percent difference relative to the static ground truth case. Paired Wilcoxon tests and Kruskal-Wallis ANOVA were used to test for significant differences. For 4DPET imaging, the maximum intensity projection CTAC produced significantly more accurate recovery coefficients than all other CTAC methods (p < 0.0001 over all metrics). Over all motion waveforms, ratios of 4DMIP CTAC recovery were 0.2 ± 5.4, -1.8 ± 6.5, -3.2 ± 5.0, and 3.0 ± 5.9 for RC(max), RC(peak), RC(mean), and RC(vol). In comparison, recovery coefficients for phase-matched CTAC were -8.4 ± 5.3, -10.5 ± 6.2, -7.6 ± 5.0, and -13.0 ± 7.7 for RC(max), RC(peak), RC(mean), and RC(vol). When testing differences between phases over all CTAC methods and waveforms, end-exhale phases were significantly more accurate (p = 0.005). However, these differences were driven by the patient-specific respiratory waveforms; when testing patient and sinusoidal waveforms separately, patient waveforms were significantly different between phases (p < 0.0001) while the sinusoidal waveforms were not significantly different (p = 0.98). When considering only the subset of 4DMATCH images that corresponded to the end-exhale image phase, 4DEXH, mean and interquartile range were similar to 4DMATCH but variability was considerably reduced. Comparative advantages in accuracy and precision of SUV metrics and segmented volumes were demonstrated with the use of the maximum intensity projection and end-exhale CT attenuation correction. While respiratory phase-matched CTAC should in theory provide optimal corrections, image artifacts and differences in implementation of 4DCT and 4DPET sorting can degrade the benefit of this approach. These results may be useful to guide the implementation, analysis, and development of respiratory-correlated thoracic PET/CT in the radiation oncology and diagnostic settings.

A Hierarchical Specialization Approach for Generating Optimized Sorting Code

Most of the existing sorting implementations are manually optimized since the compilers are unable to generate optimized code, mainly due to unavailability of necessary information required at compile time. This information is only available during execution of the code. However, it can be exposed at compile time through specialization to facilitate the compiler for performing optimizations. This paper presents an automated approach using specialization to generate optimized code for sorting data on different architectures. The sorting kernel is iteratively specialized in a hierarchical way to generate an optimized version comprising a high-level kernel and three low-level kernels: insertion, base, and merge kernels. The high-level kernel working in conjunction with the low-level kernels is embedded into quick sort kernel to be invoked when the data fit within cache sizes. The experiments for our optimization approach have been performed on the Intel Core-2 Duo and Power 4 (PowerPC) processors using icc and gcc compilers, respectively. The sorting code optimized through hierarchical specialization results in fast execution and, in many cases, performs better than the manually optimized implementations.

A C++ App for Demonstration of Sorting Algorithms on Mobile Platforms

This paper presents a systematic approach for designing a C++ app for demonstrating sorting algorithms on smartphones and tablets. It is part of an on-going project on the usages of new technologies in education. The general properties of mobile platforms are discussed together with details specific to demonstrating sorting algorithms. The implementation of Insertion Sort is given as an example. The obtained results (e.g. design rules and algorithms) have been tested within a prototype application.

Streamlining the initial sample receipt process using lean methodology

Prior to assessing the need for front-end automation, a Lean based process improvement project to optimise the central specimen receipt and sorting area at Canterbury Health Laboratories (CHL) was initiated. A dedicated project team was established and used a structured framework to define improvement opportunities, identify root causes, implement improvement initiatives and establish control measures and sustainability plans ensuring initiatives were maintained and developed. The implementation of direct sorting of all samples on receipt streamlined the process, reduced sorting duplication and sample touch points. In addition there was a 25% increase in the number of samples going directly to the automated analysers from central reception and a greater than 85% reduction in the number of samples sorted to testing laboratories by core chemistry. Overall there was a 56% reduction in the number of samples going through the core chemistry separating area. Sustainability planning involved a task specific follow-up list, audit check sheets and determination of key performance indicators. This targeted short timeframe project successfully used Lean tools to implement process improvement initiatives as the basis for continuous improvement.

Fast Parallel Sorting Algorithms on GPUs

This paper presents a comparative analysis of the three widely used parallel sorting algorithms: Odd-Even sort, Rank sort and Bitonic sort in terms of sorting rate, sorting time and speed-up on CPU and different GPU architectures. Alongside we have implemented novel parallel algorithm: min-max butterfly network, for finding minimum and maximum in large data sets. All algorithms have been implemented exploiting data parallelism model, for achieving high performance, as available on multi-core GPUs using the OpenCL specification. Our results depicts minimum speed-up19x of bitonic sort against odd-even sorting technique for small queue sizes on CPU and maximum of 2300x speed-up for very large queue sizes on Nvidia Quadro 6000 GPU architecture. Our implementation of full-butterfly network sorting results in relatively better performance than all of the three sorting techniques: bitonic, odd-even and rank sort. For min-max butterfly network, our findings report high speed-up of Nvidia quadro 6000 GPU for high data set size reaching 2^24 with much lower sorting time

Categorizing variations of student-implemented sorting algorithms

In this study, we examined freshmen students' sorting algorithm implementations in data structures and algorithms' course in two phases: at the beginning of the course before the students received any instruction on sorting algorithms, and after taking a lecture on sorting algorithms. The analysis revealed that many students have insufficient understanding of implementing sorting algorithms. For example, they include unnecessary swaps in their Insertion or Selection sort implementations resulting in more complicated and inefficient code. Based on the data, we present a categorization of these types of variations and discuss the implications of the results. In addition, we introduce an instrument to recognize these algorithms automatically. This is done in terms of white-box testing. Our aim is to develop an automatic assessment system to help teachers in the burden of marking students' assignments and give feedback to the students on their algorithmic solutions. We outline how the presented results can be used to develop the instrument further.

Automatic On-Line Detection and Sorting System Design and Implementation for Paper-Making Printing

Transforms the papermaking production line to spurt the code automatic detection separation system is the production of impending rapid requirement. This design using the original paper cutter to cut the paper separating function is bad, choose the trigger for separating door action by photoelectric sensor signal, triggering bad signal detection equipments, and complete code identification papers in the test paper separating bad logo. In printing, the PLC control high-speed counter acquisition traction, printing roll encoder pulse signal range. This system includes color standard sensor signal detection, Siemens S7-200 PLC controller, etc. Also gives the system installation problems and presents the corresponding countermeasures. The paper realize online automatic testing equipments, satisfying the function of separation, stable, zero leakage rate of selected control of the production requirement.

Implementation and Performance Analysis of Exponential Tree Sorting

The traditional algorithm for sorting gives a bound of expected time without randomization and with randomization. Recent researches have optimized lower bound for deterministic algorithms for integer sorting [1-3]. Andersson has given the idea of Exponential tree which can be used for sorting [4]. Andersson, Hagerup, Nilson and Raman have given an algorithm which sorts n integers in expected time but uses space [4, 5]. Andersson has given improved algorithm which sort integers in expected time and linear space but uses randomization [2, 4]. Yijie Han has improved further to sort integers in expected time and linear space but passes integers in a batch i.e. all integers at a time [6]. These algorithms are very complex to implement. In this paper we discussed a way to implement the exponential tree sorting and later compare results with traditional sorting technique. General Terms Algorithms, Data Structure.

Design and implementation of an efficient integer count sort in CUDA GPUs

SUMMARYWe describe experience on design and implementation of an efficient count sort algorithm on Compute Unified Device Architecture graphics processing units. The novelty of this work is twofold. At first, we propose a count sort algorithm for integers that needs no synchronization at its last step and thus, offers superior performance. At second, this work contributes ad hoc techniques for optimizing the performance of the algorithm on Compute Unified Device Architecture‐enabled graphics processing units. Copyright © 2011 John Wiley &amp; Sons, Ltd.

A specimen of parallel programming

One common example of parallel processing is the implementation of the merge sort within a parallel processing environment. In the fully parallel model, you repeatedly split the sublists down to the point where you have single-element lists [3]. You then merge these in parallel back up the processing tree until you obtain the fully merged list at the top of the tree. While of theoretical interest, you probably don't have the massively parallel processor that this would require. Instead, you can use a mixed strategy. Determine the number of parallel processes you can realistically obtain within your computing environment. Then construct the processing tree so that you have that number of leaf nodes. Within the leaf nodes of the processing tree, simply use the best sequential algorithm to accomplish the sorting, and send that result upstream to the internal nodes of the processing tree, which will merge the sorted sublists and then send the resulting list farther upstream in the tree. Figure One shows the processing tree for the case in which you have a list of 2000 items to be sorted and have resources only sufficient for four parallel processes. The processes receiving the size 500 lists use some sequential sorting algorithm. Because of the implementation environment, it will be something in the C/C++ language---either qsort() or your favorite implementation of a fast sorting algorithm. Each leaf node (with a size 500 list) then provides the sorted result to the parent process within the processing tree. That process combines the two lists to generate a size 1000 list, and then sends that result upstream to its parent process. Finally, the root process in the processing tree merges the two lists to obtain a size 2000 list, fully sorted. If your environment supports more parallel processes, you might take the processing tree to four levels, so that eight processes do the sequential sorting of size 250 lists. For that matter, you could even deal with circumstances in which the supported number of parallel processes is not an exact power of two. That just means that some of the leaf nodes will be at the bottommost level and some conceptually at a higher level above in the processing tree. Since in parallel processing, the time required is the time required by the slowest process, you will probably want to stick with circumstances where the number of leaf nodes is a power of two---in other words, the processing tree is a full binary tree and all leaf nodes are doing approximately the same amount of work.

Energy aware data management on AVR micro controller based systems

Data management systems comprise various algorithms for efficiently retrieving and managing data. Typically, algorithm efficiency or performance is correlated with execution speed. However, the uptime of battery-powered mobile- and embedded systems strongly depends on the energy consumption of the involved components. This paper reports our results concerning the energy consumption of different implementations of sorting and join algorithms. We demonstrate that high performance algorithms often require more energy than slower ones. Furthermore, we show that dynamically exchanging algorithms at runtime results in a better throughput if energy is limited.

Critical success factors for on-site sorting of construction waste: A china study

Benefits of conducting on-site sorting of construction waste, typically including increasing the rates of reuse and recycling, reducing the cost for waste transportation and disposal, prolonging the lifespan of landfills designed for receiving non-inert construction waste, and lessening the pollution resulted from the huge amount of construction waste, have been extensively investigated by previous studies. However, effective implementation of construction waste sorting requires a wide range of factors involving human beings, management, technology, environment and resources. So far, we know little about how to conduct effective construction waste sorting in China. This research therefore aims to identify the critical success factors (CSFs) for on-site sorting of construction waste in China. A set of methods including CSF approach, pilot study, questionnaire survey and face-to-face interview are adopted to facilitate the identification and analysis of the CSFs. Six factors including (1) manpower, (2) market for recycled materials, (3) waste sortability, (4) better management, (5) site space, (6) equipment for sorting of construction waste, are considered the CSFs for effective on-site sorting of construction waste in Shenzhen, China. These CSFs are of great significance both to researchers and industry practitioners.