Data elements and bindings

Transcription

1 Imperative programming Data elements and bindings Variables and their values Expression (value) evaluation Binding of variables and types static and dynamic binding Lifetime of variables Scopes of variables static and dynamic scoping Lambdas in C++11 TUT Pervasive Computing 1

2 von Neumann Memory (instructions and data) architecture Instructions and data Results of operations CPU Arithmetic and logic unit Control unit Input and output devices Imperative programming variable assignment von Neumannin architecture memory cell transfer (CPU-memory) TUT Pervasive Computing 2

3 Data items (variables) Creating and handling data is based on changing the state (memory content) of the computer Essential operation of the program memory location = space for data item content of the location = value of the data item Pointer/reference type value of a data item is a memory address or a reference to a memory location in most languages identifies a variable equal pointers = same variables A named variable can be either a data item or a reference to it TUT Pervasive Computing 3

4 Variables vs. memory location for a variable value of a variable Characteristics: name address (L-value) value (R-value) type lifetime scope Aliasing Pascal: Fortran: C: X := X + 1; var X: Integer; subroutine SUM ( I, J, K ) integer I, J, K I = J + K return end call SUM ( 1, 2, 3 ) ( f ( a ) + 3 ) -> b [ c ] = 2; TUT Pervasive Computing 4

5 Value vs. reference semantics In some languages (C, C++, ) variables contain the data In other languages (Java, Python, ) variables (=names) are references to objects that contain the data Affects how variables/objects work (e.g. lifetime, memory allocation) A major source of confusion when changing to another language TUT Pervasive Computing

6 Value semantics Variables: named data items (Nameless variables also possible) Assigning to a variable changes the data Pointers/references: variables that refer to another variable p a 3 TUT Pervasive Computing

7 Reference semantics Objects: nameless data items Variables/references/names (term depend on language): named references to objects (Nameless references also possible) Assigning to a variable changes the reference (refer now to another object) Objects and variables separate, variables cannot refer to other variables, only to objects 3 a TUT Pervasive Computing

8 Assignment Changes the state of data L := R Type checking ensures that the memory location referenced by L has room for the value of expression R Indirect referencing e.g. through pointer dereference usually what we want makes compiler optimization harder 0x0804a865 0x0804a008 0x0804a ptr == 0x0804a008 *ptr == 2148 ptr TUT Pervasive Computing 8

9 Variations of assignments Multiple assignment e.g. Python function may return several values (e.g Clu) Compound operations e.g. C (+=, -=) Increment and decrement operations a, b = b, a Triple = proc ( ) returns ( int, int, int ) return ( 1, 2, 3 ) end Triple;... a, b, c: int := Triple ( ) a.b [ i + j ] = a.b [ i + j ] + 2; a.b [ i + j ] += 2; a [ i ++ ] *= 10; TUT Pervasive Computing 9

10 Expression language if ( x = y ) if ( x == y ) Statement has a value C: assignment has a value enables multiple assignments Algol68: begin a := if b < c then d else e; a := begin f ( b ); g ( c ) end; g ( d ); end a = b = 1 a = ( b = 1 ) while ( ( ch = getchar ( ) )!= EOF )... TUT Pervasive Computing 10

11 Expressions Expressions consist of operands e.g. variables, constants, function calls operators e.g. operator symbols, functions a f ( 1, 2 ) * 3 TUT Pervasive Computing 11

12 Operators (1) Different amount of operands: unary (signs, negation, C s ++ and &) binary (arithmetic operators, comparison operators, assignment, ->) ternary (in C) Different layout: a? b : c prefix (many unary operators, e.g. -1,!a, ++i) operators in Scheme postfix (e.g. i++) infix (many binary operators) TUT Pervasive Computing 12

13 Operators (2) Precedence described as precedence levels e.g. binary *-operator usually has a higher precedence (level) than binary +-operator Association applied to operators of the same precedence level operators associated from left to right: e.g. arithmetic operators, C s <<, -> operators associated from right to left: e.g. power raising, C s +=, = TUT Pervasive Computing 13

14 Operator precedences Fortran Pascal C Ada ** *, /, div, mod ++, -- **, abs *, / +, - (all) +, - (unary) *, /, mod, rem +, - (all) *, /, % +, - (unary) +, - (binary) +, - (binary) C-code: Obs! Parentheses are recommended s!= 1 << n + 1; A [ i ] = i = x; (Does not work) a = b << c = d; TUT Pervasive Computing 14

15 Expression evaluation (1) ( a + b ) * ( c d ) Evaluation can be based on an intermediate presentation syntax tree passed in post-order (left subtree, right subtree, root) postfix notation evaluation can be based on stack three-address-code common sub-expressions can be used in optimization memory space needed for temporary variables a b + c d - * + TUT Pervasive Computing 15 * - a b c d t1 = a + b t2 = c d t3 = t1 * t2

16 Expression evaluation (2) Precedence levels and associations do not determine the evaluation order of the whole syntax tree + 3 * ( y 1 ) + 2 * ( x + 3 ) * * Obs: side effects a = 10; b = a + fun ( a ); y 1 x 3 TUT Pervasive Computing 16

17 Expression evaluation (3) Evaluation of logic expressions can be based on Ashort- B short-circuit evaluation A and B Modula-2: IF ( i > 0 ) AND ( i < 11 ) AND ( a [ i ] = b ) THEN... C: if ( p && ( p->item == x ) )... Ada: short-circuit operators: andthen, orelse Example of lazy evaluation which means that expression is evaluated only when its value is needed e.g. passing an expression as a parameter does not require evaluation of the expression TUT Pervasive Computing 17

18 Bindings Binding relation or association e.g. between an object and property/feature e.g. between an operation and its symbol Binding time time, when a binding occurs Static and dynamic binding TUT Pervasive Computing 18

19 Example bindings Set of possible types for count bound at language design time Type of count bound at compile time Set of possible values of count bound at compiler design time Value of count C-code: int count;... count = count * 5; bound at execution time with this statement Set of possible meanings for the operator symbol * bound at language design time Meaning of the operator symbol * in this statement bound at compile time Internal representation of the literal 5 bound at compiler design time TUT Pervasive Computing 19

20 Binding of types Static (compile-time) / dynamic (run-time)? Objects only / objects + references? Can the type of an object change? Can an object have several types at the same time: inheritance (polymorphism) Explicit/implicit typing Type deduction TUT Pervasive Computing

21 Binding of variables and types Static binding before a variable can be referenced, it must be bound to a data type Choices for static binding: explicit declaration implicit declaration Fortran: identifier beginning with I, J, K, L, M, or N => INTEGER other letter as the first letter => REAL Perl beginning with$ => scalar (numeric value or string) beginning with@=> array beginning with%=> hash (associative array) TUT Pervasive Computing 21

22 Explicit declaration Basic rule: declare indentifiers before using them Exceptions for the rule: pointers, mutually recursive subprograms Pascal: type APtr = ^A; A = record next: APtr; data:... end; Ada: type A; type APtr is access A; type A is record next: APtr; data:... end record; TUT Pervasive Computing 22

23 Dynamic binding of types Variable is bound to a type when it is assigned a value at execution time e.g. JavaScript, Python Advantages: flexibility, genericity Disadvantages: JavaScript-code: list = [ 10.2, 3.5 ]... list = 47 missing support for error detection (= errors reported to users, not to programmers) implementation costs TUT Pervasive Computing 23

24 Type deduction (ML, Haskell,..) fun circumf ( r ) = 3.14 * r * r; fun square ( x ) = x * x; fun square ( x ) : int = x * x; suffix x = x ++.jpg square x = x * x auto iter = v.begin ( ) + 2; argument is float, result is float cannot be deduced a hint given by programmer argument is string, result is string deduced only when used C++ TUT Pervasive Computing 24

25 Lifetime Storage bindings (variable bound to memory) reservation of memory space for a variable (allocation) releasing the reserved memory space (deallocation) Variable lifetime time during which the variable is bound to a specific memory location binding between data item (variable declaration) and memory location occurs at execution time (usually) except for persistent variables stored in a database TUT Pervasive Computing 25

26 Variable classification according to lifetime Static variables bound to memory location before program execution binding is preserved through the whole execution Stack-dynamic variables bound to memory location during elaboration of their declaration type is bound statically Explicit heap-dynamic variables bound to memory location according to programmer s instructions variables are referenced via pointers (no name) type is bound statically Implicit heap-dynamic variables bound to memory location when values are assigned global variables static (in C) local variables pointer variables variables in script languages TUT Pervasive Computing 26

27 Garbage collection 1. Separate alive objects from those not in use any more 2. Collect objects not in use Memory management memory allocation memory deallocation can be done automatically, when an object can no longer be reached from the program Triggering garbage collection immediately when garbage may be created size of reserved blocks has grown over some limit a given time limit is reached the system has nothing else to do TUT Pervasive Computing 27

28 Garbage collection methods Reference counts keep track of the number of pointers that refer to the same memory location Mark and sweep before collection all memory allocations are marked as not seen referenced allocation blocks are marked as seen sweep phase sweeps away all allocations that are not seen Stop and copy memory space is split into two parts, and only one of them is used for new object allocations in garbage collection, reachable objects are copied from the allocation space (from-space) to the other, initially empty space (to-space) finally the roles of these two spaces are switched TUT Pervasive Computing 28

29 Pointer problems Lost heap-dynamic variable (garbage) memory is allocated for a dynamic variable via a pointer memory is re-allocated via the same pointer Dangling pointer or dangling reference memory is allocated for a dynamic variable via a pointer the value of the pointer is assigned to another pointer the space is deallocated via one of the above pointers the other pointer references now to the deallocated space New ( p );... New ( p ); Pascalcodes New ( p1 ); p2 = p1; Dispose ( p1 ); TUT Pervasive Computing 29

30 Example pointer problem C-code: char *init_line ( ) { char *line = new char [ 60 ];... return line; } Who (which program structure) owns the pointer? TUT Pervasive Computing 30

31 Solution for dangling pointers: tombstones Each heap-dynamic variable include a special cell (tombstone) that is itself a pointer to a heapdynamic variable Actual pointer variables point only to tombstones When a heap-dynamic variable is deallocated, the tombstone remains but is set to nil delete p; p = nil; if ( p == nil )... new ( ptr1 ); ptr2 := ptr1; free ( ptr1 ); RIP TUT Pervasive Computing 31

32 Solution for dangling pointers: locks and keys Pointer values are associated with an integer (key) Heap-dynamic variables are associated with an integer (lock) In space allocation, the same value is given for both key and lock Upon referencing, the equality of the lock and key is checked Upon deallocation, the value is set invalid new ( ptr1 ); ptr2 := ptr1; free ( ptr1 ); TUT Pervasive Computing 32 0

33 Scope Solves which identifier (where declared) is meant in a reference (usage) Binding between the use of data element and its definition (declaration) Creates a visibility region range of statements in which the variable is visible a variable is visible in statement if it can be referenced in that statement scopes can be nested Static and dynamic scope TUT Pervasive Computing 33

34 Moving between scopes Each subprogram has an own scope Moving to a new scope (e.g. calling a subprogram) elaboration of declarations creating bindings to the local variables of the scope hiding binding of non-local variables of the same name Moving back to the previous scope (e.g. returning from a subprogram) restoring bindings as they were earlier TUT Pervasive Computing 34

35 Scope example Pascal-code: In inner scope, bindings to those outer variables that have same names as inner variables, are not preserved program P; var x, y: Real; procedure P1; var y, z: Integer; begin... y := 2; x := 2.2;... end; begin... x := 1.1; y := 3.3;... end. TUT Pervasive Computing 35

36 Static scoping Bindings (between variable declarations and variable usages) are created at compile time can be detected in the program text Choices for static binding: single global scope Basic both global and local variables Fortran nested subprograms Algol60, Pascal, Ada nested blocks C, Ada Modules and classes determine scopes TUT Pervasive Computing 36

37 Dynamic scoping Bindings depend on control flow and the order of subprogram calls e.g. APL, Snobol, early dialects of Lisp, Perl Rule: latest binding that is created during execution holds Pseudo code: a: integer procedure first a := 1 procedure second a: integer first ( ) a := 2 if read_integer ( ) > 0 second ( ) else first ( ) write_integer ( a ) global declaration local declaration main program TUT Pervasive Computing 37

38 Lifetime and scope Variable lifetime and (static) scope can be closely related e.g. Pascal, nested subprograms Lifetime and scope may not be related e.g. static variables in C e.g. subprogram calls from another subprogram C-code: void printheader ( ) {... } void compute ( ) { int sum;... printheader ( ); } TUT Pervasive Computing 38

39 Lambdas and closures Lambda = lambda expression exists in source code (compile-time feature) definition Closure = lambda s run-time counterpart definition + environment = instantiation environment binds each free variable in lambda expression to a value free variables become closed -> closure cf. class instance of a class = object TUT Pervasive Computing 39

40 Lambda example in C++11 #include <iostream> using namespace std; int main ( ) { auto func = [ ] ( int x, int y ) { return x + y; }; cout << func ( 2, 3 ) << endl; } => 5 TUT Pervasive Computing

41 Lambda example in C++11 #include <iostream> using namespace std; int main ( ) { int n = [ ] ( int x, int y ) { return x + y; } ( 5, 4 ); cout << n << endl; } => 9 TUT Pervasive Computing

42 Captures in C++11 Capture clause = lambda introducer Specify which outside (free) variables are available for the lambda function and how to capture them by value or by reference In other words: how to bind free variables (variables referenced in the body of a lambda) TUT Pervasive Computing

43 Capture choices in C++11 [ ] captures nothing [ = ] captures all outside variables by value [ & ] captures all outside variables by reference [ a, &b ] captures a by value and b by reference [ this ] captures this pointer by value TUT Pervasive Computing

44 Lambda example in C++11 #include <iostream> using namespace std; int main ( ) { int x = 3; int y = 5; auto func = [ x, &y ] { return x + y; }; x = 22; y = 44; cout << func ( ) << endl; } => 47 TUT Pervasive Computing

45 Lambda and STL (for_each) vector<int> v; v.push_back ( 1 ); v.push_back ( 2 ); // for ( auto itr = v.begin ( ), end = v.end ( ); itr!= end; itr++ ) { cout << *itr; } vector<int> v; v.push_back ( 1 ); v.push_back ( 2 ); // for_each ( v.begin ( ), v.end ( ), [ ] ( int val ) { cout << val; } ); TUT Pervasive Computing