A copy of this work was available on the public web and has been preserved in the Wayback Machine. The capture dates from 2010; you can also visit the original URL.
The file type is `application/pdf`

.

## Filters

##
###
On parallel integer sorting

1992
*
Acta Informatica
*

Known

doi:10.1007/bf01178563
fatcat:bsxj243apffztnveqbsqpkt4d4
*Parallel**Sorting*Algorithms The performance of a*parallel*algorithm can be specified by bounds*on*its principal resources namely, processors and time. ... Using this algorithm, the best known upper bound for*integer**sorting**on*the (O(log n) word length) EREW PRAM model is improved. ... But no*parallel*analogue of this algorithm exists. In this section we present a*parallel*range reduction algorithm that results in a P T bound of O(n √ log n) for*INTEGER**SORT**on*the CRCW PRAM. ...##
###
A NOTE ON COARSE GRAINED PARALLEL INTEGER SORTING

1999
*
Parallel Processing Letters
*

We observe that for n=p p, which is usually the case in practice, there exists a very simple, deterministic, optimal coarse grained

doi:10.1142/s0129626499000499
fatcat:qibrschgrfcq5mcn6yvpil7vcu
*parallel**integer**sorting*algorithm with 24 communication rounds (6 n ... p -relations and 18 p-relations),*On*=p memory per processor and*On*=p local computation. ... Algorithms 2:*Sorting*n*integers**on*a p processors machine when n p p. ...##
###
An optimal parallel algorithm for integer sorting

1985
*
26th Annual Symposium on Foundations of Computer Science (sfcs 1985)
*

Our main result is an optimal randomized

doi:10.1109/sfcs.1985.9
dblp:conf/focs/Reif85
fatcat:uouccsjcfnhkdkkvmremtascsq
*parallel*algorithm for INTE-GER*SORT*i.e., for*sorting*n*integers*in the range 1; n . ... And nally, w e present sub-logarithmic time algorithms for GENERAL*SORT*and*INTEGER**SORT*. Our sublogarithmic GENERAL*SORT*algorithm is also optimal. ... step2 1 an optimal*parallel*algorithm for*INTEGER**SORT*. ...##
###
A Note on Coarse Grained Parallel Integer Sorting
[chapter]

*
High Performance Computing Systems and Applications
*

We observe that for n=p p, which is usually the case in practice, there exists a very simple, deterministic, optimal coarse grained

doi:10.1007/0-306-47015-2_36
fatcat:afjgtn6onrhwnnqgizznvbv7ta
*parallel**integer**sorting*algorithm with 24 communication rounds (6 n ... p -relations and 18 p-relations),*On*=p memory per processor and*On*=p local computation. ... Algorithms 2:*Sorting*n*integers**on*a p processors machine when n p p. ...##
###
Integer sorting algorithms for coarse-grained parallel machines

*
Proceedings Fourth International Conference on High-Performance Computing
*

These results are compared with two other well known practical

doi:10.1109/hipc.1997.634487
dblp:conf/hipc/AlsabtiR97
fatcat:ztnvsc5lffd4lb3ehi3wfocgxy
*parallel**sorting*algorithms based*on*radix*sort*and sample*sort*. ...*Integer**sorting*is a subclass of the*sorting*problem where the elements have*integer*values and the largest element is polynomially bounded in the number of elements to be*sorted*. ... the performance of our algorithm is comparable or superior to the sample based*integer**sort*for small sized*integers*(16-bit or 32-bit) especially for large data sets or number of processors. ...##
###
Integer sorting on a mesh-connected array of processors

*
Proceedings of the Second IEEE Symposium on Parallel and Distributed Processing 1990
*

Using a less restrictive, more realistic model we show that the

doi:10.1109/spdp.1990.143542
dblp:conf/spdp/Krizanc90
fatcat:kavxxfaslbej3d2j7jl33fsuym
*sorting*N = n 2*integers*in the range [1 ... N] can be performed in 2n + o(n) steps*on*a n X n mesh. ... Schnorr and Shamir and independently Kunde, have shown that*sorting*N = n 2 inputs into snake-like ordering*on*a n X n mesh requires 3n -o(n) steps. ... Theorem 3 N = n 2*integers*in the range [1 ... N] can be*sorted*into snake like order in 2n + o(n) steps*on*a n X n mesh. Proof: A*sorted*list of k*integers*in the range [1 ... ...##
###
Sorting using networks of deques

1979
*
Journal of computer and system sciences (Print)
*

The number of required deques for

doi:10.1016/0022-0000(79)90007-2
fatcat:y2nshyei5zcjhpymgujroebd3e
*sorting*all sequences of n items in a*parallel*or series network of deques is considered. ... For*sorting*all sequences of n*integers*by a series networks of stacks, we need O(log n) stacks. ... For the case when n is equal to*one*, the theorem is trivially true: No IRDQ is required for*sorting**one**integer*. So we prove the theorem by induction*on*n. ...##
###
Parallel Merging and Sorting on Linked List

2021
*
International Journal of Computer and Information Technology(2279-0764)
*

We also show that two

doi:10.24203/ijcit.v10i2.85
fatcat:ciydjz474nfjhordxvp2qximli
*sorted*linked lists of n*integers*in {0, 1, ..., m} can be merged into*one**sorted*linked list in O(log(c)n(loglogm)1/2) time using n/(log(c)n(loglogm)1/2) processors, where c is an ... We study linked list*sorting*and merging*on*the PRAM model. ... INTRODUCTION In this paper we study*parallel*merging and*sorting*. ...##
###
More Efficient Parallel Integer Sorting
[chapter]

2012
*
Lecture Notes in Computer Science
*

We present a more efficient CREW PRAM algorithm for

doi:10.1007/978-3-642-29700-7_26
fatcat:hh27ugs3lfh25h4flns7oxeotu
*integer**sorting*. ... This algorithm*sorts*n*integers*in {0, 1, 2, ..., n 1/2 } in O((log n) 3/2 / log log n) time and O(n(log n/ log log n) 1/2 ) operations. ...*Parallel**integer**sorting*is such a fundamental problem in*parallel*algorithm design and many renowned researchers worked*on*this problem relentlessly. ...##
###
A Parallel Solution to Finding Nodal Neighbors in Generic Meshes
[article]

2016
*
arXiv
*
pre-print

The presented

arXiv:1604.04689v3
fatcat:ql455op7njhq3i4cvw3akwx4j4
*parallel*solution is heavily dependent*on*the*parallel**sorting*, scan, and reduction, and can be applied to determine both the neighboring nodes and elements. ... In this paper we specifically present a*parallel*solution to finding the*one*-ring neighboring nodes and elements for each vertex in generic meshes. ... Our solution is a topology-based method, and is heavily dependent*on*the use of*parallel**sorting*, scan, and reduction. ...##
###
A Parallel Solution to Finding Nodal Neighbors in Generic Meshes

2020
*
MethodsX
*

The presented

doi:10.1016/j.mex.2020.100954
pmid:32596136
pmcid:PMC7306601
fatcat:7hbglvyopjhhlhnjgoryb55xxu
*parallel*solution is heavily dependent*on*the*parallel**sorting*, scan, and reduction. ... In this paper we specifically present a*parallel*solution to finding the*one*-ring neighboring nodes and elements for each vertex in generic meshes. ... The presented*parallel*solution is heavily dependent*on*the*parallel**sorting*, scan, and reduction. ...##
###
An NC Algorithm for Sorting Real Numbers in O(nlogn/√loglogn) Operations

2019
*
Open Journal of Applied Sciences
*

We apply the recent important result of serial

doi:10.4236/ojapps.2019.95034
fatcat:5b2kc4bwjrf3tnicscsumqgj3q
*sorting*of n real numbers in ( ) log O n n time to the design of a*parallel*algorithm for*sorting*real numbers in ( ) 1 log O n ε + time and log log log operations ... This is the first NC algorithm known to take ( ) log o n n operations for*sorting*real numbers. ... There are also*parallel*algorithms for*integer**sorting*[8] [9] [10] [11]. In the case of*integer**sorting*, the operation bound can be improved to below ( ) log O n n . ...##
###
AA-Sort: A New Parallel Sorting Algorithm for Multi-Core SIMD Processors

2007
*
Parallel Architecture and Compilation Techniques (PACT), Proceedings of the International Conference on
*

970MP when

doi:10.1109/pact.2007.4336211
fatcat:m27r5taoajec3fbgkryac4cf3y
*sorting*32 M of random 32-bit*integers*. ... Furthermore, a*parallel*version of AA-*sort*demonstrated better scalability with increasing numbers of cores than a*parallel*version of GPUTeraSort*on*both platforms. 16th International Conference*on**Parallel*... Figure 12 shows the execution time of*parallel*versions of the AA-*sort*and the GPUTeraSort*on*1, 2, and 4 PowerPC 970MP cores for 32 M random*integers*. ...##
###
A General Framework for Sorting Large Data Sets Using Independent Subarrays of Approximately Equal Length

2022
*
IEEE Access
*

The third experiment shows the effectiveness of the proposed

doi:10.1109/access.2022.3145981
fatcat:arem7eoy5zavtifdpfw5eivzse
*parallel*framework to the*parallel**sorting*based*on*the random-access machine model. ... using*one*of the popular comparison-based*sorting*algorithms. ... Most data*sorting*research works focus*on**integer*/noninteger uniform or*integer*/non-*integer*Gaussian data sets. ...##
###
A high-performance sorting algorithm for multicore single-instruction multiple-data processors

2011
*
Software, Practice & Experience
*

*on*PowerPC 970MP when

*sorting*32 million random 32-bit

*integers*. ... Also, a

*parallel*version of AA-

*sort*demonstrated better scalability with increasing numbers of cores than a

*parallel*version of bitonic merge

*sort*

*on*both platforms. ... Fig. 17 . 17 The execution times of

*parallel*versions of AA-

*sort*and GPUTeraSort for

*sorting*32 million uniform random

*integers*

*on*up to 4 cores of PowerPC 970MP. 19 shows the

*sorting*time for 32 million ...

« Previous

*Showing results 1 — 15 out of 95,479 results*