Programming Language Implementation

Transcription

1 A Practical Introduction to Programming Language Implementation 2014: Week 12 Optimisation College of Information Science and Engineering Ritsumeikan University 1

2 review of last week s topics why primitives are not scalable operating system calls platform library calls dynamic lookup and calling of functions by name foreign function interfaces without a declaration some functions cannot be called representation of primitive types representation of function signature calling a function safely conversion of data representations across function call boundary project: improve numbers/identifiers in your language 2

3 this week s topics the purpose of optimisation faster programs smaller programs compile-time techniques partial evaluation constant folding run-time techniques cached variable lookup project add constant folding to your language 3

4 purpose of optimisation op ti mize verb [ trans. ] make the best or most effective use of (a situation, opportunity, or resource) : to optimise viewing conditions the microscope should be correctly adjusted. Computing : rearrange or rewrite data to improve efficiency of retrieval or processing. DERIVATIVES optimisation noun optimiser noun ORIGIN early 19th cent.: from Latin optimus best + -IZE. 4

5 purpose of optimisation when running a program, where does the time go? executing instructions waiting for data how can we make a program faster? reduce the number of instructions executed read (or write) less data sometimes these two are related eliminating instructions eliminates the need to read operands and write results eliminating data eliminates the need for instructions that process that data we can also make the program smaller uses fewer resources spends less time waiting for instructions 5

6 optimisation techniques inter-procedural optimisations consider the program as a whole; e.g: global optimisations consider an entire function at a time; e.g: local optimisations consider a single statement/expression with linear control flow peephole optimisations of machine code consider sequences of generated machine instructions machine code optimisations consider the binary during linking and loading run-time optimisations consider the dynamic behaviour of the program 6

7 inter-procedural optimisations consider the whole program, transform it for performance/size e.g: passing arguments in registers (instead of on the stack) to static (local, unexported) functions only e.g: keep static (unexported) global variables in registers e.g: inline simple functions into their caller(s) int foo(int a, int b) { return a + b;... int p = foo(x, y); int p = x + y; 7

8 global optimisations consider an entire function e.g: keep local variables in registers (instead of in the stack frame) e.g: loop-invariant code motion out of loops int j =?, n = 0;... for (i = 0; i < 100; ++i) n += array[i + j * 2]; int tmp = j * 2; for (i = 0; i < 100; ++i) n += array[i + tmp]; 8

9 e.g: dead code elimination more global optimisations if (1) dosomething(); else dontsomething(); dosomething(); e.g: redundant store elimination int a = 1;... /* no references to a in this code */ a = 2;... /* no references to a in this code */ a = 3; int a = 3; e.g: variables that are never read can be deleted entirely but not any initialising expressions that have side-effects 9

10 local optimisations consider single expressions or sequences of linear control flow e.g: common sub-expression elimination int ab, h;... h = sqrt(ab * ab + ab * ab); int tmp = ab * ab; h = sqrt(tmp + tmp); 10

11 more local optimisations e.g: strength reduction of operators /* cycle counts for Intel Core 2 (Pentium 4) */ /* assuming that i is in a register and is */ /* a 32-bit signed integer... */ i = i / 2; /* 40 (80) cycles */ i = i >> 1; /* 1 (2) cycle(s) */ i *= 5; i += i << 2; etc... Instruction mul 11 add 1 sal 2 Core 2 Cycles 11

12 peephole optimisation consider sequences of generated machine instructions e.g: replace instruction sequences with shorter/faster equivalents usually by pattern matching; e.g., given an optimiser rule : movl X, ra; movl Y, rb; add rb, ra movl X, ra; addl Y, ra int add(int a, int b) { return a + b; movl 4(%esp), %eax movl 8(%esp), %ecx addl %ecx, %eax ret movl 4(%esp), %eax addl 8(%esp), %eax ret # eax := a # ecx := b # eax += ecx # return eax # eax := a # eax := b # return eax 12

13 machine code optimisation consider the executable in memory, during linking e.g: use short branch instructions for small displacements F80A cmpl $10, %eax F jne L C030 addl $48, %eax 000C L1: F80A cmpl $10, %eax jnes L C030 addl $48, %eax 0008 L1:... 13

14 run-time optimisation consider the dynamic behaviour of the program memoise the results of expensive operations #include <stdio.h> int f(int n) /* must be a pure function! */ { int r= n < 2? 1 : 1 + f(n - 1) + f(n - 2); return r; int main() { for (int i= 0; i < 40; ++i) printf("%i %i\n", i, f(i)); return 0; (try this with one, and then two, levels of memoisation) 14

15 partial evaluation partial evaluation is a compile-time technique that interprets the program (or parts of it) symbolically and replaces the computation with its results, thereby eliminating the computation from the executable program a simple (but powerful) example is constant folding find arithmetic operations involving constants perform the operation at compile time replace the operation with the constant result if we do this bottom-up then complex constant expressions reduce to a single constant 15

16 constant folding + * this can be applied in an interpreter during (e.g.) function definition 16

17 constant folding Token *fold(token *expr) { if (LIST == expr->type) { expr = fold_list(expr); /* cf. eval_list() */ Token *op = expr->list.value; if ( op->type == IDENTIFIER && list_length(expr) == 3 && nth(1, expr)->type == INTEGER && nth(2, expr)->type == INTEGER) { int a = nth(1, expr)->integer; int b = nth(2, expr)->integer; if (op == symbol_plus) return make_integer(a + b); if (op == symbol_minus) return make_integer(a - b); /* etc... */ return expr; 17

18 run-time optimisations for interpreters techniques focus on reducing interpretation overhead short-circuiting commonly-computed control caching commonly-computed values expensive run-time computation in our language: variable lookup linear search of association list (the more globals, the more expensive it is to access them) caching is a kind of memoisation memoise (cache) the last few variable lookup results return results from the cache if possible but, variable lookup is not a pure function defining a new variable can change the function s result the cache must be invalidated when a variable is defined 18

19 cached variable lookup lookup(env, key) = while (env) { if (env->head->key == key) return env->head; env = env->next; return 0; cached lookup(env, key) = index = hash(env, key) if (cache[index].key == key && cache[index].env == env) return cache[index].value; value = lookup(env, key); cache[index].key = key; cache[index].env = env; return cache[index].value = value; 19

20 project either add constant folding to your language or add cached variable lookups to your language 20

21 project: cached lookup #define CACHE_SIZE 11 struct { Token *key; Token *value; cache[cache_size]; Token *lookup(token *environment, Token *key) { /* try to find the key in locals */ /* try to find the key in the cache */ /* find the key in the globals */ /* update the cache */ return value; 21

22 project: cached lookup Token *lookup(token *environment, Token *key) { /* try to find the key in locals */ while (environment && environment!= globals) { Token *binding = environment->list.value; if (binding->association.key == key) { return binding; environment = environment->list.next; if (!environment) return 0; /* try to find the key in the cache */ unsigned long hash = (unsigned long)key % CACHE_SIZE; if (cache[hash].key == key) return cache[hash].value; 22

23 project: cached lookup /* find the key in the globals */ Token *value = 0; while (environment && environment->type == LIST) { Token *binding = environment->list.value; if (binding->association.key == key) { value= binding; break; environment = environment->list.next; /* update the cache */ cache[hash].key= key; cache[hash].value= value; return value; 23

24 project: constant folding Token *fold(token *expr) { if (expr && LIST == expr->type) { expr = fold_list(expr); if (3 == list_length(expr)) { Token *op = expr->list.value; Token *a = expr->list.next->list.value; Token *b = expr->list.next->list.next->list.value; if (INTEGER == a->type && INTEGER == b->type) { int l = a->integer, r = b->integer; if (op == id_plus) return make_integer(l + r); if (op == id_minus) return make_integer(l - r); if (op == id_star) return make_integer(l * r); if (op == id_slash) return make_integer(l / r); /* etc... */ return expr; 24

25 project: constant folding Token *fold_list(token *expr) { if (!expr LIST!= expr->type) return expr; return make_list(fold(expr->list.value), fold_list(expr->list.next)); Token *id_plus = 0; Token *id_minus = 0; /* etc... */ int main(int argc, char **argv) { globals = extend(globals, id_plus = intern("+"), make_primitive(primitive_add)); globals = extend(globals, id_minus = intern("-"), make_primitive(primitive_sub)); /* etc... */ 25

26 glossary bottom-up processing a tree structure in order from the leaves upwards towards the root caching a run-time optimisation that saves the results of an expensive computation, keyed by its input parameters, in a data structure. Subsequent computations of the same results probe the structure for the same keys and, if present, the cached result is used thereby avoiding the expensive computation. Caches differ from memoised results in that they can be used with non-pure functions and invalidated if any conditions that affect the result of the computation are changed. common sub-expression part of an expression that occurs more than once in some larger expression. This can be generalised to any computation that is repeated in a context in which each repetition produces the same result. All but the first occurrence can be eliminated by caching the result of the first occurrence in a temporary variable and using the value directly in subsequent occurrences of the sub-expression. 26

27 constant folding evaluating constant expressions at compile time and substituting the constant result as a literal in place of the original expression. dead code code that can never be reached. global optimisations optimisations that involve the analysis and manipulation of an entire function. inline copying the body of a function into the code that calls it, thereby eliminating the function call and the need to pass parameters and return a result. inter-procedural optimisations optimisations that involve the analysis and manipulation of the entire program. invalidate clear the contents of a cache because the conditions under which its mapping are valid have changed. 27

28 local optimisations optimisations that involve a single expression or series of statements that have strictly linear control flow. In other words these optimisations rely on the code having no conditional instructions, branches or function calls. loop-invariant code motion moving statements and expressions out of a loop body if their value is the same for each iteration of the loop. Their values can be computed once, on initial entry to the loop region, and then reused directly for each iteration. machine code optimisations optimisations that are performed on the binary code during or after it is loaded into memory and linked with libraries. memoise remember the value of a pure function so that its value can be returned immediately whenever the function is called with the same arguments. 28

29 partial evaluation symbolic evaluation of part or all of a program to convert computation into literals for any variables that can be fixed for the entire duration of the program s execution. pattern matching detecting patterns in some text, e.g., the assembly language statements of a compiled program. When used for peephole optimisation the patterns typically include parameters that match anything and which are bound to the actual items found in the program (literals, symbols, register names, etc.); these variables can be referred to within the replacement sequence, and will be expanded to their original values in the input text. peephole optimisations optimisations that replace a contiguous sequence of instructions with another equivalent sequence that is either faster, shorter, or both. pure function a function whose value depends only on the arguments to the function and which generates no side effects. 29

30 redundant store a store of a value into a variable that will not be used before being overwritten by another value. run-time optimisations optimisations that are performed while the program is running and which can take advantage of information that is not known at compile time such as actual computed values, or their types, or the dynamic behaviour of the program. short-circuiting jumping directly to a destination address of a computed jump or function call, based on the parameters used to compute the destination and a previously-cached address computed from them. strength reduction replacing an expensive operator with an equivalent operator (or sequence of operators) that have much lower cost. For example, multiplying by 5 is equivalent to adding four time a value to itself. 30