Algorithms and data structures 10.4.2017. Protected by http://creativecommons.org/licenses/by-nc-sa/3.0/hr/

Creative Commons You are free to: Under the following terms: share — copy and redistribute the material in any medium or format adapt — remix, transform, and build upon the material Under the following terms: Attribution — You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use. NonCommercial — You may not use the material for commercial purposes. ShareAlike — If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original. No additional restrictions — You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits. Riječ-dvije o velikim slovima na početku bulleta: Ako je u pitanju rečenica, slovo je veliko. rečenicu prepoznajete po posljednjem znaku (npr. točka, uskličnik, upitnik; ne i dvotočka!)  inače je malo Notices: You do not have to comply with the license for elements of the material in the public domain or where your use is permitted by an applicable exception or limitation. No warranties are given. The license may not give you all of the permissions necessary for your intended use. For example, other rights such as publicity, privacy, or moral rights may limit how you use the material. Text copied from http://creativecommons.org/licenses/by-nc-sa/3.0/ Algorithms and data structures, FER 10.4.2017.

Memory assignment Function call mechanism System stack 10.4.2017.

Process: a created program instance Virtual memory Process: a created program instance When a process is activated, a part of physical memory is assigned to it It is virtual memory – the process feels like having assigned to it the whole computer memory The process is not aware of how that virtual memory is mapped into the physical one – only the size and the beginning address are known – 0x00000000 for 32-bit architecture The process is not aware of virtual memories of other processes Even if it knew, it cannot access them physically (prevented by the OS) At each memory access (read, write), mapping between virtual and physical addresses is performed The mapping must be fast, because it occurs very often Algorithms and data structures, FER 10.4.2017.

Depending on the operating system Memory layout Lower addresses Depending on the operating system TEXT The stored program DATA Initialised global and static local variables BSS Uninitialised global and static local variables Heap Dynamically allocated memory (malloc) Stack Local variables of functions and stack frames It is on the bottom (highest addresses) TEXT DATA BSS HEAP STACK Higher addresses Algorithms and data structures, FER 10.4.2017.

Storage for execution code and constants Memory segments - TEXT Storage for execution code and constants TEXT DATA BSS char *word = “Hello"; int iSize; char *func() { char *p; iSize = 8; p = malloc(iSize); return p; } HEAP STACK Algorithms and data structures, FER 10.4.2017.

Memory segments - DATA i BSS Global variables, static local variables DATA: initialised in code BSS: uninitialised in code TEXT DATA BSS char *word= "Zdravo"; int iSize; char *func() { char *p; iSize = 8; p = malloc(iSize); return p; } HEAP STACK Algorithms and data structures, FER 10.4.2017.

Memory segments - heap Dynamic memory malloc, realloc TEXT DATA BSS char *word= “Hello"; int iSize; char *func() { char *p; iSize = 8; p = malloc(iSize); return p; } HEAP STACK Algorithms and data structures, FER 10.4.2017.

Memory segments - stack Temporary memory, while a function is executed grows upwards (to lower addresses) TEXT DATA BSS char *word= “Hello"; int iSize; char *func() { char *p; iSize = 8; p = malloc(iSize); return p; } HEAP STACK Algorithms and data structures, FER 10.4.2017.

Program sequence at function call How x is transferred? int main () { ... y1 = f(x1); y2 = f(x2); y3 = f(x3); } float f (float x) { ... return y; } Which way to return? Algorithms and data structures, FER 10.4.2017.

Temporary storage of variables and return addresses System stack Temporary storage of variables and return addresses Data structure of type LIFO (Last In First Out) Newer elements are stored on lower memory addresses Putting on stack: push Taking from stack: pop C B B B A A A A A Algorithms and data structures, FER 10.4.2017.

Stack is a collection of stack frames A stack frame contains: Return address to go to after the execution of the called function Local variables of the function Arguments (parameters) of the function Processor registers (depending on the compiler and its options) The stack also contains the base pointer Starting address for allocation of arguments and local variables for their easier handling In figures, address above which upon return everything may be cleared For generality, stack frame and base pointer shall not be considered here Algorithms and data structures, FER 10.4.2017.

Stack frame of the function main When a program is started, there is only one stack frame on the stack - the one belonging to the function main In the following examples this frame shall be omitted For simplicity reasons, in the stack there shall be presented: Function arguments Return address Local variables main Algorithms and data structures, FER 10.4.2017.

Program sequence and stack at function call int main () { ... y1 = f(x1); a) y2 = f(x2); b) y3 = f(x3); c) } x1 float f (float x) { ... return y; } b) x2 c) x3 Algorithms and data structures, FER 10.4.2017.

Program sequence and stack at function call – a more complex example float f (float x) { ... g(x); c) return z*z; } int main () { ... y1 = f(x1); a) y2 = g(x2); b) } c) x void g (float x) { ... return; } a) b) x1 x2 Algorithms and data structures, FER 10.4.2017.

Program sequence and stack at function call – even more complex example float f (float x) { float z; ... z = g(x); return z*z; } float g (float w) { float y; ... return y; } float f (float x) { float z; ... z = g(x); return z*z; } int main () { ... y1 = f(x1); y2 = g(x2); } y Ret.addr. x z z z Ret.addr. Ret.addr. Ret.addr. x1 x1 x1 Algorithms and data structures, FER 10.4.2017.

Program sequence and stack at function call – a more complex example float f (float x) { float z; ... z = g(x); return z*z; } int main () { ... y1 = f(x1); y2 = g(x2); } float g (float w) { float y; ... return y; } int main () { ... y1 = f(x1); y2 = g(x2); } z y Ret.addr. Ret.addr. x2 x1 Algorithms and data structures, FER 10.4.2017.

Function call by value x 1 y 1 x 1 y 1 2 x 1 #include <stdio.h> int x; void f (int y) { y = 2; } int main () { x = 1; f(x); ... return 0; main stack function call Ret.addr. x 1 y 1 execution y=2 x 1 Ret.addr. y 1 2 after return x 1 Algorithms and data structures, FER 10.4.2017.

Function call by reference – 1 #include <stdio.h> void exchange (short *x, short *y) { short aux; aux= *x; *x = *y; *y = aux; } short a, b; int main () { a = 3; b = 5; exchange(&a, &b); return 0; main stack function call aux ? 3 Ret.addr. 0x102 a 5 x 0x102 0x100 b y 0x100 execution aux=*x aux ? 3 3 Ret.addr. 0x102 a 5 x 0x102 0x100 b y 0x100 Algorithms and data structures, FER 10.4.2017.

Function call by reference – 2 #include <stdio.h> void exchange (short *x, short *y) { short aux; aux = *x; *x = *y; *y = aux; } short a, b; int main () { a = 3; b = 5; exchange(&a, &b); return 0; main stack execution *x=*y aux 3 5 3 Ret.addr. 0x102 a 5 x 0x102 0x100 b y 0x100 execution *y=aux aux 3 5 Ret.addr. 0x102 a 3 5 x 0x102 0x100 b y 0x100 Algorithms and data structures, FER 10.4.2017.

Function call by reference – 3 #include <stdio.h> void exchange (short *x, short *y) { short aux; aux = *x; *x = *y; *y = aux; } short a, b; int main () { a = 3; b = 5; exchange(&a, &b); return 0; main stack return to main aux 3 5 Ret.addr. 0x102 a 3 x 0x102 0x100 b y 0x100 after return 5 0x102 a 3 0x100 b Algorithms and data structures, FER 10.4.2017.