To teach Newton's square root algorithm

Peelle, Howard A.

doi:10.1145/585882.585889

Cited by 5 publications

(4 citation statements)

References 0 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…The second implementation, named λ N , computes the square root by using three iterations of the Newton-Raphson method [20,19] which is available from the implementation of Carmack and Lomont. This square root implementation has proved to be effective for applications that allow small errors.…”

Section: Choosing a Proper Square Rootmentioning

confidence: 99%

A Non-linear GPU Thread Map for Triangular Domains

Navarro,

Bustos,

Hitschfeld

2016

Preprint

View full text Add to dashboard Cite

There is a stage in the GPU computing pipeline where a grid of thread-blocks, in parallel space, is mapped onto the problem domain, in data space. Since the parallel space is restricted to a box type geometry, the mapping approach is typically a k-dimensional bounding box (BB) that covers a p-dimensional data space. Threads that fall inside the domain perform computations while threads that fall outside are discarded at runtime. In this work we study the case of mapping threads efficiently onto triangular domain problems and propose a block-space linear map λ(ω), based on the properties of the lower triangular matrix, that reduces the number of unnnecessary threads from O(n 2 ) to O(n). Performance results for global memory accesses show an improvement of up to 18% with respect to the bounding-box approach, placing λ(ω) on second place below the rectangular-box approach and above the recursive-partition and upper-triangular approaches. For shared memory scenarios λ(ω) was the fastest approach achieving 7% of performance improvement while preserving thread locality. The results obtained in this work make λ(ω) an interesting map for efficient GPU computing on parallel problems that define a triangular domain with or without neighborhood interactions. The extension to tetrahedral domains is analyzed, with applications to triplet-interaction n-body applications.

show abstract

Section: Choosing a Proper Square Rootmentioning

confidence: 99%

A Non-linear GPU Thread Map for Triangular Domains

Navarro,

Bustos,

Hitschfeld

2016

Preprint

View full text Add to dashboard Cite

show abstract

“…The second implementation of LTM, named 'LTM-N', computes the square root by using three iterations of the Newton-Raphson method [13], [12]. More in detail, we use the implementation of Carmack and Lomont.…”

Section: A Choosing the Best Implementation For Ltmmentioning

confidence: 99%

“…[11] proposed a mapping function that given a thread id k, it computes the coordinates (a, b), based on the properties of the upper-triangular section of a symmetric matrix. The authors mention that they use Carmack's and Lomont's fast square root approximation (based on the Newton-Raphson approximation algorithm [12]) for speeding up the mapping function. The authors also mention that all approximation errors can be fixed by using only two conditionals statements.…”

Section: Introduction and Related Workmentioning

confidence: 99%

GPU Maps for the Space of Computation in Triangular Domain Problems

Navarro

Hitschfeld

2014

2014 IEEE Intl Conf on High Performance Computing and Communications, 2014 IEEE 6th Intl Symp on Cyberspace Safety and Security

View full text Add to dashboard Cite

There is a stage in the GPU computing pipeline where a grid of thread-blocks is mapped to the problem domain. Normally, this grid is a k-dimensional bounding box that covers a k-dimensional problem no matter its shape. Threads that fall inside the problem domain perform computations, otherwise they are discarded at runtime. For problems with non-square geometry, this is not always the best idea because part of the space of computation is executed without any practical use. Twodimensional triangular domain problems, alias td-problems, are a particular case of interest. Problems such as the Euclidean distance map, LU decomposition, collision detection and simulations over triangular tiled domains are all td-problems and they appear frequently in many areas of science. In this work, we propose an improved GPU mapping function g(λ), that maps any λ block to a unique location (i, j) in the triangular domain. The mapping is based on the properties of the lower triangular matrix and it works at a block level, thus not compromising thread organization within a block. The theoretical improvement from using g(λ) is upper bounded as I < 2 and the number of wasted blocks is reduced from O(n 2 ) to O(n). We compare our strategy with other proposed methods; the upper-triangular mapping (UTM), the rectangular box (RB) and the recursive partition (REC). Our experimental results on Nvidia's Kepler GPU architecture show that g(λ) is between 12% and 15% faster than the bounding box (BB) strategy. When compared to the other strategies, our mapping runs significantly faster than UTM and it is as fast as RB in practical use, with the advantage that thread organization is not compromised, as in RB. This work also contributes at presenting, for the first time, a fair comparison of all existing strategies running the same experiments under the same hardware.

show abstract

“…For example, the approximation of √ x using the Newton-Rhapson method [100] cannot be parallelized because each iteration depends on the value of the previous one; there is the issue of time dependence. Such problems do not benefit from parallelism at all and are best solved using a CPU.…”

Section: Introductionmentioning

confidence: 99%

A Survey on Parallel Computing and its Applications in Data-Parallel Problems Using GPU Architectures

Navarro

Hitschfeld

Mateu

2014

Commun. comput. phys.

162

View full text Add to dashboard Cite

Abstract. Parallel computing has become an important subject in the field of computer science and has proven to be critical when researching high performance solutions. The evolution of computer architectures (multi-core and many-core) towards a higher number of cores can only confirm that parallelism is the method of choice for speeding up an algorithm. In the last decade, the graphics processing unit, or GPU, has gained an important place in the field of high performance computing (HPC) because of its low cost and massive parallel processing power. Super-computing has become, for the first time, available to anyone at the price of a desktop computer. In this paper, we survey the concept of parallel computing and especially GPU computing. Achieving efficient parallel algorithms for the GPU is not a trivial task, there are several technical restrictions that must be satisfied in order to achieve the expected performance. Some of these limitations are consequences of the underlying architecture of the GPU and the theoretical models behind it. Our goal is to present a set of theoretical and technical concepts that are often required to understand the GPU and its massive parallelism model. In particular, we show how this new technology can help the field of computational physics, especially when the problem is data-parallel. We present four examples of computational physics problems; n-body, collision detection, Potts model and cellular automata simulations. These examples well represent the kind of problems that are suitable for GPU computing. By understanding the GPU architecture and its massive parallelism programming model, one can overcome many of the technical limitations found along the way, design better GPU-based algorithms for computational physics problems and achieve speedups that can reach up to two orders of magnitude when compared to sequential implementations.

show abstract

To teach Newton's square root algorithm

Cited by 5 publications

References 0 publications

A Non-linear GPU Thread Map for Triangular Domains

A Non-linear GPU Thread Map for Triangular Domains

GPU Maps for the Space of Computation in Triangular Domain Problems

A Survey on Parallel Computing and its Applications in Data-Parallel Problems Using GPU Architectures

Contact Info

Product

Resources

About