|
|
| Line 1: |
Line 1: |
| {{Use dmy dates|date=June 2013}}
| | I would like to introduce myself to you, I am Jayson Simcox but I don't like when individuals use my full title. She is truly fond of caving but she doesn't have the time lately. Office supervising is where her main earnings comes from. I've always loved living in Kentucky but now I'm contemplating other options.<br><br>Have a look at my weblog :: [http://Www.huboston.com/groups/tips-to-become-an-expert-on-organic-gardening/ are psychics real] |
| In [[computer science]], '''algorithmic efficiency''' is used to describe those properties of an [[algorithm]] which relate to the amount of [[Computational resource|resources]] used by the algorithm. An algorithm must be [[Analysis of algorithms|analysed]] to determine its resource usage. Algorithmic efficiency can be thought of as analogous to engineering [[productivity]] for a repeating or continuous process.
| |
| | |
| For maximum efficiency we wish to minimize resource usage. However, the various resources (e.g. time, space) can not be compared directly, so which of two algorithms is considered to be more efficient often depends on which measure of efficiency is being considered as the most important, e.g. is the requirement for high speed, or for minimum memory usage, or for some other measure?
| |
| | |
| :''Note that this article is '''not''' about optimization, which is discussed in [[program optimization]], [[optimizing compiler]], [[loop optimization]], [[object code optimizer]], etc. The term 'optimization' is itself misleading, since all that can generally be done is an 'improvement'.''
| |
| | |
| ==Background==
| |
| The importance of efficiency with respect to time was emphasised by [[Ada Lovelace]] in 1843 as applying to [[Charles Babbage]]'s mechanical analytical engine:
| |
| <blockquote>"In almost every computation a great variety of arrangements for the succession of the processes is possible, and various considerations must influence the selections amongst them for the purposes of a calculating engine. One essential object is to choose that arrangement which shall tend to reduce to a minimum the time necessary for completing the calculation"<ref>{{
| |
| Citation
| |
| | last1 = Green | first1 = Christopher
| |
| | title = Classics in the History of Psychology
| |
| | url = http://psychclassics.yorku.ca/Lovelace/lovelace.htm
| |
| | accessdate = 19 May 2013
| |
| }}</ref></blockquote>
| |
| | |
| Early electronic computers were severely limited both by the speed of operations and the amount of memory available. In some cases it was realised that there was a [[space–time tradeoff]], whereby a task could be handled either by using a fast algorithm which used quite a lot of working memory, or by using a slower algorithm which used very little working memory. The engineering tradeoff was then to use the fastest algorithm which would fit in the available memory.
| |
| | |
| Modern computers are very much faster than the early computers, and have a much larger amount of memory available (Gigabytes instead of Kilobytes). Nevertheless, [[Donald Knuth]] emphasised that efficiency is still an important consideration:
| |
| | |
| <blockquote> "In established engineering disciplines a 12% improvement, easily obtained, is never considered marginal and I believe the same viewpoint should prevail in software engineering"<ref name="Knuth1974">{{
| |
| Citation
| |
| | last1 = Knuth | first1 = Donald
| |
| | title = Structured Programming with go-to Statements
| |
| | publisher = ACM
| |
| | journal = Computing Surveys
| |
| | volume = 6
| |
| | issue = 4
| |
| | year = 1974
| |
| | url = http://pplab.snu.ac.kr/courses/adv_pl05/papers/p261-knuth.pdf
| |
| | accessdate = 19 May 2013
| |
| }}</ref></blockquote>
| |
| | |
| ==Overview==
| |
| An algorithm is considered efficient if its resource consumption is at or below some acceptable level. Roughly speaking, 'acceptable' means: will it run in a reasonable amount of time on an available computer. Since the 1950s computers have seen dramatic increases in both the available computational power and in the available amount of memory, so current acceptable levels would have been unacceptable even 10 years ago.
| |
| | |
| Computer manufacturers frequently bring out new models, often with higher [[Computer performance|performance]]. Software costs can be quite high, so in some cases the simplest and cheapest way of getting higher performance might be to just buy a faster computer, provided it is [[Backward compatibility|compatible]] with an existing computer.
| |
| | |
| There are many ways in which the resources used by an algorithm can be measured: the two most common measures are speed and memory usage; other measures could include transmission speed, temporary disk usage, long-term disk usage, power consumption, [[total cost of ownership]], response time to external stimuli, etc. Many of these measures depend on the size of the input to the algorithm (i.e. the amount of data to be processed); they might also depend on the way in which the data is arranged (e.g. some sorting algorithms perform poorly on data which is already sorted, or which is sorted in reverse order).
| |
| | |
| In practice, there are other factors which can affect the efficiency of an algorithm, such as requirements for accuracy and/or reliability. As detailed below, the way in which an algorithm is implemented can also have a significant effect on actual efficiency, though many aspects of this relate to optimization issues.
| |
| | |
| ===Theoretical analysis===
| |
| In the theoretical analysis of algorithms, the normal practice is to estimate their complexity in the asymptotic sense, i.e. use [[Big O notation]] to represent the complexity of an algorithm as a function of the size of the input '''n'''. This is generally sufficiently accurate when '''n''' is large, but may be misleading for small values of '''n''' (e.g. bubble sort may be faster than quicksort when only a few items are to be sorted).
| |
| | |
| Some examples of Big O notation include:
| |
| | |
| {| class="wikitable"
| |
| |-
| |
| !Notation !! Name !! Examples
| |
| |-
| |
| |<math>O(1)\,</math> || [[Constant time|constant]] || Determining if a number is even or odd; Using a constant-size [[lookup table]]; Using a suitable [[hash function]] for looking up an item.
| |
| |-
| |
| |<math>O(\log n)\,</math> || [[Logarithmic time|logarithmic]] || Finding an item in a sorted array with a [[Binary search algorithm|binary search]] or a balanced search [[Tree data structure|tree]] as well as all operations in a [[Binomial heap]].
| |
| |-
| |
| |<math>O(n)\,</math> || [[linear time|linear]] || Finding an item in an unsorted list or a malformed tree (worst case) or in an unsorted array; Adding two ''n''-bit integers by [[Ripple carry adder|ripple carry]].
| |
| |-
| |
| |<math>O(n\log n)\,</math> || [[Linearithmic time|linearithmic]], loglinear, or quasilinear || Performing a [[Fast Fourier transform]]; [[heapsort]], [[quicksort]] (best and average case), or [[merge sort]]
| |
| |-
| |
| |<math>O(n^2)\,</math> || [[quadratic time|quadratic]] || Multiplying two ''n''-digit numbers by a simple algorithm; [[bubble sort]] (worst case or naive implementation), [[Shell sort]], quicksort (worst case), [[selection sort]] or [[insertion sort]]
| |
| |-
| |
| |<math>O(c^n),\;c>1</math> || [[exponential time|exponential]] || Finding the (exact) solution to the [[travelling salesman problem]] using [[dynamic programming]]; determining if two logical statements are equivalent using [[brute-force search]]
| |
| |}
| |
| | |
| ===Benchmarking: measuring performance===
| |
| For new versions of software or to provide comparisons with competitive systems, [[Benchmark (computing)|benchmark]]s are sometimes used, which assist with gauging an algorithms relative performance. If a new [[Sorting algorithm|sort]] algorithm is produced for example it can be compared with its predecessors to ensure that at least it is efficient as before with known data—taking into consideration any functional improvements. Benchmarks can be used by customers when comparing various products from alternative suppliers to estimate which product will best suit their specific requirements in terms of functionality and performance. For example in the [[Mainframe computer|mainframe]] world certain proprietary [[Mainframe sort merge|sort]] products from independent software companies such as [[Syncsort]] compete with products from the major suppliers such as [[IBM]] for speed.
| |
| | |
| Some benchmarks provide opportunities for producing an analysis comparing the relative speed of various compiled and interpreted languages for example<ref name="fourmilab.ch" /><ref>{{cite web|url=http://www.roylongbottom.org.uk/whetstone.htm#anchorPC2 |title=Whetstone Benchmark History |publisher=Roylongbottom.org.uk |date= |accessdate=2011-12-14}}</ref>
| |
| and ''The Computer Language Benchmarks Game''<ref>{{cite web|url=http://benchmarksgame.alioth.debian.org/ |title=The Computer Language Benchmarks Game |publisher=benchmarksgame.alioth.debian.org |date= |accessdate=2011-12-14}}</ref> compares the performance of implementations of typical programming problems in several programming languages.
| |
| | |
| (Even creating "[[do it yourself]]" benchmarks to get at least some appreciation of the relative performance of different programming languages, using a variety of user specified criteria, is quite simple to produce as this "Nine language Performance roundup" by Christopher W. Cowell-Shah demonstrates by example)<ref>http://www.osnews.com/story/5602</ref>
| |
| | |
| ===Implementation issues===
| |
| Implementation issues can also have an effect on actual efficiency, such as the choice of programming language, or the way in which the algorithm is actually coded, or the choice of a [[compiler]] for a particular language, or the compilation options used, or even the operating system being used. In some cases a language implemented by an [[Interpreter (computing)|interpreter]] may be much slower than a language implemented by a compiler.<ref name="fourmilab.ch">{{cite web|url=http://www.fourmilab.ch/fourmilog/archives/2005-08/000567.html |title=Floating Point Benchmark: Comparing Languages (Fourmilog: None Dare Call It Reason) |publisher=Fourmilab.ch |date=2005-08-04 |accessdate=2011-12-14}}</ref>
| |
| | |
| There are other factors which may affect time or space issues, but which may be outside of a programmer's control; these include [[data alignment]], [[granularity#Data granularity|data granuality]], [[garbage collection (computer science)|garbage collection]], [[instruction-level parallelism]], and subroutine calls.<ref name="steele1997">Guy Lewis Steele, Jr. "Debunking the 'Expensive Procedure Call' Myth, or, Procedure Call Implementations Considered Harmful, or, Lambda: The Ultimate GOTO". MIT AI Lab. AI Lab Memo AIM-443. October 1977.[http://dspace.mit.edu/handle/1721.1/5753]</ref>
| |
| | |
| Some processors have capabilities for [[vector processor|vector processing]], which allow a single instruction to operate on multiple operands; it may or may not be easy for a programmer or compiler to use these capabilities. Algorithms designed for sequential processing may need to be completely redesigned to make use of [[parallel processing]].
| |
| | |
| Another problem which can arise with compatible processors is that they may implement an instruction in different ways, so that instructions which are relatively fast on some models may be relatively slow on other models; this can make life difficult for an optimizing compiler.
| |
| | |
| ==Measures of resource usage==
| |
| | |
| Measures are normally expressed as a function of the size of the input '''n'''.
| |
| | |
| The two most common measures are:
| |
| * ''Time'': how long does the algorithm take to complete.
| |
| * ''Space'': how much working memory (typically RAM) is needed by the algorithm. This has two aspects: the amount of memory needed by the code, and the amount of memory needed for the data on which the code operates.
| |
| | |
| For computers whose power is supplied by a battery (e.g. [[laptop]]s), or for very long/large calculations (e.g. [[supercomputer]]s), other measures of interest are:
| |
| * ''Direct power consumption'': power needed directly to operate the computer.
| |
| * ''Indirect power consumption'': power needed for cooling, lighting, etc.
| |
| | |
| In some cases other less common measures may also be relevant:
| |
| * ''Transmission size'': bandwidth could be a limiting factor. [[Data compression]] can be used to reduce the amount of data to be transmitted. Displaying a picture or image (e.g. [[:File:Google.png|Google logo]]) can result in transmitting tens of thousands of bytes (48K in this case) compared with transmitting six bytes for the text "Google".
| |
| * ''External space'': space needed on a disk or other external memory device; this could be for temporary storage while the algorithm is being carried out, or it could be long-term storage needed to be carried forward for future reference.
| |
| * ''Response time'': this is particularly relevant in a real-time application when the computer system must respond quickly to some external event.
| |
| * ''Total cost of ownership'': particularly if a computer is dedicated to one particular algorithm.
| |
| | |
| ===Time===
| |
| | |
| ====Theory====
| |
| | |
| [[Analysis of algorithms|Analyse]] the algorithm, typically using [[time complexity]] analysis to get an estimate of the running time as a function as the size of the input data. The result is normally expressed using [[Big O notation]]. This is useful for comparing algorithms, especially when a large amount of data is to processed. More detailed estimates are needed for algorithm comparison when the amount of data is small (though in this situation time is less likely to be a problem anyway). Algorithms which include parallel processing may be more difficult to analyse.
| |
| | |
| ====Practice====
| |
| | |
| Use a benchmark to time the use of an algorithm. Many programming languages have an available function which provides CPU time usage. For long-running algorithms the elapsed time could also be of interest. Results should generally be averaged over several tests.
| |
| | |
| This sort of test can be very sensitive to hardware configuration and the possibility of other programs or tasks running at the same time in a [[multi-processing]] and [[multi-programming]] environment.
| |
| | |
| This sort of test also depends heavily on the selection of a particular programming language, compiler, and compiler options, so algorithms being compared must all be implemented under the same conditions.
| |
| | |
| ===Space===
| |
| This section is concerned with the use of main memory (often RAM) while the algorithm is being carried out. As for time analysis above, [[Analysis of algorithms|analyse]] the algorithm, typically using [[DSPACE|space complexity]] analysis to get an estimate of the run-time memory needed as a function as the size of the input data. The result is normally expressed using [[Big O notation]].
| |
| | |
| There are up to four aspects of memory usage to consider:
| |
| * The amount of memory needed to hold the code for the algorithm.
| |
| * The amount of memory needed for the input data.
| |
| * The amount of memory needed for any output data (some algorithms, such as sorting, often just rearrange the input data and don't need any space for output data).
| |
| * The amount of memory needed as working space during the calculation (this includes both named variables and any stack space needed by routines called during the calculation; this stack space can be significant for algorithms which use [[Recursion (computer science)|recursive]] techniques).
| |
| | |
| Early electronic computers, and early home computers, had relatively small amounts of working memory. E.g. the 1949 [[Electronic Delay Storage Automatic Calculator|EDSAC]] had a maximum working memory of 1024 17-bit words, while the 1980 Sinclair [[ZX80]] came initially with 1024 8-bit bytes of working memory.
| |
| | |
| Current computers can have relatively large amounts of memory (possibly Gigabytes), so having to squeeze an algorithm into a confined amount of memory is much less of a problem than it used to be. But the presence of three different categories of memory can be significant:
| |
| * Cache memory (often static RAM) - this operates at speeds comparable with the CPU.
| |
| * Main physical memory (often dynamic RAM) - this operates somewhat slower than the CPU.
| |
| * Virtual memory (often on disk) - this gives the illusion of lots of memory, and operates thousands of times slower than RAM.
| |
| | |
| An algorithm whose memory needs will fit in cache memory will be much faster than an algorithm which fits in main memory, which in turn will be very much faster than an algorithm which has to resort to virtual memory. To further complicate the issue, some systems have up to three levels of cache memory, with varying effective speeds. Different systems will have different amounts of these various types of memory, so the effect of algorithm memory needs can vary greatly from one system to another.
| |
| | |
| In the early days of electronic computing, if an algorithm and its data wouldn't fit in main memory then the algorithm couldn't be used. Nowadays the use of virtual memory appears to provide lots of memory, but at the cost of performance. If an algorithm and its data will fit in cache memory, then very high speed can be obtained; in this case minimising space will also help minimise time. An algorithm which will not fit completely in cache memory but which exhibits [[locality of reference]] may perform reasonably well.
| |
| | |
| ==Examples of efficient algorithms==
| |
| | |
| * [[quicksort]] First known sorting algorithm with speed of order <math>O(n\log n)\,</math>.
| |
| * [[heapsort]] Another fast sorting algorithm.
| |
| * [[Binary search algorithm|binary search]] Searching an ordered table.
| |
| * [[Boyer–Moore string search algorithm]] Finding a string within another string.
| |
| | |
| ==Criticism of the current state of programming==
| |
| * [[David May (computer scientist)|David May]] FRS a [[United Kingdom|British]] [[computer scientist]] and currently [[Professor]] of [[Computer Science]] at [[University of Bristol]] and founder and [[Chief technical officer|CTO]] of [[XMOS|XMOS Semiconductor]], believes one of the problems is that there is a reliance on [[Moore's law]] to solve inefficiencies. He has advanced an 'alternative' to Moore's law ([[May's law]]) stated as follows:<ref>http://www.cs.bris.ac.uk/~dave/iee.pdf</ref> <blockquote>Software efficiency halves every 18 months, compensating Moore's Law</blockquote> He goes on to state <blockquote>In ubiquitous systems, halving the instructions executed can double the battery life and big data sets bring big opportunities for better software and algorithms: Reducing the number of operations from N x N to N x log(N) has a dramatic effect when N is large... for N = 30 billion, this change is as good as 50 years of technology improvements</blockquote>
| |
| | |
| * Software author Adam N. Rosenburg in his blog "''The failure of the Digital computer''", has described the current state of programming as nearing the "Software event horizon", (alluding to the fictitious "''shoe event horizon''" described by [[Douglas Adams]] in his ''Hitchhiker's Guide to the Galaxy'' book<ref>http://www.the-adam.com/adam/rantrave/computers.htm</ref>). He estimates there has been a 70 dB factor loss of productivity or "99.99999 percent, of its ability to deliver the goods", since the 1980s—"When [[Arthur C. Clarke]] compared the reality of computing in 2001 to the computer [[HAL 9000|HAL]] in his book [[2001: A Space Odyssey]], he pointed out how wonderfully small and powerful computers were but how disappointing computer programming had become".
| |
| * Conrad Weisert gives examples, some of which were published in ACM SIGPLAN (Special Interest Group on Programming Languages) Notices, December 1995 in: "Atrocious Programming Thrives"<ref>{{cite web|url=http://www.idinews.com/atrocious.html |title=Atrocious Programming Thrives |publisher=Idinews.com |date=2003-01-09 |accessdate=2011-12-14}}</ref>
| |
| * [[Marc Andreessen]] co-founder of [[Netscape]] is quoted in "[[Mavericks at Work]]" (ISBN 0060779616) as saying "Five great programmers can completely outperform 1,000 mediocre programmers."[http://www.linkedin.com/news?actionBar=&articleID=590198259&ids=0NdjgSd3wOejkIc3cPej0VczARb3ARczwVcj0VdiMVczcUcP8OejkIc3gTdj0TczAR&aag=true&freq=weekly&trk=eml-tod-b-ttle-96]
| |
| | |
| ==Competitions for the best algorithms==
| |
| The following competitions invite entries for the best algorithms based on some arbitrary criteria decided by the judges:-
| |
| * [[Wired magazine]]<ref>{{cite news| url=http://www.wired.com/magazine/2010/11/mf_algorithmolympics/all/1 | work=Wired | first=Jason | last=Fagone | title=Teen Mathletes Do Battle at Algorithm Olympics | date=2010-11-29}}</ref>
| |
| | |
| ==See also==
| |
| * [[Analysis of algorithms]] - how to determine the resources needed by an algorithm
| |
| * [[Arithmetic coding]]—a form of [[variable-length code|variable-length]] [[entropy encoding]] for efficient data compression
| |
| * [[Associative array]]—a data structure that can be made more efficient using [[Patricia tree]]s or [[Judy array]]s
| |
| * [[Binary search algorithm]]—a simple and efficient technique for searching sorted arrays
| |
| * [[Benchmark (computing)|Benchmark]]—a method for measuring comparative execution times in defined cases
| |
| * [[Best, worst and average case]]—considerations for estimating execution times in three scenarios
| |
| * [[Branch table]]—a technique for reducing instruction path-length, size of [[machine code]], (and often also memory)
| |
| * [[Comparison of programming paradigms]]—paradigm specific performance considerations
| |
| * [[Compiler optimization]]—compiler-derived optimization
| |
| * [[Computational complexity theory]]
| |
| * [[Computer performance]]—computer hardware metrics
| |
| * [[Data compression]]—reducing transmission bandwidth and disk storage
| |
| * [[Database index]]—a data structure that improves the speed of data retrieval operations on a database table
| |
| * [[Entropy encoding]]—encoding data efficiently using frequency of occurrence of strings as a criterion for substitution
| |
| * [[Garbage collection (computer science)|Garbage collection]]—automatic freeing of memory after use
| |
| * [[Green computing]]—a move to implement 'greener' technologies, consuming less resources
| |
| * [[Huffman algorithm]]—an algorithm for efficient data encoding
| |
| * [[Locality of reference]]—for avoidance of [[CPU cache|caching]] delays caused by non-local memory access
| |
| * [[Loop optimization]]
| |
| * [[Memory management]]
| |
| * [[Optimization (computer science)]]
| |
| * [[Profiling (computer programming)|Performance analysis]]—methods of measuring actual performance of an algorithm at run-time
| |
| * [[Real-time computing]]—further examples of time-critical applications
| |
| * [[Run-time analysis]]—estimation of expected run-times and an algorithm's scalability
| |
| * [[Super-threading]]
| |
| * [[Simultaneous multithreading]]
| |
| * [[Speculative execution]] or [[Eager execution]]
| |
| * [[Threaded code]]—similar to virtual method table or branch table
| |
| * [[Virtual method table]]—branch table with dynamically assigned pointers for dispatching
| |
| * [http://msdn.microsoft.com/en-us/library/ff647790.aspx Improving Managed code Performance]—Microsoft MSDN Library
| |
| | |
| ==References==
| |
| {{reflist|colwidth=30em}}
| |
| | |
| ==External links==
| |
| {{wikibooks|Optimizing Code for Speed}}
| |
| * [http://cgjennings.ca/fjs/index.html Animation of the Boyer-Moore algorithm] ([[Java Applet]])
| |
| * [http://www.dailymotion.com/video/xn8cg8_ted-talk-kevin-slavin-how-algorithms-shape-our-world_tech#.UNqz4axdxlM "How algorithms shape our world". ] A [[TED (conference)]] Talk by Kevin Slavin.
| |
| * [http://dx.doi.org/10.1016/j.compedu.2003.07.004 Misconceptions about algorithmic efficiency in high-schools]
| |
| | |
| {{DEFAULTSORT:Algorithmic Efficiency}}
| |
| [[Category:Analysis of algorithms]]
| |
| [[Category:Computer performance]]
| |
| [[Category:Software optimization]]
| |