|
|
| Line 1: |
Line 1: |
| [[Image:AmdahlsLaw.svg|thumb|right|300px|The speedup of a program using multiple processors in parallel computing is limited by the sequential fraction of the program. For example, if 95% of the program can be parallelized, the theoretical maximum speedup using parallel computing would be 20× as shown in the diagram, no matter how many processors are used.]]
| | Today I am sharing a dark experience with you as I am out of this darkness now. Whoa! Google Chrome has crashed was the disaster that struck on me early this morning. My blood flow seemed to stop for a limited minutes. Next I regained my senses and decided to fix Chrome crash.<br><br>Carry out window's program restore. It is important to do this because it removes incorrect changes that have happened inside the program. Some of the errors outcome from inability of your system to create restore point frequently.<br><br>Although this issue affects millions of computer consumers throughout the planet, there is an effortless method to fix it. We see, there's one reason for a slow loading computer, plus that's because the PC cannot read the files it must run. In a nutshell, this merely signifies that when we do anything on Windows, it demands to read up on how to do it. It's traditionally a rather 'dumb' system, that has to have files to tell it to do everything.<br><br>If that does not function you need to try plus repair the problem with a 'registry cleaner'. What occurs on various computers is the fact that their registry database becomes damaged and unable to show a computer where the DLL files that it requires are. Every Windows PC has a central 'registry' database that shops info about all the DLL files on a computer.<br><br>So to fix this, you really should be able to create all registry files non-corrupted again. This might dramatically speed up the loading time of the computer plus allows you to a big number of points on it again. And fixing these files couldn't be easier - we only need to use a tool called a [http://bestregistrycleanerfix.com/regzooka regzooka].<br><br>Software mistakes or hardware mistakes that happen when running Windows and intermittent mistakes are the general factors for a blue screen bodily memory dump. New software or drivers which have been installed or changes in the registry settings are the typical s/w causes. Intermittent mistakes refer to failed system memory/ hard disk or over heated processor plus these too can result the blue screen physical memory dump error.<br><br>The System File Checker (SFC) can enable inside resolving error 1721 as it, by its nature, scans the system files for corruption plus replaces them with their authentic versions. This needs we to have the Windows Installation DVD ROM for continuing.<br><br>What I would recommend is to search on your for registry products. We can do this with a Google search. When you find products, look for ratings and testimonials about the product. Next we can see how others like the product, plus how perfectly it functions. |
| | |
| '''Amdahl's law''', also known as '''Amdahl's argument''',<ref>{{harv|Rodgers|1985|p=226}}</ref> is used to find the maximum expected improvement to an overall system when only part of the system is improved. It is often used in [[parallel computing]] to predict the theoretical maximum [[speedup]] using multiple processors. The law is named after [[Computer architecture|computer architect]] [[Gene Amdahl]], and was presented at the [[American Federation of Information Processing Societies|AFIPS]] Spring Joint Computer Conference in 1967.
| |
| | |
| The speedup of a program using multiple processors in parallel computing is limited by the time needed for the sequential fraction of the program. For example, if a program needs 20 hours using a single processor core, and a particular portion of the program which takes one hour to execute cannot be parallelized, while the remaining 19 hours (95%) of execution time can be parallelized, then regardless of how many processors are devoted to a parallelized execution of this program, the minimum execution time cannot be less than that critical one hour. Hence the speedup is limited to at most 20×.
| |
| | |
| ==Definition ==
| |
| Given:
| |
| * <math>n \in \mathbb{N}</math>, the number of [[thread of execution|threads of execution]],
| |
| * <math>B\in [0, 1]</math>, the fraction of the algorithm that is strictly serial,
| |
| | |
| The time <math>T \left(n \right)</math> an algorithm takes to finish when being executed on <math>n</math> thread(s) of execution corresponds to:
| |
| | |
| <math>T(n) = T(1) \left(B + \frac{1}{n}\left(1 - B\right)\right)</math>
| |
| | |
| | |
| Therefore, the theoretical speedup that can be had by executing a given algorithm on a system capable of executing <math>n</math> threads of execution is:
| |
| | |
| <math>S(n) = \frac{ T\left(1\right)}{T\left(n\right)} = \frac{T\left(1\right)}{T\left(1\right)\left(B + \frac{1}{n}\left(1 - B\right)\right) } = \frac{1}{B + \frac{1}{n}\left(1-B\right)}</math>
| |
| | |
| ==Description==
| |
| Amdahl's law is a model for the relationship between the expected speedup of parallelized implementations of an algorithm relative to the serial algorithm, under the assumption that the problem size remains the same when parallelized. For example, if for a given problem size a parallelized implementation of an algorithm can run 12% of the algorithm's operations arbitrarily quickly (while the remaining 88% of the operations are not parallelizable), Amdahl's law states that the maximum speedup of the parallelized version is {{nowrap|1=1/(1 – 0.12) = 1.136}} times as fast as the non-parallelized implementation.
| |
| | |
| More technically, the law is concerned with the speedup achievable from an improvement to a computation that affects a proportion ''P'' of that computation where the improvement has a speedup of ''S''. (For example, if 30% of the computation may be the subject of a speed up, ''P'' will be 0.3; if the improvement makes the portion affected twice as fast, ''S'' will be 2.) Amdahl's law states that the overall speedup of applying the improvement will be:
| |
| | |
| :<math>\frac{1}{(1 - P) + \frac{P}{S}} = \frac{1}{(1 - 0.3) + \frac{0.3}{2}} = 1.1765</math>
| |
| | |
| To see how this formula was derived, assume that the running time of the old computation was 1, for some unit of time. The running time of the new computation will be the length of time the unimproved fraction takes (which is 1 − ''P''), plus the length of time the improved fraction takes. The length of time for the improved part of the computation is the length of the improved part's former running time divided by the speedup, making the length of time of the improved part ''P''/''S''. The final speedup is computed by dividing the old running time by the new running time, which is what the above formula does.
| |
| | |
| Here's another example. We are given a sequential task which is split into four consecutive parts: P1, P2, P3 and P4 with the percentages of runtime being 11%, 18%, 23% and 48% respectively. Then we are told that P1 is not sped up, so S1 = 1, while P2 is sped up 5×, P3 is sped up 20×, and P4 is sped up 1.6×. By using the formula
| |
| P1/S1 + P2/S2 + P3/S3 + P4/S4, we find the new sequential running time is:
| |
| | |
| :<math>\frac{0.11}{1} + \frac{0.18}{5} + \frac{0.23}{20} + \frac{0.48}{1.6} = 0.4575.</math>
| |
| | |
| or a little less than {{frac|1|2}} the original running time. Using the formula {{nowrap|(P1/S1 + P2/S2 + P3/S3 + P4/S4)<sup>−1</sup>}}, the overall speed boost is 1 / 0.4575 = 2.186, or a little more than double the original speed. Notice how the 20× and 5× speedup don't have much effect on the overall speed when P1 (11%) is not sped up, and P4 (48%) is sped up only 1.6 times.
| |
| | |
| == Parallelization ==
| |
| In the case of parallelization, Amdahl's law states that if ''P'' is the proportion of a program that can be made parallel (i.e., benefit from parallelization), and (1 − ''P'') is the proportion that cannot be parallelized (remains serial), then the maximum speedup that can be achieved by using ''N'' processors is
| |
| | |
| :<math>S(N) = \frac{1}{(1-P) + \frac{P}{N}}</math>.
| |
| | |
| In the limit, as ''N'' tends to [[Extended real number line|infinity]], the maximum speedup tends to 1 / (1 − ''P''). In practice, performance to price ratio falls rapidly as ''N'' is increased once there is even a small component of (1 − ''P'').
| |
| | |
| As an example, if ''P'' is 90%, then (1 − ''P'') is 10%, and the problem can be sped up by a maximum of a factor of 10, no matter how large the value of ''N'' used. For this reason, parallel computing is only useful for either small numbers of [[central processing unit|processor]]s, or problems with very high values of ''P'': so-called [[embarrassingly parallel]] problems. A great part of the craft of [[parallel programming]] consists of attempting to reduce the component (1 – ''P'') to the smallest possible value.
| |
| | |
| ''P'' can be estimated by using the measured speedup (''SU'') on a specific number of processors (''NP'') using
| |
| | |
| :<math>P_\text{estimated} = \frac{\frac{1}{SU} - 1}{\frac{1}{NP} - 1}</math>.
| |
| | |
| ''P'' estimated in this way can then be used in Amdahl's law to predict speedup for a different number of processors.
| |
| | |
| ==Relation to law of diminishing returns==
| |
| Amdahl's law is often conflated with the [[Diminishing returns|law of diminishing returns]], whereas only a special case of applying Amdahl's law demonstrates 'law of diminishing returns'. If one picks optimally (in terms of the achieved speed-up) what to improve, then one will see monotonically decreasing improvements as one improves. If, however, one picks non-optimally, after improving a sub-optimal component and moving on to improve a more optimal component, one can see an increase in return. Note that it is often rational to improve a system in an order that is "non-optimal" in this sense, given that some improvements are more difficult or consuming of development time than others.
| |
| | |
| Amdahl's law does represent the law of diminishing returns if you are considering what sort of return you get by adding more processors to a machine, if you are running a fixed-size computation that will use all available processors to their capacity. Each new processor you add to the system will add less usable power than the previous one. Each time you double the number of processors the speedup ratio will diminish, as the total throughput heads toward the limit of <math>\scriptstyle 1 / (1 \,-\, P)</math>.
| |
| | |
| This analysis neglects other potential bottlenecks such as [[memory bandwidth]] and I/O bandwidth, if they do not scale with the number of processors; however, taking into account such bottlenecks would tend to further demonstrate the diminishing returns of only adding processors.
| |
| | |
| == Speedup in a sequential program ==
| |
| [[Image:Optimizing-different-parts.svg|thumb|400px|Assume that a task has two independent parts, A and B. B takes roughly 25% of the time of the whole computation. By working very hard, one may be able to make this part 5 times faster, but this only reduces the time for the whole computation by a little. In contrast, one may need to perform less work to make part A be twice as fast. This will make the computation much faster than by optimizing part B, even though B's speed-up is greater by ratio, (5× versus 2×).]]
| |
| The maximum speedup in an improved sequential program, where some part was sped up <math>p</math> times is limited by inequality
| |
| | |
| :<math>\text{maximum speedup } \le \frac{p}{1 + f \cdot (p - 1)}</math>
| |
| | |
| where <math>\scriptstyle f</math> (<math>\scriptstyle 0 \;<\; f \;<\; 1</math>) is the fraction of time (before the improvement) spent in the part that was not improved. For example (see picture on right):
| |
| | |
| *If part B is made five times faster (<math>\scriptstyle p \;=\; 5</math>), <math>\scriptstyle t_A \;=\; 3</math>, <math>\scriptstyle t_B \;=\; 1</math>, and <math>\scriptstyle f \;=\; t_A / (t_A \,+\, t_B) \;=\; 0.75</math>, then
| |
| *:<math>\text{maximum speedup } \le \frac{5}{1 + 0.75 \cdot (5 - 1)} = 1.25</math>
| |
| *If part A is made to run twice as fast (<math>\scriptstyle p \;=\; 2</math>), <math>\scriptstyle t_B \;=\; 1</math>, <math>\scriptstyle t_A \;=\; 3</math>, and <math>\scriptstyle f \;=\; t_B / (t_A \,+\, t_B) \;=\; 0.25</math>, then
| |
| *:<math>\text{maximum speedup } \le \frac{2}{1 + 0.25 \cdot (2 - 1)} = 1.60</math>
| |
| | |
| Therefore, making A twice as fast is better than making B five times faster. The percentage improvement in speed can be calculated as
| |
| | |
| :<math>\text{percentage improvement} = \left(1 - \frac{1}{\text{speedup factor}}\right) \cdot 100</math>
| |
| | |
| *Improving part A by a factor of two will increase overall program speed by a factor of 1.6, which makes it 37.5% faster than the original computation.
| |
| *However, improving part B by a factor of five, which presumably requires more effort, will only achieve an overall speedup factor of 1.25, which makes it 20% faster.
| |
| | |
| == Relation to Gustafson's Law ==
| |
| {{Unreferenced section|date=August 2010}}
| |
| | |
| [[John L. Gustafson]] pointed out in 1988 what is now known as [[Gustafson's Law]]: people typically are not interested in solving a fixed problem in the shortest possible period of time, as Amdahl's Law describes, but rather in solving the largest possible problem (e.g., the most accurate possible approximation) in a fixed "reasonable" amount of time. If the non-parallelizable portion of the problem is fixed, or grows very slowly with problem size (e.g., [[Big O notation|O]](log ''n'')), then additional processors can increase the possible problem size without limit.
| |
| | |
| == See also ==
| |
| | |
| * [[Amdahl Corporation]]
| |
| * [[Karp–Flatt metric]]
| |
| * [[Moore's law]]
| |
| * [[Gustafson's law]]
| |
| | |
| ==Notes==
| |
| {{Reflist}}
| |
| | |
| ==References==
| |
| * {{Cite journal | first = Gene M. | last = Amdahl | url = http://www-inst.eecs.berkeley.edu/~n252/paper/Amdahl.pdf|doi=10.1145/1465482.1465560 | title = Validity of the Single Processor Approach to Achieving Large-Scale Computing Capabilities | journal = AFIPS Conference Proceedings | issue = 30 | pages = 483–485 | year = 1967|ref=harv}}
| |
| * {{Cite journal | last = Rodgers | first = David P. |date=June 1985 | url = http://portal.acm.org/citation.cfm?id=327215 | title = Improvements in multiprocessor system design | journal = ACM SIGARCH Computer Architecture News archive | volume = 13 | issue = 3 | pages = 225–231 | issn = 0163-5964 | publisher = [[Association for Computing Machinery|ACM]] | location = New York, NY, USA | doi = 10.1145/327070.327215|ref=harv|isbn=0-8186-0634-7}}
| |
| | |
| ==External links==
| |
| {{Commons category|Amdahl's law}}
| |
| * [http://www.futurechips.org/thoughts-for-researchers/parallel-programming-gene-amdahl-said.html Cases where Amdahl's law is inapplicable]
| |
| * [http://purl.umn.edu/104341 Oral history interview with Gene M. Amdahl] [[Charles Babbage Institute]], University of Minnesota. Amdahl discusses his graduate work at the University of Wisconsin and his design of [[Wisconsin Integrally Synchronized Computer|WISC]]. Discusses his role in the design of several computers for IBM including the [[IBM Stretch|STRETCH]], [[IBM 701]], and [[IBM 704]]. He discusses his work with [[Nathaniel Rochester (computer scientist)|Nathaniel Rochester]] and IBM's management of the design process. Mentions work with [[TRW Inc.|Ramo-Wooldridge]], [[Aeronutronic]], and [[Computer Sciences Corporation]]
| |
| * [http://www.scl.ameslab.gov/Publications/Gus/AmdahlsLaw/Amdahls.html Reevaluating Amdahl's Law]
| |
| * [http://www.julianbrowne.com/article/viewer/amdahls-law A simple interactive Amdahl's Law calculator]
| |
| * [http://demonstrations.wolfram.com/AmdahlsLaw/ "Amdahl's Law"] by Joel F. Klein, [[Wolfram Demonstrations Project]], 2007.
| |
| * [http://www.cs.wisc.edu/multifacet/amdahl/ Amdahl's Law in the Multicore Era]
| |
| * [http://www.gordon-taft.net/Amdahl_Law.html Amdahl's Law explanation]
| |
| * [http://www.cilk.com/multicore-blog/bid/5365/What-the-is-Parallelism-Anyhow Blog Post: "What the $#@! is Parallelism, Anyhow?"]
| |
| * [http://www.multicorepacketprocessing.com/how-should-amdahl-law-drive-the-redesigns-of-socket-system-calls-for-an-os-on-a-multicore-cpu Amdahl's Law applied to OS system calls on multicore CPU]
| |
| {{Parallel Computing}}
| |
| | |
| {{DEFAULTSORT:Amdahl's Law}}
| |
| [[Category:Parallel computing]]
| |
| [[Category:Programming rules of thumb]]
| |
Today I am sharing a dark experience with you as I am out of this darkness now. Whoa! Google Chrome has crashed was the disaster that struck on me early this morning. My blood flow seemed to stop for a limited minutes. Next I regained my senses and decided to fix Chrome crash.
Carry out window's program restore. It is important to do this because it removes incorrect changes that have happened inside the program. Some of the errors outcome from inability of your system to create restore point frequently.
Although this issue affects millions of computer consumers throughout the planet, there is an effortless method to fix it. We see, there's one reason for a slow loading computer, plus that's because the PC cannot read the files it must run. In a nutshell, this merely signifies that when we do anything on Windows, it demands to read up on how to do it. It's traditionally a rather 'dumb' system, that has to have files to tell it to do everything.
If that does not function you need to try plus repair the problem with a 'registry cleaner'. What occurs on various computers is the fact that their registry database becomes damaged and unable to show a computer where the DLL files that it requires are. Every Windows PC has a central 'registry' database that shops info about all the DLL files on a computer.
So to fix this, you really should be able to create all registry files non-corrupted again. This might dramatically speed up the loading time of the computer plus allows you to a big number of points on it again. And fixing these files couldn't be easier - we only need to use a tool called a regzooka.
Software mistakes or hardware mistakes that happen when running Windows and intermittent mistakes are the general factors for a blue screen bodily memory dump. New software or drivers which have been installed or changes in the registry settings are the typical s/w causes. Intermittent mistakes refer to failed system memory/ hard disk or over heated processor plus these too can result the blue screen physical memory dump error.
The System File Checker (SFC) can enable inside resolving error 1721 as it, by its nature, scans the system files for corruption plus replaces them with their authentic versions. This needs we to have the Windows Installation DVD ROM for continuing.
What I would recommend is to search on your for registry products. We can do this with a Google search. When you find products, look for ratings and testimonials about the product. Next we can see how others like the product, plus how perfectly it functions.