Spara som favorit. Skickas inom vardagar.
Download Parallel Computing: Numerics, Applications, And Trends
The use of parallel programming and architectures is essential for simulating and solving problems in modern computational practice. There has been rapid progress in microprocessor architecture, interconnection technology and software devel- ment, which are in? However, in order to make these bene? The contributions to this book are focused on topics most concerned in the trends of today's parallel computing. These range from parallel algorithmics, progr- ming, tools, network computing to future parallel computing.
Particular attention is paid to parallel numerics: linear algebra, differential equations, numerical integ- tion, number theory and their applications in computer simulations, which together form the kernel of the monograph. We expect that the book will be of interest to scientists working on parallel computing, doctoral students, teachers, engineers and mathematicians dealing with numerical applications and computer simulations of natural phenomena. Passar bra ihop. Body Sensors and Electrocardiography Roman Trobec. The effort to quantify the potential for performance increases by means of parallelization draws from a tradition of study that traces its roots to the work of Gene Amdahl in the s.
Some 20 years later, John Gustafson reconsidered Amdahl's findings, modifying those original conclusions. Taken together, these characterizations of the potential performance impacts of parallelizing software form a canonical statement of theory, with which everyone associated with software development should be familiar.
This paper provides an overview of Amdahl's Law and Gustafson's Trend, placing them in the context of current development considerations. This discussion is intended as a strategic resource for software makers and others concerned with the future of software performance in the multi-core age. In order to illuminate software optimization as the means of taking advantage of hardware performance, it is useful to characterize advances in that hardware performance in three broad categories:.
The above list suggests that, of the factors that will increase native hardware performance going forward, developers should be concerned primarily with increased parallelism and support for specific architectural improvements such as new instruction sets. Multi-threading can add significantly to the complexity, time requirements, and cost of the software development process, and so a balance must be struck between the needs of planning ahead and meeting near-term budget and time-to-market goals.
While it may be superficially attractive simply to ensure that the current generation of software takes good advantage of the hardware it is likely to be run on during its life cycle, that short-term strategy can be a long-term liability. As discussed in the paper Scaling Software Architectures for the Future of Multi-Core Computing, robust threading will become more important as time goes on, as the performance penalties for inadequate threading become more severe. Failure to put good threading practices to work now may cause software makers to perform redundant work later, driving up development costs and making their products less competitive in the marketplace.
As software companies develop a long-term strategy around parallelizing their applications, it is valuable to begin with the theoretical underpinnings of how parallelizable an application is. Next, by considering some key tools and processes that can help them to implement multi-threading in their applications, decision makers can set expectations around near-term and long-term goals.
In , Gene Amdahl's work at IBM began to quantify the inherent difficulties of scaling up computational performance through parallelization. He began by positing that certain "housekeeping" activities are necessary within the execution environment, which tend to be sequential serial in nature and therefore not able to benefit from parallel processing . Because those activities represent a fairly fixed proportion of the overall computational load, Amdahl goes on; parallelizing the load in general is in vain without driving up the accompanying sequential processing rates.
Amdahl's Law, Gustafson's Trend, and the Performance Limits of Parallel Applications
Moreover, he suggests, irregularities in real-world problem sets would degrade parallel performance even further. From the outset, Amdahl shows that increasing the parallelism of the computing environment by some number N e. The two main factors contribute to this limitation are the presence of the inherently serial portion of the computational load the performance of which cannot be improved by parallelization and the overhead associated with parallelization.
That overhead consists of such factors as creating and destroying threads, locking data to prevent multiple threads from manipulating it simultaneously, and synchronizing the computations performed among various threads to obtain a coordinated result. Successive work led to a set of mathematical relationships that became known as Amdahl's Law, which quantifies the theoretical speedup that can be obtained by parallelizing a computational load among a set number of processors.
One way of expressing that relationship is given in Equation 1. A simplified case of Equation 1 helps to illuminate the relationship being shown. Therefore, for example, if one neglects both the serial component of the workload and the parallelization overhead the ideal case , the speedup from splitting a workload from one processor onto two processors produces a speedup of 2x, splitting it onto eight cores would yield a speedup of 8x, etc. Further, viewing Equation 1 as the subtraction of ON from a complex fraction, the complex fraction represents the speedup without being adjusted for threading overhead.
To illustrate the limitations on possible performance gains from parallelizing workloads which was Amdahl's actual intent , consider the effect on Equation 1 when N tends toward infinity and ON tends toward zero. That represents the case where infinitely parallel processing capacity is available, without any overhead from parallelization, and it therefore demonstrates the theoretical upper limit to the performance increase available from parallelization.
Download Parallel Computing: Numerics, Applications, And Trends
Equation 2. A specialized case of Amdahl's Law with infinitely parallel execution resources and zero parallelization overhead. One conclusion made by Amdahl is that " In , John Gustafson, working with E. Barsis, helped to refine Amdahl's model by adjusting some of its underlying assumptions to more accurately reflect the course of his work at Sandia National Laboratories.
Since image rendering is to a large extent inherently parallel in nature independent rendering of many blocks of pixels simultaneously, for example , that dramatic increase in processing requirements represents an equally dramatic change in the ratio of parallel-to-serial tasks in the computational load. Put simply, as compute resources increased, the problem size also increased, and the inherently serial portion became much smaller as a proportion of the overall problem.
Recommended for you
Because Amdahl's Law cannot address this relationship, Gustafson modifies Amdahl's work according to the precept based on experimental findings at Sandia that the overall problem size should increase proportionally to the number of processor cores N , while the size of the serial portion of the problem should remain constant as N increases. The result i s shown in Equation 3. In this equation, note first that S represents the serial proportion of the unscaled workload; that is, unlike in Amdahl's Law Equations 1 and 2 , S remains steady in the numerator versus denominator as a quantity of work, rather than as a proportion of the overall work.
That is, while the parallel portion of the workload 1 - S  scales with the number of processor cores in the numerator of the equation, the serial portion S does not. Obviously, Equation 3 can be easily simplified by adding the components of the denominator together, and by doing so as well as eliminating for the moment the effect of parallelization overhead, Gustafson's trend reduces to the relationship shown in Equation 4.
Taking the most extreme case first, according to this simplified version of Gustafson's trend, scaling the number of processor cores toward infinity should result in a speedup that also scales toward infinity. Of course, infinite numbers of cores are not directly relevant to real-world implementations, but this relationship is instructive as a comparison with Amdahl's Law.
To see more clearly what the effect of increasing the number of cores on a specific workload might be, consider a computational load that is 10 percent serial, where the serial portion remains a fixed size and the parallel portion increases in size proportionally to the number of processor cores, as called for in Gustafson's Trend.
Table 2 shows the projected result as the number of processor cores applied to the theoretical problem is increased. Table 2. Gustafson's Trend applied to a hypothetical problem being scaled to various numbers of processors. Clearly, these calculations show that the performance result continues to scale upward as more processor cores are applied to the computational load.
It's also worth noting that the per-core efficiency trends downward as additional cores are added, although the data in Table 2 shows the decrease in per-core efficiency between the two-core case and the four-core case to be greater than the entire decrease between four cores and cores. On the other hand, this relationship does not take parallelization overhead into account, which obviously increases dramatically as the number of threads and therefore the complexity of the associated thread management increases.
Both Amdahl and Gustafson focus on theoretical performance scaling in the ideal case, rather than on the confounding factors that inherently limit scalability represented as ON in Equations 1 and 3. While it is beyond the scope of this paper to examine those overheads in depth, brief consideration of them gives the context necessary to consider how the theoretical discussion above relates to the real world.
To begin, it is important to recognize that the overhead from a given number of threads is not a set quantity, but rather a reflection of the efficiency with which threading has been applied to a given piece of software though it can never be equal to zero. Once threading has been introduced into the application, the tuning process must identify bottlenecks that represent threading overhead; broadly speaking, most elements of threading overhead fall into the following categories: . As the number of processor cores available to the workload increases, so must the number of threads.