On the Cache Performance of Time-Efficient Sorting Algorithms

The quest to develop the most memory efficient and the fastest sorting algorithm has become one of the crucial mathematical challenges of the last half century, resulting in many tried and tested algorithm available to the individual, who needs to sort the list of data. Today, the amount of data is very large, we require some sorting techniques that can arrange these data as fast as possible and also provide the best efficiency in terms of time and space. In this paper, we will discuss some of the sorting algorithms and compare their time complexities for the set of data

Proceedings International Parallel and Distributed Processing Symposium, 2003

Hardware performance counters are available on most modern microprocessors. These counters are implemented as a small set of registers that count events related to the processor's functions. The Perfctr toolkit is one of the most popular toolkits (for x86 processors) for monitoring these events. In this paper, it is used to discover the impact of L1 data cache misses on the overall performance of six integer sorting algorithms. Most of them are cache conscious algorithms recently introduced, or known to behave well according to previous simulations, or they are totally not explored. We demonstrate through experiments on an Athlon processor that a good balance between L1 data cache misses and retired instructions provides the fastest algorithm for sorting in practical cases. The fastest sorting algorithm is not obtained with the implementation that gives the smallest number of misses and the smallest number of instructions. The fastest algorithm in practice is thus a new flavour of mergesort that we have developed and it beats its rival. Keywords: hardware performance counters, cache conscious and oblivious algorithms, in-core sorting algorithms, two levels memory hierarchy, parallelism at the chip level.

Sorting is a process of rearranging a sequence of objects into some kind of predefined linear order. String data is very common and most occurring data type. Sorting a string involves comparison it character by character which is more time consuming than integer sorting. Also, sorting forms the basis of many applications like data processing, databases, pattern matching and searching etc. So implementing improvements to make it fast and efficient will help in reducing the computational time and thus making our applications run faster. This paper briefs about various fast and efficient string sorting algorithms. The algorithms have been divided into two categories: cache-aware and cache-oblivious. The various algorithms discussed are: CRadix Sort, Burstsort and cache-oblivious string sorting algorithm. The improvement in CRadix Sort is achieved by starting the sorting with the most significant digit and associating a small block of main memory called the key buffer to each key and sorting a portion of each key into its corresponding key buffer. Burstsort is a trie-based string sorting algorithm that distributes strings into small buckets whose contents are then sorted in cache. The cache-oblivious string sorting algorithm is a randomized algorithm for string sorting which uses signature technique (reduces the sequence by creating a set of “signatures” strings having the same trie structure as the original set) to sort strings.

2016

The paper presents a new sorting algorithm that takes input data integer elements and sorts them without any comparison operations between the data—a comparison-free sorting. The algorithm uses a one-hot representation for each input element that is stored in a two-dimensional matrix called a one-hot matrix. Concurrently, each input element is also stored in a one-dimensional matrix in the input element’s integer representation. Subsequently, the transposed one-hot matrix is mapped to a binary matrix producing a sorted matrix with all elements in their sorted order. The algorithm exploits parallelism that is suitable for single instruction multiple thread (SIMT) computing that can harness the resources of these computing machines, such as CPUs with multiple cores and GPUs with large thread blocks. We analyze our algorithm’s sorting time on varying CPU architectures, including singleand multi-threaded implementations on a single CPU. Our results show a fast sorting time for the singl...

Abstract: When using the visualize to compare algorithms, never forget that the visualize sorts only very small arrays. The effect of quadratic complexity (either a square number of moves or a square number of exchanges) is dramatic as the size of the array grows. For instance, dichotomic insertion, which is only marginally slower than quick sort on 100 items, becomes 10 times slower on 10000 items. We have investigated the complexity values researchers have obtained and observed that there is scope for fine tuning in present context. Strong evidence to that effect is also presented. We aim to provide a useful and comprehensive note to researcher about how complexity aspects of sorting algorithms can be best analyzed. Keywords: Algorithm analysis, Sorting algorithm, Empirical Analysis Computational Complexity notations. Title: Performance Comparison of Sorting Algorithms On The Basis Of Complexity Author: Mr. Niraj Kumar, Mr. Rajesh Singh International Journal of Computer Science and Information Technology Research ISSN 2348-120X (online), ISSN 2348-1196 (print) Research Publish Journals

International Journal of Scientific Research in Computer Science, Engineering and Information Technology, 2023

In today's era, the development of information technology is increasingly rapid. This is because human life is currently very dependent on the needs of information technology. This can be proven by the number of human interactions with various gadgets, such as laptops, cellphones, computers, and so on. The development of information technology has made IT activists such as companies and programmers compete in making good applications. One of the most basic things that are mastered in making an application is making algorithms. Currently, there are many types of algorithms. One of them is the data sorting algorithm. In this study, we will try to examine 3 data sorting algorithms, namely Insertion Sort, Quick Sort, and Merge Sort. These three algorithms will be used to sort random data ranging from 1000 to 20,000 data. The three algorithms will be compared in terms of execution time. The results show that the Insertion Sort algorithm is a data sorting algorithm that has the fastest execution time compared to other algorithms, while the Merge Sort algorithm is the most time consuming algorithm compared to other algorithms.

International Journal of Computer Applications, 2020

Sorting is one of the most important task in many computer applications. Efficiency becomes a big problem when the sorting involves a large amounts of data. There are a lot of sorting algorithms with different implementations. Some of them sort data by comparison while others don't. The main aim of this thesis is to evaluate the comparison and noncomparison based algorithms in terms of execution time and memory consumption. Five main algorithms were selected for evaluation. Out of these five, three were comparison based algorithms (quick, bubble and merge) while the remaining two were non-comparison based (radix and counting). After conducting an experiment using array of different data sizes (ranging from 1000 to 35000), it was realized that the comparison based algorithms were less efficient than the noncomparison ones. Among the comparison algorithms, bubble sort had the highest time complexity due to the swapping nature of the algorithm. It never stops execution until the largest element is bubbled to the right of the array in every iteration. Despite this disadvantage, it was realized that it is memory efficient since it does not create new memory in every iteration. It relies on a single memory for the swapping array operation. The quick sort algorithm uses a reasonable amount of time to execute, but has a poor memory utilization due to the creation of numerous sub arrays to complete the sorting process. Among the comparison based algorithms, merge sort was far better than both quick and bubble. On the average, merge sort utilized 32.261 seconds to sort all the arrays used in the experiment while quick and bubble utilized 41.05 and 165.11 seconds respectively. The merge algorithm recorded an average memory consumption of 5.5MB for all the experiment while quick and bubble recorded 650.792MB and 4.54MB respectively. Even though the merge sort is better than both quick and bubble, it cannot be compared to the non-comparison based algorithms since they perform far better than the comparison based ones. When the two groups were evaluated against execution time, the comparison based algorithms recorded an average score of 476.757 seconds while the non-comparison obtained 17.849 seconds. With respect to the memory utilization, the non-comparison based algorithms obtained 27.12MB while the comparison ones obtained 1321.681MB. This clearly reveals the efficiency of the non-comparison based algorithms over the comparison ones in terms of execution time and memory utilization.

2009

Since the dawn of computing, the sorting problem has attracted a great deal of research. In past, many researchers have attempted to optimize it properly using empirical analysis. We have investigated the complexity values researchers have obtained and observed that there is scope for fine tuning in present context. Strong evidence to that effect is also presented. We aim to provide a useful and comprehensive note to researcher about how complexity aspects of sorting algorithms can be best analyzed. It is also intended current researchers to think about whether their own work might be improved by a suggestive fine tuning. Our work is based on the knowledge learned after literature review of experimentation, survey paper analysis being carried out for the performance improvements of sorting algorithms. Although written from the perspective of a theoretical computer scientist, it is intended to be of use to researchers from all fields who want to study sorting algorithms rigorously.

International Journal of Modern Education and Computer Science, 2013

Sorting allows information or data to be put into a meaningful order. As efficiency is a major concern of computing, data are sorted in order to gain the efficiency in retrieving or searching tasks. The factors affecting the efficiency of shell, Heap, Bubble, Quick and Merge sorting techniques in terms of running time, memory usage and the number of exchanges were investigated. Experiment was conducted for the decision variables generated from algorithms implemented in Java programming and factor analysis by principal components of the obtained experimental data was carried out in order to estimate the contribution of each factor to the success of the sorting algorithms. Further statistical analysis was carried out to generate eigenvalue of the extracted factor and hence, a system of linear equations which was used to estimate the assessment of each factor of the sorting techniques was proposed. The study revealed that the main factor affecting these sorting techniques was time taken to sort. It contributed 97.842%, 97.693%, 89.351%, 98.336% and 90.480% for Bubble sort, Heap sort, Merge sort, Quick sort and Shell sort respectively. The number of swap came second contributing 1.587% for Bubble sort, 2.305% for Heap sort, 10.63% for Merge sort, 1.643% for Quick sort and 9.514% for Shell sort. The memory used was the least of the factors contributing negligible percentage for the five sorting techniques. It contributed 0.571% for Bubble sort, 0.002% for Heap sort, 0.011% for Merge sort, 0.021% for Quick sort and 0.006% for Shell sort.

Computers in Physics, 1990

Four sorting algorithms-bubble, insertion, heap, and quick-are studied on an IBM 3090/ 600, a VAX 11/780, and the NYU Ultracomputer. It is verified that for N items the bubble and insertion sorts are of order N 2 whereas the heap and quick sorts are of order N In N. It is shown that the choice of algorithm is more important than the choice of machine. Moreover, the influence of paging on algorithm performance is examined.

International Journal of Computer Science and Mobile Computing, 2022

Data is the new fuel. With the expansion of the global technology, the increasing standards of living and with modernization, data values have caught a great height. Now a days, nearly all top MNCs feed on data. Now, to store all this data is a prime concern for all of them, which is relieved by the Data Structures, the systematic way of storing data. Now, once these data are stored and charged in secure vaults, it's time to utilize them in the most efficient way. Now, there are a lot of operations that needs to be performed on these massive chunks of data, like searching, sorting, inserting, deleting, merging and so more. In this paper, we would be comparing all the major sorting algorithms that have prevailed till date. Further, work have been done and an inequality in dimension of time between the four Sorting algorithms, Bubble, Selection, Insertion, Merge, that have been discussed in the paper have been proposed.

The main purpose of the project is to test 5 main sorting algorithms according to their speed. Different tests are used to see the difference in each step.

2015

Sorting is considered as a very basic operation in computer science. Sorting is used as an intermediate step in many operations. Sorting refers to the process of arranging list of elements in a particular order either ascending or descending using a key value. There are a lot of sorting algorithms have been developed so far. This research paper presents the different types of sorting algorithms of data structure like Bubble Sort, Selection Sort, Insertion Sort, Merge Sort, Heap Sort and Quick Sort and also gives their performance analysis with respect to time complexity. These six algorithms are important and have been an area of focus for a long time but still the question remains the same of "which to use when?" which is the main reason to perform this research. Each algorithm solves the sorting problem in a different way. This research provides a detailed study of how all the six algorithms work and then compares them on the basis of various parameters apart from time c...

2020

The problem of sorting is a problem that arises frequently in computer programming and though which is need to be resolved. Many different sorting algorithms have been developed and improved to make sorting optimized and fast. As a measure of performance mainly the average number of operations or the average execution times of these algorithms have been compared. There is no one sorting method that is best for every situation. Some of the factors to be considered in choosing a sorting algorithm include the size of the list to be sorted, the programming effort, the number of words of main memory available,the size of disk or tape units, the extent to which the list is already ordered, and the distribution of values.