1 / 59

Subprogram and its implementation

Subprogram and its implementation. Fundamentals. Two fundamental abstractions in PL Process abstraction (subprogram) Data abstraction (chap 11) Subprogram characteristics Single entry point Caller is suspended during callee execution

thi
Download Presentation

Subprogram and its implementation

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Subprogram and its implementation PLLab, NTHU,Cs2403 Programming Languages

  2. Fundamentals • Two fundamental abstractions in PL • Process abstraction (subprogram) • Data abstraction (chap 11) • Subprogram characteristics • Single entry point • Caller is suspended during callee execution • Control returns to caller when callee execution terminates PLLab, NTHU,Cs2403 Programming Languages

  3. Definitions • Subprogram definition describes the interface to and the actions of the subprogram abstraction • Header: 1st part of the definition (name, return type, parameters…) • Parameter profile: describes the number, order and type of its formal parameters • Declaration: providing type information PLLab, NTHU,Cs2403 Programming Languages

  4. Parameters • Two ways for subprogram to gain access to the data it is to process: • Direct access to nonlocal variables • Parameter passing PLLab, NTHU,Cs2403 Programming Languages

  5. Parameters (cont.) • Formal parameters: defined in the subprogram header • Bound to storage when subprogram is called through some other variables • e.g. void sumer(int num1, real num2); • Actual parameters: parameters used in the subprogram call • Bound to formal parameters • e.g. Sumer(10. 1.4) PLLab, NTHU,Cs2403 Programming Languages

  6. Parameters (cont.) • Actual and formal parameter correspondences • Positional parameters: binding is based on position • Keyword parameters: binding is based on keyword mapping • e.g. (Ada) sumer(num1=> 10, num2=>1.4) • Defalut values: C++ FORTRAN 90, Ada allow default values for formal parameters • e.g. (C++) void sumer(int Num1, real num2, int flag = 1);Caller: sumer(10.1.4); PLLab, NTHU,Cs2403 Programming Languages

  7. Local referencing environment • Local variables: variables that are defined inside the subprogram • Stack dynamic local variables • Storage is allocated from stack • Allows recursive programming • Cost of time for allocation, initialization and deallocation • Static local variables: • More efficient for direct addressing • History sensitive PLLab, NTHU,Cs2403 Programming Languages

  8. Example I #include <stdio.h> int count; main( ) { int i ; for (i=0; i<=10; i++) { test( ) ; } } test( ) { int i ; static int count = 0; count = count + 1 ; } virtual address space test::i main::i run-time stack ptr static var ptr test::count count PLLab, NTHU,Cs2403 Programming Languages

  9. Example I #include <stdio.h> int count; main( ) { int i ; for (i=0; i<=10; i++) { test( ) ; } } test( ) { int i ; static int count = 0; count = count + 1 ; } PLLab, NTHU,Cs2403 Programming Languages

  10. Parameter Passing Methods • We discuss these at several different levels: • Semantic models: • in mode: receive data from actual params. • out mode: transmit data to actual params • Inout mode: do both above • Conceptual models of transfer: • Actual value is copied • Move an access path PLLab, NTHU,Cs2403 Programming Languages

  11. Parameter-passing methods PLLab, NTHU,Cs2403 Programming Languages

  12. Pass-by-value • Pass-by-value • Use the value of the actual params to initialize the corresponding formal params • Pascal, c, c++ • EX. main( ) { int a = 6; int b = 4; Cswap(a, b); // a = 6 // b = 4 } Cswap(int c, int d) { int temp = c; c = d; d = temp; } PLLab, NTHU,Cs2403 Programming Languages

  13. Pass-by-value example main( ) { int a = 6; int b = 4; Cswap(a, b); // a = 6 // b = 4 } temp=6 d=4 6 Cswap(int c, int d) { int temp = c; c = d; d = temp; } c=6 c=6 4 b=4 b=4 Cswap stack point a=6 a=6 main stack point PLLab, NTHU,Cs2403 Programming Languages

  14. Pass-by-result • Pass-by-result • no value is transmitted to the subprogram • the value of the formal para is passed back to the actual para when the subprogram returns • Example (in a pseudo language) caller( ) { int a ; int b ; foo(a, b); // a = 6 // b = 4 } foo(int c, int d ) { c = 6 ; d = 4 ; } PLLab, NTHU,Cs2403 Programming Languages

  15. Pass-by-result example caller( ) { int a ; int b ; foo(a, b); // a = 6 // b = 4 } d =4 =4 foo(int c, int d ) { c = 6 ; d = 4 ; } c =6 =6 b foo stack point a caller stack point PLLab, NTHU,Cs2403 Programming Languages

  16. Pass-by-value-result • Pass-by-value-result (a.k.a. pass-by-copy) • the combination of pass-by-value and pass-by-result • Ada • Example (in Ada) procedure swap(a : in out integer, b : in out integer) is temp : integer; begin temp := a ; a := b ; b := temp ; end swap; integer a = 3 ; integer b = 1 ; integer k[10] ; k[3] = 7; swap(a, b); swap(b, k[b]); PLLab, NTHU,Cs2403 Programming Languages

  17. Pass-by-value-result example integer a = 3 ; integer b = 1 ; integer k[10] ; k[3] = 7; swap(a, b); swap(b, k[b]); temp temp =3 =3 b=1 b=7 3 3 a=3 a=3 1 7 swap stack point swap stack point ….. k[3] =7 3 procedure swap(a : in out integer, b : in out integer) is temp : integer; begin temp := a ; a := b ; b := temp ; end swap; k[2] k[1] k[0] b=1 3 7 a=3 1 main stack point PLLab, NTHU,Cs2403 Programming Languages

  18. Pass-by-reference • Pass-by-reference • access path is transmitted to the called subprogram: efficient in terms of time & space • access to formal paras are slower • Example (in C) caller( ) { int a = 3 ; int b = 1 ; int k[10] ; k[3] = 7; swap(&a, &b) ; swap(&b, &k[b]) ; } swap(int *c, int *d ) { temp = *c; *c = *d ; *d = temp ; } PLLab, NTHU,Cs2403 Programming Languages

  19. Pass-by-reference example caller( ) { int a = 3 ; int b = 1 ; int k[10] ; k[3] = 7; swap(&a, &b) ; swap(&b, &k[b]) ; } temp=3 temp=3 d=2020 d=2004 c=2004 c=2000 2024 2020 2016 2012 2008 2004 2000 ….. swap stack point swap stack point k[3] =7 3 k[2] k[1] swap(int *c, int *d ) { temp = *c; *c = *d ; *d = temp ; } k[0] b=1 3 7 a=3 1 caller stackpoint PLLab, NTHU,Cs2403 Programming Languages

  20. Pass-by-reference (con’t) temp=3 temp=3 caller( ) { int a = 3 ; int b = 1 ; int k[10] ; k[3] = 7; swap(a, b) ; swap(b, k[b]) ; } • Example (in C++) &d=2020 &d=2004 &c=2004 &c=2000 2024 2020 2016 2012 2008 2004 2000 ….. swap stack point swap stack point k[3] =7 3 k[2] k[1] swap(int &c, int &d ) { temp = c; c = d ; d = temp ; } k[0] b=1 3 7 a=3 1 caller stack point PLLab, NTHU,Cs2403 Programming Languages

  21. Singlemensional array para • C does not check the array subscript range  run-time error if our-of-bound access void fun(int *a) { a[3] = 77; } main( ) { int a[10]; a[3] = 55; fun(a); // a[3] = 77 } void fun(int a[ ]) { a[3] = 77; } main( ) { int a[10]; a[3] = 55; fun(a); // a[3] = 77 } void fun(int a[ ]) { a[13] = 77; // run-time error } main( ) { int a[10]; a[3] = 55; fun(a); } PLLab, NTHU,Cs2403 Programming Languages

  22. Interesting C pointer usage fun(int *a) { a = (int *) malloc(40); a[5] = 1234; } main( ) { int *array; fun(array); printf(“%d”, array[5]); } a[5]=1234 memory leakage!! temp=6 2060 d=4 6 4 a=0 2060 array=0 fun stack Segmentation fault!! main stack PLLab, NTHU,Cs2403 Programming Languages

  23. Correct C pointer usage fun(int *a) { a[5] = 1234; } main( ) { int *array; array = (int *) malloc(40); fun(array); // array[5] == 1234 } a[5]=1234 temp=6 2060 d=4 6 4 a=2060 a=6 array=0 2060 fun stack main stack PLLab, NTHU,Cs2403 Programming Languages

  24. Array implementation • One-dim array address calculation • addr(a[j]) = addr(a[0]) + j * elementSize; int bounds[10]; // one int = 4 bytes &bounds[0] = 1200  &bounds[4] = • Row-major allocation: a[m,n] = a[3, 3] • addr(a[i,j]) = addr(a[0,0]) + ((i * n) + j) * elementSize; a[0, ] = 3 4 7 a[1, ] = 6 2 5 3, 4, 7, 6, 2, 5, 1, 3, 8 a[2, ] = 1 3 8 &a[0,0] = 1200  &a[1,2] = 1216 1220 PLLab, NTHU,Cs2403 Programming Languages

  25. Multidimensional array para • Compiler needs to know the declared size of the multi-dim array to build the mapping function in subprograms • C uses raw-major allocation fun(int a[ ][ ]) { a[3][5] = 4321; } main( ) { int a[10][20]; a[3][5] = 1234; fun(a); } // compiler error fun(int a[ ][25]) { a[3][5] = 4321; } main( ) { int a[10][20]; a[3][5] = 1234; fun(a); } // compiler error fun(int a[ ][20]) { a[3][5] = 4321; } main( ) { int a[10][20]; a[3][5] = 1234; fun(a); // a[3][5] = 4321 } PLLab, NTHU,Cs2403 Programming Languages

  26. Multidimensional array (con’t) fun(int a[ ][ ][ ]) { a[3][4][5] = 4321; } main( ) { int a[10][20][25] ; a[3][4][5] = 1234 ; fun(a); } // compiler error fun(int a[ ][ ][25]) { a[3][4][5] = 4321; } main( ) { int a[10][20][25]; a[3][4][5] = 1234; fun(a); } // compiler error fun(int a[ ][20][25]) { a[3][4][5] = 4321; } main( ) { int a[10][20][25]; a[3][4][5] = 1234; fun(a); // a[3][4][5] = 4321 } • Work around: • Use heap-dynamic variables for array • int *a; a = (int *) malloc(sizeof(int) * m * n); • Pass the arrry variable alone with m and n • fun(int *a, int num_rows, int num_cols) • a[i, j] == *(a + i * num_cols + j) PLLab, NTHU,Cs2403 Programming Languages

  27. Function as parameters int main( ) { int Result ; int (*pF)(int) ; pF = Plus; Result = Execute(3, pF); // Result = 6 pF = Square; Result = Execute(3, pF); // Result = 9 } int Plus (int num) { return num + num ; } int Square (int num) { return num * num; } void Execute(int seed, int (*pF)(int)) { return pF(seed) ; } PLLab, NTHU,Cs2403 Programming Languages

  28. Reference environment procedure SUB1; var x : integer; procedure SUB2; begin write(‘x = ‘, x); end; procedure SUB3; var x : integer; begin x := 3; SUB4(SUB2); end; procedure SUB4(SUBX); var x : integer; begin x := 4; SUBX end; begin x := 1; SUB3; end; • Referencing env • shallow binding: env of the call statement • x = 4 • deep binding: env of the defined subprogram • x = 1 • C, C++, Java. • ad hoc binding: env of the actual passing statement • x = 3 PLLab, NTHU,Cs2403 Programming Languages

  29. Generic Subprograms • A generic or polymorphic subprogram is one that takes parameters of different types on different activations • A subprogram that takes a generic parameter that is used in a type expression that describes the type of the parameters of the subprogram provides parametric polymorphism PLLab, NTHU,Cs2403 Programming Languages

  30. Without generic data structure class Name{ char fullname[64]; } ; class Person{ char firstName[64]; char lastName[32]; } ; class PersonStack{ Personnodes[50]; int stackptr; public: stack() { stackptr = 0; } void push(Persondata) { nodes[stackptr++] = data; } Personpop() { return nodes[stackptr--]; } } ; class NameStack{ Namenodes[50]; int stackptr; public: stack() { stackptr = 0; } void push(Namedata) { nodes[stackptr++] = data; } Namepop() { return nodes[stackptr--]; } } ; int main(int argc, char* argv[ ]) { NameStackDepartmentStack; PersonStackStudentsStack; Name dep; DepartmentStack.push(dep); } PLLab, NTHU,Cs2403 Programming Languages

  31. Generic data structure class Name{ char fullname[64]; } ; class Person{ char firstName[64]; char lastName[32]; } ; int main(int argc, char* argv[ ]) { stack<Name,10>DepartmentStack; stack<Person,20>StudentsStack; stack<Name,50>SchoolStack; Name dep; DepartmentStack.push(dep); } template<class item, int max_items> class stack{ itemnodes[max_items]; int stackptr; public: stack() { stackptr = 0; } void push(itemdata) { nodes[stackptr++] = data; } itempop() { return nodes[stackptr--]; } } ; PLLab, NTHU,Cs2403 Programming Languages

  32. Generic function • Example in C++ (similar in Ada) template <class Type> Type max(Type first, Type second) { return first > second ? first : second; } main( ) { int a, b, c; char d, e, f; c = max(a, b); // code generation for int max(…) f = max(d, e); // code generation for char max(…) b = max(a, c); // no code generation } PLLab, NTHU,Cs2403 Programming Languages

  33. Subprogram implementation PLLab, NTHU,Cs2403 Programming Languages

  34. General semantic • Def: The subprogram call and return operations of a language are together called its subprogram linkage PLLab, NTHU,Cs2403 Programming Languages

  35. Implementing “Simple” Subprograms • Call Semantics: 1. Save the execution status of the caller 2. Carry out the parameter-passing process 3. Pass the return address to the callee 4. Transfer control to the callee PLLab, NTHU,Cs2403 Programming Languages

  36. Implementing “Simple” Subprograms • Return Semantics: 1. If pass-by-value-result parameters are used, move the current values of those parameters to their corresponding actual parameters 2. If it is a function, move the functional value to a place the caller can get it 3. Restore the execution status of the caller 4. Transfer control back to the caller PLLab, NTHU,Cs2403 Programming Languages

  37. Implementing “Simple” Subprograms • Required Storage: • Caller status, parameters, return address, and functional value (if it is a function) • The format, or layout, of the noncode part of an executing subprogram is called an activation record PLLab, NTHU,Cs2403 Programming Languages

  38. Subprogram implementation • Activation record: the layout of the call stack for call-related data • Static-scoping PL implementation • dynamic-scoping discussed later • Two approaches to implementing nonlocal variables accesses • static chains • displays Local variables Parameters Dynamic link Static link stack top Return address An activation record PLLab, NTHU,Cs2403 Programming Languages

  39. Scope example Proc A reference environment Static scope: A  main Dynamic scope: A  B  main proc main var X1, X2; proc A var X1, X2; end proc B var X1, X2; call A; end call B; end PLLab, NTHU,Cs2403 Programming Languages

  40. Static & dynamic scope Static scope: (31) x = big’s x (4) x = big’s x (2) x = sub2’s x (51) x = big’s x Dynamic scope (31) x = big’s x (4) x = big’s x (2) x = sub2’s x (51) x = sub2’s x Procedure big; var x : integer; procedure sub1; begin …x…  (1) end; procedure sub2; var x : integer; begin …x…  (2) sub1; end; begin sub1;  (3) …x…  (4) sub2;  (5) end PLLab, NTHU,Cs2403 Programming Languages

  41. Local sum Local List [5] Local List [4] Local List [3] Local List [2] Local List [1] Parameter part Parameter total Dynamic link Static link Return address Activation record Procedure sub (var total: real; part: integer); var list : array [1..5] of integer; sum : real; Begin … End; • static link: used for nonlocal variables reference • dynamic link: points to the top of the AR of the caller The activation record for procedure sub PLLab, NTHU,Cs2403 Programming Languages

  42. Parameter Q Dynamic link Static link Return (to A) Local Y Parameter X Dynamic link Static link Return (to B) Local T Local S Parameter R Dynamic link Static link Return (to MAIN) Local reference example Program MAIN_1; var P : real; procedure A (X : integer); var Y : boolean; procedure C (Q : boolean); begin {C} … end; {C} begin {A} … C(Y); … end; {A} procedure B (R : real); var S, T :integer; begin {B} … A(S); … end; {B} begin {MAIN_1} … B(P); … end. {MAIN_1} Local P PLLab, NTHU,Cs2403 Programming Languages

  43. Function value 1 ? Recursion example Parameter n 1 Dynamic link Static link int factorial (int n){ If (n <=1) return 1; else return (n* factorial (n-1)); } void main(){ int value; value = factorial (3); } Return(to factorial) If (n <=1) Function value 2 ? return 1; Parameter n 2 Dynamic link Static link Return(to factorial) Function value ? 6 6 Parameter n 3 Dynamic link Static link Return (to main) Local value ? PLLab, NTHU,Cs2403 Programming Languages

  44. Static chain & Display • Static chain: following the static chain for nonlocal variable reference • costly • nondeterministic • Display: the only widely used alternative to static chain • static links are collected in a single array called a display • exactly 2 steps to access nonlocal variables PLLab, NTHU,Cs2403 Programming Languages

  45. Nested Subprograms • Technique 1 - Static Chains • A static chain is a chain of static links that connects certain activation record instances • The static link in an activation record instance for subprogram A points to one of the activation record instances of A's static parent • The static chain from an activation record instance connects it to all of its static ancestors PLLab, NTHU,Cs2403 Programming Languages

  46. Static Chains (continued) • To find the declaration for a reference to a nonlocal variable: • You could chase the static chain until the activation record instance (ari) that has the variable is found, searching each ari as it is found, if variable names were stored in the ari • Def: static_depth is an integer associated with a static scope whose value is the depth of nesting of that scope PLLab, NTHU,Cs2403 Programming Languages

  47. Static Chains (continued) main ----- static_depth = 0 A ----- static_depth = 1 B ----- static_depth = 2 C ----- static_depth = 1 PLLab, NTHU,Cs2403 Programming Languages

  48. Static Chains (continued) • Def: The chain_offset or nesting_depth of a nonlocal reference is the difference between the static_depth of the reference and that of the scope where it is declared • A reference can be represented by the pair: (chain_offset, local_offset) where local_offset is the offset in the activation record of the variable being referenced PLLab, NTHU,Cs2403 Programming Languages

  49. MAIN_2 var x proc BIGSUB BIGSUB; var A, B, C proc SUB1 SUB2(7); proc SUB2(X) var A, D A := B + C; var B, E proc SUB3 SUB3; A := X + E; var C, E SUB1; E := B + A; Nonlocal reference example program MAIN_2; var X : integer; procedure BIGSUB; var A, B, C : integer; procedure SUB1; var A, D : integer; begin { SUB1 } A := B + C; <-----------------------1 end; { SUB1 } procedure SUB2(X : integer); var B, E : integer; procedure SUB3; var C, E : integer; begin { SUB3 } SUB1; E := B + A: <--------------------2 end; { SUB3 } begin { SUB2 } SUB3; A := D + E; <-----------------------3 end; { SUB2 } begin { BIGSUB } SUB2(7); end; { BIGSUB } begin BIGSUB; end. { MAIN_2 } PLLab, NTHU,Cs2403 Programming Languages

  50. Example Pascal Program Call sequence forMAIN_2 MAIN_2 callsBIGSUB BIGSUBcallsSUB2 SUB2callsSUB3 SUB3callsSUB1 PLLab, NTHU,Cs2403 Programming Languages

More Related