### Performance Analysis

posted Oct 20, 2013, 10:52 PM by Anupinder Singh   [ updated Mar 3, 2014, 1:57 AM by Anupinder Singh ]
< Previous-What is an Algorithm                                                                                                                                                                                                                              Next - Asymptotic Notations >

Performance analysis of an algorithm depends upon two factors i.e. amount of memory used and amount of compute time consumed on any CPU. Formally they are notified as complexities in terms of:
• Space Complexity.
• Time Complexity.

Space Complexity of an algorithm is the amount of memory it needs to run to completion i.e. from start of execution to its termination. Space need by any algorithm is the sum of following components:

1. Fixed Component: This is independent of the characteristics of the inputs and outputs. This part includes: Instruction Space, Space of simple variables, fixed size component variables, and  constants variables.
2. Variable Component: This consist of the space needed by component variables whose size is dependent on the particular problems instances(Inputs/Outputs) being solved, the space needed by referenced variables and the recursion stack space is one of the most prominent components. Also this included the data structure components like Linked list, heap, trees, graphs etc.

Therefore the total space requirement of any algorithm 'A' can be provided as

Space(A)  = Fixed Components(A) + Variable Components(A)

Among both fixed and variable component the variable part is important to be determined accurately, so that the actual space requirement can be identified for an algorithm 'A'.  To identify the space complexity of any algorithm following steps can be followed:

1. Determine the variables which are instantiated by some default values.
2. Determine which instance characteristics should be used to measure the space requirement and this is will be problem specific.
3. Generally the choices are limited to quantities related to the number and magnitudes of the inputs to and outputs from the algorithms.
4. Sometimes more complex measures of the interrelationships among the data items can used.

Example: Space Complexity

`Algorithm Sum(number,size)\\ procedure will produce sum of all numbers provided in 'number' list`
`{`
`    ``    ``result=0.0;`
`    ``    ``for ``count = 1 to size do                    \\will repeat from 1,2,3,4,....size times`
`    ``    ``    ``    ``result= result + number[count];`
`    ``    ``return result;`
`}`

In above example, when calculating the space complexity we will be looking for both fixed and variable components. here we have

Fixed components
as 'result','count' and 'size' variable there for total space required is three(3) words.

Variable components
is characterized as the value stored in 'size' variable (suppose value store in variable 'size 'is 'n'). because this will decide the size of 'number' list and will also drive the for loop. therefore if the space used by size is one word then the total space required by 'number' variable will be 'n'(value stored in variable 'size').

therefore the space complexity can be written as Space(Sum) = 3 + n;

Time Complexity of an algorithm(basically when converted to program) is the amount of computer time it needs to run to completion. The time taken by a program is the sum of the compile time and the run/execution time . The compile time is independent of the instance(problem specific) characteristics. following factors effect the time complexity:
1. Characteristics of compiler used to compile the program.
2. Computer Machine on which the program is executed and physically clocked.
3. Multiuser execution system.
4. Number of program steps.
Therefore the again the time complexity consist of two components fixed(factor 1 only) and variable/instance(factor 2,3 & 4),  so for any algorithm 'A' it is provided as:

Time(A) = Fixed Time(A) + Instance Time(A)

Here the number of steps is the most prominent instance characteristics and The number of steps any program statement is assigned depends on the kind of statement like
• comments count as zero steps,
• an assignment statement which does not involve any calls to other algorithm is counted as one step,
• for iterative statements we consider the steps count only for the control part of the statement etc.
Therefore to calculate total number program of program steps we use following procedure. For this we build a table in which we list the total number of steps contributed by each statement. This is often arrived at by first determining the number of steps per execution of the statement and the frequency of each statement executed. This procedure is explained using an example.

Example
: Time Complexity

 ` Statement` ` Steps per execution` ` Frequency` ` Total Steps` ` Algorithm Sum(number,size)` ` 0` ` -` `0 ` ` {` ` 0` ` -` `0` ` ``        result=0.0;` ` 1` ` 1` `1` `         for count = 1 to size do` ` 1` ` size+1` `size + 1` `                 result= result + number[count];` ` 1` ` size` `size` `         return result;` ` 1` ` 1` `1` ` }` ` 0` ` -` `0` ` Total` ` ` ` ` `2size + 3`

In above example if you analyze carefully frequency of "`for count = 1 to size do`" it is 'size +1' this is because the statement will be executed one time more die to condition check for false situation of condition provided in for statement. Now once the total steps are calculated they will resemble the instance characteristics in time complexity of algorithm. Also the repeated compile time of an algorithm will also be constant every time we compile the same set of instructions so we can consider this time as constant 'C'. Therefore the time complexity can be expressed as: Time(Sum) = C + (2size +3)

So in this way both the Space complexity and Time complexity can be calculated. Combination of both complexity comprises the Performance analysis of any algorithm and can not be used independently. Both these complexities also helps in defining parameters on basis of which we optimize algorithms.

< Previous-What is an Algorithm                                                                                                                                                                                                                              Next - Asymptotic Notations >